Move platform abstraction to base library

src/base/platform/platform-win32.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Platform-specific code for Win32.
 
 // Secure API functions are not available using MinGW with msvcrt.dll
 // on Windows XP. Make sure MINGW_HAS_SECURE_API is not defined to
 // disable definition of secure API functions in standard headers that
 // would conflict with our own implementation.
 #ifdef __MINGW32__
 #include <_mingw.h>
 #ifdef MINGW_HAS_SECURE_API
 #undef MINGW_HAS_SECURE_API
 #endif  // MINGW_HAS_SECURE_API
 #endif  // __MINGW32__
 
+#ifdef _MSC_VER
+#include <limits>
+#endif
+
 #include "src/base/win32-headers.h"
 
 #include "src/base/lazy-instance.h"
-#include "src/platform.h"
-#include "src/platform/time.h"
-#include "src/utils.h"
-#include "src/utils/random-number-generator.h"
+#include "src/base/macros.h"
+#include "src/base/platform/platform.h"
+#include "src/base/platform/time.h"
+#include "src/base/utils/random-number-generator.h"
 
 #ifdef _MSC_VER
 
 // Case-insensitive bounded string comparisons. Use stricmp() on Win32. Usually
 // defined in strings.h.
 int strncasecmp(const char* s1, const char* s2, int n) {
   return _strnicmp(s1, s2, n);
 }
 
 #endif  // _MSC_VER
@@ skipping 59 matching lines @@
     }
   }
   CHECK_GT(dest_size, 0);
   *dest = 0;
   return 0;
 }
 
 #endif  // __MINGW32__
 
 namespace v8 {
-namespace internal {
+namespace base {
 
 namespace {
 
 bool g_hard_abort = false;
 
 }  // namespace
 
 intptr_t OS::MaxVirtualMemory() {
   return 0;
 }
@@ skipping 593 matching lines @@
   static size_t allocate_alignment = 0;
   if (allocate_alignment == 0) {
     SYSTEM_INFO info;
     GetSystemInfo(&info);
     allocate_alignment = info.dwAllocationGranularity;
   }
   return allocate_alignment;
 }
 
 
-static base::LazyInstance<RandomNumberGenerator>::type
+static LazyInstance<RandomNumberGenerator>::type
     platform_random_number_generator = LAZY_INSTANCE_INITIALIZER;
 
 
 void OS::Initialize(int64_t random_seed, bool hard_abort,
                     const char* const gc_fake_mmap) {
   if (random_seed) {
     platform_random_number_generator.Pointer()->SetSeed(random_seed);
   }
   g_hard_abort = hard_abort;
 }
@@ skipping 154 matching lines @@
   // Open a physical file
   HANDLE file = CreateFileA(name, GENERIC_READ | GENERIC_WRITE,
       FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, NULL);
   if (file == NULL) return NULL;
   // Create a file mapping for the physical file
   HANDLE file_mapping = CreateFileMapping(file, NULL,
       PAGE_READWRITE, 0, static_cast<DWORD>(size), NULL);
   if (file_mapping == NULL) return NULL;
   // Map a view of the file into memory
   void* memory = MapViewOfFile(file_mapping, FILE_MAP_ALL_ACCESS, 0, 0, size);
-  if (memory) MemMove(memory, initial, size);
+  if (memory) memmove(memory, initial, size);
   return new Win32MemoryMappedFile(file, file_mapping, memory, size);
 }
 
 
 Win32MemoryMappedFile::~Win32MemoryMappedFile() {
   if (memory_ != NULL)
     UnmapViewOfFile(memory_);
   CloseHandle(file_mapping_);
   CloseHandle(file_);
 }
@@ skipping 185 matching lines @@
 
   DWORD options = _SymGetOptions();
   options |= SYMOPT_LOAD_LINES;
   options |= SYMOPT_FAIL_CRITICAL_ERRORS;
   options = _SymSetOptions(options);
 
   char buf[OS::kStackWalkMaxNameLen] = {0};
   ok = _SymGetSearchPath(process_handle, buf, OS::kStackWalkMaxNameLen);
   if (!ok) {
     int err = GetLastError();
-    PrintF("%d\n", err);
+    OS::Print("%d\n", err);
     return result;
   }
 
   HANDLE snapshot = _CreateToolhelp32Snapshot(
       TH32CS_SNAPMODULE,       // dwFlags
       GetCurrentProcessId());  // th32ProcessId
   if (snapshot == INVALID_HANDLE_VALUE) return result;
   MODULEENTRY32W module_entry;
   module_entry.dwSize = sizeof(module_entry);  // Set the size of the structure.
   BOOL cont = _Module32FirstW(snapshot, &module_entry);
@@ skipping 73 matching lines @@
 
 int OS::NumberOfProcessorsOnline() {
   SYSTEM_INFO info;
   GetSystemInfo(&info);
   return info.dwNumberOfProcessors;
 }
 
 
 double OS::nan_value() {
 #ifdef _MSC_VER
-  // Positive Quiet NaN with no payload (aka. Indeterminate) has all bits
-  // in mask set, so value equals mask.
-  static const __int64 nanval = kQuietNaNMask;
-  return *reinterpret_cast<const double*>(&nanval);
+  return std::numeric_limits<double>::quiet_NaN();
 #else  // _MSC_VER
   return NAN;
 #endif  // _MSC_VER
 }
 
 
 int OS::ActivationFrameAlignment() {
 #ifdef _WIN64
   return 16;  // Windows 64-bit ABI requires the stack to be 16-byte aligned.
 #elif defined(__MINGW32__)
@@ skipping 206 matching lines @@
   USE(result);
   ASSERT(result);
 }
 
 
 
 void Thread::YieldCPU() {
   Sleep(0);
 }
 
-} }  // namespace v8::internal
+} }  // namespace v8::base