Async-step, first cut.

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 640 matching lines @@
   intptr_t var_desc_len = var_descriptors_.Length();
   for (intptr_t i = 0; i < var_desc_len; i++) {
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(i, &var_info);
     const int8_t kind = var_info.kind();
     if (kind == RawLocalVarDescriptors::kSavedCurrentContext) {
       if (FLAG_trace_debugger_stacktrace) {
         OS::PrintErr("\tFound saved current ctx at index %d\n",
             var_info.index());
       }
-      ctx_ ^= GetLocalVar(var_info.index());
+      ctx_ ^= GetStackVar(var_info.index());
       return ctx_;
     }
   }
   UNREACHABLE();
   return Context::ZoneHandle(Context::null());
 }
 
 
+RawObject* ActivationFrame::GetAsyncOperation() {
+  GetVarDescriptors();
+  intptr_t var_desc_len = var_descriptors_.Length();
+  for (intptr_t i = 0; i < var_desc_len; i++) {
+    RawLocalVarDescriptors::VarInfo var_info;
+    var_descriptors_.GetInfo(i, &var_info);
+    const int8_t kind = var_info.kind();
+    if (kind == RawLocalVarDescriptors::kAsyncOperation) {
+      return GetContextVar(var_info.scope_id, var_info.index());
+    }
+  }
+  return Object::null();
+}
+
+
 ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
     const Instance& exc_obj) const {
   ExceptionHandlers& handlers = ExceptionHandlers::Handle();
   Array& handled_types = Array::Handle();
   AbstractType& type = Type::Handle();
   const TypeArguments& no_instantiator = TypeArguments::Handle();
   for (intptr_t frame_index = 0;
        frame_index < Length();
        frame_index++) {
     ActivationFrame* frame = FrameAt(frame_index);
@@ skipping 129 matching lines @@
   }
 }
 
 
 RawObject* ActivationFrame::GetClosure() {
   ASSERT(function().IsClosureFunction());
   return GetParameter(0);
 }
 
 
-RawObject* ActivationFrame::GetLocalVar(intptr_t slot_index) {
+RawObject* ActivationFrame::GetStackVar(intptr_t slot_index) {
   if (deopt_frame_.IsNull()) {
     uword var_address = fp() + slot_index * kWordSize;
     return reinterpret_cast<RawObject*>(
         *reinterpret_cast<uword*>(var_address));
   } else {
     return deopt_frame_.At(deopt_frame_offset_ + slot_index);
   }
 }
 
 
-RawInstance* ActivationFrame::GetLocalInstanceVar(intptr_t slot_index) {
-  Instance& instance = Instance::Handle();
-  instance ^= GetLocalVar(slot_index);
-  return instance.raw();
-}
-
-
 void ActivationFrame::PrintContextMismatchError(
-    const String& var_name,
     intptr_t ctx_slot,
     intptr_t frame_ctx_level,
     intptr_t var_ctx_level) {
   OS::PrintErr("-------------------------\n"
                "Encountered context mismatch\n"
-               "\tvar name: %s\n"
                "\tctx_slot: %" Pd "\n"
                "\tframe_ctx_level: %" Pd "\n"
                "\tvar_ctx_level: %" Pd "\n\n",
-               var_name.ToCString(),
                ctx_slot,
                frame_ctx_level,
                var_ctx_level);
 
   OS::PrintErr("-------------------------\n"
                "Current frame:\n%s\n",
                this->ToCString());
 
   OS::PrintErr("-------------------------\n"
                "Context contents:\n");
@@ skipping 37 matching lines @@
 
   RawLocalVarDescriptors::VarInfo var_info;
   var_descriptors_.GetInfo(desc_index, &var_info);
   ASSERT(token_pos != NULL);
   *token_pos = var_info.begin_pos;
   ASSERT(end_pos != NULL);
   *end_pos = var_info.end_pos;
   ASSERT(value != NULL);
   const int8_t kind = var_info.kind();
   if (kind == RawLocalVarDescriptors::kStackVar) {
-    *value = GetLocalInstanceVar(var_info.index());
+    *value = GetStackVar(var_info.index());
   } else {
     ASSERT(kind == RawLocalVarDescriptors::kContextVar);
-    const Context& ctx = GetSavedCurrentContext();
-    ASSERT(!ctx.IsNull());
-
-    // The context level at the PC/token index of this activation frame.
-    intptr_t frame_ctx_level = ContextLevel();
-
-    // The context level of the variable.
-    intptr_t var_ctx_level = var_info.scope_id;
-    intptr_t level_diff = frame_ctx_level - var_ctx_level;
-    intptr_t ctx_slot = var_info.index();
-    if (level_diff == 0) {
-      if ((ctx_slot < 0) ||
-          (ctx_slot >= ctx.num_variables())) {
-        PrintContextMismatchError(*name, ctx_slot,
-                                  frame_ctx_level, var_ctx_level);
-      }
-      ASSERT((ctx_slot >= 0) && (ctx_slot < ctx.num_variables()));
-      *value = ctx.At(ctx_slot);
-    } else {
-      ASSERT(level_diff > 0);
-      Context& var_ctx = Context::Handle(ctx.raw());
-      while (level_diff > 0 && !var_ctx.IsNull()) {
-        level_diff--;
-        var_ctx = var_ctx.parent();
-      }
-      if (var_ctx.IsNull() ||
-          (ctx_slot < 0) ||
-          (ctx_slot >= var_ctx.num_variables())) {
-        PrintContextMismatchError(*name, ctx_slot,
-                                  frame_ctx_level, var_ctx_level);
-      }
-      ASSERT(!var_ctx.IsNull());
-      ASSERT((ctx_slot >= 0) && (ctx_slot < var_ctx.num_variables()));
-      *value = var_ctx.At(ctx_slot);
-    }
+    *value = GetContextVar(var_info.scope_id, var_info.index());
   }
 }
 
+
+RawObject* ActivationFrame::GetContextVar(intptr_t var_ctx_level,
+                                          intptr_t ctx_slot) {
+  const Context& ctx = GetSavedCurrentContext();
+  ASSERT(!ctx.IsNull());
+
+  // The context level at the PC/token index of this activation frame.
+  intptr_t frame_ctx_level = ContextLevel();
+
+  intptr_t level_diff = frame_ctx_level - var_ctx_level;
+  if (level_diff == 0) {
+    if ((ctx_slot < 0) ||
+        (ctx_slot >= ctx.num_variables())) {
+      PrintContextMismatchError(ctx_slot, frame_ctx_level, var_ctx_level);
+    }
+    ASSERT((ctx_slot >= 0) && (ctx_slot < ctx.num_variables()));
+    return ctx.At(ctx_slot);
+  } else {
+    ASSERT(level_diff > 0);
+    Context& var_ctx = Context::Handle(ctx.raw());
+    while (level_diff > 0 && !var_ctx.IsNull()) {
+      level_diff--;
+      var_ctx = var_ctx.parent();
+    }
+    if (var_ctx.IsNull() ||
+        (ctx_slot < 0) ||
+        (ctx_slot >= var_ctx.num_variables())) {
+      PrintContextMismatchError(ctx_slot, frame_ctx_level, var_ctx_level);
+    }
+    ASSERT(!var_ctx.IsNull());
+    ASSERT((ctx_slot >= 0) && (ctx_slot < var_ctx.num_variables()));
+    return var_ctx.At(ctx_slot);
+  }
+}
+
 
 RawArray* ActivationFrame::GetLocalVariables() {
   GetDescIndices();
   intptr_t num_variables = desc_indices_.length();
   String& var_name = String::Handle();
   Object& value = Instance::Handle();
   const Array& list = Array::Handle(Array::New(2 * num_variables));
   for (intptr_t i = 0; i < num_variables; i++) {
     intptr_t ignore;
     VariableAt(i, &var_name, &ignore, &ignore, &value);
@@ skipping 880 matching lines @@
           }
         }
       }
     }
   }
   return best_fit.raw();
 }
 
 
 BreakpointLocation* Debugger::SetBreakpoint(const Script& script,
-                                          intptr_t token_pos,
-                                          intptr_t last_token_pos) {
+                                            intptr_t token_pos,
+                                            intptr_t last_token_pos) {
   Function& func = Function::Handle(isolate_);
   func = FindBestFit(script, token_pos);
   if (func.IsNull()) {
     return NULL;
   }
   // There may be more than one function object for a given function
   // in source code. There may be implicit closure functions, and
   // there may be copies of mixin functions. Collect all compiled
   // functions whose source code range matches exactly the best fit
   // function we found.
@@ skipping 510 matching lines @@
                                  Breakpoint* bpt) {
   resume_action_ = kContinue;
   stepping_fp_ = 0;
   isolate_->set_single_step(false);
   ASSERT(!IsPaused());
   ASSERT(obj_cache_ == NULL);
   if ((bpt != NULL) && bpt->IsSingleShot())  {
     RemoveBreakpoint(bpt->id());
     bpt = NULL;
   }
+
   DebuggerEvent event(isolate_, DebuggerEvent::kBreakpointReached);
   event.set_top_frame(top_frame);
   event.set_breakpoint(bpt);
+  Object& closure_or_null = Object::Handle(top_frame->GetAsyncOperation());
+  event.set_async_continuation(&closure_or_null);
   Pause(&event);
 }
 
 
 void Debugger::DebuggerStepCallback() {
   ASSERT(isolate_->single_step());
   // We can't get here unless the debugger event handler enabled
   // single stepping.
   ASSERT(HasEventHandler());
   // Don't pause recursively.
@@ skipping 599 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart