Minor cleanup of activation frame creation code. Get the code object while iterating the frames as …

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 117 matching lines @@
 }
 
 
 
 void CodeBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 }
 
 
 ActivationFrame::ActivationFrame(uword pc, uword fp, uword sp,
+                                 const Code& code,
                                  const Context& ctx)
     : pc_(pc), fp_(fp), sp_(sp),
       ctx_(Context::ZoneHandle(ctx.raw())),
-      function_(Function::ZoneHandle()),
-      code_(Code::ZoneHandle()),
+      code_(Code::ZoneHandle(code.raw())),
+      function_(Function::ZoneHandle(code.function())),
       token_pos_(-1),
       pc_desc_index_(-1),
       line_number_(-1),
       context_level_(-1),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {
 }
 
 
-const Code& ActivationFrame::DartCode() {
-  if (code_.IsNull()) {
-    Isolate* isolate = Isolate::Current();
-    ASSERT(isolate != NULL);
-    code_ = Code::LookupCode(pc_);
-  }
-  return code_;
-}
-
-
-const Function& ActivationFrame::DartFunction() {
-  if (function_.IsNull()) {
-    function_ = DartCode().function();
-  }
-  return function_;
-}
-
-
 void Debugger::SignalIsolateEvent(EventType type) {
   if (event_handler_ != NULL) {
     Debugger* debugger = Isolate::Current()->debugger();
     ASSERT(debugger != NULL);
     DebuggerEvent event;
     event.type = type;
     event.isolate_id = debugger->GetIsolateId();
     ASSERT(event.isolate_id != ILLEGAL_ISOLATE_ID);
     if (type == kIsolateInterrupted) {
       DebuggerStackTrace* stack_trace = debugger->CollectStackTrace();
@@ skipping 52 matching lines @@
     if (func.raw() == cbpt->function()) {
       return true;
     }
     cbpt = cbpt->next_;
   }
   return false;
 }
 
 
 RawString* ActivationFrame::QualifiedFunctionName() {
-  const Function& func = DartFunction();
-  return String::New(Debugger::QualifiedFunctionName(func));
+  return String::New(Debugger::QualifiedFunctionName(function()));
 }
 
 
 RawString* ActivationFrame::SourceUrl() {
   const Script& script = Script::Handle(SourceScript());
   return script.url();
 }
 
 
 RawScript* ActivationFrame::SourceScript() {
-  const Function& func = DartFunction();
-  return func.script();
+  return function().script();
 }
 
 
 RawLibrary* ActivationFrame::Library() {
-  const Function& func = DartFunction();
-  const Class& cls = Class::Handle(func.Owner());
+  const Class& cls = Class::Handle(function().Owner());
   return cls.library();
 }
 
 
 void ActivationFrame::GetPcDescriptors() {
   if (pc_desc_.IsNull()) {
-    const Code& code = DartCode();
-    ASSERT(!code.IsNull());
-    pc_desc_ = code.pc_descriptors();
+    pc_desc_ = code().pc_descriptors();
     ASSERT(!pc_desc_.IsNull());
   }
 }
 
 
 // Compute token_pos_ and pc_desc_index_.
 intptr_t ActivationFrame::TokenPos() {
   if (token_pos_ < 0) {
     GetPcDescriptors();
     for (int i = 0; i < pc_desc_.Length(); i++) {
@@ skipping 30 matching lines @@
     const Script& script = Script::Handle(SourceScript());
     intptr_t ignore_column;
     script.GetTokenLocation(TokenPos(), &line_number_, &ignore_column);
   }
   return line_number_;
 }
 
 
 void ActivationFrame::GetVarDescriptors() {
   if (var_descriptors_.IsNull()) {
-    const Code& code = DartCode();
-    var_descriptors_ = code.var_descriptors();
+    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) {
     context_level_ = 0;
     intptr_t pc_desc_idx = PcDescIndex();
@@ skipping 46 matching lines @@
 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 (int frame_index = 0; frame_index < Length(); frame_index++) {
     ActivationFrame* frame = trace_[frame_index];
     intptr_t try_index = frame->TryIndex();
     if (try_index < 0) continue;
-    const Code& code = frame->DartCode();
-    handlers = code.exception_handlers();
+    handlers = frame->code().exception_handlers();
     ASSERT(!handlers.IsNull());
     intptr_t num_handlers_checked = 0;
     while (try_index >= 0) {
       // Detect circles in the exception handler data.
       num_handlers_checked++;
       ASSERT(num_handlers_checked <= handlers.Length());
       handled_types = handlers.GetHandledTypes(try_index);
       const intptr_t num_types = handled_types.Length();
       for (int k = 0; k < num_types; k++) {
         type ^= handled_types.At(k);
@@ skipping 16 matching lines @@
 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 (DartCode().is_optimized()) {
+  if (code().is_optimized()) {
     vars_initialized_ = true;
     return;
   }
 
   GrowableArray<String*> var_names(8);
   intptr_t activation_token_pos = TokenPos();
   intptr_t var_desc_len = var_descriptors_.Length();
   for (int cur_idx = 0; cur_idx < var_desc_len; cur_idx++) {
     ASSERT(var_names.length() == desc_indices_.length());
     RawLocalVarDescriptors::VarInfo var_info;
@@ skipping 116 matching lines @@
     list.SetAt(2 * i, var_name);
     list.SetAt((2 * i) + 1, value);
   }
   return list.raw();
 }
 
 
 const char* ActivationFrame::ToCString() {
   const char* kFormat = "Function: '%s' url: '%s' line: %d";
 
-  const Function& func = DartFunction();
   const String& url = String::Handle(SourceUrl());
   intptr_t line = LineNumber();
-  const char* func_name = Debugger::QualifiedFunctionName(func);
+  const char* func_name = Debugger::QualifiedFunctionName(function());
 
   intptr_t len =
       OS::SNPrint(NULL, 0, kFormat, func_name, url.ToCString(), line);
   len++;  // String terminator.
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, func_name, url.ToCString(), line);
   return chars;
 }
 
 
@@ skipping 293 matching lines @@
   if (event_handler_ != NULL) {
     DebuggerEvent event;
     event.type = kBreakpointResolved;
     event.breakpoint = bpt;
     (*event_handler_)(&event);
   }
 }
 
 
 DebuggerStackTrace* Debugger::CollectStackTrace() {
+  Isolate* isolate = Isolate::Current();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
-  Context& ctx = Context::Handle(Isolate::Current()->top_context());
+  Context& ctx = Context::Handle(isolate->top_context());
+  Code& code = Code::Handle(isolate);
   DartFrameIterator iterator;
   StackFrame* frame = iterator.NextFrame();
   while (frame != NULL) {
     ASSERT(frame->IsValid());
     ASSERT(frame->IsDartFrame());
+    code = frame->LookupDartCode();
     ActivationFrame* activation =
-        new ActivationFrame(frame->pc(), frame->fp(), frame->sp(), ctx);
+        new ActivationFrame(frame->pc(), frame->fp(), frame->sp(), code, ctx);
     ctx = activation->CallerContext();
     stack_trace->AddActivation(activation);
     frame = iterator.NextFrame();
   }
   return stack_trace;
 }
 
 
 void Debugger::SetExceptionPauseInfo(Dart_ExceptionPauseInfo pause_info) {
   ASSERT((pause_info == kNoPauseOnExceptions) ||
@@ skipping 577 matching lines @@
   Function& func_to_instrument = Function::Handle();
   if (resume_action_ == kContinue) {
     // Nothing to do here, any potential instrumentation will be removed
     // below.
   } else if (resume_action_ == kStepOver) {
     func_to_instrument = bpt->function();
     if (bpt->breakpoint_kind_ == PcDescriptors::kReturn) {
       // If we are at the function return, do a StepOut action.
       if (stack_trace->Length() > 1) {
         ActivationFrame* caller_frame = stack_trace->ActivationFrameAt(1);
-        func_to_instrument = caller_frame->DartFunction().raw();
+        func_to_instrument = caller_frame->function().raw();
       }
     }
   } else if (resume_action_ == kStepInto) {
     // If the call target is not debuggable, we treat StepInto like
     // a StepOver, that is we instrument the current function.
     if (bpt->breakpoint_kind_ == PcDescriptors::kIcCall) {
       func_to_instrument = bpt->function();
       ICData& ic_data = ICData::Handle();
       Array& descriptor = Array::Handle();
       CodePatcher::GetInstanceCallAt(bpt->pc_, &ic_data, &descriptor);
@@ skipping 19 matching lines @@
           Function::Handle(code.GetStaticCallTargetFunctionAt(bpt->pc_));
       ASSERT(!callee.IsNull());
       if (IsDebuggable(callee)) {
         func_to_instrument = callee.raw();
       }
     } else {
       ASSERT(bpt->breakpoint_kind_ == PcDescriptors::kReturn);
       // Treat like stepping out to caller.
       if (stack_trace->Length() > 1) {
         ActivationFrame* caller_frame = stack_trace->ActivationFrameAt(1);
-        func_to_instrument = caller_frame->DartFunction().raw();
+        func_to_instrument = caller_frame->function().raw();
       }
     }
   } else {
     ASSERT(resume_action_ == kStepOut);
     // Set stepping breakpoints in the caller.
     if (stack_trace->Length() > 1) {
       ActivationFrame* caller_frame = stack_trace->ActivationFrameAt(1);
-      func_to_instrument = caller_frame->DartFunction().raw();
+      func_to_instrument = caller_frame->function().raw();
     }
   }
 
   if (func_to_instrument.IsNull() ||
       (func_to_instrument.raw() != currently_instrumented_func.raw())) {
     last_bpt_line_ = -1;
     RemoveInternalBreakpoints();  // *bpt is now invalid.
     if (!func_to_instrument.IsNull()) {
       InstrumentForStepping(func_to_instrument);
     }
@@ skipping 180 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart