@swiftbrowser/wasm-sdk 0.0.0-stage → 0.9.1

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/Reflection.h

@@ -0,0 +1,36 @@
+//===--- Reflection.h - Types for access to reflection metadata. ----------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_REFLECTION_H
+#define SWIFT_STDLIB_SHIMS_REFLECTION_H
+
+#include "SwiftStdbool.h"
+#include "SwiftStdint.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*NameFreeFunc)(const char*);
+
+typedef struct _FieldReflectionMetadata {
+  const char* name;
+  NameFreeFunc freeFunc;
+  __swift_bool isStrong;
+  __swift_bool isVar;
+} _FieldReflectionMetadata;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // SWIFT_STDLIB_SHIMS_REFLECTION_H

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/RuntimeShims.h

@@ -0,0 +1,161 @@
+//===--- 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);
+
+// Caveat: _swift_stdlib_strto{f,d,ld}_clocale() was called directly from inlineable
+// code until Feb 2020 (commit 4d0e2adbef4d changed this), so they need to be
+// exported with the same C-callable ABI for as long as we support code compiled
+// with Swift 5.3.
+
+// _swift_stdlib_strto{d,f,f16}_clocale were reimplemented in
+// Swift in Dec 2025.  See FloatingPointFromString.swift
+// _swift_stdlib_strtold_clocale was not reimplemented at that time.
+
+/// 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.
+// FIXME? Can this be deleted?  _swift_stdlib_strtof16_clocale was never
+// actually called from inlineable code.
+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));
+
+/// Redeclare _swift_disableExclusivityChecking from Exclusivity.h for use in
+/// Exclusivity.swift
+SWIFT_RUNTIME_EXPORT
+__swift_bool _swift_disableExclusivityChecking;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // SWIFT_STDLIB_SHIMS_RUNTIMESHIMS_H
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/RuntimeStubs.h

@@ -0,0 +1,61 @@
+//===--- RuntimeStubs.h -----------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Misc stubs for functions which should be defined in the core standard
+// library, but are difficult or impossible to write in Swift at the
+// moment.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_RUNTIMESTUBS_H_
+#define SWIFT_STDLIB_SHIMS_RUNTIMESTUBS_H_
+
+#include "LibcShims.h"
+#include "Visibility.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
+
+SWIFT_RUNTIME_STDLIB_API
+__swift_ssize_t
+swift_stdlib_readLine_stdin(unsigned char * _Nullable * _Nonnull LinePtr);
+
+// Pick a return-address strategy
+#if defined(__wasm__)
+// Wasm can't access call frame for security purposes
+#define get_return_address() ((void*) 0)
+#elif __GNUC__
+#define get_return_address() __builtin_return_address(0)
+#elif _MSC_VER
+#include <intrin.h>
+#define get_return_address() _ReturnAddress()
+#else
+#error missing implementation for get_return_address
+#define get_return_address() ((void*) 0)
+#endif
+
+SWIFT_ALWAYS_INLINE
+static inline const void *_Nullable _swift_stdlib_get_return_address() {
+  return get_return_address();
+}
+
+SWIFT_END_NULLABILITY_ANNOTATIONS
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // SWIFT_STDLIB_SHIMS_RUNTIMESTUBS_H_
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/SwiftStdbool.h

@@ -0,0 +1,23 @@
+//===------------------------------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_SWIFTSTDBOOL_H_
+#define SWIFT_STDLIB_SHIMS_SWIFTSTDBOOL_H_
+
+#ifdef __cplusplus
+typedef bool __swift_bool;
+#else
+typedef _Bool __swift_bool;
+#endif
+
+#endif
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/SwiftStddef.h

@@ -0,0 +1,53 @@
+//===--- SwiftStddef.h ------------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_SWIFT_STDDEF_H
+#define SWIFT_STDLIB_SHIMS_SWIFT_STDDEF_H
+
+// stddef.h is provided by Clang, but it dispatches to libc's stddef.h.  As a
+// result, using stddef.h here would pull in Darwin module (which includes
+// libc). This creates a dependency cycle, so we can't use stddef.h in
+// SwiftShims.
+//
+// On Linux, the story is different. We get the error message
+// "/usr/include/x86_64-linux-gnu/sys/types.h:146:10: error: 'stddef.h' file not
+// found"
+// This is a known Clang/Ubuntu bug.
+//
+// On Windows, the complicated setup between clang and MSVC causes a circular
+// dependency between `ucrt` and `SwiftShims`, preventing a successful build of
+// the module.
+//
+// Opt to use the compiler vended type whenever possible.
+#if defined(__clang__)
+typedef __SIZE_TYPE__ __swift_size_t;
+#else
+#include <stddef.h>
+typedef size_t __swift_size_t;
+#endif
+
+// This selects the signed equivalent of the unsigned type chosen for size_t.
+#if __STDC_VERSION__-0 >= 201112l || defined(__swift__)
+typedef __typeof__(_Generic((__swift_size_t)0,                                 \
+                            unsigned long long int : (long long int)0,         \
+                            unsigned long int : (long int)0,                   \
+                            unsigned int : (int)0,                             \
+                            unsigned short : (short)0,                         \
+                            unsigned char : (signed char)0)) __swift_ssize_t;
+#elif defined(__cplusplus)
+#include <type_traits>
+using __swift_ssize_t = std::make_signed<__swift_size_t>::type;
+#else
+#error "do not have __swift_ssize_t defined"
+#endif
+
+#endif // SWIFT_STDLIB_SHIMS_SWIFT_STDDEF_H

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/SwiftStdint.h

@@ -0,0 +1,89 @@
+//===--- SwiftStdint.h ------------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_SWIFT_STDINT_H
+#define SWIFT_STDLIB_SHIMS_SWIFT_STDINT_H
+
+// stdint.h is provided by Clang, but it dispatches to libc's stdint.h.  As a
+// result, using stdint.h here would pull in Darwin module (which includes
+// libc). This creates a dependency cycle, so we can't use stdint.h in
+// SwiftShims.
+// On Linux, the story is different. We get the error message
+// "/usr/include/x86_64-linux-gnu/sys/types.h:146:10: error: 'stddef.h' file not
+// found"
+// This is a known Clang/Ubuntu bug.
+
+// Clang has been defining __INTxx_TYPE__ macros for a long time.
+// __UINTxx_TYPE__ are defined only since Clang 3.5.
+#if !defined(__APPLE__) && !defined(__linux__) && !defined(__OpenBSD__) && !defined(__FreeBSD__) && !defined(__wasi__) && !defined(__swift_embedded__)
+#include <stdint.h>
+typedef int64_t __swift_int64_t;
+typedef uint64_t __swift_uint64_t;
+typedef int32_t __swift_int32_t;
+typedef uint32_t __swift_uint32_t;
+typedef int16_t __swift_int16_t;
+typedef uint16_t __swift_uint16_t;
+typedef int8_t __swift_int8_t;
+typedef uint8_t __swift_uint8_t;
+typedef intptr_t __swift_intptr_t;
+typedef uintptr_t __swift_uintptr_t;
+#else
+typedef __INT64_TYPE__ __swift_int64_t;
+#ifdef __UINT64_TYPE__
+typedef __UINT64_TYPE__ __swift_uint64_t;
+#else
+typedef unsigned __INT64_TYPE__ __swift_uint64_t;
+#endif
+
+typedef __INT32_TYPE__ __swift_int32_t;
+#ifdef __UINT32_TYPE__
+typedef __UINT32_TYPE__ __swift_uint32_t;
+#else
+typedef unsigned __INT32_TYPE__ __swift_uint32_t;
+#endif
+
+typedef __INT16_TYPE__ __swift_int16_t;
+#ifdef __UINT16_TYPE__
+typedef __UINT16_TYPE__ __swift_uint16_t;
+#else
+typedef unsigned __INT16_TYPE__ __swift_uint16_t;
+#endif
+
+typedef __INT8_TYPE__ __swift_int8_t;
+#ifdef __UINT8_TYPE__
+typedef __UINT8_TYPE__ __swift_uint8_t;
+#else
+typedef unsigned __INT8_TYPE__ __swift_uint8_t;
+#endif
+
+#define __swift_join3(a,b,c) a ## b ## c
+
+#define __swift_intn_t(n) __swift_join3(__swift_int, n, _t)
+#define __swift_uintn_t(n) __swift_join3(__swift_uint, n, _t)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#if defined(_WIN64)
+typedef __swift_int64_t __swift_intptr_t;
+typedef __swift_uint64_t __swift_uintptr_t;
+#elif defined(_WIN32)
+typedef __swift_int32_t __swift_intptr_t;
+typedef __swift_uint32_t __swift_uintptr_t;
+#else
+#error unknown windows pointer width
+#endif
+#else
+typedef __swift_intn_t(__INTPTR_WIDTH__) __swift_intptr_t;
+typedef __swift_uintn_t(__INTPTR_WIDTH__) __swift_uintptr_t;
+#endif
+#endif
+
+#endif // SWIFT_STDLIB_SHIMS_SWIFT_STDINT_H

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/shims/System.h

@@ -0,0 +1,227 @@
+//===--- System.h - Swift ABI system-specific constants ---------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Here are some fun facts about the target platforms we support!
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_ABI_SYSTEM_H
+#define SWIFT_STDLIB_SHIMS_ABI_SYSTEM_H
+
+// In general, these macros are expected to expand to host-independent
+// integer constant expressions.  This allows the same data to feed
+// both the compiler and runtime implementation.
+
+/******************************* Default Rules ********************************/
+
+/// The least valid pointer value for an actual pointer (as opposed to
+/// Objective-C pointers, which may be tagged pointers and are covered
+/// separately).  Values up to this are "extra inhabitants" of the
+/// pointer representation, and payloaded enum types can take
+/// advantage of that as they see fit.
+///
+/// By default, we assume that there's at least an unmapped page at
+/// the bottom of the address space.  4K is a reasonably likely page
+/// size.
+///
+/// The minimum possible value for this macro is 1; we always assume
+/// that the null representation is available.
+#define SWIFT_ABI_DEFAULT_LEAST_VALID_POINTER 4096
+
+/// The bitmask of spare bits in a function pointer.
+#define SWIFT_ABI_DEFAULT_FUNCTION_SPARE_BITS_MASK 0
+
+/// The bitmask of spare bits in a Swift heap object pointer.  A Swift
+/// heap object allocation will never set any of these bits.
+#define SWIFT_ABI_DEFAULT_SWIFT_SPARE_BITS_MASK 0
+
+/// The bitmask of reserved bits in an Objective-C object pointer.
+/// By default we assume the ObjC runtime doesn't use tagged pointers.
+#define SWIFT_ABI_DEFAULT_OBJC_RESERVED_BITS_MASK 0
+
+/// The number of low bits in an Objective-C object pointer that
+/// are reserved by the Objective-C runtime.
+#define SWIFT_ABI_DEFAULT_OBJC_NUM_RESERVED_LOW_BITS 0
+
+/// The ObjC runtime will not use pointer values for which
+/// ``pointer & SWIFT_ABI_XXX_OBJC_RESERVED_BITS_MASK == 0 && 
+/// pointer & SWIFT_ABI_XXX_SWIFT_SPARE_BITS_MASK != 0``.
+
+// Weak references use a marker to tell when they are controlled by
+// the ObjC runtime and when they are controlled by the Swift runtime.
+// Non-ObjC platforms don't use this marker.
+#define SWIFT_ABI_DEFAULT_OBJC_WEAK_REFERENCE_MARKER_MASK 0
+#define SWIFT_ABI_DEFAULT_OBJC_WEAK_REFERENCE_MARKER_VALUE 0
+
+// BridgeObject uses this bit to indicate a tagged value.
+#define SWIFT_ABI_DEFAULT_BRIDGEOBJECT_TAG_32 0U
+#define SWIFT_ABI_DEFAULT_BRIDGEOBJECT_TAG_64 0x8000000000000000ULL
+
+// Only the bottom 56 bits are used, and heap objects are eight-byte-aligned.
+#define SWIFT_ABI_DEFAULT_64BIT_SPARE_BITS_MASK 0xFF00000000000007ULL
+
+// Poison sentinel value recognized by LLDB as a former reference to a
+// potentially deinitialized object. It uses no spare bits and cannot point to
+// readable memory.
+//
+// This is not ABI per-se but does stay in-sync with LLDB. If it becomes
+// out-of-sync, then users won't see a friendly diagnostic when inspecting
+// references past their lifetime.
+#define SWIFT_ABI_DEFAULT_REFERENCE_POISON_DEBUG_VALUE_32 0x00000440U
+#define SWIFT_ABI_DEFAULT_REFERENCE_POISON_DEBUG_VALUE_64 0x0000000000000440ULL
+
+/*********************************** i386 *************************************/
+
+// Heap objects are pointer-aligned, so the low two bits are unused.
+#define SWIFT_ABI_I386_SWIFT_SPARE_BITS_MASK 0x00000003U
+
+// ObjC weak reference discriminator is the LSB.
+#define SWIFT_ABI_I386_OBJC_WEAK_REFERENCE_MARKER_MASK  \
+  (SWIFT_ABI_DEFAULT_OBJC_RESERVED_BITS_MASK |          \
+   1<<SWIFT_ABI_DEFAULT_OBJC_NUM_RESERVED_LOW_BITS)
+#define SWIFT_ABI_I386_OBJC_WEAK_REFERENCE_MARKER_VALUE \
+  (1<<SWIFT_ABI_DEFAULT_OBJC_NUM_RESERVED_LOW_BITS)
+
+// BridgeObject uses this bit to indicate whether it holds an ObjC object or
+// not.
+#define SWIFT_ABI_I386_IS_OBJC_BIT 0x00000002U
+
+/*********************************** arm **************************************/
+
+// Heap objects are pointer-aligned, so the low two bits are unused.
+#define SWIFT_ABI_ARM_SWIFT_SPARE_BITS_MASK 0x00000003U
+
+// ObjC weak reference discriminator is the LSB.
+#define SWIFT_ABI_ARM_OBJC_WEAK_REFERENCE_MARKER_MASK  \
+  (SWIFT_ABI_DEFAULT_OBJC_RESERVED_BITS_MASK |          \
+   1<<SWIFT_ABI_DEFAULT_OBJC_NUM_RESERVED_LOW_BITS)
+#define SWIFT_ABI_ARM_OBJC_WEAK_REFERENCE_MARKER_VALUE \
+  (1<<SWIFT_ABI_DEFAULT_OBJC_NUM_RESERVED_LOW_BITS)
+
+// BridgeObject uses this bit to indicate whether it holds an ObjC object or
+// not.
+#define SWIFT_ABI_ARM_IS_OBJC_BIT 0x00000002U
+
+/*********************************** x86-64 ***********************************/
+
+/// Darwin reserves the low 4GB of address space.
+#define SWIFT_ABI_DARWIN_X86_64_LEAST_VALID_POINTER 0x100000000ULL
+
+// Only the bottom 56 bits are used, and heap objects are eight-byte-aligned.
+// This is conservative: in practice architectural limitations and other
+// compatibility concerns likely constrain the address space to 52 bits.
+#define SWIFT_ABI_X86_64_SWIFT_SPARE_BITS_MASK                                 \
+  SWIFT_ABI_DEFAULT_64BIT_SPARE_BITS_MASK
+
+// Objective-C reserves the low bit for tagged pointers on macOS, but
+// reserves the high bit on simulators.
+#define SWIFT_ABI_X86_64_OBJC_RESERVED_BITS_MASK 0x0000000000000001ULL
+#define SWIFT_ABI_X86_64_OBJC_NUM_RESERVED_LOW_BITS 1
+#define SWIFT_ABI_X86_64_SIMULATOR_OBJC_RESERVED_BITS_MASK 0x8000000000000000ULL
+#define SWIFT_ABI_X86_64_SIMULATOR_OBJC_NUM_RESERVED_LOW_BITS 0
+
+
+// BridgeObject uses this bit to indicate whether it holds an ObjC object or
+// not.
+#define SWIFT_ABI_X86_64_IS_OBJC_BIT 0x4000000000000000ULL
+
+// ObjC weak reference discriminator is the bit reserved for ObjC tagged
+// pointers plus one more low bit.
+#define SWIFT_ABI_X86_64_OBJC_WEAK_REFERENCE_MARKER_MASK  \
+  (SWIFT_ABI_X86_64_OBJC_RESERVED_BITS_MASK |          \
+   1<<SWIFT_ABI_X86_64_OBJC_NUM_RESERVED_LOW_BITS)
+#define SWIFT_ABI_X86_64_OBJC_WEAK_REFERENCE_MARKER_VALUE \
+  (1<<SWIFT_ABI_X86_64_OBJC_NUM_RESERVED_LOW_BITS)
+#define SWIFT_ABI_X86_64_SIMULATOR_OBJC_WEAK_REFERENCE_MARKER_MASK  \
+  (SWIFT_ABI_X86_64_SIMULATOR_OBJC_RESERVED_BITS_MASK |          \
+   1<<SWIFT_ABI_X86_64_SIMULATOR_OBJC_NUM_RESERVED_LOW_BITS)
+#define SWIFT_ABI_X86_64_SIMULATOR_OBJC_WEAK_REFERENCE_MARKER_VALUE \
+  (1<<SWIFT_ABI_X86_64_SIMULATOR_OBJC_NUM_RESERVED_LOW_BITS)
+
+/*********************************** arm64 ************************************/
+
+/// Darwin reserves the low 4GB of address space.
+#define SWIFT_ABI_DARWIN_ARM64_LEAST_VALID_POINTER 0x100000000ULL
+
+// Android AArch64 reserves the top byte for pointer tagging since Android 11,
+// so shift the spare bits tag to the second byte and zero the ObjC tag.
+#define SWIFT_ABI_ANDROID_ARM64_SWIFT_SPARE_BITS_MASK 0x00F0000000000007ULL
+#define SWIFT_ABI_ANDROID_ARM64_OBJC_RESERVED_BITS_MASK 0x0000000000000000ULL
+
+#if defined(__ANDROID__) && defined(__aarch64__)
+#define SWIFT_ABI_ARM64_SWIFT_SPARE_BITS_MASK SWIFT_ABI_ANDROID_ARM64_SWIFT_SPARE_BITS_MASK
+#else
+// TBI guarantees the top byte of pointers is unused, but ARMv8.5-A
+// claims the bottom four bits of that for memory tagging.
+// Heap objects are eight-byte aligned.
+#define SWIFT_ABI_ARM64_SWIFT_SPARE_BITS_MASK 0xF000000000000007ULL
+#endif
+
+// Objective-C reserves just the high bit for tagged pointers.
+#define SWIFT_ABI_ARM64_OBJC_RESERVED_BITS_MASK 0x8000000000000000ULL
+#define SWIFT_ABI_ARM64_OBJC_NUM_RESERVED_LOW_BITS 0
+
+// BridgeObject uses this bit to indicate whether it holds an ObjC object or
+// not.
+#define SWIFT_ABI_ARM64_IS_OBJC_BIT 0x4000000000000000ULL
+
+// ObjC weak reference discriminator is the high bit
+// reserved for ObjC tagged pointers plus the LSB.
+#define SWIFT_ABI_ARM64_OBJC_WEAK_REFERENCE_MARKER_MASK  \
+  (SWIFT_ABI_ARM64_OBJC_RESERVED_BITS_MASK |          \
+   1<<SWIFT_ABI_ARM64_OBJC_NUM_RESERVED_LOW_BITS)
+#define SWIFT_ABI_ARM64_OBJC_WEAK_REFERENCE_MARKER_VALUE \
+  (1<<SWIFT_ABI_ARM64_OBJC_NUM_RESERVED_LOW_BITS)
+
+/*********************************** powerpc ********************************/
+
+// Heap objects are pointer-aligned, so the low two bits are unused.
+#define SWIFT_ABI_POWERPC_SWIFT_SPARE_BITS_MASK 0x00000003U
+
+/*********************************** powerpc64 ********************************/
+
+// Heap objects are pointer-aligned, so the low three bits are unused.
+#define SWIFT_ABI_POWERPC64_SWIFT_SPARE_BITS_MASK                              \
+  SWIFT_ABI_DEFAULT_64BIT_SPARE_BITS_MASK
+
+/*********************************** s390x ************************************/
+
+// Top byte of pointers is unused, and heap objects are eight-byte aligned.
+// On s390x it is theoretically possible to have high bit set but in practice
+// it is unlikely.
+#define SWIFT_ABI_S390X_SWIFT_SPARE_BITS_MASK SWIFT_ABI_DEFAULT_64BIT_SPARE_BITS_MASK
+
+// Objective-C reserves just the high bit for tagged pointers.
+#define SWIFT_ABI_S390X_OBJC_RESERVED_BITS_MASK 0x8000000000000000ULL
+#define SWIFT_ABI_S390X_OBJC_NUM_RESERVED_LOW_BITS 0
+
+// BridgeObject uses this bit to indicate whether it holds an ObjC object or
+// not.
+#define SWIFT_ABI_S390X_IS_OBJC_BIT 0x4000000000000000ULL
+
+// ObjC weak reference discriminator is the high bit
+// reserved for ObjC tagged pointers plus the LSB.
+#define SWIFT_ABI_S390X_OBJC_WEAK_REFERENCE_MARKER_MASK  \
+  (SWIFT_ABI_S390X_OBJC_RESERVED_BITS_MASK |          \
+   1<<SWIFT_ABI_S390X_OBJC_NUM_RESERVED_LOW_BITS)
+#define SWIFT_ABI_S390X_OBJC_WEAK_REFERENCE_MARKER_VALUE \
+  (1<<SWIFT_ABI_S390X_OBJC_NUM_RESERVED_LOW_BITS)
+
+/*********************************** wasm32 ************************************/
+
+// WebAssembly doesn't reserve low addresses. But without "extra inhabitants" of
+// the pointer representation, runtime performance and memory footprint are
+// worse. So assume that compiler driver uses wasm-ld and --global-base=4096 to
+// reserve low 4KB.
+#define SWIFT_ABI_WASM32_LEAST_VALID_POINTER 4096
+
+#endif // SWIFT_STDLIB_SHIMS_ABI_SYSTEM_H