mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
fbe990481b
Recent Swift uses 2 as the is-Swift bit when running on newer versions, and 1 on older versions. Since it's difficult or impossible to know what we'll be running on at build time, make the selection at runtime.
229 lines
8.4 KiB
C++
229 lines
8.4 KiB
C++
//===--- Config.h - Swift Language Platform Configuration -------*- C++ -*-===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Definitions of common interest in Swift.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_RUNTIME_CONFIG_H
|
|
#define SWIFT_RUNTIME_CONFIG_H
|
|
|
|
#include "swift/Runtime/CMakeConfig.h"
|
|
|
|
/// \macro SWIFT_RUNTIME_GNUC_PREREQ
|
|
/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't
|
|
/// available.
|
|
#ifndef SWIFT_RUNTIME_GNUC_PREREQ
|
|
# if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
|
|
# define SWIFT_RUNTIME_GNUC_PREREQ(maj, min, patch) \
|
|
((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
|
|
((maj) << 20) + ((min) << 10) + (patch))
|
|
# elif defined(__GNUC__) && defined(__GNUC_MINOR__)
|
|
# define SWIFT_RUNTIME_GNUC_PREREQ(maj, min, patch) \
|
|
((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
|
|
# else
|
|
# define SWIFT_RUNTIME_GNUC_PREREQ(maj, min, patch) 0
|
|
# endif
|
|
#endif
|
|
|
|
/// SWIFT_RUNTIME_LIBRARY_VISIBILITY - If a class marked with this attribute is
|
|
/// linked into a shared library, then the class should be private to the
|
|
/// library and not accessible from outside it. Can also be used to mark
|
|
/// variables and functions, making them private to any shared library they are
|
|
/// linked into.
|
|
/// On PE/COFF targets, library visibility is the default, so this isn't needed.
|
|
#if (__has_attribute(visibility) || SWIFT_RUNTIME_GNUC_PREREQ(4, 0, 0)) && \
|
|
!defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32)
|
|
#define SWIFT_RUNTIME_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
|
|
#else
|
|
#define SWIFT_RUNTIME_LIBRARY_VISIBILITY
|
|
#endif
|
|
|
|
/// Attributes.
|
|
/// SWIFT_RUNTIME_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
|
|
/// mark a method "not for inlining".
|
|
#if __has_attribute(noinline) || SWIFT_RUNTIME_GNUC_PREREQ(3, 4, 0)
|
|
#define SWIFT_RUNTIME_ATTRIBUTE_NOINLINE __attribute__((noinline))
|
|
#elif defined(_MSC_VER)
|
|
#define SWIFT_RUNTIME_ATTRIBUTE_NOINLINE __declspec(noinline)
|
|
#else
|
|
#define SWIFT_RUNTIME_ATTRIBUTE_NOINLINE
|
|
#endif
|
|
|
|
/// SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
|
|
/// so, mark a method "always inline" because it is performance sensitive. GCC
|
|
/// 3.4 supported this but is buggy in various cases and produces unimplemented
|
|
/// errors, just use it in GCC 4.0 and later.
|
|
#if __has_attribute(always_inline) || SWIFT_RUNTIME_GNUC_PREREQ(4, 0, 0)
|
|
#define SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
|
|
#elif defined(_MSC_VER)
|
|
#define SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE __forceinline
|
|
#else
|
|
#define SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
|
|
#endif
|
|
|
|
#ifdef __GNUC__
|
|
#define SWIFT_RUNTIME_ATTRIBUTE_NORETURN __attribute__((noreturn))
|
|
#elif defined(_MSC_VER)
|
|
#define SWIFT_RUNTIME_ATTRIBUTE_NORETURN __declspec(noreturn)
|
|
#else
|
|
#define SWIFT_RUNTIME_ATTRIBUTE_NORETURN
|
|
#endif
|
|
|
|
/// SWIFT_RUNTIME_BUILTIN_TRAP - On compilers which support it, expands to an expression
|
|
/// which causes the program to exit abnormally.
|
|
#if __has_builtin(__builtin_trap) || SWIFT_RUNTIME_GNUC_PREREQ(4, 3, 0)
|
|
# define SWIFT_RUNTIME_BUILTIN_TRAP __builtin_trap()
|
|
#elif defined(_MSC_VER)
|
|
// The __debugbreak intrinsic is supported by MSVC, does not require forward
|
|
// declarations involving platform-specific typedefs (unlike RaiseException),
|
|
// results in a call to vectored exception handlers, and encodes to a short
|
|
// instruction that still causes the trapping behavior we want.
|
|
# define SWIFT_RUNTIME_BUILTIN_TRAP __debugbreak()
|
|
#else
|
|
# define SWIFT_RUNTIME_BUILTIN_TRAP *(volatile int*)0x11 = 0
|
|
#endif
|
|
|
|
/// Does the current Swift platform support "unbridged" interoperation
|
|
/// with Objective-C? If so, the implementations of various types must
|
|
/// implicitly handle Objective-C pointers.
|
|
///
|
|
/// Apple platforms support this by default.
|
|
#ifndef SWIFT_OBJC_INTEROP
|
|
#ifdef __APPLE__
|
|
#define SWIFT_OBJC_INTEROP 1
|
|
#else
|
|
#define SWIFT_OBJC_INTEROP 0
|
|
#endif
|
|
#endif
|
|
|
|
/// Does the current Swift platform allow information other than the
|
|
/// class pointer to be stored in the isa field? If so, when deriving
|
|
/// the class pointer of an object, we must apply a
|
|
/// dynamically-determined mask to the value loaded from the first
|
|
/// field of the object.
|
|
///
|
|
/// According to the Objective-C ABI, this is true only for 64-bit
|
|
/// platforms.
|
|
#ifndef SWIFT_HAS_ISA_MASKING
|
|
#if SWIFT_OBJC_INTEROP && __POINTER_WIDTH__ == 64
|
|
#define SWIFT_HAS_ISA_MASKING 1
|
|
#else
|
|
#define SWIFT_HAS_ISA_MASKING 0
|
|
#endif
|
|
#endif
|
|
|
|
/// Does the current Swift platform have ISA pointers which should be opaque
|
|
/// to anyone outside the Swift runtime? Similarly to the ISA_MASKING case
|
|
/// above, information other than the class pointer could be contained in the
|
|
/// ISA.
|
|
#ifndef SWIFT_HAS_OPAQUE_ISAS
|
|
#if defined(__arm__) && __ARM_ARCH_7K__ >= 2
|
|
#define SWIFT_HAS_OPAQUE_ISAS 1
|
|
#else
|
|
#define SWIFT_HAS_OPAQUE_ISAS 0
|
|
#endif
|
|
#endif
|
|
|
|
#if SWIFT_HAS_OPAQUE_ISAS && SWIFT_HAS_ISA_MASKING
|
|
#error Masking ISAs are incompatible with opaque ISAs
|
|
#endif
|
|
|
|
/// Which bits in the class metadata are used to distinguish Swift classes
|
|
/// from ObjC classes?
|
|
#ifndef SWIFT_CLASS_IS_SWIFT_MASK
|
|
|
|
// Non-Apple platforms always use 1.
|
|
# if !defined(__APPLE__)
|
|
# define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
|
|
|
|
// Builds for Swift-in-the-OS always use 2.
|
|
# elif SWIFT_BNI_OS_BUILD
|
|
# define SWIFT_CLASS_IS_SWIFT_MASK 2ULL
|
|
|
|
// Builds for Xcode always use 1.
|
|
# elif SWIFT_BNI_XCODE_BUILD
|
|
# define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
|
|
|
|
// Other builds (such as local builds on developers' computers)
|
|
// dynamically choose the bit at runtime based on the current OS
|
|
// version.
|
|
# else
|
|
# define SWIFT_CLASS_IS_SWIFT_MASK _swift_classIsSwiftMask
|
|
# define SWIFT_CLASS_IS_SWIFT_MASK_GLOBAL_VARIABLE 1
|
|
# include "BackDeployment.h"
|
|
|
|
# endif
|
|
#endif
|
|
|
|
// We try to avoid global constructors in the runtime as much as possible.
|
|
// These macros delimit allowed global ctors.
|
|
#if __clang__
|
|
# define SWIFT_ALLOWED_RUNTIME_GLOBAL_CTOR_BEGIN \
|
|
_Pragma("clang diagnostic push") \
|
|
_Pragma("clang diagnostic ignored \"-Wglobal-constructors\"")
|
|
# define SWIFT_ALLOWED_RUNTIME_GLOBAL_CTOR_END \
|
|
_Pragma("clang diagnostic pop")
|
|
#else
|
|
# define SWIFT_ALLOWED_RUNTIME_GLOBAL_CTOR_BEGIN
|
|
# define SWIFT_ALLOWED_RUNTIME_GLOBAL_CTOR_END
|
|
#endif
|
|
|
|
// Bring in visibility attribute macros
|
|
#include "../../../stdlib/public/SwiftShims/Visibility.h"
|
|
|
|
// Define mappings for calling conventions.
|
|
|
|
// Annotation for specifying a calling convention of
|
|
// a runtime function. It should be used with declarations
|
|
// of runtime functions like this:
|
|
// void runtime_function_name() SWIFT_CC(swift)
|
|
#define SWIFT_CC(CC) SWIFT_CC_##CC
|
|
|
|
// SWIFT_CC(c) is the C calling convention.
|
|
#define SWIFT_CC_c
|
|
|
|
// SWIFT_CC(swift) is the Swift calling convention.
|
|
// FIXME: the next comment is false.
|
|
// Functions outside the stdlib or runtime that include this file may be built
|
|
// with a compiler that doesn't support swiftcall; don't define these macros
|
|
// in that case so any incorrect usage is caught.
|
|
#if __has_attribute(swiftcall)
|
|
#define SWIFT_CC_swift __attribute__((swiftcall))
|
|
#define SWIFT_CONTEXT __attribute__((swift_context))
|
|
#define SWIFT_ERROR_RESULT __attribute__((swift_error_result))
|
|
#define SWIFT_INDIRECT_RESULT __attribute__((swift_indirect_result))
|
|
#else
|
|
#define SWIFT_CC_swift
|
|
#define SWIFT_CONTEXT
|
|
#define SWIFT_ERROR_RESULT
|
|
#define SWIFT_INDIRECT_RESULT
|
|
#endif
|
|
|
|
// SWIFT_CC(PreserveMost) is used in the runtime implementation to prevent
|
|
// register spills on the hot path.
|
|
// It is not safe to use for external calls; the loader's lazy function
|
|
// binding may not save all of the registers required for this convention.
|
|
#if __has_attribute(preserve_most) && \
|
|
(defined(__aarch64__) || defined(__x86_64__))
|
|
#define SWIFT_CC_PreserveMost __attribute__((preserve_most))
|
|
#else
|
|
#define SWIFT_CC_PreserveMost
|
|
#endif
|
|
|
|
// This is the DefaultCC value used by the compiler.
|
|
// FIXME: the runtime's code does not honor DefaultCC
|
|
// so changing this value is not sufficient.
|
|
#define SWIFT_DEFAULT_LLVM_CC llvm::CallingConv::C
|
|
|
|
#endif // SWIFT_RUNTIME_CONFIG_H
|