Tree-shake consts.

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 130 matching lines @@
     dropped_library_count_(0),
     libraries_(GrowableObjectArray::Handle(I->object_store()->libraries())),
     pending_functions_(
         GrowableObjectArray::Handle(GrowableObjectArray::New())),
     sent_selectors_(),
     enqueued_functions_(),
     fields_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[]) {
   ASSERT(I->compilation_allowed());
 
   {
     StackZone stack_zone(T);
@@ skipping 241 matching lines @@
 
   while (changed_) {
     changed_ = false;
 
     while (pending_functions_.Length() > 0) {
       function ^= pending_functions_.RemoveLast();
       ProcessFunction(function);
     }
 
     CheckForNewDynamicFunctions();
+    if (!changed_) {
+      TraceConstFunctions();
+    }
   }
 }
 
 
 void Precompiler::ProcessFunction(const Function& function) {
   if (!function.HasCode()) {
     function_count_++;
 
     if (FLAG_trace_precompiler) {
       THR_Print("Precompiling %" Pd " %s (%s, %s)\n",
@@ skipping 247 matching lines @@
     return;
   }
 
   // Can't ask immediate objects if they're canoncial.
   if (instance.IsSmi()) return;
 
   // Some Instances in the ObjectPool aren't const objects, such as
   // argument descriptors.
   if (!instance.IsCanonical()) return;
 
+  consts_to_retain_.Insert(&Instance::ZoneHandle(Z, instance.raw()));
+
   if (cls.NumTypeArguments() > 0) {
     AddTypeArguments(TypeArguments::Handle(Z, instance.GetTypeArguments()));
   }
 
   class ConstObjectVisitor : public ObjectPointerVisitor {
    public:
     ConstObjectVisitor(Precompiler* precompiler, Isolate* isolate) :
         ObjectPointerVisitor(isolate),
         precompiler_(precompiler),
         subinstance_(Object::Handle()) {}
@@ skipping 464 matching lines @@
                                          Object* function) {
   UniqueFunctionsSet functions_set(
       isolate->object_store()->unique_dynamic_targets());
   ASSERT(fname.IsSymbol());
   *function = functions_set.GetOrNull(fname);
   ASSERT(functions_set.Release().raw() ==
       isolate->object_store()->unique_dynamic_targets());
 }
 
 
+void Precompiler::TraceConstFunctions() {
+  // Compilation of const accessors happens outside of the treeshakers
+  // queue, so we haven't previously scanned its literal pool.
+
+  Library& lib = Library::Handle(Z);
+  Class& cls = Class::Handle(Z);
+  Array& functions = Array::Handle(Z);
+  Function& function = Function::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();
+      for (intptr_t j = 0; j < functions.Length(); j++) {
+        function ^= functions.At(j);
+        if (function.is_const() && function.HasCode()) {
+          AddCalleesOf(function);
+        }
+      }
+    }
+  }
+}
+
+
 void Precompiler::DropFunctions() {
   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);
 
@@ skipping 28 matching lines @@
           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);
           }
           dropped_function_count_++;
           if (FLAG_trace_precompiler) {
-            THR_Print("Precompilation dropping %s\n",
+            THR_Print("Dropping function %s\n",
                       function.ToLibNamePrefixedQualifiedCString());
           }
         }
       }
 
       if (retained_functions.Length() > 0) {
         functions = Array::MakeArray(retained_functions);
         cls.SetFunctions(functions);
       } 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();
     if (retain) {
       retained_functions.Add(function);
       AddTypesOf(function);
     } else {
       dropped_function_count_++;
       if (FLAG_trace_precompiler) {
-        THR_Print("Precompilation dropping %s\n",
+        THR_Print("Dropping function %s\n",
                   function.ToLibNamePrefixedQualifiedCString());
       }
     }
   }
   isolate()->object_store()->set_closure_functions(retained_functions);
 }
 
 
 void Precompiler::DropFields() {
   Library& lib = Library::Handle(Z);
@@ skipping 24 matching lines @@
           AddType(type);
         } else {
           bool top_level = cls.IsTopLevel();
           if (top_level) {
             name = field.DictionaryName();
             bool removed = lib.RemoveObject(field, name);
             ASSERT(removed);
           }
           dropped_field_count_++;
           if (FLAG_trace_precompiler) {
-            THR_Print("Precompilation dropping %s\n",
+            THR_Print("Dropping field %s\n",
                       field.ToCString());
           }
         }
       }
 
       if (retained_fields.Length() > 0) {
         fields = Array::MakeArray(retained_fields);
         cls.SetFields(fields);
       } else {
         cls.SetFields(Object::empty_array());
@@ skipping 90 matching lines @@
   new_table.SetAt(dict_size, used);
 
   I->object_store()->set_canonical_type_arguments(new_table);
 }
 
 
 void Precompiler::TraceTypesFromRetainedClasses() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& members = Array::Handle(Z);
+  Array& constants = Array::Handle(Z);
+  GrowableObjectArray& retained_constants = GrowableObjectArray::Handle(Z);
+  Instance& constant = Instance::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.
       }
 
@@ skipping 10 matching lines @@
         retain = true;
       }
       if (cls.is_allocated()) {
         retain = true;
       }
       if (cls.is_enum_class()) {
         // Enum classes have live instances, so we cannot unregister
         // them.
         retain = true;
       }
-      members = cls.constants();
-      if (members.Length() > 0) {
-        // --compile_all?
+
+      constants = cls.constants();
+      retained_constants = GrowableObjectArray::New();
+      for (intptr_t j = 0; j < constants.Length(); j++) {
+        constant ^= constants.At(j);
+        bool retain = consts_to_retain_.Lookup(&constant) != NULL;
+        if (retain) {
+          retained_constants.Add(constant);
+        }
+      }
+      if (retained_constants.Length() > 0) {
+        constants = Array::MakeArray(retained_constants);
+        cls.set_constants(constants);
+      } else {
+        cls.set_constants(Object::empty_array());
+      }
+
+      if (constants.Length() > 0) {
+        ASSERT(retain);  // This shouldn't be the reason we keep a class.
         retain = true;
       }
 
       if (retain) {
         AddTypesOf(cls);
       }
     }
   }
 }
 
@@ skipping 49 matching lines @@
         class_table->StatsWithUpdatedSize(cid)->post_gc.old_count;
     if (instances != 0) {
       FATAL2("Want to drop class %s, but it has %" Pd " instances\n",
              cls.ToCString(),
              instances);
     }
 #endif
 
     dropped_class_count_++;
     if (FLAG_trace_precompiler) {
-      THR_Print("Precompilation dropping %" Pd " %s\n", cid, cls.ToCString());
+      THR_Print("Dropping class %" Pd " %s\n", cid, cls.ToCString());
     }
 
 #if defined(DEBUG)
     class_table->Unregister(cid);
 #endif
     cls.set_id(kIllegalCid);  // We check this when serializing.
 
     lib = cls.library();
     name = cls.DictionaryName();
     lib.RemoveObject(cls, name);
@@ skipping 16 matching lines @@
       entries++;
     }
     bool retain = (entries > 0) || lib.is_dart_scheme();
     if (retain) {
       lib.set_index(retained_libraries.Length());
       retained_libraries.Add(lib);
     } else {
       dropped_library_count_++;
       lib.set_index(-1);
       if (FLAG_trace_precompiler) {
-        THR_Print("Precompilation dropping %s\n", lib.ToCString());
+        THR_Print("Dropping library %s\n", lib.ToCString());
       }
     }
   }
 
   I->object_store()->set_libraries(retained_libraries);
   libraries_ = retained_libraries.raw();
 }
 
 
 void Precompiler::BindStaticCalls() {
@@ skipping 997 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