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 1136 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 (sizeof(*dest) == sizeof(*src)) {

[Jakob Kummerow, 2016/08/30 13:29:28]

Well, this check is pretty pointless, because always sizeof(*dest) ==
sizeof(*src) == sizeof(uint8_t) == 1.

Comparing this with the function right above, it seems what you really want is
to change the value of kMinComplexMemCopy (to 0?) on x64. Why don't you just do
that?

+    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_