Contribution of PowerPC port (continuation of 422063005) - AIX Common1

src/base/platform/platform-posix.cc

 // 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.
 
 // Platform-specific code for POSIX goes here. This is not a platform on its
 // own, but contains the parts which are the same across the POSIX platforms
 // Linux, MacOS, FreeBSD, OpenBSD, NetBSD and QNX.
 
 #include <errno.h>
 #include <limits.h>
@@ skipping 37 matching lines @@
 #endif
 
 #if V8_OS_MACOSX
 #include <dlfcn.h>
 #endif
 
 #if V8_OS_LINUX
 #include <sys/prctl.h>  // NOLINT, for prctl
 #endif
 
-#if !V8_OS_NACL
+#if !defined(V8_OS_NACL) && !defined(_AIX)
 #include <sys/syscall.h>
 #endif
 
 namespace v8 {
 namespace base {
 
 namespace {
 
 // 0 is never a valid thread id.
 const pthread_t kNoThread = (pthread_t) 0;
@@ skipping 96 matching lines @@
 #endif
   uintptr_t raw_addr;
   platform_random_number_generator.Pointer()->NextBytes(&raw_addr,
                                                         sizeof(raw_addr));
 #if V8_TARGET_ARCH_X64
   // Currently available CPUs have 48 bits of virtual addressing.  Truncate
   // the hint address to 46 bits to give the kernel a fighting chance of
   // fulfilling our placement request.
   raw_addr &= V8_UINT64_C(0x3ffffffff000);
 #elif V8_TARGET_ARCH_PPC64
-#if V8_TARGET_BIG_ENDIAN
+#if V8_OS_AIX
+  // AIX: 64 bits of virtual addressing, but we limit address range to:
+  //   a) minimize Segment Lookaside Buffer (SLB) misses and
+  //   b) avoid losing precision if address is stored as a double.

[Sven Panne, 2015/01/27 11:47:05]

Same question again: Where do we store addresses as doubles?

[michael_dawson, 2015/01/29 00:08:29]

See explanation on similar comment on src/base/platform/platform-aix.cc.  In
this case we still want to limit the address range for a) so I'll just remove
comment b)

+  raw_addr &= V8_UINT64_C(0x3ffff000);
+  // Use extra address space to isolate the mmap regions.
+  raw_addr += V8_UINT64_C(0x400000000000);
+#elif V8_TARGET_BIG_ENDIAN
   // Big-endian Linux: 44 bits of virtual addressing.
   raw_addr &= V8_UINT64_C(0x03fffffff000);
 #else
   // Little-endian Linux: 48 bits of virtual addressing.
   raw_addr &= V8_UINT64_C(0x3ffffffff000);
 #endif
 #else
   raw_addr &= 0x3ffff000;
 
 # ifdef __sun
   // For our Solaris/illumos mmap hint, we pick a random address in the bottom
   // half of the top half of the address space (that is, the third quarter).
   // Because we do not MAP_FIXED, this will be treated only as a hint -- the
   // system will not fail to mmap() because something else happens to already
   // be mapped at our random address. We deliberately set the hint high enough
   // to get well above the system's break (that is, the heap); Solaris and
   // illumos will try the hint and if that fails allocate as if there were
   // no hint at all. The high hint prevents the break from getting hemmed in
   // at low values, ceding half of the address space to the system heap.
   raw_addr += 0x80000000;
+#elif V8_OS_AIX
+  // The range 0x30000000 - 0xD0000000 is available on AIX;
+  // choose the upper range.
+  raw_addr += 0x90000000;
 # else
   // The range 0x20000000 - 0x60000000 is relatively unpopulated across a
   // variety of ASLR modes (PAE kernel, NX compat mode, etc) and on macos
   // 10.6 and 10.7.
   raw_addr += 0x20000000;
 # endif
 #endif
   return reinterpret_cast<void*>(raw_addr);
 }
 
@@ skipping 48 matching lines @@
 }
 
 
 int OS::GetCurrentThreadId() {
 #if V8_OS_MACOSX || (V8_OS_ANDROID && defined(__APPLE__))
   return static_cast<int>(pthread_mach_thread_np(pthread_self()));
 #elif V8_OS_LINUX
   return static_cast<int>(syscall(__NR_gettid));
 #elif V8_OS_ANDROID
   return static_cast<int>(gettid());
+#elif V8_OS_AIX
+  return static_cast<int>(thread_self());
 #else
   return static_cast<int>(reinterpret_cast<intptr_t>(pthread_self()));
 #endif
 }
 
 
 // ----------------------------------------------------------------------------
 // POSIX date/time support.
 //
 
@@ skipping 243 matching lines @@
 
 
 void Thread::Start() {
   int result;
   pthread_attr_t attr;
   memset(&attr, 0, sizeof(attr));
   result = pthread_attr_init(&attr);
   DCHECK_EQ(0, result);
   // Native client uses default stack size.
 #if !V8_OS_NACL
-  if (stack_size_ > 0) {
-    result = pthread_attr_setstacksize(&attr, static_cast<size_t>(stack_size_));
+  size_t stack_size = stack_size_;
+#if V8_OS_AIX
+  if (stack_size == 0) {
+    // Default on AIX is 96KB -- bump up to 2MB
+    stack_size = 2 * 1024 * 1024;
+  }
+#endif
+  if (stack_size > 0) {
+    result = pthread_attr_setstacksize(&attr, stack_size);
     DCHECK_EQ(0, result);
   }
 #endif
   {
     LockGuard<Mutex> lock_guard(&data_->thread_creation_mutex_);
     result = pthread_create(&data_->thread_, &attr, ThreadEntry, this);
   }
   DCHECK_EQ(0, result);
   result = pthread_attr_destroy(&attr);
   DCHECK_EQ(0, result);
@@ skipping 132 matching lines @@
 
 void Thread::SetThreadLocal(LocalStorageKey key, void* value) {
   pthread_key_t pthread_key = LocalKeyToPthreadKey(key);
   int result = pthread_setspecific(pthread_key, value);
   DCHECK_EQ(0, result);
   USE(result);
 }
 
 
 } }  // namespace v8::base