Fix 'step in' after live edit stack manipulation

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 314 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_debug_break_return_address,
     k_debug_break_slot_address,
+    k_restarter_frame_function_pointer,
     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* restarter_frame_function_pointer_address() {
+    Object*** address = &thread_local_.restarter_frame_function_pointer_;
+    return reinterpret_cast<Address*>(address);
+  }
 
   // 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 56 matching lines @@
     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,
-                                    FrameDropMode mode);
+                                    FrameDropMode mode,
+                                    Object** restarter_frame_function_pointer);
 
-  static void SetUpFrameDropperFrame(StackFrame* bottom_js_frame,
-                                     Handle<Code> code);
+  // Initializes an artificial stack frame. The data it contains is used for:
+  //  a. successful work of frame dropper code which eventually gets control,
+  //  b. being compatible with regular stack structure for various stack
+  //     iterators.
+  // Returns address of stack allocated pointer to restarted function,
+  // the value that is called 'restarter_frame_function_pointer'. The value
+  // at this address (possibly updated by GC) may be used later when preparing
+  // 'step in' operation.
+  // The implementation is architecture-specific.
+  // TODO(LiveEdit): consider reviewing it as architecture-independent.
+  static Object** SetUpFrameDropperFrame(StackFrame* bottom_js_frame,
+                                         Handle<Code> code);
+
   static const int kFrameDropperFrameSize;
 
  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();
@@ skipping 56 matching lines @@
 
     // 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_;
+
+    // When restarter frame is on stack, stores the address
+    // of the pointer to function being restarted. Otherwise (most of the time)
+    // stores NULL. This pointer is used with 'step in' implementation.
+    Object** restarter_frame_function_pointer_;
   };
 
   // Storage location for registers when handling debug break calls
   static JSCallerSavedBuffer registers_;
   static ThreadLocal thread_local_;
   static void ThreadInit();
 
   // Code to call for handling debug break on return.
   static Code* debug_break_return_;
 
@@ skipping 425 matching lines @@
   }
 
   static Debug_Address AfterBreakTarget() {
     return Debug_Address(Debug::k_after_break_target_address);
   }
 
   static Debug_Address DebugBreakReturn() {
     return Debug_Address(Debug::k_debug_break_return_address);
   }
 
+  static Debug_Address RestarterFrameFunctionPointer() {
+    return Debug_Address(Debug::k_restarter_frame_function_pointer);
+  }
+
   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_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_restarter_frame_function_pointer:
+        return reinterpret_cast<Address>(
+            Debug::restarter_frame_function_pointer_address());
       case Debug::k_register_address:
         return reinterpret_cast<Address>(Debug::register_address(reg_));
       default:
         UNREACHABLE();
         return NULL;
     }
   }
  private:
   Debug::AddressId id_;
   int reg_;
@@ skipping 19 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MessageDispatchHelperThread);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 #endif  // V8_DEBUG_H_