1// Copyright 2011 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6//     * Redistributions of source code must retain the above copyright
7//       notice, this list of conditions and the following disclaimer.
8//     * Redistributions in binary form must reproduce the above
9//       copyright notice, this list of conditions and the following
10//       disclaimer in the documentation and/or other materials provided
11//       with the distribution.
12//     * Neither the name of Google Inc. nor the names of its
13//       contributors may be used to endorse or promote products derived
14//       from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#include "v8.h"
29
30#if defined(V8_TARGET_ARCH_ARM)
31
32#include "codegen.h"
33#include "debug.h"
34
35namespace v8 {
36namespace internal {
37
38#ifdef ENABLE_DEBUGGER_SUPPORT
39bool BreakLocationIterator::IsDebugBreakAtReturn() {
40  return Debug::IsDebugBreakAtReturn(rinfo());
41}
42
43
44void BreakLocationIterator::SetDebugBreakAtReturn() {
45  // Patch the code changing the return from JS function sequence from
46  //   mov sp, fp
47  //   ldmia sp!, {fp, lr}
48  //   add sp, sp, #4
49  //   bx lr
50  // to a call to the debug break return code.
51  // #if USE_BLX
52  //   ldr ip, [pc, #0]
53  //   blx ip
54  // #else
55  //   mov lr, pc
56  //   ldr pc, [pc, #-4]
57  // #endif
58  //   <debug break return code entry point address>
59  //   bktp 0
60  CodePatcher patcher(rinfo()->pc(), Assembler::kJSReturnSequenceInstructions);
61#ifdef USE_BLX
62  patcher.masm()->ldr(v8::internal::ip, MemOperand(v8::internal::pc, 0));
63  patcher.masm()->blx(v8::internal::ip);
64#else
65  patcher.masm()->mov(v8::internal::lr, v8::internal::pc);
66  patcher.masm()->ldr(v8::internal::pc, MemOperand(v8::internal::pc, -4));
67#endif
68  patcher.Emit(Isolate::Current()->debug()->debug_break_return()->entry());
69  patcher.masm()->bkpt(0);
70}
71
72
73// Restore the JS frame exit code.
74void BreakLocationIterator::ClearDebugBreakAtReturn() {
75  rinfo()->PatchCode(original_rinfo()->pc(),
76                     Assembler::kJSReturnSequenceInstructions);
77}
78
79
80// A debug break in the frame exit code is identified by the JS frame exit code
81// having been patched with a call instruction.
82bool Debug::IsDebugBreakAtReturn(RelocInfo* rinfo) {
83  ASSERT(RelocInfo::IsJSReturn(rinfo->rmode()));
84  return rinfo->IsPatchedReturnSequence();
85}
86
87
88bool BreakLocationIterator::IsDebugBreakAtSlot() {
89  ASSERT(IsDebugBreakSlot());
90  // Check whether the debug break slot instructions have been patched.
91  return rinfo()->IsPatchedDebugBreakSlotSequence();
92}
93
94
95void BreakLocationIterator::SetDebugBreakAtSlot() {
96  ASSERT(IsDebugBreakSlot());
97  // Patch the code changing the debug break slot code from
98  //   mov r2, r2
99  //   mov r2, r2
100  //   mov r2, r2
101  // to a call to the debug break slot code.
102  // #if USE_BLX
103  //   ldr ip, [pc, #0]
104  //   blx ip
105  // #else
106  //   mov lr, pc
107  //   ldr pc, [pc, #-4]
108  // #endif
109  //   <debug break slot code entry point address>
110  CodePatcher patcher(rinfo()->pc(), Assembler::kDebugBreakSlotInstructions);
111#ifdef USE_BLX
112  patcher.masm()->ldr(v8::internal::ip, MemOperand(v8::internal::pc, 0));
113  patcher.masm()->blx(v8::internal::ip);
114#else
115  patcher.masm()->mov(v8::internal::lr, v8::internal::pc);
116  patcher.masm()->ldr(v8::internal::pc, MemOperand(v8::internal::pc, -4));
117#endif
118  patcher.Emit(Isolate::Current()->debug()->debug_break_slot()->entry());
119}
120
121
122void BreakLocationIterator::ClearDebugBreakAtSlot() {
123  ASSERT(IsDebugBreakSlot());
124  rinfo()->PatchCode(original_rinfo()->pc(),
125                     Assembler::kDebugBreakSlotInstructions);
126}
127
128
129#define __ ACCESS_MASM(masm)
130
131
132static void Generate_DebugBreakCallHelper(MacroAssembler* masm,
133                                          RegList object_regs,
134                                          RegList non_object_regs) {
135  {
136    FrameScope scope(masm, StackFrame::INTERNAL);
137
138    // Store the registers containing live values on the expression stack to
139    // make sure that these are correctly updated during GC. Non object values
140    // are stored as a smi causing it to be untouched by GC.
141    ASSERT((object_regs & ~kJSCallerSaved) == 0);
142    ASSERT((non_object_regs & ~kJSCallerSaved) == 0);
143    ASSERT((object_regs & non_object_regs) == 0);
144    if ((object_regs | non_object_regs) != 0) {
145      for (int i = 0; i < kNumJSCallerSaved; i++) {
146        int r = JSCallerSavedCode(i);
147        Register reg = { r };
148        if ((non_object_regs & (1 << r)) != 0) {
149          if (FLAG_debug_code) {
150            __ tst(reg, Operand(0xc0000000));
151            __ Assert(eq, "Unable to encode value as smi");
152          }
153          __ mov(reg, Operand(reg, LSL, kSmiTagSize));
154        }
155      }
156      __ stm(db_w, sp, object_regs | non_object_regs);
157    }
158
159#ifdef DEBUG
160    __ RecordComment("// Calling from debug break to runtime - come in - over");
161#endif
162    __ mov(r0, Operand(0, RelocInfo::NONE));  // no arguments
163    __ mov(r1, Operand(ExternalReference::debug_break(masm->isolate())));
164
165    CEntryStub ceb(1);
166    __ CallStub(&ceb);
167
168    // Restore the register values from the expression stack.
169    if ((object_regs | non_object_regs) != 0) {
170      __ ldm(ia_w, sp, object_regs | non_object_regs);
171      for (int i = 0; i < kNumJSCallerSaved; i++) {
172        int r = JSCallerSavedCode(i);
173        Register reg = { r };
174        if ((non_object_regs & (1 << r)) != 0) {
175          __ mov(reg, Operand(reg, LSR, kSmiTagSize));
176        }
177        if (FLAG_debug_code &&
178            (((object_regs |non_object_regs) & (1 << r)) == 0)) {
179          __ mov(reg, Operand(kDebugZapValue));
180        }
181      }
182    }
183
184    // Leave the internal frame.
185  }
186
187  // Now that the break point has been handled, resume normal execution by
188  // jumping to the target address intended by the caller and that was
189  // overwritten by the address of DebugBreakXXX.
190  ExternalReference after_break_target =
191      ExternalReference(Debug_Address::AfterBreakTarget(), masm->isolate());
192  __ mov(ip, Operand(after_break_target));
193  __ ldr(ip, MemOperand(ip));
194  __ Jump(ip);
195}
196
197
198void Debug::GenerateLoadICDebugBreak(MacroAssembler* masm) {
199  // Calling convention for IC load (from ic-arm.cc).
200  // ----------- S t a t e -------------
201  //  -- r2    : name
202  //  -- lr    : return address
203  //  -- r0    : receiver
204  //  -- [sp]  : receiver
205  // -----------------------------------
206  // Registers r0 and r2 contain objects that need to be pushed on the
207  // expression stack of the fake JS frame.
208  Generate_DebugBreakCallHelper(masm, r0.bit() | r2.bit(), 0);
209}
210
211
212void Debug::GenerateStoreICDebugBreak(MacroAssembler* masm) {
213  // Calling convention for IC store (from ic-arm.cc).
214  // ----------- S t a t e -------------
215  //  -- r0    : value
216  //  -- r1    : receiver
217  //  -- r2    : name
218  //  -- lr    : return address
219  // -----------------------------------
220  // Registers r0, r1, and r2 contain objects that need to be pushed on the
221  // expression stack of the fake JS frame.
222  Generate_DebugBreakCallHelper(masm, r0.bit() | r1.bit() | r2.bit(), 0);
223}
224
225
226void Debug::GenerateKeyedLoadICDebugBreak(MacroAssembler* masm) {
227  // ---------- S t a t e --------------
228  //  -- lr     : return address
229  //  -- r0     : key
230  //  -- r1     : receiver
231  Generate_DebugBreakCallHelper(masm, r0.bit() | r1.bit(), 0);
232}
233
234
235void Debug::GenerateKeyedStoreICDebugBreak(MacroAssembler* masm) {
236  // ---------- S t a t e --------------
237  //  -- r0     : value
238  //  -- r1     : key
239  //  -- r2     : receiver
240  //  -- lr     : return address
241  Generate_DebugBreakCallHelper(masm, r0.bit() | r1.bit() | r2.bit(), 0);
242}
243
244
245void Debug::GenerateCallICDebugBreak(MacroAssembler* masm) {
246  // Calling convention for IC call (from ic-arm.cc)
247  // ----------- S t a t e -------------
248  //  -- r2     : name
249  // -----------------------------------
250  Generate_DebugBreakCallHelper(masm, r2.bit(), 0);
251}
252
253
254void Debug::GenerateReturnDebugBreak(MacroAssembler* masm) {
255  // In places other than IC call sites it is expected that r0 is TOS which
256  // is an object - this is not generally the case so this should be used with
257  // care.
258  Generate_DebugBreakCallHelper(masm, r0.bit(), 0);
259}
260
261
262void Debug::GenerateCallFunctionStubDebugBreak(MacroAssembler* masm) {
263  // Register state for CallFunctionStub (from code-stubs-arm.cc).
264  // ----------- S t a t e -------------
265  //  -- r1 : function
266  // -----------------------------------
267  Generate_DebugBreakCallHelper(masm, r1.bit(), 0);
268}
269
270
271void Debug::GenerateCallFunctionStubRecordDebugBreak(MacroAssembler* masm) {
272  // Register state for CallFunctionStub (from code-stubs-arm.cc).
273  // ----------- S t a t e -------------
274  //  -- r1 : function
275  //  -- r2 : cache cell for call target
276  // -----------------------------------
277  Generate_DebugBreakCallHelper(masm, r1.bit() | r2.bit(), 0);
278}
279
280
281void Debug::GenerateCallConstructStubDebugBreak(MacroAssembler* masm) {
282  // Calling convention for CallConstructStub (from code-stubs-arm.cc)
283  // ----------- S t a t e -------------
284  //  -- r0     : number of arguments (not smi)
285  //  -- r1     : constructor function
286  // -----------------------------------
287  Generate_DebugBreakCallHelper(masm, r1.bit(), r0.bit());
288}
289
290
291void Debug::GenerateCallConstructStubRecordDebugBreak(MacroAssembler* masm) {
292  // Calling convention for CallConstructStub (from code-stubs-arm.cc)
293  // ----------- S t a t e -------------
294  //  -- r0     : number of arguments (not smi)
295  //  -- r1     : constructor function
296  //  -- r2     : cache cell for call target
297  // -----------------------------------
298  Generate_DebugBreakCallHelper(masm, r1.bit() | r2.bit(), r0.bit());
299}
300
301
302void Debug::GenerateSlot(MacroAssembler* masm) {
303  // Generate enough nop's to make space for a call instruction. Avoid emitting
304  // the constant pool in the debug break slot code.
305  Assembler::BlockConstPoolScope block_const_pool(masm);
306  Label check_codesize;
307  __ bind(&check_codesize);
308  __ RecordDebugBreakSlot();
309  for (int i = 0; i < Assembler::kDebugBreakSlotInstructions; i++) {
310    __ nop(MacroAssembler::DEBUG_BREAK_NOP);
311  }
312  ASSERT_EQ(Assembler::kDebugBreakSlotInstructions,
313            masm->InstructionsGeneratedSince(&check_codesize));
314}
315
316
317void Debug::GenerateSlotDebugBreak(MacroAssembler* masm) {
318  // In the places where a debug break slot is inserted no registers can contain
319  // object pointers.
320  Generate_DebugBreakCallHelper(masm, 0, 0);
321}
322
323
324void Debug::GeneratePlainReturnLiveEdit(MacroAssembler* masm) {
325  masm->Abort("LiveEdit frame dropping is not supported on arm");
326}
327
328
329void Debug::GenerateFrameDropperLiveEdit(MacroAssembler* masm) {
330  masm->Abort("LiveEdit frame dropping is not supported on arm");
331}
332
333const bool Debug::kFrameDropperSupported = false;
334
335#undef __
336
337
338
339#endif  // ENABLE_DEBUGGER_SUPPORT
340
341} }  // namespace v8::internal
342
343#endif  // V8_TARGET_ARCH_ARM
344