Experimental: port bleeding_edge r1276 (a grab bag of optimizations)...

src/codegen-ia32.cc

 // Copyright 2006-2008 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 1172 matching lines @@
       } else {
         deferred = new DeferredInlineSmiOperationReversed(this, op, smi_value,
                                                           overwrite_mode);
       }
       Result operand = frame_->Pop();
       operand.ToRegister();
       __ test(operand.reg(), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, &operand, not_taken);
       frame_->Spill(operand.reg());
       if (op == Token::BIT_AND) {
-        __ and_(Operand(operand.reg()), Immediate(value));
+        if (int_value == 0) {
+          __ xor_(Operand(operand.reg()), operand.reg());
+        } else {
+          __ and_(Operand(operand.reg()), Immediate(value));
+        }
       } else if (op == Token::BIT_XOR) {
-        __ xor_(Operand(operand.reg()), Immediate(value));
+        if (int_value != 0) {
+          __ xor_(Operand(operand.reg()), Immediate(value));
+        }
       } else {
         ASSERT(op == Token::BIT_OR);
-        __ or_(Operand(operand.reg()), Immediate(value));
+        if (int_value != 0) {
+          __ or_(Operand(opernand.reg()), Immediate(value));

[Lasse Reichstein, 2009/02/19 12:19:37]

"opernand" typo?

[Kevin Millikin (Chromium), 2009/02/19 12:21:06]

Duh.  Thanks.

+        }
       }
       deferred->BindExit(&operand);
       frame_->Push(&operand);
       break;
     }
 
     default: {
       if (!reversed) {
         frame_->Push(value);
       } else {
@@ skipping 2905 matching lines @@
       frame_->SetElementAt(0, Factory::true_value());
     }
 
   } else if (op == Token::TYPEOF) {
     // Special case for loading the typeof expression; see comment on
     // LoadTypeofExpression().
     LoadTypeofExpression(node->expression());
     Result answer = frame_->CallRuntime(Runtime::kTypeof, 1);
     frame_->Push(&answer);
 
+  } else if (op == Token::VOID) {
+    Expression* expression = node->expression();
+    if (expression && expression->AsLiteral() && (
+        expression->AsLiteral()->IsTrue() ||
+        expression->AsLiteral()->IsFalse() ||
+        expression->AsLiteral()->handle()->IsNumber() ||
+        expression->AsLiteral()->handle()->IsString() ||
+        expression->AsLiteral()->handle()->IsJSRegExp() ||
+        expression->AsLiteral()->IsNull())) {
+      // Omit evaluating the value of the primitive literal.
+      // It will be discarded anyway, and can have no side effect.
+      frame_->Push(Factory::undefined_value());
+    } else {
+      Load(node->expression());
+      frame_->SetElementAt(0, Factory::undefined_value());
+    }
+
   } else {
     Load(node->expression());
     switch (op) {
       case Token::NOT:
       case Token::DELETE:
       case Token::TYPEOF:
         UNREACHABLE();  // handled above
         break;
 
       case Token::SUB: {
@@ skipping 23 matching lines @@
         smi_label.Bind(&answer);
         answer.ToRegister();
         frame_->Spill(answer.reg());
         __ not_(answer.reg());
         __ and_(answer.reg(), ~kSmiTagMask);  // Remove inverted smi-tag.
         continue_label.Bind(&answer);
         frame_->Push(&answer);
         break;
       }
 
-      case Token::VOID: {
-        frame_->SetElementAt(0, Factory::undefined_value());
-        break;
-      }
-
       case Token::ADD: {
         // Smi check.
         JumpTarget continue_label(this);
         Result operand = frame_->Pop();
         operand.ToRegister();
         __ test(operand.reg(), Immediate(kSmiTagMask));
         continue_label.Branch(zero, &operand, taken);
 
         frame_->Push(&operand);
         Result answer = frame_->InvokeBuiltin(Builtins::TO_NUMBER,
@@ skipping 2385 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal