Add ./tools/test.py -c precompiler -r dart_precompiled.

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 52 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;
 
 
+// Value of the --gen/run_precompiled_snapshot flag.
+// (This pointer points into an argv buffer and does not need to be
+// free'd.)
+static const char* precompiled_snapshot_directory = NULL;
+
+
 // 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";
@@ skipping 213 matching lines @@
     return false;
   }
   has_compile_all = true;
   return true;
 }
 
 
 static bool ProcessGenPrecompiledSnapshotOption(
     const char* arg,
     CommandLineOptions* vm_options) {
-  ASSERT(arg != NULL);
-  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;
   }
+  ASSERT(arg != NULL);
+  precompiled_snapshot_directory = arg;
+  if ((precompiled_snapshot_directory[0] == '=') ||
+      (precompiled_snapshot_directory[0] == ':')) {
+    precompiled_snapshot_directory = &precompiled_snapshot_directory[1];
+  }
   has_gen_precompiled_snapshot = true;
   vm_options->AddArgument("--precompilation");
   return true;
 }
 
 
 static bool ProcessRunPrecompiledSnapshotOption(
     const char* arg,
     CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
-  if (*arg != '\0') {
-    return false;
+  precompiled_snapshot_directory = arg;
+  if ((precompiled_snapshot_directory[0] == '=') ||
+      (precompiled_snapshot_directory[0] == ':')) {
+    precompiled_snapshot_directory = &precompiled_snapshot_directory[1];
   }
   has_run_precompiled_snapshot = true;
   vm_options->AddArgument("--precompilation");
   return true;
 }
 
 
 static bool ProcessNooptOption(
     const char* arg,
     CommandLineOptions* vm_options) {
@@ skipping 665 matching lines @@
 
 static void ServiceStreamCancelCallback(const char* stream_id) {
   if (strcmp(stream_id, kStdoutStreamId) == 0) {
     SetCaptureStdout(false);
   } else if (strcmp(stream_id, kStderrStreamId) == 0) {
     SetCaptureStderr(false);
   }
 }
 
 
-static void WriteSnapshotFile(const char* filename,
-                              const uint8_t* buffer,
-                              const intptr_t size) {
-  File* file = File::Open(filename, File::kWriteTruncate);
+static void WritePrecompiledSnapshotFile(const char* filename,
+                                         const uint8_t* buffer,
+                                         const intptr_t size) {
+  const char* qualified_filename;
+  if (strlen(precompiled_snapshot_directory) > 0) {
+    intptr_t len = snprintf(NULL, 0, "%s/%s",
+                            precompiled_snapshot_directory, filename);
+    char* concat = reinterpret_cast<char*>(alloca(len + 1));

[Florian Schneider, 2015/12/17 12:53:25]

I would avoid alloca - it is not standard C++, and there seems no performance
reason for not using new/delete.

[rmacnak, 2015/12/17 19:20:51]

Done.

+    snprintf(concat, len + 1, "%s/%s",
+             precompiled_snapshot_directory, filename);
+    qualified_filename = concat;
+  } else {
+    qualified_filename = filename;
+  }
+
+  File* file = File::Open(qualified_filename, File::kWriteTruncate);
   ASSERT(file != NULL);
   if (!file->WriteFully(buffer, size)) {
     ErrorExit(kErrorExitCode,
               "Unable to open file %s for writing snapshot\n",
-              filename);
+              qualified_filename);
   }
   delete file;
 }
 
 
-static void ReadSnapshotFile(const char* filename,
-                             const uint8_t** buffer) {
-  void* file = DartUtils::OpenFile(filename, false);
+static void ReadPrecompiledSnapshotFile(const char* filename,
+                                        const uint8_t** buffer) {
+  const char* qualified_filename;
+  if (strlen(precompiled_snapshot_directory) > 0) {
+    intptr_t len = snprintf(NULL, 0, "%s/%s",
+                            precompiled_snapshot_directory, filename);
+    char* concat = reinterpret_cast<char*>(alloca(len + 1));

[Florian Schneider, 2015/12/17 12:53:25]

Same here. Maybe something like this:

char* concat = NULL;

...

concat = new char[len + 1];

...

if (concat != NULL) delete[] concat;

[rmacnak, 2015/12/17 19:20:51]

Done.

+    snprintf(concat, len + 1, "%s/%s",
+             precompiled_snapshot_directory, filename);
+    qualified_filename = concat;
+  } else {
+    qualified_filename = filename;
+  }
+
+  void* file = DartUtils::OpenFile(qualified_filename, false);
   if (file == NULL) {
     ErrorExit(kErrorExitCode,
-              "Error: Unable to open file %s for reading snapshot\n", filename);
+              "Error: Unable to open file %s for reading snapshot\n",
+              qualified_filename);
   }
   intptr_t len = -1;
   DartUtils::ReadFile(buffer, &len, file);
   if (*buffer == NULL || len == -1) {
     ErrorExit(kErrorExitCode,
-              "Error: Unable to read snapshot file %s\n", filename);
+              "Error: Unable to read snapshot file %s\n", qualified_filename);
   }
   DartUtils::CloseFile(file);
 }
 
 
 static void* LoadLibrarySymbol(const char* libname, const char* symname) {
   void* library = Extensions::LoadExtensionLibrary(libname);
   if (library == NULL) {
     Log::PrintErr("Error: Failed to load library '%s'\n", libname);
     Platform::Exit(kErrorExitCode);
@@ skipping 160 matching lines @@
       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,
                                               &instructions_buffer,
                                               &instructions_size);
       CHECK_RESULT(result);
-      WriteSnapshotFile(kPrecompiledVmIsolateName,
-                        vm_isolate_buffer,
-                        vm_isolate_size);
-      WriteSnapshotFile(kPrecompiledIsolateName,
-                        isolate_buffer,
-                        isolate_size);
-      WriteSnapshotFile(kPrecompiledInstructionsName,
-                        instructions_buffer,
-                        instructions_size);
+      WritePrecompiledSnapshotFile(kPrecompiledVmIsolateName,
+                                   vm_isolate_buffer,
+                                   vm_isolate_size);
+      WritePrecompiledSnapshotFile(kPrecompiledIsolateName,
+                                   isolate_buffer,
+                                   isolate_size);
+      WritePrecompiledSnapshotFile(kPrecompiledInstructionsName,
+                                   instructions_buffer,
+                                   instructions_size);
     } else {
       if (has_compile_all) {
         result = Dart_CompileAll();
         CHECK_RESULT(result);
       }
 
       if (Dart_IsNull(root_lib)) {
         ErrorExit(kErrorExitCode,
                   "Unable to find root library for '%s'\n",
                   script_name);
@@ skipping 109 matching lines @@
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Start event handler.
   EventHandler::Start();
 
   const uint8_t* instructions_snapshot = NULL;
   if (has_run_precompiled_snapshot) {
     instructions_snapshot = reinterpret_cast<const uint8_t*>(
         LoadLibrarySymbol(kPrecompiledLibraryName, kPrecompiledSymbolName));
-    ReadSnapshotFile(kPrecompiledVmIsolateName, &vm_isolate_snapshot_buffer);
-    ReadSnapshotFile(kPrecompiledIsolateName, &isolate_snapshot_buffer);
+    ReadPrecompiledSnapshotFile(kPrecompiledVmIsolateName,
+                                &vm_isolate_snapshot_buffer);
+    ReadPrecompiledSnapshotFile(kPrecompiledIsolateName,
+                                &isolate_snapshot_buffer);
   }
 
   // Initialize the Dart VM.
   char* error = Dart_Initialize(
       vm_isolate_snapshot_buffer, instructions_snapshot,
       CreateIsolateAndSetup, NULL, NULL, ShutdownIsolate,
       DartUtils::OpenFile,
       DartUtils::ReadFile,
       DartUtils::WriteFile,
       DartUtils::CloseFile,
@@ skipping 50 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }