srctree

atoms_extra: std.ArrayListUnmanaged(u32) = .{},

/// List of output merge sections with deduped contents.

merge_sections: std.ArrayListUnmanaged(MergeSection) = .{},

/// List of output merge subsections.

/// Each subsection is akin to Atom but belongs to a MergeSection.

merge_subsections: std.ArrayListUnmanaged(MergeSubsection) = .{},

/// List of input merge sections as parsed from input relocatables.

merge_input_sections: std.ArrayListUnmanaged(InputMergeSection) = .{},

 

try self.atoms_extra.append(gpa, 0);

// Append null input merge section.

try self.merge_input_sections.append(gpa, .{});

self.atoms_extra.deinit(gpa);

for (self.thunks.items) |*th| {

th.deinit(gpa);

}

for (self.merge_sections.items) |*sect| {

sect.deinit(gpa);

}

self.merge_sections.deinit(gpa);

self.merge_subsections.deinit(gpa);

for (self.merge_input_sections.items) |*sect| {

sect.deinit(gpa);

}

self.merge_input_sections.deinit(gpa);

try self.resolveMergeSections();

try self.addCommentString();

try self.finalizeMergeSections();

try self.initMergeSections();

try self.updateMergeSectionSizes();

const file_offset = shdr.sh_offset + @as(u64, @intCast(atom_ptr.value));

try self.writeMergeSections();

const e_entry = if (self.entry_index) |entry_index|

@as(u64, @intCast(self.symbol(entry_index).address(.{}, self)))

else

0;

symbol_ptr.value = @intCast(shdr.sh_addr);

symbol_ptr.value = @intCast(self.image_base);

start_sym.value = @intCast(shdr.sh_addr);

end_sym.value = @intCast(shdr.sh_addr + shdr.sh_size);

start_sym.value = @intCast(shdr.sh_addr);

end_sym.value = @intCast(shdr.sh_addr + shdr.sh_size);

start_sym.value = @intCast(shdr.sh_addr);

end_sym.value = @intCast(shdr.sh_addr + shdr.sh_size);

sym.value = @intCast(shdr.sh_addr);

sym.value = @intCast(shdr.sh_addr);

symbol_ptr.value = @intCast(shdr.sh_addr);

symbol_ptr.value = @intCast(shdr.sh_addr);

symbol_ptr.value = @intCast(shdr.sh_addr);

start_sym.value = @intCast(start_addr);

end_sym.value = @intCast(end_addr);

end_symbol.value = @intCast(shdr.sh_addr + shdr.sh_size);

start.value = @intCast(shdr.sh_addr);

stop.value = @intCast(shdr.sh_addr + shdr.sh_size);

sym.value = @intCast(shdr.sh_addr + 0x800);

pub fn addCommentString(self: *Elf) !void {

const msec_index = try self.getOrCreateMergeSection(".comment", elf.SHF_MERGE | elf.SHF_STRINGS, elf.SHT_PROGBITS);

const msec = self.mergeSection(msec_index);

const res = try msec.insertZ(self.base.comp.gpa, "zig " ++ builtin.zig_version_string);

if (res.found_existing) return;

const msub_index = try self.addMergeSubsection();

const msub = self.mergeSubsection(msub_index);

msub.merge_section_index = msec_index;

msub.string_index = res.key.pos;

msub.alignment = .@"1";

msub.size = res.key.len;

msub.entsize = 1;

msub.alive = true;

res.sub.* = msub_index;

}

 

pub fn resolveMergeSections(self: *Elf) !void {

const tracy = trace(@src());

defer tracy.end();

 

var has_errors = false;

for (self.objects.items) |index| {

const file_ptr = self.file(index).?;

if (!file_ptr.isAlive()) continue;

file_ptr.object.initMergeSections(self) catch |err| switch (err) {

error.MalformedObject => has_errors = true,

else => |e| return e,

};

}

 

if (has_errors) return error.FlushFailure;

 

for (self.objects.items) |index| {

const file_ptr = self.file(index).?;

if (!file_ptr.isAlive()) continue;

file_ptr.object.resolveMergeSubsections(self) catch |err| switch (err) {

error.MalformedObject => has_errors = true,

else => |e| return e,

};

}

 

if (has_errors) return error.FlushFailure;

}

 

pub fn finalizeMergeSections(self: *Elf) !void {

for (self.merge_sections.items) |*msec| {

try msec.finalize(self);

}

}

 

pub fn updateMergeSectionSizes(self: *Elf) !void {

for (self.merge_sections.items) |*msec| {

const shdr = &self.shdrs.items[msec.output_section_index];

for (msec.subsections.items) |msub_index| {

const msub = self.mergeSubsection(msub_index);

assert(msub.alive);

const offset = msub.alignment.forward(shdr.sh_size);

const padding = offset - shdr.sh_size;

msub.value = @intCast(offset);

shdr.sh_size += padding + msub.size;

shdr.sh_addralign = @max(shdr.sh_addralign, msub.alignment.toByteUnits() orelse 1);

}

}

}

 

pub fn writeMergeSections(self: *Elf) !void {

const gpa = self.base.comp.gpa;

var buffer = std.ArrayList(u8).init(gpa);

defer buffer.deinit();

 

for (self.merge_sections.items) |msec| {

const shdr = self.shdrs.items[msec.output_section_index];

const size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;

try buffer.ensureTotalCapacity(size);

buffer.appendNTimesAssumeCapacity(0, size);

 

for (msec.subsections.items) |msub_index| {

const msub = self.mergeSubsection(msub_index);

assert(msub.alive);

const string = msub.getString(self);

const off = math.cast(usize, msub.value) orelse return error.Overflow;

@memcpy(buffer.items[off..][0..string.len], string);

}

 

try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);

buffer.clearRetainingCapacity();

}

}

 

pub fn initMergeSections(self: *Elf) !void {

for (self.merge_sections.items) |*msec| {

if (msec.subsections.items.len == 0) continue;

const name = msec.name(self);

const shndx = self.sectionByName(name) orelse try self.addSection(.{

.name = name,

.type = msec.type,

.flags = msec.flags,

});

msec.output_section_index = shndx;

 

var entsize = self.mergeSubsection(msec.subsections.items[0]).entsize;

for (msec.subsections.items) |index| {

const msub = self.mergeSubsection(index);

entsize = @min(entsize, msub.entsize);

}

const shdr = &self.shdrs.items[shndx];

shdr.sh_entsize = entsize;

}

}

 

for (self.merge_sections.items) |*msec| {

msec.output_section_index = backlinks[msec.output_section_index];

}

 

atom_ptr.value = @intCast(offset);

const offset = math.cast(usize, atom_ptr.value - @as(i64, @intCast(base_offset))) orelse

const offset = @as(u64, @intCast(th.value)) + shdr.sh_offset;

nlocals += @intCast(self.merge_sections.items.len);

 

for (self.merge_sections.items) |msec| {

const shdr = self.shdrs.items[msec.output_section_index];

const out_sym = &self.symtab.items[ilocal];

out_sym.* = .{

.st_name = 0,

.st_value = shdr.sh_addr,

.st_info = elf.STT_SECTION,

.st_shndx = @intCast(msec.output_section_index),

.st_size = 0,

.st_other = 0,

};

ilocal += 1;

}

const base: usize = if (self.eh_frame_section_index == null) 0 else 1;

for (self.merge_sections.items, 0..) |msec, index| {

if (msec.output_section_index == shndx) return @intCast(self.output_sections.keys().len + 1 + index + base);

}

pub fn addAtomExtra(self: *Elf, extra: Atom.Extra) !u32 {

const fields = @typeInfo(Atom.Extra).Struct.fields;

try self.atoms_extra.ensureUnusedCapacity(self.base.comp.gpa, fields.len);

return self.addAtomExtraAssumeCapacity(extra);

}

 

pub fn addAtomExtraAssumeCapacity(self: *Elf, extra: Atom.Extra) u32 {

const index = @as(u32, @intCast(self.atoms_extra.items.len));

const fields = @typeInfo(Atom.Extra).Struct.fields;

inline for (fields) |field| {

self.atoms_extra.appendAssumeCapacity(switch (field.type) {

u32 => @field(extra, field.name),

else => @compileError("bad field type"),

});

}

return index;

}

 

pub fn atomExtra(self: *Elf, index: u32) ?Atom.Extra {

if (index == 0) return null;

const fields = @typeInfo(Atom.Extra).Struct.fields;

var i: usize = index;

var result: Atom.Extra = undefined;

inline for (fields) |field| {

@field(result, field.name) = switch (field.type) {

u32 => self.atoms_extra.items[i],

else => @compileError("bad field type"),

};

i += 1;

}

return result;

}

 

pub fn setAtomExtra(self: *Elf, index: u32, extra: Atom.Extra) void {

assert(index > 0);

const fields = @typeInfo(Atom.Extra).Struct.fields;

inline for (fields, 0..) |field, i| {

self.atoms_extra.items[index + i] = switch (field.type) {

u32 => @field(extra, field.name),

else => @compileError("bad field type"),

};

}

}

 

pub fn addInputMergeSection(self: *Elf) !InputMergeSection.Index {

const index: InputMergeSection.Index = @intCast(self.merge_input_sections.items.len);

const msec = try self.merge_input_sections.addOne(self.base.comp.gpa);

msec.* = .{};

return index;

}

 

pub fn inputMergeSection(self: *Elf, index: InputMergeSection.Index) ?*InputMergeSection {

if (index == 0) return null;

return &self.merge_input_sections.items[index];

}

 

pub fn addMergeSubsection(self: *Elf) !MergeSubsection.Index {

const index: MergeSubsection.Index = @intCast(self.merge_subsections.items.len);

const msec = try self.merge_subsections.addOne(self.base.comp.gpa);

msec.* = .{};

return index;

}

 

pub fn mergeSubsection(self: *Elf, index: MergeSubsection.Index) *MergeSubsection {

assert(index < self.merge_subsections.items.len);

return &self.merge_subsections.items[index];

}

 

pub fn getOrCreateMergeSection(self: *Elf, name: []const u8, flags: u64, @"type": u32) !MergeSection.Index {

const gpa = self.base.comp.gpa;

const out_name = name: {

if (self.base.isRelocatable()) break :name name;

if (mem.eql(u8, name, ".rodata") or mem.startsWith(u8, name, ".rodata"))

break :name if (flags & elf.SHF_STRINGS != 0) ".rodata.str" else ".rodata.cst";

break :name name;

};

const out_off = try self.strings.insert(gpa, out_name);

const out_flags = flags & ~@as(u64, elf.SHF_COMPRESSED | elf.SHF_GROUP);

for (self.merge_sections.items, 0..) |msec, index| {

if (msec.name_offset == out_off) return @intCast(index);

}

const index = @as(MergeSection.Index, @intCast(self.merge_sections.items.len));

const msec = try self.merge_sections.addOne(gpa);

msec.* = .{

.name_offset = out_off,

.flags = out_flags,

.type = @"type",

};

return index;

}

 

pub fn mergeSection(self: *Elf, index: MergeSection.Index) *MergeSection {

assert(index < self.merge_sections.items.len);

return &self.merge_sections.items[index];

}

 

pub fn gotAddress(self: *Elf) i64 {

return if (shndx) |index| @intCast(self.shdrs.items[index].sh_addr) else 0;

pub fn tpAddress(self: *Elf) i64 {

const addr = switch (self.getTarget().cpu.arch) {

return @intCast(addr);

pub fn dtpAddress(self: *Elf) i64 {

return @intCast(phdr.p_vaddr);

pub fn tlsAddress(self: *Elf) i64 {

return @intCast(phdr.p_vaddr);

try writer.writeAll("\nOutput merge sections\n");

for (self.merge_sections.items) |msec| {

try writer.print(" shdr({d}) : {}\n", .{ msec.output_section_index, msec.fmt(self) });

}

 

const merge_section = @import("Elf/merge_section.zig");

const InputMergeSection = merge_section.InputMergeSection;

const MergeSection = merge_section.MergeSection;

const MergeSubsection = merge_section.MergeSubsection;

value: i64 = 0,

/// Flags we use for state tracking.

flags: Flags = .{},

 

extra_index: u32 = 0,

 

pub fn address(self: Atom, elf_file: *Elf) i64 {

return @as(i64, @intCast(shdr.sh_addr)) + self.value;

}

 

pub fn debugTombstoneValue(self: Atom, target: Symbol, elf_file: *Elf) ?u64 {

if (target.mergeSubsection(elf_file)) |msub| {

if (msub.alive) return null;

}

if (target.atom(elf_file)) |atom_ptr| {

if (atom_ptr.flags.alive) return null;

}

const atom_name = self.name(elf_file);

if (!mem.startsWith(u8, atom_name, ".debug")) return null;

return if (mem.eql(u8, atom_name, ".debug_loc") or mem.eql(u8, atom_name, ".debug_ranges")) 1 else 0;

assert(self.flags.thunk);

const extras = self.extra(elf_file).?;

return elf_file.thunk(extras.thunk);

return @intCast(next_addr - self.address(elf_file));

const cap: u64 = @intCast(next.address(elf_file) - self.address(elf_file));

const ideal_capacity_end_vaddr = std.math.add(u64, @intCast(big_atom.value), ideal_capacity) catch ideal_capacity;

const capacity_end_vaddr = @as(u64, @intCast(big_atom.value)) + cap;

break :blk @intCast(new_start_vaddr);

const ideal_capacity_end_vaddr = @as(u64, @intCast(last.value)) + ideal_capacity;

break :blk @intCast(new_start_vaddr);

self.address(elf_file) + @as(i64, @intCast(self.size)),

const needed_size: u64 = @intCast(self.value + @as(i64, @intCast(self.size)));

if (!self.alignment.check(@intCast(self.value)) or self.size > self.capacity(elf_file))

switch (self.file(elf_file).?) {

.zig_object => |x| return x.relocs.items[shndx].items,

.object => |x| {

const extras = self.extra(elf_file).?;

return x.relocs.items[extras.rel_index..][0..extras.rel_count];

},

}

const r_offset: u64 = @intCast(self.value + @as(i64, @intCast(rel.r_offset)));

elf.STT_SECTION => if (target.mergeSubsection(elf_file)) |msub| {

r_addend += @intCast(target.address(.{}, elf_file));

r_sym = elf_file.sectionSymbolOutputSymtabIndex(msub.mergeSection(elf_file).output_section_index);

} else {

if (!self.flags.fde) return &[0]Fde{};

const extras = self.extra(elf_file).?;

return object.fdes.items[extras.fde_start..][0..extras.fde_count];

const is_synthetic_symbol = switch (file_ptr) {

.zig_object => false, // TODO: implement this once we support merge sections in ZigObject

.object => |x| rel.r_sym() >= x.symtab.items.len,

else => unreachable,

};

 

if (!is_synthetic_symbol and (try self.reportUndefined(elf_file, symbol, symbol_index, rel, undefs)))

continue;

const P = self.address(elf_file) + @as(i64, @intCast(rel.r_offset));

const S = target.address(.{}, elf_file);

const GOT = elf_file.gotAddress();

const ZIG_GOT = target.zigGotAddress(elf_file);

const G = target.gotAddress(elf_file) - GOT;

const TP = elf_file.tpAddress();

const DTP = elf_file.dtpAddress();

const P: u64 = @intCast(self.address(elf_file) + @as(i64, @intCast(rel.r_offset)));

const S = target.address(.{}, elf_file);

const S_ = target.address(.{ .plt = false }, elf_file);

const is_synthetic_symbol = switch (file_ptr) {

.zig_object => false, // TODO: implement this once we support merge sections in ZigObject

.object => |x| rel.r_sym() >= x.symtab.items.len,

else => unreachable,

};

if (!is_synthetic_symbol and (try self.reportUndefined(elf_file, target, target_index, rel, undefs)))

continue;

const P = self.address(elf_file) + @as(i64, @intCast(rel.r_offset));

const S = target.address(.{}, elf_file);

const GOT = elf_file.gotAddress();

const DTP = elf_file.dtpAddress();

const AddExtraOpts = struct {

thunk: ?u32 = null,

fde_start: ?u32 = null,

fde_count: ?u32 = null,

rel_index: ?u32 = null,

rel_count: ?u32 = null,

};

 

pub fn addExtra(atom: *Atom, opts: AddExtraOpts, elf_file: *Elf) !void {

if (atom.extra(elf_file) == null) {

atom.extra_index = try elf_file.addAtomExtra(.{});

}

var extras = atom.extra(elf_file).?;

inline for (@typeInfo(@TypeOf(opts)).Struct.fields) |field| {

if (@field(opts, field.name)) |x| {

@field(extras, field.name) = x;

}

}

atom.setExtra(extras, elf_file);

}

 

pub inline fn extra(atom: Atom, elf_file: *Elf) ?Extra {

return elf_file.atomExtra(atom.extra_index);

}

 

pub inline fn setExtra(atom: Atom, extras: Extra, elf_file: *Elf) void {

elf_file.setAtomExtra(atom.extra_index, extras);

}

 

if (atom.flags.fde) {

const extras = atom.extra(elf_file).?;

for (atom.fdes(elf_file), extras.fde_start..) |fde, i| {

if (i - extras.fde_start < extras.fde_count - 1) try writer.writeAll(", ");

 

/// Whether this atom has a range extension thunk.

thunk: bool = false,

 

/// Whether this atom has FDE records.

fde: bool = false,

const S_ = target.tlsGdAddress(elf_file);

const S_ = target.gotTpAddress(elf_file);

const S_ = tlsld_entry.address(elf_file);

@as(i32, @intCast(TP - elf_file.tlsAddress())),

const S_ = target.tlsDescAddress(elf_file);

const S_ = target.gotTpAddress(elf_file);

.@"64" => if (atom.debugTombstoneValue(target.*, elf_file)) |value|

try cwriter.writeInt(u64, value, .little)

else

try cwriter.writeInt(i64, S + A, .little),

.DTPOFF32 => if (atom.debugTombstoneValue(target.*, elf_file)) |value|

try cwriter.writeInt(u64, value, .little)

else

try cwriter.writeInt(i32, @as(i32, @intCast(S + A - DTP)), .little),

.DTPOFF64 => if (atom.debugTombstoneValue(target.*, elf_file)) |value|

try cwriter.writeInt(u64, value, .little)

else

try cwriter.writeInt(i64, S + A - DTP, .little),

const S_ = th.targetAddress(target_index, elf_file);

const pages = @as(u21, @bitCast(try aarch64_util.calcNumberOfPages(P, S + A)));

const pages = @as(u21, @bitCast(try aarch64_util.calcNumberOfPages(P, G + GOT + A)));

const S_ = target.gotTpAddress(elf_file);

relocs_log.debug(" [{x} => {x}]", .{ P, S_ + A });

const pages: u21 = @bitCast(try aarch64_util.calcNumberOfPages(P, S_ + A));

const S_ = target.gotTpAddress(elf_file);

relocs_log.debug(" [{x} => {x}]", .{ P, S_ + A });

const offset: u12 = try math.divExact(u12, @truncate(@as(u64, @bitCast(S_ + A))), 8);

const S_ = target.tlsGdAddress(elf_file);

relocs_log.debug(" [{x} => {x}]", .{ P, S_ + A });

const pages: u21 = @bitCast(try aarch64_util.calcNumberOfPages(P, S_ + A));

const S_ = target.tlsGdAddress(elf_file);

relocs_log.debug(" [{x} => {x}]", .{ P, S_ + A });

const offset: u12 = @truncate(@as(u64, @bitCast(S_ + A)));

const S_ = target.tlsDescAddress(elf_file);

relocs_log.debug(" [{x} => {x}]", .{ P, S_ + A });

const pages: u21 = @bitCast(try aarch64_util.calcNumberOfPages(P, S_ + A));

const S_ = target.tlsDescAddress(elf_file);

relocs_log.debug(" [{x} => {x}]", .{ P, S_ + A });

const offset: u12 = try math.divExact(u12, @truncate(@as(u64, @bitCast(S_ + A))), 8);

const S_ = target.tlsDescAddress(elf_file);

relocs_log.debug(" [{x} => {x}]", .{ P, S_ + A });

const offset: u12 = @truncate(@as(u64, @bitCast(S_ + A)));

.ABS64 => if (atom.debugTombstoneValue(target.*, elf_file)) |value|

try cwriter.writeInt(u64, value, .little)

else

try cwriter.writeInt(i64, S + A, .little),

if (S == atom_addr + @as(i64, @intCast(pair.r_offset))) break pair;

const S_ = target_.address(.{}, elf_file);

const P_ = atom_addr + @as(i64, @intCast(pair.r_offset));

const G_ = target_.gotAddress(elf_file) - GOT;

.@"64" => if (atom.debugTombstoneValue(target.*, elf_file)) |value|

try cwriter.writeInt(u64, value, .little)

else

try cwriter.writeInt(i64, S + A, .little),

pub const Extra = struct {

/// Index of the range extension thunk of this atom.

thunk: u32 = 0,

 

/// Start index of FDEs referencing this atom.

fde_start: u32 = 0,

 

/// Count of FDEs referencing this atom.

fde_count: u32 = 0,

 

/// Start index of relocations belonging to this atom.

rel_index: u32 = 0,

 

/// Count of relocations belonging to this atom.

rel_count: u32 = 0,

};

 

try global.addExtra(.{ .symtab = self.output_symtab_ctx.nlocals }, elf_file);

try global.addExtra(.{ .symtab = self.output_symtab_ctx.nglobals }, elf_file);

merge_sections: std.ArrayListUnmanaged(InputMergeSection.Index) = .{},

 

self.merge_sections.deinit(allocator);

const rel_index: u32 = @intCast(self.relocs.items.len);

const rel_count: u32 = @intCast(relocs.len);

try atom.addExtra(.{ .rel_index = rel_index, .rel_count = rel_count }, elf_file);

sortRelocs(self.relocs.items[rel_index..][0..rel_count]);

if (shdr.sh_flags & elf.SHF_MERGE != 0) break :blk name;

sym_ptr.value = @intCast(sym.st_value);

const start = i;

try atom.addExtra(.{ .fde_start = start, .fde_count = i - start }, elf_file);

atom.flags.fde = true;

global.value = @intCast(esym.st_value);

pub fn initMergeSections(self: *Object, elf_file: *Elf) !void {

const gpa = elf_file.base.comp.gpa;

 

try self.merge_sections.resize(gpa, self.shdrs.items.len);

@memset(self.merge_sections.items, 0);

 

for (self.shdrs.items, 0..) |shdr, shndx| {

if (shdr.sh_flags & elf.SHF_MERGE == 0) continue;

 

const atom_index = self.atoms.items[shndx];

const atom_ptr = elf_file.atom(atom_index) orelse continue;

if (!atom_ptr.flags.alive) continue;

if (atom_ptr.relocs(elf_file).len > 0) continue;

 

const imsec_idx = try elf_file.addInputMergeSection();

const imsec = elf_file.inputMergeSection(imsec_idx).?;

self.merge_sections.items[shndx] = imsec_idx;

 

imsec.merge_section_index = try elf_file.getOrCreateMergeSection(atom_ptr.name(elf_file), shdr.sh_flags, shdr.sh_type);

imsec.atom_index = atom_index;

 

const data = try self.codeDecompressAlloc(elf_file, atom_index);

defer gpa.free(data);

 

if (shdr.sh_flags & elf.SHF_STRINGS != 0) {

const sh_entsize: u32 = switch (shdr.sh_entsize) {

// According to mold's source code, GHC emits MS sections with sh_entsize = 0.

// This actually can also happen for output created with `-r` mode.

0 => 1,

else => |x| @intCast(x),

};

 

const isNull = struct {

fn isNull(slice: []u8) bool {

for (slice) |x| if (x != 0) return false;

return true;

}

}.isNull;

 

var start: u32 = 0;

while (start < data.len) {

var end = start;

while (end < data.len - sh_entsize and !isNull(data[end .. end + sh_entsize])) : (end += sh_entsize) {}

if (!isNull(data[end .. end + sh_entsize])) {

var err = try elf_file.addErrorWithNotes(1);

try err.addMsg(elf_file, "string not null terminated", .{});

try err.addNote(elf_file, "in {}:{s}", .{ self.fmtPath(), atom_ptr.name(elf_file) });

return error.MalformedObject;

}

end += sh_entsize;

const string = data[start..end];

try imsec.insert(gpa, string);

try imsec.offsets.append(gpa, start);

start = end;

}

} else {

const sh_entsize: u32 = @intCast(shdr.sh_entsize);

if (sh_entsize == 0) continue; // Malformed, don't split but don't error out

if (shdr.sh_size % sh_entsize != 0) {

var err = try elf_file.addErrorWithNotes(1);

try err.addMsg(elf_file, "size not a multiple of sh_entsize", .{});

try err.addNote(elf_file, "in {}:{s}", .{ self.fmtPath(), atom_ptr.name(elf_file) });

return error.MalformedObject;

}

 

var pos: u32 = 0;

while (pos < data.len) : (pos += sh_entsize) {

const string = data.ptr[pos..][0..sh_entsize];

try imsec.insert(gpa, string);

try imsec.offsets.append(gpa, pos);

}

}

 

atom_ptr.flags.alive = false;

}

}

 

pub fn resolveMergeSubsections(self: *Object, elf_file: *Elf) !void {

const gpa = elf_file.base.comp.gpa;

 

for (self.merge_sections.items) |index| {

const imsec = elf_file.inputMergeSection(index) orelse continue;

if (imsec.offsets.items.len == 0) continue;

const msec = elf_file.mergeSection(imsec.merge_section_index);

const atom_ptr = elf_file.atom(imsec.atom_index).?;

const isec = atom_ptr.inputShdr(elf_file);

 

try imsec.subsections.resize(gpa, imsec.strings.items.len);

 

for (imsec.strings.items, imsec.subsections.items) |str, *imsec_msub| {

const string = imsec.bytes.items[str.pos..][0..str.len];

const res = try msec.insert(gpa, string);

if (!res.found_existing) {

const msub_index = try elf_file.addMergeSubsection();

const msub = elf_file.mergeSubsection(msub_index);

msub.merge_section_index = imsec.merge_section_index;

msub.string_index = res.key.pos;

msub.alignment = atom_ptr.alignment;

msub.size = res.key.len;

msub.entsize = math.cast(u32, isec.sh_entsize) orelse return error.Overflow;

msub.alive = !elf_file.base.gc_sections or isec.sh_flags & elf.SHF_ALLOC == 0;

res.sub.* = msub_index;

}

imsec_msub.* = res.sub.*;

}

 

imsec.clearAndFree(gpa);

}

 

for (self.symtab.items, 0..) |*esym, idx| {

const sym_index = self.symbols.items[idx];

const sym = elf_file.symbol(sym_index);

 

if (esym.st_shndx == elf.SHN_COMMON or esym.st_shndx == elf.SHN_UNDEF or esym.st_shndx == elf.SHN_ABS) continue;

 

const imsec_index = self.merge_sections.items[esym.st_shndx];

const imsec = elf_file.inputMergeSection(imsec_index) orelse continue;

if (imsec.offsets.items.len == 0) continue;

const msub_index, const offset = imsec.findSubsection(@intCast(esym.st_value)) orelse {

var err = try elf_file.addErrorWithNotes(2);

try err.addMsg(elf_file, "invalid symbol value: {x}", .{esym.st_value});

try err.addNote(elf_file, "for symbol {s}", .{sym.name(elf_file)});

try err.addNote(elf_file, "in {}", .{self.fmtPath()});

return error.MalformedObject;

};

 

try sym.addExtra(.{ .subsection = msub_index }, elf_file);

sym.flags.merge_subsection = true;

sym.value = offset;

}

 

for (self.atoms.items) |atom_index| {

const atom_ptr = elf_file.atom(atom_index) orelse continue;

if (!atom_ptr.flags.alive) continue;

const extras = atom_ptr.extra(elf_file) orelse continue;

const relocs = self.relocs.items[extras.rel_index..][0..extras.rel_count];

for (relocs) |*rel| {

const esym = self.symtab.items[rel.r_sym()];

if (esym.st_type() != elf.STT_SECTION) continue;

 

const imsec_index = self.merge_sections.items[esym.st_shndx];

const imsec = elf_file.inputMergeSection(imsec_index) orelse continue;

if (imsec.offsets.items.len == 0) continue;

const msub_index, const offset = imsec.findSubsection(@intCast(@as(i64, @intCast(esym.st_value)) + rel.r_addend)) orelse {

var err = try elf_file.addErrorWithNotes(1);

try err.addMsg(elf_file, "invalid relocation at offset 0x{x}", .{rel.r_offset});

try err.addNote(elf_file, "in {}:{s}", .{ self.fmtPath(), atom_ptr.name(elf_file) });

return error.MalformedObject;

};

const msub = elf_file.mergeSubsection(msub_index);

const msec = msub.mergeSection(elf_file);

 

const out_sym_idx: u64 = @intCast(self.symbols.items.len);

try self.symbols.ensureUnusedCapacity(gpa, 1);

const name = try std.fmt.allocPrint(gpa, "{s}$subsection{d}", .{ msec.name(elf_file), msub_index });

defer gpa.free(name);

const sym_index = try elf_file.addSymbol();

const sym = elf_file.symbol(sym_index);

sym.* = .{

.value = @bitCast(@as(i64, @intCast(offset)) - rel.r_addend),

.name_offset = try self.addString(gpa, name),

.esym_index = rel.r_sym(),

.file_index = self.index,

};

try sym.addExtra(.{ .subsection = msub_index }, elf_file);

sym.flags.merge_subsection = true;

self.symbols.addOneAssumeCapacity().* = sym_index;

rel.r_info = (out_sym_idx << 32) | rel.r_type();

}

}

}

 

if (local.mergeSubsection(elf_file)) |msub| {

if (!msub.alive) continue;

local.output_section_index = msub.mergeSection(elf_file).output_section_index;

continue;

}

if (global.file(elf_file).?.index() != self.index) continue;

if (global.mergeSubsection(elf_file)) |msub| {

if (!msub.alive) continue;

global.output_section_index = msub.mergeSection(elf_file).output_section_index;

continue;

}

 

for (self.symbols.items[self.symtab.items.len..]) |local_index| {

const local = elf_file.symbol(local_index);

const msub = local.mergeSubsection(elf_file).?;

if (!msub.alive) continue;

local.output_section_index = msub.mergeSection(elf_file).output_section_index;

}

const isAlive = struct {

fn isAlive(sym: *const Symbol, ctx: *Elf) bool {

if (sym.mergeSubsection(ctx)) |msub| return msub.alive;

if (sym.atom(ctx)) |atom_ptr| return atom_ptr.flags.alive;

return true;

}

}.isAlive;

 

if (!isAlive(local, elf_file)) continue;

try local.addExtra(.{ .symtab = self.output_symtab_ctx.nlocals }, elf_file);

if (!isAlive(global, elf_file)) continue;

try global.addExtra(.{ .symtab = self.output_symtab_ctx.nlocals }, elf_file);

try global.addExtra(.{ .symtab = self.output_symtab_ctx.nglobals }, elf_file);

assert(self.symbols.items.len >= self.symtab.items.len);

const end = self.first_global orelse self.symtab.items.len;

assert(self.symbols.items.len >= self.symtab.items.len);

const start = self.first_global orelse self.symtab.items.len;

return self.symbols.items[start..self.symtab.items.len];

fn addString(self: *Object, allocator: Allocator, str: []const u8) !u32 {

const off: u32 = @intCast(self.strtab.items.len);

try self.strtab.ensureUnusedCapacity(allocator, str.len + 1);

self.strtab.appendSliceAssumeCapacity(str);

self.strtab.appendAssumeCapacity(0);

return off;

}

 

const InputMergeSection = @import("merge_section.zig").InputMergeSection;

global.value = @intCast(this_sym.st_value);

try global.addExtra(.{ .symtab = self.output_symtab_ctx.nglobals }, elf_file);

value: i64 = 0,

/// Assigned output section index for this symbol.

return !symbol.flags.import and symbol.atom(elf_file) == null and

symbol.mergeSubsection(elf_file) == null and symbol.outputShndx() == null and

pub fn mergeSubsection(symbol: Symbol, elf_file: *Elf) ?*MergeSubsection {

if (!symbol.flags.merge_subsection) return null;

const extras = symbol.extra(elf_file).?;

return elf_file.mergeSubsection(extras.subsection);

}

 

pub fn address(symbol: Symbol, opts: struct { plt: bool = true }, elf_file: *Elf) i64 {

if (symbol.mergeSubsection(elf_file)) |msub| {

if (!msub.alive) return 0;

return msub.address(elf_file) + symbol.value;

}

const sh_addr, const sh_size = blk: {

const shndx = elf_file.eh_frame_section_index orelse break :blk .{ 0, 0 };

const shdr = elf_file.shdrs.items[shndx];

break :blk .{ shdr.sh_addr, shdr.sh_size };

};

return @intCast(sh_addr);

return @intCast(sh_addr + sh_size);

pub fn gotAddress(symbol: Symbol, elf_file: *Elf) i64 {

pub fn pltGotAddress(symbol: Symbol, elf_file: *Elf) i64 {

return @intCast(shdr.sh_addr + extras.plt_got * PltGotSection.entrySize(cpu_arch));

pub fn pltAddress(symbol: Symbol, elf_file: *Elf) i64 {

return @intCast(shdr.sh_addr + extras.plt * PltSection.entrySize(cpu_arch) + PltSection.preambleSize(cpu_arch));

pub fn gotPltAddress(symbol: Symbol, elf_file: *Elf) i64 {

return @intCast(shdr.sh_addr + extras.plt * 8 + GotPltSection.preamble_size);

pub fn copyRelAddress(symbol: Symbol, elf_file: *Elf) i64 {

return @as(i64, @intCast(shdr.sh_addr)) + symbol.value;

pub fn tlsGdAddress(symbol: Symbol, elf_file: *Elf) i64 {

pub fn gotTpAddress(symbol: Symbol, elf_file: *Elf) i64 {

pub fn tlsDescAddress(symbol: Symbol, elf_file: *Elf) i64 {

pub fn zigGotAddress(symbol: Symbol, elf_file: *Elf) i64 {

const AddExtraOpts = struct {

got: ?u32 = null,

plt: ?u32 = null,

plt_got: ?u32 = null,

dynamic: ?u32 = null,

symtab: ?u32 = null,

copy_rel: ?u32 = null,

tlsgd: ?u32 = null,

gottp: ?u32 = null,

tlsdesc: ?u32 = null,

zig_got: ?u32 = null,

subsection: ?u32 = null,

};

 

pub fn addExtra(symbol: *Symbol, opts: AddExtraOpts, elf_file: *Elf) !void {

if (symbol.extra(elf_file) == null) {

symbol.extra_index = try elf_file.addSymbolExtra(.{});

}

var extras = symbol.extra(elf_file).?;

inline for (@typeInfo(@TypeOf(opts)).Struct.fields) |field| {

if (@field(opts, field.name)) |x| {

@field(extras, field.name) = x;

}

}

symbol.setExtra(extras, elf_file);

if (symbol.mergeSubsection(elf_file)) |msub| break :blk @intCast(msub.mergeSection(elf_file).output_section_index);

out.st_value = @intCast(st_value);

 

/// Whether the symbol is a merge subsection.

merge_subsection: bool = false,

subsection: u32 = 0,

const MergeSubsection = @import("merge_section.zig").MergeSubsection;

global.value = @intCast(esym.st_value);

try local.addExtra(.{ .symtab = self.output_symtab_ctx.nlocals }, elf_file);

try global.addExtra(.{ .symtab = self.output_symtab_ctx.nlocals }, elf_file);

try global.addExtra(.{ .symtab = self.output_symtab_ctx.nglobals }, elf_file);

const file_offset = shdr.sh_offset + @as(u64, @intCast(atom.value));

return @intCast(vaddr);

return @intCast(vaddr);

const need_realloc = code.len > capacity or !required_alignment.check(@intCast(atom_ptr.value));

const file_offset = shdr.sh_offset + @as(u64, @intCast(atom_ptr.value));

@intCast(sym.address(.{}, elf_file)),

@intCast(sym.address(.{}, elf_file)),

const file_offset = shdr.sh_offset + @as(u64, @intCast(atom_ptr.value));

const file_offset = shdr.sh_offset + @as(u64, @intCast(atom_ptr.value));

global_esym.st_value = @intCast(elf_file.symbol(sym_index).value);

if (sym.mergeSubsection(elf_file)) |msub| {

msub.alive = true;

return;

}

if (target_sym.mergeSubsection(elf_file)) |msub| {

msub.alive = true;

continue;

}

pub const MergeSection = struct {

name_offset: u32 = 0,

type: u32 = 0,

flags: u64 = 0,

output_section_index: u32 = 0,

bytes: std.ArrayListUnmanaged(u8) = .{},

table: std.HashMapUnmanaged(

String,

MergeSubsection.Index,

IndexContext,

std.hash_map.default_max_load_percentage,

) = .{},

subsections: std.ArrayListUnmanaged(MergeSubsection.Index) = .{},

 

pub fn deinit(msec: *MergeSection, allocator: Allocator) void {

msec.bytes.deinit(allocator);

msec.table.deinit(allocator);

msec.subsections.deinit(allocator);

}

 

pub fn name(msec: MergeSection, elf_file: *Elf) [:0]const u8 {

return elf_file.strings.getAssumeExists(msec.name_offset);

}

 

pub fn address(msec: MergeSection, elf_file: *Elf) i64 {

const shdr = elf_file.shdrs.items[msec.output_section_index];

return @intCast(shdr.sh_addr);

}

 

const InsertResult = struct {

found_existing: bool,

key: String,

sub: *MergeSubsection.Index,

};

 

pub fn insert(msec: *MergeSection, allocator: Allocator, string: []const u8) !InsertResult {

const gop = try msec.table.getOrPutContextAdapted(

allocator,

string,

IndexAdapter{ .bytes = msec.bytes.items },

IndexContext{ .bytes = msec.bytes.items },

);

if (!gop.found_existing) {

const index: u32 = @intCast(msec.bytes.items.len);

try msec.bytes.appendSlice(allocator, string);

gop.key_ptr.* = .{ .pos = index, .len = @intCast(string.len) };

}

return .{ .found_existing = gop.found_existing, .key = gop.key_ptr.*, .sub = gop.value_ptr };

}

 

pub fn insertZ(msec: *MergeSection, allocator: Allocator, string: []const u8) !InsertResult {

const with_null = try allocator.alloc(u8, string.len + 1);

defer allocator.free(with_null);

@memcpy(with_null[0..string.len], string);

with_null[string.len] = 0;

return msec.insert(allocator, with_null);

}

 

/// Finalizes the merge section and clears hash table.

/// Sorts all owned subsections.

pub fn finalize(msec: *MergeSection, elf_file: *Elf) !void {

const gpa = elf_file.base.comp.gpa;

try msec.subsections.ensureTotalCapacityPrecise(gpa, msec.table.count());

 

var it = msec.table.iterator();

while (it.next()) |entry| {

const msub = elf_file.mergeSubsection(entry.value_ptr.*);

if (!msub.alive) continue;

msec.subsections.appendAssumeCapacity(entry.value_ptr.*);

}

msec.table.clearAndFree(gpa);

 

const sortFn = struct {

pub fn sortFn(ctx: *Elf, lhs: MergeSubsection.Index, rhs: MergeSubsection.Index) bool {

const lhs_msub = ctx.mergeSubsection(lhs);

const rhs_msub = ctx.mergeSubsection(rhs);

if (lhs_msub.alignment.compareStrict(.eq, rhs_msub.alignment)) {

if (lhs_msub.size == rhs_msub.size) {

return mem.order(u8, lhs_msub.getString(ctx), rhs_msub.getString(ctx)) == .lt;

}

return lhs_msub.size < rhs_msub.size;

}

return lhs_msub.alignment.compareStrict(.lt, rhs_msub.alignment);

}

}.sortFn;

 

std.mem.sort(MergeSubsection.Index, msec.subsections.items, elf_file, sortFn);

}

 

pub const IndexContext = struct {

bytes: []const u8,

 

pub fn eql(_: @This(), a: String, b: String) bool {

return a.pos == b.pos;

}

 

pub fn hash(ctx: @This(), key: String) u64 {

const str = ctx.bytes[key.pos..][0..key.len];

return std.hash_map.hashString(str);

}

};

 

pub const IndexAdapter = struct {

bytes: []const u8,

 

pub fn eql(ctx: @This(), a: []const u8, b: String) bool {

const str = ctx.bytes[b.pos..][0..b.len];

return mem.eql(u8, a, str);

}

 

pub fn hash(_: @This(), adapted_key: []const u8) u64 {

return std.hash_map.hashString(adapted_key);

}

};

 

pub fn format(

msec: MergeSection,

comptime unused_fmt_string: []const u8,

options: std.fmt.FormatOptions,

writer: anytype,

) !void {

_ = msec;

_ = unused_fmt_string;

_ = options;

_ = writer;

@compileError("do not format MergeSection directly");

}

 

pub fn fmt(msec: MergeSection, elf_file: *Elf) std.fmt.Formatter(format2) {

return .{ .data = .{

.msec = msec,

.elf_file = elf_file,

} };

}

 

const FormatContext = struct {

msec: MergeSection,

elf_file: *Elf,

};

 

pub fn format2(

ctx: FormatContext,

comptime unused_fmt_string: []const u8,

options: std.fmt.FormatOptions,

writer: anytype,

) !void {

_ = options;

_ = unused_fmt_string;

const msec = ctx.msec;

const elf_file = ctx.elf_file;

try writer.print("{s} : @{x} : type({x}) : flags({x})\n", .{

msec.name(elf_file),

msec.address(elf_file),

msec.type,

msec.flags,

});

for (msec.subsections.items) |index| {

try writer.print(" {}\n", .{elf_file.mergeSubsection(index).fmt(elf_file)});

}

}

 

pub const Index = u32;

};

 

pub const MergeSubsection = struct {

value: i64 = 0,

merge_section_index: MergeSection.Index = 0,

string_index: u32 = 0,

size: u32 = 0,

alignment: Atom.Alignment = .@"1",

entsize: u32 = 0,

alive: bool = false,

 

pub fn address(msub: MergeSubsection, elf_file: *Elf) i64 {

return msub.mergeSection(elf_file).address(elf_file) + msub.value;

}

 

pub fn mergeSection(msub: MergeSubsection, elf_file: *Elf) *MergeSection {

return elf_file.mergeSection(msub.merge_section_index);

}

 

pub fn getString(msub: MergeSubsection, elf_file: *Elf) []const u8 {

const msec = msub.mergeSection(elf_file);

return msec.bytes.items[msub.string_index..][0..msub.size];

}

 

pub fn format(

msub: MergeSubsection,

comptime unused_fmt_string: []const u8,

options: std.fmt.FormatOptions,

writer: anytype,

) !void {

_ = msub;

_ = unused_fmt_string;

_ = options;

_ = writer;

@compileError("do not format MergeSubsection directly");

}

 

pub fn fmt(msub: MergeSubsection, elf_file: *Elf) std.fmt.Formatter(format2) {

return .{ .data = .{

.msub = msub,

.elf_file = elf_file,

} };

}

 

const FormatContext = struct {

msub: MergeSubsection,

elf_file: *Elf,

};

 

pub fn format2(

ctx: FormatContext,

comptime unused_fmt_string: []const u8,

options: std.fmt.FormatOptions,

writer: anytype,

) !void {

_ = options;

_ = unused_fmt_string;

const msub = ctx.msub;

const elf_file = ctx.elf_file;

try writer.print("@{x} : align({x}) : size({x})", .{

msub.address(elf_file),

msub.alignment,

msub.size,

});

if (!msub.alive) try writer.writeAll(" : [*]");

}

 

pub const Index = u32;

};

 

pub const InputMergeSection = struct {

merge_section_index: MergeSection.Index = 0,

atom_index: Atom.Index = 0,

offsets: std.ArrayListUnmanaged(u32) = .{},

subsections: std.ArrayListUnmanaged(MergeSubsection.Index) = .{},

bytes: std.ArrayListUnmanaged(u8) = .{},

strings: std.ArrayListUnmanaged(String) = .{},

 

pub fn deinit(imsec: *InputMergeSection, allocator: Allocator) void {

imsec.offsets.deinit(allocator);

imsec.subsections.deinit(allocator);

imsec.bytes.deinit(allocator);

imsec.strings.deinit(allocator);

}

 

pub fn clearAndFree(imsec: *InputMergeSection, allocator: Allocator) void {

imsec.bytes.clearAndFree(allocator);

// TODO: imsec.strings.clearAndFree(allocator);

}

 

pub fn findSubsection(imsec: InputMergeSection, offset: u32) ?struct { MergeSubsection.Index, u32 } {

// TODO: binary search

for (imsec.offsets.items, 0..) |off, index| {

if (offset < off) return .{

imsec.subsections.items[index - 1],

offset - imsec.offsets.items[index - 1],

};

}

const last = imsec.offsets.items.len - 1;

const last_off = imsec.offsets.items[last];

const last_len = imsec.strings.items[last].len;

if (offset < last_off + last_len) return .{ imsec.subsections.items[last], offset - last_off };

return null;

}

 

pub fn insert(imsec: *InputMergeSection, allocator: Allocator, string: []const u8) !void {

const index: u32 = @intCast(imsec.bytes.items.len);

try imsec.bytes.appendSlice(allocator, string);

try imsec.strings.append(allocator, .{ .pos = index, .len = @intCast(string.len) });

}

 

pub const Index = u32;

};

 

const String = struct { pos: u32, len: u32 };

 

const assert = std.debug.assert;

const mem = std.mem;

const std = @import("std");

 

const Allocator = mem.Allocator;

const Atom = @import("Atom.zig");

const Elf = @import("../Elf.zig");

try elf_file.addCommentString();

try elf_file.finalizeMergeSections();

try elf_file.initMergeSections();

try elf_file.updateMergeSectionSizes();

try elf_file.writeMergeSections();

try elf_file.resolveMergeSections();

try elf_file.addCommentString();

try elf_file.finalizeMergeSections();

try elf_file.initMergeSections();

try elf_file.updateMergeSectionSizes();

try elf_file.writeMergeSections();

atom_ptr.value = @intCast(offset);

const offset = math.cast(usize, atom_ptr.value - @as(i64, @intCast(shdr.sh_addr - base_offset))) orelse

try symbol.addExtra(.{ .zig_got = index }, elf_file);

pub fn entryAddress(zig_got: ZigGotSection, index: Index, elf_file: *Elf) i64 {

return @as(i64, @intCast(shdr.sh_addr)) + entry_size * index;

const vaddr: u64 = @intCast(zig_got.entryAddress(index, elf_file));

std.mem.writeInt(u16, &buf, @intCast(value), endian);

std.mem.writeInt(u32, &buf, @intCast(value), endian);

std.mem.writeInt(u64, &buf, @intCast(value), endian);

.offset = @intCast(offset),

.addend = symbol.address(.{ .plt = false }, elf_file),

.st_value = @intCast(st_value),

pub fn address(entry: Entry, elf_file: *Elf) i64 {

const ptr_bytes = elf_file.archPtrWidthBytes();

return @as(i64, @intCast(shdr.sh_addr)) + entry.cell_index * ptr_bytes;

try symbol.addExtra(.{ .got = index }, elf_file);

try symbol.addExtra(.{ .tlsgd = index }, elf_file);

try symbol.addExtra(.{ .gottp = index }, elf_file);

try symbol.addExtra(.{ .tlsdesc = index }, elf_file);

const offset = symbol.?.address(.{}, elf_file) - elf_file.tpAddress();

symbol.?.address(.{}, elf_file) - elf_file.tlsAddress()

const offset: u64 = @intCast(symbol.?.gotAddress(elf_file));

.addend = symbol.?.address(.{ .plt = false }, elf_file),

.addend = symbol.?.address(.{ .plt = false }, elf_file),

const offset: u64 = @intCast(entry.address(elf_file));

const offset: u64 = @intCast(symbol.?.tlsGdAddress(elf_file));

const offset: u64 = @intCast(symbol.?.gotTpAddress(elf_file));

.addend = symbol.?.address(.{}, elf_file) - elf_file.tlsAddress(),

const offset: u64 = @intCast(symbol.?.tlsDescAddress(elf_file));

.addend = if (symbol.?.flags.import) 0 else symbol.?.address(.{}, elf_file) - elf_file.tlsAddress(),

.st_value = @intCast(st_value),

try symbol.addExtra(.{ .plt = index }, elf_file);

const r_offset: u64 = @intCast(sym.gotPltAddress(elf_file));

.st_value = @intCast(sym.pltAddress(elf_file)),

const plt_addr: i64 = @intCast(elf_file.shdrs.items[elf_file.plt_section_index.?].sh_addr);

const got_plt_addr: i64 = @intCast(elf_file.shdrs.items[elf_file.got_plt_section_index.?].sh_addr);

const ldr_off = try math.divExact(u12, @truncate(@as(u64, @bitCast(got_plt_addr + 16))), 8);

const add_off: u12 = @truncate(@as(u64, @bitCast(got_plt_addr + 16)));

const ldr_off = try math.divExact(u12, @truncate(@as(u64, @bitCast(target_addr))), 8);

const add_off: u12 = @truncate(@as(u64, @bitCast(target_addr)));

try writer.writeInt(u64, @intCast(symbol.address(.{}, elf_file)), .little);

try symbol.addExtra(.{ .plt_got = index }, elf_file);

.st_value = @intCast(sym.pltGotAddress(elf_file)),

const off = try math.divExact(u12, @truncate(@as(u64, @bitCast(target_addr))), 8);

try symbol.addExtra(.{ .copy_rel = index }, elf_file);

symbol.value = @intCast(mem.alignForward(u64, shdr.sh_size, alignment));

shdr.sh_size = @as(u64, @intCast(symbol.value)) + symbol.elfSym(elf_file).st_size;

.offset = @intCast(sym.address(.{}, elf_file)),

try sym.addExtra(.{ .dynamic = index }, elf_file);

elf_file.atom(atom_index).?.value = -1;

if (@as(i64, @intCast(atom.alignment.forward(shdr.sh_size))) - start_atom.value >= max_distance)

break;

try atom.addExtra(.{ .thunk = thunk_index }, elf_file);

atom.flags.thunk = true;

fn advance(shdr: *elf.Elf64_Shdr, size: u64, alignment: Atom.Alignment) !i64 {

return @intCast(offset);

value: i64 = 0,

pub fn address(thunk: Thunk, elf_file: *Elf) i64 {

return @as(i64, @intCast(shdr.sh_addr)) + thunk.value;

pub fn targetAddress(thunk: Thunk, sym_index: Symbol.Index, elf_file: *Elf) i64 {

return thunk.address(elf_file) + @as(i64, @intCast(thunk.symbols.getIndex(sym_index).? * trampolineSize(cpu_arch)));

.st_value = @intCast(thunk.targetAddress(sym_index, elf_file)),

if (target_atom.value == -1) return false;

const saddr = atom.address(elf_file) + @as(i64, @intCast(rel.r_offset));

const taddr = target.address(.{}, elf_file);

const saddr = thunk.address(elf_file) + @as(i64, @intCast(i * trampoline_size));

const off: u12 = @truncate(@as(u64, @bitCast(taddr)));

const pages = @as(u21, @bitCast(try aarch64.calcNumberOfPages(@intCast(source), @intCast(target))));

const pages = try aarch64.calcNumberOfPages(@intCast(source), @intCast(target));

const pages = try aarch64.calcNumberOfPages(@intCast(sect.addr), @intCast(dyld_private_addr));

const pages = try aarch64.calcNumberOfPages(@intCast(sect.addr + 12), @intCast(dyld_stub_binder_addr));

const pages = try aarch64.calcNumberOfPages(@intCast(source), @intCast(target));

const pages = try aarch64.calcNumberOfPages(@intCast(source), @intCast(target));

const pages = try aarch64.calcNumberOfPages(@intCast(saddr), @intCast(taddr));

pub fn calcNumberOfPages(saddr: i64, taddr: i64) error{Overflow}!i21 {

elf_step.dependOn(testCommentString(b, .{ .target = musl_target }));

elf_step.dependOn(testMergeStrings(b, .{ .target = musl_target }));

elf_step.dependOn(testMergeStrings2(b, .{ .target = musl_target }));

elf_step.dependOn(testCommentString(b, .{ .target = gnu_target }));

elf_step.dependOn(testCommentString(b, .{ .use_llvm = false, .target = default_target }));

elf_step.dependOn(testCommentStringStaticLib(b, .{ .use_llvm = false, .target = default_target }));

fn testCommentString(b: *Build, opts: Options) *Step {

const test_step = addTestStep(b, "comment-string", opts);

 

const exe = addExecutable(b, opts, .{ .name = "main", .zig_source_bytes =

\\pub fn main() void {}

});

 

const check = exe.checkObject();

check.dumpSection(".comment");

check.checkContains("zig");

test_step.dependOn(&check.step);

 

return test_step;

}

 

fn testCommentStringStaticLib(b: *Build, opts: Options) *Step {

const test_step = addTestStep(b, "comment-string-static-lib", opts);

 

const lib = addStaticLibrary(b, opts, .{ .name = "lib", .zig_source_bytes =

\\export fn foo() void {}

});

 

const check = lib.checkObject();

check.dumpSection(".comment");

check.checkContains("zig");

test_step.dependOn(&check.step);

 

return test_step;

}

 

// Adapted from https://github.com/rui314/mold/blob/main/test/elf/mergeable-strings.sh

fn testMergeStrings(b: *Build, opts: Options) *Step {

const test_step = addTestStep(b, "merge-strings", opts);

 

const obj1 = addObject(b, opts, .{ .name = "a.o" });

addCSourceBytes(obj1,

\\#include <uchar.h>

\\#include <wchar.h>

\\char *cstr1 = "foo";

\\wchar_t *wide1 = L"foo";

\\char16_t *utf16_1 = u"foo";

\\char32_t *utf32_1 = U"foo";

, &.{"-O2"});

obj1.linkLibC();

 

const obj2 = addObject(b, opts, .{ .name = "b.o" });

addCSourceBytes(obj2,

\\#include <stdio.h>

\\#include <assert.h>

\\#include <uchar.h>

\\#include <wchar.h>

\\extern char *cstr1;

\\extern wchar_t *wide1;

\\extern char16_t *utf16_1;

\\extern char32_t *utf32_1;

\\char *cstr2 = "foo";

\\wchar_t *wide2 = L"foo";

\\char16_t *utf16_2 = u"foo";

\\char32_t *utf32_2 = U"foo";

\\int main() {

\\ printf("%p %p %p %p %p %p %p %p\n",

\\ cstr1, cstr2, wide1, wide2, utf16_1, utf16_2, utf32_1, utf32_2);

\\ assert((void*)cstr1 == (void*)cstr2);

\\ assert((void*)wide1 == (void*)wide2);

\\ assert((void*)utf16_1 == (void*)utf16_2);

\\ assert((void*)utf32_1 == (void*)utf32_2);

\\ assert((void*)wide1 == (void*)utf32_1);

\\ assert((void*)cstr1 != (void*)wide1);

\\ assert((void*)cstr1 != (void*)utf32_1);

\\ assert((void*)wide1 != (void*)utf16_1);

\\}

, &.{"-O2"});

obj2.linkLibC();

 

const exe = addExecutable(b, opts, .{ .name = "main" });

exe.addObject(obj1);

exe.addObject(obj2);

exe.linkLibC();

 

const run = addRunArtifact(exe);

run.expectExitCode(0);

test_step.dependOn(&run.step);

 

return test_step;

}

 

fn testMergeStrings2(b: *Build, opts: Options) *Step {

const test_step = addTestStep(b, "merge-strings2", opts);

 

const obj1 = addObject(b, opts, .{ .name = "a", .zig_source_bytes =

\\const std = @import("std");

\\export fn foo() void {

\\ var arr: [5:0]u16 = [_:0]u16{ 1, 2, 3, 4, 5 };

\\ const slice = std.mem.sliceTo(&arr, 3);

\\ std.testing.expectEqualSlices(u16, arr[0..2], slice) catch unreachable;

\\}

});

 

const obj2 = addObject(b, opts, .{ .name = "b", .zig_source_bytes =

\\const std = @import("std");

\\extern fn foo() void;

\\pub fn main() void {

\\ foo();

\\ var arr: [5:0]u16 = [_:0]u16{ 5, 4, 3, 2, 1 };

\\ const slice = std.mem.sliceTo(&arr, 3);

\\ std.testing.expectEqualSlices(u16, arr[0..2], slice) catch unreachable;

\\}

});

 

{

const exe = addExecutable(b, opts, .{ .name = "main1" });

exe.addObject(obj1);

exe.addObject(obj2);

 

const run = addRunArtifact(exe);

run.expectExitCode(0);

test_step.dependOn(&run.step);

 

const check = exe.checkObject();

check.dumpSection(".rodata.str");

check.checkContains("\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x00\x00");

check.dumpSection(".rodata.str");

check.checkContains("\x05\x00\x04\x00\x03\x00\x02\x00\x01\x00\x00\x00");

test_step.dependOn(&check.step);

}

 

{

const obj3 = addObject(b, opts, .{ .name = "c" });

obj3.addObject(obj1);

obj3.addObject(obj2);

 

const exe = addExecutable(b, opts, .{ .name = "main2" });

exe.addObject(obj3);

 

const run = addRunArtifact(exe);

run.expectExitCode(0);

test_step.dependOn(&run.step);

 

const check = exe.checkObject();

check.dumpSection(".rodata.str");

check.checkContains("\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x00\x00");

check.dumpSection(".rodata.str");

check.checkContains("\x05\x00\x04\x00\x03\x00\x02\x00\x01\x00\x00\x00");

test_step.dependOn(&check.step);

}

 

return test_step;

}

 

// Adapted from https://github.com/rui314/mold/blob/main/test/elf/relocatable-mergeable-sections.sh

fn testRelocatableMergeStrings(b: *Build, opts: Options) *Step {

const test_step = addTestStep(b, "relocatable-merge-strings", opts);

 

const obj1 = addObject(b, opts, .{ .name = "a", .asm_source_bytes =

\\.section .rodata.str1.1,"aMS",@progbits,1

\\val1:

\\.ascii "Hello \0"

\\.section .rodata.str1.1,"aMS",@progbits,1

\\val5:

\\.ascii "World \0"

\\.section .rodata.str1.1,"aMS",@progbits,1

\\val7:

\\.ascii "Hello \0"

});

 

const obj2 = addObject(b, opts, .{ .name = "b" });

obj2.addObject(obj1);

 

const check = obj2.checkObject();

check.dumpSection(".rodata.str1.1");

check.checkExact("Hello \x00World \x00");

test_step.dependOn(&check.step);

 

return test_step;

}