[vm/compiler] Make precompiler prune invocation dispatchers the same way we do for regular/closure functions

The precompiler has a notion of when a function should get its code
generated, when it should retain a functions types. This information
is used to prune function objects after AOT compilation.

This CL introduces the same pruning logic which we do for regular
functions as well as closure functions to invocation dispatchers.

Change-Id: I5c8a75f0cc822c71e876b8e2c9648d9976745895
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/154002
Commit-Queue: Martin Kustermann <[email protected]>
Reviewed-by: Tess Strickland <[email protected]>

Author: mkustermann

runtime/vm/compiler/aot/precompiler.cc

@@ -1461,6 +1461,7 @@ void Precompiler::TraceForRetainedFunctions() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
+  String& name = String::Handle(Z);
   Function& function = Function::Handle(Z);
   Function& function2 = Function::Handle(Z);
   GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
@@ -1487,6 +1488,19 @@ void Precompiler::TraceForRetainedFunctions() {
           AddTypesOf(function);
         }
       }
+
+      {
+        functions = cls.invocation_dispatcher_cache();
+        InvocationDispatcherTable dispatchers(functions);
+        for (auto dispatcher : dispatchers) {
+          name = dispatcher.Get<Class::kInvocationDispatcherName>();
+          if (name.IsNull()) break;  // Reached last entry.
+          function = dispatcher.Get<Class::kInvocationDispatcherFunction>();
+          if (possibly_retained_functions_.ContainsKey(function)) {
+            AddTypesOf(function);
+          }
+        }
+      }
     }
   }
 
@@ -1601,6 +1615,26 @@ void Precompiler::DropFunctions() {
   GrowableObjectArray& retained_functions = GrowableObjectArray::Handle(Z);
   GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
 
+  auto drop_function = [&](const Function& function) {
+    if (function.HasCode()) {
+      code = function.CurrentCode();
+      function.ClearCode();
+      // Wrap the owner of the code object in case the code object will be
+      // serialized but the function object will not.
+      owner = code.owner();
+      owner = WeakSerializationReference::Wrap(Z, owner);
+      code.set_owner(owner);
+    }
+    dropped_function_count_++;
+    if (FLAG_trace_precompiler) {
+      THR_Print("Dropping function %s\n",
+                function.ToLibNamePrefixedQualifiedCString());
+    }
+  };
+
+  auto& dispatchers_array = Array::Handle(Z);
+  auto& name = String::Handle(Z);
+  auto& desc = Array::Handle(Z);
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
@@ -1610,26 +1644,12 @@ void Precompiler::DropFunctions() {
       retained_functions = GrowableObjectArray::New();
       for (intptr_t j = 0; j < functions.Length(); j++) {
         function ^= functions.At(j);
-        bool retain = functions_to_retain_.ContainsKey(function);
         function.DropUncompiledImplicitClosureFunction();
         function.ClearBytecode();
-        if (retain) {
+        if (functions_to_retain_.ContainsKey(function)) {
           retained_functions.Add(function);
         } else {
-          if (function.HasCode()) {
-            code = function.CurrentCode();
-            function.ClearCode();
-            // Wrap the owner of the code object in case the code object will be
-            // serialized but the function object will not.
-            owner = code.owner();
-            owner = WeakSerializationReference::Wrap(Z, owner);
-            code.set_owner(owner);
-          }
-          dropped_function_count_++;
-          if (FLAG_trace_precompiler) {
-            THR_Print("Dropping function %s\n",
-                      function.ToLibNamePrefixedQualifiedCString());
-          }
+          drop_function(function);
         }
       }
 
@@ -1639,32 +1659,47 @@ void Precompiler::DropFunctions() {
       } else {
         cls.SetFunctions(Object::empty_array());
       }
+
+      retained_functions = GrowableObjectArray::New();
+      {
+        dispatchers_array = cls.invocation_dispatcher_cache();
+        InvocationDispatcherTable dispatchers(dispatchers_array);
+        for (auto dispatcher : dispatchers) {
+          name = dispatcher.Get<Class::kInvocationDispatcherName>();
+          if (name.IsNull()) break;  // Reached last entry.
+          desc = dispatcher.Get<Class::kInvocationDispatcherArgsDesc>();
+          function = dispatcher.Get<Class::kInvocationDispatcherFunction>();
+          if (functions_to_retain_.ContainsKey(function)) {
+            retained_functions.Add(name);
+            retained_functions.Add(desc);
+            retained_functions.Add(function);
+          } else {
+            drop_function(function);
+          }
+        }
+      }
+      if (retained_functions.Length() > 0) {
+        // Last entry must be null.
+        retained_functions.Add(Object::null_object());
+        retained_functions.Add(Object::null_object());
+        retained_functions.Add(Object::null_object());
+        functions = Array::MakeFixedLength(retained_functions);
+      } else {
+        functions = Object::empty_array().raw();
+      }
+      cls.set_invocation_dispatcher_cache(functions);
     }
   }
 
   closures = isolate()->object_store()->closure_functions();
   retained_functions = GrowableObjectArray::New();
   for (intptr_t j = 0; j < closures.Length(); j++) {
     function ^= closures.At(j);
-    bool retain = functions_to_retain_.ContainsKey(function);
     function.ClearBytecode();
-    if (retain) {
+    if (functions_to_retain_.ContainsKey(function)) {
       retained_functions.Add(function);
     } else {
-      if (function.HasCode()) {
-        code = function.CurrentCode();
-        function.ClearCode();
-        // Wrap the owner of the code object in case the code object will be
-        // serialized but the function object will not.
-        owner = code.owner();
-        owner = WeakSerializationReference::Wrap(Z, owner);
-        code.set_owner(owner);
-      }
-      dropped_function_count_++;
-      if (FLAG_trace_precompiler) {
-        THR_Print("Dropping function %s\n",
-                  function.ToLibNamePrefixedQualifiedCString());
-      }
+      drop_function(function);
     }
   }
   isolate()->object_store()->set_closure_functions(retained_functions);

runtime/vm/object.h

@@ -1773,6 +1773,7 @@ class Class : public Object {
   friend class InterpreterHelpers;
   friend class Intrinsifier;
   friend class ProgramWalker;
+  friend class Precompiler;
 };
 
 // Classification of type genericity according to type parameter owners.