本文使用的 runtime 版本为 objc4-706

+alloc-init 是我们经常使用的两个方法,通常它们也是以 [[SomeClass alloc] init] 这个形式出现的,本篇文章对它们的实现做一点记录。

alloc

NSObject.mm 中,可以找到 +alloc 的实现:

+ (id)alloc {
    return _objc_rootAlloc(self);
}

+alloc 的实现就是简单的将事情甩给了 _objc_rootAlloc,接着看 _objc_rootAlloc 的实现:

// Base class implementation of +alloc. cls is not nil.
// Calls [cls allocWithZone:nil].
id
_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

_objc_rootAlloc 也是一个甩锅侠,将锅甩给了 callAlloc,继续看 callAlloc 的实现:

// Call [cls alloc] or [cls allocWithZone:nil], with appropriate 
// shortcutting optimizations.
static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
    if (slowpath(checkNil && !cls)) return nil;

#if __OBJC2__
    if (fastpath(!cls->ISA()->hasCustomAWZ())) {
        // No alloc/allocWithZone implementation. Go straight to the allocator.
        // fixme store hasCustomAWZ in the non-meta class and 
        // add it to canAllocFast's summary
        if (fastpath(cls->canAllocFast())) {
            // No ctors, raw isa, etc. Go straight to the metal.
            bool dtor = cls->hasCxxDtor();
            id obj = (id)calloc(1, cls->bits.fastInstanceSize());
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            obj->initInstanceIsa(cls, dtor);
            return obj;
        }
        else {
            // Has ctor or raw isa or something. Use the slower path.
            id obj = class_createInstance(cls, 0);
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            return obj;
        }
    }
#endif

    // No shortcuts available.
    if (allocWithZone) return [cls allocWithZone:nil];
    return [cls alloc];
}

其中 slowpathfastpath 宏的定义如下:

#define fastpath(x) (__builtin_expect(bool(x), 1))
#define slowpath(x) (__builtin_expect(bool(x), 0))

__builtin_expect 起的是优化性能的作用,表示分支预测时第一个参数较大概率会是第二个参数,所以 fastpath(x) 表示 x 较大概率为真,slowpath(x) 表示 x 较大概率为假,返回值就是 x 本身。

回到 callAlloc,刚开始的一句 if (slowpath(checkNil && !cls)) return nil; 进行了对 cls 参数为 nil 的判断,使用的是 slowpath,表示这是比较不可能出现的情况。

接下来从 #if __OBJC2__ 开始至 #endif,都是在 Objective-C 2.0 下才会有的代码,那当然是我们需要关注的地方了,毕竟我们现在使用的就是 Objective-C 2.0。

其中,首先要进行一下判断:if (fastpath(!cls->ISA()->hasCustomAWZ())) { ... },这里判断一个类是否有自定义的 +allocWithZone: 实现,有的话,就不能走这里面的默认实现了。

继续关注默认实现,接下来进行判断 if (fastpath(cls->canAllocFast())) { ... } else { ... }。首先关于 canAllocFast 的定义是这样的,在 objc-runtime-new.h 中:

#if FAST_ALLOC

    ...

    bool canAllocFast() {
        return bits & FAST_ALLOC;
    }
#else
    size_t fastInstanceSize() {
        abort();
    }
    void setFastInstanceSize(size_t) {
        // nothing
    }
    bool canAllocFast() {
        return false;
    }
#endif

同样还是在 objc-runtime-new.h 中,可以看到有关 FAST_ALLOC 的定义:

#if !__LP64__

...

#elif 1
// Leaks-compatible version that steals low bits only.

... 根本没有 FAST_ALLOC ...

#else
// Leaks-incompatible version that steals lots of bits.

...

// summary bit for fast alloc path: !hasCxxCtor and 
//   !instancesRequireRawIsa and instanceSize fits into shiftedSize
#define FAST_ALLOC              (1UL<<50)
// instance size in units of 16 bytes
//   or 0 if the instance size is too big in this field
//   This field must be LAST
#define FAST_SHIFTED_SIZE_SHIFT 51

// FAST_ALLOC means
//   FAST_HAS_CXX_CTOR is set
//   FAST_REQUIRES_RAW_ISA is not set
//   FAST_SHIFTED_SIZE is not zero
// FAST_ALLOC does NOT check FAST_HAS_DEFAULT_AWZ because that 
// bit is stored on the metaclass.
#define FAST_ALLOC_MASK  (FAST_HAS_CXX_CTOR | FAST_REQUIRES_RAW_ISA)
#define FAST_ALLOC_VALUE (0)

#endif

其中的 #elif 1 真是亮瞎狗眼。所以现在使用的 runtime 里根本就没有 FAST_ALLOC 这个玩意……所以现在 canAllocFast 其实是一个永远返回 false 的函数了,那我们只需要关心上面判断中 else 里的代码了。

else 里只有 3 行代码:

  1. id obj = class_createInstance(cls, 0);
  2. if (slowpath(!obj)) return callBadAllocHanlder(cls);
  3. return obj;

很明显,1 就是创建对象的调用,2 用来进行错误处理。对于我们现在所关心的,那就是 class_createInstance 函数了。在 objc-runtime-new.mm,可以找到它的实现:

id 
class_createInstance(Class cls, size_t extraBytes)
{
    return _class_createInstanceFromZone(cls, extraBytes, nil);
}

可以看到它只是调用了 _class_createInstanceFromZone,其第三个参数是 zone,用来表示 NSZone,但是 NSZone 已经是个没有使用的东西,所以这里直接传入了 nil

还是在 objc-runtime-new.mm 中,可以看到 _class_createInstanceFromZone 的实现:

static __attribute__((always_inline)) 
id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone, 
                              bool cxxConstruct = true, 
                              size_t *outAllocatedSize = nil)
{
    if (!cls) return nil;

    assert(cls->isRealized());

    // Read class's info bits all at once for performance
    bool hasCxxCtor = cls->hasCxxCtor();
    bool hasCxxDtor = cls->hasCxxDtor();
    bool fast = cls->canAllocNonpointer();

    size_t size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (!zone  &&  fast) {
        obj = (id)calloc(1, size);
        if (!obj) return nil;
        obj->initInstanceIsa(cls, hasCxxDtor);
    } 
    else {
        if (zone) {
            obj = (id)malloc_zone_calloc ((malloc_zone_t *)zone, 1, size);
        } else {
            obj = (id)calloc(1, size);
        }
        if (!obj) return nil;

        // Use raw pointer isa on the assumption that they might be 
        // doing something weird with the zone or RR.
        obj->initIsa(cls);
    }

    if (cxxConstruct && hasCxxCtor) {
        obj = _objc_constructOrFree(obj, cls);
    }

    return obj;
}

函数一开始会对 cls 判断 nil,如果 clsnil 的话就直接返回 nil,这算是遵循着 Objective-C 中对 nil 发送消息不会崩溃的一致性吧。

接下来的 assert(cls->isRealized());,断言 cls 是已经 realize 了,关于类的 realize 是什么,可以看一下 Objective-C 小记(5)类的加载,其中有简略的介绍。

接下来的 hasCxxCtorhasCxxDtor 是对 Objective-C++ 的支持,表示这个类是否有 C++ 类构造函数和析构函数,如果有的话,需要进行额外的工作。而 fast,是对 isa 的类型的区分,如果一个类的实例不能使用 isa_t 类型的 isa 的话,fast 就为 false,但是在 Objective-C 2.0 中,大部分类都是支持的。关于 isa 的类型,可以看看 Objective-C 小记(1)MessagingObjective-C 小记(2)对象 2.0

接着要获得 size,想要创建一个对象当然要知道它有多大,才能给它分配合适大小的内存,size 是通过 cls->instanceSize(extraBytes) 来获得的,可以看一下 instanceSize 的实现:

     // May be unaligned depending on class's ivars.
    uint32_t unalignedInstanceSize() {
        assert(isRealized());
        return data()->ro->instanceSize;
    }

    // Class's ivar size rounded up to a pointer-size boundary.
    uint32_t alignedInstanceSize() {
        return word_align(unalignedInstanceSize());
    }

    size_t instanceSize(size_t extraBytes) {
        size_t size = alignedInstanceSize() + extraBytes;
        // CF requires all objects be at least 16 bytes.
        if (size < 16) size = 16;
        return size;
    }

不难看出就是从 clsro 中获得 instanceSize 然后将它对齐,并加上 extraBytes,最后 Core Foundation 需要对象至少要有 16 字节,小于 16 的统统返回 16。

在进行了 id obj; 的声明后,就要真正的创建 obj 这个对象了,首先对 zonefast 进行判断,如果没有 zone 并且 fast 为真,这是现在最常见的情况了,因为 zone 肯定是没有的,NSZone 已经弃用了,fast 几乎也都是真,在这个分支里面,obj 首先使用大家都熟悉的 C 标准库这套内存申请函数中的 calloc 申请了一个 size 大小的空间,然后使用 initInstanceIsa 进行初始化。对于下面的分支,zone 也肯定还是没有的,所以还是会调用 obj = (id)calloc(1, size); 申请空间,之后会调用 initIsa

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

initIsa 只是调用了另一个 initIsa,这个 initIsa 会在后面讲到。

继续关注最常见的 initInstanceIsa 的调用,它的实现可以在 objc-object.h 中看到:

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

函数一开始的 assert(!isTaggedPointer()); 是断言对象的指针不是 Tagged Pointer,比如像 NSNumber,它的数值可以直接存在对象指针上,对象指针是一个 Tagged Pointer,但是 NSNumber 是有自己的 +allocWithZone: 的实现的。因此我个人也不清楚这个断言在这的用处大小了,但这不妨碍我们继续看下面的代码。

接下来就是对 isa 类型的判断 if (!nonpointer) { ... } else { ... },如果 isa 不是 nonpointer,也就是单纯的指针(Class 类型),则 isa 就直接被赋值为 cls。如果 isanonpointer,也就是 isa_t 类型的话,则先初始化一个所有位为 0 的指针 isa_t newisa(0)

关于 SUPPORT_INDEXED_ISA 宏,它的定义是这样的:

// Define SUPPORT_INDEXED_ISA=1 on platforms that store the class in the isa 
// field as an index into a class table.
// Note, keep this in sync with any .s files which also define it.
// Be sure to edit objc-abi.h as well.
#if __ARM_ARCH_7K__ >= 2
#   define SUPPORT_INDEXED_ISA 1
#else
#   define SUPPORT_INDEXED_ISA 0
#endif

__ARM_ARCH_7K__ 这个宏的信息在网上完全找不到,但是我们可以发现在 Xcode 中,watchOS 的 valid architectures 是 armv7k,所以 __ARM_ARCH_7K__ 应该是在 Apple Watch 上的架构,并且可能它与 Apple Watch 的代数是有关系的(第一代和第二代)。因此 SUPPORT_INDEXED_ISA 这个所谓的 indexed isa,应该是对 watchOS 的优化(记忆中 Apple 有提及对 watchOS 进行过优化,我猜这也是一项了)。

我们现在不关心 SUPPORT_INDEXED_ISA 里的内容,只看 #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;

可以看到,先将 newisabits 赋值为常量 ISA_MAGIC_VALUE,里面包括了 magicnonpointer 的值。然后将是否有 C++ 析构函数标示上,最后将位移(shift)后的 cls 存入 shiftcls(类指针按照 8 字节对齐,所以最后三位一定是 0,所以可以右移三位来节省位的使用)。

最后将 isa = newisa,工作就结束了。

至此,+alloc 的实现就告一段落了。

init

NSObject.mm 中,可以找到 -init 的实现:

- (id)init {
    return _objc_rootInit(self);
}

简单的调用了 _objc_rootInit 函数,在同一个文件中也能找到它的实现:

id
_objc_rootInit(id obj)
{
    // In practice, it will be hard to rely on this function.
    // Many classes do not properly chain -init calls.
    return obj;
}

_objc_rootInit 函数直接就将 obj 返回了,所以 -init 方法其实什么都没有做。

但是开发者留下的注释非常值得玩味,说到很多类没有使用 [super init],所以这个函数非常靠不住(很可能不被调用),看起来应该是个历史遗留问题。从上面对 +alloc 的分析也能看出,+alloc 已经把所有的工作都做完了。

总结

Objective-C 中创建对象,直白的看就是和 C 是一样的,使用 calloc 申请内存空间,然后对结构体进行初始化,虽然夹杂着很多细节,但本质上就是这样。