Remove old stack-walking code. The new code seems to be doing fine.

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"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/deopt_instructions.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/port.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, verbose_debug, false, "Verbose debugger messages");
-DEFINE_FLAG(bool, use_new_stacktrace, true,
-            "Use new stacktrace creation");
 
 
 Debugger::EventHandler* Debugger::event_handler_ = NULL;
 
 
 class RemoteObjectCache : public ZoneAllocated {
  public:
   explicit RemoteObjectCache(intptr_t initial_size);
   intptr_t AddObject(const Object& obj);
   RawObject* GetObj(intptr_t obj_id) const;
@@ skipping 317 matching lines @@
           context_level_ = var_info.index;
         }
       }
     }
     ASSERT(context_level_ >= 0);
   }
   return context_level_;
 }
 
 
-// Get the caller's context, or return ctx if the function does not
-// save the caller's context on entry.
-RawContext* ActivationFrame::GetSavedEntryContext(const Context& 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);
-    if (var_info.kind == RawLocalVarDescriptors::kSavedEntryContext) {
-      return GetLocalContextVar(var_info.index);
-    }
-  }
-  return ctx.raw();
-}
-
-
-RawContext* ActivationFrame::GetSavedEntryContextNew() {
+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++) {
@@ skipping 63 matching lines @@
   return NULL;
 }
 
 
 void ActivationFrame::GetDescIndices() {
   if (vars_initialized_) {
     return;
   }
   GetVarDescriptors();
 
-  // We don't trust variable descriptors in optimized code.
-  // Rather than potentially displaying incorrect values, we
-  // pretend that there are no variables in the frame.
-  // We should be more clever about this in the future.
-  if (!FLAG_use_new_stacktrace && code().is_optimized()) {
-    vars_initialized_ = true;
-    return;
-  }
-
   intptr_t activation_token_pos = TokenPos();
   if (activation_token_pos < 0) {
     // We don't have a token position for this frame, so can't determine
     // which variables are visible.
     vars_initialized_ = true;
     return;
   }
 
   GrowableArray<String*> var_names(8);
   intptr_t var_desc_len = var_descriptors_.Length();
@@ skipping 103 matching lines @@
   *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);
     // 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;
-    }
+    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) {
-      // 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>");
-      }
+      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());
       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>");
-      }
+      ASSERT(!var_ctx.IsNull());
+      ASSERT((ctx_slot >= 0) && (ctx_slot < var_ctx.num_variables()));
+      *value = var_ctx.At(ctx_slot);
     }
   }
 }
 
 
 RawArray* ActivationFrame::GetLocalVariables() {
   GetDescIndices();
   intptr_t num_variables = desc_indices_.length();
   String& var_name = String::Handle();
   Instance& value = Instance::Handle();
@@ skipping 392 matching lines @@
 
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
   if (event_handler_ != NULL) {
     DebuggerEvent event(kBreakpointResolved);
     event.breakpoint = bpt;
     (*event_handler_)(&event);
   }
 }
 
 
-static void PrintStackTraceError(const char* message,
-                                 ActivationFrame* current_activation,
-                                 ActivationFrame* callee_activation) {
-  const Function& current = current_activation->function();
-  const Function& callee = callee_activation->function();
-  const Script& script =
-      Script::Handle(Class::Handle(current.Owner()).script());
-  intptr_t line, col;
-  script.GetTokenLocation(current_activation->TokenPos(), &line, &col);
-  OS::PrintErr("Error building stack trace: %s:"
-               "current function '%s' callee_function '%s' "
-               " line %" Pd " column %" Pd "\n",
-               message,
-               current.ToFullyQualifiedCString(),
-               callee.ToFullyQualifiedCString(),
-               line, col);
-}
-
-
 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) {
   // 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);
 
   // 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.
     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);
 
-    // Sometimes there is no saved context. This is a bug.
-    // https://code.google.com/p/dart/issues/detail?id=12767
-    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());
+        Context::Handle(isolate, callee_activation->GetSavedEntryContext());
     activation->SetContext(callee_ctx);
   }
   return activation;
 }
 
 
 RawArray* Debugger::DeoptimizeToArray(Isolate* isolate,
                                       StackFrame* frame,
                                       const Code& code) {
   ASSERT(code.is_optimized());
 
   // Create the DeoptContext for this deoptimization.
   DeoptContext* deopt_context =
       new DeoptContext(frame, code,
                        DeoptContext::kDestIsAllocated,
                        NULL, NULL);
   isolate->set_deopt_context(deopt_context);
 
   deopt_context->FillDestFrame();
   deopt_context->MaterializeDeferredObjects();
   const Array& dest_frame = Array::Handle(deopt_context->DestFrameAsArray());
 
   isolate->set_deopt_context(NULL);
   delete deopt_context;
 
   return dest_frame.raw();
 }
 
 
-DebuggerStackTrace* Debugger::CollectStackTraceNew() {
+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->top_context());
   Code& code = Code::Handle(isolate);
   Code& inlined_code = Code::Handle(isolate);
   Array& deopt_frame = Array::Handle(isolate);
 
   for (StackFrame* frame = iterator.NextFrame();
@@ skipping 35 matching lines @@
                                               entry_ctx);
         stack_trace->AddActivation(current_activation);
         entry_ctx = Context::null();  // Only use entry context once.
       }
     }
   }
   return stack_trace;
 }
 
 
-
-DebuggerStackTrace* Debugger::CollectStackTrace() {
-  if (FLAG_use_new_stacktrace) {
-    // Guard new stack trace generation under a flag in case there are
-    // problems rolling it out.
-    return CollectStackTraceNew();
-  }
-  Isolate* isolate = Isolate::Current();
-  DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
-  Context& ctx = Context::Handle(isolate->top_context());
-  Code& code = Code::Handle(isolate);
-  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,
-                              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());
-          intptr_t line, col;
-          script.GetTokenLocation(activation->TokenPos(), &line, &col);
-          OS::Print("CollectStackTrace error: no saved context in function "
-              "'%s' which calls closure '%s' "
-              " in line %" Pd " column %" Pd "\n",
-              caller.ToFullyQualifiedCString(),
-              callee.ToFullyQualifiedCString(),
-              line, col);
-        }
-      }
-      if (optimized_frame_found || code.is_optimized()) {
-        // Set context to null, to avoid returning bad context variable values.
-        activation->SetContext(Context::Handle());
-        optimized_frame_found = true;
-      } else {
-        ASSERT(!ctx.IsNull());
-        activation->SetContext(ctx);
-      }
-      stack_trace->AddActivation(activation);
-      callee_activation = activation;
-      // Get caller's context if this function saved it on entry.
-      ctx = activation->GetSavedEntryContext(ctx);
-    } else if (frame->IsEntryFrame()) {
-      ctx = reinterpret_cast<EntryFrame*>(frame)->SavedContext();
-      callee_activation = NULL;
-    }
-  }
-  return stack_trace;
-}
-
-
 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,
                           Object::null_array(), 0);
   return activation;
 }
 
 
 DebuggerStackTrace* Debugger::StackTrace() {
   return (stack_trace_ != NULL) ? stack_trace_ : CollectStackTrace();
 }
 
 DebuggerStackTrace* Debugger::CurrentStackTrace() {
-  return CollectStackTraceNew();
+  return CollectStackTrace();
 }
 
 DebuggerStackTrace* Debugger::StackTraceFrom(const Stacktrace& ex_trace) {
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   Function& function = Function::Handle();
   Code& code = Code::Handle();
 
   const uword fp = 0;
   const uword sp = 0;
   const Array& deopt_frame = Array::Handle();
@@ skipping 941 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart