Implement rewind: drop one or more frames from the debugger.

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 RUNTIME_VM_DEBUGGER_H_
 #define RUNTIME_VM_DEBUGGER_H_
 
 #include "include/dart_tools_api.h"
 
 #include "vm/object.h"
@@ skipping 258 matching lines @@
   RawScript* SourceScript();
   RawLibrary* Library();
   TokenPosition TokenPos();
   intptr_t LineNumber();
   intptr_t ColumnNumber();
 
   // Returns true if this frame is for a function that is visible
   // to the user and can be debugged.
   bool IsDebuggable() const;
 
+  // Returns true if it is possible to rewind the debugger to this frame.
+  bool IsRewindable() const;
+
   // The context level of a frame is the context level at the
   // PC/token index of the frame. It determines the depth of the context
   // chain that belongs to the function of this activation frame.
   intptr_t ContextLevel();
 
   const char* ToCString();
 
   intptr_t NumLocalVariables();
 
   void VariableAt(intptr_t i,
@@ skipping 77 matching lines @@
   void AddActivation(ActivationFrame* frame);
   ZoneGrowableArray<ActivationFrame*> trace_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(DebuggerStackTrace);
 };
 
 
 class Debugger {
  public:
+  enum ResumeAction {
+    kContinue,
+    kStepInto,
+    kStepOver,
+    kStepOut,
+    kStepRewind,
+    kStepOverAsyncSuspension,
+  };
+
   typedef void EventHandler(ServiceEvent* event);
 
   Debugger();
   ~Debugger();
 
   void Initialize(Isolate* isolate);
   void NotifyIsolateCreated();
   void Shutdown();
 
   void NotifyCompilation(const Function& func);
@@ skipping 19 matching lines @@
   RawError* OneTimeBreakAtEntry(const Function& target_function);
 
   BreakpointLocation* BreakpointLocationAtLineCol(const String& script_url,
                                                   intptr_t line_number,
                                                   intptr_t column_number);
 
 
   void RemoveBreakpoint(intptr_t bp_id);
   Breakpoint* GetBreakpointById(intptr_t id);
 
-  // Will return false if we are not at an await.
-  bool SetupStepOverAsyncSuspension();
-  void SetStepOver();
-  void SetSingleStep();
-  void SetStepOut();
+  bool SetResumeAction(ResumeAction action,
+                       intptr_t frame_index = 1,
+                       const char** error = NULL);
+
   bool IsStepping() const { return resume_action_ != kContinue; }
 
   bool IsPaused() const { return pause_event_ != NULL; }
 
   // Put the isolate into single stepping mode when Dart code next runs.
   //
   // This is used by the vm service to allow the user to step while
   // paused at isolate start.
   void EnterSingleStepMode();
 
@@ skipping 76 matching lines @@
 
   RawCode* GetPatchedStubAddress(uword breakpoint_address);
 
   void PrintBreakpointsToJSONArray(JSONArray* jsarr) const;
   void PrintSettingsToJSONObject(JSONObject* jsobj) const;
 
   static bool IsDebuggable(const Function& func);
 
   intptr_t limitBreakpointId() { return next_id_; }
 
+  // Callback to the debugger to continue frame rewind, post-deoptimization.
+  void RewindPostDeopt();
+
  private:
-  enum ResumeAction { kContinue, kStepOver, kStepOut, kSingleStep };
+  RawError* PauseRequest(ServiceEvent::EventKind kind);
 
-  RawError* PauseRequest(ServiceEvent::EventKind kind);
+  // Will return false if we are not at an await.
+  bool SetupStepOverAsyncSuspension(const char** error);
 
   bool NeedsIsolateEvents();
   bool NeedsDebugEvents();
   void InvokeEventHandler(ServiceEvent* event);
 
   void SendBreakpointEvent(ServiceEvent::EventKind kind, Breakpoint* bpt);
 
   bool IsAtAsyncJump(ActivationFrame* top_frame);
   void FindCompiledFunctions(const Script& script,
                              TokenPosition start_pos,
@@ skipping 51 matching lines @@
                             const String& prefix,
                             bool include_private_fields);
 
   // Handles any events which pause vm execution.  Breakpoints,
   // interrupts, etc.
   void Pause(ServiceEvent* event);
 
   void HandleSteppingRequest(DebuggerStackTrace* stack_trace,
                              bool skip_next_step = false);
 
+  // Can we rewind to the indicated frame?
+  bool CanRewindFrame(intptr_t frame_index, const char** error) const;
+
+  void RewindToFrame(intptr_t frame_index);
+  void RewindToUnoptimizedFrame(StackFrame* frame, const Code& code);
+  void RewindToOptimizedFrame(StackFrame* frame,
+                              const Code& code,
+                              intptr_t post_deopt_frame_index);
+
   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_;
   CodeBreakpoint* code_breakpoints_;
 
   // Tells debugger what to do when resuming execution after a breakpoint.
   ResumeAction resume_action_;
+  intptr_t resume_frame_index_;
+  intptr_t post_deopt_frame_index_;
 
   // 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_;
 
   // Indicates why the debugger is currently paused.  If the debugger
   // is not paused, this is NULL.  Note that the debugger can be
   // paused for breakpoints, isolate interruption, and (sometimes)
   // exceptions.
@@ skipping 26 matching lines @@
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DEBUGGER_H_