Reimplement stack manipulations for LiveEdit

src/debug.h

 // 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
@@ skipping 312 matching lines @@
   }
 
   // Getters for the current exception break state.
   static bool break_on_exception() { return break_on_exception_; }
   static bool break_on_uncaught_exception() {
     return break_on_uncaught_exception_;
   }
 
   enum AddressId {
     k_after_break_target_address,
+    k_restarted_frame_fp_address,
     k_debug_break_return_address,
     k_debug_break_slot_address,
     k_register_address
   };
 
   // Support for setting the address to jump to when returning from break point.
   static Address* after_break_target_address() {
     return reinterpret_cast<Address*>(&thread_local_.after_break_target_);
   }
 
+  static Address* restarted_frame_fp_address() {
+    return reinterpret_cast<Address*>(&thread_local_.restarted_frame_fp_);
+  }
+
+
+
   // Support for saving/restoring registers when handling debug break calls.
   static Object** register_address(int r) {
     return &registers_[r];
   }
 
   // Access to the debug break on return code.
   static Code* debug_break_return() { return debug_break_return_; }
   static Code** debug_break_return_address() {
     return &debug_break_return_;
   }
@@ skipping 35 matching lines @@
   static void GenerateSlot(MacroAssembler* masm);
   static void GenerateLoadICDebugBreak(MacroAssembler* masm);
   static void GenerateStoreICDebugBreak(MacroAssembler* masm);
   static void GenerateKeyedLoadICDebugBreak(MacroAssembler* masm);
   static void GenerateKeyedStoreICDebugBreak(MacroAssembler* masm);
   static void GenerateConstructCallDebugBreak(MacroAssembler* masm);
   static void GenerateReturnDebugBreak(MacroAssembler* masm);
   static void GenerateStubNoRegistersDebugBreak(MacroAssembler* masm);
   static void GenerateSlotDebugBreak(MacroAssembler* masm);
   static void GeneratePlainReturnLiveEdit(MacroAssembler* masm);
-  static void GenerateFrameDropperLiveEdit(MacroAssembler* masm);
+
+  // LiveEdit restarter patch. For javascript stack frames that has to be
+  // restarted. First it is appended at the end of a regular code of javascript
+  // function. Frame PC should be set to the entry point
+  // of the patch. When control finally returns to the frame, restarter resets
+  // registers and jumps to the function entry. Stack analizer sees
+  // the frame as if paused at the very beginning of the function (from source
+  // point of view). Local scope is not available in this state and shouldn't be
+  // accessed.
+  // The patch code starts with NOP instruction. The next byte is a patch
+  // starting point (its offset is typically 1 and is defined
+  // in Debug::kFrameDropperEntryOffset. The NOP instruction is for being
+  // annotated with position-bearing rinfo (in the actual function), because
+  // source position resolver expects position-bearing rinfo exactly before
+  // pc pointer (see Code::SourcePosition).
+  // It also resets the global variable restarter_frame_fp.
+  //
+  static void GenerateRestarterPatchLiveEdit(MacroAssembler* masm);
+
 
   // Called from stub-cache.cc.
   static void GenerateCallICDebugBreak(MacroAssembler* masm);
 
   // Describes how exactly a frame has been dropped from stack.
   enum FrameDropMode {
     // No frame has been dropped.
     FRAMES_UNTOUCHED,
     // The top JS frame had been calling IC stub. IC stub mustn't be called now.
     FRAME_DROPPED_IN_IC_CALL,
     // The top JS frame had been calling debug break slot stub. Patch the
     // address this stub jumps to in the end.
     FRAME_DROPPED_IN_DEBUG_SLOT_CALL,
     // The top JS frame had been calling some C++ function. The return address
     // gets patched automatically.
     FRAME_DROPPED_IN_DIRECT_CALL
   };
 
-  static void FramesHaveBeenDropped(StackFrame::Id new_break_frame_id,
+  static void FramesHaveBeenDropped(JavaScriptFrame* new_top_js_frame,
                                     FrameDropMode mode);
 
-  static void SetUpFrameDropperFrame(StackFrame* bottom_js_frame,
-                                     Handle<Code> code);
-  static const int kFrameDropperFrameSize;
+  // Returns fp of the restarted frame that is currently on the active stack
+  // or NULL.
+  static Address GetRestartedFrameFp();
+
+  // The actual entry point offset in the frame restarter patch.
+  static const int kFrameRestarterEntryOffset;
+
+  // The height (in words) of the restarted JavaScript frame.
+  // A negative value indicates that stack manipulation is not supported.
+  static const int kRestartedFrameHeight;
 
  private:
   static bool CompileDebuggerScript(int index);
   static void ClearOneShot();
   static void ActivateStepIn(StackFrame* frame);
   static void ClearStepIn();
   static void ActivateStepOut(StackFrame* frame);
   static void ClearStepOut();
   static void ClearStepNext();
   // Returns whether the compile succeeded.
@@ skipping 46 matching lines @@
     // Frame pointer for frame from which step in was performed.
     Address step_into_fp_;
 
     // Frame pointer for the frame where debugger should be called when current
     // step out action is completed.
     Address step_out_fp_;
 
     // Storage location for jump when exiting debug break calls.
     Address after_break_target_;
 
+    // Stores fp of the restarted frame that is currently on the active stack
+    // or NULL. This variable is reset when that frame gets running.
+    Address restarted_frame_fp_;
+
     // Stores the way how LiveEdit has patched the stack. It is used when
     // debugger returns control back to user script.
     FrameDropMode frame_drop_mode_;
 
     // Top debugger entry.
     EnterDebugger* debugger_entry_;
 
     // Pending interrupts scheduled while debugging.
     int pending_interrupts_;
   };
@@ skipping 411 matching lines @@
  public:
   Debug_Address(Debug::AddressId id, int reg = 0)
     : id_(id), reg_(reg) {
     ASSERT(reg == 0 || id == Debug::k_register_address);
   }
 
   static Debug_Address AfterBreakTarget() {
     return Debug_Address(Debug::k_after_break_target_address);
   }
 
+  static Debug_Address RestartedFrameFp() {
+    return Debug_Address(Debug::k_restarted_frame_fp_address);
+  }
+
   static Debug_Address DebugBreakReturn() {
     return Debug_Address(Debug::k_debug_break_return_address);
   }
 
   static Debug_Address Register(int reg) {
     return Debug_Address(Debug::k_register_address, reg);
   }
 
   Address address() const {
     switch (id_) {
       case Debug::k_after_break_target_address:
         return reinterpret_cast<Address>(Debug::after_break_target_address());
+      case Debug::k_restarted_frame_fp_address:
+        return reinterpret_cast<Address>(Debug::restarted_frame_fp_address());
       case Debug::k_debug_break_return_address:
         return reinterpret_cast<Address>(Debug::debug_break_return_address());
       case Debug::k_debug_break_slot_address:
         return reinterpret_cast<Address>(Debug::debug_break_slot_address());
       case Debug::k_register_address:
         return reinterpret_cast<Address>(Debug::register_address(reg_));
       default:
         UNREACHABLE();
         return NULL;
     }
@@ skipping 23 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MessageDispatchHelperThread);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 #endif  // V8_DEBUG_H_