Local closures may be the only survivors in a library.

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 128 matching lines @@
     dropped_class_count_(0),
     dropped_typearg_count_(0),
     dropped_type_count_(0),
     dropped_library_count_(0),
     libraries_(GrowableObjectArray::Handle(I->object_store()->libraries())),
     pending_functions_(
         GrowableObjectArray::Handle(GrowableObjectArray::New())),
     sent_selectors_(),
     enqueued_functions_(),
     fields_to_retain_(),
+    functions_to_retain_(),
     classes_to_retain_(),
     typeargs_to_retain_(),
     types_to_retain_(),
     consts_to_retain_(),
     error_(Error::Handle()) {
 }
 
 
 void Precompiler::DoCompileAll(
     Dart_QualifiedFunctionName embedder_entry_points[]) {
@@ skipping 33 matching lines @@
       // Start with the allocations and invocations that happen from C++.
       AddRoots(embedder_entry_points);
 
       // Compile newly found targets and add their callees until we reach a
       // fixed point.
       Iterate();
     }
 
     I->set_compilation_allowed(false);
 
+    TraceForRetainedFunctions();
     DropFunctions();
     DropFields();
     TraceTypesFromRetainedClasses();
     DropTypes();
     DropTypeArguments();
 
     // Clear these before dropping classes as they may hold onto otherwise
     // dead instances of classes we will remove.
     I->object_store()->set_compile_time_constants(Array::null_array());
     I->object_store()->set_unique_dynamic_targets(Array::null_array());
@@ skipping 364 matching lines @@
   type = cls.mixin();
   AddType(type);
 
   if (cls.IsTypedefClass()) {
     AddTypesOf(Function::Handle(Z, cls.signature_function()));
   }
 }
 
 
 void Precompiler::AddTypesOf(const Function& function) {
+  if (function.IsNull()) return;
+  if (functions_to_retain_.Lookup(&function) != NULL) return;
+  functions_to_retain_.Insert(&Function::ZoneHandle(Z, function.raw()));
+
   AbstractType& type = AbstractType::Handle(Z);
   type = function.result_type();
   AddType(type);
   for (intptr_t i = 0; i < function.NumParameters(); i++) {
     type = function.ParameterTypeAt(i);
     AddType(type);
   }
   Code& code = Code::Handle(Z, function.CurrentCode());
   if (code.IsNull()) {
     ASSERT(function.kind() == RawFunction::kSignatureFunction);
@@ skipping 607 matching lines @@
         function ^= functions.At(j);
         if (function.is_const() && function.HasCode()) {
           AddCalleesOf(function);
         }
       }
     }
   }
 }
 
 
-void Precompiler::DropFunctions() {
+void Precompiler::TraceForRetainedFunctions() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
   Function& function = Function::Handle(Z);
   Function& function2 = Function::Handle(Z);
-  GrowableObjectArray& retained_functions = GrowableObjectArray::Handle(Z);
   GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
-  String& name = String::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
     while (it.HasNext()) {
       cls = it.GetNextClass();
       if (cls.IsDynamicClass()) {
         continue;  // class 'dynamic' is in the read-only VM isolate.
       }
 
       functions = cls.functions();
-      retained_functions = GrowableObjectArray::New();
       for (intptr_t j = 0; j < functions.Length(); j++) {
         function ^= functions.At(j);
         bool retain = function.HasCode();
         if (!retain && function.HasImplicitClosureFunction()) {
           // It can happen that all uses of an implicit closure inline their
           // target function, leaving the target function uncompiled. Keep
           // the target function anyway so we can enumerate it to bind its
           // static calls, etc.
           function2 = function.ImplicitClosureFunction();
           retain = function2.HasCode();
         }
         if (retain) {
-          retained_functions.Add(function);
           function.DropUncompiledImplicitClosureFunction();
           AddTypesOf(function);
+        }
+      }
+    }
+  }
+
+  closures = isolate()->object_store()->closure_functions();
+  for (intptr_t j = 0; j < closures.Length(); j++) {
+    function ^= closures.At(j);
+    bool retain = function.HasCode();
+    if (retain) {
+      AddTypesOf(function);
+
+      cls = function.Owner();
+      AddTypesOf(cls);
+
+      // It can happen that all uses of a function are inlined, leaving
+      // a compiled local function with an uncompiled parent. Retain such
+      // parents and their enclosing classes and libraries.
+      function = function.parent_function();
+      while (!function.IsNull()) {
+        AddTypesOf(function);
+        function = function.parent_function();
+      }
+    }
+  }
+}
+
+
+void Precompiler::DropFunctions() {
+  Library& lib = Library::Handle(Z);
+  Class& cls = Class::Handle(Z);
+  Array& functions = Array::Handle(Z);
+  Function& function = Function::Handle(Z);
+  GrowableObjectArray& retained_functions = GrowableObjectArray::Handle(Z);
+  GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
+  String& name = String::Handle(Z);
+
+  for (intptr_t i = 0; i < libraries_.Length(); i++) {
+    lib ^= libraries_.At(i);
+    ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
+    while (it.HasNext()) {
+      cls = it.GetNextClass();
+      if (cls.IsDynamicClass()) {
+        continue;  // class 'dynamic' is in the read-only VM isolate.
+      }
+
+      functions = cls.functions();
+      retained_functions = GrowableObjectArray::New();
+      for (intptr_t j = 0; j < functions.Length(); j++) {
+        function ^= functions.At(j);
+        bool retain = functions_to_retain_.Lookup(&function) != NULL;
+        function.DropUncompiledImplicitClosureFunction();
+        if (retain) {
+          retained_functions.Add(function);
         } else {
           bool top_level = cls.IsTopLevel();
           if (top_level &&
               (function.kind() != RawFunction::kImplicitStaticFinalGetter)) {
             // Implicit static final getters are not added to the library
             // dictionary in the first place.
             name = function.DictionaryName();
             bool removed = lib.RemoveObject(function, name);
             ASSERT(removed);
           }
@@ skipping 11 matching lines @@
       } else {
         cls.SetFunctions(Object::empty_array());
       }
     }
   }
 
   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 = function.HasCode();
+    bool retain = functions_to_retain_.Lookup(&function) != NULL;
     if (retain) {
       retained_functions.Add(function);
-      AddTypesOf(function);
     } else {
       dropped_function_count_++;
       if (FLAG_trace_precompiler) {
         THR_Print("Dropping function %s\n",
                   function.ToLibNamePrefixedQualifiedCString());
       }
     }
   }
   isolate()->object_store()->set_closure_functions(retained_functions);
 }
@@ skipping 318 matching lines @@
     explicit BindStaticCallsVisitor(Zone* zone) :
         code_(Code::Handle(zone)),
         table_(Array::Handle(zone)),
         pc_offset_(Smi::Handle(zone)),
         target_(Function::Handle(zone)),
         target_code_(Code::Handle(zone)) {
     }
 
     void VisitFunction(const Function& function) {
       if (!function.HasCode()) {
-        ASSERT(function.HasImplicitClosureFunction());
         return;
       }
       code_ = function.CurrentCode();
       table_ = code_.static_calls_target_table();
 
       for (intptr_t i = 0;
            i < table_.Length();
            i += Code::kSCallTableEntryLength) {
         pc_offset_ ^= table_.At(i + Code::kSCallTableOffsetEntry);
         target_ ^= table_.At(i + Code::kSCallTableFunctionEntry);
@@ skipping 48 matching lines @@
         pool_(ObjectPool::Handle(zone)),
         entry_(Object::Handle(zone)),
         ic_(ICData::Handle(zone)),
         target_(Function::Handle(zone)),
         target_code_(Code::Handle(zone)),
         entry_point_(Smi::Handle(zone)) {
     }
 
     void VisitFunction(const Function& function) {
       if (!function.HasCode()) {
-        ASSERT(function.HasImplicitClosureFunction());
         return;
       }
 
       code_ = function.CurrentCode();
       pool_ = code_.object_pool();
       for (intptr_t i = 0; i < pool_.Length(); i++) {
         if (pool_.InfoAt(i) != ObjectPool::kTaggedObject) continue;
         entry_ = pool_.ObjectAt(i);
         if (entry_.IsICData()) {
           ic_ ^= entry_.raw();
@@ skipping 48 matching lines @@
     explicit DedupStackmapsVisitor(Zone* zone) :
       zone_(zone),
       canonical_stackmaps_(),
       code_(Code::Handle(zone)),
       stackmaps_(Array::Handle(zone)),
       stackmap_(Stackmap::Handle(zone)) {
     }
 
     void VisitFunction(const Function& function) {
       if (!function.HasCode()) {
-        ASSERT(function.HasImplicitClosureFunction());
         return;
       }
       code_ = function.CurrentCode();
       stackmaps_ = code_.stackmaps();
       if (stackmaps_.IsNull()) return;
       for (intptr_t i = 0; i < stackmaps_.Length(); i++) {
         stackmap_ ^= stackmaps_.At(i);
         stackmap_ = DedupStackmap(stackmap_);
         stackmaps_.SetAt(i, stackmap_);
       }
@@ skipping 30 matching lines @@
     explicit DedupStackmapListsVisitor(Zone* zone) :
       zone_(zone),
       canonical_stackmap_lists_(),
       code_(Code::Handle(zone)),
       stackmaps_(Array::Handle(zone)),
       stackmap_(Stackmap::Handle(zone)) {
     }
 
     void VisitFunction(const Function& function) {
       if (!function.HasCode()) {
-        ASSERT(function.HasImplicitClosureFunction());
         return;
       }
       code_ = function.CurrentCode();
       stackmaps_ = code_.stackmaps();
       if (stackmaps_.IsNull()) return;
 
       stackmaps_ = DedupStackmapList(stackmaps_);
       code_.set_stackmaps(stackmaps_);
     }
 
@@ skipping 863 matching lines @@
       CompilationPipeline::New(thread->zone(), function);
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   return PrecompileFunctionHelper(pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart