| //===--- 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. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| /// 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)) |
| |
| FUNCTION(ProjectBox, swift_projectBox, C_CC, AlwaysAvailable, |
| RETURNS(OpaquePtrTy), |
| ARGS(RefCountedPtrTy), |
| ATTRS(NoUnwind, ReadNone)) |
| |
| 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_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); |
| FUNCTION(GetObjCClassFromObject, swift_getObjCClassFromObject, |
| C_CC, AlwaysAvailable, |
| RETURNS(ObjCClassPtrTy), |
| ARGS(ObjCPtrTy), |
| ATTRS(NoUnwind, ReadNone)) |
| |
| // 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)) |
| |
| // void *swift_task_alloc(AsyncTask *task, size_t size); |
| FUNCTION(TaskAlloc, |
| swift_task_alloc, SwiftCC, |
| ConcurrencyAvailability, |
| RETURNS(Int8PtrTy), |
| ARGS(SwiftTaskPtrTy, SizeTy), |
| ATTRS(NoUnwind, ArgMemOnly)) |
| |
| // void swift_task_dealloc(AsyncTask *task, void *ptr); |
| FUNCTION(TaskDealloc, |
| swift_task_dealloc, SwiftCC, |
| ConcurrencyAvailability, |
| RETURNS(VoidTy), |
| ARGS(SwiftTaskPtrTy, 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 flags, AsyncTask *task, TaskContinuationFunction* function, |
| // size_t contextSize); |
| FUNCTION(TaskCreateFunc, |
| swift_task_create_f, SwiftCC, |
| ConcurrencyAvailability, |
| RETURNS(AsyncTaskAndContextTy), |
| ARGS(SizeTy, SwiftTaskPtrTy, TaskContinuationFunctionPtrTy, SizeTy), |
| ATTRS(NoUnwind, ArgMemOnly)) |
| |
| // AsyncTaskAndContext swift_task_create_future_f( |
| // size_t flags, AsyncTask *task, const Metadata *futureResultType, |
| // TaskContinuationFunction *function, size_t contextSize); |
| FUNCTION(TaskCreateFutureFunc, |
| swift_task_create_future_f, SwiftCC, |
| ConcurrencyAvailability, |
| RETURNS(AsyncTaskAndContextTy), |
| ARGS(SizeTy, SwiftTaskPtrTy, TypeMetadataPtrTy, |
| TaskContinuationFunctionPtrTy, SizeTy), |
| ATTRS(NoUnwind, ArgMemOnly)) |
| |
| // void swift_task_switch(AsyncTask *task, |
| // ExecutorRef currentExecutor, |
| // ExecutorRef newExecutor); |
| FUNCTION(TaskSwitchFunc, |
| swift_task_switch, SwiftCC, |
| ConcurrencyAvailability, |
| RETURNS(VoidTy), |
| ARGS(SwiftTaskPtrTy, SwiftExecutorPtrTy, SwiftExecutorPtrTy), |
| ATTRS(NoUnwind)) |
| |
| // 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)) |
| |
| // 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)) |
| |
| #undef RETURNS |
| #undef ARGS |
| #undef ATTRS |
| #undef NO_ARGS |
| #undef NO_ATTRS |
| #undef FUNCTION |
| #undef FUNCTION_NAME |
