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

runtime/vm/exceptions.cc

 // Copyright (c) 2011, 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/exceptions.h"
 
 #include "platform/address_sanitizer.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ skipping 171 matching lines @@
   }
   // No catch-all encountered, needs stacktrace.
   *needs_stacktrace = true;
   return handler_pc_set;
 }
 
 
 static void FindErrorHandler(uword* handler_pc,
                              uword* handler_sp,
                              uword* handler_fp) {
+  // TODO(turnidge): Is there a faster way to get the next entry frame?
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);
   while (!frame->IsEntryFrame()) {
     frame = frames.NextFrame();
     ASSERT(frame != NULL);
   }
   ASSERT(frame->IsEntryFrame());
   *handler_pc = frame->pc();
   *handler_sp = frame->sp();
@@ skipping 18 matching lines @@
         // Jump to the deopt stub instead of the catch handler.
         program_counter =
             StubCode::DeoptimizeLazyFromThrow_entry()->EntryPoint();
         if (FLAG_trace_deoptimization) {
           THR_Print("Throwing to frame scheduled for lazy deopt fp=%" Pp "\n",
                     frame_pointer);
         }
         break;
       }
     }
-  }
-#endif  // !DBC
-  return program_counter;
-}
 
-
-static void ClearLazyDeopts(Thread* thread, uword frame_pointer) {
-#if !defined(TARGET_ARCH_DBC)
-  MallocGrowableArray<PendingLazyDeopt>* pending_deopts =
-      thread->isolate()->pending_deopts();
-  if (pending_deopts->length() > 0) {
     // We may be jumping over frames scheduled for lazy deopt. Remove these
     // frames from the pending deopt table, but only after unmarking them so
     // any stack walk that happens before the stack is unwound will still work.
     {
       DartFrameIterator frames(thread);
       StackFrame* frame = frames.NextFrame();
       while ((frame != NULL) && (frame->fp() < frame_pointer)) {
         if (frame->IsMarkedForLazyDeopt()) {
           frame->UnmarkForLazyDeopt();
         }
@@ skipping 15 matching lines @@
         }
         pending_deopts->RemoveAt(i);
       }
     }
 
 #if defined(DEBUG)
     ValidateFrames();
 #endif
   }
 #endif  // !DBC
+  return program_counter;
 }
 
 
 static void JumpToExceptionHandler(Thread* thread,
                                    uword program_counter,
                                    uword stack_pointer,
                                    uword frame_pointer,
                                    const Object& exception_object,
                                    const Object& stacktrace_object) {
   uword remapped_pc =
       RemapExceptionPCForDeopt(thread, program_counter, frame_pointer);
   thread->set_active_exception(exception_object);
   thread->set_active_stacktrace(stacktrace_object);
   thread->set_resume_pc(remapped_pc);
   uword run_exception_pc = StubCode::RunExceptionHandler_entry()->EntryPoint();
   Exceptions::JumpToFrame(thread, run_exception_pc, stack_pointer,
-                          frame_pointer, false /* do not clear deopt */);
+                          frame_pointer);
 }
 
 
 void Exceptions::JumpToFrame(Thread* thread,
                              uword program_counter,
                              uword stack_pointer,
-                             uword frame_pointer,
-                             bool clear_deopt_at_target) {
-  uword fp_for_clearing =
-      (clear_deopt_at_target ? frame_pointer + 1 : frame_pointer);
-  ClearLazyDeopts(thread, fp_for_clearing);
+                             uword frame_pointer) {
 #if defined(USING_SIMULATOR)
   // Unwinding of the C++ frames and destroying of their stack resources is done
   // by the simulator, because the target stack_pointer is a simulated stack
   // pointer and not the C++ stack pointer.
 
   // Continue simulating at the given pc in the given frame after setting up the
   // exception object in the kExceptionObjectReg register and the stacktrace
   // object (may be raw null) in the kStackTraceObjectReg register.
 
   Simulator::Current()->JumpToFrame(program_counter, stack_pointer,
@@ skipping 496 matching lines @@
       class_name = &Symbols::_CompileTimeError();
       break;
   }
 
   return DartLibraryCalls::InstanceCreate(library, *class_name,
                                           *constructor_name, arguments);
 }
 
 
 }  // namespace dart