Make --noopt behave like an in-place precompilation.

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 63 matching lines @@
 // Global flag that is used to indicate that we want to compile all the
 // dart functions before running main and not compile anything thereafter.
 static bool has_gen_precompiled_snapshot = false;
 
 
 // Global flag that is used to indicate that we want to run from a precompiled
 // snapshot.
 static bool has_run_precompiled_snapshot = false;
 
 
+// Global flag that is used to indicate that we want to compile everything in
+// the same way as precompilation before main, then continue running in the
+// same process.
+static bool has_noopt = false;
+
+
 extern const char* kPrecompiledLibraryName;
 extern const char* kPrecompiledSymbolName;
 static const char* kPrecompiledVmIsolateName = "precompiled.vmisolate";
 static const char* kPrecompiledIsolateName = "precompiled.isolate";
 static const char* kPrecompiledInstructionsName = "precompiled.S";
 
 
 // Global flag that is used to indicate that we want to trace resolution of
 // URIs and the loading of libraries, parts and scripts.
 static bool has_trace_loading = false;
@@ skipping 225 matching lines @@
   if (*arg != '\0') {
     return false;
   }
   // Ensure that we are not already running using a full snapshot.
   if (isolate_snapshot_buffer != NULL) {
     Log::PrintErr("Precompiled snapshots must be generated with"
                   " dart_no_snapshot.\n");
     return false;
   }
   has_gen_precompiled_snapshot = true;
-  vm_options->AddArgument("--precompile");
+  vm_options->AddArgument("--precompilation");
   return true;
 }
 
 
 static bool ProcessRunPrecompiledSnapshotOption(
     const char* arg,
     CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   has_run_precompiled_snapshot = true;
-  vm_options->AddArgument("--precompile");
+  vm_options->AddArgument("--precompilation");
   return true;
 }
 
+
+static bool ProcessNooptOption(
+    const char* arg,
+    CommandLineOptions* vm_options) {
+  ASSERT(arg != NULL);
+  if (*arg != '\0') {
+    return false;
+  }
+  has_noopt = true;
+  vm_options->AddArgument("--precompilation");
+  return true;
+}
+
 
 static bool ProcessDebugOption(const char* option_value,
                                CommandLineOptions* vm_options) {
   ASSERT(option_value != NULL);
   if (!ExtractPortAndIP(option_value, &debug_port, &debug_ip,
                         DEFAULT_DEBUG_PORT, DEFAULT_DEBUG_IP)) {
     Log::PrintErr("unrecognized --debug option syntax. "
                   "Use --debug[:<port number>[/<IPv4 address>]]\n");
     return false;
   }
@@ skipping 120 matching lines @@
   { "-v", ProcessVerboseOption },
   { "--verbose", ProcessVerboseOption },
   { "--version", ProcessVersionOption },
 
   // VM specific options to the standalone dart program.
   { "--break-at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
   { "--debug", ProcessDebugOption },
   { "--enable-vm-service", ProcessEnableVmServiceOption },
   { "--gen-precompiled-snapshot", ProcessGenPrecompiledSnapshotOption },
+  { "--noopt", ProcessNooptOption },
   { "--observe", ProcessObserveOption },
   { "--run-precompiled-snapshot", ProcessRunPrecompiledSnapshotOption },
   { "--shutdown", ProcessShutdownOption },
   { "--snapshot=", ProcessGenScriptSnapshotOption },
   { "--trace-debug-protocol", ProcessTraceDebugProtocolOption },
   { "--trace-loading", ProcessTraceLoadingOption },
   { NULL, NULL }
 };
 
 
@@ skipping 384 matching lines @@
 "--snapshot=<file_name>\n"
 "  loads Dart script and generates a snapshot in the specified file\n"
 "\n"
 "--trace-loading\n"
 "  enables tracing of library and script loading\n"
 "\n"
 "--enable-vm-service[:<port number>]\n"
 "  enables the VM service and listens on specified port for connections\n"
 "  (default port number is 8181)\n"
 "\n"
-"--noopt\n"
-"  run unoptimized code only\n"
-"\n"
 "The following options are only used for VM development and may\n"
 "be changed in any future version:\n");
     const char* print_flags = "--print_flags";
     Dart_SetVMFlags(1, &print_flags);
   }
 }
 
 
 static Dart_Handle SetBreakpoint(const char* breakpoint_at,
                                  Dart_Handle library) {
@@ skipping 344 matching lines @@
   } else {
     // Lookup the library of the root script.
     Dart_Handle root_lib = Dart_RootLibrary();
     // Import the root library into the builtin library so that we can easily
     // lookup the main entry point exported from the root library.
     Dart_Handle builtin_lib =
         Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
     ASSERT(!Dart_IsError(builtin_lib));
     result = Dart_LibraryImportLibrary(builtin_lib, root_lib, Dart_Null());
 
-    if (has_gen_precompiled_snapshot) {
+    if (has_noopt || has_gen_precompiled_snapshot) {
       Dart_QualifiedFunctionName standalone_entry_points[] = {
         { "dart:_builtin", "::", "_getMainClosure" },
         { "dart:_builtin", "::", "_getPrintClosure" },
         { "dart:_builtin", "::", "_getUriBaseClosure" },
         { "dart:_builtin", "::", "_resolveUri" },
         { "dart:_builtin", "::", "_setWorkingDirectory" },
         { "dart:_builtin", "::", "_loadDataAsync" },
         { "dart:io", "::", "_makeUint8ListView" },
         { "dart:io", "::", "_makeDatagram" },
         { "dart:io", "::", "_setupHooks" },
         { "dart:io", "CertificateException", "CertificateException." },
         { "dart:io", "HandshakeException", "HandshakeException." },
         { "dart:io", "TlsException", "TlsException." },
         { "dart:io", "X509Certificate", "X509Certificate." },
         { "dart:io", "_ExternalBuffer", "set:data" },
         { "dart:io", "_Platform", "set:_nativeScript" },
         { "dart:io", "_ProcessStartStatus", "set:_errorCode" },
         { "dart:io", "_ProcessStartStatus", "set:_errorMessage" },
         { "dart:io", "_SecureFilterImpl", "get:ENCRYPTED_SIZE" },
         { "dart:io", "_SecureFilterImpl", "get:SIZE" },
         { "dart:vmservice_io", "::", "_addResource" },
         { "dart:vmservice_io", "::", "main" },
         { NULL, NULL, NULL }  // Must be terminated with NULL entries.
       };
 
-      result = Dart_Precompile(standalone_entry_points);
+      const bool reset_fields = has_gen_precompiled_snapshot;
+      result = Dart_Precompile(standalone_entry_points, reset_fields);
       DartExitOnError(result);
+    }
 
+    if (has_gen_precompiled_snapshot) {
       uint8_t* vm_isolate_buffer = NULL;
       intptr_t vm_isolate_size = 0;
       uint8_t* isolate_buffer = NULL;
       intptr_t isolate_size = 0;
       uint8_t* instructions_buffer = NULL;
       intptr_t instructions_size = 0;
       result = Dart_CreatePrecompiledSnapshot(&vm_isolate_buffer,
                                               &vm_isolate_size,
                                               &isolate_buffer,
                                               &isolate_size,
@@ skipping 95 matching lines @@
   exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }