Revert "Deoptimization support in inlined code."

runtime/vm/code_generator.cc

 // Copyright (c) 2012, 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_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 1464 matching lines @@
   while (frame != NULL) {
     optimized_code = frame->LookupDartCode();
     if (optimized_code.is_optimized()) {
       intptr_t deopt_id, deopt_reason, deopt_index;
       GetDeoptIxDescrAtPc(optimized_code, frame->pc(),
                           &deopt_id, &deopt_reason, &deopt_index);
       ASSERT(deopt_id != Isolate::kNoDeoptId);
       function = optimized_code.function();
       unoptimized_code = function.unoptimized_code();
       ASSERT(!unoptimized_code.IsNull());
+      uword continue_at_pc =
+          unoptimized_code.GetDeoptAfterPcAtDeoptId(deopt_id);
+      ASSERT(continue_at_pc != 0);
       // The switch to unoptimized code may have already occured.
       if (function.HasOptimizedCode()) {
         function.SwitchToUnoptimizedCode();
       }
       // Patch call site (lazy deoptimization is quite rare, patching it twice
       // is not a performance issue).
       uword lazy_deopt_jump = optimized_code.GetLazyDeoptPc();
       ASSERT(lazy_deopt_jump != 0);
       CodePatcher::InsertCallAt(frame->pc(), lazy_deopt_jump);
       // Mark code as dead (do not GC its embedded objects).
@@ skipping 104 matching lines @@
       function.HasOptionalParameters() ? 0 : function.num_fixed_parameters();
   intptr_t unoptimized_stack_size =
       + deopt_info.Length() - num_args
       - 2;  // Subtract caller FP and PC.
   return unoptimized_stack_size * kWordSize;
 }
 END_LEAF_RUNTIME_ENTRY
 
 
 
-static intptr_t DeoptimizeWithDeoptInfo(const Code& code,
-                                        const DeoptInfo& deopt_info,
-                                        const StackFrame& caller_frame) {
+static void DeoptimizeWithDeoptInfo(const Code& code,
+                                    const DeoptInfo& deopt_info,
+                                    const StackFrame& caller_frame) {
   const intptr_t len = deopt_info.Length();
   GrowableArray<DeoptInstr*> deopt_instructions(len);
   for (intptr_t i = 0; i < len; i++) {
     deopt_instructions.Add(DeoptInstr::Create(deopt_info.Instruction(i),
                                               deopt_info.FromIndex(i)));
   }
 
   intptr_t* start = reinterpret_cast<intptr_t*>(caller_frame.sp() - kWordSize);
   const Function& function = Function::Handle(code.function());
   const intptr_t num_args =
@@ skipping 12 matching lines @@
   }
   if (FLAG_trace_deopt) {
     for (intptr_t i = 0; i < len; i++) {
       OS::Print("*%"Pd". [%p] %#014"Px" [%s]\n",
           i,
           &start[i],
           start[i],
           deopt_instructions[i]->ToCString());
     }
   }
-  return deopt_context.GetCallerFp();
 }
 
 
 // The stack has been adjusted to fit all values for unoptimized frame.
 // Fill the unoptimized frame.
-DEFINE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeFillFrame, uword last_fp) {
+DEFINE_LEAF_RUNTIME_ENTRY(void, DeoptimizeFillFrame, uword last_fp) {
   Isolate* isolate = Isolate::Current();
   Zone zone(isolate);
   HANDLESCOPE(isolate);
 
   DartFrameIterator iterator(last_fp);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
   const Function& function = Function::Handle(optimized_code.function());
   ASSERT(!function.IsNull());
   const Code& unoptimized_code = Code::Handle(function.unoptimized_code());
   ASSERT(!optimized_code.IsNull() && optimized_code.is_optimized());
   ASSERT(!unoptimized_code.IsNull() && !unoptimized_code.is_optimized());
 
   intptr_t* frame_copy = isolate->deopt_frame_copy();
   intptr_t* cpu_registers_copy = isolate->deopt_cpu_registers_copy();
   double* xmm_registers_copy = isolate->deopt_xmm_registers_copy();
 
   intptr_t deopt_id, deopt_reason, deopt_index;
   GetDeoptIxDescrAtPc(optimized_code, caller_frame->pc(),
                       &deopt_id, &deopt_reason, &deopt_index);
   ASSERT(deopt_id != Isolate::kNoDeoptId);
+  uword continue_at_pc = 0;
+  if (deopt_reason == kDeoptAtCall) {
+    continue_at_pc = unoptimized_code.GetDeoptAfterPcAtDeoptId(deopt_id);
+  } else {
+    continue_at_pc = unoptimized_code.GetDeoptBeforePcAtDeoptId(deopt_id);
+  }
+  ASSERT(continue_at_pc != 0);
+  if (FLAG_trace_deopt) {
+    OS::Print("  -> continue at %#"Px"\n", continue_at_pc);
+    // TODO(srdjan): If we could allow GC, we could print the line where
+    // deoptimization occured.
+  }
   const Array& deopt_info_array =
       Array::Handle(optimized_code.deopt_info_array());
   ASSERT(!deopt_info_array.IsNull());
   DeoptInfo& deopt_info = DeoptInfo::Handle();
   deopt_info ^= deopt_info_array.At(deopt_index);
   ASSERT(!deopt_info.IsNull());
-  const intptr_t caller_fp =
-      DeoptimizeWithDeoptInfo(optimized_code, deopt_info, *caller_frame);
+  DeoptimizeWithDeoptInfo(optimized_code, deopt_info, *caller_frame);
 
   isolate->SetDeoptFrameCopy(NULL, 0);
   isolate->set_deopt_cpu_registers_copy(NULL);
   isolate->set_deopt_xmm_registers_copy(NULL);
   delete[] frame_copy;
   delete[] cpu_registers_copy;
   delete[] xmm_registers_copy;
 
   // Clear invocation counter so that the function gets optimized after
   // classes have been collected.
   function.set_usage_counter(0);
   function.set_deoptimization_counter(function.deoptimization_counter() + 1);
 
   if (function.HasOptimizedCode()) {
     function.SwitchToUnoptimizedCode();
   }
-  return caller_fp;
 }
 END_LEAF_RUNTIME_ENTRY
 
 
 DEFINE_RUNTIME_ENTRY(DeoptimizeMaterializeDoubles, 0) {
   DeferredDouble* deferred_double = Isolate::Current()->DetachDeferredDoubles();
 
   while (deferred_double != NULL) {
     DeferredDouble* current = deferred_double;
     deferred_double = deferred_double->next();
 
     RawDouble** slot = current->slot();
     *slot = Double::New(current->value());
 
     if (FLAG_trace_deopt) {
       OS::Print("materialing double at %p: %g\n",
                 current->slot(),
                 current->value());
     }
 
     delete current;
   }
 }
 
 
 }  // namespace dart