如何在Go中程序化执行机器代码？C++转Go代码段错误排查

我把一个C的JIT示例转换成Go代码后运行出现段错误，但原C代码可以正常运行，求修复方法。

Go代码如下：

package main

import (
    "fmt"
    "os"
    "strconv"
    "syscall"
    "unsafe"
)

func main() {
    // Machine code for "mov eax, 0; ret"
    code := []byte{0xb8, 0x00, 0x00, 0x00, 0x00, 0xc3}

    if len(os.Args) < 2 {
        fmt.Fprintf(os.Stderr, "Usage: %s <integer>\n", os.Args[0])
        os.Exit(1)
    }

    // Convert the user's value to an integer
    num, err := strconv.Atoi(os.Args[1])
    if err != nil {
        fmt.Fprintf(os.Stderr, "Invalid integer: %s\n", os.Args[1])
        os.Exit(1)
    }

    // Copy the integer value into the machine code
    copy(code[1:], (*(*[4]byte)(unsafe.Pointer(&num)))[:])

    // Allocate readable/writable memory
    pageSize := syscall.Getpagesize()
    mem, err := syscall.Mmap(
        -1,
        0,
        pageSize,
        syscall.PROT_READ|syscall.PROT_WRITE,
        syscall.MAP_ANON|syscall.MAP_PRIVATE,
    )
    if err != nil {
        panic(err)
    }

    // Copy the machine code into the allocated memory
    copy(mem, code)

    // Change memory protection to readable and executable
    if err := syscall.Mprotect(mem, syscall.PROT_READ|syscall.PROT_EXEC); err != nil {
        panic(err)
    }

    // Convert the memory to a function pointer
    funcPtr := uintptr(unsafe.Pointer(&mem[0]))
    funcCall := *(*func() int)(unsafe.Pointer(&funcPtr))

    // Call the function and print the result
    result := funcCall()
    fmt.Printf("Your number was: %d\n", result)

    // Unmap the memory
    if err := syscall.Munmap(mem); err != nil {
        panic(err)
    }
}

错误信息：

unexpected fault address 0x0
fatal error: fault
[signal SIGSEGV: segmentation violation code=0x80 addr=0x0 pc=0x47ed57]

goroutine 1 [running]:
runtime.throw({0x4979a7?, 0x5?})
    /home/linuxbrew/.linuxbrew/Cellar/go/1.21.1/libexec/src/runtime/panic.go:1077 +0x5c fp=0xc000068650 sp=0xc000068620 pc=0x430d9c
runtime.sigpanic()
    /home/linuxbrew/.linuxbrew/Cellar/go/1.21.1/libexec/src/runtime/signal_unix.go:875 +0x285 fp=0xc0000686b0 sp=0xc000068650 pc=0x445505
main.main()
    /home/user100/go-jit/cmd/main.go:56 +0x217 fp=0xc000068740 sp=0xc0000686b0 pc=0x47ed57
runtime.main()
    /home/linuxbrew/.linuxbrew/Cellar/go/1.21.1/libexec/src/runtime/proc.go:267 +0x2bb fp=0xc0000687e0 sp=0xc000068740 pc=0x43377b
runtime.goexit()
    /home/linuxbrew/.linuxbrew/Cellar/go/1.21.1/libexec/src/runtime/asm_amd64.s:1650 +0x1 fp=0xc0000687e8 sp=0xc0000687e0 pc=0x45cf61

段错误的根源是Go的x86-64调用约定和原生系统调用约定不匹配，直接用ret指令返回会破坏Go的栈结构，导致栈指针错位触发段错误。此外，原代码中直接复制整数内存字节的方式没有明确处理字节序，存在潜在问题。

具体修复步骤： #

1. 替换返回指令，适配Go调用约定：
   将单条ret（0xc3）替换为栈帧恢复序列：0x48, 0x8b, 0x7c, 0x24, 0x08, 0xc3。这段指令先恢复栈帧状态，再执行返回，确保栈指针保持16字节对齐（Go调用约定强制要求）。

2. 规范处理字节序：
   使用binary.LittleEndian将整数转换为小端字节序后写入机器码，适配x86-64架构的指令格式。

3. 自动内存释放：
   添加defer syscall.Munmap(mem)确保内存无论程序执行结果如何都能被正确释放，避免内存泄漏。

修复后的完整代码： #

package main

import (
	"encoding/binary"
	"fmt"
	"os"
	"strconv"
	"syscall"
	"unsafe"
)

func main() {
	// Machine code: mov eax, 0; 恢复栈帧; ret
	// 适配Go x86-64调用约定的返回序列
	code := []byte{0xb8, 0x00, 0x00, 0x00, 0x00, 0x48, 0x8b, 0x7c, 0x24, 0x08, 0xc3}

	if len(os.Args) < 2 {
		fmt.Fprintf(os.Stderr, "Usage: %s <integer>\n", os.Args[0])
		os.Exit(1)
	}

	num, err := strconv.Atoi(os.Args[1])
	if err != nil {
		fmt.Fprintf(os.Stderr, "Invalid integer: %s\n", os.Args[1])
		os.Exit(1)
	}

	// 按小端字节序写入立即数，适配x86-64架构
	binary.LittleEndian.PutUint32(code[1:], uint32(num))

	pageSize := syscall.Getpagesize()
	mem, err := syscall.Mmap(
		-1,
		0,
		pageSize,
		syscall.PROT_READ|syscall.PROT_WRITE,
		syscall.MAP_ANON|syscall.MAP_PRIVATE,
	)
	if err != nil {
		panic(err)
	}
	defer syscall.Munmap(mem)

	copy(mem, code)

	if err := syscall.Mprotect(mem, syscall.PROT_READ|syscall.PROT_EXEC); err != nil {
		panic(err)
	}

	// 转换为函数指针并调用
	funcPtr := uintptr(unsafe.Pointer(&mem[0]))
	funcCall := *(*func() int)(unsafe.Pointer(&funcPtr))

	result := funcCall()
	fmt.Printf("Your number was: %d\n", result)
}

关键修复点说明： #

• 栈对齐修复：添加的栈帧恢复指令0x48, 0x8b, 0x7c, 0x24, 0x08对应mov rdi, [rsp+8]，用于恢复Go调用时的栈状态，确保rsp指针保持16字节对齐，避免段错误。
• 字节序处理：用binary.LittleEndian.PutUint32明确将整数转换为小端字节序，避免因系统字节序差异导致的指令解析错误。
• 自动内存管理：defer语句保证内存会被释放，即使程序中途出错也不会遗留内存泄漏问题。

内容的提问来源于stack exchange，提问作者user1870400