Fixes a problem with the recovery of contexts in the debugger at closure calls.

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 10 matching lines @@
 #include "vm/port.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, verbose_debug, false, "Verbose debugger messages");
+DEFINE_FLAG(bool, trace_debugger_stacktrace, false,
+            "Trace debugger stacktrace collection");
 
 
 Debugger::EventHandler* Debugger::event_handler_ = NULL;
 
 
 class RemoteObjectCache : public ZoneAllocated {
  public:
   explicit RemoteObjectCache(intptr_t initial_size);
   intptr_t AddObject(const Object& obj);
   RawObject* GetObj(intptr_t obj_id) const;
@@ skipping 398 matching lines @@
 
 
 RawContext* ActivationFrame::GetSavedEntryContext() {
   // Attempt to find a saved context.
   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);
     if (var_info.kind == RawLocalVarDescriptors::kSavedEntryContext) {
+      if (FLAG_trace_debugger_stacktrace) {
+        OS::PrintErr("\tFound saved entry ctx at index %" Pd "\n",
+                     var_info.index);
+      }
       return GetLocalContextVar(var_info.index);
     }
   }
 
   // No saved context.  Return the current context.
   return ctx_.raw();
 }
 
 
 // Get the saved context if the callee of this activation frame is a
 // closure function.
 RawContext* ActivationFrame::GetSavedCurrentContext() {
   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);
     if (var_info.kind == RawLocalVarDescriptors::kSavedCurrentContext) {
+      if (FLAG_trace_debugger_stacktrace) {
+        OS::PrintErr("\tFound saved current ctx at index %" Pd "\n",
+                     var_info.index);
+      }
       return GetLocalContextVar(var_info.index);
     }
   }
   UNREACHABLE();
   return Context::null();
 }
 
 
 ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
     const Instance& exc_obj) const {
@@ skipping 141 matching lines @@
   } else if (context.raw() == Symbols::OptimizedOut().raw()) {
     // The optimizing compiler has eliminated the saved context.
     return Context::null();
   } else {
     UNREACHABLE();
     return Context::null();
   }
 }
 
 
+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");
+  ctx_.Dump(8);
+
+  OS::PrintErr("-------------------------\n"
+               "Debugger stack trace...\n\n");
+  DebuggerStackTrace* stack =
+      Isolate::Current()->debugger()->StackTrace();
+  intptr_t num_frames = stack->Length();
+  for (intptr_t i = 0; i < num_frames; i++) {
+    ActivationFrame* frame = stack->FrameAt(i);
+    OS::PrintErr("#%04" Pd " %s", i, frame->ToCString());
+  }
+
+  OS::PrintErr("-------------------------\n"
+               "All frames...\n\n");
+  StackFrameIterator iterator(false);
+  StackFrame* frame = iterator.NextFrame();
+  intptr_t num = 0;
+  while ((frame != NULL)) {
+    frame = iterator.NextFrame();
+    OS::PrintErr("#%04" Pd " %s\n", num++, frame->ToCString());
+  }
+}
+
+
 void ActivationFrame::VariableAt(intptr_t i,
                                  String* name,
                                  intptr_t* token_pos,
                                  intptr_t* end_pos,
                                  Instance* value) {
   GetDescIndices();
   ASSERT(i < desc_indices_.length());
   intptr_t desc_index = desc_indices_[i];
   ASSERT(name != NULL);
   *name ^= var_descriptors_.GetName(desc_index);
   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);
   if (var_info.kind == RawLocalVarDescriptors::kStackVar) {
     *value = GetLocalInstanceVar(var_info.index);
   } else {
     ASSERT(var_info.kind == RawLocalVarDescriptors::kContextVar);
     if (ctx_.IsNull()) {
       // The context has been removed by the optimizing compiler.
+      //
+      // TODO(turnidge): This may be erroneous.  Revisit.
       *value = Symbols::OptimizedOut().raw();
       return;
     }
 
     // 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);
     }
   }
 }
 
 
 RawArray* ActivationFrame::GetLocalVariables() {
   GetDescIndices();
   intptr_t num_variables = desc_indices_.length();
   String& var_name = String::Handle();
   Instance& 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);
     list.SetAt(2 * i, var_name);
     list.SetAt((2 * i) + 1, value);
   }
   return list.raw();
 }
 
 
 const char* ActivationFrame::ToCString() {
-  const char* kFormat = "Function: '%s' url: '%s' line: %d";
-
   const String& url = String::Handle(SourceUrl());
   intptr_t line = LineNumber();
   const char* func_name = Debugger::QualifiedFunctionName(function());
-
-  intptr_t len =
-      OS::SNPrint(NULL, 0, kFormat, func_name, url.ToCString(), line);
-  len++;  // String terminator.
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, func_name, url.ToCString(), line);
-  return chars;
+  return Isolate::Current()->current_zone()->
+      PrintToString("[ Frame pc(0x%" Px ") fp(0x%" Px ") sp(0x%" Px ")\n"
+                    "\tfunction = %s\n"
+                    "\turl = %s\n"
+                    "\tline = %" Pd "\n"
+                    "\tcontext = %s\n"
+                    "\tcontext level = %" Pd " ]\n",
+                    pc(), fp(), sp(),
+                    func_name,
+                    url.ToCString(),
+                    line,
+                    ctx_.ToCString(),
+                    ContextLevel());
 }
 
 
 void ActivationFrame::PrintToJSONObject(JSONObject* jsobj) {
   const Script& script = Script::Handle(SourceScript());
   jsobj->AddProperty("script", script);
   jsobj->AddProperty("tokenPos", TokenPos());
   jsobj->AddProperty("function", function());
   jsobj->AddProperty("code", code());
   {
@@ skipping 339 matching lines @@
                                             intptr_t deopt_frame_offset,
                                             ActivationFrame* callee_activation,
                                             const Context& entry_ctx) {
   // We provide either a callee activation or an entry context.  Not both.
   ASSERT(((callee_activation != NULL) && entry_ctx.IsNull()) ||
          ((callee_activation == NULL) && !entry_ctx.IsNull()));
   ActivationFrame* activation =
       new ActivationFrame(pc, frame->fp(), frame->sp(), code,
                           deopt_frame, deopt_frame_offset);
 
+  // Is there a closure call at the current PC?
+  //
+  // We can't just check the callee_activation to see if it is a
+  // closure function, because it may not be on the stack yet.
+  bool is_closure_call = false;
+  const PcDescriptors& pc_desc =
+      PcDescriptors::Handle(code.pc_descriptors());
+  ASSERT(code.ContainsInstructionAt(pc));
+  for (int i = 0; i < pc_desc.Length(); i++) {
+    if (pc_desc.PC(i) == pc &&
+        pc_desc.DescriptorKind(i) == PcDescriptors::kClosureCall) {
+      is_closure_call = true;
+      break;
+    }
+  }
+
   // Recover the context for this frame.
-  if (callee_activation == NULL) {
-    // No callee.  Use incoming entry context.  Could be from
-    // isolate's top context or from an entry frame.
-    ASSERT(!entry_ctx.IsNull());
-    activation->SetContext(entry_ctx);
-
-  } else if (callee_activation->function().IsClosureFunction()) {
+  if (is_closure_call) {
     // If the callee is a closure, we should have stored the context
     // in the current frame before making the call.
     const Context& closure_call_ctx =
         Context::Handle(isolate, activation->GetSavedCurrentContext());
     ASSERT(!closure_call_ctx.IsNull());
     activation->SetContext(closure_call_ctx);
-
+    if (FLAG_trace_debugger_stacktrace) {
+      OS::PrintErr("\tUsing closure call ctx: %s\n",
+                   closure_call_ctx.ToCString());
+    }
+  } else if (callee_activation == NULL) {
+    // No callee available.  Use incoming entry context.  Could be from
+    // isolate's top context or from an entry frame.
+    ASSERT(!entry_ctx.IsNull());
+    activation->SetContext(entry_ctx);
+    if (FLAG_trace_debugger_stacktrace) {
+      OS::PrintErr("\tUsing entry ctx: %s\n", entry_ctx.ToCString());
+    }
   } else {
     // Use the context provided by our callee.  This is either the
     // callee's context or a context that was saved in the callee's
     // frame.
     //
     // The callee's saved context may be NULL if it was eliminated by
     // the optimizing compiler.
     const Context& callee_ctx =
         Context::Handle(isolate, callee_activation->GetSavedEntryContext());
     activation->SetContext(callee_ctx);
+    if (FLAG_trace_debugger_stacktrace) {
+      OS::PrintErr("\tUsing callee call ctx: %s\n",
+                   callee_ctx.ToCString());
+    }
+  }
+  if (FLAG_trace_debugger_stacktrace) {
+    OS::PrintErr("\tLine number: %" Pd "\n", activation->LineNumber());
   }
   return activation;
 }
 
 
 RawArray* Debugger::DeoptimizeToArray(Isolate* isolate,
                                       StackFrame* frame,
                                       const Code& code) {
   ASSERT(code.is_optimized());
 
@@ skipping 22 matching lines @@
   ActivationFrame* current_activation = NULL;
   Context& entry_ctx = Context::Handle(isolate->top_context());
   Code& code = Code::Handle(isolate);
   Code& inlined_code = Code::Handle(isolate);
   Array& deopt_frame = Array::Handle(isolate);
 
   for (StackFrame* frame = iterator.NextFrame();
        frame != NULL;
        frame = iterator.NextFrame()) {
     ASSERT(frame->IsValid());
+    if (FLAG_trace_debugger_stacktrace) {
+      OS::PrintErr("CollectStackTrace: visiting frame:\n\t%s\n",
+                   frame->ToCString());
+    }
     if (frame->IsEntryFrame()) {
       current_activation = NULL;
       entry_ctx = reinterpret_cast<EntryFrame*>(frame)->SavedContext();
+      if (FLAG_trace_debugger_stacktrace) {
+        OS::PrintErr("\tFound saved ctx in  entry frame:\n\t%s\n",
+                     entry_ctx.ToCString());
+      }
 
     } else if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
       if (code.is_optimized()) {
         deopt_frame = DeoptimizeToArray(isolate, frame, code);
         for (InlinedFunctionsIterator it(code, frame->pc());
              !it.Done();
              it.Advance()) {
           inlined_code = it.code();
+          if (FLAG_trace_debugger_stacktrace) {
+            const Function& function =
+                Function::Handle(inlined_code.function());
+            ASSERT(!function.IsNull());
+            OS::PrintErr("CollectStackTrace: visiting inlined function: %s\n",
+                         function.ToFullyQualifiedCString());
+          }
           intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
           current_activation = CollectDartFrame(isolate,
                                                 it.pc(),
                                                 frame,
                                                 inlined_code,
                                                 deopt_frame,
                                                 deopt_frame_offset,
                                                 current_activation,
                                                 entry_ctx);
           stack_trace->AddActivation(current_activation);
@@ skipping 1157 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart