(一)动态方法决议
- 案例如下 创建一个LGTeacher类，声明一个say666方法，方法不实现
int main(int argc, const char * argv[]) {
@autoreleasepool {
LGTeacher *p = [LGTeacher alloc];
[LGTeacher say666];
}
return 0;
}
image.png
unrecognized selector 经典的方法为实现奔溃，我们没有写log 为什么会有这样的输出呢？
-
在方法慢速查找我们找到相关代码
image.png -
这里找到给forward_imp 一个定语赋值，当慢速查找父类为nil时
image.png 当慢速查找没有找到时会进入_bjc_msgForward_impcache 方法决议
STATIC_ENTRY __objc_msgForward_impcache
// No stret specialization.
b __objc_msgForward
END_ENTRY __objc_msgForward_impcache
ENTRY __objc_msgForward
adrp x17, __objc_forward_handler@PAGE
ldr p17, [x17, __objc_forward_handler@PAGEOFF]
TailCallFunctionPointer x17
END_ENTRY __objc_msgForward
- 从源码中找到x17，进入 __objc_forward_handler 方法判断
objc_defaultForwardHandler(id self, SEL sel)
{
_objc_fatal("%c[%s %s]: unrecognized selector sent to instance %p "
"(no message forward handler is installed)",
class_isMetaClass(object_getClass(self)) ? '+' : '-',
object_getClassName(self), sel_getName(sel), self);
}
void *_objc_forward_handler = (void*)objc_defaultForwardHandler;
从_objc_forward_handler 方法中终于找到日志实现的地方
思考：？？？？当返回unrecognized selector 之前 lookUpImpOrForward 里面有没做其他操作？
在探究慢速查找流程lookUpImpOrForward中，如果没有查找到imp就会走动态方法决议流程resolveMethod_locked
IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior){
...
if (slowpath(behavior & LOOKUP_RESOLVER)) {
behavior ^= LOOKUP_RESOLVER;
return resolveMethod_locked(inst, sel, cls, behavior);
}
- 从上面判断逻辑可以得出resolveMethod_locked 只会进入一次 我们看下resolveMethod_locked 里面做了什么？？
resolveMethod_locked(id inst, SEL sel, Class cls, int behavior)
{
runtimeLock.assertLocked();
ASSERT(cls->isRealized());
runtimeLock.unlock();
// 给你一次机会 拯救地球 -> imp
if (! cls->isMetaClass()) {
// try [cls resolveInstanceMethod:sel]
resolveInstanceMethod(inst, sel, cls);
}
else {
// try [nonMetaClass resolveClassMethod:sel]
// and [cls resolveInstanceMethod:sel]
resolveClassMethod(inst, sel, cls);
if (!lookUpImpOrNilTryCache(inst, sel, cls)) {
resolveInstanceMethod(inst, sel, cls);
}
}
// chances are that calling the resolver have populated the cache
// so attempt using it
return lookUpImpOrForwardTryCache(inst, sel, cls, behavior);
}
return lookUpImpOrForwardTryCache(inst, sel, cls, behavior); 从这句代码可以得出resolveMethod_locked是做了一次容错，从新给一次拯救机会
resolveInstanceMethod 是非元类实现的方法（实例方法），resolveClassMethod元类方法（类方法）
static void resolveInstanceMethod(id inst, SEL sel, Class cls)
{
runtimeLock.assertUnlocked();
ASSERT(cls->isRealized());
SEL resolve_sel = @selector(resolveInstanceMethod:);
if (!lookUpImpOrNilTryCache(cls, resolve_sel, cls->ISA(/*authenticated*/true))) {
// Resolver not implemented.
return;
}
BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
bool resolved = msg(cls, resolve_sel, sel);
static void resolveClassMethod(id inst, SEL sel, Class cls)
{
runtimeLock.assertUnlocked();
ASSERT(cls->isRealized());
ASSERT(cls->isMetaClass());
if (!lookUpImpOrNilTryCache(inst, @selector(resolveClassMethod:), cls)) {
// Resolver not implemented.
return;
}
Class nonmeta;
{
mutex_locker_t lock(runtimeLock);
nonmeta = getMaybeUnrealizedNonMetaClass(cls, inst);
// +initialize path should have realized nonmeta already
if (!nonmeta->isRealized()) {
_objc_fatal("nonmeta class %s (%p) unexpectedly not realized",
nonmeta->nameForLogging(), nonmeta);
}
}
BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
bool resolved = msg(nonmeta, @selector(resolveClassMethod:), sel);
// Cache the result (good or bad) so the resolver doesn't fire next time.
// +resolveClassMethod adds to self->ISA() a.k.a. cls
IMP imp = lookUpImpOrNilTryCache(inst, sel, cls);
if (resolved && PrintResolving) {
if (imp) {
_objc_inform("RESOLVE: method %c[%s %s] "
"dynamically resolved to %p",
cls->isMetaClass() ? '+' : '-',
cls->nameForLogging(), sel_getName(sel), imp);
}
else {
// Method resolver didn't add anything?
_objc_inform("RESOLVE: +[%s resolveClassMethod:%s] returned YES"
", but no new implementation of %c[%s %s] was found",
cls->nameForLogging(), sel_getName(sel),
cls->isMetaClass() ? '+' : '-',
cls->nameForLogging(), sel_getName(sel));
}
}
}
BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
bool resolved = msg(cls, resolve_sel, sel);BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
bool resolved = msg(nonmeta, @selector(resolveClassMethod:), sel);这2个方法都调用 objc_msgSend 向系统发送消息
在LGTeacher类中添加resolveInstanceMethod方法
+ (BOOL)resolveInstanceMethod:(SEL)sel{
NSLog(@"resolveInstanceMethod :%@-%@",self,NSStringFromSelector(sel));
return [super resolveInstanceMethod:sel];
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
LGTeacher *p = [LGTeacher alloc];
[p say666];
}
return 0;
}
- lldb输出为
2021-07-12 17:37:18.775526+0800 KCObjcBuild[7443:173330] resolveInstanceMethod :LGTeacher-say666
2021-07-12 17:37:18.776380+0800 KCObjcBuild[7443:173330] resolveInstanceMethod :LGTeacher-say666
2021-07-12 17:37:18.776749+0800 KCObjcBuild[7443:173330] -[LGTeacher say666]: unrecognized selector sent to instance 0x1011405d0
- 从输出可以看出resolveInstanceMethod调用了2次 为什么呢
image.png
-
从图看出第一调用发起者是resolveMethod_locked 可以看到走的是慢速查找流程的动态决议方法
image.png 上图可以看出第二次 发起者CoreFoundation`-[NSObject(NSObject) methodSignatureForSelector:]:
根据上面分析得出动态消息决议流程图
image.png