Reviewers: Kevin Millikin,
Description:
Recognize special comparisons via pattern matching on the hydrogen graph.
Previously, comparisons against null/undefined and comparisons of the
result of
typeof against a constant string were done syntactically. Now we do this via
pattern matching on the hydrogen graph, which opens up more opportunities
for
better code generation, e.g. the following comparisons are now recognized
to be
special:
var bar = typeof foo;
var baz = "undefined";
if (bar == baz) ...
var blah = undefined;
if (hurz == blah) ...
If we did this handling of special cases even later at lithium generation
time,
even more cases could be recognized, but this would involve bigger changes
and
this CL handles most common cases.
Please review this at http://codereview.chromium.org/8242002/
SVN Base: http://v8.googlecode.com/svn/branches/bleeding_edge/
Affected files:
M src/hydrogen.h
M src/hydrogen.cc
Index: src/hydrogen.cc
===================================================================
--- src/hydrogen.cc (revision 9587)
+++ src/hydrogen.cc (working copy)
@@ -5791,38 +5791,69 @@
void HGraphBuilder::HandleLiteralCompareTypeof(CompareOperation* expr,
- Expression* sub_expr,
- Handle<String> check) {
- CHECK_ALIVE(VisitForTypeOf(sub_expr));
- HValue* value = Pop();
- HTypeofIsAndBranch* instr = new(zone()) HTypeofIsAndBranch(value, check);
+ HValue* typeof_expr,
+ HValue* check) {
+ HValue* value = HTypeof::cast(typeof_expr)->value();
+ Handle<String> blah =
Handle<String>::cast(HConstant::cast(check)->handle());
+ HTypeofIsAndBranch* instr = new(zone()) HTypeofIsAndBranch(value, blah);
instr->set_position(expr->position());
- return ast_context()->ReturnControl(instr, expr->id());
+ ast_context()->ReturnControl(instr, expr->id());
+ typeof_expr->DeleteAndReplaceWith(instr);
}
-bool HGraphBuilder::TryLiteralCompare(CompareOperation* expr) {
- Expression *sub_expr;
- Handle<String> check;
- if (expr->IsLiteralCompareTypeof(&sub_expr, &check)) {
- HandleLiteralCompareTypeof(expr, sub_expr, check);
+static bool MatchLiteralCompareNil(HValue* left,
+ Token::Value op,
+ HValue* right,
+ Handle<Object> nil,
+ HValue** expr) {
+ if (left->IsConstant() &&
+ HConstant::cast(left)->handle().is_identical_to(nil) &&
+ Token::IsEqualityOp(op)) {
+ *expr = right;
return true;
}
+ return false;
+}
- if (expr->IsLiteralCompareUndefined(&sub_expr)) {
- HandleLiteralCompareNil(expr, sub_expr, kUndefinedValue);
- return true;
- }
- if (expr->IsLiteralCompareNull(&sub_expr)) {
- HandleLiteralCompareNil(expr, sub_expr, kNullValue);
+static bool MatchLiteralCompareTypeof(HValue* left,
+ Token::Value op,
+ HValue* right,
+ HValue** typeof_expr,
+ HValue** check) {
+ if (left->IsTypeof() &&
+ Token::IsEqualityOp(op) &&
+ right->IsConstant() &&
+ HConstant::cast(right)->HasStringValue()) {
+ *typeof_expr = left;
+ *check = right;
return true;
}
-
return false;
}
+static bool IsLiteralCompareTypeof(HValue* left,
+ Token::Value op,
+ HValue* right,
+ HValue** typeof_expr,
+ HValue** check) {
+ return MatchLiteralCompareTypeof(left, op, right, typeof_expr, check) ||
+ MatchLiteralCompareTypeof(right, op, left, typeof_expr, check);
+}
+
+
+static bool IsLiteralCompareNil(HValue* left,
+ Token::Value op,
+ HValue* right,
+ Handle<Object> nil,
+ HValue** expr) {
+ return MatchLiteralCompareNil(left, op, right, nil, expr) ||
+ MatchLiteralCompareNil(right, op, left, nil, expr);
+}
+
+
void HGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
ASSERT(!HasStackOverflow());
ASSERT(current_block() != NULL);
@@ -5840,11 +5871,9 @@
return ast_context()->ReturnControl(instr, expr->id());
}
- // Check for special cases that compare against literals.
- if (TryLiteralCompare(expr)) return;
-
TypeInfo type_info = oracle()->CompareType(expr);
// Check if this expression was ever executed according to type feedback.
+ // Note that for the special typeof/null/undefined cases we get unknown
here.
if (type_info.IsUninitialized()) {
AddInstruction(new(zone()) HSoftDeoptimize);
current_block()->MarkAsDeoptimizing();
@@ -5859,6 +5888,20 @@
HValue* left = Pop();
Token::Value op = expr->op();
+ HValue* typeof_expr = NULL;
+ HValue* check = NULL;
+ if (IsLiteralCompareTypeof(left, op, right, &typeof_expr, &check)) {
+ return HandleLiteralCompareTypeof(expr, typeof_expr, check);
+ }
+ HValue* sub_expr = NULL;
+ Factory* f = graph()->isolate()->factory();
+ if (IsLiteralCompareNil(left, op, right, f->undefined_value(),
&sub_expr)) {
+ return HandleLiteralCompareNil(expr, sub_expr, kUndefinedValue);
+ }
+ if (IsLiteralCompareNil(left, op, right, f->null_value(), &sub_expr)) {
+ return HandleLiteralCompareNil(expr, sub_expr, kNullValue);
+ }
+
if (op == Token::INSTANCEOF) {
// Check to see if the rhs of the instanceof is a global function not
// residing in new space. If it is we assume that the function will
stay the
@@ -5947,13 +5990,11 @@
void HGraphBuilder::HandleLiteralCompareNil(CompareOperation* expr,
- Expression* sub_expr,
+ HValue* value,
NilValue nil) {
ASSERT(!HasStackOverflow());
ASSERT(current_block() != NULL);
ASSERT(current_block()->HasPredecessor());
- CHECK_ALIVE(VisitForValue(sub_expr));
- HValue* value = Pop();
EqualityKind kind =
expr->op() == Token::EQ_STRICT ? kStrictEquality :
kNonStrictEquality;
HIsNilAndBranch* instr = new(zone()) HIsNilAndBranch(value, kind, nil);
Index: src/hydrogen.h
===================================================================
--- src/hydrogen.h (revision 9587)
+++ src/hydrogen.h (working copy)
@@ -912,12 +912,11 @@
HValue* receiver,
SmallMapList* types,
Handle<String> name);
- bool TryLiteralCompare(CompareOperation* expr);
void HandleLiteralCompareTypeof(CompareOperation* expr,
- Expression* sub_expr,
- Handle<String> check);
+ HValue* typeof_expr,
+ HValue* check);
void HandleLiteralCompareNil(CompareOperation* expr,
- Expression* sub_expr,
+ HValue* value,
NilValue nil);
HStringCharCodeAt* BuildStringCharCodeAt(HValue* context,
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
