Read platform.dill in 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 16 matching lines @@
 #include "bin/utils.h"
 #include "bin/vmservice_impl.h"
 #include "platform/globals.h"
 #include "platform/growable_array.h"
 #include "platform/hashmap.h"
 #include "platform/text_buffer.h"
 #if !defined(DART_PRECOMPILER)
 #include "zlib/zlib.h"
 #endif
 
+#include "vm/kernel.h"
+
 namespace dart {
 namespace bin {
 
 // Snapshot pieces if we link in a snapshot, otherwise initialized to NULL.
 extern const uint8_t* vm_snapshot_data;
 extern const uint8_t* vm_snapshot_instructions;
 extern const uint8_t* core_isolate_snapshot_data;
 extern const uint8_t* core_isolate_snapshot_instructions;
 
 /**
@@ skipping 13 matching lines @@
   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;
+
 // 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 246 matching lines @@
   if (filename[0] == '\0') {
     return false;
   }
   use_dart_frontend = true;
   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;
+  return true;
+}
+
+
 static bool ProcessUseBlobsOption(const char* arg,
                                   CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   use_blobs = true;
   return true;
 }
 
@@ skipping 204 matching lines @@
     {"--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},
     {"--dfe=", ProcessFrontendOption},
+    {"--platform=", ProcessPlatformOption},
     {"--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 276 matching lines @@
       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);
     }
   }
 #endif
 
-  const uint8_t* kernel_file = NULL;
-  intptr_t kernel_length = -1;
-  bool is_kernel = false;
+  void* kernel_platform = NULL;
+  void* kernel_program = NULL;
+  if (!is_kernel_isolate && !is_service_isolate) {
+    const uint8_t* platform_file = NULL;
+    if (use_platform_binary) {
+      intptr_t platform_length = -1;
+      bool success = TryReadKernel(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);
+    }
 
-  if (!is_kernel_isolate && !is_service_isolate) {
+    bool is_kernel = false;
+    const uint8_t* kernel_file = NULL;
+    intptr_t kernel_length = -1;
     if (use_dart_frontend) {
       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;
-          return NULL;
+          break;
         case Dart_KernelCompilationStatus_Crash:
           *exit_code = kDartFrontendErrorExitCode;
-          return NULL;
+          break;
         case Dart_KernelCompilationStatus_Unknown:
           *exit_code = kErrorExitCode;
-          return NULL;
+          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);
     }
-  }
 
-  void* kernel_program = NULL;
-  if (is_kernel) {
-    kernel_program = Dart_ReadKernelBinary(kernel_file, kernel_length);
+    if (is_kernel) {
+      kernel_program = Dart_ReadKernelBinary(kernel_file, kernel_length);
+    }
   }
 
   IsolateData* isolate_data =
       new IsolateData(script_uri, package_root, packages_config, app_snapshot);
   if (is_main_isolate && (snapshot_deps_filename != NULL)) {
     isolate_data->set_dependencies(new MallocGrowableArray<char*>());
   }
-  // If the script is a Kernel binary, then we will try to bootstrap from the
-  // script.
   Dart_Isolate isolate =
-      is_kernel ? Dart_CreateIsolateFromKernel(script_uri, main, kernel_program,
-                                               flags, isolate_data, error)
-                : Dart_CreateIsolate(script_uri, main, isolate_snapshot_data,
-                                     isolate_snapshot_instructions, flags,
-                                     isolate_data, error);
+      kernel_platform != NULL
+          ? Dart_CreateIsolateFromKernel(script_uri, main, kernel_platform,
+                                         flags, isolate_data, error)
+          : Dart_CreateIsolate(script_uri, main, isolate_snapshot_data,
+                               isolate_snapshot_instructions, flags,
+                               isolate_data, error);
   if (isolate == NULL) {
     delete isolate_data;
     return NULL;
   }
 
   Dart_EnterScope();
 
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   CHECK_RESULT(result);
 
-  if (is_kernel) {
+  if (kernel_program != NULL) {
     Dart_Handle result = Dart_LoadKernel(kernel_program);
     CHECK_RESULT(result);
   }
-  if (is_kernel || (isolate_snapshot_data != NULL)) {
+  if ((kernel_platform != NULL) || (isolate_snapshot_data != NULL)) {
     // Setup the native resolver as the snapshot does not carry it.
     Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
     Builtin::SetNativeResolver(Builtin::kIOLibrary);
   }
   if (isolate_run_app_snapshot) {
     Dart_Handle result = Loader::ReloadNativeExtensions();
     CHECK_RESULT(result);
   }
 
   if (Dart_IsServiceIsolate(isolate)) {
@@ skipping 49 matching lines @@
       CHECK_RESULT(result);
       ASSERT(app_script_uri == NULL);
       app_script_uri = strdup(resolved_script_uri);
     }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
   } else {
     // Load the specified application script into the newly created isolate.
     Dart_Handle uri =
         DartUtils::ResolveScript(Dart_NewStringFromCString(script_uri));
     CHECK_RESULT(uri);
-    if (!is_kernel) {
+    if (kernel_platform == NULL) {
       result = Loader::LibraryTagHandler(Dart_kScriptTag, Dart_Null(), uri);
       CHECK_RESULT(result);
     } else {
       // Various core-library parts will send requests to the Loader to resolve
       // relative URIs and perform other related tasks. We need Loader to be
       // initialized for this to work because loading from Kernel binary
       // bypasses normal source code loading paths that initialize it.
       Loader::InitForSnapshot(script_uri);
     }
 
@@ skipping 718 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }