VM support for running Kernel binaries.

runtime/bin/dartutils.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 "bin/dartutils.h"
 
 #include "bin/crypto.h"
 #include "bin/directory.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
@@ skipping 28 matching lines @@
 const char* const DartUtils::kBuiltinLibURL = "dart:_builtin";
 const char* const DartUtils::kCoreLibURL = "dart:core";
 const char* const DartUtils::kInternalLibURL = "dart:_internal";
 const char* const DartUtils::kIsolateLibURL = "dart:isolate";
 const char* const DartUtils::kIOLibURL = "dart:io";
 const char* const DartUtils::kIOLibPatchURL = "dart:io-patch";
 const char* const DartUtils::kUriLibURL = "dart:uri";
 const char* const DartUtils::kHttpScheme = "http:";
 const char* const DartUtils::kVMServiceLibURL = "dart:vmservice";
 
-const uint8_t DartUtils::magic_number[] = { 0xf5, 0xf5, 0xdc, 0xdc };
+
+struct MagicNumberData {
+  static const intptr_t kLength = 4;
+
+  const uint8_t bytes[kLength];
+  bool should_skip;
+};
+
+
+MagicNumberData snapshot_magic_number = { { 0xf5, 0xf5, 0xdc, 0xdc }, true };
+MagicNumberData kernel_magic_number = { {0x90, 0xab, 0xcd, 0xef}, false };
+
+
+bool TryReadKernel(const char* script_uri,
+                   const uint8_t** kernel_file,
+                   intptr_t* kernel_length) {
+  *kernel_file = NULL;
+  *kernel_length = -1;
+  bool is_kernel_file = false;
+  void* script_file = DartUtils::OpenFile(script_uri, false);
+  if (script_file != NULL) {
+    const uint8_t* buffer = NULL;
+    DartUtils::ReadFile(&buffer, kernel_length, script_file);
+    DartUtils::CloseFile(script_file);
+    if (*kernel_length > 0 && buffer != NULL) {
+      *kernel_file = buffer;
+      if (DartUtils::SniffForMagicNumber(&buffer, kernel_length) !=
+              DartUtils::kKernelMagicNumber) {
+        free(const_cast<uint8_t*>(buffer));
+        *kernel_file = NULL;
+      } else {
+        // Do not free buffer if this is a kernel file - kernel_file will be
+        // backed by the same memory as the buffer and caller will own it.
+        // Caller is responsible for freeing the buffer when this function
+        // returns true.
+        is_kernel_file = true;
+      }
+    }
+  }
+  return is_kernel_file;
+}
 
 
 static bool IsWindowsHost() {
 #if defined(TARGET_OS_WINDOWS)
   return true;
 #else  // defined(TARGET_OS_WINDOWS)
   return false;
 #endif  // defined(TARGET_OS_WINDOWS)
 }
 
@@ skipping 400 matching lines @@
                                      extension_path,
                                      library);
   }
 
   // Handle 'import' or 'part' requests for all other URIs. Call dart code to
   // read the source code asynchronously.
   return LoadDataAsync_Invoke(Dart_NewInteger(tag), url, library_url);
 }
 
 
-const uint8_t* DartUtils::SniffForMagicNumber(const uint8_t* text_buffer,
-                                              intptr_t* buffer_len,
-                                              bool* is_snapshot) {
-  intptr_t len = sizeof(magic_number);
-  if (*buffer_len <= len) {
-    *is_snapshot = false;
-    return text_buffer;
+static bool CheckMagicNumber(const uint8_t** buf,
+                             intptr_t* len,
+                             const MagicNumberData& magic_number) {
+  if ((*len >= MagicNumberData::kLength) &&
+      (memcmp(*buf, magic_number.bytes, MagicNumberData::kLength) == 0)) {
+    if (magic_number.should_skip) {
+      *buf += MagicNumberData::kLength;
+      *len -= MagicNumberData::kLength;
+    }
+    return true;
   }
-  for (intptr_t i = 0; i < len; i++) {
-    if (text_buffer[i] != magic_number[i]) {
-      *is_snapshot = false;
-      return text_buffer;
-    }
+  return false;
+}
+
+
+DartUtils::MagicNumber DartUtils::SniffForMagicNumber(const uint8_t** buf,
+                                           intptr_t* len) {
+  if (CheckMagicNumber(buf, len, snapshot_magic_number)) {
+    return kSnapshotMagicNumber;
   }
-  *is_snapshot = true;
-  ASSERT(*buffer_len > len);
-  *buffer_len -= len;
-  return text_buffer + len;
+
+  if (CheckMagicNumber(buf, len, kernel_magic_number)) {
+    return kKernelMagicNumber;
+  }
+
+  return kUnknownMagicNumber;
 }
 
 
 void DartUtils::WriteMagicNumber(File* file) {
   // Write a magic number and version information into the snapshot file.
-  bool bytes_written = file->WriteFully(magic_number, sizeof(magic_number));
+  bool bytes_written = file->WriteFully(snapshot_magic_number.bytes,
+                                        MagicNumberData::kLength);
   ASSERT(bytes_written);
 }
 
 
 Dart_Handle DartUtils::LoadScript(const char* script_uri) {
   Dart_TimelineEvent("LoadScript",
                      Dart_TimelineGetMicros(),
                      Dart_GetMainPortId(),
                      Dart_Timeline_Event_Async_Begin,
                      0, NULL, NULL);
@@ skipping 47 matching lines @@
     // If the buffer is not external, take a copy.
     buffer_copy = reinterpret_cast<uint8_t*>(malloc(num_bytes));
     memmove(buffer_copy, data, num_bytes);
     data = buffer_copy;
   }
 
   Dart_TypedDataReleaseData(source_data);
 
   if (Dart_IsNull(tag_in) && Dart_IsNull(library_uri)) {
     // Entry file. Check for payload and load accordingly.
-    bool is_snapshot = false;
-    const uint8_t *payload =
-        DartUtils::SniffForMagicNumber(data, &num_bytes, &is_snapshot);
+    const uint8_t* payload = data;
+    const DartUtils::MagicNumber payload_type =
+        DartUtils::SniffForMagicNumber(&payload, &num_bytes);
 
-    if (is_snapshot) {
+    if (payload_type == DartUtils::kSnapshotMagicNumber) {
       result = Dart_LoadScriptFromSnapshot(payload, num_bytes);
+    } else if (payload_type == DartUtils::kKernelMagicNumber) {
+      UNREACHABLE();
     } else {
       Dart_Handle source = Dart_NewStringFromUTF8(data, num_bytes);
       if (Dart_IsError(source)) {
         result = DartUtils::NewError("%s is not a valid UTF-8 script",
                                      resolved_script_uri);
       } else {
         result = Dart_LoadScript(resolved_script_uri, Dart_Null(),
                                  source, 0, 0);
       }
     }
@@ skipping 686 matching lines @@
       new CObjectString(CObject::NewString(os_error->message()));
   CObjectArray* result = new CObjectArray(CObject::NewArray(3));
   result->SetAt(0, new CObjectInt32(CObject::NewInt32(kOSError)));
   result->SetAt(1, new CObjectInt32(CObject::NewInt32(os_error->code())));
   result->SetAt(2, error_message);
   return result;
 }
 
 }  // namespace bin
 }  // namespace dart