A64: Synchronize with r18444.

src/platform.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 41 matching lines @@
 #include "v8globals.h"
 
 #ifdef __sun
 # ifndef signbit
 namespace std {
 int signbit(double x);
 }
 # endif
 #endif
 
+#if V8_OS_QNX
+#include "qnx-math.h"
+#endif
+
 // Microsoft Visual C++ specific stuff.
 #if V8_CC_MSVC
 
 #include "win32-headers.h"
 #include "win32-math.h"
 
 int strncasecmp(const char* s1, const char* s2, int n);
 
 // Visual C++ 2013 and higher implement this function.
 #if (_MSC_VER < 1800)
@@ skipping 17 matching lines @@
 #endif  // _MSC_VER < 1800
 
 #endif  // V8_CC_MSVC
 
 namespace v8 {
 namespace internal {
 
 double modulo(double x, double y);
 
 // Custom implementation of math functions.
-double fast_log(double input);
 double fast_exp(double input);
 double fast_sqrt(double input);
 // The custom exp implementation needs 16KB of lookup data; initialize it
 // on demand.
 void lazily_initialize_fast_exp();
 
 // ----------------------------------------------------------------------------
 // Fast TLS support
 
 #ifndef V8_NO_FAST_TLS
@@ skipping 248 matching lines @@
   static 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.
   static const int kMinComplexConvertMemCopy = 12;
   static 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);
+  static MemCopyUint8Function memcopy_uint8_function;
+  static 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.
+  static const int kMinComplexMemCopy = 16;
+  static 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);
+  }
+  static void MemMove(void* dest, const void* src, size_t size) {
+    memmove(dest, src, size);
+  }
 #else
   // Copy memory area to disjoint memory area.
   static void MemCopy(void* dest, const void* src, size_t size) {
     memcpy(dest, src, size);
   }
   static void MemMove(void* dest, const void* src, size_t size) {
     memmove(dest, src, size);
   }
   static const int kMinComplexMemCopy = 16 * kPointerSize;
 #endif  // V8_TARGET_ARCH_IA32
@@ skipping 210 matching lines @@
   char name_[kMaxThreadNameLength];
   int stack_size_;
   Semaphore* start_semaphore_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_PLATFORM_H_