Precompilation: drop Field objects unless they are an entry point or referenced from a constant poo…

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/cha.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/hash_table.h"
@@ skipping 45 matching lines @@
 Precompiler::Precompiler(Thread* thread, bool reset_fields) :
     thread_(thread),
     zone_(thread->zone()),
     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),
     libraries_(GrowableObjectArray::Handle(Z, I->object_store()->libraries())),
     pending_functions_(
         GrowableObjectArray::Handle(Z, GrowableObjectArray::New())),
     sent_selectors_(),
     enqueued_functions_(),
     error_(Error::Handle(Z)) {
 }
 
 
 void Precompiler::DoCompileAll(
@@ skipping 28 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();
   }
 
   DropUncompiledFunctions();
+  DropFields();
 
   // TODO(rmacnak): DropEmptyClasses();
 
   BindStaticCalls();
 
   DedupStackmaps();
 
   if (FLAG_trace_precompiler) {
     THR_Print("Precompiled %" Pd " functions, %" Pd " dynamic types,"
-              " %" Pd " dynamic selectors.\n Dropped %" Pd " functions.\n",
+              " %" Pd " dynamic selectors.\n Dropped %" Pd " functions, %" Pd
+              " fields.\n",
               function_count_,
               class_count_,
               selector_count_,
-              dropped_function_count_);
+              dropped_function_count_,
+              dropped_field_count_);
   }
 
   I->set_compilation_allowed(false);
 }
 
 
 void Precompiler::ClearAllCode() {
   class ClearCodeFunctionVisitor : public FunctionVisitor {
     void VisitFunction(const Function& function) {
       function.ClearCode();
@@ skipping 81 matching lines @@
     kIllegalCid
   };
 
   Class& cls = Class::Handle(Z);
   for (intptr_t i = 0; kExternallyAllocatedCids[i] != kIllegalCid; i++) {
     cls = isolate()->class_table()->At(kExternallyAllocatedCids[i]);
     AddInstantiatedClass(cls);
   }
 
   Dart_QualifiedFunctionName vm_entry_points[] = {
+    // Functions
     { "dart:async", "::", "_setScheduleImmediateClosure" },
     { "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" },
@@ skipping 18 matching lines @@
     { "dart:isolate", "::", "_startMainIsolate" },
     { "dart:isolate", "_RawReceivePortImpl", "_handleMessage" },
     { "dart:isolate", "_RawReceivePortImpl", "_lookupHandler" },
     { "dart:isolate", "_SendPortImpl", "send" },
     { "dart:typed_data", "ByteData", "ByteData." },
     { "dart:typed_data", "ByteData", "ByteData._view" },
     { "dart:typed_data", "_ByteBuffer", "_ByteBuffer._New" },
     { "dart:_vmservice", "::", "_registerIsolate" },
     { "dart:_vmservice", "::", "boot" },
     { "dart:developer", "Metrics", "_printMetrics" },
+    // Fields
+    { "dart:core", "Error", "_stackTrace" },
+    { "dart:math", "_Random", "_state" },
     { NULL, NULL, NULL }  // Must be terminated with NULL entries.
   };
 
   AddEntryPoints(vm_entry_points);
   AddEntryPoints(embedder_entry_points);
 }
 
 
 void Precompiler::AddEntryPoints(Dart_QualifiedFunctionName entry_points[]) {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Function& func = Function::Handle(Z);
+  Field& field = Field::Handle(Z);
   String& library_uri = String::Handle(Z);
   String& class_name = String::Handle(Z);
   String& function_name = String::Handle(Z);
 
   for (intptr_t i = 0; entry_points[i].library_uri != NULL; i++) {
     library_uri = Symbols::New(entry_points[i].library_uri);
     class_name = Symbols::New(entry_points[i].class_name);
     function_name = Symbols::New(entry_points[i].function_name);
 
     lib = Library::LookupLibrary(library_uri);
     if (lib.IsNull()) {
       if (FLAG_trace_precompiler) {
         THR_Print("WARNING: Missing %s\n", entry_points[i].library_uri);
       }
       continue;
     }
 
     if (class_name.raw() == Symbols::TopLevel().raw()) {
       func = lib.LookupFunctionAllowPrivate(function_name);
+      field = lib.LookupFieldAllowPrivate(function_name);
     } else {
       cls = lib.LookupClassAllowPrivate(class_name);
       if (cls.IsNull()) {
         if (FLAG_trace_precompiler) {
           THR_Print("WARNING: Missing %s %s\n",
                     entry_points[i].library_uri,
                     entry_points[i].class_name);
         }
         continue;
       }
 
       ASSERT(!cls.IsNull());
       func = cls.LookupFunctionAllowPrivate(function_name);
+      field = cls.LookupField(function_name);
     }
 
-    if (func.IsNull()) {
+    if (func.IsNull() && field.IsNull()) {
       if (FLAG_trace_precompiler) {
         THR_Print("WARNING: Missing %s %s %s\n",
                   entry_points[i].library_uri,
                   entry_points[i].class_name,
                   entry_points[i].function_name);
       }
-      continue;
     }
 
-    AddFunction(func);
-    if (func.IsGenerativeConstructor()) {
-      // Allocation stubs are referenced from the call site of the constructor,
-      // not in the constructor itself. So compiling the constructor isn't
-      // enough for us to discover the class is instantiated if the class isn't
-      // otherwise instantiated from Dart code and only instantiated from C++.
-      AddInstantiatedClass(cls);
+    if (!func.IsNull()) {
+      AddFunction(func);
+      if (func.IsGenerativeConstructor()) {
+        // Allocation stubs are referenced from the call site of the
+        // constructor, not in the constructor itself. So compiling the
+        // constructor isn't enough for us to discover the class is
+        // instantiated if the class isn't otherwise instantiated from Dart
+        // code and only instantiated from C++.
+        AddInstantiatedClass(cls);
+      }
+    }
+    if (!field.IsNull()) {
+      AddField(field);
     }
   }
 }
 
 
 void Precompiler::Iterate() {
   Function& function = Function::Handle(Z);
 
   while (changed_) {
     changed_ = false;
@@ skipping 179 matching lines @@
   const Function& dispatcher = Function::Handle(Z,
       cache_class.GetInvocationDispatcher(Symbols::Call(),
                                           arguments_descriptor,
                                           RawFunction::kInvokeFieldDispatcher,
                                           true /* create_if_absent */));
   AddFunction(dispatcher);
 }
 
 
 void Precompiler::AddField(const Field& field) {
+  fields_to_retain_.Insert(&Field::ZoneHandle(Z, field.raw()));
+
   if (field.is_static()) {
     const Object& value = Object::Handle(Z, field.StaticValue());
     if (value.IsInstance()) {
       AddConstObject(Instance::Cast(value));
     }
 
     if (field.has_initializer()) {
       // Should not be in the middle of initialization while precompiling.
       ASSERT(value.raw() != Object::transition_sentinel().raw());
 
@@ skipping 361 matching lines @@
           function.DropUncompiledImplicitClosureFunction();
         } else {
           dropped_function_count_++;
           if (FLAG_trace_precompiler) {
             THR_Print("Precompilation dropping %s\n",
                       function.ToLibNamePrefixedQualifiedCString());
           }
         }
       }
 
-      functions = Array::New(retained_functions.Length(), Heap::kOld);
-      for (intptr_t j = 0; j < retained_functions.Length(); j++) {
-        function ^= retained_functions.At(j);
-        functions.SetAt(j, function);
+      if (retained_functions.Length() > 0) {
+        functions = Array::MakeArray(retained_functions);
+        cls.SetFunctions(functions);
+      } else {
+        cls.SetFunctions(Object::empty_array());
       }
-      cls.SetFunctions(functions);
     }
   }
 
   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()) {
       retained_functions.Add(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);
+
+  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 drop = fields_to_retain_.Lookup(&field) == NULL;
+        if (drop) {
+          dropped_field_count_++;
+          if (FLAG_trace_precompiler) {
+            THR_Print("Precompilation dropping %s\n",
+                      field.ToCString());
+          }
+        } else {
+          retained_fields.Add(field);
+        }
+      }
+
+      if (retained_fields.Length() > 0) {
+        fields = Array::MakeArray(retained_fields);
+        cls.SetFields(fields);
+      } else {
+        cls.SetFields(Object::empty_array());
+      }
+    }
+  }
+}
+
+
 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 194 matching lines @@
       cls = it.GetNextClass();
       if (cls.IsDynamicClass()) {
         continue;  // class 'dynamic' is in the read-only VM isolate.
       }
       cls.set_is_allocated(false);
     }
   }
 }
 
 }  // namespace dart