[vm, service] Account for weakness in getRetainingPath and getRetainedSize.

We had been treating all references as strong for these RPCs. Now weak references are skipped, but ephemeron references are still treated as strong.

TEST=ci
Bug: #49155
Change-Id: I6c4f344ce3c0df5bdbeb133a697bb26ff972f372
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/302367
Reviewed-by: Ben Konyi <[email protected]>
Commit-Queue: Ryan Macnak <[email protected]>

Author: rmacnak-google

runtime/observatory/tests/service/get_retained_size_rpc_test.dart

@@ -2,11 +2,15 @@
 // 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.
 
+import 'dart:typed_data';
+
 import 'package:observatory/service_io.dart';
 import 'package:test/test.dart';
 
 import 'test_helper.dart';
 
+const MB = 1 << 20;
+
 class _TestClass {
   _TestClass(this.x, this.y);
   // Make sure these fields are not removed by the tree shaker.
@@ -25,6 +29,9 @@ invoke1() => myVar = new _TestClass(null, null);
 @pragma("vm:entry-point")
 invoke2() => myVar = new _TestClass(new _TestClass(null, null), null);
 
+@pragma("vm:entry-point")
+invoke3() => myVar = new _TestClass(new WeakReference(new Uint8List(MB)), null);
+
 invoke(Isolate isolate, String selector) async {
   Map params = {
     'targetId': isolate.rootLibrary.id,
@@ -71,6 +78,17 @@ var tests = <IsolateTest>[
     int value3 = int.parse(result['valueAsString']);
     expect(value3, isPositive);
     expect(value3, equals(value2));
+
+    // Target of WeakReference not retained.
+    evalResult = await invoke(isolate, 'invoke3');
+    params = {
+      'targetId': evalResult['id'],
+    };
+    result = await isolate.invokeRpcNoUpgrade('_getRetainedSize', params);
+    expect(result['type'], equals('@Instance'));
+    expect(result['kind'], equals('Int'));
+    int value4 = int.parse(result['valueAsString']);
+    expect(value4, lessThan(MB));
   },
 ];
 

runtime/observatory/tests/service/get_retaining_path_rpc_test.dart

@@ -22,6 +22,9 @@ dynamic target3 = new _TestClass();
 dynamic target4 = new _TestClass();
 dynamic target5 = new _TestClass();
 dynamic target6 = new _TestClass();
+dynamic target7 = new _TestClass();
+dynamic target8 = new _TestClass();
+
 @pragma("vm:entry-point") // Prevent obfuscation
 Expando<_TestClass> expando = Expando<_TestClass>();
 @pragma("vm:entry-point") // Prevent obfuscation
@@ -32,13 +35,25 @@ dynamic globalList = new List<dynamic>.filled(100, null);
 dynamic globalMap1 = new Map();
 @pragma("vm:entry-point") // Prevent obfuscation
 dynamic globalMap2 = new Map();
+@pragma("vm:entry-point") // Prevent obfuscation
+dynamic weakReachable = new _TestClass();
+@pragma("vm:entry-point") // Prevent obfuscation
+dynamic weakUnreachable = new _TestClass();
 
 void warmup() {
   globalObject.x = target1;
   globalObject.y = target2;
   globalList[12] = target3;
   globalMap1['key'] = target4;
   globalMap2[target5] = 'value';
+
+  // The weak reference will be traced first in DFS, but the retaining path
+  // include the strong reference.
+  weakReachable.x = new WeakReference<_TestClass>(target7);
+  weakReachable.y = target7;
+
+  weakUnreachable.x = new WeakReference<_TestClass>(target8);
+  weakUnreachable.y = null;
 }
 
 @pragma("vm:entry-point") // Prevent obfuscation
@@ -88,6 +103,20 @@ takeExpandoTarget() {
   return tmp2;
 }
 
+@pragma("vm:entry-point") // Prevent obfuscation
+takeWeakReachableTarget() {
+  var tmp = target7;
+  target7 = null;
+  return tmp;
+}
+
+@pragma("vm:entry-point") // Prevent obfuscation
+takeWeakUnreachableTarget() {
+  var tmp = target8;
+  target8 = null;
+  return tmp;
+}
+
 @pragma("vm:entry-point") // Prevent obfuscation
 getTrue() => true;
 
@@ -220,6 +249,31 @@ var tests = <IsolateTest>[
     expect(result['elements'][4]['value']['name'], 'expando');
   },
 
+  (Isolate isolate) async {
+    var target7 = await invoke(isolate, 'takeWeakReachableTarget');
+    var params = {
+      'targetId': target7['id'],
+      'limit': 100,
+    };
+    var result = await isolate.invokeRpcNoUpgrade('getRetainingPath', params);
+    expect(result['type'], equals('RetainingPath'));
+    expect(result['gcRootType'], 'user global');
+    expect(result['elements'].length, equals(3));
+    expect(result['elements'][1]['parentField'], equals('y'));
+    expect(result['elements'][2]['value']['name'], equals('weakReachable'));
+  },
+
+  (Isolate isolate) async {
+    var target8 = await invoke(isolate, 'takeWeakUnreachableTarget');
+    var params = {
+      'targetId': target8['id'],
+      'limit': 100,
+    };
+    var result = await isolate.invokeRpcNoUpgrade('getRetainingPath', params);
+    expect(result['type'], equals('RetainingPath'));
+    expect(result['elements'].length, equals(0));
+  },
+
   // object store
   (Isolate isolate) async {
     var obj = await invoke(isolate, 'getTrue');

runtime/vm/object_graph.cc

@@ -240,12 +240,50 @@ class ObjectGraph::Stack : public ObjectPointerVisitor {
       }
       if (direction == ObjectGraph::Visitor::kProceed) {
         set_gc_root_type(node.gc_root_type);
-        obj->untag()->VisitPointers(this);
+        ASSERT(obj->IsHeapObject());
+        switch (obj->GetClassId()) {
+          case kWeakArrayCid:
+            VisitWeakArray(static_cast<WeakArrayPtr>(obj));
+            break;
+          case kWeakReferenceCid:
+            VisitWeakReference(static_cast<WeakReferencePtr>(obj));
+            break;
+          case kFinalizerEntryCid:
+            VisitFinalizerEntry(static_cast<FinalizerEntryPtr>(obj));
+            break;
+          default:
+            obj->untag()->VisitPointers(this);
+            break;
+        }
         clear_gc_root_type();
       }
     }
   }
 
+  void VisitWeakArray(WeakArrayPtr array) {}
+
+  void VisitWeakReference(WeakReferencePtr ref) {
+#if !defined(DART_COMPRESSED_POINTERS)
+    VisitPointers(&ref->untag()->type_arguments_,
+                  &ref->untag()->type_arguments_);
+#else
+    VisitCompressedPointers(ref->heap_base(), &ref->untag()->type_arguments_,
+                            &ref->untag()->type_arguments_);
+#endif
+  }
+
+  void VisitFinalizerEntry(FinalizerEntryPtr entry) {
+#if !defined(DART_COMPRESSED_POINTERS)
+    VisitPointers(&entry->untag()->token_, &entry->untag()->token_);
+    VisitPointers(&entry->untag()->next_, &entry->untag()->next_);
+#else
+    VisitCompressedPointers(entry->heap_base(), &entry->untag()->token_,
+                            &entry->untag()->token_);
+    VisitCompressedPointers(entry->heap_base(), &entry->untag()->next_,
+                            &entry->untag()->next_);
+#endif
+  }
+
   bool visit_weak_persistent_handles() const override {
     return visit_weak_persistent_handles_;
   }

runtime/vm/raw_object.h

@@ -3492,6 +3492,7 @@ class UntaggedWeakReference : public UntaggedInstance {
   friend class Scavenger;
   template <bool>
   friend class ScavengerVisitorBase;
+  friend class ObjectGraph;
   friend class FastObjectCopy;  // For OFFSET_OF
   friend class SlowObjectCopy;  // For OFFSET_OF
 };
@@ -3527,6 +3528,7 @@ class UntaggedFinalizerBase : public UntaggedInstance {
   friend class Scavenger;
   template <bool>
   friend class ScavengerVisitorBase;
+  friend class ObjectGraph;
 };
 
 class UntaggedFinalizer : public UntaggedFinalizerBase {
@@ -3603,6 +3605,7 @@ class UntaggedFinalizerEntry : public UntaggedInstance {
   template <bool>
   friend class ScavengerVisitorBase;
   friend class ScavengerFinalizerVisitor;
+  friend class ObjectGraph;
 };
 
 // MirrorReferences are used by mirrors to hold reflectees that are VM