src/v8/src/arm64/debug-arm64.cc

   1 // Copyright 2013 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/v8.h"
   6
   7 #if V8_TARGET_ARCH_ARM64
   8
   9 #include "src/codegen.h"
  10 #include "src/debug.h"
  11
  12 namespace v8 {
  13 namespace internal {
  14
  15
  16 #define __ ACCESS_MASM(masm)
  17
  18 bool BreakLocationIterator::IsDebugBreakAtReturn() {
  19   return Debug::IsDebugBreakAtReturn(rinfo());
  20 }
  21
  22
  23 void BreakLocationIterator::SetDebugBreakAtReturn() {
  24   // Patch the code emitted by FullCodeGenerator::EmitReturnSequence, changing
  25   // the return from JS function sequence from
  26   //   mov sp, fp
  27   //   ldp fp, lr, [sp] #16
  28   //   lrd ip0, [pc, #(3 * kInstructionSize)]
  29   //   add sp, sp, ip0
  30   //   ret
  31   //   <number of paramters ...
  32   //    ... plus one (64 bits)>
  33   // to a call to the debug break return code.
  34   //   ldr ip0, [pc, #(3 * kInstructionSize)]
  35   //   blr ip0
  36   //   hlt kHltBadCode    @ code should not return, catch if it does.
  37   //   <debug break return code ...
  38   //    ... entry point address (64 bits)>
  39
  40   // The patching code must not overflow the space occupied by the return
  41   // sequence.
  42   STATIC_ASSERT(Assembler::kJSRetSequenceInstructions >= 5);
  43   PatchingAssembler patcher(reinterpret_cast<Instruction*>(rinfo()->pc()), 5);
  44   byte* entry =
  45       debug_info_->GetIsolate()->builtins()->Return_DebugBreak()->entry();
  46
  47   // The first instruction of a patched return sequence must be a load literal
  48   // loading the address of the debug break return code.
  49   patcher.ldr_pcrel(ip0, (3 * kInstructionSize) >> kLoadLiteralScaleLog2);
  50   // TODO(all): check the following is correct.
  51   // The debug break return code will push a frame and call statically compiled
  52   // code. By using blr, even though control will not return after the branch,
  53   // this call site will be registered in the frame (lr being saved as the pc
  54   // of the next instruction to execute for this frame). The debugger can now
  55   // iterate on the frames to find call to debug break return code.
  56   patcher.blr(ip0);
  57   patcher.hlt(kHltBadCode);
  58   patcher.dc64(reinterpret_cast<int64_t>(entry));
  59 }
  60
  61
  62 void BreakLocationIterator::ClearDebugBreakAtReturn() {
  63   // Reset the code emitted by EmitReturnSequence to its original state.
  64   rinfo()->PatchCode(original_rinfo()->pc(),
  65                      Assembler::kJSRetSequenceInstructions);
  66 }
  67
  68
  69 bool Debug::IsDebugBreakAtReturn(RelocInfo* rinfo) {
  70   DCHECK(RelocInfo::IsJSReturn(rinfo->rmode()));
  71   return rinfo->IsPatchedReturnSequence();
  72 }
  73
  74
  75 bool BreakLocationIterator::IsDebugBreakAtSlot() {
  76   DCHECK(IsDebugBreakSlot());
  77   // Check whether the debug break slot instructions have been patched.
  78   return rinfo()->IsPatchedDebugBreakSlotSequence();
  79 }
  80
  81
  82 void BreakLocationIterator::SetDebugBreakAtSlot() {
  83   // Patch the code emitted by DebugCodegen::GenerateSlots, changing the debug
  84   // break slot code from
  85   //   mov x0, x0    @ nop DEBUG_BREAK_NOP
  86   //   mov x0, x0    @ nop DEBUG_BREAK_NOP
  87   //   mov x0, x0    @ nop DEBUG_BREAK_NOP
  88   //   mov x0, x0    @ nop DEBUG_BREAK_NOP
  89   // to a call to the debug slot code.
  90   //   ldr ip0, [pc, #(2 * kInstructionSize)]
  91   //   blr ip0
  92   //   <debug break slot code ...
  93   //    ... entry point address (64 bits)>
  94
  95   // TODO(all): consider adding a hlt instruction after the blr as we don't
  96   // expect control to return here. This implies increasing
  97   // kDebugBreakSlotInstructions to 5 instructions.
  98
  99   // The patching code must not overflow the space occupied by the return
 100   // sequence.
 101   STATIC_ASSERT(Assembler::kDebugBreakSlotInstructions >= 4);
 102   PatchingAssembler patcher(reinterpret_cast<Instruction*>(rinfo()->pc()), 4);
 103   byte* entry =
 104       debug_info_->GetIsolate()->builtins()->Slot_DebugBreak()->entry();
 105
 106   // The first instruction of a patched debug break slot must be a load literal
 107   // loading the address of the debug break slot code.
 108   patcher.ldr_pcrel(ip0, (2 * kInstructionSize) >> kLoadLiteralScaleLog2);
 109   // TODO(all): check the following is correct.
 110   // The debug break slot code will push a frame and call statically compiled
 111   // code. By using blr, event hough control will not return after the branch,
 112   // this call site will be registered in the frame (lr being saved as the pc
 113   // of the next instruction to execute for this frame). The debugger can now
 114   // iterate on the frames to find call to debug break slot code.
 115   patcher.blr(ip0);
 116   patcher.dc64(reinterpret_cast<int64_t>(entry));
 117 }
 118
 119
 120 void BreakLocationIterator::ClearDebugBreakAtSlot() {
 121   DCHECK(IsDebugBreakSlot());
 122   rinfo()->PatchCode(original_rinfo()->pc(),
 123                      Assembler::kDebugBreakSlotInstructions);
 124 }
 125
 126
 127 static void Generate_DebugBreakCallHelper(MacroAssembler* masm,
 128                                           RegList object_regs,
 129                                           RegList non_object_regs,
 130                                           Register scratch) {
 131   {
 132     FrameScope scope(masm, StackFrame::INTERNAL);
 133
 134     // Load padding words on stack.
 135     __ Mov(scratch, Smi::FromInt(LiveEdit::kFramePaddingValue));
 136     __ PushMultipleTimes(scratch, LiveEdit::kFramePaddingInitialSize);
 137     __ Mov(scratch, Smi::FromInt(LiveEdit::kFramePaddingInitialSize));
 138     __ Push(scratch);
 139
 140     // Any live values (object_regs and non_object_regs) in caller-saved
 141     // registers (or lr) need to be stored on the stack so that their values are
 142     // safely preserved for a call into C code.
 143     //
 144     // Also:
 145     //  * object_regs may be modified during the C code by the garbage
 146     //    collector. Every object register must be a valid tagged pointer or
 147     //    SMI.
 148     //
 149     //  * non_object_regs will be converted to SMIs so that the garbage
 150     //    collector doesn't try to interpret them as pointers.
 151     //
 152     // TODO(jbramley): Why can't this handle callee-saved registers?
 153     DCHECK((~kCallerSaved.list() & object_regs) == 0);
 154     DCHECK((~kCallerSaved.list() & non_object_regs) == 0);
 155     DCHECK((object_regs & non_object_regs) == 0);
 156     DCHECK((scratch.Bit() & object_regs) == 0);
 157     DCHECK((scratch.Bit() & non_object_regs) == 0);
 158     DCHECK((masm->TmpList()->list() & (object_regs | non_object_regs)) == 0);
 159     STATIC_ASSERT(kSmiValueSize == 32);
 160
 161     CPURegList non_object_list =
 162         CPURegList(CPURegister::kRegister, kXRegSizeInBits, non_object_regs);
 163     while (!non_object_list.IsEmpty()) {
 164       // Store each non-object register as two SMIs.
 165       Register reg = Register(non_object_list.PopLowestIndex());
 166       __ Lsr(scratch, reg, 32);
 167       __ SmiTagAndPush(scratch, reg);
 168
 169       // Stack:
 170       //  jssp[12]: reg[63:32]
 171       //  jssp[8]: 0x00000000 (SMI tag & padding)
 172       //  jssp[4]: reg[31:0]
 173       //  jssp[0]: 0x00000000 (SMI tag & padding)
 174       STATIC_ASSERT(kSmiTag == 0);
 175       STATIC_ASSERT(static_cast<unsigned>(kSmiShift) == kWRegSizeInBits);
 176     }
 177
 178     if (object_regs != 0) {
 179       __ PushXRegList(object_regs);
 180     }
 181
 182 #ifdef DEBUG
 183     __ RecordComment("// Calling from debug break to runtime - come in - over");
 184 #endif
 185     __ Mov(x0, 0);  // No arguments.
 186     __ Mov(x1, ExternalReference::debug_break(masm->isolate()));
 187
 188     CEntryStub stub(masm->isolate(), 1);
 189     __ CallStub(&stub);
 190
 191     // Restore the register values from the expression stack.
 192     if (object_regs != 0) {
 193       __ PopXRegList(object_regs);
 194     }
 195
 196     non_object_list =
 197         CPURegList(CPURegister::kRegister, kXRegSizeInBits, non_object_regs);
 198     while (!non_object_list.IsEmpty()) {
 199       // Load each non-object register from two SMIs.
 200       // Stack:
 201       //  jssp[12]: reg[63:32]
 202       //  jssp[8]: 0x00000000 (SMI tag & padding)
 203       //  jssp[4]: reg[31:0]
 204       //  jssp[0]: 0x00000000 (SMI tag & padding)
 205       Register reg = Register(non_object_list.PopHighestIndex());
 206       __ Pop(scratch, reg);
 207       __ Bfxil(reg, scratch, 32, 32);
 208     }
 209
 210     // Don't bother removing padding bytes pushed on the stack
 211     // as the frame is going to be restored right away.
 212
 213     // Leave the internal frame.
 214   }
 215
 216   // Now that the break point has been handled, resume normal execution by
 217   // jumping to the target address intended by the caller and that was
 218   // overwritten by the address of DebugBreakXXX.
 219   ExternalReference after_break_target =
 220       ExternalReference::debug_after_break_target_address(masm->isolate());
 221   __ Mov(scratch, after_break_target);
 222   __ Ldr(scratch, MemOperand(scratch));
 223   __ Br(scratch);
 224 }
 225
 226
 227 void DebugCodegen::GenerateCallICStubDebugBreak(MacroAssembler* masm) {
 228   // Register state for CallICStub
 229   // ----------- S t a t e -------------
 230   //  -- x1 : function
 231   //  -- x3 : slot in feedback array
 232   // -----------------------------------
 233   Generate_DebugBreakCallHelper(masm, x1.Bit() | x3.Bit(), 0, x10);
 234 }
 235
 236
 237 void DebugCodegen::GenerateLoadICDebugBreak(MacroAssembler* masm) {
 238   // Calling convention for IC load (from ic-arm.cc).
 239   Register receiver = LoadIC::ReceiverRegister();
 240   Register name = LoadIC::NameRegister();
 241   Generate_DebugBreakCallHelper(masm, receiver.Bit() | name.Bit(), 0, x10);
 242 }
 243
 244
 245 void DebugCodegen::GenerateStoreICDebugBreak(MacroAssembler* masm) {
 246   // Calling convention for IC store (from ic-arm64.cc).
 247   Register receiver = StoreIC::ReceiverRegister();
 248   Register name = StoreIC::NameRegister();
 249   Register value = StoreIC::ValueRegister();
 250   Generate_DebugBreakCallHelper(
 251       masm, receiver.Bit() | name.Bit() | value.Bit(), 0, x10);
 252 }
 253
 254
 255 void DebugCodegen::GenerateKeyedLoadICDebugBreak(MacroAssembler* masm) {
 256   // Calling convention for keyed IC load (from ic-arm.cc).
 257   GenerateLoadICDebugBreak(masm);
 258 }
 259
 260
 261 void DebugCodegen::GenerateKeyedStoreICDebugBreak(MacroAssembler* masm) {
 262   // Calling convention for IC keyed store call (from ic-arm64.cc).
 263   Register receiver = KeyedStoreIC::ReceiverRegister();
 264   Register name = KeyedStoreIC::NameRegister();
 265   Register value = KeyedStoreIC::ValueRegister();
 266   Generate_DebugBreakCallHelper(
 267       masm, receiver.Bit() | name.Bit() | value.Bit(), 0, x10);
 268 }
 269
 270
 271 void DebugCodegen::GenerateCompareNilICDebugBreak(MacroAssembler* masm) {
 272   // Register state for CompareNil IC
 273   // ----------- S t a t e -------------
 274   //  -- r0    : value
 275   // -----------------------------------
 276   Generate_DebugBreakCallHelper(masm, x0.Bit(), 0, x10);
 277 }
 278
 279
 280 void DebugCodegen::GenerateReturnDebugBreak(MacroAssembler* masm) {
 281   // In places other than IC call sites it is expected that r0 is TOS which
 282   // is an object - this is not generally the case so this should be used with
 283   // care.
 284   Generate_DebugBreakCallHelper(masm, x0.Bit(), 0, x10);
 285 }
 286
 287
 288 void DebugCodegen::GenerateCallFunctionStubDebugBreak(MacroAssembler* masm) {
 289   // Register state for CallFunctionStub (from code-stubs-arm64.cc).
 290   // ----------- S t a t e -------------
 291   //  -- x1 : function
 292   // -----------------------------------
 293   Generate_DebugBreakCallHelper(masm, x1.Bit(), 0, x10);
 294 }
 295
 296
 297 void DebugCodegen::GenerateCallConstructStubDebugBreak(MacroAssembler* masm) {
 298   // Calling convention for CallConstructStub (from code-stubs-arm64.cc).
 299   // ----------- S t a t e -------------
 300   //  -- x0 : number of arguments (not smi)
 301   //  -- x1 : constructor function
 302   // -----------------------------------
 303   Generate_DebugBreakCallHelper(masm, x1.Bit(), x0.Bit(), x10);
 304 }
 305
 306
 307 void DebugCodegen::GenerateCallConstructStubRecordDebugBreak(
 308     MacroAssembler* masm) {
 309   // Calling convention for CallConstructStub (from code-stubs-arm64.cc).
 310   // ----------- S t a t e -------------
 311   //  -- x0 : number of arguments (not smi)
 312   //  -- x1 : constructor function
 313   //  -- x2     : feedback array
 314   //  -- x3     : feedback slot (smi)
 315   // -----------------------------------
 316   Generate_DebugBreakCallHelper(
 317       masm, x1.Bit() | x2.Bit() | x3.Bit(), x0.Bit(), x10);
 318 }
 319
 320
 321 void DebugCodegen::GenerateSlot(MacroAssembler* masm) {
 322   // Generate enough nop's to make space for a call instruction. Avoid emitting
 323   // the constant pool in the debug break slot code.
 324   InstructionAccurateScope scope(masm, Assembler::kDebugBreakSlotInstructions);
 325
 326   __ RecordDebugBreakSlot();
 327   for (int i = 0; i < Assembler::kDebugBreakSlotInstructions; i++) {
 328     __ nop(Assembler::DEBUG_BREAK_NOP);
 329   }
 330 }
 331
 332
 333 void DebugCodegen::GenerateSlotDebugBreak(MacroAssembler* masm) {
 334   // In the places where a debug break slot is inserted no registers can contain
 335   // object pointers.
 336   Generate_DebugBreakCallHelper(masm, 0, 0, x10);
 337 }
 338
 339
 340 void DebugCodegen::GeneratePlainReturnLiveEdit(MacroAssembler* masm) {
 341   __ Ret();
 342 }
 343
 344
 345 void DebugCodegen::GenerateFrameDropperLiveEdit(MacroAssembler* masm) {
 346   ExternalReference restarter_frame_function_slot =
 347       ExternalReference::debug_restarter_frame_function_pointer_address(
 348           masm->isolate());
 349   UseScratchRegisterScope temps(masm);
 350   Register scratch = temps.AcquireX();
 351
 352   __ Mov(scratch, restarter_frame_function_slot);
 353   __ Str(xzr, MemOperand(scratch));
 354
 355   // We do not know our frame height, but set sp based on fp.
 356   __ Sub(masm->StackPointer(), fp, kPointerSize);
 357   __ AssertStackConsistency();
 358
 359   __ Pop(x1, fp, lr);  // Function, Frame, Return address.
 360
 361   // Load context from the function.
 362   __ Ldr(cp, FieldMemOperand(x1, JSFunction::kContextOffset));
 363
 364   // Get function code.
 365   __ Ldr(scratch, FieldMemOperand(x1, JSFunction::kSharedFunctionInfoOffset));
 366   __ Ldr(scratch, FieldMemOperand(scratch, SharedFunctionInfo::kCodeOffset));
 367   __ Add(scratch, scratch, Code::kHeaderSize - kHeapObjectTag);
 368
 369   // Re-run JSFunction, x1 is function, cp is context.
 370   __ Br(scratch);
 371 }
 372
 373
 374 const bool LiveEdit::kFrameDropperSupported = true;
 375
 376 } }  // namespace v8::internal
 377
 378 #endif  // V8_TARGET_ARCH_ARM64