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

runtime/vm/code_generator.cc

 // Copyright (c) 2013, 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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 1917 matching lines @@
     Exceptions::PropagateError(error);
   }
   const Code& unoptimized_code =
       Code::Handle(zone, function.unoptimized_code());
   ASSERT(!unoptimized_code.IsNull());
   // The switch to unoptimized code may have already occurred.
   if (function.HasOptimizedCode()) {
     function.SwitchToUnoptimizedCode();
   }
 
+#if defined(TARGET_ARCH_DBC)
+  const Instructions& instrs =
+      Instructions::Handle(zone, optimized_code.instructions());
+  {
+    WritableInstructionsScope writable(instrs.PayloadStart(), instrs.Size());
+    CodePatcher::InsertDeoptimizationCallAt(frame->pc());
+    if (FLAG_trace_patching) {
+      const String& name = String::Handle(function.name());
+      OS::PrintErr("InsertDeoptimizationCallAt: 0x%" Px " for %s\n",
+                   frame->pc(), name.ToCString());
+    }
+    const ExceptionHandlers& handlers =
+        ExceptionHandlers::Handle(zone, optimized_code.exception_handlers());
+    ExceptionHandlerInfo info;
+    for (intptr_t i = 0; i < handlers.num_entries(); ++i) {
+      handlers.GetHandlerInfo(i, &info);
+      const uword patch_pc = instrs.PayloadStart() + info.handler_pc_offset;
+      CodePatcher::InsertDeoptimizationCallAt(patch_pc);
+      if (FLAG_trace_patching) {
+        OS::PrintErr("  at handler 0x%" Px "\n", patch_pc);
+      }
+    }
+  }
+#else  // !DBC
   if (frame->IsMarkedForLazyDeopt()) {
     // Deopt already scheduled.
     if (FLAG_trace_deoptimization) {
       THR_Print("Lazy deopt already scheduled for fp=%" Pp "\n", frame->fp());
     }
   } else {
     uword deopt_pc = frame->pc();
     ASSERT(optimized_code.ContainsInstructionAt(deopt_pc));
 
 #if defined(DEBUG)
     ValidateFrames();
 #endif
 
     // N.B.: Update the pending deopt table before updating the frame. The
     // profiler may attempt a stack walk in between.
     thread->isolate()->AddPendingDeopt(frame->fp(), deopt_pc);
     frame->MarkForLazyDeopt();
 
     if (FLAG_trace_deoptimization) {
       THR_Print("Lazy deopt scheduled for fp=%" Pp ", pc=%" Pp "\n",
                 frame->fp(), deopt_pc);
     }
   }
+#endif  // !DBC
 
   // Mark code as dead (do not GC its embedded objects).
   optimized_code.set_is_alive(false);
 }
 
 
 // Currently checks only that all optimized frames have kDeoptIndex
 // and unoptimized code has the kDeoptAfter.
 void DeoptimizeFunctionsOnStack() {
   DartFrameIterator iterator;
@@ skipping 77 matching lines @@
       Function::Handle(thread->zone(), optimized_code.function());
   const bool deoptimizing_code = top_function.HasOptimizedCode();
   if (FLAG_trace_deoptimization) {
     const Function& function = Function::Handle(optimized_code.function());
     THR_Print("== Deoptimizing code for '%s', %s, %s\n",
               function.ToFullyQualifiedCString(),
               deoptimizing_code ? "code & frame" : "frame",
               is_lazy_deopt ? "lazy-deopt" : "");
   }
 
+#if !defined(TARGET_ARCH_DBC)
   if (is_lazy_deopt) {
     uword deopt_pc = isolate->FindPendingDeopt(caller_frame->fp());
     if (FLAG_trace_deoptimization) {
       THR_Print("Lazy deopt fp=%" Pp " pc=%" Pp "\n", caller_frame->fp(),
                 deopt_pc);
     }
 
     // N.B.: Update frame before updating pending deopt table. The profiler
     // may attempt a stack walk in between.
     caller_frame->set_pc(deopt_pc);
-    ASSERT(!caller_frame->IsMarkedForLazyDeopt());
     ASSERT(caller_frame->pc() == deopt_pc);
     ASSERT(optimized_code.ContainsInstructionAt(caller_frame->pc()));
     isolate->ClearPendingDeoptsAtOrBelow(caller_frame->fp());
   } else {
     if (FLAG_trace_deoptimization) {
       THR_Print("Eager deopt fp=%" Pp " pc=%" Pp "\n", caller_frame->fp(),
                 caller_frame->pc());
     }
   }
+#endif  // !DBC
 
   // Copy the saved registers from the stack.
   fpu_register_t* fpu_registers;
   intptr_t* cpu_registers;
   CopySavedRegisters(saved_registers_address, &fpu_registers, &cpu_registers);
 
   // Create the DeoptContext.
   DeoptContext* deopt_context = new DeoptContext(
       caller_frame, optimized_code, DeoptContext::kDestIsOriginalFrame,
       fpu_registers, cpu_registers, is_lazy_deopt != 0, deoptimizing_code);
@@ skipping 147 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart