tiny.tldr.formats.elf.ehframe.header.writer

1pub const writer = @import("writer.zig");

1const std = @import("std");2const root = @import("../../../../root.zig");3const elf = @import("../../root.zig");4const ehframe = @import("../root.zig");5const reservation = @import("reservation.zig");67const Allocator = std.mem.Allocator;8const model = root.model;9const addressing = elf.addressing;10const format = elf.format;11const layout = elf.layout;12const output_section = elf.output_section;13const parser = elf.parser;14const ObjectFile = parser.ObjectFile;15const ObjectLayout = layout.ObjectLayout;16const OutputSection = layout.OutputSection;17const GlobalSymbol = layout.GlobalSymbol;18const SymbolAddressCache = addressing.Cache;19const Rela = format.Rela;20const OutputSectionKind = output_section.OutputSectionKind;21const eh_frame_hdr_fixed_size = format.eh_frame_hdr_fixed_size;22const eh_frame_hdr_entry_size = format.eh_frame_hdr_entry_size;23const dwarf_eh_pe_udata4 = format.dwarf_eh_pe_udata4;24const dwarf_eh_pe_sdata4 = format.dwarf_eh_pe_sdata4;25const dwarf_eh_pe_pcrel = format.dwarf_eh_pe_pcrel;26const dwarf_eh_pe_datarel = format.dwarf_eh_pe_datarel;27const contributionAt = layout.contributionAt;28const ehFrameSectionLayout = layout.ehFrameSection;29const sectionBytes = format.sectionBytes;30const readU32 = format.readU32;31const writeU32 = format.writeU32;32const requireRange = format.requireRange;33const relocationTargetAddress = addressing.relocationTarget;34const record = ehframe.record;35const section = ehframe.section;3637const Entry = struct {38    start_ip: u64,39    fde_address: u64,40};4142pub fn write(43    scratch: Allocator,44    image: []u8,45    objects: []const ObjectFile,46    layouts: []const ObjectLayout,47    output_sections: []const OutputSection,48    globals: *const std.StringHashMapUnmanaged(GlobalSymbol),49    symbol_addresses: *SymbolAddressCache,50    options: model.LinkOptions,51) model.Error!void {52    if (!options.eh_frame_header) return;53    const header = output_sections[@backingInt(OutputSectionKind.eh_frame_hdr)];54    if (header.logicalSize() == 0) return;55    const eh_frame_start = startAddress(objects, layouts, output_sections) orelse return error.MissingSection;5657    var entries = std.ArrayListUnmanaged(Entry).empty;58    defer entries.deinit(scratch);59    try collectEntries(scratch, &entries, objects, layouts, output_sections, globals, symbol_addresses);60    if (try reservation.size(entries.items.len) != header.logicalSize()) return error.InvalidRange;6162    std.mem.sort(Entry, entries.items, {}, compareEntries);63    try requireRange(image, header.file_offset, header.logicalSize());64    const start: usize = @intCast(header.file_offset);65    image[start + 0] = 1;66    image[start + 1] = dwarf_eh_pe_pcrel | dwarf_eh_pe_sdata4;67    image[start + 2] = dwarf_eh_pe_udata4;68    image[start + 3] = dwarf_eh_pe_datarel | dwarf_eh_pe_sdata4;69    writeU32(image, start + 4, @bitCast(try elf.relocation.checkedI32(@as(i128, @intCast(eh_frame_start)) - @as(i128, @intCast(header.address + 4)))));70    writeU32(image, start + 8, try elf.relocation.checkedU32(@intCast(entries.items.len)));7172    var cursor = start + eh_frame_hdr_fixed_size;73    for (entries.items) |entry| {74        writeU32(image, cursor + 0, @bitCast(try elf.relocation.checkedI32(@as(i128, @intCast(entry.start_ip)) - @as(i128, @intCast(header.address)))));75        writeU32(image, cursor + 4, @bitCast(try elf.relocation.checkedI32(@as(i128, @intCast(entry.fde_address)) - @as(i128, @intCast(header.address)))));76        cursor += eh_frame_hdr_entry_size;77    }78}7980fn collectEntries(81    allocator: Allocator,82    entries: *std.ArrayListUnmanaged(Entry),83    objects: []const ObjectFile,84    layouts: []const ObjectLayout,85    output_sections: []const OutputSection,86    globals: *const std.StringHashMapUnmanaged(GlobalSymbol),87    symbol_addresses: *SymbolAddressCache,88) model.Error!void {89    for (objects, 0..) |object, object_index| {90        const object_layout = layouts[object_index];91        for (object.sections, 0..) |input_section, section_index| {92            const contribution = contributionAt(object_layout.sections, section_index) orelse continue;93            if (!section.is(object, section_index, input_section)) continue;94            const output = output_sections[contribution.outputIndex()];95            const section_address = output.address + contribution.offset;96            const bytes = try sectionBytes(object.bytes, input_section);97            if (ehFrameSectionLayout(object_layout, section_index)) |eh_frame_section| {98                var cursor = record.Cursor.init(eh_frame_section.relocations);99                for (eh_frame_section.pieces) |piece| {100                    try appendEntry(101                        allocator,102                        entries,103                        objects,104                        layouts,105                        output_sections,106                        globals,107                        symbol_addresses,108                        object_index,109                        bytes,110                        piece.input_offset,111                        piece.size,112                        piece.output_offset,113                        &cursor,114                        section_address,115                    );116                }117                continue;118            }119            try collectRawEntries(120                allocator,121                entries,122                objects,123                layouts,124                output_sections,125                globals,126                symbol_addresses,127                object_index,128                bytes,129                object.relocationsForSection(section_index),130                section_address,131            );132        }133    }134}135136fn collectRawEntries(137    allocator: Allocator,138    entries: *std.ArrayListUnmanaged(Entry),139    objects: []const ObjectFile,140    layouts: []const ObjectLayout,141    output_sections: []const OutputSection,142    globals: *const std.StringHashMapUnmanaged(GlobalSymbol),143    symbol_addresses: *SymbolAddressCache,144    object_index: usize,145    bytes: []const u8,146    relocations: []const Rela,147    section_address: u64,148) model.Error!void {149    var cursor = record.Cursor.init(relocations);150    var input_offset: u64 = 0;151    while (input_offset < bytes.len) {152        const record_start: usize = @intCast(input_offset);153        if (bytes.len - record_start < 4) return error.InvalidObject;154        const record_length = readU32(bytes, record_start);155        if (record_length == 0xffffffff) return error.UnsupportedFormat;156        const record_size = @as(u64, record_length) + 4;157        if (record_size < 4) return error.InvalidObject;158        if (input_offset > std.math.maxInt(u64) - record_size) return error.InvalidObject;159        const record_end = input_offset + record_size;160        if (record_end > bytes.len) return error.InvalidObject;161        try appendEntry(162            allocator,163            entries,164            objects,165            layouts,166            output_sections,167            globals,168            symbol_addresses,169            object_index,170            bytes,171            input_offset,172            record_size,173            input_offset,174            &cursor,175            section_address,176        );177        if (record_length == 0) break;178        input_offset = record_end;179    }180}181182fn appendEntry(183    allocator: Allocator,184    entries: *std.ArrayListUnmanaged(Entry),185    objects: []const ObjectFile,186    layouts: []const ObjectLayout,187    output_sections: []const OutputSection,188    globals: *const std.StringHashMapUnmanaged(GlobalSymbol),189    symbol_addresses: *SymbolAddressCache,190    object_index: usize,191    bytes: []const u8,192    input_offset: u64,193    entry_size: u64,194    output_offset: u64,195    cursor: *record.Cursor,196    section_address: u64,197) model.Error!void {198    if (!try record.hasHeaderEntry(bytes, input_offset, entry_size, output_offset, cursor)) return;199    const relocation = cursor.at(output_offset + 8) orelse return;200    const symbol_index: usize = @intCast(relocation.symbolIndex());201    const target = try relocationTargetAddress(.serial, objects, layouts, output_sections, globals, symbol_addresses, object_index, symbol_index, relocation, false);202    try entries.append(allocator, .{203        .start_ip = try elf.relocation.checkedU64(target.address + target.addend),204        .fde_address = section_address + output_offset,205    });206}207208fn startAddress(209    objects: []const ObjectFile,210    layouts: []const ObjectLayout,211    output_sections: []const OutputSection,212) ?u64 {213    var start: ?u64 = null;214    for (objects, 0..) |object, object_index| {215        const object_layout = layouts[object_index];216        for (object.sections, 0..) |input_section, section_index| {217            const contribution = contributionAt(object_layout.sections, section_index) orelse continue;218            if (!section.is(object, section_index, input_section)) continue;219            const output = output_sections[contribution.outputIndex()];220            const address = output.address + contribution.offset;221            if (start == null or address < start.?) start = address;222        }223    }224    return start;225}226227fn compareEntries(_: void, left: Entry, right: Entry) bool {228    if (left.start_ip != right.start_ip) return left.start_ip < right.start_ip;229    return left.fde_address < right.fde_address;230}