调试信息与源码映射

# 编译时开启调试信息
gcc -g -O2 foo.c -o foo            # -g 生成完整调试信息
clang -g -gdwarf-5 -O2 foo.c       # 指定 DWARF 版本

# 查看目标文件里的调试节区
readelf -S foo | grep debug
#   .debug_info     .debug_abbrev   .debug_line
#   .debug_str      .debug_loc      .debug_ranges

DW_TAG_compile_unit
  DW_AT_name        "foo.c"
  DW_AT_comp_dir    "/home/user/src"
  DW_TAG_subprogram
    DW_AT_name        "square"
    DW_AT_low_pc      0x401126
    DW_AT_high_pc     0x401132
    DW_AT_frame_base  DW_OP_call_frame_cfa
    DW_TAG_formal_parameter
      DW_AT_name      "x"
      DW_AT_type      <0x2a>          # 指向 int 类型的 DIE
      DW_AT_location  DW_OP_fbreg -20 # 相对 CFA 偏移 -20
    DW_TAG_variable
      DW_AT_name      "tmp"
      DW_AT_location  DW_OP_reg5      # 住在 rdi 里

def parse_die_tree(debug_info, abbrev_table, string_pool):
    """解析 DIE 树: 按 abbrev 编号读取属性"""
    dies = []
    stream = iter_debug_info(debug_info)
    depth = 0
    while True:
        code = stream.read_uleb128()
        if code == 0:                       # 结束当前兄弟列表
            depth -= 1
            if depth < 0: break
            continue
        abbrev = abbrev_table[code]
        attrs = {}
        for spec in abbrev.attributes:
            attrs[spec.name] = read_form(stream, spec.form, string_pool)
        dies.append(Die(tag=abbrev.tag, attrs=attrs, depth=depth))
        if abbrev.has_children:
            depth += 1
    return dies

class LineState:
    def __init__(self):
        self.address = 0        # 当前地址
        self.file = 1           # 当前文件索引
        self.line = 1           # 当前行号
        self.column = 0         # 当前列号
        self.is_stmt = False    # 是否是一条语句的起点
        self.end_sequence = False

def run_line_program(program, state):
    """行号状态机: 解释 .debug_line 字节码, 产出 (地址, 文件, 行) 表"""
    rows = []
    for op in program:
        if op.kind == "DW_LNS_copy":
            rows.append((state.address, state.file, state.line, state.column))
        elif op.kind == "DW_LNS_advance_pc":
            state.address += op.operand * min_insn_length
        elif op.kind == "DW_LNS_advance_line":
            state.line += op.operand                  # 有符号增量
        elif op.kind == "DW_LNS_set_file":
            state.file = op.operand
        elif op.kind == "special":
            # 特殊操作码: 高位编码地址增量, 低位编码行增量
            addr_adv, line_adv = decode_special(op.opcode)
            state.address += addr_adv * min_insn_length
            state.line += line_adv
            rows.append((state.address, state.file, state.line, state.column))
        elif op.kind == "DW_LNE_end_sequence":
            rows.append((state.address, state.file, state.line, 0))
            state = LineState()                        # 重置, 开始新序列
    return rows

# -O0: 变量 x 固定在栈帧偏移 -20
DW_AT_location: DW_OP_fbreg -20

# -O2: 同一个变量在不同区间位置不同
location list for x:
  [0x401126, 0x401130):  DW_OP_reg5          # rdi 里
  [0x401130, 0x401138):  DW_OP_fbreg -24     # 溢出到栈
  [0x401138, 0x401140):  <空>                # 变量已死, 值不存在

def locate_variable(var, pc, frame):
    """按位置列表定位变量当前值"""
    for (lo, hi), expr in var.location_list:
        if lo <= pc < hi:
            return eval_dwarf_expr(expr, frame)
    return None            # 该地址处变量无位置 -> optimized out

DW_TAG_subprogram              # 调用者: process
  DW_AT_name  "process"
  DW_TAG_inlined_subroutine    # 被内联进来的 validate
    DW_AT_abstract_origin  <0x1a2>   # 指向 validate 的抽象定义
    DW_AT_low_pc   0x401200
    DW_AT_high_pc  0x401218
    DW_AT_call_file    "input.c"
    DW_AT_call_line    37
    DW_AT_call_column  9

# GDB: 查看被内联的帧
(gdb) bt
# #0  validate (x=7) at validate.c:12        <- 内联帧
# #1  0x0000000000401200 in process (p=0x7fff...) at input.c:37
(gdb) info frame
# inlined into frame #1

{
  "version": 3,
  "sources": ["src/app.ts"],
  "names": ["add", "x", "y"],
  "mappings": "AAAA,GAAG,MAAM,GAAG..."
}

B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
B64_INDEX = {c: i for i, c in enumerate(B64)}

def decode_vlq(segment):
    """解码一个 Base64 VLQ 分段为整数列表"""
    values, result, shift = [], 0, 0
    for ch in segment:
        digit = B64_INDEX[ch]
        cont = digit & 0x20            # 第 5 位是续位
        digit &= 0x1F                  # 低 4 位是数值
        result += digit << shift
        if cont:
            shift += 5                 # 还有后续字节
        else:
            sign = -1 if (result & 1) else 1   # 最低位是符号位
            values.append(sign * (result >> 1))
            result, shift = 0, 0
    return values

def decode_mappings(mappings):
    """还原整张 Source Map 表"""
    rows, src_file, src_line, src_col, name_idx = [], 0, 0, 0, 0
    for gen_line, line in enumerate(mappings.split(";")):
        gen_col = 0
        for seg in line.split(","):
            if not seg:
                continue
            vals = decode_vlq(seg)
            gen_col += vals[0]
            if len(vals) >= 4:
                src_file += vals[1]
                src_line += vals[2]
                src_col  += vals[3]
                name_idx = name_idx + vals[4] if len(vals) == 5 else name_idx
                rows.append((gen_line, gen_col, src_file, src_line, src_col))
    return rows

# 1. 按需选择调试信息级别
gcc -g1   # 只保留行号与函数名, 体积最小, 够做栈回溯
gcc -g    # 标准级别
gcc -g3  # 额外包含宏定义, 体积最大

# 2. 分离调试信息: .o 里只留一个指针, 调试信息进 .dwo
gcc -gsplit-dwarf -O2 -c foo.c -o foo.o
# 链接期只处理 .o, 调试信息不需要读入 -> 显著加快链接

# 3. 抹掉绝对路径, 保证可复现
gcc -g -fdebug-prefix-map=/home/user/src=. -ffile-prefix-map=/home/user/src=.

# 4. 压缩调试节区
gcc -g -Wa,--compress-debug-sections=zlib

# 5. 用 build-id 关联二进制与调试文件, 按需下载
readelf -n foo | grep 'Build ID'
debuginfod-find debuginfo <build-id>

# 剥离调试信息到独立文件, 保留 build-id 关联
objcopy --only-keep-debug foo foo.debug
objcopy --strip-debug foo
objcopy --add-gnu-debuglink=foo.debug foo
# 崩溃时: 用 build-id 或 debuglink 找到 foo.debug 还原符号