tiny.tldr.formats.elf

1pub fn linkExecutable(2    allocator: Allocator,3    inputs: []const model.Input,4    options: model.LinkOptions,5) model.Error!root.LinkedImage {6    const link_phase = trace.scope("link.elf");7    defer link_phase.end();8    if (options.diagnostics) |diagnostics| diagnostics.clear();9    if (options.requiresDynamicLinking()) return error.UnsupportedDynamicLinking;10    if (options.output_kind != .executable) return error.UnsupportedOutputKind;11    if (options.target.architecture != .x86_64 or options.target.endianness != .little) {12        return error.UnsupportedArchitecture;13    }14    if (inputs.len == 0) return error.NoAllocSections;1516    var selection_state = std.heap.ArenaAllocator.init(allocator);17    defer selection_state.deinit();18    var selection_lock = allocators.LockedAllocator.init(selection_state.allocator());19    const selection = selection_lock.allocator();2021    var scratch_state = std.heap.ArenaAllocator.init(allocator);22    defer scratch_state.deinit();23    const scratch = scratch_state.allocator();2425    var manifest_builder = build_manifest: {26        const manifest_phase = trace.product(.manifest_recording);27        defer manifest_phase.end();28        var builder = try incremental.Builder.init(allocator, options);29        errdefer builder.deinit();30        for (inputs) |input| try builder.addInput(input);31        break :build_manifest builder;32    };33    errdefer manifest_builder.deinit();3435    var objects = std.ArrayListUnmanaged(ObjectFile).empty;36    defer objects.deinit(scratch);37    try objects.ensureTotalCapacity(scratch, inputs.len);3839    var archive_state: archive_selection.ExtractionState = .{};40    defer archive_state.deinit(scratch);4142    var prefetcher = archive_selection.Prefetcher.init(selection, inputs, options);43    defer prefetcher.deinit();44    prefetcher.advance(0);4546    for (inputs, 0..) |input, input_index| {47        if (archive.isArchive(input.bytes)) {48            const archive_phase = trace.product(.archive_member_selection);49            defer archive_phase.end();50            try archive_state.observeNewObjects(scratch, objects.items);51            try archive_selection.addCandidates(scratch, selection, input, input_index, &archive_state, options, &prefetcher);52            prefetcher.advance(input_index + 1);53        } else {54            var object = try parseInputObject(scratch, input, options);55            object.input_index = input_index;56            try objects.append(scratch, object);57        }58        if (archive_state.hasCandidates()) {59            const archive_phase = trace.product(.archive_member_selection);60            defer archive_phase.end();61            try archive_state.observeNewObjects(scratch, objects.items);62            try archive_selection.extractCandidates(63                scratch,64                selection,65                &objects,66                &archive_state,67                options,68            );69        }70    }71    if (manifest_builder.recordsContributions()) {72        const manifest_phase = trace.product(.manifest_recording);73        defer manifest_phase.end();74        try relink.recordInputLinkEvidence(&manifest_builder, scratch, inputs, objects.items, &archive_state);75    }76    var globals: std.StringHashMapUnmanaged(GlobalSymbol) = .{};77    defer globals.deinit(scratch);78    var global_symbol_refs = std.ArrayListUnmanaged(SymbolRef).empty;79    defer global_symbol_refs.deinit(scratch);80    {81        const symbol_phase = trace.product(.symbol_database);82        defer symbol_phase.end();83        {84            const duplicate_phase = trace.product(.duplicate_policy);85            defer duplicate_phase.end();86            try group.discardDuplicates(scratch, objects.items);87        }88        try collectGlobalSymbols(scratch, objects.items, &globals, &global_symbol_refs, options.max_link_jobs);89        if (options.gc_sections) {90            try liveness.discardUnreachable(scratch, objects.items, &globals, options);91        }92        if (options.icf == .all) {93            const duplicate_phase = trace.product(.duplicate_policy);94            defer duplicate_phase.end();95            try icf.fold(scratch, objects.items);96        }97        try requireResolvedRelocationSymbols(scratch, objects.items, &globals, options);98        try requireSupportedRelocations(scratch, objects.items, options);99        try requireEntrySymbol(&globals, options);100    }101    if (options.commit_observer) |observer| observer.notify();102103    var output_sections = [output_section_count]OutputSection{104        .{ .kind = .build_id_note, .alignment = 4 },105        .{ .kind = .init, .alignment = 4 },106        .{ .kind = .text, .alignment = 16 },107        .{ .kind = .fini, .alignment = 4 },108        .{ .kind = .iplt, .alignment = 16 },109        .{ .kind = .eh_frame_hdr, .alignment = 4 },110        .{ .kind = .eh_frame, .alignment = 8 },111        .{ .kind = .rodata, .alignment = 1 },112        .{ .kind = .rela_iplt, .alignment = 8 },113        .{ .kind = .preinit_array, .alignment = 8 },114        .{ .kind = .init_array, .alignment = 8 },115        .{ .kind = .fini_array, .alignment = 8 },116        .{ .kind = .data, .alignment = 8 },117        .{ .kind = .got, .alignment = 8 },118        .{ .kind = .igot, .alignment = 8 },119        .{ .kind = .tdata, .alignment = 1 },120        .{ .kind = .tbss, .alignment = 1 },121        .{ .kind = .bss, .alignment = 1 },122        .{ .kind = .debug_abbrev, .alignment = 1 },123        .{ .kind = .debug_addr, .alignment = 1 },124        .{ .kind = .debug_aranges, .alignment = 1 },125        .{ .kind = .debug_cu_index, .alignment = 1 },126        .{ .kind = .debug_frame, .alignment = 1 },127        .{ .kind = .debug_info, .alignment = 1 },128        .{ .kind = .debug_line, .alignment = 1 },129        .{ .kind = .debug_line_str, .alignment = 1 },130        .{ .kind = .debug_loc, .alignment = 1 },131        .{ .kind = .debug_loclists, .alignment = 1 },132        .{ .kind = .debug_macinfo, .alignment = 1 },133        .{ .kind = .debug_macro, .alignment = 1 },134        .{ .kind = .debug_names, .alignment = 1 },135        .{ .kind = .debug_pubnames, .alignment = 1 },136        .{ .kind = .debug_pubtypes, .alignment = 1 },137        .{ .kind = .debug_ranges, .alignment = 1 },138        .{ .kind = .debug_rnglists, .alignment = 1 },139        .{ .kind = .debug_str, .alignment = 1 },140        .{ .kind = .debug_str_offsets, .alignment = 1 },141        .{ .kind = .debug_tu_index, .alignment = 1 },142        .{ .kind = .debug_types, .alignment = 1 },143    };144145    var layouts = try scratch.alloc(ObjectLayout, objects.items.len);146    var layout_count: usize = 0;147    var section_contributions: []SectionContribution = &.{};148    defer {149        for (layouts[0..layout_count]) |*object_layout| object_layout.deinit(scratch);150        scratch.free(section_contributions);151        scratch.free(layouts);152    }153154    {155        const layout_phase = trace.product(.section_contribution_graph);156        defer layout_phase.end();157        const section_contribution_count = try layout.collect.countObjectSections(objects.items);158        section_contributions = try scratch.alloc(SectionContribution, section_contribution_count);159        try layout.collect.sections(scratch, objects.items, &output_sections, layouts, section_contributions, &layout_count, &globals, options);160        reserveBuildIdNote(&output_sections, options);161        try ehframe.reserveHeader(&output_sections, objects.items, layouts[0..layout_count], options);162    }163    var ifunc_collector: elf.ifunc.Collector = undefined;164    var got_layout: layout.GotLayout = undefined;165    var ifunc_layout: elf.ifunc.IfuncLayout = undefined;166    {167        const layout_phase = trace.product(.layout_groups);168        defer layout_phase.end();169        ifunc_collector = try elf.ifunc.Collector.init(scratch, objects.items, &globals, options.max_link_jobs);170        errdefer ifunc_collector.deinit(scratch);171        const collect_ifunc = ifunc_collector.enabled();172        got_layout = if (collect_ifunc)173            try got_table.collectEntriesWithIfunc(scratch, objects.items, &output_sections, &globals, &ifunc_collector)174        else175            try collectGotEntries(scratch, objects.items, &output_sections, &globals);176        errdefer got_layout.deinit(scratch);177        ifunc_layout = if (collect_ifunc)178            try ifunc_collector.finish(scratch, &output_sections)179        else180            elf.ifunc.IfuncLayout{};181        errdefer ifunc_layout.deinit(scratch);182    }183    defer ifunc_collector.deinit(scratch);184    defer got_layout.deinit(scratch);185    defer ifunc_layout.deinit(scratch);186187    const live_output_count = layout.output.countLive(&output_sections);188    if (live_output_count == 0) return error.NoAllocSections;189    const program_header_count = try countProgramHeaders(&output_sections);190191    {192        const layout_phase = trace.product(.address_assignment);193        defer layout_phase.end();194        try layout.output.assign(&output_sections, options, program_header_count);195    }196    {197        const manifest_phase = trace.product(.manifest_recording);198        defer manifest_phase.end();199        for (output_sections) |section| {200            if (section.logicalSize() == 0) continue;201            try manifest_builder.addSection(202                section.kind.name(),203                section.address,204                section.file_offset,205                section.logicalSize(),206                section.reserved_size,207                section.alignment,208            );209        }210        if (manifest_builder.recordsContributions()) {211            try addContributionRecords(&manifest_builder, objects.items, layouts[0..layout_count], &output_sections);212        }213    }214215    var symbol_addresses = try SymbolAddressCache.init(scratch, objects.items, layouts[0..layout_count], &output_sections);216    defer symbol_addresses.deinit(scratch);217218    try elf.ifunc.finalize(objects.items, layouts[0..layout_count], &output_sections, &globals, &symbol_addresses, ifunc_layout);219220    const entry_address = resolve_entry: {221        const symbol_phase = trace.product(.symbol_database);222        defer symbol_phase.end();223        break :resolve_entry try resolveEntry(objects.items, layouts, &output_sections, &globals, &symbol_addresses, options.entry_symbol);224    };225226    var linked_image = write_image: {227        const write_phase = trace.product(.output_writing);228        defer write_phase.end();229        break :write_image try image.write(230            scratch,231            allocator,232            objects.items,233            layouts,234            &output_sections,235            &globals,236            global_symbol_refs.items,237            &symbol_addresses,238            got_layout,239            options,240            entry_address,241            live_output_count,242            program_header_count,243        );244    };245    errdefer linked_image.deinit(allocator);246    const linked_bytes = linked_image.bytes;247248    try elf.ifunc.write(linked_bytes, &output_sections, ifunc_layout);249    {250        const materialize_phase = trace.product(.payload_materialization);251        defer materialize_phase.end();252        try relocation_namespace.materialize(scratch, objects.items, layouts, &output_sections, &globals, &symbol_addresses, got_layout, linked_bytes, options);253    }254    if (@import("builtin").mode == .debug) elf.payload.verifyMergePieceBytes(linked_bytes, objects.items, layouts, &output_sections);255    try finishBuildIdNote(linked_bytes, &output_sections, options);256257    var manifest = finish_manifest: {258        const manifest_phase = trace.product(.manifest_recording);259        defer manifest_phase.end();260        if (manifest_builder.recordsContributions()) {261            try addExternalTargetRecords(262                &manifest_builder,263                scratch,264                objects.items,265                layouts[0..layout_count],266                &output_sections,267                &globals,268                global_symbol_refs.items,269                &symbol_addresses,270            );271            try addGotEntryRecords(&manifest_builder, objects.items, &output_sections, &globals, got_layout);272            try addMergePieceRecords(&manifest_builder, objects.items, layouts[0..layout_count], &output_sections);273        }274        break :finish_manifest try manifest_builder.finish();275    };276    errdefer manifest.deinit(allocator);277278    return .{279        .bytes = linked_bytes,280        .storage = linked_image.storage,281        .manifest = manifest,282    };283}

1pub fn buildIdNoteRange(image: []const u8) model.Error!?MetadataRange {2    const note = linkedSectionByName(image, build_id_note.section_name) catch |err| switch (err) {3        error.MissingSection => return null,4        else => return err,5    };6    return .{7        .offset = std.math.cast(usize, note.offset) orelse return error.InvalidRange,8        .len = std.math.cast(usize, note.size) orelse return error.InvalidRange,9    };10}

1pub fn finishIncrementalMetadata(image: []u8, options: model.LinkOptions) model.Error!void {2    try finishGeneratedBuildIdNote(image, options.build_id);3}

1pub fn patchIncrementalMetadata(image: []u8, candidate_image: []const u8) model.Error!void {2    if (image.len != candidate_image.len) return error.InvalidRange;3    const image_metadata = try metadataLayout(image);4    const candidate_metadata = try metadataLayout(candidate_image);5    if (image_metadata.start != candidate_metadata.start) return error.InvalidElfHeader;6    if (image_metadata.section_header_offset != candidate_metadata.section_header_offset) return error.InvalidElfHeader;7    if (image_metadata.section_count != candidate_metadata.section_count) return error.InvalidElfHeader;8    if (image_metadata.string_section_index != candidate_metadata.string_section_index) return error.InvalidElfHeader;9    const start: usize = @intCast(image_metadata.start);10    @memcpy(image[start..], candidate_image[start..]);11    try patchGeneratedBuildIdNote(image, candidate_image);12}

1pub fn patchIncrementalMetadataRange(image: []const u8) model.Error!MetadataRange {2    const image_metadata = try metadataLayout(image);3    const start = std.math.cast(usize, image_metadata.start) orelse return error.InvalidRange;4    return .{ .offset = start, .len = image.len - start };5}

1const link = @import("link.zig");2const metadata = @import("metadata.zig");34pub const addressing = @import("address/root.zig");5pub const diagnostic = @import("diagnostic.zig");6pub const ehframe = @import("ehframe/root.zig");7pub const format = @import("format.zig");8pub const got_table = @import("got.zig");9pub const ifunc = @import("ifunc.zig");10pub const group = @import("group/root.zig");11pub const icf = @import("icf/root.zig");12pub const image = @import("image/root.zig");13pub const layout = @import("layout/root.zig");14pub const liveness = @import("liveness/root.zig");15pub const merge = @import("merge/root.zig");16pub const note = @import("note.zig");17pub const object = @import("object/root.zig");18pub const payload = @import("payload.zig");19pub const program = @import("program.zig");20pub const parser = @import("parser.zig");21pub const relink = @import("relink.zig");22pub const output_section = @import("section.zig");23pub const relocation = @import("relocation/root.zig");24pub const section_state = @import("sections.zig");25pub const string = @import("string.zig");26pub const symbol_table = @import("symbol.zig");27pub const view = @import("view.zig");2829pub const parseObjectMetadata = parser.parseObjectMetadata;30pub const linkExecutable = link.linkExecutable;31pub const patchIncrementalMetadata = metadata.patchIncrementalMetadata;32pub const finishIncrementalMetadata = metadata.finishIncrementalMetadata;33pub const buildIdNoteRange = metadata.buildIdNoteRange;34pub const patchIncrementalMetadataRange = metadata.patchIncrementalMetadataRange;

1pub const elf = @import("elf/root.zig");