[futex] Allow debugger to break in the middle of a futexWait

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 580 matching lines @@
   LockingCommandMessageQueue command_queue_;
 
   bool is_active_;
   bool is_suppressed_;
   bool live_edit_enabled_;
   bool has_break_points_;
   bool break_disabled_;
   bool in_debug_event_listener_;
   bool break_on_exception_;
   bool break_on_uncaught_exception_;
+  bool break_in_nondebuggable_;
 
   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 {
@@ skipping 45 matching lines @@
   // Storage location for registers when handling debug break calls
   ThreadLocal thread_local_;
 
   Isolate* isolate_;
 
   friend class Isolate;
   friend class DebugScope;
   friend class DisableBreak;
   friend class LiveEdit;
   friend class SuppressDebug;
+  friend class EnableBreakInNonDebuggable;
 
   friend Handle<FixedArray> GetDebuggedFunctions();  // In test-debug.cc
   friend void CheckDebuggerUnloaded(bool check_functions);  // In test-debug.cc
 
   DISALLOW_COPY_AND_ASSIGN(Debug);
 };
 
 
 // This scope is used to load and enter the debug context and create a new
 // break state.  Leaving the scope will restore the previous state.
@@ skipping 38 matching lines @@
   }
 
  private:
   Debug* debug_;
   bool previous_break_disabled_;
   bool previous_in_debug_event_listener_;
   DISALLOW_COPY_AND_ASSIGN(DisableBreak);
 };
 
 
+// Stack allocated class for enabling breaking in a normally non-debuggable
+// function (e.g. a builtin).
+class EnableBreakInNonDebuggable BASE_EMBEDDED {
+ public:
+  explicit EnableBreakInNonDebuggable(Debug* debug, bool enable)
+      : debug_(debug), previous_(debug->break_in_nondebuggable_) {
+    debug_->break_in_nondebuggable_ = enable;
+  }
+  ~EnableBreakInNonDebuggable() { debug_->break_in_nondebuggable_ = previous_; }
+
+ private:
+  Debug* debug_;
+  bool previous_;
+  DISALLOW_COPY_AND_ASSIGN(EnableBreakInNonDebuggable);
+};
+
+
 class SuppressDebug BASE_EMBEDDED {
  public:
   explicit SuppressDebug(Debug* debug)
       : debug_(debug), old_state_(debug->is_suppressed_) {
     debug_->is_suppressed_ = true;
   }
   ~SuppressDebug() { debug_->is_suppressed_ = old_state_; }
 
  private:
   Debug* debug_;
@@ skipping 26 matching lines @@
                            int call_argc = -1);
 
   static void PatchDebugBreakSlot(Address pc, Handle<Code> code);
   static void ClearDebugBreakSlot(Address pc);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEBUG_DEBUG_H_