Handle contexts which have been optimized out.

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 414 matching lines @@
         }
       }
     }
     ASSERT(context_level_ >= 0);
   }
   return context_level_;
 }
 
 
 RawContext* ActivationFrame::GetSavedEntryContext() {
-  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 (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) {
       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) {
       return GetLocalContextVar(var_info.index);
     }
   }
+  UNREACHABLE();
   return Context::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();
@@ skipping 125 matching lines @@
 RawInstance* ActivationFrame::GetLocalInstanceVar(intptr_t slot_index) {
   Instance& instance = Instance::Handle();
   instance ^= GetLocalVar(slot_index);
   return instance.raw();
 }
 
 
 RawContext* ActivationFrame::GetLocalContextVar(intptr_t slot_index) {
   Object& context = Object::Handle(GetLocalVar(slot_index));
   if (context.IsContext()) {
+    // We found a saved context.
     return Context::Cast(context).raw();
+  } else if (context.raw() == Symbols::OptimizedOut().raw()) {
+    // The optimizing compiler has eliminated the saved context.
+    return Context::null();

[turnidge, 2014/02/13 18:55:49]

I decided to use Context::null() to represent an optimized-out context.  All
other cases which return Context::null() should now be tagged as UNREACHABLE.

+  } else {
+    UNREACHABLE();
+    return Context::null();
   }
-  return Context::null();
 }
 
 
 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.
+      *value = Symbols::OptimizedOut().raw();
+      return;
+    }
+
     // The context level at the PC/token index of this activation frame.
     intptr_t frame_ctx_level = ContextLevel();
-    ASSERT(!ctx_.IsNull());
 
     // 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) {
       ASSERT((ctx_slot >= 0) && (ctx_slot < ctx_.num_variables()));
       *value = ctx_.At(ctx_slot);
     } else {
       ASSERT(level_diff > 0);
@@ skipping 402 matching lines @@
   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);
 
   // 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 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);
 
   } 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);
   }
   return activation;
 }
 
 
 RawArray* Debugger::DeoptimizeToArray(Isolate* isolate,
                                       StackFrame* frame,
@@ skipping 1215 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart