這里會介紹一些runtime源碼中使用位運算的例子。

在runtime源碼中，判斷是否是TaggedPointer的函數定義如下：

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

其中參數const void * _Nullable ptr為對象的地址。_OBJC_TAG_MASK是一個掩碼,其宏定義比較長，我將它簡單的整理了一下：

#if (TARGET_OS_OSX || TARGET_OS_IOSMAC) && __x86_64__
    // 64-bit Mac - tag bit is LSB
#   define _OBJC_TAG_MASK 1UL
#else
    // Everything else - tag bit is MSB
#   define _OBJC_TAG_MASK (1UL<<63)
#endif

我們得到了結論：

64-bit Mac下， _OBJC_TAG_MASK為1UL，對應二進制為：00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

其他平臺下， _OBJC_TAG_MASK 為(1UL<<63)，對應二進制為：10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000

根據以上結論，結合_objc_isTaggedPointer函數的代碼，很容易理解它的原理：

在64-bit MAC下，取出對象地址二進制的最低位(LSB)，若最低位為1則為TaggedPointer。

在其他平臺下，取出對象地址二進制的最高位(MSB),若為1則為TaggedPointer。

在ARM64架構之前，對象的isa指針直接指向類對象地址；在ARM64架構之后，一個8字節的isa變量額外存儲了許多與當前對象相關的信息。 我們先看來看一下最新的isa結構定義：

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

    Class cls;
    uintptr_t bits;
#if defined(ISA_BITFIELD)
    struct {
        ISA_BITFIELD;  // defined in isa.h
    };
#endif
};

相關的宏定義：

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
#   define ISA_MAGIC_MASK  0x000003f000000001ULL
#   define ISA_MAGIC_VALUE 0x000001a000000001ULL
#   define ISA_BITFIELD                                                      
      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 deallocating      : 1;                                       
      uintptr_t has_sidetable_rc  : 1;                                       
      uintptr_t extra_rc          : 19
#   define RC_ONE   (1ULL<<45)
#   define RC_HALF  (1ULL<<18)

# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL
#   define ISA_MAGIC_MASK  0x001f800000000001ULL
#   define ISA_MAGIC_VALUE 0x001d800000000001ULL
#   define ISA_BITFIELD                                                        
      uintptr_t nonpointer        : 1;                                         
      uintptr_t has_assoc         : 1;                                         
      uintptr_t has_cxx_dtor      : 1;                                         
      uintptr_t shiftcls          : 44; /*MACH_VM_MAX_ADDRESS 0x7fffffe00000*/ 
      uintptr_t magic             : 6;                                         
      uintptr_t weakly_referenced : 1;                                         
      uintptr_t deallocating      : 1;                                         
      uintptr_t has_sidetable_rc  : 1;                                         
      uintptr_t extra_rc          : 8
#   define RC_ONE   (1ULL<<56)
#   define RC_HALF  (1ULL<<7)

# else
#   error unknown architecture for packed isa
# endif

上面代碼中用了c語言的聯合體以及位段的技術，當然這不是我們的重點，有興趣的話可以去了解下。 我在Mac上編寫了一段代碼，用來展示這8個字節里所存儲的數據有多么豐富。要知道，8個字節僅僅是一個long變量的大小。

#import 
#   define ISA_MASK        0x00007ffffffffff8ULL
union isa_t {
    Class cls;
    uintptr_t bits;
    struct {
        uintptr_t nonpointer        : 1;
        uintptr_t has_assoc         : 1;
        uintptr_t has_cxx_dtor      : 1;
        uintptr_t shiftcls          : 44;
        uintptr_t magic             : 6;
        uintptr_t weakly_referenced : 1;
        uintptr_t deallocating      : 1;
        uintptr_t has_sidetable_rc  : 1;
        uintptr_t extra_rc          : 8;
    };
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSObject *obj =  [[NSObject alloc]init]; // 這塊內存記為#1，obj指向#1，#1的引用計數器+1
        NSObject *obj2 = obj; // obj2也指向#1，#1的引用計數器+1
        NSObject *obj3 = obj; // obj3也指向#1，#1的引用計數器+1
        __weak NSObject *weak_obj = obj;// 弱引用
        union isa_t _isa_t;
        void *_obj = (__bridge void *)(obj);
        _isa_t.bits = *((uintptr_t*)_obj);
        printf("是否使用isa指針優化:%x
",_isa_t.nonpointer);
        printf("是否有用關聯對象:%x
",_isa_t.has_assoc);
        printf("是否有C++析構函數:%x
",_isa_t.has_cxx_dtor);
        printf("isa取出類對象:%llx
",_isa_t.bits & ISA_MASK);
        printf("class方法取出類對象:%lx
",(long)[NSObject class]);
        printf("調試時是否完成初始化:%x
",_isa_t.magic);
        printf("是否有被弱引用指向過:%x
",_isa_t.weakly_referenced);
        printf("是否正在釋放:%x
",_isa_t.deallocating);
        printf("是否使用了sidetable:%x
",_isa_t.has_sidetable_rc);
        printf("引用計數器-1:%x
",_isa_t.extra_rc);
    }
    return 0;
}

輸出的結果：

是否使用isa指針優化:1

是否有用關聯對象:0

是否有C++析構函數:0

isa取出類對象:7fffb506f140

class方法取出類對象:7fffb506f140

調試時是否完成初始化:3b

是否有被弱引用指向過:1

是否正在釋放:0

是否使用了sidetable:0

引用計數器-1:2

先給出Runtime源碼里從緩存中查找方法的函數：

 bucket_t * cache_t::find(cache_key_t k, id receiver)
{
    assert(k != 0);

    bucket_t *b = buckets();
    mask_t m = mask();
    mask_t begin = cache_hash(k, m);
    mask_t i = begin;
    do {
        if (b[i].key() == 0  ||  b[i].key() == k) {
            return &b[i];
        }
    } while ((i = cache_next(i, m)) != begin);

    // hack
    Class cls = (Class)((uintptr_t)this - offsetof(objc_class, cache));
    cache_t::bad_cache(receiver, (SEL)k, cls);
}

再來看下cache_hash的實現：

// Class points to cache. SEL is key. Cache buckets store SEL+IMP.
// Caches are never built in the dyld shared cache.
static inline mask_t cache_hash(cache_key_t key, mask_t mask) 
{
    return (mask_t)(key & mask);
}

這里需要說明cache_hash函數中幾個參數的意義：

key： 方法SEL的地址（8字節64位）

mask： 哈希表長度 -1

(key & mask)的結果能保證在[0,mask]整數范圍內，所以可以正確的映射到Hash表上。

typedef NS_OPTIONS(NSUInteger, NSKeyValueObservingOptions) {

    NSKeyValueObservingOptionNew = 0x01,
    NSKeyValueObservingOptionOld = 0x02,
    NSKeyValueObservingOptionInitial = 0x04,
    NSKeyValueObservingOptionPrior = 0x08
};

- (void)readOptions:(NSKeyValueObservingOptions)options {
    NSLog(@"---------------begin---------------");
    if (options & NSKeyValueObservingOptionNew ) {
        NSLog(@"contain NSKeyValueObservingOptionNew");
    }
    if (options & NSKeyValueObservingOptionOld ) {
        NSLog(@"contain NSKeyValueObservingOptionOld");
    }
    if (options & NSKeyValueObservingOptionInitial ) {
         NSLog(@"contain NSKeyValueObservingOptionInitial");
    }
    if (options & NSKeyValueObservingOptionPrior ) {
         NSLog(@"contain NSKeyValueObservingOptionPrior");
    }
     NSLog(@"---------------end-----------------");
}

// 輸出
/*
     ---------------begin---------------
     contain NSKeyValueObservingOptionNew
     contain NSKeyValueObservingOptionOld
     ---------------end-----------------
     ---------------begin---------------
     contain NSKeyValueObservingOptionNew
     contain NSKeyValueObservingOptionInitial
     contain NSKeyValueObservingOptionPrior
     ---------------end-----------------
*/

 [self readOptions:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew];
 [self readOptions:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionInitial |NSKeyValueObservingOptionPrior];

/*
     ---------------begin---------------
     contain NSKeyValueObservingOptionNew
     contain NSKeyValueObservingOptionOld
     ---------------end-----------------
     ---------------begin---------------
     contain NSKeyValueObservingOptionNew
     contain NSKeyValueObservingOptionInitial
     contain NSKeyValueObservingOptionPrior
     ---------------end-----------------
*/