First part of inspecting local variables

runtime/vm/object.cc

Index: runtime/vm/object.cc
===================================================================
--- runtime/vm/object.cc	(revision 2646)
+++ runtime/vm/object.cc	(working copy)
@@ -68,6 +68,8 @@
 RawClass* Object::code_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::pc_descriptors_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::var_descriptors_class_ =
+    reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::exception_handlers_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ -117,6 +119,8 @@
     return kInstructionsClass;
   } else if (raw_class == pc_descriptors_class()) {
     return kPcDescriptorsClass;
+  } else if (raw_class == var_descriptors_class()) {
+    return kLocalVarDescriptorsClass;
   } else if (raw_class == exception_handlers_class()) {
     return kExceptionHandlersClass;
   } else if (raw_class == context_class()) {
@@ -153,6 +157,7 @@
     case kCodeClass: return code_class();
     case kInstructionsClass: return instructions_class();
     case kPcDescriptorsClass: return pc_descriptors_class();
+    case kLocalVarDescriptorsClass: return var_descriptors_class();
     case kExceptionHandlersClass: return exception_handlers_class();
     case kContextClass: return context_class();
     case kContextScopeClass: return context_scope_class();
@@ -186,6 +191,7 @@
     case kCodeClass: return "Code";
     case kInstructionsClass: return "Instructions";
     case kPcDescriptorsClass: return "PcDescriptors";
+    case kLocalVarDescriptorsClass: return "LocalVarDescriptors";
     case kExceptionHandlersClass: return "ExceptionHandlers";
     case kContextClass: return "Context";
     case kContextScopeClass: return "ContextScope";
@@ -320,6 +326,9 @@
   cls = Class::New<PcDescriptors>();
   pc_descriptors_class_ = cls.raw();
 
+  cls = Class::New<LocalVarDescriptors>();
+  var_descriptors_class_ = cls.raw();
+
   cls = Class::New<ExceptionHandlers>();
   exception_handlers_class_ = cls.raw();
 
@@ -4578,6 +4587,68 @@
 }
 
 
+RawString* LocalVarDescriptors::GetName(intptr_t var_index) const {
+  ASSERT(var_index < Length());
+  const Array& names = Array::Handle(raw_ptr()->names_);
+  ASSERT(Length() == names.Length());
+  const String& name = String::CheckedHandle(names.At(var_index));
+  return name.raw();
+}
+
+
+void LocalVarDescriptors::GetRange(intptr_t var_index,
+                                   intptr_t* begin_token_pos,
+                                   intptr_t* end_token_pos) const {
+  ASSERT(var_index < Length());
+  RawLocalVarDescriptors::VarInfo *info = &raw_ptr()->data_[var_index];
+  *begin_token_pos = info->begin_pos;
+  *end_token_pos = info->end_pos;
+}
+
+
+void LocalVarDescriptors::SetVar(intptr_t var_index,
+                                const String& name,
+                                intptr_t stack_slot,
+                                intptr_t begin_pos,
+                                intptr_t end_pos) const {
+  ASSERT(var_index < Length());
+  const Array& names = Array::Handle(raw_ptr()->names_);
+  ASSERT(Length() == names.Length());
+  names.SetAt(var_index, name);
+  RawLocalVarDescriptors::VarInfo *info = &raw_ptr()->data_[var_index];
+  info->index = stack_slot;
+  info->begin_pos = begin_pos;
+  info->end_pos = end_pos;
+}
+
+
+const char* LocalVarDescriptors::ToCString() const {
+  UNIMPLEMENTED();
+  return "";
+}
+
+
+RawLocalVarDescriptors* LocalVarDescriptors::New(intptr_t num_variables) {
+  const Class& cls = Class::Handle(Object::var_descriptors_class());
+  LocalVarDescriptors& result = LocalVarDescriptors::Handle();
+  {
+    uword size = LocalVarDescriptors::InstanceSize(num_variables);
+    RawObject* raw = Object::Allocate(cls, size, Heap::kOld);
+    NoGCScope no_gc;
+    result ^= raw;
+    result.raw_ptr()->length_ = num_variables;
+  }
+  const Array& names = Array::Handle(Array::New(num_variables, Heap::kOld));
+  result.raw_ptr()->names_ = names.raw();
+  return result.raw();
+}
+
+
+intptr_t LocalVarDescriptors::Length() const {
+  return raw_ptr()->length_;
+}
+
+
 intptr_t ExceptionHandlers::Length() const {
   return Smi::Value(raw_ptr()->length_);
 }