Do not rely on code patching on DBC for lazy deoptimization.

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 "lib/stacktrace.h"
 
@@ skipping 191 matching lines @@
   ASSERT(frame->IsEntryFrame());
   *handler_pc = frame->pc();
   *handler_sp = frame->sp();
   *handler_fp = frame->fp();
 }
 
 
 static uword RemapExceptionPCForDeopt(Thread* thread,
                                       uword program_counter,
                                       uword frame_pointer) {
-#if !defined(TARGET_ARCH_DBC)
   MallocGrowableArray<PendingLazyDeopt>* pending_deopts =
       thread->isolate()->pending_deopts();
   if (pending_deopts->length() > 0) {
     // Check if the target frame is scheduled for lazy deopt.
     for (intptr_t i = 0; i < pending_deopts->length(); i++) {
       if ((*pending_deopts)[i].fp() == frame_pointer) {
         // Deopt should now resume in the catch handler instead of after the
         // call.
         (*pending_deopts)[i].set_pc(program_counter);
 
         // 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)) {
+      while ((frame != NULL) && IsCalleeFrameOf(frame_pointer, frame->fp())) {
         if (frame->IsMarkedForLazyDeopt()) {
           frame->UnmarkForLazyDeopt();
         }
         frame = frames.NextFrame();
       }
     }
 
 #if defined(DEBUG)
     ValidateFrames();
 #endif
 
     for (intptr_t i = 0; i < pending_deopts->length(); i++) {
-      if ((*pending_deopts)[i].fp() < frame_pointer) {
+      if (IsCalleeFrameOf(frame_pointer, (*pending_deopts)[i].fp())) {
         if (FLAG_trace_deoptimization) {
           THR_Print(
               "Lazy deopt skipped due to throw for "
               "fp=%" Pp ", pc=%" Pp "\n",
               (*pending_deopts)[i].fp(), (*pending_deopts)[i].pc());
         }
         pending_deopts->RemoveAt(i);
       }
     }
 
 #if defined(DEBUG)
     ValidateFrames();
 #endif
   }
-#endif  // !DBC
 }
 
 
 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 */);
 }
 
 
 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);
+  uword fp_for_clearing = (clear_deopt_at_target
+#if defined(TARGET_ARCH_DBC)
+                               ? frame_pointer - 1
+#else
+                               ? frame_pointer + 1
+#endif
+                               : frame_pointer);
   ClearLazyDeopts(thread, fp_for_clearing);
 #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.
 
@@ skipping 501 matching lines @@
       class_name = &Symbols::_CompileTimeError();
       break;
   }
 
   return DartLibraryCalls::InstanceCreate(library, *class_name,
                                           *constructor_name, arguments);
 }
 
 
 }  // namespace dart