Revision: 15625
Author: [email protected]
Date: Thu Jul 11 04:47:05 2013
Log: Introduce type Bounds record
Refactoring in anticipation of handling variable bounds.
[email protected]
BUG=
Review URL: https://codereview.chromium.org/18415005
http://code.google.com/p/v8/source/detail?r=15625
Modified:
/branches/bleeding_edge/src/ast.h
/branches/bleeding_edge/src/hydrogen.cc
/branches/bleeding_edge/src/types.h
/branches/bleeding_edge/src/typing.cc
/branches/bleeding_edge/src/typing.h
=======================================
--- /branches/bleeding_edge/src/ast.h Fri Jul 5 01:49:37 2013
+++ /branches/bleeding_edge/src/ast.h Thu Jul 11 04:47:05 2013
@@ -357,10 +357,8 @@
bool IsUndefinedLiteral();
// Expression type bounds
- Handle<Type> upper_type() { return upper_type_; }
- Handle<Type> lower_type() { return lower_type_; }
- void set_upper_type(Handle<Type> type) { upper_type_ = type; }
- void set_lower_type(Handle<Type> type) { lower_type_ = type; }
+ Bounds bounds() { return bounds_; }
+ void set_bounds(Bounds bounds) { bounds_ = bounds; }
// Type feedback information for assignments and properties.
virtual bool IsMonomorphic() {
@@ -391,15 +389,13 @@
protected:
explicit Expression(Isolate* isolate)
- : upper_type_(Type::Any(), isolate),
- lower_type_(Type::None(), isolate),
+ : bounds_(Type::None(), Type::Any(), isolate),
id_(GetNextId(isolate)),
test_id_(GetNextId(isolate)) {}
void set_to_boolean_types(byte types) { to_boolean_types_ = types; }
private:
- Handle<Type> upper_type_;
- Handle<Type> lower_type_;
+ Bounds bounds_;
byte to_boolean_types_;
const BailoutId id_;
=======================================
--- /branches/bleeding_edge/src/hydrogen.cc Thu Jul 11 01:21:50 2013
+++ /branches/bleeding_edge/src/hydrogen.cc Thu Jul 11 04:47:05 2013
@@ -7280,12 +7280,11 @@
} else {
VariableProxy* proxy = expr->expression()->AsVariableProxy();
- bool global_call = proxy != NULL && proxy->var()->IsUnallocated();
-
if (proxy != NULL && proxy->var()->is_possibly_eval(isolate())) {
return Bailout("possible direct call to eval");
}
+ bool global_call = proxy != NULL && proxy->var()->IsUnallocated();
if (global_call) {
Variable* var = proxy->var();
bool known_global_function = false;
@@ -7609,7 +7608,7 @@
void HOptimizedGraphBuilder::VisitSub(UnaryOperation* expr) {
CHECK_ALIVE(VisitForValue(expr->expression()));
HValue* value = Pop();
- Handle<Type> operand_type = expr->expression()->lower_type();
+ Handle<Type> operand_type = expr->expression()->bounds().lower;
HInstruction* instr = BuildUnaryMathOp(value, operand_type, Token::SUB);
return ast_context()->ReturnInstruction(instr, expr->id());
}
@@ -7618,7 +7617,7 @@
void HOptimizedGraphBuilder::VisitBitNot(UnaryOperation* expr) {
CHECK_ALIVE(VisitForValue(expr->expression()));
HValue* value = Pop();
- Handle<Type> operand_type = expr->expression()->lower_type();
+ Handle<Type> operand_type = expr->expression()->bounds().lower;
HInstruction* instr = BuildUnaryMathOp(value, operand_type,
Token::BIT_NOT);
return ast_context()->ReturnInstruction(instr, expr->id());
}
@@ -7954,9 +7953,9 @@
HValue* left,
HValue* right) {
HValue* context = environment()->LookupContext();
- Handle<Type> left_type = expr->left()->lower_type();
- Handle<Type> right_type = expr->right()->lower_type();
- Handle<Type> result_type = expr->lower_type();
+ Handle<Type> left_type = expr->left()->bounds().lower;
+ Handle<Type> right_type = expr->right()->bounds().lower;
+ Handle<Type> result_type = expr->bounds().lower;
Maybe<int> fixed_right_arg = expr->fixed_right_arg();
Representation left_rep = Representation::FromType(left_type);
Representation right_rep = Representation::FromType(right_type);
@@ -8278,8 +8277,8 @@
return ast_context()->ReturnControl(instr, expr->id());
}
- Handle<Type> left_type = expr->left()->lower_type();
- Handle<Type> right_type = expr->right()->lower_type();
+ Handle<Type> left_type = expr->left()->bounds().lower;
+ Handle<Type> right_type = expr->right()->bounds().lower;
Handle<Type> combined_type = expr->combined_type();
Representation combined_rep = Representation::FromType(combined_type);
Representation left_rep = Representation::FromType(left_type);
=======================================
--- /branches/bleeding_edge/src/types.h Wed Jul 10 04:20:00 2013
+++ /branches/bleeding_edge/src/types.h Thu Jul 11 04:47:05 2013
@@ -291,6 +291,40 @@
}
};
+
+// A simple struct to represent a pair of lower/upper type bounds.
+struct Bounds {
+ Handle<Type> lower;
+ Handle<Type> upper;
+
+ Bounds() {}
+ Bounds(Handle<Type> l, Handle<Type> u) : lower(l), upper(u) {}
+ Bounds(Type* l, Type* u, Isolate* isl) : lower(l, isl), upper(u, isl) {}
+ explicit Bounds(Handle<Type> t) : lower(t), upper(t) {}
+ Bounds(Type* t, Isolate* isl) : lower(t, isl), upper(t, isl) {}
+
+ // Meet: both b1 and b2 are known to hold.
+ static Bounds Both(Bounds b1, Bounds b2, Isolate* isl) {
+ return Bounds(
+ handle(Type::Union(b1.lower, b2.lower), isl),
+ handle(Type::Intersect(b1.upper, b2.upper), isl));
+ }
+
+ // Join: either b1 or b2 is known to hold.
+ static Bounds Either(Bounds b1, Bounds b2, Isolate* isl) {
+ return Bounds(
+ handle(Type::Intersect(b1.lower, b2.lower), isl),
+ handle(Type::Union(b1.upper, b2.upper), isl));
+ }
+
+ static Bounds NarrowLower(Bounds b, Handle<Type> t, Isolate* isl) {
+ return Bounds(handle(Type::Union(b.lower, t), isl), b.upper);
+ }
+ static Bounds NarrowUpper(Bounds b, Handle<Type> t, Isolate* isl) {
+ return Bounds(b.lower, handle(Type::Intersect(b.upper, t), isl));
+ }
+};
+
} } // namespace v8::internal
#endif // V8_TYPES_H_
=======================================
--- /branches/bleeding_edge/src/typing.cc Tue Jul 9 04:48:47 2013
+++ /branches/bleeding_edge/src/typing.cc Thu Jul 11 04:47:05 2013
@@ -248,12 +248,9 @@
expr->condition()->RecordToBooleanTypeFeedback(oracle());
- MergeLowerType(expr, Type::Intersect(
- expr->then_expression()->lower_type(),
- expr->else_expression()->lower_type()));
- MergeUpperType(expr, Type::Union(
- expr->then_expression()->upper_type(),
- expr->else_expression()->upper_type()));
+ NarrowType(expr, Bounds::Either(
+ expr->then_expression()->bounds(),
+ expr->else_expression()->bounds(), isolate_));
}
@@ -264,14 +261,12 @@
void AstTyper::VisitLiteral(Literal* expr) {
Type* type = Type::Constant(expr->value(), isolate_);
- MergeLowerType(expr, type);
- MergeUpperType(expr, type);
+ NarrowType(expr, Bounds(type, isolate_));
}
void AstTyper::VisitRegExpLiteral(RegExpLiteral* expr) {
- MergeLowerType(expr, Type::RegExp());
- MergeUpperType(expr, Type::RegExp());
+ NarrowType(expr, Bounds(Type::RegExp(), isolate_));
}
@@ -290,8 +285,7 @@
}
}
- MergeLowerType(expr, Type::Object());
- MergeUpperType(expr, Type::Object());
+ NarrowType(expr, Bounds(Type::Object(), isolate_));
}
@@ -302,8 +296,7 @@
RECURSE(Visit(value));
}
- MergeLowerType(expr, Type::Array());
- MergeUpperType(expr, Type::Array());
+ NarrowType(expr, Bounds(Type::Array(), isolate_));
}
@@ -320,6 +313,8 @@
expr->RecordTypeFeedback(oracle(), zone());
}
}
+
+ NarrowType(expr, expr->binary_operation()->bounds());
} else {
RECURSE(Visit(expr->target()));
RECURSE(Visit(expr->value()));
@@ -328,8 +323,7 @@
expr->RecordTypeFeedback(oracle(), zone());
}
- MergeLowerType(expr, expr->value()->lower_type());
- MergeUpperType(expr, expr->value()->upper_type());
+ NarrowType(expr, expr->value()->bounds());
}
// TODO(rossberg): handle target variables
}
@@ -346,8 +340,7 @@
void AstTyper::VisitThrow(Throw* expr) {
RECURSE(Visit(expr->exception()));
- // Lower type is None already.
- MergeUpperType(expr, Type::None());
+ NarrowType(expr, Bounds(Type::None(), isolate_));
}
@@ -412,7 +405,7 @@
// Collect type feedback.
Handle<Type> op_type =
oracle()->UnaryType(expr->UnaryOperationFeedbackId());
- MergeLowerType(expr->expression(), op_type);
+ NarrowLowerType(expr->expression(), op_type);
if (expr->op() == Token::NOT) {
// TODO(rossberg): only do in test or value context.
expr->expression()->RecordToBooleanTypeFeedback(oracle());
@@ -421,27 +414,23 @@
switch (expr->op()) {
case Token::NOT:
case Token::DELETE:
- MergeLowerType(expr, Type::Boolean());
- MergeUpperType(expr, Type::Boolean());
+ NarrowType(expr, Bounds(Type::Boolean(), isolate_));
break;
case Token::VOID:
- MergeLowerType(expr, Type::Undefined());
- MergeUpperType(expr, Type::Undefined());
+ NarrowType(expr, Bounds(Type::Undefined(), isolate_));
break;
case Token::ADD:
case Token::SUB: {
- MergeLowerType(expr, Type::Smi());
- Type* upper = *expr->expression()->upper_type();
- MergeUpperType(expr, upper->Is(Type::Number()) ? upper :
Type::Number());
+ Type* upper = *expr->expression()->bounds().upper;
+ if (!upper->Is(Type::Number())) upper = Type::Number();
+ NarrowType(expr, Bounds(Type::Smi(), upper, isolate_));
break;
}
case Token::BIT_NOT:
- MergeLowerType(expr, Type::Smi());
- MergeUpperType(expr, Type::Signed32());
+ NarrowType(expr, Bounds(Type::Smi(), Type::Signed32(), isolate_));
break;
case Token::TYPEOF:
- MergeLowerType(expr, Type::InternalizedString());
- MergeUpperType(expr, Type::InternalizedString());
+ NarrowType(expr, Bounds(Type::InternalizedString(), isolate_));
break;
default:
UNREACHABLE();
@@ -458,8 +447,7 @@
prop->RecordTypeFeedback(oracle(), zone());
}
- MergeLowerType(expr, Type::Smi());
- MergeUpperType(expr, Type::Number());
+ NarrowType(expr, Bounds(Type::Smi(), Type::Number(), isolate_));
}
@@ -472,9 +460,9 @@
Maybe<int> fixed_right_arg;
oracle()->BinaryType(expr->BinaryOperationFeedbackId(),
&left_type, &right_type, &type, &fixed_right_arg);
- MergeLowerType(expr, type);
- MergeLowerType(expr->left(), left_type);
- MergeLowerType(expr->right(), right_type);
+ NarrowLowerType(expr, type);
+ NarrowLowerType(expr->left(), left_type);
+ NarrowLowerType(expr->right(), right_type);
expr->set_fixed_right_arg(fixed_right_arg);
if (expr->op() == Token::OR || expr->op() == Token::AND) {
expr->left()->RecordToBooleanTypeFeedback(oracle());
@@ -482,56 +470,50 @@
switch (expr->op()) {
case Token::COMMA:
- MergeLowerType(expr, expr->right()->lower_type());
- MergeUpperType(expr, expr->right()->upper_type());
+ NarrowType(expr, expr->right()->bounds());
break;
case Token::OR:
case Token::AND:
- MergeLowerType(expr, Type::Intersect(
- expr->left()->lower_type(), expr->right()->lower_type()));
- MergeUpperType(expr, Type::Union(
- expr->left()->upper_type(), expr->right()->upper_type()));
+ NarrowType(expr, Bounds::Either(
+ expr->left()->bounds(), expr->right()->bounds(), isolate_));
break;
case Token::BIT_OR:
case Token::BIT_AND: {
- MergeLowerType(expr, Type::Smi());
- Type* upper =
- Type::Union(expr->left()->upper_type(),
expr->right()->upper_type());
- MergeUpperType(expr,
- upper->Is(Type::Signed32()) ? upper : Type::Signed32());
+ Type* upper = Type::Union(
+ expr->left()->bounds().upper, expr->right()->bounds().upper);
+ if (!upper->Is(Type::Signed32())) upper = Type::Signed32();
+ NarrowType(expr, Bounds(Type::Smi(), upper, isolate_));
break;
}
case Token::BIT_XOR:
case Token::SHL:
case Token::SAR:
- MergeLowerType(expr, Type::Smi());
- MergeUpperType(expr, Type::Signed32());
+ NarrowType(expr, Bounds(Type::Smi(), Type::Signed32(), isolate_));
break;
case Token::SHR:
- MergeLowerType(expr, Type::Smi());
- MergeUpperType(expr, Type::Unsigned32());
+ NarrowType(expr, Bounds(Type::Smi(), Type::Unsigned32(), isolate_));
break;
case Token::ADD: {
- Handle<Type> l = expr->left()->lower_type();
- Handle<Type> r = expr->right()->lower_type();
- MergeLowerType(expr,
- l->Is(Type::Number()) && r->Is(Type::Number()) ? Type::Smi() :
- l->Is(Type::String()) || r->Is(Type::String()) ? Type::String() :
- Type::None());
- l = expr->left()->upper_type();
- r = expr->right()->upper_type();
- MergeUpperType(expr,
- l->Is(Type::Number()) && r->Is(Type::Number()) ? Type::Number() :
- l->Is(Type::String()) || r->Is(Type::String()) ? Type::String() :
- Type::NumberOrString());
+ Bounds l = expr->left()->bounds();
+ Bounds r = expr->right()->bounds();
+ Type* lower =
+ l.lower->Is(Type::Number()) && r.lower->Is(Type::Number()) ?
+ Type::Smi() :
+ l.lower->Is(Type::String()) || r.lower->Is(Type::String()) ?
+ Type::String() : Type::None();
+ Type* upper =
+ l.upper->Is(Type::Number()) && r.upper->Is(Type::Number()) ?
+ Type::Number() :
+ l.upper->Is(Type::String()) || r.upper->Is(Type::String()) ?
+ Type::String() : Type::NumberOrString();
+ NarrowType(expr, Bounds(lower, upper, isolate_));
break;
}
case Token::SUB:
case Token::MUL:
case Token::DIV:
case Token::MOD:
- MergeLowerType(expr, Type::Smi());
- MergeUpperType(expr, Type::Number());
+ NarrowType(expr, Bounds(Type::Smi(), Type::Number(), isolate_));
break;
default:
UNREACHABLE();
@@ -547,12 +529,11 @@
Handle<Type> left_type, right_type, combined_type;
oracle()->CompareType(expr->CompareOperationFeedbackId(),
&left_type, &right_type, &combined_type);
- MergeLowerType(expr->left(), left_type);
- MergeLowerType(expr->right(), right_type);
+ NarrowLowerType(expr->left(), left_type);
+ NarrowLowerType(expr->right(), right_type);
expr->set_combined_type(combined_type);
- MergeLowerType(expr, Type::Boolean());
- MergeUpperType(expr, Type::Boolean());
+ NarrowType(expr, Bounds(Type::Boolean(), isolate_));
}
=======================================
--- /branches/bleeding_edge/src/typing.h Tue Jul 9 04:48:47 2013
+++ /branches/bleeding_edge/src/typing.h Thu Jul 11 04:47:05 2013
@@ -34,6 +34,7 @@
#include "ast.h"
#include "compiler.h"
#include "type-info.h"
+#include "types.h"
#include "zone.h"
#include "scopes.h"
@@ -62,17 +63,11 @@
TypeFeedbackOracle* oracle() { return &oracle_; }
Zone* zone() const { return info_->zone(); }
- void MergeLowerType(Expression* e, Handle<Type> t) {
- e->set_lower_type(handle(Type::Union(e->lower_type(), t), isolate_));
+ void NarrowType(Expression* e, Bounds b) {
+ e->set_bounds(Bounds::Both(e->bounds(), b, isolate_));
}
- void MergeUpperType(Expression* e, Handle<Type> t) {
- e->set_upper_type(handle(Type::Intersect(e->upper_type(), t),
isolate_));
- }
- void MergeLowerType(Expression* e, Type* t) {
- MergeLowerType(e, handle(t, isolate_));
- }
- void MergeUpperType(Expression* e, Type* t) {
- MergeUpperType(e, handle(t, isolate_));
+ void NarrowLowerType(Expression* e, Handle<Type> t) {
+ e->set_bounds(Bounds::NarrowLower(e->bounds(), t, isolate_));
}
void VisitDeclarations(ZoneList<Declaration*>* declarations);
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/groups/opt_out.
