isa底层结构分析

isa底层结构分析

IOS小彩虹2021-08-15 1:33:27150A+A-

一、对象的本质

main.m文件

#import <Foundation/Foundation.h>
#import <objc/runtime.h>

@interface FXPerson : NSObject
@property (nonatomic, copy) NSString *name;
@end

@implementation FXPerson
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
    }
    return 0;
}

首先,我们使用终端先跳转到把main.m的根目录,把main.m文件使用clang编译命令转为cpp文件,会得到下面main.cpp文件

clang -rewrite-objc main.m -o main.cpp

main.cpp文件

typedef struct objc_object FXPerson;
typedef struct {} _objc_exc_FXPerson;
#endif

extern "C" unsigned long OBJC_IVAR_$_FXPerson$_name;
struct FXPerson_IMPL {
	struct NSObject_IMPL NSObject_IVARS;
	NSString *_name;
};

main.cpp文件中我们可以看到对象的本质其实都是结构体。而结构体当中的struct NSObject_IMPL NSObject_IVARS其实对应的就是我们的isa指针

二、联合体、位域

@interface FXCar : NSObject

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

// 对象 - 属性
// 1*4 = 4字节*8位 = 32位 浪费

- (void)setFront:(BOOL)isFront;  // 存储 : 1字节 = 8位 0000 1111  char + 位域  bit 结构体
- (BOOL)isFront;

- (void)setBack:(BOOL)isBack;
- (BOOL)isBack;

@end

假设我们一个对象(FXCar)里面有4个属性(front、back、left、right),每个BOOL属性占1个字节,4个属性就占4个字节(32位数据)。其实只需要一个字节后面4位的内容就可以存储这4个属性。

结构体(struct)中所有变量是“共存”的

  • 优点: “有容乃大”、全面;
  • 缺点: struct内存空间的分配是粗放的,不管用不用,全分配。

联合体(union)中是各变量是“互斥”的

  • 优点: 内存使用更为精细灵活,也节省了内存空间;
  • 缺点: 就是不够“包容”。

苹果也针对于这种现象做了一些优化,采用联合体、位域的方式来节省内存以存储更多内容。

@interface FXCar(){
    // 联合体
    union {
        char bits;
        // 位域
        struct { // 0000 1111
            char front  : 1;
            char back   : 1;
            char left   : 1;
            char right  : 1;
        };
    } _direction;
}
@end

三、isa结构信息

alloc流程分析中我们针对alloc进行源码调试过程中,我们会走到obj->initInstanceIsa这个方法,我们按照obj->initInstanceIsa ->initIsa -> isa_t流程可以分别看到下面几个方法

obj->initInstanceIsa

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

    initIsa(cls, true, hasCxxDtor);
}

obj->initInstanceIsa方法中的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;
    }
}

initIsa方法中,我们可以看到isa = isa_t((uintptr_t)cls);,isa的数据结构其实为 isa_t,然后我们再进入isa_t看一下。 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_t是一个union(共用体/联合体) 其中 ISA_BITFIELD 宏定义在不同架构下表示如下 :

# if __arm64__
#   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
# elif __x86_64__
#   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

首先看到isa_t是一个联合体的数据结构 , 联合体意味着公用内存 , 也就是说isa其实总共还是占用 8 个字节内存 , 共 64 个二进制位 。

而上述不同架构的宏定义中定义的位域就是 64 个二进制位中 , 每个位置存储的是什么内容。

  • 由于联合体的特性 ,cls,bits以及struct都是 8 字节内存 , 也就是说他们在内存中是完全重叠的。
  • 实际上在runtime中,任何对struct的操作和获取某些值,如 extra_rc,实际上都是通过对bits做位运算实现的。
  • bits struct的关系可以看做 : bits 向外提供了操作struct的接口,而struct本身则说明了bits中各个二进制位的定义。

参照arm64架构下 ,ISA_BITFIELD我们来看看每个字段都存储了什么内容 , 以便更深刻的理解对象的本质。

成员 含义
nonpointer 1bit 表示是否对 isa 指针开启指针优化。 0:纯 isa 指针;1:不止是类对象地址。isa 中包含了类信息、对象的引用计数等
has_assoc 1bit 标志位: 表明对象是否有关联对象。0:没有;1:存在。没有关联对象的对象释放的更快
has_cxx_dtor 1bit 标志位: 表明对象是否有C++或ARC析构函数。没有析构函数的对象释放的更快
shiftcls 33bit 存储类指针的值。开启指针优化的情况下,在 arm64 架构中有 33 位用来存储类指针。
magic 6bit 用于调试器判断当前对象是真的对象还是没有初始化的空间 , 固定为 0x1a
weakly_referenced 1bit 标志位:用于表示该对象是否被别ARC对象弱引用或者引用过。没有被弱引用的对象释放的更快
deallocating 1bit 标志位: 用于表示该对象是否正在被释放
has_sidetable_rc 1bit 标志位: 用于标识是否当前的引用计数过大 ( 大于 10 ) ,无法在 isa 中存储,则需要借用sidetable来存储,标志是否有外挂的散列表
extra_rc 19bit 实际上是对象的引用计数减 1 . 比如,一个 object 对象的引用计数为7,则此时 extra_rc 的值为 6
### 四、isa关联类
在上面的initIsa方法中,isa初始化方法中会有如下赋值,我们也可以断点调试 newisa 的值
isa初始化方法
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;
···
`newisa` 的值
···
(lldb) p newisa
(isa_t) $2 = {
  cls = 0x001d800000000001
 ··
   = {
    nonpointer = 1
    has_assoc = 0
    has_cxx_dtor = 0
    shiftcls = 0
    magic = 59
    weakly_referenced = 0
    deallocating = 0
    has_sidetable_rc = 0
    extra_rc = 0
  }
}

isa初始化方法当中的宏 ISA_MAGIC_VALUEULL表示unsign long long类型

#   define ISA_MAGIC_VALUE 0x001d800000000001ULL

我们可以用计算器看一下isa当中的 cls = 0x001d800000000001 信息, 计算器查看cls信息.png cls的十进制信息.png 我们可以看到从47位开始有一个111011,然后我们再打印一下 isa当中的 magic = 59 信息,使用计算器打印一下59的二进制信息,我们会发现也是11101。然后我们再看一下cls = 0x001d800000000001 信息的十进制信息,发现就等于 bits = 8303511812964353 ,这也就说明了cls,bits以及struct都是 8 字节内存 , 也就是说他们在内存中是完全重叠的。

然后我们把断点调试到下面这行代码执行完毕

newisa.shiftcls = (uintptr_t)cls >> 3;

我们 (uintptr_t)cls 右移3位,可以打印如下信息

(lldb) p (uintptr_t)cls
(uintptr_t) $4 = 4294976104
(lldb) p $4 >> 3
(uintptr_t) $5 = 536872013
(lldb) p newisa
(isa_t) $6 = {
  cls = FXPerson
  bits = 8303516107940461
   = {
    nonpointer = 1
    has_assoc = 0
    has_cxx_dtor = 1
    shiftcls = 536872013
    magic = 59
    weakly_referenced = 0
    deallocating = 0
    has_sidetable_rc = 0
    extra_rc = 0
  }
}

从上面我们可以看到,shiftcls 存储类指针的值,并且将类 FXPersonshiftcls = 536872013 关联起来了。

五、isa通过位运算验证关联类

我们先将断点调试到 obj->initInstanceIsa 这个方法之后,然后打印 obj 信息,通过位运算验证关联 FXPerson 信息 位运算验证关联类.png

位运算方法解析:isa结构体信息如下图所示: isa结构体信息.png

  1. 先将 isa指针 右移 3位isa指针 的右边 3位 信息抹掉,左边空出 3位 使用 0 来填充。
  2. isa指针 左移 20位 ,将 步骤1当中新增的3位 + isa指针的左边17信息抹掉。
  3. 最后将 isa指针 右移 17 位即可恢复 44位shiftcls 的位置信息
(lldb) x/4gx obj
0x103225090: 0x001d800100002275 0x0000000000000000
0x1032250a0: 0x0000000000000000 0x0000000000000000
(lldb) p/x 0x001d800100002275 >> 3
(long) $2 = 0x0003b0002000044e
(lldb) p/x 0x0003b0002000044e << 20
(long) $3 = 0x0002000044e00000
(lldb) p/x 0x0002000044e00000 >> 17
(long) $4 = 0x0000000100002270
(lldb) p/x cls
(Class) $5 = 0x0000000100002270 FXPerson

到此isa位运算关联类信息验证完毕!

六、通过 isa & ISA_MSAK可以查看isa指向类信息

arm64x86_64 中掩码 ISA_MASK 定义

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
...
# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL
...

其实一步一步的位运算不免显得有些繁琐,苹果为大家提供了和alloc流程分析中内存对齐一样的算法,提供一个掩码执行 与操作 (&),即可得出 isa 指向的类信息。

(lldb) po 0x001d800100002275 & 0x00007ffffffffff8ULL
FXPerson

点击这里复制本文地址 以上内容由权冠洲的博客整理呈现,请务必在转载分享时注明本文地址!如对内容有疑问,请联系我们,谢谢!

支持Ctrl+Enter提交

联系我们| 本站介绍| 留言建议 | 交换友链 | 域名展示
本站资源来自互联网收集,仅供用于学习和交流,请遵循相关法律法规,本站一切资源不代表本站立场,如有侵权、后门、不妥请联系本站删除

权冠洲的博客 © All Rights Reserved.  Copyright quanguanzhou.top All Rights Reserved
苏公网安备 32030302000848号   苏ICP备20033101号-1
本网站由 提供CDN/云存储服务

联系我们