Revert "Remove V8_HOST_CAN_READ_UNALIGNED and its uses."

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 662 matching lines @@
   }
 };
 
 
 // Compare 8bit/16bit chars to 8bit/16bit chars.
 template <typename lchar, typename rchar>
 inline int CompareCharsUnsigned(const lchar* lhs,
                                 const rchar* rhs,
                                 int chars) {
   const lchar* limit = lhs + chars;
+#ifdef V8_HOST_CAN_READ_UNALIGNED
   if (sizeof(*lhs) == sizeof(*rhs)) {
-    return memcmp(lhs, rhs, sizeof(*lhs) * chars);
+    // Number of characters in a uintptr_t.
+    static const int kStepSize = sizeof(uintptr_t) / sizeof(*lhs);  // NOLINT
+    while (lhs <= limit - kStepSize) {
+      if (*reinterpret_cast<const uintptr_t*>(lhs) !=
+          *reinterpret_cast<const uintptr_t*>(rhs)) {
+        break;
+      }
+      lhs += kStepSize;
+      rhs += kStepSize;
+    }
   }
+#endif
   while (lhs < limit) {
     int r = static_cast<int>(*lhs) - static_cast<int>(*rhs);
     if (r != 0) return r;
     ++lhs;
     ++rhs;
   }
   return 0;
 }
 
 template<typename lchar, typename rchar>
@@ skipping 572 matching lines @@
       CopyCharsUnsigned(reinterpret_cast<uint16_t*>(dest),
                         reinterpret_cast<const uint16_t*>(src),
                         chars);
     }
   }
 }
 
 template <typename sourcechar, typename sinkchar>
 void CopyCharsUnsigned(sinkchar* dest, const sourcechar* src, int chars) {
   sinkchar* limit = dest + chars;
+#ifdef V8_HOST_CAN_READ_UNALIGNED
   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++);
+    return;
+  }
+#endif
+  while (dest < limit) {
+    *dest++ = static_cast<sinkchar>(*src++);
   }
 }
 
 
 #if defined(V8_HOST_ARCH_ARM)
 void CopyCharsUnsigned(uint8_t* dest, const uint8_t* src, int chars) {
   switch (static_cast<unsigned>(chars)) {
     case 0:
       break;
     case 1:
@@ skipping 159 matching lines @@
   // Takes the address of the limit variable in order to find out where
   // the top of stack is right now.
   uintptr_t limit = reinterpret_cast<uintptr_t>(&limit);
   return limit;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_UTILS_H_