Allow access to context variables in optimized/inlined frames.

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 108 matching lines @@
 void SourceBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 }
 
 
 
 void CodeBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 }
 
-
-ActivationFrame::ActivationFrame(uword pc, uword fp, uword sp, const Code& code)
+ActivationFrame::ActivationFrame(
+    uword pc,
+    uword fp,
+    uword sp,
+    const Code& code,
+    const Array& deopt_frame,
+    intptr_t deopt_frame_offset)
     : 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),
+      deopt_frame_(Array::ZoneHandle(deopt_frame.raw())),
+      deopt_frame_offset_(deopt_frame_offset),
       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 422 matching lines @@
   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);
     // The context level at the PC/token index of this activation frame.
     intptr_t frame_ctx_level = ContextLevel();
     if (ctx_.IsNull()) {
+      if (FLAG_use_new_stacktrace) {
+        UNREACHABLE();  // ctx_ should never be null.
+      }
       *value = Symbols::New("<unknown>");
       return;
     }
     // 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) {
       // TODO(12767) : Need to ensure that we end up with the correct context
       // here so that this check can be an assert.
       if ((ctx_slot < ctx_.num_variables()) && (ctx_slot >= 0)) {
         *value = ctx_.At(ctx_slot);
       } else {
+        if (FLAG_use_new_stacktrace) {
+          UNREACHABLE();  // ctx_ should be correct.
+        }
         *value = Symbols::New("<unknown>");
       }
     } 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();
       }
       // TODO(12767) : Need to ensure that we end up with the correct context
       // here so that this check can be assert.
       if (!var_ctx.IsNull() &&
           ((ctx_slot < var_ctx.num_variables()) && (ctx_slot >= 0))) {
         *value = var_ctx.At(ctx_slot);
       } else {
+        if (FLAG_use_new_stacktrace) {
+          UNREACHABLE();  // var_ctx should be correct.
+        }
         *value = Symbols::New("<unknown>");
       }
     }
   }
 }
 
 
 RawArray* ActivationFrame::GetLocalVariables() {
   GetDescIndices();
   intptr_t num_variables = desc_indices_.length();
@@ skipping 395 matching lines @@
                current.ToFullyQualifiedCString(),
                callee.ToFullyQualifiedCString(),
                line, col);
 }
 
 
 ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
                                             uword pc,
                                             StackFrame* frame,
                                             const Code& code,
-                                            bool optimized,
+                                            const Array& deopt_frame,
+                                            intptr_t deopt_frame_offset,
                                             ActivationFrame* callee_activation,
                                             const Context& entry_ctx) {
-  // We never provide both a callee activation and an entry context.
+  // We provide either a callee activation or an entry context.  Not both.
   ASSERT((callee_activation == NULL) || entry_ctx.IsNull());
+  ASSERT((callee_activation != NULL) || !entry_ctx.IsNull());

[siva, 2013/10/15 17:39:12]

The two asserts seem hard to read together, I am wondering if this combo makes
it easier:

ASSERT(((callee_activation != NULL) && entry_ctx.IsNull()) ||
       ((callee_activation == NULL) && !entry_ctx.IsNull()));

[turnidge, 2013/10/15 18:07:28]

Done.

   ActivationFrame* activation =
-      new ActivationFrame(pc, frame->fp(), frame->sp(), code);
+      new ActivationFrame(pc, frame->fp(), frame->sp(), code,
+                          deopt_frame, deopt_frame_offset);
 
   // 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) {
+  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.
     // https://code.google.com/p/dart/issues/detail?id=12767
-    if (FLAG_verbose_debug && closure_call_ctx.IsNull()) {
+    if ((FLAG_verbose_debug || FLAG_use_new_stacktrace) &&
+        closure_call_ctx.IsNull()) {
       PrintStackTraceError(
           "Expected to find saved context for call to closure function",
           activation, callee_activation);
+      if (FLAG_use_new_stacktrace) {
+        UNREACHABLE();  // This bug should be fixed with new stack collection.
+      }
     }
 
   } 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);
   }
@@ skipping 48 matching lines @@
         deopt_frame = DeoptimizeToArray(isolate, frame, code);
         for (InlinedFunctionsIterator it(code, frame->pc());
              !it.Done();
              it.Advance()) {
           inlined_code = it.code();
           intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
           current_activation = CollectDartFrame(isolate,
                                                 it.pc(),
                                                 frame,
                                                 inlined_code,
-                                                true,
+                                                deopt_frame,
+                                                deopt_frame_offset,
                                                 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,
+                                              Object::null_array(),
+                                              0,
                                               current_activation,
                                               entry_ctx);
         stack_trace->AddActivation(current_activation);
         entry_ctx = Context::null();  // Only use entry context once.
       }
     }
   }
   return stack_trace;
 }
 
@@ skipping 12 matching lines @@
   StackFrameIterator iterator(false);
   ActivationFrame* callee_activation = NULL;
   bool optimized_frame_found = false;
   for (StackFrame* frame = iterator.NextFrame();
        frame != NULL;
        frame = iterator.NextFrame()) {
     ASSERT(frame->IsValid());
     if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
       ActivationFrame* activation =
-          new ActivationFrame(frame->pc(), frame->fp(), frame->sp(), code);
+          new ActivationFrame(frame->pc(), frame->fp(), frame->sp(), code,
+                              Object::null_array(), 0);
       // If this activation frame called a closure, the function has
       // saved its context before the call.
       if ((callee_activation != NULL) &&
           (callee_activation->function().IsClosureFunction())) {
         ctx = activation->GetSavedCurrentContext();
         if (FLAG_verbose_debug && ctx.IsNull()) {
           const Function& caller = activation->function();
           const Function& callee = callee_activation->function();
           const Script& script =
               Script::Handle(Class::Handle(caller.Owner()).script());
@@ skipping 29 matching lines @@
 
 
 ActivationFrame* Debugger::TopDartFrame() const {
   StackFrameIterator iterator(false);
   StackFrame* frame = iterator.NextFrame();
   while ((frame != NULL) && !frame->IsDartFrame()) {
     frame = iterator.NextFrame();
   }
   Code& code = Code::Handle(isolate_, frame->LookupDartCode());
   ActivationFrame* activation =
-      new ActivationFrame(frame->pc(), frame->fp(), frame->sp(), code);
+      new ActivationFrame(frame->pc(), frame->fp(), frame->sp(), code,
+                          Object::null_array(), 0);
   return activation;
 }
 
 
 DebuggerStackTrace* Debugger::StackTrace() {
   return (stack_trace_ != NULL) ? stack_trace_ : CollectStackTrace();
 }
 
 
 void Debugger::SetExceptionPauseInfo(Dart_ExceptionPauseInfo pause_info) {
@@ skipping 853 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart