Revert "Lazy deopt without code patching."

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 1978 matching lines @@
 #define DEOPT_REASON_TO_TEXT(name) case ICData::kDeopt##name: return #name;
 DEOPT_REASONS(DEOPT_REASON_TO_TEXT)
 #undef DEOPT_REASON_TO_TEXT
     default:
       UNREACHABLE();
       return "";
   }
 }
 
 
-void DeoptimizeAt(const Code& optimized_code, StackFrame* frame) {
+void DeoptimizeAt(const Code& optimized_code, uword pc) {
   ASSERT(optimized_code.is_optimized());
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
+  ICData::DeoptReasonId deopt_reason = ICData::kDeoptUnknown;
+  uint32_t deopt_flags = 0;
+  const TypedData& deopt_info = TypedData::Handle(zone,
+      optimized_code.GetDeoptInfoAtPc(pc, &deopt_reason, &deopt_flags));
+  ASSERT(!deopt_info.IsNull());
   const Function& function = Function::Handle(zone, optimized_code.function());
   const Error& error =
       Error::Handle(zone, Compiler::EnsureUnoptimizedCode(thread, function));
   if (!error.IsNull()) {
     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)
+  // Patch call site (lazy deoptimization is quite rare, patching it twice
+  // is not a performance issue).
+  uword lazy_deopt_jump_return = optimized_code.GetLazyDeoptReturnPc();
+  uword lazy_deopt_jump_throw = optimized_code.GetLazyDeoptThrowPc();
+#if !defined(TARGET_ARCH_DBC)
+  ASSERT(lazy_deopt_jump_return != 0);
+  ASSERT(lazy_deopt_jump_throw != 0);
+#endif
   const Instructions& instrs =
       Instructions::Handle(zone, optimized_code.instructions());
   {
     WritableInstructionsScope writable(instrs.PayloadStart(), instrs.size());
-    CodePatcher::InsertDeoptimizationCallAt(frame->pc());
+    CodePatcher::InsertDeoptimizationCallAt(pc, lazy_deopt_jump_return);
     if (FLAG_trace_patching) {
       const String& name = String::Handle(function.name());
       OS::PrintErr(
-          "InsertDeoptimizationCallAt: 0x%" Px " for %s\n",
-          frame->pc(), name.ToCString());
+          "InsertDeoptimizationCallAt: 0x%" Px " to 0x%" Px " for %s\n",
+          pc, lazy_deopt_jump_return, name.ToCString());
     }
     const ExceptionHandlers& handlers =
         ExceptionHandlers::Handle(zone, optimized_code.exception_handlers());
     RawExceptionHandlers::HandlerInfo 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);
+      CodePatcher::InsertDeoptimizationCallAt(patch_pc, lazy_deopt_jump_throw);
       if (FLAG_trace_patching) {
         OS::PrintErr("  at handler 0x%" Px "\n", patch_pc);
       }
     }
   }
-#else  // !DBC
-  uword lazy_deopt_entry =
-      StubCode::DeoptimizeLazyFromReturn_entry()->EntryPoint();
-  if (frame->pc() == lazy_deopt_entry) {
-    // 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));
-    PendingLazyDeopt pair(frame->fp(), deopt_pc);
-    thread->isolate()->pending_deopts()->Add(pair);
-    frame->set_pc(lazy_deopt_entry);
-
-    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;
   StackFrame* frame = iterator.NextFrame();
   Code& optimized_code = Code::Handle();
   while (frame != NULL) {
     optimized_code = frame->LookupDartCode();
     if (optimized_code.is_optimized()) {
-      DeoptimizeAt(optimized_code, frame);
+      DeoptimizeAt(optimized_code, frame->pc());
     }
     frame = iterator.NextFrame();
   }
 }
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #if !defined(TARGET_ARCH_DBC)
 static const intptr_t kNumberOfSavedCpuRegisters = kNumberOfCpuRegisters;
 static const intptr_t kNumberOfSavedFpuRegisters = kNumberOfFpuRegisters;
 #else
@@ skipping 60 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 = 0;
-    MallocGrowableArray<PendingLazyDeopt>* pending_deopts =
-        isolate->pending_deopts();
-    for (intptr_t i = pending_deopts->length() - 1; i >= 0; i--) {
-      if ((*pending_deopts)[i].fp() == caller_frame->fp()) {
-        deopt_pc = (*pending_deopts)[i].pc();
-        break;
-      }
-    }
-    for (intptr_t i = pending_deopts->length() - 1; i >= 0; i--) {
-      if ((*pending_deopts)[i].fp() <= caller_frame->fp()) {
-        pending_deopts->RemoveAt(i);
-      }
-    }
-    if (FLAG_trace_deoptimization) {
-      THR_Print("Lazy deopt fp=%" Pp " pc=%" Pp "\n",
-                caller_frame->fp(), deopt_pc);
-      THR_Print("%" Pd " pending lazy deopts\n",
-                pending_deopts->length());
-    }
-    ASSERT(deopt_pc != 0);
-    caller_frame->set_pc(deopt_pc);
-    ASSERT(caller_frame->pc() == deopt_pc);
-  } else {
-    if (FLAG_trace_deoptimization) {
-      THR_Print("Eager deopt fp=%" Pp " pc=%" Pp "\n",
-                caller_frame->fp(), caller_frame->pc());
-    }
-  }
-  ASSERT(optimized_code.ContainsInstructionAt(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,
@@ skipping 40 matching lines @@
     // The code will be the same as before.
     ASSERT(code.raw() == optimized_code.raw());
 
     // Some sanity checking of the optimized code.
     ASSERT(!optimized_code.IsNull() && optimized_code.is_optimized());
   }
 #endif
 
   deopt_context->set_dest_frame(caller_frame);
   deopt_context->FillDestFrame();
-
 #else
   UNREACHABLE();
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 END_LEAF_RUNTIME_ENTRY
 
 
 // This is the last step in the deoptimization, GC can occur.
 // Returns number of bytes to remove from the expression stack of the
 // bottom-most deoptimized frame. Those arguments were artificially injected
@@ skipping 93 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