iOS底層原理之alloc探究(三)物件本質與神秘的isa

iOS 底層原理之alloc 探究（三）物件本質與神秘的isa

一，準備作業

1.了解Clang編譯器

Clang是?個C、C++、Objective-C語?的輕量級編譯器，源代碼發布于BSD協議下，
Clang是?個C++撰寫由Apple主導，基于LLVM的C/C++/Objective-C編譯器2013年4?,
Clang已經全??持C++11標準，并開始實作C++1y特性（也就是C++14，這是C++的下?個?更新版本），
Clang將?持其普通lambda運算式、回傳型別的簡化處理以及更好的處理constexpr關鍵字，
Objective-C++編譯器，它與GNU C語?規范?乎完全兼容（當然，也有部分不兼容的內容，
包括編譯命令選項也會有點差異），并在此基礎上增加了額外的語法特性，?如C函式多載（通過

2.將oc?件編譯成c++?件
1）直接使用clang命令
clang -rewrite-objc main.m -o main.cpp
在使用上面的命令可能會報錯需要修改 xcode版本，以及模擬器版本，和最后的檔案名稱

2）使用xcrun命令（clang基礎上的封裝）
xcrun -sdk iphonesimulator clang -arch x86_64 -rewrite-objc main.m -o main-x86_64.cpp (模擬器)
3）
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o mainarm64.cpp(真機)

二，分析編譯后的c++檔案

隨便在.m檔案中創建一個類

@interface Goods : NSObject
@property (nonatomic, strong) NSString *good;

@end

@implementation Goods

編譯后全域搜索Goods

extern "C" unsigned long OBJC_IVAR_$_Goods$_good;
struct Goods_IMPL {
	struct NSObject_IMPL NSObject_IVARS;
	NSString *_good;
};

struct NSObject_IMPL {
	Class isa;
};

我們將會看到這樣一個結構體，這里的NSObject_IVARS即isa成員變數，因此可以得出一個結論：物件在底層的本質就是結構體

三，物件之神秘成員變數isa

1.isa 低層原始碼分析
在第一講我們提到isa主要作用是將 物件開辟的記憶體和class進行系結，

   if (!zone && fast) {
        obj->initInstanceIsa(cls, hasCxxDtor);
    } else {
        // Use raw pointer isa on the assumption that they might be
        // doing something weird with the zone or RR.
        obj->initIsa(cls);
    }

我們繼續深入 initIsa 方法實作

inline void 
objc_object::initIsa(Class cls)
{
    initIsa(cls, false, false);
}

inline void 
objc_object::initIsa(Class cls, bool nonpointer, UNUSED_WITHOUT_INDEXED_ISA_AND_DTOR_BIT bool hasCxxDtor)
{ 
    ASSERT(!isTaggedPointer()); 
    
    isa_t newisa(0);

    if (!nonpointer) {
        newisa.setClass(cls, this);
    } else {
        ASSERT(!DisableNonpointerIsa);
        ASSERT(!cls->instancesRequireRawIsa());


#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
#   if ISA_HAS_CXX_DTOR_BIT
        newisa.has_cxx_dtor = hasCxxDtor;
#   endif
        newisa.setClass(cls, this);
#endif
        newisa.extra_rc = 1;
    }

    // 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 newisa(0) ----->isa = newisa進而確定isa型別 isa_t
這里的引數：nonpointer 表示不單單只是一個指標，為什么會有這樣一個定義？
因為每一個物件都包含isa指標，isa指標會分配8位元組，即8*8=64位，又因為isa的主要作用是將記憶體和類進行系結，那么如果將對應的類（即指標）存盤到isa中只需要8位，那么這里造成大量的記憶體空閑，因此蘋果針對空余的空間做了相關優化，將一些關鍵的資訊也放入到這里，如參考計數，是否正在釋放，weak，關聯物件等，

#include "isa.h"
union isa_t {
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    uintptr_t bits;

private:
    // Accessing the class requires custom ptrauth operations, so
    // force clients to go through setClass/getClass by making this
    // private.
    Class cls;

public:
#if defined(ISA_BITFIELD)
    struct {
        ISA_BITFIELD;  // defined in isa.h
    };

};

    struct {
        ISA_BITFIELD;  // defined in isa.h
    };

#   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 unused            : 1;                                         \
      uintptr_t has_sidetable_rc  : 1;                                         \
      uintptr_t extra_rc          : 8

我們可以通過上面的原始碼可以得出，isa_t 是一個聯合體， Class cls為什么會在 union isa_t聯合體里面，這就利用了聯合體的一個特性，互斥，獨一無二，（后面會對聯合體位域做補充）
nonpointer：表示是否對isa指標進行優化，0表示純指標，1表示不止是類物件的地址，isa中包含了類資訊、物件、參考計數等
has_assoc：關聯物件標志位，0表示未關聯，1表示關聯
has_cxx_dtor：該物件是否C ++ 或者Objc的析構器，如果有解構式，則需要做析構邏輯，沒有，則釋放物件
shiftcls：儲存類指標的值，開啟指標優化的情況下，在arm64架構中有33位用來存盤類指標，x86_64架構中占44位
magic：用于除錯器判斷當前物件是真的物件還是沒有初始化的空間
weakly_referenced：指物件是否被指向或者曾經指向一個ARC的弱變數，沒有弱參考的物件可以更快釋放
deallocating：標志物件是否正在釋放
has_sidetable_rc：當物件參考計數大于10時，則需要借用該變數存盤進位
hextra_rc：表示該物件的參考計數值，實際上參考計數值減1，例如，如果物件的參考計數為10，那么extra_rc為9，如果大于10，就需要用到上面的has_sidetable_rc

著作權歸作者所有，商業轉載請聯系作者獲得授權，非商業轉載請注明出處，

四，聯合體位域補充

struct LGTeacher1 {
    char        *name;
    int         age;
    double      height ;
};

   struct Goods   good;
   good.name = "shouji";
   good.num  = 2;
   good.wight  = 5;

(lldb) p good
(Goods) $0 = (name = "shouji", num = 0, wight = 0)
(lldb) p good
(Goods) $1 = (name = "shouji", num = 2, wight = 5)

結構體(struct)中所有變數是“共存”的——優點是“有容乃大”， 全面;缺點是struct記憶體空間的分配是粗放的，不管用不用，全分配，

// 4 * 8 = 32  0000 0000 0000 0000 0000 0000 0000 1111
// 4 位
// 1 位元組 3倍浪費
struct Goodss1 {
    BOOL good1; // 0 1
    BOOL good2;
    BOOL good3;
    BOOL good4;
};

// 位域
struct Goodss2 {
    BOOL good1: 1;
    BOOL good2 : 1;
    BOOL good3 : 1;
    BOOL good4: 1;
};
struct Goodss3 {
    BOOL good1: 1;
    BOOL good2 : 2;
    BOOL good3 : 6;
    BOOL good4: 1;
};

2021-06-13 21:42:45.076498+0800 001-聯合體位域[1931:92731] 4-1-2

通過代碼測驗可以得出結論：結構體可以動態調整成員變數的存盤大小，即位域， 主要目的還是為了記憶體利用最大化，

// 聯合體 : 互斥
union Goods2 {
    char        *name;
    int         age;
    double      height ;
};

(lldb) p good2
(Goods2) $0 = (name = "是", age = 15999, height = 2.1220036955215401E-314)
(lldb) p good2
(Goods2) $2 = (name = "", age = 100, height = 2.1219958403718369E-314)

聯合體可以定義多個不同型別的成員，聯合體的記憶體大小由其中最大的成員的大小決定，
聯合體中修改其中的某個變數會覆寫其他變數的值，
聯合體所有的變數公用一塊記憶體，變數之間互斥，

五，讀取 isa 中的存盤資訊

        Goods *p = [Goods alloc];
        NSLog(@"%@",p);

(lldb) x/4gx p
0x100621d60: 0x011d800100008275 0x0000000000000000
0x100621d70: 0x0000000000000000 0x0000000000000000
(lldb) p/x Goods.class
(Class) $2 = 0x0000000100008270 Goods
(lldb) p/x 0x011d800100008275 & 0x00007ffffffffff8ULL
(unsigned long long) $3 = 0x0000000100008270

1）通過列印可以發現 0x011d800100008275 即為isa的記憶體，可以發現并沒有存滿，
0x0000000100008270 位類的資訊儲存值，當我們通過 總的記憶體 & 上 # define ISA_MASK 0x00007ffffffffff8ULL時可以得到class 的存盤資訊，這里用到 ISA_MASK 是一個掩碼 ，通過 & 操作讀取對應記憶體中的資訊，因為我們存盤的時候也是通過這種方式存盤的，

(lldb) p/x 0x011d800100008275 >>3
(long) $4 = 0x0023b0002000104e
(lldb) p/x 0x0023b0002000104e << 20
(long) $5 = 0x0002000104e00000
(lldb) p/x 0x0002000104e00000 >> 17
(long) $6 = 0x0000000100008270

這里為什么先向右移3位， 1+1+1=3
在向左移動20位  3+6+1+1+1+8=20
最后在向右移動17位 回到原來的位置，

      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 unused            : 1;                                         \
      uintptr_t has_sidetable_rc  : 1;                                         \
      uintptr_t extra_rc          : 8

2）通過位運算得到存盤的 class 資訊這里
物件中的成員變數是通過平移也是通過對應的屬性存盤的大小通過位運算平移取值，

總結

1.物件在底層的本質就是結構體
2.物件中的成員變數isa主要是通過聯合體+位域的方式存盤資訊，優點就是節省大量記憶體，
3.isa主要是通過shiftcls進行儲存類指標的值，進而將類和對應申請的記憶體進行系結，
未完待續，，，