iOS 底层探索之isa结构分析

引：

什么是对象

OC的对象、类主要是基于C\C++的结构体数据结构实现的。OC对象的本质就是结构体。

在探索本质前，我们需要了解一个编辑器：clang

Clang

clang是一个由Apple主导编写，基于LLVM的C/C++/OC的编辑器
主要是用于底层编译，将一些文件输出成C++文件，例如main.m输出成main.cpp，其目的是为了更好的观察底层的一些结构及实现的逻辑，方便理解底层原理。

对象的本质

在main中定义一个LGPerson类继承于NSObject

@interface LGPerson : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, strong) NSString *nickName;
@end

@implementation LGPerson
@end

通过终端，利用clang将main.m编译成main.cpp。有以下4几种编译指令，可以根据自己的实际情况来编译。

//1、将 main.m 编译成 main.cpp
clang -rewrite-objc main.m -o main.cpp

//2、将 ViewController.m 编译成  ViewController.cpp
clang -rewrite-objc -fobjc-arc -fobjc-runtime=ios-13.0.0 -isysroot / /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator13.7.sdk ViewController.m

//以下两种方式是通过指定架构模式的命令行，使用xcode工具 xcrun
//3、模拟器文件编译
- xcrun -sdk iphonesimulator clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp 

//4、真机文件编译
- xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main- arm64.cpp

编译完成之后，打开main.cpp的文件，找到我们定义好的LGPerson类，发现在底层会被编译成struct结构体
- LGPerson_IMPL中的第一个属性为NSObject_IMPL的结构体，通过代码发现此结构体就是isa，是继承自NSObject,属于伪继承，伪继承的方式是直接将NSObject结构体定义为LGPerson中的第一个属性，意味着LGPerson 拥有 NSObject中的所有成员变量。每个类的第一个属性都是Class isa

//NSObject的定义
@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}

//NSObject通过clang编译的定义
struct NSObject_IMPL {
    Class isa;
};

extern "C" unsigned long OBJC_IVAR_$_LGPerson$_name;
extern "C" unsigned long OBJC_IVAR_$_LGPerson$_nickName;
// LGPerson的底层编译结果
struct LGPerson_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    NSString *_name;
    NSString *_nickName;
};

编译后得到的结果如下图所示：

clang编译后的代码

问：isa的类型为什么会是Class？
通过之前查找源代码找到initIsa方法，知道isa是通过isa_t类型初始化的。通过分析获取isa是通过get方法，于是我们找到了getIsa这个方法，结果如下图：

#if SUPPORT_NONPOINTER_ISA

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返回的时候做了一个类型强制转换。

union联合体位域

结构体 struct：各成员各自拥有自己额内存，各自使用互不干涉，同时存在的，遵循内存对齐原则。一个struct的总长度等于内部最大成员的整数倍，不足的要补齐， 结构体(struct)中所有变量是“共存”的——优点是“有容乃大”，全面;缺点是struct内存空间的分配是粗放的，不管用不用，全分配。

联合体union：各成员共用一块内存空间，并且同时只有一个成员可以得到这块内存的使用权（对该内存的读写），各变量共用一个内存首地址。因此，联合体比结构体更加节约内存。一个union变量的总长度至少能容纳最大的成员变量，而且要满足是所有成员变量类型大小的整数倍。不允许对联合体变量名U2直接赋值或其他操作。联合体(union)中是各变量是“互斥”的——缺点就是不够“包容”; 但优点是内存使用更为精细灵活，也节省了内存空间

有时候为了节省内存占用可以使用的技术

@interface Car : NSObject

@property (nonatomic, assign) BOOL front;
@property (nonatomic, assign) BOOL left;
@property (nonatomic, assign) BOOL back;
@property (nonatomic, assign) BOOL right;

@end

@implementation Car

@end

四个 BOOL属性占用内存为 4 字节（sizeof(BOOL）= 1), 因为每次只能选择一个方向，所以有点内存浪费，直接用 1 bit 表示一个方向也是可以的

union direction_t {
    char bits; // 1 字节
    struct {
        char front: 1; // 1 bit
        char left: 1; // 1 bit
        char back: 1;   // 1 bit
        char right: 1; // 1 bit
    };
};

printf("size of union direction_t = %lu",sizeof(_direction));
//size of union direction_t = 1

isa的类型isa_t

从源码中，可以看到到isa指针的类型isa_t的定义，从定义中可以看出是通过联合体(union)定义的。

union isa_t {//联合体
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }
    //提供了cls和bits，两者是互斥的关系
    Class cls;
    uintptr_t bits;
#if defined(ISA_BITFIELD)
    struct {
        ISA_BITFIELD;  // defined in isa.h
    };
#endif
};

isa_t类型使用联合体的原因也是基于内存优化的考虑，这里的内存优化是指在isa指针中通过char + 位域（即二进制中每一位均可表示不同的信息）的原理实现。通常来说，isa指针占用的内存大小8字节，即64位，已经足够存储很多信息了，这样可以极大的节省内存，以提高性能

inline void 
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) 
{ 
    ASSERT(!isTaggedPointer()); 
    
    if (!nonpointer) {
        isa = isa_t((uintptr_t)cls);///isa初始化
    } else {
        ASSERT(!DisableNonpointerIsa);
        ASSERT(!cls->instancesRequireRawIsa());

        isa_t newisa(0);///isa初始化
#if SUPPORT_INDEXED_ISA /// !nonpointer的执行流程，即isa 通过cls定义
        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 ///bits的执行流程
        newisa.bits = �ISA_MAGIC_VALUE;///bits进行赋值为0x001f800000000001ULL
        // 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;
    }
}

提供了两个成员，cls和 bits，由联合体的定义所知，这两个成员是互斥的，也可以通过上诉的代码可以看出cls赋值和bit是赋值也是互斥的。也就意味着，当初始化isa指针时，有两种初始化方式
- 通过cls初始化，bits无默认值
- 通过bits初始化，cls有默认值
还提供了一个结构体定义的位域，用于存储类信息及其他信息，结构体的成员ISA_BITFIEID，这是一个宏定义，有两个版本__arm64__(对应iOS移动端)和__x86_64__(对应macOS)，以下是它们的一些宏定义如下：

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
#   define ISA_MAGIC_MASK  0x000003f000000001ULL
#   define ISA_MAGIC_VALUE 0x000001a000000001ULL
#   define ISA_BITFIELD                                                     \
      uintptr_t nonpointer        : 1;                                       \/*是否对isa指针开启指针优化 */ 
      uintptr_t has_assoc         : 1;                                       \/*是否有关联对象*/
      uintptr_t has_cxx_dtor      : 1;                                       \/*是否有C++相关实现*/
      uintptr_t shiftcls          : 33; /*MACH_VM_MAX_ADDRESS 0x1000000000*/ \/*存储类信息*/ 
      uintptr_t magic             : 6;                                       \/*调试器判断对象是真对象还是为初始化空间*/ 
      uintptr_t weakly_referenced : 1;                                       \/*对象是否被指向或者曾经指向一个ARC的弱变量 */ 
      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;                                         \/*是否对isa指针开启指针优化 */ 
      uintptr_t has_assoc         : 1;                                         \/*是否有关联对象*/
      uintptr_t has_cxx_dtor      : 1;                                         \/*是否有C++相关实现*/
      uintptr_t shiftcls          : 44; /*MACH_VM_MAX_ADDRESS 0x7fffffe00000*/ \/*存储类信息*/ 
      uintptr_t magic             : 6;                                         \/*调试器判断对象是真对象还是为初始化空间*/ 
      uintptr_t weakly_referenced : 1;                                         \/*对象是否被指向或者曾经指向一个ARC的弱变量 */ 
      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

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

isa 与类的关联

cls 与 isa 关联原理就是isa指针中的shiftcls位域中存储了类信息，其中initInstanceIsa的过程是将calloc 指针和当前的类cls关联起来，有以下几种验证方式：

1、通过initIsa方法中的newisa.shiftcls = (uintptr_t)cls >> 3;验证

通过 lldb打印赋值前后的newisa的过程我们发现shiftcls在赋值的过程中有两个值发生了变化， cls通过0x001d800000000001变成了LGPerson，bits中的shiftcls从0变成了536871965，将isa和cls关联了起来。

如结果下图：

赋值前后对比.png

2、通过isa指针地址与ISA_MSAK 的值 & 来验证

arm64中，ISA_MASK 宏定义的值为0x0000000ffffffff8ULL
x86_64中，ISA_MASK宏定义的值为0x00007ffffffffff8ULL
首先知道ISA_MASK宏定义如上，然后回到obj->initInstanceIsa，通过LLDB打印结果如下:

isa指针地址& ISA_MASK的结果

3、通过位运算验证
通过上述的一些源码分析，我们知道isa中占有的64位信息，而存储类信息的shiftcls是占33位或者44位，是从第4位开始存储。而我们的源码是macOS环境所以此时shiftcls占44位。
所以我们获取isa的值时，需要将右边3位和左边17位抹零，并且保证其相对位置不变。

然后通过LLDB指令验证步骤如下图：

位运算验证过程及结果