Experimental: thread live register references to deferred code....

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 549 matching lines @@
 
  private:
   Major MajorKey() { return ToBoolean; }
   int MinorKey() { return 0; }
 };
 
 
 // ECMA-262, section 9.2, page 30: ToBoolean(). Pop the top of stack and
 // convert it to a boolean in the condition code register or jump to
 // 'false_target'/'true_target' as appropriate.
-void CodeGenerator::ToBoolean(JumpTarget* true_target, JumpTarget* false_target) {
+void CodeGenerator::ToBoolean(JumpTarget* true_target,
+                              JumpTarget* false_target) {
   Comment cmnt(masm_, "[ ToBoolean");
 
   // The value to convert should be popped from the stack.
   frame_->EmitPop(eax);
 
   // Fast case checks.
 
   // 'false' => false.
   __ cmp(eax, Factory::false_value());
   false_target->Branch(equal);
@@ skipping 187 matching lines @@
         new DeferredInlineBinaryOperation(this, op, overwrite_mode, flags);
     // Fetch the operands from the stack.
     frame_->EmitPop(ebx);  // get y
     __ mov(eax, frame_->Top());  // get x
     // Generate the inline part of the code.
     deferred->GenerateInlineCode();
     // Put result back on the stack. It seems somewhat weird to let
     // the deferred code jump back before the assignment to the frame
     // top, but this is just to let the peephole optimizer get rid of
     // more code.
-    deferred->exit()->Bind();
+    deferred->BindExit();
     __ mov(frame_->Top(), eax);
   } else {
     // Call the stub and push the result to the stack.
     GenericBinaryOpStub stub(op, overwrite_mode, flags);
     frame_->CallStub(&stub, 2);
     frame_->EmitPush(eax);
   }
 }
 
 
@@ skipping 164 matching lines @@
     case Token::ADD: {
       DeferredCode* deferred = NULL;
       if (!reversed) {
         deferred = new DeferredInlinedSmiAdd(this, int_value, overwrite_mode);
       } else {
         deferred = new DeferredInlinedSmiAddReversed(this, int_value,
                                                      overwrite_mode);
       }
       frame_->EmitPop(eax);
       __ add(Operand(eax), Immediate(value));
-      deferred->enter()->Branch(overflow, not_taken);
+      deferred->BranchTo(overflow);
       __ test(eax, Immediate(kSmiTagMask));
-      deferred->enter()->Branch(not_zero, not_taken);
-      deferred->exit()->Bind();
+      deferred->BranchTo(not_zero);
+      deferred->BindExit();
       frame_->EmitPush(eax);
       break;
     }
 
     case Token::SUB: {
       DeferredCode* deferred = NULL;
       frame_->EmitPop(eax);
       if (!reversed) {
         deferred = new DeferredInlinedSmiSub(this, int_value, overwrite_mode);
         __ sub(Operand(eax), Immediate(value));
       } else {
         deferred = new DeferredInlinedSmiSubReversed(this, edx, overwrite_mode);
         __ mov(edx, Operand(eax));
         __ mov(eax, Immediate(value));
         __ sub(eax, Operand(edx));
       }
-      deferred->enter()->Branch(overflow, not_taken);
+      deferred->BranchTo(overflow);
       __ test(eax, Immediate(kSmiTagMask));
-      deferred->enter()->Branch(not_zero, not_taken);
-      deferred->exit()->Bind();
+      deferred->BranchTo(not_zero);
+      deferred->BindExit();
       frame_->EmitPush(eax);
       break;
     }
 
     case Token::SAR: {
       if (reversed) {
         frame_->EmitPop(eax);
         frame_->EmitPush(Immediate(value));
         frame_->EmitPush(eax);
         GenericBinaryOperation(op, type, overwrite_mode);
       } else {
         int shift_value = int_value & 0x1f;  // only least significant 5 bits
         DeferredCode* deferred =
           new DeferredInlinedSmiOperation(this, Token::SAR, shift_value,
                                           overwrite_mode);
         frame_->EmitPop(eax);
         __ test(eax, Immediate(kSmiTagMask));
-        deferred->enter()->Branch(not_zero, not_taken);
+        deferred->BranchTo(not_zero);
         __ sar(eax, shift_value);
         __ and_(eax, ~kSmiTagMask);
-        deferred->exit()->Bind();
+        deferred->BindExit();
         frame_->EmitPush(eax);
       }
       break;
     }
 
     case Token::SHR: {
       if (reversed) {
         frame_->EmitPop(eax);
         frame_->EmitPush(Immediate(value));
         frame_->EmitPush(eax);
         GenericBinaryOperation(op, type, overwrite_mode);
       } else {
         int shift_value = int_value & 0x1f;  // only least significant 5 bits
         DeferredCode* deferred =
         new DeferredInlinedSmiOperation(this, Token::SHR, shift_value,
                                         overwrite_mode);
         frame_->EmitPop(eax);
         __ test(eax, Immediate(kSmiTagMask));
         __ mov(ebx, Operand(eax));
-        deferred->enter()->Branch(not_zero, not_taken);
+        deferred->BranchTo(not_zero);
         __ sar(ebx, kSmiTagSize);
         __ shr(ebx, shift_value);
         __ test(ebx, Immediate(0xc0000000));
-        deferred->enter()->Branch(not_zero, not_taken);
+        deferred->BranchTo(not_zero);
         // tag result and store it in TOS (eax)
         ASSERT(kSmiTagSize == times_2);  // adjust code if not the case
         __ lea(eax, Operand(ebx, ebx, times_1, kSmiTag));
-        deferred->exit()->Bind();
+        deferred->BindExit();
         frame_->EmitPush(eax);
       }
       break;
     }
 
     case Token::SHL: {
       if (reversed) {
         frame_->EmitPop(eax);
         frame_->EmitPush(Immediate(value));
         frame_->EmitPush(eax);
         GenericBinaryOperation(op, type, overwrite_mode);
       } else {
         int shift_value = int_value & 0x1f;  // only least significant 5 bits
         DeferredCode* deferred =
         new DeferredInlinedSmiOperation(this, Token::SHL, shift_value,
                                         overwrite_mode);
         frame_->EmitPop(eax);
         __ test(eax, Immediate(kSmiTagMask));
         __ mov(ebx, Operand(eax));
-        deferred->enter()->Branch(not_zero, not_taken);
+        deferred->BranchTo(not_zero);
         __ sar(ebx, kSmiTagSize);
         __ shl(ebx, shift_value);
         __ lea(ecx, Operand(ebx, 0x40000000));
         __ test(ecx, Immediate(0x80000000));
-        deferred->enter()->Branch(not_zero, not_taken);
+        deferred->BranchTo(not_zero);
         // tag result and store it in TOS (eax)
         ASSERT(kSmiTagSize == times_2);  // adjust code if not the case
         __ lea(eax, Operand(ebx, ebx, times_1, kSmiTag));
-        deferred->exit()->Bind();
+        deferred->BindExit();
         frame_->EmitPush(eax);
       }
       break;
     }
 
     case Token::BIT_OR:
     case Token::BIT_XOR:
     case Token::BIT_AND: {
       DeferredCode* deferred = NULL;
       if (!reversed) {
         deferred =  new DeferredInlinedSmiOperation(this, op, int_value,
                                                     overwrite_mode);
       } else {
         deferred = new DeferredInlinedSmiOperationReversed(this, op, int_value,
                                                            overwrite_mode);
       }
       frame_->EmitPop(eax);
       __ test(eax, Immediate(kSmiTagMask));
-      deferred->enter()->Branch(not_zero, not_taken);
+      deferred->BranchTo(not_zero);
       if (op == Token::BIT_AND) {
         __ and_(Operand(eax), Immediate(value));
       } else if (op == Token::BIT_XOR) {
         __ xor_(Operand(eax), Immediate(value));
       } else {
         ASSERT(op == Token::BIT_OR);
         __ or_(Operand(eax), Immediate(value));
       }
-      deferred->exit()->Bind();
+      deferred->BindExit();
       frame_->EmitPush(eax);
       break;
     }
 
     default: {
       if (!reversed) {
         frame_->EmitPush(Immediate(value));
       } else {
         frame_->EmitPop(eax);
         frame_->EmitPush(Immediate(value));
@@ skipping 112 matching lines @@
   // Strict only makes sense for equality comparisons.
   ASSERT(!strict || cc == equal);
 
   int int_value = Smi::cast(*value)->value();
   ASSERT(is_intn(int_value, kMaxSmiInlinedBits));
 
   SmiComparisonDeferred* deferred =
       new SmiComparisonDeferred(this, cc, strict, int_value);
   frame_->EmitPop(eax);
   __ test(eax, Immediate(kSmiTagMask));
-  deferred->enter()->Branch(not_zero, not_taken);
+  deferred->BranchTo(not_zero);

[William Hesse, 2008/12/16 09:10:54]

Will conflict with my changes, I think

   // Test smi equality by pointer comparison.
   __ cmp(Operand(eax), Immediate(value));
-  deferred->exit()->Bind();
+  deferred->BindExit();
   cc_reg_ = cc;
 }
 
 
 class CallFunctionStub: public CodeStub {
  public:
   explicit CallFunctionStub(int argc) : argc_(argc) { }
 
   void Generate(MacroAssembler* masm);
 
@@ skipping 1463 matching lines @@
   __ mov(ecx, FieldOperand(ecx, JSFunction::kLiteralsOffset));
 
   // Load the literal at the ast saved index.
   int literal_offset =
       FixedArray::kHeaderSize + node->literal_index() * kPointerSize;
   __ mov(ebx, FieldOperand(ecx, literal_offset));
 
   // Check whether we need to materialize the RegExp object.
   // If so, jump to the deferred code.
   __ cmp(ebx, Factory::undefined_value());
-  deferred->enter()->Branch(equal, not_taken);
-  deferred->exit()->Bind();
+  deferred->BranchTo(equal);
+  deferred->BindExit();
 
   // Push the literal.
   frame_->EmitPush(ebx);
 }
 
 
 // This deferred code stub will be used for creating the boilerplate
 // by calling Runtime_CreateObjectLiteral.
 // Each created boilerplate is stored in the JSFunction and they are
 // therefore context dependent.
@@ skipping 39 matching lines @@
   __ mov(ecx, FieldOperand(ecx, JSFunction::kLiteralsOffset));
 
   // Load the literal at the ast saved index.
   int literal_offset =
       FixedArray::kHeaderSize + node->literal_index() * kPointerSize;
   __ mov(ebx, FieldOperand(ecx, literal_offset));
 
   // Check whether we need to materialize the object literal boilerplate.
   // If so, jump to the deferred code.
   __ cmp(ebx, Factory::undefined_value());
-  deferred->enter()->Branch(equal, not_taken);
-  deferred->exit()->Bind();
+  deferred->BranchTo(equal);
+  deferred->BindExit();
 
   // Push the literal.
   frame_->EmitPush(ebx);
   // Clone the boilerplate object.
   frame_->CallRuntime(Runtime::kCloneObjectLiteralBoilerplate, 1);
   // Push the new cloned literal object as the result.
   frame_->EmitPush(eax);
 
 
   for (int i = 0; i < node->properties()->length(); i++) {
@@ skipping 981 matching lines @@
     // Perform optimistic increment/decrement.
     if (is_increment) {
       __ add(Operand(eax), Immediate(Smi::FromInt(1)));
     } else {
       __ sub(Operand(eax), Immediate(Smi::FromInt(1)));
     }
 
     // If the count operation didn't overflow and the result is a
     // valid smi, we're done. Otherwise, we jump to the deferred
     // slow-case code.
-    deferred->enter()->Branch(overflow, not_taken);
+    deferred->BranchTo(overflow);
     __ test(eax, Immediate(kSmiTagMask));
-    deferred->enter()->Branch(not_zero, not_taken);
+    deferred->BranchTo(not_zero);
 
     // Store the new value in the target if not const.
-    deferred->exit()->Bind();
+    deferred->BindExit();
     frame_->EmitPush(eax);  // Push the new value to TOS
     if (!is_const) target.SetValue(NOT_CONST_INIT);
   }
 
   // Postfix: Discard the new value and use the old.
   if (is_postfix) {
     frame_->Drop();
   }
 }
 
@@ skipping 295 matching lines @@
       __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
       __ cmp(ecx, FIRST_JS_OBJECT_TYPE);
       false_target()->Branch(less);
       __ cmp(ecx, LAST_JS_OBJECT_TYPE);
       cc_reg_ = less_equal;
 
     } else {
       // Uncommon case: typeof testing against a string literal that is
       // never returned from the typeof operator.
       false_target()->Jump();
-      // TODO(): Can this cause a problem because it is an expression that
-      // exits without a virtual frame in place?
     }
     return;
   }
 
   Condition cc = no_condition;
   bool strict = false;
   switch (op) {
     case Token::EQ_STRICT:
       strict = true;
       // Fall through
@@ skipping 279 matching lines @@
   // leave result in register eax.
 
   // Prepare the smi check of both operands by or'ing them together
   // before checking against the smi mask.
   __ mov(ecx, Operand(ebx));
   __ or_(ecx, Operand(eax));
 
   switch (op_) {
     case Token::ADD:
       __ add(eax, Operand(ebx));  // add optimistically
-      enter()->Branch(overflow, not_taken);
+      BranchTo(overflow);
       break;
 
     case Token::SUB:
       __ sub(eax, Operand(ebx));  // subtract optimistically
-      enter()->Branch(overflow, not_taken);
+      BranchTo(overflow);
       break;
 
     case Token::DIV:
     case Token::MOD:
       // Sign extend eax into edx:eax.
       __ cdq();
       // Check for 0 divisor.
       __ test(ebx, Operand(ebx));
-      enter()->Branch(zero, not_taken);
+      BranchTo(zero);
       break;
 
     default:
       // Fall-through to smi check.
       break;
   }
 
   // Perform the actual smi check.
   ASSERT(kSmiTag == 0);  // adjust zero check if not the case
   __ test(ecx, Immediate(kSmiTagMask));
-  enter()->Branch(not_zero, not_taken);
+  BranchTo(not_zero);
 
   switch (op_) {
     case Token::ADD:
     case Token::SUB:
       // Do nothing here.
       break;
 
     case Token::MUL:
       // If the smi tag is 0 we can just leave the tag on one operand.
       ASSERT(kSmiTag == 0);  // adjust code below if not the case
       // Remove tag from one of the operands (but keep sign).
       __ sar(eax, kSmiTagSize);
       // Do multiplication.
       __ imul(eax, Operand(ebx));  // multiplication of smis; result in eax
       // Go slow on overflows.
-      enter()->Branch(overflow, not_taken);
-      // Check for negative zero result.  Use ecx = x | y.
-      __ NegativeZeroTest(generator(), eax, ecx, enter());
+      BranchTo(overflow);
+      // Check for negative zero result.  Use ecx = x | y.  NegativeZeroTest
+      // must be called after the deferred code has already been branched to
+      // via BranchTo, because NegativeZeroTest will not set the entry frame
+      // or register file for the deferred code.
+      __ NegativeZeroTest(eax, ecx, enter());
       break;
 
     case Token::DIV:
       // Divide edx:eax by ebx.
       __ idiv(ebx);
       // Check for the corner case of dividing the most negative smi
       // by -1. We cannot use the overflow flag, since it is not set
       // by idiv instruction.
       ASSERT(kSmiTag == 0 && kSmiTagSize == 1);
       __ cmp(eax, 0x40000000);
-      enter()->Branch(equal);
-      // Check for negative zero result.  Use ecx = x | y.
-      __ NegativeZeroTest(generator(), eax, ecx, enter());
+      BranchTo(equal);
+      // Check for negative zero result.  Use ecx = x | y.  NegativeZeroTest
+      // must be called after the deferred code has already been branched to
+      // via BranchTo, because NegativeZeroTest will not set the entry frame
+      // or register file for the deferred code.
+      __ NegativeZeroTest(eax, ecx, enter());
       // Check that the remainder is zero.
       __ test(edx, Operand(edx));
-      enter()->Branch(not_zero);
+      BranchTo(not_zero);
       // Tag the result and store it in register eax.
       ASSERT(kSmiTagSize == times_2);  // adjust code if not the case
       __ lea(eax, Operand(eax, eax, times_1, kSmiTag));
       break;
 
     case Token::MOD:
       // Divide edx:eax by ebx.
       __ idiv(ebx);
-      // Check for negative zero result.  Use ecx = x | y.
-      __ NegativeZeroTest(generator(), edx, ecx, enter());
+      // Check for negative zero result.  Use ecx = x | y.  NegativeZeroTest
+      // must be called after the deferred code has already been branched to
+      // via BranchTo, because NegativeZeroTest will not set the entry frame
+      // or register file for the deferred code.
+      __ NegativeZeroTest(edx, ecx, enter());
       // Move remainder to register eax.
       __ mov(eax, Operand(edx));
       break;
 
     case Token::BIT_OR:
       __ or_(eax, Operand(ebx));
       break;
 
     case Token::BIT_AND:
       __ and_(eax, Operand(ebx));
@@ skipping 19 matching lines @@
           break;
         case Token::SHR:
           __ shr(eax);
           // Check that the *unsigned* result fits in a smi.
           // Neither of the two high-order bits can be set:
           // - 0x80000000: high bit would be lost when smi tagging.
           // - 0x40000000: this number would convert to negative when
           // Smi tagging these two cases can only happen with shifts
           // by 0 or 1 when handed a valid smi.
           __ test(eax, Immediate(0xc0000000));
-          enter()->Branch(not_zero, not_taken);
+          BranchTo(not_zero);
           break;
         case Token::SHL:
           __ shl(eax);
           // Check that the *signed* result fits in a smi.
           __ lea(ecx, Operand(eax, 0x40000000));
           __ test(ecx, Immediate(0x80000000));
-          enter()->Branch(not_zero, not_taken);
+          BranchTo(not_zero);
           break;
         default:
           UNREACHABLE();
       }
       // Tag the result and store it in register eax.
       ASSERT(kSmiTagSize == times_2);  // adjust code if not the case
       __ lea(eax, Operand(eax, eax, times_1, kSmiTag));
       break;
 
     default:
@@ skipping 1167 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal