Allow the debugger to inspect local variables from optimized and

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"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
+#include "vm/deopt_instructions.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #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, use_new_stacktrace, true,
+            "Use new stacktrace creation");
 
 
 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 87 matching lines @@
 
 ActivationFrame::ActivationFrame(uword pc, uword fp, uword sp, const Code& code)
     : pc_(pc), fp_(fp), sp_(sp),
       ctx_(Context::ZoneHandle()),
       code_(Code::ZoneHandle(code.raw())),
       function_(Function::ZoneHandle(code.function())),
       token_pos_(-1),
       pc_desc_index_(-1),
       line_number_(-1),
       context_level_(-1),
+      deopt_frame_(Array::ZoneHandle()),
+      deopt_frame_offset_(0),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {
 }
 
 
 void Debugger::SignalIsolateEvent(EventType type) {
   if (event_handler_ != NULL) {
     Debugger* debugger = Isolate::Current()->debugger();
@@ skipping 205 matching lines @@
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(i, &var_info);
     if (var_info.kind == RawLocalVarDescriptors::kSavedEntryContext) {
       return reinterpret_cast<RawContext*>(GetLocalVarValue(var_info.index));
     }
   }
   return ctx.raw();
 }
 
 
+RawContext* ActivationFrame::GetSavedEntryContextNew() {
+  if (ctx_.IsNull()) {
+    // We have bailed on providing a context for this frame.  Bail for
+    // the caller as well.
+    return Context::null();
+  }
+
+  // Attempt to find a saved context.
+  GetVarDescriptors();
+  intptr_t var_desc_len = var_descriptors_.Length();
+  for (int i = 0; i < var_desc_len; i++) {

[srdjan, 2013/10/07 21:36:53]

s/int/intptr_t/

[turnidge, 2013/10/08 17:29:12]

Done.

There is other cases like this in this file -- GetTokenPos,
GetSavedCurrentContext, GetDescIndices, etc. -- should I be fixing those too?

[srdjan, 2013/10/08 18:41:25]

Either here or a later CL.

+    RawLocalVarDescriptors::VarInfo var_info;
+    var_descriptors_.GetInfo(i, &var_info);
+    if (var_info.kind == RawLocalVarDescriptors::kSavedEntryContext) {
+      return reinterpret_cast<RawContext*>(GetLocalVarValue(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 (int i = 0; i < var_desc_len; i++) {
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(i, &var_info);
     if (var_info.kind == RawLocalVarDescriptors::kSavedCurrentContext) {
       return reinterpret_cast<RawContext*>(GetLocalVarValue(var_info.index));
@@ skipping 43 matching lines @@
 void ActivationFrame::GetDescIndices() {
   if (vars_initialized_) {
     return;
   }
   GetVarDescriptors();
 
   // We don't trust variable descriptors in optimized code.
   // Rather than potentially displaying incorrect values, we
   // pretend that there are no variables in the frame.
   // We should be more clever about this in the future.
-  if (code().is_optimized()) {
+  if (!FLAG_use_new_stacktrace && code().is_optimized()) {
     vars_initialized_ = true;
     return;
   }
 
   intptr_t activation_token_pos = TokenPos();
   if (activation_token_pos < 0) {
     // We don't have a token position for this frame, so can't determine
     // which variables are visible.
     vars_initialized_ = true;
     return;
@@ skipping 59 matching lines @@
   vars_initialized_ = true;
 }
 
 
 intptr_t ActivationFrame::NumLocalVariables() {
   GetDescIndices();
   return desc_indices_.length();
 }
 
 
+// TODO(hausner): Handle captured variables.
+RawInstance* ActivationFrame::GetLocalVarValue(intptr_t slot_index) {
+  if (deopt_frame_.IsNull()) {
+    uword var_address = fp() + slot_index * kWordSize;

[srdjan, 2013/10/07 21:36:53]

If you assign the result first to an instance (as done below) and then return
instance.raw(), you would have a runtime check in debug mode.

[turnidge, 2013/10/08 17:29:12]

Done.

[turnidge, 2013/10/08 18:21:11]

Turns out this uncovered an oddness -- value isn't always an Instance, sometimes
it is a Context.  Introduced typed accessors GetLocalContextVar and
GetLocalInstanceVar which both check for the correct type.

+    return reinterpret_cast<RawInstance*>(
+        *reinterpret_cast<uword*>(var_address));
+  } else {
+    Instance& instance = Instance::Handle();
+    instance ^= deopt_frame_.At(deopt_frame_offset_ + slot_index);
+    return instance.raw();
+  }
+}
+
+
 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);
@@ skipping 424 matching lines @@
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
   if (event_handler_ != NULL) {
     DebuggerEvent event;
     event.type = kBreakpointResolved;
     event.breakpoint = bpt;
     (*event_handler_)(&event);
   }
 }
 
 
+static void PrintStackTraceError(const char* message,
+                                 ActivationFrame* current_activation,
+                                 ActivationFrame* callee_activation) {
+  const Function& current = current_activation->function();
+  const Function& callee = callee_activation->function();
+  const Script& script =
+      Script::Handle(Class::Handle(current.Owner()).script());
+  intptr_t line, col;
+  script.GetTokenLocation(current_activation->TokenPos(), &line, &col);
+  OS::PrintErr("Error building stack trace: %s:"
+               "current function '%s' callee_function '%s' "
+               " line %" Pd " column %" Pd "\n",
+               message,
+               current.ToFullyQualifiedCString(),
+               callee.ToFullyQualifiedCString(),
+               line, col);
+}
+
+
+ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
+                                            uword pc,
+                                            StackFrame* frame,
+                                            const Code& code,
+                                            bool optimized,
+                                            ActivationFrame* callee_activation,
+                                            const Context& entry_ctx) {
+  // We never provide both a callee activation and an entry context.
+  ASSERT(callee_activation == NULL || entry_ctx.IsNull());

[srdjan, 2013/10/07 21:36:53]

Add parenthesis

[turnidge, 2013/10/08 17:29:12]

Where do you want the parentheses?

[turnidge, 2013/10/08 18:21:11]

Added the parentheses.

+  ActivationFrame* activation =
+      new ActivationFrame(pc, frame->fp(), frame->sp(), code);
+
+  // Recover the context for this frame.
+  if (optimized) {
+    // Bail out for optimized frames for now.
+    activation->SetContext(Context::Handle(isolate));
+
+  } else if (callee_activation == NULL) {
+    // No callee.  Use incoming entry context.  Could be from
+    // isolate's top context or from an entry frame.
+    activation->SetContext(entry_ctx);
+
+  } else if (callee_activation->function().IsClosureFunction()) {
+    // 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());
+    activation->SetContext(closure_call_ctx);
+
+    // Sometimes there is no saved context. This is a bug.

[srdjan, 2013/10/07 21:36:53]

Please add bug id.

[turnidge, 2013/10/08 17:29:12]

Done.

+    if (FLAG_verbose_debug && closure_call_ctx.IsNull()) {
+      PrintStackTraceError(
+          "Expected to find saved context for call to closure function",
+          activation, callee_activation);
+    }
+
+  } 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.
+    const Context& callee_ctx =
+        Context::Handle(isolate, callee_activation->GetSavedEntryContextNew());
+    activation->SetContext(callee_ctx);
+  }
+  return activation;
+}
+

[srdjan, 2013/10/07 21:36:53]

2 lines between functions

[turnidge, 2013/10/08 17:29:12]

Done.

+RawArray* Debugger::DeoptimizeToArray(Isolate* isolate,
+                                 StackFrame* frame,
+                                 const Code& code) {

[srdjan, 2013/10/07 21:36:53]

Fix indent

[turnidge, 2013/10/08 17:29:12]

Done.

+  ASSERT(code.is_optimized());
+
+  // Create the DeoptContext for this deoptimization.
+  DeoptContext* deopt_context =
+      new DeoptContext(frame, code,
+                       DeoptContext::kDestIsAllocated,
+                       NULL, NULL);
+  isolate->set_deopt_context(deopt_context);
+
+  deopt_context->FillDestFrame();
+  deopt_context->MaterializeDeferredObjects();
+  const Array& dest_frame = Array::Handle(deopt_context->DestFrameAsArray());
+
+  isolate->set_deopt_context(NULL);
+  delete deopt_context;
+
+  return dest_frame.raw();
+}
+
+
+DebuggerStackTrace* Debugger::CollectStackTraceNew() {
+  Isolate* isolate = Isolate::Current();
+  DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
+  StackFrameIterator iterator(false);
+  ActivationFrame* current_activation = NULL;
+  Context& entry_ctx = Context::Handle(isolate->top_context());
+  for (StackFrame* frame = iterator.NextFrame();
+       frame != NULL;
+       frame = iterator.NextFrame()) {
+    ASSERT(frame->IsValid());
+    if (frame->IsEntryFrame()) {
+      current_activation = NULL;
+      entry_ctx = reinterpret_cast<EntryFrame*>(frame)->SavedContext();
+
+    } else if (frame->IsDartFrame()) {
+      const Code& code = Code::Handle(isolate, frame->LookupDartCode());
+      if (code.is_optimized()) {
+        const Array& deopt_frame =
+            Array::Handle(DeoptimizeToArray(isolate, frame, code));
+        for (InlinedFunctionsIterator it(code, frame->pc());
+             !it.Done();
+             it.Advance()) {
+          const Code& inlined_code = Code::Handle(isolate, it.code());
+          intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
+          current_activation = CollectDartFrame(isolate,
+                                                it.pc(),
+                                                frame,
+                                                inlined_code,
+                                                true,
+                                                current_activation,
+                                                entry_ctx);
+          current_activation->SetDeoptFrame(deopt_frame, deopt_frame_offset);
+          stack_trace->AddActivation(current_activation);
+          entry_ctx = Context::null();  // Only use entry context once.
+        }
+      } else {
+        current_activation = CollectDartFrame(isolate,
+                                              frame->pc(),
+                                              frame,
+                                              code,
+                                              false,
+                                              current_activation,
+                                              entry_ctx);
+        stack_trace->AddActivation(current_activation);
+        entry_ctx = Context::null();  // Only use entry context once.
+      }
+    }
+  }
+  return stack_trace;
+}
+
+
+
 DebuggerStackTrace* Debugger::CollectStackTrace() {
+  if (FLAG_use_new_stacktrace) {
+    // Guard new stack trace generation under a flag in case there are
+    // problems rolling it out.
+    return CollectStackTraceNew();
+  }
   Isolate* isolate = Isolate::Current();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   Context& ctx = Context::Handle(isolate->top_context());
   Code& code = Code::Handle(isolate);
   StackFrameIterator iterator(false);
   ActivationFrame* callee_activation = NULL;
   bool optimized_frame_found = false;
   for (StackFrame* frame = iterator.NextFrame();
        frame != NULL;
        frame = iterator.NextFrame()) {
@@ skipping 918 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart