Thumb2 Backend: Use sp-relative offsets for stack slot operations in Crankshaft

src/arm/lithium-codegen-arm.cc

 // Copyright 2012 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 132 matching lines @@
       __ b(eq, &ok);
       int receiver_offset = scope()->num_parameters() * kPointerSize;
       __ LoadRoot(r2, Heap::kUndefinedValueRootIndex);
       __ str(r2, MemOperand(sp, receiver_offset));
       __ bind(&ok);
     }
   }
 
   info()->set_prologue_offset(masm_->pc_offset());
   if (NeedsEagerFrame()) {
+    fp_sp_delta_ = 2 * kPointerSize;
     if (info()->IsStub()) {
       __ stm(db_w, sp, cp.bit() | fp.bit() | lr.bit());
       __ Push(Smi::FromInt(StackFrame::STUB));
       // Adjust FP to point to saved FP.
-      __ add(fp, sp, Operand(2 * kPointerSize));
+      __ add(fp, sp, Operand(fp_sp_delta_));
     } else {
       PredictableCodeSizeScope predictible_code_size_scope(
           masm_, kNoCodeAgeSequenceLength * Assembler::kInstrSize);
       // The following three instructions must remain together and unmodified
       // for code aging to work properly.
       __ stm(db_w, sp, r1.bit() | cp.bit() | fp.bit() | lr.bit());
       __ nop(ip.code());
       if (masm()->is_thumb_mode()) {
         __ nop(ip.code());
       }
       // Adjust FP to point to saved FP.
-      __ add(fp, sp, Operand(2 * kPointerSize));
+      __ add(fp, sp, Operand(fp_sp_delta_));
     }
     frame_is_built_ = true;
     info_->AddNoFrameRange(0, masm_->pc_offset());
   }
 
   // Reserve space for the stack slots needed by the code.
   int slots = GetStackSlotCount();
   if (slots > 0) {
+    int slots_size = slots * kPointerSize;
+    fp_sp_delta_ += slots_size;
     if (FLAG_debug_code) {
-      __ sub(sp,  sp, Operand(slots * kPointerSize));
+      __ sub(sp,  sp, Operand(slots_size));
       __ push(r0);
       __ push(r1);
-      __ add(r0, sp, Operand(slots *  kPointerSize));
+      __ add(r0, sp, Operand(slots_size));
       __ mov(r1, Operand(kSlotsZapValue));
       Label loop;
       __ bind(&loop);
       __ sub(r0, r0, Operand(kPointerSize));
       __ str(r1, MemOperand(r0, 2 * kPointerSize));
       __ cmp(r0, sp);
       __ b(ne, &loop);
       __ pop(r1);
       __ pop(r0);
     } else {
-      __ sub(sp,  sp, Operand(slots * kPointerSize));
+      __ sub(sp,  sp, Operand(slots_size));
     }
   }
 
   if (info()->saves_caller_doubles()) {
     Comment(";;; Save clobbered callee double registers");
     int count = 0;
     BitVector* doubles = chunk()->allocated_double_registers();
     BitVector::Iterator save_iterator(doubles);
     while (!save_iterator.Done()) {
       __ vstr(DwVfpRegister::FromAllocationIndex(save_iterator.Current()),
               MemOperand(sp, count * kDoubleSize));
       save_iterator.Advance();
       count++;
     }
   }
 
   // Possibly allocate a local context.
   int heap_slots = info()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
   if (heap_slots > 0) {
+    ASSERT(frame_is_built_);
     Comment(";;; Allocate local context");
     // Argument to NewContext is the function, which is in r1.
     __ push(r1);
     if (heap_slots <= FastNewContextStub::kMaximumSlots) {
       FastNewContextStub stub(heap_slots);
       __ CallStub(&stub);
     } else {
       __ CallRuntime(Runtime::kNewFunctionContext, 1);
     }
     RecordSafepoint(Safepoint::kNoLazyDeopt);
     // Context is returned in both r0 and cp.  It replaces the context
     // passed to us.  It's saved in the stack and kept live in cp.
-    __ str(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+    int cp_offset = StandardFrameConstants::kContextOffset + fp_sp_delta_;
+    __ str(cp, MemOperand(sp, cp_offset));
     // Copy any necessary parameters into the context.
     int num_parameters = scope()->num_parameters();
     for (int i = 0; i < num_parameters; i++) {
       Variable* var = scope()->parameter(i);
       if (var->IsContextSlot()) {
         int parameter_offset = StandardFrameConstants::kCallerSPOffset +
-            (num_parameters - 1 - i) * kPointerSize;
+            (num_parameters - 1 - i) * kPointerSize + fp_sp_delta_;
         // Load parameter from stack.
-        __ ldr(r0, MemOperand(fp, parameter_offset));
+        __ ldr(r0, MemOperand(sp, parameter_offset));
         // Store it in the context.
         MemOperand target = ContextOperand(cp, var->index());
         __ str(r0, target);
         // Update the write barrier. This clobbers r3 and r0.
         __ RecordWriteContextSlot(
             cp,
             target.offset(),
             r0,
             r3,
             GetLinkRegisterState(),
@@ skipping 14 matching lines @@
 bool LCodeGen::GenerateBody() {
   ASSERT(is_generating());
   bool emit_instructions = true;
   for (current_instruction_ = 0;
        !is_aborted() && current_instruction_ < instructions_->length();
        current_instruction_++) {
     LInstruction* instr = instructions_->at(current_instruction_);
 
     // Don't emit code for basic blocks with a replacement.
     if (instr->IsLabel()) {
-      emit_instructions = !LLabel::cast(instr)->HasReplacement();
+      LLabel* label = LLabel::cast(instr);
+      emit_instructions = !label->HasReplacement();
+      if (emit_instructions) {
+        HBasicBlock* block = label->block();
+        int argument_count = block->HasPredecessor()
+            ? block->predecessors()->at(0)->argument_count()
+            : 0;
+        SetFpSpDelta(argument_count);
+      }
     }
     if (!emit_instructions) continue;
 
     if (FLAG_code_comments && instr->HasInterestingComment(this)) {
       Comment(";;; <@%d,#%d> %s",
               current_instruction_,
               instr->hydrogen_value()->id(),
               instr->Mnemonic());
     }
 
@@ skipping 20 matching lines @@
               "-------------------- Deferred %s --------------------",
               code->instruction_index(),
               code->instr()->hydrogen_value()->id(),
               code->instr()->Mnemonic());
       __ bind(code->entry());
       if (NeedsDeferredFrame()) {
         Comment(";;; Build frame");
         ASSERT(!frame_is_built_);
         ASSERT(info()->IsStub());
         frame_is_built_ = true;
+        fp_sp_delta_ = 2 * kPointerSize;
         __ stm(db_w, sp, cp.bit() | fp.bit() | lr.bit());
         __ mov(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));
         __ push(scratch0());
-        __ add(fp, sp, Operand(2 * kPointerSize));
+        __ add(fp, sp, Operand(fp_sp_delta_));
         Comment(";;; Deferred code");
       }
       code->Generate();
       if (NeedsDeferredFrame()) {
         Comment(";;; Destroy frame");
         ASSERT(frame_is_built_);
         __ pop(ip);
         __ ldm(ia_w, sp, cp.bit() | fp.bit() | lr.bit());
         frame_is_built_ = false;
+        fp_sp_delta_ = -1;
       }
       __ jmp(code->exit());
     }
   }
 
   // Force constant pool emission at the end of the deferred code to make
   // sure that no constant pools are emitted after.
   masm()->CheckConstPool(true, false);
 
   return !is_aborted();
@@ skipping 35 matching lines @@
         __ b(&needs_frame);
       } else {
         __ bind(&needs_frame);
         __ stm(db_w, sp, cp.bit() | fp.bit() | lr.bit());
         // This variant of deopt can only be used with stubs. Since we don't
         // have a function pointer to install in the stack frame that we're
         // building, install a special marker there instead.
         ASSERT(info()->IsStub());
         __ mov(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));
         __ push(scratch0());
-        __ add(fp, sp, Operand(2 * kPointerSize));
+        fp_sp_delta_ = 2 * kPointerSize;
+        __ add(fp, sp, Operand(fp_sp_delta_));
         __ mov(lr, Operand(pc), LeaveCC, al);
         __ mov(pc, ip);
       }
     } else {
       __ mov(lr, Operand(pc), LeaveCC, al);
       __ mov(pc, Operand(ExternalReference::ForDeoptEntry(entry)));
     }
     masm()->CheckConstPool(false, false);
   }
 
@@ skipping 167 matching lines @@
   // Stack slots not implemented, use ToMemOperand instead.
   UNREACHABLE();
   return Operand::Zero();
 }
 
 
 MemOperand LCodeGen::ToMemOperand(LOperand* op) const {
   ASSERT(!op->IsRegister());
   ASSERT(!op->IsDoubleRegister());
   ASSERT(op->IsStackSlot() || op->IsDoubleStackSlot());
-  return MemOperand(fp, StackSlotOffset(op->index()));
+  return MemOperand(sp, StackSlotOffset(op->index(), fp_sp_delta_));
 }
 
 
 MemOperand LCodeGen::ToHighMemOperand(LOperand* op) const {
   ASSERT(op->IsDoubleStackSlot());
-  return MemOperand(fp, StackSlotOffset(op->index()) + kPointerSize);
+  int offset = StackSlotOffset(op->index(), fp_sp_delta_) + kPointerSize;
+  return MemOperand(sp, offset);
 }
 
 
 void LCodeGen::WriteTranslation(LEnvironment* environment,
                                 Translation* translation) {
   if (environment == NULL) return;
 
   // The translation includes one command per value in the environment.
   int translation_size = environment->translation_size();
   // The output frame height does not include the parameters.
@@ skipping 111 matching lines @@
   } else if (op->IsConstantOperand()) {
     HConstant* constant = chunk()->LookupConstant(LConstantOperand::cast(op));
     int src_index = DefineDeoptimizationLiteral(constant->handle());
     translation->StoreLiteral(src_index);
   } else {
     UNREACHABLE();
   }
 }
 
 
+void LCodeGen::SetFpSpDelta(int argument_count) {
+  int slots_size = GetStackSlotCount() * kPointerSize;
+  int args_size = argument_count * kPointerSize;
+  int fixed_size = 2 * kPointerSize;
+  fp_sp_delta_ = slots_size + args_size + fixed_size;
+}
+
+
+void LCodeGen::Push(Register src1) {
+  fp_sp_delta_ += kPointerSize;
+  __ push(src1);
+}
+
+
+void LCodeGen::Push(Register src1, Register src2) {
+  fp_sp_delta_ += 2 * kPointerSize;
+  __ Push(src1, src2);
+}
+
+
+void LCodeGen::Push(Register src1, Register src2, Register src3) {
+  fp_sp_delta_ += 3 * kPointerSize;
+  __ Push(src1, src2, src3);
+}
+
+
+void LCodeGen::Push(Register src1,
+                    Register src2,
+                    Register src3,
+                    Register src4) {
+  fp_sp_delta_ += 4 * kPointerSize;
+  __ Push(src1, src2, src3, src4);
+}
+
+
+#ifdef DEBUG
+void LCodeGen::CheckFpSpDelta(LInstruction* instr) {
+  if (fp_sp_delta_ == -1 || !instr->HasEnvironment())
+    return;
+  int slots_size = GetStackSlotCount() * kPointerSize;
+  int args_size = instr->environment()->arguments_stack_height() * kPointerSize;
+  int fixed_size = 2 * kPointerSize;
+  int expected_delta = slots_size + args_size + fixed_size;
+  ASSERT_EQ(expected_delta, fp_sp_delta_);
+}
+#endif  // DEBUG
+
+
 void LCodeGen::CallCode(Handle<Code> code,
                         RelocInfo::Mode mode,
+                        int num_arguments,
                         LInstruction* instr,
                         TargetAddressStorageMode storage_mode) {
-  CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT, storage_mode);
+  CallCodeGeneric(code, mode, num_arguments, instr, RECORD_SIMPLE_SAFEPOINT,
+                  storage_mode);
 }
 
 
 void LCodeGen::CallCodeGeneric(Handle<Code> code,
                                RelocInfo::Mode mode,
+                               int num_arguments,
                                LInstruction* instr,
                                SafepointMode safepoint_mode,
                                TargetAddressStorageMode storage_mode) {
   EnsureSpaceForLazyDeopt();
   ASSERT(instr != NULL);
   // Block literal pool emission to ensure nop indicating no inlined smi code
   // is in the correct position.
   Assembler::BlockConstPoolScope block_const_pool(masm());
   LPointerMap* pointers = instr->pointer_map();
   RecordPosition(pointers->position());
   __ Call(code, mode, TypeFeedbackId::None(), al, storage_mode);
+  fp_sp_delta_ -= num_arguments * kPointerSize;
   RecordSafepointWithLazyDeopt(instr, safepoint_mode);
 
   // Signal that we don't inline smi code before these stubs in the
   // optimizing code generator.
   if (code->kind() == Code::BINARY_OP_IC ||
       code->kind() == Code::COMPARE_IC) {
     __ nop();
   }
 }
 
 
 void LCodeGen::CallRuntime(const Runtime::Function* function,
                            int num_arguments,
                            LInstruction* instr) {
   ASSERT(instr != NULL);
   LPointerMap* pointers = instr->pointer_map();
   ASSERT(pointers != NULL);
   RecordPosition(pointers->position());
 
   __ CallRuntime(function, num_arguments);
+  fp_sp_delta_ -= num_arguments * kPointerSize;
   RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
 }
 
 
 void LCodeGen::CallRuntimeFromDeferred(Runtime::FunctionId id,
                                        int argc,
                                        LInstruction* instr) {
   __ CallRuntimeSaveDoubles(id);
+  fp_sp_delta_ -= argc * kPointerSize;
   RecordSafepointWithRegisters(
       instr->pointer_map(), argc, Safepoint::kNoLazyDeopt);
 }
 
 
 void LCodeGen::RegisterEnvironmentForDeoptimization(LEnvironment* environment,
                                                     Safepoint::DeoptMode mode) {
   if (!environment->HasBeenRegistered()) {
     // Physical stack frame layout:
     // -x ............. -4  0 ..................................... y
@@ skipping 299 matching lines @@
 void LCodeGen::DoParameter(LParameter* instr) {
   // Nothing to do.
 }
 
 
 void LCodeGen::DoCallStub(LCallStub* instr) {
   ASSERT(ToRegister(instr->result()).is(r0));
   switch (instr->hydrogen()->major_key()) {
     case CodeStub::RegExpConstructResult: {
       RegExpConstructResultStub stub;
-      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 3, instr);
       break;
     }
     case CodeStub::RegExpExec: {
       RegExpExecStub stub;
-      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 4, instr);
       break;
     }
     case CodeStub::SubString: {
       SubStringStub stub;
-      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 3, instr);
       break;
     }
     case CodeStub::NumberToString: {
       NumberToStringStub stub;
-      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 1, instr);
       break;
     }
     case CodeStub::StringCompare: {
       StringCompareStub stub;
-      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 2, instr);
       break;
     }
     case CodeStub::TranscendentalCache: {
       __ ldr(r0, MemOperand(sp, 0));
       TranscendentalCacheStub stub(instr->transcendental_type(),
                                    TranscendentalCacheStub::TAGGED);
-      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 1, instr);
       break;
     }
     default:
       UNREACHABLE();
   }
 }
 
 
 void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) {
   // Record the address of the first unknown OSR value as the place to enter.
@@ skipping 885 matching lines @@
     // MemOperand with ip as the base register is not allowed for strh, so
     // we do the address calculation explicitly.
     __ add(ip, ip, Operand(index, LSL, 1));
     __ strh(value, MemOperand(ip));
   }
 }
 
 
 void LCodeGen::DoThrow(LThrow* instr) {
   Register input_reg = EmitLoadRegister(instr->value(), ip);
-  __ push(input_reg);
+  Push(input_reg);
   CallRuntime(Runtime::kThrow, 1, instr);
 
   if (FLAG_debug_code) {
     __ stop("Unreachable code.");
   }
 }
 
 
 void LCodeGen::DoAddI(LAddI* instr) {
   LOperand* left = instr->left();
@@ skipping 96 matching lines @@
       break;
     case Token::MUL:
       __ vmul(result, left, right);
       break;
     case Token::DIV:
       __ vdiv(result, left, right);
       break;
     case Token::MOD: {
       // Save r0-r3 on the stack.
       __ stm(db_w, sp, r0.bit() | r1.bit() | r2.bit() | r3.bit());
-
+      fp_sp_delta_ += 4 * kPointerSize;
       __ PrepareCallCFunction(0, 2, scratch0());
       __ SetCallCDoubleArguments(left, right);
       __ CallCFunction(
           ExternalReference::double_fp_operation(Token::MOD, isolate()),
           0, 2);
       // Move the result in the double result register.
       __ GetCFunctionDoubleResult(result);
 
       // Restore r0-r3.
       __ ldm(ia_w, sp, r0.bit() | r1.bit() | r2.bit() | r3.bit());
+      fp_sp_delta_ -= 4 * kPointerSize;
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 void LCodeGen::DoArithmeticT(LArithmeticT* instr) {
   ASSERT(ToRegister(instr->left()).is(r1));
   ASSERT(ToRegister(instr->right()).is(r0));
   ASSERT(ToRegister(instr->result()).is(r0));
 
   BinaryOpStub stub(instr->op(), NO_OVERWRITE);
   // Block literal pool emission to ensure nop indicating no inlined smi code
   // is in the correct position.
   Assembler::BlockConstPoolScope block_const_pool(masm());
-  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 0, instr);
   __ nop();  // Signals no inlined code.
 }
 
 
 int LCodeGen::GetNextEmittedBlock() const {
   for (int i = current_block_ + 1; i < graph()->blocks()->length(); ++i) {
     if (!chunk_->GetLabel(i)->HasReplacement()) return i;
   }
   return -1;
 }
@@ skipping 404 matching lines @@
       UNREACHABLE();
       return kNoCondition;
   }
 }
 
 
 void LCodeGen::DoStringCompareAndBranch(LStringCompareAndBranch* instr) {
   Token::Value op = instr->op();
 
   Handle<Code> ic = CompareIC::GetUninitialized(isolate(), op);
-  CallCode(ic, RelocInfo::CODE_TARGET, instr);
+  CallCode(ic, RelocInfo::CODE_TARGET, 0, instr);
   // This instruction also signals no smi code inlined.
   __ cmp(r0, Operand::Zero());
 
   Condition condition = ComputeCompareCondition(op);
 
   EmitBranch(instr, condition);
 }
 
 
 static InstanceType TestType(HHasInstanceTypeAndBranch* instr) {
@@ skipping 140 matching lines @@
   __ cmp(temp, Operand(instr->map()));
   EmitBranch(instr, eq);
 }
 
 
 void LCodeGen::DoInstanceOf(LInstanceOf* instr) {
   ASSERT(ToRegister(instr->left()).is(r0));  // Object is in r0.
   ASSERT(ToRegister(instr->right()).is(r1));  // Function is in r1.
 
   InstanceofStub stub(InstanceofStub::kArgsInRegisters);
-  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 0, instr);
 
   __ cmp(r0, Operand::Zero());
   __ mov(r0, Operand(factory()->false_value()), LeaveCC, ne);
   __ mov(r0, Operand(factory()->true_value()), LeaveCC, eq);
 }
 
 
 void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
   class DeferredInstanceOfKnownGlobal: public LDeferredCode {
    public:
@@ skipping 121 matching lines @@
   if (masm_->SizeOfCodeGeneratedSince(&before_push_delta) != 8) {
     ASSERT_EQ(1, masm_->InstructionsGeneratedSince(&before_push_delta));
     __ nop();
     if (masm_->is_thumb_mode()) {
       __ nop();
     }
   }
   __ StoreToSafepointRegisterSlot(temp, temp);
   CallCodeGeneric(stub.GetCode(isolate()),
                   RelocInfo::CODE_TARGET,
+                  0,
                   instr,
                   RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
   LEnvironment* env = instr->GetDeferredLazyDeoptimizationEnvironment();
   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
   // Put the result value into the result register slot and
   // restore all registers.
   __ StoreToSafepointRegisterSlot(result, result);
 }
 
 
 void LCodeGen::DoInstanceSize(LInstanceSize* instr) {
   Register object = ToRegister(instr->object());
   Register result = ToRegister(instr->result());
   __ ldr(result, FieldMemOperand(object, HeapObject::kMapOffset));
   __ ldrb(result, FieldMemOperand(result, Map::kInstanceSizeOffset));
 }
 
 
 void LCodeGen::DoCmpT(LCmpT* instr) {
   Token::Value op = instr->op();
 
   Handle<Code> ic = CompareIC::GetUninitialized(isolate(), op);
-  CallCode(ic, RelocInfo::CODE_TARGET, instr);
+  CallCode(ic, RelocInfo::CODE_TARGET, 0, instr);
   // This instruction also signals no smi code inlined.
   __ cmp(r0, Operand::Zero());
 
   Condition condition = ComputeCompareCondition(op);
   __ LoadRoot(ToRegister(instr->result()),
               Heap::kTrueValueRootIndex,
               condition);
   __ LoadRoot(ToRegister(instr->result()),
               Heap::kFalseValueRootIndex,
               NegateCondition(condition));
@@ skipping 59 matching lines @@
 
 
 void LCodeGen::DoLoadGlobalGeneric(LLoadGlobalGeneric* instr) {
   ASSERT(ToRegister(instr->global_object()).is(r0));
   ASSERT(ToRegister(instr->result()).is(r0));
 
   __ mov(r2, Operand(instr->name()));
   RelocInfo::Mode mode = instr->for_typeof() ? RelocInfo::CODE_TARGET
                                              : RelocInfo::CODE_TARGET_CONTEXT;
   Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
-  CallCode(ic, mode, instr);
+  CallCode(ic, mode, 0, instr);
 }
 
 
 void LCodeGen::DoStoreGlobalCell(LStoreGlobalCell* instr) {
   Register value = ToRegister(instr->value());
   Register cell = scratch0();
 
   // Load the cell.
   __ mov(cell, Operand(instr->hydrogen()->cell()));
 
@@ skipping 16 matching lines @@
 
 
 void LCodeGen::DoStoreGlobalGeneric(LStoreGlobalGeneric* instr) {
   ASSERT(ToRegister(instr->global_object()).is(r1));
   ASSERT(ToRegister(instr->value()).is(r0));
 
   __ mov(r2, Operand(instr->name()));
   Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode)
       ? isolate()->builtins()->StoreIC_Initialize_Strict()
       : isolate()->builtins()->StoreIC_Initialize();
-  CallCode(ic, RelocInfo::CODE_TARGET_CONTEXT, instr);
+  CallCode(ic, RelocInfo::CODE_TARGET_CONTEXT, 0, instr);
 }
 
 
 void LCodeGen::DoLoadContextSlot(LLoadContextSlot* instr) {
   Register context = ToRegister(instr->context());
   Register result = ToRegister(instr->result());
   __ ldr(result, ContextOperand(context, instr->slot_index()));
   if (instr->hydrogen()->RequiresHoleCheck()) {
     __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
     __ cmp(result, ip);
@@ skipping 71 matching lines @@
 }
 
 
 void LCodeGen::DoLoadNamedGeneric(LLoadNamedGeneric* instr) {
   ASSERT(ToRegister(instr->object()).is(r0));
   ASSERT(ToRegister(instr->result()).is(r0));
 
   // Name is always in r2.
   __ mov(r2, Operand(instr->name()));
   Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
-  CallCode(ic, RelocInfo::CODE_TARGET, instr, NEVER_INLINE_TARGET_ADDRESS);
+  CallCode(ic, RelocInfo::CODE_TARGET, 0, instr, NEVER_INLINE_TARGET_ADDRESS);
 }
 
 
 void LCodeGen::DoLoadFunctionPrototype(LLoadFunctionPrototype* instr) {
   Register scratch = scratch0();
   Register function = ToRegister(instr->function());
   Register result = ToRegister(instr->result());
 
   // Check that the function really is a function. Load map into the
   // result register.
@@ skipping 264 matching lines @@
     return MemOperand(base, scratch0(), LSR, 1);
   }
 }
 
 
 void LCodeGen::DoLoadKeyedGeneric(LLoadKeyedGeneric* instr) {
   ASSERT(ToRegister(instr->object()).is(r1));
   ASSERT(ToRegister(instr->key()).is(r0));
 
   Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Initialize();
-  CallCode(ic, RelocInfo::CODE_TARGET, instr, NEVER_INLINE_TARGET_ADDRESS);
+  CallCode(ic, RelocInfo::CODE_TARGET, 0, instr, NEVER_INLINE_TARGET_ADDRESS);
 }
 
 
 void LCodeGen::DoArgumentsElements(LArgumentsElements* instr) {
   Register scratch = scratch0();
   Register result = ToRegister(instr->result());
 
   if (instr->hydrogen()->from_inlined()) {
     __ sub(result, sp, Operand(2 * kPointerSize));
   } else {
     // Check if the calling frame is an arguments adaptor frame.
     Label done, adapted;
-    __ ldr(scratch, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+    int fp_offset = StandardFrameConstants::kCallerFPOffset + fp_sp_delta_;
+    __ ldr(scratch, MemOperand(sp, fp_offset));
     __ ldr(result, MemOperand(scratch, StandardFrameConstants::kContextOffset));
     __ cmp(result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
 
     // Result is the frame pointer for the frame if not adapted and for the real
     // frame below the adaptor frame if adapted.
     __ mov(result, fp, LeaveCC, ne);
     __ mov(result, scratch, LeaveCC, eq);
   }
 }
 
 
 void LCodeGen::DoArgumentsLength(LArgumentsLength* instr) {
   Register elem = ToRegister(instr->elements());
   Register result = ToRegister(instr->result());
 
   Label done;
 
   // If no arguments adaptor frame the number of arguments is fixed.
   __ cmp(fp, elem);
   __ mov(result, Operand(scope()->num_parameters()), LeaveCC);
   __ b(eq, &done);
 
   // Arguments adaptor frame present. Get argument length from there.
-  __ ldr(result, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+  int fp_offset = StandardFrameConstants::kCallerFPOffset + fp_sp_delta_;
+  __ ldr(result, MemOperand(sp, fp_offset));
   __ ldr(result,
          MemOperand(result, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ SmiUntag(result);
 
   // Argument length is in result register.
   __ bind(&done);
 }
 
 
 void LCodeGen::DoWrapReceiver(LWrapReceiver* instr) {
@@ skipping 82 matching lines @@
   ASSERT(instr->HasPointerMap());
   LPointerMap* pointers = instr->pointer_map();
   RecordPosition(pointers->position());
   SafepointGenerator safepoint_generator(
       this, pointers, Safepoint::kLazyDeopt);
   // The number of arguments is stored in receiver which is r0, as expected
   // by InvokeFunction.
   ParameterCount actual(receiver);
   __ InvokeFunction(function, actual, CALL_FUNCTION,
                     safepoint_generator, CALL_AS_METHOD);
-  __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  int cp_offset = StandardFrameConstants::kContextOffset + fp_sp_delta_;
+  __ ldr(cp, MemOperand(sp, cp_offset));
 }
 
 
 void LCodeGen::DoPushArgument(LPushArgument* instr) {
   LOperand* argument = instr->value();
   if (argument->IsDoubleRegister() || argument->IsDoubleStackSlot()) {
     Abort(kDoPushArgumentNotImplementedForDoubleType);
   } else {
     Register argument_reg = EmitLoadRegister(argument, ip);
-    __ push(argument_reg);
+    Push(argument_reg);
   }
 }
 
 
 void LCodeGen::DoDrop(LDrop* instr) {
   __ Drop(instr->count());
+  fp_sp_delta_ -= instr->count() * kPointerSize;
 }
 
 
 void LCodeGen::DoThisFunction(LThisFunction* instr) {
   Register result = ToRegister(instr->result());
-  __ ldr(result, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+  int offset = JavaScriptFrameConstants::kFunctionOffset + fp_sp_delta_;
+  __ ldr(result, MemOperand(sp, offset));
 }
 
 
 void LCodeGen::DoContext(LContext* instr) {
   // If there is a non-return use, the context must be moved to a register.
   Register result = ToRegister(instr->result());
   for (HUseIterator it(instr->hydrogen()->uses()); !it.Done(); it.Advance()) {
     if (!it.value()->IsReturn()) {
       __ mov(result, cp);
       return;
     }
   }
 }
 
 
 void LCodeGen::DoOuterContext(LOuterContext* instr) {
   Register context = ToRegister(instr->context());
   Register result = ToRegister(instr->result());
   __ ldr(result,
          MemOperand(context, Context::SlotOffset(Context::PREVIOUS_INDEX)));
 }
 
 
 void LCodeGen::DoDeclareGlobals(LDeclareGlobals* instr) {
-  __ push(cp);  // The context is the first argument.
+  Push(cp);  // The context is the first argument.
   __ LoadHeapObject(scratch0(), instr->hydrogen()->pairs());
-  __ push(scratch0());
+  Push(scratch0());
   __ mov(scratch0(), Operand(Smi::FromInt(instr->hydrogen()->flags())));
-  __ push(scratch0());
+  Push(scratch0());
   CallRuntime(Runtime::kDeclareGlobals, 3, instr);
 }
 
 
 void LCodeGen::DoGlobalObject(LGlobalObject* instr) {
   Register result = ToRegister(instr->result());
   __ ldr(result, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
 }
 
 
@@ skipping 39 matching lines @@
 
     // Set up deoptimization.
     RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
   } else {
     SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
     ParameterCount count(arity);
     ParameterCount expected(formal_parameter_count);
     __ InvokeFunction(
         function, expected, count, CALL_FUNCTION, generator, call_kind);
   }
+  fp_sp_delta_ -= (arity + 1) * kPointerSize;
 
   // Restore context.
-  __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  int cp_offset = StandardFrameConstants::kContextOffset + fp_sp_delta_;
+  __ ldr(cp, MemOperand(sp, cp_offset));
 }
 
 
 void LCodeGen::DoCallConstantFunction(LCallConstantFunction* instr) {
   ASSERT(ToRegister(instr->result()).is(r0));
   CallKnownFunction(instr->hydrogen()->function(),
                     instr->hydrogen()->formal_parameter_count(),
                     instr->arity(),
                     instr,
                     CALL_AS_METHOD,
@@ skipping 327 matching lines @@
   MathExpGenerator::EmitMathExp(
       masm(), input, result, double_scratch1, double_scratch2,
       temp1, temp2, scratch0());
 }
 
 
 void LCodeGen::DoMathLog(LMathLog* instr) {
   ASSERT(ToDoubleRegister(instr->result()).is(d2));
   TranscendentalCacheStub stub(TranscendentalCache::LOG,
                                TranscendentalCacheStub::UNTAGGED);
-  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 0, instr);
 }
 
 
 void LCodeGen::DoMathTan(LMathTan* instr) {
   ASSERT(ToDoubleRegister(instr->result()).is(d2));
   TranscendentalCacheStub stub(TranscendentalCache::TAN,
                                TranscendentalCacheStub::UNTAGGED);
-  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 0, instr);
 }
 
 
 void LCodeGen::DoMathCos(LMathCos* instr) {
   ASSERT(ToDoubleRegister(instr->result()).is(d2));
   TranscendentalCacheStub stub(TranscendentalCache::COS,
                                TranscendentalCacheStub::UNTAGGED);
-  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 0, instr);
 }
 
 
 void LCodeGen::DoMathSin(LMathSin* instr) {
   ASSERT(ToDoubleRegister(instr->result()).is(d2));
   TranscendentalCacheStub stub(TranscendentalCache::SIN,
                                TranscendentalCacheStub::UNTAGGED);
-  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 0, instr);
 }
 
 
 void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {
   ASSERT(ToRegister(instr->function()).is(r1));
   ASSERT(instr->HasPointerMap());
 
   Handle<JSFunction> known_function = instr->hydrogen()->known_function();
   if (known_function.is_null()) {
     LPointerMap* pointers = instr->pointer_map();
     RecordPosition(pointers->position());
     SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
     ParameterCount count(instr->arity());
     __ InvokeFunction(r1, count, CALL_FUNCTION, generator, CALL_AS_METHOD);
-    __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+    fp_sp_delta_ -= (instr->arity() + 1) * kPointerSize;
+    int cp_offset = StandardFrameConstants::kContextOffset + fp_sp_delta_;
+    __ ldr(cp, MemOperand(sp, cp_offset));
   } else {
     CallKnownFunction(known_function,
                       instr->hydrogen()->formal_parameter_count(),
                       instr->arity(),
                       instr,
                       CALL_AS_METHOD,
                       R1_CONTAINS_TARGET);
   }
 }
 
 
 void LCodeGen::DoCallKeyed(LCallKeyed* instr) {
   ASSERT(ToRegister(instr->result()).is(r0));
 
   int arity = instr->arity();
   Handle<Code> ic =
       isolate()->stub_cache()->ComputeKeyedCallInitialize(arity);
-  CallCode(ic, RelocInfo::CODE_TARGET, instr, NEVER_INLINE_TARGET_ADDRESS);
-  __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  CallCode(ic, RelocInfo::CODE_TARGET, arity + 1, instr,
+           NEVER_INLINE_TARGET_ADDRESS);
+  int cp_offset = StandardFrameConstants::kContextOffset + fp_sp_delta_;
+  __ ldr(cp, MemOperand(sp, cp_offset));
 }
 
 
 void LCodeGen::DoCallNamed(LCallNamed* instr) {
   ASSERT(ToRegister(instr->result()).is(r0));
 
   int arity = instr->arity();
   RelocInfo::Mode mode = RelocInfo::CODE_TARGET;
   Handle<Code> ic =
       isolate()->stub_cache()->ComputeCallInitialize(arity, mode);
   __ mov(r2, Operand(instr->name()));
-  CallCode(ic, mode, instr, NEVER_INLINE_TARGET_ADDRESS);
+  CallCode(ic, mode, arity + 1, instr, NEVER_INLINE_TARGET_ADDRESS);
   // Restore context register.
-  __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  int cp_offset = StandardFrameConstants::kContextOffset + fp_sp_delta_;
+  __ ldr(cp, MemOperand(sp, cp_offset));
 }
 
 
 void LCodeGen::DoCallFunction(LCallFunction* instr) {
   ASSERT(ToRegister(instr->function()).is(r1));
   ASSERT(ToRegister(instr->result()).is(r0));
 
   int arity = instr->arity();
   CallFunctionStub stub(arity, NO_CALL_FUNCTION_FLAGS);
-  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
-  __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, arity + 1, instr);
+  int cp_offset = StandardFrameConstants::kContextOffset + fp_sp_delta_;
+  __ ldr(cp, MemOperand(sp, cp_offset));
 }
 
 
 void LCodeGen::DoCallGlobal(LCallGlobal* instr) {
   ASSERT(ToRegister(instr->result()).is(r0));
 
   int arity = instr->arity();
   RelocInfo::Mode mode = RelocInfo::CODE_TARGET_CONTEXT;
   Handle<Code> ic =
       isolate()->stub_cache()->ComputeCallInitialize(arity, mode);
   __ mov(r2, Operand(instr->name()));
-  CallCode(ic, mode, instr, NEVER_INLINE_TARGET_ADDRESS);
-  __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  CallCode(ic, mode, arity + 1, instr, NEVER_INLINE_TARGET_ADDRESS);
+  int cp_offset = StandardFrameConstants::kContextOffset + fp_sp_delta_;
+  __ ldr(cp, MemOperand(sp, cp_offset));
 }
 
 
 void LCodeGen::DoCallKnownGlobal(LCallKnownGlobal* instr) {
   ASSERT(ToRegister(instr->result()).is(r0));
   CallKnownFunction(instr->hydrogen()->target(),
                     instr->hydrogen()->formal_parameter_count(),
                     instr->arity(),
                     instr,
                     CALL_AS_FUNCTION,
                     R1_UNINITIALIZED);
 }
 
 
 void LCodeGen::DoCallNew(LCallNew* instr) {
   ASSERT(ToRegister(instr->constructor()).is(r1));
   ASSERT(ToRegister(instr->result()).is(r0));
 
   __ mov(r0, Operand(instr->arity()));
   // No cell in r2 for construct type feedback in optimized code
   Handle<Object> undefined_value(isolate()->factory()->undefined_value());
   __ mov(r2, Operand(undefined_value));
   CallConstructStub stub(NO_CALL_FUNCTION_FLAGS);
-  CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL, instr);
+  CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL,
+           instr->arity() + 1, instr);
 }
 
 
 void LCodeGen::DoCallNewArray(LCallNewArray* instr) {
   ASSERT(ToRegister(instr->constructor()).is(r1));
   ASSERT(ToRegister(instr->result()).is(r0));
 
   __ mov(r0, Operand(instr->arity()));
   __ mov(r2, Operand(instr->hydrogen()->property_cell()));
   ElementsKind kind = instr->hydrogen()->elements_kind();
   AllocationSiteOverrideMode override_mode =
       (AllocationSite::GetMode(kind) == TRACK_ALLOCATION_SITE)
           ? DISABLE_ALLOCATION_SITES
           : DONT_OVERRIDE;
   ContextCheckMode context_mode = CONTEXT_CHECK_NOT_REQUIRED;
 
   if (instr->arity() == 0) {
     ArrayNoArgumentConstructorStub stub(kind, context_mode, override_mode);
-    CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL, instr);
+    CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL,
+             instr->arity() + 1, instr);
   } else if (instr->arity() == 1) {
     Label done;
     if (IsFastPackedElementsKind(kind)) {
       Label packed_case;
       // We might need a change here
       // look at the first argument
       __ ldr(r5, MemOperand(sp, 0));
       __ cmp(r5, Operand::Zero());
       __ b(eq, &packed_case);
 
       ElementsKind holey_kind = GetHoleyElementsKind(kind);
       ArraySingleArgumentConstructorStub stub(holey_kind, context_mode,
                                               override_mode);
-      CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL, instr);
+      CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL,
+               instr->arity() + 1, instr);
       __ jmp(&done);
       __ bind(&packed_case);
+      fp_sp_delta_ += (instr->arity() + 1) * kPointerSize;
     }
 
     ArraySingleArgumentConstructorStub stub(kind, context_mode, override_mode);
-    CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL, instr);
+    CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL,
+             instr->arity() + 1, instr);
     __ bind(&done);
   } else {
     ArrayNArgumentsConstructorStub stub(kind, context_mode, override_mode);
-    CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL, instr);
+    CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL,
+             instr->arity() + 1, instr);
   }
 }
 
 
 void LCodeGen::DoCallRuntime(LCallRuntime* instr) {
   CallRuntime(instr->function(), instr->arity(), instr);
 }
 
 
 void LCodeGen::DoInnerAllocatedObject(LInnerAllocatedObject* instr) {
@@ skipping 91 matching lines @@
 
 void LCodeGen::DoStoreNamedGeneric(LStoreNamedGeneric* instr) {
   ASSERT(ToRegister(instr->object()).is(r1));
   ASSERT(ToRegister(instr->value()).is(r0));
 
   // Name is always in r2.
   __ mov(r2, Operand(instr->name()));
   Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode)
       ? isolate()->builtins()->StoreIC_Initialize_Strict()
       : isolate()->builtins()->StoreIC_Initialize();
-  CallCode(ic, RelocInfo::CODE_TARGET, instr, NEVER_INLINE_TARGET_ADDRESS);
+  CallCode(ic, RelocInfo::CODE_TARGET, 0, instr, NEVER_INLINE_TARGET_ADDRESS);
 }
 
 
 void LCodeGen::ApplyCheckIf(Condition condition, LBoundsCheck* check) {
   if (FLAG_debug_code && check->hydrogen()->skip_check()) {
     Label done;
     __ b(NegateCondition(condition), &done);
     __ stop("eliminated bounds check failed");
     __ bind(&done);
   } else {
@@ skipping 195 matching lines @@
 
 
 void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {
   ASSERT(ToRegister(instr->object()).is(r2));
   ASSERT(ToRegister(instr->key()).is(r1));
   ASSERT(ToRegister(instr->value()).is(r0));
 
   Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode)
       ? isolate()->builtins()->KeyedStoreIC_Initialize_Strict()
       : isolate()->builtins()->KeyedStoreIC_Initialize();
-  CallCode(ic, RelocInfo::CODE_TARGET, instr, NEVER_INLINE_TARGET_ADDRESS);
+  CallCode(ic, RelocInfo::CODE_TARGET, 0, instr, NEVER_INLINE_TARGET_ADDRESS);
 }
 
 
 void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {
   Register object_reg = ToRegister(instr->object());
   Register scratch = scratch0();
 
   Handle<Map> from_map = instr->original_map();
   Handle<Map> to_map = instr->transitioned_map();
   ElementsKind from_kind = instr->from_kind();
@@ skipping 27 matching lines @@
 
 void LCodeGen::DoTrapAllocationMemento(LTrapAllocationMemento* instr) {
   Register object = ToRegister(instr->object());
   Register temp = ToRegister(instr->temp());
   __ TestJSArrayForAllocationMemento(object, temp);
   DeoptimizeIf(eq, instr->environment());
 }
 
 
 void LCodeGen::DoStringAdd(LStringAdd* instr) {
-  __ push(ToRegister(instr->left()));
-  __ push(ToRegister(instr->right()));
+  Push(ToRegister(instr->left()));
+  Push(ToRegister(instr->right()));
   StringAddStub stub(instr->hydrogen()->flags());
-  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 2, instr);
 }
 
 
 void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
   class DeferredStringCharCodeAt: public LDeferredCode {
    public:
     DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     virtual void Generate() { codegen()->DoDeferredStringCharCodeAt(instr_); }
     virtual LInstruction* instr() { return instr_; }
@@ skipping 17 matching lines @@
   Register string = ToRegister(instr->string());
   Register result = ToRegister(instr->result());
   Register scratch = scratch0();
 
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   __ mov(result, Operand::Zero());
 
   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
-  __ push(string);
+  Push(string);
   // Push the index as a smi. This is safe because of the checks in
   // DoStringCharCodeAt above.
   if (instr->index()->IsConstantOperand()) {
     int const_index = ToInteger32(LConstantOperand::cast(instr->index()));
     __ mov(scratch, Operand(Smi::FromInt(const_index)));
-    __ push(scratch);
+    Push(scratch);
   } else {
     Register index = ToRegister(instr->index());
     __ SmiTag(index);
-    __ push(index);
+    Push(index);
   }
   CallRuntimeFromDeferred(Runtime::kStringCharCodeAt, 2, instr);
   __ AssertSmi(r0);
   __ SmiUntag(r0);
   __ StoreToSafepointRegisterSlot(r0, result);
 }
 
 
 void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
   class DeferredStringCharFromCode: public LDeferredCode {
@@ skipping 30 matching lines @@
   Register char_code = ToRegister(instr->char_code());
   Register result = ToRegister(instr->result());
 
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   __ mov(result, Operand::Zero());
 
   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
   __ SmiTag(char_code);
-  __ push(char_code);
+  Push(char_code);
   CallRuntimeFromDeferred(Runtime::kCharFromCode, 1, instr);
   __ StoreToSafepointRegisterSlot(r0, result);
 }
 
 
 void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {
   LOperand* input = instr->value();
   ASSERT(input->IsRegister() || input->IsStackSlot());
   LOperand* output = instr->result();
   ASSERT(output->IsDoubleRegister());
@@ skipping 710 matching lines @@
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   __ mov(result, Operand(Smi::FromInt(0)));
 
   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
   if (instr->size()->IsRegister()) {
     Register size = ToRegister(instr->size());
     ASSERT(!size.is(result));
     __ SmiTag(size);
-    __ push(size);
+    Push(size);
   } else {
     int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
     __ Push(Smi::FromInt(size));
   }
 
   if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {
     ASSERT(!instr->hydrogen()->IsOldDataSpaceAllocation());
     ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
     CallRuntimeFromDeferred(Runtime::kAllocateInOldPointerSpace, 1, instr);
   } else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {
     ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
     CallRuntimeFromDeferred(Runtime::kAllocateInOldDataSpace, 1, instr);
   } else {
     CallRuntimeFromDeferred(Runtime::kAllocateInNewSpace, 1, instr);
   }
   __ StoreToSafepointRegisterSlot(r0, result);
 }
 
 
 void LCodeGen::DoToFastProperties(LToFastProperties* instr) {
   ASSERT(ToRegister(instr->value()).is(r0));
-  __ push(r0);
+  Push(r0);
   CallRuntime(Runtime::kToFastProperties, 1, instr);
 }
 
 
 void LCodeGen::DoRegExpLiteral(LRegExpLiteral* instr) {
   Label materialized;
   // Registers will be used as follows:
   // r7 = literals array.
   // r1 = regexp literal.
   // r0 = regexp literal clone.
   // r2 and r4-r6 are used as temporaries.
   int literal_offset =
       FixedArray::OffsetOfElementAt(instr->hydrogen()->literal_index());
   __ LoadHeapObject(r7, instr->hydrogen()->literals());
   __ ldr(r1, FieldMemOperand(r7, literal_offset));
   __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
   __ cmp(r1, ip);
   __ b(ne, &materialized);
 
   // Create regexp literal using runtime function
   // Result will be in r0.
   __ mov(r6, Operand(Smi::FromInt(instr->hydrogen()->literal_index())));
   __ mov(r5, Operand(instr->hydrogen()->pattern()));
   __ mov(r4, Operand(instr->hydrogen()->flags()));
-  __ Push(r7, r6, r5, r4);
+  Push(r7, r6, r5, r4);
   CallRuntime(Runtime::kMaterializeRegExpLiteral, 4, instr);
   __ mov(r1, r0);
 
   __ bind(&materialized);
   int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
   Label allocated, runtime_allocate;
 
   __ Allocate(size, r0, r2, r3, &runtime_allocate, TAG_OBJECT);
   __ jmp(&allocated);
 
   __ bind(&runtime_allocate);
   __ mov(r0, Operand(Smi::FromInt(size)));
-  __ Push(r1, r0);
+  Push(r1, r0);
   CallRuntime(Runtime::kAllocateInNewSpace, 1, instr);
   __ pop(r1);
+  fp_sp_delta_ -= kPointerSize;
 
   __ bind(&allocated);
   // Copy the content into the newly allocated memory.
   __ CopyFields(r0, r1, double_scratch0(), size / kPointerSize);
 }
 
 
 void LCodeGen::DoFunctionLiteral(LFunctionLiteral* instr) {
   // Use the fast case closure allocation code that allocates in new
   // space for nested functions that don't need literals cloning.
   bool pretenure = instr->hydrogen()->pretenure();
   if (!pretenure && instr->hydrogen()->has_no_literals()) {
     FastNewClosureStub stub(instr->hydrogen()->language_mode(),
                             instr->hydrogen()->is_generator());
     __ mov(r1, Operand(instr->hydrogen()->shared_info()));
-    __ push(r1);
-    CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+    Push(r1);
+    CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 1, instr);
   } else {
     __ mov(r2, Operand(instr->hydrogen()->shared_info()));
     __ mov(r1, Operand(pretenure ? factory()->true_value()
                                  : factory()->false_value()));
-    __ Push(cp, r2, r1);
+    Push(cp, r2, r1);
     CallRuntime(Runtime::kNewClosure, 3, instr);
   }
 }
 
 
 void LCodeGen::DoTypeof(LTypeof* instr) {
   Register input = ToRegister(instr->value());
-  __ push(input);
+  Push(input);
   CallRuntime(Runtime::kTypeof, 1, instr);
 }
 
 
 void LCodeGen::DoTypeofIsAndBranch(LTypeofIsAndBranch* instr) {
   Register input = ToRegister(instr->value());
 
   Condition final_branch_condition = EmitTypeofIs(instr->TrueLabel(chunk_),
                                                   instr->FalseLabel(chunk_),
                                                   input,
@@ skipping 184 matching lines @@
   // There is no LLazyBailout instruction for stack-checks. We have to
   // prepare for lazy deoptimization explicitly here.
   if (instr->hydrogen()->is_function_entry()) {
     // Perform stack overflow check.
     Label done;
     __ LoadRoot(ip, Heap::kStackLimitRootIndex);
     __ cmp(sp, Operand(ip));
     __ b(hs, &done);
     StackCheckStub stub;
     PredictableCodeSizeScope predictable(masm_, 2 * Assembler::kInstrSize);
-    CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+    CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 0, instr);
     EnsureSpaceForLazyDeopt();
     last_lazy_deopt_pc_ = masm()->pc_offset();
     __ bind(&done);
     RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt);
     safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
   } else {
     ASSERT(instr->hydrogen()->is_backwards_branch());
     // Perform stack overflow check if this goto needs it before jumping.
     DeferredStackCheck* deferred_stack_check =
         new(zone()) DeferredStackCheck(this, instr);
@@ skipping 47 matching lines @@
   DeoptimizeIf(le, instr->environment());
 
   Label use_cache, call_runtime;
   __ CheckEnumCache(null_value, &call_runtime);
 
   __ ldr(r0, FieldMemOperand(r0, HeapObject::kMapOffset));
   __ b(&use_cache);
 
   // Get the set of properties to enumerate.
   __ bind(&call_runtime);
-  __ push(r0);
+  Push(r0);
   CallRuntime(Runtime::kGetPropertyNamesFast, 1, instr);
 
   __ ldr(r1, FieldMemOperand(r0, HeapObject::kMapOffset));
   __ LoadRoot(ip, Heap::kMetaMapRootIndex);
   __ cmp(r1, ip);
   DeoptimizeIf(ne, instr->environment());
   __ bind(&use_cache);
 }
 
 
@@ skipping 51 matching lines @@
   __ sub(scratch, result, Operand::PointerOffsetFromSmiKey(index));
   __ ldr(result, FieldMemOperand(scratch,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal