Swift 泛型3

大鬼丫
149 阅读3分钟

「这是我参与2022首次更文挑战的第25天，活动详情查看：2022首次更文挑战」。

泛型函数传入函数的分析

上面都是对变量进行的分析，那么一问来了

如果泛型函数中传的是一个函数呢？

代码如下所示，此时传入的m，是传入的整个结构体吗？

//如果此时传入的是一个函数呢？
func makeIncrement() -> (Int) -> Int{
    var runningTotal = 10
    return {
        runningTotal += $0
        return runningTotal
    }
}

func testGenric<T>(_ value: T){}

//m中存储的是一个结构体：{i8*, swift type *}
let m = makeIncrement()
testGenric(m)
  • 分析IR代码
define i32 @main(i32 %0, i8** %1) #0 {
entry:
  %2 = alloca %swift.function, align 8
  %3 = bitcast i8** %1 to i8*
  ; s4main13makeIncrementS2icyF 调用makeIncrement函数，返回一个结构体 {函数调用地址， 捕获值的内存地址}
  %4 = call swiftcc { i8*, %swift.refcounted* } @"$s4main13makeIncrementS2icyF"()
     ; 闭包表达式的地址
  %5 = extractvalue { i8*, %swift.refcounted* } %4, 0
     ; 捕获值的引用类型
  %6 = extractvalue { i8*, %swift.refcounted* } %4, 1

  ; 往m变量地址中存值
    ; 将 %5 存入 swift.function*结构体中（%swift.function = type { i8*, %swift.refcounted* }）
    ; s4main1myS2icvp ==>  main.m : (Swift.Int) -> Swift.Int，即全局变量 m
  store i8* %5, i8** getelementptr inbounds (%swift.function, %swift.function* @"$s4main1myS2icvp", i32 0, i32 0), align 8

  ; 将值放入 f 这个变量中，并强转为指针
  store %swift.refcounted* %6, %swift.refcounted** getelementptr inbounds (%swift.function, %swift.function* @"$s4main1myS2icvp", i32 0, i32 1), align 8
    ; 将%2 强转为 i8*（即 void*）
  %7 = bitcast %swift.function* %2 to i8*
  call void @llvm.lifetime.start.p0i8(i64 16, i8* %7)

  ; 取出 function中 闭包表达式的地址
  %8 = load i8*, i8** getelementptr inbounds (%swift.function, %swift.function* @"$s4main1myS2icvp", i32 0, i32 0), align 8
  %9 = load %swift.refcounted*, %swift.refcounted** getelementptr inbounds (%swift.function, %swift.function* @"$s4main1myS2icvp", i32 0, i32 1), align 8

  ; 将返回的闭包表达式 当做一个参数传入 方法，所以 retainCount+1
  %10 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %9) #2

  ; 创建了一个对象，存储了 <{ %swift.refcounted, %swift.function }>*
  %11 = call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata, i32 0, i32 2), i64 32, i64 7) #2
  ; 将 %swift.refcounted* %11 强转成了一个结构体类型
  %12 = bitcast %swift.refcounted* %11 to <{ %swift.refcounted, %swift.function }>*

  ; 取出 %swift.function （最终的结果就是往 <{ %swift.refcounted, %swift.function }> 的%swift.function 中存值 ==> 做了间接的转换与传递） 
  %13 = getelementptr inbounds <{ %swift.refcounted, %swift.function }>, <{ %swift.refcounted, %swift.function }>* %12, i32 0, i32 1
  ; 取出 <i8*, %swift.function>的首地址
  %.fn = getelementptr inbounds %swift.function, %swift.function* %13, i32 0, i32 0
  ; 将 i8* 放入 i8** %.fn 中（即创建的数据结构 <{ %swift.refcounted, %swift.function }> 的 %swift.function 中）
  store i8* %8, i8** %.fn, align 8
  %.data = getelementptr inbounds %swift.function, %swift.function* %13, i32 0, i32 1
  store %swift.refcounted* %9, %swift.refcounted** %.data, align 8
  %.fn1 = getelementptr inbounds %swift.function, %swift.function* %2, i32 0, i32 0
  ; 将 %swift.refcounted 存入 %swift.function 中
  store i8* bitcast (void (%TSi*, %TSi*, %swift.refcounted*)* @"$sS2iIegyd_S2iIegnr_TRTA" to i8*), i8** %.fn1, align 8
  %.data2 = getelementptr inbounds %swift.function, %swift.function* %2, i32 0, i32 1
  store %swift.refcounted* %11, %swift.refcounted** %.data2, align 8

  ; 将%2强转成了 %swift.opaque* 类型，其中 %2 就是  %swift.function内存空间，即存储的东西（函数地址 + 捕获值地址）
  %14 = bitcast %swift.function* %2 to %swift.opaque*
  ; sS2icMD ==> demangling cache variable for type metadata for (Swift.Int) -> Swift.Int 即函数的metadata
  %15 = call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* @"$sS2icMD") #9

  ; 调用 testGenric 函数
  call swiftcc void @"$s4main10testGenricyyxlF"(%swift.opaque* noalias nocapture %14, %swift.type* %15)
  ......

仿写泛型函数传入函数时的底层结构

仿写上述逻辑的结构

//如果此时传入的是一个函数呢？
struct HeapObject {
    var type: UnsafeRawPointer
    var refCount1: UInt32
    var refCount2: UInt32
}
struct FunctionData<T> {
    var ptr: UnsafeRawPointer
    var captureValue: UnsafePointer<T>
}
struct Box<T> {
    var refCounted: HeapObject
    var value: T
}
struct GenData<T> {
    var ref: HeapObject
    var function: FunctionData<T>
}

func makeIncrement() -> (Int) -> Int{
    var runningTotal = 10
    return {
        runningTotal += $0
        return runningTotal
    }
}

func testGenric<T>(_ value: T){
    //查看T的存储
    let ptr = UnsafeMutablePointer<T>.allocate(capacity: 1)
    ptr.initialize(to: value)
    /*
     - 将 %13的值给了 %2即 %swift.function*
     %13 = getelementptr inbounds <{ %swift.refcounted, %swift.function }>, <{ %swift.refcounted, %swift.function }>* %12, i32 0, i32 1

     - 调用方法 %14 -> %2
     %14 = bitcast %swift.function* %2 to %swift.opaque*
     call swiftcc void @"$s4main10testGenricyyxlF"(%swift.opaque* noalias nocapture %14, %swift.type* %15)
     */
    let ctx = ptr.withMemoryRebound(to: FunctionData<GenData<Box<Int>>>.self, capacity: 1) {
        $0.pointee.captureValue.pointee.function.captureValue
    }
    print(ctx.pointee.value)//捕获的值是10
}

//m中存储的是一个结构体：{i8*, swift type *}
let m = makeIncrement()
testGenric(m)

<!--打印结果-->
10

所以当是一个泛型函数传递过程中，会做一层包装，意味着并不会直接的将m中的函数值、type给testGenric函数，而是做了一层抽象，目的是解决不同类型在传递过程中的问题

总结

  • 泛型主要用于解决代码的抽象能力，以及提升代码的复用性

  • 如果一个泛型遵循了某个协议，则在使用时，要求具体的类型也是必须遵循某个协议的

  • 在定义协议时，可以使用关联类型给协议中用到的类型起一个占位符名称

  • where语句主要用于表明泛型需要满足的条件，即限制形式参数的要求

  • 泛型类型使用VWT进行内存管理（即通过VWT区分不同类型），VWT由编译器生成，其存储了该类型的size、alignment以及针对该类型的基本内存操作

    • 1、当对泛型类型进行内存操作时（例如：内存拷贝）时，最终会调用对应泛型的VWT中的基本内存操作
    • 2、泛型类型不同，其对应的VWT也不同

  • 当希望泛型指定类型时拥有特定功能，可以通过extension实现

  • 对于泛型函数来说，有以下几种情况：

    • 传入的是一个值类型，例如Integer，

      • 1、该类型的copy和move操作会进行内存拷贝，
      • 2、destory操作则不进行任何操作

    • 传入的是一个引用类型，如class，

      • 1、该类型的copy操作会对引用计数+1，
      • 2、move操作会拷贝指针，而不会更新引用计数；
      • 3、destory操作会对引用计数-1

    • 如果泛型函数传入的是一个函数，在传递过程中，会做一层包装，简单来说，就是不会直接将函数的函数值+type给泛型函数，而是做了一层抽象，主要是用于解决不同类型的传递问题

avatar
文章
阅读
粉丝