634fb9152c
Added support for more precise break points when debugging and stepping. To achieve that additional nop instructions are inserted where breaking would otherwise be impossible. The number of nop instructions inserted are sufficient to make place for patching with a call to a debug break code stub. On Intel that is 5 nop's for 32-bit and 13 for 64-bit. Om ARM 3 nop instructions (12 bytes) are required. In order to avoid inserting nop's in to many places a simple ast checker have been added to check whether there are breakable code in a statement or expression. If it is possible to break in an expression no additional break enabeling code is inserted. Added break locations to the true and false part of a conditional expression. Added stepping tests to cover more constructs. These changes are only in the full compiler. Changed the default value for the option --debugger in teh d8 shell from true to false. The reason for this is that with --debugger turned on the full compiler will be used for all code in when running d8, which can be unexpeceted. Review URL: http://codereview.chromium.org/2693002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@4820 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
308 lines
10 KiB
C++
308 lines
10 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(), Assembler::kJSReturnSequenceInstructions);
|
|
#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::kJSReturnSequenceInstructions);
|
|
}
|
|
|
|
|
|
// A debug break in the frame exit code is identified by the JS frame exit code
|
|
// having been patched with a call instruction.
|
|
bool Debug::IsDebugBreakAtReturn(RelocInfo* rinfo) {
|
|
ASSERT(RelocInfo::IsJSReturn(rinfo->rmode()));
|
|
return rinfo->IsPatchedReturnSequence();
|
|
}
|
|
|
|
|
|
bool BreakLocationIterator::IsDebugBreakAtSlot() {
|
|
ASSERT(IsDebugBreakSlot());
|
|
// Check whether the debug break slot instructions have been patched.
|
|
return rinfo()->IsPatchedDebugBreakSlotSequence();
|
|
}
|
|
|
|
|
|
void BreakLocationIterator::SetDebugBreakAtSlot() {
|
|
ASSERT(IsDebugBreakSlot());
|
|
// Patch the code changing the debug break slot code from
|
|
// mov r2, r2
|
|
// mov r2, r2
|
|
// mov r2, r2
|
|
// to a call to the debug break slot code.
|
|
// #if USE_BLX
|
|
// ldr ip, [pc, #0]
|
|
// blx ip
|
|
// #else
|
|
// mov lr, pc
|
|
// ldr pc, [pc, #-4]
|
|
// #endif
|
|
// <debug break slot code entry point address>
|
|
CodePatcher patcher(rinfo()->pc(), Assembler::kDebugBreakSlotInstructions);
|
|
#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());
|
|
}
|
|
|
|
|
|
void BreakLocationIterator::ClearDebugBreakAtSlot() {
|
|
ASSERT(IsDebugBreakSlot());
|
|
rinfo()->PatchCode(original_rinfo()->pc(),
|
|
Assembler::kDebugBreakSlotInstructions);
|
|
}
|
|
|
|
|
|
#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::GenerateSlot(MacroAssembler* masm) {
|
|
// Generate enough nop's to make space for a call instruction.
|
|
Label check_codesize;
|
|
__ bind(&check_codesize);
|
|
__ RecordDebugBreakSlot();
|
|
for (int i = 0; i < Assembler::kDebugBreakSlotInstructions; i++) {
|
|
__ nop(2);
|
|
}
|
|
ASSERT_EQ(Assembler::kDebugBreakSlotInstructions,
|
|
masm->InstructionsGeneratedSince(&check_codesize));
|
|
}
|
|
|
|
|
|
void Debug::GenerateSlotDebugBreak(MacroAssembler* masm) {
|
|
// In the places where a debug break slot is inserted no registers can contain
|
|
// object pointers.
|
|
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
|