Incoming references service request and UI.

runtime/vm/object_graph.cc

 // Copyright (c) 2014, 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/object_graph.h"
 
 #include "vm/dart.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
@@ skipping 283 matching lines @@
   // To break the trivial path, the handle 'obj' is temporarily cleared during
   // the search, but restored before returning.
   RawObject* raw = obj->raw();
   *obj = Object::null();
   RetainingPathVisitor visitor(raw, path);
   IterateObjects(&visitor);
   *obj = raw;
   return visitor.length();
 }
 
+
+class InboundReferencesVisitor : public ObjectVisitor,
+                                 public ObjectPointerVisitor {
+ public:
+  // We cannot use a GrowableObjectArray, since we must not trigger GC.
+  InboundReferencesVisitor(Isolate* isolate,
+                           RawObject* target,
+                           const Array& references,
+                           Object* scratch)
+    : ObjectVisitor(isolate), ObjectPointerVisitor(isolate), source_(0),

[koda, 2014/08/21 18:21:20]

I think we usually use NULL rather than 0.

+      target_(target), references_(references), scratch_(scratch), length_(0) {
+    ASSERT(Isolate::Current()->no_gc_scope_depth() != 0);
+  }
+
+  intptr_t length() const { return length_; }
+
+  virtual void VisitObject(RawObject* raw_obj) {
+    source_ = raw_obj;
+    raw_obj->VisitPointers(this);
+  }
+
+  virtual void VisitPointers(RawObject** first, RawObject** last) {
+    for (RawObject** current_ptr = first; current_ptr <= last; current_ptr++) {
+      RawObject* current_obj = *current_ptr;
+      if (current_obj == target_) {
+        intptr_t obj_index = length_ * 2;
+        intptr_t offset_index = obj_index + 1;
+        if (!references_.IsNull() && offset_index < references_.Length()) {
+          *scratch_ = source_;
+          references_.SetAt(obj_index, *scratch_);
+
+          *scratch_ = Smi::New(0);
+          uword source_start = RawObject::ToAddr(source_);
+          uword current_ptr_addr = reinterpret_cast<uword>(current_ptr);
+          intptr_t offset = current_ptr_addr - source_start;
+          if (offset > 0 && offset < source_->Size()) {
+            ASSERT(Utils::IsAligned(offset, kWordSize));
+            *scratch_ = Smi::New(offset >> kWordSizeLog2);
+          } else {
+            // Some internal VM objects visit pointers not contained within the
+            // parent. For instance, RawCode::VisitCodePointers visits pointers
+            // in instructions.
+            ASSERT(!source_->IsDartInstance());
+            *scratch_ = Smi::New(-1);
+          }
+          references_.SetAt(offset_index, *scratch_);
+        }
+        ++length_;
+      }
+    }
+  }
+
+ private:
+  RawObject* source_;
+  RawObject* target_;
+  const Array& references_;
+  Object* scratch_;
+  intptr_t length_;
+};
+
+
+intptr_t ObjectGraph::InboundReferences(Object* obj, const Array& path) {
+  Object& scratch = Object::Handle();
+  NoGCScope no_gc_scope_;
+  // To break the trivial path, the handle 'obj' is temporarily cleared during

[koda, 2014/08/21 18:21:20]

Is this needed here? You don't seem to look at handles, just pointers from other
heap objects, so this trivial path should not impact your computation. (I guess
it will if you start iterating over the handles too. An alternative would then
be to filter this one out.)

[rmacnak, 2014/08/21 22:06:44]

True; removed.

+  // the search, but restored before returning.
+  RawObject* raw = obj->raw();
+  *obj = Object::null();
+  InboundReferencesVisitor visitor(isolate(), raw, path, &scratch);
+  isolate()->heap()->IterateObjects(&visitor);
+  *obj = raw;
+  return visitor.length();
+}
+
 }  // namespace dart