motiejus/zig
1
Fork 0
Code Releases Activity

elf: correctly copy and write out debug sections

Browse Source
This commit is contained in:
Jakub Konka
2023-10-16 12:38:40 +02:00
parent b0e2c6323b
commit ee1c3c7058
2 changed files with 64 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/link/Dwarf.zig
View File

@@ -1851,8 +1851,7 @@ pub fn writeDbgInfoHeader(self: *Dwarf, module: *Module, low_pc: u64, high_pc: u
// not including the initial length itself.
// We have to come back and write it later after we know the size.
const after_init_len = di_buf.items.len + init_len_size;
// +1 for the final 0 that ends the compilation unit children.
const dbg_info_end = self.getDebugInfoEnd().? + 1;
const dbg_info_end = self.getDebugInfoEnd().?;
const init_len = dbg_info_end - after_init_len;
if (self.bin_file.tag == .macho) {
mem.writeIntLittle(u32, di_buf.addManyAsArrayAssumeCapacity(4), @as(u32, @intCast(init_len)));
@@ -2501,7 +2500,7 @@ fn getDebugInfoOff(self: Dwarf) ?u32 {
fn getDebugInfoEnd(self: Dwarf) ?u32 {
const last_index = self.di_atom_last_index orelse return null;
const last = self.getAtom(.di_atom, last_index);
return last.off + last.len;
return last.off + last.len + 1;
}
fn getDebugLineProgramOff(self: Dwarf) ?u32 {

74
src/link/Elf.zig
View File

@@ -108,12 +108,21 @@ zig_rodata_section_index: ?u16 = null,
zig_data_section_index: ?u16 = null,
zig_bss_section_index: ?u16 = null,
zig_got_section_index: ?u16 = null,
debug_info_section_index: ?u16 = null,
debug_abbrev_section_index: ?u16 = null,
debug_str_section_index: ?u16 = null,
debug_aranges_section_index: ?u16 = null,
debug_line_section_index: ?u16 = null,
/// Size contribution of Zig's metadata to each debug section.
/// Used to track start of metadata from input object files.
debug_info_section_zig_size: u64 = 0,
debug_abbrev_section_zig_size: u64 = 0,
debug_str_section_zig_size: u64 = 0,
debug_aranges_section_zig_size: u64 = 0,
debug_line_section_zig_size: u64 = 0,
copy_rel_section_index: ?u16 = null,
dynamic_section_index: ?u16 = null,
dynstrtab_section_index: ?u16 = null,
@@ -924,7 +933,7 @@ pub fn growNonAllocSection(
shdr.sh_offset = new_offset;
}
shdr.sh_size = needed_size; // anticipating adding the global symbols later
shdr.sh_size = needed_size;
self.markDirty(shdr_index);
}
@@ -1522,8 +1531,6 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
}
if (self.debug_info_header_dirty) {
// Currently only one compilation unit is supported, so the address range is simply
// identical to the main program header virtual address and memory size.
const text_phdr = &self.phdrs.items[self.phdr_zig_load_re_index.?];
const low_pc = text_phdr.p_vaddr;
const high_pc = text_phdr.p_vaddr + text_phdr.p_memsz;
@@ -1532,8 +1539,6 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
}
if (self.debug_aranges_section_dirty) {
// Currently only one compilation unit is supported, so the address range is simply
// identical to the main program header virtual address and memory size.
const text_phdr = &self.phdrs.items[self.phdr_zig_load_re_index.?];
try dw.writeDbgAranges(text_phdr.p_vaddr, text_phdr.p_memsz);
self.debug_aranges_section_dirty = false;
@@ -1552,6 +1557,8 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
self.debug_strtab_dirty = false;
}
}
self.saveDebugSectionsSizes();
}
// Generate and emit non-incremental sections.
@@ -4345,6 +4352,24 @@ fn sortShdrs(self: *Elf) !void {
}
}
fn saveDebugSectionsSizes(self: *Elf) void {
if (self.debug_info_section_index) |shndx| {
self.debug_info_section_zig_size = self.shdrs.items[shndx].sh_size;
}
if (self.debug_abbrev_section_index) |shndx| {
self.debug_abbrev_section_zig_size = self.shdrs.items[shndx].sh_size;
}
if (self.debug_str_section_index) |shndx| {
self.debug_str_section_zig_size = self.shdrs.items[shndx].sh_size;
}
if (self.debug_aranges_section_index) |shndx| {
self.debug_aranges_section_zig_size = self.shdrs.items[shndx].sh_size;
}
if (self.debug_line_section_index) |shndx| {
self.debug_line_section_zig_size = self.shdrs.items[shndx].sh_size;
}
}
fn updateSectionSizes(self: *Elf) !void {
for (self.output_sections.keys(), self.output_sections.values()) |shndx, atom_list| {
if (atom_list.items.len == 0) continue;
@@ -4675,18 +4700,31 @@ fn allocateNonAllocSections(self: *Elf) !void {
const new_offset = self.findFreeSpace(needed_size, shdr.sh_addralign);
if (self.isDebugSection(@intCast(shndx))) {
log.debug("moving {s} from 0x{x} to 0x{x}", .{
self.shstrtab.getAssumeExists(shdr.sh_name),
shdr.sh_offset,
new_offset,
});
const existing_size = blk: {
if (shndx == self.debug_info_section_index.?) break :blk self.debug_info_section_zig_size;
if (shndx == self.debug_abbrev_section_index.?) break :blk self.debug_abbrev_section_zig_size;
if (shndx == self.debug_str_section_index.?) break :blk self.debug_str_section_zig_size;
if (shndx == self.debug_aranges_section_index.?) break :blk self.debug_aranges_section_zig_size;
if (shndx == self.debug_line_section_index.?) break :blk self.debug_line_section_zig_size;
unreachable;
};
const amt = try self.base.file.?.copyRangeAll(
shdr.sh_offset,
self.base.file.?,
new_offset,
needed_size, // TODO this will copy too much but ah well
existing_size,
);
if (amt != needed_size) return error.InputOutput;
if (amt != existing_size) return error.InputOutput;
}
shdr.sh_offset = new_offset;
shdr.sh_size = needed_size;
}
shdr.sh_size = needed_size;
}
}
@@ -4771,7 +4809,19 @@ fn writeAtoms(self: *Elf) !void {
log.debug("writing atoms in '{s}' section", .{self.shstrtab.getAssumeExists(shdr.sh_name)});
const buffer = try gpa.alloc(u8, shdr.sh_size);
// TODO really, really handle debug section separately
const base_offset = if (self.isDebugSection(@intCast(shndx))) blk: {
if (shndx == self.debug_info_section_index.?) break :blk self.debug_info_section_zig_size;
if (shndx == self.debug_abbrev_section_index.?) break :blk self.debug_abbrev_section_zig_size;
if (shndx == self.debug_str_section_index.?) break :blk self.debug_str_section_zig_size;
if (shndx == self.debug_aranges_section_index.?) break :blk self.debug_aranges_section_zig_size;
if (shndx == self.debug_line_section_index.?) break :blk self.debug_line_section_zig_size;
unreachable;
} else 0;
const sh_offset = shdr.sh_offset + base_offset;
const sh_size = shdr.sh_size - base_offset;
const buffer = try gpa.alloc(u8, sh_size);
defer gpa.free(buffer);
const padding_byte: u8 = if (shdr.sh_type == elf.SHT_PROGBITS and
shdr.sh_flags & elf.SHF_EXECINSTR != 0)
@@ -4785,9 +4835,9 @@ fn writeAtoms(self: *Elf) !void {
assert(atom_ptr.flags.alive);
const object = atom_ptr.file(self).?.object;
const offset = atom_ptr.value - shdr.sh_addr;
const offset = atom_ptr.value - shdr.sh_addr - base_offset;
log.debug("writing atom({d}) at 0x{x}", .{ atom_index, shdr.sh_offset + offset });
log.debug("writing atom({d}) at 0x{x}", .{ atom_index, sh_offset + offset });
// TODO decompress directly into provided buffer
const out_code = buffer[offset..][0..atom_ptr.size];
@@ -4808,7 +4858,7 @@ fn writeAtoms(self: *Elf) !void {
}
}
try self.base.file.?.pwriteAll(buffer, shdr.sh_offset);
try self.base.file.?.pwriteAll(buffer, sh_offset);
}
try self.reportUndefined(&undefs);