Replace OS::MemCopy with OS::MemMove (just as fast but more flexible).

src/utils.h

 // Copyright 2012 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 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_UTILS_H_
 #define V8_UTILS_H_
 
 #include <stdlib.h>
 #include <string.h>
 #include <climits>
 
+#include "allocation.h"
+#include "checks.h"
 #include "globals.h"
-#include "checks.h"
-#include "allocation.h"
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // General helper functions
 
 #define IS_POWER_OF_TWO(x) (((x) & ((x) - 1)) == 0)
 
 // Returns true iff x is a power of 2 (or zero). Cannot be used with the
@@ skipping 439 matching lines @@
 
   explicit EmbeddedVector(T initial_value) : Vector<T>(buffer_, kSize) {
     for (int i = 0; i < kSize; ++i) {
       buffer_[i] = initial_value;
     }
   }
 
   // When copying, make underlying Vector to reference our buffer.
   EmbeddedVector(const EmbeddedVector& rhs)
       : Vector<T>(rhs) {
+    // TODO(jkummerow): Refactor #includes and use OS::MemCopy() instead.
     memcpy(buffer_, rhs.buffer_, sizeof(T) * kSize);
     set_start(buffer_);
   }
 
   EmbeddedVector& operator=(const EmbeddedVector& rhs) {
     if (this == &rhs) return *this;
     Vector<T>::operator=(rhs);
+    // TODO(jkummerow): Refactor #includes and use OS::MemCopy() instead.
     memcpy(buffer_, rhs.buffer_, sizeof(T) * kSize);
     this->set_start(buffer_);
     return *this;
   }
 
  private:
   T buffer_[kSize];
 };
 
 
@@ skipping 355 matching lines @@
 
 // We need different implementations of BitCast for pointer and non-pointer
 // values. We use partial specialization of auxiliary struct to work around
 // issues with template functions overloading.
 template <class Dest, class Source>
 struct BitCastHelper {
   STATIC_ASSERT(sizeof(Dest) == sizeof(Source));
 
   INLINE(static Dest cast(const Source& source)) {
     Dest dest;
+    // TODO(jkummerow): Refactor #includes and use OS::MemCopy() instead.
     memcpy(&dest, &source, sizeof(dest));
     return dest;
   }
 };
 
 template <class Dest, class Source>
 struct BitCastHelper<Dest, Source*> {
   INLINE(static Dest cast(Source* source)) {
     return BitCastHelper<Dest, uintptr_t>::
         cast(reinterpret_cast<uintptr_t>(source));
@@ skipping 191 matching lines @@
 
   // Every compiled stub starts with this id.
   static const int kStubEntryId = 5;
 
   int id_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_UTILS_H_