mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
84a1ffcb33
This replaces a number of `#include`-s like this:
```
#include "../../../stdlib/public/SwiftShims/Visibility.h"
```
with this:
```
#include "swift/shims/Visibility.h"
```
This is needed to allow SwiftCompilerSources to use C++ headers which include SwiftShims headers. Currently trying to do that results in errors:
```
swift/swift/include/swift/Demangling/../../../stdlib/public/SwiftShims/module.modulemap:1:8: error: redefinition of module 'SwiftShims'
module SwiftShims {
^
Builds.noindex/swift/swift/bootstrapping0/lib/swift/shims/module.modulemap:1:8: note: previously defined here
module SwiftShims {
^
```
This happens because the headers in both the source dir and the build dir refer to SwiftShims headers by relative path, and both the source root and the build root contain SwiftShims headers (which are equivalent, but since they are located in different dirs, Clang treats them as different modules).
146 lines
5.6 KiB
C
146 lines
5.6 KiB
C
//===--- RuntimeShims.h - Access to runtime facilities for the core -------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Runtime functions and structures needed by the core stdlib are
|
|
// declared here.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_STDLIB_SHIMS_RUNTIMESHIMS_H
|
|
#define SWIFT_STDLIB_SHIMS_RUNTIMESHIMS_H
|
|
|
|
#include "SwiftStdbool.h"
|
|
#include "SwiftStddef.h"
|
|
#include "SwiftStdint.h"
|
|
#include "SwiftStdbool.h"
|
|
#include "Visibility.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/// Return an NSString to be used as the Mirror summary of the object
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
void *_swift_objCMirrorSummary(const void * nsObject);
|
|
|
|
/// Call strtold_l with the C locale, swapping argument and return
|
|
/// types so we can operate on Float80.
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
const char *_swift_stdlib_strtold_clocale(const char *nptr, void *outResult);
|
|
/// Call strtod_l with the C locale, swapping argument and return
|
|
/// types so we can operate consistently on Float80.
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
const char *_swift_stdlib_strtod_clocale(const char *nptr, double *outResult);
|
|
/// Call strtof_l with the C locale, swapping argument and return
|
|
/// types so we can operate consistently on Float80.
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
const char *_swift_stdlib_strtof_clocale(const char *nptr, float *outResult);
|
|
/// Call strtof_l with the C locale, swapping argument and return
|
|
/// types so we can operate consistently on Float80.
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
const char *_swift_stdlib_strtof16_clocale(const char *nptr, __fp16 *outResult);
|
|
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
void _swift_stdlib_immortalize(void *obj);
|
|
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
void _swift_stdlib_flockfile_stdout(void);
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
void _swift_stdlib_funlockfile_stdout(void);
|
|
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
int _swift_stdlib_putc_stderr(int C);
|
|
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
__swift_size_t _swift_stdlib_getHardwareConcurrency(void);
|
|
|
|
#ifdef __swift__
|
|
/// Called by ReflectionMirror in stdlib through C-calling-convention
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
__swift_bool swift_isClassType(const void *type);
|
|
#endif
|
|
|
|
/// Manually allocated memory is at least 16-byte aligned in Swift.
|
|
///
|
|
/// When swift_slowAlloc is called with "default" alignment (alignMask ==
|
|
/// ~(size_t(0))), it will execute the "aligned allocation path" (AlignedAlloc)
|
|
/// using this value for the alignment.
|
|
///
|
|
/// This is done so users do not need to specify the allocation alignment when
|
|
/// manually deallocating memory via Unsafe[Raw][Buffer]Pointer. Any
|
|
/// user-specified alignment less than or equal to _swift_MinAllocationAlignment
|
|
/// results in a runtime request for "default" alignment. This guarantees that
|
|
/// manual allocation always uses an "aligned" runtime allocation. If an
|
|
/// allocation is "aligned" then it must be freed using an "aligned"
|
|
/// deallocation. The converse must also hold. Since manual Unsafe*Pointer
|
|
/// deallocation is always "aligned", the user never needs to specify alignment
|
|
/// during deallocation.
|
|
///
|
|
/// This value is inlined (and constant propagated) in user code. On Windows,
|
|
/// the Swift runtime and user binaries need to agree on this value.
|
|
#define _swift_MinAllocationAlignment (__swift_size_t) 16
|
|
|
|
/// Checks if the @em current thread's stack has room for an allocation with
|
|
/// the specified size and alignment.
|
|
///
|
|
/// @param byteCount The size of the desired allocation in bytes.
|
|
/// @param alignment The alignment of the desired allocation in bytes.
|
|
///
|
|
/// @returns Whether or not the desired allocation can be safely performed on
|
|
/// the current thread's stack.
|
|
///
|
|
/// This function is used by
|
|
/// @c withUnsafeTemporaryAllocation(byteCount:alignment:_:).
|
|
SWIFT_RUNTIME_STDLIB_API
|
|
#if defined(__APPLE__) && defined(__MACH__)
|
|
SWIFT_WEAK_IMPORT
|
|
#endif
|
|
__swift_bool swift_stdlib_isStackAllocationSafe(__swift_size_t byteCount,
|
|
__swift_size_t alignment);
|
|
|
|
/// Get the bounds of the current thread's stack.
|
|
///
|
|
/// @param outBegin On successful return, the beginning (lower bound) of the
|
|
/// current thread's stack.
|
|
/// @param outEnd On successful return, the end (upper bound) of the current
|
|
/// thread's stack.
|
|
///
|
|
/// @returns Whether or not the stack bounds could be read. Not all platforms
|
|
/// support reading these values.
|
|
///
|
|
/// This function is used by the stdlib test suite when testing
|
|
/// @c withUnsafeTemporaryAllocation(byteCount:alignment:_:).
|
|
SWIFT_RUNTIME_STDLIB_SPI
|
|
__swift_bool _swift_stdlib_getCurrentStackBounds(__swift_uintptr_t *outBegin,
|
|
__swift_uintptr_t *outEnd);
|
|
|
|
/// A value representing a version number for the Standard Library.
|
|
typedef struct {
|
|
__swift_uint32_t _value;
|
|
} _SwiftStdlibVersion;
|
|
|
|
/// Checks if the currently running executable was built using a Swift release
|
|
/// matching or exceeding the specified Standard Library version number. This
|
|
/// can be used to stage behavioral changes in the Standard Library, preventing
|
|
/// them from causing compatibility issues with existing binaries.
|
|
SWIFT_RUNTIME_STDLIB_INTERNAL
|
|
__swift_bool _swift_stdlib_isExecutableLinkedOnOrAfter(
|
|
_SwiftStdlibVersion version
|
|
) __attribute__((const));
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
|
|
#endif // SWIFT_STDLIB_SHIMS_RUNTIMESHIMS_H
|
|
|