Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
659 lines (522 sloc) 17.5 KB
//===--- 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/Basic/RelativePointer.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,
};
int_type Data = 0;
public:
bool isIndirectCase() const {
return (Data & IsIndirectCase) == IsIndirectCase;
}
bool isVar() const {
return (Data & IsVar) == IsVar;
}
void setIsIndirectCase(bool IndirectCase=true) {
if (IndirectCase)
Data |= IsIndirectCase;
else
Data &= ~IsIndirectCase;
}
void setIsVar(bool Var=true) {
if (Var)
Data |= IsVar;
else
Data &= ~IsVar;
}
int_type getRawValue() const {
return Data;
}
};
class FieldRecord {
const FieldRecordFlags Flags;
const RelativeDirectPointer<const char> MangledTypeName;
const RelativeDirectPointer<const char> FieldName;
public:
FieldRecord() = delete;
bool hasMangledTypeName() const {
return MangledTypeName;
}
StringRef getMangledTypeName(uintptr_t Offset) const {
return Demangle::makeSymbolicMangledNameStringRef(
(const char *)((uintptr_t)MangledTypeName.get() + Offset));
}
StringRef getFieldName(uintptr_t Offset, uintptr_t Low,
uintptr_t High) const {
uintptr_t nameAddr = (uintptr_t)FieldName.get() + Offset;
if (nameAddr < Low || nameAddr > High)
return "";
return (const char *)nameAddr;
}
bool isIndirectCase() const {
return Flags.isIndirectCase();
}
};
struct FieldRecordIterator {
const FieldRecord *Cur;
const FieldRecord * const End;
FieldRecordIterator(const FieldRecord *Cur, const FieldRecord * const End)
: Cur(Cur), End(End) {}
const FieldRecord &operator*() const {
return *Cur;
}
const FieldRecord *operator->() const {
return Cur;
}
FieldRecordIterator &operator++() {
++Cur;
return *this;
}
bool operator==(const FieldRecordIterator &other) const {
return Cur == other.Cur && End == other.End;
}
bool operator!=(const FieldRecordIterator &other) const {
return !(*this == other);
}
};
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.
class FieldDescriptor {
const FieldRecord *getFieldRecordBuffer() const {
return reinterpret_cast<const FieldRecord *>(this + 1);
}
const RelativeDirectPointer<const char> MangledTypeName;
const RelativeDirectPointer<const char> Superclass;
public:
FieldDescriptor() = 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<FieldRecord> getFields() const {
return {getFieldRecordBuffer(), NumFields};
}
bool hasMangledTypeName() const {
return MangledTypeName;
}
StringRef getMangledTypeName(uintptr_t Offset) const {
return Demangle::makeSymbolicMangledNameStringRef(
(const char *)((uintptr_t)MangledTypeName.get() + Offset));
}
bool hasSuperclass() const {
return Superclass;
}
StringRef getSuperclass(uintptr_t Offset) const {
return Demangle::makeSymbolicMangledNameStringRef(
(const char*)((uintptr_t)Superclass.get() + Offset));
}
};
class FieldDescriptorIterator
: public std::iterator<std::forward_iterator_tag, FieldDescriptor> {
public:
const void *Cur;
const void * const End;
FieldDescriptorIterator(const void *Cur, const void * const End)
: Cur(Cur), End(End) {}
const FieldDescriptor &operator*() const {
return *reinterpret_cast<const FieldDescriptor *>(Cur);
}
const FieldDescriptor *operator->() const {
return reinterpret_cast<const FieldDescriptor *>(Cur);
}
FieldDescriptorIterator &operator++() {
const auto &FR = this->operator*();
const void *Next = reinterpret_cast<const char *>(Cur)
+ sizeof(FieldDescriptor) + FR.NumFields * FR.FieldRecordSize;
Cur = Next;
return *this;
}
bool operator==(FieldDescriptorIterator const &other) const {
return Cur == other.Cur && End == other.End;
}
bool operator!=(FieldDescriptorIterator const &other) const {
return !(*this == other);
}
};
// Associated type records describe the mapping from an associated
// type to the type witness of a conformance.
class AssociatedTypeRecord {
const RelativeDirectPointer<const char> Name;
const RelativeDirectPointer<const char> SubstitutedTypeName;
public:
StringRef getName(uintptr_t Offset) const {
return (const char*)((uintptr_t)Name.get() + Offset);
}
StringRef getMangledSubstitutedTypeName(uintptr_t Offset) const {
return Demangle::makeSymbolicMangledNameStringRef(
(const char*)((uintptr_t)SubstitutedTypeName.get() + Offset));
}
};
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
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 {
private:
const RelativeDirectPointer<const char> ConformingTypeName;
const RelativeDirectPointer<const char> ProtocolTypeName;
public:
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 };
}
StringRef getMangledProtocolTypeName(uintptr_t Offset) const {
return Demangle::makeSymbolicMangledNameStringRef(
(const char*)((uintptr_t)ProtocolTypeName.get() + Offset));
}
StringRef getMangledConformingTypeName(uintptr_t Offset) const {
return Demangle::makeSymbolicMangledNameStringRef(
(const char*)((uintptr_t)ConformingTypeName.get() + Offset));
}
};
class AssociatedTypeIterator
: public std::iterator<std::forward_iterator_tag, AssociatedTypeDescriptor> {
public:
const void *Cur;
const void * const End;
AssociatedTypeIterator(const void *Cur, const void * const End)
: Cur(Cur), End(End) {}
const AssociatedTypeDescriptor &operator*() const {
return *reinterpret_cast<const AssociatedTypeDescriptor *>(Cur);
}
const AssociatedTypeDescriptor *operator->() const {
return reinterpret_cast<const AssociatedTypeDescriptor *>(Cur);
}
AssociatedTypeIterator &operator++() {
const auto &ATR = this->operator*();
size_t Size = sizeof(AssociatedTypeDescriptor) +
ATR.NumAssociatedTypes * ATR.AssociatedTypeRecordSize;
const void *Next = reinterpret_cast<const char *>(Cur) + Size;
Cur = Next;
return *this;
}
bool operator==(AssociatedTypeIterator const &other) const {
return Cur == other.Cur && End == other.End;
}
bool operator!=(AssociatedTypeIterator const &other) const {
return !(*this == other);
}
};
// Builtin type records describe basic layout information about
// any builtin types referenced from the other sections.
class BuiltinTypeDescriptor {
const RelativeDirectPointer<const char> TypeName;
public:
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;
}
StringRef getMangledTypeName(uintptr_t Offset) const {
return Demangle::makeSymbolicMangledNameStringRef(
(const char*)((uintptr_t)TypeName.get() + Offset));
}
};
class BuiltinTypeDescriptorIterator
: public std::iterator<std::forward_iterator_tag, BuiltinTypeDescriptor> {
public:
const void *Cur;
const void * const End;
BuiltinTypeDescriptorIterator(const void *Cur, const void * const End)
: Cur(Cur), End(End) {}
const BuiltinTypeDescriptor &operator*() const {
return *reinterpret_cast<const BuiltinTypeDescriptor *>(Cur);
}
const BuiltinTypeDescriptor *operator->() const {
return reinterpret_cast<const BuiltinTypeDescriptor *>(Cur);;
}
BuiltinTypeDescriptorIterator &operator++() {
const void *Next = reinterpret_cast<const char *>(Cur)
+ sizeof(BuiltinTypeDescriptor);
Cur = Next;
return *this;
}
bool operator==(BuiltinTypeDescriptorIterator const &other) const {
return Cur == other.Cur && End == other.End;
}
bool operator!=(BuiltinTypeDescriptorIterator const &other) const {
return !(*this == other);
}
};
class CaptureTypeRecord {
const RelativeDirectPointer<const char> MangledTypeName;
public:
CaptureTypeRecord() = delete;
bool hasMangledTypeName() const {
return MangledTypeName;
}
StringRef getMangledTypeName(uintptr_t Offset) const {
return Demangle::makeSymbolicMangledNameStringRef(
(const char*)((uintptr_t)MangledTypeName.get() + Offset));
}
};
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 {
const RelativeDirectPointer<const char> MangledTypeName;
const RelativeDirectPointer<const char> MangledMetadataSource;
public:
MetadataSourceRecord() = delete;
bool hasMangledTypeName() const {
return MangledTypeName;
}
StringRef getMangledTypeName(uintptr_t Offset) const {
return Demangle::makeSymbolicMangledNameStringRef(
(const char*)((uintptr_t)MangledTypeName.get() + Offset));
}
bool hasMangledMetadataSource() const {
return MangledMetadataSource;
}
StringRef getMangledMetadataSource(uintptr_t Offset) const {
return Demangle::makeSymbolicMangledNameStringRef(
(const char*)((uintptr_t)MangledMetadataSource.get() + Offset));
}
};
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 };
}
};
class CaptureDescriptorIterator
: public std::iterator<std::forward_iterator_tag, CaptureDescriptor> {
public:
const void *Cur;
const void * const End;
CaptureDescriptorIterator(const void *Cur, const void * const End)
: Cur(Cur), End(End) {}
const CaptureDescriptor &operator*() const {
return *reinterpret_cast<const CaptureDescriptor *>(Cur);
}
const CaptureDescriptor *operator->() const {
return reinterpret_cast<const CaptureDescriptor *>(Cur);
}
CaptureDescriptorIterator &operator++() {
const auto &CR = this->operator*();
const void *Next = reinterpret_cast<const char *>(Cur)
+ sizeof(CaptureDescriptor)
+ CR.NumCaptureTypes * sizeof(CaptureTypeRecord)
+ CR.NumMetadataSources * sizeof(MetadataSourceRecord);
Cur = Next;
return *this;
}
bool operator==(CaptureDescriptorIterator const &other) const {
return Cur == other.Cur && End == other.End;
}
bool operator!=(CaptureDescriptorIterator const &other) const {
return !(*this == other);
}
};
} // end namespace reflection
} // end namespace swift
#endif // SWIFT_REFLECTION_RECORDS_H
You can’t perform that action at this time.