The function CopyCharsUnsigned(uint8_t* dest, const uint8_t* src, size_t chars) is now a specializa…

src/utils.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.
 
 #ifndef V8_UTILS_H_
 #define V8_UTILS_H_
 
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 423 matching lines @@
 
 // Copy memory area. No restrictions.
 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.
 V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
   MemMove(dest, src, size);
 }
+#elif defined(V8_TARGET_ARCH_X64)
+// Limit below which the extra overhead of the MemCopy function is likely
+// to outweigh the benefits of faster copying.
+const int kMinComplexMemCopy = 8;
+
+// Copy memory area to disjoint memory area.
+V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
+  memcpy(dest, src, size);
+}
+V8_INLINE void MemMove(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);
 extern MemCopyUint8Function memcopy_uint8_function;
 V8_INLINE 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.
 const int kMinComplexMemCopy = 16;
@@ skipping 693 matching lines @@
                             bool* exists,
                             bool verbose = true);
 Vector<const char> ReadFile(FILE* file,
                             bool* exists,
                             bool verbose = true);
 
 
 template <typename sourcechar, typename sinkchar>
 INLINE(static void CopyCharsUnsigned(sinkchar* dest, const sourcechar* src,
                                      size_t chars));
-#if defined(V8_HOST_ARCH_ARM)
+#if defined(V8_HOST_ARCH_X64)
+INLINE(void CopyCharsUnsigned(uint8_t* dest, const uint8_t* src, size_t chars));
+#elif defined(V8_HOST_ARCH_ARM)
 INLINE(void CopyCharsUnsigned(uint8_t* dest, const uint8_t* src, size_t chars));
 INLINE(void CopyCharsUnsigned(uint16_t* dest, const uint8_t* src,
                               size_t chars));
 INLINE(void CopyCharsUnsigned(uint16_t* dest, const uint16_t* src,
                               size_t chars));
 #elif defined(V8_HOST_ARCH_MIPS)
 INLINE(void CopyCharsUnsigned(uint8_t* dest, const uint8_t* src, size_t chars));
 INLINE(void CopyCharsUnsigned(uint16_t* dest, const uint16_t* src,
                               size_t chars));
 #elif defined(V8_HOST_ARCH_PPC) || defined(V8_HOST_ARCH_S390)
@@ skipping 38 matching lines @@
   sinkchar* limit = dest + chars;
   if ((sizeof(*dest) == sizeof(*src)) &&
       (chars >= static_cast<int>(kMinComplexMemCopy / sizeof(*dest)))) {
     MemCopy(dest, src, chars * sizeof(*dest));
   } else {
     while (dest < limit) *dest++ = static_cast<sinkchar>(*src++);
   }
 }
 
 
-#if defined(V8_HOST_ARCH_ARM)
+#if defined(V8_HOST_ARCH_X64)
+void CopyCharsUnsigned(uint8_t* dest, const uint8_t* src, size_t chars) {
+  uint8_t* limit = dest + chars;
+  if (chars >= static_cast<int>(kMinComplexMemCopy / sizeof(*dest))) {
+    MemCopy(dest, src, chars * sizeof(*dest));
+  } else {
+    while (dest < limit) *dest++ = *src++;
+  }
+}
+#elif defined(V8_HOST_ARCH_ARM)
 void CopyCharsUnsigned(uint8_t* dest, const uint8_t* src, size_t chars) {
   switch (static_cast<unsigned>(chars)) {
     case 0:
       break;
     case 1:
       *dest = *src;
       break;
     case 2:
       memcpy(dest, src, 2);
       break;
@@ skipping 360 matching lines @@
   byte* dst = reinterpret_cast<byte*>(p);
   for (size_t i = 0; i < sizeof(V); i++) {
     dst[i] = src[sizeof(V) - i - 1];
   }
 #endif  // V8_TARGET_LITTLE_ENDIAN
 }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_UTILS_H_