Lazy deopt without code patching.

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"
 #include "vm/debugger.h"
 #include "vm/flags.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 
 namespace dart {
 
+DECLARE_FLAG(bool, trace_deoptimization);
 DEFINE_FLAG(bool, print_stacktrace_at_throw, false,
             "Prints a stack trace everytime a throw occurs.");
 
 
 class StacktraceBuilder : public ValueObject {
  public:
   StacktraceBuilder() { }
   virtual ~StacktraceBuilder() { }
 
   virtual void AddFrame(const Code& code, const Smi& offset) = 0;
@@ skipping 87 matching lines @@
 
 static void BuildStackTrace(StacktraceBuilder* builder) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);  // We expect to find a dart invocation frame.
   Code& code = Code::Handle();
   Smi& offset = Smi::Handle();
   while (frame != NULL) {
     if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
+      ASSERT(code.ContainsInstructionAt(frame->pc()));
       offset = Smi::New(frame->pc() - code.PayloadStart());
       builder->AddFrame(code, offset);
     }
     frame = frames.NextFrame();
   }
 }
 
 
 // Iterate through the stack frames and try to find a frame with an
 // exception handler. Once found, set the pc, sp and fp so that execution
@@ skipping 66 matching lines @@
                                    uword stack_pointer,
                                    uword frame_pointer,
                                    const Object& exception_object,
                                    const Object& stacktrace_object) {
   // The no_gc StackResource is unwound through the tear down of
   // stack resources below.
   NoSafepointScope no_safepoint;
   RawObject* raw_exception = exception_object.raw();
   RawObject* raw_stacktrace = stacktrace_object.raw();
 
+#if !defined(TARGET_ARCH_DBC)
+  MallocGrowableArray<PendingLazyDeopt>* pending_deopts =
+      thread->isolate()->pending_deopts();
+  for (intptr_t i = pending_deopts->length() - 1; i >= 0; i--) {
+    if ((*pending_deopts)[i].fp() == frame_pointer) {
+      // Frame is scheduled for lazy deopt.
+      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;
+    }
+  }
+  for (intptr_t i = pending_deopts->length() - 1; i >= 0; i--) {
+    // Leave the mapping at fp itself for use in DeoptimizeCopyFrame.
+    if ((*pending_deopts)[i].fp() < frame_pointer) {
+      pending_deopts->RemoveAt(i);
+    }
+  }
+#endif  // !DBC
+
+
 #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()->Longjmp(program_counter, stack_pointer, frame_pointer,
@@ skipping 511 matching lines @@
   }
 
   return DartLibraryCalls::InstanceCreate(library,
                                           *class_name,
                                           *constructor_name,
                                           arguments);
 }
 
 
 }  // namespace dart