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

runtime/bin/main.cc

 // Copyright (c) 2012, 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 <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 115 matching lines @@
 // Exit code indicating an unhandled error that is not a compilation error.
 static const int kErrorExitCode = 255;
 // Exit code indicating a vm restart request.  Never returned to the user.
 static const int kRestartRequestExitCode = 1000;
 
 static void ErrorExit(int exit_code, const char* format, ...) {
   va_list arguments;
   va_start(arguments, format);
   Log::VPrintErr(format, arguments);
   va_end(arguments);
-  fflush(stderr);
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   char* error = Dart_Cleanup();
   if (error != NULL) {
     Log::PrintErr("VM cleanup failed: %s\n", error);
@@ skipping 1444 matching lines @@
     // lookup the main entry point exported from the root library.
     IsolateData* isolate_data =
         reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
     result = Dart_LibraryImportLibrary(isolate_data->builtin_lib(), root_lib,
                                        Dart_Null());
     if (is_noopt || (gen_snapshot_kind == kAppAOT) ||
         (gen_snapshot_kind == kAppJIT)) {
       // Load the embedder's portion of the VM service's Dart code so it will
       // be included in the app snapshot.
       if (!VmService::LoadForGenPrecompiled()) {
-        fprintf(stderr, "VM service loading failed: %s\n",
-                VmService::GetErrorMessage());
-        fflush(stderr);
+        Log::PrintErr("VM service loading failed: %s\n",
+                      VmService::GetErrorMessage());
         exit(kErrorExitCode);
       }
     }
 
     if (compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
     }
 
     if (parse_all) {
@@ skipping 227 matching lines @@
       Platform::Exit(kErrorExitCode);
     }
   }
 
   Thread::InitOnce();
 
   Loader::InitOnce();
 
   if (!DartUtils::SetOriginalWorkingDirectory()) {
     OSError err;
-    fprintf(stderr, "Error determining current directory: %s\n", err.message());
-    fflush(stderr);
+    Log::PrintErr("Error determining current directory: %s\n", err.message());
     Platform::Exit(kErrorExitCode);
   }
 
   const uint8_t* instructions_snapshot = NULL;
   const uint8_t* data_snapshot = NULL;
 
   if (ReadAppSnapshot(script_name, &vm_isolate_snapshot_buffer,
                       &isolate_snapshot_buffer, &instructions_snapshot,
                       &data_snapshot)) {
     run_app_snapshot = true;
@@ skipping 40 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;
   init_params.get_service_assets = GetVMServiceAssetsArchiveCallback;
 
   char* error = Dart_Initialize(&init_params);
   if (error != NULL) {
     EventHandler::Stop();
-    fprintf(stderr, "VM initialization failed: %s\n", error);
-    fflush(stderr);
+    Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     Platform::Exit(kErrorExitCode);
   }
 
   Dart_RegisterIsolateServiceRequestCallback("getIO", &ServiceGetIOHandler,
                                              NULL);
   Dart_SetServiceStreamCallbacks(&ServiceStreamListenCallback,
                                  &ServiceStreamCancelCallback);
   Dart_SetFileModifiedCallback(&FileModifiedCallback);
 
@@ skipping 32 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }