目录
- 1. alloc 对象的指针地址和内存
- 2. 底层探索的三种方法
2.1 下符号断点
2.2 汇编跟流程
2.3 通过已知函数下符号断点，断住位置- 3. 编译源码，探索底层
3.1 源码下载
3.2 源码断点调试
instanceSize：计算所需内存
calloc：开辟内存，返回地址指针
initInstanceIsa：初始化指针，和类进行关联
1. alloc 对象的指针地址和内存
首先我们先用一个例子进行分析：
SSLPerson *p1 = [SSLPerson alloc];
SSLPerson *p2 = [p1 init];
SSLPerson *p3 = [p2 init];
SSLPerson *p4 = [SSLPerson alloc];
NSLog(@"%@-%p-%p",p1,p1,&p1);
NSLog(@"%@-%p-%p",p2,p2,&p2);
NSLog(@"%@-%p-%p",p3,p3,&p3);
NSLog(@"%@-%p-%p",p4,p4,&p4);
查看打印结果：
-0x600000eef1a0-0x7ffeeec48448
-0x600000eef1a0-0x7ffeeec48440
-0x600000eef1a0-0x7ffeeec48438
-0x600000eef1b0-0x7ffeeec48430
-
p1、p2、p3指向同一片内存空间：0x600000eef1a0； -
p4指向内存空间：0x600000eef1b0； -
p1、p2、p3、p4的指针地址分别是：0x7ffeeec48448、0x7ffeeec48440、0x7ffeeec48438、0x7ffeeec48430。
分析：
-
alloc有开辟内存，init没有开辟内存； - 内存地址是以
0x6开头，存储在了堆上，指针地址是以0x7开头，存储在了栈上； - 指针地址尾部
48、40、38，30相差8，说明他们是连续开辟的内存地址，48>40>38>30，说明栈是高地址向低地址存储； -
b0>a0，说明堆是低地址向高地址存储。
通过上面我们可以发现，对象内存地址是通过alloc创建，我们看一下alloc是怎么实现的。
点击alloc方法进入NSObject.h:
+ (instancetype)alloc OBJC_SWIFT_UNAVAILABLE("use object initializers instead");
进入NSObject.h我们发现看不到alloc的实现，下面介绍探索底层的三种方法。
2. 底层探索的三种方法
2.1 下符号断点
- 在
alloc调用位置打断点，运行程序，断点断住的时候，按住control键，点击step into进入下一步； - 在汇编中找到方法
objc_alloc； - 为
objc_alloc方法添加符号断点； - 找到所在底层库和方法。
具体步骤如下图：
2.2 汇编跟流程
- 在
alloc调用位置打断点，运行程序； - 断点断住的时候，
Xcode->Debug->Debug Workflow->Always Show Disassembly,进入汇编； - 汇编中
callq是函数调用的意思，通过它找到方法调用； - 找到方法调用以后可以通过
step into或者下符号断点的方式继续调试，来找到所在底层库和方法。。
具体步骤如下图：
2.3 通过已知函数下符号断点，断住位置
- 在
alloc调用位置打断点，运行程序； - 添加
alloc符号断点，点击断点跳转按钮； - 找到所在底层库和方法。
具体步骤如下图：
3. 编译源码，探索底层
上面介绍的三种方法，帮助我们找到了底层方法objc_alloc和所在的底层库libobjc。接下来我们把objc源码跑起来，进行更加深入的底层探索。
3.1 源码下载
苹果开源源码: https://opensource.apple.com/tarballs/
下载步骤如下：
下载下来的源码不能直接编译调试，可以去网上查一下配置方法，我们下边用配置好的代码进行探索，用的版本是818.2。
3.2 源码断点调试
根据源码调试，alloc调用流程如下：
断点进入alloc方法：
+ (id)alloc {
return _objc_rootAlloc(self);
}
断点进入_objc_rootAlloc方法：
id _objc_rootAlloc(Class cls)
{
return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}
断点进入callAlloc方法：
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
if (slowpath(checkNil && !cls)) return nil;
if (fastpath(!cls->ISA()->hasCustomAWZ())) {
return _objc_rootAllocWithZone(cls, nil);
}
#endif
// No shortcuts available.
if (allocWithZone) {
return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
}
return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}
断点进入_objc_rootAllocWithZone：
id _objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
// allocWithZone under __OBJC2__ ignores the zone parameter
return _class_createInstanceFromZone(cls, 0, nil,
OBJECT_CONSTRUCT_CALL_BADALLOC);
}
这里，断点进入到核心方法_class_createInstanceFromZone：
static ALWAYS_INLINE id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
int construct_flags = OBJECT_CONSTRUCT_NONE,
bool cxxConstruct = true,
size_t *outAllocatedSize = nil)
{
ASSERT(cls->isRealized());
// Read class's info bits all at once for performance
bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
bool hasCxxDtor = cls->hasCxxDtor();
bool fast = cls->canAllocNonpointer();
size_t size;
size = cls->instanceSize(extraBytes);
if (outAllocatedSize) *outAllocatedSize = size;
id obj;
if (zone) {
obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
} else {
obj = (id)calloc(1, size);
}
if (slowpath(!obj)) {
if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
return _objc_callBadAllocHandler(cls);
}
return nil;
}
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);
}
if (fastpath(!hasCxxCtor)) {
return obj;
}
construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
return object_cxxConstructFromClass(obj, cls, construct_flags);
}
这个方法中有三个核心子方法：
-
cls->instanceSize(extraBytes)：计算所需内存; -
(id)calloc(1, size)：开辟内存，返回地址指针; -
obj->initInstanceIsa(cls, hasCxxDtor)：初始化指针，和类进行 关联。
instanceSize：计算所需内存
断点进入instanceSize：
inline size_t instanceSize(size_t extraBytes) const {
if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
return cache.fastInstanceSize(extraBytes);
}
size_t size = alignedInstanceSize() + extraBytes;
// CF requires all objects be at least 16 bytes.
if (size < 16) size = 16;
return size;
}
断点进入cache.fastInstanceSize：
size_t fastInstanceSize(size_t extra) const
{
ASSERT(hasFastInstanceSize(extra));
if (__builtin_constant_p(extra) && extra == 0) {
return _flags & FAST_CACHE_ALLOC_MASK16;
} else {
size_t size = _flags & FAST_CACHE_ALLOC_MASK;
// remove the FAST_CACHE_ALLOC_DELTA16 that was added
// by setFastInstanceSize
return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
}
}
断点进入align16：
得到所需空间大小：
通过上面的结果，我们发现align16这个方法进行了16字节对齐处理，下面我们来分析一下(x + size_t(15)) & ~size_t(15)。
解释说明：
- 先简化下代码得到：
(x + 15) & ~15； -
(x + 15)的意思是对x进行升阶操作，如果x不是16的整数倍，那么升阶到下一个倍数等级，等待下一步计算； -
~15的意思是对15取反得到1111 0000； - 最后
&操作，得到的是16的倍数，剩下不足16的抹去。
注：此算法和
>> 4 << 4是一样的
以x = 23为例：
(23 + 15) = 38，把23从16的一倍数升阶到了16的二倍数，得到0010 0110
15：0000 1111
~15：1111 0000
38 & ~150010 0110 & 1111 0000
结果：0010 0000即32
为什么需要16字节对齐
- 访问速度更快：
cpu并不是以字节为单位来存取数据的，它会把内存当成一块一块的，每次读取都是一个固定的开销，减少内存存取次数提升应用程序的性能。 - 更安全：
iOS中对象都有自己的isa指针，占8字节内存，如果8字节对齐，对象之间都是紧挨着没有一点空隙，内存访问时一点的错误或者偏移就有可能发生内存混乱，所以我们选取8的倍数16来进行对齐。
现在所需内存size已经计算完成，接下来根据size进行内存空间的开辟。
calloc：开辟内存，返回地址指针
断点继续查看：
可以看到我们并没有给obj赋值，它却已经有地址了，说明这是一块脏地址，并没有什么实际意义。
calloc调用后查看：
可以发现obj地址已经发生变化，说明内存已经开辟完成。
initInstanceIsa：初始化指针，和类进行关联
断点进入initInstanceIsa方法：
inline void
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
ASSERT(!cls->instancesRequireRawIsa());
ASSERT(hasCxxDtor == cls->hasCxxDtor());
initIsa(cls, true, hasCxxDtor);
}
initInstanceIsa调用后打印ojb：
打印结果为：alloc探索完成。