d25c36deee
The calling convention for keyed store IC on ARM is changed to receive the arguments value, key and receiver in registers r0, r1 and r2 instead of on the stack. When calling keyed store IC with a virtual frame the arguments are passed through the virtual frame and consumed by the call. Changed the register usage in the IC code to postpone spilling the registers holding value, key and receiver to the stack until making a call into the runtime system. Runs all the tests with: --special-command="@ --nofull-compiler" --special-command="@ --always-full-compiler" --special-command="@ --noenable-vfp3" Review URL: http://codereview.chromium.org/2116003 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@4668 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
245 lines
8.4 KiB
C++
245 lines
8.4 KiB
C++
// 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
|
|
// with the distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#include "v8.h"
|
|
|
|
#if defined(V8_TARGET_ARCH_ARM)
|
|
|
|
#include "codegen-inl.h"
|
|
#include "debug.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
|
bool BreakLocationIterator::IsDebugBreakAtReturn() {
|
|
return Debug::IsDebugBreakAtReturn(rinfo());
|
|
}
|
|
|
|
|
|
void BreakLocationIterator::SetDebugBreakAtReturn() {
|
|
// Patch the code changing the return from JS function sequence from
|
|
// mov sp, fp
|
|
// ldmia sp!, {fp, lr}
|
|
// add sp, sp, #4
|
|
// bx lr
|
|
// to a call to the debug break return code.
|
|
// #if USE_BLX
|
|
// ldr ip, [pc, #0]
|
|
// blx ip
|
|
// #else
|
|
// mov lr, pc
|
|
// ldr pc, [pc, #-4]
|
|
// #endif
|
|
// <debug break return code entry point address>
|
|
// bktp 0
|
|
CodePatcher patcher(rinfo()->pc(), 4);
|
|
#ifdef USE_BLX
|
|
patcher.masm()->ldr(v8::internal::ip, MemOperand(v8::internal::pc, 0));
|
|
patcher.masm()->blx(v8::internal::ip);
|
|
#else
|
|
patcher.masm()->mov(v8::internal::lr, v8::internal::pc);
|
|
patcher.masm()->ldr(v8::internal::pc, MemOperand(v8::internal::pc, -4));
|
|
#endif
|
|
patcher.Emit(Debug::debug_break_return()->entry());
|
|
patcher.masm()->bkpt(0);
|
|
}
|
|
|
|
|
|
// Restore the JS frame exit code.
|
|
void BreakLocationIterator::ClearDebugBreakAtReturn() {
|
|
rinfo()->PatchCode(original_rinfo()->pc(),
|
|
Assembler::kJSReturnSequenceLength);
|
|
}
|
|
|
|
|
|
// A debug break in the exit code is identified by a call.
|
|
bool Debug::IsDebugBreakAtReturn(RelocInfo* rinfo) {
|
|
ASSERT(RelocInfo::IsJSReturn(rinfo->rmode()));
|
|
return rinfo->IsPatchedReturnSequence();
|
|
}
|
|
|
|
|
|
#define __ ACCESS_MASM(masm)
|
|
|
|
|
|
static void Generate_DebugBreakCallHelper(MacroAssembler* masm,
|
|
RegList pointer_regs) {
|
|
// Save the content of all general purpose registers in memory. This copy in
|
|
// memory is later pushed onto the JS expression stack for the fake JS frame
|
|
// generated and also to the C frame generated on top of that. In the JS
|
|
// frame ONLY the registers containing pointers will be pushed on the
|
|
// expression stack. This causes the GC to update these pointers so that
|
|
// they will have the correct value when returning from the debugger.
|
|
__ SaveRegistersToMemory(kJSCallerSaved);
|
|
|
|
__ EnterInternalFrame();
|
|
|
|
// Store the registers containing object pointers on the expression stack to
|
|
// make sure that these are correctly updated during GC.
|
|
// Use sp as base to push.
|
|
__ CopyRegistersFromMemoryToStack(sp, pointer_regs);
|
|
|
|
#ifdef DEBUG
|
|
__ RecordComment("// Calling from debug break to runtime - come in - over");
|
|
#endif
|
|
__ mov(r0, Operand(0)); // no arguments
|
|
__ mov(r1, Operand(ExternalReference::debug_break()));
|
|
|
|
CEntryStub ceb(1, ExitFrame::MODE_DEBUG);
|
|
__ CallStub(&ceb);
|
|
|
|
// Restore the register values containing object pointers from the expression
|
|
// stack in the reverse order as they where pushed.
|
|
// Use sp as base to pop.
|
|
__ CopyRegistersFromStackToMemory(sp, r3, pointer_regs);
|
|
|
|
__ LeaveInternalFrame();
|
|
|
|
// Finally restore all registers.
|
|
__ RestoreRegistersFromMemory(kJSCallerSaved);
|
|
|
|
// Now that the break point has been handled, resume normal execution by
|
|
// jumping to the target address intended by the caller and that was
|
|
// overwritten by the address of DebugBreakXXX.
|
|
__ mov(ip, Operand(ExternalReference(Debug_Address::AfterBreakTarget())));
|
|
__ ldr(ip, MemOperand(ip));
|
|
__ Jump(ip);
|
|
}
|
|
|
|
|
|
void Debug::GenerateLoadICDebugBreak(MacroAssembler* masm) {
|
|
// Calling convention for IC load (from ic-arm.cc).
|
|
// ----------- S t a t e -------------
|
|
// -- r2 : name
|
|
// -- lr : return address
|
|
// -- r0 : receiver
|
|
// -- [sp] : receiver
|
|
// -----------------------------------
|
|
// Registers r0 and r2 contain objects that need to be pushed on the
|
|
// expression stack of the fake JS frame.
|
|
Generate_DebugBreakCallHelper(masm, r0.bit() | r2.bit());
|
|
}
|
|
|
|
|
|
void Debug::GenerateStoreICDebugBreak(MacroAssembler* masm) {
|
|
// Calling convention for IC store (from ic-arm.cc).
|
|
// ----------- S t a t e -------------
|
|
// -- r0 : value
|
|
// -- r1 : receiver
|
|
// -- r2 : name
|
|
// -- lr : return address
|
|
// -----------------------------------
|
|
// Registers r0, r1, and r2 contain objects that need to be pushed on the
|
|
// expression stack of the fake JS frame.
|
|
Generate_DebugBreakCallHelper(masm, r0.bit() | r1.bit() | r2.bit());
|
|
}
|
|
|
|
|
|
void Debug::GenerateKeyedLoadICDebugBreak(MacroAssembler* masm) {
|
|
// ---------- S t a t e --------------
|
|
// -- lr : return address
|
|
// -- r0 : key
|
|
// -- sp[0] : key
|
|
// -- sp[4] : receiver
|
|
Generate_DebugBreakCallHelper(masm, r0.bit());
|
|
}
|
|
|
|
|
|
void Debug::GenerateKeyedStoreICDebugBreak(MacroAssembler* masm) {
|
|
// ---------- S t a t e --------------
|
|
// -- r0 : value
|
|
// -- r1 : key
|
|
// -- r2 : receiver
|
|
// -- lr : return address
|
|
Generate_DebugBreakCallHelper(masm, r0.bit() | r1.bit() | r2.bit());
|
|
}
|
|
|
|
|
|
void Debug::GenerateCallICDebugBreak(MacroAssembler* masm) {
|
|
// Calling convention for IC call (from ic-arm.cc)
|
|
// ----------- S t a t e -------------
|
|
// -- r0: number of arguments
|
|
// -- r1: receiver
|
|
// -- lr: return address
|
|
// -----------------------------------
|
|
// Register r1 contains an object that needs to be pushed on the expression
|
|
// stack of the fake JS frame. r0 is the actual number of arguments not
|
|
// encoded as a smi, therefore it cannot be on the expression stack of the
|
|
// fake JS frame as it can easily be an invalid pointer (e.g. 1). r0 will be
|
|
// pushed on the stack of the C frame and restored from there.
|
|
Generate_DebugBreakCallHelper(masm, r1.bit());
|
|
}
|
|
|
|
|
|
void Debug::GenerateConstructCallDebugBreak(MacroAssembler* masm) {
|
|
// In places other than IC call sites it is expected that r0 is TOS which
|
|
// is an object - this is not generally the case so this should be used with
|
|
// care.
|
|
Generate_DebugBreakCallHelper(masm, r0.bit());
|
|
}
|
|
|
|
|
|
void Debug::GenerateReturnDebugBreak(MacroAssembler* masm) {
|
|
// In places other than IC call sites it is expected that r0 is TOS which
|
|
// is an object - this is not generally the case so this should be used with
|
|
// care.
|
|
Generate_DebugBreakCallHelper(masm, r0.bit());
|
|
}
|
|
|
|
|
|
void Debug::GenerateStubNoRegistersDebugBreak(MacroAssembler* masm) {
|
|
// ----------- S t a t e -------------
|
|
// No registers used on entry.
|
|
// -----------------------------------
|
|
Generate_DebugBreakCallHelper(masm, 0);
|
|
}
|
|
|
|
|
|
void Debug::GeneratePlainReturnLiveEdit(MacroAssembler* masm) {
|
|
masm->Abort("LiveEdit frame dropping is not supported on arm");
|
|
}
|
|
|
|
void Debug::GenerateFrameDropperLiveEdit(MacroAssembler* masm) {
|
|
masm->Abort("LiveEdit frame dropping is not supported on arm");
|
|
}
|
|
|
|
#undef __
|
|
|
|
|
|
void Debug::SetUpFrameDropperFrame(StackFrame* bottom_js_frame,
|
|
Handle<Code> code) {
|
|
UNREACHABLE();
|
|
}
|
|
const int Debug::kFrameDropperFrameSize = -1;
|
|
|
|
#endif // ENABLE_DEBUGGER_SUPPORT
|
|
|
|
} } // namespace v8::internal
|
|
|
|
#endif // V8_TARGET_ARCH_ARM
|