Revert 21502 - "Move OS::MemCopy and OS::MemMove out of platform to utils"

src/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.
@@ skipping 89 matching lines @@
 #endif  // __MINGW32__
 
 namespace v8 {
 namespace internal {
 
 intptr_t OS::MaxVirtualMemory() {
   return 0;
 }
 
 
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
+static void MemMoveWrapper(void* dest, const void* src, size_t size) {
+  memmove(dest, src, size);
+}
+
+
+// Initialize to library version so we can call this at any time during startup.
+static OS::MemMoveFunction memmove_function = &MemMoveWrapper;
+
+// Defined in codegen-ia32.cc.
+OS::MemMoveFunction CreateMemMoveFunction();
+
+// Copy memory area to disjoint memory area.
+void OS::MemMove(void* dest, const void* src, size_t size) {
+  if (size == 0) return;
+  // Note: here we rely on dependent reads being ordered. This is true
+  // on all architectures we currently support.
+  (*memmove_function)(dest, src, size);
+}
+
+#endif  // V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
+
+
 class TimezoneCache {
  public:
   TimezoneCache() : initialized_(false) { }
 
   void Clear() {
     initialized_ = false;
   }
 
   // Initialize timezone information. The timezone information is obtained from
   // windows. If we cannot get the timezone information we fall back to CET.
@@ skipping 302 matching lines @@
 
 // Returns a string identifying the current timezone for the
 // timestamp taking into account daylight saving.
 char* Win32Time::LocalTimezone(TimezoneCache* cache) {
   // Return the standard or DST time zone name based on whether daylight
   // saving is in effect at the given time.
   return InDST(cache) ? cache->dst_tz_name_ : cache->std_tz_name_;
 }
 
 
+void OS::PostSetUp() {
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
+  OS::MemMoveFunction generated_memmove = CreateMemMoveFunction();
+  if (generated_memmove != NULL) {
+    memmove_function = generated_memmove;
+  }
+#endif
+}
+
+
 // Returns the accumulated user time for thread.
 int OS::GetUserTime(uint32_t* secs,  uint32_t* usecs) {
   FILETIME dummy;
   uint64_t usertime;
 
   // Get the amount of time that the thread has executed in user mode.
   if (!GetThreadTimes(GetCurrentThread(), &dummy, &dummy, &dummy,
                       reinterpret_cast<FILETIME*>(&usertime))) return -1;
 
   // Adjust the resolution to micro-seconds.
@@ skipping 431 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) OS::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 502 matching lines @@
   ASSERT(result);
 }
 
 
 
 void Thread::YieldCPU() {
   Sleep(0);
 }
 
 } }  // namespace v8::internal