iOS 探索Objective-C中Block的实现原理

短命女 2022-03-18 05:00 221阅读 0赞

首先大家要先知道Block的类型分为三种：  
\_NSConcreteStackBlock：在栈上创建的Block对象  
\_NSConcreteMallocBlock：在堆上创建的Block对象  
\_NSConcreteGlobalBlock：全局数据区的Block对象  
具体的介绍可以看一下这篇文章：https://www.jianshu.com/p/e03292674e60

然后我们可以先去看一下Block开源的部分：  
https://opensource.apple.com/source/libclosure/libclosure-67/

下面开始探究：  
首先创建一个简单的命令行工程，打开main.m文件，输入以下代码：

#import <Foundation/Foundation.h>
    
    int main(int argc, const char * argv[]) { 
        @autoreleasepool { 
            __block int b = 0;
            void (^block)(void) = ^(void) { 
                b = 1;
            };
            b = 10;
            block();
        }
        return 0;
    }

这是一个很简单的block的调用。

然后打开终端，进入main.m的目录，使用clang命令将OC编译成C++：

clang -rewrite-objc main.m

打开生成的main.cpp文件，发现一共有。。emmm。98319行C++代码。  
我们直接拉到最底部，看一下main函数是怎么实现的（文件前面可以分析出很多东西，包括objc\_message\_send，但是不是本文重点要讲的内容）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lvdXNoYW9kdW8_size_16_color_FFFFFF_t_70]

我们可以看到第98288行，这里告诉了你，你写的block是\_NSConcreteStackBlock类型的。而且还可以看出来，这Block其实就是一个OC对象啊。。

在\_\_main\_block\_impl\_0里面可以看到，\_\_Block\_byref\_b\_0这是引用计数，还有isa代表类型。跟NSObject一样一样的。

再看block执行时的C++代码，发现这里出现了一个\_\_block\_impl结构体：

((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

我们搜一下\_block\_impl的定义，在文件第62行:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lvdXNoYW9kdW8_size_16_color_FFFFFF_t_70 1]

虽然这一行括号看上去很复杂，但其实就办了一件事，就是去找block中FuncPtr代码块，这里面FuncPtr就是Block所要执行的代码。这个是在哪赋值的呢？我们看到第98312行的代码

((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_b_0 *)&b, 570425344))

这里的\_\_main\_block\_func\_0就是要执行的func，那么\_\_main\_block\_func\_0又是在哪出现的，看到第98294行：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) { 
      __Block_byref_b_0 *b = __cself->b; // bound by ref
    
                (b->__forwarding->b) = 1;
               }

看到这里，大家应该就明白了，这里就是block所要执行的代码块。也就是b=1。

知道了这些，我们可以解决以下问题：

## 1.实现下面的函数,将Block的实现修改成 NSLog(@”Hello world”) ##

也就是说,再调完这个函数后调用block()时,并不调用原始实现,而是打印”Hello world”

void HookBlockToPrintHelloWorld(id block) { 
        
    }

因为所有的Block执行的时候都是调用了\_\_block\_impl 结构中的FuncPtr来执行, 因此我们只要将block参数中的FuncPtr指针换成打印HelloWorld的函数就好：

struct __block_impl {  //自己定义一个__block_impl，因为系统的你调不到
        void *isa;
        int Flags;
        int Reserved;
        void *FuncPtr;
    };
    
    void hookBlock(struct __block_impl * impl, ...) { 
        NSLog(@"Hello World");
    }
    
    void HookBlockToPrintHelloWorld(id block) { 
        struct __block_impl *blockStruct = (__bridge struct __block_impl *)block;
        blockStruct->FuncPtr = &hookBlock;
    }

## 2.实现下面的函数,将Block的实现修改成打印所有入参,并调用原始实现. ##

void(^block)(int a, NSString *b) = ^(int a, NSString *b) { 
        NSLog(@"block invoke");
    }
    HookBlockToPrintArguments(block);
    block(123,@"aaa");
    //这里输出"123, aaa" 和 "block invoke";

基本思路是将原始的Block的实现函数替换成我们自定义的函数,然后将参数打印,最后回调原始的Block实现函数.简单解法：

static void (* orig_func)(void *v, int a, NSString *b);
    
    void hookBlockWithArgs(void *v, int a, NSString *b) { 
        NSLog(@"%d, %@", a, b);
        orig_func(v, a, b);
    }
    void HookBlockToPrintArguments(id block) { 
        struct __block_impl * blockStruct = (__bridge struct __block_impl *)block;
        orig_func = blockStruct->FuncPtr;
        blockStruct->FuncPtr = &hookBlockWithArgs;
    }

通用解法，很长，但是没办法，因为要接收不确定的参数类型和个数，所以需要for循环挨个参数的判断类型，然后赋值。而且这里需要深拷贝一份原本的block作为参数传递，所以代码略复杂：

typedef struct __block_impl { 
        void *isa;
        int Flags;
        int Reserved;
        void *FuncPtr;
    }__block_impl;
    
    typedef struct __main_block_impl_0 { 
        struct __block_impl impl;
        struct __main_block_desc_0* Desc;
    }__main_block_impl_0;
    
    struct __main_block_desc_0 { 
        size_t reserved;
        size_t Block_size;
        void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
        void (*dispose)(struct __main_block_impl_0*);
    };
    
    __main_block_impl_0 * g_backupBlock;
    
    void hookBlockArgs(__block_impl *impl, ...) { 
        va_list arg_ptr;
        va_start(arg_ptr, impl);
        NSObject * myblock = CFBridgingRelease(g_backupBlock);
        
        const char *_Block_signature(void *);
        const char *hookBlockSignature = _Block_signature((__bridge void *)myblock);
        NSMethodSignature *methodSignature = [NSMethodSignature signatureWithObjCTypes:hookBlockSignature];
        NSInvocation *blockInvocation = [NSInvocation invocationWithMethodSignature:methodSignature];
        
        [blockInvocation setArgument:&myblock atIndex:0];
        
        NSMutableArray *paramArray = [[NSMutableArray alloc] init];
        for (NSInteger i = 1; i<methodSignature.numberOfArguments; ++i) { 
            const char *s = [methodSignature getArgumentTypeAtIndex:i];
            NSString *str = [NSString stringWithUTF8String:s];
            [paramArray addObject:str];
        }
        NSInteger paramCount = 1;
        for (NSString * varType in paramArray) { 
            if ([varType isEqualToString:@"i"]) { 
                int arg = va_arg(arg_ptr, int);
                NSLog(@"int param %d",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else if ([varType isEqualToString:@"I"]) { 
                unsigned int arg = va_arg(arg_ptr, unsigned int);
                NSLog(@"unsigned int param %d",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            }else if ([varType isEqualToString:@"f"]) { 
                double arg = va_arg(arg_ptr, double);
                NSLog(@"float param %lf",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else if ([varType isEqualToString:@"d"]) { 
                double arg = va_arg(arg_ptr, double);
                NSLog(@"double param %lf",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else if ([varType isEqualToString:@"B"]) { 
                int arg = va_arg(arg_ptr, int);
                NSLog(@"BOOL param %d", arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else if ([varType isEqualToString:@"c"]) { 
                char arg = va_arg(arg_ptr, int);
                NSLog(@"char param %c",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else if ([varType isEqualToString:@"l"]) { 
                long arg = va_arg(arg_ptr, long);
                NSLog(@"long param %ld",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else if ([varType isEqualToString:@"L"]) { 
                unsigned long arg = va_arg(arg_ptr, unsigned long);
                NSLog(@"long param %lu",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else if ([varType isEqualToString:@"q"]) { 
                long long arg = va_arg(arg_ptr, long long);
                NSLog(@"long long param %lld",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else if ([varType isEqualToString:@"Q"]) { 
                unsigned long long arg = va_arg(arg_ptr, unsigned long long);
                NSLog(@"unsigned long long param %llu",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else if ([varType isEqualToString:@"*"]) { 
                void *arg = va_arg(arg_ptr, void *);
                NSLog(@"pointer param %p",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else if (varType.length > 2) { 
                id arg = va_arg(arg_ptr, id);
                NSLog(@"%@ %@",[arg class], arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            } else { 
                //unknow 指针
                void *arg = va_arg(arg_ptr, void *);
                NSLog(@"%p",arg);
                [blockInvocation setArgument:&arg atIndex:(paramCount)];
            }
            paramCount += 1;
        }
        
        va_end(arg_ptr);
        [blockInvocation invokeWithTarget:myblock];
    }
    
    void HookBlockToPrintArguments(id block) { 
        __main_block_impl_0 * blockStruct = (__bridge __main_block_impl_0 *)block;
        g_backupBlock = malloc(blockStruct->Desc->Block_size);
        memcpy(g_backupBlock, blockStruct, blockStruct->Desc->Block_size);
        
        __block_impl * blockImpl = (__bridge __block_impl *)block;
        blockImpl->FuncPtr = &hookBlockArgs;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lvdXNoYW9kdW8_size_16_color_FFFFFF_t_70]: /images/20220318/63c1b3765b474706ae73a4dafc6ae9c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lvdXNoYW9kdW8_size_16_color_FFFFFF_t_70 1]: /images/20220318/301a6990432b46578437f378ddc9fad2.png