Don't include usage counters, etc in snapshots with code. If we already have code, eagerly recompil…

runtime/bin/gen_snapshot.cc

 // Copyright (c) 2013, 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.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 977 matching lines @@
   // |CleanupEntryPointsCollection|
   return entries;
 }
 
 
 static Dart_QualifiedFunctionName* ParseEntryPointsManifestIfPresent() {
   Dart_QualifiedFunctionName* entries = ParseEntryPointsManifestFiles();
   if ((entries == NULL) && IsSnapshottingForPrecompilation()) {
     Log::PrintErr(
         "Could not find native embedder entry points during precompilation\n");
-    exit(255);
+    exit(kErrorExitCode);
   }
   return entries;
 }
 
 
 static void CreateAndWriteSnapshot() {
   ASSERT(!IsSnapshottingForPrecompilation());
   Dart_Handle result;
   uint8_t* vm_isolate_buffer = NULL;
   intptr_t vm_isolate_size = 0;
@@ skipping 65 matching lines @@
 }
 
 
 static void SetupForUriResolution() {
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   if (Dart_IsError(result)) {
     Log::PrintErr("%s", Dart_GetError(result));
     Dart_ExitScope();
     Dart_ShutdownIsolate();
-    exit(255);
+    exit(kErrorExitCode);
   }
   // This is a generic dart snapshot which needs builtin library setup.
   Dart_Handle library =
       LoadGenericSnapshotCreationScript(Builtin::kBuiltinLibrary);
   VerifyLoaded(library);
 }
 
 
 static void SetupForGenericSnapshotCreation() {
   SetupForUriResolution();
 
   Dart_Handle library = LoadGenericSnapshotCreationScript(Builtin::kIOLibrary);
   VerifyLoaded(library);
   Dart_Handle result = Dart_FinalizeLoading(false);
   if (Dart_IsError(result)) {
     const char* err_msg = Dart_GetError(library);
     Log::PrintErr("Errors encountered while loading: %s\n", err_msg);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
-    exit(255);
+    exit(kErrorExitCode);
   }
 }
 
 
 static Dart_Isolate CreateServiceIsolate(const char* script_uri,
                                          const char* main,
                                          const char* package_root,
                                          const char* package_config,
                                          Dart_IsolateFlags* flags,
                                          void* data,
@@ skipping 44 matching lines @@
   CommandLineOptions cmdline_url_mapping(argc);
   DartUtils::url_mapping = &cmdline_url_mapping;
 
   // Initialize the entrypoints array.
   CommandLineOptions entry_points_files_array(argc);
   entry_points_files = &entry_points_files_array;
 
   // Parse command line arguments.
   if (ParseArguments(argc, argv, &vm_options, &app_script_name) < 0) {
     PrintUsage();
-    return 255;
+    return kErrorExitCode;
   }
 
   Thread::InitOnce();
   Loader::InitOnce();
   DartUtils::SetOriginalWorkingDirectory();
   // Start event handler.
   TimerUtils::InitOnce();
   EventHandler::Start();
 
 #if !defined(PRODUCT)
   // Constant true in PRODUCT mode.
   vm_options.AddArgument("--load_deferred_eagerly");
 #endif
 
   if (IsSnapshottingForPrecompilation()) {
     vm_options.AddArgument("--precompilation");
+    vm_options.AddArgument("--print_snapshot_sizes");
 #if TARGET_ARCH_ARM
     // This is for the iPod Touch 5th Generation (and maybe other older devices)
     vm_options.AddArgument("--no-use_integer_division");
 #endif
   }
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Initialize the Dart VM.
   // Note: We don't expect isolates to be created from dart code during
@@ skipping 10 matching lines @@
   init_params.file_open = DartUtils::OpenFile;
   init_params.file_read = DartUtils::ReadFile;
   init_params.file_write = DartUtils::WriteFile;
   init_params.file_close = DartUtils::CloseFile;
   init_params.entropy_source = DartUtils::EntropySource;
 
   char* error = Dart_Initialize(&init_params);
   if (error != NULL) {
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
-    return 255;
+    return kErrorExitCode;
   }
 
   IsolateData* isolate_data = new IsolateData(NULL, commandline_package_root,
                                               commandline_packages_file);
   Dart_Isolate isolate =
       Dart_CreateIsolate(NULL, NULL, NULL, NULL, isolate_data, &error);
   if (isolate == NULL) {
     Log::PrintErr("Error: %s", error);
     free(error);
-    exit(255);
+    exit(kErrorExitCode);
   }
 
   Dart_Handle result;
   Dart_Handle library;
   Dart_EnterScope();
 
   result = Dart_SetEnvironmentCallback(EnvironmentCallback);
   CHECK_RESULT(result);
 
   ASSERT(vm_isolate_snapshot_filename != NULL);
@@ skipping 32 matching lines @@
     const uint8_t* kernel = NULL;
     intptr_t kernel_length = 0;
     const bool is_kernel_file =
         TryReadKernel(app_script_name, &kernel, &kernel_length);
     Dart_Isolate isolate =
         is_kernel_file
             ? Dart_CreateIsolateFromKernel(NULL, NULL, kernel, kernel_length,
                                            NULL, isolate_data, &error)
             : Dart_CreateIsolate(NULL, NULL, NULL, NULL, isolate_data, &error);
     if (isolate == NULL) {
-      fprintf(stderr, "%s", error);
+      Log::PrintErr("%s", error);
       free(error);
-      exit(255);
+      exit(kErrorExitCode);
     }
     Dart_EnterScope();
     result = Dart_SetEnvironmentCallback(EnvironmentCallback);
     CHECK_RESULT(result);
 
     // Set up the library tag handler in such a manner that it will use the
     // URL mapping specified on the command line to load the libraries.
     result = Dart_SetLibraryTagHandler(CreateSnapshotLibraryTagHandler);
     CHECK_RESULT(result);
 
@@ skipping 47 matching lines @@
   EventHandler::Stop();
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }