Experimental: this is a substantial change to allow the virtual frame...

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 695 matching lines @@
                                 OverwriteMode mode,
                                 GenericBinaryFlags flags)
       : DeferredCode(generator),
         stub_(op, mode, flags),
         op_(op) {
   }
 
   void GenerateInlineCode();
 
   virtual void Generate() {
-    __ push(ebx);
-    __ CallStub(&stub_);
+    // The arguments are is actually passed in ebx and the top of the stack.
+    enter()->Bind();
+    VirtualFrame::SpilledScope spilled_scope(generator());
+    generator()->frame()->EmitPush(ebx);
+    generator()->frame()->CallStub(&stub_, 2);
     // 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);
+    generator()->frame()->EmitPush(eax);
+    // The result is actually returned on the top of the stack.
+    exit()->Jump();
   }
 
  private:
   GenericBinaryOpStub stub_;
   Token::Value op_;
 };
 
 
 void CodeGenerator::GenericBinaryOperation(Token::Value op,
                                            StaticType* type,
@@ skipping 29 matching lines @@
       // By default only inline the Smi check code for likely smis if this
       // operation is part of a loop.
       flags = ((loop_nesting() > 0) && type->IsLikelySmi())
               ? SMI_CODE_INLINED
               : SMI_CODE_IN_STUB;
       break;
   }
 
   if (flags == SMI_CODE_INLINED) {
     // Create a new deferred code for the slow-case part.
+    //
+    // TODO(): When this code is updated to use the virtual frame, it
+    // has to properly flow to the inline code from this deferred code
+    // stub.
     DeferredInlineBinaryOperation* deferred =
         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
@@ skipping 12 matching lines @@
 class DeferredInlinedSmiOperation: public DeferredCode {
  public:
   DeferredInlinedSmiOperation(CodeGenerator* generator,
                               Token::Value op, int value,
                               OverwriteMode overwrite_mode) :
       DeferredCode(generator), op_(op), value_(value),
       overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiOperation");
   }
   virtual void Generate() {
-    __ push(eax);
-    __ push(Immediate(Smi::FromInt(value_)));
+    // The argument is actually passed in eax.
+    enter()->Bind();
+    VirtualFrame::SpilledScope spilled_scope(generator());
+    generator()->frame()->EmitPush(eax);
+    generator()->frame()->EmitPush(Immediate(Smi::FromInt(value_)));
     GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
-    __ CallStub(&igostub);
+    generator()->frame()->CallStub(&igostub, 2);
+    // The result is actually returned in eax.
+    exit()->Jump();
   }
 
  private:
   Token::Value op_;
   int value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 class DeferredInlinedSmiOperationReversed: public DeferredCode {
  public:
   DeferredInlinedSmiOperationReversed(CodeGenerator* generator,
                                       Token::Value op, int value,
                                       OverwriteMode overwrite_mode) :
       DeferredCode(generator), op_(op), value_(value),
       overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiOperationReversed");
   }
   virtual void Generate() {
-    __ push(Immediate(Smi::FromInt(value_)));
-    __ push(eax);
+    // The argument is actually passed in eax.
+    enter()->Bind();
+    VirtualFrame::SpilledScope spilled_scope(generator());
+    generator()->frame()->EmitPush(Immediate(Smi::FromInt(value_)));
+    generator()->frame()->EmitPush(eax);
     GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
-    __ CallStub(&igostub);
+    generator()->frame()->CallStub(&igostub, 2);
+    // The result is actually returned in eax.
+    exit()->Jump();
   }
 
  private:
   Token::Value op_;
   int value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 class DeferredInlinedSmiAdd: public DeferredCode {
  public:
   DeferredInlinedSmiAdd(CodeGenerator* generator, int value,
                         OverwriteMode overwrite_mode) :
       DeferredCode(generator), value_(value), overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiAdd");
   }
 
   virtual void Generate() {
+    // The argument is actually passed in eax.
+    enter()->Bind();
+    VirtualFrame::SpilledScope spilled_scope(generator());
     // Undo the optimistic add operation and call the shared stub.
     Immediate immediate(Smi::FromInt(value_));
     __ sub(Operand(eax), immediate);
-    __ push(eax);
-    __ push(immediate);
+    generator()->frame()->EmitPush(eax);
+    generator()->frame()->EmitPush(immediate);
     GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
-    __ CallStub(&igostub);
+    generator()->frame()->CallStub(&igostub, 2);
+    // The result is actually returned in eax.
+    exit()->Jump();
   }
 
  private:
   int value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 class DeferredInlinedSmiAddReversed: public DeferredCode {
  public:
   DeferredInlinedSmiAddReversed(CodeGenerator* generator, int value,
                         OverwriteMode overwrite_mode) :
       DeferredCode(generator), value_(value), overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiAddReversed");
   }
 
   virtual void Generate() {
+    // The argument is actually passed in eax.
+    enter()->Bind();
+    VirtualFrame::SpilledScope spilled_scope(generator());
     // Undo the optimistic add operation and call the shared stub.
     Immediate immediate(Smi::FromInt(value_));
     __ sub(Operand(eax), immediate);
-    __ push(immediate);
-    __ push(eax);
+    generator()->frame()->EmitPush(immediate);
+    generator()->frame()->EmitPush(eax);
     GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
-    __ CallStub(&igostub);
+    generator()->frame()->CallStub(&igostub, 2);
+    // The result is actually returned in eax.
+    exit()->Jump();
   }
 
  private:
   int value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 class DeferredInlinedSmiSub: public DeferredCode {
  public:
   DeferredInlinedSmiSub(CodeGenerator* generator, int value,
                         OverwriteMode overwrite_mode) :
       DeferredCode(generator), value_(value), overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiSub");
   }
 
   virtual void Generate() {
+    // The argument is actually passed in eax.
+    enter()->Bind();
+    VirtualFrame::SpilledScope spilled_scope(generator());
     // Undo the optimistic sub operation and call the shared stub.
     Immediate immediate(Smi::FromInt(value_));
     __ add(Operand(eax), immediate);
-    __ push(eax);
-    __ push(immediate);
+    generator()->frame()->EmitPush(eax);
+    generator()->frame()->EmitPush(immediate);
     GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
-    __ CallStub(&igostub);
+    generator()->frame()->CallStub(&igostub, 2);
+    // The result is actually returned in eax.
+    exit()->Jump();
   }
 
  private:
   int value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 class DeferredInlinedSmiSubReversed: public DeferredCode {
  public:
   // tos_reg is used to save the TOS value before reversing the operands
   // eax will contain the immediate value after undoing the optimistic sub.
   DeferredInlinedSmiSubReversed(CodeGenerator* generator, Register tos_reg,
                                 OverwriteMode overwrite_mode) :
       DeferredCode(generator), tos_reg_(tos_reg),
       overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiSubReversed");
   }
 
   virtual void Generate() {
+    // The arguments are actually passed in eax and tos_reg.
+    enter()->Bind();
+    VirtualFrame::SpilledScope spilled_scope(generator());
     // Undo the optimistic sub operation and call the shared stub.
     __ add(eax, Operand(tos_reg_));
-    __ push(eax);
-    __ push(tos_reg_);
+    generator()->frame()->EmitPush(eax);
+    generator()->frame()->EmitPush(tos_reg_);
     GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
-    __ CallStub(&igostub);
+    generator()->frame()->CallStub(&igostub, 2);
+    // The result is actually returned in eax.
+    exit()->Jump();
   }
 
  private:
   Register tos_reg_;
   OverwriteMode overwrite_mode_;
 };
 
 
 void CodeGenerator::SmiOperation(Token::Value op,
                                  StaticType* type,
@@ skipping 238 matching lines @@
   // Test smi equality by pointer comparison.
   is_smi.Bind();
   __ cmp(edx, Operand(eax));
   // Fall through to |done|.
 
   done.Bind();
   cc_reg_ = cc;
 }
 
 
-class SmiComparisonDeferred: public DeferredCode {
+class DeferredSmiComparison: public DeferredCode {
  public:
-  SmiComparisonDeferred(CodeGenerator* generator,
+  DeferredSmiComparison(CodeGenerator* generator,
                         Condition cc,
                         bool strict,
-                        Register left_side,
-                        int right_side) :
+                        int int_value) :
       DeferredCode(generator),
       cc_(cc),
       strict_(strict),
-      left_side_(left_side),
-      right_side_(right_side) {
+      int_value_(int_value) {
     set_comment("[ ComparisonDeferred");
   }
   virtual void Generate();
 
  private:
   Condition cc_;
   bool strict_;
-  Register left_side_;
-  int right_side_;
+  int int_value_;
 };
 
 
-void SmiComparisonDeferred::Generate() {
+void DeferredSmiComparison::Generate() {
+  CodeGenerator* cgen = generator();
   CompareStub stub(cc_, strict_);
+  Result argument(cgen);
+  enter()->Bind(&argument);
+
   // Setup parameters and call stub.
-  if (!left_side_.is(edx)) {
-    __ mov(edx, Operand(left_side_));
-  }
-  __ Set(eax, Immediate(Smi::FromInt(right_side_)));
-  __ CallStub(&stub);
-  __ cmp(eax, 0);
-  // "result" is returned in the flags.
+  argument.ToRegister(edx);
+  Result value = cgen->allocator()->Allocate(eax);
+  ASSERT(value.is_valid());
+  __ Set(value.reg(), Immediate(Smi::FromInt(int_value_)));
+  Result result = cgen->frame()->CallStub(&stub, &argument, &value, 0);
+  ASSERT(result.is_register());
+  __ cmp(result.reg(), 0);
+  result.Unuse();
+  // The actual result is returned in the flags.
+  exit()->Jump();
 }
 
 
 void CodeGenerator::SmiComparison(Condition cc,
                                   Handle<Object> value,
                                   bool strict) {
   // Strict only makes sense for equality comparisons.
   ASSERT(!strict || cc == equal);
 
   int int_value = Smi::cast(*value)->value();
   ASSERT(is_intn(int_value, kMaxSmiInlinedBits));
 
+  DeferredSmiComparison* deferred =
+      new DeferredSmiComparison(this, cc, strict, int_value);
+
   Result comparee = frame_->Pop();
   comparee.ToRegister();
-  Register reg = comparee.reg();
-  __ test(reg, Immediate(kSmiTagMask));
-  SmiComparisonDeferred* deferred =
-      new SmiComparisonDeferred(this, cc, strict, reg, int_value);
-  deferred->enter()->Branch(not_zero, not_taken);
+  __ test(comparee.reg(), Immediate(kSmiTagMask));
+  deferred->enter()->Branch(not_zero, &comparee, not_taken);
   // Test smi equality and comparison by signed int comparison.
-  __ cmp(Operand(reg), Immediate(value));
+  __ cmp(Operand(comparee.reg()), Immediate(value));
   comparee.Unuse();
   deferred->exit()->Bind();
   cc_reg_ = cc;
 }
 
 
 class CallFunctionStub: public CodeStub {
  public:
   explicit CallFunctionStub(int argc) : argc_(argc) { }
 
@@ skipping 1418 matching lines @@
     int bits = reinterpret_cast<int>(*node->handle());
     __ mov(temp.reg(), bits & 0x0000FFFF);
     __ xor_(temp.reg(), bits & 0xFFFF0000);
     frame_->Push(&temp);
   } else {
     frame_->Push(node->handle());
   }
 }
 
 
-class RegExpDeferred: public DeferredCode {
+class DeferredRegExpLiteral: public DeferredCode {
  public:
-  RegExpDeferred(CodeGenerator* generator, RegExpLiteral* node)
+  DeferredRegExpLiteral(CodeGenerator* generator, RegExpLiteral* node)
       : DeferredCode(generator), node_(node) {
     set_comment("[ RegExpDeferred");
   }
   virtual void Generate();
  private:
   RegExpLiteral* node_;
 };
 
 
-void RegExpDeferred::Generate() {
+void DeferredRegExpLiteral::Generate() {
+  // The argument is actually passed in ecx.
+  enter()->Bind();
+  VirtualFrame::SpilledScope spilled_scope(generator());
   // If the entry is undefined we call the runtime system to compute the
   // literal.
 
   // Literal array (0).
-  __ push(ecx);
+  generator()->frame()->EmitPush(ecx);
   // Literal index (1).
-  __ push(Immediate(Smi::FromInt(node_->literal_index())));
+  generator()->frame()->EmitPush(
+      Immediate(Smi::FromInt(node_->literal_index())));
   // RegExp pattern (2).
-  __ push(Immediate(node_->pattern()));
+  generator()->frame()->EmitPush(Immediate(node_->pattern()));
   // RegExp flags (3).
-  __ push(Immediate(node_->flags()));
-  __ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
+  generator()->frame()->EmitPush(Immediate(node_->flags()));
+  generator()->frame()->CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
   __ mov(ebx, Operand(eax));  // "caller" expects result in ebx
+  // The result is actually returned in ebx.
+  exit()->Jump();
 }
 
 
 void CodeGenerator::VisitRegExpLiteral(RegExpLiteral* node) {
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ RegExp Literal");
-  RegExpDeferred* deferred = new RegExpDeferred(this, node);
+  DeferredRegExpLiteral* deferred = new DeferredRegExpLiteral(this, node);
 
   // Retrieve the literal array and check the allocated entry.
 
   // Load the function of this activation.
   __ mov(ecx, frame_->Function());
 
   // Load the literals array of the function.
   __ 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();
 
   // 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.
-class ObjectLiteralDeferred: public DeferredCode {
+class DeferredObjectLiteral: public DeferredCode {
  public:
-  ObjectLiteralDeferred(CodeGenerator* generator,
+  DeferredObjectLiteral(CodeGenerator* generator,
                         ObjectLiteral* node)
       : DeferredCode(generator), node_(node) {
     set_comment("[ ObjectLiteralDeferred");
   }
   virtual void Generate();
  private:
   ObjectLiteral* node_;
 };
 
 
-void ObjectLiteralDeferred::Generate() {
+void DeferredObjectLiteral::Generate() {
+  // The argument is actually passed in ecx.
+  enter()->Bind();
+  VirtualFrame::SpilledScope spilled_scope(generator());
   // If the entry is undefined we call the runtime system to compute
   // the literal.
 
   // Literal array (0).
-  __ push(ecx);
+  generator()->frame()->EmitPush(ecx);
   // Literal index (1).
-  __ push(Immediate(Smi::FromInt(node_->literal_index())));
+  generator()->frame()->EmitPush(
+      Immediate(Smi::FromInt(node_->literal_index())));
   // Constant properties (2).
-  __ push(Immediate(node_->constant_properties()));
-  __ CallRuntime(Runtime::kCreateObjectLiteralBoilerplate, 3);
+  generator()->frame()->EmitPush(Immediate(node_->constant_properties()));
+  generator()->frame()->CallRuntime(Runtime::kCreateObjectLiteralBoilerplate,
+                                    3);
   __ mov(ebx, Operand(eax));
+  // The result is actually returned in ebx.
+  exit()->Jump();
 }
 
 
 void CodeGenerator::VisitObjectLiteral(ObjectLiteral* node) {
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ ObjectLiteral");
-  ObjectLiteralDeferred* deferred = new ObjectLiteralDeferred(this, node);
+  DeferredObjectLiteral* deferred = new DeferredObjectLiteral(this, node);
 
   // Retrieve the literal array and check the allocated entry.
 
   // Load the function of this activation.
   __ mov(ecx, frame_->Function());
 
   // Load the literals array of the function.
   __ mov(ecx, FieldOperand(ecx, JSFunction::kLiteralsOffset));
 
   // Load the literal at the ast saved index.
@@ skipping 833 matching lines @@
         break;
       }
 
       default:
         UNREACHABLE();
     }
   }
 }
 
 
-class CountOperationDeferred: public DeferredCode {
+class DeferredCountOperation: public DeferredCode {
  public:
-  CountOperationDeferred(CodeGenerator* generator,
+  DeferredCountOperation(CodeGenerator* generator,
                          bool is_postfix,
                          bool is_increment,
                          int result_offset)
       : DeferredCode(generator),
         is_postfix_(is_postfix),
         is_increment_(is_increment),
         result_offset_(result_offset) {
     set_comment("[ CountOperationDeferred");
   }
 
@@ skipping 52 matching lines @@
     PrintF("CounterOpStub (result_offset %d), (is_postfix %s),"
            " (is_increment %s)\n",
            result_offset_,
            is_postfix_ ? "true" : "false",
            is_increment_ ? "true" : "false");
   }
 #endif
 };
 
 
-void CountOperationDeferred::Generate() {
+void DeferredCountOperation::Generate() {
+  // The argument is actually passed in eax.
+  enter()->Bind();
+  VirtualFrame::SpilledScope spilled_scope(generator());
   if (is_postfix_) {
     RevertToNumberStub to_number_stub(is_increment_);
-    __ CallStub(&to_number_stub);
+    generator()->frame()->CallStub(&to_number_stub, 0);
   }
   CounterOpStub stub(result_offset_, is_postfix_, is_increment_);
-  __ CallStub(&stub);
+  generator()->frame()->CallStub(&stub, 0);
+  // The result is actually returned in eax.
+  exit()->Jump();
 }
 
 
 void CodeGenerator::VisitCountOperation(CountOperation* node) {
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ CountOperation");
 
   bool is_postfix = node->is_postfix();
   bool is_increment = node->op() == Token::INC;
 
   Variable* var = node->expression()->AsVariableProxy()->AsVariable();
   bool is_const = (var != NULL && var->mode() == Variable::CONST);
 
   // Postfix: Make room for the result.
   if (is_postfix) {
     frame_->EmitPush(Immediate(0));
   }
 
   { Reference target(this, node->expression());
     if (target.is_illegal()) {
       // Spoof the virtual frame to have the expected height (one higher
       // than on entry).
       if (!is_postfix) {
         frame_->EmitPush(Immediate(Smi::FromInt(0)));
       }
       return;
     }
     target.GetValueAndSpill(NOT_INSIDE_TYPEOF);
 
-    CountOperationDeferred* deferred =
-        new CountOperationDeferred(this, is_postfix, is_increment,
+    DeferredCountOperation* deferred =
+        new DeferredCountOperation(this, is_postfix, is_increment,
                                    target.size() * kPointerSize);
 
     frame_->EmitPop(eax);  // Load TOS into eax for calculations below
 
     // Postfix: Store the old value as the result.
     if (is_postfix) {
       __ mov(frame_->ElementAt(target.size()), eax);
     }
 
     // Perform optimistic increment/decrement.
@@ skipping 386 matching lines @@
   LoadAndSpill(right);
   Comparison(cc, strict);
 }
 
 
 bool CodeGenerator::IsActualFunctionReturn(JumpTarget* target) {
   return (target == &function_return_ && !function_return_is_shadowed_);
 }
 
 
+#ifdef DEBUG
+bool CodeGenerator::HasValidEntryRegisters() {
+  return (allocator()->count(eax) - frame()->register_count(eax) == 0)
+      && (allocator()->count(ebx) - frame()->register_count(ebx) == 0)
+      && (allocator()->count(ecx) - frame()->register_count(ecx) == 0)
+      && (allocator()->count(edx) - frame()->register_count(edx) == 0)
+      && (allocator()->count(edi) - frame()->register_count(edi) == 0);
+}
+#endif
+
+
 #undef __
 #define __ masm->
 
 Handle<String> Reference::GetName() {
   ASSERT(type_ == NAMED);
   Property* property = expression_->AsProperty();
   if (property == NULL) {
     // Global variable reference treated as a named property reference.
     VariableProxy* proxy = expression_->AsVariableProxy();
     ASSERT(proxy->AsVariable() != NULL);
@@ skipping 44 matching lines @@
       }
       frame->EmitPush(eax);  // IC call leaves result in eax, push it out
       break;
     }
 
     case KEYED: {
       // TODO(1241834): Make sure that this it is safe to ignore the
       // distinction between expressions in a typeof and not in a typeof.
       VirtualFrame::SpilledScope spilled_scope(cgen_);
       Comment cmnt(masm, "[ Load from keyed Property");
-      Property* property = expression_->AsProperty();
-      ASSERT(property != NULL);
       Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
 
       Variable* var = expression_->AsVariableProxy()->AsVariable();
       if (var != NULL) {
         ASSERT(var->is_global());
         frame->CallCodeObject(ic, RelocInfo::CODE_TARGET_CONTEXT, 0);
       } else {
         frame->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
       }
       frame->EmitPush(eax);  // IC call leaves result in eax, push it out
@@ skipping 31 matching lines @@
       // Setup the name register.
       __ mov(ecx, name);
       frame->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
       frame->EmitPush(eax);  // IC call leaves result in eax, push it out
       break;
     }
 
     case KEYED: {
       VirtualFrame::SpilledScope spilled_scope(cgen_);
       Comment cmnt(masm, "[ Store to keyed Property");
-      Property* property = expression_->AsProperty();
-      ASSERT(property != NULL);
       // Call IC code.
       Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
       // TODO(1222589): Make the IC grab the values from the stack.
       frame->EmitPop(eax);
       frame->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
       frame->EmitPush(eax);  // IC call leaves result in eax, push it out
       break;
     }
 
     default:
@@ skipping 1376 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal