Category也就是分类，可以在没有类定义的情况下为现有类添加方法、属性、协议，众所周知是不能增加成员变量的，但是是可以通过关联对象给类增加的。

struct category_t {
    const char *name;
    classref_t cls;
    WrappedPtr<method_list_t, method_list_t::Ptrauth> instanceMethods;
    WrappedPtr<method_list_t, method_list_t::Ptrauth> classMethods;
    struct protocol_list_t *protocols;
    struct property_list_t *instanceProperties;
    // Fields below this point are not always present on disk.
    struct property_list_t *_classProperties;

    method_list_t *methodsForMeta(bool isMeta) {
        if (isMeta) return classMethods;
        else return instanceMethods;
    }

    property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
    
    protocol_list_t *protocolsForMeta(bool isMeta) {
        if (isMeta) return nullptr;
        else return protocols;
    }
};

可以看出，这里面只有方法、协议、属性列表，并没有存储成员变量的地方。所以就用到了关联对象去存储这些数据。

关联对象主要通过以下三个函数进行实现

//设置
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
    _object_set_associative_reference(object, key, value, policy);
}
//获取
id objc_getAssociatedObject(id object, const void *key)
{
    return _object_get_associative_reference(object, key);
}
//删除
void objc_removeAssociatedObjects(id object) 
{
    if (object && object->hasAssociatedObjects()) {
        _object_remove_associations(object, /*deallocating*/false);
    }
}

先看下objc_AssociationPolicy 策略的定义

typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
    OBJC_ASSOCIATION_ASSIGN = 0,           /**< Specifies a weak reference to the associated object. */
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, /**< Specifies a strong reference to the associated object. 
                                            *   The association is not made atomically. */
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,   /**< Specifies that the associated object is copied. 
                                            *   The association is not made atomically. */
    OBJC_ASSOCIATION_RETAIN = 01401,       /**< Specifies a strong reference to the associated object.
                                            *   The association is made atomically. */
    OBJC_ASSOCIATION_COPY = 01403          /**< Specifies that the associated object is copied.
                                            *   The association is made atomically. */
};

这里分别提供了weak、strong、copy对应的策略。怎么使用这里就不多说明了，主要看下内部是怎么实现的。

objc_setAssociatedObject方法里面调用了object_set_associative_reference方法，方法比较长，一段段分析

void
_object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)
{
    // This code used to work when nil was passed for object and key. Some code
    // probably relies on that to not crash. Check and handle it explicitly.
    // rdar://problem/44094390
    if (!object && !value) return;

    if (object->getIsa()->forbidsAssociatedObjects())
        _objc_fatal("objc_setAssociatedObject called on instance (%p) of class %s which does not allow associated objects", object, object_getClassName(object));

    DisguisedPtr<objc_object> disguised{(objc_object *)object};
    ObjcAssociation association{policy, value};

    // retain the new value (if any) outside the lock.
    association.acquireValue();

先判断对象和设置的值是否为空，空的话直接返回。再判断对象是否禁止设置关联对象。DisguisedPtr类的disguised指针，DisguisedPtr是为了是为了躲过内存泄漏工具的检查。然后用policy和valus初始化ObjcAssociation类型对象，再调用对象的acquireValue方法。

class ObjcAssociation {
    uintptr_t _policy;
    id _value;
    省略部分代码
    inline void acquireValue() {
            if (_value) {
                switch (_policy & 0xFF) {
                case OBJC_ASSOCIATION_SETTER_RETAIN:
                    _value = objc_retain(_value);
                    break;
                case OBJC_ASSOCIATION_SETTER_COPY:
                    _value = ((id(*)(id, SEL))objc_msgSend)(_value, @selector(copy));
                    break;
                }
            }
        }
}

可以看到，这里是根据策略执行value的retain还是copy。

bool isFirstAssociation = false;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());

        if (value) {
            auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
            if (refs_result.second) {
                /* it's the first association we make */
                isFirstAssociation = true;
            }

            /* establish or replace the association */
            auto &refs = refs_result.first->second;
            auto result = refs.try_emplace(key, std::move(association));
            if (!result.second) {
                association.swap(result.first->second);
            }
        } else {
            auto refs_it = associations.find(disguised);
            if (refs_it != associations.end()) {
                auto &refs = refs_it->second;
                auto it = refs.find(key);
                if (it != refs.end()) {
                    association.swap(it->second);
                    refs.erase(it);
                    if (refs.size() == 0) {
                        associations.erase(refs_it);

                    }
                }
            }
        }
    }

1、定义是否是第一次设置关联对象isFirstAssociation = false

2、获取AssociationsManager，然后通过manager获取全局AssociationsHashMap

class AssociationsManager {
    using Storage = ExplicitInitDenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap>;
    static Storage _mapStorage;

public:
    AssociationsManager()   { AssociationsManagerLock.lock(); }
    ~AssociationsManager()  { AssociationsManagerLock.unlock(); }

    AssociationsHashMap &get() {
        return _mapStorage.get();
    }

    static void init() {
        _mapStorage.init();
    }
};

可以看出AssociationsHashMap是static的 Storage获取的，全局唯一的。

3、关联对象如果存在，从AssociationsHashMap中通过对象指针获取ObjectAssociationMap

template <typename... Ts>
std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
    BucketT *TheBucket;
    if (LookupBucketFor(Key, TheBucket))
      return std::make_pair(
               makeIterator(TheBucket, getBucketsEnd(), true),
               false); // Already in map.

    // Otherwise, insert the new element.
    TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
    return std::make_pair(
             makeIterator(TheBucket, getBucketsEnd(), true),
             true);
}

如果之前设置过，通过查找获取后返回，不存在创建后返回。

4、判断如果是第一次设置关联对象，将isFirstAssociation赋值true

5、再将ObjcAssociation存储到ObjectAssociationMap中，以key作为键值。

6、如果value不存在的时候，通过对象指针从hashmap中获取map，然后再通过key从map中获取object，如果存在就erase，如果map的size为空也erase掉。

    if (isFirstAssociation)
        object->setHasAssociatedObjects();

    // release the old value (outside of the lock).
    association.releaseHeldValue();
}

这部分就比较简单了，如果是第一次设置关联对象，就把对象的 newisa.has_assoc设置为true，方便对象释放的时候同时释放关联对象，最后release旧的value。

再看下objc_getAssociatedObject里面是调用了_object_get_associative_reference方法

id
_object_get_associative_reference(id object, const void *key)
{
    ObjcAssociation association{};

    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            ObjectAssociationMap &refs = i->second;
            ObjectAssociationMap::iterator j = refs.find(key);
            if (j != refs.end()) {
                association = j->second;
                association.retainReturnedValue();
            }
        }
    }

    return association.autoreleaseReturnedValue();
}

这里很直观的可以看出，先声明了个ObjcAssociation，然后创建AssociationsManager，再获取AssociationsHashMap，再通过AssociationsHashMap以object为key获取ObjectAssociationMap，再以key获取ObjcAssociation，然后返回获取到的值。

综上可看出，存储结构如下图所示

AutoreleasePool(自动释放池)是Objective-C中的一种内存自动回收机制，它可以延迟加入AutoreleasePool中的变量release的时机。

@autoreleasepool { ... }可以通过 clang -rewrite-objc 命令转成C++代码如下

/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

}

然后可以从objc源码中找到__AtAutoreleasePool的定义

struct __AtAutoreleasePool {
  __AtAutoreleasePool() {
      atautoreleasepoolobj = objc_autoreleasePoolPush();
  }
  ~__AtAutoreleasePool() {
      objc_autoreleasePoolPop(atautoreleasepoolobj);
  }
  void * atautoreleasepoolobj;
};

这个结构体先通过构造函数构(__AtAutoreleasePool)创建一个栈变量__autoreleasepool，然后在大括号结束的时候通过析构函数(~__AtAutoreleasePool)销毁__autoreleasepool变量，这里利用了变量声明和自动变量在代码块结束后自动销毁的特性。所以@autoreleasepool { ... }相当于以下代码

{
   atautoreleasepoolobj = objc_autoreleasePoolPush();
   //AutoreleasePool中的其他代码
   objc_autoreleasePoolPop(atautoreleasepoolobj);
}

这里分别调用了 objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 函数。在源码中可以找到函数实现

void *objc_autoreleasePoolPush(void)
{
    return AutoreleasePoolPage::push();
}

void objc_autoreleasePoolPop(void *ctxt)
{
    AutoreleasePoolPage::pop(ctxt);
}

可以看到这里分别调用了AutoreleasePoolPage的push和pop类方法。而AutoreleasePoolPage继承于AutoreleasePoolPageData的结构体。

struct AutoreleasePoolPageData
{
	magic_t const magic;
	__unsafe_unretained id *next;
	pthread_t const thread;
	AutoreleasePoolPage * const parent;
	AutoreleasePoolPage *child;
	uint32_t const depth;
	uint32_t hiwat;

	AutoreleasePoolPageData(__unsafe_unretained id* _next, pthread_t _thread, AutoreleasePoolPage* _parent, uint32_t _depth, uint32_t _hiwat)
		: magic(), next(_next), thread(_thread),
		  parent(_parent), child(nil),
		  depth(_depth), hiwat(_hiwat)
	{
	}
};
class AutoreleasePoolPage : private AutoreleasePoolPageData
{
    //省略
}

下面看下AutoreleasePoolPageData每一个成员变量的作用

magic：magic_t类型，是用来检查 AutoreleasePoolPage的内存没有损坏

struct magic_t {
	static const uint32_t M0 = 0xA1A1A1A1;
#   define M1 "AUTORELEASE!"
	static const size_t M1_len = 12;
	uint32_t m[4];

	magic_t() {
		OBJC_ASSERT(M1_len == strlen(M1));
		OBJC_ASSERT(M1_len == 3 * sizeof(m[1]));

		m[0] = M0;
		strncpy((char *)&m[1], M1, M1_len);
	}

	~magic_t() {
		volatile uint64_t *p = (volatile uint64_t *)m;
		p[0] = 0; p[1] = 0;
	}
}

可以看出构造的时候

m[0]= 0xA1A1A1A1 
m[1-3] = AUTORELEASE!

检查的时候方法如下，判断第一个字节是0xA1A1A1A1, 后面三个字节是AUTORELEASE! 如下

bool check() const {
    return (m[0] == M0 && 0 == strncmp((char *)&m[1], M1, M1_len));
}

next：类型是 __unsafe_unretained id *，存放的是下一个被 autorelease 对象的指针存放的地址。

thread：自动释放池对应的线程。

parent和child：用来保存前一个 AutoreleasePoolPage 和后一个 AutoreleasePoolPage，双向链表结构。

depth：链表长度

hiwat：一个在 DEBUG 时才有用的参数，表示最高记录过多少对象。

下面看下这些变量是怎么存储的，会发现AutoreleasePoolPage 重载了 new 操作符

#define PAGE_MIN_SHIFT          12
#define PAGE_MIN_SIZE           (1 << PAGE_MIN_SHIFT)
static size_t const SIZE = PAGE_MIN_SIZE;

static void * operator new(size_t size) {
    return malloc_zone_memalign(malloc_default_zone(), SIZE, SIZE);
}

这样一个新的AutoreleasePoolPage对象就需要 SIZE大小，可以看出SIZE的大小为4096，而AutoreleasePoolPage的成员变量大小加在一起也只有 56 字节，剩下多出的就是存储autorelease对象的地方。如下图

图片中 begin、end方法定义如下

id * begin() {
    return (id *) ((uint8_t *)this+sizeof(*this));
}

id * end() {
    return (id *) ((uint8_t *)this+SIZE);
}

接下来看AutoreleasePoolPage::push()方法，定义如下

static inline void *push() 
{
    id *dest;
    if (slowpath(DebugPoolAllocation)) {
        // Each autorelease pool starts on a new pool page.
        dest = autoreleaseNewPage(POOL_BOUNDARY);
    } else {
        dest = autoreleaseFast(POOL_BOUNDARY);
    }
    ASSERT(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
    return dest;
}

当slowpath(DebugPoolAllocation)的时候，会调用autoreleaseNewPage。也就是当Xcode中设置环境变量OBJC_DEBUG_POOL_ALLOCATION为YES的时候。

OPTION( DebugPoolAllocation,      OBJC_DEBUG_POOL_ALLOCATION,      "halt when autorelease pools are popped out of order, and allow heap debuggers to track autorelease pools")

EMPTY_POOL_PLACEHOLDER和POOL_BOUNDARY的定义如下

#   define EMPTY_POOL_PLACEHOLDER ((id*)1)
#   define POOL_BOUNDARY nil

其他时候调用autoreleaseFast

static __attribute__((noinline))
id *autoreleaseNewPage(id obj)
{
    AutoreleasePoolPage *page = hotPage();
    if (page) return autoreleaseFullPage(obj, page);
    else return autoreleaseNoPage(obj);
}
static inline id *autoreleaseFast(id obj)
{
    AutoreleasePoolPage *page = hotPage();
    if (page && !page->full()) {
        return page->add(obj);
    } else if (page) {
        return autoreleaseFullPage(obj, page);
    } else {
        return autoreleaseNoPage(obj);
    }
}

两个方法不同的地方是，Debug的时候会返回一个全新的AutoreleasePoolPage。

看hotPage方法如下

static inline AutoreleasePoolPage *hotPage() 
{
    AutoreleasePoolPage *result = (AutoreleasePoolPage *)
        tls_get_direct(key);
    if ((id *)result == EMPTY_POOL_PLACEHOLDER) return nil;
    if (result) result->fastcheck();
    return result;
}

这里是从tls中获取之前存入的page，tls是线程局部存储(Thread Local Storage)的缩写。如果是EMPTY_POOL_PLACEHOLDER的话，返回nil，后面会具体说明其作用。存入的方法如下

static inline void setHotPage(AutoreleasePoolPage *page) 
{
    if (page) page->fastcheck();
    tls_set_direct(key, (void *)page);
}

继续看autoreleaseFullPage方法

static __attribute__((noinline))
id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
{
    // The hot page is full. 
    // Step to the next non-full page, adding a new page if necessary.
    // Then add the object to that page.
    ASSERT(page == hotPage());
    ASSERT(page->full()  ||  DebugPoolAllocation);

    do {
        if (page->child) page = page->child;
        else page = new AutoreleasePoolPage(page);
    } while (page->full());

    setHotPage(page);
    return page->add(obj);
}

意思是，初始化个Page，添加为现有Page的子节点，再设置成hotPage，然后添加对象。

最后是autoreleaseNoPage

    static __attribute__((noinline))
    id *autoreleaseNoPage(id obj)
    {
        // "No page" could mean no pool has been pushed
        // or an empty placeholder pool has been pushed and has no contents yet
        ASSERT(!hotPage());

        bool pushExtraBoundary = false;
        if (haveEmptyPoolPlaceholder()) {
            // We are pushing a second pool over the empty placeholder pool
            // or pushing the first object into the empty placeholder pool.
            // Before doing that, push a pool boundary on behalf of the pool 
            // that is currently represented by the empty placeholder.
            pushExtraBoundary = true;
        }
        else if (obj != POOL_BOUNDARY  &&  DebugMissingPools) {
            // We are pushing an object with no pool in place, 
            // and no-pool debugging was requested by environment.
            _objc_inform("MISSING POOLS: (%p) Object %p of class %s "
                         "autoreleased with no pool in place - "
                         "just leaking - break on "
                         "objc_autoreleaseNoPool() to debug", 
                         objc_thread_self(), (void*)obj, object_getClassName(obj));
            objc_autoreleaseNoPool(obj);
            return nil;
        }
        else if (obj == POOL_BOUNDARY  &&  !DebugPoolAllocation) {
            // We are pushing a pool with no pool in place,
            // and alloc-per-pool debugging was not requested.
            // Install and return the empty pool placeholder.
            return setEmptyPoolPlaceholder();
        }

        // We are pushing an object or a non-placeholder'd pool.

        // Install the first page.
        AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
        setHotPage(page);
        
        // Push a boundary on behalf of the previously-placeholder'd pool.
        if (pushExtraBoundary) {
            page->add(POOL_BOUNDARY);
        }
        
        // Push the requested object or pool.
        return page->add(obj);
    }

可以看出，因为push的时候传的是POOL_BOUNDARY，这里并没有初始化新的page，而是设置了个EMPTY_POOL_PLACEHOLDER。

static inline id* setEmptyPoolPlaceholder()
{
    ASSERT(tls_get_direct(key) == nil);
    tls_set_direct(key, (void *)EMPTY_POOL_PLACEHOLDER);
    return EMPTY_POOL_PLACEHOLDER;
}

等有再有autorelease对象进来的时候，先判断有没有占位符，然后再把初始化page并且设置为hotPage，并把POOL_BOUNDARY添加到其中，最后再添加对象到page中。

对象的autorelease最终是调用到AutoreleasePoolPage的autorelease方法

static inline id autorelease(id obj)
{
    ASSERT(!_objc_isTaggedPointerOrNil(obj));
    id *dest __unused = autoreleaseFast(obj);
#if SUPPORT_AUTORELEASEPOOL_DEDUP_PTRS
    ASSERT(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  (id)((AutoreleasePoolEntry *)dest)->ptr == obj);
#else
    ASSERT(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  *dest == obj);
#endif
    return obj;
}

可以看出，这里主要是调用了autoreleaseFast方法，更上面push的时候调用的方法是一样的，只不过这里obj是对象地址，push的时候是POOL_BOUNDARY。

最后就是pop方法

    static inline void
    pop(void *token)
    {
        AutoreleasePoolPage *page;
        id *stop;
        if (token == (void*)EMPTY_POOL_PLACEHOLDER) {
            // Popping the top-level placeholder pool.
            page = hotPage();
            if (!page) {
                // Pool was never used. Clear the placeholder.
                return setHotPage(nil);
            }
            // Pool was used. Pop its contents normally.
            // Pool pages remain allocated for re-use as usual.
            page = coldPage();
            token = page->begin();
        } else {
            page = pageForPointer(token);
        }

        stop = (id *)token;
        if (*stop != POOL_BOUNDARY) {
            if (stop == page->begin()  &&  !page->parent) {
                // Start of coldest page may correctly not be POOL_BOUNDARY:
                // 1. top-level pool is popped, leaving the cold page in place
                // 2. an object is autoreleased with no pool
            } else {
                // Error. For bincompat purposes this is not 
                // fatal in executables built with old SDKs.
                return badPop(token);
            }
        }

        if (slowpath(PrintPoolHiwat || DebugPoolAllocation || DebugMissingPools)) {
            return popPageDebug(token, page, stop);
        }

        return popPage<false>(token, page, stop);
    }

这里面主要是通过token获取需要pop的Page，真正的操作在popPage方法，模板传值为false，所以去除Debug相关的逻辑

template<bool allowDebug>
static void
popPage(void *token, AutoreleasePoolPage *page, id *stop)
{
    page->releaseUntil(stop);
    if (page->child) {
        // hysteresis: keep one empty child if page is more than half full
        if (page->lessThanHalfFull()) {
            page->child->kill();
        }
        else if (page->child->child) {
            page->child->child->kill();
        }
    }
}

先看下releaseUntil方法中做了什么

void releaseUntil(id *stop) 
{
    // Not recursive: we don't want to blow out the stack 
    // if a thread accumulates a stupendous amount of garbage

    while (this->next != stop) {
        // Restart from hotPage() every time, in case -release 
        // autoreleased more objects
        AutoreleasePoolPage *page = hotPage();

        // fixme I think this `while` can be `if`, but I can't prove it
        while (page->empty()) {
            page = page->parent;
            setHotPage(page);
        }

        page->unprotect();
        AutoreleasePoolEntry* entry = (AutoreleasePoolEntry*) --page->next;
        // create an obj with the zeroed out top byte and release that
        id obj = (id)entry->ptr;
        int count = (int)entry->count;  // grab these before memset
        memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
        page->protect();

        if (obj != POOL_BOUNDARY) {
            // release count+1 times since it is count of the additional
            // autoreleases beyond the first one
            for (int i = 0; i < count + 1; i++) {
                objc_release(obj);
            }
        }
    }
    setHotPage(this);
}

大概逻辑上，向下遍历，然后通过内存平移获取对象，判断如果不是哨兵对象，会调用objc_release的操作。最后设置当前页面为hotPage。

最后看下kill

void kill() 
{
    // Not recursive: we don't want to blow out the stack 
    // if a thread accumulates a stupendous amount of garbage
    AutoreleasePoolPage *page = this;
    while (page->child) page = page->child;

    AutoreleasePoolPage *deathptr;
    do {
        deathptr = page;
        page = page->parent;
        if (page) {
            page->unprotect();
            page->child = nil;
            page->protect();
        }
        delete deathptr;
    } while (deathptr != this);
}

上面是把对象都释放了，这里把不需要的page设置为nil。

综上所述：

1、自动释放池的压栈和出栈，是通过结构体的构造函数和析构函数触发的，压栈调用objc_autoreleasePoolPush函数，出栈调用objc_autoreleasePoolPop函数。

2、自动释放池是一个存储指针的栈结构，指针是一个要释放的对象或者是POOL_BOUNDARY自动释放池边界。

3、池页大小为4096字节，每一页都包含56字节的成员变量，一个Page最多可以容纳 (4096-56) / 8 = 505个autorelease的对象。

可以写代码验证下，写之前要先把工程设置为MRC。

void _objc_autoreleasePoolPrint(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        for (int i = 0; i < 505; i++) {
            NSObject *obj = [[[NSObject alloc] init] autorelease];
        }
        _objc_autoreleasePoolPrint();
    }
    return 0;
}

输入结果如下

objc[11901]: [0x101010000]  ................  PAGE (full)  (cold)
objc[11901]: [0x101010038]  ################  POOL 0x101010038
objc[11901]: [0x101010040]       0x100c277e0  NSObject
objc[11901]: [0x101010048]       0x100c272e0  NSObject
objc[11901]: [0x101010050]       0x100c26ba0  NSObject
objc[11901]: [0x101010058]       0x100c26160  NSObject
......
objc[11927]: [0x10100d000]  ................  PAGE  (hot) 
objc[11927]: [0x10100d038]       0x100ab2920  NSObject

可以看出，第一个是POOL_BOUNDARY，505个对象循环加入到page中，最后一个的时候page满了，所以最后一个加到了新的page中。

本文章只用于学习和交流，转载请注明出处。

玩过越狱手机的应该都了解，iOS的越狱插件是可以为系统或者应用添加一些特色的功能的。越狱插件的开发，已经有完整的工具链，并且插件的加载运行Substrate框架已经为我们做好。

更改应用的功能实现有两种方法，一种是通过反编译工具更改汇编代码后生成新的可执行文件。另一种是写一个动态库，然后注入到可执行文件。第一种适合简单的逻辑修改，毕竟用汇编实现功能是需要很大的工作量的。

第二种要怎么注入呢？了解Mach-O 二进制文件的应该知道，Mach-O 二进制文件Load Commands中的 LC_LOAD_DYLIB 标头告诉 macOS在执行期间要加载哪些动态库 (dylib)。所以我们只需要在二进制文件中添加一条LC_LOAD_DYLIB就可以。而insert_dylib工具已经为我们实现了添加的功能。所以现在唯一需要考虑的就是插件如何开发。

废话不多说，现在就以mac版的迅雷为例开发一款属于我们自己的插件。首先下载最新版本的迅雷(版本5.0.2)。然后用Xcode新建一个macOS下的Framework，如下

新建完目录结构如下，如果有Tests target 不影响后续。

然后新建个.m文件(文件名随意)，把以下代码复制粘贴进去

#import "libThunderPlugin.h"
#import "objc/runtime.h"

void lm_hookMethod(Class originalClass, SEL originalSelector, Class swizzledClass, SEL swizzledSelector) {
    Method originalMethod = class_getInstanceMethod(originalClass, originalSelector);
    Method swizzledMethod = class_getInstanceMethod(swizzledClass, swizzledSelector);
    if(originalMethod && swizzledMethod) {
        method_exchangeImplementations(originalMethod, swizzledMethod);
    }
}

@implementation NSObject (Thunder)
+ (void)hookThunder{
    lm_hookMethod(objc_getClass("XLUserInformation"), @selector(initWithUserInfo:), [self class], @selector(hook_initWithUserInfo:));
    lm_hookMethod(objc_getClass("XLUserInformation"), @selector(updateUserInfo:), [self class], @selector(hook_updateUserInfo:));
}
- (id)hook_initWithUserInfo:(id)arg1{
    return [self hook_initWithUserInfo:[self modify:arg1]];
}
- (void)hook_updateUserInfo:(id)arg1{
    [self hook_updateUserInfo:[self modify:arg1]];
}
- (NSDictionary *)modify:(NSDictionary *)user{
    NSDictionary *vipInfo = [[user objectForKey:@"vipList"] firstObject];
    NSMutableDictionary *mutableVipInfo = [vipInfo mutableCopy];
    [mutableVipInfo setValue:@"1" forKey:@"isVip"];
    [mutableVipInfo setValue:@"20990131" forKey:@"expireDate"];
    [mutableVipInfo setValue:@"4" forKey:@"vasType"];
    NSMutableDictionary *userInfo = [user mutableCopy];
    [userInfo setObject:@[mutableVipInfo] forKey:@"vipList"];
    return userInfo;
}
@end

static void __attribute__((constructor)) initialize(void) {
    [NSObject hookThunder];
}

再把以下代码复制粘贴到.h文件中

@interface XLUserInformation : NSObject
- (void)updateUserInfo:(id)arg1;
- (id)initWithUserInfo:(id)arg1;
@end

后续会说明代码的意思和怎么获取的。以上操作完成后编译运行，会生成一个framework，但是Xcode13把Products隐藏了，并不能很便捷的找到生成的动态库。

这时候我们需要按照以下步骤可以使Products文件显示出来。

1、找到项目工程文件，右键点击libThunderPlugin.xcodeproj -> 选择显示包内容

2、双击打开project.pbxproj文件，在文件中搜索productRefGroup关键字

3、将productRefGroup对应的值改成和mainGroup相同即可。

改完后Xcode会自动刷新，显示出Products目录。

然后右键生成的framework，点击 Show in Finder，然后把framework复制到迅雷的可执行文件同目录下，目录为 /Applications/Thunder.app/Contents/MacOS。

framework有了，下面就是注入到可执行文件。去Github上下载insert_dylib代码，编译得到insert_dylib文件。同样复制到迅雷可执行文件同目录下，再把Thunder改成Thunder_backup。

然后打开终端，进入到这个目录下面，执行如下代码

./insert_dylib --all-yes /Applications/Thunder.app/Contents/MacOS/libThunderPlugin.framework/libThunderPlugin Thunder_backup Thunder

出现以下内容就表示成功了

同时目录下会再生成个Thunder文件。

这时候再打开迅雷，登录账号，会发现已经成为SVIP了，并且有效期到2099年。

不过这仅仅是显示而已，并没有实际作用。其他功能感兴趣自己研究，这里仅作为例子。

下面开始讲代码，做iOS开发的应该可以看懂，上面的代码其实就是通过runtime替换原有方法实现，更改参数以实现显示的效果。但是这里的重点是怎么去找替换那个方法，更改哪些参数。

应用的方法和类信息存在于Mach-O 二进制文件中，我们是可以从二进制文件中提取这些信息的。下面介绍一款工具class-dump，它可以使我们快速的获取到应用的头文件信息。

同样和insert_dylib一样，我们需要下载源码，编译可执行文件。如果安装了MonkeyDev的就可以直接使用。打开终端，使用以下命令获取头文件

class-dump -H /Applications/Thunder.app/Contents/MacOS/Thunder -o ~/Desktop/Thunder.h

-H是获取头文件，-o 是指定头文件的目录，不指定就是当前文件夹。这里就不多做介绍。完成后找到Thunder.h目录，会发现有好多文件

这种情况要怎么找呢？一个个找无疑就是大海捞针。首先我们要学会关键字搜索，我们的目的是让用户状态显示为vip，那就尝试搜索这个关键字试试。

很明显，头文件少了很多。打开第一个文件看看，看名字就知道这个是用户信息的模型类。这个文件有各种用户信息相关的属性，并且提供了两个方法。

方法找到了，下一步就是验证这个方法是不是我们想要找的。导入头文件写代码

void lm_hookMethod(Class originalClass, SEL originalSelector, Class swizzledClass, SEL swizzledSelector) {
    Method originalMethod = class_getInstanceMethod(originalClass, originalSelector);
    Method swizzledMethod = class_getInstanceMethod(swizzledClass, swizzledSelector);
    if(originalMethod && swizzledMethod) {
        method_exchangeImplementations(originalMethod, swizzledMethod);
    }
}

@implementation NSObject (Thunder)
+ (void)hookThunder{
    lm_hookMethod(objc_getClass("XLUserInformation"), @selector(initWithUserInfo:), [self class], @selector(hook_initWithUserInfo:));
    lm_hookMethod(objc_getClass("XLUserInformation"), @selector(updateUserInfo:), [self class], @selector(hook_updateUserInfo:));
}
- (id)hook_initWithUserInfo:(id)arg1{
    return [self hook_initWithUserInfo:arg1];
}
- (void)hook_updateUserInfo:(id)arg1{
    [self hook_updateUserInfo:arg1];
}
@end

上面代码是通过runtime实现了方法的hook，这时又有新问题出现了，我们怎么知道方法参数类型，要改哪些值才能实现我们的目的？这个时候就想能调试就好了。做过越狱开发的应该都了解，我们通过给debugserver添加task_for_pid权限就可以调试第三方应用了。macOS上没那么复杂，只需要在编译framework的时候选择启动我们需要调试的应用即可。

在Edit Scheme里面，Executable里面选择我们需要调试的应用，如图

点击Other，然后选择迅雷即可。完成后会变成这样

这时候再点击运行，就会发现可以调试了。如果没有之前insert_dylib的操作，会有以下错误

Failure Reason: attach failed (Not allowed to attach to process.  Look in the console messages (Console.app), near the debugserver entries, when the attach failed.  The subsystem that denied the attach permission will likely have logged an informative message about why it was denied.)

可以看出这里是权限的问题，运行的时候验证了签名，insert_dylib处理过的二进制文件移除了LC_CODE_SIGNATURE，所以可以正常调试。这里只需要更改签名添加权限即可。先把以下内容保存到文件中，文件名随意，我用的是entitlements.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
  <dict>
    <key>com.apple.security.cs.allow-jit</key>
      <true/>
    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
      <true/>
    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
      <true/>
    <key>com.apple.security.cs.disable-library-validation</key>
      <true/>
    <key>com.apple.security.get-task-allow</key>
      <true/>
  </dict>
</plist>

然后通过以下命令替换二进制文件的签名，开发者证书名选择自己的证书即可。

codesign --entitlements entitlements.xml -fs <开发者证书名> /Applications/Thunder.app

这个就表示替换成功了。然后再运行发现还是会报错，但是现在可以正常启动应用了。

这时候在我们自己方法里面打断点，发现还是不会断住，这是因为应用还没有加载我们的动态库。只需要在应用启动之前把我们的动态库插入到应用即可，这时候又需要用到insert_dylib了。在项目根目录创建个Other文件夹，然后把insert_dylib放进去。

然后在工程Build Phases中创建个脚本

创建完成后，把以下内容复制进去

app_name="Thunder"
framework_name="libThunderPlugin"
app_bundle_path="/Applications/${app_name}.app/Contents/MacOS"
app_executable_path="${app_bundle_path}/${app_name}"
app_executable_backup_path="${app_executable_path}_backup"
framework_path="${app_bundle_path}/${framework_name}.framework"
# 备份原始可执行文件
if [ ! -f "$app_executable_backup_path" ]
then
cp "$app_executable_path" "$app_executable_backup_path"
fi

rm -rf "./Other/Products/Debug/${framework_name}.framework"
cp -r "${BUILT_PRODUCTS_DIR}/${framework_name}.framework" "./Other/Products/Debug/${framework_name}.framework"
cp -r "${BUILT_PRODUCTS_DIR}/${framework_name}.framework" ${app_bundle_path}
./Other/insert_dylib --all-yes "${framework_path}/${framework_name}" "$app_executable_backup_path" "$app_executable_path"

这里面的内容其实就是帮我们完成了上面我们手动插入framework的操作。上述操作都完成后断点还是没有生效的，是因为还没有调用方法的替换，一般的话是在类 + (void)load方法里面实现方法的替换，但是对于framework来说，还会有一些C、C++和Swift的方法替换，这种情况是没有load方法的。了解dyld加载流程的应该知道，dyld会调用每个framework的initialize方法去初始化。然后我们写入以下代码

static void __attribute__((constructor)) initialize(void) {
    [NSObject hookThunder];
}

这时候再运行，发现是可以正常断住的，并且可以看到arg1是NSDictionary类型。

具体更改哪些数据可以达到我们想要的效果就需要自己一个个尝试了，这里就不多说了。

到这里就会有人问，如果通过搜索找不到我们需要的方法怎么办？不过确实，做逆向不是每次都那么好运气的。如果这样的话就需要通过UI找数据了。Xcode有个Debug View Hierarchy的功能，如下

感兴趣自己研究吧，这里就不多说了。

无意间看到了这篇文章 iOS objc_msgSend尾调用优化详解，讲的是在Release模式下，当某函数的最后一项操作是调用另外一个函数，编译器会生成调转至另一函数所需的指令码，而且不会向调用堆栈中推入新的“栈帧”（frame stack），以实现栈帧复用。

栈帧就是一个函数执行的环境：函数参数、函数的局部变量、函数执行完后返回到哪里等等。所以在每一次函数调用之前，需要保存下执行的环境，以确保正常返回到调用位置。下面是- (void)viewDidLoad方法的汇编代码

可以看出在调用[super viewDidLoad]之前，先申请栈空间，然后保存x29和x30寄存器的值，调用结束后恢复寄存器的值，然后平栈。x29寄存器也就是fp寄存器，保存栈底的地址。x30寄存器也就是lr寄存器，保存返回地址。那栈帧复用又是怎么实现的呢？本着知其然知其所以然的精神，深入研究下。用下文章中的例子

- (NSInteger)func1:(NSInteger)num{
    if (num >= 2000000) {
        return num;
    }
    return [self func1:num + 1];
}

运行打断点，查看汇编代码如下

可以发现，这里面并没有保存和恢复寄存器的操作，也没有申请栈空间。如果不保存，函数执行完会返回哪里呢？这里就要看下，fp和lr寄存器了。

多次点继续执行，会发现这三个寄存器的值是不会变的。也就是说，被调用函数继承了调用函数的执行环境。这就很好理解了，因为是尾调用，编译器认为已经没必要再返回到调用函数了，当前函数执行完直接返回到最终地址就可以了。

执行环境是包含fp和sp的，也就是标识着栈空间的起始，如果栈空间发生变化，那么还会复用栈帧吗？写以下代码

- (NSInteger)func1:(NSInteger)num{
    NSObject *obj = [NSObject new];
    if (num >= 2000000) {
        return num;
    }
    return [self func1:num + 1];
}

继续调试，发现这种情况下，并没有优化。如图

也就是说，尾调用优化需要同时满足栈空间没有变化。

文章中提到尾调用优化的条件有一条为：尾调用函数不需要访问当前栈帧中的变量。（变量可以作为形参，但是不能作为实参）

如果调用函数的参数数量大于寄存器所能传递的数量时，是需要通过栈传递的。这种情况下，是不是也不会优化呢？写以下代码验证

- (NSInteger)func1:(NSInteger)num{
    if (num >= 2000000) {
        return num;
    }
    return [self funcA:1 B:2 C:3 D:4 E:5 F:6 G:7 H:8 J:9];
}

- (int)funcA:(int)a B:(int)b C:(int)c D:(int)d E:(int)e F:(int)f G:(int)g H:(int)h J:(int)j{
    int value = a + b + c + d + e + f + g + h + j;
    if (value >= 200000) {
        return value;
    }
    return [self funcA:a + 1 B:b + 1 C:c + 1 D:d + 1 E:e + 1 F:f + 1 G:g + 1 H:h +1 J:j + 1];
}

切换到汇编下断点在objc_msgSend前，可以发现当参数大于9个的时候，就需要栈传递了

继续运行可以发现，这里funcA并没有复用func1的栈帧，也就是没有尾调用优化。而funcA函数的栈帧被复用了。

通过以上可以看出，当被调用函数的栈空间大于调用函数的栈空间时，因为需要开辟新的空间，fp和sp是需要变化的，这种情况下是不会优化的。当相等的时候，也是可以尾调用优化的。那会有人问，为什么以下情况没有复用栈帧呢？

- (NSInteger)func1:(NSInteger)num{
    NSObject *obj = [NSObject new];
    if (num >= 2000000) {
        return num;
    }
    return [self func1:num + 1];
}

因为对象是涉及到生命周期的，在调用方法之前，对象还没有释放，栈空间还是使用状态，所以被调用函数无法复用调用函数的栈空间。

既然栈空间相等是可以复用的，那么当小于的时候一定也是可以的，这里就不贴代码了。有兴趣的可以自己验证下。

栈帧复用取决于sp、fp和lr寄存器，那么以下情况也是可以的

- (NSInteger)func1:(NSInteger)num{
    if (num >= 2000000) {
        return num;
    }
    num = [self func2:num];
    return num;
}
- (NSInteger)func2:(NSInteger)num{
    return num;
}

毕竟对于编译器来说直接返回函数和返回函数的返回值是一样的，看汇编确实是这样的

那么这种情况也是可以实现栈复用，而如果返回值不单纯是被调用函数的返回值，当被调用函数返回后还需要做一些需要寄存器相关的操作的话，这种情况是需要保存上下文的，所以不能实现尾调用优化。这里就不做测试了。

综上尾调用优化条件如下：

1、调用函数返回值为被调用函数的返回值或者被调用函数本体。

2、被调用函数的栈空间不能大于调用函数所申请的栈空间。

__weak 在开发中经常用到，主要是为了解决内存管理中的循环引用。__weak修饰的指针特性是其指向的对象销毁后，会自动置为 nil。

用到__weak基本上分两种情况，一种是先声明再赋值（@property (weak)也是这种），另一种是声明的时候赋值。

NSObject *obj = [NSObject new];
__weak id weak;
weak = obj;
__weak id weak1 = obj;

新建个项目，在项目中写入以上代码，然后再终端输入以下命令编译成C++源码

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 "替换为写代码的文件"

可得到以下内容，发现__weak 对应的类型属性都为__attribute((objc_ownership(weak)))，代表以weak弱引⽤的⽅式管理对象所有权。

__attribute__((objc_ownership(weak))) id weak;
weak = obj;
__attribute__((objc_ownership(weak))) id week2 = obj;

然后再在源码中打断点，运行进入调试模式。再通过Xcode菜单Debug->Debug Workflow->Always Show Disassembly 进入到汇编模式。

查看汇编。如下

可以看出，先声明后赋值调用的是objc_storeWeak。声明的时候赋值，调用的是objc_initWeak。为什么同样是weak指针，实现逻辑却不一样呢。

在objc源码中找到这两个方法的源码。如下

id objc_storeWeak(id *location, id newObj)
{
    return storeWeak<DoHaveOld, DoHaveNew, DoCrashIfDeallocating>
        (location, (objc_object *)newObj);
}

id objc_initWeak(id *location, id newObj)
{
    if (!newObj) {
        *location = nil;
        return nil;
    }

    return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
        (location, (objc_object*)newObj);
}

唯一不同的地方是，当对象不存在时，把指针设置为nil，可以防止坏内存访问。可以看出location存储着weak指针的地址。而第一种没有这个操作的原因是编译器第一次使用这个指针的时候，已经做了这个操作。

然后看后面调用了两次objc_destroyWeak，这是因为离开了局部变量的范围了，每一个弱指针都需要有一次调用。代码如下

void objc_destroyWeak(id *location)
{
    (void)storeWeak<DoHaveOld, DontHaveNew, DontCrashIfDeallocating>
        (location, nil);
}

可以看到这三个方法都调用了storeWeak方法，查看源码,函数的实现太长，这里分段分析。

// Update a weak variable.
// If HaveOld is true, the variable has an existing value 
//   that needs to be cleaned up. This value might be nil.
// If HaveNew is true, there is a new value that needs to be 
//   assigned into the variable. This value might be nil.
// If CrashIfDeallocating is true, the process is halted if newObj is 
//   deallocating or newObj's class does not support weak references. 
//   If CrashIfDeallocating is false, nil is stored instead.
enum CrashIfDeallocating {
    DontCrashIfDeallocating = false, DoCrashIfDeallocating = true
};
template <HaveOld haveOld, HaveNew haveNew,
          enum CrashIfDeallocating crashIfDeallocating>
static id 
storeWeak(id *location, objc_object *newObj)
{
    ASSERT(haveOld  ||  haveNew);
    if (!haveNew) ASSERT(newObj == nil);

    Class previouslyInitializedClass = nil;
    id oldObj;
    SideTable *oldTable;
    SideTable *newTable;

函数前面的注释，表面了模板中三个参数的作用，这里就不做翻译了。函数开始的这部分，主要是变量声明，这里主要注意下SideTable类型。查代码可以看到结构体定义如下（省略了结构体函数）。

struct SideTable {
    spinlock_t slock;
    RefcountMap refcnts;
    weak_table_t weak_table;
}

其中 slock 是一个自旋锁，对 SideTable 实例进行操作时用来加锁。refcnts是当对象的引用计数大于isa指针所能存储的数值时，存放引用计数的地方。weak_table 则是存放弱引用指针的地方（后面将详细分析 weak_table_t）。

继续看storeWeak函数

    // Acquire locks for old and new values.
    // Order by lock address to prevent lock ordering problems. 
    // Retry if the old value changes underneath us.
 retry:
    if (haveOld) {
        oldObj = *location;
        oldTable = &SideTables()[oldObj];
    } else {
        oldTable = nil;
    }
    if (haveNew) {
        newTable = &SideTables()[newObj];
    } else {
        newTable = nil;
    }

    SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);

    if (haveOld  &&  *location != oldObj) {
        SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
        goto retry;
    }

这一段是获取oldOb，以及从SideTables里面分别通过oldObj和newObj的地址作为key获取到了oldTable和newTable，然后上锁。

SideTables返回的是StripedMap<SideTable>类型的哈希表，表的长度在iPhone上是8，模拟器和macOS是64，如下

class StripedMap {
#if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR
    enum { StripeCount = 8 };
#else
    enum { StripeCount = 64 };
#endif

    struct PaddedT {
        T value alignas(CacheLineSize);
    };

    PaddedT array[StripeCount];

    static unsigned int indexForPointer(const void *p) {
        uintptr_t addr = reinterpret_cast<uintptr_t>(p);
        return ((addr >> 4) ^ (addr >> 9)) % StripeCount;
    }
    //省略下面内容
}

继续storeWeak函数

// Prevent a deadlock between the weak reference machinery
    // and the +initialize machinery by ensuring that no 
    // weakly-referenced object has an un-+initialized isa.
    if (haveNew  &&  newObj) {
        Class cls = newObj->getIsa();
        if (cls != previouslyInitializedClass  &&  
            !((objc_class *)cls)->isInitialized()) 
        {
            SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
            class_initialize(cls, (id)newObj);

            // If this class is finished with +initialize then we're good.
            // If this class is still running +initialize on this thread 
            // (i.e. +initialize called storeWeak on an instance of itself)
            // then we may proceed but it will appear initializing and 
            // not yet initialized to the check above.
            // Instead set previouslyInitializedClass to recognize it on retry.
            previouslyInitializedClass = cls;

            goto retry;
        }
    }

看注释可以得出，这里是确保对象的类已经完成+initialize流程。

    // Clean up old value, if any.
    if (haveOld) {
        weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
    }

    // Assign new value, if any.
    if (haveNew) {
        newObj = (objc_object *)
            weak_register_no_lock(&newTable->weak_table, (id)newObj, location, 
                                  crashIfDeallocating ? CrashIfDeallocating : ReturnNilIfDeallocating);
        // weak_register_no_lock returns nil if weak store should be rejected

        // Set is-weakly-referenced bit in refcount table.
        if (!_objc_isTaggedPointerOrNil(newObj)) {
            newObj->setWeaklyReferenced_nolock();
        }

        // Do not set *location anywhere else. That would introduce a race.
        *location = (id)newObj;
    }
    else {
        // No new value. The storage is not changed.
    }
    
    SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);

    callSetWeaklyReferenced((id)newObj);

    return (id)newObj;
}

如果这个弱指针本身指向旧的对象，先通过weak_unregister_no_lock方法，其从 oldTable 的 weak_table 中移除。如果有新的值，则使用 weak_register_no_lock 方法将其注册到 newTable 的 weak_table 中，并使用 setWeaklyReferenced_nolock 函数将对象标记为被弱引用过。

到这里，对storeWeak大概流程已经分析完成 ，其重点就在 weak_register_no_lock 和 weak_unregister_no_lock 函数上。这两个函数都用到了weak_table，先看下weak_table_t定义如下

/**
 * The global weak references table. Stores object ids as keys,
 * and weak_entry_t structs as their values.
 */
struct weak_table_t {
    weak_entry_t *weak_entries; //weak_entry_t的数组
    size_t    num_entries; //数组中weak_entry_t的数量
    uintptr_t mask;  //哈希后的值取余算索引
    uintptr_t max_hash_displacement; //哈希碰撞后最大的位移值
};

再看下weak_entry_t结构如下（省略结构体方法）

struct weak_entry_t {
    DisguisedPtr<objc_object> referent;
    union {
        struct {
            weak_referrer_t *referrers;
            uintptr_t        out_of_line_ness : 2;
            uintptr_t        num_refs : PTR_MINUS_2;
            uintptr_t        mask;
            uintptr_t        max_hash_displacement;
        };
        struct {
            // out_of_line_ness field is low bits of inline_referrers[1]
            weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT];
        };
    };
}

第一个DisguisedPtr<objc_object>其实就是 objc_object*，DisguisedPtr是为了是为了躲过内存泄漏工具的检查。

// DisguisedPtr<T> acts like pointer type T*, except the 
// stored value is disguised to hide it from tools like `leaks`.

第二个是两个结构体的联合体，先分析第一种。

referrers是一个指向weak_referrer_t 的数组指针，也就是objc_object *的数组指针

typedef DisguisedPtr<objc_object *> weak_referrer_t;

out_of_line_ness占用2 bit 标记位，用来确定联合里的内存是第一个结构体还是第二个结构体；

num_refs：PTR_MINUS_2 是字节长度减去 2 位，和 out_of_line_ness 一起组成一个字节，用来存储 referrers 的大小；

mask 和 max_hash_displacement做哈希表用到的东西。

然后看第二种，inline_referrers是一个长度为WEAK_INLINE_COUNT（4）的数组。

通过搜索代码可以找到append_referrer方法里面区分两种结果的存在时机

if (! entry->out_of_line()) {
        // Try to insert inline.
        for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
            if (entry->inline_referrers[i] == nil) {
                entry->inline_referrers[i] = new_referrer;
                return;
            }
        }

        // Couldn't insert inline. Allocate out of line.
        weak_referrer_t *new_referrers = (weak_referrer_t *)
            calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));
        // This constructed table is invalid, but grow_refs_and_insert
        // will fix it and rehash it.
        for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
            new_referrers[i] = entry->inline_referrers[i];
        }
        entry->referrers = new_referrers;
        entry->num_refs = WEAK_INLINE_COUNT;
        entry->out_of_line_ness = REFERRERS_OUT_OF_LINE;
        entry->mask = WEAK_INLINE_COUNT-1;
        entry->max_hash_displacement = 0;
    }

当weak_referrer_t的数量大于4个的时候，用哈希表存储，反之数组存储。

现在回到weak_register_no_lock方法，去掉内存管理相关内容代码如下

id weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                      id *referrer_id, WeakRegisterDeallocatingOptions deallocatingOptions)
{
    objc_object *referent = (objc_object *)referent_id;
    objc_object **referrer = (objc_object **)referrer_id;

    if (_objc_isTaggedPointerOrNil(referent)) return referent_id;

    // now remember it and where it is being stored
    weak_entry_t *entry;
    if ((entry = weak_entry_for_referent(weak_table, referent))) {
        append_referrer(entry, referrer);
    } 
    else {
        weak_entry_t new_entry(referent, referrer);
        weak_grow_maybe(weak_table);
        weak_entry_insert(weak_table, &new_entry);
    }

    // Do not set *referrer. objc_storeWeak() requires that the 
    // value not change.

    return referent_id;
}

首先获取referent和referrers，referent 是被弱引用的对象，referrers是存储弱引用变量的地址。再判断referent是否为TaggedPointer或者nil，是的话直接返回。

然后用 weak_entry_for_referent 函数搜索对象是否已经有了 weak_entry_t 类型的条目，有的话则使用 append_referrer 把referrer添加到里面，没有的话新建一个 weak_entry_t 条目，然后使用 weak_grow_maybe 函数判断是否需要扩大弱引用表的大小，再使用 weak_entry_insert 将弱引用插入表中。

先看append_referrer函数

static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
{
    if (! entry->out_of_line()) {
        // Try to insert inline.
        for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
            if (entry->inline_referrers[i] == nil) {
                entry->inline_referrers[i] = new_referrer;
                return;
            }
        }

        // Couldn't insert inline. Allocate out of line.
        weak_referrer_t *new_referrers = (weak_referrer_t *)
            calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));
        // This constructed table is invalid, but grow_refs_and_insert
        // will fix it and rehash it.
        for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
            new_referrers[i] = entry->inline_referrers[i];
        }
        entry->referrers = new_referrers;
        entry->num_refs = WEAK_INLINE_COUNT;
        entry->out_of_line_ness = REFERRERS_OUT_OF_LINE;
        entry->mask = WEAK_INLINE_COUNT-1;
        entry->max_hash_displacement = 0;
    }

    ASSERT(entry->out_of_line());

    if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) {
        return grow_refs_and_insert(entry, new_referrer);
    }
    size_t begin = w_hash_pointer(new_referrer) & (entry->mask);
    size_t index = begin;
    size_t hash_displacement = 0;
    while (entry->referrers[index] != nil) {
        hash_displacement++;
        index = (index+1) & entry->mask;
        if (index == begin) bad_weak_table(entry);
    }
    if (hash_displacement > entry->max_hash_displacement) {
        entry->max_hash_displacement = hash_displacement;
    }
    weak_referrer_t &ref = entry->referrers[index];
    ref = new_referrer;
    entry->num_refs++;
}

大概逻辑就是，先用weak_entry_t中的数组存储，如果满了就换哈希表存储。

再看weak_grow_maybe函数

#define TABLE_SIZE(entry) (entry->mask ? entry->mask + 1 : 0)

static void weak_grow_maybe(weak_table_t *weak_table)
{
    size_t old_size = TABLE_SIZE(weak_table);

    // Grow if at least 3/4 full.
    if (weak_table->num_entries >= old_size * 3 / 4) {
        weak_resize(weak_table, old_size ? old_size*2 : 64);
    }
}

可以看到，当 weak_table 里的弱引用数量到它容量的四分之三时，便会将容量拓展为两倍。值得注意的是第一次拓展也就是当 mask 为 0 的情况，初始值是 64。

最后是weak_entry_insert函数

static void weak_entry_insert(weak_table_t *weak_table, weak_entry_t *new_entry)
{
    weak_entry_t *weak_entries = weak_table->weak_entries;
    ASSERT(weak_entries != nil);

    size_t begin = hash_pointer(new_entry->referent) & (weak_table->mask);
    size_t index = begin;
    size_t hash_displacement = 0;
    while (weak_entries[index].referent != nil) {
        index = (index+1) & weak_table->mask;
        if (index == begin) bad_weak_table(weak_entries);
        hash_displacement++;
    }

    weak_entries[index] = *new_entry;
    weak_table->num_entries++;

    if (hash_displacement > weak_table->max_hash_displacement) {
        weak_table->max_hash_displacement = hash_displacement;
    }
}

先判断哈希表是否存在，不存在证明弱引用的数量不大于4个，还使用数组存储。存在的话就是哈希表插入的过程。

下面看weak_unregister_no_lock

void
weak_unregister_no_lock(weak_table_t *weak_table, id referent_id, 
                        id *referrer_id)
{
    objc_object *referent = (objc_object *)referent_id;
    objc_object **referrer = (objc_object **)referrer_id;

    weak_entry_t *entry;

    if (!referent) return;

    if ((entry = weak_entry_for_referent(weak_table, referent))) {
        remove_referrer(entry, referrer);
        bool empty = true;
        if (entry->out_of_line()  &&  entry->num_refs != 0) {
            empty = false;
        }
        else {
            for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                if (entry->inline_referrers[i]) {
                    empty = false; 
                    break;
                }
            }
        }

        if (empty) {
            weak_entry_remove(weak_table, entry);
        }
    }

    // Do not set *referrer = nil. objc_storeWeak() requires that the 
    // value not change.
}

先使用 weak_entry_for_referent 函数找到对应的弱引用条目，并用 remove_referrer 将对应的弱引用变量位置从中移除。最后判断条目是否为空，为空则使用 weak_entry_remove 将其从弱引用表中移除。

remove_referrer函数实现如下

static void remove_referrer(weak_entry_t *entry, objc_object **old_referrer)
{
    if (! entry->out_of_line()) {
        for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
            if (entry->inline_referrers[i] == old_referrer) {
                entry->inline_referrers[i] = nil;
                return;
            }
        }
        _objc_inform("Attempted to unregister unknown __weak variable "
                     "at %p. This is probably incorrect use of "
                     "objc_storeWeak() and objc_loadWeak(). "
                     "Break on objc_weak_error to debug.\n", 
                     old_referrer);
        objc_weak_error();
        return;
    }

    size_t begin = w_hash_pointer(old_referrer) & (entry->mask);
    size_t index = begin;
    size_t hash_displacement = 0;
    while (entry->referrers[index] != old_referrer) {
        index = (index+1) & entry->mask;
        if (index == begin) bad_weak_table(entry);
        hash_displacement++;
        if (hash_displacement > entry->max_hash_displacement) {
            _objc_inform("Attempted to unregister unknown __weak variable "
                         "at %p. This is probably incorrect use of "
                         "objc_storeWeak() and objc_loadWeak(). "
                         "Break on objc_weak_error to debug.\n", 
                         old_referrer);
            objc_weak_error();
            return;
        }
    }
    entry->referrers[index] = nil;
    entry->num_refs--;
}

先判断是否是inline存储（! entry->out_of_line()），如果是的话把old_referrer直接设置为nil (entry->inline_referrers[i] = nil)，不是的话遍历哈希表referrers找到索引，再通过索引设置为nil（entry->referrers[index] = nil），然后将长度-1。

然后看weak_entry_remove方法

static void weak_entry_remove(weak_table_t *weak_table, weak_entry_t *entry)
{
    // remove entry
    if (entry->out_of_line()) free(entry->referrers);
    bzero(entry, sizeof(*entry));

    weak_table->num_entries--;

    weak_compact_maybe(weak_table);
}

直接的清零 entry，并给 weak_table 的 num_entries 减 1，最后调用weak_compact_maybe方法检查看weak_table是否需要缩小。

static void weak_compact_maybe(weak_table_t *weak_table)
{
    size_t old_size = TABLE_SIZE(weak_table);

    // Shrink if larger than 1024 buckets and at most 1/16 full.
    if (old_size >= 1024  && old_size / 16 >= weak_table->num_entries) {
        weak_resize(weak_table, old_size / 8);
        // leaves new table no more than 1/2 full
    }
}

缩小的话则是需要表本身大于等于 1024 并且存放了不足十六分之一的条目时，直接通过weak_resize方法缩小 8 倍。

static void weak_resize(weak_table_t *weak_table, size_t new_size)
{
    size_t old_size = TABLE_SIZE(weak_table);

    weak_entry_t *old_entries = weak_table->weak_entries;
    weak_entry_t *new_entries = (weak_entry_t *)
        calloc(new_size, sizeof(weak_entry_t));

    weak_table->mask = new_size - 1;
    weak_table->weak_entries = new_entries;
    weak_table->max_hash_displacement = 0;
    weak_table->num_entries = 0;  // restored by weak_entry_insert below
    
    if (old_entries) {
        weak_entry_t *entry;
        weak_entry_t *end = old_entries + old_size;
        for (entry = old_entries; entry < end; entry++) {
            if (entry->referent) {
                weak_entry_insert(weak_table, entry);
            }
        }
        free(old_entries);
    }
}

weak_resize 函数的过程就是新建一个数组，将老数组里的值使用 weak_entry_insert 函数添加进去，mask是新数组长度-1，max_hash_displacement 和 num_entries 也都清零了，因为 weak_entry_insert 函数会对这两个值进行操作。

到这里，弱引用的整个流程已经分析完成了。现在看下为什么对象销毁后，弱引用变量被置为 nil。通过搜索找到对象在是否的时候调用了以下方法

void
objc_object::clearDeallocating_slow()
{
    ASSERT(isa().nonpointer  &&  (isa().weakly_referenced || isa().has_sidetable_rc));

    SideTable& table = SideTables()[this];
    table.lock();
    if (isa().weakly_referenced) {
        weak_clear_no_lock(&table.weak_table, (id)this);
    }
    if (isa().has_sidetable_rc) {
        table.refcnts.erase(this);
    }
    table.unlock();
}

如果对象有弱引用会调用weak_clear_no_lock方法

void 
weak_clear_no_lock(weak_table_t *weak_table, id referent_id) 
{
    objc_object *referent = (objc_object *)referent_id;

    weak_entry_t *entry = weak_entry_for_referent(weak_table, referent);
    if (entry == nil) {
        /// XXX shouldn't happen, but does with mismatched CF/objc
        //printf("XXX no entry for clear deallocating %p\n", referent);
        return;
    }

    // zero out references
    weak_referrer_t *referrers;
    size_t count;
    
    if (entry->out_of_line()) {
        referrers = entry->referrers;
        count = TABLE_SIZE(entry);
    } 
    else {
        referrers = entry->inline_referrers;
        count = WEAK_INLINE_COUNT;
    }
    
    for (size_t i = 0; i < count; ++i) {
        objc_object **referrer = referrers[i];
        if (referrer) {
            if (*referrer == referent) {
                *referrer = nil;
            }
            else if (*referrer) {
                _objc_inform("__weak variable at %p holds %p instead of %p. "
                             "This is probably incorrect use of "
                             "objc_storeWeak() and objc_loadWeak(). "
                             "Break on objc_weak_error to debug.\n", 
                             referrer, (void*)*referrer, (void*)referent);
                objc_weak_error();
            }
        }
    }
    
    weak_entry_remove(weak_table, entry);
}

先获取存储弱引用的weak_entry_t，然后从中获取到存储的位置和数量，再遍历设置为nil，最后从weak_table中删除。

通过分析流程可以得知弱引用的存储结构 SideTables->SideTable->weak_table_t->weak_entry_t->weak_referrer_t数组或者哈希表。

从苹果开源网站https://opensource.apple.com/releases/下载最新源码，这里是objc4-841.13版本，各个版本需要处理的问题差别不是很大。编译环境如下

• 系统: macOS 12.4 (21F79)
• 工具: Xcode 13.4.1 (13F100)
• 源码: objc4-841.13

下载好代码解压，打开后编译objc Target。下面按照错误出现的顺序，依次解决。

1、unable to find sdk 'macosx.internal'

分别选objc和objc-trampolines两个target，然后把Base SDK选为macOS。

2、'sys/reason.h' file not found

头文件缺失，只要找到对应的头文件添加到工程中就可以解决，首先在工程的根目录创建include文件夹，然后在工程的Build Settings->Header Search Paths添加$(SRCROOT)/include，并且把后面选项设置为recursive。

因为头文件是<sys/reason.h>，所以还要在include文件夹中创建sys文件夹。然后在xnu-8020.121.3的/bsd/sys目录下找到reason.h，复制到新建的/include/sys目录。

3、'mach-o/dyld_priv.h' file not found

需要先在include文件夹下面创建mach-o文件夹，然后在dyld-957的/include/mach-o目录下找到dyld_priv.h，复制到/include/mach-o目录下。

4、'os/lock_private.h' file not found

需要先在include文件夹下面创建os文件夹，然后在libplatform-273.100.5的/private/os目录下找到lock_private.h，复制到/include/os目录下。

5、Expected ','

删除文件中所有的bridgeos(3.0)，带前面'，'一并删除，搜索替换即可，如下图

后面还会出现bridgeos相关的报错，一并删除即可。

6、'os/base_private.h' file not found

在libplatform-220.100.1的/private/os目录下找到base_private.h，复制到/include/os目录下。

7、'pthread/tsd_private.h' file not found

需要先在include文件夹下面创建pthread文件夹，然后在libpthread-486.100.11的/private/pthread目录下找到tsd_private.h，复制到/include/pthread目录下。

8、'System/machine/cpu_capabilities.h' file not found

需要在include文件夹下创建System文件夹，然后再System文件夹下创建machine文件夹，然后在xnu-8020.121.3的/osfmk/machine目录下找到cpu_capabilities.h，复制到/include/System/machin目录下。

9、'os/tsd.h' file not found

在xnu-8020.121.3的/libsyscall/os下找到tsd.h文件，复制到/include/os目录下。

10、'pthread/spinlock_private.h' file not found

在libpthread-486.100.11的/private/pthread下找到spinlock_private.h，复制到/include/pthread目录下。

11、'os/feature_private.h' file not found

从apple_internal_sdk的/usr/include/os目录中找到feature_private.h文件，复制到/include/os目录下。

12、'os/variant_private.h' file not found

从Libc-1507.100.9 的/os目录下找到variant_private.h文件，复制到/include/os目录下。

13、'System/pthread_machdep.h' file not found

从Libc-825.26的/pthreads目录下找到pthread_machdep.h，复制到/include/System目录下。

14、'CrashReporterClient.h' file not found

1.从Libc-825.26的/include目录下找到CrashReporterClient.h文件，复制到objc工程中自己创建的include目录下。

2.复制完成还是会报错

需要在报错文件中添加#define LIBC_NO_LIBCRASHREPORTERCLIENT

3.在Build Settings->Linking->Other Linker Flags里删掉"-lCrashReporterClient"，因为后面运行的时候会报错ld: library not found for -lCrashReporterClient

15、Typedef redefinition with different types ('int' vs 'volatile OSSpinLock' (aka 'volatile int')) 等，

上面pthread_machdep.h中的四个报错，注释掉即可。

16、'os/bsd.h' file not found

注释掉即可，然后注释is_root_ramdisk方法和调用此方法的地方。

17、'os/reason_private.h' file not found

从xnu-8020.121.3的/libkern/os的目录下找到reason_private.h，复制到/include/os目录下。

18、'objc-shared-cache.h' file not found

从dyld-957的/include目录中找到objc-shared-cache.h，复制到objc工程的include目录下。

19、Use of undeclared identifier 'dyld_platform_version_*

注释或者删除即可。

20、'_simple.h' file not found

从libplatform-220.100.1的/private目录找到_simple.h，复制到objc工程的include目录。

21、'os/linker_set.h' file not found

从xnu-8020.121.3的/bsd/sys目录找到linker_set.h，复制到/include/os目录。

22、'Block_private.h' file not found

从libclosure-79.1根目录找到Block_private.h，复制到objc工程的include目录。

23、'Cambria/Traps.h' file not found和'Cambria/Cambria.h' file not found

注释掉。第二个图片除了红色框住的，都注释掉。就算头文件正常导入，也会提示以下错误

24、'kern/restartable.h' file not found

在xnu-8020.121.3的/osfmk/kern找到restartable.h，然后在objc工程的include目录下创建kern文件夹，再把找到的文件复制进去。

25、ld: library not found for -loah

在Build Settings -> Linking -> Other Linker Flags里删掉-loah

26、'_static_assert' declared as an array with a negative size

注释掉。

27、SDK "macosx.internal" cannot be located.

选择 target -> objc -> Build Phases -> Run Script(markgc)，把脚本文本 macosx.internal 改成 macosx。

到这一步，应该就可以正常地编译了。

调试部分，需新建个target->macOS->Command Line Tool

然后在新建的target-> Frameworks and Libraries -> 添加编译出来的libobjc.A.dylib

然后在新建的target->Build Settings->Enable hardened runtime设置为NO

在新建的target里面随便新建个类文件，并且在main文件中初始化个对象。然后在objc的alloc方法打断点

并且在main文件打断点

运行，如果alloc没有断住，需要检查Enable hardened runtime是否设置为NO，如果第二个没断住，需要在Compile Sources中把main文件移动到对上面。

按照以上步骤处理完成，就会得到一份可以编译调试的objc代码。

上一篇分析了cache_t的结构和怎么缓存方法的，这里继续分析objc_class中的class_data_bits_t，搜索可以找到主要结构如下

struct class_data_bits_t {
    friend objc_class;
    uintptr_t bits;

    class_rw_t* data() const {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }

    bool isAnySwift() {
        return isSwiftStable() || isSwiftLegacy();
    }
};

可以看出，结构体里面只有一个bits，然后主要方法就是获取class_rw_t，和判断是不是Swift的类。

看标题就知道，这篇文章的重点就是class_rw_t，源码中搜索找到结构体定义

struct class_rw_t {
    uint32_t flags; //标记位
    uint16_t witness; //存放cls地址 缓存range的索引
    
    explicit_atomic<uintptr_t> ro_or_rw_ext;

    Class firstSubclass; //第一个子类
    Class nextSiblingClass; //兄弟类
}

这里主要关注ro_or_rw_ext，使用的时候，会通过联合指针转换成ro_or_rw_ext_t

using ro_or_rw_ext_t = objc::PointerUnion<const class_ro_t, class_rw_ext_t, PTRAUTH_STR("class_ro_t"), PTRAUTH_STR("class_rw_ext_t")>;

const ro_or_rw_ext_t get_ro_or_rwe() const {
    return ro_or_rw_ext_t{ro_or_rw_ext};
}

void set_ro_or_rwe(const class_ro_t *ro) {
    ro_or_rw_ext_t{ro, &ro_or_rw_ext}.storeAt(ro_or_rw_ext, memory_order_relaxed);
}

void set_ro_or_rwe(class_rw_ext_t *rwe, const class_ro_t *ro) {
    // the release barrier is so that the class_rw_ext_t::ro initialization
    // is visible to lockless readers
    rwe->ro = ro;
    ro_or_rw_ext_t{rwe, &ro_or_rw_ext}.storeAt(ro_or_rw_ext, memory_order_release);
}

这个里面可能存储着const class_ro_t或者class_rw_ext_t，但只有class_ro_t的时候，就存储class_ro_t，当两者同时存在的时候，就存储class_rw_ext_t。也就是需要的时候才会加载class_rw_ext_t进行分配内存。

class_rw_ext_t *extAllocIfNeeded() {
    auto v = get_ro_or_rwe();
    if (fastpath(v.is<class_rw_ext_t *>())) {
        return v.get<class_rw_ext_t *>(&ro_or_rw_ext);
    } else {
        return extAlloc(v.get<const class_ro_t *>(&ro_or_rw_ext));
    }
}

class_rw_ext_t *
class_rw_t::extAlloc(const class_ro_t *ro, bool deepCopy)
{
    runtimeLock.assertLocked();

    auto rwe = objc::zalloc<class_rw_ext_t>();

    rwe->version = (ro->flags & RO_META) ? 7 : 0;

    method_list_t *list = ro->baseMethods();
    if (list) {
        if (deepCopy) list = list->duplicate();
        rwe->methods.attachLists(&list, 1);
    }

    // See comments in objc_duplicateClass
    // property lists and protocol lists historically
    // have not been deep-copied
    //
    // This is probably wrong and ought to be fixed some day
    property_list_t *proplist = ro->baseProperties;
    if (proplist) {
        rwe->properties.attachLists(&proplist, 1);
    }

    protocol_list_t *protolist = ro->baseProtocols;
    if (protolist) {
        rwe->protocols.attachLists(&protolist, 1);
    }

    set_ro_or_rwe(rwe, ro);
    return rwe;
}

搜索extAllocIfNeeded，会发现在以下方法中调用

static void
attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,int flags)

BOOL class_addProtocol(Class cls, Protocol *protocol_gen)

static bool 
_class_addProperty(Class cls, const char *name, const objc_property_attribute_t *attrs, unsigned int count, bool replace)

可以看出，当类的方法、协议、属性，除类本身外有额外添加的时候就会加载class_rw_ext_t分配内存。

class_rw_ext_t 结构如下

struct class_rw_ext_t {
    DECLARE_AUTHED_PTR_TEMPLATE(class_ro_t)
    class_ro_t_authed_ptr<const class_ro_t> ro;
    method_array_t methods;
    property_array_t properties;
    protocol_array_t protocols;
    char *demangledName;
    uint32_t version;
};

这里面存储着，*_array_t类型的方法、属性、协议。

char *demangledName;，可以找到如下方法，应该是Swift类OC化的类名。

const char *
protocol_t::demangledName() 
{
    if (!hasDemangledNameField())
        return mangledName;
    
    if (! _demangledName) {
        char *de = copySwiftV1DemangledName(mangledName, true/*isProtocol*/);
        if (! OSAtomicCompareAndSwapPtrBarrier(nil, (void*)(de ?: mangledName), 
                                               (void**)&_demangledName)) 
        {
            if (de) free(de);
        }
    }
    return _demangledName;
}

version应该是版本，这里如果是7的话当前类为元类，0的话为普通类

rwe->version = (ro->flags & RO_META) ? 7 : 0;

class_ro_t结构如下

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize;
#ifdef __LP64__
    uint32_t reserved;
#endif

    union {
        const uint8_t * ivarLayout;
        Class nonMetaclass;
    };

    explicit_atomic<const char *> name;
    // With ptrauth, this is signed if it points to a small list, but
    // may be unsigned if it points to a big list.
    void *baseMethodList;
    protocol_list_t * baseProtocols;
    const ivar_list_t * ivars;

    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties;

    method_list_t *baseMethods() const {
#if __has_feature(ptrauth_calls)
        method_list_t *ptr = ptrauth_strip((method_list_t *)baseMethodList, ptrauth_key_method_list_pointer);
        if (ptr == nullptr)
            return nullptr;

        // Don't auth if the class_ro and the method list are both in the shared cache.
        // This is secure since they'll be read-only, and this allows the shared cache
        // to cut down on the number of signed pointers it has.
        bool roInSharedCache = objc::inSharedCache((uintptr_t)this);
        bool listInSharedCache = objc::inSharedCache((uintptr_t)ptr);
        if (roInSharedCache && listInSharedCache)
            return ptr;

        // Auth all other small lists.
        if (ptr->isSmallList())
            ptr = ptrauth_auth_data((method_list_t *)baseMethodList,
                                    ptrauth_key_method_list_pointer,
                                    ptrauth_blend_discriminator(&baseMethodList,
                                                                methodListPointerDiscriminator));
        return ptr;
#else
        return (method_list_t *)baseMethodList;
#endif
    }
};

这里面主要存储着类的信息，包含大小、类名、成员变量、属性列表、方法列表、协议等信息。还有就是class_ro_t是只读的，存储的信息在编译时期就已经确定了，不能再更改，并且必要的时候可以清除，需要用的时候重磁盘中加载就好了。

class_rw_t 是可读可写的，它信息的存储是在运行的时候，需要用到的时候才会写入，并且一直存在于内存中。因为class_rw_ext_t没有成员变量列表，这就是为什么分类中不能添加成员变量的原因。

继续看下 *_array_t 和 *_list_t，查找代码可以找到如下代码

class *_array_t : public list_array_tt<*_t, *_list_t, *_list_t_authed_ptr>

*_array_t 继承于list_array_tt，里面存放着*_list_t。相当于一个二维数组，结构如下

class list_array_tt {
    struct array_t {
        uint32_t count;
        Ptr<List> lists[0];

        static size_t byteSize(uint32_t count) {
            return sizeof(array_t) + count*sizeof(lists[0]);
        }
        size_t byteSize() {
            return byteSize(count);
        }
    };
}

*_list_t里面存储着各自的*_t的对象，分别包含各自的信息，列如method_t（简化）

struct method_t {
    //…
    struct big {
        SEL name;
        const char *types;
        MethodListIMP imp;
    };
    //…
}

其他更多请查看源码，这里就不贴代码了。

在Objective-C中Class底层实现其实是一个objc_class类型的结构体

/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;

查看源码，可以看到objc_class的结构如下

struct objc_class : objc_object {
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags
}

objc_class继承于objc_object结构体，objc_object里面只有个isa_t isa指针，这里就不再分析，想了解更多可以看往期内容。

除了isa指针外，可以看到还有个Class类型的superclass，很明显这个是指向父类的指针。

然后就是cache_t类型的cache，从源码中查找其结构，只需要提取需要的部分。然后又发现CACHE_MASK_STORAGE宏对应的不同的情况，搜索宏CACHE_MASK_STORAGE可以找到如下

#if defined(__arm64__) && __LP64__
    #if TARGET_OS_OSX || TARGET_OS_SIMULATOR
    #define CACHE_MASK_STORAGE CACHE_MASK_STORAGE_HIGH_16_BIG_ADDRS
    #else
    #define CACHE_MASK_STORAGE CACHE_MASK_STORAGE_HIGH_16
    #endif
#elif defined(__arm64__) && !__LP64__
#define CACHE_MASK_STORAGE CACHE_MASK_STORAGE_LOW_4
#else
#define CACHE_MASK_STORAGE CACHE_MASK_STORAGE_OUTLINED
#endif

可得只有CACHE_MASK_STORAGE==CACHE_MASK_STORAGE_HIGH_16的时候才是需要的部分，可以简化cache_t结构如下

struct cache_t {
    explicit_atomic<uintptr_t> _bucketsAndMaybeMask;
    union {
        struct {
            explicit_atomic<mask_t>    _maybeMask;
#if __LP64__
            uint16_t                   _flags;
#endif
            uint16_t                   _occupied;
        };
        explicit_atomic<preopt_cache_t *> _originalPreoptCache;
    };

    // _bucketsAndMaybeMask is a buckets_t pointer in the low 48 bits
    // _maybeMask is unused, the mask is stored in the top 16 bits.
};

看注释，_bucketsAndMaybeMask是一个低48位存储着buckets_t的指针，_maybeMask在当前架构下unused，mask存在了_bucketsAndMaybeMask高16位里面。

搜索flags，发现参与FAST_CACHE_ALLOC_MASK位运算，应该FAST CACHE标志位

搜索_occupied，发现在setBucketsAndMask的时候，被赋值0，在cache_t::insert方法中找到调用了 _occupied++，insert是插入新方法缓存，所以这个值应该为当前cache已存储缓存方法的数量。

方法最终是存储在bucket_t中的，先看下是怎么存储的，搜索找到如下结构体

struct bucket_t {
private:
    // IMP-first is better for arm64e ptrauth and no worse for arm64.
    // SEL-first is better for armv7* and i386 and x86_64.
#if __arm64__
    explicit_atomic<uintptr_t> _imp;
    explicit_atomic<SEL> _sel;
#else
    explicit_atomic<SEL> _sel;
    explicit_atomic<uintptr_t> _imp;
#endif
};

可以看到这是一个存放方法指针和方法名的结构体，需要注意的是，arm64架构下方法实现在前方法名在后。

SEL _sel为什么是方法名字？搜索SEL可得，SEL 是一个struct objc_selector的指针

/// An opaque type that represents a method selector.
typedef struct objc_selector *SEL;

然后写以下代码测试下

SEL sel = @selector(run);
NSLog(@"%s",sel);

运行后输出结果如下图

可以看出_sel是指向方法名的指针。

void bucket_t::set(bucket_t *base, SEL newSel, IMP newImp, Class cls)方法可以看到具体写入过程

template<Atomicity atomicity, IMPEncoding impEncoding>
void bucket_t::set(bucket_t *base, SEL newSel, IMP newImp, Class cls)
{
    uintptr_t encodedImp = (impEncoding == Encoded
                            ? encodeImp(base, newImp, newSel, cls)
                            : (uintptr_t)newImp);

    // LDP/STP guarantees that all observers get
    // either imp/sel or newImp/newSel
    stp(encodedImp, (uintptr_t)newSel, this);
}

可以看到，stp写入的是方法名和加密后的方法，可以找到stp方法实现如下

stp(uintptr_t onep, uintptr_t twop, void *destp)
{
    __asm__ ("stp %" p "[one], %" p "[two], [%x[dest]]"
             : "=m" (((uintptr_t *)(destp))[0]),
               "=m" (((uintptr_t *)(destp))[1])
             : [one] "r" (onep),
               [two] "r" (twop),
               [dest] "r" (destp)
             : /* no clobbers */
             );
}

通过汇编把两个值写入到bucket_t里面，加快了写入速度。

分析完方法时如何写入的，继续看bucket_t是怎么写入的。在objc-cache.mm文件中搜索.set找到void cache_t::insert(SEL sel, IMP imp, id receiver)方法，简化后代码如下

void cache_t::insert(SEL sel, IMP imp, id receiver)
{
    mask_t newOccupied = occupied() + 1;
    unsigned oldCapacity = capacity(), capacity = oldCapacity;
    if (slowpath(isConstantEmptyCache())) {
        // Cache is read-only. Replace it.
        if (!capacity) capacity = INIT_CACHE_SIZE;
        reallocate(oldCapacity, capacity, /* freeOld */false);
    }
    else if (fastpath(newOccupied + CACHE_END_MARKER <= cache_fill_ratio(capacity))) {
        // Cache is less than 3/4 or 7/8 full. Use it as-is.
    }
#if CACHE_ALLOW_FULL_UTILIZATION
    else if (capacity <= FULL_UTILIZATION_CACHE_SIZE && newOccupied + CACHE_END_MARKER <= capacity) {
        // Allow 100% cache utilization for small buckets. Use it as-is.
    }
#endif
    else {
        capacity = capacity ? capacity * 2 : INIT_CACHE_SIZE;
        if (capacity > MAX_CACHE_SIZE) {
            capacity = MAX_CACHE_SIZE;
        }
        reallocate(oldCapacity, capacity, true);
    }

    bucket_t *b = buckets();
    mask_t m = capacity - 1;
    mask_t begin = cache_hash(sel, m);
    mask_t i = begin;

    // Scan for the first unused slot and insert there.
    // There is guaranteed to be an empty slot.
    do {
        if (fastpath(b[i].sel() == 0)) {
            incrementOccupied();
            b[i].set<Atomic, Encoded>(b, sel, imp, cls());
            return;
        }
        if (b[i].sel() == sel) {
            // The entry was added to the cache by some other thread
            // before we grabbed the cacheUpdateLock.
            return;
        }
    } while (fastpath((i = cache_next(i, m)) != begin));

    bad_cache(receiver, (SEL)sel);
}

先获取capacity，搜索capacity()方法，发现capacity = mask() + 1

unsigned cache_t::capacity() const
{
    return mask() ? mask()+1 : 0; 
}

继续搜索找到mask的赋值和取值过程

void cache_t::setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask)
{
    uintptr_t buckets = (uintptr_t)newBuckets;
    uintptr_t mask = (uintptr_t)newMask;

    ASSERT(buckets <= bucketsMask);
    ASSERT(mask <= maxMask);

    _bucketsAndMaybeMask.store(((uintptr_t)newMask << maskShift) | (uintptr_t)newBuckets, memory_order_relaxed);
    _occupied = 0;
}

mask_t cache_t::mask() const
{
    uintptr_t maskAndBuckets = _bucketsAndMaybeMask.load(memory_order_relaxed);
    return maskAndBuckets >> maskShift;
}

搜索setBucketsAndMask，可以找到

void cache_t::reallocate(mask_t oldCapacity, mask_t newCapacity, bool freeOld)
{
    bucket_t *oldBuckets = buckets();
    bucket_t *newBuckets = allocateBuckets(newCapacity);

    // Cache's old contents are not propagated. 
    // This is thought to save cache memory at the cost of extra cache fills.
    // fixme re-measure this

    ASSERT(newCapacity > 0);
    ASSERT((uintptr_t)(mask_t)(newCapacity-1) == newCapacity-1);

    setBucketsAndMask(newBuckets, newCapacity - 1);
    
    if (freeOld) {
        collect_free(oldBuckets, oldCapacity);
    }
}

可以得出capacity是buckets的长度，mask是capacity-1。

继续分析insert方法，

第一个if是当cache为空的时候，初始化buckets。

第二个和第三个if分别是新的长度小于等于容器的3/4或者小于等于容器的大小的时候什么也不做。

第四个是新的长度大于容器的长度时，以2倍的capacity扩容，并且释放之前的buckets。

在下面就是插入逻辑，通过buckets()获取bucket_t 数组指针，通过长度减1获取mask，再通过sel和mask算出插入的索引。

static inline mask_t cache_hash(SEL sel, mask_t mask) 
{
    uintptr_t value = (uintptr_t)sel;
#if CONFIG_USE_PREOPT_CACHES
    value ^= value >> 7;
#endif
    return (mask_t)(value & mask);
}

do while是插入方法。如果，当前索引下的bucket没有被使用或者是当前存入的方法和要存入的方法一样的话就会返回。如果有值且不一样的话，计算新的索引继续插入。具体索引算法如下

static inline mask_t cache_next(mask_t i, mask_t mask) {
    return i ? i-1 : mask;
}

最后就是，遍历完buckets，方法依旧没能插入成功，就会Crash。

综上，cache_t里面有个散列表buckets，buckets里面存储bucket_t，bucket_t里面存储着方法实现和方法名。方法存入buckets的索引是以sel和mask算出的。如果存入的方法大于buckets的长度后，会以2倍的长度扩容一个新的buckets，然后释放旧的。

Tagged Pointer是苹果在64bit设备引入的一种技术，是用于优化NSNumber、NSDate、NSString等小对象的存储。

查看objc4源码可以找到只要64位系统才支持

#if __LP64__  //文件objc-internal.h line 283
#define OBJC_HAVE_TAGGED_POINTERS 1
#endif

同时也可以找到，Tagged Pointer 所支持的类型，一个objc_tag_index_t类型的枚举，如下

    // 60-bit payloads
    OBJC_TAG_NSAtom            = 0, 
    OBJC_TAG_1                 = 1, 
    OBJC_TAG_NSString          = 2, 
    OBJC_TAG_NSNumber          = 3, 
    OBJC_TAG_NSIndexPath       = 4, 
    OBJC_TAG_NSManagedObjectID = 5, 
    OBJC_TAG_NSDate            = 6,

    // 60-bit reserved
    OBJC_TAG_RESERVED_7        = 7, 

    // 52-bit payloads
    OBJC_TAG_Photos_1          = 8,
    OBJC_TAG_Photos_2          = 9,
    OBJC_TAG_Photos_3          = 10,
    OBJC_TAG_Photos_4          = 11,
    OBJC_TAG_XPC_1             = 12,
    OBJC_TAG_XPC_2             = 13,
    OBJC_TAG_XPC_3             = 14,
    OBJC_TAG_XPC_4             = 15,
    OBJC_TAG_NSColor           = 16,
    OBJC_TAG_UIColor           = 17,
    OBJC_TAG_CGColor           = 18,
    OBJC_TAG_NSIndexSet        = 19,
    OBJC_TAG_NSMethodSignature = 20,
    OBJC_TAG_UTTypeRecord      = 21,

ARM64位的设备，tags在最低位，扩展的tags在最高位。64位的Mac，tags存储在LSB（Least Significant Bit 最低位）。其它情况比如模拟器和32位的真机，tag存储在MSB（Most Significant Bit 最高位）。

#if __arm64__
// ARM64 uses a new tagged pointer scheme where normal tags are in
// the low bits, extended tags are in the high bits, and half of the
// extended tag space is reserved for unobfuscated payloads.
#   define OBJC_SPLIT_TAGGED_POINTERS 1
#else
#   define OBJC_SPLIT_TAGGED_POINTERS 0
#endif

#if (TARGET_OS_OSX || TARGET_OS_MACCATALYST) && __x86_64__
    // 64-bit Mac - tag bit is LSB
#   define OBJC_MSB_TAGGED_POINTERS 0
#else
    // Everything else - tag bit is MSB
#   define OBJC_MSB_TAGGED_POINTERS 1
#endif

这里主要写下ARM64位下的情况，其他的如果感兴趣可以查看源码。写之前，先新建个iOS工程，然后写入以下代码，并在最后以后打上断点，然后运行

NSString *str1 = @"a";
NSString *str2 = [NSString stringWithFormat:@"a"];
NSLog(@"%@ %p %@",str1, str1, str1.class);
NSLog(@"%@ %p %@",str2, str2, str2.class);
NSLog(@"END");

然后会看到如下输出结果，并且会进入调试状态

str2的Class 是NSTaggedPointerString，确实是TaggedPoint，但是内存地址很大，并看不出来数据是怎么存储的。

然后打开Xcode的内存查看窗口，路径Debug->Debug Workflow->View Memory如下图

并在打开窗口的最下方Address里面搜索两个内存地址，str2的地址确实是搜索不到的，证明这个指针并没有指向任何内存。

这个地址是怎么生成的呢？这时候需要从源码中寻找答案了。在源码中搜索TaggedPoint，找到一个_objc_makeTaggedPointer的方法

static inline void * _Nonnull
_objc_makeTaggedPointer(objc_tag_index_t tag, uintptr_t value)
{
    if (tag <= OBJC_TAG_Last60BitPayload) {
        uintptr_t result =
            (_OBJC_TAG_MASK | 
             ((uintptr_t)tag << _OBJC_TAG_INDEX_SHIFT) | 
             ((value << _OBJC_TAG_PAYLOAD_RSHIFT) >> _OBJC_TAG_PAYLOAD_LSHIFT));
        return _objc_encodeTaggedPointer(result);
    } else {
        uintptr_t result =
            (_OBJC_TAG_EXT_MASK |
             ((uintptr_t)(tag - OBJC_TAG_First52BitPayload) << _OBJC_TAG_EXT_INDEX_SHIFT) |
             ((value << _OBJC_TAG_EXT_PAYLOAD_RSHIFT) >> _OBJC_TAG_EXT_PAYLOAD_LSHIFT));
        return _objc_encodeTaggedPointer(result);
    }
}

可以看到，这里区分了60位playload和52位payload。点objc_tag_index_t进去看下

    OBJC_TAG_Last60BitPayload  = 6, 
    OBJC_TAG_First52BitPayload = 8, 

这里先分析OBJC_TAG_Last60BitPayload的情况，可以查看到小于等于6包含的类型如下

    // 60-bit payloads
    OBJC_TAG_NSAtom            = 0, 
    OBJC_TAG_1                 = 1, 
    OBJC_TAG_NSString          = 2, 
    OBJC_TAG_NSNumber          = 3, 
    OBJC_TAG_NSIndexPath       = 4, 
    OBJC_TAG_NSManagedObjectID = 5, 
    OBJC_TAG_NSDate            = 6,

点击方法内的宏定义进去，可以找到位移操作所对应的值，这里只截取ARM64所对应的

#if OBJC_SPLIT_TAGGED_POINTERS
#   define _OBJC_TAG_MASK (1UL<<63)
#   define _OBJC_TAG_INDEX_SHIFT 0
#   define _OBJC_TAG_SLOT_SHIFT 0
#   define _OBJC_TAG_PAYLOAD_LSHIFT 1
#   define _OBJC_TAG_PAYLOAD_RSHIFT 4
#   define _OBJC_TAG_EXT_MASK (_OBJC_TAG_MASK | 0x7UL)
#   define _OBJC_TAG_NO_OBFUSCATION_MASK ((1UL<<62) | _OBJC_TAG_EXT_MASK)
#   define _OBJC_TAG_CONSTANT_POINTER_MASK \
        ~(_OBJC_TAG_EXT_MASK | ((uintptr_t)_OBJC_TAG_EXT_SLOT_MASK << _OBJC_TAG_EXT_SLOT_SHIFT))
#   define _OBJC_TAG_EXT_INDEX_SHIFT 55
#   define _OBJC_TAG_EXT_SLOT_SHIFT 55
#   define _OBJC_TAG_EXT_PAYLOAD_LSHIFT 9
#   define _OBJC_TAG_EXT_PAYLOAD_RSHIFT 12

通过分析代码可得，指针的最高1位是_OBJC_TAG_MASK，因为60位payload情况下，tag的最大值是6，二进制位110，可得最低3位是tag，然后返回的值还要通过_objc_encodeTaggedPointer处理

static inline void * _Nonnull
_objc_encodeTaggedPointer(uintptr_t ptr)
{
    uintptr_t value = (objc_debug_taggedpointer_obfuscator ^ ptr);
#if OBJC_SPLIT_TAGGED_POINTERS
    if ((value & _OBJC_TAG_NO_OBFUSCATION_MASK) == _OBJC_TAG_NO_OBFUSCATION_MASK)
        return (void *)ptr;
    uintptr_t basicTag = (value >> _OBJC_TAG_INDEX_SHIFT) & _OBJC_TAG_INDEX_MASK;
    uintptr_t permutedTag = _objc_basicTagToObfuscatedTag(basicTag);
    value &= ~(_OBJC_TAG_INDEX_MASK << _OBJC_TAG_INDEX_SHIFT);
    value |= permutedTag << _OBJC_TAG_INDEX_SHIFT;
#endif
    return (void *)value;
}

可以看到实际的值还需要异或一个objc_debug_taggedpointer_obfuscator，搜索可的这是一个随机值，并且是在iOS12开始引入的。

// tagged pointers are obfuscated by XORing with a random value
// decoded_obj = (obj ^ obfuscator)
OBJC_EXPORT uintptr_t objc_debug_taggedpointer_obfuscator
    OBJC_AVAILABLE(10.14, 12.0, 12.0, 5.0, 3.0);

继续搜索找到initializeTaggedPointerObfuscator(void)方法，可以看到objc_debug_taggedpointer_obfuscator确实是个随机值，并且至少2018后的dyld版本才生效

static void
initializeTaggedPointerObfuscator(void)
{
    if (!DisableTaggedPointerObfuscation && dyld_program_sdk_at_least(dyld_fall_2018_os_versions)) {
        arc4random_buf(&objc_debug_taggedpointer_obfuscator,
                       sizeof(objc_debug_taggedpointer_obfuscator));
        objc_debug_taggedpointer_obfuscator &= ~_OBJC_TAG_MASK;
#if OBJC_SPLIT_TAGGED_POINTERS
        objc_debug_taggedpointer_obfuscator &= ~(_OBJC_TAG_EXT_MASK | _OBJC_TAG_NO_OBFUSCATION_MASK);
        int max = 7;
        for (int i = max - 1; i >= 0; i--) {
            int target = arc4random_uniform(i + 1);
            swap(objc_debug_tag60_permutations[i],
                 objc_debug_tag60_permutations[target]);
        }
#endif
    } else {
        objc_debug_taggedpointer_obfuscator = 0;
    }
}

再搜索DisableTaggedPointerObfuscation，发现这是个环境变量，是可以设置关闭混淆的

OPTION( DisableTaggedPointerObfuscation, OBJC_DISABLE_TAG_OBFUSCATION,    "disable obfuscation of tagged pointers")

为了方便分析，回到工程，把OBJC_DISABLE_TAG_OBFUSCATION设置为YES

运行会看到如下结果

str2已经不再是混淆的状态，然后在调试窗口输入 p/t str2，查看下指针的2进制结果如下

可以看出，最高位为1，最低3位，十进制为2，OBJC_TAG_NSString=2，可以证明对函数的分析是正确的。

查ASCII 表可得，a的二进制为01100001，分析可得如下

TAG和值中间4位表示什么意思呢？查资料得，这4位是Type Index，表示数据的类型。然后写以下代码帮助分析，并在最后一行打上断点

    NSNumber *number1 = [NSNumber numberWithChar:2];
    NSNumber *number2 = [NSNumber numberWithShort:2];
    NSNumber *number3 = [NSNumber numberWithInt:2];

    NSLog(@"%@ %p %@",number1, number1, number1.class);
    NSLog(@"%@ %p %@",number2, number2, number2.class);
    NSLog(@"%@ %p %@",number3, number3, number3.class);
    NSLog(@"END");

运行后，在调试窗口，分别通过p/t输出3个指针的二进制，可得如下

可以看出，不同类型值确实是不一样的，char为0、short为1，int为2。然后看到这个显示的是__NSCFNumber类型，查看CF源码，在CFNumber里面找到如下定义

static const struct {
    uint16_t canonicalType:5;	// canonical fixed-width type
    uint16_t floatBit:1;	// is float
    uint16_t storageBit:1;	// storage size (0: (float ? 4 : 8), 1: (float ? 8 : 16) bits)
    uint16_t lgByteSize:3;	// base-2 log byte size of public type
    uint16_t unused:6;
} __CFNumberTypeTable[] = {
    //省略
    /* kCFNumberCharType */	{kCFNumberSInt8Type, 0, 0, 0, 0},
    /* kCFNumberShortType */	{kCFNumberSInt16Type, 0, 0, 1, 0},
    /* kCFNumberIntType */	{kCFNumberSInt32Type, 0, 0, 2, 0},
    //省略
};

发现Type Index的值可以和这个结构体里面的lgByteSize对应上。

综上，可以知道Tagged Pointer在OBJC_TAG_Last60BitPayload情况下，最高1位是标志位，因为define _OBJC_TAG_MASK (1UL<<63)，是1的话，就表示这个值为Tagged Pointer。

static inline bool 
_objc_isTaggedPointer(const void * _Nullable ptr)
{
    return ((uintptr_t)ptr & _OBJC_TAG_MASK) == _OBJC_TAG_MASK;
}

低3位表示tag，区分Tagged Pointer的类型，低4-7位区分数据类型。所有剩下的56位可以表示数据。最高位预留符号位，那么剩下55位可表示理论上最大数字范围就是-2^55~2^55-1这么大，十进制就是-36028797018963968～36028797018963967。然后写以下代码测试下

    NSNumber *number1 = [NSNumber numberWithLong:36028797018963967];
    NSNumber *number2 = [NSNumber numberWithLong:36028797018963968];
    NSNumber *number3 = [NSNumber numberWithLong:-36028797018963968];
    NSNumber *number4 = [NSNumber numberWithLong:-36028797018963967];

    NSLog(@"%@ %p %@",number1, number1, number1.class);
    NSLog(@"%@ %p %@",number2, number2, number2.class);
    NSLog(@"%@ %p %@",number3, number3, number3.class);
    NSLog(@"%@ %p %@",number4, number4, number4.class);

可以看到输出结果

可见最大值确实是2^55-1，但是最小值却是-2^55+1，为什么呢？再写以下代码测试，断点打在最后一行。

    NSNumber *number1 = [NSNumber numberWithLong:-36028797018963968];
    NSNumber *number2 = [NSNumber numberWithLong:-36028797018963967];
    NSNumber *number3 = [NSNumber numberWithLong:-36028797018963966];

    NSLog(@"%@ %p %@",number1, number1, number1.class);
    NSLog(@"%@ %p %@",number2, number2, number2.class);
    NSLog(@"%@ %p %@",number3, number3, number3.class);
    NSLog(@"END");

运行代码，在调试窗口分别p/t输出number2和number3的值

可以看出，最小值+1的时候，也就是值为-36028797018963966的时候，数据位的产生了进位。如果最小值-1的话，存储数值的所有位都为0了,还需要多一位来显示数据才可以。所以最小值为-2^55 + 1。

所以Tagged Pointer可表示的数字范围是-2^55+1 ~ 2^55-1，超出这个范围的数字，NSNumber会转换为普通的Objective-C对象分配在堆上。

self和super在开发中经常遇到，最常见的场景就是 self=[super init]，很明显这是两个不同的关键字，肯定是有区别的。

在写区别之前，先新建个工程，然后创建个Ghost类文件，在文件中写入以下方法并调用。

- (void)run{
    NSLog(@"%@", [self class]);
    NSLog(@"%@", [super class]);
    
    NSLog(@"%@", [self superclass]);
    NSLog(@"%@", [super superclass]);
}

会神奇的发现，self和super调用相同方法，输入的结果也是一样的。

为什么呢？Objective-C的底层是C/C++封装的，把上面代码转成C++代码以更好的分析。转代码之前，先把代码简化为以下，可以更方面查看。

- (void)run{
    [self class];
    [super class];
    
    [self superclass];
    [super superclass];
}

打开终端，进入到Ghost.m目录，然后执行以下命令

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc Ghost.m -o Ghost.cpp

然后打开Ghost.cpp文件，搜索NSLog就可以找到以下代码

static void _I_Ghost_run(Ghost * self, SEL _cmd) {
    ((Class (*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("class"));
    ((Class (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("Ghost"))}, sel_registerName("class"));
    ((Class (*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("superclass"));
    ((Class (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("Ghost"))}, sel_registerName("superclass"));
}

简化代码，只留下了 self和super方法调用相关内容

objc_msgSend(self, sel_registerName("class"));

objc_msgSendSuper((__rw_objc_super){self, class_getSuperclass(objc_getClass("Ghost"))},
sel_registerName("class"));

objc_msgSend(self, sel_registerName("superclass"));

objc_msgSendSuper((__rw_objc_super){self, class_getSuperclass(objc_getClass("Ghost"))}, sel_registerName("superclass"));

发现self的调用被转换成了objc_msgSend调用，就是常见的方法调用，这里就不多做解释。

而super调用的地方，被转换成了objc_msgSendSuper调用，在objc4-818.2源码中搜索这个方法定义找到如下

objc_msgSendSuper(struct objc_super * _Nonnull super, SEL _Nonnull op, ...)

struct objc_super的定义如下

struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained _Nonnull id receiver;

    /// Specifies the particular superclass of the instance to message. 
    __unsafe_unretained _Nonnull Class super_class;
};

可以看出，第一个参数是实例对象，第二个参数是实例对象的父类，因为Ghost对象继承于NSObject那上面关于super调用的相关代码 就可以简化成如下

objc_msgSendSuper({self, [NSObject class]}, @selector(class));
objc_msgSendSuper({self, [NSObject class]}, @selector(superclass));

objc_msgSendSuper方法里面做了什么呢？源码中搜索下，找到各个平台的汇编代码，arm平台相关的代码如下(arm64汇编比这个复杂，整体逻辑是一样的)

ENTRY _objc_msgSendSuper

ldr    r9, [r0, #CLASS]    // r9 = struct super->class
CacheLookup NORMAL, _objc_msgSendSuper
// cache hit, IMP in r12, eq already set for nonstret forwarding
ldr    r0, [r0, #RECEIVER]    // load real receiver
bx    r12            // call imp

CacheLookup2 NORMAL, _objc_msgSendSuper
// cache miss
ldr    r9, [r0, #CLASS]    // r9 = struct super->class
ldr    r0, [r0, #RECEIVER]    // load real receiver
b    __objc_msgSend_uncached

END_ENTRY _objc_msgSendSuper

汇编的大概意思是，r0(第一个参数 super)中取出class(这里是NSObject) 存入r9, 然后从这个class方法缓存中找方法的实现，如果找到就放入r12中，再把receiver(这里是self)放入如r0中，然后再调用方法。再下面是如果在方法缓存中没找到方法实现的话，把superclass放入r9，把receiver放入r0，然后跳转到__objc_msgSend_uncached方法，汇编代码如下

STATIC_ENTRY __objc_msgSend_uncached

// THIS IS NOT A CALLABLE C FUNCTION
// Out-of-band r9 is the class to search

MethodTableLookup NORMAL    // returns IMP in r12
bx    r12

END_ENTRY __objc_msgSend_uncached

意思是从r9中搜索方法实现，MethodTableLookup 会把方法实现放到r12寄存其中，bx r12就是方法调用。

上面逻辑简化就是，从r9中(也就是父类)搜索方法实现，搜索到放入r12中，然后调用。了解arm汇编的就会知道，在 Objective-C中r0寄存器中的对象就是这个方法的调用者。

总是，self其实就是一个指向当前调用对象的指针，在调用方法时会作为第一个参数传入objc_msgSend方法中。super是一个编译器指示符，在编译的时候会被替换为

objc_msgSendSuper(struct objc_super * _Nonnull super, SEL _Nonnull op, ...)

并且会把当前调用对象和对象的父类放入到objc_super结构体中作为方法的第一个参数。

而objc_msgSendSuper的本质就是，从父类的方法列表中查找方法，让当前类调用。因为class和superclass的方法实现本身就在NSObject中，然后调用者其实都是self，也就是为什么输出结果都是一样的原因。

公有云笔记有很多，就不一一列举。这些云笔记各有各的特点，不足的是数据不可控，并且部分功能需要付费才能使用。

为知笔记也算是老牌的笔记了，但是知道的人却不是很多。为知笔记服务端提供了docker镜像，只需要简单几步，就可以将为知笔记服务端部署在自己的服务器上。选择它的原因主要有以下几点。

1、多端丰富，PC、Mac、iOS、安卓都有，且支持多端同步。

2、有加密功能，有些个人资料可以加密处理。

3、笔记支持多级目录，并且支持多格式导出。

4、私有版5 用户以下免费使用。

我的服务器是腾讯云的云主机，系统是Ubuntu Server 18.04.1 64位。因为为知笔记是docker镜像的，所以装之前需要先安装docker。首先通过终端连接到服务器，然后在终端按顺序输入以下命令。

1、先卸载旧版本的docker；

sudo apt-get remove docker docker-engine docker.io containerd runc

2、更新apt包索引，并安装以下包以允许apt通过 HTTPS 使用存储库；

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg lsb-release

3、添加 Docker 的官方 GPG 密钥；

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

4、设置存储库；

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

5、更新apt包索引，并安装docker；

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

6、安装完成后，每次执行都需要sudo才可以正常执行，可以通过以下命令解决

sudo groupadd docker
sudo usermod -aG docker $USER

7、设置开机启动，服务器重启后docker服务可以自启动。

sudo systemctl enable docker.service
sudo systemctl enable containerd.service

现在在终端输入 docker --version 能看到docker的版本就证明安装成功了。以上更详细内容可以查看官方说明文档。

docker安装完成后，现在就可以部署为知笔记了。在终端输入以下命令

cd ~
mkdir wizdata

这个是进入当前用户目录，创建wizdata目录，也是可以创建其他位置的，不过后续命令需要对应修改，新手不建议更改目录。

docker run --name wiz --restart=always -it -d -v  ~/wizdata:/wiz/storage -v  /etc/localtime:/etc/localtime -p 8080:80 -p 9269:9269/udp  wiznote/wizserver

如果wizdata不在用户根目录，需要把~/wizdata改到对应的路径。等命令执行完成，没报错的话私有笔记就部署完成了。

打开浏览器，在地址栏输入 服务器的IP地址:8080，敲回车。就可以看到如下界面

默认管理员账号：admin@wiz.cn，密码：123456。请在部署完成后，使用这个账号，登录网页版，然后修改管理员密码。

以上更多内容可以查看为知笔记官方文档。

虽然部署完成了，但是又有些问题需要考虑下。一直使用IP加端口访问的方式不够美观，并且如果服务器换IP或者端口换了，客户端都需要更改，用域名访问才是更好的解决办法。注册域名和域名解析在这里不就说了。

这里主要说下nginx的安装了配置。安装比较简单，输入以下命令即可

sudo apt-get install nginx

安装完成后，在浏览器中输入服务器的IP地址，就可以看到nginx的说明界面。如果看不到可能还需要执行以下命令，打开nginx对应的端口并且启动nginx。

sudo ufw allow 'Nginx Full'
sudo systemctl restart nginx

然后就是申请免费的HTTPS证书，可以通过acme.h申请，详细内容看这里。

证书申请完成后，进入nginx目录创建域名的配置文件，配置nginx反向代理。

cd /etc/nginx/sites-available/

通过上面命令进入的nginx的配置文件目录，然后

vi 域名.conf //域名替换为为知笔记对应的域名，用于区分

然后按 i 进入编辑模式，复制以下内容，把中文替换为相应域名，再粘贴进去即可。

server {
    listen 80;
    server_name 为知笔记域名;
    return	301 https://为知笔记域名$request_uri;
}

server{
    listen 443 ssl;
    server_name 为知笔记域名;
    ssl on;

    ssl_certificate 	/etc/nginx/ssl/证书目录/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/证书目录/key.pem;
    ssl_protocols       TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers         ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;

    access_log   /var/log/nginx/wzi.log;
    error_log    /var/log/nginx/wzi_error.log;

    root /var/www/blog/system/nginx-root; # Used for acme.sh SSL verification (https://acme.sh)

    location / {
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header x-wiz-real-ip $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_pass http://127.0.0.1:8080;
    }

    location ~ /.well-known {
        allow all;
    }

    client_max_body_size 50m;
}

然后 按ESC退出编辑模式，在终端键入:wq! 回车保存并退出编辑器。官方配置看这里

配置文件完成后，其实还并没有生效。只有在sites-enabled目录下的配置文件才是启用的配置。现在就需要进入创建个软链接指向刚创建的文件即可，然后重启nginx，如果不报错，到这里私有笔记就部署成功了。

sudo ln -s /etc/nginx/sites-available/域名.conf /etc/nginx/sites-enabled/域名.conf

sudo systemctl restart nginx 

实例对象的isa指针指对象的类，类对象的isa指针指向对象的元类，这种说法对吗？

对，但也不完全对。因为在arm64架构之前，isa确实只存储着Class、Meta-Class对象的内存地址，但是在之后苹果对isa进行了优化，变成了一个共用体结构，使其能用位域存储更多的信息。而指向Class的指针需要按位与个ISA_MASK才可以获取到。

上图是一张很经典的指针指向图，虽然已经不完全正确，但是还是可以作为参考的。

上一篇文章提到，isa指针被优化成union isa_t类型，源码中搜索可以在objc-private.h文件中找到定义，去除方法简化后的代码如下

union isa_t {
    uintptr_t bits;
private:
    Class cls;
public:
    struct {
        ISA_BITFIELD;  // defined in isa.h
    };
};

然后再isa.h文件里面找到ISA_BITFIELD的定义，忽略x86和模拟器，把定义替换到以上代码中，可以变成如下

union isa_t {
    uintptr_t bits;
private:
    Class cls;
public:
    struct {
        uintptr_t nonpointer        : 1;
        uintptr_t has_assoc         : 1;
        uintptr_t has_cxx_dtor      : 1;
        uintptr_t shiftcls          : 33; /*MACH_VM_MAX_ADDRESS 0x1000000000*/ 
        uintptr_t magic             : 6;
        uintptr_t weakly_referenced : 1;
        uintptr_t unused            : 1;
        uintptr_t has_sidetable_rc  : 1; 
        uintptr_t extra_rc          : 19
    };
};

那这些结构体里面的东西都表示什么意思呢？可以在源码里面搜索找下答案，我的源码版本是objc4-818.2，不同版本可能不太一样。

搜索isa.nonpointer; 会找到一个 hasNonpointerIsa()方法里面使用了，然后继续搜索hasNonpointerIsa()，会发现在objc-object.h文件里面有两个地方定义了这个函数，为什么会有两个呢，不会冲突吗？所以一定有条件编译指令区分编译。继续查找代码，会发现以下内容(简化代码)

#if SUPPORT_NONPOINTER_ISA  //line 172
inline bool 
objc_object::hasNonpointerIsa()
{
    return isa.nonpointer;
}
#else //line 952
inline bool 
objc_object::hasNonpointerIsa()
{
    return false;
}
#endif //1217

对比下很明显可以看出，在SUPPORT_NONPOINTER_ISA部分，返回值应该为true，也就是当nonpointer为1时，表示优化过的指针。

搜索isa.has_assoc; 找到个hasAssociatedObjects()方法被调用，然后搜索has_assoc = 找到setHasAssociatedObjects()方法中被设置为true，但是并没有设置为false的地方。所以当这个值为1的时候，表示被设置过关联对象。

搜索isa.has_cxx_dtor; 找到hasCxxDtor()，然后搜索hasCxxDtor()方法在objc-private.h文件中找到以下注释

// object may have -.cxx_destruct implementation?
bool hasCxxDtor();

可以看出，这个值表示对象是否有C++的析构函数。苹果标识这些的作用是什么呢？

搜索hasCxxDtor();方法，发现objc-runtime-new.mm文件中如下代码

void *objc_destructInstance(id obj) 
{
    if (obj) {
        // Read all of the flags at once for performance.
        bool cxx = obj->hasCxxDtor();
        bool assoc = obj->hasAssociatedObjects();

        // This order is important.
        if (cxx) object_cxxDestruct(obj);
        if (assoc) _object_remove_assocations(obj, /*deallocating*/true);
        obj->clearDeallocating();
    }

    return obj;
}

可以看出，在对象释放的时候，用于判断是否有关联对象和C++的析构函数，如果没有的话，可以更快的释放对象。

搜索shiftcls，并没有找到有用的信息。不过看名字猜测一定和类有关系，如果获取类指针的话，需要在现有的isa指针上按位与ISA_MASK，查看下ISA_MASK的值为0x0000000ffffffff8ULL，复制粘贴到计算器如图

看到值为1的位的长度正好和shiftcls的长度对应上，按照按位与的逻辑，保留值为1对应部分的值。可以确定shiftcls 存储的Class、Meta-Class对象的内存地址信息。

源码中搜索magic，并没有找到太多有用的信息，通过查询资料，得知这个值是为了在调试的时候分辨对象是否未完成初始化。

weakly_referenced 从字面意思就能看出，这个标识是否有弱引用。相同方法搜索得如下代码

// object may be weakly referenced?
bool isWeaklyReferenced();

搜索extra_rc; 会找到如下代码

inline uintptr_t 
objc_object::rootRetainCount()
{
    if (isTaggedPointer()) return (uintptr_t)this;

    sidetable_lock();
    isa_t bits = __c11_atomic_load((_Atomic uintptr_t *)&isa.bits, __ATOMIC_RELAXED);
    if (bits.nonpointer) {
        uintptr_t rc = bits.extra_rc;
        if (bits.has_sidetable_rc) {
            rc += sidetable_getExtraRC_nolock();
        }
        sidetable_unlock();
        return rc;
    }

    sidetable_unlock();
    return sidetable_retainCount();
}

可以看到，extra_rc存储值为对象的引用计数，同时可以看到当has_sidetable_rc为1的时候，还需要加上另一个值才能得到准确的引用计数。

什么时候才会把引用计数写到sidetable中呢。搜索has_sidetable_rc = true 得到如下代码

    if (slowpath(carry)) {
        // newisa.extra_rc++ overflowed
        if (variant != RRVariant::Full) {
            ClearExclusive(&isa.bits);
            return rootRetain_overflow(tryRetain);
        }
        // Leave half of the retain counts inline and
        // prepare to copy the other half to the side table.
        if (!tryRetain && !sideTableLocked) sidetable_lock();
        sideTableLocked = true;
        transcribeToSideTable = true;
        newisa.extra_rc = RC_HALF;
        newisa.has_sidetable_rc = true;
    }

发现newisa.extra_rc++ overflowed，当引用计数过大无法存入到extra_rc，会把引用计数写入到sidetable里面，并把has_sidetable_rc设置为true，extra_rc的值设置为RC_HALF，查看宏定义的值define RC_HALF  (1ULL<<18)，可得extra_rc最大存储引用计数为2^18 - 1 = 262143。

通过以上内容可以看出，优化后的指针可以存储很多内容，并且可以更有效率的获取存储的内容。

作为一个iOS开发，接触最多的可能就是Objective-C语言了，众所周知Objective-C是一种面向对象的语言，苹果用C/C++为其封装了成员变量、方法的存储和方法调用逻辑，但是具体的实现并没有暴露给我们。

分析之前，需要先新建个Command Line Tool工程，然后再main文件中写入以下代码：

@interface Ghost : NSObject
{
    int age;
}
@end

@implementation Ghost
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Ghost *ghost = [[Ghost alloc] init];
    }
    return 0;
}

然后需要把它转成C/C++代码，打开终端，进入main文件所在的目录，执行以下命令

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main_arm64.cpp

这个命令的意思是，把main.m文件中的代码，转换成iOS平台对应的C++代码。接下来打开main_arm64.cpp文件，搜索类名 Ghost，会找到Ghost_IMPL的结构体如下

typedef struct objc_object Ghost;
struct Ghost_IMPL {
	struct NSObject_IMPL NSObject_IVARS;
        int age;
};

从这里不难发现Objective-C对象的本质就是objc_object类型的结构体。结构体里面有一个NSObject_IMPL类型的结构体和一个int类型名字为age的变量，这个NSObject_IMPL又是什么呢？可以在main_arm64.cpp文件里面搜索NSObject_IMPL，会发现一个结构体如下

typedef struct objc_object NSObject;
struct NSObject_IMPL {
	Class isa;
};

不难猜出，这个应该是NSobject类的底层实现，通过Xcode进入NSObject的头文件，会发现类的实现是这样的

@interface NSObject <NSObject> {
    Class isa  OBJC_ISA_AVAILABILITY;
}

上下对比下，可以证明猜测是正确的。并且可以看到NSObject对象里面只有一个 Class 类型的isa指针。

这个Class类型又是什么呢，可以通过Xcode进入objc.h找到如下代码

typedef struct objc_class *Class;

struct objc_object {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
};

typedef struct objc_object *id;

这里能看到Class是struct objc_class类型的指针，同时可以看到id是struct objc_object类型的指针。

那么struct objc_class内部又是什么样子的结构呢，Xcode并不能跳到定义的地方，这时候就需要查看苹果开源的代码了。

从这里下载最新源码，版本号最大的就是苹果开源的最新的代码。下载完成后解压,我下载的（objc4-818.2），用Xcode打开工程。这时候搜索struct objc_class，发现有两个文件定义了这个结构体（objc-runtime-new.h和objc-runtime-old.h），忽略old直接看new,可以找到如下定义（line 1688）

struct objc_class : objc_object {
    //省略...
    // Class ISA;
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;   
    //省略...
}

可以看到objc_class是继承于objc_object的结构体，然后再搜索下struct objc_object，会在objc-private.h找到如下定义

struct objc_object {
private:
    isa_t isa;
//省略 ...
}

发现isa指针并不是Class类型的了，那是因为苹果在64位系统，为了让指针存储更多的数据，isa指针优化成union isa_t的类型，找到isa_t的定义

union isa_t {
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }
    uintptr_t bits;

private:
    Class cls;
    void setClass(Class cls, objc_object *obj);
    Class getClass(bool authenticated);
    Class getDecodedClass(bool authenticated);
};

进入getClass方法里面，会发现 clsbits &= ISA_MASK，可以得知现在指向Class的指针需要再按位与ISA_MASK后才可以得到。

综上，Objective-C 中

1、实例对象是objc_object类型的结构体，里面包含isa指针和成员变量。

2、类对象是objc_class类型的结构体，因为继承于objc_object类型，所以同样包含isa指针，还有superclass指针等类的一些信息。

3、元类也是Class类型，同样也是objc_class类型的结构体。