Go开发自定义解释器：栈扩展时unsafe.Pointer无效地址panic解决

问题背景 #

我正在开发一款自定义编程语言的解释器，语言支持整数、字符串、数组、函数等多种类型，目前卡在高效表示这些类型的问题上。

初始方案：基于接口的类型系统 #

最初采用通用接口定义所有类型的行为：

type Obj interface {
    Type() Type
    Clone() Obj
    Equals(other Obj) bool
    fmt.Stringer
}

每种类型实现对应的结构体和接口方法，示例如下：

type Int int
func (integer Int) Type() types.Type { return types.TypeInt }
func (integer Int) Clone() types.Obj { return integer }
func (integer Int) Equals(other types.Obj) bool { /* 实现逻辑 */ }

// 布尔类型示例
type Bool bool
func (boolean Bool) Type() types.Type { return types.TypeBool }
func (boolean Bool) Clone() types.Obj { return boolean }
func (boolean Bool) String() string   { return strconv.FormatBool(bool(boolean)) }

// 数组类型示例
type Array struct {
    Slice []types.Obj
}
func (array *Array) Type() types.Type { return types.TypeArray }
func (array *Array) Clone() types.Obj { /* 实现逻辑 */ }
func (array *Array) Equals(other types.Obj) bool { /* 实现逻辑 */ }

解释器用接口实例存储变量，功能正常但性能拉胯——动态类型转换和大量堆分配拖慢了速度。

尝试模拟标记联合类型 #

因为Go原生不支持联合类型，先尝试用标签+字节数组模拟：

type Tag int

type Object struct {
    Tag  Tag
    Data [MAX_SIZE]byte
}

通过As函数把字节数组转成具体类型：

func As[T any](obj Obj) T {
    ptr := (*T)unsafe.Pointer(&obj.Data[0])
    return *ptr
}

但字符串、数组这类需要存指针的类型出了问题：字节数组里的指针会被GC当成普通数值，导致对象被误回收或覆盖。

改进的联合类型方案（引发panic） #

为了让GC识别指针，改用unsafe.Pointer数组存储数据：

type Tag int

type Object struct {
    Tag  Tag
    Data [MaxTypeSize / unsafe.Sizeof(unsafe.Pointer(nil))]unsafe.Pointer
}

这个方案偶尔正常，但经常触发panic：

runtime: bad pointer in frame banek/interpreter.(*interpreter).evalBinaryOp at 0xc000292890: 0x1
fatal error: invalid pointer found on stack

栈追踪显示panic发生在栈扩展重分配时，此时Data数组里存了非指针数据（比如整数），被GC判定为无效指针。

问题 #

1. 有没有办法阻止栈指针调整，但仍让GC识别有效指针？我的场景里不会有指向栈值的指针，不需要调整操作（不能用uintptr）。
2. 如果做不到，有没有其他无需手动引用计数和对象固定的模拟联合类型的方法？

解决方案 #

针对问题1：无法阻止栈指针调整 #

Go的栈管理由runtime完全掌控，没有合法方式能阻止栈扩展时的指针重分配。而且你用unsafe.Pointer数组存储非指针值本身就违反了Go的内存安全规则——GC会把数组里的每个元素都当作需要验证的指针，一旦遇到整数这类非指针值，必然触发panic，这个问题无法绕过。

针对问题2：替代的高效类型表示方案 #

方案1：优化版接口类型系统

虽然初始方案用了接口，但可以通过减少堆分配优化性能：

• 对于整数、布尔这类小类型，直接用基础类型实现接口，Go的逃逸分析会自动将它们分配在栈上；
• 对于数组、字符串这类引用类型，提前预分配或复用对象池，减少频繁的堆分配；
• 用类型断言的分支判断代替频繁的类型转换，示例：

func handleObj(obj Obj) {
    switch v := obj.(type) {
    case Int:
        // 直接处理int值，无堆分配
    case Bool:
        // 处理布尔值
    case *Array:
        // 处理数组
    }
}

这种方式比模拟联合类型更安全，且通过逃逸分析和对象池能把性能拉到接近原生水平。

方案2：结构体嵌入+类型标记

定义一个包含所有可能类型字段的结构体，用标记区分当前有效的类型：

type Tag int

const (
    TagInt Tag = iota
    TagBool
    TagArray
    TagString
)

type Object struct {
    Tag Tag
    IntVal int
    BoolVal bool
    ArrayVal *Array
    StringVal string
}

这种方式没有接口的动态转换开销，所有字段都存在同一个结构体里，GC能正确识别所有指针字段（比如ArrayVal、StringVal）。缺点是结构体大小是所有字段的总和，但对于解释器场景来说，内存浪费的代价远低于接口转换和堆分配的性能损耗。

方案3：reflect包辅助（不推荐）

如果需要更灵活的类型管理，可以用reflect.Value存储不同类型的值，结合类型标记使用。但reflect的性能比前两种方案差，只适合类型特别多且变化频繁的场景。

内容的提问来源于stack exchange，提问作者Đorđe Milanović