Ivar *
class_copyIvarList(Class cls, unsigned int *outCount)
{
    const ivar_list_t *ivars;
    Ivar *result = nil;
    unsigned int count = 0;

    if(! cls) {if (outCount) *outCount = 0;
        return nil;
    }

    mutex_locker_t lock(runtimeLock);

    assert(cls->isRealized());

    if ((ivars = cls->data()->ro->ivars)  &&  ivars->count) {
        result = (Ivar *)malloc((ivars->count+1) * sizeof(Ivar));

        for (auto& ivar : *ivars) {
            if(! ivar.offset)continue;  // anonymous bitfield
            result[count++] = &ivar;
        }
        result[count] = nil;
    }

    if (outCount) *outCount = count;
    returnresult; } Duplicate codeCopy the code

objc_property_t *
class_copyPropertyList(Class cls, unsigned int *outCount)
{
    if(! cls) {if (outCount) *outCount = 0;
        return nil;
    }

    mutex_locker_t lock(runtimeLock);

    checkIsKnownClass(cls);
    assert(cls->isRealized());

    auto rw = cls->data();

    property_t **result = nil;
    unsigned int count = rw->properties.count();
    if (count > 0) {
        result = (property_t **)malloc((count + 1) * sizeof(property_t *));

        count = 0;
        for (auto& prop : rw->properties) {
            result[count++] = ∝
        }
        result[count] = nil;
    }

    if (outCount) *outCount = count;
    return(objc_property_t *)result; } Duplicate codeCopy the code

struct class_ro_t {
    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;
    protocol_list_t * baseProtocols;
    const ivar_list_t * ivars;

    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties;

    method_list_t *baseMethods() const {
        returnbaseMethodList; }}; struct class_rw_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; property_array_t properties; protocol_array_t protocols; Class firstSubclass; Class nextSiblingClass; char *demangledName;#if SUPPORT_INDEXED_ISA
    uint32_t index;
#endif} Duplicate codeCopy the code

static void methodizeClass(Class cls) { runtimeLock.assertLocked(); bool isMeta = cls->isMetaClass(); auto rw = cls->data(); auto ro = rw->ro; / / = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = / / ellipsis... // ======================================= property_list_t *proplist = ro->baseProperties;if(proplist) { rw->properties.attachLists(&proplist, 1); } / / = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = / / ellipsis... // ======================================= // Attach categories. category_list *cats = unattachedCategoriesForClass(cls,true /*realizing*/);
    attachCategories(cls, cats, false /*don't flush caches*/); / / = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = / / ellipsis... // ======================================= if (cats) free(cats); } Duplicate codeCopy the code

property_list_t *proplist = ro->baseProperties;
if(proplist) { rw->properties.attachLists(&proplist, 1); Void attachLists(List* const * addedLists, uint32_t addedCount) {if (addedCount == 0) return;

        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; /* struct array_t {uint32_t count; List* lists[0]; }; */ 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])); }} Copy the codeCopy the code

static void 
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    if(! cats)return;
    if (PrintReplacedMethods) printReplacements(cls, cats);

    bool isMeta = cls->isMetaClass();

    // fixme rearrange to remove these intermediate allocations
    method_list_t **mlists = (method_list_t **)
        malloc(cats->count * sizeof(*mlists));
    property_list_t **proplists = (property_list_t **)
        malloc(cats->count * sizeof(*proplists));
    protocol_list_t **protolists = (protocol_list_t **)
        malloc(cats->count * sizeof(*protolists));

    // Count backwards through cats to get newest categories first
    int mcount = 0;
    int propcount = 0;
    int protocount = 0;
    int i = cats->count;
    bool fromBundle = NO;
    while (i--) {
        auto& entry = cats->list[i];

        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            mlists[mcount++] = mlist;
            fromBundle |= entry.hi->isBundle();
        }

        property_list_t *proplist = 
            entry.cat->propertiesForMeta(isMeta, entry.hi);
        if (proplist) {
            proplists[propcount++] = proplist;
        }

        protocol_list_t *protolist = entry.cat->protocols;
        if(protolist) { protolists[protocount++] = protolist; } } auto rw = cls->data(); Preparelists (CLS, mLists, McOunt, NO, fromBundle); prepareLists (CLS, mLists, McOunt, NO, fromBundle); rw->methods.attachLists(mlists, mcount); free(mlists);if(flush_caches && mcount > 0) flushCaches(cls); rw->properties.attachLists(proplists, propcount); free(proplists); rw->protocols.attachLists(protolists, protocount); free(protolists); } Duplicate codeCopy the code

typedef struct method_t *Method; using MethodListIMP = IMP; struct method_t { SEL name; const char *types; MethodListIMP imp; }; Copy the codeCopy the code

void
load_images(const char *path __unused, const struct mach_header *mh)
{
    // Return without taking locks if there are no +load methods here.
    if(! hasLoadMethods((const headerType *)mh))return;

    recursive_mutex_locker_t lock(loadMethodLock);

    // Discover load methods
    {
        mutex_locker_t lock2(runtimeLock);
        prepare_load_methods((const headerType *)mh);
    }

    // Call +load methods (without runtimeLock - re-entrant)
    call_load_methods();
}

void call_load_methods(void)
{
    static bool loading = NO;
    bool more_categories;

    loadMethodLock.assertLocked();

    // Re-entrant calls do nothing; the outermost call will finish the job.
    if (loading) return;
    loading = YES;

    void *pool = objc_autoreleasePoolPush();

    do {
        // 1\. Repeatedly call class +loads until there aren't any more while (loadable_classes_used > 0) { call_class_loads(); } // 2\. Call category +loads ONCE more_categories = call_category_loads(); // 3\. Run more +loads if there are classes OR more untried categories } while (loadable_classes_used > 0 || more_categories); objc_autoreleasePoolPop(pool); loading = NO; } Duplicate codeCopy the code

void _class_initialize(Class cls) { assert(! cls->isMetaClass()); Class supercls; bool reallyInitialize = NO; // Make sure super isdone initializing BEFORE beginning to initialize cls.
    // See note about deadlock above.
    supercls = cls->superclass;
    if(supercls && ! supercls->isInitialized()) { _class_initialize(supercls); } // Try to atomicallyset CLS_INITIALIZING.
    {
        monitor_locker_t lock(classInitLock);
        if(! cls->isInitialized() && ! cls->isInitializing()) { cls->setInitializing(); reallyInitialize = YES; }}if (reallyInitialize) {
        // We successfully set the CLS_INITIALIZING bit. Initialize the class.

        // Record that we're initializing this class so we can message it. _setThisThreadIsInitializingClass(cls); if (MultithreadedForkChild) { // LOL JK we don't really call +initialize methods after fork().
            performForkChildInitialize(cls, supercls);
            return;
        }

        // Send the +initialize message.
        // Note that +initialize is sent to the superclass (again) if 
        // this class doesn't implement +initialize. 2157218 if (PrintInitializing) { _objc_inform("INITIALIZE: thread %p: calling +[%s initialize]", pthread_self(), cls->nameForLogging()); } // Exceptions: A +initialize call that throws an exception // is deemed to be a complete and successful +initialize. // // Only __OBJC2__ adds these handlers. ! __OBJC2__ has a // bootstrapping problem of this versus CF's call to
        // objc_exception_set_functions().
#if __OBJC2__
        @try
#endif
        {
            callInitialize(cls);

            if (PrintInitializing) {
                _objc_inform("INITIALIZE: thread %p: finished +[%s initialize]", pthread_self(), cls->nameForLogging()); }}#if __OBJC2__
        @catch (...) {
            if (PrintInitializing) {
                _objc_inform("INITIALIZE: thread %p: +[%s initialize] "
                             "threw an exception",
                             pthread_self(), cls->nameForLogging());
            }
            @throw;
        }
        @finally
#endif
        {
            // Done initializing.
            lockAndFinishInitializing(cls, supercls);
        }
        return;
    }

    else if (cls->isInitializing()) {
        // We couldn't set INITIALIZING because INITIALIZING was already set. // If this thread set it earlier, continue normally. // If some other thread set it, block until initialize is done. // It's ok if INITIALIZING changes to INITIALIZED while we're here, // because we safely check for INITIALIZED inside the lock // before blocking. if (_thisThreadIsInitializingClass(cls)) { return; } else if (! MultithreadedForkChild) { waitForInitializeToComplete(cls); return; } else { // We're on the child side of fork(), facing a class that // was initializing by some other thread when fork() was called. _setThisThreadIsInitializingClass(cls); performForkChildInitialize(cls, supercls); }}else if (cls->isInitialized()) {
        // Set CLS_INITIALIZING failed because someone else already 
        //   initialized the class. Continue normally.
        // NOTE this check must come AFTER the ISINITIALIZING case.
        // Otherwise: Another thread is initializing this class. ISINITIALIZED 
        //   is false. Skip this clause. Then the other thread finishes 
        //   initialization and sets INITIALIZING=no and INITIALIZED=yes. 
        //   Skip the ISINITIALIZING clause. Die horribly.
        return;
    }

    else {
        // We shouldn't be here. _objc_fatal("thread-safe class init in objc runtime is buggy!" ); } } void callInitialize(Class cls) { ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize); asm(""); } Duplicate codeCopy the code

NSObject *p = [[NSObject alloc] init]; __weak NSObject *p1 = p; // ====> base is runtime objc_initWeak // xcrun-sdk iphoneos clang-arch arm64-rewrite-objc-fobjc-arc -fobjc-runtime=ios-13.2 main.m NSObject objc_initWeak(&p, object pointer); Copy the codeCopy the code

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

    returnstoreWeak<DontHaveOld, DoHaveNew, DontCrashIfDeallocating> (location, (objc_object*)newObj); } Duplicate codeCopy the code

Struct SideTable {// spinlock_t slock; RefcountMap refcnts; // weak reference weak_table_t weak_table; } struct weak_table_t {// Save weak pointer to weak_entry_t *weak_entries; // Storage space size_t num_entries; // Uintptr_t mask; //hashUintptr_t max_hash_displacement; }; Copy the codeCopy the code

Static SideTable *tableForPointer(const void *p) copies the codeCopy the code

static StripedMap<SideTable>& SideTables() {
    return*reinterpret_cast<StripedMap<SideTable>*>(SideTableBuf); } Duplicate codeCopy the code

Reinterpret_cast <new_type> (expression) Copies codeCopy the code

typedef objc_object ** weak_referrer_t;

struct weak_entry_t {
    DisguisedPtr<objc_object> referent;
    union {
        struct {
            weak_referrer_t *referrers;
            uintptr_t        out_of_line : 1;
            uintptr_t        num_refs : PTR_MINUS_1;
            uintptr_t        mask;
            uintptr_t        max_hash_displacement;
        };
        struct {
            // out_of_line=0 is LSB of one of these (don't care which) weak_referrer_t inline_referrers[WEAK_INLINE_COUNT]; }; } Duplicate codeCopy the code

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

    weak_entry_t *entry;

    if(! referent)return; // Find the referent from weak_table, which is the instance object of class A aboveif((entry = weak_entry_for_referent(weak_table, Referent))) {// Find the location of the pointer referrer in the entry structure // set the location of the pointer to nil, 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 changeCopy the code

#import <objc/runtime.h>

static NSString * const kKeyOfImageProperty;

@implementation UIView (Image)

- (UIImage *)pt_image {
    return objc_getAssociatedObject(self, &kKeyOfImageProperty);
}

- (void)setPTImage:(UIImage *)image { objc_setAssociatedObject(self, &kKeyOfImageProperty, image,OBJC_ASSOCIATION_RETAIN); } @end copies the codeCopy the code

id _object_get_associative_reference(id object, void *key) { id value = nil; uintptr_t policy = OBJC_ASSOCIATION_ASSIGN; { AssociationsManager manager; // Manager.associations () returns an 'AssociationsHashMap' object (*_map) &associations(manager.associations()); // Intptr_t is used for platform compatibility. On 64-bit machines, intptr_t and uintptr_t are aliases for long int and unsigned long int respectively; On 32-bit machines, intptr_t and uintptr_t are aliases for int and unsigned int respectively. disguised_ptr_t disguised_object = DISGUISE(object); /* AssociationsHashMap inherits from unordered_map and stores the key-value combination iterator find (const key_type& key). If the key does not exist, find returns unordered_map::end; Therefore, 'map.find(key) == map.end()' can be used to determine whether the key exists in the current map. */ AssociationsHashMap::iterator i = associations.find(disguised_object);if(i ! = associations. End ()) {/* Unordered_map keys are first and second attributes of iterators, respectively. I ->second fetch another ObjectAssociationMap. Now use the key set by ourselves to find the corresponding associated attribute value. */ ObjectAssociationMap *refs = I ->second; ObjectAssociationMap::iterator j = refs->find(key);if(j ! = refs->end()) { ObjcAssociation &entry = j->second; value = entry.value(); policy = entry.policy(); OBJC_ASSOCIATION_RETAIN = 01401 // OBJC_ASSOCIATION_GETTER_RETAIN = (1 << 8)if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) {
                    // TODO: 有学问
                    objc_retain(value);
                }
            }
        }
    }
    if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
        objc_autorelease(value);
    }
    returnvalue; } Duplicate codeCopy the code

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    // retain the new value (ifany) outside the lock. ObjcAssociation old_association(0, nil); // Retain or copy if the value object exists id new_value = value? acquireValue(value, policy) : nil; { AssociationsManager manager; // Manager.associations () returns an 'AssociationsHashMap' object (*_map) &associations(manager.associations()); // Intptr_t is used for platform compatibility. On 64-bit machines, intptr_t and uintptr_t are aliases for long int and unsigned long int respectively; On 32-bit machines, intptr_t and uintptr_t are aliases for int and unsigned int respectively. Disguised_ptr_t DISGUised_object = DISGUISE(object);if (new_value) {
            // breakAny existing association. /* AssociationsHashMap inherits from unordered_map, Iterator find (const key_type& key), which returns an iterator of the key object if it exists, or unordered_map::end if it does not; Therefore, 'map.find(key) == map.end()' can be used to determine whether the key exists in the current map. */ AssociationsHashMap::iterator i = associations.find(disguised_object); // This is different from the get operation,set// A new ObjectAssociationMap is created to store all associated attributes of the instance objectif(i ! // secondary table exists /* unordered_map keys are first and second attributes of iterators. I ->second fetch another ObjectAssociationMap. Now use the key set by ourselves to find the corresponding associated attribute value. */ ObjectAssociationMap *refs = I ->second; ObjectAssociationMap::iterator j = refs->find(key); // The association attributes are encapsulated in the Objcassociety structureif(j ! = refs->end()) { old_association = j->second; j->second = ObjcAssociation(policy, new_value); }else{ (*refs)[key] = ObjcAssociation(policy, new_value); }}else{ // create the new association (first time). ObjectAssociationMap *refs = new ObjectAssociationMap; associations[disguised_object] = refs; (*refs)[key] = ObjcAssociation(policy, new_value); // newisa.has_assoc =true;
                object->setHasAssociatedObjects(); }}else {
            // setting the association to nil breaks the association.
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if(i ! = associations.end()) { ObjectAssociationMap *refs = i->second; ObjectAssociationMap::iterator j = refs->find(key);if(j ! = refs->end()) { old_association = j->second; refs->erase(j); } } } } // release the old value (outside of the lock).if(old_association.hasValue()) ReleaseValue()(old_association); } Duplicate codeCopy the code

// Send notification [[NSNotificationCenter defaultCenter] addObserver:self Selector :@selector(handleNotification:) name:@"TestNotification"object:@1]; / / receive notifications [NSNotificationCenter defaultCenter postNotificationName: @"TestNotification"object:nil]; Copy the codeCopy the code