Precompilation: drop unused types and type arguments and empty classes and libraries.

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/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
@@ skipping 122 matching lines @@
     thread_(thread),
     zone_(NULL),
     isolate_(thread->isolate()),
     reset_fields_(reset_fields),
     changed_(false),
     function_count_(0),
     class_count_(0),
     selector_count_(0),
     dropped_function_count_(0),
     dropped_field_count_(0),
+    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_(),
+    classes_to_retain_(),
+    typeargs_to_retain_(),
+    types_to_retain_(),
     error_(Error::Handle()) {
 }
 
 
 void Precompiler::DoCompileAll(
     Dart_QualifiedFunctionName embedder_entry_points[]) {
   ASSERT(I->compilation_allowed());
 
   {
     StackZone stack_zone(T);
     zone_ = stack_zone.GetZone();
 
     // Make sure class hierarchy is stable before compilation so that CHA
     // can be used. Also ensures lookup of entry points won't miss functions
     // because their class hasn't been finalized yet.
     FinalizeAllClasses();
 
     const intptr_t kPrecompilerRounds = 1;
     for (intptr_t round = 0; round < kPrecompilerRounds; round++) {
       if (FLAG_trace_precompiler) {
-        OS::Print("Precompiler round %" Pd "\n", round);
+        THR_Print("Precompiler round %" Pd "\n", round);
       }
 
       if (round > 0) {
         ResetPrecompilerState();
       }
 
       // TODO(rmacnak): We should be able to do a more thorough job and drop
       // some
       //  - implicit static closures
       //  - field initializers
@@ skipping 10 matching lines @@
 
       // Compile newly found targets and add their callees until we reach a
       // fixed point.
       Iterate();
     }
 
     I->set_compilation_allowed(false);
 
     DropFunctions();
     DropFields();
-
-    // TODO(rmacnak): DropEmptyClasses();
+    TraceTypesFromRetainedClasses();
+    DropTypes();
+    DropTypeArguments();
+    DropClasses();
+    DropLibraries();
 
     BindStaticCalls();
 
     DedupStackmaps();
     DedupStackmapLists();
 
     if (FLAG_dedup_instructions) {
       // Reduces binary size but obfuscates profiler results.
       DedupInstructions();
     }
 
     I->object_store()->set_compile_time_constants(Array::null_array());
     I->object_store()->set_unique_dynamic_targets(Array::null_array());
 
     zone_ = NULL;
   }
 
   intptr_t dropped_symbols_count = Symbols::Compact(I);
 
   if (FLAG_trace_precompiler) {
-    THR_Print("Precompiled %" Pd " functions, %" Pd " dynamic types,"
-              " %" Pd " dynamic selectors.\n Dropped %" Pd " functions, %" Pd
-              " fields, %" Pd " symbols.\n",
-              function_count_,
-              class_count_,
-              selector_count_,
-              dropped_function_count_,
-              dropped_field_count_,
-              dropped_symbols_count);
+    THR_Print("Precompiled %" Pd " functions,", function_count_);
+    THR_Print(" %" Pd " dynamic types,", class_count_);
+    THR_Print(" %" Pd " dynamic selectors.\n", selector_count_);
+
+    THR_Print("Dropped %" Pd " functions,", dropped_function_count_);
+    THR_Print(" %" Pd " fields,", dropped_field_count_);
+    THR_Print(" %" Pd " symbols,", dropped_symbols_count);
+    THR_Print(" %" Pd " types,", dropped_type_count_);
+    THR_Print(" %" Pd " type arguments,", dropped_typearg_count_);
+    THR_Print(" %" Pd " classes,", dropped_class_count_);
+    THR_Print(" %" Pd " libraries.\n", dropped_library_count_);
   }
 }
 
 
 void Precompiler::ClearAllCode() {
   class ClearCodeFunctionVisitor : public FunctionVisitor {
     void VisitFunction(const Function& function) {
       function.ClearCode();
+      function.ClearICDataArray();
     }
   };
   ClearCodeFunctionVisitor visitor;
   VisitFunctions(&visitor);
 }
 
 
 void Precompiler::AddRoots(Dart_QualifiedFunctionName embedder_entry_points[]) {
   // Note that <rootlibrary>.main is not a root. The appropriate main will be
   // discovered through _getMainClosure.
 
   AddSelector(Symbols::NoSuchMethod());
 
   AddSelector(Symbols::Call());  // For speed, not correctness.
 
   // Allocated from C++.
-  static const intptr_t kExternallyAllocatedCids[] = {
-    kBoolCid,
-    kNullCid,
-    kClosureCid,
-
-    kSmiCid,
-    kMintCid,
-    kBigintCid,
-    kDoubleCid,
-
-    kOneByteStringCid,
-    kTwoByteStringCid,
-    kExternalOneByteStringCid,
-    kExternalTwoByteStringCid,
-
-    kArrayCid,
-    kImmutableArrayCid,
-    kGrowableObjectArrayCid,
-    kLinkedHashMapCid,
-
-    kTypedDataUint8ClampedArrayCid,
-    kTypedDataUint8ArrayCid,
-    kTypedDataUint16ArrayCid,
-    kTypedDataUint32ArrayCid,
-    kTypedDataUint64ArrayCid,
-    kTypedDataInt8ArrayCid,
-    kTypedDataInt16ArrayCid,
-    kTypedDataInt32ArrayCid,
-    kTypedDataInt64ArrayCid,
-
-    kExternalTypedDataUint8ArrayCid,
-    kExternalTypedDataUint16ArrayCid,
-    kExternalTypedDataUint32ArrayCid,
-    kExternalTypedDataUint64ArrayCid,
-    kExternalTypedDataInt8ArrayCid,
-    kExternalTypedDataInt16ArrayCid,
-    kExternalTypedDataInt32ArrayCid,
-    kExternalTypedDataInt64ArrayCid,
-
-    kTypedDataFloat32ArrayCid,
-    kTypedDataFloat64ArrayCid,
-
-    kTypedDataFloat32x4ArrayCid,
-    kTypedDataInt32x4ArrayCid,
-    kTypedDataFloat64x2ArrayCid,
-
-    kInt32x4Cid,
-    kFloat32x4Cid,
-    kFloat64x2Cid,
-
-    kTypeCid,
-    kFunctionTypeCid,
-    kTypeRefCid,
-    kTypeParameterCid,
-    kBoundedTypeCid,
-    kLibraryPrefixCid,
-
-    kJSRegExpCid,
-    kUserTagCid,
-    kStacktraceCid,
-    kWeakPropertyCid,
-    kCapabilityCid,
-    ReceivePort::kClassId,
-    SendPort::kClassId,
-
-    kIllegalCid
-  };
-
   Class& cls = Class::Handle(Z);
-  for (intptr_t i = 0; kExternallyAllocatedCids[i] != kIllegalCid; i++) {
-    cls = isolate()->class_table()->At(kExternallyAllocatedCids[i]);
+  for (intptr_t cid = kInstanceCid; cid < kNumPredefinedCids; cid++) {
+    ASSERT(isolate()->class_table()->IsValidIndex(cid));
+    if (!isolate()->class_table()->HasValidClassAt(cid)) {
+      continue;
+    }
+    if ((cid == kDynamicCid) ||
+        (cid == kVoidCid) ||
+        (cid == kFreeListElement)) {
+      continue;
+    }
+    cls = isolate()->class_table()->At(cid);
     AddInstantiatedClass(cls);
   }
 
   Dart_QualifiedFunctionName vm_entry_points[] = {
     // Functions
     { "dart:async", "::", "_setScheduleImmediateClosure" },
-    { "dart:core", "::", "_completeDeferredLoads"},
+    { "dart:core", "::", "_completeDeferredLoads" },
     { "dart:core", "AbstractClassInstantiationError",
                    "AbstractClassInstantiationError._create" },
     { "dart:core", "ArgumentError", "ArgumentError." },
     { "dart:core", "CyclicInitializationError",
                    "CyclicInitializationError." },
     { "dart:core", "FallThroughError", "FallThroughError._create" },
     { "dart:core", "FormatException", "FormatException." },
     { "dart:core", "NoSuchMethodError", "NoSuchMethodError._withType" },
     { "dart:core", "NullThrownError", "NullThrownError." },
     { "dart:core", "OutOfMemoryError", "OutOfMemoryError." },
@@ skipping 133 matching lines @@
                 Function::KindToCString(function.kind()));
     }
 
     ASSERT(!function.is_abstract());
     ASSERT(!function.IsRedirectingFactory());
 
     error_ = CompileFunction(thread_, function);
     if (!error_.IsNull()) {
       Jump(error_);
     }
+    // Used in the JIT to save type-feedback across compilations.
+    function.ClearICDataArray();
   } else {
     if (FLAG_trace_precompiler) {
       // This function was compiled from somewhere other than Precompiler,
       // such as const constructors compiled by the parser.
       THR_Print("Already has code: %s (%s, %s)\n",
                 function.ToLibNamePrefixedQualifiedCString(),
                 function.token_pos().ToCString(),
                 Function::KindToCString(function.kind()));
     }
   }
 
   ASSERT(function.HasCode());
   AddCalleesOf(function);
 }
 
 
 void Precompiler::AddCalleesOf(const Function& function) {
   ASSERT(function.HasCode());
 
   const Code& code = Code::Handle(Z, function.CurrentCode());
 
   const Array& table = Array::Handle(Z, code.static_calls_target_table());
   Object& entry = Object::Handle(Z);
   Function& target = Function::Handle(Z);
   for (intptr_t i = 0; i < table.Length(); i++) {
     entry = table.At(i);
     if (entry.IsFunction()) {
-      target ^= table.At(i);
+      target ^= entry.raw();
       AddFunction(target);
     }
   }
 
 #if defined(TARGET_ARCH_IA32)
   FATAL("Callee scanning unimplemented for IA32");
 #endif
 
   const ObjectPool& pool = ObjectPool::Handle(Z, code.GetObjectPool());
   ICData& call_site = ICData::Handle(Z);
   MegamorphicCache& cache = MegamorphicCache::Handle(Z);
   String& selector = String::Handle(Z);
   Field& field = Field::Handle(Z);
   Class& cls = Class::Handle(Z);
   Instance& instance = Instance::Handle(Z);
   Code& target_code = Code::Handle(Z);
   for (intptr_t i = 0; i < pool.Length(); i++) {
     if (pool.InfoAt(i) == ObjectPool::kTaggedObject) {
       entry = pool.ObjectAt(i);
       if (entry.IsICData()) {
         call_site ^= entry.raw();
-        if (call_site.NumberOfChecks() == 1) {
-          // Probably a static call.
-          target = call_site.GetTargetAt(0);
+        for (intptr_t j = 0; j < call_site.NumberOfChecks(); j++) {
+          target = call_site.GetTargetAt(j);
           AddFunction(target);
           if (!target.is_static()) {
             // Super call (should not enqueue selector) or dynamic call with a
             // CHA prediction (should enqueue selector).
             selector = call_site.target_name();
             AddSelector(selector);
           }
-        } else {
+        }
+        if (call_site.NumberOfChecks() == 0) {
           // A dynamic call.
           selector = call_site.target_name();
           AddSelector(selector);
           if (selector.raw() == Symbols::Call().raw()) {
             // Potential closure call.
             AddClosureCall(call_site);
           }
         }
       } else if (entry.IsMegamorphicCache()) {
         // A dynamic call.
         cache ^= entry.raw();
         selector = cache.target_name();
         AddSelector(selector);
       } else if (entry.IsField()) {
         // Potential need for field initializer.
         field ^= entry.raw();
         AddField(field);
       } else if (entry.IsInstance()) {
         // Const object, literal or args descriptor.
         instance ^= entry.raw();
-        AddConstObject(instance);
+        if (entry.IsAbstractType()) {
+          AddType(AbstractType::Cast(entry));
+        } else {
+          AddConstObject(instance);
+        }
       } else if (entry.IsFunction()) {
         // Local closure function.
         target ^= entry.raw();
         AddFunction(target);
       } else if (entry.IsCode()) {
         target_code ^= entry.raw();
         if (target_code.IsAllocationStubCode()) {
           cls ^= target_code.owner();
           AddInstantiatedClass(cls);
         }
+      } else if (entry.IsTypeArguments()) {
+        AddTypeArguments(TypeArguments::Cast(entry));
       }
     }
   }
 }
 
 
+void Precompiler::AddTypesOf(const Class& cls) {
+  if (cls.IsNull()) return;
+  if (classes_to_retain_.Lookup(&cls) != NULL) return;
+  classes_to_retain_.Insert(&Class::ZoneHandle(Z, cls.raw()));
+
+  Array& interfaces = Array::Handle(Z, cls.interfaces());
+  AbstractType& type = AbstractType::Handle(Z);
+  for (intptr_t i = 0; i < interfaces.Length(); i++) {
+    type ^= interfaces.At(i);
+    AddType(type);
+  }
+
+  AddTypeArguments(TypeArguments::Handle(Z, cls.type_parameters()));
+
+  type = cls.super_type();
+  AddType(type);
+
+  type = cls.mixin();
+  AddType(type);
+
+  if (cls.IsTypedefClass()) {
+    AddTypesOf(Function::Handle(Z, cls.signature_function()));
+  }
+}
+
+
+void Precompiler::AddTypesOf(const Function& function) {
+  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);
+  }
+}
+
+
+void Precompiler::AddType(const AbstractType& abstype) {
+  if (abstype.IsNull()) return;
+
+  if (types_to_retain_.Lookup(&abstype) != NULL) return;
+  types_to_retain_.Insert(&AbstractType::ZoneHandle(Z, abstype.raw()));
+
+  if (abstype.IsType()) {
+    const Type& type = Type::Cast(abstype);
+    const Class& cls = Class::Handle(Z, type.type_class());
+    AddTypesOf(cls);
+    const TypeArguments& vector = TypeArguments::Handle(Z, abstype.arguments());
+    AddTypeArguments(vector);
+  } else if (abstype.IsFunctionType()) {
+    const FunctionType& func_type = FunctionType::Cast(abstype);
+    const Class& cls = Class::Handle(Z, func_type.scope_class());
+    AddTypesOf(cls);
+    const Function& func = Function::Handle(Z, func_type.signature());
+    AddTypesOf(func);
+    const TypeArguments& vector = TypeArguments::Handle(Z, abstype.arguments());
+    AddTypeArguments(vector);
+  } else if (abstype.IsBoundedType()) {
+    AbstractType& type = AbstractType::Handle(Z);
+    type = BoundedType::Cast(abstype).type();
+    AddType(type);
+    type = BoundedType::Cast(abstype).bound();
+    AddType(type);
+  } else if (abstype.IsTypeRef()) {
+    AbstractType& type = AbstractType::Handle(Z);
+    type = TypeRef::Cast(abstype).type();
+    AddType(type);
+  }
+}
+
+
+void Precompiler::AddTypeArguments(const TypeArguments& args) {
+  if (args.IsNull()) return;
+
+  if (typeargs_to_retain_.Lookup(&args) != NULL) return;
+  typeargs_to_retain_.Insert(&TypeArguments::ZoneHandle(Z, args.raw()));
+
+  AbstractType& arg = AbstractType::Handle(Z);
+  for (intptr_t i = 0; i < args.Length(); i++) {
+    arg = args.TypeAt(i);
+    AddType(arg);
+  }
+}
+
+
 void Precompiler::AddConstObject(const Instance& instance) {
   const Class& cls = Class::Handle(Z, instance.clazz());
   AddInstantiatedClass(cls);
 
   if (instance.IsClosure()) {
     // An implicit static closure.
     const Function& func =
         Function::Handle(Z, Closure::Cast(instance).function());
     ASSERT(func.is_static());
     AddFunction(func);
+    AddTypeArguments(TypeArguments::Handle(Z, instance.GetTypeArguments()));
     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;
 
+  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()) {}
 
     virtual void VisitPointers(RawObject** first, RawObject** last) {
       for (RawObject** current = first; current <= last; current++) {
         subinstance_ = *current;
@@ skipping 62 matching lines @@
       AddCalleesOf(function);
     }
   }
 }
 
 
 RawFunction* Precompiler::CompileStaticInitializer(const Field& field) {
   ASSERT(field.is_static());
   if (field.HasPrecompiledInitializer()) {
     // TODO(rmacnak): Investigate why this happens for _enum_names.
-    OS::Print("Warning: Ignoring repeated request for initializer for %s\n",
+    THR_Print("Warning: Ignoring repeated request for initializer for %s\n",
               field.ToCString());
     return Function::null();
   }
   Thread* thread = Thread::Current();
   StackZone zone(thread);
 
   ParsedFunction* parsed_function = Parser::ParseStaticFieldInitializer(field);
 
   parsed_function->AllocateVariables();
   // Non-optimized code generator.
@@ skipping 439 matching lines @@
           // 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);
         } 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);
-    if (function.HasCode()) {
+    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",
                   function.ToLibNamePrefixedQualifiedCString());
       }
     }
   }
   isolate()->object_store()->set_closure_functions(retained_functions);
 }
 
 
 void Precompiler::DropFields() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& fields = Array::Handle(Z);
   Field& field = Field::Handle(Z);
   GrowableObjectArray& retained_fields = GrowableObjectArray::Handle(Z);
   String& name = String::Handle(Z);
+  AbstractType& type = AbstractType::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.
       }
 
       fields = cls.fields();
       retained_fields = GrowableObjectArray::New();
       for (intptr_t j = 0; j < fields.Length(); j++) {
         field ^= fields.At(j);
         bool retain = fields_to_retain_.Lookup(&field) != NULL;
         if (retain) {
           retained_fields.Add(field);
+          type = field.type();
+          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",
                       field.ToCString());
           }
         }
       }
 
       if (retained_fields.Length() > 0) {
         fields = Array::MakeArray(retained_fields);
         cls.SetFields(fields);
       } else {
         cls.SetFields(Object::empty_array());
       }
     }
   }
 }
 
 
+void Precompiler::DropTypes() {
+  Library& lib = Library::Handle(Z);
+  Class& cls = Class::Handle(Z);
+  Object& obj = Object::Handle(Z);
+  Array& arr = Array::Handle(Z);
+  GrowableObjectArray& retained_types = GrowableObjectArray::Handle(Z);
+  AbstractType& type = AbstractType::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.
+      }
+      obj = cls.canonical_types();
+      if (!obj.IsArray()) {
+        // Class only has one type, keep it.
+      } else {
+        // Class has many types.
+        arr ^= obj.raw();
+        retained_types = GrowableObjectArray::New();
+
+        // Always keep the first one.
+        ASSERT(arr.Length() >= 1);
+        obj = arr.At(0);
+        retained_types.Add(obj);
+
+        for (intptr_t i = 1; i < arr.Length(); i++) {
+          obj = arr.At(i);
+          if (obj.IsNull()) {
+            continue;
+          }
+          type ^= obj.raw();
+          bool retain = types_to_retain_.Lookup(&type) != NULL;
+          if (retain) {
+            retained_types.Add(type);
+          } else {
+            dropped_type_count_++;
+          }
+        }
+        arr = Array::MakeArray(retained_types);
+        cls.set_canonical_types(arr);
+      }
+    }
+  }
+}
+
+
+void Precompiler::DropTypeArguments() {
+  const Array& typeargs_table =
+      Array::Handle(Z, I->object_store()->canonical_type_arguments());
+  GrowableObjectArray& retained_typeargs =
+      GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
+  TypeArguments& typeargs = TypeArguments::Handle(Z);
+  for (intptr_t i = 0; i < (typeargs_table.Length() - 1); i++) {
+    typeargs ^= typeargs_table.At(i);
+    bool retain = typeargs_to_retain_.Lookup(&typeargs) != NULL;
+    if (retain) {
+      retained_typeargs.Add(typeargs);
+    } else {
+      dropped_typearg_count_++;
+    }
+  }
+
+  const intptr_t dict_size =
+      Utils::RoundUpToPowerOfTwo(retained_typeargs.Length() * 4 / 3);
+  const Array& new_table = Array::Handle(Z, Array::New(dict_size + 1));
+
+  Object& element = Object::Handle(Z);
+  for (intptr_t i = 0; i < retained_typeargs.Length(); i++) {
+    typeargs ^= retained_typeargs.At(i);
+    intptr_t hash = typeargs.Hash();
+    intptr_t index = hash & (dict_size - 1);
+    element = new_table.At(index);
+    while (!element.IsNull()) {
+      index = (index + 1) & (dict_size - 1);
+      element = new_table.At(index);
+    }
+    new_table.SetAt(index, typeargs);
+  }
+
+  const Smi& used = Smi::Handle(Z, Smi::New(retained_typeargs.Length()));
+  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);
+
+  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.
+      }
+
+      // The subclasses array is only needed for CHA.
+      cls.ClearDirectSubclasses();
+
+      bool retain = false;
+      members = cls.fields();
+      if (members.Length() > 0) {
+        retain = true;
+      }
+      members = cls.functions();
+      if (members.Length() > 0) {
+        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?
+        retain = true;
+      }
+
+      if (retain) {
+        AddTypesOf(cls);
+      }
+    }
+  }
+}
+
+
+void Precompiler::DropClasses() {
+  Library& lib = Library::Handle(Z);
+  Class& cls = Class::Handle(Z);
+  Array& members = Array::Handle(Z);
+  String& name = String::Handle(Z);
+
+#if defined(DEBUG)
+  {
+    // Force GC for allocation stats.
+    I->heap()->CollectAllGarbage();
+  }
+#endif
+
+  ClassTable* class_table = I->class_table();
+  intptr_t num_cids = class_table->NumCids();
+
+  for (intptr_t cid = kNumPredefinedCids; cid < num_cids; cid++) {
+    if (!class_table->IsValidIndex(cid)) continue;
+    if (!class_table->HasValidClassAt(cid)) continue;
+
+    cls = class_table->At(cid);
+    ASSERT(!cls.IsNull());
+
+    if (cls.IsTopLevel()) {
+      // Top-level classes are referenced directly from their library. They
+      // will only be removed as a consequence of an entire library being
+      // removed.
+      continue;
+    }
+    if (cls.is_enum_class()) {
+      // Enum classes have live instances, so we cannot unregister
+      // them.
+      continue;
+    }
+    members = cls.constants();
+    if (members.Length() > 0) {
+      // --compile_all?
+      continue;
+    }
+
+    bool retain = classes_to_retain_.Lookup(&cls) != NULL;
+    if (retain) {
+      continue;
+    }
+
+#if defined(DEBUG)
+    intptr_t instances =
+        class_table->StatsWithUpdatedSize(cid)->post_gc.new_count +
+        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());
+    }
+
+#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);
+  }
+}
+
+
+void Precompiler::DropLibraries() {
+  const GrowableObjectArray& retained_libraries =
+      GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
+  Library& lib = Library::Handle(Z);
+
+  for (intptr_t i = 0; i < libraries_.Length(); i++) {
+    lib ^= libraries_.At(i);
+    lib.DropDependencies();
+    intptr_t entries = 0;
+    DictionaryIterator it(lib);
+    while (it.HasNext()) {
+      it.GetNext();
+      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());
+      }
+    }
+  }
+
+  I->object_store()->set_libraries(retained_libraries);
+  libraries_ = retained_libraries.raw();
+}
+
+
 void Precompiler::BindStaticCalls() {
   class BindStaticCallsVisitor : public FunctionVisitor {
    public:
     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)) {
     }
@@ skipping 978 matching lines @@
       CompilationPipeline::New(thread->zone(), function);
 
   ASSERT(FLAG_precompilation);
   const bool optimized = function.IsOptimizable();  // False for natives.
   return PrecompileFunctionHelper(pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart