1// Copyright 2013 the V8 project authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef V8CONFIG_H_ 6#define V8CONFIG_H_ 7 8// clang-format off 9 10// Platform headers for feature detection below. 11#if defined(__ANDROID__) 12# include <sys/cdefs.h> 13#elif defined(__APPLE__) 14# include <TargetConditionals.h> 15#elif defined(__linux__) 16# include <features.h> 17#endif 18 19 20// This macro allows to test for the version of the GNU C library (or 21// a compatible C library that masquerades as glibc). It evaluates to 22// 0 if libc is not GNU libc or compatible. 23// Use like: 24// #if V8_GLIBC_PREREQ(2, 3) 25// ... 26// #endif 27#if defined(__GLIBC__) && defined(__GLIBC_MINOR__) 28# define V8_GLIBC_PREREQ(major, minor) \ 29 ((__GLIBC__ * 100 + __GLIBC_MINOR__) >= ((major) * 100 + (minor))) 30#else 31# define V8_GLIBC_PREREQ(major, minor) 0 32#endif 33 34 35// This macro allows to test for the version of the GNU C++ compiler. 36// Note that this also applies to compilers that masquerade as GCC, 37// for example clang and the Intel C++ compiler for Linux. 38// Use like: 39// #if V8_GNUC_PREREQ(4, 3, 1) 40// ... 41// #endif 42#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) 43# define V8_GNUC_PREREQ(major, minor, patchlevel) \ 44 ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= \ 45 ((major) * 10000 + (minor) * 100 + (patchlevel))) 46#elif defined(__GNUC__) && defined(__GNUC_MINOR__) 47# define V8_GNUC_PREREQ(major, minor, patchlevel) \ 48 ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= \ 49 ((major) * 10000 + (minor) * 100 + (patchlevel))) 50#else 51# define V8_GNUC_PREREQ(major, minor, patchlevel) 0 52#endif 53 54 55 56// ----------------------------------------------------------------------------- 57// Operating system detection 58// 59// V8_OS_ANDROID - Android 60// V8_OS_BSD - BSDish (Mac OS X, Net/Free/Open/DragonFlyBSD) 61// V8_OS_CYGWIN - Cygwin 62// V8_OS_DRAGONFLYBSD - DragonFlyBSD 63// V8_OS_FREEBSD - FreeBSD 64// V8_OS_LINUX - Linux 65// V8_OS_MACOSX - Mac OS X 66// V8_OS_NACL - Native Client 67// V8_OS_NETBSD - NetBSD 68// V8_OS_OPENBSD - OpenBSD 69// V8_OS_POSIX - POSIX compatible (mostly everything except Windows) 70// V8_OS_QNX - QNX Neutrino 71// V8_OS_SOLARIS - Sun Solaris and OpenSolaris 72// V8_OS_AIX - AIX 73// V8_OS_WIN - Microsoft Windows 74 75#if defined(__ANDROID__) 76# define V8_OS_ANDROID 1 77# define V8_OS_LINUX 1 78# define V8_OS_POSIX 1 79#elif defined(__APPLE__) 80# define V8_OS_BSD 1 81# define V8_OS_MACOSX 1 82# define V8_OS_POSIX 1 83#elif defined(__native_client__) 84# define V8_OS_NACL 1 85# define V8_OS_POSIX 1 86#elif defined(__CYGWIN__) 87# define V8_OS_CYGWIN 1 88# define V8_OS_POSIX 1 89#elif defined(__linux__) 90# define V8_OS_LINUX 1 91# define V8_OS_POSIX 1 92#elif defined(__sun) 93# define V8_OS_POSIX 1 94# define V8_OS_SOLARIS 1 95#elif defined(_AIX) 96#define V8_OS_POSIX 1 97#define V8_OS_AIX 1 98#elif defined(__FreeBSD__) 99# define V8_OS_BSD 1 100# define V8_OS_FREEBSD 1 101# define V8_OS_POSIX 1 102#elif defined(__DragonFly__) 103# define V8_OS_BSD 1 104# define V8_OS_DRAGONFLYBSD 1 105# define V8_OS_POSIX 1 106#elif defined(__NetBSD__) 107# define V8_OS_BSD 1 108# define V8_OS_NETBSD 1 109# define V8_OS_POSIX 1 110#elif defined(__OpenBSD__) 111# define V8_OS_BSD 1 112# define V8_OS_OPENBSD 1 113# define V8_OS_POSIX 1 114#elif defined(__QNXNTO__) 115# define V8_OS_POSIX 1 116# define V8_OS_QNX 1 117#elif defined(_WIN32) 118# define V8_OS_WIN 1 119#endif 120 121 122// ----------------------------------------------------------------------------- 123// C library detection 124// 125// V8_LIBC_MSVCRT - MSVC libc 126// V8_LIBC_BIONIC - Bionic libc 127// V8_LIBC_BSD - BSD libc derivate 128// V8_LIBC_GLIBC - GNU C library 129// V8_LIBC_UCLIBC - uClibc 130// 131// Note that testing for libc must be done using #if not #ifdef. For example, 132// to test for the GNU C library, use: 133// #if V8_LIBC_GLIBC 134// ... 135// #endif 136 137#if defined (_MSC_VER) 138# define V8_LIBC_MSVCRT 1 139#elif defined(__BIONIC__) 140# define V8_LIBC_BIONIC 1 141# define V8_LIBC_BSD 1 142#elif defined(__UCLIBC__) 143// Must test for UCLIBC before GLIBC, as UCLIBC pretends to be GLIBC. 144# define V8_LIBC_UCLIBC 1 145#elif defined(__GLIBC__) || defined(__GNU_LIBRARY__) 146# define V8_LIBC_GLIBC 1 147#else 148# define V8_LIBC_BSD V8_OS_BSD 149#endif 150 151 152// ----------------------------------------------------------------------------- 153// Compiler detection 154// 155// V8_CC_GNU - GCC, or clang in gcc mode 156// V8_CC_INTEL - Intel C++ 157// V8_CC_MINGW - Minimalist GNU for Windows 158// V8_CC_MINGW32 - Minimalist GNU for Windows (mingw32) 159// V8_CC_MINGW64 - Minimalist GNU for Windows (mingw-w64) 160// V8_CC_MSVC - Microsoft Visual C/C++, or clang in cl.exe mode 161// 162// C++11 feature detection 163// 164// V8_HAS_CXX11_ALIGNAS - alignas specifier supported 165// V8_HAS_CXX11_ALIGNOF - alignof(type) operator supported 166// 167// Compiler-specific feature detection 168// 169// V8_HAS___ALIGNOF - __alignof(type) operator supported 170// V8_HAS___ALIGNOF__ - __alignof__(type) operator supported 171// V8_HAS_ATTRIBUTE_ALIGNED - __attribute__((aligned(n))) supported 172// V8_HAS_ATTRIBUTE_ALWAYS_INLINE - __attribute__((always_inline)) 173// supported 174// V8_HAS_ATTRIBUTE_DEPRECATED - __attribute__((deprecated)) supported 175// V8_HAS_ATTRIBUTE_NOINLINE - __attribute__((noinline)) supported 176// V8_HAS_ATTRIBUTE_NORETURN - __attribute__((noreturn)) supported 177// V8_HAS_ATTRIBUTE_UNUSED - __attribute__((unused)) supported 178// V8_HAS_ATTRIBUTE_VISIBILITY - __attribute__((visibility)) supported 179// V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT - __attribute__((warn_unused_result)) 180// supported 181// V8_HAS_BUILTIN_CLZ - __builtin_clz() supported 182// V8_HAS_BUILTIN_CTZ - __builtin_ctz() supported 183// V8_HAS_BUILTIN_EXPECT - __builtin_expect() supported 184// V8_HAS_BUILTIN_FRAME_ADDRESS - __builtin_frame_address() supported 185// V8_HAS_BUILTIN_POPCOUNT - __builtin_popcount() supported 186// V8_HAS_BUILTIN_SADD_OVERFLOW - __builtin_sadd_overflow() supported 187// V8_HAS_BUILTIN_SSUB_OVERFLOW - __builtin_ssub_overflow() supported 188// V8_HAS_BUILTIN_UADD_OVERFLOW - __builtin_uadd_overflow() supported 189// V8_HAS_DECLSPEC_ALIGN - __declspec(align(n)) supported 190// V8_HAS_DECLSPEC_DEPRECATED - __declspec(deprecated) supported 191// V8_HAS_DECLSPEC_NOINLINE - __declspec(noinline) supported 192// V8_HAS_DECLSPEC_SELECTANY - __declspec(selectany) supported 193// V8_HAS_DECLSPEC_NORETURN - __declspec(noreturn) supported 194// V8_HAS___FORCEINLINE - __forceinline supported 195// 196// Note that testing for compilers and/or features must be done using #if 197// not #ifdef. For example, to test for Intel C++ Compiler, use: 198// #if V8_CC_INTEL 199// ... 200// #endif 201 202#if defined(__clang__) 203 204#if defined(__GNUC__) // Clang in gcc mode. 205# define V8_CC_GNU 1 206#endif 207 208// Clang defines __alignof__ as alias for __alignof 209# define V8_HAS___ALIGNOF 1 210# define V8_HAS___ALIGNOF__ V8_HAS___ALIGNOF 211 212# define V8_HAS_ATTRIBUTE_ALIGNED (__has_attribute(aligned)) 213# define V8_HAS_ATTRIBUTE_ALWAYS_INLINE (__has_attribute(always_inline)) 214# define V8_HAS_ATTRIBUTE_DEPRECATED (__has_attribute(deprecated)) 215# define V8_HAS_ATTRIBUTE_NOINLINE (__has_attribute(noinline)) 216# define V8_HAS_ATTRIBUTE_NORETURN (__has_attribute(noreturn)) 217# define V8_HAS_ATTRIBUTE_UNUSED (__has_attribute(unused)) 218# define V8_HAS_ATTRIBUTE_VISIBILITY (__has_attribute(visibility)) 219# define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT \ 220 (__has_attribute(warn_unused_result)) 221 222# define V8_HAS_BUILTIN_CLZ (__has_builtin(__builtin_clz)) 223# define V8_HAS_BUILTIN_CTZ (__has_builtin(__builtin_ctz)) 224# define V8_HAS_BUILTIN_EXPECT (__has_builtin(__builtin_expect)) 225# define V8_HAS_BUILTIN_FRAME_ADDRESS (__has_builtin(__builtin_frame_address)) 226# define V8_HAS_BUILTIN_POPCOUNT (__has_builtin(__builtin_popcount)) 227# define V8_HAS_BUILTIN_SADD_OVERFLOW (__has_builtin(__builtin_sadd_overflow)) 228# define V8_HAS_BUILTIN_SSUB_OVERFLOW (__has_builtin(__builtin_ssub_overflow)) 229# define V8_HAS_BUILTIN_UADD_OVERFLOW (__has_builtin(__builtin_uadd_overflow)) 230 231# define V8_HAS_CXX11_ALIGNAS (__has_feature(cxx_alignas)) 232 233#elif defined(__GNUC__) 234 235# define V8_CC_GNU 1 236# if defined(__INTEL_COMPILER) // Intel C++ also masquerades as GCC 3.2.0 237# define V8_CC_INTEL 1 238# endif 239# if defined(__MINGW32__) 240# define V8_CC_MINGW32 1 241# endif 242# if defined(__MINGW64__) 243# define V8_CC_MINGW64 1 244# endif 245# define V8_CC_MINGW (V8_CC_MINGW32 || V8_CC_MINGW64) 246 247# define V8_HAS___ALIGNOF__ (V8_GNUC_PREREQ(4, 3, 0)) 248 249# define V8_HAS_ATTRIBUTE_ALIGNED (V8_GNUC_PREREQ(2, 95, 0)) 250// always_inline is available in gcc 4.0 but not very reliable until 4.4. 251// Works around "sorry, unimplemented: inlining failed" build errors with 252// older compilers. 253# define V8_HAS_ATTRIBUTE_ALWAYS_INLINE (V8_GNUC_PREREQ(4, 4, 0)) 254# define V8_HAS_ATTRIBUTE_DEPRECATED (V8_GNUC_PREREQ(3, 4, 0)) 255# define V8_HAS_ATTRIBUTE_DEPRECATED_MESSAGE (V8_GNUC_PREREQ(4, 5, 0)) 256# define V8_HAS_ATTRIBUTE_NOINLINE (V8_GNUC_PREREQ(3, 4, 0)) 257# define V8_HAS_ATTRIBUTE_NORETURN (V8_GNUC_PREREQ(2, 5, 0)) 258# define V8_HAS_ATTRIBUTE_UNUSED (V8_GNUC_PREREQ(2, 95, 0)) 259# define V8_HAS_ATTRIBUTE_VISIBILITY (V8_GNUC_PREREQ(4, 3, 0)) 260# define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT \ 261 (!V8_CC_INTEL && V8_GNUC_PREREQ(4, 1, 0)) 262 263# define V8_HAS_BUILTIN_CLZ (V8_GNUC_PREREQ(3, 4, 0)) 264# define V8_HAS_BUILTIN_CTZ (V8_GNUC_PREREQ(3, 4, 0)) 265# define V8_HAS_BUILTIN_EXPECT (V8_GNUC_PREREQ(2, 96, 0)) 266# define V8_HAS_BUILTIN_FRAME_ADDRESS (V8_GNUC_PREREQ(2, 96, 0)) 267# define V8_HAS_BUILTIN_POPCOUNT (V8_GNUC_PREREQ(3, 4, 0)) 268 269# if __cplusplus >= 201103L 270# define V8_HAS_CXX11_ALIGNAS (V8_GNUC_PREREQ(4, 8, 0)) 271# define V8_HAS_CXX11_ALIGNOF (V8_GNUC_PREREQ(4, 8, 0)) 272# endif 273#endif 274 275#if defined(_MSC_VER) 276# define V8_CC_MSVC 1 277# define V8_HAS___ALIGNOF 1 278 279# define V8_HAS_DECLSPEC_ALIGN 1 280# define V8_HAS_DECLSPEC_DEPRECATED 1 281# define V8_HAS_DECLSPEC_NOINLINE 1 282# define V8_HAS_DECLSPEC_SELECTANY 1 283# define V8_HAS_DECLSPEC_NORETURN 1 284 285# define V8_HAS___FORCEINLINE 1 286 287#endif 288 289 290// ----------------------------------------------------------------------------- 291// Helper macros 292 293// A macro used to make better inlining. Don't bother for debug builds. 294// Use like: 295// V8_INLINE int GetZero() { return 0; } 296#if !defined(DEBUG) && V8_HAS_ATTRIBUTE_ALWAYS_INLINE 297# define V8_INLINE inline __attribute__((always_inline)) 298#elif !defined(DEBUG) && V8_HAS___FORCEINLINE 299# define V8_INLINE __forceinline 300#else 301# define V8_INLINE inline 302#endif 303 304 305// A macro used to tell the compiler to never inline a particular function. 306// Don't bother for debug builds. 307// Use like: 308// V8_NOINLINE int GetMinusOne() { return -1; } 309#if !defined(DEBUG) && V8_HAS_ATTRIBUTE_NOINLINE 310# define V8_NOINLINE __attribute__((noinline)) 311#elif !defined(DEBUG) && V8_HAS_DECLSPEC_NOINLINE 312# define V8_NOINLINE __declspec(noinline) 313#else 314# define V8_NOINLINE /* NOT SUPPORTED */ 315#endif 316 317 318// A macro used to tell the compiler that a particular function never returns. 319// Use like: 320// V8_NORETURN void MyAbort() { abort(); } 321#if V8_HAS_ATTRIBUTE_NORETURN 322# define V8_NORETURN __attribute__((noreturn)) 323#elif HAS_DECLSPEC_NORETURN 324# define V8_NORETURN __declspec(noreturn) 325#else 326# define V8_NORETURN /* NOT SUPPORTED */ 327#endif 328 329 330// A macro (V8_DEPRECATED) to mark classes or functions as deprecated. 331#if defined(V8_DEPRECATION_WARNINGS) && V8_HAS_ATTRIBUTE_DEPRECATED_MESSAGE 332#define V8_DEPRECATED(message, declarator) \ 333 declarator __attribute__((deprecated(message))) 334#elif defined(V8_DEPRECATION_WARNINGS) && V8_HAS_ATTRIBUTE_DEPRECATED 335#define V8_DEPRECATED(message, declarator) \ 336 declarator __attribute__((deprecated)) 337#elif defined(V8_DEPRECATION_WARNINGS) && V8_HAS_DECLSPEC_DEPRECATED 338#define V8_DEPRECATED(message, declarator) __declspec(deprecated) declarator 339#else 340#define V8_DEPRECATED(message, declarator) declarator 341#endif 342 343 344// A macro (V8_DEPRECATE_SOON) to make it easier to see what will be deprecated. 345#if defined(V8_IMMINENT_DEPRECATION_WARNINGS) && \ 346 V8_HAS_ATTRIBUTE_DEPRECATED_MESSAGE 347#define V8_DEPRECATE_SOON(message, declarator) \ 348 declarator __attribute__((deprecated(message))) 349#elif defined(V8_IMMINENT_DEPRECATION_WARNINGS) && V8_HAS_ATTRIBUTE_DEPRECATED 350#define V8_DEPRECATE_SOON(message, declarator) \ 351 declarator __attribute__((deprecated)) 352#elif defined(V8_IMMINENT_DEPRECATION_WARNINGS) && V8_HAS_DECLSPEC_DEPRECATED 353#define V8_DEPRECATE_SOON(message, declarator) __declspec(deprecated) declarator 354#else 355#define V8_DEPRECATE_SOON(message, declarator) declarator 356#endif 357 358 359// A macro to provide the compiler with branch prediction information. 360#if V8_HAS_BUILTIN_EXPECT 361# define V8_UNLIKELY(condition) (__builtin_expect(!!(condition), 0)) 362# define V8_LIKELY(condition) (__builtin_expect(!!(condition), 1)) 363#else 364# define V8_UNLIKELY(condition) (condition) 365# define V8_LIKELY(condition) (condition) 366#endif 367 368 369// This macro allows to specify memory alignment for structs, classes, etc. 370// Use like: 371// class V8_ALIGNED(16) MyClass { ... }; 372// V8_ALIGNED(32) int array[42]; 373#if V8_HAS_CXX11_ALIGNAS 374# define V8_ALIGNED(n) alignas(n) 375#elif V8_HAS_ATTRIBUTE_ALIGNED 376# define V8_ALIGNED(n) __attribute__((aligned(n))) 377#elif V8_HAS_DECLSPEC_ALIGN 378# define V8_ALIGNED(n) __declspec(align(n)) 379#else 380# define V8_ALIGNED(n) /* NOT SUPPORTED */ 381#endif 382 383 384// This macro is similar to V8_ALIGNED(), but takes a type instead of size 385// in bytes. If the compiler does not supports using the alignment of the 386// |type|, it will align according to the |alignment| instead. For example, 387// Visual Studio C++ cannot combine __declspec(align) and __alignof. The 388// |alignment| must be a literal that is used as a kind of worst-case fallback 389// alignment. 390// Use like: 391// struct V8_ALIGNAS(AnotherClass, 16) NewClass { ... }; 392// V8_ALIGNAS(double, 8) int array[100]; 393#if V8_HAS_CXX11_ALIGNAS 394# define V8_ALIGNAS(type, alignment) alignas(type) 395#elif V8_HAS___ALIGNOF__ && V8_HAS_ATTRIBUTE_ALIGNED 396# define V8_ALIGNAS(type, alignment) __attribute__((aligned(__alignof__(type)))) 397#else 398# define V8_ALIGNAS(type, alignment) V8_ALIGNED(alignment) 399#endif 400 401 402// This macro returns alignment in bytes (an integer power of two) required for 403// any instance of the given type, which is either complete type, an array type, 404// or a reference type. 405// Use like: 406// size_t alignment = V8_ALIGNOF(double); 407#if V8_HAS_CXX11_ALIGNOF 408# define V8_ALIGNOF(type) alignof(type) 409#elif V8_HAS___ALIGNOF 410# define V8_ALIGNOF(type) __alignof(type) 411#elif V8_HAS___ALIGNOF__ 412# define V8_ALIGNOF(type) __alignof__(type) 413#else 414// Note that alignment of a type within a struct can be less than the 415// alignment of the type stand-alone (because of ancient ABIs), so this 416// should only be used as a last resort. 417namespace v8 { template <typename T> class AlignOfHelper { char c; T t; }; } 418# define V8_ALIGNOF(type) (sizeof(::v8::AlignOfHelper<type>) - sizeof(type)) 419#endif 420 421// Annotate a function indicating the caller must examine the return value. 422// Use like: 423// int foo() WARN_UNUSED_RESULT; 424#if V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT 425#define V8_WARN_UNUSED_RESULT __attribute__((warn_unused_result)) 426#else 427#define V8_WARN_UNUSED_RESULT /* NOT SUPPORTED */ 428#endif 429 430// clang-format on 431 432#endif // V8CONFIG_H_ 433