跳转到内容
标准库Zig 0.17.1官方原文
源码std/pie.zig

第 1 行

std.pie.assert

别名

第 4 行

别名目标 std.debug.assert

std.pie.builtin

常量

第 2 行

std.pie.elf

别名

第 3 行

别名目标 std.elf

std.pie.getDynamicSymbol

函数

第 54 行

inline fn getDynamicSymbol() [*]const elf.Dyn

std.pie.R_386_RELATIVE

常量

第 8 行

std.pie.R_390_RELATIVE

常量

第 22 行

std.pie.R_68K_RELATIVE

常量

第 16 行

std.pie.R_AARCH64_RELATIVE

常量

第 11 行

std.pie.R_ALPHA_RELATIVE

常量

第 6 行

std.pie.R_AMD64_RELATIVE

常量

第 7 行

std.pie.R_ARC_RELATIVE

常量

第 9 行

std.pie.R_ARM_RELATIVE

常量

第 10 行

std.pie.R_CSKY_RELATIVE

常量

第 12 行

std.pie.R_HEXAGON_RELATIVE

常量

第 13 行

std.pie.R_KVX_RELATIVE

常量

第 14 行

std.pie.R_LARCH_RELATIVE

常量

第 15 行

std.pie.R_MICROBLAZE_REL

常量

第 17 行

std.pie.R_MIPS_RELATIVE

常量

第 18 行

std.pie.R_OR1K_RELATIVE

常量

第 19 行

std.pie.R_PPC_RELATIVE

常量

第 20 行

std.pie.R_RELATIVE

常量

第 27 行

std.pie.R_RISCV_RELATIVE

常量

第 21 行

std.pie.R_SH_RELATIVE

常量

第 23 行

std.pie.R_SPARC_RELATIVE

常量

第 24 行

std.pie.R_XTENSA_RELATIVE

常量

第 25 行

std.pie.relocate

函数

第 317 行

pub fn relocate(phdrs: []const elf.ElfN.Phdr) void

参数

phdrs: []const elf.ElfN.Phdr

std.pie.std

别名

第 1 行

别名目标 std

源码

std/pie.zig

const std = @import("std");
const builtin = @import("builtin");
const elf = std.elf;
const assert = std.debug.assert;

const R_ALPHA_RELATIVE = 27;
const R_AMD64_RELATIVE = 8;
const R_386_RELATIVE = 8;
const R_ARC_RELATIVE = 56;
const R_ARM_RELATIVE = 23;
const R_AARCH64_RELATIVE = 1027;
const R_CSKY_RELATIVE = 9;
const R_HEXAGON_RELATIVE = 35;
const R_KVX_RELATIVE = 39;
const R_LARCH_RELATIVE = 3;
const R_68K_RELATIVE = 22;
const R_MICROBLAZE_REL = 16;
const R_MIPS_RELATIVE = 128;
const R_OR1K_RELATIVE = 21;
const R_PPC_RELATIVE = 22;
const R_RISCV_RELATIVE = 3;
const R_390_RELATIVE = 12;
const R_SH_RELATIVE = 165;
const R_SPARC_RELATIVE = 22;
const R_XTENSA_RELATIVE = 5;

const R_RELATIVE = switch (builtin.cpu.arch) {
    .x86 => R_386_RELATIVE,
    .x86_64 => R_AMD64_RELATIVE,
    .arc, .arceb => R_ARC_RELATIVE,
    .arm, .armeb, .thumb, .thumbeb => R_ARM_RELATIVE,
    .aarch64, .aarch64_be => R_AARCH64_RELATIVE,
    .alpha => R_ALPHA_RELATIVE,
    .csky => R_CSKY_RELATIVE,
    .hexagon => R_HEXAGON_RELATIVE,
    .kvx => R_KVX_RELATIVE,
    .loongarch32, .loongarch64 => R_LARCH_RELATIVE,
    .m68k => R_68K_RELATIVE,
    .microblaze, .microblazeel => R_MICROBLAZE_REL,
    .mips, .mipsel, .mips64, .mips64el => R_MIPS_RELATIVE,
    .or1k => R_OR1K_RELATIVE,
    .powerpc, .powerpcle, .powerpc64, .powerpc64le => R_PPC_RELATIVE,
    .riscv32, .riscv32be, .riscv64, .riscv64be => R_RISCV_RELATIVE,
    .s390x => R_390_RELATIVE,
    .sh, .sheb => R_SH_RELATIVE,
    .sparc, .sparc64 => R_SPARC_RELATIVE,
    .xtensa, .xtensaeb => R_XTENSA_RELATIVE,
    else => @compileError("Missing R_RELATIVE definition for this target"),
};

// 获取 _DYNAMIC 数组的指针。
// 必须以程序计数器相对量计算其地址,避免依赖此时尚未应用的重定位。
//
inline fn getDynamicSymbol() [*]const elf.Dyn {
    return switch (builtin.zig_backend) {
        else => switch (builtin.cpu.arch) {
            .x86 => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ call 1f
                \\1:
                \\ pop %[ret]
                \\ lea _DYNAMIC - 1b(%[ret]), %[ret]
                : [ret] "=r" (-> [*]const elf.Dyn),
            ),
            .x86_64 => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ lea _DYNAMIC(%%rip), %[ret]
                : [ret] "=r" (-> [*]const elf.Dyn),
            ),
            .arc, .arceb => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ add %[ret], pcl, _DYNAMIC@pcl
                : [ret] "=r" (-> [*]const elf.Dyn),
            ),
            // 规避 `ldr` 偏移范围有限的问题
            .arm, .armeb, .thumb, .thumbeb => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ ldr %[ret], 1f
                \\ add %[ret], pc
                \\ b 2f
                \\1:
                \\ .word _DYNAMIC - 1b
                \\2:
                : [ret] "=r" (-> [*]const elf.Dyn),
            ),
            // 单独的 `adr` 不够,因为其偏移量范围有限。
            .aarch64, .aarch64_be => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ adrp %[ret], _DYNAMIC
                \\ add %[ret], %[ret], #:lo12:_DYNAMIC
                : [ret] "=r" (-> [*]const elf.Dyn),
            ),
            // 编译器不一定加载 GP 寄存器,因此自行加载。
            .alpha => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ br $29, 1f
                \\1:
                \\ ldgp $29, 0($29)
                \\ ldah %[ret], _DYNAMIC($29) !gprelhigh
                \\ lda %[ret], _DYNAMIC(%[ret]) !gprellow
                : [ret] "=r" (-> [*]const elf.Dyn),
                :
                : .{ .r29 = true }),
            .csky => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ grs %[ret], 1f
                \\ br 2f
                \\1:
                \\ .long _DYNAMIC - 1b
                \\2:
                \\ ldw r12, (%[ret], 0)
                \\ addu %[ret], %[ret], r12
                : [ret] "=r" (-> [*]const elf.Dyn),
                :
                : .{ .r12 = true }),
            .hexagon => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ jump 1f
                \\ .word _DYNAMIC - .
                \\1:
                \\ r1 = pc
                \\ r1 = add(r1, #-4)
                \\ %[ret] = memw(r1)
                \\ %[ret] = add(r1, %[ret])
                : [ret] "=r" (-> [*]const elf.Dyn),
                :
                : .{ .r1 = true }),
            .kvx => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ pcrel %[ret] = @pcrel(_DYNAMIC)
                : [ret] "=r" (-> [*]const elf.Dyn),
            ),
            .loongarch32, .loongarch64 => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ la.local %[ret], _DYNAMIC
                : [ret] "=r" (-> [*]const elf.Dyn),
            ),
            // 注意,需要减去 8,因为第二条 lea 指令中的 pc 指向
            // 该指令的中间位置。(第一条 lea 为 6 字节,第二条为 4 字节。)
            .m68k => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ lea _DYNAMIC - . - 8, %[ret]
                \\ lea (%[ret], %%pc), %[ret]
                : [ret] "=a" (-> [*]const elf.Dyn),
            ),
            .microblaze, .microblazeel => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ mfs %[ret], rpc
                \\ bri 1f
                \\ .word _DYNAMIC - . + 8
                \\1:
                \\ lwi r18, %[ret], 8
                \\ add %[ret], %[ret], r18
                : [ret] "=r" (-> [*]const elf.Dyn),
                :
                : .{ .r18 = true }),
            .mips, .mipsel => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ bal 1f
                \\ .gpword _DYNAMIC
                \\1:
                \\ lw %[ret], 0($ra)
                \\ nop
                \\ addu %[ret], %[ret], $gp
                : [ret] "=r" (-> [*]const elf.Dyn),
                :
                : .{ .lr = true }),
            .mips64, .mips64el => switch (builtin.abi) {
                .gnuabin32, .muslabin32, .abin32 => asm volatile (
                    \\ .weak _DYNAMIC
                    \\ .hidden _DYNAMIC
                    \\ bal 1f
                    \\ .gpword _DYNAMIC
                    \\1:
                    \\ lw %[ret], 0($ra)
                    \\ addu %[ret], %[ret], $gp
                    : [ret] "=r" (-> [*]const elf.Dyn),
                    :
                    : .{ .lr = true }),
                else => asm volatile (
                    \\ .weak _DYNAMIC
                    \\ .hidden _DYNAMIC
                    \\ .balign 8
                    \\ bal 1f
                    \\ .gpdword _DYNAMIC
                    \\1:
                    \\ ld %[ret], 0($ra)
                    \\ daddu %[ret], %[ret], $gp
                    : [ret] "=r" (-> [*]const elf.Dyn),
                    :
                    : .{ .lr = true }),
            },
            .or1k => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ l.jal 1f
                \\  l.nop
                \\ .word _DYNAMIC - .
                \\1:
                \\ l.lwz %[ret], 0(r9)
                \\ l.add %[ret], %[ret], r9
                : [ret] "=r" (-> [*]const elf.Dyn),
                :
                : .{ .r9 = true }),
            .powerpc, .powerpcle => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ bl 1f
                \\ .long _DYNAMIC - .
                \\1:
                \\ mflr %[ret]
                \\ lwz 4, 0(%[ret])
                \\ add %[ret], 4, %[ret]
                : [ret] "=r" (-> [*]const elf.Dyn),
                :
                : .{ .lr = true, .r4 = true }),
            .powerpc64, .powerpc64le => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ .balign 8
                \\ bl 1f
                \\ nop
                \\ .quad _DYNAMIC - . + 4
                \\1:
                \\ mflr %[ret]
                \\ ld 4, 4(%[ret])
                \\ add %[ret], 4, %[ret]
                : [ret] "=r" (-> [*]const elf.Dyn),
                :
                : .{ .lr = true, .r4 = true }),
            .riscv32, .riscv32be, .riscv64, .riscv64be => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ lla %[ret], _DYNAMIC
                : [ret] "=r" (-> [*]const elf.Dyn),
            ),
            .s390x => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ larl %[ret], 1f
                \\ ag %[ret], 0(%[ret])
                \\ jg 2f
                \\1:
                \\ .quad _DYNAMIC - .
                \\2:
                : [ret] "=a" (-> [*]const elf.Dyn),
            ),
            .sh, .sheb => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ mova 1f, r0
                \\ mov.l 1f, %[ret]
                \\ add r0, %[ret]
                \\ bra 2f
                \\  nop
                \\ .balign 4
                \\1:
                \\ .long _DYNAMIC - .
                \\2:
                : [ret] "=r" (-> [*]const elf.Dyn),
                :
                : .{ .r0 = true }),
            .sparc, .sparc64 => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                \\ sethi %%pc22(_DYNAMIC - 4), %[ret]
                \\ call 1f
                \\  add %[ret], %%pc10(_DYNAMIC + 4), %[ret]
                \\1:
                \\ add %[ret], %%o7, %[ret]
                : [ret] "=r" (-> [*]const elf.Dyn),
                :
                : .{ .o7 = true }),
            .xtensa, .xtensaeb => asm volatile (
                \\ .weak _DYNAMIC
                \\ .hidden _DYNAMIC
                // 安排代码,使执行 `call0` 后,`a0` 指向嵌入常量前 1 字节。
                // 注意,`call0` 是 3 字节指令,因此为确保安全,
                // 需要两条 `.balign` 指令。
                \\ .balign 4
                \\ call0 1f
                \\ .balign 4
                \\ .word _DYNAMIC - .
                \\1:
                \\ addi a0, a0, 1
                \\ l32i a8, a0, 0
                \\ add %[ret], a0, a8
                : [ret] "=a" (-> [*]const elf.Dyn),
                :
                : .{ .a0 = true, .a8 = true }),
            else => {
                @compileError("PIE startup is not yet supported for this target!");
            },
        },
        .stage2_x86_64 => @extern([*]const elf.Dyn, .{
            .name = "_DYNAMIC",
            .linkage = .weak,
            .visibility = .hidden,
            .relocation = .pcrel,
        }).?,
    };
}

pub fn relocate(phdrs: []const elf.ElfN.Phdr) void {
    @setRuntimeSafety(false);
    @disableInstrumentation();

    const dynv = getDynamicSymbol();

    // 比较 `_DYNAMIC` 符号的实际加载地址与理论加载地址,
    // 恢复加载器应用的偏移量。
    const base_addr = base: {
        for (phdrs) |*phdr| {
            if (phdr.type != .DYNAMIC) continue;
            break :base @intFromPtr(dynv) - phdr.vaddr;
        }
        // 格式正确的二进制文件不应出现这种情况。
        @trap();
    };

    var sorted_dynv: [elf.DT_NUM]elf.Addr = undefined;

    // 以此方式零初始化,防止编译器将其转换为
    // `memcpy` 或 `memset` 调用(它们可能需要重定位)。
    for (&sorted_dynv) |*dyn| {
        const pdyn: *volatile elf.Addr = @ptrCast(dyn);
        pdyn.* = 0;
    }

    {
        // `dynv` 没有规定顺序。修正这一点。
        var i: usize = 0;
        while (dynv[i].d_tag != elf.DT_NULL) : (i += 1) {
            if (dynv[i].d_tag < elf.DT_NUM) sorted_dynv[@bitCast(dynv[i].d_tag)] = dynv[i].d_val;
        }
    }

    // 先处理 MIPS 使用的 GOT 重定位。
    if (builtin.cpu.arch.isMIPS()) {
        const count: elf.Addr = blk: {
            // 这是架构专属标签,因此不属于 `sorted_dynv`。
            var i: usize = 0;
            while (dynv[i].d_tag != elf.DT_NULL) : (i += 1) {
                if (dynv[i].d_tag == elf.DT_MIPS_LOCAL_GOTNO) break :blk dynv[i].d_val;
            }

            break :blk 0;
        };

        const got: [*]usize = @ptrFromInt(base_addr + sorted_dynv[elf.DT_PLTGOT]);

        for (0..count) |i| {
            got[i] += base_addr;
        }
    }

    // 应用普通重定位。

    const rel = sorted_dynv[elf.DT_REL];
    if (rel != 0) {
        const rels: []const elf.Rel = @ptrCast(@alignCast(
            @as([*]align(@alignOf(elf.Rel)) const u8, @ptrFromInt(base_addr + rel))[0..sorted_dynv[elf.DT_RELSZ]],
        ));
        for (rels) |r| {
            if (r.r_type() != R_RELATIVE) continue;
            @as(*usize, @ptrFromInt(base_addr + r.r_offset)).* += base_addr;
        }
    }

    const rela = sorted_dynv[elf.DT_RELA];
    if (rela != 0) {
        const relas: []const elf.Rela = @ptrCast(@alignCast(
            @as([*]align(@alignOf(elf.Rela)) const u8, @ptrFromInt(base_addr + rela))[0..sorted_dynv[elf.DT_RELASZ]],
        ));
        for (relas) |r| {
            if (r.r_type() != R_RELATIVE) continue;
            @as(*usize, @ptrFromInt(base_addr + r.r_offset)).* = base_addr + @as(usize, @bitCast(r.r_addend));
        }
    }

    const relr = sorted_dynv[elf.DT_RELR];
    if (relr != 0) {
        const relrs: []const elf.Relr = @ptrCast(
            @as([*]align(@alignOf(elf.Relr)) const u8, @ptrFromInt(base_addr + relr))[0..sorted_dynv[elf.DT_RELRSZ]],
        );
        var current: [*]usize = undefined;
        for (relrs) |r| {
            if ((r & 1) == 0) {
                current = @ptrFromInt(base_addr + r);
                current[0] += base_addr;
                current += 1;
            } else {
                // 跳过第一个位;位图中共有 63 个位置。
                var i: if (@sizeOf(usize) == 8) u6 else u5 = 1;
                while (i < @bitSizeOf(elf.Relr)) : (i += 1) {
                    if (((r >> i) & 1) != 0) current[i] += base_addr;
                }

                current += @bitSizeOf(elf.Relr) - 1;
            }
        }
    }
}