iOS-OC对象原理_NONPOINTER_ISA

前言

在前面的文章中我们探索了在iOS中alloc执行流程，在流程中最后的_class_createInstanceFromZone()方法中，主要执行如下：

1. size = cls->instanceSize(extraBytes); 确认要开辟的空间大小
2. obj = (id)calloc(1, size); 开辟空间
3. obj->initInstanceIsa(cls, hasCxxDtor); 建立cls与isa的绑定。

这里文章就重点探索下initInstanceIsa()的内部实现。

联合体位域

联合体：在进行某些算法的C语言编程的时候，需要使几种不同类型的变量存放到同一段内存单元中。也就是使用覆盖技术，几个变量互相覆盖。这种几个不同的变量共同占用一段内存的结构，在C语言中，被称作“共用体”类型结构，简称共用体，也叫联合体。

union 共用体名{
    成员列表
};

共用体有时也被称为联合或者联合体，这也是 Union 这个单词的本意。

struct与union的区别

struct	union
各个成员会占用不同的内存，互相之间没有影响	所有成员占用同一段内存，修改一个成员会影响其余所有成员
结构体占用的内存大于等于所有成员占用的内存的总和（成员之间可能会存在缝隙）	共用体占用的内存等于最长的成员占用的内存

位域：信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态， 用一位二进位即可。为了节省存储空间，并使处理简便，C语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几 个不同的区域， 并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。 这样就可以把几个不同的对象用一个字节的二进制位域来表示。

联合体+位域

// 联合体
union
{
    uint8_t  value;
    //位域
    struct  
    {
        uint8_t  lowbit : 2;
        uint8_t  middlebit : 3;
        uint8_t  highbit : 3;
    }byte;
}data;

value和byte共用一个字节的内存空间，改变value的值，那么byte的值也就改变了，同样改变byte中的位（lowbit占2位， middlebit占3位，highbit也占3位;）value的值也就改变了；一般情况下，我们要得到value中的高三位的值，需要得到这样（暂定高三位的值为x）x=(value>>5)&0x03,但是使用了位域，就可以直接得到了，省去了这样的一个计算的过程。

int main(int argc, const char * argv[]) {
  @autoreleasepool {
     //联合体
     union {
       uint8_t value;
       // 位域
       struct {
         uint8_t bit0:2;
         uint8_t bit1:3;
         uint8_t bit2:3;
       };
     }data1,data2; 
     
     data1.value = 20;    
      
     data2.bit0 = 3;
     data2.bit1 = 3;
     data2.bit2 = 0;
      
     printf("bit0 = %d\r\n",data1.bit0);
     printf("bit1 = %d\r\n",data1.bit1);
     printf("bit2 = %d\r\n",data1.bit2);
    
     printf("data1.value = %d\r\n",data1.value);
     printf("data2.value = %d\r\n",data2.value);
  }
}
console=>
bit0 = 0
bit1 = 5
bit2 = 0
data1.value = 20
data2.value = 15

回到OC

obj->initInstanceIsa(cls, hasCxxDtor):

inline void 
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
    ASSERT(!cls->instancesRequireRawIsa());
    ASSERT(hasCxxDtor == cls->hasCxxDtor());

    initIsa(cls, true, hasCxxDtor);
}
核心进入 -> initIsa()
inline void 
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) 
{ 
    ASSERT(!isTaggedPointer()); 
    
    if (!nonpointer) {
        isa = isa_t((uintptr_t)cls);
    } else {
        ASSERT(!DisableNonpointerIsa);
        ASSERT(!cls->instancesRequireRawIsa());

        isa_t newisa(0);
        
#if SUPPORT_INDEXED_ISA
        ASSERT(cls->classArrayIndex() > 0);
        newisa.bits = ISA_INDEX_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
        newisa.bits = ISA_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.shiftcls = (uintptr_t)cls >> 3;
#endif

        // This write must be performed in a single store in some cases
        // (for example when realizing a class because other threads
        // may simultaneously try to use the class).
        // fixme use atomics here to guarantee single-store and to
        // guarantee memory order w.r.t. the class index table
        // ...but not too atomic because we don't want to hurt instantiation
        isa = newisa;
    }
}

isa_t:一个典型的联合体位域结构

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
};

ISA_BITFIELD:位域结构分布宏定义(arm64和x86_64)

# 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

isa_t联合体位域段位信息分布(转载于Cooci)

以下是各段位字段注释：
nonpointer:表示是否对 isa 指针开启指针优化 0:纯isa指针，1:不止是类对象地址,isa 中包含了类信息、对象的引用计数等。
has_assoc:关联对象标志位，0没有，1存在。
has_cxx_dtor:该对象是否有 C++ 或者 Objc 的析构器,如果有析构函数,则需要做析构逻辑, 如果没有,则可以更快的释放对象
shiftcls:存储类指针的值。开启指针优化的情况下，在 arm64 架构中有 33 位用来存储类指针。（重要）
magic:用于调试器判断当前对象是真的对象还是没有初始化的空间
weakly_referenced:标志对象是否被指向或者曾经指向一个 ARC 的弱变量，没有弱引用的对象可以更快释放。
deallocating:标志对象是否正在释放内存
has_sidetable_rc:当对象引用计数大于 10 时，则需要借用该变量存储进位。
extra_rc:当表示该对象的引用计数值，实际上是引用计数值减 1， 例如，如果对象的引用计数为 10，那么 extra_rc 为 9。如果引用计数大于 10， 则需要使用到上面的 has_sidetable_rc。

到此，我们可以看出isa在其64bit的长度中，存储了很多的信息；而广义上的我们说isa其实读取的是shiftcls段位的信息。如下：

inline Class 
objc_object::ISA() 
{
    ASSERT(!isTaggedPointer()); 
#if SUPPORT_INDEXED_ISA
    if (isa.nonpointer) {
        uintptr_t slot = isa.indexcls;
        return classForIndex((unsigned)slot);
    }
    return (Class)isa.bits;
#else
    return (Class)(isa.bits & ISA_MASK);  
#endif
}

isa经典走位图

isa流程图.png

总结

以上仅为罗列笔记。