Remove dart_noopt and related parts from the VM.

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 79 matching lines @@
 // dart functions and not run anything.
 static bool compile_all = false;
 static bool parse_all = false;
 
 
 // Global flag that is used to indicate that we want to use blobs/mmap instead
 // of assembly/shared libraries for precompilation.
 static bool use_blobs = 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.
-// Always set this with dart_noopt.
-#if defined(DART_PRECOMPILER) && !defined(DART_NO_SNAPSHOT)
-static const bool is_noopt = true;
-#else
-static const bool is_noopt = false;
-#endif
-
-
 extern const char* kPrecompiledVMIsolateSymbolName;
 extern const char* kPrecompiledIsolateSymbolName;
 extern const char* kPrecompiledInstructionsSymbolName;
 extern const char* kPrecompiledDataSymbolName;
 
 
 // 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 trace_loading = false;
 
@@ skipping 602 matching lines @@
   if ((commandline_package_root != NULL) &&
       (strlen(commandline_package_root) == 0)) {
     Log::PrintErr("Empty package root specified.\n");
     return -1;
   }
   if ((commandline_packages_file != NULL) &&
       (strlen(commandline_packages_file) == 0)) {
     Log::PrintErr("Empty package file name specified.\n");
     return -1;
   }
-  if (is_noopt && gen_snapshot_kind != kNone) {
-    Log::PrintErr("Generating a snapshot with dart_noopt is invalid.\n");
-    return -1;
-  }
   if ((gen_snapshot_kind != kNone) && (snapshot_filename == NULL)) {
     Log::PrintErr("Generating a snapshot requires a filename (--snapshot).\n");
     return -1;
   }
   if ((gen_snapshot_kind != kNone) && run_app_snapshot) {
     Log::PrintErr(
         "Specifying an option to generate a snapshot and"
         " run using a snapshot is invalid.\n");
     return -1;
   }
@@ skipping 76 matching lines @@
 
 // Returns true on success, false on failure.
 static Dart_Isolate CreateIsolateAndSetupHelper(const char* script_uri,
                                                 const char* main,
                                                 const char* package_root,
                                                 const char* packages_config,
                                                 Dart_IsolateFlags* flags,
                                                 char** error,
                                                 int* exit_code) {
   ASSERT(script_uri != NULL);
-
-  const bool needs_load_port = true;
-#if defined(PRODUCT)
-  const bool run_service_isolate = needs_load_port;
-#else
-  // Always create the service isolate in DEBUG and RELEASE modes for profiling,
-  // even if we don't need it for loading.
-  const bool run_service_isolate = true;
-#endif  // PRODUCT
-  if (!run_service_isolate &&
-      (strcmp(script_uri, DART_VM_SERVICE_ISOLATE_NAME) == 0)) {
-    return NULL;
-  }
   if (strcmp(script_uri, DART_KERNEL_ISOLATE_NAME) == 0) {
     if (!use_dart_frontend) {
       *error = strdup("Kernel isolate not supported.");
       return NULL;
     } else {
       if (packages_config == NULL) {
         packages_config = commandline_packages_file;
       }
     }
   }
@@ skipping 62 matching lines @@
     Dart_ExitIsolate();
     return isolate;
   }
 
   // Prepare builtin and other core libraries for use to resolve URIs.
   // Set up various closures, e.g: printing, timers etc.
   // Set up 'package root' for URI resolution.
   result = DartUtils::PrepareForScriptLoading(false, trace_loading);
   CHECK_RESULT(result);
 
-  if (needs_load_port) {
-    // Set up the load port provided by the service isolate so that we can
-    // load scripts.
-    result = DartUtils::SetupServiceLoadPort();
-    CHECK_RESULT(result);
-  }
+  // Set up the load port provided by the service isolate so that we can
+  // load scripts.
+  result = DartUtils::SetupServiceLoadPort();
+  CHECK_RESULT(result);
 
   if (Dart_IsKernelIsolate(isolate)) {
     script_uri = frontend_filename;
   }
 
   // Setup package root if specified.
   result = DartUtils::SetupPackageRoot(package_root, packages_config);
   CHECK_RESULT(result);
 
   result = Dart_SetEnvironmentCallback(EnvironmentCallback);
@@ skipping 708 matching lines @@
     GenerateScriptSnapshot();
   } 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.
     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)) {
+    if ((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()) {
         Log::PrintErr("VM service loading failed: %s\n",
                       VmService::GetErrorMessage());
         exit(kErrorExitCode);
       }
     }
 
     if (compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
     }
 
     if (parse_all) {
       result = Dart_ParseAll();
       CHECK_RESULT(result);
       Dart_ExitScope();
       // Shutdown the isolate.
       Dart_ShutdownIsolate();
       return false;
     }
 
-    if (is_noopt || (gen_snapshot_kind == kAppAOT)) {
+    if (gen_snapshot_kind == kAppAOT) {
       Dart_QualifiedFunctionName standalone_entry_points[] = {
           {"dart:_builtin", "::", "_getMainClosure"},
           {"dart:_builtin", "::", "_getPrintClosure"},
           {"dart:_builtin", "::", "_getUriBaseClosure"},
           {"dart:_builtin", "::", "_resolveInWorkingDirectory"},
           {"dart:_builtin", "::", "_setWorkingDirectory"},
           {"dart:_builtin", "::", "_setPackageRoot"},
           {"dart:_builtin", "::", "_setPackagesMap"},
           {"dart:_builtin", "::", "_libraryFilePath"},
           {"dart:io", "::", "_makeUint8ListView"},
@@ skipping 32 matching lines @@
           ErrorExit(kErrorExitCode, "Failed to read JIT feedback.\n");
         }
         feedback_length = file->Length();
         feedback_buffer = reinterpret_cast<uint8_t*>(malloc(feedback_length));
         if (!file->ReadFully(feedback_buffer, feedback_length)) {
           ErrorExit(kErrorExitCode, "Failed to read JIT feedback.\n");
         }
         file->Release();
       }
 
-      const bool reset_fields = gen_snapshot_kind == kAppAOT;
-      result = Dart_Precompile(standalone_entry_points, reset_fields,
-                               feedback_buffer, feedback_length);
+      result = Dart_Precompile(standalone_entry_points, feedback_buffer,
+                               feedback_length);
       if (feedback_buffer != NULL) {
         free(feedback_buffer);
       }
       CHECK_RESULT(result);
     }
 
     if (gen_snapshot_kind == kAppAOT) {
       GeneratePrecompiledSnapshot();
     } else {
       if (Dart_IsNull(root_lib)) {
@@ skipping 207 matching lines @@
     vm_options.AddArgument("--load_deferred_eagerly");
   }
 #endif
 
   if (gen_snapshot_kind == kAppJIT) {
     vm_options.AddArgument("--fields_may_be_reset");
 #if !defined(PRODUCT)
     vm_options.AddArgument("--collect_code=false");
 #endif
   }
-  if ((gen_snapshot_kind == kAppAOT) || is_noopt) {
+  if (gen_snapshot_kind == kAppAOT) {
     vm_options.AddArgument("--precompilation");
   }
 #if defined(DART_PRECOMPILED_RUNTIME)
   vm_options.AddArgument("--precompilation");
 #endif
   if (gen_snapshot_kind == kAppJIT) {
     Process::SetExitHook(SnapshotOnExitHook);
   }
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
@@ skipping 67 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }