debug/gosym - Go 符号表

概述

debug/gosym 包提供了对 Go 二进制文件符号表的访问支持。

gosym 是什么：

• 📋 符号表解析：解析 Go 编译生成的符号表信息
• 🔧 函数映射：提供 PC（程序计数器）到函数/源码行的映射
• 📦 调试支持：用于调试器、性能分析工具等
• 🛠️ 运行时集成：与 Go 运行时符号表格式兼容

主要用途：

• 🔍 调试器开发：实现源码级调试功能
• 📊 性能分析：将 PC 值映射到函数和源码行
• 🐛 崩溃分析：解析栈追踪信息
• 🔐 安全工具：分析 Go 二进制文件结构

重要说明：

• ⚠️ 只读访问：仅用于读取符号表
• ⚠️ Go 特定：专用于 Go 编译的二进制文件
• ⚠️ 底层格式：需要了解 Go 符号表格式
• ✅ 标准库支持：Go 标准库提供完整支持

与 DWARF 的关系：

• debug/gosym：解析 Go 特有的符号表格式（更轻量）
• debug/dwarf：解析标准 DWARF 调试格式（更详细）
• 两者可以配合使用，提供完整的调试信息

核心类型

1. Table - 符号表

type Table struct {
    // 包含过滤或未导出的字段
}

功能：表示 Go 符号表，包含所有函数和源码行的映射信息。

创建方法：

// 从原始符号表数据创建
func NewTable(symtab []byte, pcln *LineTable) (*Table, error)

// 从 ELF 文件创建
func ReadTable(symtab []byte, pcln *LineTable) (*Table, error)

主要方法：

// 查找函数（通过 PC）
func (t *Table) PCToFunc(pc uint64) *Func

// 查找函数（通过名称）
func (t *Table) LookupFunc(name string) *Func

// 查找源码行（通过 PC）
func (t *Table) PCToLine(pc uint64) (file string, line int, fn *Func)

// 查找 PC（通过源码行）
func (t *Table) LineToPC(file string, line int) (uint64, error)

// 获取所有函数
func (t *Table) Funcs() []*Func

// 获取所有源码文件
func (t *Table) Files() []string

注意事项：

• ⚠️ 符号表数据通常从 ELF 文件的 .gosymtab 段读取
• ⚠️ 需要配合 LineTable 一起使用
• ✅ 提供高效的 PC 到源码的映射

2. Func - 函数信息

type Func struct {
    Sym  *Sym
    LineTable
}

功能：表示一个 Go 函数，包含函数符号和行号表。

字段说明：

• Sym：函数符号信息（名称、地址等）
• LineTable：函数的行号表

主要方法：

// 获取函数名称
func (f *Func) Name() string

// 获取函数入口地址
func (f *Func) Entry() uint64

// 获取函数结束地址
func (f *Func) End() uint64

// PC 转源码行
func (f *Func) PCToLine(pc uint64) (file string, line int)

// 源码行转 PC
func (f *Func) LineToPC(file string, line int) uint64

// 获取函数所在文件
func (f *Func) File() string

// 获取函数起始行
func (f *Func) StartLine() int

// 获取函数结束行
func (f *Func) EndLine() int

使用示例：

func := table.PCToFunc(pc)
if fn != nil {
    fmt.Printf("函数：%s\n", fn.Name())
    fmt.Printf("文件：%s\n", fn.File())
    fmt.Printf("行号：%d\n", fn.StartLine())
}

3. Sym - 符号

type Sym struct {
    Value  uint64  // 符号地址
    Type   byte    // 符号类型
    Name   string  // 符号名称
}

功能：表示一个符号（函数、变量等）。

字段说明：

• Value：符号的地址（PC 值）
• Type：符号类型（‘T’ 表示代码，‘D’ 表示数据等）
• Name：符号名称（如 main.main）

符号类型常量：

const (
    'T' = 0x54  // 代码段符号
    't' = 0x74  // 静态代码段符号
    'D' = 0x44  // 数据段符号
    'd' = 0x64  // 静态数据段符号
    'B' = 0x42  // BSS 段符号
    'b' = 0x62  // 静态 BSS 段符号
)

使用示例：

sym := &Sym{
    Value: 0x1000,
    Type:  'T',
    Name:  "main.main",
}

4. LineTable - 行号表

type LineTable struct {
    // 包含过滤或未导出的字段
}

功能：表示行号表，提供 PC 到源码行的映射。

创建方法：

// 从原始数据创建
func NewLineTable(data []byte, textStart uint64) *LineTable

主要方法：

// PC 转源码行
func (t *LineTable) PCToLine(pc uint64) (file string, line int)

// 源码行转 PC
func (t *LineTable) LineToPC(file string, line int) uint64

// 获取所有行号信息
func (t *LineTable) AllLines() []Line

// 获取函数行号表
func (t *LineTable) FuncLines(fn *Func) []Line

注意事项：

• ⚠️ 行号表数据通常从 .gopclntab 段读取
• ⚠️ 需要指定 textStart（代码段起始地址）
• ✅ 支持高效的二分查找

5. Line - 行号信息

type Line struct {
    PC   uint64 // 程序计数器地址
    File string // 源文件名
    Line int    // 行号
}

功能：表示一个行号映射条目。

字段说明：

• PC：程序计数器地址
• File：源文件路径
• Line：源码行号

使用示例：

lines := lineTable.AllLines()
for _, line := range lines {
    fmt.Printf("0x%x -> %s:%d\n", line.PC, line.File, line.Line)
}

常量定义

符号类型

const (
    SymText  = 'T'  // 代码段符号
    SymSText = 't'  // 静态代码段符号
    SymData  = 'D'  // 数据段符号
    SymSData = 'd'  // 静态数据段符号
    SymBSS   = 'B'  // BSS 段符号
    SymSBSS  = 'b'  // 静态 BSS 段符号
)

魔术数字（用于识别符号表格式）

const (
    Go12MagicLittleEndian  = 0xfffffffb
    Go12MagicBigEndian     = 0xfffffffc
    Go116MagicLittleEndian = 0xfffffff0
    Go116MagicBigEndian    = 0xfffffff1
)

完整示例

示例 1：从 ELF 文件读取符号表

package main

import (
    "debug/elf"
    "debug/gosym"
    "fmt"
    "log"
)

func main() {
    // 1. 打开 ELF 文件
    f, err := elf.Open("myprogram")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    
    // 2. 读取 .gosymtab 段
    symtabSection := f.Section(".gosymtab")
    if symtabSection == nil {
        log.Fatal("无 .gosymtab 段")
    }
    
    symtabData, err := symtabSection.Data()
    if err != nil {
        log.Fatal(err)
    }
    
    // 3. 读取 .gopclntab 段
    pclntabSection := f.Section(".gopclntab")
    if pclntabSection == nil {
        log.Fatal("无 .gopclntab 段")
    }
    
    pclntabData, err := pclntabSection.Data()
    if err != nil {
        log.Fatal(err)
    }
    
    // 4. 创建行号表
    pcln := gosym.NewLineTable(pclntabData, f.Sections[0].Addr)
    
    // 5. 创建符号表
    table, err := gosym.NewTable(symtabData, pcln)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("符号表加载成功\n")
    fmt.Printf("函数数量：%d\n", len(table.Funcs()))
    fmt.Printf("文件数量：%d\n", len(table.Files()))
}

示例 2：查找函数信息

package main

import (
    "debug/elf"
    "debug/gosym"
    "fmt"
    "log"
)

func main() {
    f, err := elf.Open("myprogram")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    
    // 读取符号表（省略错误处理）
    symtabData, _ := f.Section(".gosymtab").Data()
    pclntabData, _ := f.Section(".gopclntab").Data()
    pcln := gosym.NewLineTable(pclntabData, f.Sections[0].Addr)
    table, _ := gosym.NewTable(symtabData, pcln)
    
    // 1. 通过名称查找函数
    fn := table.LookupFunc("main.main")
    if fn != nil {
        fmt.Printf("函数：%s\n", fn.Name())
        fmt.Printf("入口地址：0x%x\n", fn.Entry())
        fmt.Printf("结束地址：0x%x\n", fn.End())
        fmt.Printf("所在文件：%s\n", fn.File())
        fmt.Printf("起始行：%d\n", fn.StartLine())
        fmt.Printf("结束行：%d\n", fn.EndLine())
    }
    
    // 2. 遍历所有函数
    fmt.Println("\n所有函数：")
    for i, fn := range table.Funcs() {
        if i >= 20 {
            break
        }
        fmt.Printf("%3d. %-40s 0x%x\n", i, fn.Name(), fn.Entry())
    }
}

示例 3：PC 到源码行的映射

package main

import (
    "debug/elf"
    "debug/gosym"
    "fmt"
    "log"
)

func main() {
    f, err := elf.Open("myprogram")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    
    // 读取符号表
    symtabData, _ := f.Section(".gosymtab").Data()
    pclntabData, _ := f.Section(".gopclntab").Data()
    pcln := gosym.NewLineTable(pclntabData, f.Sections[0].Addr)
    table, _ := gosym.NewTable(symtabData, pcln)
    
    // 1. PC 转源码行
    pcs := []uint64{0x1000000, 0x1000100, 0x1000200}
    
    for _, pc := range pcs {
        file, line, fn := table.PCToLine(pc)
        if fn != nil {
            fmt.Printf("0x%x -> %s:%d (函数：%s)\n", 
                pc, file, line, fn.Name())
        } else {
            fmt.Printf("0x%x -> %s:%d (无函数信息)\n", 
                pc, file, line)
        }
    }
    
    // 2. 遍历函数的所有行号
    fn := table.LookupFunc("main.main")
    if fn != nil {
        fmt.Printf("\n%s 的行号信息：\n", fn.Name())
        
        for pc := fn.Entry(); pc < fn.End(); pc++ {
            file, line := fn.PCToLine(pc)
            if line > 0 {
                fmt.Printf("  0x%x -> %s:%d\n", pc, file, line)
            }
        }
    }
}

示例 4：源码行到 PC 的映射

package main

import (
    "debug/elf"
    "debug/gosym"
    "fmt"
    "log"
)

func main() {
    f, err := elf.Open("myprogram")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    
    // 读取符号表
    symtabData, _ := f.Section(".gosymtab").Data()
    pclntabData, _ := f.Section(".gopclntab").Data()
    pcln := gosym.NewLineTable(pclntabData, f.Sections[0].Addr)
    table, _ := gosym.NewTable(symtabData, pcln)
    
    // 1. 源码行转 PC
    file := "/path/to/main.go"
    line := 42
    
    pc, err := table.LineToPC(file, line)
    if err != nil {
        log.Printf("未找到 %s:%d: %v", file, line, err)
    } else {
        fmt.Printf("%s:%d -> 0x%x\n", file, line, pc)
    }
    
    // 2. 获取函数的所有 PC 值
    fn := table.LookupFunc("main.main")
    if fn != nil {
        fmt.Printf("\n%s 的所有 PC 值：\n", fn.Name())
        
        startLine := fn.StartLine()
        endLine := fn.EndLine()
        
        for line := startLine; line <= endLine; line++ {
            pc := fn.LineToPC(fn.File(), line)
            if pc > 0 {
                fmt.Printf("  %s:%d -> 0x%x\n", fn.File(), line, pc)
            }
        }
    }
}

示例 5：解析栈追踪信息

package main

import (
    "debug/elf"
    "debug/gosym"
    "fmt"
    "log"
    "runtime"
)

// StackFrame 栈帧
type StackFrame struct {
    PC   uint64
    Func string
    File string
    Line int
}

// Symbolizer 符号化器
type Symbolizer struct {
    table *gosym.Table
}

// NewSymbolizer 创建符号化器
func NewSymbolizer(filename string) (*Symbolizer, error) {
    f, err := elf.Open(filename)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    
    // 读取符号表
    symtabSection := f.Section(".gosymtab")
    if symtabSection == nil {
        return nil, fmt.Errorf("无 .gosymtab 段")
    }
    
    symtabData, err := symtabSection.Data()
    if err != nil {
        return nil, err
    }
    
    pclntabSection := f.Section(".gopclntab")
    if pclntabSection == nil {
        return nil, fmt.Errorf("无 .gopclntab 段")
    }
    
    pclntabData, err := pclntabSection.Data()
    if err != nil {
        return nil, err
    }
    
    pcln := gosym.NewLineTable(pclntabData, f.Sections[0].Addr)
    table, err := gosym.NewTable(symtabData, pcln)
    if err != nil {
        return nil, err
    }
    
    return &Symbolizer{table: table}, nil
}

// Symbolize 符号化 PC 值
func (s *Symbolizer) Symbolize(pc uint64) *StackFrame {
    file, line, fn := s.table.PCToLine(pc)
    
    frame := &StackFrame{
        PC:   pc,
        File: file,
        Line: line,
    }
    
    if fn != nil {
        frame.Func = fn.Name()
    }
    
    return frame
}

// SymbolizeStack 符号化整个栈
func (s *Symbolizer) SymbolizeStack(pcs []uintptr) []StackFrame {
    frames := make([]StackFrame, 0, len(pcs))
    
    for _, pc := range pcs {
        frame := s.Symbolize(uint64(pc))
        frames = append(frames, *frame)
    }
    
    return frames
}

func main() {
    // 创建符号化器
    symbolizer, err := NewSymbolizer("myprogram")
    if err != nil {
        log.Fatal(err)
    }
    
    // 获取当前 goroutine 的栈追踪
    pcs := make([]uintptr, 100)
    n := runtime.Callers(1, pcs)
    pcs = pcs[:n]
    
    // 符号化栈追踪
    frames := symbolizer.SymbolizeStack(pcs)
    
    fmt.Println("栈追踪：")
    for i, frame := range frames {
        fmt.Printf("%2d. %s\n", i, frame.Func)
        fmt.Printf("    %s:%d\n", frame.File, frame.Line)
        fmt.Printf("    PC: 0x%x\n", frame.PC)
    }
}

示例 6：分析 Go 二进制文件

package main

import (
    "debug/elf"
    "debug/gosym"
    "fmt"
    "log"
    "os"
    "sort"
    "strings"
)

// BinaryAnalyzer Go 二进制分析器
type BinaryAnalyzer struct {
    file  *elf.File
    table *gosym.Table
}

// NewBinaryAnalyzer 创建分析器
func NewBinaryAnalyzer(filename string) (*BinaryAnalyzer, error) {
    f, err := elf.Open(filename)
    if err != nil {
        return nil, err
    }
    
    // 读取符号表
    symtabSection := f.Section(".gosymtab")
    if symtabSection == nil {
        f.Close()
        return nil, fmt.Errorf("不是 Go 编译的二进制文件")
    }
    
    symtabData, err := symtabSection.Data()
    if err != nil {
        f.Close()
        return nil, err
    }
    
    pclntabSection := f.Section(".gopclntab")
    if pclntabSection == nil {
        f.Close()
        return nil, fmt.Errorf("缺少行号表")
    }
    
    pclntabData, err := pclntabSection.Data()
    if err != nil {
        f.Close()
        return nil, err
    }
    
    pcln := gosym.NewLineTable(pclntabData, f.Sections[0].Addr)
    table, err := gosym.NewTable(symtabData, pcln)
    if err != nil {
        f.Close()
        return nil, err
    }
    
    return &BinaryAnalyzer{
        file:  f,
        table: table,
    }, nil
}

// Close 关闭文件
func (a *BinaryAnalyzer) Close() error {
    return a.file.Close()
}

// ShowSummary 显示摘要信息
func (a *BinaryAnalyzer) ShowSummary() {
    fmt.Println("=== Go 二进制摘要 ===")
    fmt.Printf("文件类型：%v\n", a.file.Type)
    fmt.Printf("目标架构：%v\n", a.file.Machine)
    fmt.Printf("函数数量：%d\n", len(a.table.Funcs()))
    fmt.Printf("文件数量：%d\n", len(a.table.Files()))
    fmt.Println()
}

// ShowMainPackage 显示 main 包的函数
func (a *BinaryAnalyzer) ShowMainPackage() {
    fmt.Println("=== main 包函数 ===")
    
    count := 0
    for _, fn := range a.table.Funcs() {
        if strings.HasPrefix(fn.Name(), "main.") {
            fmt.Printf("  %-40s 0x%x\n", fn.Name(), fn.Entry())
            count++
            if count >= 20 {
                break
            }
        }
    }
    fmt.Printf("\n共 %d 个函数（显示前 20 个）\n\n", count)
}

// ShowLargestFunctions 显示最大的函数
func (a *BinaryAnalyzer) ShowLargestFunctions() {
    fmt.Println("=== 最大的函数 ===")
    
    // 按大小排序
    type FuncSize struct {
        fn   *gosym.Func
        size uint64
    }
    
    sizes := make([]FuncSize, 0, len(a.table.Funcs()))
    for _, fn := range a.table.Funcs() {
        size := fn.End() - fn.Entry()
        sizes = append(sizes, FuncSize{fn: fn, size: size})
    }
    
    sort.Slice(sizes, func(i, j int) bool {
        return sizes[i].size > sizes[j].size
    })
    
    // 显示前 10 个
    for i := 0; i < 10 && i < len(sizes); i++ {
        fs := sizes[i]
        fmt.Printf("%2d. %-40s %6d 字节 (0x%x - 0x%x)\n", 
            i+1, fs.fn.Name(), fs.size, fs.fn.Entry(), fs.fn.End())
    }
    fmt.Println()
}

// ShowFilesByPackage 按包显示源文件
func (a *BinaryAnalyzer) ShowFilesByPackage() {
    fmt.Println("=== 源文件统计 ===")
    
    // 按包分组
    packages := make(map[string][]string)
    for _, file := range a.table.Files() {
        // 提取包路径
        parts := strings.Split(file, "/")
        if len(parts) > 0 {
            pkg := parts[len(parts)-2]
            packages[pkg] = append(packages[pkg], file)
        }
    }
    
    // 显示统计
    for pkg, files := range packages {
        fmt.Printf("%-30s %d 个文件\n", pkg, len(files))
    }
    fmt.Println()
}

// FindFunction 查找函数
func (a *BinaryAnalyzer) FindFunction(pattern string) {
    fmt.Printf("=== 查找 '%s' ===\n", pattern)
    
    count := 0
    for _, fn := range a.table.Funcs() {
        if strings.Contains(fn.Name(), pattern) {
            fmt.Printf("  %-40s 0x%x (%s:%d)\n", 
                fn.Name(), fn.Entry(), fn.File(), fn.StartLine())
            count++
            if count >= 20 {
                break
            }
        }
    }
    fmt.Printf("\n找到 %d 个匹配函数\n\n", count)
}

func main() {
    if len(os.Args) < 2 {
        log.Fatal("用法：go-analyzer <binary-file> [command]")
    }
    
    filename := os.Args[1]
    
    analyzer, err := NewBinaryAnalyzer(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer analyzer.Close()
    
    if len(os.Args) > 2 {
        command := os.Args[2]
        
        switch command {
        case "summary":
            analyzer.ShowSummary()
        case "main":
            analyzer.ShowMainPackage()
        case "largest":
            analyzer.ShowLargestFunctions()
        case "files":
            analyzer.ShowFilesByPackage()
        case "find":
            if len(os.Args) > 3 {
                analyzer.FindFunction(os.Args[3])
            }
        default:
            // 显示所有信息
            analyzer.ShowSummary()
            analyzer.ShowMainPackage()
            analyzer.ShowLargestFunctions()
            analyzer.ShowFilesByPackage()
        }
    } else {
        // 默认显示所有信息
        analyzer.ShowSummary()
        analyzer.ShowMainPackage()
        analyzer.ShowLargestFunctions()
        analyzer.ShowFilesByPackage()
    }
}

示例 7：性能分析器符号解析

package main

import (
    "debug/elf"
    "debug/gosym"
    "fmt"
    "log"
    "runtime/pprof"
)

// ProfileSymbolizer 性能分析符号化器
type ProfileSymbolizer struct {
    table *gosym.Table
}

// NewProfileSymbolizer 创建符号化器
func NewProfileSymbolizer(binary string) (*ProfileSymbolizer, error) {
    f, err := elf.Open(binary)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    
    symtabData, _ := f.Section(".gosymtab").Data()
    pclntabData, _ := f.Section(".gopclntab").Data()
    pcln := gosym.NewLineTable(pclntabData, f.Sections[0].Addr)
    table, err := gosym.NewTable(symtabData, pcln)
    if err != nil {
        return nil, err
    }
    
    return &ProfileSymbolizer{table: table}, nil
}

// SymbolizeProfile 符号化性能分析数据
func (ps *ProfileSymbolizer) SymbolizeProfile(profile *pprof.Profile) {
    profile.WriteTo(os.Stdout, 0)
}

func main() {
    symbolizer, err := NewProfileSymbolizer("myprogram")
    if err != nil {
        log.Fatal(err)
    }
    
    // 获取 CPU 性能分析
    profile := pprof.Lookup("cpu")
    if profile != nil {
        symbolizer.SymbolizeProfile(profile)
    }
    
    // 获取内存性能分析
    profile = pprof.Lookup("heap")
    if profile != nil {
        fmt.Println("\n堆内存分析：")
        profile.WriteTo(os.Stdout, 0)
    }
}

示例 8：符号表比较工具

package main

import (
    "debug/elf"
    "debug/gosym"
    "fmt"
    "log"
    "os"
    "sort"
)

// compareTables 比较两个符号表
func compareTables(table1, table2 *gosym.Table) {
    funcs1 := table1.Funcs()
    funcs2 := table2.Funcs()
    
    // 创建映射
    map1 := make(map[string]*gosym.Func)
    map2 := make(map[string]*gosym.Func)
    
    for _, fn := range funcs1 {
        map1[fn.Name()] = fn
    }
    for _, fn := range funcs2 {
        map2[fn.Name()] = fn
    }
    
    // 查找新增的函数
    fmt.Println("新增的函数：")
    added := make([]string, 0)
    for name := range map2 {
        if _, ok := map1[name]; !ok {
            added = append(added, name)
        }
    }
    sort.Strings(added)
    for _, name := range added {
        fmt.Printf("  + %s\n", name)
    }
    
    // 查找删除的函数
    fmt.Println("\n删除的函数：")
    removed := make([]string, 0)
    for name := range map1 {
        if _, ok := map2[name]; !ok {
            removed = append(removed, name)
        }
    }
    sort.Strings(removed)
    for _, name := range removed {
        fmt.Printf("  - %s\n", name)
    }
    
    // 查找变化的函数
    fmt.Println("\n变化的函数：")
    for name, fn1 := range map1 {
        fn2, ok := map2[name]
        if ok {
            size1 := fn1.End() - fn1.Entry()
            size2 := fn2.End() - fn2.Entry()
            if size1 != size2 {
                fmt.Printf("  ~ %s (%d -> %d 字节)\n", name, size1, size2)
            }
        }
    }
}

func main() {
    if len(os.Args) < 3 {
        log.Fatal("用法：sym-compare <binary1> <binary2>")
    }
    
    // 加载第一个文件
    f1, err := elf.Open(os.Args[1])
    if err != nil {
        log.Fatal(err)
    }
    defer f1.Close()
    
    symtab1, _ := f1.Section(".gosymtab").Data()
    pclntab1, _ := f1.Section(".gopclntab").Data()
    pcln1 := gosym.NewLineTable(pclntab1, f1.Sections[0].Addr)
    table1, _ := gosym.NewTable(symtab1, pcln1)
    
    // 加载第二个文件
    f2, err := elf.Open(os.Args[2])
    if err != nil {
        log.Fatal(err)
    }
    defer f2.Close()
    
    symtab2, _ := f2.Section(".gosymtab").Data()
    pclntab2, _ := f2.Section(".gopclntab").Data()
    pcln2 := gosym.NewLineTable(pclntab2, f2.Sections[0].Addr)
    table2, _ := gosym.NewTable(symtab2, pcln2)
    
    // 比较
    compareTables(table1, table2)
}

安全最佳实践

✅ 推荐做法

1. 始终检查段是否存在

   section := f.Section(".gosymtab")
   if section == nil {
       return fmt.Errorf("不是 Go 二进制文件")
   }
   

2. 验证符号表格式

   if len(symtabData) < 16 {
       return fmt.Errorf("符号表数据太小")
   }
   

3. 处理缺失的调试信息

   fn := table.PCToFunc(pc)
   if fn == nil {
       // 回退到 DWARF 信息
   }
   

❌ 不安全做法

1. 不要假设符号表一定存在

   // ❌ 错误
   symtabData, _ := f.Section(".gosymtab").Data()
   
   // ✅ 正确
   section := f.Section(".gosymtab")
   if section == nil {
       return error
   }
   

2. 不要忘记关闭文件

   f, _ := elf.Open("file")
   defer f.Close()
   

总结

核心类型

Table      // 符号表
Func       // 函数信息
Sym        // 符号
LineTable  // 行号表
Line       // 行号条目

使用场景

符号类型

ELF 段

与 DWARF 的比较

参考资料

• Go debug/gosym 包文档
• Go 符号表格式
• Go 1.23 发布说明
• debug/dwarf 包文档
• debug/elf 包文档

最后更新：2026-04-03
Go 版本：Go 1.23+