Implement File::Map on Windows.

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 1216 matching lines @@
       Utils::RoundUp(vmisolate_position + header[1], kAppSnapshotPageSize);
   int64_t rodata_position =
       Utils::RoundUp(isolate_position + header[2], kAppSnapshotPageSize);
   int64_t instructions_position =
       Utils::RoundUp(rodata_position + header[3], kAppSnapshotPageSize);
 
   void* read_only_buffer =
     file->Map(File::kReadOnly, vmisolate_position,
               instructions_position - vmisolate_position);
   if (read_only_buffer == NULL) {
-    ErrorExit(kErrorExitCode, "Failed to memory map snapshot\n");
+    Log::PrintErr("Failed to memory map snapshot\n");
+    Platform::Exit(kErrorExitCode);
   }
 
   *vmisolate_buffer = reinterpret_cast<const uint8_t*>(read_only_buffer)
       + (vmisolate_position - vmisolate_position);
   *isolate_buffer = reinterpret_cast<const uint8_t*>(read_only_buffer)
       + (isolate_position - vmisolate_position);
   if (header[3] == 0) {
     *rodata_buffer = NULL;
   } else {
     *rodata_buffer = reinterpret_cast<const uint8_t*>(read_only_buffer)
         + (rodata_position - vmisolate_position);
   }
 
   if (header[4] == 0) {
     *instructions_buffer = NULL;
   } else {
     *instructions_buffer = reinterpret_cast<const uint8_t*>(
         file->Map(File::kReadExecute, instructions_position, header[4]));
     if (*instructions_buffer == NULL) {
-      ErrorExit(kErrorExitCode, "Failed to memory map snapshot2\n");
+      Log::PrintErr("Failed to memory map snapshot\n");
+      Platform::Exit(kErrorExitCode);
     }
   }
 
   file->Release();
   return true;
 }
 
 
 static bool ReadAppSnapshotDynamicLibrary(const char* script_name,
                                           const uint8_t** vmisolate_buffer,
                                           const uint8_t** isolate_buffer,
                                           const uint8_t** instructions_buffer,
                                           const uint8_t** rodata_buffer) {
   void* library = Extensions::LoadExtensionLibrary(script_name);
   if (library == NULL) {
     return false;
   }
 
   *vmisolate_buffer = reinterpret_cast<const uint8_t*>(
       Extensions::ResolveSymbol(library, kPrecompiledVMIsolateSymbolName));
   if (*vmisolate_buffer == NULL) {
-    ErrorExit(kErrorExitCode, "Failed to resolve symbol '%s'\n",
-              kPrecompiledVMIsolateSymbolName);
+    Log::PrintErr("Failed to resolve symbol '%s'\n",
+                  kPrecompiledVMIsolateSymbolName);
+    Platform::Exit(kErrorExitCode);
   }
 
   *isolate_buffer = reinterpret_cast<const uint8_t*>(
       Extensions::ResolveSymbol(library, kPrecompiledIsolateSymbolName));
   if (*isolate_buffer == NULL) {
-    ErrorExit(kErrorExitCode, "Failed to resolve symbol '%s'\n",
-              kPrecompiledIsolateSymbolName);
+    Log::PrintErr("Failed to resolve symbol '%s'\n",
+                  kPrecompiledIsolateSymbolName);
+    Platform::Exit(kErrorExitCode);
   }
 
   *instructions_buffer = reinterpret_cast<const uint8_t*>(
       Extensions::ResolveSymbol(library, kPrecompiledInstructionsSymbolName));
   if (*instructions_buffer == NULL) {
-    ErrorExit(kErrorExitCode, "Failed to resolve symbol '%s'\n",
-              kPrecompiledInstructionsSymbolName);
+    Log::PrintErr("Failed to resolve symbol '%s'\n",
+                  kPrecompiledInstructionsSymbolName);
+    Platform::Exit(kErrorExitCode);
   }
 
   *rodata_buffer = reinterpret_cast<const uint8_t*>(
       Extensions::ResolveSymbol(library, kPrecompiledDataSymbolName));
   if (*rodata_buffer == NULL) {
-    ErrorExit(kErrorExitCode, "Failed to resolve symbol '%s'\n",
-              kPrecompiledDataSymbolName);
+    Log::PrintErr("Failed to resolve symbol '%s'\n",
+                  kPrecompiledDataSymbolName);
+    Platform::Exit(kErrorExitCode);
   }
 
   return true;
 }
 
 
 static bool ReadAppSnapshot(const char* script_name,
                             const uint8_t** vmisolate_buffer,
                             const uint8_t** isolate_buffer,
                             const uint8_t** instructions_buffer,
@@ skipping 637 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }