Ensure the debugger keeps a reference to code objects

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 138 matching lines @@
     location.AddProperty("type", "Location");
 
     const String& url = String::Handle(script.url());
     location.AddProperty("script", url.ToCString());
     location.AddProperty("tokenPos", token_pos);
   }
 }
 
 
 void CodeBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
-  visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
+  visitor->VisitPointer(reinterpret_cast<RawObject**>(&code_));
 }
 
 
 ActivationFrame::ActivationFrame(
     uword pc,
     uword fp,
     uword sp,
     const Code& code,
     const Array& deopt_frame,
     intptr_t deopt_frame_offset)
@@ skipping 92 matching lines @@
   while (cbpt != NULL) {
     if (func.raw() == cbpt->function()) {
       return true;
     }
     cbpt = cbpt->next_;
   }
   return false;
 }
 
 
+bool Debugger::HasBreakpoint(const Code& code) {
+  CodeBreakpoint* cbpt = code_breakpoints_;
+  while (cbpt != NULL) {
+    if (code.raw() == cbpt->code_) {
+      return true;
+    }
+    cbpt = cbpt->next_;
+  }
+  return false;
+}
+
+
 void Debugger::PrintBreakpointsToJSONArray(JSONArray* jsarr) const {
   SourceBreakpoint* sbpt = src_breakpoints_;
   while (sbpt != NULL) {
     jsarr->AddValue(sbpt);
     sbpt = sbpt->next_;
   }
 }
 
 
 RawString* ActivationFrame::QualifiedFunctionName() {
@@ skipping 417 matching lines @@
           (kind == PcDescriptors::kRuntimeCall));
 }
 
 
 static bool IsSafePoint(const PcDescriptors& desc, intptr_t i) {
   return IsSafeDescKind(desc.DescriptorKind(i)) &&
          (desc.TokenPos(i) != Scanner::kNoSourcePos);
 }
 
 
-CodeBreakpoint::CodeBreakpoint(const Function& func, intptr_t pc_desc_index)
-    : function_(func.raw()),
+CodeBreakpoint::CodeBreakpoint(const Code& code, intptr_t pc_desc_index)
+    : code_(code.raw()),
       pc_desc_index_(pc_desc_index),
       pc_(0),
       line_number_(-1),
       is_enabled_(false),
       src_bpt_(NULL),
       next_(NULL) {
   saved_value_ = 0;
-  ASSERT(!func.HasOptimizedCode());
-  Code& code = Code::Handle(func.unoptimized_code());
-  ASSERT(!code.IsNull());  // Function must be compiled.
+  ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   ASSERT(pc_desc_index < desc.Length());
   token_pos_ = desc.TokenPos(pc_desc_index);
   ASSERT(token_pos_ > 0);
   pc_ = desc.PC(pc_desc_index);
   ASSERT(pc_ != 0);
   breakpoint_kind_ = desc.DescriptorKind(pc_desc_index);
   ASSERT(IsSafeDescKind(breakpoint_kind_));
 }
 
 
 CodeBreakpoint::~CodeBreakpoint() {
   // Make sure we don't leave patched code behind.
   ASSERT(!IsEnabled());
   // Poison the data so we catch use after free errors.
 #ifdef DEBUG
-  function_ = Function::null();
+  code_ = Code::null();
   pc_ = 0ul;
   src_bpt_ = NULL;
   next_ = NULL;
   breakpoint_kind_ = PcDescriptors::kOther;
 #endif
 }
 
 
+RawFunction* CodeBreakpoint::function() const {
+  return Code::Handle(code_).function();
+}
+
+
 RawScript* CodeBreakpoint::SourceCode() {
-  const Function& func = Function::Handle(function_);
+  const Function& func = Function::Handle(this->function());
   return func.script();
 }
 
 
 RawString* CodeBreakpoint::SourceUrl() {
   const Script& script = Script::Handle(SourceCode());
   return script.url();
 }
 
 
@@ skipping 199 matching lines @@
     return;
   }
   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;
     }
   }
+  // Hang on to the code object before deoptimizing, in case deoptimization
+  // might cause the GC to run.
+  Code& code = Code::Handle(target_function.unoptimized_code());
+  ASSERT(!code.IsNull());
   DeoptimizeWorld();
   ASSERT(!target_function.HasOptimizedCode());
-  Code& code = Code::Handle(target_function.unoptimized_code());
-  ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   for (intptr_t i = 0; i < desc.Length(); i++) {
     if (IsSafePoint(desc, 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;
       }
-      bpt = new CodeBreakpoint(target_function, i);
+      bpt = new CodeBreakpoint(code, i);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
     }
   }
 }
 
 
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
   if (event_handler_ != NULL) {
     DebuggerEvent event(kBreakpointResolved);
@@ skipping 307 matching lines @@
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   for (intptr_t i = 0; i < desc.Length(); i++) {
     intptr_t desc_token_pos = desc.TokenPos(i);
     if ((desc_token_pos == bpt->token_pos_) && IsSafePoint(desc, i)) {
       CodeBreakpoint* code_bpt = GetCodeBreakpoint(desc.PC(i));
       if (code_bpt == NULL) {
         // No code breakpoint for this code exists; create one.
-        code_bpt = new CodeBreakpoint(func, i);
+        code_bpt = new CodeBreakpoint(code, i);
         RegisterCodeBreakpoint(code_bpt);
       }
       code_bpt->set_src_bpt(bpt);
       if (bpt->IsEnabled()) {
         code_bpt->Enable();
       }
     }
   }
 }
 
@@ skipping 920 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart