tiny.tldr.formats.elf.addressing

1pub const Access = enum {2    serial,3    concurrent,4};

1pub const Cache = struct {2    pub const missing = std.math.maxInt(u64);34    entries: []u64,5    object_offsets: []usize,6    synthetic_boundaries: BoundaryMap,78    pub fn init(9        allocator: Allocator,10        objects: []const ObjectFile,11        layouts: []const ObjectLayout,12        output_sections: []const OutputSection,13    ) model.Error!Cache {14        const object_offsets = try allocator.alloc(usize, objects.len + 1);15        errdefer allocator.free(object_offsets);1617        var total_symbol_count: usize = 0;18        for (objects, 0..) |object, object_index| {19            object_offsets[object_index] = total_symbol_count;20            if (object.symbols.len > std.math.maxInt(usize) - total_symbol_count) {21                return error.InvalidObject;22            }23            total_symbol_count += object.symbols.len;24        }25        object_offsets[objects.len] = total_symbol_count;2627        const entries = try allocator.alloc(u64, total_symbol_count);28        errdefer allocator.free(entries);29        @memset(entries, missing);3031        var synthetic_boundaries: BoundaryMap = .{};32        errdefer synthetic_boundaries.deinit(allocator);33        try collectSyntheticBoundaryAddresses(allocator, objects, layouts, output_sections, &synthetic_boundaries);3435        return .{36            .entries = entries,37            .object_offsets = object_offsets,38            .synthetic_boundaries = synthetic_boundaries,39        };40    }4142    pub fn deinit(self: *Cache, allocator: Allocator) void {43        allocator.free(self.entries);44        allocator.free(self.object_offsets);45        self.synthetic_boundaries.deinit(allocator);46        self.* = undefined;47    }4849    pub fn slot(self: *Cache, object_index: usize, symbol_index: usize) *u64 {50        return &self.entries[self.object_offsets[object_index] + symbol_index];51    }5253    pub fn syntheticBoundaryAddress(self: *const Cache, search_boundary: Boundary) ?u64 {54        return self.synthetic_boundaries.get(search_boundary);55    }56};

1pub fn load(access: Access, slot: *const u64) u64 {2    return switch (access) {3        .serial => slot.*,4        .concurrent => @atomicLoad(u64, slot, .monotonic),5    };6}

1pub fn store(access: Access, slot: *u64, address: u64) model.Error!u64 {2    if (address == Cache.missing) return error.InvalidRange;3    switch (access) {4        .serial => slot.* = address,5        .concurrent => @atomicStore(u64, slot, address, .monotonic),6    }7    return address;8}

1pub const boundary = @import("boundary.zig");2pub const contribution_module = @import("contribution.zig");3pub const size = @import("size.zig");4pub const symbol = @import("symbol.zig");5pub const target = @import("target.zig");6pub const tls = @import("tls.zig");78const cache_module = @import("cache.zig");910pub const Access = cache_module.Access;11pub const Boundary = boundary.Boundary;12pub const Cache = cache_module.Cache;13pub const Target = target.Target;14pub const boundaryForSymbol = boundary.forSymbol;15pub const boundarySectionNameMatches = boundary.sectionNameMatches;16pub const contribution = contribution_module.symbol;17pub const relocationAddress = symbol.relocation;18pub const relocationTarget = target.relocation;19pub const symbolAddress = symbol.address;20pub const symbolIsTls = tls.isSymbol;21pub const symbolIsUnresolvedWeak = symbol.isUnresolvedWeak;22pub const symbolSize = size.symbol;23pub const tlsOffset = tls.offset;24pub const load = cache_module.load;25pub const store = cache_module.store;

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