mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
ce1112126c
This could fail to build due to BackDeployment.h not always being included in Config.h. Check an additional condition to ensure that this code is only active when BackDeployment.h is included. rdar://problem/56735154
230 lines
8.4 KiB
C++
230 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
|
|
# define SWIFT_BUILD_HAS_BACK_DEPLOYMENT 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
|