Implement correct OS and CC detection.

src/platform-posix.cc

 // 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 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Platform specific code for POSIX goes here. This is not a platform on its
 // own but contains the parts which are the same across POSIX platforms Linux,
 // Mac OS, FreeBSD and OpenBSD.
 
 #include "platform-posix.h"
 
 #include <dlfcn.h>
 #include <pthread.h>
-#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
+#if V8_OS_FREEBSD || V8_OS_OPENBSD
 #include <pthread_np.h>  // for pthread_set_name_np
 #endif
 #include <sched.h>  // for sched_yield
 #include <unistd.h>
 #include <errno.h>
 #include <time.h>
 
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/stat.h>
-#if defined(__linux__)
+#if V8_OS_LINUX
 #include <sys/prctl.h>  // for prctl
-#endif
-#if defined(__APPLE__) || defined(__DragonFly__) || defined(__FreeBSD__) || \
-    defined(__NetBSD__) || defined(__OpenBSD__)
+#elif V8_OS_BSD4
 #include <sys/sysctl.h>  // for sysctl
 #endif
 
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <netdb.h>
 
 #undef MAP_TYPE
 
-#if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
+#if V8_OS_ANDROID && !defined(V8_ANDROID_LOG_STDOUT)
 #define LOG_TAG "v8"
 #include <android/log.h>
 #endif
 
 #include "v8.h"
 
 #include "codegen.h"
 #include "platform.h"
 
 namespace v8 {
 namespace internal {
 
 // 0 is never a valid thread id.
 static const pthread_t kNoThread = (pthread_t) 0;
 
 
 uint64_t OS::CpuFeaturesImpliedByPlatform() {
-#if defined(__APPLE__)
+#if V8_OS_DARWIN
   // Mac OS X requires all these to install so we can assume they are present.
   // These constants are defined by the CPUid instructions.
   const uint64_t one = 1;
   return (one << SSE2) | (one << CMOV) | (one << RDTSC) | (one << CPUID);
 #else
   return 0;  // Nothing special about the other systems.
 #endif
 }
 
 
@@ skipping 35 matching lines @@
 void OS::Free(void* address, const size_t size) {
   // TODO(1240712): munmap has a return value which is ignored here.
   int result = munmap(address, size);
   USE(result);
   ASSERT(result == 0);
 }
 
 
 // Get rid of writable permission on code allocations.
 void OS::ProtectCode(void* address, const size_t size) {
-#if defined(__CYGWIN__)
+#if V8_OS_CYGWIN
   DWORD old_protect;
   VirtualProtect(address, size, PAGE_EXECUTE_READ, &old_protect);
-#elif defined(__native_client__)
+#elif V8_OS_NACL
   // The Native Client port of V8 uses an interpreter, so
   // code pages don't need PROT_EXEC.
   mprotect(address, size, PROT_READ);
 #else
   mprotect(address, size, PROT_READ | PROT_EXEC);
 #endif
 }
 
 
 // Create guard pages.
 void OS::Guard(void* address, const size_t size) {
-#if defined(__CYGWIN__)
+#if V8_OS_CYGWIN
   DWORD oldprotect;
   VirtualProtect(address, size, PAGE_READONLY | PAGE_GUARD, &oldprotect);
 #else
   mprotect(address, size, PROT_NONE);
 #endif
 }
 
 
 void* OS::GetRandomMmapAddr() {
-#if defined(__native_client__)
+#if V8_OS_NACL
   // TODO(bradchen): restore randomization once Native Client gets
   // smarter about using mmap address hints.
   // See http://code.google.com/p/nativeclient/issues/3341
   return NULL;
 #endif
   Isolate* isolate = Isolate::UncheckedCurrent();
   // Note that the current isolate isn't set up in a call path via
   // CpuFeatures::Probe. We don't care about randomization in this case because
   // the code page is immediately freed.
   if (isolate != NULL) {
-#if V8_TARGET_ARCH_X64
+#if V8_HOST_ARCH_64_BIT
     uint64_t rnd1 = V8::RandomPrivate(isolate);
     uint64_t rnd2 = V8::RandomPrivate(isolate);
     uint64_t raw_addr = (rnd1 << 32) ^ rnd2;
     // 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);
 #else
     uint32_t raw_addr = V8::RandomPrivate(isolate);
 
     raw_addr &= 0x3ffff000;
 
-# ifdef __sun
+#if V8_OS_SOLARIS
     // 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;
-# else
+#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
+#endif  // V8_OS_SOLARIS
+#endif  // V8_HOST_ARCH_64_BIT
     return reinterpret_cast<void*>(raw_addr);
   }
   return NULL;
 }
 
 
 size_t OS::AllocateAlignment() {
   return getpagesize();
 }
 
@@ skipping 17 matching lines @@
   abort();
 }
 
 
 void OS::DebugBreak() {
 #if V8_HOST_ARCH_ARM
   asm("bkpt 0");
 #elif V8_HOST_ARCH_MIPS
   asm("break");
 #elif V8_HOST_ARCH_IA32
-#if defined(__native_client__)
+#if V8_OS_NACL
   asm("hlt");
 #else
   asm("int $3");
-#endif  // __native_client__
+#endif  // V8_OS_NACL
 #elif V8_HOST_ARCH_X64
   asm("int $3");
 #else
 #error Unsupported host architecture.
 #endif
 }
 
 
 // ----------------------------------------------------------------------------
 // Math functions
@@ skipping 122 matching lines @@
 
 void OS::Print(const char* format, ...) {
   va_list args;
   va_start(args, format);
   VPrint(format, args);
   va_end(args);
 }
 
 
 void OS::VPrint(const char* format, va_list args) {
-#if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
+#if V8_OS_ANDROID && !defined(V8_ANDROID_LOG_STDOUT)
   __android_log_vprint(ANDROID_LOG_INFO, LOG_TAG, format, args);
 #else
   vprintf(format, args);
 #endif
 }
 
 
 void OS::FPrint(FILE* out, const char* format, ...) {
   va_list args;
   va_start(args, format);
   VFPrint(out, format, args);
   va_end(args);
 }
 
 
 void OS::VFPrint(FILE* out, const char* format, va_list args) {
-#if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
+#if V8_OS_ANDROID && !defined(V8_ANDROID_LOG_STDOUT)
   __android_log_vprint(ANDROID_LOG_INFO, LOG_TAG, format, args);
 #else
   vfprintf(out, format, args);
 #endif
 }
 
 
 void OS::PrintError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   VPrintError(format, args);
   va_end(args);
 }
 
 
 void OS::VPrintError(const char* format, va_list args) {
-#if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
+#if V8_OS_ANDROID && !defined(V8_ANDROID_LOG_STDOUT)
   __android_log_vprint(ANDROID_LOG_ERROR, LOG_TAG, format, args);
 #else
   vfprintf(stderr, format, args);
 #endif
 }
 
 
 int OS::SNPrintF(Vector<char> str, const char* format, ...) {
   va_list args;
   va_start(args, format);
@@ skipping 31 matching lines @@
 OS::MemMoveFunction CreateMemMoveFunction();
 
 // Copy memory area. No restrictions.
 void OS::MemMove(void* dest, const void* src, size_t size) {
   if (size == 0) return;
   // Note: here we rely on dependent reads being ordered. This is true
   // on all architectures we currently support.
   (*memmove_function)(dest, src, size);
 }
 
-#elif defined(V8_HOST_ARCH_ARM)
+#elif V8_HOST_ARCH_ARM
 void OS::MemCopyUint16Uint8Wrapper(uint16_t* dest,
                                const uint8_t* src,
                                size_t chars) {
   uint16_t *limit = dest + chars;
   while (dest < limit) {
     *dest++ = static_cast<uint16_t>(*src++);
   }
 }
 
 
 OS::MemCopyUint8Function OS::memcopy_uint8_function = &OS::MemCopyUint8Wrapper;
 OS::MemCopyUint16Uint8Function OS::memcopy_uint16_uint8_function =
     &OS::MemCopyUint16Uint8Wrapper;
 // Defined in codegen-arm.cc.
 OS::MemCopyUint8Function CreateMemCopyUint8Function(
     OS::MemCopyUint8Function stub);
 OS::MemCopyUint16Uint8Function CreateMemCopyUint16Uint8Function(
     OS::MemCopyUint16Uint8Function stub);
 #endif
 
 
 void OS::PostSetUp() {
 #if V8_TARGET_ARCH_IA32
   OS::MemMoveFunction generated_memmove = CreateMemMoveFunction();
   if (generated_memmove != NULL) {
     memmove_function = generated_memmove;
   }
-#elif defined(V8_HOST_ARCH_ARM)
+#elif V8_HOST_ARCH_ARM
   OS::memcopy_uint8_function =
       CreateMemCopyUint8Function(&OS::MemCopyUint8Wrapper);
   OS::memcopy_uint16_uint8_function =
       CreateMemCopyUint16Uint8Function(&OS::MemCopyUint16Uint8Wrapper);
 #endif
   init_fast_sin_function();
   init_fast_cos_function();
   init_fast_tan_function();
   init_fast_log_function();
   // fast_exp is initialized lazily.
@@ skipping 32 matching lines @@
   set_name(options.name());
 }
 
 
 Thread::~Thread() {
   delete data_;
 }
 
 
 static void SetThreadName(const char* name) {
-#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
+#if V8_OS_FREEBSD || V8_OS_OPENBSD
   pthread_set_name_np(pthread_self(), name);
-#elif defined(__NetBSD__)
+#elif V8_OS_NETBSD
   STATIC_ASSERT(Thread::kMaxThreadNameLength <= PTHREAD_MAX_NAMELEN_NP);
   pthread_setname_np(pthread_self(), "%s", name);
-#elif defined(__APPLE__)
+#elif V8_OS_DARWIN
   // pthread_setname_np is only available in 10.6 or later, so test
   // for it at runtime.
   int (*dynamic_pthread_setname_np)(const char*);
   *reinterpret_cast<void**>(&dynamic_pthread_setname_np) =
     dlsym(RTLD_DEFAULT, "pthread_setname_np");
   if (dynamic_pthread_setname_np == NULL)
     return;
 
   // Mac OS X does not expose the length limit of the name, so hardcode it.
   static const int kMaxNameLength = 63;
@@ skipping 26 matching lines @@
 }
 
 
 void Thread::Start() {
   int result;
   pthread_attr_t attr;
   memset(&attr, 0, sizeof(attr));
   result = pthread_attr_init(&attr);
   ASSERT_EQ(0, result);
   // Native client uses default stack size.
-#if !defined(__native_client__)
+#if !V8_OS_NACL
   if (stack_size_ > 0) {
     result = pthread_attr_setstacksize(&attr, static_cast<size_t>(stack_size_));
     ASSERT_EQ(0, result);
   }
 #endif
   result = pthread_create(&data_->thread_, &attr, ThreadEntry, this);
   ASSERT_EQ(0, result);
   result = pthread_attr_destroy(&attr);
   ASSERT_EQ(0, result);
   ASSERT(data_->thread_ != kNoThread);
   USE(result);
 }
 
 
 void Thread::Join() {
   pthread_join(data_->thread_, NULL);
 }
 
 
 void Thread::YieldCPU() {
   int result = sched_yield();
   ASSERT_EQ(0, result);
   USE(result);
 }
 
 
 static Thread::LocalStorageKey PthreadKeyToLocalKey(pthread_key_t pthread_key) {
-#if defined(__CYGWIN__)
+#if V8_OS_CYGWIN
   // We need to cast pthread_key_t to Thread::LocalStorageKey in two steps
   // because pthread_key_t is a pointer type on Cygwin. This will probably not
   // work on 64-bit platforms, but Cygwin doesn't support 64-bit anyway.
   STATIC_ASSERT(sizeof(Thread::LocalStorageKey) == sizeof(pthread_key_t));
   intptr_t ptr_key = reinterpret_cast<intptr_t>(pthread_key);
   return static_cast<Thread::LocalStorageKey>(ptr_key);
 #else
   return static_cast<Thread::LocalStorageKey>(pthread_key);
 #endif
 }
 
 
 static pthread_key_t LocalKeyToPthreadKey(Thread::LocalStorageKey local_key) {
-#if defined(__CYGWIN__)
+#if V8_OS_CYGWIN
   STATIC_ASSERT(sizeof(Thread::LocalStorageKey) == sizeof(pthread_key_t));
   intptr_t ptr_key = static_cast<intptr_t>(local_key);
   return reinterpret_cast<pthread_key_t>(ptr_key);
 #else
   return static_cast<pthread_key_t>(local_key);
 #endif
 }
 
 
 #ifdef V8_FAST_TLS_SUPPORTED
@@ skipping 329 matching lines @@
   return ntohl(value);
 }
 
 
 Socket* OS::CreateSocket() {
   return new POSIXSocket();
 }
 
 
 } }  // namespace v8::internal