Changes to make isolate reload functionality work with the --dfe option.

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"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
+#include "bin/dfe.h"
 #include "bin/directory.h"
 #include "bin/embedded_dart_io.h"
 #include "bin/error_exit.h"
 #include "bin/eventhandler.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
 #include "bin/isolate_data.h"
 #include "bin/loader.h"
 #include "bin/log.h"
 #include "bin/platform.h"
@@ skipping 47 matching lines @@
 static bool vm_run_app_snapshot = false;
 static const char* snapshot_filename = NULL;
 enum SnapshotKind {
   kNone,
   kScript,
   kAppAOT,
   kAppJIT,
 };
 static SnapshotKind gen_snapshot_kind = kNone;
 static const char* snapshot_deps_filename = NULL;
-
-static bool use_dart_frontend = false;
-
-static const char* frontend_filename = NULL;
-
-// True if the VM should boostrap the SDK from a binary (.dill) file.  The
-// filename points into an argv buffer and does not need to be freed.
-static bool use_platform_binary = false;
-static const char* platform_binary_filename = NULL;
+#if !defined(DART_PRECOMPILED_RUNTIME)
+DFE dfe;
+#endif
 
 // Value of the --save-feedback flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* save_feedback_filename = NULL;
 
 // Value of the --load-feedback flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* load_feedback_filename = NULL;
@@ skipping 233 matching lines @@
                                   CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   parse_all = true;
   return true;
 }
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 static bool ProcessFrontendOption(const char* filename,
                                   CommandLineOptions* vm_options) {
   ASSERT(filename != NULL);
   if (filename[0] == '\0') {
     return false;
   }
-  use_dart_frontend = true;
-  frontend_filename = filename;
+  dfe.set_frontend_filename(filename);
   vm_options->AddArgument("--use-dart-frontend");
   return true;
 }
 
 
 static bool ProcessPlatformOption(const char* filename,
                                   CommandLineOptions* vm_options) {
   ASSERT(filename != NULL);
   if (filename[0] == '\0') {
     return false;
   }
-  use_platform_binary = true;
-  platform_binary_filename = filename;
+  dfe.set_platform_binary_filename(filename);
   return true;
 }
+#endif
 
 
 static bool ProcessUseBlobsOption(const char* arg,
                                   CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   use_blobs = true;
   return true;
@@ skipping 205 matching lines @@
     {"--help", ProcessHelpOption},
     {"--packages=", ProcessPackagesOption},
     {"--package-root=", ProcessPackageRootOption},
     {"-v", ProcessVerboseOption},
     {"--verbose", ProcessVerboseOption},
     {"--version", ProcessVersionOption},
 
     // VM specific options to the standalone dart program.
     {"--compile_all", ProcessCompileAllOption},
     {"--parse_all", ProcessParseAllOption},
+#if !defined(DART_PRECOMPILED_RUNTIME)
     {"--dfe=", ProcessFrontendOption},
     {"--platform=", ProcessPlatformOption},
+#endif
     {"--enable-vm-service", ProcessEnableVmServiceOption},
     {"--disable-service-origin-check", ProcessDisableServiceOriginCheckOption},
     {"--observe", ProcessObserveOption},
     {"--snapshot=", ProcessSnapshotFilenameOption},
     {"--snapshot-kind=", ProcessSnapshotKindOption},
     {"--snapshot-depfile=", ProcessSnapshotDepsFilenameOption},
     {"--use-blobs", ProcessUseBlobsOption},
     {"--save-feedback=", ProcessSaveFeedbackOption},
     {"--load-feedback=", ProcessLoadFeedbackOption},
     {"--trace-loading", ProcessTraceLoadingOption},
@@ skipping 227 matching lines @@
 // Returns newly created Isolate on success, NULL on failure.
 static Dart_Isolate CreateIsolateAndSetupHelper(bool is_main_isolate,
                                                 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 is_kernel_isolate =
-      strcmp(script_uri, DART_KERNEL_ISOLATE_NAME) == 0;
-  if (is_kernel_isolate) {
-    if (!use_dart_frontend) {
-      *error = strdup("Kernel isolate not supported.");
-      return NULL;
-    }
-    script_uri = frontend_filename;
-    if (packages_config == NULL) {
-      packages_config = commandline_packages_file;
-    }
-  }
-
   void* kernel_platform = NULL;
   void* kernel_program = NULL;
   AppSnapshot* app_snapshot = NULL;
 
 #if defined(DART_PRECOMPILED_RUNTIME)
   // AOT: All isolates start from the app snapshot.
   bool isolate_run_app_snapshot = true;
   const uint8_t* isolate_snapshot_data = app_isolate_snapshot_data;
   const uint8_t* isolate_snapshot_instructions =
       app_isolate_snapshot_instructions;
 #else
   // JIT: Main isolate starts from the app snapshot, if any. Other isolates
   // use the core libraries snapshot.
   bool isolate_run_app_snapshot = false;
   const uint8_t* isolate_snapshot_data = core_isolate_snapshot_data;
   const uint8_t* isolate_snapshot_instructions =
       core_isolate_snapshot_instructions;
+  const bool is_kernel_isolate =
+      strcmp(script_uri, DART_KERNEL_ISOLATE_NAME) == 0;
+  if (is_kernel_isolate) {
+    if (!dfe.UseDartFrontend()) {
+      *error = strdup("Kernel isolate not supported.");
+      return NULL;
+    }
+    script_uri = dfe.frontend_filename();
+    if (packages_config == NULL) {
+      packages_config = commandline_packages_file;
+    }
+  }
   if ((app_isolate_snapshot_data != NULL) &&
       (is_main_isolate || ((app_script_uri != NULL) &&
                            (strcmp(script_uri, app_script_uri) == 0)))) {
     isolate_run_app_snapshot = true;
     isolate_snapshot_data = app_isolate_snapshot_data;
     isolate_snapshot_instructions = app_isolate_snapshot_instructions;
   } else if (!is_main_isolate) {
     app_snapshot = Snapshot::TryReadAppSnapshot(script_uri);
     if (app_snapshot != NULL) {
       isolate_run_app_snapshot = true;
       const uint8_t* ignore_vm_snapshot_data;
       const uint8_t* ignore_vm_snapshot_instructions;
       app_snapshot->SetBuffers(
           &ignore_vm_snapshot_data, &ignore_vm_snapshot_instructions,
           &isolate_snapshot_data, &isolate_snapshot_instructions);
     }
   }
   const bool is_service_isolate =
       strcmp(script_uri, DART_VM_SERVICE_ISOLATE_NAME) == 0;
   if (!is_kernel_isolate && !is_service_isolate) {
     const uint8_t* platform_file = NULL;
-    if (use_platform_binary) {
+    if (dfe.UsePlatformBinary()) {
       intptr_t platform_length = -1;
-      bool success = TryReadKernel(platform_binary_filename, &platform_file,
-                                   &platform_length);
+      bool success = dfe.TryReadKernelFile(dfe.platform_binary_filename(),
+                                           &platform_file, &platform_length);
       if (!success) {
         *error = strdup("The platform binary is not a valid Dart Kernel file.");
         *exit_code = kErrorExitCode;
         return NULL;
       }
       kernel_platform = Dart_ReadKernelBinary(platform_file, platform_length);
     }
 
     bool is_kernel = false;
     const uint8_t* kernel_file = NULL;
     intptr_t kernel_length = -1;
-    if (use_dart_frontend) {
+    if (dfe.UseDartFrontend()) {
       Dart_KernelCompilationResult result = Dart_CompileToKernel(script_uri);
       *error = result.error;  // Copy error message (if any).
       switch (result.status) {
         case Dart_KernelCompilationStatus_Ok:
           is_kernel = true;
           kernel_file = result.kernel;
           kernel_length = result.kernel_size;
           break;
         case Dart_KernelCompilationStatus_Error:
           *exit_code = kCompilationErrorExitCode;
           break;
         case Dart_KernelCompilationStatus_Crash:
           *exit_code = kDartFrontendErrorExitCode;
           break;
         case Dart_KernelCompilationStatus_Unknown:
           *exit_code = kErrorExitCode;
           break;
       }
       if (!is_kernel) {
         free(const_cast<uint8_t*>(platform_file));
         delete reinterpret_cast<kernel::Program*>(kernel_platform);
         return NULL;
       }
     } else if (!isolate_run_app_snapshot) {
-      is_kernel = TryReadKernel(script_uri, &kernel_file, &kernel_length);
+      is_kernel =
+          dfe.TryReadKernelFile(script_uri, &kernel_file, &kernel_length);
     }
 
     if (is_kernel) {
       kernel_program = Dart_ReadKernelBinary(kernel_file, kernel_length);
     }
   }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
   IsolateData* isolate_data =
       new IsolateData(script_uri, package_root, packages_config, app_snapshot);
@@ skipping 830 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }