Better codegen for '<expression> === void <literal>'.

src/hydrogen.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 5484 matching lines @@
 
 Representation HGraphBuilder::ToRepresentation(TypeInfo info) {
   if (info.IsSmi()) return Representation::Integer32();
   if (info.IsInteger32()) return Representation::Integer32();
   if (info.IsDouble()) return Representation::Double();
   if (info.IsNumber()) return Representation::Double();
   return Representation::Tagged();
 }
 
 
+void HGraphBuilder::HandleLiteralCompareTypeof(CompareOperation* compare_expr,
+                                               Expression* expr,
+                                               Handle<String> check) {
+  CHECK_ALIVE(VisitForTypeOf(expr));
+  HValue* expr_value = Pop();
+  HInstruction* instr = new(zone()) HTypeofIs(expr_value, check);
+  instr->set_position(compare_expr->position());
+  ast_context()->ReturnInstruction(instr, compare_expr->id());
+}
+
+
+void HGraphBuilder::HandleLiteralCompareUndefined(
+    CompareOperation* compare_expr, Expression* expr) {
+  CHECK_ALIVE(VisitForValue(expr));
+  HValue* lhs = Pop();
+  HValue* rhs = graph()->GetConstantUndefined();
+  HInstruction* instr =
+      new(zone()) HCompareSymbolEq(lhs, rhs, Token::EQ_STRICT);
+  instr->set_position(compare_expr->position());
+  ast_context()->ReturnInstruction(instr, compare_expr->id());
+}
+
+
 void HGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   if (IsClassOfTest(expr)) {
     CallRuntime* call = expr->left()->AsCallRuntime();
     CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
     HValue* value = Pop();
     Literal* literal = expr->right()->AsLiteral();
     Handle<String> rhs = Handle<String>::cast(literal->handle());
     HInstruction* instr = new(zone()) HClassOfTest(value, rhs);
     instr->set_position(expr->position());
     ast_context()->ReturnInstruction(instr, expr->id());
     return;
   }
 
-  // Check for the pattern: typeof <expression> == <string literal>.
-  UnaryOperation* left_unary = expr->left()->AsUnaryOperation();
-  Literal* right_literal = expr->right()->AsLiteral();
-  if ((expr->op() == Token::EQ || expr->op() == Token::EQ_STRICT) &&
-      left_unary != NULL && left_unary->op() == Token::TYPEOF &&
-      right_literal != NULL && right_literal->handle()->IsString()) {
-    CHECK_ALIVE(VisitForTypeOf(left_unary->expression()));
-    HValue* left = Pop();
-    HInstruction* instr = new(zone()) HTypeofIs(left,
-        Handle<String>::cast(right_literal->handle()));
-    instr->set_position(expr->position());
-    ast_context()->ReturnInstruction(instr, expr->id());
-    return;
+  if (expr->op() == Token::EQ || expr->op() == Token::EQ_STRICT) {
+    UnaryOperation* left_unary = expr->left()->AsUnaryOperation();
+    UnaryOperation* right_unary = expr->right()->AsUnaryOperation();
+    Literal* left_literal = expr->left()->AsLiteral();
+    Literal* right_literal = expr->right()->AsLiteral();
+
+    // Check for the pattern: typeof <expression> == <string literal>.

[fschneider, 2011/06/21 11:36:08]

Since this pattern matching code is exactly the same in the two code generators,
it would be a good idea to share it to avoid code duplication. You could make a
predicate on the AST node CompareOperation in ast.h/ast.cc and write sth like:

if (expr->IsLiteralCompareTypeof() {
  return HandleLiteralCompareTypeof(expr)
}

if  (expr->IsLiteralCompareUndefined()) {
  return HandleLiteralCompareUndefined(expr);
}

[Steven, 2011/06/22 10:00:53]

Done.

+    if (left_unary != NULL && left_unary->op() == Token::TYPEOF &&
+        right_literal != NULL && right_literal->handle()->IsString()) {
+      HandleLiteralCompareTypeof(
+          expr, left_unary->expression(),
+          Handle<String>::cast(right_literal->handle()));
+      return;
+    }
+
+    // Check for the pattern: <string literal> == typeof <expression>.
+    if (right_unary != NULL && right_unary->op() == Token::TYPEOF &&
+        left_literal != NULL && left_literal->handle()->IsString()) {
+      HandleLiteralCompareTypeof(
+          expr, right_unary->expression(),
+          Handle<String>::cast(left_literal->handle()));
+      return;
+    }
+
+    // Check for the pattern: <expression> === void <literal>.
+    if (expr->op() == Token::EQ_STRICT && right_unary != NULL &&
+        right_unary->op() == Token::VOID &&
+        right_unary->expression()->AsLiteral() != NULL) {
+      HandleLiteralCompareUndefined(expr, expr->left());
+      return;
+    }
+    
+    // Check for the pattern: void <literal> === <expression>.
+    if (expr->op() == Token::EQ_STRICT && left_unary != NULL &&
+        left_unary->op() == Token::VOID &&
+        left_unary->expression()->AsLiteral() != NULL) {
+      HandleLiteralCompareUndefined(expr, expr->right());
+      return;
+    }    
   }
 
   TypeInfo type_info = oracle()->CompareType(expr);
   // Check if this expression was ever executed according to type feedback.
   if (type_info.IsUninitialized()) {
     AddInstruction(new(zone()) HSoftDeoptimize);
     current_block()->MarkAsDeoptimizing();
     type_info = TypeInfo::Unknown();
   }
 
@@ skipping 1030 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal