v8config.h 17.1 KB
Newer Older
1
// Copyright 2013 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4 5 6 7

#ifndef V8CONFIG_H_
#define V8CONFIG_H_

8 9 10 11 12 13 14 15
#ifdef V8_GN_HEADER
#if __cplusplus >= 201703L && !__has_include("v8-gn.h")
#error Missing v8-gn.h. The configuration for v8 is missing from the include \
path. Add it with -I<path> to the command line
#endif
#include "v8-gn.h"  // NOLINT(build/include_directory)
#endif

16 17
// clang-format off

18 19 20 21
// Platform headers for feature detection below.
#if defined(__ANDROID__)
# include <sys/cdefs.h>
#elif defined(__APPLE__)
22
# include <TargetConditionals.h>
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
#elif defined(__linux__)
# include <features.h>
#endif


// This macro allows to test for the version of the GNU C library (or
// a compatible C library that masquerades as glibc). It evaluates to
// 0 if libc is not GNU libc or compatible.
// Use like:
//  #if V8_GLIBC_PREREQ(2, 3)
//   ...
//  #endif
#if defined(__GLIBC__) && defined(__GLIBC_MINOR__)
# define V8_GLIBC_PREREQ(major, minor)                                    \
    ((__GLIBC__ * 100 + __GLIBC_MINOR__) >= ((major) * 100 + (minor)))
#else
# define V8_GLIBC_PREREQ(major, minor) 0
#endif


// This macro allows to test for the version of the GNU C++ compiler.
// Note that this also applies to compilers that masquerade as GCC,
// for example clang and the Intel C++ compiler for Linux.
// Use like:
//  #if V8_GNUC_PREREQ(4, 3, 1)
//   ...
//  #endif
#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
# define V8_GNUC_PREREQ(major, minor, patchlevel)                         \
    ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >=   \
     ((major) * 10000 + (minor) * 100 + (patchlevel)))
#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
55 56
# define V8_GNUC_PREREQ(major, minor, patchlevel)      \
    ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >=      \
57 58 59 60 61 62 63
     ((major) * 10000 + (minor) * 100 + (patchlevel)))
#else
# define V8_GNUC_PREREQ(major, minor, patchlevel) 0
#endif



64
// -----------------------------------------------------------------------------
65
// Operating system detection (host)
66 67 68 69 70 71
//
//  V8_OS_ANDROID       - Android
//  V8_OS_BSD           - BSDish (Mac OS X, Net/Free/Open/DragonFlyBSD)
//  V8_OS_CYGWIN        - Cygwin
//  V8_OS_DRAGONFLYBSD  - DragonFlyBSD
//  V8_OS_FREEBSD       - FreeBSD
scottmg's avatar
scottmg committed
72
//  V8_OS_FUCHSIA       - Fuchsia
73 74
//  V8_OS_LINUX         - Linux
//  V8_OS_MACOSX        - Mac OS X
75
//  V8_OS_IOS           - iOS
76 77 78
//  V8_OS_NETBSD        - NetBSD
//  V8_OS_OPENBSD       - OpenBSD
//  V8_OS_POSIX         - POSIX compatible (mostly everything except Windows)
79
//  V8_OS_QNX           - QNX Neutrino
80
//  V8_OS_SOLARIS       - Sun Solaris and OpenSolaris
johnx's avatar
johnx committed
81
//  V8_OS_STARBOARD     - Starboard (platform abstraction for Cobalt)
82
//  V8_OS_AIX           - AIX
83 84 85 86 87 88
//  V8_OS_WIN           - Microsoft Windows

#if defined(__ANDROID__)
# define V8_OS_ANDROID 1
# define V8_OS_LINUX 1
# define V8_OS_POSIX 1
89 90
# define V8_OS_STRING "android"

91 92 93 94
#elif defined(__APPLE__)
# define V8_OS_BSD 1
# define V8_OS_MACOSX 1
# define V8_OS_POSIX 1
95 96
# if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
#  define V8_OS_IOS 1
97 98 99
#  define V8_OS_STRING "ios"
# else
#  define V8_OS_STRING "macos"
100
# endif  // defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
101

102 103 104
#elif defined(__CYGWIN__)
# define V8_OS_CYGWIN 1
# define V8_OS_POSIX 1
105 106
# define V8_OS_STRING "cygwin"

107 108 109
#elif defined(__linux__)
# define V8_OS_LINUX 1
# define V8_OS_POSIX 1
110 111
# define V8_OS_STRING "linux"

112 113 114
#elif defined(__sun)
# define V8_OS_POSIX 1
# define V8_OS_SOLARIS 1
115 116
# define V8_OS_STRING "sun"

johnx's avatar
johnx committed
117 118
#elif defined(STARBOARD)
# define V8_OS_STARBOARD 1
119 120
# define V8_OS_STRING "starboard"

121
#elif defined(_AIX)
122 123 124 125
# define V8_OS_POSIX 1
# define V8_OS_AIX 1
# define V8_OS_STRING "aix"

126 127 128 129
#elif defined(__FreeBSD__)
# define V8_OS_BSD 1
# define V8_OS_FREEBSD 1
# define V8_OS_POSIX 1
130 131
# define V8_OS_STRING "freebsd"

scottmg's avatar
scottmg committed
132 133 134
#elif defined(__Fuchsia__)
# define V8_OS_FUCHSIA 1
# define V8_OS_POSIX 1
135 136
# define V8_OS_STRING "fuchsia"

137 138 139 140
#elif defined(__DragonFly__)
# define V8_OS_BSD 1
# define V8_OS_DRAGONFLYBSD 1
# define V8_OS_POSIX 1
141 142
# define V8_OS_STRING "dragonflybsd"

143 144 145 146
#elif defined(__NetBSD__)
# define V8_OS_BSD 1
# define V8_OS_NETBSD 1
# define V8_OS_POSIX 1
147 148
# define V8_OS_STRING "netbsd"

149 150 151 152
#elif defined(__OpenBSD__)
# define V8_OS_BSD 1
# define V8_OS_OPENBSD 1
# define V8_OS_POSIX 1
153 154
# define V8_OS_STRING "openbsd"

155 156 157
#elif defined(__QNXNTO__)
# define V8_OS_POSIX 1
# define V8_OS_QNX 1
158 159
# define V8_OS_STRING "qnx"

160 161
#elif defined(_WIN32)
# define V8_OS_WIN 1
162
# define V8_OS_STRING "windows"
163 164
#endif

165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
// -----------------------------------------------------------------------------
// Operating system detection (target)
//
//  V8_TARGET_OS_ANDROID
//  V8_TARGET_OS_FUCHSIA
//  V8_TARGET_OS_IOS
//  V8_TARGET_OS_LINUX
//  V8_TARGET_OS_MACOSX
//  V8_TARGET_OS_WIN
//
// If not set explicitly, these fall back to corresponding V8_OS_ values.

#ifdef V8_HAVE_TARGET_OS

// The target OS is provided, just check that at least one known value is set.
# if !defined(V8_TARGET_OS_ANDROID) \
  && !defined(V8_TARGET_OS_FUCHSIA) \
  && !defined(V8_TARGET_OS_IOS) \
  && !defined(V8_TARGET_OS_LINUX) \
  && !defined(V8_TARGET_OS_MACOSX) \
  && !defined(V8_TARGET_OS_WIN)
#  error No known target OS defined.
# endif

#else  // V8_HAVE_TARGET_OS

# if defined(V8_TARGET_OS_ANDROID) \
  || defined(V8_TARGET_OS_FUCHSIA) \
  || defined(V8_TARGET_OS_IOS) \
  || defined(V8_TARGET_OS_LINUX) \
  || defined(V8_TARGET_OS_MACOSX) \
  || defined(V8_TARGET_OS_WIN)
#  error A target OS is defined but V8_HAVE_TARGET_OS is unset.
# endif

// Fall back to the detected host OS.
#ifdef V8_OS_ANDROID
# define V8_TARGET_OS_ANDROID
#endif

#ifdef V8_OS_FUCHSIA
# define V8_TARGET_OS_FUCHSIA
#endif

#ifdef V8_OS_IOS
# define V8_TARGET_OS_IOS
#endif

#ifdef V8_OS_LINUX
# define V8_TARGET_OS_LINUX
#endif

#ifdef V8_OS_MACOSX
# define V8_TARGET_OS_MACOSX
#endif

#ifdef V8_OS_WIN
# define V8_TARGET_OS_WIN
#endif

#endif  // V8_HAVE_TARGET_OS
226

227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
#if defined(V8_TARGET_OS_ANDROID)
# define V8_TARGET_OS_STRING "android"
#elif defined(V8_TARGET_OS_FUCHSIA)
# define V8_TARGET_OS_STRING "fuchsia"
#elif defined(V8_TARGET_OS_IOS)
# define V8_TARGET_OS_STRING "ios"
#elif defined(V8_TARGET_OS_LINUX)
# define V8_TARGET_OS_STRING "linux"
#elif defined(V8_TARGET_OS_MACOSX)
# define V8_TARGET_OS_STRING "macos"
#elif defined(V8_TARGET_OS_WINDOWS)
# define V8_TARGET_OS_STRING "windows"
#else
# define V8_TARGET_OS_STRING "unknown"
#endif

243 244 245
// -----------------------------------------------------------------------------
// C library detection
//
246
//  V8_LIBC_MSVCRT  - MSVC libc
247 248 249
//  V8_LIBC_BIONIC  - Bionic libc
//  V8_LIBC_BSD     - BSD libc derivate
//  V8_LIBC_GLIBC   - GNU C library
250
//  V8_LIBC_UCLIBC  - uClibc
251 252 253 254 255 256 257
//
// Note that testing for libc must be done using #if not #ifdef. For example,
// to test for the GNU C library, use:
//  #if V8_LIBC_GLIBC
//   ...
//  #endif

258 259 260
#if defined (_MSC_VER)
# define V8_LIBC_MSVCRT 1
#elif defined(__BIONIC__)
261 262
# define V8_LIBC_BIONIC 1
# define V8_LIBC_BSD 1
263 264 265
#elif defined(__UCLIBC__)
// Must test for UCLIBC before GLIBC, as UCLIBC pretends to be GLIBC.
# define V8_LIBC_UCLIBC 1
266 267 268 269 270 271 272
#elif defined(__GLIBC__) || defined(__GNU_LIBRARY__)
# define V8_LIBC_GLIBC 1
#else
# define V8_LIBC_BSD V8_OS_BSD
#endif


273 274 275
// -----------------------------------------------------------------------------
// Compiler detection
//
276
//  V8_CC_GNU     - GCC, or clang in gcc mode
277
//  V8_CC_INTEL   - Intel C++
278
//  V8_CC_MINGW   - Minimalist GNU for Windows
279 280
//  V8_CC_MINGW32 - Minimalist GNU for Windows (mingw32)
//  V8_CC_MINGW64 - Minimalist GNU for Windows (mingw-w64)
281
//  V8_CC_MSVC    - Microsoft Visual C/C++, or clang in cl.exe mode
282 283 284 285 286
//
// C++11 feature detection
//
// Compiler-specific feature detection
//
287 288
//  V8_HAS_ATTRIBUTE_ALWAYS_INLINE      - __attribute__((always_inline))
//                                        supported
289
//  V8_HAS_ATTRIBUTE_NONNULL            - __attribute__((nonnull)) supported
290
//  V8_HAS_ATTRIBUTE_NOINLINE           - __attribute__((noinline)) supported
291
//  V8_HAS_ATTRIBUTE_UNUSED             - __attribute__((unused)) supported
292 293 294
//  V8_HAS_ATTRIBUTE_VISIBILITY         - __attribute__((visibility)) supported
//  V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT - __attribute__((warn_unused_result))
//                                        supported
295
//  V8_HAS_CPP_ATTRIBUTE_NODISCARD      - [[nodiscard]] supported
296 297 298
//  V8_HAS_BUILTIN_BSWAP16              - __builtin_bswap16() supported
//  V8_HAS_BUILTIN_BSWAP32              - __builtin_bswap32() supported
//  V8_HAS_BUILTIN_BSWAP64              - __builtin_bswap64() supported
299 300
//  V8_HAS_BUILTIN_CLZ                  - __builtin_clz() supported
//  V8_HAS_BUILTIN_CTZ                  - __builtin_ctz() supported
301
//  V8_HAS_BUILTIN_EXPECT               - __builtin_expect() supported
302
//  V8_HAS_BUILTIN_FRAME_ADDRESS        - __builtin_frame_address() supported
303
//  V8_HAS_BUILTIN_POPCOUNT             - __builtin_popcount() supported
304 305
//  V8_HAS_BUILTIN_SADD_OVERFLOW        - __builtin_sadd_overflow() supported
//  V8_HAS_BUILTIN_SSUB_OVERFLOW        - __builtin_ssub_overflow() supported
306
//  V8_HAS_BUILTIN_UADD_OVERFLOW        - __builtin_uadd_overflow() supported
307 308
//  V8_HAS_COMPUTED_GOTO                - computed goto/labels as values
//                                        supported
309
//  V8_HAS_DECLSPEC_NOINLINE            - __declspec(noinline) supported
310
//  V8_HAS_DECLSPEC_SELECTANY           - __declspec(selectany) supported
311 312 313 314 315 316 317
//  V8_HAS___FORCEINLINE                - __forceinline supported
//
// Note that testing for compilers and/or features must be done using #if
// not #ifdef. For example, to test for Intel C++ Compiler, use:
//  #if V8_CC_INTEL
//   ...
//  #endif
318

319 320 321 322 323 324
#if defined(__has_cpp_attribute)
#define V8_HAS_CPP_ATTRIBUTE(FEATURE) __has_cpp_attribute(FEATURE)
#else
#define V8_HAS_CPP_ATTRIBUTE(FEATURE) 0
#endif

325 326
#if defined(__clang__)

327 328 329
#if defined(__GNUC__)  // Clang in gcc mode.
# define V8_CC_GNU 1
#endif
330

331
# define V8_HAS_ATTRIBUTE_ALWAYS_INLINE (__has_attribute(always_inline))
332
# define V8_HAS_ATTRIBUTE_NONNULL (__has_attribute(nonnull))
333
# define V8_HAS_ATTRIBUTE_NOINLINE (__has_attribute(noinline))
334
# define V8_HAS_ATTRIBUTE_UNUSED (__has_attribute(unused))
335
# define V8_HAS_ATTRIBUTE_VISIBILITY (__has_attribute(visibility))
336 337
# define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT \
    (__has_attribute(warn_unused_result))
338

339 340
# define V8_HAS_CPP_ATTRIBUTE_NODISCARD (V8_HAS_CPP_ATTRIBUTE(nodiscard))

341
# define V8_HAS_BUILTIN_ASSUME_ALIGNED (__has_builtin(__builtin_assume_aligned))
342 343 344
# define V8_HAS_BUILTIN_BSWAP16 (__has_builtin(__builtin_bswap16))
# define V8_HAS_BUILTIN_BSWAP32 (__has_builtin(__builtin_bswap32))
# define V8_HAS_BUILTIN_BSWAP64 (__has_builtin(__builtin_bswap64))
345 346
# define V8_HAS_BUILTIN_CLZ (__has_builtin(__builtin_clz))
# define V8_HAS_BUILTIN_CTZ (__has_builtin(__builtin_ctz))
347
# define V8_HAS_BUILTIN_EXPECT (__has_builtin(__builtin_expect))
348
# define V8_HAS_BUILTIN_FRAME_ADDRESS (__has_builtin(__builtin_frame_address))
349
# define V8_HAS_BUILTIN_POPCOUNT (__has_builtin(__builtin_popcount))
350 351
# define V8_HAS_BUILTIN_SADD_OVERFLOW (__has_builtin(__builtin_sadd_overflow))
# define V8_HAS_BUILTIN_SSUB_OVERFLOW (__has_builtin(__builtin_ssub_overflow))
352
# define V8_HAS_BUILTIN_UADD_OVERFLOW (__has_builtin(__builtin_uadd_overflow))
353

354 355 356 357
// Clang has no __has_feature for computed gotos.
// GCC doc: https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html
# define V8_HAS_COMPUTED_GOTO 1

358 359 360
#elif defined(__GNUC__)

# define V8_CC_GNU 1
361 362 363 364 365 366 367 368 369
# if defined(__INTEL_COMPILER)  // Intel C++ also masquerades as GCC 3.2.0
#  define V8_CC_INTEL 1
# endif
# if defined(__MINGW32__)
#  define V8_CC_MINGW32 1
# endif
# if defined(__MINGW64__)
#  define V8_CC_MINGW64 1
# endif
370
# define V8_CC_MINGW (V8_CC_MINGW32 || V8_CC_MINGW64)
371

372 373 374
// always_inline is available in gcc 4.0 but not very reliable until 4.4.
// Works around "sorry, unimplemented: inlining failed" build errors with
// older compilers.
375 376 377 378 379
# define V8_HAS_ATTRIBUTE_ALWAYS_INLINE 1
# define V8_HAS_ATTRIBUTE_NOINLINE 1
# define V8_HAS_ATTRIBUTE_UNUSED 1
# define V8_HAS_ATTRIBUTE_VISIBILITY 1
# define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT (!V8_CC_INTEL)
380 381 382 383

// [[nodiscard]] does not work together with with
// __attribute__((visibility(""))) on GCC 7.4 which is why there is no define
// for V8_HAS_CPP_ATTRIBUTE_NODISCARD. See https://crbug.com/v8/11707.
384 385 386 387 388 389 390

# define V8_HAS_BUILTIN_ASSUME_ALIGNED 1
# define V8_HAS_BUILTIN_CLZ 1
# define V8_HAS_BUILTIN_CTZ 1
# define V8_HAS_BUILTIN_EXPECT 1
# define V8_HAS_BUILTIN_FRAME_ADDRESS 1
# define V8_HAS_BUILTIN_POPCOUNT 1
391

392
// GCC doc: https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html
393
#define V8_HAS_COMPUTED_GOTO 1
394

395
#endif
396

397
#if defined(_MSC_VER)
398
# define V8_CC_MSVC 1
399

400
# define V8_HAS_DECLSPEC_NOINLINE 1
401
# define V8_HAS_DECLSPEC_SELECTANY 1
402 403 404 405 406 407 408 409 410 411

# define V8_HAS___FORCEINLINE 1

#endif


// -----------------------------------------------------------------------------
// Helper macros

// A macro used to make better inlining. Don't bother for debug builds.
412 413
// Use like:
//   V8_INLINE int GetZero() { return 0; }
414
#if !defined(DEBUG) && V8_HAS_ATTRIBUTE_ALWAYS_INLINE
415
# define V8_INLINE inline __attribute__((always_inline))
416
#elif !defined(DEBUG) && V8_HAS___FORCEINLINE
417
# define V8_INLINE __forceinline
418
#else
419
# define V8_INLINE inline
420 421
#endif

422 423 424 425
#if V8_HAS_BUILTIN_ASSUME_ALIGNED
# define V8_ASSUME_ALIGNED(ptr, alignment) \
  __builtin_assume_aligned((ptr), (alignment))
#else
426
# define V8_ASSUME_ALIGNED(ptr, alignment) (ptr)
427
#endif
428

429 430 431 432 433 434 435 436 437 438 439

// A macro to mark specific arguments as non-null.
// Use like:
//   int add(int* x, int y, int* z) V8_NONNULL(1, 3) { return *x + y + *z; }
#if V8_HAS_ATTRIBUTE_NONNULL
# define V8_NONNULL(...) __attribute__((nonnull(__VA_ARGS__)))
#else
# define V8_NONNULL(...) /* NOT SUPPORTED */
#endif


440
// A macro used to tell the compiler to never inline a particular function.
441 442
// Use like:
//   V8_NOINLINE int GetMinusOne() { return -1; }
443
#if V8_HAS_ATTRIBUTE_NOINLINE
444
# define V8_NOINLINE __attribute__((noinline))
445
#elif V8_HAS_DECLSPEC_NOINLINE
446
# define V8_NOINLINE __declspec(noinline)
447
#else
448
# define V8_NOINLINE /* NOT SUPPORTED */
449 450 451
#endif


452
// A macro (V8_DEPRECATED) to mark classes or functions as deprecated.
453 454
#if defined(V8_DEPRECATION_WARNINGS)
# define V8_DEPRECATED(message) [[deprecated(message)]]
455
#else
456
# define V8_DEPRECATED(message)
457 458 459
#endif


460
// A macro (V8_DEPRECATE_SOON) to make it easier to see what will be deprecated.
461 462
#if defined(V8_IMMINENT_DEPRECATION_WARNINGS)
# define V8_DEPRECATE_SOON(message) [[deprecated(message)]]
463
#else
464
# define V8_DEPRECATE_SOON(message)
465
#endif
466 467


468 469 470 471 472 473 474 475 476
#if defined(__GNUC__) && !defined(__clang__) && (__GNUC__ < 6)
# define V8_ENUM_DEPRECATED(message)
# define V8_ENUM_DEPRECATE_SOON(message)
#else
# define V8_ENUM_DEPRECATED(message) V8_DEPRECATED(message)
# define V8_ENUM_DEPRECATE_SOON(message) V8_DEPRECATE_SOON(message)
#endif


477 478 479 480 481 482 483 484 485 486
// A macro to provide the compiler with branch prediction information.
#if V8_HAS_BUILTIN_EXPECT
# define V8_UNLIKELY(condition) (__builtin_expect(!!(condition), 0))
# define V8_LIKELY(condition) (__builtin_expect(!!(condition), 1))
#else
# define V8_UNLIKELY(condition) (condition)
# define V8_LIKELY(condition) (condition)
#endif


487 488
// Annotate a function indicating the caller must examine the return value.
// Use like:
489
//   int foo() V8_WARN_UNUSED_RESULT;
490 491 492 493 494 495
#if V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT
#define V8_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
#else
#define V8_WARN_UNUSED_RESULT /* NOT SUPPORTED */
#endif

496 497 498 499 500 501 502 503 504 505 506 507 508 509

// Annotate a class or constructor indicating the caller must assign the
// constructed instances.
// Apply to the whole class like:
//   class V8_NODISCARD Foo() { ... };
// or apply to just one constructor like:
//   V8_NODISCARD Foo() { ... };
// [[nodiscard]] comes in C++17 but supported in clang with -std >= c++11.
#if V8_HAS_CPP_ATTRIBUTE_NODISCARD
#define V8_NODISCARD [[nodiscard]]
#else
#define V8_NODISCARD /* NOT SUPPORTED */
#endif

510 511 512 513 514 515 516 517 518 519
// Helper macro to define no_sanitize attributes only with clang.
#if defined(__clang__) && defined(__has_attribute)
#if __has_attribute(no_sanitize)
#define V8_CLANG_NO_SANITIZE(what) __attribute__((no_sanitize(what)))
#endif
#endif
#if !defined(V8_CLANG_NO_SANITIZE)
#define V8_CLANG_NO_SANITIZE(what)
#endif

520 521 522 523 524 525
#if defined(BUILDING_V8_SHARED) && defined(USING_V8_SHARED)
#error Inconsistent build configuration: To build the V8 shared library \
set BUILDING_V8_SHARED, to include its headers for linking against the \
V8 shared library set USING_V8_SHARED.
#endif

526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
#ifdef V8_OS_WIN

// Setup for Windows DLL export/import. When building the V8 DLL the
// BUILDING_V8_SHARED needs to be defined. When building a program which uses
// the V8 DLL USING_V8_SHARED needs to be defined. When either building the V8
// static library or building a program which uses the V8 static library neither
// BUILDING_V8_SHARED nor USING_V8_SHARED should be defined.
#ifdef BUILDING_V8_SHARED
# define V8_EXPORT __declspec(dllexport)
#elif USING_V8_SHARED
# define V8_EXPORT __declspec(dllimport)
#else
# define V8_EXPORT
#endif  // BUILDING_V8_SHARED

#else  // V8_OS_WIN

// Setup for Linux shared library export.
#if V8_HAS_ATTRIBUTE_VISIBILITY
# ifdef BUILDING_V8_SHARED
#  define V8_EXPORT __attribute__ ((visibility("default")))
# else
#  define V8_EXPORT
# endif
#else
# define V8_EXPORT
#endif

#endif  // V8_OS_WIN

556 557
// clang-format on

558 559
#undef V8_HAS_CPP_ATTRIBUTE

560
#endif  // V8CONFIG_H_