v8  4.5.103 (node 4.8.7)
V8 is Google's open source JavaScript engine
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
v8config.h
Go to the documentation of this file.
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 // V8_HAS_CXX11_STATIC_ASSERT - static_assert() supported
167 //
168 // Compiler-specific feature detection
169 //
170 // V8_HAS___ALIGNOF - __alignof(type) operator supported
171 // V8_HAS___ALIGNOF__ - __alignof__(type) operator supported
172 // V8_HAS_ATTRIBUTE_ALIGNED - __attribute__((aligned(n))) supported
173 // V8_HAS_ATTRIBUTE_ALWAYS_INLINE - __attribute__((always_inline))
174 // supported
175 // V8_HAS_ATTRIBUTE_DEPRECATED - __attribute__((deprecated)) supported
176 // V8_HAS_ATTRIBUTE_NOINLINE - __attribute__((noinline)) 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___FORCEINLINE - __forceinline supported
194 //
195 // Note that testing for compilers and/or features must be done using #if
196 // not #ifdef. For example, to test for Intel C++ Compiler, use:
197 // #if V8_CC_INTEL
198 // ...
199 // #endif
200 
201 #if defined(__clang__)
202 
203 #if defined(__GNUC__) // Clang in gcc mode.
204 # define V8_CC_GNU 1
205 #endif
206 
207 // Clang defines __alignof__ as alias for __alignof
208 # define V8_HAS___ALIGNOF 1
209 # define V8_HAS___ALIGNOF__ V8_HAS___ALIGNOF
210 
211 # define V8_HAS_ATTRIBUTE_ALIGNED (__has_attribute(aligned))
212 # define V8_HAS_ATTRIBUTE_ALWAYS_INLINE (__has_attribute(always_inline))
213 # define V8_HAS_ATTRIBUTE_DEPRECATED (__has_attribute(deprecated))
214 # define V8_HAS_ATTRIBUTE_NOINLINE (__has_attribute(noinline))
215 # define V8_HAS_ATTRIBUTE_UNUSED (__has_attribute(unused))
216 # define V8_HAS_ATTRIBUTE_VISIBILITY (__has_attribute(visibility))
217 # define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT
218  (__has_attribute(warn_unused_result))
219 
220 # define V8_HAS_BUILTIN_CLZ (__has_builtin(__builtin_clz))
221 # define V8_HAS_BUILTIN_CTZ (__has_builtin(__builtin_ctz))
222 # define V8_HAS_BUILTIN_EXPECT (__has_builtin(__builtin_expect))
223 # define V8_HAS_BUILTIN_FRAME_ADDRESS (__has_builtin(__builtin_frame_address))
224 # define V8_HAS_BUILTIN_POPCOUNT (__has_builtin(__builtin_popcount))
225 # define V8_HAS_BUILTIN_SADD_OVERFLOW (__has_builtin(__builtin_sadd_overflow))
226 # define V8_HAS_BUILTIN_SSUB_OVERFLOW (__has_builtin(__builtin_ssub_overflow))
227 # define V8_HAS_BUILTIN_UADD_OVERFLOW (__has_builtin(__builtin_uadd_overflow))
228 
229 # define V8_HAS_CXX11_ALIGNAS (__has_feature(cxx_alignas))
230 # define V8_HAS_CXX11_STATIC_ASSERT (__has_feature(cxx_static_assert))
231 
232 #elif defined(__GNUC__)
233 
234 # define V8_CC_GNU 1
235 # if defined(__INTEL_COMPILER) // Intel C++ also masquerades as GCC 3.2.0
236 # define V8_CC_INTEL 1
237 # endif
238 # if defined(__MINGW32__)
239 # define V8_CC_MINGW32 1
240 # endif
241 # if defined(__MINGW64__)
242 # define V8_CC_MINGW64 1
243 # endif
244 # define V8_CC_MINGW (V8_CC_MINGW32 || V8_CC_MINGW64)
245 
246 # define V8_HAS___ALIGNOF__ (V8_GNUC_PREREQ(4, 3, 0))
247 
248 # define V8_HAS_ATTRIBUTE_ALIGNED (V8_GNUC_PREREQ(2, 95, 0))
249 // always_inline is available in gcc 4.0 but not very reliable until 4.4.
250 // Works around "sorry, unimplemented: inlining failed" build errors with
251 // older compilers.
252 # define V8_HAS_ATTRIBUTE_ALWAYS_INLINE (V8_GNUC_PREREQ(4, 4, 0))
253 # define V8_HAS_ATTRIBUTE_DEPRECATED (V8_GNUC_PREREQ(3, 4, 0))
254 # define V8_HAS_ATTRIBUTE_DEPRECATED_MESSAGE (V8_GNUC_PREREQ(4, 5, 0))
255 # define V8_HAS_ATTRIBUTE_NOINLINE (V8_GNUC_PREREQ(3, 4, 0))
256 # define V8_HAS_ATTRIBUTE_UNUSED (V8_GNUC_PREREQ(2, 95, 0))
257 # define V8_HAS_ATTRIBUTE_VISIBILITY (V8_GNUC_PREREQ(4, 3, 0))
258 # define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT
259  (!V8_CC_INTEL && V8_GNUC_PREREQ(4, 1, 0))
260 
261 # define V8_HAS_BUILTIN_CLZ (V8_GNUC_PREREQ(3, 4, 0))
262 # define V8_HAS_BUILTIN_CTZ (V8_GNUC_PREREQ(3, 4, 0))
263 # define V8_HAS_BUILTIN_EXPECT (V8_GNUC_PREREQ(2, 96, 0))
264 # define V8_HAS_BUILTIN_FRAME_ADDRESS (V8_GNUC_PREREQ(2, 96, 0))
265 # define V8_HAS_BUILTIN_POPCOUNT (V8_GNUC_PREREQ(3, 4, 0))
266 
267 // g++ requires -std=c++0x or -std=gnu++0x to support C++11 functionality
268 // without warnings (functionality used by the macros below). These modes
269 // are detectable by checking whether __GXX_EXPERIMENTAL_CXX0X__ is defined or,
270 // more standardly, by checking whether __cplusplus has a C++11 or greater
271 // value. Current versions of g++ do not correctly set __cplusplus, so we check
272 // both for forward compatibility.
273 # if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
274 # define V8_HAS_CXX11_ALIGNAS (V8_GNUC_PREREQ(4, 8, 0))
275 # define V8_HAS_CXX11_ALIGNOF (V8_GNUC_PREREQ(4, 8, 0))
276 # define V8_HAS_CXX11_STATIC_ASSERT (V8_GNUC_PREREQ(4, 3, 0))
277 # endif
278 #endif
279 
280 #if defined(_MSC_VER)
281 # define V8_CC_MSVC 1
282 # define V8_HAS___ALIGNOF 1
283 
284 # define V8_HAS_DECLSPEC_ALIGN 1
285 # define V8_HAS_DECLSPEC_DEPRECATED 1
286 # define V8_HAS_DECLSPEC_NOINLINE 1
287 # define V8_HAS_DECLSPEC_SELECTANY 1
288 
289 # define V8_HAS___FORCEINLINE 1
290 
291 #endif
292 
293 
294 // -----------------------------------------------------------------------------
295 // Helper macros
296 
297 // A macro used to make better inlining. Don't bother for debug builds.
298 // Use like:
299 // V8_INLINE int GetZero() { return 0; }
300 #if !defined(DEBUG) && V8_HAS_ATTRIBUTE_ALWAYS_INLINE
301 # define V8_INLINE inline __attribute__((always_inline))
302 #elif !defined(DEBUG) && V8_HAS___FORCEINLINE
303 # define V8_INLINE __forceinline
304 #else
305 # define V8_INLINE inline
306 #endif
307 
308 
309 // A macro used to tell the compiler to never inline a particular function.
310 // Don't bother for debug builds.
311 // Use like:
312 // V8_NOINLINE int GetMinusOne() { return -1; }
313 #if !defined(DEBUG) && V8_HAS_ATTRIBUTE_NOINLINE
314 # define V8_NOINLINE __attribute__((noinline))
315 #elif !defined(DEBUG) && V8_HAS_DECLSPEC_NOINLINE
316 # define V8_NOINLINE __declspec(noinline)
317 #else
318 # define V8_NOINLINE /* NOT SUPPORTED */
319 #endif
320 
321 
322 // A macro (V8_DEPRECATED) to mark classes or functions as deprecated.
323 #if defined(V8_DEPRECATION_WARNINGS) && V8_HAS_ATTRIBUTE_DEPRECATED_MESSAGE
324 #define V8_DEPRECATED(message, declarator)
325  declarator __attribute__((deprecated(message)))
326 #elif defined(V8_DEPRECATION_WARNINGS) && V8_HAS_ATTRIBUTE_DEPRECATED
327 #define V8_DEPRECATED(message, declarator)
328  declarator __attribute__((deprecated))
329 #elif defined(V8_DEPRECATION_WARNINGS) && V8_HAS_DECLSPEC_DEPRECATED
330 #define V8_DEPRECATED(message, declarator) __declspec(deprecated) declarator
331 #else
332 #define V8_DEPRECATED(message, declarator) declarator
333 #endif
334 
335 
336 // A macro (V8_DEPRECATE_SOON) to make it easier to see what will be deprecated.
337 #if defined(V8_IMMINENT_DEPRECATION_WARNINGS) &&
338  V8_HAS_ATTRIBUTE_DEPRECATED_MESSAGE
339 #define V8_DEPRECATE_SOON(message, declarator)
340  declarator __attribute__((deprecated(message)))
341 #elif defined(V8_IMMINENT_DEPRECATION_WARNINGS) && V8_HAS_ATTRIBUTE_DEPRECATED
342 #define V8_DEPRECATE_SOON(message, declarator)
343  declarator __attribute__((deprecated))
344 #elif defined(V8_IMMINENT_DEPRECATION_WARNINGS) && V8_HAS_DECLSPEC_DEPRECATED
345 #define V8_DEPRECATE_SOON(message, declarator) __declspec(deprecated) declarator
346 #else
347 #define V8_DEPRECATE_SOON(message, declarator) declarator
348 #endif
349 
350 
351 // A macro to provide the compiler with branch prediction information.
352 #if V8_HAS_BUILTIN_EXPECT
353 # define V8_UNLIKELY(condition) (__builtin_expect(!!(condition), 0))
354 # define V8_LIKELY(condition) (__builtin_expect(!!(condition), 1))
355 #else
356 # define V8_UNLIKELY(condition) (condition)
357 # define V8_LIKELY(condition) (condition)
358 #endif
359 
360 
361 // This macro allows to specify memory alignment for structs, classes, etc.
362 // Use like:
363 // class V8_ALIGNED(16) MyClass { ... };
364 // V8_ALIGNED(32) int array[42];
365 #if V8_HAS_CXX11_ALIGNAS
366 # define V8_ALIGNED(n) alignas(n)
367 #elif V8_HAS_ATTRIBUTE_ALIGNED
368 # define V8_ALIGNED(n) __attribute__((aligned(n)))
369 #elif V8_HAS_DECLSPEC_ALIGN
370 # define V8_ALIGNED(n) __declspec(align(n))
371 #else
372 # define V8_ALIGNED(n) /* NOT SUPPORTED */
373 #endif
374 
375 
376 // This macro is similar to V8_ALIGNED(), but takes a type instead of size
377 // in bytes. If the compiler does not supports using the alignment of the
378 // |type|, it will align according to the |alignment| instead. For example,
379 // Visual Studio C++ cannot combine __declspec(align) and __alignof. The
380 // |alignment| must be a literal that is used as a kind of worst-case fallback
381 // alignment.
382 // Use like:
383 // struct V8_ALIGNAS(AnotherClass, 16) NewClass { ... };
384 // V8_ALIGNAS(double, 8) int array[100];
385 #if V8_HAS_CXX11_ALIGNAS
386 # define V8_ALIGNAS(type, alignment) alignas(type)
387 #elif V8_HAS___ALIGNOF__ && V8_HAS_ATTRIBUTE_ALIGNED
388 # define V8_ALIGNAS(type, alignment) __attribute__((aligned(__alignof__(type))))
389 #else
390 # define V8_ALIGNAS(type, alignment) V8_ALIGNED(alignment)
391 #endif
392 
393 
394 // This macro returns alignment in bytes (an integer power of two) required for
395 // any instance of the given type, which is either complete type, an array type,
396 // or a reference type.
397 // Use like:
398 // size_t alignment = V8_ALIGNOF(double);
399 #if V8_HAS_CXX11_ALIGNOF
400 # define V8_ALIGNOF(type) alignof(type)
401 #elif V8_HAS___ALIGNOF
402 # define V8_ALIGNOF(type) __alignof(type)
403 #elif V8_HAS___ALIGNOF__
404 # define V8_ALIGNOF(type) __alignof__(type)
405 #else
406 // Note that alignment of a type within a struct can be less than the
407 // alignment of the type stand-alone (because of ancient ABIs), so this
408 // should only be used as a last resort.
409 namespace v8 { template <typename T> class AlignOfHelper { char c; T t; }; }
410 # define V8_ALIGNOF(type) (sizeof(::v8::AlignOfHelper<type>) - sizeof(type))
411 #endif
412 
413 // Annotate a function indicating the caller must examine the return value.
414 // Use like:
415 // int foo() WARN_UNUSED_RESULT;
416 #if V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT
417 #define V8_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
418 #else
419 #define V8_WARN_UNUSED_RESULT /* NOT SUPPORTED */
420 #endif
421 
422 // clang-format on
423 
424 #endif // V8CONFIG_H_