Disable stack context when its frame is for optimized 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 286 matching lines @@
 void ActivationFrame::GetVarDescriptors() {
   if (var_descriptors_.IsNull()) {
     var_descriptors_ = code().var_descriptors();
     ASSERT(!var_descriptors_.IsNull());
   }
 }
 
 
 // Calculate the context level at the current token index of the frame.
 intptr_t ActivationFrame::ContextLevel() {
-  if (context_level_ < 0) {
+  if (context_level_ < 0 && !ctx_.IsNull()) {
+    if (code_.is_optimized()) {
+      // Set context to null, since this and all subsequent frames are
+      // invalid.
+      SetContext(Context::Handle());
+      return context_level_;
+    }
     context_level_ = 0;
     intptr_t pc_desc_idx = PcDescIndex();
     ASSERT(!pc_desc_.IsNull());
     if (pc_desc_.DescriptorKind(pc_desc_idx) == PcDescriptors::kReturn) {
       // Special case: the context chain has already been deallocated.
       // The context level is 0.
       return context_level_;
     }
     intptr_t innermost_begin_pos = 0;
     intptr_t activation_token_pos = TokenPos();
@@ skipping 168 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);
   if (var_info.kind == RawLocalVarDescriptors::kStackVar) {
     *value = GetLocalVarValue(var_info.index);
   } else {
-    // TODO(tball): enable context variables once problem with VariableAt() is
-    // fixed, where frame_ctx_level is sometimes off by 1 (issues 8593 and 8594)
-    /*
     ASSERT(var_info.kind == RawLocalVarDescriptors::kContextVar);
-    ASSERT(!ctx_.IsNull());
     // The context level at the PC/token index of this activation frame.
     intptr_t frame_ctx_level = ContextLevel();
+    if (ctx_.IsNull()) {
+      *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) {
       *value = ctx_.At(ctx_slot);
     } else {
       ASSERT(level_diff > 0);
       Context& ctx = Context::Handle(ctx_.raw());
       while (level_diff > 0) {
         ASSERT(!ctx.IsNull());
         level_diff--;
         ctx = ctx.parent();
       }
       ASSERT(!ctx.IsNull());
       *value = ctx.At(ctx_slot);
-    } */
-    *value = Symbols::New("<unknown>");
+    }
   }
 }
 
 
 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));
@@ skipping 349 matching lines @@
   while (frame != NULL) {
     ASSERT(frame->IsValid());
     if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
       ActivationFrame* activation = new ActivationFrame(frame->pc(),
                                                         frame->fp(),
                                                         frame->sp(),
                                                         code);
       if (get_saved_context && !activation->code().is_optimized()) {
         ctx = activation->GetSavedContext();
       }

[Ivan Posva, 2013/03/12 16:31:25]

What I am concerned about is this scenario:

Traversing from top-of-stack you have a set of unoptimized frames, followed by a
set of optimized frames, followed by a set of unoptimized frames.

The set of optimized frames is handled perfectly fine with your change in
ContextLevel(), but the unoptimized frames below the optimized frames also
cannot rely on the contexts to be set up properly when we get to them. A
temporary solution would be to set ctx to the empty handle once we see an
optimized frame and keep that for all following frames.

P.S. There could be a way to recover the context chain once we have a set of
unoptimized frames, but I am not sure it warrants the complications.

       activation->SetContext(ctx);
       stack_trace->AddActivation(activation);
       get_saved_context = activation->function().IsClosureFunction();
     } else if (frame->IsEntryFrame()) {
       ctx = reinterpret_cast<EntryFrame*>(frame)->SavedContext();
       get_saved_context = false;
     }
     frame = iterator.NextFrame();
   }
   return stack_trace;
@@ skipping 833 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart