[liveedit] reimplement frame restarting.

src/debug/debug.h

 // Copyright 2012 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.
 
 #ifndef V8_DEBUG_DEBUG_H_
 #define V8_DEBUG_DEBUG_H_
 
 #include "src/allocation.h"
 #include "src/arguments.h"
 #include "src/assembler.h"
@@ skipping 408 matching lines @@
                              v8::Debug::ClientData* client_data = NULL);
   MUST_USE_RESULT MaybeHandle<Object> Call(Handle<Object> fun,
                                            Handle<Object> data);
   Handle<Context> GetDebugContext();
   void HandleDebugBreak();
   void ProcessDebugMessages(bool debug_command_only);
 
   // Internal logic
   bool Load();
   void Break(JavaScriptFrame* frame);
-  void SetAfterBreakTarget(JavaScriptFrame* frame);
 
   // Scripts handling.
   Handle<FixedArray> GetLoadedScripts();
 
   // Break point handling.
   bool SetBreakPoint(Handle<JSFunction> function,
                      Handle<Object> break_point_object,
                      int* source_position);
   bool SetBreakPointForScript(Handle<Script> script,
                               Handle<Object> break_point_object,
@@ skipping 47 matching lines @@
       Handle<SharedFunctionInfo> shared,
       BreakPositionAlignment position_aligment);
 
   // Check whether a global object is the debug global object.
   bool IsDebugGlobal(JSGlobalObject* global);
 
   // Check whether this frame is just about to return.
   bool IsBreakAtReturn(JavaScriptFrame* frame);
 
   // Support for LiveEdit
-  void FramesHaveBeenDropped(StackFrame::Id new_break_frame_id,
-                             LiveEditFrameDropMode mode);
+  void UpdateBreakFrameId();
 
   // Threading support.
   char* ArchiveDebug(char* to);
   char* RestoreDebug(char* from);
   static int ArchiveSpacePerThread();
   void FreeThreadResources() { }
   void Iterate(ObjectVisitor* v);
 
   bool CheckExecutionState(int id) {
     return CheckExecutionState() && break_id() == id;
@@ skipping 22 matching lines @@
   inline bool is_loaded() const { return !debug_context_.is_null(); }
   inline bool in_debug_scope() const {
     return !!base::NoBarrier_Load(&thread_local_.current_debug_scope_);
   }
   void set_break_points_active(bool v) { break_points_active_ = v; }
   bool break_points_active() const { return break_points_active_; }
 
   StackFrame::Id break_frame_id() { return thread_local_.break_frame_id_; }
   int break_id() { return thread_local_.break_id_; }
 
-  Handle<Object> return_value() { return thread_local_.return_value_; }
-  void set_return_value(Handle<Object> value) {
-    thread_local_.return_value_ = value;
-  }
+  Object* return_value() { return thread_local_.return_value_; }
+  void set_return_value(Object* value) { thread_local_.return_value_ = value; }
 
   // Support for embedding into generated code.
   Address is_active_address() {
     return reinterpret_cast<Address>(&is_active_);
   }
 
   Address hook_on_function_call_address() {
     return reinterpret_cast<Address>(&hook_on_function_call_);
   }
 
-  Address after_break_target_address() {
-    return reinterpret_cast<Address>(&after_break_target_);
-  }
-
   Address last_step_action_address() {
     return reinterpret_cast<Address>(&thread_local_.last_step_action_);
   }
 
   Address suspended_generator_address() {
     return reinterpret_cast<Address>(&thread_local_.suspended_generator_);
   }
 
+  Address new_fp_address() {
+    return reinterpret_cast<Address>(&thread_local_.new_fp_);
+  }
+
+  void DropToFP(Address fp) {
+    // Drop to a lower a frame.

[jgruber, 2017/01/17 13:29:58]

Nit: 'a lower a'.

A diagram or brief description of how frame dropping works would be very helpful
since the code to handle it is pretty scattered (and this function doesn't
actually drop frames as its name suggests).

If I understood correctly, this function marks an upcoming drop, which then
actually takes place once we return from the DebugBreakStub. new_fp_ is only
reset when entering a new DebugBreak.

[Yang, 2017/01/18 07:49:08]

Done. Added comment.

+    if (fp > thread_local_.new_fp_) thread_local_.new_fp_ = fp;
+  }
+
   StepAction last_step_action() { return thread_local_.last_step_action_; }
 
   DebugFeatureTracker* feature_tracker() { return &feature_tracker_; }
 
  private:
   explicit Debug(Isolate* isolate);
 
   void UpdateState();
   void UpdateHookOnFunctionCall();
   void Unload();
@@ skipping 113 matching lines @@
   // Trigger debug break events for all exceptions.
   bool break_on_exception_;
   // Trigger debug break events for uncaught exceptions.
   bool break_on_uncaught_exception_;
   // Termination exception because side effect check has failed.
   bool side_effect_check_failed_;
 
   // List of active debug info objects.
   DebugInfoListNode* debug_info_list_;
 
-  // Storage location for jump when exiting debug break calls.
-  // Note that this address is not GC safe.  It should be computed immediately
-  // before returning to the DebugBreakCallHelper.
-  Address after_break_target_;
-
   // Used to collect histogram data on debugger feature usage.
   DebugFeatureTracker feature_tracker_;
 
   // Per-thread data.
   class ThreadLocal {
    public:
     // Top debugger entry.
     base::AtomicWord current_debug_scope_;
 
     // Counter for generating next break id.
@@ skipping 15 matching lines @@
     Address last_fp_;
 
     // Frame pointer of the target frame we want to arrive at.
     Address target_fp_;
 
     // Stores the way how LiveEdit has patched the stack. It is used when
     // debugger returns control back to user script.
     LiveEditFrameDropMode frame_drop_mode_;
 
     // Value of accumulator in interpreter frames. In non-interpreter frames
     // this value will be the hole.

[jgruber, 2017/01/17 13:29:58]

Is the comment about the hole still valid?

[Yang, 2017/01/18 07:49:07]

Done.

-    Handle<Object> return_value_;
+    Object* return_value_;
 
+    // The suspended generator object to track when stepping.
     Object* suspended_generator_;
 
+    // The new frame pointer to drop to when restarting a frame.
+    Address new_fp_;

[jgruber, 2017/01/17 13:29:58]

Nit: 'new_fp_' isn't very descriptive, maybe something like frame_drop_fp? Up to
you.

[Yang, 2017/01/18 07:49:08]

renamed to restart_fp_

+
     int async_task_count_;
   };
 
   // Storage location for registers when handling debug break calls
   ThreadLocal thread_local_;
 
   Isolate* isolate_;
 
   friend class Isolate;
   friend class DebugScope;
@@ skipping 96 matching lines @@
 class DebugCodegen : public AllStatic {
  public:
   enum DebugBreakCallHelperMode {
     SAVE_RESULT_REGISTER,
     IGNORE_RESULT_REGISTER
   };
 
   static void GenerateDebugBreakStub(MacroAssembler* masm,
                                      DebugBreakCallHelperMode mode);
 
-  // FrameDropper is a code replacement for a JavaScript frame with possibly
-  // several frames above.
-  // There is no calling conventions here, because it never actually gets
-  // called, it only gets returned to.
-  static void GenerateFrameDropperLiveEdit(MacroAssembler* masm);
+  static void GenerateSlot(MacroAssembler* masm, RelocInfo::Mode mode);
 
-
-  static void GenerateSlot(MacroAssembler* masm, RelocInfo::Mode mode);
+  static void GenerateFrameDropperTrampoline(MacroAssembler* masm);
 
   static void PatchDebugBreakSlot(Isolate* isolate, Address pc,
                                   Handle<Code> code);
   static bool DebugBreakSlotIsPatched(Address pc);
   static void ClearDebugBreakSlot(Isolate* isolate, Address pc);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_DEBUG_DEBUG_H_