As an attempt to make String::WriteToFlat faster, I take some effort to optimize

src/v8utils.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 180 matching lines @@
 // Simple support to read a file into a 0-terminated C-string.
 // The returned buffer must be freed by the caller.
 // On return, *exits tells whether the file existed.
 Vector<const char> ReadFile(const char* filename,
                             bool* exists,
                             bool verbose = true);
 Vector<const char> ReadFile(FILE* file,
                             bool* exists,
                             bool verbose = true);
 
+template<typename sourcechar, typename sinkchar>
+static inline void AlignedCharCopy(sinkchar* dest,
+                                   const sourcechar* src, int chars) {
+  #define COPY(offset)    \
+    *(dest+offset) = static_cast<sinkchar>(*(src+offset));
 
+  int div = chars >> 4;
+  while ( div ) {
+    COPY(0)  COPY(1)  COPY(2)  COPY(3)
+    COPY(4)  COPY(5)  COPY(6)  COPY(7)
+    COPY(8)  COPY(9)  COPY(10) COPY(11)
+    COPY(12) COPY(13) COPY(14) COPY(15)
+    dest += 16;
+    src += 16;
+    div--;
+  }
+
+  #define CASE_COPY(N)  \
+    case N : COPY(N-1)
+
+  int mod = chars & 0xF;
+  switch ( mod ) {
+  CASE_COPY(15)  CASE_COPY(14)  CASE_COPY(13)  CASE_COPY(12)
+  CASE_COPY(11)  CASE_COPY(10)  CASE_COPY(9)   CASE_COPY(8)
+  CASE_COPY(7)   CASE_COPY(6)   CASE_COPY(5)   CASE_COPY(4)
+  CASE_COPY(3)   CASE_COPY(2)   CASE_COPY(1)
+  break;
+  }
+
+  #undef CASE_COPY
+  #undef COPY
+}
+
+#ifdef V8_HOST_CAN_READ_UNALIGNED
+template<typename Char>
+static inline void UnalignedCharCopy(Char* dest, const Char* src, int chars) {
+  int size = static_cast<int>(chars * sizeof(Char));
+  if ( size >= OS::kMinComplexMemCopy ) {
+    OS::MemCopy(dest, src, size);
+    return;
+  }
+
+  unsigned int* dest_ = reinterpret_cast<unsigned int*>(dest);
+  const unsigned int* src_  = reinterpret_cast<const unsigned int*>(src);
+  const int cell = size / sizeof(unsigned int);
+
+  #define COPY(offset)    \
+    *(dest_+offset) = *(src_+offset);
+
+  // copy patch cells by 16
+  int div = cell >> 4;
+  while ( div ) {
+    COPY(0)  COPY(1)  COPY(2)  COPY(3)
+    COPY(4)  COPY(5)  COPY(6)  COPY(7)
+    COPY(8)  COPY(9)  COPY(10) COPY(11)
+    COPY(12) COPY(13) COPY(14) COPY(15)
+    dest_ += 16;
+    src_  += 16;
+    div--;
+  }
+
+  #define CASE_COPY(N)  \
+    case N : COPY(N-1)
+
+  // copy left cells
+  int mod = cell & 0xF;
+  switch ( mod ) {
+  CASE_COPY(15) CASE_COPY(14) CASE_COPY(13) CASE_COPY(12)
+  CASE_COPY(11) CASE_COPY(10) CASE_COPY(9)  CASE_COPY(8)
+  CASE_COPY(7)  CASE_COPY(6)  CASE_COPY(5)  CASE_COPY(4)
+  CASE_COPY(3)  CASE_COPY(2)  CASE_COPY(1)
+  dest_ += mod;
+  src_ += mod;
+  break;
+  }
+
+  // copy left chars
+  Char* limit = dest + chars;
+  dest = reinterpret_cast<Char*>(dest_);
+  src  = reinterpret_cast<const Char*>(src_);
+  while ( dest < limit ) {
+    *dest++ = *src++;
+  }
+
+  #undef CASE_COPY
+  #undef COPY
+}
+#endif
+
+template<typename sourcechar, typename sinkchar>
+class CharCopier {
+ public:
+  static void Copy(sinkchar* dest, const sourcechar* src, int chars) {
+    AlignedCharCopy(dest, src, chars);
+  }
+};
+
+template<>
+class CharCopier<char, char> {
+ public:
+  static void Copy(char* dest, const char* src, int chars) {
+  #ifdef V8_HOST_CAN_READ_UNALIGNED
+    UnalignedCharCopy(dest, src, chars);
+  #else
+    AlignedCharCopy(dest, src, chars);
+  #endif
+  }
+};
+
+template<>
+class CharCopier<uc16, uc16> {
+ public:
+  static void Copy(uc16* dest, const uc16* src, int chars) {
+  #ifdef V8_HOST_CAN_READ_UNALIGNED
+    UnalignedCharCopy(dest, src, chars);
+  #else
+    AlignedCharCopy(dest, src, chars);
+  #endif
+  }
+};
 
 // Copy from ASCII/16bit chars to ASCII/16bit chars.
 template <typename sourcechar, typename sinkchar>
-inline void CopyChars(sinkchar* dest, const sourcechar* src, int chars) {
-  sinkchar* limit = dest + chars;
-#ifdef V8_HOST_CAN_READ_UNALIGNED
-  if (sizeof(*dest) == sizeof(*src)) {
-    if (chars >= static_cast<int>(OS::kMinComplexMemCopy / sizeof(*dest))) {
-      OS::MemCopy(dest, src, chars * sizeof(*dest));
-      return;
-    }
-    // Number of characters in a uintptr_t.
-    static const int kStepSize = sizeof(uintptr_t) / sizeof(*dest);  // NOLINT
-    while (dest <= limit - kStepSize) {
-      *reinterpret_cast<uintptr_t*>(dest) =
-          *reinterpret_cast<const uintptr_t*>(src);
-      dest += kStepSize;
-      src += kStepSize;
-    }
+static inline void CopyChars(sinkchar* dest, const sourcechar* src, int chars) {
+  // return faster if chars is small
+  switch ( chars ) {
+  #define CASE_COPY(N)    \
+    case N : *(dest+N-1) = static_cast<sinkchar>(*(src+N-1));
+  CASE_COPY(8) CASE_COPY(7)
+  CASE_COPY(6) CASE_COPY(5)
+  CASE_COPY(4) CASE_COPY(3)
+  CASE_COPY(2) CASE_COPY(1)
+  return;
+  #undef CASE_COPY
   }
-#endif
-  while (dest < limit) {
-    *dest++ = static_cast<sinkchar>(*src++);
-  }
+
+  // fall to copier
+  CharCopier<sourcechar, sinkchar>::Copy(dest, src, chars);
 }
 
 
 // A resource for using mmapped files to back external strings that are read
 // from files.
 class MemoryMappedExternalResource: public
     v8::String::ExternalAsciiStringResource {
  public:
   explicit MemoryMappedExternalResource(const char* filename);
   MemoryMappedExternalResource(const char* filename,
@@ skipping 31 matching lines @@
 
   // Add formatted contents like printf based on a va_list.
   void AddFormattedList(const char* format, va_list list);
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_V8UTILS_H_