mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
642 lines
17 KiB
C++
642 lines
17 KiB
C++
//===--- Records.h - Swift Type Reflection Records --------------*- 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Implements the structures of type reflection records.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_REFLECTION_RECORDS_H
|
|
#define SWIFT_REFLECTION_RECORDS_H
|
|
|
|
#include "swift/ABI/TargetLayout.h"
|
|
#include "swift/Demangling/Demangle.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
|
|
namespace swift {
|
|
|
|
const uint16_t SWIFT_REFLECTION_METADATA_VERSION = 3; // superclass field
|
|
|
|
namespace reflection {
|
|
|
|
// Field records describe the type of a single stored property or case member
|
|
// of a class, struct or enum.
|
|
class FieldRecordFlags {
|
|
using int_type = uint32_t;
|
|
enum : int_type {
|
|
// Is this an indirect enum case?
|
|
IsIndirectCase = 0x1,
|
|
|
|
// Is this a mutable `var` property?
|
|
IsVar = 0x2,
|
|
|
|
// Is this an artificial field?
|
|
IsArtificial = 0x4,
|
|
};
|
|
int_type Data = 0;
|
|
|
|
public:
|
|
bool isIndirectCase() const {
|
|
return (Data & IsIndirectCase) == IsIndirectCase;
|
|
}
|
|
|
|
bool isVar() const {
|
|
return (Data & IsVar) == IsVar;
|
|
}
|
|
|
|
bool isArtificial() const {
|
|
return (Data & IsArtificial) == IsArtificial;
|
|
}
|
|
|
|
void setIsIndirectCase(bool IndirectCase=true) {
|
|
if (IndirectCase)
|
|
Data |= IsIndirectCase;
|
|
else
|
|
Data &= ~IsIndirectCase;
|
|
}
|
|
|
|
void setIsVar(bool Var=true) {
|
|
if (Var)
|
|
Data |= IsVar;
|
|
else
|
|
Data &= ~IsVar;
|
|
}
|
|
|
|
void setIsArtificial(bool artificial=true) {
|
|
if (artificial)
|
|
Data |= IsArtificial;
|
|
else
|
|
Data &= ~IsArtificial;
|
|
}
|
|
|
|
int_type getRawValue() const {
|
|
return Data;
|
|
}
|
|
};
|
|
|
|
template <typename Runtime>
|
|
class TargetFieldRecord {
|
|
const FieldRecordFlags Flags;
|
|
|
|
public:
|
|
const TargetRelativeDirectPointer<Runtime, const char> MangledTypeName;
|
|
const TargetRelativeDirectPointer<Runtime, const char> FieldName;
|
|
|
|
TargetFieldRecord() = delete;
|
|
|
|
bool hasMangledTypeName() const {
|
|
return MangledTypeName;
|
|
}
|
|
|
|
llvm::StringRef getMangledTypeName() const {
|
|
return Demangle::makeSymbolicMangledNameStringRef(MangledTypeName.get());
|
|
}
|
|
|
|
llvm::StringRef getFieldName() const {
|
|
return FieldName.get();
|
|
}
|
|
|
|
bool isIndirectCase() const {
|
|
return Flags.isIndirectCase();
|
|
}
|
|
|
|
bool isVar() const {
|
|
return Flags.isVar();
|
|
}
|
|
};
|
|
using FieldRecord = TargetFieldRecord<InProcess>;
|
|
|
|
template <typename Runtime>
|
|
struct TargetFieldRecordIterator {
|
|
const TargetFieldRecord<Runtime> *Cur;
|
|
const TargetFieldRecord<Runtime> *const End;
|
|
|
|
TargetFieldRecordIterator(const TargetFieldRecord<Runtime> *Cur,
|
|
const TargetFieldRecord<Runtime> *const End)
|
|
: Cur(Cur), End(End) {}
|
|
|
|
const TargetFieldRecord<Runtime> &operator*() const { return *Cur; }
|
|
|
|
const TargetFieldRecord<Runtime> *operator->() const { return Cur; }
|
|
|
|
TargetFieldRecordIterator &operator++() {
|
|
++Cur;
|
|
return *this;
|
|
}
|
|
|
|
bool operator==(const TargetFieldRecordIterator &other) const {
|
|
return Cur == other.Cur && End == other.End;
|
|
}
|
|
|
|
bool operator!=(const TargetFieldRecordIterator &other) const {
|
|
return !(*this == other);
|
|
}
|
|
};
|
|
|
|
using FieldRecordIterator = TargetFieldRecordIterator<InProcess>;
|
|
|
|
enum class FieldDescriptorKind : uint16_t {
|
|
// Swift nominal types.
|
|
Struct,
|
|
Class,
|
|
Enum,
|
|
|
|
// Fixed-size multi-payload enums have a special descriptor format that
|
|
// encodes spare bits.
|
|
//
|
|
// FIXME: Actually implement this. For now, a descriptor with this kind
|
|
// just means we also have a builtin descriptor from which we get the
|
|
// size and alignment.
|
|
MultiPayloadEnum,
|
|
|
|
// A Swift opaque protocol. There are no fields, just a record for the
|
|
// type itself.
|
|
Protocol,
|
|
|
|
// A Swift class-bound protocol.
|
|
ClassProtocol,
|
|
|
|
// An Objective-C protocol, which may be imported or defined in Swift.
|
|
ObjCProtocol,
|
|
|
|
// An Objective-C class, which may be imported or defined in Swift.
|
|
// In the former case, field type metadata is not emitted, and
|
|
// must be obtained from the Objective-C runtime.
|
|
ObjCClass
|
|
};
|
|
|
|
// Field descriptors contain a collection of field records for a single
|
|
// class, struct or enum declaration.
|
|
template <typename Runtime>
|
|
class TargetFieldDescriptor {
|
|
const TargetFieldRecord<Runtime> *getFieldRecordBuffer() const {
|
|
return reinterpret_cast<const TargetFieldRecord<Runtime> *>(this + 1);
|
|
}
|
|
|
|
public:
|
|
const TargetRelativeDirectPointer<Runtime, const char> MangledTypeName;
|
|
const TargetRelativeDirectPointer<Runtime, const char> Superclass;
|
|
|
|
TargetFieldDescriptor() = delete;
|
|
|
|
const FieldDescriptorKind Kind;
|
|
const uint16_t FieldRecordSize;
|
|
const uint32_t NumFields;
|
|
|
|
using const_iterator = FieldRecordIterator;
|
|
|
|
bool isEnum() const {
|
|
return (Kind == FieldDescriptorKind::Enum ||
|
|
Kind == FieldDescriptorKind::MultiPayloadEnum);
|
|
}
|
|
|
|
bool isClass() const {
|
|
return (Kind == FieldDescriptorKind::Class ||
|
|
Kind == FieldDescriptorKind::ObjCClass);
|
|
}
|
|
|
|
bool isProtocol() const {
|
|
return (Kind == FieldDescriptorKind::Protocol ||
|
|
Kind == FieldDescriptorKind::ClassProtocol ||
|
|
Kind == FieldDescriptorKind::ObjCProtocol);
|
|
}
|
|
|
|
bool isStruct() const {
|
|
return Kind == FieldDescriptorKind::Struct;
|
|
}
|
|
|
|
const_iterator begin() const {
|
|
auto Begin = getFieldRecordBuffer();
|
|
auto End = Begin + NumFields;
|
|
return const_iterator { Begin, End };
|
|
}
|
|
|
|
const_iterator end() const {
|
|
auto Begin = getFieldRecordBuffer();
|
|
auto End = Begin + NumFields;
|
|
return const_iterator { End, End };
|
|
}
|
|
|
|
llvm::ArrayRef<TargetFieldRecord<Runtime>> getFields() const {
|
|
return {getFieldRecordBuffer(), NumFields};
|
|
}
|
|
|
|
bool hasMangledTypeName() const {
|
|
return MangledTypeName;
|
|
}
|
|
|
|
llvm::StringRef getMangledTypeName() const {
|
|
return Demangle::makeSymbolicMangledNameStringRef(MangledTypeName.get());
|
|
}
|
|
|
|
bool hasSuperclass() const {
|
|
return Superclass;
|
|
}
|
|
|
|
llvm::StringRef getSuperclass() const {
|
|
return Demangle::makeSymbolicMangledNameStringRef(Superclass.get());
|
|
}
|
|
};
|
|
using FieldDescriptor = TargetFieldDescriptor<InProcess>;
|
|
|
|
// Associated type records describe the mapping from an associated
|
|
// type to the type witness of a conformance.
|
|
class AssociatedTypeRecord {
|
|
public:
|
|
const RelativeDirectPointer<const char> Name;
|
|
const RelativeDirectPointer<const char> SubstitutedTypeName;
|
|
|
|
llvm::StringRef getName() const {
|
|
return Name.get();
|
|
}
|
|
|
|
llvm::StringRef getMangledSubstitutedTypeName() const {
|
|
return Demangle::makeSymbolicMangledNameStringRef(
|
|
SubstitutedTypeName.get());
|
|
}
|
|
};
|
|
|
|
struct AssociatedTypeRecordIterator {
|
|
const AssociatedTypeRecord *Cur;
|
|
const AssociatedTypeRecord * const End;
|
|
|
|
AssociatedTypeRecordIterator()
|
|
: Cur(nullptr), End(nullptr) {}
|
|
|
|
AssociatedTypeRecordIterator(const AssociatedTypeRecord *Cur,
|
|
const AssociatedTypeRecord * const End)
|
|
: Cur(Cur), End(End) {}
|
|
|
|
const AssociatedTypeRecord &operator*() const {
|
|
return *Cur;
|
|
}
|
|
|
|
const AssociatedTypeRecord *operator->() const {
|
|
return Cur;
|
|
}
|
|
|
|
AssociatedTypeRecordIterator &operator++() {
|
|
++Cur;
|
|
return *this;
|
|
}
|
|
|
|
AssociatedTypeRecordIterator(const AssociatedTypeRecordIterator &Other)
|
|
: Cur(Other.Cur), End(Other.End) {}
|
|
AssociatedTypeRecordIterator
|
|
operator=(const AssociatedTypeRecordIterator &Other) {
|
|
return { Other.Cur, Other.End };
|
|
}
|
|
|
|
bool operator==(const AssociatedTypeRecordIterator &other) const {
|
|
return Cur == other.Cur && End == other.End;
|
|
}
|
|
|
|
bool operator!=(const AssociatedTypeRecordIterator &other) const {
|
|
return !(*this == other);
|
|
}
|
|
|
|
operator bool() const {
|
|
return Cur && End;
|
|
}
|
|
};
|
|
|
|
// An associated type descriptor contains a collection of associated
|
|
// type records for a conformance.
|
|
struct AssociatedTypeDescriptor {
|
|
public:
|
|
const RelativeDirectPointer<const char> ConformingTypeName;
|
|
const RelativeDirectPointer<const char> ProtocolTypeName;
|
|
|
|
uint32_t NumAssociatedTypes;
|
|
uint32_t AssociatedTypeRecordSize;
|
|
|
|
const AssociatedTypeRecord *getAssociatedTypeRecordBuffer() const {
|
|
return reinterpret_cast<const AssociatedTypeRecord *>(this + 1);
|
|
}
|
|
|
|
using const_iterator = AssociatedTypeRecordIterator;
|
|
|
|
const_iterator begin() const {
|
|
auto Begin = getAssociatedTypeRecordBuffer();
|
|
auto End = Begin + NumAssociatedTypes;
|
|
return const_iterator { Begin, End };
|
|
}
|
|
|
|
const_iterator end() const {
|
|
auto Begin = getAssociatedTypeRecordBuffer();
|
|
auto End = Begin + NumAssociatedTypes;
|
|
return const_iterator { End, End };
|
|
}
|
|
|
|
llvm::StringRef getMangledProtocolTypeName() const {
|
|
return Demangle::makeSymbolicMangledNameStringRef(ProtocolTypeName.get());
|
|
}
|
|
|
|
llvm::StringRef getMangledConformingTypeName() const {
|
|
return Demangle::makeSymbolicMangledNameStringRef(ConformingTypeName.get());
|
|
}
|
|
};
|
|
|
|
// Builtin type records describe basic layout information about
|
|
// any builtin types referenced from the other sections.
|
|
class BuiltinTypeDescriptor {
|
|
public:
|
|
const RelativeDirectPointer<const char> TypeName;
|
|
|
|
uint32_t Size;
|
|
|
|
// - Least significant 16 bits are the alignment.
|
|
// - Bit 16 is 'bitwise takable'.
|
|
// - Remaining bits are reserved.
|
|
uint32_t AlignmentAndFlags;
|
|
|
|
uint32_t Stride;
|
|
uint32_t NumExtraInhabitants;
|
|
|
|
bool isBitwiseTakable() const {
|
|
return (AlignmentAndFlags >> 16) & 1;
|
|
}
|
|
|
|
uint32_t getAlignment() const {
|
|
return AlignmentAndFlags & 0xffff;
|
|
}
|
|
|
|
bool hasMangledTypeName() const {
|
|
return TypeName;
|
|
}
|
|
|
|
llvm::StringRef getMangledTypeName() const {
|
|
return Demangle::makeSymbolicMangledNameStringRef(TypeName.get());
|
|
}
|
|
};
|
|
|
|
class MultiPayloadEnumDescriptor {
|
|
public:
|
|
const RelativeDirectPointer<const char> TypeName;
|
|
|
|
private:
|
|
// This descriptor contains a series of 32-bit words
|
|
uint32_t contents[];
|
|
|
|
// Properties are stored in `contents` at particular indexes:
|
|
|
|
// uint32_t SizeFlags;
|
|
// Upper 16 bits are the size of the contents (in 32-bit words):
|
|
// (This allows us to expand this structure in the future;
|
|
// new fields should have accessors that test whether the
|
|
// size is large enough and return "non-existent" if the
|
|
// descriptor isn't large enough to have that field.)
|
|
// Lower 16 bits are flag bits
|
|
|
|
int getSizeFlagsIndex() const { return 0; }
|
|
|
|
// uint32_t PayloadSpareBitMaskByteOffsetCount;
|
|
// Number of bytes in "payload spare bits", and
|
|
// offset of them within the payload area
|
|
// Only present if `usePayloadSpareBits()`
|
|
|
|
int getPayloadSpareBitMaskByteCountIndex() const {
|
|
return getSizeFlagsIndex() + 1;
|
|
}
|
|
|
|
// uint8_t *PayloadSpareBits;
|
|
// Variably-sized bitmask field (padded to a multiple of 4 bytes)
|
|
// Only present if `usePayloadSpareBits()`
|
|
|
|
int getPayloadSpareBitsIndex() const {
|
|
int PayloadSpareBitMaskByteCountFieldSize = usesPayloadSpareBits() ? 1 : 0;
|
|
return getPayloadSpareBitMaskByteCountIndex() + PayloadSpareBitMaskByteCountFieldSize;
|
|
}
|
|
|
|
// uint32_t foo;
|
|
// TODO: Some future field
|
|
// int getFooIndex() const {
|
|
// int PayloadSpareBitMaskFieldSize = (getPayloadSpareBitMaskByteCount() + 3) / 4;
|
|
// return getPayloadSpareBitsIndex() + PayloadSpareBitMaskFieldSize;
|
|
// }
|
|
|
|
// uint32_t getFoo() const {
|
|
// if (getFooIndex() < getContentsSizeInWords()) {
|
|
// return contents[getFooIndex()];
|
|
// } else {
|
|
// return 0; // Field isn't present
|
|
// }
|
|
// }
|
|
|
|
public:
|
|
//
|
|
// Data derived from the above...
|
|
//
|
|
|
|
uint32_t getContentsSizeInWords() const {
|
|
return contents[getSizeFlagsIndex()] >> 16;
|
|
}
|
|
|
|
size_t getSizeInBytes() const {
|
|
// assert(getContentsSizeInWords() > 0 && "Malformed MPEnum reflection record");
|
|
size_t sizeInBytes = sizeof(TypeName) + getContentsSizeInWords() * 4;
|
|
return sizeInBytes;
|
|
}
|
|
|
|
uint32_t getFlags() const {
|
|
assert(getContentsSizeInWords() > 0 && "Malformed MPEnum reflection record");
|
|
return contents[getSizeFlagsIndex()] & 0xffff;
|
|
}
|
|
|
|
bool usesPayloadSpareBits() const {
|
|
return getFlags() & 1;
|
|
}
|
|
|
|
uint32_t getPayloadSpareBitMaskByteOffset() const {
|
|
if (usesPayloadSpareBits()) {
|
|
return contents[getPayloadSpareBitMaskByteCountIndex()] >> 16;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
uint32_t getPayloadSpareBitMaskByteCount() const {
|
|
if (usesPayloadSpareBits()) {
|
|
auto byteCount = contents[getPayloadSpareBitMaskByteCountIndex()] & 0xffff;
|
|
assert(getContentsSizeInWords() >= 2 + (byteCount + 3) / 4
|
|
&& "Malformed MPEnum reflection record: mask bigger than record");
|
|
return byteCount;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
const uint8_t *getPayloadSpareBits() const {
|
|
if (usesPayloadSpareBits()) {
|
|
return reinterpret_cast<const uint8_t *>(&contents[getPayloadSpareBitsIndex()]);
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
};
|
|
|
|
class CaptureTypeRecord {
|
|
public:
|
|
const RelativeDirectPointer<const char> MangledTypeName;
|
|
|
|
CaptureTypeRecord() = delete;
|
|
|
|
bool hasMangledTypeName() const {
|
|
return MangledTypeName;
|
|
}
|
|
|
|
llvm::StringRef getMangledTypeName() const {
|
|
return Demangle::makeSymbolicMangledNameStringRef(MangledTypeName.get());
|
|
}
|
|
};
|
|
|
|
struct CaptureTypeRecordIterator {
|
|
const CaptureTypeRecord *Cur;
|
|
const CaptureTypeRecord * const End;
|
|
|
|
CaptureTypeRecordIterator(const CaptureTypeRecord *Cur,
|
|
const CaptureTypeRecord * const End)
|
|
: Cur(Cur), End(End) {}
|
|
|
|
const CaptureTypeRecord &operator*() const {
|
|
return *Cur;
|
|
}
|
|
|
|
const CaptureTypeRecord *operator->() const {
|
|
return Cur;
|
|
}
|
|
|
|
CaptureTypeRecordIterator &operator++() {
|
|
++Cur;
|
|
return *this;
|
|
}
|
|
|
|
bool operator==(const CaptureTypeRecordIterator &other) const {
|
|
return Cur == other.Cur && End == other.End;
|
|
}
|
|
|
|
bool operator!=(const CaptureTypeRecordIterator &other) const {
|
|
return !(*this == other);
|
|
}
|
|
};
|
|
|
|
class MetadataSourceRecord {
|
|
public:
|
|
const RelativeDirectPointer<const char> MangledTypeName;
|
|
const RelativeDirectPointer<const char> MangledMetadataSource;
|
|
|
|
MetadataSourceRecord() = delete;
|
|
|
|
bool hasMangledTypeName() const {
|
|
return MangledTypeName;
|
|
}
|
|
|
|
llvm::StringRef getMangledTypeName() const {
|
|
return Demangle::makeSymbolicMangledNameStringRef(MangledTypeName.get());
|
|
}
|
|
|
|
bool hasMangledMetadataSource() const {
|
|
return MangledMetadataSource;
|
|
}
|
|
|
|
llvm::StringRef getMangledMetadataSource() const {
|
|
return Demangle::makeSymbolicMangledNameStringRef(
|
|
MangledMetadataSource.get());
|
|
}
|
|
};
|
|
|
|
struct MetadataSourceRecordIterator {
|
|
const MetadataSourceRecord *Cur;
|
|
const MetadataSourceRecord * const End;
|
|
|
|
MetadataSourceRecordIterator(const MetadataSourceRecord *Cur,
|
|
const MetadataSourceRecord * const End)
|
|
: Cur(Cur), End(End) {}
|
|
|
|
const MetadataSourceRecord &operator*() const {
|
|
return *Cur;
|
|
}
|
|
|
|
const MetadataSourceRecord *operator->() const {
|
|
return Cur;
|
|
}
|
|
|
|
MetadataSourceRecordIterator &operator++() {
|
|
++Cur;
|
|
return *this;
|
|
}
|
|
|
|
bool operator==(const MetadataSourceRecordIterator &other) const {
|
|
return Cur == other.Cur && End == other.End;
|
|
}
|
|
|
|
bool operator!=(const MetadataSourceRecordIterator &other) const {
|
|
return !(*this == other);
|
|
}
|
|
};
|
|
|
|
// Capture descriptors describe the layout of a closure context
|
|
// object. Unlike nominal types, the generic substitutions for a
|
|
// closure context come from the object, and not the metadata.
|
|
class CaptureDescriptor {
|
|
const CaptureTypeRecord *getCaptureTypeRecordBuffer() const {
|
|
return reinterpret_cast<const CaptureTypeRecord *>(this + 1);
|
|
}
|
|
|
|
const MetadataSourceRecord *getMetadataSourceRecordBuffer() const {
|
|
return reinterpret_cast<const MetadataSourceRecord *>(capture_end().End);
|
|
}
|
|
|
|
public:
|
|
/// The number of captures in the closure and the number of typerefs that
|
|
/// immediately follow this struct.
|
|
uint32_t NumCaptureTypes;
|
|
|
|
/// The number of sources of metadata available in the MetadataSourceMap
|
|
/// directly following the list of capture's typerefs.
|
|
uint32_t NumMetadataSources;
|
|
|
|
/// The number of items in the NecessaryBindings structure at the head of
|
|
/// the closure.
|
|
uint32_t NumBindings;
|
|
|
|
using const_iterator = FieldRecordIterator;
|
|
|
|
CaptureTypeRecordIterator capture_begin() const {
|
|
auto Begin = getCaptureTypeRecordBuffer();
|
|
auto End = Begin + NumCaptureTypes;
|
|
return { Begin, End };
|
|
}
|
|
|
|
CaptureTypeRecordIterator capture_end() const {
|
|
auto Begin = getCaptureTypeRecordBuffer();
|
|
auto End = Begin + NumCaptureTypes;
|
|
return { End, End };
|
|
}
|
|
|
|
MetadataSourceRecordIterator source_begin() const {
|
|
auto Begin = getMetadataSourceRecordBuffer();
|
|
auto End = Begin + NumMetadataSources;
|
|
return { Begin, End };
|
|
}
|
|
|
|
MetadataSourceRecordIterator source_end() const {
|
|
auto Begin = getMetadataSourceRecordBuffer();
|
|
auto End = Begin + NumMetadataSources;
|
|
return { End, End };
|
|
}
|
|
};
|
|
|
|
} // end namespace reflection
|
|
} // end namespace swift
|
|
|
|
#endif // SWIFT_REFLECTION_RECORDS_H
|