任意方法的Swizzle的应用之一AOP

在上篇博客曾聊过对任意方法Swizzle有多种应用,其中之一就是对多个方法的开始或者结束添加统一的切面调用。很有名的Aspect库利用类似于KVO实现原理来实现,在运行时给需要Swizzle的类动态添加子类,同时该对象isa指针指向创建的子类,然后hook子类的forwardInvocation关联到函数__ASPECTS_ARE_BEING_CALLED__。之后再将要hook的method的实现替换为_objc_msgForward,这样对该method调用会就转发到__ASPECTS_ARE_BEING_CALLED__,然后利用NSInvocation转发该调用即可。而有了对任意方法Swizzle的方案后就可以另辟蹊径来解决这个问题。

上篇博客给了个简单的demo实现,不过功能较弱,这次花了一天多时间,写了一个较为成熟的实现,总共三百行左右,其中一半是汇编。

先上代码,先吓走一票人再说。

#import 

typedef NS_OPTIONS(NSInteger, ZWInvocationOption) {
    ZWInvocationOptionReplace = 1,
    ZWInvocationOptionBefore = 1 << 1,
    ZWInvocationOptionAfter = 1 << 2,
    ZWInvocationOptionOnly = 1 << 3,
};

#if defined(__arm64__)

static NSMutableDictionary  *_ZWBeforeIMP;
static NSMutableDictionary  *_ZWOriginIMP;
static NSMutableDictionary  *_ZWAfterIMP;
static NSLock  *_ZWLock;

OS_ALWAYS_INLINE void ZWStoreParams(void) {
    asm volatile("str    d7, [x11, #0x88]\n\
                 str    d6, [x11, #0x80]\n\
                 str    d5, [x11, #0x78]\n\
                 str    d4, [x11, #0x70]\n\
                 str    d3, [x11, #0x68]\n\
                 str    d2, [x11, #0x60]\n\
                 str    d1, [x11, #0x58]\n\
                 str    d0, [x11, #0x50]\n\
                 str    x8, [x11, #0x40]\n\
                 str    x7, [x11, #0x38]\n\
                 str    x6, [x11, #0x30]\n\
                 str    x5, [x11, #0x28]\n\
                 str    x4, [x11, #0x20]\n\
                 str    x3, [x11, #0x18]\n\
                 str    x2, [x11, #0x10]\n\
                 str    x1, [x11, #0x8]\n\
                 str    x0, [x11]\n\
                 ");
}
OS_ALWAYS_INLINE void ZWLoadParams(void) {
    asm volatile("ldr    d7, [x11, #0x88]\n\
                 ldr    d6, [x11, #0x80]\n\
                 ldr    d5, [x11, #0x78]\n\
                 ldr    d4, [x11, #0x70]\n\
                 ldr    d3, [x11, #0x68]\n\
                 ldr    d2, [x11, #0x60]\n\
                 ldr    d1, [x11, #0x58]\n\
                 ldr    d0, [x11, #0x50]\n\
                 ldr    x8, [x11, #0x40]\n\
                 ldr    x7, [x11, #0x38]\n\
                 ldr    x6, [x11, #0x30]\n\
                 ldr    x5, [x11, #0x28]\n\
                 ldr    x4, [x11, #0x20]\n\
                 ldr    x3, [x11, #0x18]\n\
                 ldr    x2, [x11, #0x10]\n\
                 ldr    x1, [x11, #0x8]\n\
                 ldr    x0, [x11]\n\
                 ");
}

OS_ALWAYS_INLINE void ZWGlobalOCSwizzle(void) {
    asm volatile("stp    x29, x30, [sp, #-0x10]!");
    
    asm volatile("mov    x29, sp\n\
                 sub    sp, sp, #0xb0");
    
    asm volatile("mov    x11, sp");
    asm volatile("bl    _ZWStoreParams");

    asm volatile("mov    x0, sp");
    asm volatile("bl    _ZWBeforeInvocation");
    
    asm volatile("mov    x0, sp");
    asm volatile("bl    _ZWInvocation");
    
    asm volatile("str    x0, [sp, #0xa0]");
    asm volatile("str    d0, [sp, #0xa8]");

    asm volatile("mov    x0, sp");
    asm volatile("bl    _ZWAfterInvocation");
    
    asm volatile("ldr    x0, [sp, #0xa0]");
    asm volatile("ldr    d0, [sp, #0xa8]");
    
    asm volatile("mov    sp, x29");
    asm volatile("ldp    x29, x30, [sp], #0x10");
}

OS_ALWAYS_INLINE NSString *ZWGetMetaSelName(SEL sel) {
    return [@"__META_" stringByAppendingString:NSStringFromSelector(sel)];
}

OS_ALWAYS_INLINE id ZWGetInvocation(NSDictionary *dict, id obj, SEL sel) {
    Class class = object_getClass(obj);
    NSString *className = NSStringFromClass(class);
    NSString *selName = class_isMetaClass(class) ? ZWGetMetaSelName(sel) : NSStringFromSelector(sel);
    [_ZWLock lock];
    id Invocation = dict[className][selName];
    [_ZWLock unlock];
    return Invocation;
}

OS_ALWAYS_INLINE NSUInteger ZWGetInvocationCount(NSDictionary *dict, id obj, SEL sel) {
    id ret = ZWGetInvocation(dict, obj, sel);
    if ([ret isKindOfClass:[NSArray class]]) {
        return [ret count];
    } else if ([ret isKindOfClass:NSClassFromString(@"NSBlock")]) {
        return 1;
    }
    return 0;
}

IMP ZWGetOriginImp(id obj, SEL sel) {
    id Invocation = ZWGetInvocation(_ZWOriginIMP, obj, sel);
    if ([Invocation isKindOfClass:[NSValue class]]) {
        return [Invocation pointerValue];
    }
    return NULL;
}

IMP ZWGetCurrentImp(id obj, SEL sel) {
    id Invocation = ZWGetInvocation(_ZWOriginIMP, obj, sel);
    if ([Invocation isKindOfClass:NSClassFromString(@"NSBlock")]) {
        if (!Invocation) return NULL;
        uint64_t *p = (__bridge void *)(Invocation);
        return (IMP)*(p + 2);
    }
    return NULL;
}

IMP ZWGetAopImp(NSDictionary *Invocation, id obj, SEL sel, NSUInteger index) {
    if (!obj || !sel) return NULL;
    id block = ZWGetInvocation(Invocation, obj, sel);
    if ([block isKindOfClass:[NSArray class]]) {
        block = block[index];
    }
    if (!block) return NULL;
    uint64_t *p = (__bridge void *)(block);
    return (IMP)*(p + 2);
}


void ZWAopInvocation(void **sp, NSDictionary *Invocation, ZWInvocationOption option) {
    id obj = (__bridge id)(*sp);
    SEL sel = *(sp + 1);
    if (!obj || !sel) return;
    NSInteger count = ZWGetInvocationCount(Invocation, obj, sel);
    __autoreleasing NSArray *arr = @[obj, [NSValue valueWithPointer:sel], @(option)];
    for (int i = 0; i < count; ++i) {
        ZWGetAopImp(Invocation, obj, sel, i);
        asm volatile("cbz    x0, LBB_20181107");
        asm volatile("mov    x17, x0");
        asm volatile("ldr    x11, %0": "=m"(sp));
        asm volatile("ldr    x12, %0": "=m"(arr));
        asm volatile("bl    _ZWLoadParams");
        asm volatile("mov    x1, x12");
        asm volatile("blr    x17");
        asm volatile("LBB_20181107:");
    }
}

void ZWAfterInvocation(void **sp) {
    ZWAopInvocation(sp, _ZWAfterIMP, ZWInvocationOptionAfter);
}
void ZWInvocation(void **sp) {
    __autoreleasing id obj;
    SEL sel;
    void *obj_p = &obj;
    void *sel_p = &sel;
    
    asm volatile("ldr    x11, %0": "=m"(sp));
    asm volatile("ldr    x10, %0": "=m"(obj_p));
    asm volatile("ldr    x0, [x11]");
    asm volatile("str    x0, [x10]");
    asm volatile("ldr    x10, %0": "=m"(sel_p));
    asm volatile("ldr    x0, [x11, #0x8]");
    asm volatile("str    x0, [x10]");
    
    asm volatile("ldr    x11, %0": "=m"(sp));
    asm volatile("ldr    x0, [x11]");
    asm volatile("ldr    x1, [x11, #0x8]");
    asm volatile("bl    _ZWGetOriginImp");
    asm volatile("cbnz    x0, LZW_20181105");
    
    __autoreleasing NSArray *arr = @[obj, [NSValue valueWithPointer:sel], @(ZWInvocationOptionReplace)];

    asm volatile("ldr    x11, %0": "=m"(sp));
    asm volatile("ldr    x0, [x11]");
    asm volatile("ldr    x1, [x11, #0x8]");
    asm volatile("bl    _ZWGetCurrentImp");
    asm volatile("cbz    x0, LZW_20181106");
    asm volatile("mov    x17, x0");
    asm volatile("ldr    x12, %0": "=m"(arr));
    asm volatile("ldr    x11, %0": "=m"(sp));
    asm volatile("bl    _ZWLoadParams");
    asm volatile("mov    x1, x12");
    asm volatile("blr    x17");
    asm volatile("b LZW_20181106");

    asm volatile("LZW_20181105:");
    asm volatile("mov    x17, x0");
    asm volatile("ldr    x11, %0": "=m"(sp));
    asm volatile("bl    _ZWLoadParams");
    asm volatile("blr    x17");
    asm volatile("LZW_20181106:");
}
void ZWBeforeInvocation(void **sp) {
    ZWAopInvocation(sp, _ZWBeforeIMP, ZWInvocationOptionBefore);
}

OS_ALWAYS_INLINE Method ZWGetMethod(Class cls, SEL sel) {
    unsigned int count = 0;
    Method retMethod = NULL;
    Method *list = class_copyMethodList(cls, &count);
    for (int i = 0; i < count; ++i) {
        Method m = list[i];
        SEL s = method_getName(m);
        if (sel_isEqual(s, sel)) {
            retMethod = m;
        }
    }
    free(list);
    return retMethod;
}

OS_ALWAYS_INLINE void ZWAddInvocation(NSDictionary *dict, NSString *className, NSString *selName, id block,  ZWInvocationOption options) {
    NSArray *tmp = dict[className][selName];
    if (options & ZWInvocationOptionOnly) {
        dict[className][selName] = block;
    } else {
        if ([tmp isKindOfClass:[NSArray class]]) {
            dict[className][selName] = [tmp arrayByAddingObject:block];
        } else if (!tmp) {
            dict[className][selName] = @[block];
        }
    }
}

void ZWAddAop(id obj, SEL sel, ZWInvocationOption options, id block) {
    if (options == ZWInvocationOptionOnly || !obj || !sel || !block) return;
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _ZWOriginIMP = [NSMutableDictionary dictionary];
        _ZWBeforeIMP = [NSMutableDictionary dictionary];
        _ZWAfterIMP = [NSMutableDictionary dictionary];
        _ZWLock = [[NSLock alloc] init];
    });
    
    Class class = object_getClass(obj);
    Method method = NULL;
    NSString *className = NSStringFromClass(class);
    ZWGetMethod(class, sel, &method);//class_getInstanceMethod(class, sel)会获取父类的方法
    NSString *selName = class_isMetaClass(class) ? ZWGetMetaSelName(sel) : NSStringFromSelector(sel);
    
    [_ZWLock lock];
    if (!_ZWOriginIMP[className]) {
        _ZWOriginIMP[className] = [NSMutableDictionary dictionary];
        _ZWBeforeIMP[className] = [NSMutableDictionary dictionary];
        _ZWAfterIMP[className] = [NSMutableDictionary dictionary];
    }

    if (options & ZWInvocationOptionReplace) {
        _ZWOriginIMP[className][selName] = block;
    } else {
        IMP originImp = method_getImplementation(method);
        if (originImp != ZWGlobalOCSwizzle) {
            _ZWOriginIMP[className][selName] = [NSValue valueWithPointer:originImp];
        }
    }
    
    if (options & ZWInvocationOptionBefore) {
        ZWAddInvocation(_ZWBeforeIMP, className, selName, block, options);
    }
    if (options & ZWInvocationOptionAfter) {
        ZWAddInvocation(_ZWAfterIMP, className, selName, block, options);
    }
    method_setImplementation(method, ZWGlobalOCSwizzle);
    [_ZWLock unlock];
}
#else
void ZWAddAop(id obj, SEL sel, ZWInvocationOption options, id block) {
}
#endif

这里只写了arm64下的实现,arm32机器已经比较少,x86_64汇编比较麻烦,就不实现了。

入口函数ZWAddAop,前俩参数就不多说了,第三个参数是一个block,这个block在定义的时候,一定要注意参数类型要对应,Method的前两个参数签名为固定的“@:”,而block第一个参数签名是固定的“@?”,就是block本身,所以这里本来是需要一个占位的参数SEL和原始方法对应,后续的参数一一对应即可,如果不需要使用某些参数可以省略声明。但需要注意的是这里的占位参数被我改变成了NSArray,其会将当前调用的对象和方法,以及调用位置封装成数组传递,方便使用者。(简易实现,所以直接用了公共容器)。另外需要说明的是这里我并没有校验block和原始方法签名是否对应,需要的可以自行添加。

- (int )aMethod3:(NSString *)str;
对应
^(NSArray *info, NSString *str) {};
如果不使用str, ^(NSArray *info){};不使用info,也可以不声明

第四个参数ZWInvocationOption,表示需要在哪些位置插入该block调用。其中ZWInvocationOptionOnly不能单独使用,其他情况都可以单独使用或者复合使用。Only和Before,After复合使用时表示当前添加的block是当前位置唯一的调用,其他调用会被替换掉,否则在同一个方法的同一个位置可以添加多个block调用。Only和Replace复合没有意义,因为我觉得没有必要替换多次,因为从功能上讲Before就可以完成这项需求,如果有需求的话可以自行修改。

ZWAddAop函数实现比较容易看懂,需要说明一下的是,这里我操作NSMutableDictionary时我加了锁,如果有大量方法需要替换时,可以采用串行调用而不是加锁的方式,这样速度会提高。如果是元类方法会在存储的时候添加上__META_头和实例方法区分开。另外class_getInstanceMethod会获取父类的实现,所以这里class_copyMethodList来搜索,因为存在内存拷贝,所以效率不太好。

注意:优化点,将所有NSDictionary的selector key由NSString变成NSNumber,该地址是一个常量,而class对象是可以直接作为key的。AOP切面调用极为频繁,这就会带来极大的性能提升,优化后甚至可以提高一个数量级。

以上是添加AOP调用的过程,接下来说明一下调用过程。

所有添加AOP的方法,IMP会修改为ZWGlobalOCSwizzle方法,其声明没有参数没有返回值,也不涉及任何OC和C的代码,所以编译器会给一个空的实现,不会添加多余代码,可以方便的添加汇编代码(这种叫C桩(stub)函数)。其逻辑还是很容易看懂的。

我大概说一下,这里我抽离了参数入栈的的汇编到ZWStoreParams,这个函数会被多个地方调用,所以不能直接使用sp,我这里使用了x11,调用的时候需要设置x11的值(复杂的情况下使用寄存器,需要先暂存其值到栈上,方便之后恢复供后续使用,只不过比较麻烦,会涉及到初始栈空间的分配,这里其他地方不会使用x11存数据就简单处理了),调用ZWStoreParams,将参数存在栈上,同时将栈指针放入x0,传递给ZWBeforeInvocation使用。

接下来调用ZWBeforeInvocation,其接收了栈指针sp,上面有所有参数,其内部调用ZWAopInvocation。

在ZWAopInvocation中获枚举当前方法当前位置所有添加的AOP block。下面代码会将一些信息封装到数组中,后面写x1也就是block调用的第二个参数(info)。

__autoreleasing NSArray *arr = @[obj, [NSValue valueWithPointer:sel], @(option)];

for循环所有调用,并依次调用ZWGetAopImp获取所有block入口地址,ZWGetAopImp在字典中_ZWBeforeIMP或者_ZWAfterIMP获取存入的Block,并计算出入口地址返回。

使用cbz指令, 如果x0==0就跳转标签LBB_20181107,就是末尾。否则将入口地址写入x17,接下来加载sp指针到x11,加载arr到x12,调用ZWLoadParams加载参数到寄存器,将arr写入x1,最后跳转到x17执行block方法。

note:标签LZW_20181107似乎有一些要求,不能随便乱写,似乎要L打头(L表示局部标签),后面就随便了,确保唯一即可。

回到ZWGlobalOCSwizzle函数,调用完ZWBeforeInvocation后,调用ZWInvocation,也就是原方法或是其替换方法。该方法也接收sp参数,然后我们声明obj,sel,及其指针obj_p,sel_p,接下来将sp和obj,sel的地址加载到寄存器,然后将ps,ps+8,也就是栈上的第一第二个参数写入obj,sel中。这样就把汇编的数据转移到了C语言的变量里面,这也是内联汇编和OC/C要数据交互方法。

接下来将sp,sp+8写入x0,x1,然后调用ZWGetOriginImp,其会尝试获取_ZWOriginIMP字典中的原始IMP并返回,汇编cbnz x0, LZW_20181105如果原始IMP不为NULL,则跳转标签LZW_20181105。

再看标签LZW_20181105,其实现也比较简单,将原始IMP写入x17,同时加载sp到x11,调用ZWLoadParams恢复参数到寄存器上,然后跳转到x17执行原始IMP后就结束了(变量声明都是autoreleasing的,所以不会插入release也就不会破坏x0,d0)。

如果原始IMP为NULL,则表明其被替换过。则将obj,sel,调用位置ZWInvocationOptionReplace封装成数组arr待用。加载sp,sp+8到x0,x1,然后调用ZWGetCurrentImp,获取替换后的实现。其是一个block,计算出IMP并返回。cbz x0, LZW_20181106,如果返回值为NULL,则直接跳转到标签LZW_20181106结束调用,否则继续执行,将IMP写入x17,加载arr,sp到x12,x11,调用ZWLoadParams,恢复所有的参数,这里和调用原始IMP不一样的时候将第二个参数x1替换为数组arr。然后blr x17执行IMP,之后跳转到标签LZW_20181106,这里不能直接使用汇编的"ret"返回。因为该句之后会调用___stack_chk_guard来检查栈有没有被破坏,不过幸运的是该调用没有破坏x0,d0寄存器。

最后再次回到ZWGlobalOCSwizzle函数,调用完ZWInvocation后,将可能存储返回值的寄存器x0,d0写入sp的+0xa0,+0xa8的位置,然后加载sp为参数调用ZWAfterInvocation,其逻辑和ZWBeforeInvocation基本一致就不再多说。

然后从sp的+0xa0,+0xa8的位置恢复数据到x0,d0,然后恢复sp,x29,x30寄存器,最后返回。

怎么使用呢?这里给一些例子

- (void)viewDidLoad {
    [super viewDidLoad];

    ZWAddAop(self, @selector(aMethod1:), ZWInvocationOptionBefore | ZWInvocationOptionOnly, ^(NSArray *info){
        NSLog(@"before1 : ");
    });
    ZWAddAop(self, @selector(aMethod1:), ZWInvocationOptionBefore | ZWInvocationOptionReplace  | ZWInvocationOptionAfter , ^(NSArray *info, int a){
        NSLog(@"before1 | replace1 | after1 : %d", a);
    });

    ZWAddAop(self, @selector(aMethod2:), ZWInvocationOptionAfter, ^(NSArray *info, NSString *str){
        NSLog(@"after2: %@", str);
    });

    ZWAddAop(self, @selector(aMethod2:), ZWInvocationOptionReplace | ZWInvocationOptionOnly, ^(NSArray *info, NSString *str){
        NSLog(@"replace2 | after2: %@ \n%@",info, str);
    });

    ZWAddAop(self, @selector(aMethod3::), ZWInvocationOptionReplace, ^int (NSArray *info, NSString *str){
        NSLog(@"replace3: %@", str);
        return 11034;
    });

    ZWAddAop(self, @selector(aMethod3::), ZWInvocationOptionAfter, ^(NSArray *info, NSString *str){
        NSLog(@"after31: %@ \n %@", info, str);
    });

    ZWAddAop(self, @selector(aMethod3::), ZWInvocationOptionAfter, ^(NSArray *info, NSString *str){
        NSLog(@"after32: %@", str);
    });
    
    ZWAddAop([self class], @selector(aMethod4:), ZWInvocationOptionReplace, ^(id info , int a){
        NSLog(@"META replace4:");
    });

    [self aMethod1:8848];
    [self aMethod2:@"test str"];
    int r = [self aMethod3:@"咋不上天呢" :@[@1,@2]];
    NSLog(@"return int: %d",r);
    [ViewController aMethod4:12358];
}

- (NSRange)aMethod1:(int)a {
    NSLog(@"method1: %d",a);
    return (NSRange){0,1};
}
- (void)aMethod2:(NSString *)str {
    NSLog(@"method2: %@", str);
}
- (int )aMethod3:(NSString *)str :(NSArray *)array{
    NSLog(@"method3: %@", str);
    return 11;
}
+ (void)aMethod4:(int )obj {
    NSLog(@"method4: %d", obj);
}

本来只是想写一个demo供大家参考的,但发现很多东西还是要过手了才有说服力,于是前前后后(主要是想简单实现基本功能即可,后来发现很多功能特性还是得添加,于是乎就不断涂涂改改...)花了两天时间写了个较完善些的实现。如果对稳定性要求较高,可以多测试一下,汇编和OC/C混编确实容易出bug,写的时候稍不注意就出现莫名其妙的问题,需要不断的修改和改进,另外我测试的case也不太足。

最后说一下这套方案的优缺点吧。

优点:1、简洁,虽然可能汇编细节不太懂,但大致的实现思路还是很容易看懂。
2、效率较高,大量使用汇编,减少函数调用,当然也有一个龟速代表class_copyMethodList拖慢了效率,当然也仅仅只是指针拷贝,而且大部分类的方法也就几个十几个。主要是没有其他类似的方法,要替换class_copyMethodList就得自己访问Class的MethodList,这比较麻烦,需要大量的代码才能实现,不过class_copyMethodList调用不多。每个hook函数调用过程中AOP的开销才是重点关注的地方,目前主要是内存分配(OC对象创建)。

缺点,改进点:
1、追求简洁,抛弃了一些细节问题。比如传入的block和原始方法的签名没有校验是否匹配,再比如:block的传回的第一个参数使用NSArray来存储obj,sel和调用位置,其实最好可以使用model对象,同时也可以传回更多的信息。
2、整型参数大于6个或者浮点参数大于8个则无法处理。因为多出来的参数在栈上,目前我还没有想出除了拷贝栈以外的简洁解决方案,而拷贝栈比较麻烦(我大概思考了一下,比较麻烦的部分是确定栈上存了多少数据,这个得根据签名和参数传递的规则去计算)。如果需要处理这类函数就需要自己另外处理了。

Github源码地址

你可能感兴趣的:(任意方法的Swizzle的应用之一AOP)