function - *(*uintptr) 和 **(**uintptr) 有什么区别

Question

在 Go 中runtime/proc.go，有一段代码如下所示：

// funcPC 返回函数 f 的入口 PC。
// 它假定 f 是一个 func 值。否则行为未定义。
// 小心：在带有插件的程序中，funcPC 可以为同一个函数返回不同的值
// // 对于同一个函数（因为实际上
在地址空间中 // 同一个函数有多个副本）。为了安全起见，不要
在任何 == 表达式中使用 // 此函数的结果。//仅
将结果用作开始执行代码的地址是安全的。

//go:nosplit
func funcPC(f interface{}) uintptr {
    return **(**uintptr)(add(unsafe.Pointer(&f), sys.PtrSize))
}

我不明白为什么不使用 *(*uintptr) 而不是 **(**uintptr)？

所以我在下面写了一个测试程序来弄清楚。

package main

import (
    "fmt"
    "unsafe"
)


func main(){
    fmt.Println()

    p := funcPC(test)

    fmt.Println(p)

    p1 := funcPC1(test)

    fmt.Println(p1)

    p2 := funcPC(test)

    fmt.Println(p2)
}

func test(){
    fmt.Println("hello")
}

func funcPC(f func()) uintptr {
    return **(**uintptr)(unsafe.Pointer(&f))
}

func funcPC1(f func()) uintptr {
    return *(*uintptr)(unsafe.Pointer(&f))
}

p 不等于 p1 的结果让我感到困惑。为什么 p 的值不等于 p1 的值，而它们的类型相同？

标签： functionpointersgo

Answer 1

介绍

Go 中的函数值表示函数的代码。从远处看，它是指向函数代码的指针。它就像一个指针。

仔细观察，它是一个类似这样的结构（取自runtime/runtime2.go）：

type funcval struct {
    fn uintptr
    // variable-size, fn-specific data here
}

因此，函数值将指向函数代码的指针作为其第一个字段，我们可以取消引用以获取函数代码。

解释你的例子

要获取函数（代码）的地址，您可以使用反射：

fmt.Println("test() address:", reflect.ValueOf(test).Pointer())

为了验证我们得到正确的地址，我们可以使用runtime.FuncForPC().

这给出了与您的函数相同的值funcPC()。看这个例子：

fmt.Println("reflection test() address:", reflect.ValueOf(test).Pointer())
fmt.Println("funcPC(test):", funcPC(test))
fmt.Println("funcPC1(test):", funcPC1(test))

fmt.Println("func name for reflect ptr:",
    runtime.FuncForPC(reflect.ValueOf(test).Pointer()).Name())

它输出（在Go Playground上尝试）：

reflection test() address: 919136
funcPC(test): 919136
funcPC1(test): 1357256
func name for reflect ptr: main.test

为什么？因为函数值本身是一个指针（它只是与指针具有不同的类型，但它存储的值是指针）需要取消引用才能获得代码地址。

因此，您需要将其uintptr放入（代码地址）内部funcPC()将是简单的：

func funcPC(f func()) uintptr {
    return *(*uintptr)(f) // Compiler error!
}

当然它不会编译，转换规则不允许将函数值转换为*uintptr.

另一种尝试可能是先将其转换为unsafe.Pointer，然后再转换为*uintptr：

func funcPC(f func()) uintptr {
    return *(*uintptr)(unsafe.Pointer(f)) // Compiler error!
}

同样：转换规则不允许将函数值转换为unsafe.Pointer. 任何指针类型和uintptr值都可以转换为unsafe.Pointer反之亦然，但函数值不能。

这就是为什么我们必须从一个指针值开始。我们可以有什么指针值？是的，地址f：&f。但这不会是函数值，这是f参数（局部变量）的地址。所以&f示意性地不是（只是）一个指针，它是一个指向指针的指针（两者都需要取消引用）。我们仍然可以将它转换为unsafe.Pointer（因为任何指针值都符合条件），但它不是函数值（作为指针），而是指向它的指针。

而且我们需要函数值的代码地址，所以我们必须使用**uintptr来转换unsafe.Pointer值，并且我们必须使用 2 次取消引用来获取地址（而不仅仅是 in 中的指针f）。

这正是为什么funcPC1()给出不同的、意外的、不正确的结果：

func funcPC1(f func()) uintptr {
    return *(*uintptr)(unsafe.Pointer(&f))
}

它返回 in 中的指针f，而不是实际的代码地址。