Allow optimized code when debugger is active

runtime/vm/debugger.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/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 198 matching lines @@
   len++;  // String terminator.
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat,
               func_class.IsTopLevel() ? "" : class_name.ToCString(),
               func_class.IsTopLevel() ? "" : ".",
               func_name.ToCString());
   return chars;
 }
 
 
+bool Debugger::HasBreakpoint(const Function& func) {
+  if (!func.HasCode()) {
+    // If the function is not compiled yet, just check whether there
+    // is a user-defined latent breakpoint.
+    SourceBreakpoint* sbpt = src_breakpoints_;
+    while (sbpt != NULL) {
+      if (func.raw() == sbpt->function()) {
+        return true;
+      }
+      sbpt = sbpt->next_;
+    }
+    return false;
+  }
+  CodeBreakpoint* cbpt = code_breakpoints_;
+  while (cbpt != NULL) {
+    if (func.raw() == cbpt->function()) {
+      return true;
+    }
+    cbpt = cbpt->next_;
+  }
+  return false;
+}
+
+
 RawString* ActivationFrame::QualifiedFunctionName() {
   const Function& func = DartFunction();
   return String::New(Debugger::QualifiedFunctionName(func));
 }
 
 
 RawString* ActivationFrame::SourceUrl() {
   const Script& script = Script::Handle(SourceScript());
   return script.url();
 }
@@ skipping 467 matching lines @@
     CodeBreakpoint* bpt = code_breakpoints_;
     code_breakpoints_ = code_breakpoints_->next();
     bpt->Disable();
     delete bpt;
   }
   // Signal isolate shutdown event.
   SignalIsolateEvent(Debugger::kIsolateShutdown);
 }
 
 
-bool Debugger::IsActive() {
-  // TODO(hausner): The code generator uses this function to prevent
-  // generation of optimized code when Dart code is being debugged.
-  // This is probably not conservative enough (we could set the first
-  // breakpoint after optimized code has already been produced).
-  // Long-term, we need to be able to de-optimize code.
-  return (src_breakpoints_ != NULL) ||
-         (code_breakpoints_ != NULL) ||
-         (exc_pause_info_ != kNoPauseOnExceptions);
-}
-
-
 static RawFunction* ResolveLibraryFunction(
                         const Library& library,
                         const String& fname) {
   ASSERT(!library.IsNull());
   const Object& object = Object::Handle(library.LookupObject(fname));
   if (!object.IsNull() && object.IsFunction()) {
     return Function::Cast(object).raw();
   }
   return Function::null();
 }
@@ skipping 13 matching lines @@
   if (!cls.IsNull()) {
     function = cls.LookupStaticFunction(function_name);
     if (function.IsNull()) {
       function = cls.LookupDynamicFunction(function_name);
     }
   }
   return function.raw();
 }
 
 
-// Deoptimize function if necessary. Does not patch return addresses on the
-// stack. If there are activation frames of this function on the stack,
-// the optimized code will be executed when the callee returns.
-void Debugger::EnsureFunctionIsDeoptimized(const Function& func) {
-  if (func.HasOptimizedCode()) {
-    if (FLAG_verbose_debug) {
-      OS::Print("Deoptimizing function %s\n",
-                String::Handle(func.name()).ToCString());
+// Deoptimize all functions in the isolate.
+// TODO(hausner): Actually we only need to deoptimize those functions
+// that inline the function that contains the newly created breakpoint.
+// We currently don't have this info so we deoptimize all functions.
+void Debugger::DeoptimizeWorld() {
+  // Deoptimize all functions in stack activation frames.
+  DeoptimizeAll();
+  // Iterate over all classes, deoptimize functions.
+  // TODO(hausner): Could possibly be combined with RemoveOptimizedCode()
+  const ClassTable& class_table = *isolate_->class_table();
+  Class& cls = Class::Handle();
+  Array& functions = Array::Handle();
+  Function& function = Function::Handle();
+  intptr_t num_classes = class_table.NumCids();
+  for (intptr_t i = 1; i < num_classes; i++) {
+    if (class_table.HasValidClassAt(i)) {
+      cls = class_table.At(i);
+      functions = cls.functions();
+      intptr_t num_functions = functions.IsNull() ? 0 : functions.Length();
+      for (intptr_t f = 0; f < num_functions; f++) {
+        function ^= functions.At(f);
+        ASSERT(!function.IsNull());
+        if (function.HasOptimizedCode()) {
+          function.SwitchToUnoptimizedCode();
+        }
+      }
     }
-    func.set_usage_counter(0);
-    func.set_deoptimization_counter(func.deoptimization_counter() + 1);
-    Compiler::CompileFunction(func);
-    ASSERT(!func.HasOptimizedCode());
   }
 }
 
 
 void Debugger::InstrumentForStepping(const Function& target_function) {
-  if (target_function.HasCode()) {
-    EnsureFunctionIsDeoptimized(target_function);
-  } else {
+  if (!target_function.HasCode()) {
     Compiler::CompileFunction(target_function);
     // If there were any errors, ignore them silently and return without
     // adding breakpoints to target.
     if (!target_function.HasCode()) {
       return;
     }
   }
+  DeoptimizeWorld();
+  ASSERT(!target_function.HasOptimizedCode());
   Code& code = Code::Handle(target_function.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   for (int i = 0; i < desc.Length(); i++) {
     CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(i));
     if (bpt != NULL) {
       // There is already a breakpoint for this address. Make sure
       // it is enabled.
       bpt->Enable();
       continue;
@@ skipping 176 matching lines @@
 
 
 SourceBreakpoint* Debugger::SetBreakpoint(const Function& target_function,
                                           intptr_t first_token_pos,
                                           intptr_t last_token_pos) {
   if ((last_token_pos < target_function.token_pos()) ||
       (target_function.end_token_pos() < first_token_pos)) {
     // The given token position is not within the target function.
     return NULL;
   }
-  EnsureFunctionIsDeoptimized(target_function);
+  DeoptimizeWorld();
+  ASSERT(!target_function.HasOptimizedCode());
 
   CodeBreakpoint* cbpt = NULL;
   SourceBreakpoint* source_bpt = NULL;
   if (target_function.HasCode()) {
     cbpt = MakeCodeBreakpoint(target_function, first_token_pos, last_token_pos);
     if (cbpt != NULL) {
       if (cbpt->src_bpt() != NULL) {
         // There is already a source breakpoint for the location.
         ASSERT(cbpt->src_bpt() ==
                GetSourceBreakpoint(target_function, cbpt->token_pos()));
@@ skipping 34 matching lines @@
     }
   }
 
   if (target_function.HasImplicitClosureFunction()) {
     // There is a closurized version of this function. If the closure
     // is already compiled, we need to set a code breakpoint in its
     // code.
     const Function& closure =
         Function::Handle(target_function.ImplicitClosureFunction());
     if (closure.HasCode()) {
-      EnsureFunctionIsDeoptimized(closure);
+      ASSERT(!closure.HasOptimizedCode());
       CodeBreakpoint* closure_bpt =
           MakeCodeBreakpoint(closure, first_token_pos, last_token_pos);
       if ((closure_bpt != NULL) && (closure_bpt->src_bpt() == NULL)) {
         closure_bpt->set_src_bpt(source_bpt);
       }
     }
   }
   source_bpt->Enable();
   return source_bpt;
 }
@@ skipping 612 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart