如何在没有内存损坏的情况下从 Go 指针转换到 uintptr 并返回？

如何解决如何在没有内存损坏的情况下从 Go 指针转换到 uintptr 并返回？

指针之间的转换应该使用 unsafe.Pointer() 和 uintptr。 我正在使用 Go 编写一个解释器。这是一个非常简单的片段，使用 EID 结构在本机代码的不同部分之间携带对（类型，值）。这段代码令人惊讶，因为同一个打印语句获得两个不同的值（参见 Foo() 方法）。对象被“封装”为 EID 并转换回对象。
代码可以编译，但结果严重损坏。

如果你运行这个，你会得到：

~/go%  go run testBug.go
create object 0xc000068e28 with class 0xc00000c060
here is y:0xc000068e28,y.Isa: 0xc00000c060"
here is y:0xc000068e28,y.Isa: 0x2c

---

package main

import (
    "fmt"
    "unsafe"
)

type EID struct {
    SORT *Class
    VAL  uintptr
}

// access to VAL
func OBJ(x EID) *Anything { return (*Anything)(unsafe.Pointer(x.VAL)) }
func INT(x EID) int       { return (int)((uintptr)(unsafe.Pointer(x.VAL))) }

// useful utility get the pointer as a uintptr
func (x *Anything) Uip() uintptr { return uintptr(unsafe.Pointer(x)) }

type Anything struct {
    Isa *Class
}

func (x *Anything) Id() *Anything { return x }

type Object struct {
    Anything
    name string
}

type Class struct {
    Object
    Super *Class
}

type Integer struct {
    Anything
    Value int
}

func MakeObject(c *Class) *Anything {
    o := new(Object)
    o.Isa = c
    return o.Id()
}

// this is the surprising example - EID is passed but the content is damaged
func (c *Class) Foo() EID {
    x := c.Bar()
    y := OBJ(x)
    z := y.Isa
    fmt.Printf("here is y:%p,y.Isa: %p\n",y,z)
    fmt.Printf("here is y:%p,y.Isa)  // this produces a different value !
    return x
}

func (c *Class) Bar() EID {
    UU := EID{c,MakeObject(c).Uip()}
    fmt.Printf("create object %p with class %p\n",OBJ(UU),OBJ(UU).Isa)
    return UU
}

var aClass *Class
var aInteger *Class

func main() {
    aClass := new(Class)
    aClass.Isa = aClass
    aClass.Foo()
}

---

很明显，指向指针的 uintptr 必须是本地的，不能出现在两个不同的地方（这里是 Foo() 和 Bar()）。我找到了一种解决方法，但我对这种奇怪的行为感到好奇。

解决方法

当您将指针（任何具体类型甚至 unsafe.Pointer 类型）存储到 uintptr 中时，这对 Go 的垃圾收集器隐藏了指针。因此，如果没有指向它的 other 指针，Go 可以自由地 GC 底层对象。

当您将 uintptr 转换为 unsafe.Pointer 时，对象，即 uintptr 中存储的值所转换的指针，需要存在。如果它已被 GC 处理，则它不再存在。因此，获取任何类型 *T 的某个指针值 p 并将其存储在 uintptr 中的“安全”方法是将其存储在 unsafe.Pointer 中。 unsafe.Pointer 对象对于 Go 的垃圾收集器是可见的，作为一个指针，因此这使实际对象保持活动状态。

您会在某些 Go 内部软件中看到这种模式：

// need to keep the pointer alive while we make a syscall
p := unsafe.Pointer(foo)
ret := syscall.SyscallN(...,uintptr(foo),...)

局部变量 p 的显然毫无意义的创建用于保护底层对象在 OS 系统调用读取其字节时不会被 GC 处理。 （请注意，这对编译器来说太过分了，因为 p 的赋值在这里似乎是死代码。也许内部软件比这更漂亮，和/或他们使用 //go:... 注释作为好吧。）

如果我采用您的非最小可重现示例并对其进行明显的最小更改，则相同的模式在 Go 操场中也适用。这是否足够（以及您希望如何在解释器中使用相同的概念）完全是另一个问题，但请参阅 playground copy。注意：我不得不在你的程序中添加一个右大括号，但之后它表现出与你看到的相同的行为； here's that version。它从 go vet 中引起了关于滥用 unsafe.Pointer 的两个警告，而我的更新版本没有。