cache_key_t _key; //SEL作为Key

IMP _imp; //函数的内存地址

inline cache_key_t key() const { return _key; }

inline IMP imp() const { return (IMP)_imp; }

inline void setKey(cache_key_t newKey) { _key = newKey; }

inline void setImp(IMP newImp) { _imp = newImp; }

void set(cache_key_t newKey, IMP newImp);

struct bucket_t *_buckets; //数组,其实就是个散列表,里面存放的是bucket_t,数组[bucket_t]

mask_t _mask; //散列表长度-1(数组个数-1)

mask_t _occupied; //已经缓存的方法数量

struct bucket_t *buckets();

mask_t mask();

mask_t occupied();

void incrementOccupied();

void setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask);

void initializeToEmpty();

mask_t capacity();

bool isConstantEmptyCache();

bool canBeFreed();

static size_t bytesForCapacity(uint32_t cap);

static struct bucket_t * endMarker(struct bucket_t *b, uint32_t cap);

void expand();

void reallocate(mask_t oldCapacity, mask_t newCapacity);

struct bucket_t * find(cache_key_t key, id receiver);

static void bad_cache(id receiver, SEL sel, Class isa) __attribute__((noreturn));

uint32_t entsizeAndFlags;

uint32_t count;

Element first;

uint32_t entsize() const {

return entsizeAndFlags & ~FlagMask;

}

uint32_t flags() const {

return entsizeAndFlags & FlagMask;

}

Element& getOrEnd(uint32_t i) const {

assert(i <= count);

return *(Element *)((uint8_t *)&first + i*entsize());

}

Element& get(uint32_t i) const {

assert(i < count);

return getOrEnd(i);

}

size_t byteSize() const {

return sizeof(*this) + (count-1)*entsize();

}

List *duplicate() const {

return (List *)memdup(this, this->byteSize());

}

struct iterator;

const iterator begin() const {

return iterator(*static_cast<const List*>(this), 0);

}

iterator begin() {

return iterator(*static_cast<const List*>(this), 0);

}

const iterator end() const {

return iterator(*static_cast<const List*>(this), count);

}

iterator end() {

return iterator(*static_cast<const List*>(this), count);

}

struct iterator {

uint32_t entsize;

uint32_t index; // keeping track of this saves a divide in operator-

Element* element;

typedef std::random_access_iterator_tag iterator_category;

typedef Element value_type;

typedef ptrdiff_t difference_type;

typedef Element* pointer;

typedef Element& reference;

iterator() { }

iterator(const List& list, uint32_t start = 0)

: entsize(list.entsize())

, index(start)

, element(&list.getOrEnd(start))

{ }

const iterator& operator += (ptrdiff_t delta) {

element = (Element*)((uint8_t *)element + delta*entsize);

index += (int32_t)delta;

return *this;

}

const iterator& operator -= (ptrdiff_t delta) {

element = (Element*)((uint8_t *)element - delta*entsize);

index -= (int32_t)delta;

return *this;

}

const iterator operator + (ptrdiff_t delta) const {

return iterator(*this) += delta;

}

const iterator operator - (ptrdiff_t delta) const {

return iterator(*this) -= delta;

}

iterator& operator ++ () { *this += 1; return *this; }

iterator& operator -- () { *this -= 1; return *this; }

iterator operator ++ (int) {

iterator result(*this); *this += 1; return result;

}

iterator operator -- (int) {

iterator result(*this); *this -= 1; return result;

}

ptrdiff_t operator - (const iterator& rhs) const {

return (ptrdiff_t)this->index - (ptrdiff_t)rhs.index;

}

Element& operator * () const { return *element; }

Element* operator -> () const { return element; }

operator Element& () const { return *element; }

bool operator == (const iterator& rhs) const {

return this->element == rhs.element;

}

bool operator != (const iterator& rhs) const {

return this->element != rhs.element;

}

bool operator < (const iterator& rhs) const {

return this->element < rhs.element;

}

bool operator > (const iterator& rhs) const {

return this->element > rhs.element;

}

};

SEL name; // 方法名|函数名

const char *types; // 字符串编码（返回值类型、参数类型)

IMP imp; // 指向函数的指针(函数地址)

struct SortBySELAddress :

public std::binary_function<const method_t&,

const method_t&, bool>

{

bool operator() (const method_t& lhs,

const method_t& rhs)

{ return lhs.name < rhs.name; }

};

#if __x86_64__

// *offset was originally 64-bit on some x86_64 platforms.

// We read and write only 32 bits of it.

// Some metadata provides all 64 bits. This is harmless for unsigned

// little-endian values.

// Some code uses all 64 bits. class_addIvar() over-allocates the

// offset for their benefit.

#endif

int32_t *offset;

const char *name;

const char *type;

// alignment is sometimes -1; use alignment() instead

uint32_t alignment_raw;

uint32_t size;

uint32_t alignment() const {

if (alignment_raw == ~(uint32_t)0) return 1U << WORD_SHIFT;

return 1 << alignment_raw;

}

bool isFixedUp() const;

void setFixedUp();

uint32_t indexOfMethod(const method_t *meth) const {

uint32_t i =

(uint32_t)(((uintptr_t)meth - (uintptr_t)this) / entsize());

assert(i < count);

return i;

}

bool containsIvar(Ivar ivar) const {

return (ivar >= (Ivar)&*begin() && ivar < (Ivar)&*end());

}

const char *mangledName;

struct protocol_list_t *protocols;

method_list_t *instanceMethods;

method_list_t *classMethods;

method_list_t *optionalInstanceMethods;

method_list_t *optionalClassMethods;

property_list_t *instanceProperties;

uint32_t size; // sizeof(protocol_t)

uint32_t flags;

// Fields below this point are not always present on disk.

const char **_extendedMethodTypes;

const char *_demangledName;

property_list_t *_classProperties;

const char *demangledName();

const char *nameForLogging() {

return demangledName();

}

bool isFixedUp() const;

void setFixedUp();

# define HAS_FIELD(f) (size >= offsetof(protocol_t, f) + sizeof(f))

bool hasExtendedMethodTypesField() const {

return HAS_FIELD(_extendedMethodTypes);

}

bool hasDemangledNameField() const {

return HAS_FIELD(_demangledName);

}

bool hasClassPropertiesField() const {

return HAS_FIELD(_classProperties);

}

# undef HAS_FIELD

const char **extendedMethodTypes() const {

return hasExtendedMethodTypesField() ? _extendedMethodTypes : nil;

}

property_list_t *classProperties() const {

return hasClassPropertiesField() ? _classProperties : nil;

}

// count is 64-bit by accident.

uintptr_t count;

protocol_ref_t list[0]; // variable-size

size_t byteSize() const {

return sizeof(*this) + count*sizeof(list[0]);

}

protocol_list_t *duplicate() const {

return (protocol_list_t *)memdup(this, this->byteSize());

}

typedef protocol_ref_t* iterator;

typedef const protocol_ref_t* const_iterator;

const_iterator begin() const {

return list;

}

iterator begin() {

return list;

}

const_iterator end() const {

return list + count;

}

iterator end() {

return list + count;

}

uint32_t count;

#if __LP64__

uint32_t reserved;

#endif

locstamped_category_t list[0];

uint32_t flags;

uint32_t instanceStart;

uint32_t instanceSize; //实例对象占用的内存空间

#ifdef __LP64__

uint32_t reserved;

#endif

const uint8_t * ivarLayout;

const char * name; //类名称

method_list_t * baseMethodList; //方法列表 一维数组[method_t]

protocol_list_t * baseProtocols; //协议列表 一维数组[protocol_t]

const ivar_list_t * ivars; //成员变量列表 一维数组[ivar_t]

const uint8_t * weakIvarLayout;

property_list_t *baseProperties; //属性列表 [property_t]一维数组

method_list_t *baseMethods() const {

return baseMethodList;

}

struct array_t {

uint32_t count;

List* lists[0];

static size_t byteSize(uint32_t count) {

return sizeof(array_t) + count*sizeof(lists[0]);

}

size_t byteSize() {

return byteSize(count);

}

};

protected:

class iterator {

List **lists;

List **listsEnd;

typename List::iterator m, mEnd;

public:

iterator(List **begin, List **end)

: lists(begin), listsEnd(end)

{

if (begin != end) {

m = (*begin)->begin();

mEnd = (*begin)->end();

}

}

const Element& operator * () const {

return *m;

}

Element& operator * () {

return *m;

}

bool operator != (const iterator& rhs) const {

if (lists != rhs.lists) return true;

if (lists == listsEnd) return false; // m is undefined

if (m != rhs.m) return true;

return false;

}

const iterator& operator ++ () {

assert(m != mEnd);

m++;

if (m == mEnd) {

assert(lists != listsEnd);

lists++;

if (lists != listsEnd) {

m = (*lists)->begin();

mEnd = (*lists)->end();

}

}

return *this;

}

};

private:

union {

List* list;

uintptr_t arrayAndFlag;

};

bool hasArray() const {

return arrayAndFlag & 1;

}

array_t *array() {

return (array_t *)(arrayAndFlag & ~1);

}

void setArray(array_t *array) {

arrayAndFlag = (uintptr_t)array | 1;

}

public:

uint32_t count() {

uint32_t result = 0;

for (auto lists = beginLists(), end = endLists();

lists != end;

++lists)

{

result += (*lists)->count;

}

return result;

}

iterator begin() {

return iterator(beginLists(), endLists());

}

iterator end() {

List **e = endLists();

return iterator(e, e);

}

uint32_t countLists() {

if (hasArray()) {

return array()->count;

} else if (list) {

return 1;

} else {

return 0;

}

}

List** beginLists() {

if (hasArray()) {

return array()->lists;

} else {

return &list;

}

}

List** endLists() {

if (hasArray()) {

return array()->lists + array()->count;

} else if (list) {

return &list + 1;

} else {

return &list;

}

}

// ⚠️：dyld加载第9⃣️步(系统通过内存移动和内存拷贝将分类信息添加到类信息中)

void attachLists(List* const * addedLists, uint32_t addedCount) {

if (addedCount == 0) return;

//array()->lists: 类对象原来的方法列表

if (hasArray()) {

// many lists -> many lists

uint32_t oldCount = array()->count; //原来类对象中方法列表数组的元素个数

uint32_t newCount = oldCount + addedCount; //新数组元素个数 = 类原来元素个数 + 分类中元素个数

setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));

array()->count = newCount;

// 内存移动，将原来的地址向后移动addedCount的大小，即将类对象中的方法列表数组地址向后移动

memmove(array()->lists + addedCount, array()->lists,

oldCount * sizeof(array()->lists[0]));

//内存拷贝 将分类中的方法列表拷贝到内存移动腾空后的内存空间

memcpy(array()->lists, addedLists,

addedCount * sizeof(array()->lists[0]));

//⚠️通过内存移动和内存拷贝，分类的方法就位于类对象方法的前面了，所以分类和类有相同方法时，首先调用的就是分类中的方法

}

else if (!list && addedCount == 1) {

// 0 lists -> 1 list

list = addedLists[0];

}

else {

// 1 list -> many lists

List* oldList = list;

uint32_t oldCount = oldList ? 1 : 0;

uint32_t newCount = oldCount + addedCount;

setArray((array_t *)malloc(array_t::byteSize(newCount)));

array()->count = newCount;

if (oldList) array()->lists[addedCount] = oldList;

memcpy(array()->lists, addedLists,

addedCount * sizeof(array()->lists[0]));

}

}

void tryFree() {

if (hasArray()) {

for (uint32_t i = 0; i < array()->count; i++) {

try_free(array()->lists[i]);

}

try_free(array());

}

else if (list) {

try_free(list);

}

}

template<typename Result>

Result duplicate() {

Result result;

if (hasArray()) {

array_t *a = array();

result.setArray((array_t *)memdup(a, a->byteSize()));

for (uint32_t i = 0; i < a->count; i++) {

result.array()->lists[i] = a->lists[i]->duplicate();

}

} else if (list) {

result.list = list->duplicate();

} else {

result.list = nil;

}

return result;

}

public list_array_tt<method_t, method_list_t>

{

typedef list_array_tt<method_t, method_list_t> Super;

public:

method_list_t **beginCategoryMethodLists() {

return beginLists();

}

method_list_t **endCategoryMethodLists(Class cls);

method_array_t duplicate() {

return Super::duplicate<method_array_t>();

}

public list_array_tt<property_t, property_list_t>

{

typedef list_array_tt<property_t, property_list_t> Super;

public:

property_array_t duplicate() {

return Super::duplicate<property_array_t>();

}

public list_array_tt<protocol_ref_t, protocol_list_t>

{

typedef list_array_tt<protocol_ref_t, protocol_list_t> Super;

public:

protocol_array_t duplicate() {

return Super::duplicate<protocol_array_t>();

}

// Be warned that Symbolication knows the layout of this structure.

uint32_t flags;

uint32_t version;

const class_ro_t *ro; //存放在编译期就已经确定的类信息，不可修改

method_array_t methods; //方法列表：二维数组 [[method_t]]

property_array_t properties; //属性列表：二维数组 [[property_t]]

protocol_array_t protocols; //协议列表: 二维数组[[protocol_t]]

Class firstSubclass;

Class nextSiblingClass;

char *demangledName;

#if SUPPORT_INDEXED_ISA

uint32_t index;

#endif

void setFlags(uint32_t set)

{

OSAtomicOr32Barrier(set, &flags);

}

void clearFlags(uint32_t clear)

{

OSAtomicXor32Barrier(clear, &flags);

}

// set and clear must not overlap

void changeFlags(uint32_t set, uint32_t clear)

{

assert((set & clear) == 0);

uint32_t oldf, newf;

do {

oldf = flags;

newf = (oldf | set) & ~clear;

} while (!OSAtomicCompareAndSwap32Barrier(oldf, newf, (volatile int32_t *)&flags));

}

// Values are the FAST_ flags above.

uintptr_t bits;

bool getBit(uintptr_t bit)

{

return bits & bit;

}

#if FAST_ALLOC

static uintptr_t updateFastAlloc(uintptr_t oldBits, uintptr_t change)

{

if (change & FAST_ALLOC_MASK) {

if (((oldBits & FAST_ALLOC_MASK) == FAST_ALLOC_VALUE) &&

((oldBits >> FAST_SHIFTED_SIZE_SHIFT) != 0))

{

oldBits |= FAST_ALLOC;

} else {

oldBits &= ~FAST_ALLOC;

}

}

return oldBits;

}

#else

static uintptr_t updateFastAlloc(uintptr_t oldBits, uintptr_t change) {

return oldBits;

}

#endif

void setBits(uintptr_t set)

{

uintptr_t oldBits;

uintptr_t newBits;

do {

oldBits = LoadExclusive(&bits);

newBits = updateFastAlloc(oldBits | set, set);

} while (!StoreReleaseExclusive(&bits, oldBits, newBits));

}

void clearBits(uintptr_t clear)

{

uintptr_t oldBits;

uintptr_t newBits;

do {

oldBits = LoadExclusive(&bits);

newBits = updateFastAlloc(oldBits & ~clear, clear);

} while (!StoreReleaseExclusive(&bits, oldBits, newBits));

}

class_rw_t* data() {

return (class_rw_t *)(bits & FAST_DATA_MASK);

}

void setData(class_rw_t *newData)

{

assert(!data() || (newData->flags & (RW_REALIZING | RW_FUTURE)));

// Set during realization or construction only. No locking needed.

// Use a store-release fence because there may be concurrent

// readers of data and data's contents.

uintptr_t newBits = (bits & ~FAST_DATA_MASK) | (uintptr_t)newData;

atomic_thread_fence(memory_order_release);

bits = newBits;

}

bool hasDefaultRR() {

return getBit(FAST_HAS_DEFAULT_RR);

}

void setHasDefaultRR() {

setBits(FAST_HAS_DEFAULT_RR);

}

void setHasCustomRR() {

clearBits(FAST_HAS_DEFAULT_RR);

}

#if FAST_HAS_DEFAULT_AWZ

bool hasDefaultAWZ() {

return getBit(FAST_HAS_DEFAULT_AWZ);

}

void setHasDefaultAWZ() {

setBits(FAST_HAS_DEFAULT_AWZ);

}

void setHasCustomAWZ() {

clearBits(FAST_HAS_DEFAULT_AWZ);

}

#else

bool hasDefaultAWZ() {

return data()->flags & RW_HAS_DEFAULT_AWZ;

}

void setHasDefaultAWZ() {

data()->setFlags(RW_HAS_DEFAULT_AWZ);

}

void setHasCustomAWZ() {

data()->clearFlags(RW_HAS_DEFAULT_AWZ);

}

#endif

#if FAST_HAS_CXX_CTOR

bool hasCxxCtor() {

return getBit(FAST_HAS_CXX_CTOR);

}

void setHasCxxCtor() {

setBits(FAST_HAS_CXX_CTOR);

}

#else

bool hasCxxCtor() {

return data()->flags & RW_HAS_CXX_CTOR;

}

void setHasCxxCtor() {

data()->setFlags(RW_HAS_CXX_CTOR);

}

#endif

#if FAST_HAS_CXX_DTOR

bool hasCxxDtor() {

return getBit(FAST_HAS_CXX_DTOR);

}

void setHasCxxDtor() {

setBits(FAST_HAS_CXX_DTOR);

}

#else

bool hasCxxDtor() {

return data()->flags & RW_HAS_CXX_DTOR;

}

void setHasCxxDtor() {

data()->setFlags(RW_HAS_CXX_DTOR);

}

#endif