Refactor after break target computation.

src/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_H_
 #define V8_DEBUG_H_
 
 #include "allocation.h"
 #include "arguments.h"
 #include "assembler.h"
@@ skipping 395 matching lines @@
     bool old_state_;
     DISALLOW_COPY_AND_ASSIGN(IgnoreScope);
   };
 
 
   bool Load();
   void Unload();
   bool IsLoaded() { return !debug_context_.is_null(); }
   bool InDebugger() { return thread_local_.debugger_entry_ != NULL; }
 
-  Object* Break(Arguments args);
+  void Break(Arguments args, JavaScriptFrame*);
+  void SetAfterBreakTarget(JavaScriptFrame* frame);
   bool SetBreakPoint(Handle<JSFunction> function,
                      Handle<Object> break_point_object,
                      int* source_position);
   bool SetBreakPointForScript(Handle<Script> script,
                               Handle<Object> break_point_object,
                               int* source_position,
                               BreakPositionAlignment alignment);
   void ClearBreakPoint(Handle<Object> break_point_object);
   void ClearAllBreakPoints();
   void FloodWithOneShot(Handle<JSFunction> function);
@@ skipping 105 matching lines @@
   bool break_on_uncaught_exception() {
     return break_on_uncaught_exception_;
   }
 
   void FramesHaveBeenDropped(StackFrame::Id new_break_frame_id,
                              LiveEdit::FrameDropMode mode,
                              Object** restarter_frame_function_pointer);
 
   // Support for setting the address to jump to when returning from break point.
   Address after_break_target_address() {
-    return reinterpret_cast<Address>(&thread_local_.after_break_target_);
+    return reinterpret_cast<Address>(&after_break_target_);
   }
 
   Address restarter_frame_function_pointer_address() {
     Object*** address = &thread_local_.restarter_frame_function_pointer_;
     return reinterpret_cast<Address>(address);
   }
 
   static const int kEstimatedNofBreakPointsInFunction = 16;
 
   // Passed to MakeWeak.
@@ skipping 74 matching lines @@
   }
 
   static bool CompileDebuggerScript(Isolate* isolate, int index);
   void ClearOneShot();
   void ActivateStepIn(StackFrame* frame);
   void ClearStepIn();
   void ActivateStepOut(StackFrame* frame);
   void ClearStepNext();
   // Returns whether the compile succeeded.
   void RemoveDebugInfo(Handle<DebugInfo> debug_info);
-  void SetAfterBreakTarget(JavaScriptFrame* frame);
   Handle<Object> CheckBreakPoints(Handle<Object> break_point);
   bool CheckBreakPoint(Handle<Object> break_point_object);
 
   void EnsureFunctionHasDebugBreakSlots(Handle<JSFunction> function);
   void RecompileAndRelocateSuspendedGenerators(
       const List<Handle<JSGeneratorObject> > &suspended_generators);
 
   void ThreadInit();
 
   class PromiseOnStack {
@@ skipping 28 matching lines @@
   bool ignore_debugger_;
   bool live_edit_enabled_;
   bool has_break_points_;
   bool disable_break_;
   bool break_on_exception_;
   bool break_on_uncaught_exception_;
 
   ScriptCache* script_cache_;  // Cache of all scripts in the heap.
   DebugInfoListNode* debug_info_list_;  // List of active debug info objects.
 
+  // 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_;
+
   // Per-thread data.
   class ThreadLocal {
    public:
     // Top debugger entry.
     EnterDebugger* debugger_entry_;
 
     // Counter for generating next break id.
     int break_count_;
 
     // Current break id.
@@ skipping 17 matching lines @@
     // Number of queued steps left to perform before debug event.
     int queued_step_count_;
 
     // 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_;
-
     // Pending interrupts scheduled while debugging.
     bool has_pending_interrupt_;
 
     // Stores the way how LiveEdit has patched the stack. It is used when
     // debugger returns control back to user script.
     LiveEdit::FrameDropMode frame_drop_mode_;
 
     // 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.
@@ skipping 93 matching lines @@
   // 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);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEBUG_H_