Support LiveEdit on Arm64

src/arm64/debug-arm64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_ARM64
 
 #include "src/codegen.h"
 #include "src/debug.h"
@@ skipping 113 matching lines @@
 }
 
 
 static void Generate_DebugBreakCallHelper(MacroAssembler* masm,
                                           RegList object_regs,
                                           RegList non_object_regs,
                                           Register scratch) {
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
 
+    // Load padding words on stack.
+    __ ldr(scratch, Smi::FromInt(LiveEdit::kFramePaddingValue));
+    for (int i = 0; i < LiveEdit::kFramePaddingInitialSize; i++) {
+      __ push(scratch);
+    }
+    __ ldr(scratch, Smi::FromInt(LiveEdit::kFramePaddingInitialSize));
+    __ push(scratch);
+
     // 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
@@ skipping 49 matching lines @@
       // 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);
     }
 
+    // Don't bother removing padding bytes pushed on the stack
+    // as the frame is going to be restored right away.
+
     // 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.
   ExternalReference after_break_target =
       ExternalReference::debug_after_break_target_address(masm->isolate());
   __ Mov(scratch, after_break_target);
   __ Ldr(scratch, MemOperand(scratch));
@@ skipping 121 matching lines @@
 
 
 void DebugCodegen::GenerateSlotDebugBreak(MacroAssembler* masm) {
   // In the places where a debug break slot is inserted no registers can contain
   // object pointers.
   Generate_DebugBreakCallHelper(masm, 0, 0, x10);
 }
 
 
 void DebugCodegen::GeneratePlainReturnLiveEdit(MacroAssembler* masm) {
-  masm->Abort(kLiveEditFrameDroppingIsNotSupportedOnARM64);
+  __ Ret();
 }
 
 
 void DebugCodegen::GenerateFrameDropperLiveEdit(MacroAssembler* masm) {
-  masm->Abort(kLiveEditFrameDroppingIsNotSupportedOnARM64);
+  ExternalReference restarter_frame_function_slot =
+      ExternalReference::debug_restarter_frame_function_pointer_address(
+          masm->isolate());
+  __ mov(x1, xzr);
+  __ Mov(ip0, restarter_frame_function_slot);
+  __ str(x1, MemOperand(ip0, 0));
+
+  // We do not know our frame height, but set sp based on fp.
+  __ sub(jssp, fp, Operand(kPointerSize));
+
+  __ Pop(x1, fp, lr);  // Function, Frame, Return address.
+
+  // Load context from the function.
+  __ ldr(cp, FieldMemOperand(x1, JSFunction::kContextOffset));
+
+  // Get function code.
+  __ ldr(ip0, FieldMemOperand(x1, JSFunction::kSharedFunctionInfoOffset));
+  __ ldr(ip0, FieldMemOperand(ip0, SharedFunctionInfo::kCodeOffset));
+  __ add(ip0, ip0, Operand(Code::kHeaderSize - kHeapObjectTag));
+
+  // Re-run JSFunction, x1 is function, cp is context.
+  __ Jump(ip0);
 }
 
 
-const bool LiveEdit::kFrameDropperSupported = false;
+const bool LiveEdit::kFrameDropperSupported = true;
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64