美文网首页
isa初始化&指向分析

isa初始化&指向分析

作者: Easting | 来源:发表于2019-12-21 15:10 被阅读0次

探索对象与类如何绑定在一起

在objc4的源码中，通过研究alloc的流程就可看到下面的代码

obj->initInstanceIsa(cls, hasCxxDtor);
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
    assert(!cls->instancesRequireRawIsa());
    assert(hasCxxDtor == cls->hasCxxDtor());

    initIsa(cls, true, hasCxxDtor);
}

上面的代码我们可以看到initInstanceIsa()最终调用的函数就是initIsa(),那下面我们看看initIsa()做了啥

inline void 
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) 
{ 
    assert(!isTaggedPointer()); 
    
    if (!nonpointer) {
        isa.cls = 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就是这样初始化出来了,并做了一些相关的初始化赋值，如果这个类不是nonpointer指针就直接isa.cls = cls，现在我们的类都是nonpointer了。

那么我们的对象是怎么样与类绑定在一起的呢？

先来看isa究竟是个啥

union isa_t {
    //两个默认的构造函数
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

  //isa指向的类
    Class cls;
    uintptr_t bits;
#if defined(ISA_BITFIELD)
    struct {
        //位域
        ISA_BITFIELD;  // defined in isa.h
    };
#endif
};

isa它是一个联合体，联合体是一个结构，8个字节，它的特性就是共用内存，或者说是互斥，比如说cls赋值了 就不对bits赋值了。

我们再深入看struct ISA_BITFIELD

# 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

可以看到对于不同的架构对应的位域有不同的区别,但总共都是64位，但是field是相同的。下面我们对每个field进行描述：

  1. nonpointer 表示是否对isa指针开启优化(我们现在的都是开启了优化)，值0：纯isa指针 值1：不止是类对象地址，isa中还包含了类信息，对象的引用计数等；
  2. has_assoc 是否有关联对象， 值0 没有 值1 有；
  3. has_cxx_dtor 该对象是否有c++或者objc析构函数，如果有析构函数，先走析构逻辑，没有就更快的释放对象；
  4. shiftcls存储类指针的值，开启指针优化的时候 在arm64架构中有33位存储类指正
  5. magic用于调试器判断当前对象是真的对象还是没有初始化的空间
  6. weakly_referenced 标志对象是否指向或者曾经指向一个ARC的弱变量，没有弱引用的对象可以更快的释放
  7. deallocating 标志对象是否正在释放
  8. has_sidetable_rc 当对象引用计数大于10时，则需要借用该变量存储进位
  9. extra_rc表示对象的引用计数的值，实际上是引用计数减1.
    例如 如果对象的引用计数位10 则extra_rc为9 ，若引用计数大于10 ，则需要用到上面的has_sidetable_rc。

我们对isa联合体做了一下解释，接下来我们就看一下对象是如何与类关联的？

我们知道对象的第一个变量就是isa，那么通过isa的地址是如何与类关联的呢，既然shiftcls是用来存储指针的值，那么我们可以通过lldb调试来获取。

XDTest *test = [XDTest alloc];
(lldb) x/4gx test //打印对象test的内存信息
0x1018482f0: 0x001d800100001129 0x0000000000000000
0x101848300: 0x00000001018483d0 0x0000000101848610
(lldb) p/t XDTest.class //打印XDTest的二进制值
(Class) $1 = 0b0000000000000000000000000000000100000000000000000001000100101000 XDTest
(lldb) p/t 0x001d800100001129 //test的isa的二进制值
(long) $2 = 0b0000000000011101100000000000000100000000000000000001000100101001
(lldb) p/t $2>>3<<3 //shiftcl 前面有三位 我们需要右移3位 然后左移还原位置
(long) $3 = 0b0000000000011101100000000000000100000000000000000001000100101000
(lldb) p/t $3<<17>>17 //因为是模拟器_x86_64 shiftcl后面还有17位 故先左移17位找到 然后右移17位还原位置
(long) $4 = 0b0000000000000000000000000000000100000000000000000001000100101000
通过上面的调试我们会发现$1和$4的值是相同的

先把lldb相关的命令简单的描述一下：

  1. x/4gx objc 打印objc的4段内存信息。扩展：x/6gx就是打印6段内存信息。
  2. p/t 打印二进制信息；
    p/o 打印八进制信息；
    p/x 打印十六进制信息；

结论：通过lldb调试我们有两个值是相同的，这也验证了对象初始化的isa与class绑定了。

但是我们这个时候就会考虑，这也来看对象的isa与类绑定会过于太复杂了，会不会有其他更加简单的方法呢？

objc的源码照样没有让我们失望，它提供了，请看：

接下来的代码就是通过对象objc去获取类Class。

Class object_getClass(id obj)
{
    if (obj) return obj->getIsa();
    else return Nil;
}

具体再来看一下objc->getIsa()会干了些什么

inline Class 
objc_object::getIsa() 
{
    if (!isTaggedPointer()) return ISA();

    uintptr_t ptr = (uintptr_t)this;
    if (isExtTaggedPointer()) {
        uintptr_t slot = 
            (ptr >> _OBJC_TAG_EXT_SLOT_SHIFT) & _OBJC_TAG_EXT_SLOT_MASK;
        return objc_tag_ext_classes[slot];
    } else {
        uintptr_t slot = 
            (ptr >> _OBJC_TAG_SLOT_SHIFT) & _OBJC_TAG_SLOT_MASK;
        return objc_tag_classes[slot];
    }
}

我们已经了解到了objc 并非nonpointer （具体的原因会在后续的章节中说明）就会直接return 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
}

既然并非nonpointer 就会直接走到 return (Class)(isa.bits & ISA_MASK)了，我看看到这个会了解到objc->getIsa()返回的也是一个Class。

这里解释一下（isa.bits & ISA_MASK）：ISA_MASK(在isa_t联合体总，宏定义ISA_BITFIELD 可以查看到值)其实就相当于是一个蒙版，一个掩码（我们的子码掩码一样），来展示isa需要展示给外部看到的数据。

既然我们已经知道可以通过掩码来查看类的信息了，那么接下来开始我们的lldb调试

(lldb) x/4gx test     //打印对象的内存信息
0x101d047e0: 0x001d800100001129 0x0000000000000000
0x101d047f0: 0x00007fff9b5ff170 0x00000000c3000002
(lldb) p/x XDTest.class  //打印类的地址
(Class) $1 = 0x0000000100001128 XDTest
(lldb) p/x 0x001d800100001129 & 0x0000000ffffffff8 //通过对象的isa & ISA_MASK
(long) $2 = 0x0000000100001128

通过上面的lldb看isa的地址0x001d800100001129 & ISA_MASK之后的结果 打印出来的就是XDTest类的地址了,这样就比较简单的验证了对象的isa与类的绑定关系了。

isa的指向走位分析

通过上面的了解，我们知道了对象与类之间通过isa来绑定，那我们的isa会不会还有其他的指向走位呢？

我们继续去通过lldb调试来查看isa的指向走位

XDPerson *person = [XDPerson alloc];

(lldb) x/4gx person
0x10185eac0: 0x001d8001000011a9 0x0000000000000000
0x10185ead0: 0x000000010185eba0 0x000000010185ede0
(lldb) p/x 0x001d8001000011a9 & 0x0000000ffffffff8
(long) $1 = 0x00000001000011a8
(lldb) po $1
XDPerson
  1. 我们打印person的内存信息 通过对象的isa & ISA_MASK 获取到了类的信息。即isa 从类的实例对象person指向了类XDPerson。
(lldb) x/4gx $1
0x1000011a8: 0x001d800100001181 0x00000001000011f8
0x1000011b8: 0x00000001003a1e50 0x0000000000000000
(lldb) p/x 0x001d800100001181 & 0x0000000ffffffff8
(long) $2 = 0x0000000100001180
(lldb) po $2
XDPerson
  1. 我们打印类XDPerson的内存信息 通过类的isa & ISA_MASK 获取到了另外一个类的信息。即isa 从类XDPerson又指向了类XDPerson（其实这个类是我们XDPerson的metaClass元类）。我们编译器会把一个类作为它的元类的实例化对象来处理，就像一个对象从类实例化出来的模式。
(lldb) x/4gx $2
0x100001180: 0x001d800100aff0f1 0x00000001000011d0
0x100001190: 0x0000000101e142b0 0x0000000100000007
(lldb) p/x 0x001d800100aff0f1 & 0x0000000ffffffff8
(long) $3 = 0x0000000100aff0f0
(lldb) po $3
NSObject
  1. 我们打印元类XDPerson的内存信息 通过元类的isa & ISA_MASK 获取到了另外一个类NSObject的信息。即isa 从元类XDPerson又指向了类NSObject。
(lldb) x/4gx $3
0x100aff0f0: 0x001d800100aff0f1 0x0000000100aff140
0x100aff100: 0x0000000101e146e0 0x0000000300000007
(lldb) p/x 0x001d800100aff0f1 & 0x0000000ffffffff8
(long) $4 = 0x0000000100aff0f0
(lldb) po $4
NSObject
  1. 我们打印元类NSObject的内存信息 通过元类的isa & ISA_MASK 获取到了类NSObject的信息。即isa 从类NSObject指回了了类NSObject。其实做到这里我们就可以看到了 第三步的NSObject与第四步的NSObject是同一片内存地址。

通过上面的lldb调试我们基本上了解到了isa的指向走位分析，下面就把苹果官方提供的isa的走位图拿出来做一下解释


isa流程图.png

这是一幅很重要的图，记住了isa的指向走位和继承关系对我们以后的探索都是很重要的。

  1. 虚线代表了isa的走位。实例对象->类->元类->根元类->根根元类(根元类本身)。
  2. 实线代表了继承关系。

补充讲解继承关系

我们先定义好这么一个继承关系XDTeacher->XDPerson->NSObject。
有一点我们需要注意的就是类内存信息中的第二个地址指向是superClass（这个位置后面的章节会探索到）。

我们探索类的继承关系

XDTeacher *tea = [XDTeacher alloc];

(lldb) x/4gx XDTeacher.class
0x1000011f8: 0x001d8001000011d1 0x00000001000011a8
0x100001208: 0x00000001003a1e50 0x0000000000000000
(lldb) po 0x00000001000011a8
XDPerson
  1. 打印XDTeacher的内存信息，再打印内存信息中的第二个内存址。即验证XDTeacher 的父类 XDPerson。
(lldb) x/4gx 0x00000001000011a8
0x1000011a8: 0x001d800100001181 0x0000000100aff140
0x1000011b8: 0x00000001003a1e50 0x0000000000000000
(lldb) po 0x0000000100aff140
NSObject
  1. 打印XDPerson的内存信息，再打印内存信息中的第二个内存地址。即验证XDPerson 的父类 NSObject。
(lldb) x/4gx 0x0000000100aff140
0x100aff140: 0x001d800100aff0f1 0x0000000000000000
0x100aff150: 0x000000010105b980 0x0000000100000003
(lldb) po 0x0000000000000000
<nil>
  1. 打印NSObject的内存信息，再打印内存信息中的第二个内存地址。即验证NSObject 的父类 nil。

结论：上面的调试我们已经获取到了类的继承关系XDTeacher->XDPerson->NSObject->nil

我们继续探索元类的继承关系

(lldb) x/4xg XDTeacher.class
0x1000011f8: 0x001d8001000011d1 0x00000001000011a8
0x100001208: 0x00000001003a1e50 0x0000000000000000
(lldb) po 0x00000001000011a8
XDPerson

(lldb) x/4xg 0x00000001000011a8
0x1000011a8: 0x001d800100001181 0x0000000100aff140
0x1000011b8: 0x00000001003a1e50 0x0000000000000000
(lldb) po 0x0000000100aff140
NSObject
  1. 我们把继承链上的类的内存地址全部拿到。
(lldb) p/x 0x001d8001000011d1 & 0x0000000ffffffff8
(long) $3 = 0x00000001000011d0
(lldb) x/4xg 0x00000001000011d0
0x1000011d0: 0x001d800100aff0f1 0x0000000100001180
0x1000011e0: 0x00000001018002a0 0x0000000300000003
  1. 获取类XDTeacher的元类信息，我们可以拿到XDTeacher的元类的父类的内存地址0x0000000100001180。
(lldb) x/4xg 0x00000001000011a8
0x1000011a8: 0x001d800100001181 0x0000000100aff140
0x1000011b8: 0x00000001003a1e50 0x0000000000000000
(lldb) p/x 0x001d800100001181 & 0x0000000ffffffff8
(long) $4 = 0x0000000100001180
  1. 获取类XDPerson的元类内存地址0x0000000100001180。这时候我们发现，这一步获取的内存地址可以验证一个结论，XDTeacher的元类->XDPerson的元类。
//查看XDPerson的元类的内存信息
(lldb) x/4xg 0x0000000100001180
0x100001180: 0x001d800100aff0f1 0x0000000100aff0f0 -->XDPerson的元类的父类内存地址
0x100001190: 0x0000000101d09e50 0x0000000300000003

//查看NSObjec的内存信息
(lldb) x/4xg 0x0000000100aff140
0x100aff140: 0x001d800100aff0f1 0x0000000000000000
0x100aff150: 0x000000010183a780 0x0000000100000003
//查看NSObjec的元类内存地址
(lldb) p/x 0x001d800100aff0f1 & 0x0000000ffffffff8
(long) $5 = 0x0000000100aff0f0 -->验证XDPerson的元类->NSObjec的元类

//查看根元类的内存信息
(lldb) x/4xg 0x0000000100aff0f0
0x100aff0f0: 0x001d800100aff0f1 0x0000000100aff140
0x100aff100: 0x0000000101d094c0 0x0000000300000007
//查看根元类的父类
(lldb) x/4xg 0x0000000100aff140
0x100aff140: 0x001d800100aff0f1 0x0000000000000000
0x100aff150: 0x000000010183a780 0x0000000100000003
//这里我么可以提前获取一下打印NSObject.class的内存信息 
//方便区分根元类NSObject 和 类NSObject 我这里没有打印
//po NSObject.class
//得到根元类的父类NSObject
(lldb) p/x 0x001d800100aff0f1 & 0x0000000ffffffff8
(long) $7 = 0x0000000100aff0f0
(lldb) po $7
NSObject
(lldb) po 0x0000000000000000
<nil>

通过我们一步步的调试，我们已经完美的验证了元类的继承关系
XDTeacher元类->XDPerson元类->NSObject元类->NSObject->nil

其实有我们可以尝试的道路有很多种，下面举例

(lldb) x/4gx person
0x10185eac0: 0x001d8001000011a9 0x0000000000000000
0x10185ead0: 0x000000010185eba0 0x000000010185ede0

这个时候我们可以打印首个内存地址的值po 0x10185eac0,我们可以发现打印出来的结果 就是 0x00000001000011a8 XDPerson

(lldb) p/x 0x001d8001000011a9 & 0x0000000ffffffff8
(long) $1 = 0x00000001000011a8
(lldb) po $1
XDPerson

到这里为止，我们isa的指向走位分析以及继承关系已经探索完毕，理解不足之处还请给为大佬们指点。

相关文章

  • 第一天重点图

    一、alloc 二、内存对齐 三、isa的初始化 & 指向分析

  • isa初始化&指向分析

    探索对象与类如何绑定在一起 在objc4的源码中，通过研究alloc的流程就可看到下面的代码 上面的代码我们可以看...

  • (三) isa初始化&指向分析

    1. isa初始化 在分析 alloc 的时候跟踪到了_class_createInstanceFromZone，...

  • isa的初始化&指向分析

    一、isa的初始化 首先从源码中找到类Class的定义和结构 继续找objc_class 继续找objc_obje...

  • isa的初始化&指向分析

    在探索alloc&init一篇中，我们对alloc&init有了初步的了解，其中包括对isa的初始化，本篇我们进一...

  • ISA的初始化&指向分析

    我们都知道 alloc创建了对象并且分配内存；同时初始化isa属性；我们也知道了OC 对象在底层本质上是结构体，所...

  • isa的初始化&指向分析

    在 alloc的初探 中了解了如何获取对象大小，内存对齐的原则，对象的 alloc，但是在调用 calloc 在堆...

  • isa指向分析

    通过调试父获取isa指针 使用x/4gx person 获取了person对象的16进制的地址。第一个值就是对象的...

  • OC对象的种类和分析

    先说分析结论 1.对象 isa 指针的指向？instance 对象的 isa 指向 class 对象class 对...

  • isa指针指向和类结构分析

    isa指针指向和类结构分析 isa指向图 经典的isa指向图 从这张图能总结出类继承自父类，父类继承于NSObje...

网友评论

      本文标题：isa初始化&指向分析

      本文链接：https://www.haomeiwen.com/subject/whvvnctx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|isa初始化&指向分析|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！