mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
f2bb319bdb
Minimize the generic class metadata template by removing the class header and base-class members. Add back the set of information that's really required for instantiation. Teach swift_allocateGenericClass how to allocate classes without superclass metadata. Reorder generic initialization to establish a stronger phase-ordering between allocation (the part that doesn't really care about the generic arguments) and initialization (the part that really does care about the generic arguments and therefore might need to be delayed to handle metadata cycles). A similar thing needs to happen for resilient class relocation.
401 lines
11 KiB
C++
401 lines
11 KiB
C++
//===--- MetadataLayout.h - Type metadata layout ----------------*- 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Information recording the layout of type metadata objects.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_IRGEN_METADATALAYOUT_H
|
|
#define SWIFT_IRGEN_METADATALAYOUT_H
|
|
|
|
#include "IRGen.h"
|
|
#include "swift/SIL/SILDeclRef.h"
|
|
|
|
namespace swift {
|
|
class ClassDecl;
|
|
class EnumDecl;
|
|
class StructDecl;
|
|
class VarDecl;
|
|
|
|
namespace irgen {
|
|
class Address;
|
|
class IRGenFunction;
|
|
class IRGenModule;
|
|
|
|
/// The total size and address point of a metadata object.
|
|
struct MetadataSize {
|
|
Size FullSize;
|
|
Size AddressPoint;
|
|
|
|
/// Return the offset from the address point to the end of the
|
|
/// metadata object.
|
|
Size getOffsetToEnd() const {
|
|
return FullSize - AddressPoint;
|
|
}
|
|
};
|
|
|
|
/// A base class for various kinds of metadata layout.
|
|
class MetadataLayout {
|
|
public:
|
|
enum class Kind {
|
|
Class,
|
|
Struct,
|
|
Enum,
|
|
ForeignClass,
|
|
};
|
|
|
|
class StoredOffset {
|
|
public:
|
|
enum Kind {
|
|
/// The high bits are an integer displacement.
|
|
Static = 0,
|
|
|
|
/// The high bits are an integer displacement relative to a offset stored
|
|
/// in a class metadata base offset global variable. This is used to
|
|
/// access members of class metadata where the superclass is resilient to
|
|
/// us, and therefore has an unknown size.
|
|
Dynamic,
|
|
};
|
|
|
|
private:
|
|
enum : uint64_t {
|
|
KindBits = 1,
|
|
KindMask = (1 << KindBits) - 1,
|
|
PayloadMask = ~uint64_t(KindMask)
|
|
};
|
|
|
|
mutable uintptr_t Data;
|
|
public:
|
|
StoredOffset() : Data(0) {}
|
|
explicit StoredOffset(Size offset, Kind kind)
|
|
: Data((static_cast<uint64_t>(offset.getValue()) << KindBits) | kind) {
|
|
assert(kind == Kind::Dynamic || !offset.isZero() &&
|
|
"cannot store a zero static offset");
|
|
if (kind == Kind::Static)
|
|
assert(getStaticOffset() == offset && "overflow");
|
|
if (kind == Kind::Dynamic)
|
|
assert(getRelativeOffset() == offset && "overflow");
|
|
}
|
|
|
|
bool isValid() const { return Data != 0; }
|
|
bool isStatic() const { return isValid() && (Data & KindMask) == Static; }
|
|
bool isDynamic() const { return (Data & KindMask) == Dynamic; }
|
|
|
|
/// If this is a metadata offset into a resilient class, returns the offset
|
|
/// relative to the size of the superclass metadata.
|
|
Size getRelativeOffset() const {
|
|
assert(isDynamic());
|
|
return Size(static_cast<int64_t>(Data) >> KindBits);
|
|
}
|
|
|
|
/// Returns the offset relative to start of metadata. Only used for
|
|
/// metadata fields whose offset is completely known at compile time.
|
|
Size getStaticOffset() const {
|
|
assert(isStatic());
|
|
return Size(static_cast<int64_t>(Data) >> KindBits);
|
|
}
|
|
};
|
|
|
|
private:
|
|
Kind TheKind;
|
|
|
|
protected:
|
|
MetadataSize TheSize;
|
|
|
|
MetadataLayout(Kind theKind) : TheKind(theKind) {}
|
|
|
|
MetadataLayout(const MetadataLayout &other) = delete;
|
|
MetadataLayout &operator=(const MetadataLayout &other) = delete;
|
|
|
|
public:
|
|
/// Destruct and deallocate this layout object.
|
|
void destroy() const;
|
|
|
|
Kind getKind() const { return TheKind; }
|
|
|
|
MetadataSize getSize() const { return TheSize; }
|
|
};
|
|
|
|
/// Base class for nominal type metadata layouts.
|
|
class NominalMetadataLayout : public MetadataLayout {
|
|
protected:
|
|
NominalTypeDecl *Nominal;
|
|
StoredOffset GenericRequirements;
|
|
|
|
NominalMetadataLayout(Kind kind, NominalTypeDecl *nominal)
|
|
: MetadataLayout(kind), Nominal(nominal) {}
|
|
|
|
Offset emitOffset(IRGenFunction &IGF, StoredOffset offset) const;
|
|
|
|
public:
|
|
NominalTypeDecl *getDecl() const {
|
|
return Nominal;
|
|
}
|
|
|
|
bool hasGenericRequirements() const {
|
|
return GenericRequirements.isValid();
|
|
}
|
|
|
|
/// Should only be used when emitting the nominal type descriptor.
|
|
Size getStaticGenericRequirementsOffset() const;
|
|
|
|
Offset getGenericRequirementsOffset(IRGenFunction &IGF) const;
|
|
|
|
static bool classof(const MetadataLayout *layout) {
|
|
switch (layout->getKind()) {
|
|
case MetadataLayout::Kind::Class:
|
|
case MetadataLayout::Kind::Enum:
|
|
case MetadataLayout::Kind::Struct:
|
|
return true;
|
|
|
|
case MetadataLayout::Kind::ForeignClass:
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
|
|
/// Layout for class type metadata.
|
|
class ClassMetadataLayout : public NominalMetadataLayout {
|
|
public:
|
|
class MethodInfo {
|
|
Offset TheOffset;
|
|
public:
|
|
MethodInfo(Offset offset)
|
|
: TheOffset(offset) {}
|
|
Offset getOffset() const { return TheOffset; }
|
|
};
|
|
|
|
private:
|
|
bool HasResilientSuperclass = false;
|
|
|
|
StoredOffset StartOfImmediateMembers;
|
|
|
|
StoredOffset MetadataSize;
|
|
StoredOffset MetadataAddressPoint;
|
|
|
|
StoredOffset InstanceSize;
|
|
StoredOffset InstanceAlignMask;
|
|
|
|
struct StoredMethodInfo {
|
|
StoredOffset TheOffset;
|
|
StoredMethodInfo(StoredOffset offset) : TheOffset(offset) {}
|
|
};
|
|
llvm::DenseMap<SILDeclRef, StoredMethodInfo> MethodInfos;
|
|
|
|
/// Field offsets for various fields.
|
|
llvm::DenseMap<VarDecl*, StoredOffset> FieldOffsets;
|
|
|
|
/// The start of the vtable.
|
|
StoredOffset VTableOffset;
|
|
|
|
/// The start of the field-offset vector.
|
|
StoredOffset FieldOffsetVector;
|
|
|
|
/// The number of members to add after superclass metadata.
|
|
unsigned NumImmediateMembers;
|
|
|
|
const StoredMethodInfo &getStoredMethodInfo(SILDeclRef method) const {
|
|
auto it = MethodInfos.find(method);
|
|
assert(it != MethodInfos.end());
|
|
return it->second;
|
|
}
|
|
|
|
const StoredOffset &getStoredFieldOffset(VarDecl *field) const {
|
|
auto it = FieldOffsets.find(field);
|
|
assert(it != FieldOffsets.end());
|
|
return it->second;
|
|
}
|
|
|
|
friend class IRGenModule;
|
|
ClassMetadataLayout(IRGenModule &IGM, ClassDecl *theClass);
|
|
|
|
public:
|
|
ClassDecl *getDecl() const {
|
|
return cast<ClassDecl>(Nominal);
|
|
}
|
|
|
|
bool hasResilientSuperclass() const {
|
|
return HasResilientSuperclass;
|
|
}
|
|
|
|
constexpr static bool areImmediateMembersNegative() {
|
|
return false;
|
|
}
|
|
|
|
Size getMetadataSizeOffset() const;
|
|
|
|
Size getMetadataAddressPointOffset() const;
|
|
|
|
Size getInstanceSizeOffset() const;
|
|
|
|
Size getInstanceAlignMaskOffset() const;
|
|
|
|
/// Returns the start of the vtable in the class metadata.
|
|
Offset getVTableOffset(IRGenFunction &IGF) const;
|
|
|
|
/// Returns the size of the vtable, in words.
|
|
unsigned getVTableSize() const {
|
|
return MethodInfos.size();
|
|
}
|
|
|
|
MethodInfo getMethodInfo(IRGenFunction &IGF, SILDeclRef method) const;
|
|
|
|
/// Assuming that the given method is at a static offset in the metadata,
|
|
/// return that static offset.
|
|
///
|
|
/// DEPRECATED: callers should be updated to handle this in a
|
|
/// more arbitrary fashion.
|
|
Size getStaticMethodOffset(SILDeclRef method) const;
|
|
|
|
Offset getFieldOffset(IRGenFunction &IGF, VarDecl *field) const;
|
|
|
|
/// Assuming that the given field offset is at a static offset in
|
|
/// the metadata, return that static offset.
|
|
///
|
|
/// DEPRECATED: callers should be updated to handle this in a
|
|
/// more arbitrary fashion.
|
|
Size getStaticFieldOffset(VarDecl *field) const;
|
|
|
|
/// Should only be used when emitting the nominal type descriptor.
|
|
Size getRelativeGenericRequirementsOffset() const;
|
|
|
|
Size getStaticFieldOffsetVectorOffset() const;
|
|
Size getRelativeFieldOffsetVectorOffset() const;
|
|
|
|
Size getStaticVTableOffset() const;
|
|
Size getRelativeVTableOffset() const;
|
|
|
|
Offset getFieldOffsetVectorOffset(IRGenFunction &IGF) const;
|
|
|
|
/// If the start of the immediate members is statically known, this
|
|
/// method will return it. Otherwise, it will assert.
|
|
Size getStartOfImmediateMembers() const {
|
|
return StartOfImmediateMembers.getStaticOffset();
|
|
}
|
|
|
|
/// The number of members to add after superclass metadata. The size of
|
|
/// this metadata is the superclass size plus the number of immediate
|
|
/// members in the class itself.
|
|
unsigned getNumImmediateMembers() const {
|
|
return NumImmediateMembers;
|
|
}
|
|
|
|
static bool classof(const MetadataLayout *layout) {
|
|
return layout->getKind() == Kind::Class;
|
|
}
|
|
};
|
|
|
|
/// Layout for enum type metadata.
|
|
class EnumMetadataLayout : public NominalMetadataLayout {
|
|
/// The offset of the payload size field, if there is one.
|
|
StoredOffset PayloadSizeOffset;
|
|
|
|
// TODO: presumably it would be useful to store *something* here
|
|
// for resilience.
|
|
|
|
friend class IRGenModule;
|
|
EnumMetadataLayout(IRGenModule &IGM, EnumDecl *theEnum);
|
|
|
|
public:
|
|
EnumDecl *getDecl() const {
|
|
return cast<EnumDecl>(Nominal);
|
|
}
|
|
|
|
bool hasPayloadSizeOffset() const {
|
|
return PayloadSizeOffset.isValid();
|
|
}
|
|
|
|
Offset getPayloadSizeOffset() const;
|
|
|
|
static bool classof(const MetadataLayout *layout) {
|
|
return layout->getKind() == Kind::Enum;
|
|
}
|
|
};
|
|
|
|
/// Layout for struct type metadata.
|
|
class StructMetadataLayout : public NominalMetadataLayout {
|
|
llvm::DenseMap<VarDecl*, StoredOffset> FieldOffsets;
|
|
|
|
/// The start of the field-offset vector.
|
|
StoredOffset FieldOffsetVector;
|
|
|
|
const StoredOffset &getStoredFieldOffset(VarDecl *field) const {
|
|
auto it = FieldOffsets.find(field);
|
|
assert(it != FieldOffsets.end());
|
|
return it->second;
|
|
}
|
|
|
|
friend class IRGenModule;
|
|
StructMetadataLayout(IRGenModule &IGM, StructDecl *theStruct);
|
|
|
|
public:
|
|
StructDecl *getDecl() const {
|
|
return cast<StructDecl>(Nominal);
|
|
}
|
|
|
|
Offset getFieldOffset(IRGenFunction &IGF, VarDecl *field) const;
|
|
|
|
/// Assuming that the given field offset is at a static offset in
|
|
/// the metadata, return that static offset.
|
|
///
|
|
/// DEPRECATED: callers should be updated to handle this in a
|
|
/// more arbitrary fashion.
|
|
Size getStaticFieldOffset(VarDecl *field) const;
|
|
|
|
Offset getFieldOffsetVectorOffset() const;
|
|
|
|
static bool classof(const MetadataLayout *layout) {
|
|
return layout->getKind() == Kind::Struct;
|
|
}
|
|
};
|
|
|
|
/// Layout for foreign class type metadata.
|
|
class ForeignClassMetadataLayout : public MetadataLayout {
|
|
ClassDecl *Class;
|
|
StoredOffset SuperClassOffset;
|
|
|
|
friend class IRGenModule;
|
|
ForeignClassMetadataLayout(IRGenModule &IGM, ClassDecl *theClass);
|
|
|
|
public:
|
|
StoredOffset getSuperClassOffset() const { return SuperClassOffset; }
|
|
|
|
static bool classof(const MetadataLayout *layout) {
|
|
return layout->getKind() == Kind::ForeignClass;
|
|
}
|
|
};
|
|
|
|
/// Emit the address of the field-offset slot in the given class metadata.
|
|
Address emitAddressOfClassFieldOffset(IRGenFunction &IGF,
|
|
llvm::Value *metadata,
|
|
ClassDecl *theClass,
|
|
VarDecl *field);
|
|
|
|
/// Get the offset to a field offset in the class type metadata.
|
|
///
|
|
/// DEPRECATED: callers should be updated to handle this in a more
|
|
/// arbitrary fashion.
|
|
Size getClassFieldOffsetOffset(IRGenModule &IGM,
|
|
ClassDecl *theClass,
|
|
VarDecl *field);
|
|
|
|
/// Emit the address of the field-offset vector in the given class or struct
|
|
/// metadata.
|
|
Address emitAddressOfFieldOffsetVector(IRGenFunction &IGF,
|
|
llvm::Value *metadata,
|
|
NominalTypeDecl *theDecl);
|
|
|
|
} // end namespace irgen
|
|
} // end namespace swift
|
|
|
|
#endif
|