averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
7d12cad37fcfea9e10c31ebc29c8063f17bf2d2c
swift-mirror/include/swift/Runtime/RuntimeFunctions.def
John McCall 3aa04db87b Track whether a task is actively running. 
Tracking this as a single bit is actually largely uninteresting
to the runtime.  To handle priority escalation properly, we really
need to track this at a finer grain of detail: recording that the
task is running on a specific thread, enqueued on a specific actor,
or so on.  But starting by tracking a single bit is important for
two reasons:

- First, it's more realistic about the performance overheads of
  tasks: we're going to be doing this tracking eventually, and
  the cost of that tracking will be dominated by the atomic
  access, so doing that access now sets the baseline about right.

- Second, it ensures that we've actually got runtime involvement
  in all the right places to do this tracking.

A propos of the latter: there was no runtime involvement with
awaiting a continuation, which is a point at which the task
potentially transitions from running to suspended.  We must do
the tracking as part of this transition, rather than recognizing
in the run-loops that a task is still active and treating it as
having suspended, because the latter point potentially races with
the resumption of the task.  To do this, I've had to introduce
a runtime function, swift_continuation_await, to do this awaiting
rather than inlining the atomic operation on the continuation.

As part of doing this work, I've also fixed a bug where we failed
to load-acquire in swift_task_escalate before walking the task
status records to invoke escalation actions.

I've also fixed several places where the handling of task statuses
may have accidentally allowed the task to revert to uncancelled.
2021-07-14 20:24:01 -04:00

1779 lines
73 KiB
C++
Raw Blame History

//===--- RuntimeFunctions.def - Runtime Functions Database ------*- 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
//
//===----------------------------------------------------------------------===//
//
// This file defines x-macros used for metaprogramming with the set of
// runtime functions.
//
// Runtime functions that read from object arguments cannot be marked
// ReadNone. Otherwise the objects may be freed before the runtime call.
//
//===----------------------------------------------------------------------===//
/// FUNCTION(Id, Name, CC, Availability, ReturnTys, ArgTys, Attrs)
/// Makes available as "Id" the following runtime function:
/// ReturnTy Name(ArgTys...);
/// ReturnTys is a call to RETURNS, which takes a non-empty list
/// of expressions meant to be looked up in IRGenModule.
/// ArgTys is either NO_ARGS or a call to ARGS, which takes a non-empty
/// list of expressions meant to be looked up in IRGenModule.
/// Attrs is a parenthesized list of attributes.
///
/// By default, passes Id to FUNCTION_ID. Therefore, the valid uses of
/// this database define either:
/// FUNCTION_ID
/// or all of the following:
/// FUNCTION
/// RETURNS
/// ARGS
/// NO_ARGS
/// ATTRS
/// NO_ATTRS
#ifndef FUNCTION
#define FUNCTION(Id, Name, CC, Availability, ReturnTys, ArgTys, Attrs) FUNCTION_ID(Id)
#endif
FUNCTION(AllocBox, swift_allocBox, SwiftCC, AlwaysAvailable,
RETURNS(RefCountedPtrTy, OpaquePtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind))
// BoxPair swift_makeBoxUnique(OpaqueValue *buffer, Metadata *type, size_t alignMask);
FUNCTION(MakeBoxUnique,
swift_makeBoxUnique,
SwiftCC, AlwaysAvailable,
RETURNS(RefCountedPtrTy, OpaquePtrTy),
ARGS(OpaquePtrTy, TypeMetadataPtrTy, SizeTy),
ATTRS(NoUnwind))
FUNCTION(DeallocBox, swift_deallocBox, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// swift_projectBox reads object metadata so cannot be marked ReadNone.
FUNCTION(ProjectBox, swift_projectBox, C_CC, AlwaysAvailable,
RETURNS(OpaquePtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ReadOnly, ArgMemOnly))
FUNCTION(AllocEmptyBox, swift_allocEmptyBox, C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(),
ATTRS(NoUnwind))
// RefCounted *swift_allocObject(Metadata *type, size_t size, size_t alignMask);
FUNCTION(AllocObject, swift_allocObject, C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// HeapObject *swift_initStackObject(HeapMetadata const *metadata,
// HeapObject *object);
FUNCTION(InitStackObject, swift_initStackObject, C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(TypeMetadataPtrTy, RefCountedPtrTy),
ATTRS(NoUnwind))
// HeapObject *swift_initStaticObject(HeapMetadata const *metadata,
// HeapObject *object);
FUNCTION(InitStaticObject, swift_initStaticObject, C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(TypeMetadataPtrTy, RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_verifyEndOfLifetime(HeapObject *object);
FUNCTION(VerifyEndOfLifetime, swift_verifyEndOfLifetime, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_deallocObject(HeapObject *obj, size_t size, size_t alignMask);
FUNCTION(DeallocObject, swift_deallocObject, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// void swift_deallocUninitializedObject(HeapObject *obj, size_t size, size_t alignMask);
FUNCTION(DeallocUninitializedObject, swift_deallocUninitializedObject,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// void swift_deallocClassInstance(HeapObject *obj, size_t size, size_t alignMask);
FUNCTION(DeallocClassInstance, swift_deallocClassInstance, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// void swift_deallocPartialClassInstance(HeapObject *obj, HeapMetadata *type, size_t size, size_t alignMask);
FUNCTION(DeallocPartialClassInstance, swift_deallocPartialClassInstance,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, TypeMetadataPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// void *swift_slowAlloc(size_t size, size_t alignMask);
FUNCTION(SlowAlloc, swift_slowAlloc, C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(SizeTy, SizeTy),
ATTRS(NoUnwind))
// void swift_slowDealloc(void *ptr, size_t size, size_t alignMask);
FUNCTION(SlowDealloc, swift_slowDealloc, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(Int8PtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// void swift_willThrow(error *ptr);
FUNCTION(WillThrow, swift_willThrow, SwiftCC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(Int8PtrTy, ErrorPtrTy->getPointerTo()),
ATTRS(NoUnwind))
// void swift_errorInMain(error *ptr);
FUNCTION(ErrorInMain, swift_errorInMain, SwiftCC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ErrorPtrTy),
ATTRS(NoUnwind))
// void swift_unexpectedError(error *ptr);
FUNCTION(UnexpectedError, swift_unexpectedError, SwiftCC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ErrorPtrTy),
ATTRS(NoUnwind, NoReturn))
// void *swift_copyPOD(void *dest, void *src, Metadata *self);
FUNCTION(CopyPOD, swift_copyPOD, C_CC, AlwaysAvailable,
RETURNS(OpaquePtrTy),
ARGS(OpaquePtrTy, OpaquePtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void *swift_retain(void *ptr);
FUNCTION(NativeStrongRetain, swift_retain, C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_release(void *ptr);
FUNCTION(NativeStrongRelease, swift_release, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_retain_n(void *ptr, int32_t n);
FUNCTION(NativeStrongRetainN, swift_retain_n, C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void *swift_release_n(void *ptr, int32_t n);
FUNCTION(NativeStrongReleaseN, swift_release_n, C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_setDeallocating(void *ptr);
FUNCTION(NativeSetDeallocating, swift_setDeallocating,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_nonatomic_retain_n(void *ptr, int32_t n);
FUNCTION(NativeNonAtomicStrongRetainN, swift_nonatomic_retain_n, C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_nonatomic_release_n(void *ptr, int32_t n);
FUNCTION(NativeNonAtomicStrongReleaseN, swift_nonatomic_release_n, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void *swift_unknownObjectRetain_n(void *ptr, int32_t n);
FUNCTION(UnknownObjectRetainN, swift_unknownObjectRetain_n,
C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_unknownObjectRelease_n(void *ptr, int32_t n);
FUNCTION(UnknownObjectReleaseN, swift_unknownObjectRelease_n,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void *swift_nonatomic_unknownObjectRetain_n(void *ptr, int32_t n);
FUNCTION(NonAtomicUnknownObjectRetainN, swift_nonatomic_unknownObjectRetain_n,
C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_nonatomic_unknownObjectRelease_n(void *ptr, int32_t n);
FUNCTION(NonAtomicUnknownObjectReleaseN, swift_nonatomic_unknownObjectRelease_n,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void swift_bridgeObjectRetain_n(void *ptr, int32_t n);
FUNCTION(BridgeObjectRetainN, swift_bridgeObjectRetain_n,
C_CC, AlwaysAvailable,
RETURNS(BridgeObjectPtrTy),
ARGS(BridgeObjectPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_bridgeObjectRelease_n(void *ptr, int32_t n);
FUNCTION(BridgeObjectReleaseN, swift_bridgeObjectRelease_n,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(BridgeObjectPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void swift_nonatomic_bridgeObjectRetain_n(void *ptr, int32_t n);
FUNCTION(NonAtomicBridgeObjectRetainN, swift_nonatomic_bridgeObjectRetain_n,
C_CC, AlwaysAvailable,
RETURNS(BridgeObjectPtrTy),
ARGS(BridgeObjectPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_nonatomic_bridgeObjectRelease_n(void *ptr, int32_t n);
FUNCTION(NonAtomicBridgeObjectReleaseN, swift_nonatomic_bridgeObjectRelease_n,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(BridgeObjectPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void *swift_nonatomic_retain(void *ptr);
FUNCTION(NativeNonAtomicStrongRetain, swift_nonatomic_retain,
C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_nonatomic_release(void *ptr);
FUNCTION(NativeNonAtomicStrongRelease, swift_nonatomic_release,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_tryRetain(void *ptr);
FUNCTION(NativeTryRetain, swift_tryRetain, C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// bool swift_isDeallocating(void *ptr);
FUNCTION(IsDeallocating, swift_isDeallocating, C_CC, AlwaysAvailable,
RETURNS(Int1Ty),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
// void *swift_unknownObjectRetain(void *ptr);
FUNCTION(UnknownObjectRetain, swift_unknownObjectRetain, C_CC, AlwaysAvailable,
RETURNS(UnknownRefCountedPtrTy),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_unknownObjectRelease(void *ptr);
FUNCTION(UnknownObjectRelease, swift_unknownObjectRelease,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_nonatomic_unknownObjectRetain(void *ptr);
FUNCTION(NonAtomicUnknownObjectRetain, swift_nonatomic_unknownObjectRetain,
C_CC, AlwaysAvailable,
RETURNS(UnknownRefCountedPtrTy),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_nonatomic_unknownObjectRelease(void *ptr);
FUNCTION(NonAtomicUnknownObjectRelease, swift_nonatomic_unknownObjectRelease,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_bridgeObjectRetain(void *ptr);
FUNCTION(BridgeObjectStrongRetain, swift_bridgeObjectRetain,
C_CC, AlwaysAvailable,
RETURNS(BridgeObjectPtrTy),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_bridgeRelease(void *ptr);
FUNCTION(BridgeObjectStrongRelease, swift_bridgeObjectRelease,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind))
// void *swift_nonatomic_bridgeObjectRetain(void *ptr);
FUNCTION(NonAtomicBridgeObjectStrongRetain, swift_nonatomic_bridgeObjectRetain,
C_CC, AlwaysAvailable,
RETURNS(BridgeObjectPtrTy),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_nonatomic_bridgeRelease(void *ptr);
FUNCTION(NonAtomicBridgeObjectStrongRelease,
swift_nonatomic_bridgeObjectRelease,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind))
// error *swift_errorRetain(error *ptr);
FUNCTION(ErrorStrongRetain, swift_errorRetain,
C_CC, AlwaysAvailable,
RETURNS(ErrorPtrTy),
ARGS(ErrorPtrTy),
ATTRS(NoUnwind))
// void swift_errorRelease(void *ptr);
FUNCTION(ErrorStrongRelease, swift_errorRelease,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ErrorPtrTy),
ATTRS(NoUnwind))
#define NEVER_LOADABLE_CHECKED_REF_STORAGE_HELPER(Name, Nativeness, SymName, UnknownPrefix) \
/* void swift_##SymName##Destroy(Name##Reference *object); */ \
FUNCTION(Nativeness##Name##Destroy, swift_##SymName##Destroy, \
C_CC, AlwaysAvailable, \
RETURNS(VoidTy), \
ARGS(Name##ReferencePtrTy), \
ATTRS(NoUnwind)) \
/* void swift_##SymName##Init(Name##Reference *object, void *value); */ \
FUNCTION(Nativeness##Name##Init, swift_##SymName##Init, \
C_CC, AlwaysAvailable, \
RETURNS(Name##ReferencePtrTy), \
ARGS(Name##ReferencePtrTy, UnknownPrefix##RefCountedPtrTy), \
ATTRS(NoUnwind, FirstParamReturned)) \
/* Name##Reference *swift_##SymName##Assign(Name##Reference *object, void *value); */ \
FUNCTION(Nativeness##Name##Assign, swift_##SymName##Assign, \
C_CC, AlwaysAvailable, \
RETURNS(Name##ReferencePtrTy), \
ARGS(Name##ReferencePtrTy, UnknownPrefix##RefCountedPtrTy), \
ATTRS(NoUnwind, FirstParamReturned)) \
/* void *swift_##SymName##Load(Name##Reference *object); */ \
FUNCTION(Nativeness##Name##LoadStrong, swift_##SymName##LoadStrong, \
C_CC, AlwaysAvailable, \
RETURNS(UnknownPrefix##RefCountedPtrTy), \
ARGS(Name##ReferencePtrTy), \
ATTRS(NoUnwind)) \
/* void *swift_##SymName##Take(Name##Reference *object); */ \
FUNCTION(Nativeness##Name##TakeStrong, swift_##SymName##TakeStrong, \
C_CC, AlwaysAvailable, \
RETURNS(UnknownPrefix##RefCountedPtrTy), \
ARGS(Name##ReferencePtrTy), \
ATTRS(NoUnwind)) \
/* Name##Reference *swift_##SymName##CopyInit(Name##Reference *dest, Name##Reference *src); */ \
FUNCTION(Nativeness##Name##CopyInit, swift_##SymName##CopyInit, \
C_CC, AlwaysAvailable, \
RETURNS(Name##ReferencePtrTy), \
ARGS(Name##ReferencePtrTy, Name##ReferencePtrTy), \
ATTRS(NoUnwind, FirstParamReturned)) \
/* void *swift_##SymName##TakeInit(Name##Reference *dest, Name##Reference *src); */ \
FUNCTION(Nativeness##Name##TakeInit, swift_##SymName##TakeInit, \
C_CC, AlwaysAvailable, \
RETURNS(Name##ReferencePtrTy), \
ARGS(Name##ReferencePtrTy, Name##ReferencePtrTy), \
ATTRS(NoUnwind, FirstParamReturned)) \
/* Name##Reference *swift_##SymName##CopyAssign(Name##Reference *dest, Name##Reference *src); */ \
FUNCTION(Nativeness##Name##CopyAssign, swift_##SymName##CopyAssign, \
C_CC, AlwaysAvailable, \
RETURNS(Name##ReferencePtrTy), \
ARGS(Name##ReferencePtrTy, Name##ReferencePtrTy), \
ATTRS(NoUnwind, FirstParamReturned)) \
/* Name##Reference *swift_##SymName##TakeAssign(Name##Reference *dest, Name##Reference *src); */ \
FUNCTION(Nativeness##Name##TakeAssign, swift_##SymName##TakeAssign, \
C_CC, AlwaysAvailable, \
RETURNS(Name##ReferencePtrTy), \
ARGS(Name##ReferencePtrTy, Name##ReferencePtrTy), \
ATTRS(NoUnwind, FirstParamReturned))
#define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \
NEVER_LOADABLE_CHECKED_REF_STORAGE_HELPER(Name, Native, name, ) \
NEVER_LOADABLE_CHECKED_REF_STORAGE_HELPER(Name, Unknown, unknownObject##Name, Unknown)
#define LOADABLE_CHECKED_REF_STORAGE_HELPER(Name, name, Prefix, prefix) \
/* void *swift_##prefix##name##Retain(void *ptr); */ \
FUNCTION(Prefix##Name##Retain, swift_##prefix##name##Retain, \
C_CC, AlwaysAvailable, \
RETURNS(RefCountedPtrTy), \
ARGS(RefCountedPtrTy), \
ATTRS(NoUnwind, FirstParamReturned)) \
/* void swift_##prefix##name##Release(void *ptr); */ \
FUNCTION(Prefix##Name##Release, swift_##prefix##name##Release, \
C_CC, AlwaysAvailable, \
RETURNS(VoidTy), \
ARGS(RefCountedPtrTy), \
ATTRS(NoUnwind)) \
/* void *swift_##prefix##name##RetainStrong(void *ptr); */ \
FUNCTION(Prefix##StrongRetain##Name, swift_##prefix##name##RetainStrong, \
C_CC, AlwaysAvailable, \
RETURNS(RefCountedPtrTy), \
ARGS(RefCountedPtrTy), \
ATTRS(NoUnwind, FirstParamReturned)) \
/* void swift_##prefix##name##RetainStrongAndRelease(void *ptr); */ \
FUNCTION(Prefix##StrongRetainAnd##Name##Release, \
swift_##prefix##name##RetainStrongAndRelease, \
C_CC, AlwaysAvailable, \
RETURNS(VoidTy), \
ARGS(RefCountedPtrTy), \
ATTRS(NoUnwind))
#define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \
NEVER_LOADABLE_CHECKED_REF_STORAGE_HELPER(Name, Unknown, unknownObject##Name, Unknown) \
LOADABLE_CHECKED_REF_STORAGE_HELPER(Name, name, Native, ) \
LOADABLE_CHECKED_REF_STORAGE_HELPER(Name, name, NonAtomicNative, nonatomic_)
#define ALWAYS_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \
LOADABLE_CHECKED_REF_STORAGE_HELPER(Name, name, Native, ) \
LOADABLE_CHECKED_REF_STORAGE_HELPER(Name, name, NonAtomicNative, nonatomic_)
#include "swift/AST/ReferenceStorage.def"
#undef NEVER_LOADABLE_CHECKED_REF_STORAGE_HELPER
#undef LOADABLE_CHECKED_REF_STORAGE_HELPER
// bool swift_isUniquelyReferencedNonObjC(const void *);
FUNCTION(IsUniquelyReferencedNonObjC, swift_isUniquelyReferencedNonObjC,
C_CC, AlwaysAvailable,
RETURNS(Int1Ty),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
// bool swift_isUniquelyReferencedNonObjC_nonNull(const void *);
FUNCTION(IsUniquelyReferencedNonObjC_nonNull,
swift_isUniquelyReferencedNonObjC_nonNull,
C_CC, AlwaysAvailable,
RETURNS(Int1Ty),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
// bool swift_isUniquelyReferencedNonObjC_nonNull_bridgeObject(
// uintptr_t bits);
FUNCTION(IsUniquelyReferencedNonObjC_nonNull_bridgeObject,
swift_isUniquelyReferencedNonObjC_nonNull_bridgeObject,
C_CC, AlwaysAvailable,
RETURNS(Int1Ty),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind, ZExt))
// bool swift_isUniquelyReferenced_native(const struct HeapObject *);
FUNCTION(IsUniquelyReferenced_native, swift_isUniquelyReferenced_native,
C_CC, AlwaysAvailable,
RETURNS(Int1Ty),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
// bool swift_isUniquelyReferenced_nonNull_native(const struct HeapObject *);
FUNCTION(IsUniquelyReferenced_nonNull_native,
swift_isUniquelyReferenced_nonNull_native,
C_CC, AlwaysAvailable,
RETURNS(Int1Ty),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
// bool swift_isEscapingClosureAtFileLocation(const struct HeapObject *object,
// const unsigned char *filename,
// int32_t filenameLength,
// int32_t line,
// int32_t col,
// unsigned type);
FUNCTION(IsEscapingClosureAtFileLocation, swift_isEscapingClosureAtFileLocation,
C_CC, AlwaysAvailable,
RETURNS(Int1Ty),
ARGS(RefCountedPtrTy, Int8PtrTy, Int32Ty, Int32Ty, Int32Ty, Int32Ty),
ATTRS(NoUnwind, ZExt))
// void swift_arrayInitWithCopy(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayInitWithCopy, swift_arrayInitWithCopy,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayInitWithTakeNoAlias(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayInitWithTakeNoAlias, swift_arrayInitWithTakeNoAlias,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayInitWithTakeFrontToBack(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayInitWithTakeFrontToBack, swift_arrayInitWithTakeFrontToBack,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayInitWithTakeBackToFront(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayInitWithTakeBackToFront, swift_arrayInitWithTakeBackToFront,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayAssignWithCopyNoAlias(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayAssignWithCopyNoAlias, swift_arrayAssignWithCopyNoAlias,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayAssignWithCopyFrontToBack(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayAssignWithCopyFrontToBack, swift_arrayAssignWithCopyFrontToBack,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayAssignWithCopyBackToFront(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayAssignWithCopyBackToFront, swift_arrayAssignWithCopyBackToFront,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayAssignWithTake(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayAssignWithTake, swift_arrayAssignWithTake, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayDestroy(opaque*, size_t, type*);
FUNCTION(ArrayDestroy, swift_arrayDestroy, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// Metadata *swift_getFunctionTypeMetadata(unsigned long flags,
// const Metadata **parameters,
// const uint32_t *parameterFlags,
// const Metadata *result);
FUNCTION(GetFunctionMetadata, swift_getFunctionTypeMetadata,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy,
TypeMetadataPtrTy->getPointerTo(0),
Int32Ty->getPointerTo(0),
TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadOnly))
// Metadata *
// swift_getFunctionTypeMetadataDifferentiable(unsigned long flags,
// unsigned long diffKind,
// const Metadata **parameters,
// const uint32_t *parameterFlags,
// const Metadata *result);
FUNCTION(GetFunctionMetadataDifferentiable,
swift_getFunctionTypeMetadataDifferentiable,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy,
SizeTy,
TypeMetadataPtrTy->getPointerTo(0),
Int32Ty->getPointerTo(0),
TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadOnly))
// Metadata *
// swift_getFunctionTypeMetadataGlobalActor(unsigned long flags,
// unsigned long diffKind,
// const Metadata **parameters,
// const uint32_t *parameterFlags,
// const Metadata *result,
// const Metadata *globalActor);
FUNCTION(GetFunctionMetadataGlobalActor,
swift_getFunctionTypeMetadataGlobalActor,
C_CC, ConcurrencyAvailability,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy,
SizeTy,
TypeMetadataPtrTy->getPointerTo(0),
Int32Ty->getPointerTo(0),
TypeMetadataPtrTy,
TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadOnly))
// Metadata *swift_getFunctionTypeMetadata0(unsigned long flags,
// const Metadata *resultMetadata);
FUNCTION(GetFunctionMetadata0, swift_getFunctionTypeMetadata0,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getFunctionTypeMetadata1(unsigned long flags,
// const Metadata *arg0,
// const Metadata *resultMetadata);
FUNCTION(GetFunctionMetadata1, swift_getFunctionTypeMetadata1,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getFunctionTypeMetadata2(unsigned long flags,
// const Metadata *arg0,
// const Metadata *arg1,
// const Metadata *resultMetadata);
FUNCTION(GetFunctionMetadata2, swift_getFunctionTypeMetadata2,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getFunctionTypeMetadata3(unsigned long flags,
// const Metadata *arg0,
// const Metadata *arg1,
// const Metadata *arg2,
// const Metadata *resultMetadata);
FUNCTION(GetFunctionMetadata3, swift_getFunctionTypeMetadata3,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrTy, TypeMetadataPtrTy,
TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getForeignTypeMetadata(Metadata *nonUnique);
FUNCTION(GetForeignTypeMetadata, swift_getForeignTypeMetadata,
SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone)) // only writes to runtime-private fields
// SWIFT_RUNTIME_EXPORT
// SWIFT_CC(swift)
// bool swift_compareTypeContextDescriptors(const TypeContextDescriptor *lhs,
// const TypeContextDescriptor *rhs);
FUNCTION(CompareTypeContextDescriptors,
swift_compareTypeContextDescriptors, SwiftCC,
CompareTypeContextDescriptorsAvailability,
RETURNS(Int1Ty),
ARGS(TypeContextDescriptorPtrTy,
TypeContextDescriptorPtrTy),
ATTRS(NoUnwind, ReadNone))
// MetadataResponse swift_getSingletonMetadata(MetadataRequest request,
// TypeContextDescriptor *type);
FUNCTION(GetSingletonMetadata, swift_getSingletonMetadata,
SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy, TypeContextDescriptorPtrTy),
ATTRS(NoUnwind, ReadNone))
// MetadataResponse swift_getGenericMetadata(MetadataRequest request,
// const void * const *arguments,
// TypeContextDescriptor *type);
FUNCTION(GetGenericMetadata, swift_getGenericMetadata,
SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy, Int8PtrTy, TypeContextDescriptorPtrTy),
ATTRS(NoUnwind, ReadOnly))
// MetadataResponse swift_getCanonicalSpecializedMetadata(MetadataRequest request,
// Metadata *candidate);
FUNCTION(GetCanonicalSpecializedMetadata, swift_getCanonicalSpecializedMetadata,
SwiftCC, GetCanonicalSpecializedMetadataAvailability,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrPtrTy),
ATTRS(NoUnwind, ReadOnly))
// MetadataResponse
// swift_getCanonicalPrespecializedGenericMetadata(MetadataRequest request,
// const void * const *arguments,
// const TypeContextDescriptor *description,
// swift_once_t *cachedFlag)
FUNCTION(GetCanonicalPrespecializedGenericMetadata,
swift_getCanonicalPrespecializedGenericMetadata,
SwiftCC, GetCanonicalPrespecializedGenericMetadataAvailability,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy, Int8PtrTy, TypeContextDescriptorPtrTy, OnceTy->getPointerTo()),
ATTRS(NoUnwind, ReadOnly))
// MetadataResponse swift_getOpaqueTypeMetadata(MetadataRequest request,
// const void * const *arguments,
// const OpaqueTypeDescriptor *descriptor,
// uintptr_t index);
FUNCTION(GetOpaqueTypeMetadata, swift_getOpaqueTypeMetadata,
SwiftCC, OpaqueTypeAvailability,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy, Int8PtrTy, OpaqueTypeDescriptorPtrTy, SizeTy),
ATTRS(NoUnwind, ReadOnly))
// const WitnessTable *swift_getOpaqueTypeConformance(const void * const *arguments,
// const OpaqueTypeDescriptor *descriptor,
// uintptr_t index);
FUNCTION(GetOpaqueTypeConformance, swift_getOpaqueTypeConformance,
SwiftCC, OpaqueTypeAvailability,
RETURNS(WitnessTablePtrTy),
ARGS(Int8PtrTy, OpaqueTypeDescriptorPtrTy, SizeTy),
ATTRS(NoUnwind, ReadOnly))
// Metadata *swift_allocateGenericClassMetadata(ClassDescriptor *type,
// const void * const *arguments,
// const void *template);
FUNCTION(AllocateGenericClassMetadata, swift_allocateGenericClassMetadata,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeContextDescriptorPtrTy, Int8PtrPtrTy, Int8PtrTy),
ATTRS(NoUnwind))
// Metadata *swift_allocateGenericValueMetadata(ValueTypeDescriptor *type,
// const void * const *arguments,
// const void *template,
// size_t extraSize);
FUNCTION(AllocateGenericValueMetadata, swift_allocateGenericValueMetadata,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeContextDescriptorPtrTy, Int8PtrPtrTy, Int8PtrTy, SizeTy),
ATTRS(NoUnwind))
// MetadataResponse swift_checkMetadataState(MetadataRequest request,
// const Metadata *type);
FUNCTION(CheckMetadataState, swift_checkMetadataState,
SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadOnly))
// const ProtocolWitnessTable *
// swift_getWitnessTable(const ProtocolConformanceDescriptor *conf,
// const Metadata *type,
// const void * const *instantiationArgs);
FUNCTION(GetWitnessTable, swift_getWitnessTable, C_CC, AlwaysAvailable,
RETURNS(WitnessTablePtrTy),
ARGS(ProtocolConformanceDescriptorPtrTy,
TypeMetadataPtrTy,
WitnessTablePtrPtrTy),
ATTRS(NoUnwind, ReadOnly))
// MetadataResponse swift_getAssociatedTypeWitness(
// MetadataRequest request,
// WitnessTable *wtable,
// const Metadata *conformingType,
// ProtocolRequirement *reqBase,
// ProtocolRequirement *assocType);
FUNCTION(GetAssociatedTypeWitness, swift_getAssociatedTypeWitness,
SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy,
WitnessTablePtrTy,
TypeMetadataPtrTy,
ProtocolRequirementStructTy->getPointerTo(),
ProtocolRequirementStructTy->getPointerTo()),
ATTRS(NoUnwind, ReadNone))
// SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
// const WitnessTable *swift_getAssociatedConformanceWitness(
// WitnessTable *wtable,
// const Metadata *conformingType,
// const Metadata *assocType,
// const ProtocolRequirement *reqBase,
// const ProtocolRequirement *assocConformance);
FUNCTION(GetAssociatedConformanceWitness,
swift_getAssociatedConformanceWitness, SwiftCC, AlwaysAvailable,
RETURNS(WitnessTablePtrTy),
ARGS(WitnessTablePtrTy,
TypeMetadataPtrTy,
TypeMetadataPtrTy,
ProtocolRequirementStructTy->getPointerTo(),
ProtocolRequirementStructTy->getPointerTo()),
ATTRS(NoUnwind, ReadNone))
// SWIFT_RUNTIME_EXPORT
// SWIFT_CC(swift) bool swift_compareProtocolConformanceDescriptors(
// const ProtocolConformanceDescriptor *lhs,
// const ProtocolConformanceDescriptor *rhs);
FUNCTION(CompareProtocolConformanceDescriptors,
swift_compareProtocolConformanceDescriptors, SwiftCC,
CompareProtocolConformanceDescriptorsAvailability,
RETURNS(Int1Ty),
ARGS(ProtocolConformanceDescriptorPtrTy,
ProtocolConformanceDescriptorPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getMetatypeMetadata(Metadata *instanceTy);
FUNCTION(GetMetatypeMetadata, swift_getMetatypeMetadata, C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getExistentialMetatypeMetadata(Metadata *instanceTy);
FUNCTION(GetExistentialMetatypeMetadata,
swift_getExistentialMetatypeMetadata, C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getObjCClassMetadata(objc_class *theClass);
FUNCTION(GetObjCClassMetadata, swift_getObjCClassMetadata,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(ObjCClassPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getObjCClassFromMetadata(objc_class *theClass);
FUNCTION(GetObjCClassFromMetadata, swift_getObjCClassFromMetadata,
C_CC, AlwaysAvailable,
RETURNS(ObjCClassPtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getObjCClassFromObject(id object);
// This reads object metadata so cannot be marked ReadNone.
FUNCTION(GetObjCClassFromObject, swift_getObjCClassFromObject,
C_CC, AlwaysAvailable,
RETURNS(ObjCClassPtrTy),
ARGS(ObjCPtrTy),
ATTRS(NoUnwind, ReadOnly, ArgMemOnly))
// MetadataResponse swift_getTupleTypeMetadata(MetadataRequest request,
// TupleTypeFlags flags,
// Metadata * const *elts,
// const char *labels,
// value_witness_table_t *proposed);
FUNCTION(GetTupleMetadata, swift_getTupleTypeMetadata, SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy, SizeTy, TypeMetadataPtrTy->getPointerTo(0),
Int8PtrTy, WitnessTablePtrTy),
ATTRS(NoUnwind, ReadOnly))
// MetadataResponse swift_getTupleTypeMetadata2(MetadataRequest request,
// Metadata *elt0, Metadata *elt1,
// const char *labels,
// value_witness_table_t *proposed);
FUNCTION(GetTupleMetadata2, swift_getTupleTypeMetadata2, SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrTy,
Int8PtrTy, WitnessTablePtrTy),
ATTRS(NoUnwind, ReadOnly))
// MetadataResponse swift_getTupleTypeMetadata3(MetadataRequest request,
// Metadata *elt0, Metadata *elt1,
// Metadata *elt2,
// const char *labels,
// value_witness_table_t *proposed);
FUNCTION(GetTupleMetadata3, swift_getTupleTypeMetadata3, SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataResponseTy),
ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrTy, TypeMetadataPtrTy,
Int8PtrTy, WitnessTablePtrTy),
ATTRS(NoUnwind, ReadOnly))
// void swift_getTupleTypeLayout(TypeLayout *result,
// uint32_t offsets,
// TupleTypeFlags flags,
// const TypeLayout * const *elts);
FUNCTION(GetTupleLayout, swift_getTupleTypeLayout, SwiftCC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(FullTypeLayoutTy->getPointerTo(0), Int32Ty->getPointerTo(0),
SizeTy, Int8PtrPtrTy->getPointerTo(0)),
ATTRS(NoUnwind))
// size_t swift_getTupleTypeLayout2(TypeLayout *layout,
// const TypeLayout *elt0,
// const TypeLayout *elt1);
FUNCTION(GetTupleLayout2, swift_getTupleTypeLayout2, SwiftCC, AlwaysAvailable,
RETURNS(SizeTy),
ARGS(FullTypeLayoutTy->getPointerTo(0), Int8PtrPtrTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
// OffsetPair swift_getTupleTypeLayout3(TypeLayout *layout,
// const TypeLayout *elt0,
// const TypeLayout *elt1,
// const TypeLayout *elt2);
FUNCTION(GetTupleLayout3, swift_getTupleTypeLayout3, SwiftCC, AlwaysAvailable,
RETURNS(OffsetPairTy),
ARGS(FullTypeLayoutTy->getPointerTo(0),
Int8PtrPtrTy, Int8PtrPtrTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
// Metadata *swift_getExistentialTypeMetadata(
// ProtocolClassConstraint classConstraint,
// const Metadata *superclassConstraint,
// size_t numProtocols,
// const ProtocolDescriptorRef *protocols);
//
// Note: ProtocolClassConstraint::Class is 0, ::Any is 1.
FUNCTION(GetExistentialMetadata,
swift_getExistentialTypeMetadata,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(Int1Ty, TypeMetadataPtrTy, SizeTy,
ProtocolDescriptorRefTy->getPointerTo()),
ATTRS(NoUnwind, ReadOnly))
// Metadata *swift_relocateClassMetadata(TypeContextDescriptor *descriptor,
// const void *pattern);
FUNCTION(RelocateClassMetadata,
swift_relocateClassMetadata, C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeContextDescriptorPtrTy, Int8PtrTy),
ATTRS(NoUnwind))
// void swift_initClassMetadata(Metadata *self,
// ClassLayoutFlags flags,
// size_t numFields,
// TypeLayout * const *fieldTypes,
// size_t *fieldOffsets);
FUNCTION(InitClassMetadata,
swift_initClassMetadata, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy,
Int8PtrPtrTy->getPointerTo(),
SizeTy->getPointerTo()),
ATTRS(NoUnwind))
// void swift_updateClassMetadata(Metadata *self,
// ClassLayoutFlags flags,
// size_t numFields,
// TypeLayout * const *fieldTypes,
// size_t *fieldOffsets);
FUNCTION(UpdateClassMetadata,
swift_updateClassMetadata, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy,
Int8PtrPtrTy->getPointerTo(),
SizeTy->getPointerTo()),
ATTRS(NoUnwind))
// MetadataDependency swift_initClassMetadata2(Metadata *self,
// ClassLayoutFlags flags,
// size_t numFields,
// TypeLayout * const *fieldTypes,
// size_t *fieldOffsets);
FUNCTION(InitClassMetadata2,
swift_initClassMetadata2, SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataDependencyTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy,
Int8PtrPtrTy->getPointerTo(),
SizeTy->getPointerTo()),
ATTRS(NoUnwind))
// MetadataDependency swift_updateClassMetadata2(Metadata *self,
// ClassLayoutFlags flags,
// size_t numFields,
// TypeLayout * const *fieldTypes,
// size_t *fieldOffsets);
FUNCTION(UpdateClassMetadata2,
swift_updateClassMetadata2, SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataDependencyTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy,
Int8PtrPtrTy->getPointerTo(),
SizeTy->getPointerTo()),
ATTRS(NoUnwind))
// void *swift_lookUpClassMethod(Metadata *metadata,
// ClassDescriptor *description,
// MethodDescriptor *method);
FUNCTION(LookUpClassMethod,
swift_lookUpClassMethod, C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(TypeMetadataPtrTy,
MethodDescriptorStructTy->getPointerTo(),
TypeContextDescriptorPtrTy),
ATTRS(NoUnwind))
// void swift_initStructMetadata(Metadata *structType,
// StructLayoutFlags flags,
// size_t numFields,
// TypeLayout * const *fieldTypes,
// uint32_t *fieldOffsets);
FUNCTION(InitStructMetadata,
swift_initStructMetadata, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy,
Int8PtrPtrTy->getPointerTo(0),
Int32Ty->getPointerTo()),
ATTRS(NoUnwind))
// void swift_initEnumMetadataSingleCase(Metadata *enumType,
// EnumLayoutFlags flags,
// TypeLayout *payload);
FUNCTION(InitEnumMetadataSingleCase,
swift_initEnumMetadataSingleCase,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
// void swift_initEnumMetadataSinglePayload(Metadata *enumType,
// EnumLayoutFlags flags,
// TypeLayout *payload,
// unsigned num_empty_cases);
FUNCTION(InitEnumMetadataSinglePayload,
swift_initEnumMetadataSinglePayload,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy, Int8PtrPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void swift_initEnumMetadataMultiPayload(Metadata *enumType,
// size_t numPayloads,
// TypeLayout * const *payloadTypes);
FUNCTION(InitEnumMetadataMultiPayload,
swift_initEnumMetadataMultiPayload,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy, Int8PtrPtrTy->getPointerTo(0)),
ATTRS(NoUnwind))
// int swift_getEnumCaseMultiPayload(opaque_t *obj, Metadata *enumTy);
FUNCTION(GetEnumCaseMultiPayload,
swift_getEnumCaseMultiPayload,
C_CC, AlwaysAvailable,
RETURNS(Int32Ty),
ARGS(OpaquePtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadOnly))
// int swift_getEnumTagSinglePayloadGeneric(opaque_t *obj,
// unsigned num_empty_cases,
// Metadata *payloadType,
// int (*getExtraInhabitantIndex)(opaque_t *obj,
// unsigned numPayloadXI,
// Metadata *payload));
FUNCTION(GetEnumTagSinglePayloadGeneric,
swift_getEnumTagSinglePayloadGeneric,
SwiftCC, AlwaysAvailable,
RETURNS(Int32Ty),
ARGS(OpaquePtrTy, Int32Ty, TypeMetadataPtrTy,
llvm::FunctionType::get(Int32Ty, {OpaquePtrTy, Int32Ty,
TypeMetadataPtrTy},
false)->getPointerTo()),
ATTRS(NoUnwind, ReadOnly))
// void swift_storeEnumTagSinglePayloadGeneric(opaque_t *obj,
// unsigned case_index,
// unsigned num_empty_cases,
// Metadata *payloadType,
// void (*storeExtraInhabitant)(opaque_t *obj,
// unsigned case_index,
// unsigned numPayloadXI,
// Metadata *payload));
FUNCTION(StoreEnumTagSinglePayloadGeneric,
swift_storeEnumTagSinglePayloadGeneric,
SwiftCC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, Int32Ty, Int32Ty, TypeMetadataPtrTy,
llvm::FunctionType::get(VoidTy, {OpaquePtrTy, Int32Ty, Int32Ty,
TypeMetadataPtrTy},
false)->getPointerTo()),
ATTRS(NoUnwind))
// void swift_storeEnumTagMultiPayload(opaque_t *obj, Metadata *enumTy,
// int case_index);
FUNCTION(StoreEnumTagMultiPayload,
swift_storeEnumTagMultiPayload,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, TypeMetadataPtrTy, Int32Ty),
ATTRS(NoUnwind))
// Class object_getClass(id object);
//
// This is readonly instead of readnone because isa-rewriting can have
// a noticeable effect.
FUNCTION(GetObjectClass, object_getClass, C_CC, AlwaysAvailable,
RETURNS(ObjCClassPtrTy),
ARGS(ObjCPtrTy),
ATTRS(NoUnwind, ReadOnly))
// id object_dispose(id object);
FUNCTION(ObjectDispose, object_dispose, C_CC, AlwaysAvailable,
RETURNS(ObjCPtrTy),
ARGS(ObjCPtrTy),
ATTRS(NoUnwind))
// Class objc_lookUpClass(const char *name);
FUNCTION(LookUpClass, objc_lookUpClass, C_CC, AlwaysAvailable,
RETURNS(ObjCClassPtrTy),
ARGS(Int8PtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getObjectType(id object);
FUNCTION(GetObjectType, swift_getObjectType, C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(ObjCPtrTy),
ATTRS(NoUnwind, ReadOnly))
// Metadata *swift_getDynamicType(opaque_t *obj, Metadata *self);
FUNCTION(GetDynamicType, swift_getDynamicType, C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(OpaquePtrTy, TypeMetadataPtrTy, Int1Ty),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastClass(void*, void*);
FUNCTION(DynamicCastClass, swift_dynamicCastClass, C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastClassUnconditional(void*, void*);
FUNCTION(DynamicCastClassUnconditional, swift_dynamicCastClassUnconditional,
C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy, Int8PtrTy, Int32Ty, Int32Ty),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastObjCClass(void*, void*);
FUNCTION(DynamicCastObjCClass, swift_dynamicCastObjCClass,
C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastObjCClassUnconditional(void*, void*);
FUNCTION(DynamicCastObjCClassUnconditional,
swift_dynamicCastObjCClassUnconditional, C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy, Int8PtrTy, Int32Ty, Int32Ty),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastUnknownClass(void*, void*);
FUNCTION(DynamicCastUnknownClass, swift_dynamicCastUnknownClass,
C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastUnknownClassUnconditional(void*, void*);
FUNCTION(DynamicCastUnknownClassUnconditional,
swift_dynamicCastUnknownClassUnconditional,
C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy, Int8PtrTy, Int32Ty, Int32Ty),
ATTRS(NoUnwind, ReadOnly))
// type *swift_dynamicCastMetatype(type*, type*);
FUNCTION(DynamicCastMetatype, swift_dynamicCastMetatype,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadOnly))
// type *swift_dynamicCastMetatypeUnconditional(type*, type*);
FUNCTION(DynamicCastMetatypeUnconditional,
swift_dynamicCastMetatypeUnconditional,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, TypeMetadataPtrTy, Int8PtrTy, Int32Ty, Int32Ty),
ATTRS(NoUnwind, ReadOnly))
// objc_class *swift_dynamicCastObjCClassMetatype(objc_class*, objc_class*);
FUNCTION(DynamicCastObjCClassMetatype, swift_dynamicCastObjCClassMetatype,
C_CC, AlwaysAvailable,
RETURNS(ObjCClassPtrTy),
ARGS(ObjCClassPtrTy, ObjCClassPtrTy),
ATTRS(NoUnwind, ReadOnly))
// objc_class *swift_dynamicCastObjCClassMetatypeUnconditional(objc_class*, objc_class*);
FUNCTION(DynamicCastObjCClassMetatypeUnconditional,
swift_dynamicCastObjCClassMetatypeUnconditional,
C_CC, AlwaysAvailable,
RETURNS(ObjCClassPtrTy),
ARGS(ObjCClassPtrTy, ObjCClassPtrTy, Int8PtrTy, Int32Ty, Int32Ty),
ATTRS(NoUnwind, ReadOnly))
// bool swift_dynamicCast(opaque*, opaque*, type*, type*, size_t);
FUNCTION(DynamicCast, swift_dynamicCast, C_CC, AlwaysAvailable,
RETURNS(Int1Ty),
ARGS(OpaquePtrTy, OpaquePtrTy, TypeMetadataPtrTy, TypeMetadataPtrTy,
SizeTy),
ATTRS(ZExt, NoUnwind))
// type* swift_dynamicCastTypeToObjCProtocolUnconditional(type* object,
// size_t numProtocols,
// Protocol * const *protocols);
FUNCTION(DynamicCastTypeToObjCProtocolUnconditional,
swift_dynamicCastTypeToObjCProtocolUnconditional,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, SizeTy, Int8PtrPtrTy, Int8PtrTy, Int32Ty, Int32Ty),
ATTRS(NoUnwind))
// type* swift_dynamicCastTypeToObjCProtocolConditional(type* object,
// size_t numProtocols,
// Protocol * const *protocols);
FUNCTION(DynamicCastTypeToObjCProtocolConditional,
swift_dynamicCastTypeToObjCProtocolConditional,
C_CC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, SizeTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
// id swift_dynamicCastObjCProtocolUnconditional(id object,
// size_t numProtocols,
// Protocol * const *protocols);
FUNCTION(DynamicCastObjCProtocolUnconditional,
swift_dynamicCastObjCProtocolUnconditional, C_CC, AlwaysAvailable,
RETURNS(ObjCPtrTy),
ARGS(ObjCPtrTy, SizeTy, Int8PtrPtrTy, Int8PtrTy, Int32Ty, Int32Ty),
ATTRS(NoUnwind))
// id swift_dynamicCastObjCProtocolConditional(id object,
// size_t numProtocols,
// Protocol * const *protocols);
FUNCTION(DynamicCastObjCProtocolConditional,
swift_dynamicCastObjCProtocolConditional, C_CC, AlwaysAvailable,
RETURNS(ObjCPtrTy),
ARGS(ObjCPtrTy, SizeTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
// id swift_dynamicCastMetatypeToObjectUnconditional(type *type);
FUNCTION(DynamicCastMetatypeToObjectUnconditional,
swift_dynamicCastMetatypeToObjectUnconditional, C_CC, AlwaysAvailable,
RETURNS(ObjCPtrTy),
ARGS(TypeMetadataPtrTy, Int8PtrTy, Int32Ty, Int32Ty),
ATTRS(NoUnwind, ReadNone))
// id swift_dynamicCastMetatypeToObjectConditional(type *type);
FUNCTION(DynamicCastMetatypeToObjectConditional,
swift_dynamicCastMetatypeToObjectConditional, C_CC, AlwaysAvailable,
RETURNS(ObjCPtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// witness_table* swift_conformsToProtocol(type*, protocol*);
FUNCTION(ConformsToProtocol,
swift_conformsToProtocol, C_CC, AlwaysAvailable,
RETURNS(WitnessTablePtrTy),
ARGS(TypeMetadataPtrTy, ProtocolDescriptorPtrTy),
ATTRS(NoUnwind, ReadNone))
// bool swift_isClassType(type*);
FUNCTION(IsClassType,
swift_isClassType, C_CC, AlwaysAvailable,
RETURNS(Int1Ty),
ARGS(TypeMetadataPtrTy),
ATTRS(ZExt, NoUnwind, ReadNone))
// bool swift_isOptionalType(type*);
FUNCTION(IsOptionalType,
swift_isOptionalType, C_CC, AlwaysAvailable,
RETURNS(Int1Ty),
ARGS(TypeMetadataPtrTy),
ATTRS(ZExt, NoUnwind, ReadNone))
// void swift_once(swift_once_t *predicate,
// void (*function_code)(RefCounted*),
// void *context);
FUNCTION(Once, swift_once, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(OnceTy->getPointerTo(), Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind))
// void swift_registerProtocols(const ProtocolRecord *begin,
// const ProtocolRecord *end)
FUNCTION(RegisterProtocols,
swift_registerProtocols, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ProtocolRecordPtrTy, ProtocolRecordPtrTy),
ATTRS(NoUnwind))
// void swift_registerProtocolConformances(const ProtocolConformanceRecord *begin,
// const ProtocolConformanceRecord *end)
FUNCTION(RegisterProtocolConformances,
swift_registerProtocolConformances, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(RelativeAddressPtrTy, RelativeAddressPtrTy),
ATTRS(NoUnwind))
FUNCTION(RegisterTypeMetadataRecords,
swift_registerTypeMetadataRecords, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(TypeMetadataRecordPtrTy, TypeMetadataRecordPtrTy),
ATTRS(NoUnwind))
// void swift_beginAccess(void *pointer, ValueBuffer *scratch, size_t flags);
FUNCTION(BeginAccess, swift_beginAccess, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(Int8PtrTy, getFixedBufferTy()->getPointerTo(), SizeTy, Int8PtrTy),
ATTRS(NoUnwind))
// void swift_endAccess(ValueBuffer *scratch);
FUNCTION(EndAccess, swift_endAccess, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(getFixedBufferTy()->getPointerTo()),
ATTRS(NoUnwind))
FUNCTION(GetOrigOfReplaceable, swift_getOrigOfReplaceable, C_CC,
DynamicReplacementAvailability,
RETURNS(FunctionPtrTy),
ARGS(FunctionPtrTy->getPointerTo()),
ATTRS(NoUnwind))
FUNCTION(GetReplacement, swift_getFunctionReplacement, C_CC,
DynamicReplacementAvailability,
RETURNS(FunctionPtrTy),
ARGS(FunctionPtrTy->getPointerTo(), FunctionPtrTy),
ATTRS(NoUnwind))
FUNCTION(InstantiateObjCClass, swift_instantiateObjCClass,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind))
FUNCTION(ObjCAllocWithZone, objc_allocWithZone,
C_CC, AlwaysAvailable,
RETURNS(ObjCPtrTy), ARGS(ObjCClassPtrTy), ATTRS(NoUnwind))
FUNCTION(ObjCMsgSend, objc_msgSend,
C_CC, AlwaysAvailable,
RETURNS(VoidTy), NO_ARGS, NO_ATTRS)
FUNCTION(ObjCMsgSendStret, objc_msgSend_stret,
C_CC, AlwaysAvailable,
RETURNS(VoidTy), NO_ARGS, NO_ATTRS)
FUNCTION(ObjCMsgSendSuper, objc_msgSendSuper,
C_CC, AlwaysAvailable,
RETURNS(VoidTy), NO_ARGS, NO_ATTRS)
FUNCTION(ObjCMsgSendSuperStret, objc_msgSendSuper_stret,
C_CC, AlwaysAvailable,
RETURNS(VoidTy), NO_ARGS, NO_ATTRS)
FUNCTION(ObjCMsgSendSuper2, objc_msgSendSuper2,
C_CC, AlwaysAvailable,
RETURNS(VoidTy), NO_ARGS, NO_ATTRS)
FUNCTION(ObjCMsgSendSuperStret2, objc_msgSendSuper2_stret,
C_CC, AlwaysAvailable,
RETURNS(VoidTy), NO_ARGS, NO_ATTRS)
FUNCTION(ObjCSelRegisterName, sel_registerName,
C_CC, AlwaysAvailable,
RETURNS(ObjCSELTy), ARGS(Int8PtrTy), ATTRS(NoUnwind, ReadNone))
FUNCTION(ClassReplaceMethod, class_replaceMethod,
C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(ObjCClassPtrTy, Int8PtrTy, Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind))
FUNCTION(ClassAddProtocol, class_addProtocol,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ObjCClassPtrTy, Int8PtrTy),
ATTRS(NoUnwind))
FUNCTION(ObjCGetClass, objc_getClass, C_CC, AlwaysAvailable,
RETURNS(ObjCClassPtrTy),
ARGS(Int8PtrTy),
ATTRS(NoUnwind))
FUNCTION(ObjCGetMetaClass, objc_getMetaClass, C_CC, AlwaysAvailable,
RETURNS(ObjCClassPtrTy),
ARGS(Int8PtrTy),
ATTRS(NoUnwind))
FUNCTION(ObjCClassGetName, class_getName, C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(ObjCClassPtrTy),
ATTRS(NoUnwind))
FUNCTION(GetObjCProtocol, objc_getProtocol, C_CC, AlwaysAvailable,
RETURNS(ProtocolDescriptorPtrTy),
ARGS(Int8PtrTy),
ATTRS(NoUnwind))
FUNCTION(AllocateObjCProtocol, objc_allocateProtocol, C_CC, AlwaysAvailable,
RETURNS(ProtocolDescriptorPtrTy),
ARGS(Int8PtrTy),
ATTRS(NoUnwind))
FUNCTION(RegisterObjCProtocol, objc_registerProtocol, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ProtocolDescriptorPtrTy),
ATTRS(NoUnwind))
FUNCTION(ProtocolAddMethodDescription, protocol_addMethodDescription,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ProtocolDescriptorPtrTy, Int8PtrTy, Int8PtrTy,
ObjCBoolTy, ObjCBoolTy),
ATTRS(NoUnwind))
FUNCTION(ProtocolAddProtocol, protocol_addProtocol,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ProtocolDescriptorPtrTy, ProtocolDescriptorPtrTy),
ATTRS(NoUnwind))
FUNCTION(ObjCOptSelf, objc_opt_self,
C_CC, AlwaysAvailable,
RETURNS(ObjCClassPtrTy),
ARGS(ObjCClassPtrTy),
ATTRS(NoUnwind))
FUNCTION(Malloc, malloc, C_CC, AlwaysAvailable,
RETURNS(Int8PtrTy),
ARGS(SizeTy),
NO_ATTRS)
FUNCTION(Free, free, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(Int8PtrTy),
NO_ATTRS)
// void *_Block_copy(void *block);
FUNCTION(BlockCopy, _Block_copy, C_CC, AlwaysAvailable,
RETURNS(ObjCBlockPtrTy),
ARGS(ObjCBlockPtrTy),
NO_ATTRS)
// void _Block_release(void *block);
FUNCTION(BlockRelease, _Block_release, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ObjCBlockPtrTy),
ATTRS(NoUnwind))
// void swift_deletedMethodError();
FUNCTION(DeletedMethodError, swift_deletedMethodError, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(),
ATTRS(NoUnwind))
FUNCTION(AllocError, swift_allocError, SwiftCC, AlwaysAvailable,
RETURNS(ErrorPtrTy, OpaquePtrTy),
ARGS(TypeMetadataPtrTy, WitnessTablePtrTy, OpaquePtrTy, Int1Ty),
ATTRS(NoUnwind))
FUNCTION(DeallocError, swift_deallocError, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ErrorPtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
FUNCTION(GetErrorValue, swift_getErrorValue, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ErrorPtrTy, Int8PtrPtrTy, OpenedErrorTriplePtrTy),
ATTRS(NoUnwind))
// void __tsan_external_write(void *addr, void *caller_pc, void *tag);
// This is a Thread Sanitizer instrumentation entry point in compiler-rt.
FUNCTION(TSanInoutAccess, __tsan_external_write, C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(Int8PtrTy, Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind))
FUNCTION(GetKeyPath, swift_getKeyPath, C_CC, AlwaysAvailable,
RETURNS(RefCountedPtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind))
FUNCTION(CopyKeyPathTrivialIndices, swift_copyKeyPathTrivialIndices,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(Int8PtrTy, Int8PtrTy, SizeTy),
ATTRS(NoUnwind))
FUNCTION(GetInitializedObjCClass, swift_getInitializedObjCClass,
C_CC, AlwaysAvailable,
RETURNS(ObjCClassPtrTy),
ARGS(ObjCClassPtrTy),
ATTRS(NoUnwind))
// void swift_objc_swift3ImplicitObjCEntrypoint(id self, SEL selector)
FUNCTION(Swift3ImplicitObjCEntrypoint, swift_objc_swift3ImplicitObjCEntrypoint,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(ObjCPtrTy, ObjCSELTy, Int8PtrTy, SizeTy, SizeTy, SizeTy, Int8PtrTy),
ATTRS(NoUnwind))
FUNCTION(VerifyTypeLayoutAttribute, _swift_debug_verifyTypeLayoutAttribute,
C_CC, AlwaysAvailable,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, Int8PtrTy, Int8PtrTy, SizeTy, Int8PtrTy),
ATTRS(NoUnwind))
// float swift_intToFloat32(const size_t *data, IntegerLiteralFlags flags);
FUNCTION(IntToFloat32, swift_intToFloat32, SwiftCC, AlwaysAvailable,
RETURNS(FloatTy),
ARGS(SizeTy->getPointerTo(), SizeTy),
ATTRS(NoUnwind, ReadOnly))
FUNCTION(IntToFloat64, swift_intToFloat64, SwiftCC, AlwaysAvailable,
RETURNS(DoubleTy),
ARGS(SizeTy->getPointerTo(), SizeTy),
ATTRS(NoUnwind, ReadOnly))
// const Metadata *swift_getTypeByMangledNameInContext(
// const char *typeNameStart,
// size_t typeNameLength,
// const TargetContextDescriptor<InProcess> *context,
// const void * const *genericArgs)
FUNCTION(GetTypeByMangledNameInContext, swift_getTypeByMangledNameInContext,
SwiftCC, AlwaysAvailable,
RETURNS(TypeMetadataPtrTy),
ARGS(Int8PtrTy, SizeTy, TypeContextDescriptorPtrTy, Int8PtrPtrTy),
ATTRS(NoUnwind, ArgMemOnly))
// const Metadata *swift_getTypeByMangledNameInContextInMetadataState(
// size_t metadataState,
// const char *typeNameStart,
// size_t typeNameLength,
// const TargetContextDescriptor<InProcess> *context,
// const void * const *genericArgs)
FUNCTION(GetTypeByMangledNameInContextInMetadataState,
swift_getTypeByMangledNameInContextInMetadataState, SwiftCC,
GetTypesInAbstractMetadataStateAvailability,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy, Int8PtrTy, SizeTy, TypeContextDescriptorPtrTy,
Int8PtrPtrTy),
ATTRS(NoUnwind, ArgMemOnly))
// AsyncTask *swift_task_getCurrent();s
FUNCTION(GetCurrentTask,
swift_task_getCurrent, SwiftCC,
ConcurrencyAvailability,
RETURNS(SwiftTaskPtrTy),
ARGS(),
ATTRS(NoUnwind, ReadNone))
// void *swift_task_alloc(size_t size);
FUNCTION(TaskAlloc,
swift_task_alloc, SwiftCC,
ConcurrencyAvailability,
RETURNS(Int8PtrTy),
ARGS(SizeTy),
ATTRS(NoUnwind, ArgMemOnly))
// void swift_task_dealloc(void *ptr);
FUNCTION(TaskDealloc,
swift_task_dealloc, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(Int8PtrTy),
ATTRS(NoUnwind, ArgMemOnly))
// void swift_task_cancel(AsyncTask *task);
FUNCTION(TaskCancel,
swift_task_cancel, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(SwiftTaskPtrTy),
ATTRS(NoUnwind, ArgMemOnly))
// AsyncTaskAndContext swift_task_create(
// size_t taskCreateFlags,
// TaskOptionRecord *options,
// const Metadata *futureResultType,
// void *closureEntry, HeapObject *closureContext);
FUNCTION(TaskCreate,
swift_task_create, SwiftCC,
ConcurrencyAvailability,
RETURNS(AsyncTaskAndContextTy),
ARGS(SizeTy,
SwiftTaskOptionRecordPtrTy,
TypeMetadataPtrTy,
Int8PtrTy,
RefCountedPtrTy),
ATTRS(NoUnwind, ArgMemOnly))
// void swift_task_switch(AsyncContext *resumeContext,
// TaskContinuationFunction *resumeFunction,
// ExecutorRef newExecutor);
FUNCTION(TaskSwitchFunc,
swift_task_switch, SwiftAsyncCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(SwiftContextPtrTy, Int8PtrTy, ExecutorFirstTy, ExecutorSecondTy),
ATTRS(NoUnwind))
// AsyncTask *swift_continuation_init(AsyncContext *continuationContext,
// AsyncContinuationFlags);
FUNCTION(ContinuationInit,
swift_continuation_init, SwiftCC,
ConcurrencyAvailability,
RETURNS(SwiftTaskPtrTy),
ARGS(ContinuationAsyncContextPtrTy, SizeTy),
ATTRS(NoUnwind))
// void swift_continuation_await(AsyncContext *continuationContext);
FUNCTION(ContinuationAwait,
swift_continuation_await, SwiftAsyncCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(ContinuationAsyncContextPtrTy),
ATTRS(NoUnwind))
// void swift_continuation_resume(AsyncTask *continuation);
FUNCTION(ContinuationResume,
swift_continuation_resume, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(SwiftTaskPtrTy),
ATTRS(NoUnwind))
// void swift_continuation_throwingResume(AsyncTask *continuation);
FUNCTION(ContinuationThrowingResume,
swift_continuation_throwingResume, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(SwiftTaskPtrTy),
ATTRS(NoUnwind))
// void swift_continuation_throwingResumeWithError(AsyncTask *continuation,
// SwiftError *error);
FUNCTION(ContinuationThrowingResumeWithError,
swift_continuation_throwingResumeWithError, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(SwiftTaskPtrTy, ErrorPtrTy),
ATTRS(NoUnwind))
// ExecutorRef swift_task_getCurrentExecutor();
FUNCTION(TaskGetCurrentExecutor,
swift_task_getCurrentExecutor, SwiftCC,
ConcurrencyAvailability,
RETURNS(SwiftExecutorTy),
ARGS(),
ATTRS(NoUnwind, ArgMemOnly))
// ExecutorRef swift_task_getMainExecutor();
FUNCTION(TaskGetMainExecutor,
swift_task_getMainExecutor, SwiftCC,
ConcurrencyAvailability,
RETURNS(SwiftExecutorTy),
ARGS(),
ATTRS(NoUnwind, ArgMemOnly))
// void swift_defaultActor_initialize(DefaultActor *actor);
FUNCTION(DefaultActorInitialize,
swift_defaultActor_initialize, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_defaultActor_destroy(DefaultActor *actor);
FUNCTION(DefaultActorDestroy,
swift_defaultActor_destroy, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_defaultActor_deallocate(DefaultActor *actor);
FUNCTION(DefaultActorDeallocate,
swift_defaultActor_deallocate, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_defaultActor_deallocateResilient(HeapObject *actor);
FUNCTION(DefaultActorDeallocateResilient,
swift_defaultActor_deallocateResilient, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_distributedActor_remote_initialize(DefaultActor *actor);
FUNCTION(DistributedActorInitializeRemote,
swift_distributedActor_remote_initialize, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy), // TODO also address and transport?
ATTRS(NoUnwind))
// void swift_distributedActor_destroy(DefaultActor *actor); // TODO: ProxyActor *proxy?
FUNCTION(DistributedActorDestroy,
swift_distributedActor_destroy, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
/// void swift_asyncLet_start(
/// AsyncLet *alet,
/// TaskOptionRecord *options,
/// const Metadata *futureResultType,
/// void *closureEntryPoint,
/// HeapObject *closureContext
/// );
FUNCTION(AsyncLetStart,
swift_asyncLet_start, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(SwiftAsyncLetPtrTy, // AsyncLet*
SwiftTaskOptionRecordPtrTy, // options
TypeMetadataPtrTy, // futureResultType
Int8PtrTy, // closureEntry
OpaquePtrTy, // closureContext
),
ATTRS(NoUnwind, ArgMemOnly))
// void swift_asyncLet_end(AsyncLet *alet);
FUNCTION(EndAsyncLet,
swift_asyncLet_end, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(SwiftAsyncLetPtrTy),
ATTRS(NoUnwind))
// void swift_taskGroup_initialize(TaskGroup *group);
FUNCTION(TaskGroupInitialize,
swift_taskGroup_initialize, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(Int8PtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_taskGroup_destroy(TaskGroup *group);
FUNCTION(TaskGroupDestroy,
swift_taskGroup_destroy, SwiftCC,
ConcurrencyAvailability,
RETURNS(VoidTy),
ARGS(Int8PtrTy),
ATTRS(NoUnwind))
// AutoDiffLinearMapContext *swift_autoDiffCreateLinearMapContext(size_t);
FUNCTION(AutoDiffCreateLinearMapContext,
swift_autoDiffCreateLinearMapContext, SwiftCC,
DifferentiationAvailability,
RETURNS(RefCountedPtrTy),
ARGS(SizeTy),
ATTRS(NoUnwind, ArgMemOnly))
// void *swift_autoDiffProjectTopLevelSubcontext(AutoDiffLinearMapContext *);
FUNCTION(AutoDiffProjectTopLevelSubcontext,
swift_autoDiffProjectTopLevelSubcontext, SwiftCC,
DifferentiationAvailability,
RETURNS(Int8PtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ArgMemOnly))
// void *swift_autoDiffAllocateSubcontext(AutoDiffLinearMapContext *, size_t);
FUNCTION(AutoDiffAllocateSubcontext,
swift_autoDiffAllocateSubcontext, SwiftCC,
DifferentiationAvailability,
RETURNS(Int8PtrTy),
ARGS(RefCountedPtrTy, SizeTy),
ATTRS(NoUnwind, ArgMemOnly))
// SWIFT_RUNTIME_EXPORT
// unsigned swift_getMultiPayloadEnumTagSinglePayload(const OpaqueValue *value,
// uint32_t numExtraCases,
// const Metadata *enumType)
FUNCTION(GetMultiPayloadEnumTagSinglePayload,
swift_getMultiPayloadEnumTagSinglePayload, C_CC,
MultiPayloadEnumTagSinglePayloadAvailability,
RETURNS(Int32Ty),
ARGS(OpaquePtrTy, Int32Ty, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// SWIFT_RUNTIME_EXPORT
// void swift_storeMultiPayloadEnumTagSinglePayload(OpaqueValue *value,
// uint32_t index,
// uint32_t numExtraCases,
// const Metadata *enumType);
FUNCTION(StoreMultiPayloadEnumTagSinglePayload,
swift_storeMultiPayloadEnumTagSinglePayload, C_CC,
MultiPayloadEnumTagSinglePayloadAvailability,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, Int32Ty, Int32Ty, TypeMetadataPtrTy),
ATTRS(NoUnwind))
#undef RETURNS
#undef ARGS
#undef ATTRS
#undef NO_ARGS
#undef NO_ATTRS
#undef FUNCTION
#undef FUNCTION_NAME
Reference in New Issue View Git Blame Copy Permalink