[vm] Adding owner_class field to Function and Field objects.

TEST=vm/dart/analyze_snapshot_binary_test

Change-Id: I6ea4630a3be7074c63910e1904381b04e37e6e90
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/431705
Reviewed-by: Slava Egorov <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>
Auto-Submit: Roy Tu <[email protected]>
Commit-Queue: Martin Kustermann <[email protected]>

Author: Roy

runtime/tests/vm/dart/analyze_snapshot_binary_test.dart

@@ -204,14 +204,14 @@ Future<void> testAOT(
     );
 
     // Ensure instance fields of classes are reported.
-    final baseClass =
-        objects[classnames.entries
-            .singleWhere((e) => e.value == 'FieldTestBase')
-            .key];
-    final subClass =
-        objects[classnames.entries
-            .singleWhere((e) => e.value == 'FieldTestSub')
-            .key];
+    final baseClassId = classnames.entries
+        .singleWhere((e) => e.value == 'FieldTestBase')
+        .key;
+    final baseClass = objects[baseClassId];
+    final subClassId = classnames.entries
+        .singleWhere((e) => e.value == 'FieldTestSub')
+        .key;
+    final subClass = objects[subClassId];
     final baseFieldIds = baseClass['fields'];
     final baseFields = [for (final int id in baseFieldIds) objects[id]];
     final baseSlots = baseClass['instance_slots']
@@ -222,7 +222,7 @@ Future<void> testAOT(
     final subSlots = subClass['instance_slots'];
 
     // We have:
-    //   class Base {
+    //   class FieldTestBase {
     //     static int baseS0 = int.parse('1');
     //     static int baseS1 = int.parse('2');
     //     int base0;
@@ -233,12 +233,22 @@ Future<void> testAOT(
     //   }
     //
     // This static field is never tree shaken.
-    expectField(baseFields[0], name: 'baseS0', flags: ['static']);
-    expectField(baseFields[1], name: 'baseS1', flags: ['static']);
+    expectField(
+      baseFields[0],
+      name: 'baseS0',
+      flags: ['static'],
+      ownerClass: baseClassId,
+    );
+    expectField(
+      baseFields[1],
+      name: 'baseS1',
+      flags: ['static'],
+      ownerClass: baseClassId,
+    );
 
     // Neighboring static fields should always be one word away
-    final int staticFieldOffset0 = baseFields[0]["static_field_offset"];
-    final int staticFieldOffset1 = baseFields[1]["static_field_offset"];
+    final int staticFieldOffset0 = baseFields[0]['static_field_offset'];
+    final int staticFieldOffset1 = baseFields[1]['static_field_offset'];
     Expect.equals(staticFieldOffset1 - staticFieldOffset0, wordSize);
 
     if (isProduct) {
@@ -277,25 +287,29 @@ Future<void> testAOT(
       expectField(
         baseFields[2],
         name: 'base0',
+        ownerClass: baseClassId,
         isReference: false,
         unboxedType: 'int',
       );
       expectField(
         baseFields[3],
         name: 'base1',
+        ownerClass: baseClassId,
         isReference: false,
         unboxedType: 'double',
       );
-      expectField(baseFields[4], name: 'base2');
+      expectField(baseFields[4], name: 'base2', ownerClass: baseClassId);
       expectField(
         baseFields[5],
         name: 'base3',
+        ownerClass: baseClassId,
         isReference: false,
         unboxedType: 'Float32x4',
       );
       expectField(
         baseFields[6],
         name: 'base4',
+        ownerClass: baseClassId,
         isReference: false,
         unboxedType: 'Float64x2',
       );
@@ -336,13 +350,23 @@ Future<void> testAOT(
       );
     }
     // We have:
-    //   class Sub<T> extends Base{
+    //   class FieldTestSub<T> extends FieldTestBase{
     //     late int subL1 = int.parse('1');
     //     late final double subL2 = double.parse('1.2');
     //   }
     // These late instance fields are never tree shaken.
-    expectField(subFields[0], name: 'subL1', flags: ['late']);
-    expectField(subFields[1], name: 'subL2', flags: ['final', 'late']);
+    expectField(
+      subFields[0],
+      name: 'subL1',
+      flags: ['late'],
+      ownerClass: subClassId,
+    );
+    expectField(
+      subFields[1],
+      name: 'subL2',
+      flags: ['final', 'late'],
+      ownerClass: subClassId,
+    );
     expectTypeArgumentsSlot(
       subSlots[0],
       offsetReferences: 1,
@@ -399,6 +423,28 @@ Future<void> testAOT(
     }
     Expect.isTrue(totalGap < 500);
     Expect.isTrue((totalSize + totalGap - textSectionSize) < 500);
+
+    // Ensure that functions correctly report their owners
+    // `forceDrops` removes all Function objects, so we skip the test there
+    if (!forceDrops) {
+      final myBaseClass =
+          objects[classnames.entries
+              .singleWhere((e) => e.value == 'MyBase')
+              .key];
+      final mySubClass =
+          objects[classnames.entries
+              .singleWhere((e) => e.value == 'MySub')
+              .key];
+
+      final functions = objects.where((o) => o['type'] == 'Function').toList();
+
+      final fooFunc = functions.singleWhere((o) => o['name'] == 'MyBase.foo');
+
+      final barFunc = functions.singleWhere((o) => o['name'] == 'MySub.bar');
+
+      Expect.equals(fooFunc['owner_class'], myBaseClass['id']);
+      Expect.equals(barFunc['owner_class'], mySubClass['id']);
+    }
   });
 }
 
@@ -408,8 +454,12 @@ void expectField(
   List<String> flags = const [],
   bool isReference = true,
   String? unboxedType,
+  int? ownerClass,
 }) {
   Expect.equals(name, fieldJson['name']);
+  if (ownerClass != null) {
+    Expect.equals(ownerClass, fieldJson['owner_class']);
+  }
   Expect.equals(isReference, fieldJson['is_reference']);
   Expect.listEquals(flags, fieldJson['flags']);
   if (unboxedType != null) {

runtime/tests/vm/dart/analyze_snapshot_program.dart

@@ -18,11 +18,22 @@ final channel2 = MethodChannel("channel2");
 const constChannel = MethodChannel("constChannel1");
 const constChannel2 = MethodChannel("constChannel2");
 
-class MyBase {}
+class MyBase {
+  @pragma('vm:never-inline')
+  void foo() => print('foo!');
+}
 
-class MyInterface {}
+class MyInterface {
+  @pragma('vm:never-inline')
+  void bar() => print('bar default!');
+}
 
-class MySub extends MyBase implements MyInterface {}
+class MySub extends MyBase implements MyInterface {
+  @pragma('vm:never-inline')
+  void bar() => print('bar override!');
+}
+
+final mySub1 = MySub();
 
 main() {
   final mcs = [channel1, channel2, constChannel, constChannel2];
@@ -31,6 +42,9 @@ main() {
   }
   print('Class: ${MySub()}');
 
+  mySub1.foo();
+  mySub1.bar();
+
   final l = [
     FieldTestBase(2, 2.2, null, Float32x4.zero(), Float64x2.zero()),
     FieldTestSub<int>(),
@@ -53,6 +67,7 @@ class FieldTestBase {
     baseS1++;
   }
 
+  @pragma('vm:never-inline')
   String foo() =>
       'Base.foo: [$baseS0, $baseS1, $base0, $base1, $base2, $base3, $base4]';
 }
@@ -70,5 +85,6 @@ class FieldTestSub<T> extends FieldTestBase {
         Float64x2(2.1, 2.2),
       );
 
+  @pragma('vm:never-inline')
   String foo() => '${super.foo()} Sub<$T>.foo: [$subL1, $subL2]';
 }

runtime/vm/analyze_snapshot_api_impl.cc

@@ -258,6 +258,7 @@ void SnapshotAnalyzer::DumpFunction(const Function& function) {
                     String::Handle(function.InternalSignature()).ToCString());
 
   js_.PrintProperty("code", GetObjectId(function.CurrentCode()));
+  js_.PrintProperty("owner_class", GetObjectId(function.Owner()));
   if (function.IsClosureFunction()) {
     js_.PrintProperty("parent_function",
                       GetObjectId(function.parent_function()));
@@ -373,6 +374,7 @@ void SnapshotAnalyzer::DumpField(const Field& field) {
   js_.PrintProperty("type", "Field");
   js_.PrintProperty("name", name.ToCString());
   js_.PrintProperty64("type_class", GetObjectId(field.type()));
+  js_.PrintProperty("owner_class", GetObjectId(field.Owner()));
   if (field.is_static()) {
     js_.PrintProperty("instance", GetObjectId(field.StaticValue()));
     js_.PrintProperty64("static_field_offset",