Make CTX allocatable by the register allocator.

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 440 matching lines @@
           context_level_ = var_info.index();
         }
       }
     }
     ASSERT(context_level_ >= 0);
   }
   return context_level_;
 }
 
 
-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);
-    const int8_t kind = var_info.kind();
-    if (kind == RawLocalVarDescriptors::kSavedEntryContext) {
-      if (FLAG_trace_debugger_stacktrace) {
-        OS::PrintErr("\tFound saved entry ctx at index %d\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.
+// Get the saved current context of this activation.
 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);
     const int8_t kind = var_info.kind();
     if (kind == RawLocalVarDescriptors::kSavedCurrentContext) {
       if (FLAG_trace_debugger_stacktrace) {
         OS::PrintErr("\tFound saved current ctx at index %d\n",
             var_info.index());
       }
-      return GetLocalContextVar(var_info.index());
+      const Object& context = Object::Handle(GetLocalVar(var_info.index()));

[hausner, 2014/10/29 16:44:34]

Would be nice if you could avoid the handle creation in the non-debug build. You
only need it for the assertion. Alternatively, you can assert that the class id
is kContextCid instead of calling IsContext().

[Florian Schneider, 2014/10/29 17:50:45]

Done, but I still need a cast (the result of GetLocalVar to a RawContext*) if I
don't want to change all call-sites of GetSavedCurrentContext.

+      ASSERT(context.IsContext());
+      return Context::Cast(context).raw();
     }
   }
   UNREACHABLE();
   return Context::null();
 }
 
 
 const char* DebuggerEvent::EventTypeToCString(EventType type) {
   switch (type) {
     case kBreakpointReached:
@@ skipping 164 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();
-  } 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"
@@ skipping 48 matching lines @@
   ASSERT(token_pos != NULL);
   *token_pos = var_info.begin_pos;
   ASSERT(end_pos != NULL);
   *end_pos = var_info.end_pos;
   ASSERT(value != NULL);
   const int8_t kind = var_info.kind();
   if (kind == RawLocalVarDescriptors::kStackVar) {
     *value = GetLocalInstanceVar(var_info.index());
   } else {
     ASSERT(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;
-    }
+    ASSERT(!ctx_.IsNull());
 
     // 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) ||
@@ skipping 446 matching lines @@
     InvokeEventHandler(&event);
   }
 }
 
 
 ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
                                             uword pc,
                                             StackFrame* frame,
                                             const Code& code,
                                             const Array& deopt_frame,
-                                            intptr_t deopt_frame_offset,
-                                            ActivationFrame* callee_activation,
-                                            const Context& entry_ctx) {
+                                            intptr_t deopt_frame_offset) {
   ASSERT(code.ContainsInstructionAt(pc));
-  // 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(isolate, code.pc_descriptors());
   PcDescriptors::Iterator iter(pc_desc, RawPcDescriptors::kClosureCall);
   while (iter.MoveNext()) {
     if (iter.Pc() == pc) {
       is_closure_call = true;
       break;
     }
   }
 
   // Recover the context for this frame.
   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);
+  } else {
+    const Context& ctx =
+        Context::Handle(isolate, activation->GetSavedCurrentContext());
+    ASSERT(!ctx.IsNull());
+    activation->SetContext(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());
+      OS::PrintErr("\tUsing entry ctx: %s\n", ctx.ToCString());
     }
   }
   if (FLAG_trace_debugger_stacktrace) {
     OS::PrintErr("\tLine number: %" Pd "\n", activation->LineNumber());
   }
   return activation;
 }
 
 
 RawArray* Debugger::DeoptimizeToArray(Isolate* isolate,
@@ skipping 17 matching lines @@
   delete deopt_context;
 
   return dest_frame.raw();
 }
 
 
 DebuggerStackTrace* Debugger::CollectStackTrace() {
   Isolate* isolate = Isolate::Current();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   StackFrameIterator iterator(false);
-  ActivationFrame* current_activation = NULL;
-  Context& entry_ctx = Context::Handle(isolate, 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()) {
+    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(isolate, 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);
-          entry_ctx = Context::null();  // Only use entry context once.
+          stack_trace->AddActivation(CollectDartFrame(isolate,
+                                                      it.pc(),
+                                                      frame,
+                                                      inlined_code,
+                                                      deopt_frame,
+                                                      deopt_frame_offset));
         }
       } else {
-        current_activation = CollectDartFrame(isolate,
-                                              frame->pc(),
-                                              frame,
-                                              code,
-                                              Object::null_array(),
-                                              0,
-                                              current_activation,
-                                              entry_ctx);
-        stack_trace->AddActivation(current_activation);
-        entry_ctx = Context::null();  // Only use entry context once.
+        stack_trace->AddActivation(CollectDartFrame(isolate,
+                                                    frame->pc(),
+                                                    frame,
+                                                    code,
+                                                    Object::null_array(),
+                                                    0));
       }
     }
   }
   return stack_trace;
 }
 
 
 ActivationFrame* Debugger::TopDartFrame() const {
   StackFrameIterator iterator(false);
   StackFrame* frame = iterator.NextFrame();
@@ skipping 1189 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart