Move OS::MemCopy and OS::MemMove out of platform to utils

src/platform.h

 // 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.
 
 // This module contains the platform-specific code. This make the rest of the
 // code less dependent on operating system, compilers and runtime libraries.
 // This module does specifically not deal with differences between different
 // processor architecture.
 // The platform classes have the same definition for all platforms. The
 // implementation for a particular platform is put in platform_<os>.cc.
@@ skipping 121 matching lines @@
 
 // ----------------------------------------------------------------------------
 // OS
 //
 // This class has static methods for the different platform specific
 // functions. Add methods here to cope with differences between the
 // supported platforms.
 
 class OS {
  public:
-  // Initializes the platform OS support that depend on CPU features. This is
-  // called after CPU initialization.
-  static void PostSetUp();
-
   // Returns the accumulated user time for thread. This routine
   // can be used for profiling. The implementation should
   // strive for high-precision timer resolution, preferable
   // micro-second resolution.
   static int GetUserTime(uint32_t* secs,  uint32_t* usecs);
 
   // Returns current time as the number of milliseconds since
   // 00:00:00 UTC, January 1, 1970.
   static double TimeCurrentMillis();
 
@@ skipping 129 matching lines @@
   static double nan_value();
 
   // Support runtime detection of whether the hard float option of the
   // EABI is used.
   static bool ArmUsingHardFloat();
 
   // Returns the activation frame alignment constraint or zero if
   // the platform doesn't care. Guaranteed to be a power of two.
   static int ActivationFrameAlignment();
 
-#if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_X87)
-  // Limit below which the extra overhead of the MemCopy function is likely
-  // to outweigh the benefits of faster copying.
-  static const int kMinComplexMemCopy = 64;
-
-  // Copy memory area. No restrictions.
-  static void MemMove(void* dest, const void* src, size_t size);
-  typedef void (*MemMoveFunction)(void* dest, const void* src, size_t size);
-
-  // Keep the distinction of "move" vs. "copy" for the benefit of other
-  // architectures.
-  static void MemCopy(void* dest, const void* src, size_t size) {
-    MemMove(dest, src, size);
-  }
-#elif defined(V8_HOST_ARCH_ARM)
-  typedef void (*MemCopyUint8Function)(uint8_t* dest,
-                                       const uint8_t* src,
-                                       size_t size);
-  static MemCopyUint8Function memcopy_uint8_function;
-  static void MemCopyUint8Wrapper(uint8_t* dest,
-                                  const uint8_t* src,
-                                  size_t chars) {
-    memcpy(dest, src, chars);
-  }
-  // For values < 16, the assembler function is slower than the inlined C code.
-  static const int kMinComplexMemCopy = 16;
-  static void MemCopy(void* dest, const void* src, size_t size) {
-    (*memcopy_uint8_function)(reinterpret_cast<uint8_t*>(dest),
-                              reinterpret_cast<const uint8_t*>(src),
-                              size);
-  }
-  static void MemMove(void* dest, const void* src, size_t size) {
-    memmove(dest, src, size);
-  }
-
-  typedef void (*MemCopyUint16Uint8Function)(uint16_t* dest,
-                                             const uint8_t* src,
-                                             size_t size);
-  static MemCopyUint16Uint8Function memcopy_uint16_uint8_function;
-  static void MemCopyUint16Uint8Wrapper(uint16_t* dest,
-                                        const uint8_t* src,
-                                        size_t chars);
-  // For values < 12, the assembler function is slower than the inlined C code.
-  static const int kMinComplexConvertMemCopy = 12;
-  static void MemCopyUint16Uint8(uint16_t* dest,
-                                 const uint8_t* src,
-                                 size_t size) {
-    (*memcopy_uint16_uint8_function)(dest, src, size);
-  }
-#elif defined(V8_HOST_ARCH_MIPS)
-  typedef void (*MemCopyUint8Function)(uint8_t* dest,
-                                       const uint8_t* src,
-                                       size_t size);
-  static MemCopyUint8Function memcopy_uint8_function;
-  static void MemCopyUint8Wrapper(uint8_t* dest,
-                                  const uint8_t* src,
-                                  size_t chars) {
-    memcpy(dest, src, chars);
-  }
-  // For values < 16, the assembler function is slower than the inlined C code.
-  static const int kMinComplexMemCopy = 16;
-  static void MemCopy(void* dest, const void* src, size_t size) {
-    (*memcopy_uint8_function)(reinterpret_cast<uint8_t*>(dest),
-                              reinterpret_cast<const uint8_t*>(src),
-                              size);
-  }
-  static void MemMove(void* dest, const void* src, size_t size) {
-    memmove(dest, src, size);
-  }
-#else
-  // Copy memory area to disjoint memory area.
-  static void MemCopy(void* dest, const void* src, size_t size) {
-    memcpy(dest, src, size);
-  }
-  static void MemMove(void* dest, const void* src, size_t size) {
-    memmove(dest, src, size);
-  }
-  static const int kMinComplexMemCopy = 16 * kPointerSize;
-#endif  // V8_TARGET_ARCH_IA32
-
   static int GetCurrentProcessId();
 
  private:
   static const int msPerSecond = 1000;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(OS);
 };
 
 // Represents and controls an area of reserved memory.
 // Control of the reserved memory can be assigned to another VirtualMemory
@@ skipping 199 matching lines @@
   char name_[kMaxThreadNameLength];
   int stack_size_;
   Semaphore* start_semaphore_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_PLATFORM_H_