debug-arm64.cc 12.5 KB
Newer Older
1
// Copyright 2013 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4

5
#include "src/v8.h"
6

7
#if V8_TARGET_ARCH_ARM64
8

9 10
#include "src/codegen.h"
#include "src/debug.h"
11 12 13 14 15 16 17 18

namespace v8 {
namespace internal {


#define __ ACCESS_MASM(masm)


19
void BreakLocation::SetDebugBreakAtReturn() {
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
  // Patch the code emitted by FullCodeGenerator::EmitReturnSequence, changing
  // the return from JS function sequence from
  //   mov sp, fp
  //   ldp fp, lr, [sp] #16
  //   lrd ip0, [pc, #(3 * kInstructionSize)]
  //   add sp, sp, ip0
  //   ret
  //   <number of paramters ...
  //    ... plus one (64 bits)>
  // to a call to the debug break return code.
  //   ldr ip0, [pc, #(3 * kInstructionSize)]
  //   blr ip0
  //   hlt kHltBadCode    @ code should not return, catch if it does.
  //   <debug break return code ...
  //    ... entry point address (64 bits)>

  // The patching code must not overflow the space occupied by the return
  // sequence.
38 39
  STATIC_ASSERT(Assembler::kJSReturnSequenceInstructions >= 5);
  PatchingAssembler patcher(reinterpret_cast<Instruction*>(pc()), 5);
40
  byte* entry =
41
      debug_info_->GetIsolate()->builtins()->Return_DebugBreak()->entry();
42 43 44

  // The first instruction of a patched return sequence must be a load literal
  // loading the address of the debug break return code.
45
  patcher.ldr_pcrel(ip0, (3 * kInstructionSize) >> kLoadLiteralScaleLog2);
46 47 48 49 50 51 52 53 54 55 56 57
  // TODO(all): check the following is correct.
  // The debug break return code will push a frame and call statically compiled
  // code. By using blr, even though control will not return after the branch,
  // this call site will be registered in the frame (lr being saved as the pc
  // of the next instruction to execute for this frame). The debugger can now
  // iterate on the frames to find call to debug break return code.
  patcher.blr(ip0);
  patcher.hlt(kHltBadCode);
  patcher.dc64(reinterpret_cast<int64_t>(entry));
}


58
void BreakLocation::SetDebugBreakAtSlot() {
59 60
  // Patch the code emitted by DebugCodegen::GenerateSlots, changing the debug
  // break slot code from
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
  //   mov x0, x0    @ nop DEBUG_BREAK_NOP
  //   mov x0, x0    @ nop DEBUG_BREAK_NOP
  //   mov x0, x0    @ nop DEBUG_BREAK_NOP
  //   mov x0, x0    @ nop DEBUG_BREAK_NOP
  // to a call to the debug slot code.
  //   ldr ip0, [pc, #(2 * kInstructionSize)]
  //   blr ip0
  //   <debug break slot code ...
  //    ... entry point address (64 bits)>

  // TODO(all): consider adding a hlt instruction after the blr as we don't
  // expect control to return here. This implies increasing
  // kDebugBreakSlotInstructions to 5 instructions.

  // The patching code must not overflow the space occupied by the return
  // sequence.
  STATIC_ASSERT(Assembler::kDebugBreakSlotInstructions >= 4);
78
  PatchingAssembler patcher(reinterpret_cast<Instruction*>(pc()), 4);
79
  byte* entry =
80
      debug_info_->GetIsolate()->builtins()->Slot_DebugBreak()->entry();
81 82 83

  // The first instruction of a patched debug break slot must be a load literal
  // loading the address of the debug break slot code.
84
  patcher.ldr_pcrel(ip0, (2 * kInstructionSize) >> kLoadLiteralScaleLog2);
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
  // TODO(all): check the following is correct.
  // The debug break slot code will push a frame and call statically compiled
  // code. By using blr, event hough control will not return after the branch,
  // this call site will be registered in the frame (lr being saved as the pc
  // of the next instruction to execute for this frame). The debugger can now
  // iterate on the frames to find call to debug break slot code.
  patcher.blr(ip0);
  patcher.dc64(reinterpret_cast<int64_t>(entry));
}


static void Generate_DebugBreakCallHelper(MacroAssembler* masm,
                                          RegList object_regs,
                                          RegList non_object_regs,
                                          Register scratch) {
  {
    FrameScope scope(masm, StackFrame::INTERNAL);

103
    // Load padding words on stack.
104 105 106 107
    __ Mov(scratch, Smi::FromInt(LiveEdit::kFramePaddingValue));
    __ PushMultipleTimes(scratch, LiveEdit::kFramePaddingInitialSize);
    __ Mov(scratch, Smi::FromInt(LiveEdit::kFramePaddingInitialSize));
    __ Push(scratch);
108

109 110 111 112 113 114 115 116 117 118 119 120 121
    // Any live values (object_regs and non_object_regs) in caller-saved
    // registers (or lr) need to be stored on the stack so that their values are
    // safely preserved for a call into C code.
    //
    // Also:
    //  * object_regs may be modified during the C code by the garbage
    //    collector. Every object register must be a valid tagged pointer or
    //    SMI.
    //
    //  * non_object_regs will be converted to SMIs so that the garbage
    //    collector doesn't try to interpret them as pointers.
    //
    // TODO(jbramley): Why can't this handle callee-saved registers?
122 123 124 125 126 127
    DCHECK((~kCallerSaved.list() & object_regs) == 0);
    DCHECK((~kCallerSaved.list() & non_object_regs) == 0);
    DCHECK((object_regs & non_object_regs) == 0);
    DCHECK((scratch.Bit() & object_regs) == 0);
    DCHECK((scratch.Bit() & non_object_regs) == 0);
    DCHECK((masm->TmpList()->list() & (object_regs | non_object_regs)) == 0);
128 129 130
    STATIC_ASSERT(kSmiValueSize == 32);

    CPURegList non_object_list =
131
        CPURegList(CPURegister::kRegister, kXRegSizeInBits, non_object_regs);
132 133 134
    while (!non_object_list.IsEmpty()) {
      // Store each non-object register as two SMIs.
      Register reg = Register(non_object_list.PopLowestIndex());
135 136 137
      __ Lsr(scratch, reg, 32);
      __ SmiTagAndPush(scratch, reg);

138 139 140 141 142
      // Stack:
      //  jssp[12]: reg[63:32]
      //  jssp[8]: 0x00000000 (SMI tag & padding)
      //  jssp[4]: reg[31:0]
      //  jssp[0]: 0x00000000 (SMI tag & padding)
143 144
      STATIC_ASSERT(kSmiTag == 0);
      STATIC_ASSERT(static_cast<unsigned>(kSmiShift) == kWRegSizeInBits);
145 146 147 148 149 150 151 152 153 154
    }

    if (object_regs != 0) {
      __ PushXRegList(object_regs);
    }

#ifdef DEBUG
    __ RecordComment("// Calling from debug break to runtime - come in - over");
#endif
    __ Mov(x0, 0);  // No arguments.
155
    __ Mov(x1, ExternalReference::debug_break(masm->isolate()));
156

157
    CEntryStub stub(masm->isolate(), 1);
158 159 160 161 162 163 164 165
    __ CallStub(&stub);

    // Restore the register values from the expression stack.
    if (object_regs != 0) {
      __ PopXRegList(object_regs);
    }

    non_object_list =
166
        CPURegList(CPURegister::kRegister, kXRegSizeInBits, non_object_regs);
167 168 169 170 171 172 173 174 175 176 177 178
    while (!non_object_list.IsEmpty()) {
      // Load each non-object register from two SMIs.
      // Stack:
      //  jssp[12]: reg[63:32]
      //  jssp[8]: 0x00000000 (SMI tag & padding)
      //  jssp[4]: reg[31:0]
      //  jssp[0]: 0x00000000 (SMI tag & padding)
      Register reg = Register(non_object_list.PopHighestIndex());
      __ Pop(scratch, reg);
      __ Bfxil(reg, scratch, 32, 32);
    }

179 180 181
    // Don't bother removing padding bytes pushed on the stack
    // as the frame is going to be restored right away.

182 183 184 185 186 187
    // Leave the internal frame.
  }

  // 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.
188 189
  ExternalReference after_break_target =
      ExternalReference::debug_after_break_target_address(masm->isolate());
190
  __ Mov(scratch, after_break_target);
191 192 193 194 195
  __ Ldr(scratch, MemOperand(scratch));
  __ Br(scratch);
}


196
void DebugCodegen::GenerateCallICStubDebugBreak(MacroAssembler* masm) {
197 198 199 200 201 202 203 204 205
  // Register state for CallICStub
  // ----------- S t a t e -------------
  //  -- x1 : function
  //  -- x3 : slot in feedback array
  // -----------------------------------
  Generate_DebugBreakCallHelper(masm, x1.Bit() | x3.Bit(), 0, x10);
}


206
void DebugCodegen::GenerateLoadICDebugBreak(MacroAssembler* masm) {
207
  // Calling convention for IC load (from ic-arm.cc).
208 209
  Register receiver = LoadDescriptor::ReceiverRegister();
  Register name = LoadDescriptor::NameRegister();
210 211 212 213 214
  RegList regs = receiver.Bit() | name.Bit();
  if (FLAG_vector_ics) {
    regs |= VectorLoadICTrampolineDescriptor::SlotRegister().Bit();
  }
  Generate_DebugBreakCallHelper(masm, regs, 0, x10);
215 216 217
}


218
void DebugCodegen::GenerateStoreICDebugBreak(MacroAssembler* masm) {
219
  // Calling convention for IC store (from ic-arm64.cc).
220 221 222
  Register receiver = StoreDescriptor::ReceiverRegister();
  Register name = StoreDescriptor::NameRegister();
  Register value = StoreDescriptor::ValueRegister();
223 224
  Generate_DebugBreakCallHelper(
      masm, receiver.Bit() | name.Bit() | value.Bit(), 0, x10);
225 226 227
}


228
void DebugCodegen::GenerateKeyedLoadICDebugBreak(MacroAssembler* masm) {
229
  // Calling convention for keyed IC load (from ic-arm.cc).
230
  GenerateLoadICDebugBreak(masm);
231 232 233
}


234
void DebugCodegen::GenerateKeyedStoreICDebugBreak(MacroAssembler* masm) {
235
  // Calling convention for IC keyed store call (from ic-arm64.cc).
236 237 238
  Register receiver = StoreDescriptor::ReceiverRegister();
  Register name = StoreDescriptor::NameRegister();
  Register value = StoreDescriptor::ValueRegister();
239 240
  Generate_DebugBreakCallHelper(
      masm, receiver.Bit() | name.Bit() | value.Bit(), 0, x10);
241 242 243
}


244
void DebugCodegen::GenerateCompareNilICDebugBreak(MacroAssembler* masm) {
245 246 247 248 249 250 251 252
  // Register state for CompareNil IC
  // ----------- S t a t e -------------
  //  -- r0    : value
  // -----------------------------------
  Generate_DebugBreakCallHelper(masm, x0.Bit(), 0, x10);
}


253
void DebugCodegen::GenerateReturnDebugBreak(MacroAssembler* masm) {
254 255 256 257 258 259 260
  // 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, x0.Bit(), 0, x10);
}


261
void DebugCodegen::GenerateCallFunctionStubDebugBreak(MacroAssembler* masm) {
262
  // Register state for CallFunctionStub (from code-stubs-arm64.cc).
263 264 265 266 267 268 269
  // ----------- S t a t e -------------
  //  -- x1 : function
  // -----------------------------------
  Generate_DebugBreakCallHelper(masm, x1.Bit(), 0, x10);
}


270
void DebugCodegen::GenerateCallConstructStubDebugBreak(MacroAssembler* masm) {
271
  // Calling convention for CallConstructStub (from code-stubs-arm64.cc).
272 273 274 275 276 277 278 279
  // ----------- S t a t e -------------
  //  -- x0 : number of arguments (not smi)
  //  -- x1 : constructor function
  // -----------------------------------
  Generate_DebugBreakCallHelper(masm, x1.Bit(), x0.Bit(), x10);
}


280 281
void DebugCodegen::GenerateCallConstructStubRecordDebugBreak(
    MacroAssembler* masm) {
282
  // Calling convention for CallConstructStub (from code-stubs-arm64.cc).
283 284 285 286 287 288 289 290 291 292 293
  // ----------- S t a t e -------------
  //  -- x0 : number of arguments (not smi)
  //  -- x1 : constructor function
  //  -- x2     : feedback array
  //  -- x3     : feedback slot (smi)
  // -----------------------------------
  Generate_DebugBreakCallHelper(
      masm, x1.Bit() | x2.Bit() | x3.Bit(), x0.Bit(), x10);
}


294
void DebugCodegen::GenerateSlot(MacroAssembler* masm) {
295 296 297 298 299 300 301 302 303 304 305
  // Generate enough nop's to make space for a call instruction. Avoid emitting
  // the constant pool in the debug break slot code.
  InstructionAccurateScope scope(masm, Assembler::kDebugBreakSlotInstructions);

  __ RecordDebugBreakSlot();
  for (int i = 0; i < Assembler::kDebugBreakSlotInstructions; i++) {
    __ nop(Assembler::DEBUG_BREAK_NOP);
  }
}


306
void DebugCodegen::GenerateSlotDebugBreak(MacroAssembler* masm) {
307 308 309 310 311 312
  // In the places where a debug break slot is inserted no registers can contain
  // object pointers.
  Generate_DebugBreakCallHelper(masm, 0, 0, x10);
}


313
void DebugCodegen::GeneratePlainReturnLiveEdit(MacroAssembler* masm) {
314
  __ Ret();
315 316 317
}


318
void DebugCodegen::GenerateFrameDropperLiveEdit(MacroAssembler* masm) {
319 320 321
  ExternalReference restarter_frame_function_slot =
      ExternalReference::debug_restarter_frame_function_pointer_address(
          masm->isolate());
322 323 324 325 326
  UseScratchRegisterScope temps(masm);
  Register scratch = temps.AcquireX();

  __ Mov(scratch, restarter_frame_function_slot);
  __ Str(xzr, MemOperand(scratch));
327 328

  // We do not know our frame height, but set sp based on fp.
329 330
  __ Sub(masm->StackPointer(), fp, kPointerSize);
  __ AssertStackConsistency();
331 332 333 334

  __ Pop(x1, fp, lr);  // Function, Frame, Return address.

  // Load context from the function.
335
  __ Ldr(cp, FieldMemOperand(x1, JSFunction::kContextOffset));
336 337

  // Get function code.
338 339 340
  __ Ldr(scratch, FieldMemOperand(x1, JSFunction::kSharedFunctionInfoOffset));
  __ Ldr(scratch, FieldMemOperand(scratch, SharedFunctionInfo::kCodeOffset));
  __ Add(scratch, scratch, Code::kHeaderSize - kHeapObjectTag);
341 342

  // Re-run JSFunction, x1 is function, cp is context.
343
  __ Br(scratch);
344 345
}

346

347
const bool LiveEdit::kFrameDropperSupported = true;
348 349 350

} }  // namespace v8::internal

351
#endif  // V8_TARGET_ARCH_ARM64