mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
3cfda35b7c
functions. These were introduced in an early draft implementation of async let, but never used by a released compiler. They are not used as symbols by any app binaries. There's no reason to keep carrying them. While I'm at it, dramatically improve the documentation of the remaining async let API functions.
3068 lines
106 KiB
C++
3068 lines
106 KiB
C++
//===--- MetadataValues.h - Compiler/runtime ABI Metadata -------*- 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 header is shared between the runtime and the compiler and
|
|
// includes target-independent information which can be usefully shared
|
|
// between them.
|
|
//
|
|
// This header ought not to include any compiler-specific headers (such as
|
|
// those from `swift/AST`, `swift/SIL`, etc.) since doing so may introduce
|
|
// accidental ABI dependencies on compiler internals.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_ABI_METADATAVALUES_H
|
|
#define SWIFT_ABI_METADATAVALUES_H
|
|
|
|
#include "swift/ABI/KeyPath.h"
|
|
#include "swift/ABI/ProtocolDispatchStrategy.h"
|
|
#include "swift/ABI/InvertibleProtocols.h"
|
|
|
|
// FIXME: this include shouldn't be here, but removing it causes symbol
|
|
// mangling mismatches on Windows for some reason?
|
|
#include "swift/AST/Ownership.h"
|
|
|
|
#include "swift/Basic/Debug.h"
|
|
#include "swift/Basic/LLVM.h"
|
|
#include "swift/Basic/FlagSet.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
|
|
namespace swift {
|
|
|
|
enum {
|
|
/// The number of words (pointers) in a value buffer.
|
|
NumWords_ValueBuffer = 3,
|
|
|
|
/// The number of words in a metadata completion context.
|
|
NumWords_MetadataCompletionContext = 4,
|
|
|
|
/// The number of words in a yield-once coroutine buffer.
|
|
NumWords_YieldOnceBuffer = 4,
|
|
|
|
/// The number of words in a yield-many coroutine buffer.
|
|
NumWords_YieldManyBuffer = 8,
|
|
|
|
/// The number of words (in addition to the heap-object header)
|
|
/// in a default actor.
|
|
NumWords_DefaultActor = 12,
|
|
|
|
/// The number of words (in addition to the heap-object header)
|
|
/// in a non-default distributed actor.
|
|
NumWords_NonDefaultDistributedActor = 12,
|
|
|
|
/// The number of words in a task group.
|
|
NumWords_TaskGroup = 32,
|
|
|
|
/// The number of words in an AsyncLet (flags + child task context & allocation)
|
|
NumWords_AsyncLet = 80, // 640 bytes ought to be enough for anyone
|
|
|
|
/// The size of a unique hash.
|
|
NumBytes_UniqueHash = 16,
|
|
|
|
/// The maximum number of generic parameters that can be
|
|
/// implicitly declared, for generic signatures that support that.
|
|
MaxNumImplicitGenericParamDescriptors = 64,
|
|
};
|
|
|
|
struct InProcess;
|
|
template <typename Runtime> struct TargetMetadata;
|
|
using Metadata = TargetMetadata<InProcess>;
|
|
|
|
/// Non-type metadata kinds have this bit set.
|
|
const unsigned MetadataKindIsNonType = 0x400;
|
|
|
|
/// Non-heap metadata kinds have this bit set.
|
|
const unsigned MetadataKindIsNonHeap = 0x200;
|
|
|
|
// The above two flags are negative because the "class" kind has to be zero,
|
|
// and class metadata is both type and heap metadata.
|
|
|
|
/// Runtime-private metadata has this bit set. The compiler must not statically
|
|
/// generate metadata objects with these kinds, and external tools should not
|
|
/// rely on the stability of these values or the precise binary layout of
|
|
/// their associated data structures.
|
|
const unsigned MetadataKindIsRuntimePrivate = 0x100;
|
|
|
|
/// Kinds of Swift metadata records. Some of these are types, some
|
|
/// aren't.
|
|
enum class MetadataKind : uint32_t {
|
|
#define METADATAKIND(name, value) name = value,
|
|
#define ABSTRACTMETADATAKIND(name, start, end) \
|
|
name##_Start = start, name##_End = end,
|
|
#include "MetadataKind.def"
|
|
|
|
/// The largest possible non-isa-pointer metadata kind value.
|
|
///
|
|
/// This is included in the enumeration to prevent against attempts to
|
|
/// exhaustively match metadata kinds. Future Swift runtimes or compilers
|
|
/// may introduce new metadata kinds, so for forward compatibility, the
|
|
/// runtime must tolerate metadata with unknown kinds.
|
|
/// This specific value is not mapped to a valid metadata kind at this time,
|
|
/// however.
|
|
LastEnumerated = 0x7FF,
|
|
};
|
|
|
|
const unsigned LastEnumeratedMetadataKind =
|
|
(unsigned)MetadataKind::LastEnumerated;
|
|
|
|
inline bool isHeapMetadataKind(MetadataKind k) {
|
|
return !((uint32_t)k & MetadataKindIsNonHeap);
|
|
}
|
|
inline bool isTypeMetadataKind(MetadataKind k) {
|
|
return !((uint32_t)k & MetadataKindIsNonType);
|
|
}
|
|
inline bool isRuntimePrivateMetadataKind(MetadataKind k) {
|
|
return (uint32_t)k & MetadataKindIsRuntimePrivate;
|
|
}
|
|
|
|
/// Try to translate the 'isa' value of a type/heap metadata into a value
|
|
/// of the MetadataKind enum.
|
|
inline MetadataKind getEnumeratedMetadataKind(uint64_t kind) {
|
|
if (kind > LastEnumeratedMetadataKind)
|
|
return MetadataKind::Class;
|
|
return MetadataKind(kind);
|
|
}
|
|
|
|
StringRef getStringForMetadataKind(MetadataKind kind);
|
|
|
|
/// Kinds of Swift nominal type descriptor records.
|
|
enum class NominalTypeKind : uint32_t {
|
|
#define NOMINALTYPEMETADATAKIND(name, value) name = value,
|
|
#include "MetadataKind.def"
|
|
};
|
|
|
|
/// The maximum supported type alignment.
|
|
const size_t MaximumAlignment = 16;
|
|
|
|
/// The alignment of a DefaultActor.
|
|
const size_t Alignment_DefaultActor = MaximumAlignment;
|
|
const size_t Alignment_NonDefaultDistributedActor = MaximumAlignment;
|
|
|
|
/// The alignment of a TaskGroup.
|
|
const size_t Alignment_TaskGroup = MaximumAlignment;
|
|
|
|
/// The alignment of an AsyncLet.
|
|
const size_t Alignment_AsyncLet = MaximumAlignment;
|
|
|
|
/// Flags stored in the value-witness table.
|
|
template <typename int_type>
|
|
class TargetValueWitnessFlags {
|
|
public:
|
|
// The polarity of these bits is chosen so that, when doing struct layout, the
|
|
// flags of the field types can be mostly bitwise-or'ed together to derive the
|
|
// flags for the struct. (The "non-inline" and "has-extra-inhabitants" bits
|
|
// still require additional fixup.)
|
|
enum : uint32_t {
|
|
AlignmentMask = 0x000000FF,
|
|
// unused 0x0000FF00,
|
|
IsNonPOD = 0x00010000,
|
|
IsNonInline = 0x00020000,
|
|
// unused 0x00040000,
|
|
HasSpareBits = 0x00080000,
|
|
IsNonBitwiseTakable = 0x00100000,
|
|
HasEnumWitnesses = 0x00200000,
|
|
Incomplete = 0x00400000,
|
|
IsNonCopyable = 0x00800000,
|
|
IsNonBitwiseBorrowable = 0x01000000,
|
|
IsAddressableForDependencies = 0x02000000,
|
|
// unused 0xFC000000,
|
|
};
|
|
|
|
static constexpr const uint32_t MaxNumExtraInhabitants = 0x7FFFFFFF;
|
|
|
|
private:
|
|
uint32_t Data;
|
|
|
|
explicit constexpr TargetValueWitnessFlags(uint32_t data) : Data(data) {}
|
|
|
|
public:
|
|
constexpr TargetValueWitnessFlags() : Data(0) {}
|
|
|
|
/// The required alignment of the first byte of an object of this
|
|
/// type, expressed as a mask of the low bits that must not be set
|
|
/// in the pointer.
|
|
///
|
|
/// This representation can be easily converted to the 'alignof'
|
|
/// result by merely adding 1, but it is more directly useful for
|
|
/// performing dynamic structure layouts, and it grants an
|
|
/// additional bit of precision in a compact field without needing
|
|
/// to switch to an exponent representation.
|
|
///
|
|
/// For example, if the type needs to be 8-byte aligned, the
|
|
/// appropriate alignment mask should be 0x7.
|
|
size_t getAlignmentMask() const {
|
|
return (Data & AlignmentMask);
|
|
}
|
|
constexpr TargetValueWitnessFlags withAlignmentMask(size_t alignMask) const {
|
|
return TargetValueWitnessFlags((Data & ~AlignmentMask) | alignMask);
|
|
}
|
|
|
|
size_t getAlignment() const { return getAlignmentMask() + 1; }
|
|
constexpr TargetValueWitnessFlags withAlignment(size_t alignment) const {
|
|
return withAlignmentMask(alignment - 1);
|
|
}
|
|
|
|
/// True if the type requires out-of-line allocation of its storage.
|
|
/// This can be the case because the value requires more storage or if it is
|
|
/// not bitwise takable.
|
|
bool isInlineStorage() const { return !(Data & IsNonInline); }
|
|
constexpr TargetValueWitnessFlags withInlineStorage(bool isInline) const {
|
|
return TargetValueWitnessFlags((Data & ~IsNonInline) |
|
|
(isInline ? 0 : IsNonInline));
|
|
}
|
|
|
|
/// True if values of this type can be copied with memcpy (if it's copyable)
|
|
/// and destroyed with a no-op.
|
|
bool isPOD() const { return !(Data & IsNonPOD); }
|
|
constexpr TargetValueWitnessFlags withPOD(bool isPOD) const {
|
|
return TargetValueWitnessFlags((Data & ~IsNonPOD) |
|
|
(isPOD ? 0 : IsNonPOD));
|
|
}
|
|
|
|
/// True if values of this type can be taken with memcpy. Unlike C++ 'move',
|
|
/// 'take' is a destructive operation that invalidates the source object, so
|
|
/// most types can be taken with a simple bitwise copy. Only types with side
|
|
/// table references, like @weak references, or types with opaque value
|
|
/// semantics, like imported C++ types, are not bitwise-takable.
|
|
bool isBitwiseTakable() const { return !(Data & IsNonBitwiseTakable); }
|
|
constexpr TargetValueWitnessFlags withBitwiseTakable(bool isBT) const {
|
|
return TargetValueWitnessFlags((Data & ~IsNonBitwiseTakable) |
|
|
(isBT ? 0 : IsNonBitwiseTakable));
|
|
}
|
|
|
|
/// True if values of this type can be passed by value when borrowed.
|
|
/// If this bit is true, then borrows of the value are independent of the
|
|
/// value's address, so a value can be passed in registers or memcpy'd
|
|
/// while borrowed. This is in contrast to Rust, for instance, where a
|
|
/// `&T` type is always represented as a pointer, and borrowing a
|
|
/// value always moves the borrowed value into memory.
|
|
bool isBitwiseBorrowable() const {
|
|
/// This bit was introduced with Swift 6; prior to the introduction of
|
|
/// `Atomic` and `Mutex`, a type was always bitwise-borrowable if it
|
|
/// was bitwise-takable. Compilers and runtimes before Swift 6 would
|
|
/// never set the `IsNonBitwiseBorrowable` bit in the value witness
|
|
/// table, but any type that sets `IsNonBitwiseTakable` is definitely
|
|
/// not bitwise borrowable.
|
|
return isBitwiseTakable()
|
|
&& !(Data & IsNonBitwiseBorrowable);
|
|
}
|
|
constexpr TargetValueWitnessFlags withBitwiseBorrowable(bool isBB) const {
|
|
return TargetValueWitnessFlags((Data & ~IsNonBitwiseBorrowable) |
|
|
(isBB ? 0 : IsNonBitwiseBorrowable));
|
|
}
|
|
|
|
/// True if values of this type can be copied.
|
|
bool isCopyable() const { return !(Data & IsNonCopyable); }
|
|
constexpr TargetValueWitnessFlags withCopyable(bool isCopyable) const {
|
|
return TargetValueWitnessFlags((Data & ~IsNonCopyable) |
|
|
(isCopyable ? 0 : IsNonCopyable));
|
|
}
|
|
|
|
/// True if values of this type are addressable-for-dependencies, meaning
|
|
/// that values of this type should be passed indirectly to functions that
|
|
/// produce lifetime-dependent values that could possibly contain pointers
|
|
/// to the inline storage of this type.
|
|
bool isAddressableForDependencies() const {
|
|
return Data & IsAddressableForDependencies;
|
|
}
|
|
constexpr TargetValueWitnessFlags withAddressableForDependencies(bool afd) const {
|
|
return TargetValueWitnessFlags((Data & ~IsAddressableForDependencies) |
|
|
(afd ? IsAddressableForDependencies : 0));
|
|
}
|
|
|
|
|
|
/// True if this type's binary representation is that of an enum, and the
|
|
/// enum value witness table entries are available in this type's value
|
|
/// witness table.
|
|
bool hasEnumWitnesses() const { return Data & HasEnumWitnesses; }
|
|
constexpr TargetValueWitnessFlags
|
|
withEnumWitnesses(bool hasEnumWitnesses) const {
|
|
return TargetValueWitnessFlags((Data & ~HasEnumWitnesses) |
|
|
(hasEnumWitnesses ? HasEnumWitnesses : 0));
|
|
}
|
|
|
|
/// True if the type with this value-witness table is incomplete,
|
|
/// meaning that its external layout (size, etc.) is meaningless
|
|
/// pending completion of the metadata layout.
|
|
bool isIncomplete() const { return Data & Incomplete; }
|
|
constexpr TargetValueWitnessFlags
|
|
withIncomplete(bool isIncomplete) const {
|
|
return TargetValueWitnessFlags((Data & ~Incomplete) |
|
|
(isIncomplete ? Incomplete : 0));
|
|
}
|
|
|
|
constexpr uint32_t getOpaqueValue() const {
|
|
return Data;
|
|
}
|
|
};
|
|
using ValueWitnessFlags = TargetValueWitnessFlags<size_t>;
|
|
|
|
/// Flags for dynamic-cast operations.
|
|
enum class DynamicCastFlags : size_t {
|
|
/// All flags clear.
|
|
Default = 0x0,
|
|
|
|
/// True if the cast is not permitted to fail.
|
|
Unconditional = 0x1,
|
|
|
|
/// True if the cast should 'take' the source value on success;
|
|
/// false if the value should be copied.
|
|
TakeOnSuccess = 0x2,
|
|
|
|
/// True if the cast should destroy the source value on failure;
|
|
/// false if the value should be left in place.
|
|
DestroyOnFailure = 0x4,
|
|
|
|
/// True if the cast should prohibit the use of any isolated conformances,
|
|
/// for example because there is a Sendable constraint on the existential
|
|
/// type we're casting to.
|
|
ProhibitIsolatedConformances = 0x8,
|
|
};
|
|
inline bool operator&(DynamicCastFlags a, DynamicCastFlags b) {
|
|
return (size_t(a) & size_t(b)) != 0;
|
|
}
|
|
inline DynamicCastFlags operator|(DynamicCastFlags a, DynamicCastFlags b) {
|
|
return DynamicCastFlags(size_t(a) | size_t(b));
|
|
}
|
|
inline DynamicCastFlags operator-(DynamicCastFlags a, DynamicCastFlags b) {
|
|
return DynamicCastFlags(size_t(a) & ~size_t(b));
|
|
}
|
|
inline DynamicCastFlags &operator|=(DynamicCastFlags &a, DynamicCastFlags b) {
|
|
return a = (a | b);
|
|
}
|
|
|
|
/// Swift class flags.
|
|
/// These flags are valid only when isTypeMetadata().
|
|
/// When !isTypeMetadata() these flags will collide with other Swift ABIs.
|
|
enum class ClassFlags : uint32_t {
|
|
/// Is this a Swift class from the Darwin pre-stable ABI?
|
|
/// This bit is clear in stable ABI Swift classes.
|
|
/// The Objective-C runtime also reads this bit.
|
|
IsSwiftPreStableABI = 0x1,
|
|
|
|
/// Does this class use Swift refcounting?
|
|
UsesSwiftRefcounting = 0x2,
|
|
|
|
/// Has this class a custom name, specified with the @objc attribute?
|
|
HasCustomObjCName = 0x4,
|
|
|
|
/// Whether this metadata is a specialization of a generic metadata pattern
|
|
/// which was created during compilation.
|
|
IsStaticSpecialization = 0x8,
|
|
|
|
/// Whether this metadata is a specialization of a generic metadata pattern
|
|
/// which was created during compilation and made to be canonical by
|
|
/// modifying the metadata accessor.
|
|
IsCanonicalStaticSpecialization = 0x10,
|
|
};
|
|
inline bool operator&(ClassFlags a, ClassFlags b) {
|
|
return (uint32_t(a) & uint32_t(b)) != 0;
|
|
}
|
|
inline ClassFlags operator|(ClassFlags a, ClassFlags b) {
|
|
return ClassFlags(uint32_t(a) | uint32_t(b));
|
|
}
|
|
inline ClassFlags &operator|=(ClassFlags &a, ClassFlags b) {
|
|
return a = (a | b);
|
|
}
|
|
|
|
/// Flags that go in a MethodDescriptor structure.
|
|
class MethodDescriptorFlags {
|
|
public:
|
|
typedef uint32_t int_type;
|
|
enum class Kind {
|
|
Method,
|
|
Init,
|
|
Getter,
|
|
Setter,
|
|
ModifyCoroutine,
|
|
ReadCoroutine,
|
|
};
|
|
|
|
private:
|
|
enum : int_type {
|
|
KindMask = 0x0F, // 16 kinds should be enough for anybody
|
|
IsInstanceMask = 0x10,
|
|
IsDynamicMask = 0x20,
|
|
IsAsyncMask = 0x40,
|
|
ExtraDiscriminatorShift = 16,
|
|
ExtraDiscriminatorMask = 0xFFFF0000,
|
|
};
|
|
|
|
int_type Value;
|
|
|
|
public:
|
|
MethodDescriptorFlags(Kind kind) : Value(unsigned(kind)) {}
|
|
|
|
MethodDescriptorFlags withIsInstance(bool isInstance) const {
|
|
auto copy = *this;
|
|
if (isInstance) {
|
|
copy.Value |= IsInstanceMask;
|
|
} else {
|
|
copy.Value &= ~IsInstanceMask;
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
MethodDescriptorFlags withIsDynamic(bool isDynamic) const {
|
|
auto copy = *this;
|
|
if (isDynamic)
|
|
copy.Value |= IsDynamicMask;
|
|
else
|
|
copy.Value &= ~IsDynamicMask;
|
|
return copy;
|
|
}
|
|
|
|
MethodDescriptorFlags withIsAsync(bool isAsync) const {
|
|
auto copy = *this;
|
|
if (isAsync)
|
|
copy.Value |= IsAsyncMask;
|
|
else
|
|
copy.Value &= ~IsAsyncMask;
|
|
return copy;
|
|
}
|
|
|
|
MethodDescriptorFlags withExtraDiscriminator(uint16_t value) const {
|
|
auto copy = *this;
|
|
copy.Value = (copy.Value & ~ExtraDiscriminatorMask)
|
|
| (int_type(value) << ExtraDiscriminatorShift);
|
|
return copy;
|
|
}
|
|
|
|
Kind getKind() const { return Kind(Value & KindMask); }
|
|
|
|
/// Is the method marked 'dynamic'?
|
|
bool isDynamic() const { return Value & IsDynamicMask; }
|
|
|
|
/// Is the method an instance member?
|
|
///
|
|
/// Note that 'init' is not considered an instance member.
|
|
bool isInstance() const { return Value & IsInstanceMask; }
|
|
|
|
bool _hasAsyncBitSet() const { return Value & IsAsyncMask; }
|
|
|
|
bool isAsync() const { return !isCoroutine() && _hasAsyncBitSet(); }
|
|
|
|
bool isCoroutine() const {
|
|
switch (getKind()) {
|
|
case Kind::Method:
|
|
case Kind::Init:
|
|
case Kind::Getter:
|
|
case Kind::Setter:
|
|
return false;
|
|
case Kind::ModifyCoroutine:
|
|
case Kind::ReadCoroutine:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool isCalleeAllocatedCoroutine() const {
|
|
return isCoroutine() && _hasAsyncBitSet();
|
|
}
|
|
|
|
bool isData() const { return isAsync() || isCalleeAllocatedCoroutine(); }
|
|
|
|
uint16_t getExtraDiscriminator() const {
|
|
return (Value >> ExtraDiscriminatorShift);
|
|
}
|
|
|
|
int_type getIntValue() const { return Value; }
|
|
};
|
|
|
|
enum : unsigned {
|
|
/// Number of words reserved in generic metadata patterns.
|
|
NumGenericMetadataPrivateDataWords = 16,
|
|
};
|
|
|
|
/// Kinds of type metadata/protocol conformance records.
|
|
enum class TypeReferenceKind : unsigned {
|
|
/// The conformance is for a nominal type referenced directly;
|
|
/// getTypeDescriptor() points to the type context descriptor.
|
|
DirectTypeDescriptor = 0x00,
|
|
|
|
/// The conformance is for a nominal type referenced indirectly;
|
|
/// getTypeDescriptor() points to the type context descriptor.
|
|
IndirectTypeDescriptor = 0x01,
|
|
|
|
/// The conformance is for an Objective-C class that should be looked up
|
|
/// by class name.
|
|
DirectObjCClassName = 0x02,
|
|
|
|
/// The conformance is for an Objective-C class that has no nominal type
|
|
/// descriptor.
|
|
/// getIndirectObjCClass() points to a variable that contains the pointer to
|
|
/// the class object, which then requires a runtime call to get metadata.
|
|
///
|
|
/// On platforms without Objective-C interoperability, this case is
|
|
/// unused.
|
|
IndirectObjCClass = 0x03,
|
|
|
|
// We only reserve three bits for this in the various places we store it.
|
|
|
|
First_Kind = DirectTypeDescriptor,
|
|
Last_Kind = IndirectObjCClass,
|
|
};
|
|
|
|
/// Flag that indicates whether an existential type is class-constrained or not.
|
|
enum class ProtocolClassConstraint : bool {
|
|
/// The protocol is class-constrained, so only class types can conform to it.
|
|
///
|
|
/// This must be 0 for ABI compatibility with Objective-C protocol_t records.
|
|
Class = false,
|
|
/// Any type can conform to the protocol.
|
|
Any = true,
|
|
};
|
|
|
|
/// Identifiers for protocols with special meaning to the Swift runtime.
|
|
enum class SpecialProtocol: uint8_t {
|
|
/// Not a special protocol.
|
|
///
|
|
/// This must be 0 for ABI compatibility with Objective-C protocol_t records.
|
|
None = 0,
|
|
/// The Error protocol.
|
|
Error = 1,
|
|
};
|
|
|
|
/// Flags for protocol descriptors.
|
|
class ProtocolDescriptorFlags {
|
|
typedef uint32_t int_type;
|
|
enum : int_type {
|
|
IsSwift = 1U << 0U,
|
|
ClassConstraint = 1U << 1U,
|
|
|
|
DispatchStrategyMask = 0xFU << 2U,
|
|
DispatchStrategyShift = 2,
|
|
|
|
SpecialProtocolMask = 0x000003C0U,
|
|
SpecialProtocolShift = 6,
|
|
|
|
IsResilient = 1U << 10U,
|
|
|
|
/// Reserved by the ObjC runtime.
|
|
_ObjCReserved = 0xFFFF0000U,
|
|
};
|
|
|
|
int_type Data;
|
|
|
|
constexpr ProtocolDescriptorFlags(int_type Data) : Data(Data) {}
|
|
public:
|
|
constexpr ProtocolDescriptorFlags() : Data(0) {}
|
|
constexpr ProtocolDescriptorFlags withSwift(bool s) const {
|
|
return ProtocolDescriptorFlags((Data & ~IsSwift) | (s ? IsSwift : 0));
|
|
}
|
|
constexpr ProtocolDescriptorFlags withClassConstraint(
|
|
ProtocolClassConstraint c) const {
|
|
return ProtocolDescriptorFlags((Data & ~ClassConstraint)
|
|
| (bool(c) ? ClassConstraint : 0));
|
|
}
|
|
constexpr ProtocolDescriptorFlags withDispatchStrategy(
|
|
ProtocolDispatchStrategy s) const {
|
|
return ProtocolDescriptorFlags((Data & ~DispatchStrategyMask)
|
|
| (int_type(s) << DispatchStrategyShift));
|
|
}
|
|
constexpr ProtocolDescriptorFlags
|
|
withSpecialProtocol(SpecialProtocol sp) const {
|
|
return ProtocolDescriptorFlags((Data & ~SpecialProtocolMask)
|
|
| (int_type(sp) << SpecialProtocolShift));
|
|
}
|
|
constexpr ProtocolDescriptorFlags withResilient(bool s) const {
|
|
return ProtocolDescriptorFlags((Data & ~IsResilient) | (s ? IsResilient : 0));
|
|
}
|
|
|
|
/// Was the protocol defined in Swift 1 or 2?
|
|
bool isSwift() const { return Data & IsSwift; }
|
|
|
|
/// Is the protocol class-constrained?
|
|
ProtocolClassConstraint getClassConstraint() const {
|
|
return ProtocolClassConstraint(bool(Data & ClassConstraint));
|
|
}
|
|
|
|
/// What dispatch strategy does this protocol use?
|
|
ProtocolDispatchStrategy getDispatchStrategy() const {
|
|
return ProtocolDispatchStrategy((Data & DispatchStrategyMask)
|
|
>> DispatchStrategyShift);
|
|
}
|
|
|
|
/// Does the protocol require a witness table for method dispatch?
|
|
bool needsWitnessTable() const {
|
|
return swift::protocolRequiresWitnessTable(getDispatchStrategy());
|
|
}
|
|
|
|
/// Return the identifier if this is a special runtime-known protocol.
|
|
SpecialProtocol getSpecialProtocol() const {
|
|
return SpecialProtocol(uint8_t((Data & SpecialProtocolMask)
|
|
>> SpecialProtocolShift));
|
|
}
|
|
|
|
/// Can new requirements with default witnesses be added resiliently?
|
|
bool isResilient() const { return Data & IsResilient; }
|
|
|
|
int_type getIntValue() const {
|
|
return Data;
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
SWIFT_DEBUG_DUMP;
|
|
#endif
|
|
};
|
|
|
|
/// Flags that go in a ProtocolRequirement structure.
|
|
class ProtocolRequirementFlags {
|
|
public:
|
|
typedef uint32_t int_type;
|
|
enum class Kind {
|
|
BaseProtocol,
|
|
Method,
|
|
Init,
|
|
Getter,
|
|
Setter,
|
|
ReadCoroutine,
|
|
ModifyCoroutine,
|
|
AssociatedTypeAccessFunction,
|
|
AssociatedConformanceAccessFunction,
|
|
};
|
|
|
|
private:
|
|
enum : int_type {
|
|
KindMask = 0x0F, // 16 kinds should be enough for anybody
|
|
IsInstanceMask = 0x10,
|
|
IsAsyncMask = 0x20,
|
|
ExtraDiscriminatorShift = 16,
|
|
ExtraDiscriminatorMask = 0xFFFF0000,
|
|
};
|
|
|
|
int_type Value;
|
|
|
|
public:
|
|
ProtocolRequirementFlags(Kind kind) : Value(unsigned(kind)) {}
|
|
|
|
ProtocolRequirementFlags withIsInstance(bool isInstance) const {
|
|
auto copy = *this;
|
|
if (isInstance) {
|
|
copy.Value |= IsInstanceMask;
|
|
} else {
|
|
copy.Value &= ~IsInstanceMask;
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
ProtocolRequirementFlags withIsAsync(bool isAsync) const {
|
|
auto copy = *this;
|
|
if (isAsync)
|
|
copy.Value |= IsAsyncMask;
|
|
else
|
|
copy.Value &= ~IsAsyncMask;
|
|
return copy;
|
|
}
|
|
|
|
ProtocolRequirementFlags withExtraDiscriminator(uint16_t value) const {
|
|
auto copy = *this;
|
|
copy.Value = (copy.Value & ~ExtraDiscriminatorMask)
|
|
| (int_type(value) << ExtraDiscriminatorShift);
|
|
return copy;
|
|
}
|
|
|
|
Kind getKind() const { return Kind(Value & KindMask); }
|
|
|
|
/// Is the method an instance member?
|
|
///
|
|
/// Note that 'init' is not considered an instance member.
|
|
bool isInstance() const { return Value & IsInstanceMask; }
|
|
|
|
bool _hasAsyncBitSet() const { return Value & IsAsyncMask; }
|
|
|
|
bool isAsync() const { return !isCoroutine() && _hasAsyncBitSet(); }
|
|
|
|
bool isCoroutine() const {
|
|
switch (getKind()) {
|
|
case Kind::BaseProtocol:
|
|
case Kind::Method:
|
|
case Kind::Init:
|
|
case Kind::Getter:
|
|
case Kind::Setter:
|
|
case Kind::AssociatedTypeAccessFunction:
|
|
case Kind::AssociatedConformanceAccessFunction:
|
|
return false;
|
|
case Kind::ReadCoroutine:
|
|
case Kind::ModifyCoroutine:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool isCalleeAllocatedCoroutine() const {
|
|
return isCoroutine() && _hasAsyncBitSet();
|
|
}
|
|
|
|
bool isData() const { return isAsync() || isCalleeAllocatedCoroutine(); }
|
|
|
|
bool isSignedWithAddress() const {
|
|
return getKind() != Kind::BaseProtocol;
|
|
}
|
|
|
|
uint16_t getExtraDiscriminator() const {
|
|
return (Value >> ExtraDiscriminatorShift);
|
|
}
|
|
|
|
int_type getIntValue() const { return Value; }
|
|
|
|
/// Is the method implementation is represented as a native function pointer?
|
|
bool isFunctionImpl() const {
|
|
switch (getKind()) {
|
|
case ProtocolRequirementFlags::Kind::Method:
|
|
case ProtocolRequirementFlags::Kind::Init:
|
|
case ProtocolRequirementFlags::Kind::Getter:
|
|
case ProtocolRequirementFlags::Kind::Setter:
|
|
case ProtocolRequirementFlags::Kind::ReadCoroutine:
|
|
case ProtocolRequirementFlags::Kind::ModifyCoroutine:
|
|
return !isAsync();
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
enum : uintptr_t {
|
|
/// Bit used to indicate that an associated type witness is a pointer to
|
|
/// a mangled name (vs. a pointer to metadata).
|
|
AssociatedTypeMangledNameBit = 0x01,
|
|
};
|
|
|
|
enum : uint8_t {
|
|
/// Prefix byte used to identify an associated type whose mangled name
|
|
/// is relative to the protocol's context rather than the conforming
|
|
/// type's context.
|
|
AssociatedTypeInProtocolContextByte = 0xFF
|
|
};
|
|
};
|
|
|
|
/// Flags that go in a TargetConformanceDescriptor structure.
|
|
class ConformanceFlags {
|
|
public:
|
|
typedef uint32_t int_type;
|
|
|
|
private:
|
|
enum : int_type {
|
|
UnusedLowBits = 0x07, // historical conformance kind
|
|
|
|
TypeMetadataKindMask = 0x7u << 3, // 8 type reference kinds
|
|
TypeMetadataKindShift = 3,
|
|
|
|
IsRetroactiveMask = 0x01u << 6,
|
|
IsSynthesizedNonUniqueMask = 0x01u << 7,
|
|
|
|
NumConditionalRequirementsMask = 0xFFu << 8,
|
|
NumConditionalRequirementsShift = 8,
|
|
|
|
HasResilientWitnessesMask = 0x01u << 16,
|
|
HasGenericWitnessTableMask = 0x01u << 17,
|
|
IsConformanceOfProtocolMask = 0x01u << 18,
|
|
HasGlobalActorIsolation = 0x01u << 19,
|
|
|
|
NumConditionalPackDescriptorsMask = 0xFFu << 24,
|
|
NumConditionalPackDescriptorsShift = 24
|
|
};
|
|
|
|
int_type Value;
|
|
|
|
public:
|
|
ConformanceFlags(int_type value = 0) : Value(value) {}
|
|
|
|
ConformanceFlags withTypeReferenceKind(TypeReferenceKind kind) const {
|
|
return ConformanceFlags((Value & ~TypeMetadataKindMask)
|
|
| (int_type(kind) << TypeMetadataKindShift));
|
|
}
|
|
|
|
ConformanceFlags withIsRetroactive(bool isRetroactive) const {
|
|
return ConformanceFlags((Value & ~IsRetroactiveMask)
|
|
| (isRetroactive? IsRetroactiveMask : 0));
|
|
}
|
|
|
|
ConformanceFlags withIsSynthesizedNonUnique(
|
|
bool isSynthesizedNonUnique) const {
|
|
return ConformanceFlags(
|
|
(Value & ~IsSynthesizedNonUniqueMask)
|
|
| (isSynthesizedNonUnique ? IsSynthesizedNonUniqueMask : 0));
|
|
}
|
|
|
|
ConformanceFlags withNumConditionalRequirements(unsigned n) const {
|
|
return ConformanceFlags((Value & ~NumConditionalRequirementsMask)
|
|
| (n << NumConditionalRequirementsShift));
|
|
}
|
|
|
|
ConformanceFlags withNumConditionalPackDescriptors(unsigned n) const {
|
|
return ConformanceFlags((Value & ~NumConditionalPackDescriptorsMask)
|
|
| (n << NumConditionalPackDescriptorsShift));
|
|
}
|
|
|
|
ConformanceFlags withHasResilientWitnesses(bool hasResilientWitnesses) const {
|
|
return ConformanceFlags((Value & ~HasResilientWitnessesMask)
|
|
| (hasResilientWitnesses? HasResilientWitnessesMask
|
|
: 0));
|
|
}
|
|
|
|
ConformanceFlags withHasGenericWitnessTable(
|
|
bool hasGenericWitnessTable) const {
|
|
return ConformanceFlags((Value & ~HasGenericWitnessTableMask)
|
|
| (hasGenericWitnessTable
|
|
? HasGenericWitnessTableMask
|
|
: 0));
|
|
}
|
|
|
|
ConformanceFlags withIsConformanceOfProtocol(
|
|
bool isConformanceOfProtocol) const {
|
|
return ConformanceFlags((Value & ~IsConformanceOfProtocolMask)
|
|
| (isConformanceOfProtocol
|
|
? IsConformanceOfProtocolMask
|
|
: 0));
|
|
}
|
|
|
|
ConformanceFlags withHasGlobalActorIsolation(
|
|
bool hasGlobalActorIsolation) const {
|
|
return ConformanceFlags((Value & ~HasGlobalActorIsolation)
|
|
| (hasGlobalActorIsolation
|
|
? HasGlobalActorIsolation
|
|
: 0));
|
|
}
|
|
|
|
/// Retrieve the type reference kind.
|
|
TypeReferenceKind getTypeReferenceKind() const {
|
|
return TypeReferenceKind(
|
|
(Value & TypeMetadataKindMask) >> TypeMetadataKindShift);
|
|
}
|
|
|
|
/// Is the conformance "retroactive"?
|
|
///
|
|
/// A conformance is retroactive when it occurs in a module that is
|
|
/// neither the module in which the protocol is defined nor the module
|
|
/// in which the conforming type is defined. With retroactive conformance,
|
|
/// it is possible to detect a conflict at run time.
|
|
bool isRetroactive() const { return Value & IsRetroactiveMask; }
|
|
|
|
/// Is the conformance synthesized in a non-unique manner?
|
|
///
|
|
/// The Swift compiler will synthesize conformances on behalf of some
|
|
/// imported entities (e.g., C typedefs with the swift_wrapper attribute).
|
|
/// Such conformances are retroactive by nature, but the presence of multiple
|
|
/// such conformances is not a conflict because all synthesized conformances
|
|
/// will be equivalent.
|
|
bool isSynthesizedNonUnique() const {
|
|
return Value & IsSynthesizedNonUniqueMask;
|
|
}
|
|
|
|
/// Is this a conformance of a protocol to another protocol?
|
|
///
|
|
/// The Swift compiler can synthesize a conformance of one protocol to
|
|
/// another, meaning that every type that conforms to the first protocol
|
|
/// can also produce a witness table conforming to the second. Such
|
|
/// conformances cannot generally be written in the surface language, but
|
|
/// can be made available for specific tasks. The only such instance at the
|
|
/// time of this writing is that a (local) distributed actor can conform to
|
|
/// a local actor, but the witness table can only be used via a specific
|
|
/// builtin to form an existential.
|
|
bool isConformanceOfProtocol() const {
|
|
return Value & IsConformanceOfProtocolMask;
|
|
}
|
|
|
|
/// Does this conformance have a global actor to which it is isolated?
|
|
bool hasGlobalActorIsolation() const {
|
|
return Value & HasGlobalActorIsolation;
|
|
}
|
|
|
|
/// Retrieve the # of conditional requirements.
|
|
unsigned getNumConditionalRequirements() const {
|
|
return (Value & NumConditionalRequirementsMask)
|
|
>> NumConditionalRequirementsShift;
|
|
}
|
|
|
|
/// Retrieve the # of conditional pack shape descriptors.
|
|
unsigned getNumConditionalPackShapeDescriptors() const {
|
|
return (Value & NumConditionalPackDescriptorsMask)
|
|
>> NumConditionalPackDescriptorsShift;
|
|
}
|
|
|
|
/// Whether this conformance has any resilient witnesses.
|
|
bool hasResilientWitnesses() const {
|
|
return Value & HasResilientWitnessesMask;
|
|
}
|
|
|
|
/// Whether this conformance has a generic witness table that may need to
|
|
/// be instantiated.
|
|
bool hasGenericWitnessTable() const {
|
|
return Value & HasGenericWitnessTableMask;
|
|
}
|
|
|
|
int_type getIntValue() const { return Value; }
|
|
};
|
|
|
|
/// Flags in an existential type metadata record.
|
|
class ExistentialTypeFlags {
|
|
public:
|
|
typedef uint32_t int_type;
|
|
|
|
private:
|
|
enum : int_type {
|
|
NumWitnessTablesMask = 0x00FFFFFFU,
|
|
ClassConstraintMask = 0x80000000U, // Warning: Set if NOT class-constrained!
|
|
HasSuperclassMask = 0x40000000U,
|
|
SpecialProtocolMask = 0x3F000000U,
|
|
SpecialProtocolShift = 24U,
|
|
};
|
|
int_type Data;
|
|
|
|
public:
|
|
constexpr ExistentialTypeFlags(int_type Data) : Data(Data) {}
|
|
constexpr ExistentialTypeFlags() : Data(0) {}
|
|
constexpr ExistentialTypeFlags withNumWitnessTables(unsigned numTables) const {
|
|
return ExistentialTypeFlags((Data & ~NumWitnessTablesMask) | numTables);
|
|
}
|
|
constexpr ExistentialTypeFlags
|
|
withClassConstraint(ProtocolClassConstraint c) const {
|
|
return ExistentialTypeFlags((Data & ~ClassConstraintMask)
|
|
| (bool(c) ? ClassConstraintMask : 0));
|
|
}
|
|
constexpr ExistentialTypeFlags
|
|
withHasSuperclass(bool hasSuperclass) const {
|
|
return ExistentialTypeFlags((Data & ~HasSuperclassMask)
|
|
| (hasSuperclass ? HasSuperclassMask : 0));
|
|
}
|
|
constexpr ExistentialTypeFlags
|
|
withSpecialProtocol(SpecialProtocol sp) const {
|
|
return ExistentialTypeFlags((Data & ~SpecialProtocolMask)
|
|
| (int_type(sp) << SpecialProtocolShift));
|
|
}
|
|
|
|
unsigned getNumWitnessTables() const {
|
|
return Data & NumWitnessTablesMask;
|
|
}
|
|
|
|
ProtocolClassConstraint getClassConstraint() const {
|
|
return ProtocolClassConstraint(bool(Data & ClassConstraintMask));
|
|
}
|
|
|
|
bool hasSuperclassConstraint() const {
|
|
return bool(Data & HasSuperclassMask);
|
|
}
|
|
|
|
/// Return whether this existential type represents an uncomposed special
|
|
/// protocol.
|
|
SpecialProtocol getSpecialProtocol() const {
|
|
return SpecialProtocol(uint8_t((Data & SpecialProtocolMask)
|
|
>> SpecialProtocolShift));
|
|
}
|
|
|
|
int_type getIntValue() const {
|
|
return Data;
|
|
}
|
|
};
|
|
|
|
/// Flags in an extended existential shape.
|
|
class ExtendedExistentialTypeShapeFlags {
|
|
public:
|
|
typedef uint32_t int_type;
|
|
|
|
/// Special cases for the representation.
|
|
enum class SpecialKind {
|
|
None = 0,
|
|
|
|
/// The existential has a class constraint.
|
|
/// The inline storage is sizeof(void*) / alignof(void*),
|
|
/// the value is always stored inline, the value is reference-
|
|
/// counted (using unknown reference counting), and the
|
|
/// type metadata for the requirement generic parameters are
|
|
/// not stored in the existential container because they can
|
|
/// be recovered from the instance type of the class.
|
|
Class = 1,
|
|
|
|
/// The existential has a metatype constraint.
|
|
/// The inline storage is sizeof(void*) / alignof(void*),
|
|
/// the value is always stored inline, the value is a Metadata*,
|
|
/// and the type metadata for the requirement generic parameters
|
|
/// are not stored in the existential container because they can
|
|
/// be recovered from the stored metatype.
|
|
Metatype = 2,
|
|
|
|
/// The inline value storage has a non-storage layout. The shape
|
|
/// must include a value witness table. Type metadata for the
|
|
/// requirement generic parameters are still stored in the existential
|
|
/// container.
|
|
ExplicitLayout = 3,
|
|
|
|
// 255 is the maximum
|
|
};
|
|
|
|
private:
|
|
enum : int_type {
|
|
SpecialKindMask = 0x000000FFU,
|
|
SpecialKindShift = 0,
|
|
HasGeneralizationSignature = 0x00000100U,
|
|
HasTypeExpression = 0x00000200U,
|
|
HasSuggestedValueWitnesses = 0x00000400U,
|
|
HasImplicitReqSigParams = 0x00000800U,
|
|
HasImplicitGenSigParams = 0x00001000U,
|
|
HasTypePacks = 0x00002000U,
|
|
};
|
|
int_type Data;
|
|
|
|
public:
|
|
constexpr ExtendedExistentialTypeShapeFlags() : Data(0) {}
|
|
constexpr ExtendedExistentialTypeShapeFlags(int_type Data) : Data(Data) {}
|
|
constexpr ExtendedExistentialTypeShapeFlags
|
|
withSpecialKind(SpecialKind kind) const {
|
|
return ExtendedExistentialTypeShapeFlags(
|
|
(Data & ~SpecialKindMask) | (int_type(kind) << SpecialKindShift));
|
|
}
|
|
constexpr ExtendedExistentialTypeShapeFlags
|
|
withHasTypeExpression(bool hasTypeExpression) const {
|
|
return ExtendedExistentialTypeShapeFlags(
|
|
hasTypeExpression ? (Data | HasTypeExpression)
|
|
: (Data & ~HasTypeExpression));
|
|
}
|
|
constexpr ExtendedExistentialTypeShapeFlags
|
|
withGeneralizationSignature(bool hasGeneralization) const {
|
|
return ExtendedExistentialTypeShapeFlags(
|
|
hasGeneralization ? (Data | HasGeneralizationSignature)
|
|
: (Data & ~HasGeneralizationSignature));
|
|
}
|
|
constexpr ExtendedExistentialTypeShapeFlags
|
|
withSuggestedValueWitnesses(bool hasSuggestedVWT) const {
|
|
return ExtendedExistentialTypeShapeFlags(
|
|
hasSuggestedVWT ? (Data | HasSuggestedValueWitnesses)
|
|
: (Data & ~HasSuggestedValueWitnesses));
|
|
}
|
|
constexpr ExtendedExistentialTypeShapeFlags
|
|
withImplicitReqSigParams(bool implicit) const {
|
|
return ExtendedExistentialTypeShapeFlags(
|
|
implicit ? (Data | HasImplicitReqSigParams)
|
|
: (Data & ~HasImplicitReqSigParams));
|
|
}
|
|
constexpr ExtendedExistentialTypeShapeFlags
|
|
withImplicitGenSigParams(bool implicit) const {
|
|
return ExtendedExistentialTypeShapeFlags(
|
|
implicit ? (Data | HasImplicitGenSigParams)
|
|
: (Data & ~HasImplicitGenSigParams));
|
|
}
|
|
constexpr ExtendedExistentialTypeShapeFlags
|
|
withTypePacks(bool hasTypePacks) const {
|
|
return ExtendedExistentialTypeShapeFlags(
|
|
hasTypePacks ? (Data | HasTypePacks)
|
|
: (Data & ~HasTypePacks));
|
|
}
|
|
|
|
/// Is this a special kind of existential?
|
|
SpecialKind getSpecialKind() const {
|
|
return SpecialKind((Data & SpecialKindMask) >> SpecialKindShift);
|
|
}
|
|
bool isOpaque() const { return getSpecialKind() == SpecialKind::None; }
|
|
bool isClassConstrained() const {
|
|
return getSpecialKind() == SpecialKind::Class;
|
|
}
|
|
bool isMetatypeConstrained() const {
|
|
return getSpecialKind() == SpecialKind::Metatype;
|
|
}
|
|
|
|
bool hasGeneralizationSignature() const {
|
|
return Data & HasGeneralizationSignature;
|
|
}
|
|
|
|
bool hasTypeExpression() const {
|
|
return Data & HasTypeExpression;
|
|
}
|
|
|
|
bool hasSuggestedValueWitnesses() const {
|
|
return Data & HasSuggestedValueWitnesses;
|
|
}
|
|
|
|
/// The parameters of the requirement signature are not stored
|
|
/// explicitly in the shape.
|
|
///
|
|
/// In order to enable this, there must be no more than
|
|
/// MaxNumImplicitGenericParamDescriptors generic parameters, and
|
|
/// they must match GenericParamDescriptor::implicit().
|
|
bool hasImplicitReqSigParams() const {
|
|
return Data & HasImplicitReqSigParams;
|
|
}
|
|
|
|
/// The parameters of the generalization signature are not stored
|
|
/// explicitly in the shape.
|
|
///
|
|
/// In order to enable this, there must be no more than
|
|
/// MaxNumImplicitGenericParamDescriptors generic parameters, and
|
|
/// they must match GenericParamDescriptor::implicit().
|
|
bool hasImplicitGenSigParams() const {
|
|
return Data & HasImplicitGenSigParams;
|
|
}
|
|
|
|
/// Whether the generic context has type parameter packs. This
|
|
/// occurs when the existential has a superclass requirement
|
|
/// whose class declaration has a type parameter pack, eg
|
|
/// `any P & C<...>` with `class C<each T> {}`.
|
|
bool hasTypePacks() const {
|
|
return Data & HasTypePacks;
|
|
}
|
|
|
|
int_type getIntValue() const {
|
|
return Data;
|
|
}
|
|
};
|
|
|
|
/// Convention values for function type metadata.
|
|
enum class FunctionMetadataConvention: uint8_t {
|
|
Swift = 0,
|
|
Block = 1,
|
|
Thin = 2,
|
|
CFunctionPointer = 3,
|
|
};
|
|
|
|
/// Differentiability kind for function type metadata.
|
|
/// Duplicates `DifferentiabilityKind` in AST/AutoDiff.h.
|
|
template <typename int_type>
|
|
struct TargetFunctionMetadataDifferentiabilityKind {
|
|
enum Value : int_type {
|
|
NonDifferentiable = 0,
|
|
Forward = 1,
|
|
Reverse = 2,
|
|
Normal = 3,
|
|
Linear = 4,
|
|
} Value;
|
|
|
|
constexpr TargetFunctionMetadataDifferentiabilityKind(
|
|
enum Value value = NonDifferentiable) : Value(value) {}
|
|
|
|
int_type getIntValue() const {
|
|
return (int_type)Value;
|
|
}
|
|
|
|
bool isDifferentiable() const {
|
|
return Value != NonDifferentiable;
|
|
}
|
|
};
|
|
using FunctionMetadataDifferentiabilityKind =
|
|
TargetFunctionMetadataDifferentiabilityKind<size_t>;
|
|
|
|
/// Flags in a function type metadata record.
|
|
template <typename int_type>
|
|
class TargetFunctionTypeFlags {
|
|
// If we were ever to run out of space for function flags (8 bits)
|
|
// one of the flag bits could be used to identify that the rest of
|
|
// the flags is going to be stored somewhere else in the metadata.
|
|
enum : int_type {
|
|
NumParametersMask = 0x0000FFFFU,
|
|
ConventionMask = 0x00FF0000U,
|
|
ConventionShift = 16U,
|
|
ThrowsMask = 0x01000000U,
|
|
ParamFlagsMask = 0x02000000U,
|
|
EscapingMask = 0x04000000U,
|
|
DifferentiableMask = 0x08000000U,
|
|
GlobalActorMask = 0x10000000U,
|
|
AsyncMask = 0x20000000U,
|
|
SendableMask = 0x40000000U,
|
|
ExtendedFlagsMask = 0x80000000U,
|
|
// NOTE: No more room for flags here. Use TargetExtendedFunctionTypeFlags.
|
|
};
|
|
int_type Data;
|
|
|
|
constexpr TargetFunctionTypeFlags(int_type Data) : Data(Data) {}
|
|
public:
|
|
constexpr TargetFunctionTypeFlags() : Data(0) {}
|
|
|
|
constexpr TargetFunctionTypeFlags
|
|
withNumParameters(unsigned numParams) const {
|
|
return TargetFunctionTypeFlags((Data & ~NumParametersMask) | numParams);
|
|
}
|
|
|
|
constexpr TargetFunctionTypeFlags<int_type>
|
|
withConvention(FunctionMetadataConvention c) const {
|
|
return TargetFunctionTypeFlags((Data & ~ConventionMask)
|
|
| (int_type(c) << ConventionShift));
|
|
}
|
|
|
|
constexpr TargetFunctionTypeFlags<int_type>
|
|
withAsync(bool async) const {
|
|
return TargetFunctionTypeFlags<int_type>((Data & ~AsyncMask) |
|
|
(async ? AsyncMask : 0));
|
|
}
|
|
|
|
constexpr TargetFunctionTypeFlags<int_type>
|
|
withThrows(bool throws) const {
|
|
return TargetFunctionTypeFlags<int_type>((Data & ~ThrowsMask) |
|
|
(throws ? ThrowsMask : 0));
|
|
}
|
|
|
|
constexpr TargetFunctionTypeFlags<int_type>
|
|
withDifferentiable(bool differentiable) const {
|
|
return TargetFunctionTypeFlags<int_type>((Data & ~DifferentiableMask) |
|
|
(differentiable ? DifferentiableMask : 0));
|
|
}
|
|
|
|
constexpr TargetFunctionTypeFlags<int_type>
|
|
withParameterFlags(bool hasFlags) const {
|
|
return TargetFunctionTypeFlags<int_type>((Data & ~ParamFlagsMask) |
|
|
(hasFlags ? ParamFlagsMask : 0));
|
|
}
|
|
|
|
constexpr TargetFunctionTypeFlags<int_type>
|
|
withEscaping(bool isEscaping) const {
|
|
return TargetFunctionTypeFlags<int_type>((Data & ~EscapingMask) |
|
|
(isEscaping ? EscapingMask : 0));
|
|
}
|
|
|
|
constexpr TargetFunctionTypeFlags<int_type>
|
|
withSendable(bool isSendable) const {
|
|
return TargetFunctionTypeFlags<int_type>(
|
|
(Data & ~SendableMask) |
|
|
(isSendable ? SendableMask : 0));
|
|
}
|
|
|
|
constexpr TargetFunctionTypeFlags<int_type>
|
|
withGlobalActor(bool globalActor) const {
|
|
return TargetFunctionTypeFlags<int_type>(
|
|
(Data & ~GlobalActorMask) | (globalActor ? GlobalActorMask : 0));
|
|
}
|
|
|
|
constexpr TargetFunctionTypeFlags<int_type>
|
|
withExtendedFlags(bool extendedFlags) const {
|
|
return TargetFunctionTypeFlags<int_type>(
|
|
(Data & ~ExtendedFlagsMask) | (extendedFlags ? ExtendedFlagsMask : 0));
|
|
}
|
|
|
|
unsigned getNumParameters() const { return Data & NumParametersMask; }
|
|
|
|
FunctionMetadataConvention getConvention() const {
|
|
return FunctionMetadataConvention((Data&ConventionMask) >> ConventionShift);
|
|
}
|
|
|
|
bool isAsync() const { return bool(Data & AsyncMask); }
|
|
|
|
bool isThrowing() const { return bool(Data & ThrowsMask); }
|
|
|
|
bool isEscaping() const {
|
|
return bool (Data & EscapingMask);
|
|
}
|
|
|
|
bool isSendable() const {
|
|
return bool (Data & SendableMask);
|
|
}
|
|
|
|
bool hasParameterFlags() const { return bool(Data & ParamFlagsMask); }
|
|
|
|
bool isDifferentiable() const {
|
|
return bool (Data & DifferentiableMask);
|
|
}
|
|
|
|
bool hasGlobalActor() const {
|
|
return bool (Data & GlobalActorMask);
|
|
}
|
|
|
|
bool hasExtendedFlags() const {
|
|
return bool (Data & ExtendedFlagsMask);
|
|
}
|
|
|
|
int_type getIntValue() const {
|
|
return Data;
|
|
}
|
|
|
|
static TargetFunctionTypeFlags<int_type> fromIntValue(int_type Data) {
|
|
return TargetFunctionTypeFlags(Data);
|
|
}
|
|
|
|
bool operator==(TargetFunctionTypeFlags<int_type> other) const {
|
|
return Data == other.Data;
|
|
}
|
|
bool operator!=(TargetFunctionTypeFlags<int_type> other) const {
|
|
return Data != other.Data;
|
|
}
|
|
};
|
|
using FunctionTypeFlags = TargetFunctionTypeFlags<size_t>;
|
|
|
|
/// Extended flags in a function type metadata record.
|
|
template <typename int_type>
|
|
class TargetExtendedFunctionTypeFlags {
|
|
enum : int_type {
|
|
TypedThrowsMask = 0x00000001U,
|
|
IsolationMask = 0x0000000EU, // three bits
|
|
|
|
// Values for the enumerated isolation kinds
|
|
IsolatedAny = 0x00000002U,
|
|
NonIsolatedNonsending = 0x00000004U,
|
|
|
|
// Values if we have a sending result.
|
|
HasSendingResult = 0x00000010U,
|
|
|
|
/// A InvertibleProtocolSet in the high bits.
|
|
InvertedProtocolshift = 16,
|
|
InvertedProtocolMask = 0xFFFFU << InvertedProtocolshift,
|
|
};
|
|
int_type Data;
|
|
|
|
constexpr TargetExtendedFunctionTypeFlags(int_type Data) : Data(Data) {}
|
|
public:
|
|
constexpr TargetExtendedFunctionTypeFlags() : Data(0) {}
|
|
|
|
constexpr TargetExtendedFunctionTypeFlags<int_type>
|
|
withTypedThrows(bool typedThrows) const {
|
|
return TargetExtendedFunctionTypeFlags<int_type>(
|
|
(Data & ~TypedThrowsMask) | (typedThrows ? TypedThrowsMask : 0));
|
|
}
|
|
|
|
const TargetExtendedFunctionTypeFlags<int_type>
|
|
withNonIsolated() const {
|
|
return TargetExtendedFunctionTypeFlags<int_type>(Data & ~IsolationMask);
|
|
}
|
|
|
|
const TargetExtendedFunctionTypeFlags<int_type>
|
|
withIsolatedAny() const {
|
|
return TargetExtendedFunctionTypeFlags<int_type>(
|
|
(Data & ~IsolationMask) | IsolatedAny);
|
|
}
|
|
|
|
const TargetExtendedFunctionTypeFlags<int_type>
|
|
withNonIsolatedCaller() const {
|
|
return TargetExtendedFunctionTypeFlags<int_type>((Data & ~IsolationMask) |
|
|
NonIsolatedNonsending);
|
|
}
|
|
|
|
const TargetExtendedFunctionTypeFlags<int_type>
|
|
withSendingResult(bool newValue = true) const {
|
|
return TargetExtendedFunctionTypeFlags<int_type>(
|
|
(Data & ~HasSendingResult) |
|
|
(newValue ? HasSendingResult : 0));
|
|
}
|
|
|
|
const TargetExtendedFunctionTypeFlags<int_type>
|
|
withInvertedProtocols(InvertibleProtocolSet inverted) const {
|
|
return TargetExtendedFunctionTypeFlags<int_type>(
|
|
(Data & ~InvertedProtocolMask) |
|
|
(inverted.rawBits() << InvertedProtocolshift));
|
|
}
|
|
|
|
bool isTypedThrows() const { return bool(Data & TypedThrowsMask); }
|
|
|
|
bool isIsolatedAny() const {
|
|
return (Data & IsolationMask) == IsolatedAny;
|
|
}
|
|
|
|
bool isNonIsolatedCaller() const {
|
|
return (Data & IsolationMask) == NonIsolatedNonsending;
|
|
}
|
|
|
|
bool hasSendingResult() const {
|
|
return bool(Data & HasSendingResult);
|
|
}
|
|
|
|
int_type getIntValue() const {
|
|
return Data;
|
|
}
|
|
|
|
InvertibleProtocolSet getInvertedProtocols() const {
|
|
return InvertibleProtocolSet(Data >> InvertedProtocolshift);
|
|
}
|
|
|
|
static TargetExtendedFunctionTypeFlags<int_type> fromIntValue(int_type Data) {
|
|
return TargetExtendedFunctionTypeFlags(Data);
|
|
}
|
|
|
|
bool operator==(TargetExtendedFunctionTypeFlags<int_type> other) const {
|
|
return Data == other.Data;
|
|
}
|
|
bool operator!=(TargetExtendedFunctionTypeFlags<int_type> other) const {
|
|
return Data != other.Data;
|
|
}
|
|
};
|
|
using ExtendedFunctionTypeFlags = TargetExtendedFunctionTypeFlags<uint32_t>;
|
|
|
|
/// Different kinds of value ownership supported by function types.
|
|
enum class ParameterOwnership : uint8_t {
|
|
/// the context-dependent default ownership (sometimes shared,
|
|
/// sometimes owned)
|
|
Default,
|
|
/// an 'inout' exclusive, mutating borrow
|
|
InOut,
|
|
/// a 'borrowing' nonexclusive, usually nonmutating borrow
|
|
Shared,
|
|
/// a 'consuming' ownership transfer
|
|
Owned,
|
|
|
|
Last_Kind = Owned
|
|
};
|
|
|
|
template <typename int_type>
|
|
class TargetParameterTypeFlags {
|
|
enum : int_type {
|
|
OwnershipMask = 0x7F,
|
|
VariadicMask = 0x80,
|
|
AutoClosureMask = 0x100,
|
|
NoDerivativeMask = 0x200,
|
|
IsolatedMask = 0x400,
|
|
SendingMask = 0x800,
|
|
};
|
|
int_type Data;
|
|
|
|
constexpr TargetParameterTypeFlags(int_type Data) : Data(Data) {}
|
|
|
|
public:
|
|
constexpr TargetParameterTypeFlags() : Data(0) {}
|
|
|
|
constexpr TargetParameterTypeFlags<int_type>
|
|
withOwnership(ParameterOwnership ownership) const {
|
|
return TargetParameterTypeFlags<int_type>((Data & ~OwnershipMask) |
|
|
(int_type)ownership);
|
|
}
|
|
|
|
constexpr TargetParameterTypeFlags<int_type>
|
|
withVariadic(bool isVariadic) const {
|
|
return TargetParameterTypeFlags<int_type>((Data & ~VariadicMask) |
|
|
(isVariadic ? VariadicMask : 0));
|
|
}
|
|
|
|
constexpr TargetParameterTypeFlags<int_type>
|
|
withAutoClosure(bool isAutoClosure) const {
|
|
return TargetParameterTypeFlags<int_type>(
|
|
(Data & ~AutoClosureMask) | (isAutoClosure ? AutoClosureMask : 0));
|
|
}
|
|
|
|
constexpr TargetParameterTypeFlags<int_type>
|
|
withNoDerivative(bool isNoDerivative) const {
|
|
return TargetParameterTypeFlags<int_type>(
|
|
(Data & ~NoDerivativeMask) | (isNoDerivative ? NoDerivativeMask : 0));
|
|
}
|
|
|
|
constexpr TargetParameterTypeFlags<int_type>
|
|
withIsolated(bool isIsolated) const {
|
|
return TargetParameterTypeFlags<int_type>(
|
|
(Data & ~IsolatedMask) | (isIsolated ? IsolatedMask : 0));
|
|
}
|
|
|
|
constexpr TargetParameterTypeFlags<int_type>
|
|
withSending(bool isSending) const {
|
|
return TargetParameterTypeFlags<int_type>(
|
|
(Data & ~SendingMask) | (isSending ? SendingMask : 0));
|
|
}
|
|
|
|
bool isNone() const { return Data == 0; }
|
|
bool isVariadic() const { return Data & VariadicMask; }
|
|
bool isAutoClosure() const { return Data & AutoClosureMask; }
|
|
bool isNoDerivative() const { return Data & NoDerivativeMask; }
|
|
bool isIsolated() const { return Data & IsolatedMask; }
|
|
bool isSending() const { return Data & SendingMask; }
|
|
|
|
ParameterOwnership getOwnership() const {
|
|
return (ParameterOwnership)(Data & OwnershipMask);
|
|
}
|
|
|
|
int_type getIntValue() const { return Data; }
|
|
|
|
static TargetParameterTypeFlags<int_type> fromIntValue(int_type Data) {
|
|
return TargetParameterTypeFlags(Data);
|
|
}
|
|
|
|
bool operator==(TargetParameterTypeFlags<int_type> other) const {
|
|
return Data == other.Data;
|
|
}
|
|
bool operator!=(TargetParameterTypeFlags<int_type> other) const {
|
|
return Data != other.Data;
|
|
}
|
|
};
|
|
using ParameterFlags = TargetParameterTypeFlags<uint32_t>;
|
|
|
|
template <typename int_type>
|
|
class TargetTupleTypeFlags {
|
|
enum : int_type {
|
|
NumElementsMask = 0x0000FFFFU,
|
|
NonConstantLabelsMask = 0x00010000U,
|
|
};
|
|
int_type Data;
|
|
|
|
public:
|
|
constexpr TargetTupleTypeFlags() : Data(0) {}
|
|
constexpr TargetTupleTypeFlags(int_type Data) : Data(Data) {}
|
|
|
|
constexpr TargetTupleTypeFlags
|
|
withNumElements(unsigned numElements) const {
|
|
return TargetTupleTypeFlags((Data & ~NumElementsMask) | numElements);
|
|
}
|
|
|
|
constexpr TargetTupleTypeFlags<int_type> withNonConstantLabels(
|
|
bool hasNonConstantLabels) const {
|
|
return TargetTupleTypeFlags<int_type>(
|
|
(Data & ~NonConstantLabelsMask) |
|
|
(hasNonConstantLabels ? NonConstantLabelsMask : 0));
|
|
}
|
|
|
|
unsigned getNumElements() const { return Data & NumElementsMask; }
|
|
|
|
bool hasNonConstantLabels() const { return Data & NonConstantLabelsMask; }
|
|
|
|
int_type getIntValue() const { return Data; }
|
|
|
|
static TargetTupleTypeFlags<int_type> fromIntValue(int_type Data) {
|
|
return TargetTupleTypeFlags(Data);
|
|
}
|
|
|
|
bool operator==(TargetTupleTypeFlags<int_type> other) const {
|
|
return Data == other.Data;
|
|
}
|
|
bool operator!=(TargetTupleTypeFlags<int_type> other) const {
|
|
return Data != other.Data;
|
|
}
|
|
};
|
|
using TupleTypeFlags = TargetTupleTypeFlags<size_t>;
|
|
|
|
/// Flags for exclusivity-checking operations.
|
|
enum class ExclusivityFlags : uintptr_t {
|
|
Read = 0x0,
|
|
Modify = 0x1,
|
|
// ActionMask can grow without breaking the ABI because the runtime controls
|
|
// how these flags are encoded in the "value buffer". However, any additional
|
|
// actions must be compatible with the original behavior for the old, smaller
|
|
// ActionMask (older runtimes will continue to treat them as either a simple
|
|
// Read or Modify).
|
|
ActionMask = 0x1,
|
|
|
|
// The runtime should track this access to check against subsequent accesses.
|
|
Tracking = 0x20
|
|
};
|
|
static inline ExclusivityFlags operator|(ExclusivityFlags lhs,
|
|
ExclusivityFlags rhs) {
|
|
return ExclusivityFlags(uintptr_t(lhs) | uintptr_t(rhs));
|
|
}
|
|
static inline ExclusivityFlags &operator|=(ExclusivityFlags &lhs,
|
|
ExclusivityFlags rhs) {
|
|
return (lhs = (lhs | rhs));
|
|
}
|
|
static inline ExclusivityFlags getAccessAction(ExclusivityFlags flags) {
|
|
return ExclusivityFlags(uintptr_t(flags)
|
|
& uintptr_t(ExclusivityFlags::ActionMask));
|
|
}
|
|
static inline bool isTracking(ExclusivityFlags flags) {
|
|
return uintptr_t(flags) & uintptr_t(ExclusivityFlags::Tracking);
|
|
}
|
|
|
|
/// Flags for struct layout.
|
|
enum class StructLayoutFlags : uintptr_t {
|
|
/// Reserve space for 256 layout algorithms.
|
|
AlgorithmMask = 0xff,
|
|
|
|
/// The ABI baseline algorithm, i.e. the algorithm implemented in Swift 5.
|
|
Swift5Algorithm = 0x00,
|
|
|
|
/// Is the value-witness table mutable in place, or does layout need to
|
|
/// clone it?
|
|
IsVWTMutable = 0x100,
|
|
};
|
|
static inline StructLayoutFlags operator|(StructLayoutFlags lhs,
|
|
StructLayoutFlags rhs) {
|
|
return StructLayoutFlags(uintptr_t(lhs) | uintptr_t(rhs));
|
|
}
|
|
static inline StructLayoutFlags &operator|=(StructLayoutFlags &lhs,
|
|
StructLayoutFlags rhs) {
|
|
return (lhs = (lhs | rhs));
|
|
}
|
|
static inline StructLayoutFlags getLayoutAlgorithm(StructLayoutFlags flags) {
|
|
return StructLayoutFlags(uintptr_t(flags)
|
|
& uintptr_t(StructLayoutFlags::AlgorithmMask));
|
|
}
|
|
static inline bool isValueWitnessTableMutable(StructLayoutFlags flags) {
|
|
return uintptr_t(flags) & uintptr_t(StructLayoutFlags::IsVWTMutable);
|
|
}
|
|
|
|
/// Flags for class layout.
|
|
enum class ClassLayoutFlags : uintptr_t {
|
|
/// Reserve space for 256 layout algorithms.
|
|
AlgorithmMask = 0xff,
|
|
|
|
/// The ABI baseline algorithm, i.e. the algorithm implemented in Swift 5.
|
|
Swift5Algorithm = 0x00,
|
|
|
|
/// If true, the vtable for this class and all of its superclasses was emitted
|
|
/// statically in the class metadata. If false, the superclass vtable is
|
|
/// copied from superclass metadata, and the immediate class vtable is
|
|
/// initialized from the type context descriptor.
|
|
HasStaticVTable = 0x100,
|
|
};
|
|
static inline ClassLayoutFlags operator|(ClassLayoutFlags lhs,
|
|
ClassLayoutFlags rhs) {
|
|
return ClassLayoutFlags(uintptr_t(lhs) | uintptr_t(rhs));
|
|
}
|
|
static inline ClassLayoutFlags &operator|=(ClassLayoutFlags &lhs,
|
|
ClassLayoutFlags rhs) {
|
|
return (lhs = (lhs | rhs));
|
|
}
|
|
static inline ClassLayoutFlags getLayoutAlgorithm(ClassLayoutFlags flags) {
|
|
return ClassLayoutFlags(uintptr_t(flags)
|
|
& uintptr_t(ClassLayoutFlags::AlgorithmMask));
|
|
}
|
|
static inline bool hasStaticVTable(ClassLayoutFlags flags) {
|
|
return uintptr_t(flags) & uintptr_t(ClassLayoutFlags::HasStaticVTable);
|
|
}
|
|
|
|
/// Flags for enum layout.
|
|
enum class EnumLayoutFlags : uintptr_t {
|
|
/// Reserve space for 256 layout algorithms.
|
|
AlgorithmMask = 0xff,
|
|
|
|
/// The ABI baseline algorithm, i.e. the algorithm implemented in Swift 5.
|
|
Swift5Algorithm = 0x00,
|
|
|
|
/// Is the value-witness table mutable in place, or does layout need to
|
|
/// clone it?
|
|
IsVWTMutable = 0x100,
|
|
};
|
|
static inline EnumLayoutFlags operator|(EnumLayoutFlags lhs,
|
|
EnumLayoutFlags rhs) {
|
|
return EnumLayoutFlags(uintptr_t(lhs) | uintptr_t(rhs));
|
|
}
|
|
static inline EnumLayoutFlags &operator|=(EnumLayoutFlags &lhs,
|
|
EnumLayoutFlags rhs) {
|
|
return (lhs = (lhs | rhs));
|
|
}
|
|
static inline EnumLayoutFlags getLayoutAlgorithm(EnumLayoutFlags flags) {
|
|
return EnumLayoutFlags(uintptr_t(flags)
|
|
& uintptr_t(EnumLayoutFlags::AlgorithmMask));
|
|
}
|
|
static inline bool isValueWitnessTableMutable(EnumLayoutFlags flags) {
|
|
return uintptr_t(flags) & uintptr_t(EnumLayoutFlags::IsVWTMutable);
|
|
}
|
|
|
|
/// Flags for raw layout.
|
|
enum class RawLayoutFlags : uintptr_t {
|
|
/// Whether or not we're initializing an array like raw layout type.
|
|
IsArray = 0x1,
|
|
|
|
/// Whether or not this raw layout type was declared 'movesAsLike'.
|
|
MovesAsLike = 0x2,
|
|
|
|
/// Whether this raw layout type is bitwise borrowable.
|
|
///
|
|
/// No raw layout types are yet, but should we change our mind about that in the future,
|
|
/// this flag is here.
|
|
BitwiseBorrowable = 0x4,
|
|
};
|
|
static inline RawLayoutFlags operator|(RawLayoutFlags lhs,
|
|
RawLayoutFlags rhs) {
|
|
return RawLayoutFlags(uintptr_t(lhs) | uintptr_t(rhs));
|
|
}
|
|
static inline RawLayoutFlags &operator|=(RawLayoutFlags &lhs,
|
|
RawLayoutFlags rhs) {
|
|
return (lhs = (lhs | rhs));
|
|
}
|
|
static inline bool isRawLayoutArray(RawLayoutFlags flags) {
|
|
return uintptr_t(flags) & uintptr_t(RawLayoutFlags::IsArray);
|
|
}
|
|
static inline bool shouldRawLayoutMoveAsLike(RawLayoutFlags flags) {
|
|
return uintptr_t(flags) & uintptr_t(RawLayoutFlags::MovesAsLike);
|
|
}
|
|
static inline bool isRawLayoutBitwiseBorrowable(RawLayoutFlags flags) {
|
|
return uintptr_t(flags) & uintptr_t(RawLayoutFlags::BitwiseBorrowable);
|
|
}
|
|
|
|
namespace SpecialPointerAuthDiscriminators {
|
|
// All of these values are the stable string hash of the corresponding
|
|
// variable name:
|
|
// (computeStableStringHash % 65535 + 1)
|
|
|
|
/// HeapMetadataHeader::destroy
|
|
const uint16_t HeapDestructor = 0xbbbf;
|
|
|
|
/// Type descriptor data pointers.
|
|
const uint16_t TypeDescriptor = 0xae86;
|
|
|
|
/// Runtime function variables exported by the runtime.
|
|
const uint16_t RuntimeFunctionEntry = 0x625b;
|
|
|
|
/// Protocol conformance descriptors.
|
|
const uint16_t ProtocolConformanceDescriptor = 0xc6eb;
|
|
|
|
const uint16_t ProtocolDescriptor = 0xe909; // = 59657
|
|
|
|
// Type descriptors as arguments.
|
|
const uint16_t OpaqueTypeDescriptor = 0xbdd1; // = 48593
|
|
const uint16_t ContextDescriptor = 0xb5e3; // = 46563
|
|
|
|
/// Pointer to value witness table stored in type metadata.
|
|
///
|
|
/// Computed with ptrauth_string_discriminator("value_witness_table_t").
|
|
const uint16_t ValueWitnessTable = 0x2e3f;
|
|
|
|
/// Extended existential type shapes.
|
|
const uint16_t ExtendedExistentialTypeShape = 0x5a3d; // = 23101
|
|
const uint16_t NonUniqueExtendedExistentialTypeShape = 0xe798; // = 59288
|
|
|
|
/// Value witness functions.
|
|
const uint16_t InitializeBufferWithCopyOfBuffer = 0xda4a;
|
|
const uint16_t Destroy = 0x04f8;
|
|
const uint16_t InitializeWithCopy = 0xe3ba;
|
|
const uint16_t AssignWithCopy = 0x8751;
|
|
const uint16_t InitializeWithTake = 0x48d8;
|
|
const uint16_t AssignWithTake = 0xefda;
|
|
const uint16_t DestroyArray = 0x2398;
|
|
const uint16_t InitializeArrayWithCopy = 0xa05c;
|
|
const uint16_t InitializeArrayWithTakeFrontToBack = 0x1c3e;
|
|
const uint16_t InitializeArrayWithTakeBackToFront = 0x8dd3;
|
|
const uint16_t StoreExtraInhabitant = 0x79c5;
|
|
const uint16_t GetExtraInhabitantIndex = 0x2ca8;
|
|
const uint16_t GetEnumTag = 0xa3b5;
|
|
const uint16_t DestructiveProjectEnumData = 0x041d;
|
|
const uint16_t DestructiveInjectEnumTag = 0xb2e4;
|
|
const uint16_t GetEnumTagSinglePayload = 0x60f0;
|
|
const uint16_t StoreEnumTagSinglePayload = 0xa0d1;
|
|
|
|
/// KeyPath metadata functions.
|
|
const uint16_t KeyPathDestroy = _SwiftKeyPath_ptrauth_ArgumentDestroy;
|
|
const uint16_t KeyPathCopy = _SwiftKeyPath_ptrauth_ArgumentCopy;
|
|
const uint16_t KeyPathEquals = _SwiftKeyPath_ptrauth_ArgumentEquals;
|
|
const uint16_t KeyPathHash = _SwiftKeyPath_ptrauth_ArgumentHash;
|
|
const uint16_t KeyPathGetter = _SwiftKeyPath_ptrauth_Getter;
|
|
const uint16_t KeyPathNonmutatingSetter = _SwiftKeyPath_ptrauth_NonmutatingSetter;
|
|
const uint16_t KeyPathMutatingSetter = _SwiftKeyPath_ptrauth_MutatingSetter;
|
|
const uint16_t KeyPathGetLayout = _SwiftKeyPath_ptrauth_ArgumentLayout;
|
|
const uint16_t KeyPathInitializer = _SwiftKeyPath_ptrauth_ArgumentInit;
|
|
const uint16_t KeyPathMetadataAccessor = _SwiftKeyPath_ptrauth_MetadataAccessor;
|
|
|
|
/// ObjC bridging entry points.
|
|
const uint16_t ObjectiveCTypeDiscriminator = 0x31c3; // = 12739
|
|
const uint16_t bridgeToObjectiveCDiscriminator = 0xbca0; // = 48288
|
|
const uint16_t forceBridgeFromObjectiveCDiscriminator = 0x22fb; // = 8955
|
|
const uint16_t conditionallyBridgeFromObjectiveCDiscriminator = 0x9a9b; // = 39579
|
|
|
|
/// Dynamic replacement pointers.
|
|
const uint16_t DynamicReplacementScope = 0x48F0; // = 18672
|
|
const uint16_t DynamicReplacementKey = 0x2C7D; // = 11389
|
|
|
|
/// Resume functions for yield-once coroutines that yield a single
|
|
/// opaque borrowed/inout value. These aren't actually hard-coded, but
|
|
/// they're important enough to be worth writing in one place.
|
|
const uint16_t OpaqueReadResumeFunction = 56769;
|
|
const uint16_t OpaqueModifyResumeFunction = 3909;
|
|
|
|
/// ObjC class pointers.
|
|
const uint16_t ObjCISA = 0x6AE1;
|
|
const uint16_t ObjCSuperclass = 0xB5AB;
|
|
|
|
/// Resilient class stub initializer callback
|
|
const uint16_t ResilientClassStubInitCallback = 0xC671;
|
|
|
|
/// Jobs, tasks, and continuations.
|
|
const uint16_t JobInvokeFunction = 0xcc64; // = 52324
|
|
const uint16_t TaskResumeFunction = 0x2c42; // = 11330
|
|
const uint16_t TaskResumeContext = 0x753a; // = 30010
|
|
const uint16_t AsyncRunAndBlockFunction = 0x0f08; // 3848
|
|
const uint16_t AsyncContextParent = 0xbda2; // = 48546
|
|
const uint16_t AsyncContextResume = 0xd707; // = 55047
|
|
const uint16_t AsyncContextYield = 0xe207; // = 57863
|
|
const uint16_t CancellationNotificationFunction = 0x0f08; // = 3848
|
|
const uint16_t EscalationNotificationFunction = 0x7861; // = 30817
|
|
const uint16_t AsyncThinNullaryFunction = 0x0f08; // = 3848
|
|
const uint16_t AsyncFutureFunction = 0x720f; // = 29199
|
|
|
|
/// Swift async context parameter stored in the extended frame info.
|
|
const uint16_t SwiftAsyncContextExtendedFrameEntry = 0xc31a; // = 49946
|
|
|
|
// C type TaskContinuationFunction* descriminator.
|
|
const uint16_t ClangTypeTaskContinuationFunction = 0x2abe; // = 10942
|
|
|
|
/// Dispatch integration.
|
|
const uint16_t DispatchInvokeFunction = 0xf493; // = 62611
|
|
|
|
/// Functions accessible at runtime (i.e. distributed method accessors).
|
|
const uint16_t AccessibleFunctionRecord = 0x438c; // = 17292
|
|
|
|
/// C type GetExtraInhabitantTag function descriminator
|
|
const uint16_t GetExtraInhabitantTagFunction = 0x392e; // = 14638
|
|
|
|
/// C type StoreExtraInhabitantTag function descriminator
|
|
const uint16_t StoreExtraInhabitantTagFunction = 0x9bf6; // = 39926
|
|
|
|
// Relative protocol witness table descriminator
|
|
const uint16_t RelativeProtocolWitnessTable = 0xb830; // = 47152
|
|
|
|
const uint16_t TypeLayoutString = 0x8b65; // = 35685
|
|
|
|
/// Isolated deinit body function pointer
|
|
const uint16_t DeinitWorkFunction = 0x8438; // = 33848
|
|
|
|
/// IsCurrentGlobalActor function used between the Swift runtime and
|
|
/// concurrency runtime.
|
|
const uint16_t IsCurrentGlobalActorFunction = 0xd1b8; // = 53688
|
|
|
|
/// Function pointers stored in the coro allocator struct.
|
|
const uint16_t CoroAllocationFunction = 0x5f95; // = 24469
|
|
const uint16_t CoroDeallocationFunction = 0x9faf; // = 40879
|
|
const uint16_t CoroFrameAllocationFunction = 0xd251; // = 53841
|
|
const uint16_t CoroFrameDeallocationFunction = 0x5ba8; // = 23464
|
|
}
|
|
|
|
/// The number of arguments that will be passed directly to a generic
|
|
/// nominal type access function. The remaining arguments (if any) will be
|
|
/// passed as an array. That array has enough storage for all of the arguments,
|
|
/// but only fills in the elements not passed directly. The callee may
|
|
/// mutate the array to fill in the direct arguments.
|
|
constexpr unsigned NumDirectGenericTypeMetadataAccessFunctionArgs = 3;
|
|
|
|
/// The offset (in pointers) to the first requirement in a witness table.
|
|
constexpr unsigned WitnessTableFirstRequirementOffset = 1;
|
|
|
|
/// Kinds of context descriptor.
|
|
enum class ContextDescriptorKind : uint8_t {
|
|
/// This context descriptor represents a module.
|
|
Module = 0,
|
|
|
|
/// This context descriptor represents an extension.
|
|
Extension = 1,
|
|
|
|
/// This context descriptor represents an anonymous possibly-generic context
|
|
/// such as a function body.
|
|
Anonymous = 2,
|
|
|
|
/// This context descriptor represents a protocol context.
|
|
Protocol = 3,
|
|
|
|
/// This context descriptor represents an opaque type alias.
|
|
OpaqueType = 4,
|
|
|
|
/// First kind that represents a type of any sort.
|
|
Type_First = 16,
|
|
|
|
/// This context descriptor represents a class.
|
|
Class = Type_First,
|
|
|
|
/// This context descriptor represents a struct.
|
|
Struct = Type_First + 1,
|
|
|
|
/// This context descriptor represents an enum.
|
|
Enum = Type_First + 2,
|
|
|
|
/// Last kind that represents a type of any sort.
|
|
Type_Last = 31,
|
|
};
|
|
|
|
/// Common flags stored in the first 32-bit word of any context descriptor.
|
|
struct ContextDescriptorFlags {
|
|
private:
|
|
uint32_t Value;
|
|
|
|
explicit constexpr ContextDescriptorFlags(uint32_t Value)
|
|
: Value(Value) {}
|
|
public:
|
|
constexpr ContextDescriptorFlags() : Value(0) {}
|
|
constexpr ContextDescriptorFlags(ContextDescriptorKind kind,
|
|
bool isGeneric,
|
|
bool isUnique,
|
|
bool hasInvertibleProtocols,
|
|
uint16_t kindSpecificFlags)
|
|
: ContextDescriptorFlags(ContextDescriptorFlags()
|
|
.withKind(kind)
|
|
.withGeneric(isGeneric)
|
|
.withUnique(isUnique)
|
|
.withInvertibleProtocols(
|
|
hasInvertibleProtocols
|
|
)
|
|
.withKindSpecificFlags(kindSpecificFlags))
|
|
{}
|
|
|
|
/// The kind of context this descriptor describes.
|
|
constexpr ContextDescriptorKind getKind() const {
|
|
return ContextDescriptorKind(Value & 0x1Fu);
|
|
}
|
|
|
|
/// Whether the context being described is generic.
|
|
constexpr bool isGeneric() const {
|
|
return (Value & 0x80u) != 0;
|
|
}
|
|
|
|
/// Whether this is a unique record describing the referenced context.
|
|
constexpr bool isUnique() const {
|
|
return (Value & 0x40u) != 0;
|
|
}
|
|
|
|
/// Whether the context has information about invertible protocols, which
|
|
/// will show up as a trailing field in the context descriptor.
|
|
constexpr bool hasInvertibleProtocols() const {
|
|
return (Value & 0x20u) != 0;
|
|
}
|
|
|
|
/// The most significant two bytes of the flags word, which can have
|
|
/// kind-specific meaning.
|
|
constexpr uint16_t getKindSpecificFlags() const {
|
|
return (Value >> 16u) & 0xFFFFu;
|
|
}
|
|
|
|
constexpr ContextDescriptorFlags withKind(ContextDescriptorKind kind) const {
|
|
return assert((uint8_t(kind) & 0x1F) == uint8_t(kind)),
|
|
ContextDescriptorFlags((Value & 0xFFFFFFE0u) | uint8_t(kind));
|
|
}
|
|
|
|
constexpr ContextDescriptorFlags withGeneric(bool isGeneric) const {
|
|
return ContextDescriptorFlags((Value & 0xFFFFFF7Fu)
|
|
| (isGeneric ? 0x80u : 0));
|
|
}
|
|
|
|
constexpr ContextDescriptorFlags withUnique(bool isUnique) const {
|
|
return ContextDescriptorFlags((Value & 0xFFFFFFBFu)
|
|
| (isUnique ? 0x40u : 0));
|
|
}
|
|
|
|
constexpr ContextDescriptorFlags withInvertibleProtocols(
|
|
bool hasInvertibleProtocols
|
|
) const {
|
|
return ContextDescriptorFlags((Value & ~0x20u)
|
|
| (hasInvertibleProtocols ? 0x20u : 0));
|
|
}
|
|
|
|
constexpr ContextDescriptorFlags
|
|
withKindSpecificFlags(uint16_t flags) const {
|
|
return ContextDescriptorFlags((Value & 0xFFFFu) | (flags << 16u));
|
|
}
|
|
|
|
constexpr uint32_t getIntValue() const {
|
|
return Value;
|
|
}
|
|
};
|
|
|
|
/// Flags for nominal type context descriptors. These values are used as the
|
|
/// kindSpecificFlags of the ContextDescriptorFlags for the type.
|
|
class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
|
|
enum {
|
|
// All of these values are bit offsets or widths.
|
|
// Generic flags build upwards from 0.
|
|
// Type-specific flags build downwards from 15.
|
|
|
|
/// Whether there's something unusual about how the metadata is
|
|
/// initialized.
|
|
///
|
|
/// Meaningful for all type-descriptor kinds.
|
|
MetadataInitialization = 0,
|
|
MetadataInitialization_width = 2,
|
|
|
|
/// Set if the type has extended import information.
|
|
///
|
|
/// If true, a sequence of strings follow the null terminator in the
|
|
/// descriptor, terminated by an empty string (i.e. by two null
|
|
/// terminators in a row). See TypeImportInfo for the details of
|
|
/// these strings and the order in which they appear.
|
|
///
|
|
/// Meaningful for all type-descriptor kinds.
|
|
HasImportInfo = 2,
|
|
|
|
/// Set if the generic type descriptor has a pointer to a list of canonical
|
|
/// prespecializations, or the non-generic type descriptor has a pointer to
|
|
/// its singleton metadata.
|
|
HasCanonicalMetadataPrespecializationsOrSingletonMetadataPointer = 3,
|
|
|
|
/// Set if the metadata contains a pointer to a layout string
|
|
HasLayoutString = 4,
|
|
|
|
/// WARNING: 5 is the last bit!
|
|
|
|
// Type-specific flags:
|
|
|
|
Class_HasDefaultOverrideTable = 6,
|
|
|
|
/// Set if the class is an actor.
|
|
///
|
|
/// Only meaningful for class descriptors.
|
|
Class_IsActor = 7,
|
|
|
|
/// Set if the class is a default actor class. Note that this is
|
|
/// based on the best knowledge available to the class; actor
|
|
/// classes with resilient superclassess might be default actors
|
|
/// without knowing it.
|
|
///
|
|
/// Only meaningful for class descriptors.
|
|
Class_IsDefaultActor = 8,
|
|
|
|
/// The kind of reference that this class makes to its resilient superclass
|
|
/// descriptor. A TypeReferenceKind.
|
|
///
|
|
/// Only meaningful for class descriptors.
|
|
Class_ResilientSuperclassReferenceKind = 9,
|
|
Class_ResilientSuperclassReferenceKind_width = 3,
|
|
|
|
/// Whether the immediate class members in this metadata are allocated
|
|
/// at negative offsets. For now, we don't use this.
|
|
Class_AreImmediateMembersNegative = 12,
|
|
|
|
/// Set if the context descriptor is for a class with resilient ancestry.
|
|
///
|
|
/// Only meaningful for class descriptors.
|
|
Class_HasResilientSuperclass = 13,
|
|
|
|
/// Set if the context descriptor includes metadata for dynamically
|
|
/// installing method overrides at metadata instantiation time.
|
|
Class_HasOverrideTable = 14,
|
|
|
|
/// Set if the context descriptor includes metadata for dynamically
|
|
/// constructing a class's vtables at metadata instantiation time.
|
|
///
|
|
/// Only meaningful for class descriptors.
|
|
Class_HasVTable = 15,
|
|
};
|
|
|
|
public:
|
|
explicit TypeContextDescriptorFlags(uint16_t bits) : FlagSet(bits) {}
|
|
constexpr TypeContextDescriptorFlags() {}
|
|
|
|
enum MetadataInitializationKind {
|
|
/// There are either no special rules for initializing the metadata
|
|
/// or the metadata is generic. (Genericity is set in the
|
|
/// non-kind-specific descriptor flags.)
|
|
NoMetadataInitialization = 0,
|
|
|
|
/// The type requires non-trivial singleton initialization using the
|
|
/// "in-place" code pattern.
|
|
SingletonMetadataInitialization = 1,
|
|
|
|
/// The type requires non-trivial singleton initialization using the
|
|
/// "foreign" code pattern.
|
|
ForeignMetadataInitialization = 2,
|
|
|
|
// We only have two bits here, so if you add a third special kind,
|
|
// include more flag bits in its out-of-line storage.
|
|
};
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(MetadataInitialization,
|
|
MetadataInitialization_width,
|
|
MetadataInitializationKind,
|
|
getMetadataInitialization,
|
|
setMetadataInitialization)
|
|
|
|
bool hasSingletonMetadataInitialization() const {
|
|
return getMetadataInitialization() == SingletonMetadataInitialization;
|
|
}
|
|
|
|
bool hasForeignMetadataInitialization() const {
|
|
return getMetadataInitialization() == ForeignMetadataInitialization;
|
|
}
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(HasImportInfo, hasImportInfo, setHasImportInfo)
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(
|
|
HasCanonicalMetadataPrespecializationsOrSingletonMetadataPointer,
|
|
hasCanonicalMetadataPrespecializationsOrSingletonMetadataPointer,
|
|
setHasCanonicalMetadataPrespecializationsOrSingletonMetadataPointer)
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(HasLayoutString,
|
|
hasLayoutString,
|
|
setHasLayoutString)
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Class_HasVTable,
|
|
class_hasVTable,
|
|
class_setHasVTable)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Class_HasOverrideTable,
|
|
class_hasOverrideTable,
|
|
class_setHasOverrideTable)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Class_HasResilientSuperclass,
|
|
class_hasResilientSuperclass,
|
|
class_setHasResilientSuperclass)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Class_AreImmediateMembersNegative,
|
|
class_areImmediateMembersNegative,
|
|
class_setAreImmediateMembersNegative)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Class_IsDefaultActor,
|
|
class_isDefaultActor,
|
|
class_setIsDefaultActor)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Class_IsActor,
|
|
class_isActor,
|
|
class_setIsActor)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Class_HasDefaultOverrideTable,
|
|
class_hasDefaultOverrideTable,
|
|
class_setHasDefaultOverrideTable)
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(Class_ResilientSuperclassReferenceKind,
|
|
Class_ResilientSuperclassReferenceKind_width,
|
|
TypeReferenceKind,
|
|
class_getResilientSuperclassReferenceKind,
|
|
class_setResilientSuperclassReferenceKind)
|
|
};
|
|
|
|
/// Extra flags for resilient classes, since we need more than 16 bits of
|
|
/// flags there.
|
|
class ExtraClassDescriptorFlags : public FlagSet<uint32_t> {
|
|
enum {
|
|
/// Set if the context descriptor includes a pointer to an Objective-C
|
|
/// resilient class stub structure. See the description of
|
|
/// TargetObjCResilientClassStubInfo in Metadata.h for details.
|
|
///
|
|
/// Only meaningful for class descriptors when Objective-C interop is
|
|
/// enabled.
|
|
HasObjCResilientClassStub = 0,
|
|
};
|
|
|
|
public:
|
|
explicit ExtraClassDescriptorFlags(uint32_t bits) : FlagSet(bits) {}
|
|
constexpr ExtraClassDescriptorFlags() {}
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(HasObjCResilientClassStub,
|
|
hasObjCResilientClassStub,
|
|
setObjCResilientClassStub)
|
|
};
|
|
|
|
/// Flags for protocol context descriptors. These values are used as the
|
|
/// kindSpecificFlags of the ContextDescriptorFlags for the protocol.
|
|
class ProtocolContextDescriptorFlags : public FlagSet<uint16_t> {
|
|
enum {
|
|
/// Whether this protocol is class-constrained.
|
|
HasClassConstraint = 0,
|
|
HasClassConstraint_width = 1,
|
|
|
|
/// Whether this protocol is resilient.
|
|
IsResilient = 1,
|
|
|
|
/// Special protocol value.
|
|
SpecialProtocolKind = 2,
|
|
SpecialProtocolKind_width = 6,
|
|
};
|
|
|
|
public:
|
|
explicit ProtocolContextDescriptorFlags(uint16_t bits) : FlagSet(bits) {}
|
|
constexpr ProtocolContextDescriptorFlags() {}
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(IsResilient, isResilient, setIsResilient)
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(HasClassConstraint,
|
|
HasClassConstraint_width,
|
|
ProtocolClassConstraint,
|
|
getClassConstraint,
|
|
setClassConstraint)
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(SpecialProtocolKind,
|
|
SpecialProtocolKind_width,
|
|
SpecialProtocol,
|
|
getSpecialProtocol,
|
|
setSpecialProtocol)
|
|
};
|
|
|
|
/// Flags for anonymous type context descriptors. These values are used as the
|
|
/// kindSpecificFlags of the ContextDescriptorFlags for the anonymous context.
|
|
class AnonymousContextDescriptorFlags : public FlagSet<uint16_t> {
|
|
enum {
|
|
/// Whether this anonymous context descriptor is followed by its
|
|
/// mangled name, which can be used to match the descriptor at runtime.
|
|
HasMangledName = 0,
|
|
};
|
|
|
|
public:
|
|
explicit AnonymousContextDescriptorFlags(uint16_t bits) : FlagSet(bits) {}
|
|
constexpr AnonymousContextDescriptorFlags() {}
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(HasMangledName, hasMangledName,
|
|
setHasMangledName)
|
|
};
|
|
|
|
class GenericContextDescriptorFlags {
|
|
uint16_t Value;
|
|
|
|
public:
|
|
constexpr GenericContextDescriptorFlags() : Value(0) {}
|
|
|
|
explicit constexpr GenericContextDescriptorFlags(uint16_t value)
|
|
: Value(value) {}
|
|
|
|
constexpr GenericContextDescriptorFlags(
|
|
bool hasTypePacks, bool hasConditionalInvertedProtocols, bool hasValues
|
|
) : GenericContextDescriptorFlags(
|
|
GenericContextDescriptorFlags((uint16_t)0)
|
|
.withHasTypePacks(hasTypePacks)
|
|
.withConditionalInvertedProtocols(hasConditionalInvertedProtocols)
|
|
.withHasValues(hasValues)) {}
|
|
|
|
/// Whether this generic context has at least one type parameter
|
|
/// pack, in which case the generic context will have a trailing
|
|
/// GenericPackShapeHeader.
|
|
constexpr bool hasTypePacks() const {
|
|
return (Value & 0x1) != 0;
|
|
}
|
|
|
|
/// Whether this generic context has any conditional conformances to
|
|
/// inverted protocols, in which case the generic context will have a
|
|
/// trailing InvertibleProtocolSet and conditional requirements.
|
|
constexpr bool hasConditionalInvertedProtocols() const {
|
|
return (Value & 0x2) != 0;
|
|
}
|
|
|
|
/// Whether this generic context has at least one value parameter, in which
|
|
/// case the generic context will have a trailing GenericValueHeader.
|
|
constexpr bool hasValues() const {
|
|
return (Value & 0x4) != 0;
|
|
}
|
|
|
|
constexpr GenericContextDescriptorFlags
|
|
withHasTypePacks(bool hasTypePacks) const {
|
|
return GenericContextDescriptorFlags((uint16_t)(
|
|
(Value & ~0x1) | (hasTypePacks ? 0x1 : 0)));
|
|
}
|
|
|
|
constexpr GenericContextDescriptorFlags
|
|
withConditionalInvertedProtocols(bool value) const {
|
|
return GenericContextDescriptorFlags((uint16_t)(
|
|
(Value & ~0x2) | (value ? 0x2 : 0)));
|
|
}
|
|
|
|
constexpr GenericContextDescriptorFlags
|
|
withHasValues(bool hasValues) const {
|
|
return GenericContextDescriptorFlags((uint16_t)(
|
|
(Value & ~0x4) | (hasValues ? 0x4 : 0)));
|
|
}
|
|
|
|
constexpr uint16_t getIntValue() const {
|
|
return Value;
|
|
}
|
|
};
|
|
|
|
enum class GenericParamKind : uint8_t {
|
|
/// A type parameter.
|
|
Type = 0,
|
|
|
|
/// A type parameter pack.
|
|
TypePack = 1,
|
|
|
|
/// A value type parameter.
|
|
Value = 2,
|
|
|
|
Max = 0x3F,
|
|
};
|
|
|
|
class GenericParamDescriptor {
|
|
/// Don't set 0x40 for compatibility with pre-Swift 5.8 runtimes
|
|
uint8_t Value;
|
|
|
|
explicit constexpr GenericParamDescriptor(uint8_t Value)
|
|
: Value(Value) {}
|
|
public:
|
|
constexpr GenericParamDescriptor(GenericParamKind kind,
|
|
bool hasKeyArgument)
|
|
: GenericParamDescriptor(GenericParamDescriptor(0)
|
|
.withKind(kind)
|
|
.withKeyArgument(hasKeyArgument))
|
|
{}
|
|
|
|
constexpr bool hasKeyArgument() const {
|
|
return (Value & 0x80u) != 0;
|
|
}
|
|
|
|
constexpr GenericParamKind getKind() const {
|
|
return GenericParamKind(Value & 0x3Fu);
|
|
}
|
|
|
|
constexpr GenericParamDescriptor
|
|
withKeyArgument(bool hasKeyArgument) const {
|
|
return GenericParamDescriptor((Value & 0x7Fu)
|
|
| (hasKeyArgument ? 0x80u : 0));
|
|
}
|
|
|
|
constexpr GenericParamDescriptor withKind(GenericParamKind kind) const {
|
|
return assert((uint8_t(kind) & 0x3Fu) == uint8_t(kind)),
|
|
GenericParamDescriptor((Value & 0xC0u) | uint8_t(kind));
|
|
}
|
|
|
|
constexpr uint8_t getIntValue() const {
|
|
return Value;
|
|
}
|
|
|
|
friend bool operator==(GenericParamDescriptor lhs,
|
|
GenericParamDescriptor rhs) {
|
|
return lhs.getIntValue() == rhs.getIntValue();
|
|
}
|
|
friend bool operator!=(GenericParamDescriptor lhs,
|
|
GenericParamDescriptor rhs) {
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
/// The default parameter descriptor for an implicit parameter.
|
|
static constexpr GenericParamDescriptor implicit() {
|
|
return GenericParamDescriptor(GenericParamKind::Type,
|
|
/*key argument*/ true);
|
|
}
|
|
};
|
|
|
|
/// Can the given generic parameter array be implicit, for places in
|
|
/// the ABI which support that?
|
|
inline bool canGenericParamsBeImplicit(
|
|
llvm::ArrayRef<GenericParamDescriptor> params) {
|
|
// If there are more parameters than the maximum, they cannot be implicit.
|
|
if (params.size() > MaxNumImplicitGenericParamDescriptors)
|
|
return false;
|
|
|
|
// If any parameter is not the implicit pattern, they cannot be implicit.
|
|
for (auto param : params)
|
|
if (param != GenericParamDescriptor::implicit())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
enum class GenericRequirementKind : uint8_t {
|
|
/// A protocol requirement.
|
|
Protocol = 0,
|
|
/// A same-type requirement.
|
|
SameType = 1,
|
|
/// A base class requirement.
|
|
BaseClass = 2,
|
|
/// A "same-conformance" requirement, implied by a same-type or base-class
|
|
/// constraint that binds a parameter with protocol requirements.
|
|
SameConformance = 3,
|
|
/// A same-shape requirement between generic parameter packs.
|
|
SameShape = 4,
|
|
/// A requirement stating which invertible protocol checks are
|
|
/// inverted.
|
|
///
|
|
/// This is more of an "anti-requirement", specifing which checks don't need
|
|
/// to happen for a given type.
|
|
InvertedProtocols = 5,
|
|
/// A layout requirement.
|
|
Layout = 0x1F,
|
|
};
|
|
|
|
class GenericRequirementFlags {
|
|
/// Don't set 0x40 for compatibility with pre-Swift 5.8 runtimes
|
|
uint32_t Value;
|
|
|
|
explicit constexpr GenericRequirementFlags(uint32_t Value)
|
|
: Value(Value) {}
|
|
public:
|
|
constexpr GenericRequirementFlags(GenericRequirementKind kind,
|
|
bool hasKeyArgument,
|
|
bool isPackRequirement,
|
|
bool isValueRequirement)
|
|
: GenericRequirementFlags(GenericRequirementFlags(0)
|
|
.withKind(kind)
|
|
.withKeyArgument(hasKeyArgument)
|
|
.withPackRequirement(isPackRequirement)
|
|
.withValueRequirement(isValueRequirement))
|
|
{}
|
|
|
|
/// If this is true, the subject type of the requirement is a pack.
|
|
/// When the requirement is a conformance requirement, the corresponding
|
|
/// entry in the generic arguments array becomes a TargetWitnessTablePack.
|
|
constexpr bool isPackRequirement() const {
|
|
return (Value & 0x20u) != 0;
|
|
}
|
|
|
|
constexpr bool hasKeyArgument() const {
|
|
return (Value & 0x80u) != 0;
|
|
}
|
|
|
|
/// If this is true, the subject type of the requirement is a value.
|
|
///
|
|
/// Note: We could introduce a new SameValue requirement instead of burning a
|
|
/// a bit for value requirements, but if somehow an existing requirement makes
|
|
/// sense for values besides "SameType" then this would've been better.
|
|
constexpr bool isValueRequirement() const {
|
|
return (Value & 0x100u) != 0;
|
|
}
|
|
|
|
constexpr GenericRequirementKind getKind() const {
|
|
return GenericRequirementKind(Value & 0x1Fu);
|
|
}
|
|
|
|
constexpr GenericRequirementFlags
|
|
withKind(GenericRequirementKind kind) const {
|
|
return assert((uint8_t(kind) & 0x1Fu) == uint8_t(kind)),
|
|
GenericRequirementFlags((Value & 0xE0u) | uint8_t(kind));
|
|
}
|
|
|
|
constexpr GenericRequirementFlags
|
|
withPackRequirement(bool isPackRequirement) const {
|
|
return GenericRequirementFlags((Value & 0xBFu)
|
|
| (isPackRequirement ? 0x20u : 0));
|
|
}
|
|
|
|
constexpr GenericRequirementFlags
|
|
withKeyArgument(bool hasKeyArgument) const {
|
|
return GenericRequirementFlags((Value & 0x7Fu)
|
|
| (hasKeyArgument ? 0x80u : 0));
|
|
}
|
|
|
|
constexpr GenericRequirementFlags
|
|
withValueRequirement(bool isValueRequirement) const {
|
|
return GenericRequirementFlags((Value & 0xFFu)
|
|
| (isValueRequirement ? 0x100u : 0));
|
|
}
|
|
|
|
constexpr uint32_t getIntValue() const {
|
|
return Value;
|
|
}
|
|
};
|
|
|
|
enum class GenericRequirementLayoutKind : uint32_t {
|
|
// A class constraint.
|
|
Class = 0,
|
|
};
|
|
|
|
enum class GenericPackKind : uint16_t {
|
|
Metadata = 0,
|
|
WitnessTable = 1
|
|
};
|
|
|
|
enum class GenericValueType : uint32_t {
|
|
Int = 0,
|
|
};
|
|
|
|
class GenericEnvironmentFlags {
|
|
uint32_t Value;
|
|
|
|
enum : uint32_t {
|
|
NumGenericParameterLevelsMask = 0xFFF,
|
|
NumGenericRequirementsShift = 12,
|
|
NumGenericRequirementsMask = 0xFFFF << NumGenericRequirementsShift,
|
|
};
|
|
|
|
constexpr explicit GenericEnvironmentFlags(uint32_t value) : Value(value) { }
|
|
|
|
public:
|
|
constexpr GenericEnvironmentFlags() : Value(0) { }
|
|
|
|
constexpr GenericEnvironmentFlags
|
|
withNumGenericParameterLevels(uint16_t numGenericParameterLevels) const {
|
|
return GenericEnvironmentFlags((Value &~ NumGenericParameterLevelsMask)
|
|
| numGenericParameterLevels);
|
|
}
|
|
|
|
constexpr GenericEnvironmentFlags
|
|
withNumGenericRequirements(uint16_t numGenericRequirements) const {
|
|
return GenericEnvironmentFlags((Value &~ NumGenericRequirementsMask)
|
|
| (numGenericRequirements << NumGenericRequirementsShift));
|
|
}
|
|
|
|
constexpr unsigned getNumGenericParameterLevels() const {
|
|
return Value & NumGenericParameterLevelsMask;
|
|
}
|
|
|
|
constexpr unsigned getNumGenericRequirements() const {
|
|
return (Value & NumGenericRequirementsMask) >> NumGenericRequirementsShift;
|
|
}
|
|
|
|
constexpr uint32_t getIntValue() const {
|
|
return Value;
|
|
}
|
|
};
|
|
|
|
/// Flags used by generic metadata patterns.
|
|
class GenericMetadataPatternFlags : public FlagSet<uint32_t> {
|
|
enum {
|
|
// All of these values are bit offsets or widths.
|
|
// General flags build up from 0.
|
|
// Kind-specific flags build down from 31.
|
|
|
|
/// Does this pattern have an extra-data pattern?
|
|
HasExtraDataPattern = 0,
|
|
|
|
/// Do instances of this pattern have a bitset of flags that occur at the
|
|
/// end of the metadata, after the extra data if there is any?
|
|
HasTrailingFlags = 1,
|
|
|
|
// Class-specific flags.
|
|
|
|
/// Does this pattern have an immediate-members pattern?
|
|
Class_HasImmediateMembersPattern = 31,
|
|
|
|
// Value-specific flags.
|
|
|
|
/// For value metadata: the metadata kind of the type.
|
|
Value_MetadataKind = 21,
|
|
Value_MetadataKind_width = 11,
|
|
};
|
|
|
|
public:
|
|
explicit GenericMetadataPatternFlags(uint32_t bits) : FlagSet(bits) {}
|
|
constexpr GenericMetadataPatternFlags() {}
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Class_HasImmediateMembersPattern,
|
|
class_hasImmediateMembersPattern,
|
|
class_setHasImmediateMembersPattern)
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(HasExtraDataPattern,
|
|
hasExtraDataPattern,
|
|
setHasExtraDataPattern)
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(HasTrailingFlags,
|
|
hasTrailingFlags,
|
|
setHasTrailingFlags)
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(Value_MetadataKind,
|
|
Value_MetadataKind_width,
|
|
MetadataKind,
|
|
value_getMetadataKind,
|
|
value_setMetadataKind)
|
|
};
|
|
|
|
/// The public state of a metadata.
|
|
enum class MetadataState : size_t {
|
|
// The values of this enum are set up to give us some future flexibility
|
|
// in adding states. The compiler emits unsigned comparisons against
|
|
// these values, so adding states that aren't totally ordered with at
|
|
// least the existing values will pose a problem; but we also use a
|
|
// gradually-shrinking bitset in case it's useful to track states as
|
|
// separate capabilities. Specific values have been chosen so that a
|
|
// MetadataRequest of 0 represents a blocking complete request, which
|
|
// is the most likely request from ordinary code. The total size of a
|
|
// state is kept to 8 bits so that a full request, even with additional
|
|
// flags, can be materialized as a single immediate on common ISAs, and
|
|
// so that the state can be extracted with a byte truncation.
|
|
// The spacing between states reflects guesswork about where new
|
|
// states/capabilities are most likely to be added.
|
|
|
|
/// The metadata is fully complete. By definition, this is the
|
|
/// end-state of all metadata. Generally, metadata is expected to be
|
|
/// complete before it can be passed to arbitrary code, e.g. as
|
|
/// a generic argument to a function or as a metatype value.
|
|
///
|
|
/// In addition to the requirements of NonTransitiveComplete, certain
|
|
/// transitive completeness guarantees must hold. Most importantly,
|
|
/// complete nominal type metadata transitively guarantee the completion
|
|
/// of their stored generic type arguments and superclass metadata.
|
|
Complete = 0x00,
|
|
|
|
/// The metadata is fully complete except for any transitive completeness
|
|
/// guarantees.
|
|
///
|
|
/// In addition to the requirements of LayoutComplete, metadata in this
|
|
/// state must be prepared for all basic type operations. This includes:
|
|
///
|
|
/// - any sort of internal layout necessary to allocate and work
|
|
/// with concrete values of the type, such as the instance layout
|
|
/// of a class;
|
|
///
|
|
/// - any sort of external dynamic registration that might be required
|
|
/// for the type, such as the realization of a class by the Objective-C
|
|
/// runtime; and
|
|
///
|
|
/// - the initialization of any other information kept in the metadata
|
|
/// object, such as a class's v-table.
|
|
NonTransitiveComplete = 0x01,
|
|
|
|
/// The metadata is ready for the layout of other types that store values
|
|
/// of this type.
|
|
///
|
|
/// In addition to the requirements of Abstract, metadata in this state
|
|
/// must have a valid value witness table, meaning that its size,
|
|
/// alignment, and basic type properties (such as POD-ness) have been
|
|
/// computed.
|
|
LayoutComplete = 0x3F,
|
|
|
|
/// The metadata has its basic identity established. It is possible to
|
|
/// determine what formal type it corresponds to. Among other things, it
|
|
/// is possible to use the runtime mangling facilities with the type.
|
|
///
|
|
/// For example, a metadata for a generic struct has a metadata kind,
|
|
/// a type descriptor, and all of its type arguments. However, it does not
|
|
/// necessarily have a meaningful value-witness table.
|
|
///
|
|
/// References to other types that are not part of the type's basic identity
|
|
/// may not yet have been established. Most crucially, this includes the
|
|
/// superclass pointer.
|
|
Abstract = 0xFF,
|
|
};
|
|
|
|
/// Something that can be static_asserted in all the places where we do
|
|
/// comparisons on metadata states.
|
|
constexpr const bool MetadataStateIsReverseOrdered = true;
|
|
|
|
/// Return true if the first metadata state is at least as advanced as the
|
|
/// second.
|
|
inline bool isAtLeast(MetadataState lhs, MetadataState rhs) {
|
|
static_assert(MetadataStateIsReverseOrdered,
|
|
"relying on the ordering of MetadataState here");
|
|
return size_t(lhs) <= size_t(rhs);
|
|
}
|
|
|
|
/// Kinds of requests for metadata.
|
|
class MetadataRequest : public FlagSet<size_t> {
|
|
using IntType = size_t;
|
|
using super = FlagSet<IntType>;
|
|
|
|
public:
|
|
enum : IntType {
|
|
State_bit = 0,
|
|
State_width = 8,
|
|
|
|
/// A blocking request will not return until the runtime is able to produce
|
|
/// metadata with the given kind. A non-blocking request will return
|
|
/// "immediately", producing an abstract metadata and a flag saying that
|
|
/// the operation failed.
|
|
///
|
|
/// An abstract request will never be non-zero.
|
|
NonBlocking_bit = 8,
|
|
};
|
|
|
|
MetadataRequest(MetadataState state, bool isNonBlocking = false) {
|
|
setState(state);
|
|
setIsNonBlocking(isNonBlocking);
|
|
}
|
|
explicit MetadataRequest(IntType bits) : super(bits) {}
|
|
constexpr MetadataRequest() {}
|
|
|
|
FLAGSET_DEFINE_EQUALITY(MetadataRequest)
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(State_bit,
|
|
State_width,
|
|
MetadataState,
|
|
getState,
|
|
setState)
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(NonBlocking_bit,
|
|
isNonBlocking,
|
|
setIsNonBlocking)
|
|
bool isBlocking() const { return !isNonBlocking(); }
|
|
|
|
/// Is this request satisfied by a metadata that's in the given state?
|
|
bool isSatisfiedBy(MetadataState state) const {
|
|
return isAtLeast(state, getState());
|
|
}
|
|
};
|
|
|
|
struct MetadataTrailingFlags : public FlagSet<uint64_t> {
|
|
enum {
|
|
/// Whether this metadata is a specialization of a generic metadata pattern
|
|
/// which was created during compilation.
|
|
IsStaticSpecialization = 0,
|
|
|
|
/// Whether this metadata is a specialization of a generic metadata pattern
|
|
/// which was created during compilation and made to be canonical by
|
|
/// modifying the metadata accessor.
|
|
IsCanonicalStaticSpecialization = 1,
|
|
};
|
|
|
|
explicit MetadataTrailingFlags(uint64_t bits) : FlagSet(bits) {}
|
|
constexpr MetadataTrailingFlags() {}
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(IsStaticSpecialization,
|
|
isStaticSpecialization,
|
|
setIsStaticSpecialization)
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(IsCanonicalStaticSpecialization,
|
|
isCanonicalStaticSpecialization,
|
|
setIsCanonicalStaticSpecialization)
|
|
};
|
|
|
|
/// Flags for Builtin.IntegerLiteral values.
|
|
class IntegerLiteralFlags {
|
|
public:
|
|
enum : size_t {
|
|
IsNegativeFlag = 0x1,
|
|
|
|
// Save some space for other flags.
|
|
|
|
BitWidthShift = 8,
|
|
};
|
|
|
|
private:
|
|
size_t Data;
|
|
|
|
explicit IntegerLiteralFlags(size_t data) : Data(data) {}
|
|
|
|
public:
|
|
constexpr IntegerLiteralFlags(size_t bitWidth, bool isNegative)
|
|
: Data((bitWidth << BitWidthShift)
|
|
| (isNegative ? IsNegativeFlag : 0)) {}
|
|
|
|
/// Return true if the value is negative.
|
|
bool isNegative() const { return Data & IsNegativeFlag; }
|
|
|
|
/// Return the minimum number of bits necessary to store the value in
|
|
/// two's complement, including a leading sign bit.
|
|
unsigned getBitWidth() const { return Data >> BitWidthShift; }
|
|
|
|
size_t getOpaqueValue() const { return Data; }
|
|
static IntegerLiteralFlags getFromOpaqueValue(size_t value) {
|
|
return IntegerLiteralFlags(value);
|
|
}
|
|
};
|
|
|
|
/// Kinds of schedulable job.s
|
|
enum class JobKind : size_t {
|
|
// There are 256 possible job kinds.
|
|
|
|
/// An AsyncTask.
|
|
Task = 0,
|
|
|
|
/// Job kinds >= 192 are private to the implementation.
|
|
First_Reserved = 192,
|
|
|
|
DefaultActorInline = First_Reserved,
|
|
DefaultActorSeparate,
|
|
DefaultActorOverride,
|
|
NullaryContinuation,
|
|
IsolatedDeinit,
|
|
};
|
|
|
|
/// The priority of a job. Higher priorities are larger values.
|
|
enum class JobPriority : size_t {
|
|
// This is modelled off of Dispatch.QoS, and the values are directly
|
|
// stolen from there.
|
|
UserInteractive = 0x21, /* UI */
|
|
UserInitiated = 0x19, /* IN */
|
|
Default = 0x15, /* DEF */
|
|
Utility = 0x11, /* UT */
|
|
Background = 0x09, /* BG */
|
|
Unspecified = 0x00, /* UN */
|
|
};
|
|
|
|
/// A tri-valued comparator which orders higher priorities first.
|
|
inline int descendingPriorityOrder(JobPriority lhs,
|
|
JobPriority rhs) {
|
|
return (lhs == rhs ? 0 : lhs > rhs ? -1 : 1);
|
|
}
|
|
|
|
enum { PriorityBucketCount = 5 };
|
|
|
|
inline int getPriorityBucketIndex(JobPriority priority) {
|
|
// Any unknown priorities will be rounded up to a known one.
|
|
// Priorities higher than UserInteractive are clamped to UserInteractive.
|
|
// Jobs of unknown priorities will end up in the same bucket as jobs of a
|
|
// corresponding known priority. Within the bucket they will be sorted in
|
|
// FIFO order.
|
|
if (priority > JobPriority::UserInitiated) {
|
|
// UserInteractive and higher
|
|
return 0;
|
|
} else if (priority > JobPriority::Default) {
|
|
// UserInitiated
|
|
return 1;
|
|
} else if (priority > JobPriority::Utility) {
|
|
// Default
|
|
return 2;
|
|
} else if (priority > JobPriority::Background) {
|
|
// Utility
|
|
return 3;
|
|
} else {
|
|
// Background and lower
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
inline JobPriority withUserInteractivePriorityDowngrade(JobPriority priority) {
|
|
return (priority == JobPriority::UserInteractive) ? JobPriority::UserInitiated
|
|
: priority;
|
|
}
|
|
|
|
/// Flags for task creation.
|
|
class TaskCreateFlags : public FlagSet<size_t> {
|
|
public:
|
|
enum {
|
|
// Priority that user specified while creating the task
|
|
RequestedPriority = 0,
|
|
RequestedPriority_width = 8,
|
|
|
|
Task_IsChildTask = 8,
|
|
// Should only be set in task-to-thread model where Task.runInline is
|
|
// available
|
|
Task_IsInlineTask = 9,
|
|
Task_CopyTaskLocals = 10,
|
|
Task_InheritContext = 11,
|
|
Task_EnqueueJob = 12,
|
|
Task_AddPendingGroupTaskUnconditionally = 13,
|
|
Task_IsDiscardingTask = 14,
|
|
/// The task function is consumed by calling it (@callee_owned).
|
|
/// The context pointer should be treated as opaque and non-copyable;
|
|
/// in particular, it should not be retained or released.
|
|
///
|
|
/// Supported starting in Swift 6.1.
|
|
Task_IsTaskFunctionConsumed = 15,
|
|
Task_IsImmediateTask = 16,
|
|
};
|
|
|
|
explicit constexpr TaskCreateFlags(size_t bits) : FlagSet(bits) {}
|
|
constexpr TaskCreateFlags() {}
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(RequestedPriority, RequestedPriority_width,
|
|
JobPriority, getRequestedPriority,
|
|
setRequestedPriority)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsChildTask,
|
|
isChildTask,
|
|
setIsChildTask)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsInlineTask,
|
|
isInlineTask,
|
|
setIsInlineTask)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_CopyTaskLocals,
|
|
copyTaskLocals,
|
|
setCopyTaskLocals)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_InheritContext,
|
|
inheritContext,
|
|
setInheritContext)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_EnqueueJob,
|
|
enqueueJob,
|
|
setEnqueueJob)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_AddPendingGroupTaskUnconditionally,
|
|
addPendingGroupTaskUnconditionally,
|
|
setAddPendingGroupTaskUnconditionally)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsDiscardingTask,
|
|
isDiscardingTask,
|
|
setIsDiscardingTask)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsTaskFunctionConsumed,
|
|
isTaskFunctionConsumed,
|
|
setIsTaskFunctionConsumed)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsImmediateTask,
|
|
isImmediateTask,
|
|
setIsImmediateTask)
|
|
};
|
|
|
|
/// Flags for schedulable jobs.
|
|
class JobFlags : public FlagSet<uint32_t> {
|
|
public:
|
|
// clang-format off
|
|
enum {
|
|
Kind = 0,
|
|
Kind_width = 8,
|
|
|
|
Priority = 8,
|
|
Priority_width = 8,
|
|
|
|
// 8 bits reserved for more generic job flags.
|
|
|
|
// Kind-specific flags.
|
|
|
|
Task_IsChildTask = 24,
|
|
Task_IsFuture = 25,
|
|
Task_IsGroupChildTask = 26,
|
|
// 27 is currently unused
|
|
Task_IsAsyncLetTask = 28,
|
|
Task_HasInitialTaskExecutorPreference = 29,
|
|
Task_HasInitialTaskName = 30,
|
|
};
|
|
// clang-format on
|
|
|
|
explicit JobFlags(uint32_t bits) : FlagSet(bits) {}
|
|
JobFlags(JobKind kind) { setKind(kind); }
|
|
JobFlags(JobKind kind, JobPriority priority) {
|
|
setKind(kind);
|
|
setPriority(priority);
|
|
}
|
|
constexpr JobFlags() {}
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(Kind, Kind_width, JobKind,
|
|
getKind, setKind)
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(Priority, Priority_width, JobPriority,
|
|
getPriority, setPriority)
|
|
|
|
bool isAsyncTask() const {
|
|
return getKind() == JobKind::Task;
|
|
}
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsChildTask,
|
|
task_isChildTask,
|
|
task_setIsChildTask)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsFuture,
|
|
task_isFuture,
|
|
task_setIsFuture)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsGroupChildTask,
|
|
task_isGroupChildTask,
|
|
task_setIsGroupChildTask)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsAsyncLetTask,
|
|
task_isAsyncLetTask,
|
|
task_setIsAsyncLetTask)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_HasInitialTaskExecutorPreference,
|
|
task_hasInitialTaskExecutorPreference,
|
|
task_setHasInitialTaskExecutorPreference)
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Task_HasInitialTaskName,
|
|
task_hasInitialTaskName,
|
|
task_setHasInitialTaskName)
|
|
};
|
|
|
|
/// Kinds of task status record.
|
|
enum class TaskStatusRecordKind : uint8_t {
|
|
/// A TaskDependencyStatusRecord which tracks what the current task is
|
|
/// dependent on.
|
|
TaskDependency = 0,
|
|
|
|
/// A ChildTaskStatusRecord, which represents the potential for
|
|
/// active child tasks.
|
|
ChildTask = 1,
|
|
|
|
/// A TaskGroupTaskStatusRecord, which represents a task group
|
|
/// and child tasks spawned within it.
|
|
TaskGroup = 2,
|
|
|
|
/// A CancellationNotificationStatusRecord, which represents the
|
|
/// need to call a custom function when the task is cancelled.
|
|
CancellationNotification = 3,
|
|
|
|
/// An EscalationNotificationStatusRecord, which represents the
|
|
/// need to call a custom function when the task's priority is
|
|
/// escalated.
|
|
EscalationNotification = 4,
|
|
|
|
/// A task executor preference, which may impact what executor a task will be
|
|
/// enqueued on.
|
|
TaskExecutorPreference = 5,
|
|
|
|
/// A human-readable task name.
|
|
TaskName = 6,
|
|
|
|
// Kinds >= 192 are private to the implementation.
|
|
First_Reserved = 192,
|
|
Private_RecordLock = 192
|
|
};
|
|
|
|
/// Kinds of option records that can be passed to creating asynchronous tasks.
|
|
enum class TaskOptionRecordKind : uint8_t {
|
|
/// Request a task to start running on a specific serial executor.
|
|
/// This was renamed in 6.0 to disambiguate with task executors, but the
|
|
/// support was in the runtime from the first release.
|
|
InitialSerialExecutor = 0,
|
|
/// Request a child task to be part of a specific task group.
|
|
TaskGroup = 1,
|
|
/// UNUSED. AsyncLetWithBuffer is used instead.
|
|
/// Request a child task for an 'async let'.
|
|
// AsyncLet = 2,
|
|
/// Request a child task for an 'async let'.
|
|
AsyncLetWithBuffer = 3,
|
|
/// Information about the result type of the task, used in embedded Swift.
|
|
ResultTypeInfo = 4,
|
|
/// Set the initial task executor preference of the task.
|
|
InitialTaskExecutorUnowned = 5,
|
|
InitialTaskExecutorOwned = 6,
|
|
// Set a human-readable task name.
|
|
InitialTaskName = 7,
|
|
/// Request a child task for swift_task_run_inline.
|
|
RunInline = UINT8_MAX,
|
|
};
|
|
|
|
/// Flags for TaskGroup.
|
|
class TaskGroupFlags : public FlagSet<uint32_t> {
|
|
public:
|
|
enum {
|
|
// 8 bits are reserved for future use
|
|
/// Request the TaskGroup to immediately release completed tasks,
|
|
/// and not store their results. This also effectively disables `next()`.
|
|
TaskGroup_DiscardResults = 8,
|
|
};
|
|
|
|
explicit TaskGroupFlags(uint32_t bits) : FlagSet(bits) {}
|
|
constexpr TaskGroupFlags() {}
|
|
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(TaskGroup_DiscardResults,
|
|
isDiscardResults,
|
|
setIsDiscardResults)
|
|
};
|
|
|
|
/// Flags for cancellation records.
|
|
class TaskStatusRecordFlags : public FlagSet<size_t> {
|
|
public:
|
|
enum {
|
|
Kind = 0,
|
|
Kind_width = 8,
|
|
};
|
|
|
|
explicit TaskStatusRecordFlags(size_t bits) : FlagSet(bits) {}
|
|
constexpr TaskStatusRecordFlags() {}
|
|
TaskStatusRecordFlags(TaskStatusRecordKind kind) {
|
|
setKind(kind);
|
|
}
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(Kind, Kind_width, TaskStatusRecordKind,
|
|
getKind, setKind)
|
|
};
|
|
|
|
/// Flags for task option records.
|
|
class TaskOptionRecordFlags : public FlagSet<size_t> {
|
|
public:
|
|
enum {
|
|
Kind = 0,
|
|
Kind_width = 8,
|
|
};
|
|
|
|
explicit TaskOptionRecordFlags(size_t bits) : FlagSet(bits) {}
|
|
constexpr TaskOptionRecordFlags() {}
|
|
TaskOptionRecordFlags(TaskOptionRecordKind kind) {
|
|
setKind(kind);
|
|
}
|
|
|
|
FLAGSET_DEFINE_FIELD_ACCESSORS(Kind, Kind_width, TaskOptionRecordKind,
|
|
getKind, setKind)
|
|
};
|
|
|
|
/// Flags passed to swift_continuation_init.
|
|
class AsyncContinuationFlags : public FlagSet<size_t> {
|
|
public:
|
|
enum {
|
|
CanThrow = 0,
|
|
HasExecutorOverride = 1,
|
|
IsPreawaited = 2,
|
|
IsExecutorSwitchForced = 3,
|
|
};
|
|
|
|
explicit AsyncContinuationFlags(size_t bits) : FlagSet(bits) {}
|
|
constexpr AsyncContinuationFlags() {}
|
|
|
|
/// Whether the continuation is permitted to throw.
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(CanThrow, canThrow, setCanThrow)
|
|
|
|
/// Whether the continuation should be resumed on a different
|
|
/// executor than the current one. swift_continuation_init
|
|
/// will not initialize ResumeToExecutor if this is set.
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(HasExecutorOverride,
|
|
hasExecutorOverride,
|
|
setHasExecutorOverride)
|
|
|
|
/// Whether the switch to the target executor should be forced
|
|
/// by swift_continuation_await. If this is not set, and
|
|
/// swift_continuation_await finds that the continuation has
|
|
/// already been resumed, then execution will continue on the
|
|
/// current executor. This has no effect in combination with
|
|
/// pre-awaiting.
|
|
///
|
|
/// Setting this flag when you know statically that you're
|
|
/// already on the right executor is suboptimal. In particular,
|
|
/// there's no good reason to set this if you're not also using
|
|
/// an executor override.
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(IsExecutorSwitchForced,
|
|
isExecutorSwitchForced,
|
|
setIsExecutorSwitchForced)
|
|
|
|
/// Whether the continuation is "pre-awaited". If so, it should
|
|
/// be set up in the already-awaited state, and so resumptions
|
|
/// will immediately schedule the continuation to begin
|
|
/// asynchronously. The continuation must not be subsequently
|
|
/// awaited if this is set. The task is immediately treated as
|
|
/// suspended.
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(IsPreawaited,
|
|
isPreawaited,
|
|
setIsPreawaited)
|
|
};
|
|
|
|
/// Status values for a continuation. Note that the "not yet"s in
|
|
/// the description below aren't quite right because the system
|
|
/// does not actually promise to update the status before scheduling
|
|
/// the task. This is because the continuation context is immediately
|
|
/// invalidated once the task starts running again, so the window in
|
|
/// which we can usefully protect against (say) double-resumption may
|
|
/// be very small.
|
|
enum class ContinuationStatus : size_t {
|
|
/// The continuation has not yet been awaited or resumed.
|
|
Pending = 0,
|
|
|
|
/// The continuation has already been awaited, but not yet resumed.
|
|
Awaited = 1,
|
|
|
|
/// The continuation has already been resumed, but not yet awaited.
|
|
Resumed = 2
|
|
};
|
|
|
|
/// Flags that go in a TargetAccessibleFunction structure.
|
|
class AccessibleFunctionFlags : public FlagSet<uint32_t> {
|
|
public:
|
|
enum {
|
|
/// Whether this is a "distributed" actor function.
|
|
Distributed = 0,
|
|
};
|
|
|
|
explicit AccessibleFunctionFlags(uint32_t bits) : FlagSet(bits) {}
|
|
constexpr AccessibleFunctionFlags() {}
|
|
|
|
/// Whether the this is a "distributed" actor function.
|
|
FLAGSET_DEFINE_FLAG_ACCESSORS(Distributed, isDistributed, setDistributed)
|
|
};
|
|
|
|
} // end namespace swift
|
|
|
|
#endif // SWIFT_ABI_METADATAVALUES_H
|