1. Dynamic compute the main closure that needs to be run by the main isolate

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 328 matching lines @@
   return true;
 }
 
 
 Precompiler::Precompiler(Thread* thread)
     : thread_(thread),
       zone_(NULL),
       isolate_(thread->isolate()),
       jit_feedback_(NULL),
       changed_(false),
+      retain_root_library_caches_(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())),
@@ skipping 323 matching lines @@
     {"dart:isolate", "::", "_runPendingImmediateCallback"},
 #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);
+  const Library& lib = Library::Handle(I->object_store()->root_library());
+  const String& name = String::Handle(String::New("main"));
+  const Object& main_closure = Object::Handle(lib.GetFunctionClosure(name));
+  if (main_closure.IsClosure()) {
+    if (lib.LookupLocalFunction(name) == Function::null()) {
+      // Check whether the function is in exported namespace of library, in
+      // this case we have to retain the root library caches.
+      if (lib.LookupFunctionAllowPrivate(name) != Function::null() ||
+          lib.LookupReExport(name) != Object::null()) {
+        retain_root_library_caches_ = true;
+      }
+    }
+    AddConstObject(Closure::Cast(main_closure));
+  } else if (main_closure.IsError()) {
+    const Error& error = Error::Cast(main_closure);
+    String& msg =
+        String::Handle(Z, String::NewFormatted("Cannot find main closure %s\n",
+                                               error.ToErrorCString()));
+    Jump(Error::Handle(Z, ApiError::New(msg)));
+    UNREACHABLE();
+  }
 }
 
 
 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);
@@ skipping 1319 matching lines @@
           continue;
         }
       } else if (entry.IsLibraryPrefix()) {
         // Always drop.
       } else {
         FATAL1("Unexpected library entry: %s", entry.ToCString());
       }
       dict.SetAt(j, Object::null_object());
     }
     lib.RehashDictionary(dict, used * 4 / 3 + 1);
-    lib.DropDependenciesAndCaches();
+    if (!(retain_root_library_caches_ &&
+          (lib.raw() == I->object_store()->root_library()))) {
+      lib.DropDependenciesAndCaches();
+    }
   }
 }
 
 
 void Precompiler::DropClasses() {
   Class& cls = Class::Handle(Z);
   Array& constants = Array::Handle(Z);
 
 #if defined(DEBUG)
   // We are about to remove classes from the class table. For this to be safe,
@@ skipping 1322 matching lines @@
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   DartPrecompilationPipeline pipeline(zone, field_type_map);
   return PrecompileFunctionHelper(precompiler, &pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart