First part of inspecting local variables

runtime/vm/debugger.cc

 // Copyright (c) 2011, 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 "vm/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
@@ skipping 52 matching lines @@
 }
 
 
 void Breakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 }
 
 
 ActivationFrame::ActivationFrame(uword pc)
     : pc_(pc),
-      function_(Function::null()),
+      function_(NULL),
       token_index_(-1),
-      line_number_(-1) {
+      line_number_(-1),
+      locals_(NULL) {
 }
 
 
-RawFunction* ActivationFrame::DartFunction() {
-  if (function_ == Function::null()) {
+Function* ActivationFrame::DartFunction() {

[srdjan, 2011/12/20 22:07:04]

Maybe you could return const Function&, since you will always return a non-null
value, and then the caller does not need to worry if it is NUL or not?

[hausner, 2011/12/20 22:13:29]

Will address in next checkin. Good idea.

+  if (function_ == NULL) {
     ASSERT(Isolate::Current() != NULL);
     CodeIndexTable* code_index_table = Isolate::Current()->code_index_table();
     ASSERT(code_index_table != NULL);
-    function_ = code_index_table->LookupFunction(pc_);
+    function_ = &Function::ZoneHandle(code_index_table->LookupFunction(pc_));
   }
   return function_;
 }
 
 
 const char* Debugger::QualifiedFunctionName(const Function& func) {
   String& func_name = String::Handle(func.name());
   Class& func_class = Class::Handle(func.owner());
   String& class_name = String::Handle(func_class.Name());
 
   const char* kFormat = "%s%s%s";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat,
       func_class.IsTopLevel() ? "" : class_name.ToCString(),
       func_class.IsTopLevel() ? "" : ".",
       func_name.ToCString());
   len++;  // String terminator.
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat,
               func_class.IsTopLevel() ? "" : class_name.ToCString(),
               func_class.IsTopLevel() ? "" : ".",
               func_name.ToCString());
   return chars;
 }
 
 
 RawString* ActivationFrame::QualifiedFunctionName() {
-  Function& func = Function::Handle(DartFunction());
+  Function& func = *DartFunction();
   return String::New(Debugger::QualifiedFunctionName(func));
 }
 
 
 RawString* ActivationFrame::SourceUrl() {
   const Script& script = Script::Handle(SourceScript());
   return script.url();
 }
 
 
 RawScript* ActivationFrame::SourceScript() {
-  const Function& func = Function::Handle(DartFunction());
+  const Function& func = *DartFunction();
   const Class& cls = Class::Handle(func.owner());
   return cls.script();
 }
 
 
 intptr_t ActivationFrame::TokenIndex() {
   if (token_index_ < 0) {
-    const Function& func = Function::Handle(DartFunction());
+    const Function& func = *DartFunction();
     Code& code = Code::Handle(func.code());
     ASSERT(!code.IsNull());
     PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
     for (int i = 0; i < desc.Length(); i++) {
       if (desc.PC(i) == pc_) {
         token_index_ = desc.TokenIndex(i);
         break;
       }
     }
     ASSERT(token_index_ >= 0);
   }
   return token_index_;
 }
 
 
 intptr_t ActivationFrame::LineNumber() {
   // Compute line number lazily since it causes scanning of the script.
   if (line_number_ < 0) {
     const Script& script = Script::Handle(SourceScript());
     intptr_t ignore_column;
     script.GetTokenLocation(TokenIndex(), &line_number_, &ignore_column);
   }
   return line_number_;
 }
 
 
-RawArray* ActivationFrame::Variables() {
-  UNIMPLEMENTED();
-  return NULL;
+ActiveVariables* ActivationFrame::LocalVariables() {

[srdjan, 2011/12/20 22:07:04]

Ditto const ActiveVariables&

[hausner, 2011/12/20 22:13:29]

Ditto

+  if (locals_ == NULL) {
+    const Function& func = *DartFunction();
+    locals_ = new ActiveVariables(func, TokenIndex());
+  }
+  return locals_;
 }
 
 
 RawInstance* ActivationFrame::Value(const String& variable_name) {
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 const char* ActivationFrame::ToCString() {
   const char* kFormat = "Function: '%s' url: '%s' line: %d";
 
-  Function& func = Function::Handle(DartFunction());
+  Function& func = *DartFunction();
   String& url = String::Handle(SourceUrl());
   intptr_t line = LineNumber();
   const char* func_name = Debugger::QualifiedFunctionName(func);
 
   intptr_t len =
       OS::SNPrint(NULL, 0, kFormat, func_name, url.ToCString(), line);
   len++;  // String terminator.
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, func_name, url.ToCString(), line);
   return chars;
 }
 
 
 void StackTrace::AddActivation(ActivationFrame* frame) {
   this->trace_.Add(frame);
 }
 
 
+ActiveVariables::ActiveVariables(const Function& function, intptr_t token_pos)
+    : descriptors_(NULL),
+      desc_indices_(8) {
+  const Code& code = Code::Handle(function.code());
+  LocalVarDescriptors& var_descs =
+      LocalVarDescriptors::ZoneHandle(code.var_descriptors());
+  descriptors_ = &var_descs;
+  intptr_t desc_len = var_descs.Length();
+  for (int i = 0; i < desc_len; i++) {
+    intptr_t begin_pos, end_pos;
+    var_descs.GetRange(i, &begin_pos, &end_pos);
+    if ((begin_pos <= token_pos) && (token_pos <= end_pos)) {
+      desc_indices_.Add(i);
+    }
+  }
+}
+
+
+void ActiveVariables::VariableAt(intptr_t i,
+                                 String* name,
+                                 intptr_t* token_pos,
+                                 intptr_t* end_pos,
+                                 Instance* value) const {
+  ASSERT(i < Length());
+  ASSERT(name != NULL);
+  intptr_t desc_index = desc_indices_[i];
+  *name ^= descriptors_->GetName(desc_index);
+  descriptors_->GetRange(i, token_pos, end_pos);
+  ASSERT(value != NULL);
+  *value = Instance::null();  // TODO(hausner): get actual variable value.
+}
+
+
 Debugger::Debugger()
     : initialized_(false),
       bp_handler_(NULL),
       breakpoints_(NULL) {
 }
 
 
 bool Debugger::IsActive() {
   // TODO(hausner): The code generator uses this function to prevent
   // generation of optimized code when Dart code is being debugged.
@@ skipping 47 matching lines @@
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   for (int i = 0; i < desc.Length(); i++) {
     PcDescriptors::Kind kind = desc.DescriptorKind(i);
     Breakpoint* bpt = NULL;
     if (kind == PcDescriptors::kIcCall) {
       CodePatcher::PatchInstanceCallAt(
           desc.PC(i), StubCode::BreakpointDynamicEntryPoint());
       bpt = new Breakpoint(target_function, i);
     } else if (kind == PcDescriptors::kOther) {
-      if (CodePatcher::IsDartCall(desc.PC(i))) {
+      if ((desc.TokenIndex(i) > 0) && CodePatcher::IsDartCall(desc.PC(i))) {
         CodePatcher::PatchStaticCallAt(
             desc.PC(i), StubCode::BreakpointStaticEntryPoint());
         bpt = new Breakpoint(target_function, i);
       }
     }
     if (bpt != NULL) {
       if (verbose) {
         OS::Print("Setting breakpoint at '%s' line %d  (PC %p)\n",
             String::Handle(bpt->SourceUrl()).ToCString(),
             bpt->LineNumber(),
@@ skipping 11 matching lines @@
   ASSERT(visitor != NULL);
   Breakpoint* bpt = this->breakpoints_;
   while (bpt != NULL) {
     bpt->VisitObjectPointers(visitor);
     bpt = bpt->next();
   }
 }
 
 
 static void DefaultBreakpointHandler(Breakpoint* bpt, StackTrace* stack) {
+  String& var_name = String::Handle();
+  Instance& value = Instance::Handle();
   for (intptr_t i = 0; i < stack->Length(); i++) {
+    ActivationFrame* frame = stack->ActivationFrameAt(i);
     OS::Print("   %d. %s\n",
-              i + 1, stack->ActivationFrameAt(i)->ToCString());
+              i + 1, frame->ToCString());
+    ActiveVariables* locals = frame->LocalVariables();
+    intptr_t num_locals = locals->Length();
+    for (intptr_t i = 0; i < num_locals; i++) {
+      intptr_t token_pos, end_pos;
+      locals->VariableAt(i, &var_name, &token_pos, &end_pos, &value);
+      OS::Print("      var %s (pos %d) = %s\n",
+                var_name.ToCString(), token_pos, value.ToCString());
+    }
   }
 }
 
 
 void Debugger::SetBreakpointHandler(BreakpointHandler* handler) {
   bp_handler_ = handler;
   if (bp_handler_ == NULL) {
     bp_handler_ = &DefaultBreakpointHandler;
   }
 }
@@ skipping 49 matching lines @@
 
 
 void Debugger::AddBreakpoint(Breakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(this->breakpoints_);
   this->breakpoints_ = bpt;
 }
 
 
 }  // namespace dart