Version 5.5.228.1 (cherry-pick)

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 419 matching lines @@
 
 // Initializes the codegen support that depends on CPU features.
 void init_memcopy_functions(Isolate* isolate);
 
 #if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_X87)
 // Limit below which the extra overhead of the MemCopy function is likely
 // to outweigh the benefits of faster copying.
 const int kMinComplexMemCopy = 64;
 
 // Copy memory area. No restrictions.
-V8_EXPORT_PRIVATE void MemMove(void* dest, const void* src, size_t size);
+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_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;
 V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
   (*memcopy_uint8_function)(reinterpret_cast<uint8_t*>(dest),
                             reinterpret_cast<const uint8_t*>(src), size);
 }
-V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
-                                         size_t size) {
+V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
   memmove(dest, src, size);
 }
 
 typedef void (*MemCopyUint16Uint8Function)(uint16_t* dest, const uint8_t* src,
                                            size_t size);
 extern MemCopyUint16Uint8Function memcopy_uint16_uint8_function;
 void MemCopyUint16Uint8Wrapper(uint16_t* dest, const uint8_t* src,
                                size_t chars);
 // For values < 12, the assembler function is slower than the inlined C code.
 const int kMinComplexConvertMemCopy = 12;
 V8_INLINE void MemCopyUint16Uint8(uint16_t* dest, const uint8_t* src,
                                   size_t size) {
   (*memcopy_uint16_uint8_function)(dest, src, size);
 }
 #elif defined(V8_HOST_ARCH_MIPS)
 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;
 V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
   (*memcopy_uint8_function)(reinterpret_cast<uint8_t*>(dest),
                             reinterpret_cast<const uint8_t*>(src), size);
 }
-V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
-                                         size_t size) {
+V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
   memmove(dest, src, size);
 }
 #else
 // Copy memory area to disjoint memory area.
 V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
   memcpy(dest, src, size);
 }
-V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
-                                         size_t size) {
+V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
   memmove(dest, src, size);
 }
 const int kMinComplexMemCopy = 16 * kPointerSize;
 #endif  // V8_TARGET_ARCH_IA32
 
 
 // ----------------------------------------------------------------------------
 // Miscellaneous
 
 // A static resource holds a static instance that can be reserved in
@@ skipping 1081 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_