Introduce remote objects in Debugger protocol

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 "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.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/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 static const bool verbose = false;
 
+class RemoteObjectCache : public ZoneAllocated {
+ public:
+  explicit RemoteObjectCache(intptr_t initial_size);
+  intptr_t AddObject(const Object& obj);
+  RawObject* GetObj(intptr_t obj_id) const;
+  bool IsValidId(intptr_t obj_id) const {
+    return obj_id < objs_->Length();
+  }
+
+ private:
+  GrowableObjectArray* objs_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoteObjectCache);
+};
+
 
 SourceBreakpoint::SourceBreakpoint(intptr_t id,
                                    const Function& func,
                                    intptr_t token_index)
     : id_(id),
       function_(func.raw()),
       token_index_(token_index),
       line_number_(-1),
       is_enabled_(false),
       next_(NULL) {
@@ skipping 53 matching lines @@
 void CodeBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 }
 
 
 ActivationFrame::ActivationFrame(uword pc, uword fp, uword sp)
     : pc_(pc), fp_(fp), sp_(sp),
       function_(Function::ZoneHandle()),
       token_index_(-1),
       line_number_(-1),
-      var_descriptors_(NULL),
+      var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8) {
 }
 
 
 const Function& ActivationFrame::DartFunction() {
   if (function_.IsNull()) {
     Isolate* isolate = Isolate::Current();
     ASSERT(isolate != NULL);
     const Code& code = Code::Handle(Code::LookupCode(pc_));
     function_ = code.function();
@@ skipping 66 matching lines @@
   if (line_number_ < 0) {
     const Script& script = Script::Handle(SourceScript());
     intptr_t ignore_column;
     script.GetTokenLocation(TokenIndex(), &line_number_, &ignore_column);
   }
   return line_number_;
 }
 
 
 void ActivationFrame::GetDescIndices() {
-  if (var_descriptors_ == NULL) {
+  if (var_descriptors_.IsNull()) {
     ASSERT(!DartFunction().HasOptimizedCode());
     const Code& code = Code::Handle(DartFunction().unoptimized_code());
-    var_descriptors_ =
-        &LocalVarDescriptors::ZoneHandle(code.var_descriptors());
+    var_descriptors_ = code.var_descriptors();
     // TODO(Hausner): Consider replacing this GrowableArray.
     GrowableArray<String*> var_names(8);
     intptr_t activation_token_pos = TokenIndex();
-    intptr_t var_desc_len = var_descriptors_->Length();
+    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());
       intptr_t scope_id, begin_pos, end_pos;
-      var_descriptors_->GetScopeInfo(cur_idx, &scope_id, &begin_pos, &end_pos);
+      var_descriptors_.GetScopeInfo(cur_idx, &scope_id, &begin_pos, &end_pos);
       if ((begin_pos <= activation_token_pos) &&
           (activation_token_pos <= end_pos)) {
         // The current variable is textually in scope. Now check whether
         // there is another local variable with the same name that shadows
         // or is shadowed by this variable.
-        String& var_name = String::Handle(var_descriptors_->GetName(cur_idx));
+        String& var_name = String::Handle(var_descriptors_.GetName(cur_idx));
         intptr_t indices_len = desc_indices_.length();
         bool name_match_found = false;
         for (int i = 0; i < indices_len; i++) {
           if (var_name.Equals(*var_names[i])) {
             // Found two local variables with the same name. Now determine
             // which one is shadowed.
             name_match_found = true;
             intptr_t i_begin_pos, ignore;
-            var_descriptors_->GetScopeInfo(
+            var_descriptors_.GetScopeInfo(
                 desc_indices_[i], &ignore, &i_begin_pos, &ignore);
             if (i_begin_pos < begin_pos) {
               // The variable we found earlier is in an outer scope
               // and is shadowed by the current variable. Replace the
               // descriptor index of the previously found variable
               // with the descriptor index of the current variable.
               desc_indices_[i] = cur_idx;
             } else {
               // The variable we found earlier is in an inner scope
               // and shadows the current variable. Skip the current
@@ skipping 22 matching lines @@
 
 void ActivationFrame::VariableAt(intptr_t i,
                                  String* name,
                                  intptr_t* token_pos,
                                  intptr_t* end_pos,
                                  Instance* value) {
   GetDescIndices();
   ASSERT(i < desc_indices_.length());
   ASSERT(name != NULL);
   intptr_t desc_index = desc_indices_[i];
-  *name ^= var_descriptors_->GetName(desc_index);
+  *name ^= var_descriptors_.GetName(desc_index);
   intptr_t scope_id;
-  var_descriptors_->GetScopeInfo(desc_index, &scope_id, token_pos, end_pos);
+  var_descriptors_.GetScopeInfo(desc_index, &scope_id, token_pos, end_pos);
   ASSERT(value != NULL);
-  *value = GetLocalVarValue(var_descriptors_->GetSlotIndex(desc_index));
+  *value = GetLocalVarValue(var_descriptors_.GetSlotIndex(desc_index));
 }
 
 
 RawArray* ActivationFrame::GetLocalVariables() {
   GetDescIndices();
   intptr_t num_variables = desc_indices_.length();
   String& var_name = String::Handle();
   Instance& value = Instance::Handle();
   const Array& list = Array::Handle(Array::New(2 * num_variables));
   for (int i = 0; i < num_variables; i++) {
-    var_name = var_descriptors_->GetName(i);
+    var_name = var_descriptors_.GetName(i);
     list.SetAt(2 * i, var_name);
-    value = GetLocalVarValue(var_descriptors_->GetSlotIndex(i));
+    value = GetLocalVarValue(var_descriptors_.GetSlotIndex(i));
     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();
@@ skipping 135 matching lines @@
 
 
 void CodeBreakpoint::Disable() {
   if (is_enabled_) {
     RestoreCode();
   }
   ASSERT(!is_enabled_);
 }
 
 
+RemoteObjectCache::RemoteObjectCache(intptr_t initial_size) {
+  objs_ = &GrowableObjectArray::ZoneHandle(
+              GrowableObjectArray::New(initial_size));
+}
+
+
+intptr_t RemoteObjectCache::AddObject(const Object& obj) {
+  intptr_t len = objs_->Length();
+  for (int i = 0; i < len; i++) {
+    if (objs_->At(i) == obj.raw()) {
+      return i;
+    }
+  }
+  objs_->Add(obj);
+  return len;
+}
+
+
+RawObject* RemoteObjectCache::GetObj(intptr_t obj_id) const {
+  ASSERT(IsValidId(obj_id));
+  return objs_->At(obj_id);
+}
+
+
 Debugger::Debugger()
     : isolate_(NULL),
       initialized_(false),
       bp_handler_(NULL),
       event_handler_(NULL),
       next_id_(1),
       stack_trace_(NULL),
+      obj_cache_(NULL),
       src_breakpoints_(NULL),
       code_breakpoints_(NULL),
       resume_action_(kContinue),
       ignore_breakpoints_(false) {
 }
 
 
 Debugger::~Debugger() {
   ASSERT(src_breakpoints_ == NULL);
   ASSERT(code_breakpoints_ == NULL);
   ASSERT(stack_trace_ == NULL);
+  ASSERT(obj_cache_ == NULL);
 }
 
 
 void Debugger::Shutdown() {
   while (src_breakpoints_ != NULL) {
     SourceBreakpoint* bpt = src_breakpoints_;
     src_breakpoints_ = src_breakpoints_->next();
     delete bpt;
   }
   while (code_breakpoints_ != NULL) {
@@ skipping 258 matching lines @@
     if (verbose) {
       OS::Print("No executable code at line %d in '%s'\n",
                 line_number, script_url.ToCString());
     }
     return NULL;
   }
   return SetBreakpoint(func, token_index_at_line);
 }
 
 
+intptr_t Debugger::CacheObject(const Object& obj) {
+  ASSERT(obj_cache_ != NULL);
+  return obj_cache_->AddObject(obj);
+}
+
+
+bool Debugger::IsValidObjectId(intptr_t obj_id) {
+  ASSERT(obj_cache_ != NULL);
+  return obj_cache_->IsValidId(obj_id);
+}
+
+
+RawObject* Debugger::GetCachedObject(intptr_t obj_id) {
+  ASSERT(obj_cache_ != NULL);
+  return obj_cache_->GetObj(obj_id);
+}
+
 // TODO(hausner): Merge some of this functionality with the code in
 // dart_api_impl.cc.
 RawObject* Debugger::GetInstanceField(const Class& cls,
                                       const String& field_name,
                                       const Instance& object) {
   const Function& getter_func =
       Function::Handle(cls.LookupGetterFunction(field_name));
   ASSERT(!getter_func.IsNull());
 
   Object& result = Object::Handle();
@@ skipping 174 matching lines @@
     ActivationFrame* activation =
         new ActivationFrame(frame->pc(), frame->fp(), frame->sp());
     stack_trace->AddActivation(activation);
     frame = iterator.NextFrame();
   }
 
   resume_action_ = kContinue;
   if (bp_handler_ != NULL) {
     SourceBreakpoint* src_bpt = bpt->src_bpt();
     ASSERT(stack_trace_ == NULL);
+    ASSERT(obj_cache_ == NULL);
+    obj_cache_ = new RemoteObjectCache(64);
     stack_trace_ = stack_trace;
     (*bp_handler_)(src_bpt, stack_trace);
     stack_trace_ = NULL;
+    obj_cache_ = NULL;  // Remote object cache is zone allocated.
   }
 
   if (resume_action_ == kContinue) {
     RemoveInternalBreakpoints();
   } else if (resume_action_ == kStepOver) {
     Function& func = Function::Handle(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 = stack_trace->ActivationFrameAt(1);
@@ skipping 204 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart