Remove redundant variable descriptors from 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 442 matching lines @@
     } else {
       column_number_ = -1;
     }
   }
   return column_number_;
 }
 
 
 void ActivationFrame::GetVarDescriptors() {
   if (var_descriptors_.IsNull()) {
-    var_descriptors_ = code().var_descriptors();
+    if (code().is_optimized()) {
+      Compiler::EnsureUnoptimizedCode(Thread::Current(), function());
+    }
+    var_descriptors_ =
+        Code::Handle(function().unoptimized_code()).var_descriptors();
     ASSERT(!var_descriptors_.IsNull());
   }
 }
 
 
 bool ActivationFrame::IsDebuggable() const {
   return Debugger::IsDebuggable(function());
 }
 
 
 // Calculate the context level at the current token index of the frame.
 intptr_t ActivationFrame::ContextLevel() {
-  if (context_level_ < 0 && !ctx_.IsNull()) {
+  const Context& ctx = GetSavedCurrentContext();
+  if (context_level_ < 0 && !ctx.IsNull()) {
     ASSERT(!code_.is_optimized());
     context_level_ = 0;
     // TODO(hausner): What to do if there is no descriptor entry
     // for the code position of the frame? For now say we are at context
     // level 0.
     TokenPos();
     if (token_pos_ == -1) {
       // No PcDescriptor.
       return context_level_;
     }
@@ skipping 19 matching lines @@
         }
       }
     }
     ASSERT(context_level_ >= 0);
   }
   return context_level_;
 }
 
 
 // Get the saved current context of this activation.
-RawContext* ActivationFrame::GetSavedCurrentContext() {
+const Context& ActivationFrame::GetSavedCurrentContext() {
+  if (!ctx_.IsNull()) return ctx_;
   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());
       }
-      ASSERT(Object::Handle(GetLocalVar(var_info.index())).IsContext());
-      return Context::RawCast(GetLocalVar(var_info.index()));
+      ctx_ ^= GetLocalVar(var_info.index());
+      return ctx_;
     }
   }
   UNREACHABLE();
-  return Context::null();
+  return Context::ZoneHandle(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();
   for (intptr_t frame_index = 0;
@@ skipping 103 matching lines @@
   }
   vars_initialized_ = true;
 }
 
 
 intptr_t ActivationFrame::NumLocalVariables() {
   GetDescIndices();
   return desc_indices_.length();
 }
 
-// TODO(hausner): Handle captured variables.
+
 RawObject* ActivationFrame::GetLocalVar(intptr_t slot_index) {
   if (deopt_frame_.IsNull()) {
     uword var_address = fp() + slot_index * kWordSize;
     return reinterpret_cast<RawObject*>(
         *reinterpret_cast<uword*>(var_address));
   } else {
     return deopt_frame_.At(deopt_frame_offset_ + slot_index);
   }
 }
 
@@ skipping 20 matching lines @@
                ctx_slot,
                frame_ctx_level,
                var_ctx_level);
 
   OS::PrintErr("-------------------------\n"
                "Current frame:\n%s\n",
                this->ToCString());
 
   OS::PrintErr("-------------------------\n"
                "Context contents:\n");
-  ctx_.Dump(8);
+  const Context& ctx = GetSavedCurrentContext();
+  ctx.Dump(8);
 
   OS::PrintErr("-------------------------\n"
                "Debugger stack trace...\n\n");
   DebuggerStackTrace* stack =
       Isolate::Current()->debugger()->StackTrace();
   intptr_t num_frames = stack->Length();
   for (intptr_t i = 0; i < num_frames; i++) {
     ActivationFrame* frame = stack->FrameAt(i);
     OS::PrintErr("#%04" Pd " %s", i, frame->ToCString());
   }
@@ skipping 28 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);
-    ASSERT(!ctx_.IsNull());
+    const Context& ctx = GetSavedCurrentContext();
+    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) ||
-          (ctx_slot >= ctx_.num_variables())) {
+          (ctx_slot >= ctx.num_variables())) {
         PrintContextMismatchError(*name, ctx_slot,
                                   frame_ctx_level, var_ctx_level);
       }
-      ASSERT((ctx_slot >= 0) && (ctx_slot < ctx_.num_variables()));
-      *value = ctx_.At(ctx_slot);
+      ASSERT((ctx_slot >= 0) && (ctx_slot < ctx.num_variables()));
+      *value = ctx.At(ctx_slot);
     } else {
       ASSERT(level_diff > 0);
-      Context& var_ctx = Context::Handle(ctx_.raw());
+      Context& var_ctx = Context::Handle(ctx.raw());
       while (level_diff > 0 && !var_ctx.IsNull()) {
         level_diff--;
         var_ctx = var_ctx.parent();
       }
       if (var_ctx.IsNull() ||
           (ctx_slot < 0) ||
           (ctx_slot >= var_ctx.num_variables())) {
         PrintContextMismatchError(*name, ctx_slot,
                                   frame_ctx_level, var_ctx_level);
       }
@@ skipping 401 matching lines @@
 ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
                                             uword pc,
                                             StackFrame* frame,
                                             const Code& code,
                                             const Array& deopt_frame,
                                             intptr_t deopt_frame_offset) {
   ASSERT(code.ContainsInstructionAt(pc));
   ActivationFrame* activation =
       new ActivationFrame(pc, frame->fp(), frame->sp(), code,
                           deopt_frame, deopt_frame_offset);
-
-  // Recover the context for this frame.
-  const Context& ctx =
-      Context::Handle(isolate, activation->GetSavedCurrentContext());
-  ASSERT(!ctx.IsNull());
-  activation->SetContext(ctx);
   if (FLAG_trace_debugger_stacktrace) {
+    const Context& ctx = activation->GetSavedCurrentContext();
     OS::PrintErr("\tUsing saved context: %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 1431 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart