VM: Another fix for precompiling with >1 iterations.

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 274 matching lines @@
     if ((cid == kDynamicCid) ||
         (cid == kVoidCid) ||
         (cid == kFreeListElement)) {
       continue;
     }
     cls = isolate()->class_table()->At(cid);
     AddInstantiatedClass(cls);
   }
 
   Dart_QualifiedFunctionName vm_entry_points[] = {
-    // TODO(rmacnak): These types are not allocated from C++ but they are
-    // cached in the object store. Consider clearing them from the object store
-    // before snapshotting and adjusting InitKnownObjects to allow their
-    // absence.
-    { "dart:async", "Future", "Future." },
-    { "dart:async", "Completer", "Completer." },
-    { "dart:async", "StreamIterator", "StreamIterator." },
-
     // 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" },
     { "dart:core", "NullThrownError", "NullThrownError." },
     { "dart:core", "OutOfMemoryError", "OutOfMemoryError." },
     { "dart:core", "RangeError", "RangeError." },
     { "dart:core", "RangeError", "RangeError.range" },
     { "dart:core", "StackOverflowError", "StackOverflowError." },
     { "dart:core", "UnsupportedError", "UnsupportedError." },
     { "dart:core", "_AssertionError", "_AssertionError._create" },
     { "dart:core", "_CastError", "_CastError._create" },
     { "dart:core", "_InternalError", "_InternalError." },
     { "dart:core", "_InvocationMirror", "_allocateInvocationMirror" },
     { "dart:core", "_TypeError", "_TypeError._create" },
     { "dart:isolate", "IsolateSpawnException", "IsolateSpawnException." },
     { "dart:isolate", "::", "_getIsolateScheduleImmediateClosure" },
     { "dart:isolate", "::", "_setupHooks" },
     { "dart:isolate", "::", "_startMainIsolate" },
+    { "dart:isolate", "::", "_startIsolate" },
     { "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" },
 #if !defined(PRODUCT)
     { "dart:_vmservice", "::", "_registerIsolate" },
     { "dart:_vmservice", "::", "boot" },
     { "dart:developer", "Metrics", "_printMetrics" },
+    { "dart:developer", "::", "_runExtension" },
 #endif  // !PRODUCT
     // 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);
 }
@@ skipping 431 matching lines @@
         field.SetPrecompiledInitializer(initializer);
         AddCalleesOf(initializer);
       }
     }
   }
 }
 
 
 RawFunction* Precompiler::CompileStaticInitializer(const Field& field) {
   ASSERT(field.is_static());
-  ASSERT(!field.HasPrecompiledInitializer());
   Thread* thread = Thread::Current();
   StackZone zone(thread);
 
   ParsedFunction* parsed_function = Parser::ParseStaticFieldInitializer(field);
 
   parsed_function->AllocateVariables();
   DartCompilationPipeline pipeline;
   PrecompileParsedFunctionHelper helper(parsed_function,
                                         /* optimized = */ true);
   bool success = helper.Compile(&pipeline);
@@ skipping 322 matching lines @@
           fname = function.name();
           if (function.IsSetterFunction() ||
               function.IsImplicitSetterFunction()) {
             AddNameToFunctionsTable(zone(), &table, fname, function);
           } else if (function.IsGetterFunction() ||
                      function.IsImplicitGetterFunction()) {
             // Enter both getter and non getter name.
             AddNameToFunctionsTable(zone(), &table, fname, function);
             fname = Field::NameFromGetter(fname);
             AddNameToFunctionsTable(zone(), &table, fname, function);
+          } else if (function.IsMethodExtractor()) {
+            // Skip. We already add getter names for regular methods below.
+            continue;
           } else {
             // Regular function. Enter both getter and non getter name.
             AddNameToFunctionsTable(zone(), &table, fname, function);
             fname = Field::GetterName(fname);
             AddNameToFunctionsTable(zone(), &table, fname, function);
           }
         }
       }
     }
   }
@@ skipping 27 matching lines @@
     THR_Print("%" Pd " of %" Pd " dynamic selectors are unique\n",
         functions_set.NumOccupied(), table.NumOccupied());
   }
 
   isolate()->object_store()->set_unique_dynamic_targets(
       functions_set.Release());
   table.Release();
 }
 
 
-void Precompiler::GetUniqueDynamicTarget(Isolate* isolate,
-                                         const String& fname,
-                                         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++) {
@@ skipping 1561 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