Revert "Per-closure breakpoints; restructure breakpoint implementation to keep a list of conditions…

runtime/vm/debugger.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_DEBUGGER_H_
 #define VM_DEBUGGER_H_
 
 #include "include/dart_debugger_api.h"
 
 #include "vm/object.h"
 #include "vm/port.h"
 
 namespace dart {
 
 class CodeBreakpoint;
 class Isolate;
 class JSONArray;
 class JSONStream;
 class ObjectPointerVisitor;
 class RemoteObjectCache;
-class BreakpointLocation;
+class SourceBreakpoint;
 class StackFrame;
 
-// A user-defined breakpoint, which either fires once, for a particular closure,
-// or always. The API's notion of a breakpoint corresponds to this object.
-class Breakpoint {
- public:
-  Breakpoint(intptr_t id, BreakpointLocation* bpt_location)
-    : id_(id),
-      kind_(Breakpoint::kNone),
-      next_(NULL),
-      closure_(Instance::null()),
-      bpt_location_(bpt_location) {}
-
-  intptr_t id() const { return id_; }
-  Breakpoint* next() const { return next_; }
-  void set_next(Breakpoint* n) { next_ = n; }
-
-  BreakpointLocation* bpt_location() const { return bpt_location_; }
-  void set_bpt_location(BreakpointLocation* new_bpt_location);
-
-  bool IsRepeated() const { return kind_ == kRepeated; }
-  bool IsSingleShot() const { return kind_ == kSingleShot; }
-  bool IsPerClosure() const { return kind_ == kPerClosure; }
-  RawInstance* closure() const { return closure_; }
-
-  void SetIsRepeated() {
-    ASSERT(kind_ == kNone);
-    kind_ = kRepeated;
-  }
-
-  void SetIsSingleShot() {
-    ASSERT(kind_ == kNone);
-    kind_ = kSingleShot;
-  }
-
-  void SetIsPerClosure(const Instance& closure) {
-    ASSERT(kind_ == kNone);
-    kind_ = kPerClosure;
-    closure_ = closure.raw();
-  }
-
-  void PrintJSON(JSONStream* stream);
-
- private:
-  void VisitObjectPointers(ObjectPointerVisitor* visitor);
-
-  enum ConditionKind {
-    kNone,
-    kRepeated,
-    kSingleShot,
-    kPerClosure,
-  };
-
-  intptr_t id_;
-  ConditionKind kind_;
-  Breakpoint* next_;
-  RawInstance* closure_;
-  BreakpointLocation* bpt_location_;
-
-  friend class BreakpointLocation;
-  DISALLOW_COPY_AND_ASSIGN(Breakpoint);
-};
-
-
-// BreakpointLocation represents a collection of breakpoint conditions at the
-// same token position in Dart source. There may be more than one CodeBreakpoint
-// object per BreakpointLocation.
+// SourceBreakpoint represents a user-specified breakpoint location in
+// Dart source. There may be more than one CodeBreakpoint object per
+// SourceBreakpoint.
 // An unresolved breakpoint is one where the underlying code has not
 // been compiled yet. Since the code has not been compiled, we don't know
 // the definitive source location yet. The requested source location may
 // change when the underlying code gets compiled.
 // A latent breakpoint represents a breakpoint location in Dart source
 // that is not loaded in the VM when the breakpoint is requested.
 // When a script with matching url is loaded, a latent breakpoint
 // becomes an unresolved breakpoint.
-class BreakpointLocation {
+class SourceBreakpoint {
  public:
   // Create a new unresolved breakpoint.
-  BreakpointLocation(const Script& script,
-                     intptr_t token_pos,
-                     intptr_t end_token_pos);
+  SourceBreakpoint(intptr_t id,
+                   const Script& script,
+                   intptr_t token_pos,
+                   intptr_t end_token_pos);
   // Create a new latent breakpoint.
-  BreakpointLocation(const String& url,
-                     intptr_t line_number);
-
-  ~BreakpointLocation();
+  SourceBreakpoint(intptr_t id,
+                   const String& url,
+                   intptr_t line_number);
 
   RawFunction* function() const { return function_; }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t end_token_pos() const { return end_token_pos_; }
+  intptr_t id() const { return id_; }
 
   RawScript* script() const { return script_; }
   RawString* url() const { return url_; }
   intptr_t LineNumber();
 
   void GetCodeLocation(Library* lib, Script* script, intptr_t* token_pos);
 
-  Breakpoint* AddRepeated(Debugger* dbg);
-  Breakpoint* AddSingleShot(Debugger* dbg);
-  Breakpoint* AddPerClosure(Debugger* dbg, const Instance& closure);
-
-  bool AnyEnabled() const;
+  void Enable();
+  void Disable();
+  bool IsEnabled() const { return is_enabled_; }
   bool IsResolved() const { return is_resolved_; }
   bool IsLatent() const { return token_pos_ < 0; }
 
+  bool IsOneShot() const { return is_one_shot_; }
+  void SetIsOneShot() { is_one_shot_ = true; }
+
+  void PrintJSON(JSONStream* stream);
+
  private:
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   void SetResolved(const Function& func, intptr_t token_pos);
+  void set_next(SourceBreakpoint* value) { next_ = value; }
+  SourceBreakpoint* next() const { return this->next_; }
 
-  BreakpointLocation* next() const { return this->next_; }
-  void set_next(BreakpointLocation* value) { next_ = value; }
-
-  void AddBreakpoint(Breakpoint* bpt, Debugger* dbg);
-
-  Breakpoint* breakpoints() const { return this->conditions_; }
-  void set_breakpoints(Breakpoint* head) { this->conditions_ = head; }
-
+  const intptr_t id_;
   RawScript* script_;
   RawString* url_;
   intptr_t token_pos_;
   intptr_t end_token_pos_;
   bool is_resolved_;
-  BreakpointLocation* next_;
-  Breakpoint* conditions_;
+  bool is_enabled_;
+  bool is_one_shot_;
+  SourceBreakpoint* next_;
 
   // Valid for resolved breakpoints:
   RawFunction* function_;
   intptr_t line_number_;
 
   friend class Debugger;
-  DISALLOW_COPY_AND_ASSIGN(BreakpointLocation);
+  DISALLOW_COPY_AND_ASSIGN(SourceBreakpoint);
 };
 
 
 // CodeBreakpoint represents a location in compiled code. There may be
-// more than one CodeBreakpoint for one BreakpointLocation, e.g. when a
+// more than one CodeBreakpoint for one SourceBreakpoint, e.g. when a
 // function gets compiled as a regular function and as a closure.
 class CodeBreakpoint {
  public:
   CodeBreakpoint(const Code& code,
                  intptr_t token_pos,
                  uword pc,
                  RawPcDescriptors::Kind kind);
   ~CodeBreakpoint();
 
   RawFunction* function() const;
   uword pc() const { return pc_; }
   intptr_t token_pos() const { return token_pos_; }
-  bool IsInternal() const { return bpt_location_ == NULL; }
+  bool IsInternal() const { return src_bpt_ == NULL; }
 
   RawScript* SourceCode();
   RawString* SourceUrl();
   intptr_t LineNumber();
 
   void Enable();
   void Disable();
   bool IsEnabled() const { return is_enabled_; }
 
   uword OrigStubAddress() const;
 
  private:
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
-  BreakpointLocation* bpt_location() const { return bpt_location_; }
-  void set_bpt_location(BreakpointLocation* value) { bpt_location_ = value; }
+  SourceBreakpoint* src_bpt() const { return src_bpt_; }
+  void set_src_bpt(SourceBreakpoint* value) { src_bpt_ = value; }
 
   void set_next(CodeBreakpoint* value) { next_ = value; }
   CodeBreakpoint* next() const { return this->next_; }
 
   void PatchCode();
   void RestoreCode();
 
   RawCode* code_;
   intptr_t token_pos_;
   uword pc_;
   intptr_t line_number_;
   bool is_enabled_;
 
-  BreakpointLocation* bpt_location_;
+  SourceBreakpoint* src_bpt_;
   CodeBreakpoint* next_;
 
   RawPcDescriptors::Kind breakpoint_kind_;
   uword saved_value_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(CodeBreakpoint);
 };
 
 
@@ skipping 37 matching lines @@
 
   intptr_t NumLocalVariables();
 
   void VariableAt(intptr_t i,
                   String* name,
                   intptr_t* token_pos,
                   intptr_t* end_pos,
                   Object* value);
 
   RawArray* GetLocalVariables();
-  RawObject* GetParameter(intptr_t index);
-  RawObject* GetClosure();
   RawObject* GetReceiver();
 
   const Context& GetSavedCurrentContext();
 
   RawObject* Evaluate(const String& expr);
 
   // Print the activation frame into |jsobj|. if |full| is false, script
   // and local variable objects are only references. if |full| is true,
   // the complete script, function, and, local variable objects are included.
   void PrintToJSONObject(JSONObject* jsobj, bool full = false);
@@ skipping 59 matching lines @@
 
  private:
   void AddActivation(ActivationFrame* frame);
   ZoneGrowableArray<ActivationFrame*> trace_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(DebuggerStackTrace);
 };
 
 
+typedef void BreakpointHandler(Dart_Port isolate_id,
+                               SourceBreakpoint* bpt,
+                               DebuggerStackTrace* stack);
+
+
 class DebuggerEvent {
  public:
   enum EventType {
     kBreakpointReached = 1,
     kBreakpointResolved = 2,
     kExceptionThrown = 3,
     kIsolateCreated = 4,
     kIsolateShutdown = 5,
     kIsolateInterrupted = 6,
   };
@@ skipping 17 matching lines @@
 
   ActivationFrame* top_frame() const {
     ASSERT(IsPauseEvent());
     return top_frame_;
   }
   void set_top_frame(ActivationFrame* frame) {
     ASSERT(IsPauseEvent());
     top_frame_ = frame;
   }
 
-  Breakpoint* breakpoint() const {
+  SourceBreakpoint* breakpoint() const {
     ASSERT(type_ == kBreakpointReached || type_ == kBreakpointResolved);
     return breakpoint_;
   }
-  void set_breakpoint(Breakpoint* bpt) {
+  void set_breakpoint(SourceBreakpoint* bpt) {
     ASSERT(type_ == kBreakpointReached || type_ == kBreakpointResolved);
     breakpoint_ = bpt;
   }
 
   const Object* exception() const {
     ASSERT(type_ == kExceptionThrown);
     return exception_;
   }
   void set_exception(const Object* exception) {
     ASSERT(type_ == kExceptionThrown);
     exception_ = exception;
   }
 
   Dart_Port isolate_id() const {
     return isolate_->main_port();
   }
 
  private:
   Isolate* isolate_;
   EventType type_;
   ActivationFrame* top_frame_;
-  Breakpoint* breakpoint_;
+  SourceBreakpoint* breakpoint_;
   const Object* exception_;
 };
 
 
 class Debugger {
  public:
   typedef void EventHandler(DebuggerEvent* event);
 
   Debugger();
   ~Debugger();
 
   void Initialize(Isolate* isolate);
   void NotifyIsolateCreated();
   void Shutdown();
 
   void NotifyCompilation(const Function& func);
   void NotifyDoneLoading();
 
   RawFunction* ResolveFunction(const Library& library,
                                const String& class_name,
                                const String& function_name);
 
   // Set breakpoint at closest location to function entry.
-  Breakpoint* SetBreakpointAtEntry(const Function& target_function,
-                                   bool single_shot);
-  Breakpoint* SetBreakpointAtActivation(const Instance& closure);
+  SourceBreakpoint* SetBreakpointAtEntry(const Function& target_function);
 
   // TODO(turnidge): script_url may no longer be specific enough.
-  Breakpoint* SetBreakpointAtLine(const String& script_url,
-                                  intptr_t line_number);
+  SourceBreakpoint* SetBreakpointAtLine(const String& script_url,
+                                        intptr_t line_number);
   RawError* OneTimeBreakAtEntry(const Function& target_function);
 
-  BreakpointLocation* BreakpointLocationAtLine(const String& script_url,
-                                               intptr_t line_number);
-
-
   void RemoveBreakpoint(intptr_t bp_id);
-  Breakpoint* GetBreakpointById(intptr_t id);
+  SourceBreakpoint* GetBreakpointById(intptr_t id);
 
   void SetStepOver();
   void SetSingleStep();
   void SetStepOut();
   bool IsStepping() const { return resume_action_ != kContinue; }
 
   bool IsPaused() const { return pause_event_ != NULL; }
 
   // Indicates why the debugger is currently paused.  If the debugger
   // is not paused, this returns NULL.  Note that the debugger can be
@@ skipping 82 matching lines @@
                              intptr_t start_pos,
                              intptr_t end_pos,
                              GrowableObjectArray* function_list);
   RawFunction* FindBestFit(const Script& script, intptr_t token_pos);
   RawFunction* FindInnermostClosure(const Function& function,
                                     intptr_t token_pos);
   intptr_t ResolveBreakpointPos(const Function& func,
                                 intptr_t requested_token_pos,
                                 intptr_t last_token_pos);
   void DeoptimizeWorld();
-  BreakpointLocation* SetBreakpoint(const Script& script,
-                                    intptr_t token_pos,
-                                    intptr_t last_token_pos);
+  SourceBreakpoint* SetBreakpoint(const Script& script,
+                                  intptr_t token_pos,
+                                  intptr_t last_token_pos);
   void RemoveInternalBreakpoints();
-  void UnlinkCodeBreakpoints(BreakpointLocation* bpt_location);
-  BreakpointLocation* GetLatentBreakpoint(const String& url, intptr_t line);
-  void RegisterBreakpointLocation(BreakpointLocation* bpt);
+  void UnlinkCodeBreakpoints(SourceBreakpoint* src_bpt);
+  SourceBreakpoint* GetLatentBreakpoint(const String& url, intptr_t line);
+  void RegisterSourceBreakpoint(SourceBreakpoint* bpt);
   void RegisterCodeBreakpoint(CodeBreakpoint* bpt);
-  BreakpointLocation* GetBreakpointLocation(const Script& script,
-                                            intptr_t token_pos);
+  SourceBreakpoint* GetSourceBreakpoint(const Script& script,
+                                        intptr_t token_pos);
   void MakeCodeBreakpointAt(const Function& func,
-                            BreakpointLocation* bpt);
+                            SourceBreakpoint* bpt);
   // Returns NULL if no breakpoint exists for the given address.
   CodeBreakpoint* GetCodeBreakpoint(uword breakpoint_address);
 
-  void SyncBreakpointLocation(BreakpointLocation* loc);
+  void SyncBreakpoint(SourceBreakpoint* bpt);
 
   ActivationFrame* TopDartFrame() const;
   static ActivationFrame* CollectDartFrame(Isolate* isolate,
                                            uword pc,
                                            StackFrame* frame,
                                            const Code& code,
                                            const Array& deopt_frame,
                                            intptr_t deopt_frame_offset);
   static RawArray* DeoptimizeToArray(Isolate* isolate,
                                      StackFrame* frame,
                                      const Code& code);
   static DebuggerStackTrace* CollectStackTrace();
-  void SignalBpResolved(Breakpoint *bpt);
+  void SignalBpResolved(SourceBreakpoint *bpt);
   void SignalPausedEvent(ActivationFrame* top_frame,
-                         Breakpoint* bpt);
+                         SourceBreakpoint* bpt);
 
   intptr_t nextId() { return next_id_++; }
 
   bool ShouldPauseOnException(DebuggerStackTrace* stack_trace,
                               const Instance& exc);
 
   void CollectLibraryFields(const GrowableObjectArray& field_list,
                             const Library& lib,
                             const String& prefix,
                             bool include_private_fields);
 
   // Handles any events which pause vm execution.  Breakpoints,
   // interrupts, etc.
   void Pause(DebuggerEvent* event);
 
   void HandleSteppingRequest(DebuggerStackTrace* stack_trace);
 
   Isolate* isolate_;
   Dart_Port isolate_id_;  // A unique ID for the isolate in the debugger.
   bool initialized_;
 
   // ID number generator.
   intptr_t next_id_;
 
-  BreakpointLocation* latent_locations_;
-  BreakpointLocation* breakpoint_locations_;
+  SourceBreakpoint* latent_breakpoints_;
+  SourceBreakpoint* src_breakpoints_;
   CodeBreakpoint* code_breakpoints_;
 
   // Tells debugger what to do when resuming execution after a breakpoint.
   ResumeAction resume_action_;
 
   // Do not call back to breakpoint handler if this flag is set.
   // Effectively this means ignoring breakpoints. Set when Dart code may
   // be run as a side effect of getting values of fields.
   bool ignore_breakpoints_;
 
@@ skipping 12 matching lines @@
   // When stepping through code, only pause the program if the top
   // frame corresponds to this fp value, or if the top frame is
   // lower on the stack.
   uword stepping_fp_;
 
   Dart_ExceptionPauseInfo exc_pause_info_;
 
   static EventHandler* event_handler_;
 
   friend class Isolate;
-  friend class BreakpointLocation;
+  friend class SourceBreakpoint;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DEBUGGER_H_