__block用結構體使用forwarding指針的原因

更新記錄

時間	版本修改
2020年5月10日	初稿

1. 前言

• 閱讀本文需要先了解Block存儲域的問題，即需要了解棧Block、堆Block、全局Block的三種分類。如Block存儲域學習
• 一言以蔽之，forwarding字段是在棧Block復制到堆Block時，改變指向，從而指向真實的，且唯一的（僅有一份，在堆上，敲黑板）存儲實際變量的結構體（即類似__Block_byref_val_0的結構體）

2. Block從棧copy到堆上的細節

2.1 《Objective-C高級編程 iOS與OS X多線程和內存管理》的說到的幾個知識點

2.2 學習以下涉及block從棧復制到堆上的源代碼

2.2.1 原始代碼如下：

#import <Foundation/Foundation.h>
#include <stdio.h>
int main(int argc, char * argv[]) {
    __block int val = 0;

    printf("&val:%p, val:%d \n", &val, val);
    
    void (^blk)(void) = ^{
        printf("inBlock    &val:%p, val:%d \n", &val, val);
        ++val;
    };
    
    printf("&val:%p, val:%d \n", &val, val);
    blk();
    printf("&val:%p, val:%d \n", &val, val);
    ++val;
    printf("&val:%p, val:%d \n", &val, val);
    return 0;
}

• 輸出結果為：

&val:0x7ffee15e9ca8, val:0 
&val:0x600002985e58, val:0 
inBlock    &val:0x600002985e58, val:0 
&val:0x600002985e58, val:1 
&val:0x600002985e58, val:2 

• 由於在ARC環境下，使用strong修飾的變量指向block，會持有這個block。因此臨時變量block會從棧復制到堆上，所以__block變量也會從棧上復制到堆上。
• 觀察代碼輸出的結果，val變量的地址前后是改變過的

2.2.2 使用clang得到block轉換后的代碼如下

struct __Block_byref_val_0 {
  void *__isa;
__Block_byref_val_0 *__forwarding;
 int __flags;
 int __size;
 int val;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_val_0 *val; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_val_0 *val = __cself->val; // bound by ref

        printf("inBlock    &val:%p, val:%d \n", &(val->__forwarding->val), (val->__forwarding->val));
        ++(val->__forwarding->val);
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;__main_block_copy_0
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
int main(int argc, char * argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 0};

    printf("&val:%p, val:%d \n", &(val.__forwarding->val), (val.__forwarding->val));

    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));

    printf("&val:%p, val:%d \n", &(val.__forwarding->val), (val.__forwarding->val));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    printf("&val:%p, val:%d \n", &(val.__forwarding->val), (val.__forwarding->val));
    ++(val.__forwarding->val);
    printf("&val:%p, val:%d \n", &(val.__forwarding->val), (val.__forwarding->val));
    return 0;
}

• 按照之前所剖析過的block實現，val變量都是通過val.__forwarding->val的方式（即__forwarding指針的方式）訪問的，所以我們實際打印出來的val變量的地址和值，其實就是val.__forwarding->val的地址和值。
• 如這份代碼所示，當我們將Block從棧拷貝到堆上時，Block所捕獲的__block變量也會從棧拷貝到堆上，但是此時我們在該函數的作用域內（即Block外）仍然是可以對val變量進行修改的。
• 為了將上述修改進行同步，在將__block變量從棧拷貝到堆上時，棧上的__Block_byref_val_0結構體的__forwarding指針將會指向堆上的__Block_byref_val_0結構體。所以此時，val變量（即val.__forwarding->val變量）的地址改變了。見下圖：
  
• 上述的拷貝動作，是由__main_block_copy_0實現的。

2.3 作為對比，查看下列源代碼

• 對比的代碼

#import <Foundation/Foundation.h>
#include <stdio.h>
int main(int argc, char * argv[]) {
    int intVarInStack = 0;
    printf("&intVarInStack:%p, intVarInStack:%d \n", &intVarInStack, intVarInStack);

    __block int val = 0;
    
    printf("&b:%p, b:%d \n", &val, val);
    NSArray *blockArray = [[NSArray alloc] initWithObjects:^{
        printf("hello world!");},
        ^{
            printf("inBlock2    &val:%p, val:%d \n", &val, val);
            ++val;
        },
    nil];
    
    printf("&val:%p, val:%d \n", &val, val);
    ++val;
    return 0;
}

• 輸出結果為:

&intVarInStack:0x7ffeedfa1cac, intVarInStack:0 
&val:0x7ffeedfa1ca0, val:0 
&val:0x7ffeedfa1ca0, val:0 
&val:0x7ffeedfa1ca0, val:1 

• 由於block作為函數參數傳入，且不是GCD的API，也不是Cocoa框架中含有usingBlock的方法，因此是一個棧block。（其實，第一個block是一個全局block，因為它沒有引用外部變量，不過即使引用了外部變量，第一個block也是一個堆block，讀者可以自己嘗試。親測如此）
• 由於並不涉及Block從棧到堆上的copy，所以val變量的地址也不需要改變，而是存在棧上。從它的地址和intVarInStack變量地址經湊在一起，也可以證明它確實是在棧上的變量。

3. 總結

• __forwarding指針是為了在__block變量從棧復制到堆上后，在Block外對__block變量的修改也可以同步到堆上實際存儲__block變量的結構體上。

參考

• 掘金-深入理解iOS的block
• 《Objective-C高級編程 iOS與OS X多線程和內存管理》2.3.5節 __block變量存儲域