mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
b46e6cc5b7
This finishes up the functional behavior of <rdar://problem/16736676>. Some QoI remains. Swift SVN r17209
297 lines
10 KiB
C++
297 lines
10 KiB
C++
//===--- ClassMetadataLayout.h - CRTP for class metadata --------*- C++ -*-===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See http://swift.org/LICENSE.txt for license information
|
|
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// A CRTP helper class for class metadata.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_IRGEN_CLASSMETADATALAYOUT_H
|
|
#define SWIFT_IRGEN_CLASSMETADATALAYOUT_H
|
|
|
|
#include "swift/SIL/SILDeclRef.h"
|
|
#include "IRGen.h"
|
|
#include "MetadataLayout.h"
|
|
|
|
namespace swift {
|
|
namespace irgen {
|
|
|
|
class IRGenModule;
|
|
|
|
/// The number of fields in a FullHeapMetadata object.
|
|
const unsigned NumHeapMetadataFields = 3;
|
|
|
|
/// Does the given class method require a different dispatch-table
|
|
/// entry from from all of the methods it overrides? The restrictions
|
|
/// on overriding generally prevent this, but it can happen when a
|
|
/// class overrides a method from a generic class.
|
|
bool doesMethodRequireOverrideEntry(IRGenModule &IGM, AbstractFunctionDecl *fn,
|
|
ResilienceExpansion explosionLevel,
|
|
unsigned uncurryLevel);
|
|
|
|
/// A CRTP class for laying out class metadata. Note that this does
|
|
/// *not* handle the metadata template stuff.
|
|
template <class Impl> class ClassMetadataLayout : public MetadataLayout<Impl> {
|
|
typedef MetadataLayout<Impl> super;
|
|
|
|
protected:
|
|
using super::IGM;
|
|
using super::asImpl;
|
|
|
|
/// The most-derived class.
|
|
ClassDecl *const Target;
|
|
|
|
/// Is the object layout globally resilient at this point?
|
|
bool IsObjectResilient = false;
|
|
|
|
/// Is the metadata layout globally resilient at this point?
|
|
bool IsMetadataResilient = false;
|
|
|
|
ClassMetadataLayout(IRGenModule &IGM, ClassDecl *target)
|
|
: super(IGM), Target(target) {}
|
|
|
|
public:
|
|
void layout() {
|
|
// HeapMetadata header.
|
|
asImpl().addDestructorFunction();
|
|
|
|
// Metadata header.
|
|
super::layout();
|
|
|
|
// ClassMetadata header. In ObjCInterop mode, this must be
|
|
// layout-compatible with an Objective-C class. The superclass
|
|
// pointer is useful regardless of mode, but the rest of the data
|
|
// isn't necessary.
|
|
asImpl().addSuperClass();
|
|
if (IGM.ObjCInterop) {
|
|
asImpl().addClassCacheData();
|
|
asImpl().addClassDataPointer();
|
|
}
|
|
|
|
asImpl().addInstanceSize();
|
|
asImpl().addInstanceAlignMask();
|
|
asImpl().addClassSize();
|
|
asImpl().addClassAddressPoint();
|
|
asImpl().addNominalTypeDescriptor();
|
|
|
|
// Class members.
|
|
addClassMembers(Target);
|
|
}
|
|
|
|
private:
|
|
/// Add fields associated with the given class and its bases.
|
|
void addClassMembers(ClassDecl *theClass) {
|
|
// Add any fields associated with the superclass.
|
|
// NB: We don't apply superclass substitutions to members because we want
|
|
// consistent metadata layout between generic superclasses and concrete
|
|
// subclasses.
|
|
if (Type superclass = theClass->getSuperclass()) {
|
|
addClassMembers(superclass->getClassOrBoundGenericClass());
|
|
}
|
|
|
|
// Add a reference to the parent class, if applicable.
|
|
if (theClass->getDeclContext()->isTypeContext()) {
|
|
asImpl().addParentMetadataRef(theClass);
|
|
}
|
|
|
|
// Add space for the generic parameters, if applicable.
|
|
// Note that we only add references for the immediate parameters;
|
|
// parameters for the parent context are handled by the parent.
|
|
if (auto generics = theClass->getGenericParams()) {
|
|
addGenericClassFields(theClass, *generics);
|
|
}
|
|
|
|
// If there exists a potential context from which the class is
|
|
// resilient, subsequent fields will require indirect offsets.
|
|
if (IGM.isResilient(theClass, ResilienceScope::Universal)) {
|
|
IsObjectResilient = true;
|
|
IsMetadataResilient = true;
|
|
}
|
|
|
|
// Add entries for the methods.
|
|
for (auto member : theClass->getMembers()) {
|
|
// If this is a non-overriding @final member, we don't need table entries.
|
|
if (auto *VD = dyn_cast<ValueDecl>(member))
|
|
if (VD->isFinal() && VD->getOverriddenDecl() == nullptr)
|
|
continue;
|
|
|
|
// Add entries for methods.
|
|
if (auto fn = dyn_cast<FuncDecl>(member)) {
|
|
// Ignore accessors. These get added when their AbstractStorageDecl is
|
|
// visited.
|
|
if (fn->isAccessor())
|
|
continue;
|
|
addMethodEntries(fn);
|
|
} else if (auto ctor = dyn_cast<ConstructorDecl>(member)) {
|
|
// Add entries for constructors.
|
|
addMethodEntries(ctor);
|
|
} else if (auto *asd = dyn_cast<AbstractStorageDecl>(member)) {
|
|
// FIXME: Stored properties shouldn't be represented this way.
|
|
if (!asd->hasAccessorFunctions()) continue;
|
|
|
|
// @NSManaged properties don't have vtable entries.
|
|
if (asd->getAttrs().hasAttribute<NSManagedAttr>()) continue;
|
|
|
|
addMethodEntries(asd->getGetter());
|
|
if (auto *setter = asd->getSetter())
|
|
addMethodEntries(setter);
|
|
}
|
|
}
|
|
|
|
// Add field offsets.
|
|
for (auto member : theClass->getMembers()) {
|
|
if (auto field = dyn_cast<VarDecl>(member))
|
|
if (field->hasStorage())
|
|
updateForFieldSize(field);
|
|
}
|
|
|
|
asImpl().noteStartOfFieldOffsets(theClass);
|
|
for (auto member : theClass->getMembers()) {
|
|
if (auto field = dyn_cast<VarDecl>(member))
|
|
if (field->hasStorage())
|
|
addFieldEntries(field);
|
|
}
|
|
asImpl().noteEndOfFieldOffsets(theClass);
|
|
}
|
|
|
|
/// Notes the beginning of the field offset vector for a particular ancestor
|
|
/// of a generic-layout class.
|
|
void noteStartOfFieldOffsets(ClassDecl *whichClass) {}
|
|
|
|
/// Notes the end of the field offset vector for a particular ancestor
|
|
/// of a generic-layout class.
|
|
void noteEndOfFieldOffsets(ClassDecl *whichClass) {}
|
|
|
|
private:
|
|
/// Add fields related to the generics of this class declaration.
|
|
/// TODO: don't add new fields that are implied by the superclass.
|
|
/// fields. e.g., if B<T> extends A<T>, the witness for T in A's
|
|
/// section should be enough.
|
|
void addGenericClassFields(ClassDecl *theClass,
|
|
const GenericParamList &generics) {
|
|
asImpl().addGenericFields(generics, theClass);
|
|
}
|
|
|
|
void addFieldEntries(VarDecl *field) {
|
|
asImpl().addFieldOffset(field);
|
|
}
|
|
|
|
void updateForFieldSize(VarDecl *field) {
|
|
assert(field->hasStorage());
|
|
|
|
// Update the class layout based on abstract, globally-known
|
|
// characteristics of the type.
|
|
SILType fieldType = IGM.getLoweredType(AbstractionPattern(field->getType()),
|
|
field->getType());
|
|
switch (IGM.classifyTypeSize(fieldType, ResilienceScope::Universal)) {
|
|
case ObjectSize::Fixed:
|
|
return;
|
|
case ObjectSize::Resilient:
|
|
IsObjectResilient = true;
|
|
return;
|
|
case ObjectSize::Dependent:
|
|
IsObjectResilient = true;
|
|
return;
|
|
}
|
|
llvm_unreachable("invalid type size classification");
|
|
}
|
|
|
|
void addMethodEntries(AbstractFunctionDecl *fn) {
|
|
// If the method does not have a vtable entry, don't add any.
|
|
if (!hasKnownVTableEntry(IGM, fn))
|
|
return;
|
|
|
|
// TODO: consider emitting at different explosion levels and
|
|
// uncurryings.
|
|
auto explosionLevel = ResilienceExpansion::Minimal;
|
|
unsigned uncurryLevel = fn->getNaturalArgumentCount() - 1;
|
|
|
|
if (isa<FuncDecl>(fn))
|
|
maybeAddMethod(fn, SILDeclRef::Kind::Func, explosionLevel, uncurryLevel);
|
|
else {
|
|
auto ctor = cast<ConstructorDecl>(fn);
|
|
if (ctor->isRequired())
|
|
maybeAddMethod(fn, SILDeclRef::Kind::Allocator, explosionLevel,
|
|
uncurryLevel);
|
|
maybeAddMethod(fn, SILDeclRef::Kind::Initializer, explosionLevel,
|
|
uncurryLevel);
|
|
}
|
|
}
|
|
|
|
void maybeAddMethod(AbstractFunctionDecl *fn,
|
|
SILDeclRef::Kind kind,
|
|
ResilienceExpansion explosionLevel,
|
|
unsigned uncurryLevel) {
|
|
// If the method overrides something, we don't need a new entry.
|
|
if (fn->getOverriddenDecl()) {
|
|
// Except we do if it differs by abstraction from all the
|
|
// methods it overrides.
|
|
if (!doesMethodRequireOverrideEntry(IGM, fn, explosionLevel,
|
|
uncurryLevel))
|
|
return;
|
|
}
|
|
|
|
// Both static and non-static functions go in the metadata.
|
|
asImpl().addMethod(SILDeclRef(fn, kind, explosionLevel, uncurryLevel));
|
|
}
|
|
};
|
|
|
|
/// An "implementation" of ClassMetadataLayout that just scans through
|
|
/// the metadata layout, maintaining the offset of the next field.
|
|
template <class Impl>
|
|
class ClassMetadataScanner : public ClassMetadataLayout<Impl> {
|
|
typedef ClassMetadataLayout<Impl> super;
|
|
protected:
|
|
Size NextOffset = Size(0);
|
|
|
|
ClassMetadataScanner(IRGenModule &IGM, ClassDecl *target)
|
|
: super(IGM, target) {}
|
|
|
|
public:
|
|
void addMetadataFlags() { addPointer(); }
|
|
void addNominalTypeDescriptor() { addPointer(); }
|
|
void addValueWitnessTable() { addPointer(); }
|
|
void addDestructorFunction() { addPointer(); }
|
|
void addParentMetadataRef(ClassDecl *forClass) { addPointer(); }
|
|
void addSuperClass() { addPointer(); }
|
|
void addInstanceSize() { addInt32(); }
|
|
void addInstanceAlignMask() { addInt32(); }
|
|
void addClassSize() { addInt32(); }
|
|
void addClassAddressPoint() { addInt32(); }
|
|
void addClassCacheData() { addPointer(); addPointer(); }
|
|
void addClassDataPointer() { addPointer(); }
|
|
void addMethod(SILDeclRef fn) { addPointer(); }
|
|
void addFieldOffset(VarDecl *var) { addPointer(); }
|
|
void addGenericArgument(ArchetypeType *argument, ClassDecl *forClass) {
|
|
addPointer();
|
|
}
|
|
void addGenericWitnessTable(ArchetypeType *argument,
|
|
ProtocolDecl *protocol,
|
|
ClassDecl *forClass) {
|
|
addPointer();
|
|
}
|
|
|
|
private:
|
|
// Our layout here assumes that there will never be unclaimed space
|
|
// in the metadata.
|
|
void addPointer() {
|
|
NextOffset += super::IGM.getPointerSize();
|
|
}
|
|
void addInt32() {
|
|
NextOffset += Size(4);
|
|
}
|
|
};
|
|
|
|
} // end namespace irgen
|
|
} // end namespace swift
|
|
|
|
#endif
|