// Apple malloc is always 16-byte aligned. #define MALLOC_ALIGN_MASK 15// When alignMask == ~(size_t(0)), allocation uses the "default"// _swift_MinAllocationAlignment. This is different than calling swift_slowAlloc// with `alignMask == _swift_MinAllocationAlignment - 1` because it forces// the use of AlignedAlloc. This allows manually allocated to memory to always// be deallocated with AlignedFree without knowledge of its original allocation// alignment.//// For alignMask > (_minAllocationAlignment-1)// i.e. alignment == 0 || alignment > _minAllocationAlignment:// The runtime must use AlignedAlloc, and the standard library must// deallocate using an alignment that meets the same condition.//// For alignMask <= (_minAllocationAlignment-1)// i.e. 0 < alignment <= _minAllocationAlignment:// The runtime may use either malloc or AlignedAlloc, and the standard library// must deallocate using an identical alignment.//堆中拓荒空间（空间大小，内存对齐大小）void *swift::swift_slowAlloc(size_t size, size_t alignMask){
void *p;
// This check also forces "default" alignment to use AlignedAlloc.// 内存对其大小 <= 15 ：MAlloc运用默认的内存空间拓荒空间，也是16字节对齐if (alignMask <= MALLOC_ALIGN_MASK) {
#if defined(__APPLE__) && SWIFT_STDLIB_HAS_DARWIN_LIBMALLOC
p = malloc_zone_malloc(DEFAULT_ZONE(), size);
#else
p = malloc(size);
#endif
} else { // 内存对齐大小 > 15 ： MAlloc运用传入的内存大小进行拓荒，也是外部传入的字节对齐size_t alignment = (alignMask == ~(size_t(0)))
? _swift_MinAllocationAlignment
: alignMask + 1;
p = AlignedAlloc(size, alignment);
}
if (!p) swift::crash("Could not allocate memory.");
return p;
}
/// Kinds of Swift metadata records. Some of these are types, some/// aren't.
enum classMetadataKind : 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,
};
template <>
inline constClassMetadata *Metadata::getClassObject() const {
switch (getKind()) {
caseMetadataKind::Class: {//假如kind是class// Native Swift class metadata is also the class object.//将当时指针强转为ClassMetadata类型return static_cast<constClassMetadata *>(this);
}
#ifSWIFT_OBJC_INTEROPcaseMetadataKind::ObjCClassWrapper: {
// Objective-C class objects are referenced by their Swift metadata wrapper.
auto wrapper = static_cast<constObjCClassWrapperMetadata *>(this);
return wrapper->Class;
}
#endif
// Other kinds of types don't have class objects.default:
return nullptr;
}
}
/// The portion of a class metadata object that is compatible with/// all classes, even non-Swift ones.
template <typename Runtime>
struct TargetAnyClassMetadata : public TargetHeapMetadata<Runtime> {
using StoredPointer = typename Runtime::StoredPointer;
using StoredSize = typename Runtime::StoredSize;
using TargetClassMetadata = TargetClassMetadataType<Runtime>;
protected:
constexpr TargetAnyClassMetadata(
//isa信息TargetAnyClassMetadataObjCInterop<Runtime> *isa,
//superclass信息TargetClassMetadata *superclass)
: TargetHeapMetadata<Runtime>(isa), Superclass(superclass) {}
public:
constexpr TargetAnyClassMetadata(TargetClassMetadata *superclass)
: TargetHeapMetadata<Runtime>(MetadataKind::Class),
Superclass(superclass) {}
// Note that ObjC classes do not have a metadata header./// The metadata for the superclass. This is null for the root class.TargetSignedPointer<Runtime, constTargetClassMetadata *
__ptrauth_swift_objc_superclass>
Superclass;
/// Is this object a valid swift type metadata? That is, can it be/// safely downcast to ClassMetadata?
bool isTypeMetadata() const {
returntrue;
}
/// A different perspective on the same bit.
bool isPureObjC() const {
return !isTypeMetadata();
}
};
