Experimental: thread the virtual frame through the 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 288 matching lines @@
 
   // Adjust for function-level loop nesting.
   loop_nesting_ -= fun->loop_nesting();
 
   // Code generation state must be reset.
   ASSERT(state_ == NULL);
   ASSERT(loop_nesting() == 0);
   ASSERT(!function_return_is_shadowed_);
   function_return_.Unuse();
   ASSERT(!has_cc());
+  DeleteFrame();
+
+  // Process any deferred code using the register allocator.
+  ProcessDeferred();
+
   // There is no need to delete the register allocator, it is a
   // stack-allocated local.
-  DeleteFrame();
   allocator_ = NULL;
   scope_ = NULL;
 }
 
 
 Operand CodeGenerator::SlotOperand(Slot* slot, Register tmp) {
   // Currently, this assertion will fail if we try to assign to
   // a constant variable that is constant because it is read-only
   // (such as the variable referring to a named function expression).
   // We need to implement assignments to read-only variables.
@@ skipping 367 matching lines @@
   }
 }
 
 
 class DeferredInlineBinaryOperation: public DeferredCode {
  public:
   DeferredInlineBinaryOperation(CodeGenerator* generator,
                                 Token::Value op,
                                 OverwriteMode mode,
                                 GenericBinaryFlags flags)
-      : DeferredCode(generator), stub_(op, mode, flags) { }
+      : DeferredCode(generator),
+        stub_(op, mode, flags),
+        op_(op) {
+  }
 
-  void GenerateInlineCode() {
-    stub_.GenerateSmiCode(masm(), enter());
-  }
+  void GenerateInlineCode();

[William Hesse, 2008/12/10 12:02:51]

Where is this function now defined?  Or is it dead?

[Kevin Millikin (Chromium), 2008/12/10 12:09:50]

Not dead, we call it in the generic binary operation.  It's a clone of
GenericBinaryOpStub::GenerateSmiCode, so I defined them together to emphasize
that fact.

 
   virtual void Generate() {
     __ push(ebx);
     __ CallStub(&stub_);
     // We must preserve the eax value here, because it will be written
     // to the top-of-stack element when getting back to the fast case
     // code. See comment in GenericBinaryOperation where
     // deferred->exit() is bound.
     __ push(eax);
   }
 
  private:
   GenericBinaryOpStub stub_;
+  Token::Value op_;
 };
 
 
 void CodeGenerator::GenericBinaryOperation(Token::Value op,
                                            StaticType* type,
                                            OverwriteMode overwrite_mode) {
   Comment cmnt(masm_, "[ BinaryOperation");
   Comment cmnt_token(masm_, Token::String(op));
 
   if (op == Token::COMMA) {
@@ skipping 35 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.
-    __ bind(deferred->exit());
+    deferred->exit()->Bind();
     __ 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));
-      __ j(overflow, deferred->enter(), not_taken);
+      deferred->enter()->Branch(overflow, not_taken);
       __ test(eax, Immediate(kSmiTagMask));
-      __ j(not_zero, deferred->enter(), not_taken);
-      __ bind(deferred->exit());
+      deferred->enter()->Branch(not_zero, not_taken);
+      deferred->exit()->Bind();
       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));
       }
-      __ j(overflow, deferred->enter(), not_taken);
+      deferred->enter()->Branch(overflow, not_taken);
       __ test(eax, Immediate(kSmiTagMask));
-      __ j(not_zero, deferred->enter(), not_taken);
-      __ bind(deferred->exit());
+      deferred->enter()->Branch(not_zero, not_taken);
+      deferred->exit()->Bind();
       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));
-        __ j(not_zero, deferred->enter(), not_taken);
+        deferred->enter()->Branch(not_zero, not_taken);
         __ sar(eax, shift_value);
         __ and_(eax, ~kSmiTagMask);
-        __ bind(deferred->exit());
+        deferred->exit()->Bind();
         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));
-        __ j(not_zero, deferred->enter(), not_taken);
+        deferred->enter()->Branch(not_zero, not_taken);
         __ sar(ebx, kSmiTagSize);
         __ shr(ebx, shift_value);
         __ test(ebx, Immediate(0xc0000000));
-        __ j(not_zero, deferred->enter(), not_taken);
+        deferred->enter()->Branch(not_zero, not_taken);
         // 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));
-        __ bind(deferred->exit());
+        deferred->exit()->Bind();
         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));
-        __ j(not_zero, deferred->enter(), not_taken);
+        deferred->enter()->Branch(not_zero, not_taken);
         __ sar(ebx, kSmiTagSize);
         __ shl(ebx, shift_value);
         __ lea(ecx, Operand(ebx, 0x40000000));
         __ test(ecx, Immediate(0x80000000));
-        __ j(not_zero, deferred->enter(), not_taken);
+        deferred->enter()->Branch(not_zero, not_taken);
         // 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));
-        __ bind(deferred->exit());
+        deferred->exit()->Bind();
         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));
-      __ j(not_zero, deferred->enter(), not_taken);
+      deferred->enter()->Branch(not_zero, not_taken);
       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));
       }
-      __ bind(deferred->exit());
+      deferred->exit()->Bind();
       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));
-  __ j(not_zero, deferred->enter(), not_taken);
+  deferred->enter()->Branch(not_zero, not_taken);
   // Test smi equality by pointer comparison.
   __ cmp(Operand(eax), Immediate(value));
-  __ bind(deferred->exit());
+  deferred->exit()->Bind();
   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());
-  __ j(equal, deferred->enter(), not_taken);
-  __ bind(deferred->exit());
+  deferred->enter()->Branch(equal, not_taken);
+  deferred->exit()->Bind();
 
   // 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());
-  __ j(equal, deferred->enter(), not_taken);
-  __ bind(deferred->exit());
+  deferred->enter()->Branch(equal, not_taken);
+  deferred->exit()->Bind();
 
   // 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.
-    __ j(overflow, deferred->enter(), not_taken);
+    deferred->enter()->Branch(overflow, not_taken);
     __ test(eax, Immediate(kSmiTagMask));
-    __ j(not_zero, deferred->enter(), not_taken);
+    deferred->enter()->Branch(not_zero, not_taken);
 
     // Store the new value in the target if not const.
-    __ bind(deferred->exit());
+    deferred->exit()->Bind();
     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 576 matching lines @@
   // Return 1/0 for true/false in eax.
   __ bind(&true_result);
   __ mov(eax, 1);
   __ ret(1 * kPointerSize);
   __ bind(&false_result);
   __ mov(eax, 0);
   __ ret(1 * kPointerSize);
 }
 
 
+#undef __
+#define __ masm_->
+
+// This function's implementation is a copy of
+// GenericBinaryOpStub::GenerateSmiCode, with the slow-case label replaced
+// with the deferred code's entry target.  The duplicated code is a
+// temporary intermediate stage on the way to using the virtual frame in
+// more places.
+void DeferredInlineBinaryOperation::GenerateInlineCode() {

[Kevin Millikin (Chromium), 2008/12/10 12:09:50]

...is defined right here.

+  // Perform fast-case smi code for the operation (eax <op> ebx) and
+  // 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);
+      break;
+
+    case Token::SUB:
+      __ sub(eax, Operand(ebx));  // subtract optimistically
+      enter()->Branch(overflow, not_taken);
+      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);
+      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);
+
+  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());
+      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());
+      // Check that the remainder is zero.
+      __ test(edx, Operand(edx));
+      enter()->Branch(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());
+      // 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));
+      break;
+
+    case Token::BIT_XOR:
+      __ xor_(eax, Operand(ebx));
+      break;
+
+    case Token::SHL:
+    case Token::SHR:
+    case Token::SAR:
+      // Move the second operand into register ecx.
+      __ mov(ecx, Operand(ebx));
+      // Remove tags from operands (but keep sign).
+      __ sar(eax, kSmiTagSize);
+      __ sar(ecx, kSmiTagSize);
+      // Perform the operation.
+      switch (op_) {
+        case Token::SAR:
+          __ sar(eax);
+          // No checks of result necessary
+          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);
+          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);
+          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:
+      UNREACHABLE();
+      break;
+  }
+}
+
+
+#undef __
+#define __ masm->
+
 void GenericBinaryOpStub::GenerateSmiCode(MacroAssembler* masm, Label* slow) {
   // Perform fast-case smi code for the operation (eax <op> ebx) and
   // 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_) {
@@ skipping 1148 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal