Deoptimization can occur at Dart calls (includes native calls to C) but not at runtime calls. This …

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"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/exceptions.h"
 #include "vm/intermediate_language.h"
 #include "vm/object_store.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/parser.h"
 #include "vm/resolver.h"
 #include "vm/runtime_entry.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
+DEFINE_FLAG(bool, deoptimize_alot, false,
+    "Deoptimizes all live frames when we are about to return to Dart code from"
+    " native entries.");
 DEFINE_FLAG(bool, inline_cache, true, "Enable inline caches");
 DEFINE_FLAG(bool, trace_deopt, false, "Trace deoptimization");
 DEFINE_FLAG(bool, trace_ic, false, "Trace IC handling");
 DEFINE_FLAG(bool, trace_patching, false, "Trace patching of code.");
 DEFINE_FLAG(bool, trace_runtime_calls, false, "Trace runtime calls");
 DEFINE_FLAG(int, optimization_counter_threshold, 2000,
     "Function's usage-counter value before it is optimized, -1 means never");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, trace_type_checks);
 DECLARE_FLAG(bool, report_usage_count);
@@ skipping 1330 matching lines @@
       return "";
   }
 }
 
 
 static void GetDeoptIxDescrAtPc(const Code& code,
                                 uword pc,
                                 intptr_t* deopt_id,
                                 intptr_t* deopt_reason,
                                 intptr_t* deopt_index) {
+  ASSERT(code.is_optimized());
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(code.pc_descriptors());
   ASSERT(!descriptors.IsNull());
   // Locate deopt id at deoptimization point inside optimized code.
   for (int i = 0; i < descriptors.Length(); i++) {
     if ((static_cast<uword>(descriptors.PC(i)) == pc) &&
         (descriptors.DescriptorKind(i) == PcDescriptors::kDeoptIndex)) {
       *deopt_id = descriptors.DeoptId(i);
       *deopt_reason = descriptors.DeoptReason(i);
       *deopt_index = descriptors.DeoptIndex(i);
       return;
     }
   }
   *deopt_id = Isolate::kNoDeoptId;
   *deopt_reason = kDeoptUnknown;
   *deopt_index = -1;
 }
 
 
+// Currently checks only that all optimized frames have kDeoptIndex
+// and unoptimized code has the kDeoptAfter.
+void DeoptimizeAll() {
+  DartFrameIterator iterator;
+  StackFrame* frame = iterator.NextFrame();
+  Code& optimized_code = Code::Handle();
+  Function& function = Function::Handle();
+  Code& unoptimized_code = Code::Handle();
+  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);
+    }
+    frame = iterator.NextFrame();
+  }
+}
+
 
 // Copy saved registers into the isolate buffer.
 static void CopySavedRegisters(intptr_t* saved_registers_address) {
   intptr_t* registers_copy = new intptr_t[kNumberOfCpuRegisters];
   ASSERT(registers_copy != NULL);
   ASSERT(saved_registers_address != NULL);
   for (intptr_t i = 0; i < kNumberOfCpuRegisters; i++) {
     registers_copy[i] = *saved_registers_address;
     saved_registers_address++;
   }
@@ skipping 148 matching lines @@
   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* registers_copy = isolate->deopt_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 = unoptimized_code.GetDeoptPcAtDeoptId(deopt_id);
+  uword continue_at_pc = unoptimized_code.GetDeoptBeforePcAtDeoptId(deopt_id);
   if (FLAG_trace_deopt) {
     OS::Print("  -> continue at 0x%x\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);
@@ skipping 30 matching lines @@
   function.set_usage_counter(0);
   function.set_deoptimization_counter(function.deoptimization_counter() + 1);
 
   if (function.HasOptimizedCode()) {
     function.SwitchToUnoptimizedCode();
   }
 }
 END_LEAF_RUNTIME_ENTRY
 
 }  // namespace dart