Revert r5970 and r5975.

src/ia32/full-codegen-ia32.cc

 // Copyright 2010 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 23 matching lines @@
 #include "compiler.h"
 #include "debug.h"
 #include "full-codegen.h"
 #include "parser.h"
 #include "scopes.h"
 #include "stub-cache.h"
 
 namespace v8 {
 namespace internal {
 
-
-class JumpPatchSite BASE_EMBEDDED {
- public:
-  explicit JumpPatchSite(MacroAssembler* masm)
-      : masm_(masm) {
-#ifdef DEBUG
-    info_emitted_ = false;
-#endif
-  }
-
-  ~JumpPatchSite() {
-    ASSERT(patch_site_.is_bound() == info_emitted_);
-  }
-
-  void EmitJump(NearLabel* target) {
-    ASSERT(!patch_site_.is_bound() && !info_emitted_);
-    masm_->bind(&patch_site_);
-    masm_->jmp(target);
-  }
-
-  void EmitPatchInfo() {
-    int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(&patch_site_);
-    ASSERT(is_int8(delta_to_patch_site));
-    masm_->test(eax, Immediate(delta_to_patch_site));
-#ifdef DEBUG
-    info_emitted_ = true;
-#endif
-  }
-
-  bool is_bound() const { return patch_site_.is_bound(); }
-
- private:
-  MacroAssembler* masm_;
-  Label patch_site_;
-#ifdef DEBUG
-  bool info_emitted_;
-#endif
-};
-
-
 #define __ ACCESS_MASM(masm_)
 
 // Generate code for a JS function.  On entry to the function the receiver
 // and arguments have been pushed on the stack left to right, with the
 // return address on top of them.  The actual argument count matches the
 // formal parameter count expected by the function.
 //
 // The live registers are:
 //   o edi: the JS function object being called (ie, ourselves)
 //   o esi: our context
@@ skipping 654 matching lines @@
     Comment cmnt(masm_, "[ Case comparison");
     __ bind(&next_test);
     next_test.Unuse();
 
     // Compile the label expression.
     VisitForAccumulatorValue(clause->label());
 
     // Perform the comparison as if via '==='.
     __ mov(edx, Operand(esp, 0));  // Switch value.
     bool inline_smi_code = ShouldInlineSmiCase(Token::EQ_STRICT);
-    JumpPatchSite patch_site(masm_);
     if (inline_smi_code) {
       NearLabel slow_case;
       __ mov(ecx, edx);
       __ or_(ecx, Operand(eax));
       __ test(ecx, Immediate(kSmiTagMask));
-      patch_site.EmitJump(&slow_case);
+      __ j(not_zero, &slow_case, not_taken);
       __ cmp(edx, Operand(eax));
       __ j(not_equal, &next_test);
       __ Drop(1);  // Switch value is no longer needed.
       __ jmp(clause->body_target()->entry_label());
       __ bind(&slow_case);
     }
 
     // Record position before stub call for type feedback.
     SetSourcePosition(clause->position());
+
     Handle<Code> ic = CompareIC::GetUninitialized(Token::EQ_STRICT);
-    EmitCallIC(ic, &patch_site);
+    __ call(ic, RelocInfo::CODE_TARGET);
 
     __ test(eax, Operand(eax));
     __ j(not_equal, &next_test);
     __ Drop(1);  // Switch value is no longer needed.
     __ jmp(clause->body_target()->entry_label());
   }
 
   // Discard the test value and jump to the default if present, otherwise to
   // the end of the statement.
   __ bind(&next_test);
@@ skipping 799 matching lines @@
   SetSourcePosition(prop->position());
   Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
   EmitCallIC(ic, RelocInfo::CODE_TARGET);
 }
 
 
 void FullCodeGenerator::EmitConstantSmiAdd(Expression* expr,
                                            OverwriteMode mode,
                                            bool left_is_constant_smi,
                                            Smi* value) {
-  NearLabel call_stub, done;
+  NearLabel call_stub;
+  Label done;
   __ add(Operand(eax), Immediate(value));
   __ j(overflow, &call_stub);
   __ test(eax, Immediate(kSmiTagMask));
-  JumpPatchSite patch_site(masm_);
-  patch_site.EmitJump(&call_stub);
-  __ jmp(&done);
+  __ j(zero, &done);
 
   // Undo the optimistic add operation and call the shared stub.
   __ bind(&call_stub);
   __ sub(Operand(eax), Immediate(value));
   Token::Value op = Token::ADD;
   TypeRecordingBinaryOpStub stub(op, mode);
   if (left_is_constant_smi) {
     __ mov(edx, Immediate(value));
   } else {
     __ mov(edx, eax);
     __ mov(eax, Immediate(value));
   }
-  EmitCallIC(stub.GetCode(), &patch_site);
-
+  __ CallStub(&stub);
   __ bind(&done);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitConstantSmiSub(Expression* expr,
                                            OverwriteMode mode,
                                            bool left_is_constant_smi,
                                            Smi* value) {
-  NearLabel call_stub, done;
+  Label call_stub, done;
   if (left_is_constant_smi) {
     __ mov(ecx, eax);
     __ mov(eax, Immediate(value));
     __ sub(Operand(eax), ecx);
   } else {
     __ sub(Operand(eax), Immediate(value));
   }
   __ j(overflow, &call_stub);
   __ test(eax, Immediate(kSmiTagMask));
-  JumpPatchSite patch_site(masm_);
-  patch_site.EmitJump(&call_stub);
-  __ jmp(&done);
+  __ j(zero, &done);
 
   __ bind(&call_stub);
   if (left_is_constant_smi) {
     __ mov(edx, Immediate(value));
     __ mov(eax, ecx);
   } else {
     __ add(Operand(eax), Immediate(value));  // Undo the subtraction.
     __ mov(edx, eax);
     __ mov(eax, Immediate(value));
   }
   Token::Value op = Token::SUB;
   TypeRecordingBinaryOpStub stub(op, mode);
-  EmitCallIC(stub.GetCode(), &patch_site);
-
+  __ CallStub(&stub);
   __ bind(&done);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitConstantSmiShiftOp(Expression* expr,
                                                Token::Value op,
                                                OverwriteMode mode,
                                                Smi* value) {
-  NearLabel call_stub, done;
+  Label call_stub, smi_case, done;
   int shift_value = value->value() & 0x1f;
 
   __ test(eax, Immediate(kSmiTagMask));
-  // Patch site.
-  JumpPatchSite patch_site(masm_);
-  patch_site.EmitJump(&call_stub);
+  __ j(zero, &smi_case);
 
-  // Smi case.
+  __ bind(&call_stub);
+  __ mov(edx, eax);
+  __ mov(eax, Immediate(value));
+  TypeRecordingBinaryOpStub stub(op, mode);
+  __ CallStub(&stub);
+  __ jmp(&done);
+
+  __ bind(&smi_case);
   switch (op) {
     case Token::SHL:
       if (shift_value != 0) {
         __ mov(edx, eax);
         if (shift_value > 1) {
           __ shl(edx, shift_value - 1);
         }
         // Convert int result to smi, checking that it is in int range.
         ASSERT(kSmiTagSize == 1);  // Adjust code if not the case.
         __ add(edx, Operand(edx));
@@ skipping 18 matching lines @@
         __ mov(eax, edx);  // Put result back into eax.
       } else {
         __ SmiUntag(eax);
         __ shr(eax, shift_value);
         __ SmiTag(eax);
       }
       break;
     default:
       UNREACHABLE();
   }
-  __ jmp(&done);
-
-  // Call stub.
-  __ bind(&call_stub);
-  __ mov(edx, eax);
-  __ mov(eax, Immediate(value));
-  TypeRecordingBinaryOpStub stub(op, mode);
-  EmitCallIC(stub.GetCode(), &patch_site);
 
   __ bind(&done);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitConstantSmiBitOp(Expression* expr,
                                              Token::Value op,
                                              OverwriteMode mode,
                                              Smi* value) {
-  NearLabel call_stub, done;
+  Label smi_case, done;
   __ test(eax, Immediate(kSmiTagMask));
-  // Patch site. The first invocation of the stub will be patch the jmp with
-  // the required conditional jump.
-  JumpPatchSite patch_site(masm_);
-  patch_site.EmitJump(&call_stub);
+  __ j(zero, &smi_case);
 
-  // Smi case.
+  // The order of the arguments does not matter for bit-ops with a
+  // constant operand.
+  __ mov(edx, Immediate(value));
+  TypeRecordingBinaryOpStub stub(op, mode);
+  __ CallStub(&stub);
+  __ jmp(&done);
+
+  __ bind(&smi_case);
   switch (op) {
     case Token::BIT_OR:
       __ or_(Operand(eax), Immediate(value));
       break;
     case Token::BIT_XOR:
       __ xor_(Operand(eax), Immediate(value));
       break;
     case Token::BIT_AND:
       __ and_(Operand(eax), Immediate(value));
       break;
     default:
       UNREACHABLE();
   }
-  __ jmp(&done);
-
-  // The order of the arguments does not matter for bit-ops with a
-  // constant operand.
-  __ bind(&call_stub);
-  __ mov(edx, Immediate(value));
-  TypeRecordingBinaryOpStub stub(op, mode);
-  EmitCallIC(stub.GetCode(), &patch_site);
 
   __ bind(&done);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitConstantSmiBinaryOp(Expression* expr,
                                                 Token::Value op,
                                                 OverwriteMode mode,
                                                 bool left_is_constant_smi,
@@ skipping 33 matching lines @@
     EmitConstantSmiBinaryOp(expr, op, mode, false, value);
     return;
   } else if (constant == kLeftConstant) {
     Smi* value =  Smi::cast(*left->AsLiteral()->handle());
     EmitConstantSmiBinaryOp(expr, op, mode, true, value);
     return;
   }
 
   // Do combined smi check of the operands. Left operand is on the
   // stack. Right operand is in eax.
-  NearLabel done, stub_call;
+  Label done, stub_call, smi_case;
   __ pop(edx);
   __ mov(ecx, eax);
   __ or_(eax, Operand(edx));
   __ test(eax, Immediate(kSmiTagMask));
-  JumpPatchSite patch_site(masm_);
-  patch_site.EmitJump(&stub_call);
+  __ j(zero, &smi_case);
 
-  // Smi case.
+  __ bind(&stub_call);
+  __ mov(eax, ecx);
+  TypeRecordingBinaryOpStub stub(op, mode);
+  __ CallStub(&stub);
+  __ jmp(&done);
+
+  __ bind(&smi_case);
   __ mov(eax, edx);  // Copy left operand in case of a stub call.
 
   switch (op) {
     case Token::SAR:
       __ SmiUntag(eax);
       __ SmiUntag(ecx);
       __ sar_cl(eax);  // No checks of result necessary
       __ SmiTag(eax);
       break;
     case Token::SHL: {
@@ skipping 47 matching lines @@
       break;
     case Token::BIT_AND:
       __ and_(eax, Operand(ecx));
       break;
     case Token::BIT_XOR:
       __ xor_(eax, Operand(ecx));
       break;
     default:
       UNREACHABLE();
   }
-  __ jmp(&done);
-
-  __ bind(&stub_call);
-  __ mov(eax, ecx);
-  TypeRecordingBinaryOpStub stub(op, mode);
-  EmitCallIC(stub.GetCode(), &patch_site);
 
   __ bind(&done);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitBinaryOp(Token::Value op,
                                      OverwriteMode mode) {
   __ pop(edx);
   TypeRecordingBinaryOpStub stub(op, mode);
-  EmitCallIC(stub.GetCode(), NULL);  // NULL signals no inlined smi code.
+  __ CallStub(&stub);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitAssignment(Expression* expr) {
   // Invalid left-hand sides are rewritten to have a 'throw
   // ReferenceError' on the left-hand side.
   if (!expr->IsValidLeftHandSide()) {
     VisitForEffect(expr);
     return;
@@ skipping 1844 matching lines @@
           break;
         case KEYED_PROPERTY:
           __ mov(Operand(esp, 2 * kPointerSize), eax);
           break;
       }
     }
   }
 
   // Inline smi case if we are in a loop.
   NearLabel stub_call;
-  JumpPatchSite patch_site(masm_);
   Label done;
   if (ShouldInlineSmiCase(expr->op())) {
     if (expr->op() == Token::INC) {
       __ add(Operand(eax), Immediate(Smi::FromInt(1)));
     } else {
       __ sub(Operand(eax), Immediate(Smi::FromInt(1)));
     }
     __ j(overflow, &stub_call);
     // We could eliminate this smi check if we split the code at
     // the first smi check before calling ToNumber.
     __ test(eax, Immediate(kSmiTagMask));
-    patch_site.EmitJump(&stub_call);
-    __ jmp(&done);
-
+    __ j(zero, &done);
     __ bind(&stub_call);
     // Call stub. Undo operation first.
     if (expr->op() == Token::INC) {
       __ sub(Operand(eax), Immediate(Smi::FromInt(1)));
     } else {
       __ add(Operand(eax), Immediate(Smi::FromInt(1)));
     }
   }
 
   // Record position before stub call.
   SetSourcePosition(expr->position());
 
   // Call stub for +1/-1.
   __ mov(edx, eax);
   __ mov(eax, Immediate(Smi::FromInt(1)));
   TypeRecordingBinaryOpStub stub(expr->binary_op(),
                                  NO_OVERWRITE);
-  EmitCallIC(stub.GetCode(), &patch_site);
+  __ CallStub(&stub);
+  __ bind(&done);
 
-  __ bind(&done);
   // Store the value returned in eax.
   switch (assign_type) {
     case VARIABLE:
       if (expr->is_postfix()) {
         // Perform the assignment as if via '='.
         { EffectContext context(this);
           EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
                                  Token::ASSIGN);
         }
         // For all contexts except EffectContext We have the result on
@@ skipping 244 matching lines @@
           cc = greater_equal;
           __ pop(edx);
           break;
         case Token::IN:
         case Token::INSTANCEOF:
         default:
           UNREACHABLE();
       }
 
       bool inline_smi_code = ShouldInlineSmiCase(op);
-      JumpPatchSite patch_site(masm_);
       if (inline_smi_code) {
         NearLabel slow_case;
         __ mov(ecx, Operand(edx));
         __ or_(ecx, Operand(eax));
         __ test(ecx, Immediate(kSmiTagMask));
-        patch_site.EmitJump(&slow_case);
+        __ j(not_zero, &slow_case, not_taken);
         __ cmp(edx, Operand(eax));
         Split(cc, if_true, if_false, NULL);
         __ bind(&slow_case);
       }
 
       // Record position and call the compare IC.
+      Handle<Code> ic = CompareIC::GetUninitialized(op);
       SetSourcePosition(expr->position());
-      Handle<Code> ic = CompareIC::GetUninitialized(op);
-      EmitCallIC(ic, &patch_site);
-
+      __ call(ic, RelocInfo::CODE_TARGET);
       PrepareForBailoutBeforeSplit(TOS_REG, true, if_true, if_false);
       __ test(eax, Operand(eax));
       Split(cc, if_true, if_false, fall_through);
     }
   }
 
   // Convert the result of the comparison into one expected for this
   // expression's context.
   context()->Plug(if_true, if_false);
 }
@@ skipping 83 matching lines @@
     case Code::KEYED_STORE_IC:
       __ nop();  // Signals no inlined code.
       break;
     default:
       // Do nothing.
       break;
   }
 }
 
 
-void FullCodeGenerator::EmitCallIC(Handle<Code> ic, JumpPatchSite* patch_site) {
-  __ call(ic, RelocInfo::CODE_TARGET);
-  if (patch_site != NULL && patch_site->is_bound()) {
-    patch_site->EmitPatchInfo();
-  } else {
-    __ nop();  // Signals no inlined code.
-  }
-}
-
-
 void FullCodeGenerator::StoreToFrameField(int frame_offset, Register value) {
   ASSERT_EQ(POINTER_SIZE_ALIGN(frame_offset), frame_offset);
   __ mov(Operand(ebp, frame_offset), value);
 }
 
 
 void FullCodeGenerator::LoadContextField(Register dst, int context_index) {
   __ mov(dst, ContextOperand(esi, context_index));
 }
 
@@ skipping 27 matching lines @@
   // And return.
   __ ret(0);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32