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

runtime/vm/debugger.cc

 // 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.
 
 #include "vm/debugger.h"
 
 #include "include/dart_api.h"
 
-#include "platform/address_sanitizer.h"
-
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/deopt_instructions.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
 #include "vm/json_stream.h"
 #include "vm/message_handler.h"
@@ skipping 16 matching lines @@
 namespace dart {
 
 DEFINE_FLAG(bool,
             show_invisible_frames,
             false,
             "Show invisible frames in debugger stack traces");
 DEFINE_FLAG(bool,
             trace_debugger_stacktrace,
             false,
             "Trace debugger stacktrace collection");
-DEFINE_FLAG(bool, trace_rewind, false, "Trace frame rewind");
 DEFINE_FLAG(bool, verbose_debug, false, "Verbose debugger messages");
 DEFINE_FLAG(bool,
             steal_breakpoints,
             false,
             "Intercept breakpoints and other pause events before they "
             "are sent to the embedder and use a generic VM breakpoint "
             "handler instead.  This handler dispatches breakpoints to "
             "the VM service.");
 
 DECLARE_FLAG(bool, warn_on_pause_with_no_debugger);
@@ skipping 788 matching lines @@
 
 RawObject* ActivationFrame::GetStackVar(intptr_t slot_index) {
   if (deopt_frame_.IsNull()) {
     return GetVariableValue(LocalVarAddress(fp(), slot_index));
   } else {
     return deopt_frame_.At(LocalVarIndex(deopt_frame_offset_, slot_index));
   }
 }
 
 
-bool ActivationFrame::IsRewindable() const {
-  if (deopt_frame_.IsNull()) {
-    return true;
-  }
-  // TODO(turnidge): This is conservative.  It looks at all values in
-  // the deopt_frame_ even though some of them may correspond to other
-  // inlined frames.
-  Object& obj = Object::Handle();
-  for (int i = 0; i < deopt_frame_.Length(); i++) {
-    obj = deopt_frame_.At(i);
-    if (obj.raw() == Symbols::OptimizedOut().raw()) {
-      return false;
-    }
-  }
-  return true;
-}
-
-
 void ActivationFrame::PrintContextMismatchError(intptr_t ctx_slot,
                                                 intptr_t frame_ctx_level,
                                                 intptr_t var_ctx_level) {
   OS::PrintErr(
       "-------------------------\n"
       "Encountered context mismatch\n"
       "\tctx_slot: %" Pd
       "\n"
       "\tframe_ctx_level: %" Pd
       "\n"
@@ skipping 238 matching lines @@
         jsvar.AddProperty("declarationTokenPos", declaration_token_pos);
         // When the variable becomes visible to the scope.
         jsvar.AddProperty("scopeStartTokenPos", visible_start_token_pos);
         // When the variable stops being visible to the scope.
         jsvar.AddProperty("scopeEndTokenPos", visible_end_token_pos);
       }
     }
   }
 }
 
-static bool IsFunctionVisible(const Function& function) {
-  return FLAG_show_invisible_frames || function.is_visible();
-}
-
 
 void DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
-  if (IsFunctionVisible(frame->function())) {
+  if (FLAG_show_invisible_frames || frame->function().is_visible()) {
     trace_.Add(frame);
   }
 }
 
 
 const uint8_t kSafepointKind = RawPcDescriptors::kIcCall |
                                RawPcDescriptors::kUnoptStaticCall |
                                RawPcDescriptors::kRuntimeCall;
 
 
@@ skipping 106 matching lines @@
 
 Debugger::Debugger()
     : isolate_(NULL),
       isolate_id_(ILLEGAL_ISOLATE_ID),
       initialized_(false),
       next_id_(1),
       latent_locations_(NULL),
       breakpoint_locations_(NULL),
       code_breakpoints_(NULL),
       resume_action_(kContinue),
-      resume_frame_index_(-1),
-      post_deopt_frame_index_(-1),
       ignore_breakpoints_(false),
       pause_event_(NULL),
       obj_cache_(NULL),
       stack_trace_(NULL),
       stepping_fp_(0),
       skip_next_step_(false),
       synthetic_async_breakpoint_(NULL),
       exc_pause_info_(kNoPauseOnExceptions) {}
 
 
@@ skipping 43 matching lines @@
                                            const String& fname) {
   ASSERT(!library.IsNull());
   const Object& object = Object::Handle(library.ResolveName(fname));
   if (!object.IsNull() && object.IsFunction()) {
     return Function::Cast(object).raw();
   }
   return Function::null();
 }
 
 
-bool Debugger::SetupStepOverAsyncSuspension(const char** error) {
+bool Debugger::SetupStepOverAsyncSuspension() {
   ActivationFrame* top_frame = TopDartFrame();
   if (!IsAtAsyncJump(top_frame)) {
     // Not at an async operation.
-    if (error) {
-      *error = "Isolate must be paused at an async suspension point";
-    }
     return false;
   }
   Object& closure = Object::Handle(top_frame->GetAsyncOperation());
   ASSERT(!closure.IsNull());
   ASSERT(closure.IsInstance());
   ASSERT(Instance::Cast(closure).IsClosure());
   Breakpoint* bpt = SetBreakpointAtActivation(Instance::Cast(closure), true);
   if (bpt == NULL) {
     // Unable to set the breakpoint.
-    if (error) {
-      *error = "Unable to set breakpoint at async suspension point";
-    }
     return false;
   }
   return true;
 }
 
 
-bool Debugger::SetResumeAction(ResumeAction action,
-                               intptr_t frame_index,
-                               const char** error) {
-  if (error) {
-    *error = NULL;
-  }
-  resume_frame_index_ = -1;
-  switch (action) {
-    case kStepInto:
-    case kStepOver:
-    case kStepOut:
-    case kContinue:
-      resume_action_ = action;
-      return true;
-    case kStepRewind:
-      if (!CanRewindFrame(frame_index, error)) {
-        return false;
-      }
-      resume_action_ = kStepRewind;
-      resume_frame_index_ = frame_index;
-      return true;
-    case kStepOverAsyncSuspension:
-      return SetupStepOverAsyncSuspension(error);
-    default:
-      UNREACHABLE();
-      return false;
-  }
+void Debugger::SetSingleStep() {
+  resume_action_ = kSingleStep;
 }
 
 
+void Debugger::SetStepOver() {
+  resume_action_ = kStepOver;
+}
+
+
+void Debugger::SetStepOut() {
+  resume_action_ = kStepOut;
+}
+
+
 RawFunction* Debugger::ResolveFunction(const Library& library,
                                        const String& class_name,
                                        const String& function_name) {
   ASSERT(!library.IsNull());
   ASSERT(!class_name.IsNull());
   ASSERT(!function_name.IsNull());
   if (class_name.Length() == 0) {
     return ResolveLibraryFunction(library, function_name);
   }
   const Class& cls = Class::Handle(library.LookupClass(class_name));
@@ skipping 268 matching lines @@
     return;
   }
   ServiceEvent event(isolate_, ServiceEvent::kPauseException);
   event.set_exception(&exc);
   if (stack_trace->Length() > 0) {
     event.set_top_frame(stack_trace->FrameAt(0));
   }
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
   Pause(&event);
-  HandleSteppingRequest(stack_trace_);  // we may get a rewind request
   stack_trace_ = NULL;
 }
 
 
 static TokenPosition LastTokenOnLine(Zone* zone,
                                      const TokenStream& tokens,
                                      TokenPosition pos) {
   TokenStream::Iterator iter(zone, tokens, pos,
                              TokenStream::Iterator::kAllTokens);
   ASSERT(iter.IsValid());
@@ skipping 905 matching lines @@
 void Debugger::EnterSingleStepMode() {
   stepping_fp_ = 0;
   DeoptimizeWorld();
   isolate_->set_single_step(true);
 }
 
 
 void Debugger::HandleSteppingRequest(DebuggerStackTrace* stack_trace,
                                      bool skip_next_step) {
   stepping_fp_ = 0;
-  if (resume_action_ == kStepInto) {
+  if (resume_action_ == kSingleStep) {
     // When single stepping, we need to deoptimize because we might be
     // stepping into optimized code.  This happens in particular if
     // the isolate has been interrupted, but can happen in other cases
     // as well.  We need to deoptimize the world in case we are about
     // to call an optimized function.
     DeoptimizeWorld();
     isolate_->set_single_step(true);
     skip_next_step_ = skip_next_step;
     if (FLAG_verbose_debug) {
-      OS::Print("HandleSteppingRequest- kStepInto\n");
+      OS::Print("HandleSteppingRequest- kSingleStep\n");
     }
   } else if (resume_action_ == kStepOver) {
     DeoptimizeWorld();
     isolate_->set_single_step(true);
     skip_next_step_ = skip_next_step;
     ASSERT(stack_trace->Length() > 0);
     stepping_fp_ = stack_trace->FrameAt(0)->fp();
     if (FLAG_verbose_debug) {
       OS::Print("HandleSteppingRequest- kStepOver %" Px "\n", stepping_fp_);
     }
   } else if (resume_action_ == kStepOut) {
     DeoptimizeWorld();
     isolate_->set_single_step(true);
     // Find topmost caller that is debuggable.
     for (intptr_t i = 1; i < stack_trace->Length(); i++) {
       ActivationFrame* frame = stack_trace->FrameAt(i);
       if (frame->IsDebuggable()) {
         stepping_fp_ = frame->fp();
         break;
       }
     }
     if (FLAG_verbose_debug) {
       OS::Print("HandleSteppingRequest- kStepOut %" Px "\n", stepping_fp_);
     }
-  } else if (resume_action_ == kStepRewind) {
-    if (FLAG_trace_rewind) {
-      OS::PrintErr("Rewinding to frame %" Pd "\n", resume_frame_index_);
-      OS::PrintErr(
-          "-------------------------\n"
-          "All frames...\n\n");
-      StackFrameIterator iterator(false);
-      StackFrame* frame = iterator.NextFrame();
-      intptr_t num = 0;
-      while ((frame != NULL)) {
-        OS::PrintErr("#%04" Pd " %s\n", num++, frame->ToCString());
-        frame = iterator.NextFrame();
-      }
-    }
-    RewindToFrame(resume_frame_index_);
-    UNREACHABLE();
-  }
-}
-
-
-static intptr_t FindNextRewindFrameIndex(DebuggerStackTrace* stack,
-                                         intptr_t frame_index) {
-  for (intptr_t i = frame_index + 1; i < stack->Length(); i++) {
-    ActivationFrame* frame = stack->FrameAt(i);
-    if (frame->IsRewindable()) {
-      return i;
-    }
-  }
-  return -1;
-}
-
-
-// Can the top frame be rewound?
-bool Debugger::CanRewindFrame(intptr_t frame_index, const char** error) const {
-  // check rewind pc is found
-  DebuggerStackTrace* stack = Isolate::Current()->debugger()->StackTrace();
-  intptr_t num_frames = stack->Length();
-  if (frame_index < 1 || frame_index >= num_frames) {
-    if (error) {
-      *error = Thread::Current()->zone()->PrintToString(
-          "Frame must be in bounds [1..%" Pd
-          "]: "
-          "saw %" Pd "",
-          num_frames - 1, frame_index);
-    }
-    return false;
-  }
-  ActivationFrame* frame = stack->FrameAt(frame_index);
-  if (!frame->IsRewindable()) {
-    intptr_t next_index = FindNextRewindFrameIndex(stack, frame_index);
-    if (next_index > 0) {
-      *error = Thread::Current()->zone()->PrintToString(
-          "Cannot rewind to frame %" Pd
-          " due to conflicting compiler "
-          "optimizations. "
-          "Run the vm with --no-prune-dead-locals to disallow these "
-          "optimizations. "
-          "Next valid rewind frame is %" Pd ".",
-          frame_index, next_index);
-    } else {
-      *error = Thread::Current()->zone()->PrintToString(
-          "Cannot rewind to frame %" Pd
-          " due to conflicting compiler "
-          "optimizations. "
-          "Run the vm with --no-prune-dead-locals to disallow these "
-          "optimizations.",
-          frame_index);
-    }
-    return false;
-  }
-  return true;
-}
-
-
-// Given a return address pc, find the "rewind" pc, which is the pc
-// before the corresponding call.
-static uword LookupRewindPc(const Code& code, uword pc) {
-  ASSERT(!code.is_optimized());
-  ASSERT(code.ContainsInstructionAt(pc));
-
-  uword pc_offset = pc - code.PayloadStart();
-  const PcDescriptors& descriptors =
-      PcDescriptors::Handle(code.pc_descriptors());
-  PcDescriptors::Iterator iter(
-      descriptors, RawPcDescriptors::kRewind | RawPcDescriptors::kIcCall |
-                       RawPcDescriptors::kUnoptStaticCall);
-  intptr_t rewind_deopt_id = -1;
-  uword rewind_pc = 0;
-  while (iter.MoveNext()) {
-    if (iter.Kind() == RawPcDescriptors::kRewind) {
-      // Remember the last rewind so we don't need to iterator twice.
-      rewind_pc = code.PayloadStart() + iter.PcOffset();
-      rewind_deopt_id = iter.DeoptId();
-    }
-    if ((pc_offset == iter.PcOffset()) && (iter.DeoptId() == rewind_deopt_id)) {
-      return rewind_pc;
-    }
-  }
-  return 0;
-}
-
-
-void Debugger::RewindToFrame(intptr_t frame_index) {
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  Code& code = Code::Handle(zone);
-  Function& function = Function::Handle(zone);
-
-  // Find the requested frame.
-  StackFrameIterator iterator(false);
-  intptr_t current_frame = 0;
-  for (StackFrame* frame = iterator.NextFrame(); frame != NULL;
-       frame = iterator.NextFrame()) {
-    ASSERT(frame->IsValid());
-    if (frame->IsDartFrame()) {
-      code = frame->LookupDartCode();
-      function = code.function();
-      if (!IsFunctionVisible(function)) {
-        continue;
-      }
-      if (code.is_optimized()) {
-        intptr_t sub_index = 0;
-        for (InlinedFunctionsIterator it(code, frame->pc()); !it.Done();
-             it.Advance()) {
-          if (current_frame == frame_index) {
-            RewindToOptimizedFrame(frame, code, sub_index);
-            UNREACHABLE();
-          }
-          current_frame++;
-          sub_index++;
-        }
-      } else {
-        if (current_frame == frame_index) {
-          // We are rewinding to an unoptimized frame.
-          RewindToUnoptimizedFrame(frame, code);
-          UNREACHABLE();
-        }
-        current_frame++;
-      }
-    }
-  }
-  UNIMPLEMENTED();
-}
-
-
-void Debugger::RewindToUnoptimizedFrame(StackFrame* frame, const Code& code) {
-  // We will be jumping out of the debugger rather than exiting this
-  // function, so prepare the debugger state.
-  stack_trace_ = NULL;
-  resume_action_ = kContinue;
-  resume_frame_index_ = -1;
-  EnterSingleStepMode();
-
-  uword rewind_pc = LookupRewindPc(code, frame->pc());
-  if (FLAG_trace_rewind && rewind_pc == 0) {
-    OS::PrintErr("Unable to find rewind pc for pc(%" Px ")\n", frame->pc());
-  }
-  ASSERT(rewind_pc != 0);
-  if (FLAG_trace_rewind) {
-    OS::PrintErr(
-        "===============================\n"
-        "Rewinding to unoptimized frame:\n"
-        "    rewind_pc(0x%" Px ") sp(0x%" Px ") fp(0x%" Px
-        ")\n"
-        "===============================\n",
-        rewind_pc, frame->sp(), frame->fp());
-  }
-  Exceptions::JumpToFrame(Thread::Current(), rewind_pc, frame->sp(),
-                          frame->fp(), true /* clear lazy deopt at target */);
-  UNREACHABLE();
-}
-
-
-void Debugger::RewindToOptimizedFrame(StackFrame* frame,
-                                      const Code& optimized_code,
-                                      intptr_t sub_index) {
-  post_deopt_frame_index_ = sub_index;
-
-  // We will be jumping out of the debugger rather than exiting this
-  // function, so prepare the debugger state.
-  stack_trace_ = NULL;
-  resume_action_ = kContinue;
-  resume_frame_index_ = -1;
-  EnterSingleStepMode();
-
-  if (FLAG_trace_rewind) {
-    OS::PrintErr(
-        "===============================\n"
-        "Deoptimizing frame for rewind:\n"
-        "    deopt_pc(0x%" Px ") sp(0x%" Px ") fp(0x%" Px
-        ")\n"
-        "===============================\n",
-        frame->pc(), frame->sp(), frame->fp());
-  }
-  Thread* thread = Thread::Current();
-  thread->set_resume_pc(frame->pc());
-  uword deopt_stub_pc = StubCode::DeoptForRewind_entry()->EntryPoint();
-  Exceptions::JumpToFrame(thread, deopt_stub_pc, frame->sp(), frame->fp(),
-                          true /* clear lazy deopt at target */);
-  UNREACHABLE();
-}
-
-
-void Debugger::RewindPostDeopt() {
-  intptr_t rewind_frame = post_deopt_frame_index_;
-  post_deopt_frame_index_ = -1;
-  if (FLAG_trace_rewind) {
-    OS::PrintErr("Post deopt, jumping to frame %" Pd "\n", rewind_frame);
-    OS::PrintErr(
-        "-------------------------\n"
-        "All frames...\n\n");
-    StackFrameIterator iterator(false);
-    StackFrame* frame = iterator.NextFrame();
-    intptr_t num = 0;
-    while ((frame != NULL)) {
-      OS::PrintErr("#%04" Pd " %s\n", num++, frame->ToCString());
-      frame = iterator.NextFrame();
-    }
-  }
-
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  Code& code = Code::Handle(zone);
-
-  StackFrameIterator iterator(false);
-  intptr_t current_frame = 0;
-  for (StackFrame* frame = iterator.NextFrame(); frame != NULL;
-       frame = iterator.NextFrame()) {
-    ASSERT(frame->IsValid());
-    if (frame->IsDartFrame()) {
-      code = frame->LookupDartCode();
-      ASSERT(!code.is_optimized());
-      if (current_frame == rewind_frame) {
-        RewindToUnoptimizedFrame(frame, code);
-        UNREACHABLE();
-      }
-      current_frame++;
-    }
   }
 }
 
 
 // static
 bool Debugger::IsDebuggable(const Function& func) {
   if (!func.is_debuggable()) {
     return false;
   }
   const Class& cls = Class::Handle(func.Owner());
@@ skipping 191 matching lines @@
                 cbpt->LineNumber(), cbpt->token_pos().ToCString(),
                 top_frame->pc());
     }
 
     ASSERT(synthetic_async_breakpoint_ == NULL);
     synthetic_async_breakpoint_ = bpt_hit;
     bpt_hit = NULL;
 
     // We are at the entry of an async function.
     // We issue a step over to resume at the point after the await statement.
-    SetResumeAction(kStepOver);
+    SetStepOver();
     // When we single step from a user breakpoint, our next stepping
     // point will be at the exact same pc.  Skip it.
     HandleSteppingRequest(stack_trace_, true /* skip next step */);
     stack_trace_ = NULL;
     return Error::null();
   }
 
   if (FLAG_verbose_debug) {
     OS::Print(">>> hit %s breakpoint at %s:%" Pd
               " "
@@ skipping 32 matching lines @@
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   ASSERT(stack_trace->Length() > 0);
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
 
   // TODO(johnmccutchan): Send |msg| to Observatory.
 
   // We are in the native call to Developer_debugger.  the developer
   // gets a better experience by not seeing this call. To accomplish
   // this, we continue execution until the call exits (step out).
-  SetResumeAction(kStepOut);
+  SetStepOut();
   HandleSteppingRequest(stack_trace_);
 
   stack_trace_ = NULL;
 }
 
 
 void Debugger::Initialize(Isolate* isolate) {
   if (initialized_) {
     return;
   }
@@ skipping 432 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart