Fix debugging of async code

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 46 matching lines @@
 SourceBreakpoint::SourceBreakpoint(intptr_t id,
                                    const Script& script,
                                    intptr_t token_pos,
                                    intptr_t end_token_pos)
     : id_(id),
       script_(script.raw()),
       token_pos_(token_pos),
       end_token_pos_(end_token_pos),
       is_resolved_(false),
       is_enabled_(false),
+      is_one_shot_(false),
       next_(NULL),
       function_(Function::null()),
       line_number_(-1) {
   ASSERT(id_ > 0);
   ASSERT(!script.IsNull());
   ASSERT(token_pos_ >= 0);
 }
 
 
 void SourceBreakpoint::Enable() {
@@ skipping 1054 matching lines @@
           if (function.HasOptimizedCode()) {
             function.SwitchToUnoptimizedCode();
           }
         }
       }
     }
   }
 }
 
 
-RawError* Debugger::SetInternalBreakpoints(const Function& target_function) {
-  if (target_function.is_native()) {
-    // Can't instrument native functions. Fail silently.
-    return Error::null();
-  }
-  Isolate* isolate = Isolate::Current();
-  if (!target_function.HasCode()) {
-    const Error& error = Error::Handle(
-        Compiler::CompileFunction(isolate, target_function));
-    if (!error.IsNull()) {
-      return error.raw();
-    }
-  }
-  // Hang on to the code object before deoptimizing, in case deoptimization
-  // might cause the GC to run.
-  Code& code = Code::Handle(isolate, target_function.unoptimized_code());
-  ASSERT(!code.IsNull());
-  DeoptimizeWorld();
-  ASSERT(!target_function.HasOptimizedCode());
-  PcDescriptors& desc = PcDescriptors::Handle(isolate, code.pc_descriptors());
-  PcDescriptors::Iterator iter(desc, kSafepointKind);
-  while (iter.MoveNext()) {
-    if (iter.TokenPos() != Scanner::kNoSourcePos) {
-      CodeBreakpoint* bpt = GetCodeBreakpoint(iter.Pc());
-      if (bpt != NULL) {
-        // There is already a breakpoint for this address. Make sure
-        // it is enabled.
-        bpt->Enable();
-        continue;
-      }
-      bpt = new CodeBreakpoint(code, iter.TokenPos(),
-                               iter.Pc(), iter.Kind());
-      RegisterCodeBreakpoint(bpt);
-      bpt->Enable();
-    }
-  }
-  return Error::null();
-}
-
-
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
-  if (HasEventHandler()) {
+  if (HasEventHandler() && !bpt->IsOneShot()) {
     DebuggerEvent event(isolate_, DebuggerEvent::kBreakpointResolved);
     event.set_breakpoint(bpt);
     InvokeEventHandler(&event);
   }
 }
 
 
 ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
                                             uword pc,
                                             StackFrame* frame,
@@ skipping 218 matching lines @@
   }
   DebuggerEvent event(isolate_, DebuggerEvent::kExceptionThrown);
   event.set_exception(&exc);
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
   Pause(&event);
   stack_trace_ = NULL;
 }
 
 
+static intptr_t LastTokenOnLine(const TokenStream& tokens, intptr_t pos) {
+  TokenStream::Iterator iter(tokens, pos, TokenStream::Iterator::kAllTokens);
+  ASSERT(iter.IsValid());
+  intptr_t last_pos = pos;
+  while ((iter.CurrentTokenKind() != Token::kNEWLINE) &&
+      (iter.CurrentTokenKind() != Token::kEOS)) {
+    last_pos = iter.CurrentPosition();
+    iter.Advance();
+  }
+  return last_pos;
+}
+
+
 // Given a function and a token range, return the best fit
 // token position to set a breakpoint. The best fit is the safe point
-// with the lowest compiled code address within the token range.
+// in the line closest to the beginning of the token range, and within
+// that line, the safe point with the lowest compiled code address.
 intptr_t Debugger::ResolveBreakpointPos(const Function& func,
                                         intptr_t requested_token_pos,
                                         intptr_t last_token_pos) {
   ASSERT(func.HasCode());
   ASSERT(!func.HasOptimizedCode());
 
   if (requested_token_pos < func.token_pos()) {
     requested_token_pos = func.token_pos();
   }
   if (last_token_pos > func.end_token_pos()) {
     last_token_pos = func.end_token_pos();
   }
 
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
+
+  // First pass: find the safe point which is closest to the beginning
+  // of the given token range.
   intptr_t best_fit_pos = INT_MAX;
-  uword lowest_pc = kUwordMax;
-  intptr_t lowest_pc_token_pos = INT_MAX;
   PcDescriptors::Iterator iter(desc, kSafepointKind);
   while (iter.MoveNext()) {
     const intptr_t desc_token_pos = iter.TokenPos();
-    ASSERT(desc_token_pos >= 0);
-    if (desc_token_pos != Scanner::kNoSourcePos) {
-      if ((desc_token_pos < requested_token_pos) ||
-          (desc_token_pos > last_token_pos)) {
-        // This descriptor is outside the desired token range.
-        continue;
-      }
-      if (desc_token_pos < best_fit_pos) {
-        // So far, this descriptor has the lowest token position after
-        // the first acceptable token position.
-        best_fit_pos = desc_token_pos;
-      }
-      if (iter.Pc() < lowest_pc) {
-        // This descriptor so far has the lowest code address.
+    if ((desc_token_pos != Scanner::kNoSourcePos) &&
+        (desc_token_pos < best_fit_pos) &&
+        (desc_token_pos >= requested_token_pos) &&
+        (desc_token_pos <= last_token_pos)) {
+       best_fit_pos = desc_token_pos;
+    }
+  }
+  // Second pass (if we found a safe point in the first pass):
+  // For all token positions on the same line, select the one
+  // with the lowest compiled code address. E.g., in a line with
+  // the nested function calls f(g(x)), the call g() will have a lower
+  // compiled code address but is not the lowest token position in the
+  // line.
+  if (best_fit_pos != INT_MAX) {
+    const Script& script = Script::Handle(func.script());
+    const TokenStream& tokens = TokenStream::Handle(script.tokens());
+    const intptr_t begin_pos = best_fit_pos;
+    const intptr_t end_of_line_pos = LastTokenOnLine(tokens, begin_pos);
+    uword lowest_pc = kUwordMax;
+    PcDescriptors::Iterator iter(desc, kSafepointKind);
+    while (iter.MoveNext()) {
+      const intptr_t pos = iter.TokenPos();
+      if ((pos != Scanner::kNoSourcePos) &&
+          (begin_pos <= pos) && (pos <= end_of_line_pos) &&
+          (iter.Pc() < lowest_pc)) {
         lowest_pc = iter.Pc();
-        lowest_pc_token_pos = desc_token_pos;
+        best_fit_pos = pos;
       }
     }
-  }
-  if (lowest_pc_token_pos != INT_MAX) {
-    // We found the pc descriptor that has the lowest execution address.
-    // This is the first possible breakpoint after the requested token
-    // position. We use this instead of the nearest PC descriptor
-    // measured in token index distance.
-    return lowest_pc_token_pos;
-  }
-  if (best_fit_pos != INT_MAX) {
     return best_fit_pos;
   }
+
   // We didn't find a safe point in the given token range. Try and find
   // a safe point in the remaining source code of the function.
   if (last_token_pos < func.end_token_pos()) {
     return ResolveBreakpointPos(func, last_token_pos, func.end_token_pos());
   }
   return -1;
 }
 
 
 void Debugger::MakeCodeBreakpointAt(const Function& func,
@@ skipping 62 matching lines @@
       if (!functions.IsNull()) {
         const intptr_t num_functions = functions.Length();
         for (intptr_t pos = 0; pos < num_functions; pos++) {
           function ^= functions.At(pos);
           ASSERT(!function.IsNull());
           // Check token position first to avoid unnecessary calls
           // to script() which allocates handles.
           if ((function.token_pos() == start_pos)
               && (function.end_token_pos() == end_pos)
               && (function.script() == script.raw())) {
-            if (function.HasCode()) {
+            if (function.HasCode() && !function.IsAsyncFunction()) {
               function_list->Add(function);
             }
             if (function.HasImplicitClosureFunction()) {
               function = function.ImplicitClosureFunction();
-              if (function.HasCode()) {
+              if (function.HasCode() && !function.IsAsyncFunction()) {
                 function_list->Add(function);
               }
             }
           }
         }
       }
       closures = cls.closures();
       if (!closures.IsNull()) {
         const intptr_t num_closures = closures.Length();
         for (intptr_t pos = 0; pos < num_closures; pos++) {
           function ^= closures.At(pos);
           ASSERT(!function.IsNull());
           if ((function.token_pos() == start_pos)
               && (function.end_token_pos() == end_pos)
               && (function.script() == script.raw())) {
-            if (function.HasCode()) {
+            if (function.HasCode() && !function.IsAsyncFunction()) {
               function_list->Add(function);
             }
             if (function.HasImplicitClosureFunction()) {
               function = function.ImplicitClosureFunction();
-              if (function.HasCode()) {
+              if (function.HasCode() && !function.IsAsyncFunction()) {
                 function_list->Add(function);
               }
             }
           }
         }
       }
     }
   }
 }
 
@@ skipping 122 matching lines @@
       const intptr_t num_functions = functions.Length();
       for (intptr_t i = 0; i < num_functions; i++) {
         func ^= functions.At(i);
         ASSERT(func.HasCode());
         MakeCodeBreakpointAt(func, bpt);
       }
       bpt->Enable();
       if (FLAG_verbose_debug) {
         intptr_t line_number;
         script.GetTokenLocation(breakpoint_pos, &line_number, NULL);
-        OS::Print("Resolved breakpoint for "
+        OS::Print("Resolved BP for "
                   "function '%s' at line %" Pd "\n",
                   func.ToFullyQualifiedCString(),
                   line_number);
       }
       SignalBpResolved(bpt);
       return bpt;
     }
   }
   // There is no compiled function at this token position.
   // Register an unresolved breakpoint.
@@ skipping 26 matching lines @@
       } else {
         cbpt->Disable();
       }
     }
     cbpt = cbpt->next();
   }
 }
 
 
 RawError* Debugger::OneTimeBreakAtEntry(const Function& target_function) {
-  Error& err = Error::Handle();
-  err = SetInternalBreakpoints(target_function);
-  if (err.IsNull() && target_function.HasImplicitClosureFunction()) {
-    const Function& closure_func =
-        Function::Handle(target_function.ImplicitClosureFunction());
-    err = SetInternalBreakpoints(closure_func);
+  SourceBreakpoint* bpt = SetBreakpointAtEntry(target_function);
+  if (bpt != NULL) {
+    bpt->SetIsOneShot();
   }
-  return err.raw();
+  return Error::null();
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpointAtEntry(
       const Function& target_function) {
   ASSERT(!target_function.IsNull());
   const Script& script = Script::Handle(target_function.script());
   return SetBreakpoint(script,
                        target_function.token_pos(),
                        target_function.end_token_pos());
@@ skipping 338 matching lines @@
 }
 
 
 void Debugger::SignalPausedEvent(ActivationFrame* top_frame,
                                  SourceBreakpoint* bpt) {
   resume_action_ = kContinue;
   stepping_fp_ = 0;
   isolate_->set_single_step(false);
   ASSERT(!IsPaused());
   ASSERT(obj_cache_ == NULL);
+  if ((bpt != NULL) && bpt->IsOneShot()) {
+    RemoveBreakpoint(bpt->id());
+    bpt = NULL;
+  }
   DebuggerEvent event(isolate_, DebuggerEvent::kBreakpointReached);
   event.set_top_frame(top_frame);
   event.set_breakpoint(bpt);
   Pause(&event);
 }
 
 
 void Debugger::DebuggerStepCallback() {
   ASSERT(isolate_->single_step());
   // We can't get here unless the debugger event handler enabled
@@ skipping 348 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart