From be8e2885d3369992e9952aee02ce526b6ddd8708 Mon Sep 17 00:00:00 2001 From: "m.m.capewell@googlemail.com" Date: Mon, 10 Mar 2014 13:23:28 +0000 Subject: [PATCH] ARM: cleanning of InstanceOfKnownGlobal BUG= R=bmeurer@chromium.org Review URL: https://codereview.chromium.org/189263011 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@19758 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/arm/code-stubs-arm.cc | 19 +++++++++---------- src/arm/lithium-codegen-arm.cc | 23 ++++++----------------- 2 files changed, 15 insertions(+), 27 deletions(-) diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc index b933c4ac65..f661ad80d8 100644 --- a/src/arm/code-stubs-arm.cc +++ b/src/arm/code-stubs-arm.cc @@ -1898,8 +1898,7 @@ void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) { // * function: r1 or at sp. // // An inlined call site may have been generated before calling this stub. -// In this case the offset to the inline site to patch is passed on the stack, -// in the safepoint slot for register r4. +// In this case the offset to the inline site to patch is passed in r5. // (See LCodeGen::DoInstanceOfKnownGlobal) void InstanceofStub::Generate(MacroAssembler* masm) { // Call site inlining and patching implies arguments in registers. @@ -1958,14 +1957,14 @@ void InstanceofStub::Generate(MacroAssembler* masm) { ASSERT(HasArgsInRegisters()); // Patch the (relocated) inlined map check. - // The offset was stored in r4 safepoint slot. - // (See LCodeGen::DoDeferredLInstanceOfKnownGlobal) - __ LoadFromSafepointRegisterSlot(scratch, r4); - __ sub(inline_site, lr, scratch); - // Get the map location in scratch and patch it. - __ GetRelocatedValueLocation(inline_site, scratch); - __ ldr(scratch, MemOperand(scratch)); - __ str(map, FieldMemOperand(scratch, Cell::kValueOffset)); + // The offset was stored in r5 + // (See LCodeGen::DoDeferredLInstanceOfKnownGlobal). + const Register offset = r5; + __ sub(inline_site, lr, offset); + // Get the map location in r5 and patch it. + __ GetRelocatedValueLocation(inline_site, offset); + __ ldr(offset, MemOperand(offset)); + __ str(map, FieldMemOperand(offset, Cell::kValueOffset)); } // Register mapping: r3 is object map and r4 is function prototype. diff --git a/src/arm/lithium-codegen-arm.cc b/src/arm/lithium-codegen-arm.cc index 53d15379a6..b10ed59b1b 100644 --- a/src/arm/lithium-codegen-arm.cc +++ b/src/arm/lithium-codegen-arm.cc @@ -2703,9 +2703,6 @@ void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) { Register temp = ToRegister(instr->temp()); Register result = ToRegister(instr->result()); - ASSERT(object.is(r0)); - ASSERT(result.is(r0)); - // A Smi is not instance of anything. __ JumpIfSmi(object, &false_result); @@ -2763,9 +2760,6 @@ void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) { void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr, Label* map_check) { - Register result = ToRegister(instr->result()); - ASSERT(result.is(r0)); - InstanceofStub::Flags flags = InstanceofStub::kNoFlags; flags = static_cast( flags | InstanceofStub::kArgsInRegisters); @@ -2778,37 +2772,32 @@ void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr, PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters); LoadContextFromDeferred(instr->context()); - // Get the temp register reserved by the instruction. This needs to be r4 as - // its slot of the pushing of safepoint registers is used to communicate the - // offset to the location of the map check. - Register temp = ToRegister(instr->temp()); - ASSERT(temp.is(r4)); __ Move(InstanceofStub::right(), instr->function()); - static const int kAdditionalDelta = 5; + static const int kAdditionalDelta = 4; // Make sure that code size is predicable, since we use specific constants // offsets in the code to find embedded values.. - PredictableCodeSizeScope predictable(masm_, 6 * Assembler::kInstrSize); + PredictableCodeSizeScope predictable(masm_, 5 * Assembler::kInstrSize); int delta = masm_->InstructionsGeneratedSince(map_check) + kAdditionalDelta; Label before_push_delta; __ bind(&before_push_delta); __ BlockConstPoolFor(kAdditionalDelta); - __ mov(temp, Operand(delta * kPointerSize)); + // r5 is used to communicate the offset to the location of the map check. + __ mov(r5, Operand(delta * kPointerSize)); // The mov above can generate one or two instructions. The delta was computed // for two instructions, so we need to pad here in case of one instruction. if (masm_->InstructionsGeneratedSince(&before_push_delta) != 2) { ASSERT_EQ(1, masm_->InstructionsGeneratedSince(&before_push_delta)); __ nop(); } - __ StoreToSafepointRegisterSlot(temp, temp); CallCodeGeneric(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, 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 + // Put the result value (r0) into the result register slot and // restore all registers. - __ StoreToSafepointRegisterSlot(result, result); + __ StoreToSafepointRegisterSlot(r0, ToRegister(instr->result())); }