authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-09-08 23:21:44+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-09-08 23:21:44+02:00
loga3372050b184aa2d103f11afcd1f87bf6077fa3d
tree734f700140fc697c1e26b62aa3605de9e3c7a656
parent465431807b318aba078c911419fd74d44e24a9ae

elf: rename program_headers to phdrs

2 files changed, 45 insertions(+), 47 deletions(-)

src/link/Elf.zig+43-43
......@@ -17,7 +17,7 @@ shdr_table_offset: ?u64 = null,
1717
1818/// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
1919/// Same order as in the file.
20program_headers: std.ArrayListUnmanaged(elf.Elf64_Phdr) = .{},
20phdrs: std.ArrayListUnmanaged(elf.Elf64_Phdr) = .{},
2121/// The index into the program headers of the PT_PHDR program header
2222phdr_table_index: ?u16 = null,
2323/// The index into the program headers of the PT_LOAD program header containing the phdr
......@@ -232,7 +232,7 @@ pub fn deinit(self: *Elf) void {
232232 }
233233 self.sections.deinit(gpa);
234234
235 self.program_headers.deinit(gpa);
235 self.phdrs.deinit(gpa);
236236 self.shstrtab.deinit(gpa);
237237 self.strtab.deinit(gpa);
238238 self.symbols.deinit(gpa);
......@@ -317,10 +317,10 @@ fn detectAllocCollision(self: *Elf, start: u64, size: u64) ?u64 {
317317 return test_end;
318318 }
319319 }
320 for (self.program_headers.items) |program_header| {
321 const increased_size = padToIdeal(program_header.p_filesz);
322 const test_end = program_header.p_offset + increased_size;
323 if (end > program_header.p_offset and start < test_end) {
320 for (self.phdrs.items) |phdr| {
321 const increased_size = padToIdeal(phdr.p_filesz);
322 const test_end = phdr.p_offset + increased_size;
323 if (end > phdr.p_offset and start < test_end) {
324324 return test_end;
325325 }
326326 }
......@@ -338,9 +338,9 @@ pub fn allocatedSize(self: *Elf, start: u64) u64 {
338338 if (section.sh_offset <= start) continue;
339339 if (section.sh_offset < min_pos) min_pos = section.sh_offset;
340340 }
341 for (self.program_headers.items) |program_header| {
342 if (program_header.p_offset <= start) continue;
343 if (program_header.p_offset < min_pos) min_pos = program_header.p_offset;
341 for (self.phdrs.items) |phdr| {
342 if (phdr.p_offset <= start) continue;
343 if (phdr.p_offset < min_pos) min_pos = phdr.p_offset;
344344 }
345345 return min_pos - start;
346346}
......@@ -364,12 +364,12 @@ pub fn populateMissingMetadata(self: *Elf) !void {
364364 const ptr_size: u8 = self.ptrWidthBytes();
365365
366366 if (self.phdr_table_index == null) {
367 self.phdr_table_index = @as(u16, @intCast(self.program_headers.items.len));
367 self.phdr_table_index = @as(u16, @intCast(self.phdrs.items.len));
368368 const p_align: u16 = switch (self.ptr_width) {
369369 .p32 => @alignOf(elf.Elf32_Phdr),
370370 .p64 => @alignOf(elf.Elf64_Phdr),
371371 };
372 try self.program_headers.append(gpa, .{
372 try self.phdrs.append(gpa, .{
373373 .p_type = elf.PT_PHDR,
374374 .p_offset = 0,
375375 .p_filesz = 0,
......@@ -383,11 +383,11 @@ pub fn populateMissingMetadata(self: *Elf) !void {
383383 }
384384
385385 if (self.phdr_table_load_index == null) {
386 self.phdr_table_load_index = @as(u16, @intCast(self.program_headers.items.len));
386 self.phdr_table_load_index = @as(u16, @intCast(self.phdrs.items.len));
387387 // TODO Same as for GOT
388388 const phdr_addr: u64 = if (self.base.options.target.ptrBitWidth() >= 32) 0x1000000 else 0x1000;
389389 const p_align = self.page_size;
390 try self.program_headers.append(gpa, .{
390 try self.phdrs.append(gpa, .{
391391 .p_type = elf.PT_LOAD,
392392 .p_offset = 0,
393393 .p_filesz = 0,
......@@ -401,13 +401,13 @@ pub fn populateMissingMetadata(self: *Elf) !void {
401401 }
402402
403403 if (self.phdr_load_re_index == null) {
404 self.phdr_load_re_index = @as(u16, @intCast(self.program_headers.items.len));
404 self.phdr_load_re_index = @as(u16, @intCast(self.phdrs.items.len));
405405 const file_size = self.base.options.program_code_size_hint;
406406 const p_align = self.page_size;
407407 const off = self.findFreeSpace(file_size, p_align);
408408 log.debug("found PT_LOAD RE free space 0x{x} to 0x{x}", .{ off, off + file_size });
409409 const entry_addr: u64 = self.entry_addr orelse if (self.base.options.target.cpu.arch == .spu_2) @as(u64, 0) else default_entry_addr;
410 try self.program_headers.append(gpa, .{
410 try self.phdrs.append(gpa, .{
411411 .p_type = elf.PT_LOAD,
412412 .p_offset = off,
413413 .p_filesz = file_size,
......@@ -422,7 +422,7 @@ pub fn populateMissingMetadata(self: *Elf) !void {
422422 }
423423
424424 if (self.phdr_got_index == null) {
425 self.phdr_got_index = @as(u16, @intCast(self.program_headers.items.len));
425 self.phdr_got_index = @as(u16, @intCast(self.phdrs.items.len));
426426 const file_size = @as(u64, ptr_size) * self.base.options.symbol_count_hint;
427427 // We really only need ptr alignment but since we are using PROGBITS, linux requires
428428 // page align.
......@@ -433,7 +433,7 @@ pub fn populateMissingMetadata(self: *Elf) !void {
433433 // we'll need to re-use that function anyway, in case the GOT grows and overlaps something
434434 // else in virtual memory.
435435 const got_addr: u32 = if (self.base.options.target.ptrBitWidth() >= 32) 0x4000000 else 0x8000;
436 try self.program_headers.append(gpa, .{
436 try self.phdrs.append(gpa, .{
437437 .p_type = elf.PT_LOAD,
438438 .p_offset = off,
439439 .p_filesz = file_size,
......@@ -447,7 +447,7 @@ pub fn populateMissingMetadata(self: *Elf) !void {
447447 }
448448
449449 if (self.phdr_load_ro_index == null) {
450 self.phdr_load_ro_index = @as(u16, @intCast(self.program_headers.items.len));
450 self.phdr_load_ro_index = @as(u16, @intCast(self.phdrs.items.len));
451451 // TODO Find a hint about how much data need to be in rodata ?
452452 const file_size = 1024;
453453 // Same reason as for GOT
......@@ -456,7 +456,7 @@ pub fn populateMissingMetadata(self: *Elf) !void {
456456 log.debug("found PT_LOAD RO free space 0x{x} to 0x{x}", .{ off, off + file_size });
457457 // TODO Same as for GOT
458458 const rodata_addr: u32 = if (self.base.options.target.ptrBitWidth() >= 32) 0xc000000 else 0xa000;
459 try self.program_headers.append(gpa, .{
459 try self.phdrs.append(gpa, .{
460460 .p_type = elf.PT_LOAD,
461461 .p_offset = off,
462462 .p_filesz = file_size,
......@@ -470,7 +470,7 @@ pub fn populateMissingMetadata(self: *Elf) !void {
470470 }
471471
472472 if (self.phdr_load_rw_index == null) {
473 self.phdr_load_rw_index = @as(u16, @intCast(self.program_headers.items.len));
473 self.phdr_load_rw_index = @as(u16, @intCast(self.phdrs.items.len));
474474 // TODO Find a hint about how much data need to be in data ?
475475 const file_size = 1024;
476476 // Same reason as for GOT
......@@ -479,7 +479,7 @@ pub fn populateMissingMetadata(self: *Elf) !void {
479479 log.debug("found PT_LOAD RW free space 0x{x} to 0x{x}", .{ off, off + file_size });
480480 // TODO Same as for GOT
481481 const rwdata_addr: u32 = if (self.base.options.target.ptrBitWidth() >= 32) 0x10000000 else 0xc000;
482 try self.program_headers.append(gpa, .{
482 try self.phdrs.append(gpa, .{
483483 .p_type = elf.PT_LOAD,
484484 .p_offset = off,
485485 .p_filesz = file_size,
......@@ -544,7 +544,7 @@ pub fn populateMissingMetadata(self: *Elf) !void {
544544
545545 if (self.text_section_index == null) {
546546 self.text_section_index = @as(u16, @intCast(self.sections.slice().len));
547 const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
547 const phdr = &self.phdrs.items[self.phdr_load_re_index.?];
548548
549549 try self.sections.append(gpa, .{
550550 .shdr = .{
......@@ -566,7 +566,7 @@ pub fn populateMissingMetadata(self: *Elf) !void {
566566
567567 if (self.got_section_index == null) {
568568 self.got_section_index = @as(u16, @intCast(self.sections.slice().len));
569 const phdr = &self.program_headers.items[self.phdr_got_index.?];
569 const phdr = &self.phdrs.items[self.phdr_got_index.?];
570570
571571 try self.sections.append(gpa, .{
572572 .shdr = .{
......@@ -588,7 +588,7 @@ pub fn populateMissingMetadata(self: *Elf) !void {
588588
589589 if (self.rodata_section_index == null) {
590590 self.rodata_section_index = @as(u16, @intCast(self.sections.slice().len));
591 const phdr = &self.program_headers.items[self.phdr_load_ro_index.?];
591 const phdr = &self.phdrs.items[self.phdr_load_ro_index.?];
592592
593593 try self.sections.append(gpa, .{
594594 .shdr = .{
......@@ -610,7 +610,7 @@ pub fn populateMissingMetadata(self: *Elf) !void {
610610
611611 if (self.data_section_index == null) {
612612 self.data_section_index = @as(u16, @intCast(self.sections.slice().len));
613 const phdr = &self.program_headers.items[self.phdr_load_rw_index.?];
613 const phdr = &self.phdrs.items[self.phdr_load_rw_index.?];
614614
615615 try self.sections.append(gpa, .{
616616 .shdr = .{
......@@ -858,7 +858,7 @@ pub fn growAllocSection(self: *Elf, shdr_index: u16, needed_size: u64) !void {
858858 // TODO Also detect virtual address collisions.
859859 const shdr = &self.sections.items(.shdr)[shdr_index];
860860 const phdr_index = self.sections.items(.phdr_index)[shdr_index];
861 const phdr = &self.program_headers.items[phdr_index];
861 const phdr = &self.phdrs.items[phdr_index];
862862 const last_atom_index = self.sections.items(.last_atom_index)[shdr_index];
863863
864864 if (needed_size > self.allocatedSize(shdr.sh_offset)) {
......@@ -1078,7 +1078,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
10781078 if (self.debug_info_header_dirty) {
10791079 // Currently only one compilation unit is supported, so the address range is simply
10801080 // identical to the main program header virtual address and memory size.
1081 const text_phdr = &self.program_headers.items[self.phdr_load_re_index.?];
1081 const text_phdr = &self.phdrs.items[self.phdr_load_re_index.?];
10821082 const low_pc = text_phdr.p_vaddr;
10831083 const high_pc = text_phdr.p_vaddr + text_phdr.p_memsz;
10841084 try dw.writeDbgInfoHeader(module, low_pc, high_pc);
......@@ -1088,7 +1088,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
10881088 if (self.debug_aranges_section_dirty) {
10891089 // Currently only one compilation unit is supported, so the address range is simply
10901090 // identical to the main program header virtual address and memory size.
1091 const text_phdr = &self.program_headers.items[self.phdr_load_re_index.?];
1091 const text_phdr = &self.phdrs.items[self.phdr_load_re_index.?];
10921092 try dw.writeDbgAranges(text_phdr.p_vaddr, text_phdr.p_memsz);
10931093 if (!self.shdr_table_dirty) {
10941094 // Then it won't get written with the others and we need to do it.
......@@ -1110,11 +1110,11 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
11101110 };
11111111
11121112 const phdr_table_index = self.phdr_table_index.?;
1113 const phdr_table = &self.program_headers.items[phdr_table_index];
1114 const phdr_table_load = &self.program_headers.items[self.phdr_table_load_index.?];
1113 const phdr_table = &self.phdrs.items[phdr_table_index];
1114 const phdr_table_load = &self.phdrs.items[self.phdr_table_load_index.?];
11151115
11161116 const allocated_size = self.allocatedSize(phdr_table.p_offset);
1117 const needed_size = self.program_headers.items.len * phsize;
1117 const needed_size = self.phdrs.items.len * phsize;
11181118
11191119 if (needed_size > allocated_size) {
11201120 phdr_table.p_offset = 0; // free the space
......@@ -1133,11 +1133,11 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
11331133
11341134 switch (self.ptr_width) {
11351135 .p32 => {
1136 const buf = try gpa.alloc(elf.Elf32_Phdr, self.program_headers.items.len);
1136 const buf = try gpa.alloc(elf.Elf32_Phdr, self.phdrs.items.len);
11371137 defer gpa.free(buf);
11381138
11391139 for (buf, 0..) |*phdr, i| {
1140 phdr.* = progHeaderTo32(self.program_headers.items[i]);
1140 phdr.* = progHeaderTo32(self.phdrs.items[i]);
11411141 if (foreign_endian) {
11421142 mem.byteSwapAllFields(elf.Elf32_Phdr, phdr);
11431143 }
......@@ -1145,11 +1145,11 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
11451145 try self.base.file.?.pwriteAll(mem.sliceAsBytes(buf), phdr_table.p_offset);
11461146 },
11471147 .p64 => {
1148 const buf = try gpa.alloc(elf.Elf64_Phdr, self.program_headers.items.len);
1148 const buf = try gpa.alloc(elf.Elf64_Phdr, self.phdrs.items.len);
11491149 defer gpa.free(buf);
11501150
11511151 for (buf, 0..) |*phdr, i| {
1152 phdr.* = self.program_headers.items[i];
1152 phdr.* = self.phdrs.items[i];
11531153 if (foreign_endian) {
11541154 mem.byteSwapAllFields(elf.Elf64_Phdr, phdr);
11551155 }
......@@ -2018,7 +2018,7 @@ fn writeElfHeader(self: *Elf) !void {
20182018
20192019 const e_entry = if (elf_type == .REL) 0 else self.entry_addr.?;
20202020
2021 const phdr_table_offset = self.program_headers.items[self.phdr_table_index.?].p_offset;
2021 const phdr_table_offset = self.phdrs.items[self.phdr_table_index.?].p_offset;
20222022 switch (self.ptr_width) {
20232023 .p32 => {
20242024 mem.writeInt(u32, hdr_buf[index..][0..4], @as(u32, @intCast(e_entry)), endian);
......@@ -2065,7 +2065,7 @@ fn writeElfHeader(self: *Elf) !void {
20652065 mem.writeInt(u16, hdr_buf[index..][0..2], e_phentsize, endian);
20662066 index += 2;
20672067
2068 const e_phnum = @as(u16, @intCast(self.program_headers.items.len));
2068 const e_phnum = @as(u16, @intCast(self.phdrs.items.len));
20692069 mem.writeInt(u16, hdr_buf[index..][0..2], e_phnum, endian);
20702070 index += 2;
20712071
......@@ -2264,7 +2264,7 @@ fn updateDeclCode(
22642264 }
22652265
22662266 const phdr_index = self.sections.items(.phdr_index)[shdr_index];
2267 const section_offset = sym.value - self.program_headers.items[phdr_index].p_vaddr;
2267 const section_offset = sym.value - self.phdrs.items[phdr_index].p_vaddr;
22682268 const file_offset = self.sections.items(.shdr)[shdr_index].sh_offset + section_offset;
22692269
22702270 if (self.base.child_pid) |pid| {
......@@ -2494,7 +2494,7 @@ fn updateLazySymbol(self: *Elf, sym: link.File.LazySymbol, symbol_index: Symbol.
24942494 const got_index = try local_sym.getOrCreateGotEntry(self);
24952495 try self.got.writeEntry(self, got_index);
24962496
2497 const section_offset = atom_ptr.value - self.program_headers.items[phdr_index].p_vaddr;
2497 const section_offset = atom_ptr.value - self.phdrs.items[phdr_index].p_vaddr;
24982498 const file_offset = self.sections.items(.shdr)[local_sym.output_section_index].sh_offset + section_offset;
24992499 try self.base.file.?.pwriteAll(code, file_offset);
25002500}
......@@ -2564,7 +2564,7 @@ pub fn lowerUnnamedConst(self: *Elf, typed_value: TypedValue, decl_index: Module
25642564
25652565 try unnamed_consts.append(gpa, atom_ptr.atom_index);
25662566
2567 const section_offset = atom_ptr.value - self.program_headers.items[phdr_index].p_vaddr;
2567 const section_offset = atom_ptr.value - self.phdrs.items[phdr_index].p_vaddr;
25682568 const file_offset = self.sections.items(.shdr)[shdr_index].sh_offset + section_offset;
25692569 try self.base.file.?.pwriteAll(code, file_offset);
25702570
......@@ -2684,17 +2684,17 @@ pub fn deleteDeclExport(
26842684
26852685fn writeProgHeader(self: *Elf, index: usize) !void {
26862686 const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();
2687 const offset = self.program_headers.items[index].p_offset;
2687 const offset = self.phdrs.items[index].p_offset;
26882688 switch (self.ptr_width) {
26892689 .p32 => {
2690 var phdr = [1]elf.Elf32_Phdr{progHeaderTo32(self.program_headers.items[index])};
2690 var phdr = [1]elf.Elf32_Phdr{progHeaderTo32(self.phdrs.items[index])};
26912691 if (foreign_endian) {
26922692 mem.byteSwapAllFields(elf.Elf32_Phdr, &phdr[0]);
26932693 }
26942694 return self.base.file.?.pwriteAll(mem.sliceAsBytes(&phdr), offset);
26952695 },
26962696 .p64 => {
2697 var phdr = [1]elf.Elf64_Phdr{self.program_headers.items[index]};
2697 var phdr = [1]elf.Elf64_Phdr{self.phdrs.items[index]};
26982698 if (foreign_endian) {
26992699 mem.byteSwapAllFields(elf.Elf64_Phdr, &phdr[0]);
27002700 }
src/link/Elf/Atom.zig+2-4
......@@ -79,8 +79,6 @@ pub fn freeRelocations(elf_file: *Elf, atom_index: Index) void {
7979}
8080
8181pub fn allocate(self: *Atom, elf_file: *Elf) !void {
82 const phdr_index = elf_file.sections.items(.phdr_index)[self.output_section_index];
83 const phdr = &elf_file.program_headers.items[phdr_index];
8482 const shdr = &elf_file.sections.items(.shdr)[self.output_section_index];
8583 const free_list = &elf_file.sections.items(.free_list)[self.output_section_index];
8684 const last_atom_index = &elf_file.sections.items(.last_atom_index)[self.output_section_index];
......@@ -141,7 +139,7 @@ pub fn allocate(self: *Atom, elf_file: *Elf) !void {
141139 atom_placement = last.atom_index;
142140 break :blk new_start_vaddr;
143141 } else {
144 break :blk phdr.p_vaddr;
142 break :blk shdr.sh_addr;
145143 }
146144 };
147145
......@@ -150,7 +148,7 @@ pub fn allocate(self: *Atom, elf_file: *Elf) !void {
150148 else
151149 true;
152150 if (expand_section) {
153 const needed_size = (self.value + self.size) - phdr.p_vaddr;
151 const needed_size = (self.value + self.size) - shdr.sh_addr;
154152 try elf_file.growAllocSection(self.output_section_index, needed_size);
155153 last_atom_index.* = self.atom_index;
156154