[VM] Allow run_vm_tests to load like we do in normal dart

Our build files use non-appjit snapshots for kernel-service for
certain architectures, e.g. simulators.

Issue #31585

Change-Id: I5162b8fe266f97710c50c347ae20b53cd66cf75d
Reviewed-on: https://dart-review.googlesource.com/29240
Commit-Queue: Martin Kustermann <[email protected]>
Reviewed-by: Vyacheslav Egorov <[email protected]>

Author: mkustermann

runtime/bin/dartutils.cc

@@ -20,6 +20,7 @@
 #include "platform/assert.h"
 #include "platform/globals.h"
 #include "platform/memory_sanitizer.h"
+#include "platform/utils.h"
 
 // Return the error from the containing function if handle is in error handle.
 #define RETURN_IF_ERROR(handle)                                                \
@@ -49,13 +50,7 @@ const char* const DartUtils::kUriLibURL = "dart:uri";
 const char* const DartUtils::kHttpScheme = "http:";
 const char* const DartUtils::kVMServiceLibURL = "dart:vmservice";
 
-struct MagicNumberData {
-  static const intptr_t kMaxLength = 4;
-
-  intptr_t length;
-  const uint8_t bytes[kMaxLength];
-};
-
+MagicNumberData appjit_magic_number = {8, {0xdc, 0xdc, 0xf6, 0xf6, 0, 0, 0, 0}};
 MagicNumberData snapshot_magic_number = {4, {0xf5, 0xf5, 0xdc, 0xdc}};
 MagicNumberData kernel_magic_number = {4, {0x90, 0xab, 0xcd, 0xef}};
 MagicNumberData gzip_magic_number = {2, {0x1f, 0x8b, 0, 0}};
@@ -356,12 +351,41 @@ static bool CheckMagicNumber(const uint8_t* buffer,
   return false;
 }
 
+DartUtils::MagicNumber DartUtils::SniffForMagicNumber(const char* filename) {
+  MagicNumber magic_number = DartUtils::kUnknownMagicNumber;
+  if (File::GetType(NULL, filename, true) == File::kIsFile) {
+    File* file = File::Open(NULL, filename, File::kRead);
+    if (file != NULL) {
+      intptr_t max_magic_length = 0;
+      max_magic_length =
+          Utils::Maximum(max_magic_length, snapshot_magic_number.length);
+      max_magic_length =
+          Utils::Maximum(max_magic_length, appjit_magic_number.length);
+      max_magic_length =
+          Utils::Maximum(max_magic_length, kernel_magic_number.length);
+      max_magic_length =
+          Utils::Maximum(max_magic_length, gzip_magic_number.length);
+      ASSERT(max_magic_length <= 8);
+      uint8_t header[8];
+      if (file->ReadFully(&header, max_magic_length)) {
+        magic_number = DartUtils::SniffForMagicNumber(header, sizeof(header));
+      }
+      file->Close();
+    }
+  }
+  return magic_number;
+}
+
 DartUtils::MagicNumber DartUtils::SniffForMagicNumber(const uint8_t* buffer,
                                                       intptr_t buffer_length) {
   if (CheckMagicNumber(buffer, buffer_length, snapshot_magic_number)) {
     return kSnapshotMagicNumber;
   }
 
+  if (CheckMagicNumber(buffer, buffer_length, appjit_magic_number)) {
+    return kAppJITMagicNumber;
+  }
+
   if (CheckMagicNumber(buffer, buffer_length, kernel_magic_number)) {
     return kKernelMagicNumber;
   }
@@ -370,6 +394,10 @@ DartUtils::MagicNumber DartUtils::SniffForMagicNumber(const uint8_t* buffer,
     return kGzipMagicNumber;
   }
 
+  if (CheckMagicNumber(buffer, buffer_length, gzip_magic_number)) {
+    return kGzipMagicNumber;
+  }
+
   return kUnknownMagicNumber;
 }
 

runtime/bin/dartutils.h

@@ -202,11 +202,15 @@ class DartUtils {
 
   enum MagicNumber {
     kSnapshotMagicNumber,
+    kAppJITMagicNumber,
     kKernelMagicNumber,
     kGzipMagicNumber,
     kUnknownMagicNumber
   };
 
+  // Checks if the buffer is a script snapshot, kernel file, or gzip file.
+  static MagicNumber SniffForMagicNumber(const char* filename);
+
   // Checks if the buffer is a script snapshot, kernel file, or gzip file.
   static MagicNumber SniffForMagicNumber(const uint8_t* text_buffer,
                                          intptr_t buffer_len);
@@ -644,6 +648,18 @@ class ScopedMemBuffer {
   DISALLOW_COPY_AND_ASSIGN(ScopedMemBuffer);
 };
 
+struct MagicNumberData {
+  static const intptr_t kMaxLength = 8;
+
+  intptr_t length;
+  const uint8_t bytes[kMaxLength];
+};
+
+extern MagicNumberData appjit_magic_number;
+extern MagicNumberData snapshot_magic_number;
+extern MagicNumberData kernel_magic_number;
+extern MagicNumberData gzip_magic_number;
+
 }  // namespace bin
 }  // namespace dart
 

runtime/bin/run_vm_tests.cc

@@ -137,25 +137,33 @@ static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
   }
   script_uri = kernel_snapshot;
 
-  bin::AppSnapshot* app_snapshot =
-      bin::Snapshot::TryReadAppSnapshot(script_uri);
-  if (app_snapshot == NULL) {
-    *error = strdup("Failed to read kernel service app snapshot");
-    return NULL;
-  }
-
+  // Kernel isolate uses an app snapshot or the core libraries snapshot.
+  bool isolate_run_script_snapshot = false;
   const uint8_t* isolate_snapshot_data = bin::core_isolate_snapshot_data;
   const uint8_t* isolate_snapshot_instructions =
       bin::core_isolate_snapshot_instructions;
-
-  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);
-
+  bin::AppSnapshot* app_snapshot = NULL;
+  switch (bin::DartUtils::SniffForMagicNumber(script_uri)) {
+    case bin::DartUtils::kAppJITMagicNumber: {
+      app_snapshot = bin::Snapshot::TryReadAppSnapshot(script_uri);
+      ASSERT(app_snapshot != NULL);
+
+      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);
+      break;
+    }
+    case bin::DartUtils::kSnapshotMagicNumber: {
+      isolate_run_script_snapshot = true;
+      break;
+    }
+    default:
+      return NULL;
+  }
   bin::IsolateData* isolate_data = new bin::IsolateData(
-      script_uri, package_root, packages_config, NULL /* app_snapshot */);
+      script_uri, package_root, packages_config, app_snapshot);
   Dart_Isolate isolate = Dart_CreateIsolate(
       DART_KERNEL_ISOLATE_NAME, main, isolate_snapshot_data,
       isolate_snapshot_instructions, flags, isolate_data, error);
@@ -167,6 +175,18 @@ static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
 
   Dart_EnterScope();
 
+  if (isolate_run_script_snapshot) {
+    const uint8_t* payload;
+    intptr_t payload_length;
+    void* file = bin::DartUtils::OpenFile(script_uri, false);
+    bin::DartUtils::ReadFile(&payload, &payload_length, file);
+    bin::DartUtils::CloseFile(file);
+
+    bin::DartUtils::SkipSnapshotMagicNumber(&payload, &payload_length);
+    Dart_Handle result = Dart_LoadScriptFromSnapshot(payload, payload_length);
+    CHECK_RESULT(result);
+  }
+
   bin::DartUtils::SetOriginalWorkingDirectory();
   Dart_Handle result = bin::DartUtils::PrepareForScriptLoading(
       false /* is_service_isolate */, false /* trace_loading */);

runtime/bin/snapshot_utils.cc

@@ -21,7 +21,6 @@ extern const char* kIsolateSnapshotDataSymbolName;
 extern const char* kIsolateSnapshotInstructionsSymbolName;
 
 static const int64_t kAppSnapshotHeaderSize = 5 * kInt64Size;
-static const int64_t kAppSnapshotMagicNumber = 0xf6f6dcdc;
 static const int64_t kAppSnapshotPageSize = 4 * KB;
 
 class MappedAppSnapshot : public AppSnapshot {
@@ -86,7 +85,9 @@ static AppSnapshot* TryReadAppSnapshotBlobs(const char* script_name) {
     file->Release();
     return NULL;
   }
-  if (header[0] != kAppSnapshotMagicNumber) {
+  ASSERT(sizeof(header[0]) == appjit_magic_number.length);
+  if (memcmp(&header[0], appjit_magic_number.bytes,
+             appjit_magic_number.length) != 0) {
     file->Release();
     return NULL;
   }
@@ -287,7 +288,7 @@ static void WriteAppSnapshot(const char* filename,
     ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n", filename);
   }
 
-  file->WriteFully(&kAppSnapshotMagicNumber, sizeof(kAppSnapshotMagicNumber));
+  file->WriteFully(appjit_magic_number.bytes, appjit_magic_number.length);
   WriteInt64(file, vm_data_size);
   WriteInt64(file, vm_instructions_size);
   WriteInt64(file, isolate_data_size);