Some more debugger-related refactorings.

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 132 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BreakLocationIterator);
 };
 
 
 // Cache of all script objects in the heap. When a script is added a weak handle
 // to it is created and that weak handle is stored in the cache. The weak handle
 // callback takes care of removing the script from the cache. The key used in
 // the cache is the script id.
 class ScriptCache : private HashMap {
  public:
-  explicit ScriptCache(Isolate* isolate)
-      : HashMap(HashMap::PointersMatch),
-        isolate_(isolate),
-        collected_scripts_(10) {}
+  explicit ScriptCache(Isolate* isolate);
   virtual ~ScriptCache() { Clear(); }
 
   // Add script to the cache.
   void Add(Handle<Script> script);
 
   // Return the scripts in the cache.
   Handle<FixedArray> GetScripts();
 
   // Generate debugger events for collected scripts.
   void ProcessCollectedScripts();
@@ skipping 113 matching lines @@
 
 // Message send by user to v8 debugger or debugger output message.
 // In addition to command text it may contain a pointer to some user data
 // which are expected to be passed along with the command reponse to message
 // handler.
 class CommandMessage {
  public:
   static CommandMessage New(const Vector<uint16_t>& command,
                             v8::Debug::ClientData* data);
   CommandMessage();
-  ~CommandMessage();
 
   // Deletes user data and disposes of the text.
   void Dispose();
   Vector<uint16_t> text() const { return text_; }
   v8::Debug::ClientData* client_data() const { return client_data_; }
  private:
   CommandMessage(const Vector<uint16_t>& text,
                  v8::Debug::ClientData* data);
 
   Vector<uint16_t> text_;
@@ skipping 34 matching lines @@
   void Put(const CommandMessage& message);
   void Clear();
  private:
   Logger* logger_;
   CommandMessageQueue queue_;
   mutable Mutex mutex_;
   DISALLOW_COPY_AND_ASSIGN(LockingCommandMessageQueue);
 };
 
 
+class PromiseOnStack {
+ public:
+  PromiseOnStack(Isolate* isolate,
+                 PromiseOnStack* prev,
+                 Handle<JSFunction> getter);
+  ~PromiseOnStack();
+  StackHandler* handler() { return handler_; }
+  Handle<JSFunction> getter() { return getter_; }
+  PromiseOnStack* prev() { return prev_; }
+ private:
+  Isolate* isolate_;
+  StackHandler* handler_;
+  Handle<JSFunction> getter_;
+  PromiseOnStack* prev_;
+};
+
+
 // This class contains the debugger support. The main purpose is to handle
 // setting break points in the code.
 //
 // This class controls the debug info for all functions which currently have
 // active breakpoints in them. This debug info is held in the heap root object
 // debug_info which is a FixedArray. Each entry in this list is of class
 // DebugInfo.
 class Debug {
  public:
   enum AfterCompileFlags {
@@ skipping 12 matching lines @@
   // API facing.
   void SetEventListener(Handle<Object> callback, Handle<Object> data);
   void SetMessageHandler(v8::Debug::MessageHandler handler);
   void EnqueueCommandMessage(Vector<const uint16_t> command,
                              v8::Debug::ClientData* client_data = NULL);
   // Enqueue a debugger command to the command queue for event listeners.
   void EnqueueDebugCommand(v8::Debug::ClientData* client_data = NULL);
   MUST_USE_RESULT MaybeHandle<Object> Call(Handle<JSFunction> fun,
                                            Handle<Object> data);
   Handle<Context> GetDebugContext();
-  void DebugBreakHelper();
+  void HandleDebugBreak();
   void ProcessDebugMessages(bool debug_command_only);
 
-  // Flags and states.
-  void set_live_edit_enabled(bool v) { live_edit_enabled_ = v; }
-  bool live_edit_enabled() const {
-    return FLAG_enable_liveedit && live_edit_enabled_ ;
-  }
-
-  inline bool is_active() const { return is_active_; }
-  inline bool is_loaded() const { return !debug_context_.is_null(); }
-  inline bool has_break_points() const { return has_break_points_; }
-  inline bool is_entered() const {
-    return thread_local_.debugger_entry_ != NULL;
-  }
-
-  void set_disable_break(bool v) { break_disabled_ = v; }
-
+  // Internal logic
   bool Load();
-
   void Break(Arguments args, JavaScriptFrame*);
   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,
                               int* source_position,
                               BreakPositionAlignment alignment);
   void ClearBreakPoint(Handle<Object> break_point_object);
   void ClearAllBreakPoints();
   void FloodWithOneShot(Handle<JSFunction> function);
   void FloodBoundFunctionWithOneShot(Handle<JSFunction> function);
   void FloodHandlerWithOneShot();
   void ChangeBreakOnException(ExceptionBreakType type, bool enable);
   bool IsBreakOnException(ExceptionBreakType type);
 
-  void PromiseHandlePrologue(Handle<JSFunction> promise_getter);
-  void PromiseHandleEpilogue();
-  // Returns a promise if it does not have a reject handler.
-  Handle<Object> GetPromiseForUncaughtException();
-
+  // Stepping handling.
   void PrepareStep(StepAction step_action,
                    int step_count,
                    StackFrame::Id frame_id);
   void ClearStepping();
   void ClearStepOut();
   bool IsStepping() { return thread_local_.step_count_ > 0; }
   bool StepNextContinue(BreakLocationIterator* break_location_iterator,
                         JavaScriptFrame* frame);
+  bool StepInActive() { return thread_local_.step_into_fp_ != 0; }
+  void HandleStepIn(Handle<JSFunction> function,
+                    Handle<Object> holder,
+                    Address fp,
+                    bool is_constructor);
+  bool StepOutActive() { return thread_local_.step_out_fp_ != 0; }
+
+  // Purge all code objects that have no debug break slots.
+  void PrepareForBreakPoints();
 
   // Returns whether the operation succeeded. Compilation can only be triggered
   // if a valid closure is passed as the second argument, otherwise the shared
   // function needs to be compiled already.
   bool EnsureDebugInfo(Handle<SharedFunctionInfo> shared,
                        Handle<JSFunction> function);
   static Handle<DebugInfo> GetDebugInfo(Handle<SharedFunctionInfo> shared);
   static bool HasDebugInfo(Handle<SharedFunctionInfo> shared);
 
-  void PrepareForBreakPoints();
-
   // This function is used in FunctionNameUsing* tests.
   Object* FindSharedFunctionInfoInScript(Handle<Script> script, int position);
 
-
   // Returns true if the current stub call is patched to call the debugger.
   static bool IsDebugBreak(Address addr);
   // Returns true if the current return statement has been patched to be
   // a debugger breakpoint.
   static bool IsDebugBreakAtReturn(RelocInfo* rinfo);
-  // Check whether a code stub with the specified major key is a possible break
-  // point location.
-  static bool IsSourceBreakStub(Code* code);
-  static bool IsBreakStub(Code* code);
-  // Find the builtin to use for invoking the debug break
-  static Handle<Code> FindDebugBreak(Handle<Code> code, RelocInfo::Mode mode);
 
   static Handle<Object> GetSourceBreakLocations(
       Handle<SharedFunctionInfo> shared,
       BreakPositionAlignment position_aligment);
 
-  // Getter for the debug_context.
-  inline Handle<Context> debug_context() { return debug_context_; }
-
   // Check whether a global object is the debug global object.
   bool IsDebugGlobal(GlobalObject* global);
 
   // Check whether this frame is just about to return.
   bool IsBreakAtReturn(JavaScriptFrame* frame);
 
-  StackFrame::Id break_frame_id() { return thread_local_.break_frame_id_; }
-  int break_id() { return thread_local_.break_id_; }
+  // Promise handling.
+  void PromiseHandlePrologue(Handle<JSFunction> promise_getter);
+  void PromiseHandleEpilogue();
 
-  bool StepInActive() { return thread_local_.step_into_fp_ != 0; }
-  void HandleStepIn(Handle<JSFunction> function,
-                    Handle<Object> holder,
-                    Address fp,
-                    bool is_constructor);
-  Address step_in_fp() { return thread_local_.step_into_fp_; }
-  Address* step_in_fp_addr() { return &thread_local_.step_into_fp_; }
-
-  bool StepOutActive() { return thread_local_.step_out_fp_ != 0; }
-  Address step_out_fp() { return thread_local_.step_out_fp_; }
-
-  EnterDebugger* debugger_entry() { return thread_local_.debugger_entry_; }
-
-  // Check whether any of the specified interrupts are pending.
-  bool has_pending_interrupt() {
-    return thread_local_.has_pending_interrupt_;
-  }
-
-  // Set specified interrupts as pending.
-  void set_has_pending_interrupt(bool value) {
-    thread_local_.has_pending_interrupt_ = value;
-  }
-
-  // Getters for the current exception break state.
-  bool break_on_exception() { return break_on_exception_; }
-  bool break_on_uncaught_exception() {
-    return break_on_uncaught_exception_;
-  }
-
+  // Support for LiveEdit
   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.
+  // Passed to MakeWeak.
+  static void HandleWeakDebugInfo(
+      const v8::WeakCallbackData<v8::Value, void>& data);
+
+  // Threading support.
+  char* ArchiveDebug(char* to);
+  char* RestoreDebug(char* from);
+  static int ArchiveSpacePerThread();
+  void FreeThreadResources() { }
+
+  // Record function from which eval was called.
+  static void RecordEvalCaller(Handle<Script> script);
+
+  // Garbage collection notifications.
+  void AfterGarbageCollection();
+
+  // Flags and states.
+  EnterDebugger* debugger_entry() { return thread_local_.debugger_entry_; }
+  inline Handle<Context> debug_context() { return debug_context_; }
+  void set_live_edit_enabled(bool v) { live_edit_enabled_ = v; }
+  bool live_edit_enabled() const {
+    return FLAG_enable_liveedit && live_edit_enabled_ ;
+  }
+
+  inline bool is_active() const { return is_active_; }
+  inline bool is_loaded() const { return !debug_context_.is_null(); }
+  inline bool has_break_points() const { return has_break_points_; }
+  inline bool is_entered() const {
+    return thread_local_.debugger_entry_ != NULL;
+  }
+  void set_disable_break(bool v) { break_disabled_ = v; }
+
+  StackFrame::Id break_frame_id() { return thread_local_.break_frame_id_; }
+  int break_id() { return thread_local_.break_id_; }
+
+  // Support for embedding into generated code.
   Address after_break_target_address() {
     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.
-  static void HandleWeakDebugInfo(
-      const v8::WeakCallbackData<v8::Value, void>& data);
-
-  friend Handle<FixedArray> GetDebuggedFunctions();  // In test-debug.cc
-  friend void CheckDebuggerUnloaded(bool check_functions);  // In test-debug.cc
-
-  // Threading support.
-  char* ArchiveDebug(char* to);
-  char* RestoreDebug(char* from);
-  static int ArchiveSpacePerThread();
-  void FreeThreadResources() { }
-
-  // Script cache handling.
-  void CreateScriptCache();
-  void DestroyScriptCache();
-  void AddScriptToScriptCache(Handle<Script> script);
-  Handle<FixedArray> GetLoadedScripts();
-
-  // Record function from which eval was called.
-  static void RecordEvalCaller(Handle<Script> script);
-
-  // Garbage collection notifications.
-  void AfterGarbageCollection();
+  Address step_in_fp_addr() {
+    return reinterpret_cast<Address>(&thread_local_.step_into_fp_);
+  }
 
  private:
   explicit Debug(Isolate* isolate);
 
   void UpdateState();
   void Unload();
-
-  // Mirror cache handling.
-  void ClearMirrorCache();
-
   void SetNextBreakId() {
     thread_local_.break_id_ = ++thread_local_.break_count_;
   }
 
   // Check whether there are commands in the command queue.
   inline bool has_commands() const { return !command_queue_.IsEmpty(); }
+  inline bool ignore_events() const { return is_suppressed_ || !is_active_; }
 
   // Constructors for debug event objects.
   MUST_USE_RESULT MaybeHandle<Object> MakeJSObject(
       const char* constructor_name,
       int argc,
       Handle<Object> argv[]);
   MUST_USE_RESULT MaybeHandle<Object> MakeExecutionState();
   MUST_USE_RESULT MaybeHandle<Object> MakeBreakEvent(
       Handle<Object> break_points_hit);
   MUST_USE_RESULT MaybeHandle<Object> MakeExceptionEvent(
       Handle<Object> exception,
       bool uncaught,
       Handle<Object> promise);
   MUST_USE_RESULT MaybeHandle<Object> MakeCompileEvent(
       Handle<Script> script, bool before);
   MUST_USE_RESULT MaybeHandle<Object> MakeScriptCollectedEvent(int id);
 
+  // Mirror cache handling.
+  void ClearMirrorCache();
+
+  // Returns a promise if it does not have a reject handler.
+  Handle<Object> GetPromiseForUncaughtException();
 
   void CallEventCallback(v8::DebugEvent event,
                          Handle<Object> exec_state,
                          Handle<Object> event_data,
                          v8::Debug::ClientData* client_data);
-
   void ProcessDebugEvent(v8::DebugEvent event,
                          Handle<JSObject> event_data,
                          bool auto_continue);
   void NotifyMessageHandler(v8::DebugEvent event,
                             Handle<JSObject> exec_state,
                             Handle<JSObject> event_data,
                             bool auto_continue);
-
-  // Invoke the message handler function.
   void InvokeMessageHandler(MessageImpl message);
 
-  inline bool EventActive() {
-    // Check whether the message handler was been cleared.
-    // TODO(yangguo): handle loading and unloading of the debugger differently.
-    // Currently argument event is not used.
-    return !is_suppressed_ && is_active_;
-  }
-
   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);
   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 {
-   public:
-    PromiseOnStack(Isolate* isolate,
-                   PromiseOnStack* prev,
-                   Handle<JSFunction> getter);
-    ~PromiseOnStack();
-    StackHandler* handler() { return handler_; }
-    Handle<JSFunction> getter() { return getter_; }
-    PromiseOnStack* prev() { return prev_; }
-   private:
-    Isolate* isolate_;
-    StackHandler* handler_;
-    Handle<JSFunction> getter_;
-    PromiseOnStack* prev_;
-  };
-
   // Global handles.
   Handle<Context> debug_context_;
   Handle<Object> event_listener_;
   Handle<Object> event_listener_data_;
 
   v8::Debug::MessageHandler message_handler_;
 
   static const int kQueueInitialSize = 4;
   Semaphore command_received_;  // Signaled for each command received.
   LockingCommandMessageQueue command_queue_;
@@ skipping 45 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_;
 
-    // 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.
     Object** restarter_frame_function_pointer_;
 
     // When a promise is being resolved, we may want to trigger a debug event
     // if we catch a throw.  For this purpose we remember the try-catch
     // handler address that would catch the exception.  We also hold onto a
     // closure that returns a promise if the exception is considered uncaught.
     // Due to the possibility of reentry we use a linked list.
     PromiseOnStack* promise_on_stack_;
   };
 
   // Storage location for registers when handling debug break calls
   ThreadLocal thread_local_;
 
   Isolate* isolate_;
 
   friend class Isolate;
   friend class EnterDebugger;
   friend class FrameDropper;
   friend class DisableBreak;
   friend class SuppressDebug;
 
+  friend Handle<FixedArray> GetDebuggedFunctions();  // In test-debug.cc
+  friend void CheckDebuggerUnloaded(bool check_functions);  // In test-debug.cc
+
   DISALLOW_COPY_AND_ASSIGN(Debug);
 };
 
 
 DECLARE_RUNTIME_FUNCTION(Debug_Break);
 
 
 // This class is used for entering the debugger. Create an instance in the stack
 // to enter the debugger. This will set the current break state, make sure the
 // debugger is loaded and switch to the debugger context. If the debugger for
 // some reason could not be entered FailedToEnter will return true.
 class EnterDebugger BASE_EMBEDDED {
  public:
   explicit EnterDebugger(Isolate* isolate);
   ~EnterDebugger();
 
   // Check whether the debugger could be entered.
   inline bool FailedToEnter() { return load_failed_; }
 
-  // Check whether there are any JavaScript frames on the stack.
-  inline bool HasJavaScriptFrames() { return has_js_frames_; }
-
   // Get the active context from before entering the debugger.
   inline Handle<Context> GetContext() { return save_.context(); }
 
  private:
   Isolate* isolate_;
   EnterDebugger* prev_;  // Previous debugger entry if entered recursively.
-  bool has_js_frames_;  // Were there any JavaScript frames?
   StackFrame::Id break_frame_id_;  // Previous break frame id.
   int break_id_;  // Previous break id.
   bool load_failed_;  // Did the debugger fail to load?
   SaveContext save_;  // Saves previous context.
 };
 
 
 // Stack allocated class for disabling break.
 class DisableBreak BASE_EMBEDDED {
  public:
@@ skipping 46 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_