位运算世界畅游指南

这里会介绍一些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-----------------
*/