Experimental: introduce a simple mechanism to allow jump targets with...

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 720 matching lines @@
 };
 
 
 void DeferredInlineBinaryOperation::Generate() {
   Result left(generator());
   Result right(generator());
   enter()->Bind(&left, &right);
   generator()->frame()->Push(&left);
   generator()->frame()->Push(&right);
   Result answer = generator()->frame()->CallStub(&stub_, 2);
-  exit()->Jump(&answer);
+  exit_.Jump(&answer);
 }
 
 
 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 27 matching lines @@
       break;
   }
 
   if (flags == SMI_CODE_INLINED) {
     // Create a new deferred code for the slow-case part.
     DeferredInlineBinaryOperation* deferred =
         new DeferredInlineBinaryOperation(this, op, overwrite_mode, flags);
     // Generate the inline part of the code.
     // The operands are on the frame.
     Result answer = deferred->GenerateInlineCode();
-    deferred->exit()->Bind(&answer);
+    deferred->BindExit(&answer);
     frame_->Push(&answer);
   } else {
     // Call the stub and push the result to the stack.
     GenericBinaryOpStub stub(op, overwrite_mode, flags);
     Result answer = frame_->CallStub(&stub, 2);
     frame_->Push(&answer);
   }
 }
 
 
@@ skipping 19 matching lines @@
 };
 
 
 void DeferredInlineSmiOperation::Generate() {
   Result left(generator());
   enter()->Bind(&left);
   generator()->frame()->Push(&left);
   generator()->frame()->Push(value_);
   GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
-  exit()->Jump(&answer);
+  exit_.Jump(&answer);
 }
 
 
 class DeferredInlineSmiOperationReversed: public DeferredCode {
  public:
   DeferredInlineSmiOperationReversed(CodeGenerator* generator,
                                      Token::Value op,
                                      Smi* value,
                                      OverwriteMode overwrite_mode)
       : DeferredCode(generator),
@@ skipping 12 matching lines @@
 };
 
 
 void DeferredInlineSmiOperationReversed::Generate() {
   Result right(generator());
   enter()->Bind(&right);
   generator()->frame()->Push(value_);
   generator()->frame()->Push(&right);
   GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
-  exit()->Jump(&answer);
+  exit_.Jump(&answer);
 }
 
 
 class DeferredInlineSmiAdd: public DeferredCode {
  public:
   DeferredInlineSmiAdd(CodeGenerator* generator,
                        Smi* value,
                        OverwriteMode overwrite_mode)
       : DeferredCode(generator),
         value_(value),
@@ skipping 13 matching lines @@
   // Undo the optimistic add operation and call the shared stub.
   Result left(generator());  // Initially left + value_.
   enter()->Bind(&left);
   left.ToRegister();
   generator()->frame()->Spill(left.reg());
   __ sub(Operand(left.reg()), Immediate(value_));
   generator()->frame()->Push(&left);
   generator()->frame()->Push(value_);
   GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
-  exit()->Jump(&answer);
+  exit_.Jump(&answer);
 }
 
 
 class DeferredInlineSmiAddReversed: public DeferredCode {
  public:
   DeferredInlineSmiAddReversed(CodeGenerator* generator,
                                Smi* value,
                                OverwriteMode overwrite_mode)
       : DeferredCode(generator),
         value_(value),
@@ skipping 13 matching lines @@
   // Undo the optimistic add operation and call the shared stub.
   Result right(generator());  // Initially value_ + right.
   enter()->Bind(&right);
   right.ToRegister();
   generator()->frame()->Spill(right.reg());
   __ sub(Operand(right.reg()), Immediate(value_));
   generator()->frame()->Push(value_);
   generator()->frame()->Push(&right);
   GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
-  exit()->Jump(&answer);
+  exit_.Jump(&answer);
 }
 
 
 class DeferredInlineSmiSub: public DeferredCode {
  public:
   DeferredInlineSmiSub(CodeGenerator* generator,
                        Smi* value,
                        OverwriteMode overwrite_mode)
       : DeferredCode(generator),
         value_(value),
@@ skipping 13 matching lines @@
   // Undo the optimistic sub operation and call the shared stub.
   Result left(generator());  // Initially left - value_.
   enter()->Bind(&left);
   left.ToRegister();
   generator()->frame()->Spill(left.reg());
   __ add(Operand(left.reg()), Immediate(value_));
   generator()->frame()->Push(&left);
   generator()->frame()->Push(value_);
   GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
-  exit()->Jump(&answer);
+  exit_.Jump(&answer);
 }
 
 
 class DeferredInlineSmiSubReversed: public DeferredCode {
  public:
   DeferredInlineSmiSubReversed(CodeGenerator* generator,
                                Smi* value,
                                OverwriteMode overwrite_mode)
       : DeferredCode(generator),
         value_(value),
@@ skipping 10 matching lines @@
 
 
 void DeferredInlineSmiSubReversed::Generate() {
   // Call the shared stub.
   Result right(generator());
   enter()->Bind(&right);
   generator()->frame()->Push(value_);
   generator()->frame()->Push(&right);
   GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
-  exit()->Jump(&answer);
+  exit_.Jump(&answer);
 }
 
 
 void CodeGenerator::SmiOperation(Token::Value op,
                                  StaticType* type,
                                  Handle<Object> value,
                                  bool reversed,
                                  OverwriteMode overwrite_mode) {
   // NOTE: This is an attempt to inline (a bit) more of the code for
   // some possible smi operations (like + and -) when (at least) one
@@ skipping 19 matching lines @@
         deferred = new DeferredInlineSmiAddReversed(this, smi_value,
                                                     overwrite_mode);
       }
       Result operand = frame_->Pop();
       operand.ToRegister();
       frame_->Spill(operand.reg());
       __ add(Operand(operand.reg()), Immediate(value));
       deferred->enter()->Branch(overflow, &operand, not_taken);
       __ test(Operand(operand.reg()), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, &operand, not_taken);
-      deferred->exit()->Bind(&operand);
+      deferred->BindExit(&operand);
       frame_->Push(&operand);
       break;
     }
 
     case Token::SUB: {
       DeferredCode* deferred = NULL;
       Result operand = frame_->Pop();
       Result answer(this);  // Only allocated a new register if reversed.
       if (!reversed) {
         operand.ToRegister();
@@ skipping 14 matching lines @@
           __ sub(answer.reg(), Operand(operand.reg()));
         } else {
           ASSERT(operand.is_constant());
           __ sub(Operand(answer.reg()), Immediate(operand.handle()));
         }
       }
       deferred->enter()->Branch(overflow, &operand, not_taken);
       __ test(answer.reg(), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, &operand, not_taken);
       operand.Unuse();
-      deferred->exit()->Bind(&answer);
+      deferred->BindExit(&answer);
       frame_->Push(&answer);
       break;
     }
 
     case Token::SAR: {
       if (reversed) {
         Result top = frame_->Pop();
         frame_->Push(value);
         frame_->Push(&top);
         GenericBinaryOperation(op, type, overwrite_mode);
       } else {
         // Only the least significant 5 bits of the shift value are used.
         // In the slow case, this masking is done inside the runtime call.
         int shift_value = int_value & 0x1f;
         DeferredCode* deferred =
           new DeferredInlineSmiOperation(this, Token::SAR, smi_value,
                                          overwrite_mode);
         Result result = frame_->Pop();
         result.ToRegister();
         __ test(result.reg(), Immediate(kSmiTagMask));
         deferred->enter()->Branch(not_zero, &result, not_taken);
         frame_->Spill(result.reg());
         __ sar(result.reg(), shift_value);
         __ and_(result.reg(), ~kSmiTagMask);
-        deferred->exit()->Bind(&result);
+        deferred->BindExit(&result);
         frame_->Push(&result);
       }
       break;
     }
 
     case Token::SHR: {
       if (reversed) {
         Result top = frame_->Pop();
         frame_->Push(value);
         frame_->Push(&top);
@@ skipping 16 matching lines @@
         __ shr(answer.reg(), shift_value);
         // A negative Smi shifted right two is in the positive Smi range.
         if (shift_value < 2) {
           __ test(answer.reg(), Immediate(0xc0000000));
           deferred->enter()->Branch(not_zero, &operand, not_taken);
         }
         operand.Unuse();
         ASSERT(kSmiTagSize == times_2);  // Adjust the code if not true.
         __ lea(answer.reg(),
                Operand(answer.reg(), answer.reg(), times_1, kSmiTag));
-        deferred->exit()->Bind(&answer);
+        deferred->BindExit(&answer);
         frame_->Push(&answer);
       }
       break;
     }
 
     case Token::SHL: {
       if (reversed) {
         Result top = frame_->Pop();
         frame_->Push(value);
         frame_->Push(&top);
@@ skipping 17 matching lines @@
         if (shift_value == 0) {
           __ sar(answer.reg(), kSmiTagSize);
         } else if (shift_value > 1) {
           __ shl(answer.reg(), shift_value - 1);
         }
         // Convert int result to Smi, checking that it is in int range.
         ASSERT(kSmiTagSize == times_2);  // adjust code if not the case
         __ add(answer.reg(), Operand(answer.reg()));
         deferred->enter()->Branch(overflow, &operand, not_taken);
         operand.Unuse();
-        deferred->exit()->Bind(&answer);
+        deferred->BindExit(&answer);
         frame_->Push(&answer);
       }
       break;
     }
 
     case Token::BIT_OR:
     case Token::BIT_XOR:
     case Token::BIT_AND: {
       DeferredCode* deferred = NULL;
       if (!reversed) {
         deferred =  new DeferredInlineSmiOperation(this, op, smi_value,
                                                    overwrite_mode);
       } 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));
       } else if (op == Token::BIT_XOR) {
         __ xor_(Operand(operand.reg()), Immediate(value));
       } else {
         ASSERT(op == Token::BIT_OR);
         __ or_(Operand(operand.reg()), Immediate(value));
       }
-      deferred->exit()->Bind(&operand);
+      deferred->BindExit(&operand);
       frame_->Push(&operand);
       break;
     }
 
     default: {
       if (!reversed) {
         frame_->Push(value);
       } else {
         Result top = frame_->Pop();
         frame_->Push(value);
@@ skipping 254 matching lines @@
   }
 
   virtual void Generate();
 };
 
 
 void DeferredStackCheck::Generate() {
   enter()->Bind();
   // The stack check can trigger the debugger.  Before calling it, all
   // values including constants must be spilled to the frame.
-  generator()->frame()->SpillAll();
+  // generator()->frame()->SpillAll();

[Kasper Lund, 2009/02/18 12:11:17]

Remove?

[Kevin Millikin (Chromium), 2009/02/18 12:26:22]

Yes.

   StackCheckStub stub;
   Result ignored = generator()->frame()->CallStub(&stub, 0);
   ignored.Unuse();
-  exit()->Jump();
+  exit_.Jump();
 }
 
 
 void CodeGenerator::CheckStack() {
   if (FLAG_check_stack) {
     DeferredStackCheck* deferred = new DeferredStackCheck(this);
     ExternalReference stack_guard_limit =
         ExternalReference::address_of_stack_guard_limit();
     __ cmp(esp, Operand::StaticVariable(stack_guard_limit));
     deferred->enter()->Branch(below, not_taken);
-    deferred->exit()->Bind();
+    deferred->BindExit();
   }
 }
 
 
 void CodeGenerator::VisitStatements(ZoneList<Statement*>* statements) {
   ASSERT(!in_spilled_code());
   for (int i = 0; has_valid_frame() && i < statements->length(); i++) {
     Visit(statements->at(i));
   }
 }
@@ skipping 1594 matching lines @@
   // Literal array (0).
   frame->Push(&literals);
   // Literal index (1).
   frame->Push(Smi::FromInt(node_->literal_index()));
   // RegExp pattern (2).
   frame->Push(node_->pattern());
   // RegExp flags (3).
   frame->Push(node_->flags());
   Result boilerplate =
       frame->CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
-  exit()->Jump(&boilerplate);
+  exit_.Jump(&boilerplate);
 }
 
 
 void CodeGenerator::VisitRegExpLiteral(RegExpLiteral* node) {
   Comment cmnt(masm_, "[ RegExp Literal");
   DeferredRegExpLiteral* deferred = new DeferredRegExpLiteral(this, node);
 
   // Retrieve the literals array and check the allocated entry.  Begin
   // with a writable copy of the function of this activation in a
   // register.
@@ skipping 13 matching lines @@
   ASSERT(boilerplate.is_valid());
   __ mov(boilerplate.reg(), FieldOperand(literals.reg(), literal_offset));
 
   // Check whether we need to materialize the RegExp object.  If so,
   // jump to the deferred code passing the literals array.
   __ cmp(boilerplate.reg(), Factory::undefined_value());
   deferred->enter()->Branch(equal, &literals, not_taken);
 
   literals.Unuse();
   // The deferred code returns the boilerplate object.
-  deferred->exit()->Bind(&boilerplate);
+  deferred->BindExit(&boilerplate);
 
   // Push the boilerplate object.
   frame_->Push(&boilerplate);
 }
 
 
 // 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 20 matching lines @@
 
   VirtualFrame* frame = generator()->frame();
   // Literal array (0).
   frame->Push(&literals);
   // Literal index (1).
   frame->Push(Smi::FromInt(node_->literal_index()));
   // Constant properties (2).
   frame->Push(node_->constant_properties());
   Result boilerplate =
       frame->CallRuntime(Runtime::kCreateObjectLiteralBoilerplate, 3);
-  exit()->Jump(&boilerplate);
+  exit_.Jump(&boilerplate);
 }
 
 
 void CodeGenerator::VisitObjectLiteral(ObjectLiteral* node) {
   Comment cmnt(masm_, "[ ObjectLiteral");
   DeferredObjectLiteral* deferred = new DeferredObjectLiteral(this, node);
 
   // Retrieve the literals array and check the allocated entry.  Begin
   // with a writable copy of the function of this activation in a
   // register.
@@ skipping 13 matching lines @@
   ASSERT(boilerplate.is_valid());
   __ mov(boilerplate.reg(), FieldOperand(literals.reg(), literal_offset));
 
   // Check whether we need to materialize the object literal boilerplate.
   // If so, jump to the deferred code passing the literals array.
   __ cmp(boilerplate.reg(), Factory::undefined_value());
   deferred->enter()->Branch(equal, &literals, not_taken);
 
   literals.Unuse();
   // The deferred code returns the boilerplate object.
-  deferred->exit()->Bind(&boilerplate);
+  deferred->BindExit(&boilerplate);
 
   // Push the boilerplate object.
   frame_->Push(&boilerplate);
   // Clone the boilerplate object.
   Result clone =
       frame_->CallRuntime(Runtime::kCloneObjectLiteralBoilerplate, 1);
   // Push the newly cloned literal object as the result.
   frame_->Push(&clone);
 
   for (int i = 0; i < node->properties()->length(); i++) {
@@ skipping 1053 matching lines @@
   enter()->Bind(&value);
   value.ToRegister(eax);  // The stubs below expect their argument in eax.
 
   if (is_postfix_) {
     RevertToNumberStub to_number_stub(is_increment_);
     value = generator()->frame()->CallStub(&to_number_stub, &value, 0);
   }
 
   CounterOpStub stub(result_offset_, is_postfix_, is_increment_);
   value = generator()->frame()->CallStub(&stub, &value, 0);
-  exit()->Jump(&value);
+  exit_.Jump(&value);
 }
 
 
 void CodeGenerator::VisitCountOperation(CountOperation* node) {
   Comment cmnt(masm_, "[ CountOperation");
 
   bool is_postfix = node->is_postfix();
   bool is_increment = node->op() == Token::INC;
 
   Variable* var = node->expression()->AsVariableProxy()->AsVariable();
@@ skipping 65 matching lines @@
       tmp.Unuse();
       __ test(value.reg(), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, &value, not_taken);
     } else {
       deferred->enter()->Branch(overflow, &value, not_taken);
       __ test(value.reg(), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, &value, not_taken);
     }
 
     // Store the new value in the target if not const.
-    deferred->exit()->Bind(&value);
+    deferred->BindExit(&value);
     frame_->Push(&value);
     if (!is_const) {
       target.SetValue(NOT_CONST_INIT);
     }
   }
 
   // Postfix: Discard the new value and use the old.
   if (is_postfix) {
     frame_->Drop();
   }
@@ skipping 430 matching lines @@
   }
   // The result needs to be specifically the eax register because the
   // offset to the patch site will be expected in a test eax
   // instruction.
   ASSERT(value.is_register() && value.reg().is(eax));
   // The delta from the start of the map-compare instruction to the
   // test eax instruction.
   int delta_to_patch_site = __ SizeOfCodeGeneratedSince(patch_site());
   __ test(value.reg(), Immediate(-delta_to_patch_site));
   __ IncrementCounter(&Counters::keyed_load_inline_miss, 1);
-  exit()->Jump(&value);
+
+  // The receiver and key were spilled by the call, so their state as
+  // constants or copies has been changed.  Thus, they need to be
+  // "mergable" in the block at the exit label and are therefore
+  // passed as return results here.
+  key = cgen->frame()->Pop();
+  receiver = cgen->frame()->Pop();
+  exit_.Jump(&receiver, &key, &value);
 }
 
 
 #undef __
 #define __ masm->
 
 Handle<String> Reference::GetName() {
   ASSERT(type_ == NAMED);
   Property* property = expression_->AsProperty();
   if (property == NULL) {
@@ skipping 122 matching lines @@
                                     times_4,
                                     Array::kHeaderSize - kHeapObjectTag));
         elements.Unuse();
         index.Unuse();
         __ cmp(Operand(value.reg()), Immediate(Factory::the_hole_value()));
         deferred->enter()->Branch(equal, &receiver, &key, not_taken);
         __ IncrementCounter(&Counters::keyed_load_inline, 1);
 
         // Restore the receiver and key to the frame and push the
         // result on top of it.
+        deferred->BindExit(&receiver, &key, &value);
         cgen_->frame()->Push(&receiver);
         cgen_->frame()->Push(&key);
-        deferred->exit()->Bind(&value);
         cgen_->frame()->Push(&value);
 
       } else {
         VirtualFrame* frame = cgen_->frame();
         Comment cmnt(masm, "[ Load from keyed Property");
         Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
         RelocInfo::Mode rmode = is_global
                               ? RelocInfo::CODE_TARGET_CONTEXT
                               : RelocInfo::CODE_TARGET;
         Result answer = frame->CallCodeObject(ic, rmode, 0);
@@ skipping 1582 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal