First part of inspecting local variables

runtime/vm/object.cc

Index: runtime/vm/object.cc
===================================================================
--- runtime/vm/object.cc	(revision 2587)
+++ 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,66 @@
 }
 
 
+RawString* LocalVarDescriptors::GetName(intptr_t var_index) const {
+  ASSERT(var_index < Length());
+  const Array& names = Array::Handle(raw_ptr()->names_);
+  ASSERT(var_index < names.Length());

[siva, 2011/12/20 19:11:26]

This assertion should be:
ASSERT(Length() == names.Length());

[hausner, 2011/12/20 21:43:55]

True, that is more accurate.

+  const String& name = String::CheckedHandle(names.At(var_index));
+  return name.raw();
+}
+
+
+void LocalVarDescriptors::GetRange(intptr_t var_index,
+                                   intptr_t* begin_pos,

[siva, 2011/12/20 19:11:26]

begin_pos and end_pos don't seem to convey which position, is it code position
or token position, maybe you could qualify it as begin_tok_pos or
begin_token_pos. Ditto for end_pos.

[hausner, 2011/12/20 21:43:55]

Done.

+                                   intptr_t* end_pos) const {
+  ASSERT(var_index < Length());
+  RawLocalVarDescriptors::VarInfo *info = &raw_ptr()->data_[var_index];
+  *begin_pos = info->begin_pos;
+  *end_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_);

[siva, 2011/12/20 19:11:26]

ASSERT(Length() == names.Length());

[hausner, 2011/12/20 21:43:55]

Done.

+  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()->names_ = Array::New(num_variables);

[siva, 2011/12/20 19:11:26]

For this I would use a SetNames or set_names accessor which
would be implemented as:
void set_names(const Array& names) {
  StorePointer(&raw_ptr()->names_, names.raw());
}
and change this to:
const Array& names = Array::Handle(Array::New(num_variables, Heap::kOld));
result.set_names(names);

[hausner, 2011/12/20 21:43:55]

Done. But without the setter boilerplate. There is only this one place where we
assign to names_, so a setter seems unnecessary noise.

+  result.raw_ptr()->length_ = num_variables;

[siva, 2011/12/20 19:11:26]

The length_ field should be set inside the NoGCScope scope that you have above
because if we trigger a GC and length_ is not set then we would not be able to
calculate the instance size.

[hausner, 2011/12/20 21:43:55]

Done.

+  return result.raw();
+}
+
+
+intptr_t LocalVarDescriptors::Length() const {
+  return raw_ptr()->length_;
+}
+
+
 intptr_t ExceptionHandlers::Length() const {
   return Smi::Value(raw_ptr()->length_);
 }