Commit d9147b91a601ad2442aaa43f4dba2d01b25d803d | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-08-26 19:25:23-07:00
committer	GitHub <noreply@github.com> 2024-08-26 19:25:23-07:00
log	d9147b91a601ad2442aaa43f4dba2d01b25d803d
tree	26f06816d827f4fd82772816dd4a33e2f7a465b6
parent	492cc2ef8d1d21d96e25541c22ab885a31c62770
parent	1254509d78d8dd3d6eb7922bbb924084eae826fd
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #21212 from ziglang/elf-incr

elf: cleanups, cleanups, cleanups

12 files changed, 738 insertions(+), 854 deletions(-)

src
- link

src/link/Dwarf.zig+4-4

...	...	@@ -317,7 +317,7 @@ pub const Section = struct {
317	317	fn resize(sec: Section, dwarf: Dwarf, len: u64) UpdateError!void {
318	318	if (dwarf.bin_file.cast(.elf)) \|elf_file\| {
319	319	try elf_file.growNonAllocSection(sec.index, len, @intCast(sec.alignment.toByteUnits().?), true);
320		const shdr = &elf_file.shdrs.items[sec.index];
	320	const shdr = &elf_file.sections.items(.shdr)[sec.index];
321	321	sec.off = shdr.sh_offset;
322	322	sec.len = shdr.sh_size;
323	323	} else if (dwarf.bin_file.cast(.macho)) \|macho_file\| {
...	...	@@ -340,7 +340,7 @@ pub const Section = struct {
340	340	sec.off += len;
341	341	sec.len -= len;
342	342	if (dwarf.bin_file.cast(.elf)) \|elf_file\| {
343		const shdr = &elf_file.shdrs.items[sec.index];
	343	const shdr = &elf_file.sections.items(.shdr)[sec.index];
344	344	shdr.sh_offset = sec.off;
345	345	shdr.sh_size = sec.len;
346	346	} else if (dwarf.bin_file.cast(.macho)) \|macho_file\| {
...	...	@@ -771,7 +771,7 @@ const Entry = struct {
771	771	log.err("missing {} from {s}", .{
772	772	@as(Entry.Index, @enumFromInt(entry - unit.entries.items.ptr)),
773	773	std.mem.sliceTo(if (dwarf.bin_file.cast(.elf)) \|elf_file\|
774		elf_file.shstrtab.items[elf_file.shdrs.items[sec.index].sh_name..]
	774	elf_file.shstrtab.items[elf_file.sections.items(.shdr)[sec.index].sh_name..]
775	775	else if (dwarf.bin_file.cast(.macho)) \|macho_file\|
776	776	if (macho_file.d_sym) \|*d_sym\|
777	777	&d_sym.sections.items[sec.index].segname
...	...	@@ -1529,7 +1529,7 @@ pub fn reloadSectionMetadata(dwarf: *Dwarf) void {
1529	1529	elf_file.debug_rnglists_section_index.?,
1530	1530	elf_file.debug_str_section_index.?,
1531	1531	}) \|sec, section_index\| {
1532		const shdr = &elf_file.shdrs.items[section_index];
	1532	const shdr = &elf_file.sections.items(.shdr)[section_index];
1533	1533	sec.index = section_index;
1534	1534	sec.off = shdr.sh_offset;
1535	1535	sec.len = shdr.sh_size;

src/link/Elf.zig+213-623

...	...	@@ -45,17 +45,10 @@ linker_defined_index: ?File.Index = null,
45	45	objects: std.ArrayListUnmanaged(File.Index) = .{},
46	46	shared_objects: std.ArrayListUnmanaged(File.Index) = .{},
47	47
48		/// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
49		/// Same order as in the file.
50		shdrs: std.ArrayListUnmanaged(elf.Elf64_Shdr) = .{},
51		/// Given index to a section, pulls index of containing phdr if any.
52		phdr_to_shdr_table: std.AutoHashMapUnmanaged(u32, u32) = .{},
	48	/// List of all output sections and their associated metadata.
	49	sections: std.MultiArrayList(Section) = .{},
53	50	/// File offset into the shdr table.
54	51	shdr_table_offset: ?u64 = null,
55		/// Table of lists of atoms per output section.
56		/// This table is not used to track incrementally generated atoms.
57		output_sections: std.AutoArrayHashMapUnmanaged(u32, std.ArrayListUnmanaged(Ref)) = .{},
58		output_rela_sections: std.AutoArrayHashMapUnmanaged(u32, RelaSection) = .{},
59	52
60	53	/// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
61	54	/// Same order as in the file.
...	...	@@ -181,9 +174,6 @@ thunks: std.ArrayListUnmanaged(Thunk) = .{},
181	174	/// List of output merge sections with deduped contents.
182	175	merge_sections: std.ArrayListUnmanaged(MergeSection) = .{},
183	176
184		/// Table of last atom index in a section and matching atom free list if any.
185		last_atom_and_free_list_table: LastAtomAndFreeListTable = .{},
186
187	177	first_eflags: ?elf.Elf64_Word = null,
188	178
189	179	/// When allocating, the ideal_capacity is calculated by
...	...	@@ -387,8 +377,7 @@ pub fn createEmpty(
387	377	)}),
388	378	} });
389	379	self.zig_object_index = index;
390		try self.zigObjectPtr().?.init(self);
391		try self.initMetadata(.{
	380	try self.zigObjectPtr().?.init(self, .{
392	381	.symbol_count_hint = options.symbol_count_hint,
393	382	.program_code_size_hint = options.program_code_size_hint,
394	383	});
...	...	@@ -430,17 +419,12 @@ pub fn deinit(self: *Elf) void {
430	419	self.objects.deinit(gpa);
431	420	self.shared_objects.deinit(gpa);
432	421
433		self.shdrs.deinit(gpa);
434		self.phdr_to_shdr_table.deinit(gpa);
435		self.phdrs.deinit(gpa);
436		for (self.output_sections.values()) \|*list\| {
437		list.deinit(gpa);
	422	for (self.sections.items(.atom_list), self.sections.items(.free_list)) \|atoms, free_list\| {
	423	atoms.deinit(gpa);
	424	free_list.deinit(gpa);
438	425	}
439		self.output_sections.deinit(gpa);
440		for (self.output_rela_sections.values()) \|*sec\| {
441		sec.atom_list.deinit(gpa);
442		}
443		self.output_rela_sections.deinit(gpa);
	426	self.sections.deinit(gpa);
	427	self.phdrs.deinit(gpa);
444	428	self.shstrtab.deinit(gpa);
445	429	self.symtab.deinit(gpa);
446	430	self.strtab.deinit(gpa);
...	...	@@ -454,10 +438,6 @@ pub fn deinit(self: *Elf) void {
454	438	sect.deinit(gpa);
455	439	}
456	440	self.merge_sections.deinit(gpa);
457		for (self.last_atom_and_free_list_table.values()) \|*value\| {
458		value.free_list.deinit(gpa);
459		}
460		self.last_atom_and_free_list_table.deinit(gpa);
461	441
462	442	self.got.deinit(gpa);
463	443	self.plt.deinit(gpa);
...	...	@@ -506,7 +486,7 @@ fn detectAllocCollision(self: *Elf, start: u64, size: u64) !?u64 {
506	486
507	487	if (self.shdr_table_offset) \|off\| {
508	488	const shdr_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Shdr) else @sizeOf(elf.Elf64_Shdr);
509		const tight_size = self.shdrs.items.len * shdr_size;
	489	const tight_size = self.sections.items(.shdr).len * shdr_size;
510	490	const increased_size = padToIdeal(tight_size);
511	491	const test_end = off +\| increased_size;
512	492	if (start < test_end) {
...	...	@@ -515,7 +495,7 @@ fn detectAllocCollision(self: *Elf, start: u64, size: u64) !?u64 {
515	495	}
516	496	}
517	497
518		for (self.shdrs.items) \|shdr\| {
	498	for (self.sections.items(.shdr)) \|shdr\| {
519	499	if (shdr.sh_type == elf.SHT_NOBITS) continue;
520	500	const increased_size = padToIdeal(shdr.sh_size);
521	501	const test_end = shdr.sh_offset +\| increased_size;
...	...	@@ -545,7 +525,7 @@ pub fn allocatedSize(self: *Elf, start: u64) u64 {
545	525	if (self.shdr_table_offset) \|off\| {
546	526	if (off > start and off < min_pos) min_pos = off;
547	527	}
548		for (self.shdrs.items) \|section\| {
	528	for (self.sections.items(.shdr)) \|section\| {
549	529	if (section.sh_offset <= start) continue;
550	530	if (section.sh_offset < min_pos) min_pos = section.sh_offset;
551	531	}
...	...	@@ -574,318 +554,13 @@ pub fn findFreeSpace(self: *Elf, object_size: u64, min_alignment: u64) !u64 {
574	554	return start;
575	555	}
576	556
577		pub const InitMetadataOptions = struct {
578		symbol_count_hint: u64,
579		program_code_size_hint: u64,
580		};
581
582		/// TODO move to ZigObject
583		pub fn initMetadata(self: *Elf, options: InitMetadataOptions) !void {
584		const gpa = self.base.comp.gpa;
585		const ptr_size = self.ptrWidthBytes();
586		const target = self.base.comp.root_mod.resolved_target.result;
587		const ptr_bit_width = target.ptrBitWidth();
588		const zo = self.zigObjectPtr().?;
589
590		const fillSection = struct {
591		fn fillSection(elf_file: Elf, shdr: elf.Elf64_Shdr, size: u64, phndx: ?u16) !void {
592		if (elf_file.base.isRelocatable()) {
593		const off = try elf_file.findFreeSpace(size, shdr.sh_addralign);
594		shdr.sh_offset = off;
595		shdr.sh_size = size;
596		} else {
597		const phdr = elf_file.phdrs.items[phndx.?];
598		shdr.sh_addr = phdr.p_vaddr;
599		shdr.sh_offset = phdr.p_offset;
600		shdr.sh_size = phdr.p_memsz;
601		}
602		}
603		}.fillSection;
604
605		comptime assert(number_of_zig_segments == 5);
606
607		if (!self.base.isRelocatable()) {
608		if (self.phdr_zig_load_re_index == null) {
609		const filesz = options.program_code_size_hint;
610		const off = try self.findFreeSpace(filesz, self.page_size);
611		self.phdr_zig_load_re_index = try self.addPhdr(.{
612		.type = elf.PT_LOAD,
613		.offset = off,
614		.filesz = filesz,
615		.addr = if (ptr_bit_width >= 32) 0x4000000 else 0x4000,
616		.memsz = filesz,
617		.@"align" = self.page_size,
618		.flags = elf.PF_X \| elf.PF_R \| elf.PF_W,
619		});
620		}
621
622		if (self.phdr_zig_load_ro_index == null) {
623		const alignment = self.page_size;
624		const filesz: u64 = 1024;
625		const off = try self.findFreeSpace(filesz, alignment);
626		self.phdr_zig_load_ro_index = try self.addPhdr(.{
627		.type = elf.PT_LOAD,
628		.offset = off,
629		.filesz = filesz,
630		.addr = if (ptr_bit_width >= 32) 0xc000000 else 0xa000,
631		.memsz = filesz,
632		.@"align" = alignment,
633		.flags = elf.PF_R \| elf.PF_W,
634		});
635		}
636
637		if (self.phdr_zig_load_rw_index == null) {
638		const alignment = self.page_size;
639		const filesz: u64 = 1024;
640		const off = try self.findFreeSpace(filesz, alignment);
641		self.phdr_zig_load_rw_index = try self.addPhdr(.{
642		.type = elf.PT_LOAD,
643		.offset = off,
644		.filesz = filesz,
645		.addr = if (ptr_bit_width >= 32) 0x10000000 else 0xc000,
646		.memsz = filesz,
647		.@"align" = alignment,
648		.flags = elf.PF_R \| elf.PF_W,
649		});
650		}
651
652		if (self.phdr_zig_load_zerofill_index == null) {
653		const alignment = self.page_size;
654		self.phdr_zig_load_zerofill_index = try self.addPhdr(.{
655		.type = elf.PT_LOAD,
656		.addr = if (ptr_bit_width >= 32) 0x14000000 else 0xf000,
657		.memsz = 1024,
658		.@"align" = alignment,
659		.flags = elf.PF_R \| elf.PF_W,
660		});
661		}
662		}
663
664		if (self.zig_text_section_index == null) {
665		self.zig_text_section_index = try self.addSection(.{
666		.name = try self.insertShString(".text.zig"),
667		.type = elf.SHT_PROGBITS,
668		.flags = elf.SHF_ALLOC \| elf.SHF_EXECINSTR,
669		.addralign = 1,
670		.offset = std.math.maxInt(u64),
671		});
672		const shdr = &self.shdrs.items[self.zig_text_section_index.?];
673		try fillSection(self, shdr, options.program_code_size_hint, self.phdr_zig_load_re_index);
674		if (self.base.isRelocatable()) {
675		const rela_shndx = try self.addRelaShdr(try self.insertShString(".rela.text.zig"), self.zig_text_section_index.?);
676		try self.output_rela_sections.putNoClobber(gpa, self.zig_text_section_index.?, .{
677		.shndx = rela_shndx,
678		});
679		} else {
680		try self.phdr_to_shdr_table.putNoClobber(
681		gpa,
682		self.zig_text_section_index.?,
683		self.phdr_zig_load_re_index.?,
684		);
685		}
686		try self.output_sections.putNoClobber(gpa, self.zig_text_section_index.?, .{});
687		try self.last_atom_and_free_list_table.putNoClobber(gpa, self.zig_text_section_index.?, .{});
688		}
689
690		if (self.zig_data_rel_ro_section_index == null) {
691		self.zig_data_rel_ro_section_index = try self.addSection(.{
692		.name = try self.insertShString(".data.rel.ro.zig"),
693		.type = elf.SHT_PROGBITS,
694		.addralign = 1,
695		.flags = elf.SHF_ALLOC \| elf.SHF_WRITE,
696		.offset = std.math.maxInt(u64),
697		});
698		const shdr = &self.shdrs.items[self.zig_data_rel_ro_section_index.?];
699		try fillSection(self, shdr, 1024, self.phdr_zig_load_ro_index);
700		if (self.base.isRelocatable()) {
701		const rela_shndx = try self.addRelaShdr(
702		try self.insertShString(".rela.data.rel.ro.zig"),
703		self.zig_data_rel_ro_section_index.?,
704		);
705		try self.output_rela_sections.putNoClobber(gpa, self.zig_data_rel_ro_section_index.?, .{
706		.shndx = rela_shndx,
707		});
708		} else {
709		try self.phdr_to_shdr_table.putNoClobber(
710		gpa,
711		self.zig_data_rel_ro_section_index.?,
712		self.phdr_zig_load_ro_index.?,
713		);
714		}
715		try self.output_sections.putNoClobber(gpa, self.zig_data_rel_ro_section_index.?, .{});
716		try self.last_atom_and_free_list_table.putNoClobber(gpa, self.zig_data_rel_ro_section_index.?, .{});
717		}
718
719		if (self.zig_data_section_index == null) {
720		self.zig_data_section_index = try self.addSection(.{
721		.name = try self.insertShString(".data.zig"),
722		.type = elf.SHT_PROGBITS,
723		.addralign = ptr_size,
724		.flags = elf.SHF_ALLOC \| elf.SHF_WRITE,
725		.offset = std.math.maxInt(u64),
726		});
727		const shdr = &self.shdrs.items[self.zig_data_section_index.?];
728		try fillSection(self, shdr, 1024, self.phdr_zig_load_rw_index);
729		if (self.base.isRelocatable()) {
730		const rela_shndx = try self.addRelaShdr(
731		try self.insertShString(".rela.data.zig"),
732		self.zig_data_section_index.?,
733		);
734		try self.output_rela_sections.putNoClobber(gpa, self.zig_data_section_index.?, .{
735		.shndx = rela_shndx,
736		});
737		} else {
738		try self.phdr_to_shdr_table.putNoClobber(
739		gpa,
740		self.zig_data_section_index.?,
741		self.phdr_zig_load_rw_index.?,
742		);
743		}
744		try self.output_sections.putNoClobber(gpa, self.zig_data_section_index.?, .{});
745		try self.last_atom_and_free_list_table.putNoClobber(gpa, self.zig_data_section_index.?, .{});
746		}
747
748		if (self.zig_bss_section_index == null) {
749		self.zig_bss_section_index = try self.addSection(.{
750		.name = try self.insertShString(".bss.zig"),
751		.type = elf.SHT_NOBITS,
752		.addralign = ptr_size,
753		.flags = elf.SHF_ALLOC \| elf.SHF_WRITE,
754		.offset = 0,
755		});
756		const shdr = &self.shdrs.items[self.zig_bss_section_index.?];
757		if (self.phdr_zig_load_zerofill_index) \|phndx\| {
758		const phdr = self.phdrs.items[phndx];
759		shdr.sh_addr = phdr.p_vaddr;
760		shdr.sh_size = phdr.p_memsz;
761		try self.phdr_to_shdr_table.putNoClobber(gpa, self.zig_bss_section_index.?, phndx);
762		} else {
763		shdr.sh_size = 1024;
764		}
765		try self.output_sections.putNoClobber(gpa, self.zig_bss_section_index.?, .{});
766		try self.last_atom_and_free_list_table.putNoClobber(gpa, self.zig_bss_section_index.?, .{});
767		}
768
769		if (zo.dwarf) \|*dwarf\| {
770		const addSectionSymbol = struct {
771		fn addSectionSymbol(
772		zig_object: *ZigObject,
773		alloc: Allocator,
774		name: [:0]const u8,
775		alignment: Atom.Alignment,
776		shndx: u32,
777		) !Symbol.Index {
778		const name_off = try zig_object.addString(alloc, name);
779		const index = try zig_object.newSymbolWithAtom(alloc, name_off);
780		const sym = zig_object.symbol(index);
781		const esym = &zig_object.symtab.items(.elf_sym)[sym.esym_index];
782		esym.st_info \|= elf.STT_SECTION;
783		const atom_ptr = zig_object.atom(sym.ref.index).?;
784		atom_ptr.alignment = alignment;
785		atom_ptr.output_section_index = shndx;
786		return index;
787		}
788		}.addSectionSymbol;
789
790		if (self.debug_str_section_index == null) {
791		self.debug_str_section_index = try self.addSection(.{
792		.name = try self.insertShString(".debug_str"),
793		.flags = elf.SHF_MERGE \| elf.SHF_STRINGS,
794		.entsize = 1,
795		.type = elf.SHT_PROGBITS,
796		.addralign = 1,
797		});
798		zo.debug_str_section_dirty = true;
799		zo.debug_str_index = try addSectionSymbol(zo, gpa, ".debug_str", .@"1", self.debug_str_section_index.?);
800		try self.output_sections.putNoClobber(gpa, self.debug_str_section_index.?, .{});
801		}
802
803		if (self.debug_info_section_index == null) {
804		self.debug_info_section_index = try self.addSection(.{
805		.name = try self.insertShString(".debug_info"),
806		.type = elf.SHT_PROGBITS,
807		.addralign = 1,
808		});
809		zo.debug_info_section_dirty = true;
810		zo.debug_info_index = try addSectionSymbol(zo, gpa, ".debug_info", .@"1", self.debug_info_section_index.?);
811		try self.output_sections.putNoClobber(gpa, self.debug_info_section_index.?, .{});
812		}
813
814		if (self.debug_abbrev_section_index == null) {
815		self.debug_abbrev_section_index = try self.addSection(.{
816		.name = try self.insertShString(".debug_abbrev"),
817		.type = elf.SHT_PROGBITS,
818		.addralign = 1,
819		});
820		zo.debug_abbrev_section_dirty = true;
821		zo.debug_abbrev_index = try addSectionSymbol(zo, gpa, ".debug_abbrev", .@"1", self.debug_abbrev_section_index.?);
822		try self.output_sections.putNoClobber(gpa, self.debug_abbrev_section_index.?, .{});
823		}
824
825		if (self.debug_aranges_section_index == null) {
826		self.debug_aranges_section_index = try self.addSection(.{
827		.name = try self.insertShString(".debug_aranges"),
828		.type = elf.SHT_PROGBITS,
829		.addralign = 16,
830		});
831		zo.debug_aranges_section_dirty = true;
832		zo.debug_aranges_index = try addSectionSymbol(zo, gpa, ".debug_aranges", .@"16", self.debug_aranges_section_index.?);
833		try self.output_sections.putNoClobber(gpa, self.debug_aranges_section_index.?, .{});
834		}
835
836		if (self.debug_line_section_index == null) {
837		self.debug_line_section_index = try self.addSection(.{
838		.name = try self.insertShString(".debug_line"),
839		.type = elf.SHT_PROGBITS,
840		.addralign = 1,
841		});
842		zo.debug_line_section_dirty = true;
843		zo.debug_line_index = try addSectionSymbol(zo, gpa, ".debug_line", .@"1", self.debug_line_section_index.?);
844		try self.output_sections.putNoClobber(gpa, self.debug_line_section_index.?, .{});
845		}
846
847		if (self.debug_line_str_section_index == null) {
848		self.debug_line_str_section_index = try self.addSection(.{
849		.name = try self.insertShString(".debug_line_str"),
850		.flags = elf.SHF_MERGE \| elf.SHF_STRINGS,
851		.entsize = 1,
852		.type = elf.SHT_PROGBITS,
853		.addralign = 1,
854		});
855		zo.debug_line_str_section_dirty = true;
856		zo.debug_line_str_index = try addSectionSymbol(zo, gpa, ".debug_line_str", .@"1", self.debug_line_str_section_index.?);
857		try self.output_sections.putNoClobber(gpa, self.debug_line_str_section_index.?, .{});
858		}
859
860		if (self.debug_loclists_section_index == null) {
861		self.debug_loclists_section_index = try self.addSection(.{
862		.name = try self.insertShString(".debug_loclists"),
863		.type = elf.SHT_PROGBITS,
864		.addralign = 1,
865		});
866		zo.debug_loclists_section_dirty = true;
867		zo.debug_loclists_index = try addSectionSymbol(zo, gpa, ".debug_loclists", .@"1", self.debug_loclists_section_index.?);
868		try self.output_sections.putNoClobber(gpa, self.debug_loclists_section_index.?, .{});
869		}
870
871		if (self.debug_rnglists_section_index == null) {
872		self.debug_rnglists_section_index = try self.addSection(.{
873		.name = try self.insertShString(".debug_rnglists"),
874		.type = elf.SHT_PROGBITS,
875		.addralign = 1,
876		});
877		zo.debug_rnglists_section_dirty = true;
878		zo.debug_rnglists_index = try addSectionSymbol(zo, gpa, ".debug_rnglists", .@"1", self.debug_rnglists_section_index.?);
879		try self.output_sections.putNoClobber(gpa, self.debug_rnglists_section_index.?, .{});
880		}
881
882		try dwarf.initMetadata();
883		}
884		}
885
886	557	pub fn growAllocSection(self: *Elf, shdr_index: u32, needed_size: u64) !void {
887		const shdr = &self.shdrs.items[shdr_index];
888		const maybe_phdr = if (self.phdr_to_shdr_table.get(shdr_index)) \|phndx\| &self.phdrs.items[phndx] else null;
	558	const slice = self.sections.slice();
	559	const shdr = &slice.items(.shdr)[shdr_index];
	560	assert(shdr.sh_flags & elf.SHF_ALLOC != 0);
	561	const phndx = slice.items(.phndx)[shdr_index];
	562	const maybe_phdr = if (phndx) \|ndx\| &self.phdrs.items[ndx] else null;
	563
889	564	log.debug("allocated size {x} of {s}, needed size {x}", .{
890	565	self.allocatedSize(shdr.sh_offset),
891	566	self.getShString(shdr.sh_name),
...	...	@@ -924,9 +599,7 @@ pub fn growAllocSection(self: *Elf, shdr_index: u32, needed_size: u64) !void {
924	599	const mem_capacity = self.allocatedVirtualSize(phdr.p_vaddr);
925	600	if (needed_size > mem_capacity) {
926	601	var err = try self.base.addErrorWithNotes(2);
927		try err.addMsg("fatal linker error: cannot expand load segment phdr({d}) in virtual memory", .{
928		self.phdr_to_shdr_table.get(shdr_index).?,
929		});
	602	try err.addMsg("fatal linker error: cannot expand load segment phdr({d}) in virtual memory", .{phndx.?});
930	603	try err.addNote("TODO: emit relocations to memory locations in self-hosted backends", .{});
931	604	try err.addNote("as a workaround, try increasing pre-allocated virtual memory of each segment", .{});
932	605	}
...	...	@@ -944,7 +617,8 @@ pub fn growNonAllocSection(
944	617	min_alignment: u32,
945	618	requires_file_copy: bool,
946	619	) !void {
947		const shdr = &self.shdrs.items[shdr_index];
	620	const shdr = &self.sections.items(.shdr)[shdr_index];
	621	assert(shdr.sh_flags & elf.SHF_ALLOC == 0);
948	622
949	623	const allocated_size = self.allocatedSize(shdr.sh_offset);
950	624	if (shdr.sh_offset + allocated_size == std.math.maxInt(u64)) {
...	...	@@ -1328,7 +1002,7 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
1328	1002	const atom_ptr = zo.atom(atom_index) orelse continue;
1329	1003	if (!atom_ptr.alive) continue;
1330	1004	const out_shndx = atom_ptr.output_section_index;
1331		const shdr = &self.shdrs.items[out_shndx];
	1005	const shdr = &self.sections.items(.shdr)[out_shndx];
1332	1006	if (shdr.sh_type == elf.SHT_NOBITS) continue;
1333	1007	const code = try zo.codeAlloc(self, atom_index);
1334	1008	defer gpa.free(code);
...	...	@@ -2692,7 +2366,7 @@ pub fn writeShdrTable(self: *Elf) !void {
2692	2366	};
2693	2367
2694	2368	const shoff = self.shdr_table_offset orelse 0;
2695		const needed_size = self.shdrs.items.len * shsize;
	2369	const needed_size = self.sections.items(.shdr).len * shsize;
2696	2370
2697	2371	if (needed_size > self.allocatedSize(shoff)) {
2698	2372	self.shdr_table_offset = null;
...	...	@@ -2706,12 +2380,12 @@ pub fn writeShdrTable(self: *Elf) !void {
2706	2380
2707	2381	switch (self.ptr_width) {
2708	2382	.p32 => {
2709		const buf = try gpa.alloc(elf.Elf32_Shdr, self.shdrs.items.len);
	2383	const buf = try gpa.alloc(elf.Elf32_Shdr, self.sections.items(.shdr).len);
2710	2384	defer gpa.free(buf);
2711	2385
2712	2386	for (buf, 0..) \|*shdr, i\| {
2713		assert(self.shdrs.items[i].sh_offset != math.maxInt(u64));
2714		shdr.* = shdrTo32(self.shdrs.items[i]);
	2387	assert(self.sections.items(.shdr)[i].sh_offset != math.maxInt(u64));
	2388	shdr.* = shdrTo32(self.sections.items(.shdr)[i]);
2715	2389	if (foreign_endian) {
2716	2390	mem.byteSwapAllFields(elf.Elf32_Shdr, shdr);
2717	2391	}
...	...	@@ -2719,12 +2393,12 @@ pub fn writeShdrTable(self: *Elf) !void {
2719	2393	try self.base.file.?.pwriteAll(mem.sliceAsBytes(buf), self.shdr_table_offset.?);
2720	2394	},
2721	2395	.p64 => {
2722		const buf = try gpa.alloc(elf.Elf64_Shdr, self.shdrs.items.len);
	2396	const buf = try gpa.alloc(elf.Elf64_Shdr, self.sections.items(.shdr).len);
2723	2397	defer gpa.free(buf);
2724	2398
2725	2399	for (buf, 0..) \|*shdr, i\| {
2726		assert(self.shdrs.items[i].sh_offset != math.maxInt(u64));
2727		shdr.* = self.shdrs.items[i];
	2400	assert(self.sections.items(.shdr)[i].sh_offset != math.maxInt(u64));
	2401	shdr.* = self.sections.items(.shdr)[i];
2728	2402	if (foreign_endian) {
2729	2403	mem.byteSwapAllFields(elf.Elf64_Shdr, shdr);
2730	2404	}
...	...	@@ -2892,7 +2566,7 @@ pub fn writeElfHeader(self: *Elf) !void {
2892	2566	mem.writeInt(u16, hdr_buf[index..][0..2], e_shentsize, endian);
2893	2567	index += 2;
2894	2568
2895		const e_shnum = @as(u16, @intCast(self.shdrs.items.len));
	2569	const e_shnum = @as(u16, @intCast(self.sections.items(.shdr).len));
2896	2570	mem.writeInt(u16, hdr_buf[index..][0..2], e_shnum, endian);
2897	2571	index += 2;
2898	2572
...	...	@@ -3051,7 +2725,7 @@ pub fn updateMergeSectionSizes(self: *Elf) !void {
3051	2725	msec.updateSize();
3052	2726	}
3053	2727	for (self.merge_sections.items) \|*msec\| {
3054		const shdr = &self.shdrs.items[msec.output_section_index];
	2728	const shdr = &self.sections.items(.shdr)[msec.output_section_index];
3055	2729	const offset = msec.alignment.forward(shdr.sh_size);
3056	2730	const padding = offset - shdr.sh_size;
3057	2731	msec.value = @intCast(offset);
...	...	@@ -3067,7 +2741,7 @@ pub fn writeMergeSections(self: *Elf) !void {
3067	2741	defer buffer.deinit();
3068	2742
3069	2743	for (self.merge_sections.items) \|*msec\| {
3070		const shdr = self.shdrs.items[msec.output_section_index];
	2744	const shdr = self.sections.items(.shdr)[msec.output_section_index];
3071	2745	const fileoff = math.cast(usize, msec.value + shdr.sh_offset) orelse return error.Overflow;
3072	2746	const size = math.cast(usize, msec.size) orelse return error.Overflow;
3073	2747	try buffer.ensureTotalCapacity(size);
...	...	@@ -3355,7 +3029,7 @@ fn initSpecialPhdrs(self: *Elf) !void {
3355	3029	.@"align" = 1,
3356	3030	});
3357	3031
3358		const has_tls = for (self.shdrs.items) \|shdr\| {
	3032	const has_tls = for (self.sections.items(.shdr)) \|shdr\| {
3359	3033	if (shdr.sh_flags & elf.SHF_TLS != 0) break true;
3360	3034	} else false;
3361	3035	if (has_tls) {
...	...	@@ -3384,6 +3058,7 @@ fn initSpecialPhdrs(self: *Elf) !void {
3384	3058	/// we are about to sort.
3385	3059	fn sortInitFini(self: *Elf) !void {
3386	3060	const gpa = self.base.comp.gpa;
	3061	const slice = self.sections.slice();
3387	3062
3388	3063	const Entry = struct {
3389	3064	priority: i32,
...	...	@@ -3397,7 +3072,7 @@ fn sortInitFini(self: *Elf) !void {
3397	3072	}
3398	3073	};
3399	3074
3400		for (self.shdrs.items, 0..) \|shdr, shndx\| {
	3075	for (slice.items(.shdr), slice.items(.atom_list)) \|shdr, *atom_list\| {
3401	3076	if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
3402	3077
3403	3078	var is_init_fini = false;
...	...	@@ -3414,8 +3089,6 @@ fn sortInitFini(self: *Elf) !void {
3414	3089	}
3415	3090
3416	3091	if (!is_init_fini and !is_ctor_dtor) continue;
3417
3418		const atom_list = self.output_sections.getPtr(@intCast(shndx)).?;
3419	3092	if (atom_list.items.len == 0) continue;
3420	3093
3421	3094	var entries = std.ArrayList(Entry).init(gpa);
...	...	@@ -3483,7 +3156,7 @@ fn setVersionSymtab(self: *Elf) !void {
3483	3156
3484	3157	if (self.verneed_section_index) \|shndx\| {
3485	3158	try self.verneed.generate(self);
3486		const shdr = &self.shdrs.items[shndx];
	3159	const shdr = &self.sections.items(.shdr)[shndx];
3487	3160	shdr.sh_info = @as(u32, @intCast(self.verneed.verneed.items.len));
3488	3161	}
3489	3162	}
...	...	@@ -3563,16 +3236,15 @@ fn sortPhdrs(self: *Elf) error{OutOfMemory}!void {
3563	3236	}
3564	3237	}
3565	3238
3566		{
3567		var it = self.phdr_to_shdr_table.iterator();
3568		while (it.next()) \|entry\| {
3569		entry.value_ptr.* = backlinks[entry.value_ptr.*];
	3239	for (self.sections.items(.phndx)) \|*maybe_phndx\| {
	3240	if (maybe_phndx.) \|index\| {
	3241	index.* = backlinks[index.*];
3570	3242	}
3571	3243	}
3572	3244	}
3573	3245
3574	3246	fn shdrRank(self: *Elf, shndx: u32) u8 {
3575		const shdr = self.shdrs.items[shndx];
	3247	const shdr = self.sections.items(.shdr)[shndx];
3576	3248	const name = self.getShString(shdr.sh_name);
3577	3249	const flags = shdr.sh_flags;
3578	3250
...	...	@@ -3629,9 +3301,9 @@ pub fn sortShdrs(self: *Elf) !void {
3629	3301	};
3630	3302
3631	3303	const gpa = self.base.comp.gpa;
3632		var entries = try std.ArrayList(Entry).initCapacity(gpa, self.shdrs.items.len);
	3304	var entries = try std.ArrayList(Entry).initCapacity(gpa, self.sections.items(.shdr).len);
3633	3305	defer entries.deinit();
3634		for (0..self.shdrs.items.len) \|shndx\| {
	3306	for (0..self.sections.items(.shdr).len) \|shndx\| {
3635	3307	entries.appendAssumeCapacity(.{ .shndx = @intCast(shndx) });
3636	3308	}
3637	3309
...	...	@@ -3643,20 +3315,18 @@ pub fn sortShdrs(self: *Elf) !void {
3643	3315	backlinks[entry.shndx] = @intCast(i);
3644	3316	}
3645	3317
3646		const slice = try self.shdrs.toOwnedSlice(gpa);
3647		defer gpa.free(slice);
	3318	var slice = self.sections.toOwnedSlice();
	3319	defer slice.deinit(gpa);
3648	3320
3649		try self.shdrs.ensureTotalCapacityPrecise(gpa, slice.len);
	3321	try self.sections.ensureTotalCapacity(gpa, slice.len);
3650	3322	for (entries.items) \|sorted\| {
3651		self.shdrs.appendAssumeCapacity(slice[sorted.shndx]);
	3323	self.sections.appendAssumeCapacity(slice.get(sorted.shndx));
3652	3324	}
3653	3325
3654		try self.resetShdrIndexes(backlinks);
	3326	self.resetShdrIndexes(backlinks);
3655	3327	}
3656	3328
3657		fn resetShdrIndexes(self: *Elf, backlinks: []const u32) !void {
3658		const gpa = self.base.comp.gpa;
3659
	3329	fn resetShdrIndexes(self: *Elf, backlinks: []const u32) void {
3660	3330	for (&[_]*?u32{
3661	3331	&self.eh_frame_section_index,
3662	3332	&self.eh_frame_rela_section_index,
...	...	@@ -3697,142 +3367,88 @@ fn resetShdrIndexes(self: *Elf, backlinks: []const u32) !void {
3697	3367	}
3698	3368	}
3699	3369
	3370	for (self.merge_sections.items) \|*msec\| {
	3371	msec.output_section_index = backlinks[msec.output_section_index];
	3372	}
	3373
	3374	for (self.sections.items(.shdr)) \|*shdr\| {
	3375	if (shdr.sh_type != elf.SHT_RELA) continue;
	3376	// FIXME:JK we should spin up .symtab potentially earlier, or set all non-dynamic RELA sections
	3377	// to point at symtab
	3378	// shdr.sh_link = backlinks[shdr.sh_link];
	3379	shdr.sh_link = self.symtab_section_index.?;
	3380	shdr.sh_info = backlinks[shdr.sh_info];
	3381	}
	3382
	3383	if (self.zigObjectPtr()) \|zo\| {
	3384	for (zo.atoms_indexes.items) \|atom_index\| {
	3385	const atom_ptr = zo.atom(atom_index) orelse continue;
	3386	atom_ptr.output_section_index = backlinks[atom_ptr.output_section_index];
	3387	}
	3388	if (zo.dwarf) \|*dwarf\| dwarf.reloadSectionMetadata();
	3389	}
	3390
	3391	for (self.comdat_group_sections.items) \|*cg\| {
	3392	cg.shndx = backlinks[cg.shndx];
	3393	}
	3394
3700	3395	if (self.symtab_section_index) \|index\| {
3701		const shdr = &self.shdrs.items[index];
	3396	const shdr = &self.sections.items(.shdr)[index];
3702	3397	shdr.sh_link = self.strtab_section_index.?;
3703	3398	}
3704	3399
3705	3400	if (self.dynamic_section_index) \|index\| {
3706		const shdr = &self.shdrs.items[index];
	3401	const shdr = &self.sections.items(.shdr)[index];
3707	3402	shdr.sh_link = self.dynstrtab_section_index.?;
3708	3403	}
3709	3404
3710	3405	if (self.dynsymtab_section_index) \|index\| {
3711		const shdr = &self.shdrs.items[index];
	3406	const shdr = &self.sections.items(.shdr)[index];
3712	3407	shdr.sh_link = self.dynstrtab_section_index.?;
3713	3408	}
3714	3409
3715	3410	if (self.hash_section_index) \|index\| {
3716		const shdr = &self.shdrs.items[index];
	3411	const shdr = &self.sections.items(.shdr)[index];
3717	3412	shdr.sh_link = self.dynsymtab_section_index.?;
3718	3413	}
3719	3414
3720	3415	if (self.gnu_hash_section_index) \|index\| {
3721		const shdr = &self.shdrs.items[index];
	3416	const shdr = &self.sections.items(.shdr)[index];
3722	3417	shdr.sh_link = self.dynsymtab_section_index.?;
3723	3418	}
3724	3419
3725	3420	if (self.versym_section_index) \|index\| {
3726		const shdr = &self.shdrs.items[index];
	3421	const shdr = &self.sections.items(.shdr)[index];
3727	3422	shdr.sh_link = self.dynsymtab_section_index.?;
3728	3423	}
3729	3424
3730	3425	if (self.verneed_section_index) \|index\| {
3731		const shdr = &self.shdrs.items[index];
	3426	const shdr = &self.sections.items(.shdr)[index];
3732	3427	shdr.sh_link = self.dynstrtab_section_index.?;
3733	3428	}
3734	3429
3735	3430	if (self.rela_dyn_section_index) \|index\| {
3736		const shdr = &self.shdrs.items[index];
	3431	const shdr = &self.sections.items(.shdr)[index];
3737	3432	shdr.sh_link = self.dynsymtab_section_index orelse 0;
3738	3433	}
3739	3434
3740	3435	if (self.rela_plt_section_index) \|index\| {
3741		const shdr = &self.shdrs.items[index];
	3436	const shdr = &self.sections.items(.shdr)[index];
3742	3437	shdr.sh_link = self.dynsymtab_section_index.?;
3743	3438	shdr.sh_info = self.plt_section_index.?;
3744	3439	}
3745	3440
3746	3441	if (self.eh_frame_rela_section_index) \|index\| {
3747		const shdr = &self.shdrs.items[index];
	3442	const shdr = &self.sections.items(.shdr)[index];
3748	3443	shdr.sh_link = self.symtab_section_index.?;
3749	3444	shdr.sh_info = self.eh_frame_section_index.?;
3750	3445	}
3751
3752		{
3753		var output_sections = try self.output_sections.clone(gpa);
3754		defer output_sections.deinit(gpa);
3755
3756		self.output_sections.clearRetainingCapacity();
3757
3758		var it = output_sections.iterator();
3759		while (it.next()) \|entry\| {
3760		const shndx = entry.key_ptr.*;
3761		const meta = entry.value_ptr.*;
3762		self.output_sections.putAssumeCapacityNoClobber(backlinks[shndx], meta);
3763		}
3764		}
3765
3766		for (self.merge_sections.items) \|*msec\| {
3767		msec.output_section_index = backlinks[msec.output_section_index];
3768		}
3769
3770		{
3771		var output_rela_sections = try self.output_rela_sections.clone(gpa);
3772		defer output_rela_sections.deinit(gpa);
3773
3774		self.output_rela_sections.clearRetainingCapacity();
3775
3776		var it = output_rela_sections.iterator();
3777		while (it.next()) \|entry\| {
3778		const shndx = entry.key_ptr.*;
3779		var meta = entry.value_ptr.*;
3780		meta.shndx = backlinks[meta.shndx];
3781		self.output_rela_sections.putAssumeCapacityNoClobber(backlinks[shndx], meta);
3782		}
3783		}
3784
3785		{
3786		var last_atom_and_free_list_table = try self.last_atom_and_free_list_table.clone(gpa);
3787		defer last_atom_and_free_list_table.deinit(gpa);
3788
3789		self.last_atom_and_free_list_table.clearRetainingCapacity();
3790
3791		var it = last_atom_and_free_list_table.iterator();
3792		while (it.next()) \|entry\| {
3793		const shndx = entry.key_ptr.*;
3794		const meta = entry.value_ptr.*;
3795		self.last_atom_and_free_list_table.putAssumeCapacityNoClobber(backlinks[shndx], meta);
3796		}
3797		}
3798
3799		{
3800		var phdr_to_shdr_table = try self.phdr_to_shdr_table.clone(gpa);
3801		defer phdr_to_shdr_table.deinit(gpa);
3802
3803		self.phdr_to_shdr_table.clearRetainingCapacity();
3804
3805		var it = phdr_to_shdr_table.iterator();
3806		while (it.next()) \|entry\| {
3807		const shndx = entry.key_ptr.*;
3808		const phndx = entry.value_ptr.*;
3809		self.phdr_to_shdr_table.putAssumeCapacityNoClobber(backlinks[shndx], phndx);
3810		}
3811		}
3812
3813		if (self.zigObjectPtr()) \|zo\| {
3814		for (zo.atoms_indexes.items) \|atom_index\| {
3815		const atom_ptr = zo.atom(atom_index) orelse continue;
3816		atom_ptr.output_section_index = backlinks[atom_ptr.output_section_index];
3817		}
3818		if (zo.dwarf) \|*dwarf\| dwarf.reloadSectionMetadata();
3819		}
3820
3821		for (self.output_rela_sections.keys(), self.output_rela_sections.values()) \|shndx, sec\| {
3822		const shdr = &self.shdrs.items[sec.shndx];
3823		shdr.sh_link = self.symtab_section_index.?;
3824		shdr.sh_info = shndx;
3825		}
3826
3827		for (self.comdat_group_sections.items) \|*cg\| {
3828		cg.shndx = backlinks[cg.shndx];
3829		}
3830	3446	}
3831	3447
3832	3448	fn updateSectionSizes(self: *Elf) !void {
3833	3449	const target = self.base.comp.root_mod.resolved_target.result;
3834		for (self.output_sections.keys(), self.output_sections.values()) \|shndx, atom_list\| {
3835		const shdr = &self.shdrs.items[shndx];
	3450	const slice = self.sections.slice();
	3451	for (slice.items(.shdr), slice.items(.atom_list)) \|*shdr, atom_list\| {
3836	3452	if (atom_list.items.len == 0) continue;
3837	3453	if (self.requiresThunks() and shdr.sh_flags & elf.SHF_EXECINSTR != 0) continue;
3838	3454	for (atom_list.items) \|ref\| {
...	...	@@ -3847,38 +3463,38 @@ fn updateSectionSizes(self: *Elf) !void {
3847	3463	}
3848	3464
3849	3465	if (self.requiresThunks()) {
3850		for (self.output_sections.keys(), self.output_sections.values()) \|shndx, atom_list\| {
3851		const shdr = self.shdrs.items[shndx];
	3466	for (slice.items(.shdr), slice.items(.atom_list), 0..) \|*shdr, atom_list, shndx\| {
3852	3467	if (shdr.sh_flags & elf.SHF_EXECINSTR == 0) continue;
3853	3468	if (atom_list.items.len == 0) continue;
3854	3469
3855	3470	// Create jump/branch range extenders if needed.
3856		try thunks.createThunks(shndx, self);
	3471	try thunks.createThunks(shdr, @intCast(shndx), self);
3857	3472	}
3858	3473	}
3859	3474
	3475	const shdrs = slice.items(.shdr);
3860	3476	if (self.eh_frame_section_index) \|index\| {
3861		self.shdrs.items[index].sh_size = try eh_frame.calcEhFrameSize(self);
	3477	shdrs[index].sh_size = try eh_frame.calcEhFrameSize(self);
3862	3478	}
3863	3479
3864	3480	if (self.eh_frame_hdr_section_index) \|index\| {
3865		self.shdrs.items[index].sh_size = eh_frame.calcEhFrameHdrSize(self);
	3481	shdrs[index].sh_size = eh_frame.calcEhFrameHdrSize(self);
3866	3482	}
3867	3483
3868	3484	if (self.got_section_index) \|index\| {
3869		self.shdrs.items[index].sh_size = self.got.size(self);
	3485	shdrs[index].sh_size = self.got.size(self);
3870	3486	}
3871	3487
3872	3488	if (self.plt_section_index) \|index\| {
3873		self.shdrs.items[index].sh_size = self.plt.size(self);
	3489	shdrs[index].sh_size = self.plt.size(self);
3874	3490	}
3875	3491
3876	3492	if (self.got_plt_section_index) \|index\| {
3877		self.shdrs.items[index].sh_size = self.got_plt.size(self);
	3493	shdrs[index].sh_size = self.got_plt.size(self);
3878	3494	}
3879	3495
3880	3496	if (self.plt_got_section_index) \|index\| {
3881		self.shdrs.items[index].sh_size = self.plt_got.size(self);
	3497	shdrs[index].sh_size = self.plt_got.size(self);
3882	3498	}
3883	3499
3884	3500	if (self.rela_dyn_section_index) \|shndx\| {
...	...	@@ -3889,11 +3505,11 @@ fn updateSectionSizes(self: *Elf) !void {
3889	3505	for (self.objects.items) \|index\| {
3890	3506	num += self.file(index).?.object.num_dynrelocs;
3891	3507	}
3892		self.shdrs.items[shndx].sh_size = num * @sizeOf(elf.Elf64_Rela);
	3508	shdrs[shndx].sh_size = num * @sizeOf(elf.Elf64_Rela);
3893	3509	}
3894	3510
3895	3511	if (self.rela_plt_section_index) \|index\| {
3896		self.shdrs.items[index].sh_size = self.plt.numRela() * @sizeOf(elf.Elf64_Rela);
	3512	shdrs[index].sh_size = self.plt.numRela() * @sizeOf(elf.Elf64_Rela);
3897	3513	}
3898	3514
3899	3515	if (self.copy_rel_section_index) \|index\| {
...	...	@@ -3901,44 +3517,45 @@ fn updateSectionSizes(self: *Elf) !void {
3901	3517	}
3902	3518
3903	3519	if (self.interp_section_index) \|index\| {
3904		self.shdrs.items[index].sh_size = target.dynamic_linker.get().?.len + 1;
	3520	shdrs[index].sh_size = target.dynamic_linker.get().?.len + 1;
3905	3521	}
3906	3522
3907	3523	if (self.hash_section_index) \|index\| {
3908		self.shdrs.items[index].sh_size = self.hash.size();
	3524	shdrs[index].sh_size = self.hash.size();
3909	3525	}
3910	3526
3911	3527	if (self.gnu_hash_section_index) \|index\| {
3912		self.shdrs.items[index].sh_size = self.gnu_hash.size();
	3528	shdrs[index].sh_size = self.gnu_hash.size();
3913	3529	}
3914	3530
3915	3531	if (self.dynamic_section_index) \|index\| {
3916		self.shdrs.items[index].sh_size = self.dynamic.size(self);
	3532	shdrs[index].sh_size = self.dynamic.size(self);
3917	3533	}
3918	3534
3919	3535	if (self.dynsymtab_section_index) \|index\| {
3920		self.shdrs.items[index].sh_size = self.dynsym.size();
	3536	shdrs[index].sh_size = self.dynsym.size();
3921	3537	}
3922	3538
3923	3539	if (self.dynstrtab_section_index) \|index\| {
3924		self.shdrs.items[index].sh_size = self.dynstrtab.items.len;
	3540	shdrs[index].sh_size = self.dynstrtab.items.len;
3925	3541	}
3926	3542
3927	3543	if (self.versym_section_index) \|index\| {
3928		self.shdrs.items[index].sh_size = self.versym.items.len * @sizeOf(elf.Elf64_Versym);
	3544	shdrs[index].sh_size = self.versym.items.len * @sizeOf(elf.Elf64_Versym);
3929	3545	}
3930	3546
3931	3547	if (self.verneed_section_index) \|index\| {
3932		self.shdrs.items[index].sh_size = self.verneed.size();
	3548	shdrs[index].sh_size = self.verneed.size();
3933	3549	}
3934	3550
3935	3551	try self.updateSymtabSize();
3936	3552	self.updateShStrtabSize();
3937	3553	}
3938	3554
	3555	// FIXME:JK this is very much obsolete, remove!
3939	3556	pub fn updateShStrtabSize(self: *Elf) void {
3940	3557	if (self.shstrtab_section_index) \|index\| {
3941		self.shdrs.items[index].sh_size = self.shstrtab.items.len;
	3558	self.sections.items(.shdr)[index].sh_size = self.shstrtab.items.len;
3942	3559	}
3943	3560	}
3944	3561
...	...	@@ -3971,7 +3588,7 @@ fn getMaxNumberOfPhdrs() u64 {
3971	3588	/// We permit a maximum of 3**2 number of segments.
3972	3589	fn calcNumberOfSegments(self: *Elf) usize {
3973	3590	var covers: [9]bool = [_]bool{false} ** 9;
3974		for (self.shdrs.items, 0..) \|shdr, shndx\| {
	3591	for (self.sections.items(.shdr), 0..) \|shdr, shndx\| {
3975	3592	if (shdr.sh_type == elf.SHT_NULL) continue;
3976	3593	if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
3977	3594	if (self.isZigSection(@intCast(shndx))) continue;
...	...	@@ -4042,8 +3659,9 @@ pub fn allocateAllocSections(self: *Elf) !void {
4042	3659	}
4043	3660	};
4044	3661
	3662	const slice = self.sections.slice();
4045	3663	var alignment = Align{};
4046		for (self.shdrs.items, 0..) \|shdr, i\| {
	3664	for (slice.items(.shdr), 0..) \|shdr, i\| {
4047	3665	if (shdr.sh_type == elf.SHT_NULL) continue;
4048	3666	if (shdr.sh_flags & elf.SHF_TLS == 0) continue;
4049	3667	if (alignment.first_tls_index == null) alignment.first_tls_index = i;
...	...	@@ -4068,7 +3686,7 @@ pub fn allocateAllocSections(self: *Elf) !void {
4068	3686	cover.deinit();
4069	3687	};
4070	3688
4071		for (self.shdrs.items, 0..) \|shdr, shndx\| {
	3689	for (slice.items(.shdr), 0..) \|shdr, shndx\| {
4072	3690	if (shdr.sh_type == elf.SHT_NULL) continue;
4073	3691	if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
4074	3692	if (self.isZigSection(@intCast(shndx))) continue;
...	...	@@ -4089,7 +3707,7 @@ pub fn allocateAllocSections(self: *Elf) !void {
4089	3707
4090	3708	var @"align": u64 = self.page_size;
4091	3709	for (cover.items) \|shndx\| {
4092		const shdr = self.shdrs.items[shndx];
	3710	const shdr = slice.items(.shdr)[shndx];
4093	3711	if (shdr.sh_type == elf.SHT_NOBITS and shdr.sh_flags & elf.SHF_TLS != 0) continue;
4094	3712	@"align" = @max(@"align", shdr.sh_addralign);
4095	3713	}
...	...	@@ -4101,7 +3719,7 @@ pub fn allocateAllocSections(self: *Elf) !void {
4101	3719	var i: usize = 0;
4102	3720	while (i < cover.items.len) : (i += 1) {
4103	3721	const shndx = cover.items[i];
4104		const shdr = &self.shdrs.items[shndx];
	3722	const shdr = &slice.items(.shdr)[shndx];
4105	3723	if (shdr.sh_type == elf.SHT_NOBITS and shdr.sh_flags & elf.SHF_TLS != 0) {
4106	3724	// .tbss is a little special as it's used only by the loader meaning it doesn't
4107	3725	// need to be actually mmap'ed at runtime. We still need to correctly increment
...	...	@@ -4117,11 +3735,11 @@ pub fn allocateAllocSections(self: *Elf) !void {
4117	3735	// ...
4118	3736	var tbss_addr = addr;
4119	3737	while (i < cover.items.len and
4120		self.shdrs.items[cover.items[i]].sh_type == elf.SHT_NOBITS and
4121		self.shdrs.items[cover.items[i]].sh_flags & elf.SHF_TLS != 0) : (i += 1)
	3738	slice.items(.shdr)[cover.items[i]].sh_type == elf.SHT_NOBITS and
	3739	slice.items(.shdr)[cover.items[i]].sh_flags & elf.SHF_TLS != 0) : (i += 1)
4122	3740	{
4123	3741	const tbss_shndx = cover.items[i];
4124		const tbss_shdr = &self.shdrs.items[tbss_shndx];
	3742	const tbss_shdr = &slice.items(.shdr)[tbss_shndx];
4125	3743	tbss_addr = alignment.@"align"(tbss_shndx, tbss_shdr.sh_addralign, tbss_addr);
4126	3744	tbss_shdr.sh_addr = tbss_addr;
4127	3745	tbss_addr += tbss_shdr.sh_size;
...	...	@@ -4140,7 +3758,7 @@ pub fn allocateAllocSections(self: *Elf) !void {
4140	3758	addr += shdr.sh_size;
4141	3759	}
4142	3760
4143		const first = self.shdrs.items[cover.items[0]];
	3761	const first = slice.items(.shdr)[cover.items[0]];
4144	3762	var off = try self.findFreeSpace(filesz, @"align");
4145	3763	const phndx = try self.addPhdr(.{
4146	3764	.type = elf.PT_LOAD,
...	...	@@ -4153,7 +3771,8 @@ pub fn allocateAllocSections(self: *Elf) !void {
4153	3771	});
4154	3772
4155	3773	for (cover.items) \|shndx\| {
4156		const shdr = &self.shdrs.items[shndx];
	3774	const shdr = &slice.items(.shdr)[shndx];
	3775	slice.items(.phndx)[shndx] = phndx;
4157	3776	if (shdr.sh_type == elf.SHT_NOBITS) {
4158	3777	shdr.sh_offset = 0;
4159	3778	continue;
...	...	@@ -4161,7 +3780,6 @@ pub fn allocateAllocSections(self: *Elf) !void {
4161	3780	off = alignment.@"align"(shndx, shdr.sh_addralign, off);
4162	3781	shdr.sh_offset = off;
4163	3782	off += shdr.sh_size;
4164		try self.phdr_to_shdr_table.putNoClobber(gpa, shndx, phndx);
4165	3783	}
4166	3784
4167	3785	addr = mem.alignForward(u64, addr, self.page_size);
...	...	@@ -4170,7 +3788,7 @@ pub fn allocateAllocSections(self: *Elf) !void {
4170	3788
4171	3789	/// Allocates non-alloc sections (debug info, symtabs, etc.).
4172	3790	pub fn allocateNonAllocSections(self: *Elf) !void {
4173		for (self.shdrs.items, 0..) \|*shdr, shndx\| {
	3791	for (self.sections.items(.shdr), 0..) \|*shdr, shndx\| {
4174	3792	if (shdr.sh_type == elf.SHT_NULL) continue;
4175	3793	if (shdr.sh_flags & elf.SHF_ALLOC != 0) continue;
4176	3794	const needed_size = shdr.sh_size;
...	...	@@ -4215,13 +3833,15 @@ pub fn allocateNonAllocSections(self: *Elf) !void {
4215	3833	}
4216	3834
4217	3835	fn allocateSpecialPhdrs(self: *Elf) void {
	3836	const slice = self.sections.slice();
	3837
4218	3838	for (&[_]struct { ?u16, ?u32 }{
4219	3839	.{ self.phdr_interp_index, self.interp_section_index },
4220	3840	.{ self.phdr_dynamic_index, self.dynamic_section_index },
4221	3841	.{ self.phdr_gnu_eh_frame_index, self.eh_frame_hdr_section_index },
4222	3842	}) \|pair\| {
4223	3843	if (pair[0]) \|index\| {
4224		const shdr = self.shdrs.items[pair[1].?];
	3844	const shdr = slice.items(.shdr)[pair[1].?];
4225	3845	const phdr = &self.phdrs.items[index];
4226	3846	phdr.p_align = shdr.sh_addralign;
4227	3847	phdr.p_offset = shdr.sh_offset;
...	...	@@ -4236,11 +3856,11 @@ fn allocateSpecialPhdrs(self: *Elf) void {
4236	3856	// We assume TLS sections are laid out contiguously and that there is
4237	3857	// a single TLS segment.
4238	3858	if (self.phdr_tls_index) \|index\| {
4239		const slice = self.shdrs.items;
	3859	const shdrs = slice.items(.shdr);
4240	3860	const phdr = &self.phdrs.items[index];
4241	3861	var shndx: u32 = 0;
4242		while (shndx < slice.len) {
4243		const shdr = slice[shndx];
	3862	while (shndx < shdrs.len) {
	3863	const shdr = shdrs[shndx];
4244	3864	if (shdr.sh_flags & elf.SHF_TLS == 0) {
4245	3865	shndx += 1;
4246	3866	continue;
...	...	@@ -4256,8 +3876,8 @@ fn allocateSpecialPhdrs(self: *Elf) void {
4256	3876	}
4257	3877	phdr.p_memsz = shdr.sh_addr + shdr.sh_size - phdr.p_vaddr;
4258	3878
4259		while (shndx < slice.len) : (shndx += 1) {
4260		const next = slice[shndx];
	3879	while (shndx < shdrs.len) : (shndx += 1) {
	3880	const next = shdrs[shndx];
4261	3881	if (next.sh_flags & elf.SHF_TLS == 0) break;
4262	3882	phdr.p_align = @max(phdr.p_align, next.sh_addralign);
4263	3883	if (next.sh_type != elf.SHT_NOBITS) {
...	...	@@ -4281,13 +3901,10 @@ fn writeAtoms(self: *Elf) !void {
4281	3901	}
4282	3902
4283	3903	var has_reloc_errors = false;
4284
4285		// TODO iterate over `output_sections` directly
4286		for (self.shdrs.items, 0..) \|shdr, shndx\| {
	3904	const slice = self.sections.slice();
	3905	for (slice.items(.shdr), slice.items(.atom_list), 0..) \|shdr, atom_list, shndx\| {
4287	3906	if (shdr.sh_type == elf.SHT_NULL) continue;
4288	3907	if (shdr.sh_type == elf.SHT_NOBITS) continue;
4289
4290		const atom_list = self.output_sections.get(@intCast(shndx)) orelse continue;
4291	3908	if (atom_list.items.len == 0) continue;
4292	3909
4293	3910	log.debug("writing atoms in '{s}' section", .{self.getShString(shdr.sh_name)});
...	...	@@ -4366,7 +3983,7 @@ fn writeAtoms(self: *Elf) !void {
4366	3983	for (self.thunks.items) \|th\| {
4367	3984	const thunk_size = th.size(self);
4368	3985	try buffer.ensureUnusedCapacity(thunk_size);
4369		const shdr = self.shdrs.items[th.output_section_index];
	3986	const shdr = slice.items(.shdr)[th.output_section_index];
4370	3987	const offset = @as(u64, @intCast(th.value)) + shdr.sh_offset;
4371	3988	try th.write(self, buffer.writer());
4372	3989	assert(buffer.items.len == thunk_size);
...	...	@@ -4396,15 +4013,10 @@ pub fn updateSymtabSize(self: *Elf) !void {
4396	4013	if (self.linker_defined_index) \|index\| files.appendAssumeCapacity(index);
4397	4014
4398	4015	// Section symbols
4399		for (self.output_sections.keys()) \|_\| {
4400		nlocals += 1;
4401		}
4402		if (self.eh_frame_section_index) \|_\| {
4403		nlocals += 1;
4404		}
	4016	nlocals += @intCast(self.sections.slice().len);
4405	4017
4406	4018	if (self.requiresThunks()) for (self.thunks.items) \|*th\| {
4407		th.output_symtab_ctx.ilocal = nlocals + 1;
	4019	th.output_symtab_ctx.ilocal = nlocals;
4408	4020	th.calcSymtabSize(self);
4409	4021	nlocals += th.output_symtab_ctx.nlocals;
4410	4022	strsize += th.output_symtab_ctx.strsize;
...	...	@@ -4415,8 +4027,8 @@ pub fn updateSymtabSize(self: *Elf) !void {
4415	4027	const ctx = switch (file_ptr) {
4416	4028	inline else => \|x\| &x.output_symtab_ctx,
4417	4029	};
4418		ctx.ilocal = nlocals + 1;
4419		ctx.iglobal = nglobals + 1;
	4030	ctx.ilocal = nlocals;
	4031	ctx.iglobal = nglobals;
4420	4032	try file_ptr.updateSymtabSize(self);
4421	4033	nlocals += ctx.nlocals;
4422	4034	nglobals += ctx.nglobals;
...	...	@@ -4424,21 +4036,21 @@ pub fn updateSymtabSize(self: *Elf) !void {
4424	4036	}
4425	4037
4426	4038	if (self.got_section_index) \|_\| {
4427		self.got.output_symtab_ctx.ilocal = nlocals + 1;
	4039	self.got.output_symtab_ctx.ilocal = nlocals;
4428	4040	self.got.updateSymtabSize(self);
4429	4041	nlocals += self.got.output_symtab_ctx.nlocals;
4430	4042	strsize += self.got.output_symtab_ctx.strsize;
4431	4043	}
4432	4044
4433	4045	if (self.plt_section_index) \|_\| {
4434		self.plt.output_symtab_ctx.ilocal = nlocals + 1;
	4046	self.plt.output_symtab_ctx.ilocal = nlocals;
4435	4047	self.plt.updateSymtabSize(self);
4436	4048	nlocals += self.plt.output_symtab_ctx.nlocals;
4437	4049	strsize += self.plt.output_symtab_ctx.strsize;
4438	4050	}
4439	4051
4440	4052	if (self.plt_got_section_index) \|_\| {
4441		self.plt_got.output_symtab_ctx.ilocal = nlocals + 1;
	4053	self.plt_got.output_symtab_ctx.ilocal = nlocals;
4442	4054	self.plt_got.updateSymtabSize(self);
4443	4055	nlocals += self.plt_got.output_symtab_ctx.nlocals;
4444	4056	strsize += self.plt_got.output_symtab_ctx.strsize;
...	...	@@ -4452,24 +4064,26 @@ pub fn updateSymtabSize(self: *Elf) !void {
4452	4064	ctx.iglobal += nlocals;
4453	4065	}
4454	4066
4455		const symtab_shdr = &self.shdrs.items[self.symtab_section_index.?];
4456		symtab_shdr.sh_info = nlocals + 1;
	4067	const slice = self.sections.slice();
	4068	const symtab_shdr = &slice.items(.shdr)[self.symtab_section_index.?];
	4069	symtab_shdr.sh_info = nlocals;
4457	4070	symtab_shdr.sh_link = self.strtab_section_index.?;
4458	4071
4459	4072	const sym_size: u64 = switch (self.ptr_width) {
4460	4073	.p32 => @sizeOf(elf.Elf32_Sym),
4461	4074	.p64 => @sizeOf(elf.Elf64_Sym),
4462	4075	};
4463		const needed_size = (nlocals + nglobals + 1) * sym_size;
	4076	const needed_size = (nlocals + nglobals) * sym_size;
4464	4077	symtab_shdr.sh_size = needed_size;
4465	4078
4466		const strtab = &self.shdrs.items[self.strtab_section_index.?];
	4079	const strtab = &slice.items(.shdr)[self.strtab_section_index.?];
4467	4080	strtab.sh_size = strsize + 1;
4468	4081	}
4469	4082
4470	4083	fn writeSyntheticSections(self: *Elf) !void {
4471		const target = self.base.comp.root_mod.resolved_target.result;
4472	4084	const gpa = self.base.comp.gpa;
	4085	const target = self.getTarget();
	4086	const slice = self.sections.slice();
4473	4087
4474	4088	if (self.interp_section_index) \|shndx\| {
4475	4089	var buffer: [256]u8 = undefined;
...	...	@@ -4477,18 +4091,18 @@ fn writeSyntheticSections(self: *Elf) !void {
4477	4091	@memcpy(buffer[0..interp.len], interp);
4478	4092	buffer[interp.len] = 0;
4479	4093	const contents = buffer[0 .. interp.len + 1];
4480		const shdr = self.shdrs.items[shndx];
	4094	const shdr = slice.items(.shdr)[shndx];
4481	4095	assert(shdr.sh_size == contents.len);
4482	4096	try self.base.file.?.pwriteAll(contents, shdr.sh_offset);
4483	4097	}
4484	4098
4485	4099	if (self.hash_section_index) \|shndx\| {
4486		const shdr = self.shdrs.items[shndx];
	4100	const shdr = slice.items(.shdr)[shndx];
4487	4101	try self.base.file.?.pwriteAll(self.hash.buffer.items, shdr.sh_offset);
4488	4102	}
4489	4103
4490	4104	if (self.gnu_hash_section_index) \|shndx\| {
4491		const shdr = self.shdrs.items[shndx];
	4105	const shdr = slice.items(.shdr)[shndx];
4492	4106	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.gnu_hash.size());
4493	4107	defer buffer.deinit();
4494	4108	try self.gnu_hash.write(self, buffer.writer());
...	...	@@ -4496,12 +4110,12 @@ fn writeSyntheticSections(self: *Elf) !void {
4496	4110	}
4497	4111
4498	4112	if (self.versym_section_index) \|shndx\| {
4499		const shdr = self.shdrs.items[shndx];
	4113	const shdr = slice.items(.shdr)[shndx];
4500	4114	try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.versym.items), shdr.sh_offset);
4501	4115	}
4502	4116
4503	4117	if (self.verneed_section_index) \|shndx\| {
4504		const shdr = self.shdrs.items[shndx];
	4118	const shdr = slice.items(.shdr)[shndx];
4505	4119	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.verneed.size());
4506	4120	defer buffer.deinit();
4507	4121	try self.verneed.write(buffer.writer());
...	...	@@ -4509,7 +4123,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4509	4123	}
4510	4124
4511	4125	if (self.dynamic_section_index) \|shndx\| {
4512		const shdr = self.shdrs.items[shndx];
	4126	const shdr = slice.items(.shdr)[shndx];
4513	4127	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.dynamic.size(self));
4514	4128	defer buffer.deinit();
4515	4129	try self.dynamic.write(self, buffer.writer());
...	...	@@ -4517,7 +4131,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4517	4131	}
4518	4132
4519	4133	if (self.dynsymtab_section_index) \|shndx\| {
4520		const shdr = self.shdrs.items[shndx];
	4134	const shdr = slice.items(.shdr)[shndx];
4521	4135	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.dynsym.size());
4522	4136	defer buffer.deinit();
4523	4137	try self.dynsym.write(self, buffer.writer());
...	...	@@ -4525,12 +4139,12 @@ fn writeSyntheticSections(self: *Elf) !void {
4525	4139	}
4526	4140
4527	4141	if (self.dynstrtab_section_index) \|shndx\| {
4528		const shdr = self.shdrs.items[shndx];
	4142	const shdr = slice.items(.shdr)[shndx];
4529	4143	try self.base.file.?.pwriteAll(self.dynstrtab.items, shdr.sh_offset);
4530	4144	}
4531	4145
4532	4146	if (self.eh_frame_section_index) \|shndx\| {
4533		const shdr = self.shdrs.items[shndx];
	4147	const shdr = slice.items(.shdr)[shndx];
4534	4148	const sh_size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;
4535	4149	var buffer = try std.ArrayList(u8).initCapacity(gpa, sh_size);
4536	4150	defer buffer.deinit();
...	...	@@ -4539,7 +4153,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4539	4153	}
4540	4154
4541	4155	if (self.eh_frame_hdr_section_index) \|shndx\| {
4542		const shdr = self.shdrs.items[shndx];
	4156	const shdr = slice.items(.shdr)[shndx];
4543	4157	const sh_size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;
4544	4158	var buffer = try std.ArrayList(u8).initCapacity(gpa, sh_size);
4545	4159	defer buffer.deinit();
...	...	@@ -4548,7 +4162,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4548	4162	}
4549	4163
4550	4164	if (self.got_section_index) \|index\| {
4551		const shdr = self.shdrs.items[index];
	4165	const shdr = slice.items(.shdr)[index];
4552	4166	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.got.size(self));
4553	4167	defer buffer.deinit();
4554	4168	try self.got.write(self, buffer.writer());
...	...	@@ -4556,7 +4170,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4556	4170	}
4557	4171
4558	4172	if (self.rela_dyn_section_index) \|shndx\| {
4559		const shdr = self.shdrs.items[shndx];
	4173	const shdr = slice.items(.shdr)[shndx];
4560	4174	try self.got.addRela(self);
4561	4175	try self.copy_rel.addRela(self);
4562	4176	self.sortRelaDyn();
...	...	@@ -4564,7 +4178,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4564	4178	}
4565	4179
4566	4180	if (self.plt_section_index) \|shndx\| {
4567		const shdr = self.shdrs.items[shndx];
	4181	const shdr = slice.items(.shdr)[shndx];
4568	4182	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.plt.size(self));
4569	4183	defer buffer.deinit();
4570	4184	try self.plt.write(self, buffer.writer());
...	...	@@ -4572,7 +4186,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4572	4186	}
4573	4187
4574	4188	if (self.got_plt_section_index) \|shndx\| {
4575		const shdr = self.shdrs.items[shndx];
	4189	const shdr = slice.items(.shdr)[shndx];
4576	4190	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.got_plt.size(self));
4577	4191	defer buffer.deinit();
4578	4192	try self.got_plt.write(self, buffer.writer());
...	...	@@ -4580,7 +4194,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4580	4194	}
4581	4195
4582	4196	if (self.plt_got_section_index) \|shndx\| {
4583		const shdr = self.shdrs.items[shndx];
	4197	const shdr = slice.items(.shdr)[shndx];
4584	4198	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.plt_got.size(self));
4585	4199	defer buffer.deinit();
4586	4200	try self.plt_got.write(self, buffer.writer());
...	...	@@ -4588,7 +4202,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4588	4202	}
4589	4203
4590	4204	if (self.rela_plt_section_index) \|shndx\| {
4591		const shdr = self.shdrs.items[shndx];
	4205	const shdr = slice.items(.shdr)[shndx];
4592	4206	try self.plt.addRela(self);
4593	4207	try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.rela_plt.items), shdr.sh_offset);
4594	4208	}
...	...	@@ -4597,19 +4211,21 @@ fn writeSyntheticSections(self: *Elf) !void {
4597	4211	try self.writeShStrtab();
4598	4212	}
4599	4213
	4214	// FIXME:JK again, why is this needed?
4600	4215	pub fn writeShStrtab(self: *Elf) !void {
4601	4216	if (self.shstrtab_section_index) \|index\| {
4602		const shdr = self.shdrs.items[index];
	4217	const shdr = self.sections.items(.shdr)[index];
4603	4218	log.debug("writing .shstrtab from 0x{x} to 0x{x}", .{ shdr.sh_offset, shdr.sh_offset + shdr.sh_size });
4604	4219	try self.base.file.?.pwriteAll(self.shstrtab.items, shdr.sh_offset);
4605	4220	}
4606	4221	}
4607	4222
4608	4223	pub fn writeSymtab(self: *Elf) !void {
4609		const target = self.base.comp.root_mod.resolved_target.result;
4610	4224	const gpa = self.base.comp.gpa;
4611		const symtab_shdr = self.shdrs.items[self.symtab_section_index.?];
4612		const strtab_shdr = self.shdrs.items[self.strtab_section_index.?];
	4225	const target = self.getTarget();
	4226	const slice = self.sections.slice();
	4227	const symtab_shdr = slice.items(.shdr)[self.symtab_section_index.?];
	4228	const strtab_shdr = slice.items(.shdr)[self.strtab_section_index.?];
4613	4229	const sym_size: u64 = switch (self.ptr_width) {
4614	4230	.p32 => @sizeOf(elf.Elf32_Sym),
4615	4231	.p64 => @sizeOf(elf.Elf64_Sym),
...	...	@@ -4630,7 +4246,17 @@ pub fn writeSymtab(self: *Elf) !void {
4630	4246	const needed_strtab_size = math.cast(usize, strtab_shdr.sh_size - 1) orelse return error.Overflow;
4631	4247	try self.strtab.ensureUnusedCapacity(gpa, needed_strtab_size);
4632	4248
4633		self.writeSectionSymbols();
	4249	for (slice.items(.shdr), 0..) \|shdr, shndx\| {
	4250	const out_sym = &self.symtab.items[shndx];
	4251	out_sym.* = .{
	4252	.st_name = 0,
	4253	.st_value = shdr.sh_addr,
	4254	.st_info = if (shdr.sh_type == elf.SHT_NULL) elf.STT_NOTYPE else elf.STT_SECTION,
	4255	.st_shndx = @intCast(shndx),
	4256	.st_size = 0,
	4257	.st_other = 0,
	4258	};
	4259	}
4634	4260
4635	4261	if (self.requiresThunks()) for (self.thunks.items) \|th\| {
4636	4262	th.writeSymtab(self);
...	...	@@ -4696,44 +4322,6 @@ pub fn writeSymtab(self: *Elf) !void {
4696	4322	try self.base.file.?.pwriteAll(self.strtab.items, strtab_shdr.sh_offset);
4697	4323	}
4698	4324
4699		fn writeSectionSymbols(self: *Elf) void {
4700		var ilocal: u32 = 1;
4701		for (self.output_sections.keys()) \|shndx\| {
4702		const shdr = self.shdrs.items[shndx];
4703		const out_sym = &self.symtab.items[ilocal];
4704		out_sym.* = .{
4705		.st_name = 0,
4706		.st_value = shdr.sh_addr,
4707		.st_info = elf.STT_SECTION,
4708		.st_shndx = @intCast(shndx),
4709		.st_size = 0,
4710		.st_other = 0,
4711		};
4712		ilocal += 1;
4713		}
4714
4715		if (self.eh_frame_section_index) \|shndx\| {
4716		const shdr = self.shdrs.items[shndx];
4717		const out_sym = &self.symtab.items[ilocal];
4718		out_sym.* = .{
4719		.st_name = 0,
4720		.st_value = shdr.sh_addr,
4721		.st_info = elf.STT_SECTION,
4722		.st_shndx = @intCast(shndx),
4723		.st_size = 0,
4724		.st_other = 0,
4725		};
4726		ilocal += 1;
4727		}
4728		}
4729
4730		pub fn sectionSymbolOutputSymtabIndex(self: Elf, shndx: u32) u32 {
4731		if (self.eh_frame_section_index) \|index\| {
4732		if (index == shndx) return @intCast(self.output_sections.keys().len + 1);
4733		}
4734		return @intCast(self.output_sections.getIndex(shndx).? + 1);
4735		}
4736
4737	4325	/// Always 4 or 8 depending on whether this is 32-bit ELF or 64-bit ELF.
4738	4326	pub fn ptrWidthBytes(self: Elf) u8 {
4739	4327	return switch (self.ptr_width) {
...	...	@@ -4745,8 +4333,7 @@ pub fn ptrWidthBytes(self: Elf) u8 {
4745	4333	/// Does not necessarily match `ptrWidthBytes` for example can be 2 bytes
4746	4334	/// in a 32-bit ELF file.
4747	4335	pub fn archPtrWidthBytes(self: Elf) u8 {
4748		const target = self.base.comp.root_mod.resolved_target.result;
4749		return @intCast(@divExact(target.ptrBitWidth(), 8));
	4336	return @intCast(@divExact(self.getTarget().ptrBitWidth(), 8));
4750	4337	}
4751	4338
4752	4339	fn phdrTo32(phdr: elf.Elf64_Phdr) elf.Elf32_Phdr {
...	...	@@ -5069,7 +4656,7 @@ pub fn isDebugSection(self: Elf, shndx: u32) bool {
5069	4656	return false;
5070	4657	}
5071	4658
5072		fn addPhdr(self: *Elf, opts: struct {
	4659	pub fn addPhdr(self: *Elf, opts: struct {
5073	4660	type: u32 = 0,
5074	4661	flags: u32 = 0,
5075	4662	@"align": u64 = 0,
...	...	@@ -5126,25 +4713,26 @@ pub const AddSectionOpts = struct {
5126	4713
5127	4714	pub fn addSection(self: *Elf, opts: AddSectionOpts) !u32 {
5128	4715	const gpa = self.base.comp.gpa;
5129		const index: u32 = @intCast(self.shdrs.items.len);
5130		const shdr = try self.shdrs.addOne(gpa);
5131		shdr.* = .{
5132		.sh_name = opts.name,
5133		.sh_type = opts.type,
5134		.sh_flags = opts.flags,
5135		.sh_addr = 0,
5136		.sh_offset = opts.offset,
5137		.sh_size = 0,
5138		.sh_link = opts.link,
5139		.sh_info = opts.info,
5140		.sh_addralign = opts.addralign,
5141		.sh_entsize = opts.entsize,
5142		};
	4716	const index: u32 = @intCast(try self.sections.addOne(gpa));
	4717	self.sections.set(index, .{
	4718	.shdr = .{
	4719	.sh_name = opts.name,
	4720	.sh_type = opts.type,
	4721	.sh_flags = opts.flags,
	4722	.sh_addr = 0,
	4723	.sh_offset = opts.offset,
	4724	.sh_size = 0,
	4725	.sh_link = opts.link,
	4726	.sh_info = opts.info,
	4727	.sh_addralign = opts.addralign,
	4728	.sh_entsize = opts.entsize,
	4729	},
	4730	});
5143	4731	return index;
5144	4732	}
5145	4733
5146	4734	pub fn sectionByName(self: *Elf, name: [:0]const u8) ?u32 {
5147		for (self.shdrs.items, 0..) \|*shdr, i\| {
	4735	for (self.sections.items(.shdr), 0..) \|*shdr, i\| {
5148	4736	const this_name = self.getShString(shdr.sh_name);
5149	4737	if (mem.eql(u8, this_name, name)) return @intCast(i);
5150	4738	} else return null;
...	...	@@ -5322,7 +4910,7 @@ pub fn gotAddress(self: *Elf) i64 {
5322	4910	break :blk self.got_plt_section_index.?;
5323	4911	break :blk if (self.got_section_index) \|shndx\| shndx else null;
5324	4912	};
5325		return if (shndx) \|index\| @intCast(self.shdrs.items[index].sh_addr) else 0;
	4913	return if (shndx) \|index\| @intCast(self.sections.items(.shdr)[index].sh_addr) else 0;
5326	4914	}
5327	4915
5328	4916	pub fn tpAddress(self: *Elf) i64 {
...	...	@@ -5676,16 +5264,16 @@ fn fmtDumpState(
5676	5264	}
5677	5265
5678	5266	try writer.writeAll("\nOutput shdrs\n");
5679		for (self.shdrs.items, 0..) \|shdr, shndx\| {
	5267	for (self.sections.items(.shdr), self.sections.items(.phndx), 0..) \|shdr, phndx, shndx\| {
5680	5268	try writer.print(" shdr({d}) : phdr({?d}) : {}\n", .{
5681	5269	shndx,
5682		self.phdr_to_shdr_table.get(@intCast(shndx)),
	5270	phndx,
5683	5271	self.fmtShdr(shdr),
5684	5272	});
5685	5273	}
5686	5274	try writer.writeAll("\nOutput phdrs\n");
5687	5275	for (self.phdrs.items, 0..) \|phdr, phndx\| {
5688		try writer.print(" phdr{d} : {}\n", .{ phndx, self.fmtPhdr(phdr) });
	5276	try writer.print(" phdr({d}) : {}\n", .{ phndx, self.fmtPhdr(phdr) });
5689	5277	}
5690	5278	}
5691	5279
...	...	@@ -5746,7 +5334,7 @@ fn requiresThunks(self: Elf) bool {
5746	5334	/// so that we reserve enough space for the program header table up-front.
5747	5335	/// Bump these numbers when adding or deleting a Zig specific pre-allocated segment, or adding
5748	5336	/// more special-purpose program headers.
5749		const number_of_zig_segments = 5;
	5337	pub const number_of_zig_segments = 4;
5750	5338	const max_number_of_object_segments = 9;
5751	5339	const max_number_of_special_phdrs = 5;
5752	5340
...	...	@@ -5814,8 +5402,8 @@ pub const SystemLib = struct {
5814	5402	};
5815	5403
5816	5404	pub const Ref = struct {
5817		index: u32,
5818		file: u32,
	5405	index: u32 = 0,
	5406	file: u32 = 0,
5819	5407
5820	5408	pub fn eql(ref: Ref, other: Ref) bool {
5821	5409	return ref.index == other.index and ref.file == other.file;
...	...	@@ -5923,9 +5511,18 @@ pub const SymbolResolver = struct {
5923	5511	pub const Index = u32;
5924	5512	};
5925	5513
5926		const LastAtomAndFreeList = struct {
	5514	const Section = struct {
	5515	/// Section header.
	5516	shdr: elf.Elf64_Shdr,
	5517
	5518	/// Assigned program header index if any.
	5519	phndx: ?u32 = null,
	5520
	5521	/// List of atoms contributing to this section.
	5522	atom_list: std.ArrayListUnmanaged(Ref) = .{},
	5523
5927	5524	/// Index of the last allocated atom in this section.
5928		last_atom_index: Atom.Index = 0,
	5525	last_atom: Ref = .{ .index = 0, .file = 0 },
5929	5526
5930	5527	/// A list of atoms that have surplus capacity. This list can have false
5931	5528	/// positives, as functions grow and shrink over time, only sometimes being added
...	...	@@ -5942,15 +5539,8 @@ const LastAtomAndFreeList = struct {
5942	5539	/// overcapacity can be negative. A simple way to have negative overcapacity is to
5943	5540	/// allocate a fresh text block, which will have ideal capacity, and then grow it
5944	5541	/// by 1 byte. It will then have -1 overcapacity.
5945		free_list: std.ArrayListUnmanaged(Atom.Index) = .{},
5946		};
5947		const LastAtomAndFreeListTable = std.AutoArrayHashMapUnmanaged(u32, LastAtomAndFreeList);
5948
5949		const RelaSection = struct {
5950		shndx: u32,
5951		atom_list: std.ArrayListUnmanaged(Ref) = .{},
	5542	free_list: std.ArrayListUnmanaged(Ref) = .{},
5952	5543	};
5953		const RelaSectionTable = std.AutoArrayHashMapUnmanaged(u32, RelaSection);
5954	5544
5955	5545	fn defaultEntrySymbolName(cpu_arch: std.Target.Cpu.Arch) []const u8 {
5956	5546	return switch (cpu_arch) {

src/link/Elf/Atom.zig+94-81

...	...	@@ -25,10 +25,9 @@ relocs_section_index: u32 = 0,
25	25	/// Index of this atom in the linker's atoms table.
26	26	atom_index: Index = 0,
27	27
28		/// Points to the previous and next neighbors, based on the `text_offset`.
29		/// This can be used to find, for example, the capacity of this `TextBlock`.
30		prev_index: Index = 0,
31		next_index: Index = 0,
	28	/// Points to the previous and next neighbors.
	29	prev_atom_ref: Elf.Ref = .{},
	30	next_atom_ref: Elf.Ref = .{},
32	31
33	32	/// Specifies whether this atom is alive or has been garbage collected.
34	33	alive: bool = true,
...	...	@@ -48,10 +47,22 @@ pub fn name(self: Atom, elf_file: *Elf) [:0]const u8 {
48	47	}
49	48
50	49	pub fn address(self: Atom, elf_file: *Elf) i64 {
51		const shdr = elf_file.shdrs.items[self.output_section_index];
	50	const shdr = elf_file.sections.items(.shdr)[self.output_section_index];
52	51	return @as(i64, @intCast(shdr.sh_addr)) + self.value;
53	52	}
54	53
	54	pub fn ref(self: Atom) Elf.Ref {
	55	return .{ .index = self.atom_index, .file = self.file_index };
	56	}
	57
	58	pub fn prevAtom(self: Atom, elf_file: Elf) ?Atom {
	59	return elf_file.atom(self.prev_atom_ref);
	60	}
	61
	62	pub fn nextAtom(self: Atom, elf_file: Elf) ?Atom {
	63	return elf_file.atom(self.next_atom_ref);
	64	}
	65
55	66	pub fn debugTombstoneValue(self: Atom, target: Symbol, elf_file: *Elf) ?u64 {
56	67	if (target.mergeSubsection(elf_file)) \|msub\| {
57	68	if (msub.alive) return null;
...	...	@@ -95,18 +106,16 @@ pub fn priority(self: Atom, elf_file: *Elf) u64 {
95	106	/// File offset relocation happens transparently, so it is not included in
96	107	/// this calculation.
97	108	pub fn capacity(self: Atom, elf_file: *Elf) u64 {
98		const zo = elf_file.zigObjectPtr().?;
99		const next_addr = if (zo.atom(self.next_index)) \|next\|
100		next.address(elf_file)
	109	const next_addr = if (self.nextAtom(elf_file)) \|next_atom\|
	110	next_atom.address(elf_file)
101	111	else
102	112	std.math.maxInt(u32);
103	113	return @intCast(next_addr - self.address(elf_file));
104	114	}
105	115
106	116	pub fn freeListEligible(self: Atom, elf_file: *Elf) bool {
107		const zo = elf_file.zigObjectPtr().?;
108	117	// No need to keep a free list node for the last block.
109		const next = zo.atom(self.next_index) orelse return false;
	118	const next = self.nextAtom(elf_file) orelse return false;
110	119	const cap: u64 = @intCast(next.address(elf_file) - self.address(elf_file));
111	120	const ideal_cap = Elf.padToIdeal(self.size);
112	121	if (cap <= ideal_cap) return false;
...	...	@@ -115,11 +124,10 @@ pub fn freeListEligible(self: Atom, elf_file: *Elf) bool {
115	124	}
116	125
117	126	pub fn allocate(self: Atom, elf_file: Elf) !void {
118		const zo = elf_file.zigObjectPtr().?;
119		const shdr = &elf_file.shdrs.items[self.output_section_index];
120		const meta = elf_file.last_atom_and_free_list_table.getPtr(self.output_section_index).?;
121		const free_list = &meta.free_list;
122		const last_atom_index = &meta.last_atom_index;
	127	const slice = elf_file.sections.slice();
	128	const shdr = &slice.items(.shdr)[self.output_section_index];
	129	const free_list = &slice.items(.free_list)[self.output_section_index];
	130	const last_atom_ref = &slice.items(.last_atom)[self.output_section_index];
123	131	const new_atom_ideal_capacity = Elf.padToIdeal(self.size);
124	132
125	133	// We use these to indicate our intention to update metadata, placing the new atom,
...	...	@@ -127,7 +135,7 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {
127	135	// It would be simpler to do it inside the for loop below, but that would cause a
128	136	// problem if an error was returned later in the function. So this action
129	137	// is actually carried out at the end of the function, when errors are no longer possible.
130		var atom_placement: ?Atom.Index = null;
	138	var atom_placement: ?Elf.Ref = null;
131	139	var free_list_removal: ?usize = null;
132	140
133	141	// First we look for an appropriately sized free list node.
...	...	@@ -135,8 +143,8 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {
135	143	self.value = blk: {
136	144	var i: usize = if (elf_file.base.child_pid == null) 0 else free_list.items.len;
137	145	while (i < free_list.items.len) {
138		const big_atom_index = free_list.items[i];
139		const big_atom = zo.atom(big_atom_index).?;
	146	const big_atom_ref = free_list.items[i];
	147	const big_atom = elf_file.atom(big_atom_ref).?;
140	148	// We now have a pointer to a live atom that has too much capacity.
141	149	// Is it enough that we could fit this new atom?
142	150	const cap = big_atom.capacity(elf_file);
...	...	@@ -163,50 +171,52 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {
163	171	const keep_free_list_node = remaining_capacity >= Elf.min_text_capacity;
164	172
165	173	// Set up the metadata to be updated, after errors are no longer possible.
166		atom_placement = big_atom_index;
	174	atom_placement = big_atom_ref;
167	175	if (!keep_free_list_node) {
168	176	free_list_removal = i;
169	177	}
170	178	break :blk @intCast(new_start_vaddr);
171		} else if (zo.atom(last_atom_index.*)) \|last\| {
172		const ideal_capacity = Elf.padToIdeal(last.size);
173		const ideal_capacity_end_vaddr = @as(u64, @intCast(last.value)) + ideal_capacity;
	179	} else if (elf_file.atom(last_atom_ref.*)) \|last_atom\| {
	180	const ideal_capacity = Elf.padToIdeal(last_atom.size);
	181	const ideal_capacity_end_vaddr = @as(u64, @intCast(last_atom.value)) + ideal_capacity;
174	182	const new_start_vaddr = self.alignment.forward(ideal_capacity_end_vaddr);
175	183	// Set up the metadata to be updated, after errors are no longer possible.
176		atom_placement = last.atom_index;
	184	atom_placement = last_atom.ref();
177	185	break :blk @intCast(new_start_vaddr);
178	186	} else {
179	187	break :blk 0;
180	188	}
181	189	};
182	190
183		log.debug("allocated atom({d}) : '{s}' at 0x{x} to 0x{x}", .{
184		self.atom_index,
	191	log.debug("allocated atom({}) : '{s}' at 0x{x} to 0x{x}", .{
	192	self.ref(),
185	193	self.name(elf_file),
186	194	self.address(elf_file),
187	195	self.address(elf_file) + @as(i64, @intCast(self.size)),
188	196	});
189	197
190		const expand_section = if (atom_placement) \|placement_index\|
191		zo.atom(placement_index).?.next_index == 0
	198	const expand_section = if (atom_placement) \|placement_ref\|
	199	elf_file.atom(placement_ref).?.nextAtom(elf_file) == null
192	200	else
193	201	true;
194	202	if (expand_section) {
195	203	const needed_size: u64 = @intCast(self.value + @as(i64, @intCast(self.size)));
196	204	try elf_file.growAllocSection(self.output_section_index, needed_size);
197		last_atom_index.* = self.atom_index;
198
199		const zig_object = elf_file.zigObjectPtr().?;
200		if (zig_object.dwarf) \|_\| {
201		// The .debug_info section has `low_pc` and `high_pc` values which is the virtual address
202		// range of the compilation unit. When we expand the text section, this range changes,
203		// so the DW_TAG.compile_unit tag of the .debug_info section becomes dirty.
204		zig_object.debug_info_section_dirty = true;
205		// This becomes dirty for the same reason. We could potentially make this more
206		// fine-grained with the addition of support for more compilation units. It is planned to
207		// model each package as a different compilation unit.
208		zig_object.debug_aranges_section_dirty = true;
209		zig_object.debug_rnglists_section_dirty = true;
	205	last_atom_ref.* = self.ref();
	206
	207	switch (self.file(elf_file).?) {
	208	.zig_object => \|zo\| if (zo.dwarf) \|_\| {
	209	// The .debug_info section has `low_pc` and `high_pc` values which is the virtual address
	210	// range of the compilation unit. When we expand the text section, this range changes,
	211	// so the DW_TAG.compile_unit tag of the .debug_info section becomes dirty.
	212	zo.debug_info_section_dirty = true;
	213	// This becomes dirty for the same reason. We could potentially make this more
	214	// fine-grained with the addition of support for more compilation units. It is planned to
	215	// model each package as a different compilation unit.
	216	zo.debug_aranges_section_dirty = true;
	217	zo.debug_rnglists_section_dirty = true;
	218	},
	219	else => {},
210	220	}
211	221	}
212	222	shdr.sh_addralign = @max(shdr.sh_addralign, self.alignment.toByteUnits().?);
...	...	@@ -214,21 +224,21 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {
214	224	// This function can also reallocate an atom.
215	225	// In this case we need to "unplug" it from its previous location before
216	226	// plugging it in to its new location.
217		if (zo.atom(self.prev_index)) \|prev\| {
218		prev.next_index = self.next_index;
	227	if (self.prevAtom(elf_file)) \|prev\| {
	228	prev.next_atom_ref = self.next_atom_ref;
219	229	}
220		if (zo.atom(self.next_index)) \|next\| {
221		next.prev_index = self.prev_index;
	230	if (self.nextAtom(elf_file)) \|next\| {
	231	next.prev_atom_ref = self.prev_atom_ref;
222	232	}
223	233
224		if (atom_placement) \|big_atom_index\| {
225		const big_atom = zo.atom(big_atom_index).?;
226		self.prev_index = big_atom_index;
227		self.next_index = big_atom.next_index;
228		big_atom.next_index = self.atom_index;
	234	if (atom_placement) \|big_atom_ref\| {
	235	const big_atom = elf_file.atom(big_atom_ref).?;
	236	self.prev_atom_ref = big_atom_ref;
	237	self.next_atom_ref = big_atom.next_atom_ref;
	238	big_atom.next_atom_ref = self.ref();
229	239	} else {
230		self.prev_index = 0;
231		self.next_index = 0;
	240	self.prev_atom_ref = .{ .index = 0, .file = 0 };
	241	self.next_atom_ref = .{ .index = 0, .file = 0 };
232	242	}
233	243	if (free_list_removal) \|i\| {
234	244	_ = free_list.swapRemove(i);
...	...	@@ -248,64 +258,70 @@ pub fn grow(self: Atom, elf_file: Elf) !void {
248	258	}
249	259
250	260	pub fn free(self: Atom, elf_file: Elf) void {
251		log.debug("freeAtom {d} ({s})", .{ self.atom_index, self.name(elf_file) });
	261	log.debug("freeAtom atom({}) ({s})", .{ self.ref(), self.name(elf_file) });
252	262
253		const zo = elf_file.zigObjectPtr().?;
254	263	const comp = elf_file.base.comp;
255	264	const gpa = comp.gpa;
256	265	const shndx = self.output_section_index;
257		const meta = elf_file.last_atom_and_free_list_table.getPtr(shndx).?;
258		const free_list = &meta.free_list;
259		const last_atom_index = &meta.last_atom_index;
	266	const slice = elf_file.sections.slice();
	267	const free_list = &slice.items(.free_list)[shndx];
	268	const last_atom_ref = &slice.items(.last_atom)[shndx];
260	269	var already_have_free_list_node = false;
261	270	{
262	271	var i: usize = 0;
263	272	// TODO turn free_list into a hash map
264	273	while (i < free_list.items.len) {
265		if (free_list.items[i] == self.atom_index) {
	274	if (free_list.items[i].eql(self.ref())) {
266	275	_ = free_list.swapRemove(i);
267	276	continue;
268	277	}
269		if (free_list.items[i] == self.prev_index) {
270		already_have_free_list_node = true;
	278	if (self.prevAtom(elf_file)) \|prev_atom\| {
	279	if (free_list.items[i].eql(prev_atom.ref())) {
	280	already_have_free_list_node = true;
	281	}
271	282	}
272	283	i += 1;
273	284	}
274	285	}
275	286
276		if (zo.atom(last_atom_index.*)) \|last_atom\| {
277		if (last_atom.atom_index == self.atom_index) {
278		if (zo.atom(self.prev_index)) \|_\| {
	287	if (elf_file.atom(last_atom_ref.*)) \|last_atom\| {
	288	if (last_atom.ref().eql(self.ref())) {
	289	if (self.prevAtom(elf_file)) \|prev_atom\| {
279	290	// TODO shrink the section size here
280		last_atom_index.* = self.prev_index;
	291	last_atom_ref.* = prev_atom.ref();
281	292	} else {
282		last_atom_index.* = 0;
	293	last_atom_ref.* = .{};
283	294	}
284	295	}
285	296	}
286	297
287		if (zo.atom(self.prev_index)) \|prev\| {
288		prev.next_index = self.next_index;
289		if (!already_have_free_list_node and prev.*.freeListEligible(elf_file)) {
	298	if (self.prevAtom(elf_file)) \|prev_atom\| {
	299	prev_atom.next_atom_ref = self.next_atom_ref;
	300	if (!already_have_free_list_node and prev_atom.*.freeListEligible(elf_file)) {
290	301	// The free list is heuristics, it doesn't have to be perfect, so we can
291	302	// ignore the OOM here.
292		free_list.append(gpa, prev.atom_index) catch {};
	303	free_list.append(gpa, prev_atom.ref()) catch {};
293	304	}
294	305	} else {
295		self.prev_index = 0;
	306	self.prev_atom_ref = .{};
296	307	}
297	308
298		if (zo.atom(self.next_index)) \|next\| {
299		next.prev_index = self.prev_index;
	309	if (self.nextAtom(elf_file)) \|next_atom\| {
	310	next_atom.prev_atom_ref = self.prev_atom_ref;
300	311	} else {
301		self.next_index = 0;
	312	self.next_atom_ref = .{};
302	313	}
303	314
304		// TODO create relocs free list
305		self.freeRelocs(zo);
306		// TODO figure out how to free input section mappind in ZigModule
307		// const zig_object = elf_file.zigObjectPtr().?
308		// assert(zig_object.atoms.swapRemove(self.atom_index));
	315	switch (self.file(elf_file).?) {
	316	.zig_object => \|zo\| {
	317	// TODO create relocs free list
	318	self.freeRelocs(zo);
	319	// TODO figure out how to free input section mappind in ZigModule
	320	// const zig_object = elf_file.zigObjectPtr().?
	321	// assert(zig_object.atoms.swapRemove(self.atom_index));
	322	},
	323	else => {},
	324	}
309	325	self.* = .{};
310	326	}
311	327
...	...	@@ -336,10 +352,7 @@ pub fn writeRelocs(self: Atom, elf_file: Elf, out_relocs: std.ArrayList(elf.El
336	352	switch (target.type(elf_file)) {
337	353	elf.STT_SECTION => {
338	354	r_addend += @intCast(target.address(.{}, elf_file));
339		r_sym = if (target.outputShndx(elf_file)) \|osec\|
340		elf_file.sectionSymbolOutputSymtabIndex(osec)
341		else
342		0;
	355	r_sym = target.outputShndx(elf_file) orelse 0;
343	356	},
344	357	else => {
345	358	r_sym = target.outputSymtabIndex(elf_file) orelse 0;

src/link/Elf/LinkerDefined.zig+17-15

...	...	@@ -129,9 +129,10 @@ pub fn initSymbols(self: LinkerDefined, elf_file: Elf) !void {
129	129
130	130	pub fn initStartStopSymbols(self: LinkerDefined, elf_file: Elf) !void {
131	131	const gpa = elf_file.base.comp.gpa;
	132	const slice = elf_file.sections.slice();
132	133
133	134	var nsyms: usize = 0;
134		for (elf_file.shdrs.items) \|shdr\| {
	135	for (slice.items(.shdr)) \|shdr\| {
135	136	if (elf_file.getStartStopBasename(shdr)) \|_\| {
136	137	nsyms += 2; // __start_, __stop_
137	138	}
...	...	@@ -143,7 +144,7 @@ pub fn initStartStopSymbols(self: LinkerDefined, elf_file: Elf) !void {
143	144	try self.symbols_extra.ensureUnusedCapacity(gpa, nsyms * @sizeOf(Symbol.Extra));
144	145	try self.symbols_resolver.ensureUnusedCapacity(gpa, nsyms);
145	146
146		for (elf_file.shdrs.items) \|shdr\| {
	147	for (slice.items(.shdr)) \|shdr\| {
147	148	if (elf_file.getStartStopBasename(shdr)) \|name\| {
148	149	const start_name = try std.fmt.allocPrintZ(gpa, "__start_{s}", .{name});
149	150	defer gpa.free(start_name);
...	...	@@ -193,6 +194,7 @@ pub fn resolveSymbols(self: LinkerDefined, elf_file: Elf) !void {
193	194	pub fn allocateSymbols(self: LinkerDefined, elf_file: Elf) void {
194	195	const comp = elf_file.base.comp;
195	196	const link_mode = comp.config.link_mode;
	197	const shdrs = elf_file.sections.items(.shdr);
196	198
197	199	const allocSymbol = struct {
198	200	fn allocSymbol(ld: LinkerDefined, index: Symbol.Index, value: u64, osec: u32, ef: Elf) void {
...	...	@@ -204,7 +206,7 @@ pub fn allocateSymbols(self: LinkerDefined, elf_file: Elf) void {
204	206
205	207	// _DYNAMIC
206	208	if (elf_file.dynamic_section_index) \|shndx\| {
207		const shdr = &elf_file.shdrs.items[shndx];
	209	const shdr = shdrs[shndx];
208	210	allocSymbol(self, self.dynamic_index.?, shdr.sh_addr, shndx, elf_file);
209	211	}
210	212
...	...	@@ -213,21 +215,21 @@ pub fn allocateSymbols(self: LinkerDefined, elf_file: Elf) void {
213	215
214	216	// __init_array_start, __init_array_end
215	217	if (elf_file.sectionByName(".init_array")) \|shndx\| {
216		const shdr = &elf_file.shdrs.items[shndx];
	218	const shdr = shdrs[shndx];
217	219	allocSymbol(self, self.init_array_start_index.?, shdr.sh_addr, shndx, elf_file);
218	220	allocSymbol(self, self.init_array_end_index.?, shdr.sh_addr + shdr.sh_size, shndx, elf_file);
219	221	}
220	222
221	223	// __fini_array_start, __fini_array_end
222	224	if (elf_file.sectionByName(".fini_array")) \|shndx\| {
223		const shdr = &elf_file.shdrs.items[shndx];
	225	const shdr = shdrs[shndx];
224	226	allocSymbol(self, self.fini_array_start_index.?, shdr.sh_addr, shndx, elf_file);
225	227	allocSymbol(self, self.fini_array_end_index.?, shdr.sh_addr + shdr.sh_size, shndx, elf_file);
226	228	}
227	229
228	230	// __preinit_array_start, __preinit_array_end
229	231	if (elf_file.sectionByName(".preinit_array")) \|shndx\| {
230		const shdr = &elf_file.shdrs.items[shndx];
	232	const shdr = shdrs[shndx];
231	233	allocSymbol(self, self.preinit_array_start_index.?, shdr.sh_addr, shndx, elf_file);
232	234	allocSymbol(self, self.preinit_array_end_index.?, shdr.sh_addr + shdr.sh_size, shndx, elf_file);
233	235	}
...	...	@@ -235,38 +237,38 @@ pub fn allocateSymbols(self: LinkerDefined, elf_file: Elf) void {
235	237	// _GLOBAL_OFFSET_TABLE_
236	238	if (elf_file.getTarget().cpu.arch == .x86_64) {
237	239	if (elf_file.got_plt_section_index) \|shndx\| {
238		const shdr = elf_file.shdrs.items[shndx];
	240	const shdr = shdrs[shndx];
239	241	allocSymbol(self, self.got_index.?, shdr.sh_addr, shndx, elf_file);
240	242	}
241	243	} else {
242	244	if (elf_file.got_section_index) \|shndx\| {
243		const shdr = elf_file.shdrs.items[shndx];
	245	const shdr = shdrs[shndx];
244	246	allocSymbol(self, self.got_index.?, shdr.sh_addr, shndx, elf_file);
245	247	}
246	248	}
247	249
248	250	// _PROCEDURE_LINKAGE_TABLE_
249	251	if (elf_file.plt_section_index) \|shndx\| {
250		const shdr = &elf_file.shdrs.items[shndx];
	252	const shdr = shdrs[shndx];
251	253	allocSymbol(self, self.plt_index.?, shdr.sh_addr, shndx, elf_file);
252	254	}
253	255
254	256	// __dso_handle
255	257	if (self.dso_handle_index) \|index\| {
256		const shdr = &elf_file.shdrs.items[1];
	258	const shdr = shdrs[1];
257	259	allocSymbol(self, index, shdr.sh_addr, 0, elf_file);
258	260	}
259	261
260	262	// __GNU_EH_FRAME_HDR
261	263	if (elf_file.eh_frame_hdr_section_index) \|shndx\| {
262		const shdr = &elf_file.shdrs.items[shndx];
	264	const shdr = shdrs[shndx];
263	265	allocSymbol(self, self.gnu_eh_frame_hdr_index.?, shdr.sh_addr, shndx, elf_file);
264	266	}
265	267
266	268	// __rela_iplt_start, __rela_iplt_end
267	269	if (elf_file.rela_dyn_section_index) \|shndx\| blk: {
268	270	if (link_mode != .static or comp.config.pie) break :blk;
269		const shdr = &elf_file.shdrs.items[shndx];
	271	const shdr = shdrs[shndx];
270	272	const end_addr = shdr.sh_addr + shdr.sh_size;
271	273	const start_addr = end_addr - elf_file.calcNumIRelativeRelocs() * @sizeOf(elf.Elf64_Rela);
272	274	allocSymbol(self, self.rela_iplt_start_index.?, start_addr, shndx, elf_file);
...	...	@@ -277,7 +279,7 @@ pub fn allocateSymbols(self: LinkerDefined, elf_file: Elf) void {
277	279	{
278	280	var value: u64 = 0;
279	281	var osec: u32 = 0;
280		for (elf_file.shdrs.items, 0..) \|shdr, shndx\| {
	282	for (shdrs, 0..) \|shdr, shndx\| {
281	283	if (shdr.sh_flags & elf.SHF_ALLOC != 0) {
282	284	value = shdr.sh_addr + shdr.sh_size;
283	285	osec = @intCast(shndx);
...	...	@@ -289,7 +291,7 @@ pub fn allocateSymbols(self: LinkerDefined, elf_file: Elf) void {
289	291	// __global_pointer$
290	292	if (self.global_pointer_index) \|index\| {
291	293	const value, const osec = if (elf_file.sectionByName(".sdata")) \|shndx\| .{
292		elf_file.shdrs.items[shndx].sh_addr + 0x800,
	294	shdrs[shndx].sh_addr + 0x800,
293	295	shndx,
294	296	} else .{ 0, 0 };
295	297	allocSymbol(self, index, value, osec, elf_file);
...	...	@@ -305,7 +307,7 @@ pub fn allocateSymbols(self: LinkerDefined, elf_file: Elf) void {
305	307	const stop_ref = self.resolveSymbol(self.start_stop_indexes.items[index + 1], elf_file);
306	308	const stop = elf_file.symbol(stop_ref).?;
307	309	const shndx = elf_file.sectionByName(name["__start_".len..]).?;
308		const shdr = &elf_file.shdrs.items[shndx];
	310	const shdr = shdrs[shndx];
309	311	start.value = @intCast(shdr.sh_addr);
310	312	start.output_section_index = shndx;
311	313	stop.value = @intCast(shdr.sh_addr + shdr.sh_size);

src/link/Elf/Object.zig+9-11

...	...	@@ -998,9 +998,8 @@ pub fn addAtomsToOutputSections(self: Object, elf_file: Elf) !void {
998	998
999	999	const comp = elf_file.base.comp;
1000	1000	const gpa = comp.gpa;
1001		const gop = try elf_file.output_sections.getOrPut(gpa, atom_ptr.output_section_index);
1002		if (!gop.found_existing) gop.value_ptr.* = .{};
1003		try gop.value_ptr.append(gpa, .{ .index = atom_index, .file = self.index });
	1001	const atom_list = &elf_file.sections.items(.atom_list)[atom_ptr.output_section_index];
	1002	try atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
1004	1003	}
1005	1004	}
1006	1005
...	...	@@ -1011,7 +1010,8 @@ pub fn initRelaSections(self: Object, elf_file: Elf) !void {
1011	1010	const shndx = atom_ptr.relocsShndx() orelse continue;
1012	1011	const shdr = self.shdrs.items[shndx];
1013	1012	const out_shndx = try self.initOutputSection(elf_file, shdr);
1014		const out_shdr = &elf_file.shdrs.items[out_shndx];
	1013	const out_shdr = &elf_file.sections.items(.shdr)[out_shndx];
	1014	out_shdr.sh_type = elf.SHT_RELA;
1015	1015	out_shdr.sh_addralign = @alignOf(elf.Elf64_Rela);
1016	1016	out_shdr.sh_entsize = @sizeOf(elf.Elf64_Rela);
1017	1017	out_shdr.sh_flags \|= elf.SHF_INFO_LINK;
...	...	@@ -1027,15 +1027,13 @@ pub fn addAtomsToRelaSections(self: Object, elf_file: Elf) !void {
1027	1027	const shdr = self.shdrs.items[shndx];
1028	1028	break :blk self.initOutputSection(elf_file, shdr) catch unreachable;
1029	1029	};
1030		const shdr = &elf_file.shdrs.items[shndx];
	1030	const slice = elf_file.sections.slice();
	1031	const shdr = &slice.items(.shdr)[shndx];
1031	1032	shdr.sh_info = atom_ptr.output_section_index;
1032	1033	shdr.sh_link = elf_file.symtab_section_index.?;
1033
1034		const comp = elf_file.base.comp;
1035		const gpa = comp.gpa;
1036		const gop = try elf_file.output_rela_sections.getOrPut(gpa, atom_ptr.output_section_index);
1037		if (!gop.found_existing) gop.value_ptr.* = .{ .shndx = shndx };
1038		try gop.value_ptr.atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
	1034	const gpa = elf_file.base.comp.gpa;
	1035	const atom_list = &elf_file.sections.items(.atom_list)[shndx];
	1036	try atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
1039	1037	}
1040	1038	}
1041	1039

src/link/Elf/Symbol.zig+7-7

...	...	@@ -11,7 +11,7 @@ file_index: File.Index = 0,
11	11
12	12	/// Reference to Atom or merge subsection containing this symbol if any.
13	13	/// Use `atom` or `mergeSubsection` to get the pointer to the atom.
14		ref: Elf.Ref = .{ .index = 0, .file = 0 },
	14	ref: Elf.Ref = .{},
15	15
16	16	/// Assigned output section index for this symbol.
17	17	output_section_index: u32 = 0,
...	...	@@ -126,7 +126,7 @@ pub fn address(symbol: Symbol, opts: struct { plt: bool = true, trampoline: bool
126	126	const sym_name = symbol.name(elf_file);
127	127	const sh_addr, const sh_size = blk: {
128	128	const shndx = elf_file.eh_frame_section_index orelse break :blk .{ 0, 0 };
129		const shdr = elf_file.shdrs.items[shndx];
	129	const shdr = elf_file.sections.items(.shdr)[shndx];
130	130	break :blk .{ shdr.sh_addr, shdr.sh_size };
131	131	};
132	132	if (mem.startsWith(u8, sym_name, "__EH_FRAME_BEGIN__") or
...	...	@@ -173,7 +173,7 @@ pub fn gotAddress(symbol: Symbol, elf_file: *Elf) i64 {
173	173	pub fn pltGotAddress(symbol: Symbol, elf_file: *Elf) i64 {
174	174	if (!(symbol.flags.has_plt and symbol.flags.has_got)) return 0;
175	175	const extras = symbol.extra(elf_file);
176		const shdr = elf_file.shdrs.items[elf_file.plt_got_section_index.?];
	176	const shdr = elf_file.sections.items(.shdr)[elf_file.plt_got_section_index.?];
177	177	const cpu_arch = elf_file.getTarget().cpu.arch;
178	178	return @intCast(shdr.sh_addr + extras.plt_got * PltGotSection.entrySize(cpu_arch));
179	179	}
...	...	@@ -181,7 +181,7 @@ pub fn pltGotAddress(symbol: Symbol, elf_file: *Elf) i64 {
181	181	pub fn pltAddress(symbol: Symbol, elf_file: *Elf) i64 {
182	182	if (!symbol.flags.has_plt) return 0;
183	183	const extras = symbol.extra(elf_file);
184		const shdr = elf_file.shdrs.items[elf_file.plt_section_index.?];
	184	const shdr = elf_file.sections.items(.shdr)[elf_file.plt_section_index.?];
185	185	const cpu_arch = elf_file.getTarget().cpu.arch;
186	186	return @intCast(shdr.sh_addr + extras.plt * PltSection.entrySize(cpu_arch) + PltSection.preambleSize(cpu_arch));
187	187	}
...	...	@@ -189,13 +189,13 @@ pub fn pltAddress(symbol: Symbol, elf_file: *Elf) i64 {
189	189	pub fn gotPltAddress(symbol: Symbol, elf_file: *Elf) i64 {
190	190	if (!symbol.flags.has_plt) return 0;
191	191	const extras = symbol.extra(elf_file);
192		const shdr = elf_file.shdrs.items[elf_file.got_plt_section_index.?];
	192	const shdr = elf_file.sections.items(.shdr)[elf_file.got_plt_section_index.?];
193	193	return @intCast(shdr.sh_addr + extras.plt * 8 + GotPltSection.preamble_size);
194	194	}
195	195
196	196	pub fn copyRelAddress(symbol: Symbol, elf_file: *Elf) i64 {
197	197	if (!symbol.flags.has_copy_rel) return 0;
198		const shdr = elf_file.shdrs.items[elf_file.copy_rel_section_index.?];
	198	const shdr = elf_file.sections.items(.shdr)[elf_file.copy_rel_section_index.?];
199	199	return @as(i64, @intCast(shdr.sh_addr)) + symbol.value;
200	200	}
201	201
...	...	@@ -300,7 +300,7 @@ pub fn setOutputSym(symbol: Symbol, elf_file: Elf, out: elf.Elf64_Sym) void {
300	300	break :blk 0;
301	301	}
302	302	if (st_shndx == elf.SHN_ABS or st_shndx == elf.SHN_COMMON) break :blk symbol.address(.{ .plt = false }, elf_file);
303		const shdr = elf_file.shdrs.items[st_shndx];
	303	const shdr = elf_file.sections.items(.shdr)[st_shndx];
304	304	if (shdr.sh_flags & elf.SHF_TLS != 0 and file_ptr != .linker_defined)
305	305	break :blk symbol.address(.{ .plt = false }, elf_file) - elf_file.tlsAddress();
306	306	break :blk symbol.address(.{ .plt = false, .trampoline = false }, elf_file);

src/link/Elf/ZigObject.zig+310-38

...	...	@@ -63,24 +63,300 @@ pub const global_symbol_bit: u32 = 0x80000000;
63	63	pub const symbol_mask: u32 = 0x7fffffff;
64	64	pub const SHN_ATOM: u16 = 0x100;
65	65
66		pub fn init(self: ZigObject, elf_file: Elf) !void {
	66	const InitOptions = struct {
	67	symbol_count_hint: u64,
	68	program_code_size_hint: u64,
	69	};
	70
	71	pub fn init(self: ZigObject, elf_file: Elf, options: InitOptions) !void {
67	72	const comp = elf_file.base.comp;
68	73	const gpa = comp.gpa;
	74	const ptr_size = elf_file.ptrWidthBytes();
	75	const target = elf_file.getTarget();
	76	const ptr_bit_width = target.ptrBitWidth();
69	77
70	78	try self.atoms.append(gpa, .{ .extra_index = try self.addAtomExtra(gpa, .{}) }); // null input section
71	79	try self.relocs.append(gpa, .{}); // null relocs section
72	80	try self.strtab.buffer.append(gpa, 0);
73	81
74		const name_off = try self.strtab.insert(gpa, self.path);
75		const symbol_index = try self.newLocalSymbol(gpa, name_off);
76		const sym = self.symbol(symbol_index);
77		const esym = &self.symtab.items(.elf_sym)[sym.esym_index];
78		esym.st_info = elf.STT_FILE;
79		esym.st_shndx = elf.SHN_ABS;
	82	{
	83	const name_off = try self.strtab.insert(gpa, self.path);
	84	const symbol_index = try self.newLocalSymbol(gpa, name_off);
	85	const sym = self.symbol(symbol_index);
	86	const esym = &self.symtab.items(.elf_sym)[sym.esym_index];
	87	esym.st_info = elf.STT_FILE;
	88	esym.st_shndx = elf.SHN_ABS;
	89	}
	90
	91	const fillSection = struct {
	92	fn fillSection(ef: Elf, shdr: elf.Elf64_Shdr, size: u64, phndx: ?u16) !void {
	93	if (ef.base.isRelocatable()) {
	94	const off = try ef.findFreeSpace(size, shdr.sh_addralign);
	95	shdr.sh_offset = off;
	96	shdr.sh_size = size;
	97	} else {
	98	const phdr = ef.phdrs.items[phndx.?];
	99	shdr.sh_addr = phdr.p_vaddr;
	100	shdr.sh_offset = phdr.p_offset;
	101	shdr.sh_size = phdr.p_memsz;
	102	}
	103	}
	104	}.fillSection;
	105
	106	comptime assert(Elf.number_of_zig_segments == 4);
	107
	108	if (!elf_file.base.isRelocatable()) {
	109	if (elf_file.phdr_zig_load_re_index == null) {
	110	const filesz = options.program_code_size_hint;
	111	const off = try elf_file.findFreeSpace(filesz, elf_file.page_size);
	112	elf_file.phdr_zig_load_re_index = try elf_file.addPhdr(.{
	113	.type = elf.PT_LOAD,
	114	.offset = off,
	115	.filesz = filesz,
	116	.addr = if (ptr_bit_width >= 32) 0x4000000 else 0x4000,
	117	.memsz = filesz,
	118	.@"align" = elf_file.page_size,
	119	.flags = elf.PF_X \| elf.PF_R \| elf.PF_W,
	120	});
	121	}
	122
	123	if (elf_file.phdr_zig_load_ro_index == null) {
	124	const alignment = elf_file.page_size;
	125	const filesz: u64 = 1024;
	126	const off = try elf_file.findFreeSpace(filesz, alignment);
	127	elf_file.phdr_zig_load_ro_index = try elf_file.addPhdr(.{
	128	.type = elf.PT_LOAD,
	129	.offset = off,
	130	.filesz = filesz,
	131	.addr = if (ptr_bit_width >= 32) 0xc000000 else 0xa000,
	132	.memsz = filesz,
	133	.@"align" = alignment,
	134	.flags = elf.PF_R \| elf.PF_W,
	135	});
	136	}
	137
	138	if (elf_file.phdr_zig_load_rw_index == null) {
	139	const alignment = elf_file.page_size;
	140	const filesz: u64 = 1024;
	141	const off = try elf_file.findFreeSpace(filesz, alignment);
	142	elf_file.phdr_zig_load_rw_index = try elf_file.addPhdr(.{
	143	.type = elf.PT_LOAD,
	144	.offset = off,
	145	.filesz = filesz,
	146	.addr = if (ptr_bit_width >= 32) 0x10000000 else 0xc000,
	147	.memsz = filesz,
	148	.@"align" = alignment,
	149	.flags = elf.PF_R \| elf.PF_W,
	150	});
	151	}
	152
	153	if (elf_file.phdr_zig_load_zerofill_index == null) {
	154	const alignment = elf_file.page_size;
	155	elf_file.phdr_zig_load_zerofill_index = try elf_file.addPhdr(.{
	156	.type = elf.PT_LOAD,
	157	.addr = if (ptr_bit_width >= 32) 0x14000000 else 0xf000,
	158	.memsz = 1024,
	159	.@"align" = alignment,
	160	.flags = elf.PF_R \| elf.PF_W,
	161	});
	162	}
	163	}
	164
	165	if (elf_file.zig_text_section_index == null) {
	166	elf_file.zig_text_section_index = try elf_file.addSection(.{
	167	.name = try elf_file.insertShString(".text.zig"),
	168	.type = elf.SHT_PROGBITS,
	169	.flags = elf.SHF_ALLOC \| elf.SHF_EXECINSTR,
	170	.addralign = 1,
	171	.offset = std.math.maxInt(u64),
	172	});
	173	const shdr = &elf_file.sections.items(.shdr)[elf_file.zig_text_section_index.?];
	174	const phndx = &elf_file.sections.items(.phndx)[elf_file.zig_text_section_index.?];
	175	try fillSection(elf_file, shdr, options.program_code_size_hint, elf_file.phdr_zig_load_re_index);
	176	if (elf_file.base.isRelocatable()) {
	177	_ = try elf_file.addRelaShdr(
	178	try elf_file.insertShString(".rela.text.zig"),
	179	elf_file.zig_text_section_index.?,
	180	);
	181	} else {
	182	phndx.* = elf_file.phdr_zig_load_re_index.?;
	183	}
	184	}
	185
	186	if (elf_file.zig_data_rel_ro_section_index == null) {
	187	elf_file.zig_data_rel_ro_section_index = try elf_file.addSection(.{
	188	.name = try elf_file.insertShString(".data.rel.ro.zig"),
	189	.type = elf.SHT_PROGBITS,
	190	.addralign = 1,
	191	.flags = elf.SHF_ALLOC \| elf.SHF_WRITE,
	192	.offset = std.math.maxInt(u64),
	193	});
	194	const shdr = &elf_file.sections.items(.shdr)[elf_file.zig_data_rel_ro_section_index.?];
	195	const phndx = &elf_file.sections.items(.phndx)[elf_file.zig_data_rel_ro_section_index.?];
	196	try fillSection(elf_file, shdr, 1024, elf_file.phdr_zig_load_ro_index);
	197	if (elf_file.base.isRelocatable()) {
	198	_ = try elf_file.addRelaShdr(
	199	try elf_file.insertShString(".rela.data.rel.ro.zig"),
	200	elf_file.zig_data_rel_ro_section_index.?,
	201	);
	202	} else {
	203	phndx.* = elf_file.phdr_zig_load_ro_index.?;
	204	}
	205	}
	206
	207	if (elf_file.zig_data_section_index == null) {
	208	elf_file.zig_data_section_index = try elf_file.addSection(.{
	209	.name = try elf_file.insertShString(".data.zig"),
	210	.type = elf.SHT_PROGBITS,
	211	.addralign = ptr_size,
	212	.flags = elf.SHF_ALLOC \| elf.SHF_WRITE,
	213	.offset = std.math.maxInt(u64),
	214	});
	215	const shdr = &elf_file.sections.items(.shdr)[elf_file.zig_data_section_index.?];
	216	const phndx = &elf_file.sections.items(.phndx)[elf_file.zig_data_section_index.?];
	217	try fillSection(elf_file, shdr, 1024, elf_file.phdr_zig_load_rw_index);
	218	if (elf_file.base.isRelocatable()) {
	219	_ = try elf_file.addRelaShdr(
	220	try elf_file.insertShString(".rela.data.zig"),
	221	elf_file.zig_data_section_index.?,
	222	);
	223	} else {
	224	phndx.* = elf_file.phdr_zig_load_rw_index.?;
	225	}
	226	}
	227
	228	if (elf_file.zig_bss_section_index == null) {
	229	elf_file.zig_bss_section_index = try elf_file.addSection(.{
	230	.name = try elf_file.insertShString(".bss.zig"),
	231	.type = elf.SHT_NOBITS,
	232	.addralign = ptr_size,
	233	.flags = elf.SHF_ALLOC \| elf.SHF_WRITE,
	234	.offset = 0,
	235	});
	236	const shdr = &elf_file.sections.items(.shdr)[elf_file.zig_bss_section_index.?];
	237	const phndx = &elf_file.sections.items(.phndx)[elf_file.zig_bss_section_index.?];
	238	if (elf_file.base.isRelocatable()) {
	239	shdr.sh_size = 1024;
	240	} else {
	241	phndx.* = elf_file.phdr_zig_load_zerofill_index.?;
	242	const phdr = elf_file.phdrs.items[phndx.*.?];
	243	shdr.sh_addr = phdr.p_vaddr;
	244	shdr.sh_size = phdr.p_memsz;
	245	}
	246	}
80	247
81	248	switch (comp.config.debug_format) {
82	249	.strip => {},
83		.dwarf => \|v\| self.dwarf = Dwarf.init(&elf_file.base, v),
	250	.dwarf => \|v\| {
	251	var dwarf = Dwarf.init(&elf_file.base, v);
	252
	253	const addSectionSymbol = struct {
	254	fn addSectionSymbol(
	255	zig_object: *ZigObject,
	256	alloc: Allocator,
	257	name: [:0]const u8,
	258	alignment: Atom.Alignment,
	259	shndx: u32,
	260	) !Symbol.Index {
	261	const name_off = try zig_object.addString(alloc, name);
	262	const index = try zig_object.newSymbolWithAtom(alloc, name_off);
	263	const sym = zig_object.symbol(index);
	264	const esym = &zig_object.symtab.items(.elf_sym)[sym.esym_index];
	265	esym.st_info \|= elf.STT_SECTION;
	266	const atom_ptr = zig_object.atom(sym.ref.index).?;
	267	atom_ptr.alignment = alignment;
	268	atom_ptr.output_section_index = shndx;
	269	return index;
	270	}
	271	}.addSectionSymbol;
	272
	273	if (elf_file.debug_str_section_index == null) {
	274	elf_file.debug_str_section_index = try elf_file.addSection(.{
	275	.name = try elf_file.insertShString(".debug_str"),
	276	.flags = elf.SHF_MERGE \| elf.SHF_STRINGS,
	277	.entsize = 1,
	278	.type = elf.SHT_PROGBITS,
	279	.addralign = 1,
	280	});
	281	self.debug_str_section_dirty = true;
	282	self.debug_str_index = try addSectionSymbol(self, gpa, ".debug_str", .@"1", elf_file.debug_str_section_index.?);
	283	}
	284
	285	if (elf_file.debug_info_section_index == null) {
	286	elf_file.debug_info_section_index = try elf_file.addSection(.{
	287	.name = try elf_file.insertShString(".debug_info"),
	288	.type = elf.SHT_PROGBITS,
	289	.addralign = 1,
	290	});
	291	self.debug_info_section_dirty = true;
	292	self.debug_info_index = try addSectionSymbol(self, gpa, ".debug_info", .@"1", elf_file.debug_info_section_index.?);
	293	}
	294
	295	if (elf_file.debug_abbrev_section_index == null) {
	296	elf_file.debug_abbrev_section_index = try elf_file.addSection(.{
	297	.name = try elf_file.insertShString(".debug_abbrev"),
	298	.type = elf.SHT_PROGBITS,
	299	.addralign = 1,
	300	});
	301	self.debug_abbrev_section_dirty = true;
	302	self.debug_abbrev_index = try addSectionSymbol(self, gpa, ".debug_abbrev", .@"1", elf_file.debug_abbrev_section_index.?);
	303	}
	304
	305	if (elf_file.debug_aranges_section_index == null) {
	306	elf_file.debug_aranges_section_index = try elf_file.addSection(.{
	307	.name = try elf_file.insertShString(".debug_aranges"),
	308	.type = elf.SHT_PROGBITS,
	309	.addralign = 16,
	310	});
	311	self.debug_aranges_section_dirty = true;
	312	self.debug_aranges_index = try addSectionSymbol(self, gpa, ".debug_aranges", .@"16", elf_file.debug_aranges_section_index.?);
	313	}
	314
	315	if (elf_file.debug_line_section_index == null) {
	316	elf_file.debug_line_section_index = try elf_file.addSection(.{
	317	.name = try elf_file.insertShString(".debug_line"),
	318	.type = elf.SHT_PROGBITS,
	319	.addralign = 1,
	320	});
	321	self.debug_line_section_dirty = true;
	322	self.debug_line_index = try addSectionSymbol(self, gpa, ".debug_line", .@"1", elf_file.debug_line_section_index.?);
	323	}
	324
	325	if (elf_file.debug_line_str_section_index == null) {
	326	elf_file.debug_line_str_section_index = try elf_file.addSection(.{
	327	.name = try elf_file.insertShString(".debug_line_str"),
	328	.flags = elf.SHF_MERGE \| elf.SHF_STRINGS,
	329	.entsize = 1,
	330	.type = elf.SHT_PROGBITS,
	331	.addralign = 1,
	332	});
	333	self.debug_line_str_section_dirty = true;
	334	self.debug_line_str_index = try addSectionSymbol(self, gpa, ".debug_line_str", .@"1", elf_file.debug_line_str_section_index.?);
	335	}
	336
	337	if (elf_file.debug_loclists_section_index == null) {
	338	elf_file.debug_loclists_section_index = try elf_file.addSection(.{
	339	.name = try elf_file.insertShString(".debug_loclists"),
	340	.type = elf.SHT_PROGBITS,
	341	.addralign = 1,
	342	});
	343	self.debug_loclists_section_dirty = true;
	344	self.debug_loclists_index = try addSectionSymbol(self, gpa, ".debug_loclists", .@"1", elf_file.debug_loclists_section_index.?);
	345	}
	346
	347	if (elf_file.debug_rnglists_section_index == null) {
	348	elf_file.debug_rnglists_section_index = try elf_file.addSection(.{
	349	.name = try elf_file.insertShString(".debug_rnglists"),
	350	.type = elf.SHT_PROGBITS,
	351	.addralign = 1,
	352	});
	353	self.debug_rnglists_section_dirty = true;
	354	self.debug_rnglists_index = try addSectionSymbol(self, gpa, ".debug_rnglists", .@"1", elf_file.debug_rnglists_section_index.?);
	355	}
	356
	357	try dwarf.initMetadata();
	358	self.dwarf = dwarf;
	359	},
84	360	.code_view => unreachable,
85	361	}
86	362	}
...	...	@@ -198,7 +474,7 @@ pub fn flushModule(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !voi
198	474	const atom_ptr = self.atom(sym.ref.index).?;
199	475	if (!atom_ptr.alive) continue;
200	476	const shndx = sym.outputShndx(elf_file).?;
201		const shdr = elf_file.shdrs.items[shndx];
	477	const shdr = elf_file.sections.items(.shdr)[shndx];
202	478	const esym = &self.symtab.items(.elf_sym)[sym.esym_index];
203	479	esym.st_size = shdr.sh_size;
204	480	atom_ptr.size = shdr.sh_size;
...	...	@@ -358,13 +634,10 @@ pub fn flushModule(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !voi
358	634	}
359	635
360	636	if (elf_file.base.isRelocatable() and relocs.items.len > 0) {
361		const gop = try elf_file.output_rela_sections.getOrPut(gpa, shndx);
362		if (!gop.found_existing) {
363		const rela_sect_name = try std.fmt.allocPrintZ(gpa, ".rela{s}", .{elf_file.getShString(shdr.sh_name)});
364		defer gpa.free(rela_sect_name);
365		const rela_sh_name = try elf_file.insertShString(rela_sect_name);
366		const rela_shndx = try elf_file.addRelaShdr(rela_sh_name, shndx);
367		gop.value_ptr.* = .{ .shndx = rela_shndx };
	637	const rela_sect_name = try std.fmt.allocPrintZ(gpa, ".rela{s}", .{elf_file.getShString(shdr.sh_name)});
	638	defer gpa.free(rela_sect_name);
	639	if (elf_file.sectionByName(rela_sect_name) == null) {
	640	_ = try elf_file.addRelaShdr(try elf_file.insertShString(rela_sect_name), shndx);
368	641	}
369	642	}
370	643	}
...	...	@@ -446,7 +719,7 @@ fn newAtom(self: *ZigObject, allocator: Allocator, name_off: u32) !Atom.Index {
446	719	return index;
447	720	}
448	721
449		pub fn newSymbolWithAtom(self: *ZigObject, allocator: Allocator, name_off: u32) !Symbol.Index {
	722	fn newSymbolWithAtom(self: *ZigObject, allocator: Allocator, name_off: u32) !Symbol.Index {
450	723	const atom_index = try self.newAtom(allocator, name_off);
451	724	const sym_index = try self.newLocalSymbol(allocator, name_off);
452	725	const sym = self.symbol(sym_index);
...	...	@@ -460,7 +733,7 @@ pub fn newSymbolWithAtom(self: *ZigObject, allocator: Allocator, name_off: u32)
460	733	pub fn inputShdr(self: ZigObject, atom_index: Atom.Index, elf_file: Elf) elf.Elf64_Shdr {
461	734	const atom_ptr = self.atom(atom_index) orelse return Elf.null_shdr;
462	735	const shndx = atom_ptr.output_section_index;
463		var shdr = elf_file.shdrs.items[shndx];
	736	var shdr = elf_file.sections.items(.shdr)[shndx];
464	737	shdr.sh_addr = 0;
465	738	shdr.sh_offset = 0;
466	739	shdr.sh_size = atom_ptr.size;
...	...	@@ -638,8 +911,8 @@ pub fn readFileContents(self: ZigObject, elf_file: Elf) !void {
638	911	.p32 => @sizeOf(elf.Elf32_Shdr),
639	912	.p64 => @sizeOf(elf.Elf64_Shdr),
640	913	};
641		var end_pos: u64 = elf_file.shdr_table_offset.? + elf_file.shdrs.items.len * shsize;
642		for (elf_file.shdrs.items) \|shdr\| {
	914	var end_pos: u64 = elf_file.shdr_table_offset.? + elf_file.sections.items(.shdr).len * shsize;
	915	for (elf_file.sections.items(.shdr)) \|shdr\| {
643	916	if (shdr.sh_type == elf.SHT_NOBITS) continue;
644	917	end_pos = @max(end_pos, shdr.sh_offset + shdr.sh_size);
645	918	}
...	...	@@ -692,12 +965,14 @@ pub fn addAtomsToRelaSections(self: ZigObject, elf_file: Elf) !void {
692	965	// TODO this check will become obsolete when we rework our relocs mechanism at the ZigObject level
693	966	if (self.relocs.items[rela_shndx].items.len == 0) continue;
694	967	const out_shndx = atom_ptr.output_section_index;
695		const out_shdr = elf_file.shdrs.items[out_shndx];
	968	const out_shdr = elf_file.sections.items(.shdr)[out_shndx];
696	969	if (out_shdr.sh_type == elf.SHT_NOBITS) continue;
697
	970	const out_rela_shndx = for (elf_file.sections.items(.shdr), 0..) \|out_rela_shdr, out_rela_shndx\| {
	971	if (out_rela_shdr.sh_type == elf.SHT_RELA and out_rela_shdr.sh_info == out_shndx) break out_rela_shndx;
	972	} else unreachable;
	973	const atom_list = &elf_file.sections.items(.atom_list)[out_rela_shndx];
698	974	const gpa = elf_file.base.comp.gpa;
699		const sec = elf_file.output_rela_sections.getPtr(out_shndx).?;
700		try sec.atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
	975	try atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
701	976	}
702	977	}
703	978
...	...	@@ -767,7 +1042,7 @@ pub fn writeSymtab(self: ZigObject, elf_file: *Elf) void {
767	1042	pub fn codeAlloc(self: ZigObject, elf_file: Elf, atom_index: Atom.Index) ![]u8 {
768	1043	const gpa = elf_file.base.comp.gpa;
769	1044	const atom_ptr = self.atom(atom_index).?;
770		const shdr = &elf_file.shdrs.items[atom_ptr.output_section_index];
	1045	const shdr = &elf_file.sections.items(.shdr)[atom_ptr.output_section_index];
771	1046
772	1047	if (shdr.sh_flags & elf.SHF_TLS != 0) {
773	1048	const tlv = self.tls_variables.get(atom_index).?;
...	...	@@ -1094,7 +1369,7 @@ fn updateNavCode(
1094	1369	}
1095	1370	}
1096	1371
1097		const shdr = elf_file.shdrs.items[shdr_index];
	1372	const shdr = elf_file.sections.items(.shdr)[shdr_index];
1098	1373	if (shdr.sh_type != elf.SHT_NOBITS) {
1099	1374	const file_offset = shdr.sh_offset + @as(u64, @intCast(atom_ptr.value));
1100	1375	try elf_file.base.file.?.pwriteAll(code, file_offset);
...	...	@@ -1149,16 +1424,13 @@ fn updateTlv(
1149	1424	gop.value_ptr.* = .{ .symbol_index = sym_index };
1150	1425
1151	1426	// We only store the data for the TLV if it's non-zerofill.
1152		if (elf_file.shdrs.items[shndx].sh_type != elf.SHT_NOBITS) {
	1427	if (elf_file.sections.items(.shdr)[shndx].sh_type != elf.SHT_NOBITS) {
1153	1428	gop.value_ptr.code = try gpa.dupe(u8, code);
1154	1429	}
1155	1430	}
1156	1431
1157		{
1158		const gop = try elf_file.output_sections.getOrPut(gpa, atom_ptr.output_section_index);
1159		if (!gop.found_existing) gop.value_ptr.* = .{};
1160		try gop.value_ptr.append(gpa, .{ .index = atom_ptr.atom_index, .file = self.index });
1161		}
	1432	const atom_list = &elf_file.sections.items(.atom_list)[atom_ptr.output_section_index];
	1433	try atom_list.append(gpa, .{ .index = atom_ptr.atom_index, .file = self.index });
1162	1434	}
1163	1435
1164	1436	pub fn updateFunc(
...	...	@@ -1210,7 +1482,7 @@ pub fn updateFunc(
1210	1482	const shndx = try self.getNavShdrIndex(elf_file, zcu, func.owner_nav, sym_index, code);
1211	1483	log.debug("setting shdr({x},{s}) for {}", .{
1212	1484	shndx,
1213		elf_file.getShString(elf_file.shdrs.items[shndx].sh_name),
	1485	elf_file.getShString(elf_file.sections.items(.shdr)[shndx].sh_name),
1214	1486	ip.getNav(func.owner_nav).fqn.fmt(ip),
1215	1487	});
1216	1488	const old_rva, const old_alignment = blk: {
...	...	@@ -1338,10 +1610,10 @@ pub fn updateNav(
1338	1610	const shndx = try self.getNavShdrIndex(elf_file, zcu, nav_index, sym_index, code);
1339	1611	log.debug("setting shdr({x},{s}) for {}", .{
1340	1612	shndx,
1341		elf_file.getShString(elf_file.shdrs.items[shndx].sh_name),
	1613	elf_file.getShString(elf_file.sections.items(.shdr)[shndx].sh_name),
1342	1614	nav.fqn.fmt(ip),
1343	1615	});
1344		if (elf_file.shdrs.items[shndx].sh_flags & elf.SHF_TLS != 0)
	1616	if (elf_file.sections.items(.shdr)[shndx].sh_flags & elf.SHF_TLS != 0)
1345	1617	try self.updateTlv(elf_file, pt, nav_index, sym_index, shndx, code)
1346	1618	else
1347	1619	try self.updateNavCode(elf_file, pt, nav_index, sym_index, shndx, code, elf.STT_OBJECT);
...	...	@@ -1440,7 +1712,7 @@ fn updateLazySymbol(
1440	1712	local_sym.value = 0;
1441	1713	local_esym.st_value = 0;
1442	1714
1443		const shdr = elf_file.shdrs.items[output_section_index];
	1715	const shdr = elf_file.sections.items(.shdr)[output_section_index];
1444	1716	const file_offset = shdr.sh_offset + @as(u64, @intCast(atom_ptr.value));
1445	1717	try elf_file.base.file.?.pwriteAll(code, file_offset);
1446	1718	}
...	...	@@ -1496,7 +1768,7 @@ fn lowerConst(
1496	1768	// TODO rename and re-audit this method
1497	1769	errdefer self.freeNavMetadata(elf_file, sym_index);
1498	1770
1499		const shdr = elf_file.shdrs.items[output_section_index];
	1771	const shdr = elf_file.sections.items(.shdr)[output_section_index];
1500	1772	const file_offset = shdr.sh_offset + @as(u64, @intCast(atom_ptr.value));
1501	1773	try elf_file.base.file.?.pwriteAll(code, file_offset);
1502	1774
...	...	@@ -1660,7 +1932,7 @@ fn trampolineSize(cpu_arch: std.Target.Cpu.Arch) u64 {
1660	1932
1661	1933	fn writeTrampoline(tr_sym: Symbol, target: Symbol, elf_file: *Elf) !void {
1662	1934	const atom_ptr = tr_sym.atom(elf_file).?;
1663		const shdr = elf_file.shdrs.items[atom_ptr.output_section_index];
	1935	const shdr = elf_file.sections.items(.shdr)[atom_ptr.output_section_index];
1664	1936	const fileoff = shdr.sh_offset + @as(u64, @intCast(atom_ptr.value));
1665	1937	const source_addr = tr_sym.address(.{}, elf_file);
1666	1938	const target_addr = target.address(.{ .trampoline = false }, elf_file);

src/link/Elf/eh_frame.zig+12-7

...	...	@@ -13,7 +13,7 @@ pub const Fde = struct {
13	13
14	14	pub fn address(fde: Fde, elf_file: *Elf) u64 {
15	15	const base: u64 = if (elf_file.eh_frame_section_index) \|shndx\|
16		elf_file.shdrs.items[shndx].sh_addr
	16	elf_file.sections.items(.shdr)[shndx].sh_addr
17	17	else
18	18	0;
19	19	return base + fde.out_offset;
...	...	@@ -112,7 +112,7 @@ pub const Cie = struct {
112	112
113	113	pub fn address(cie: Cie, elf_file: *Elf) u64 {
114	114	const base: u64 = if (elf_file.eh_frame_section_index) \|shndx\|
115		elf_file.shdrs.items[shndx].sh_addr
	115	elf_file.sections.items(.shdr)[shndx].sh_addr
116	116	else
117	117	0;
118	118	return base + cie.out_offset;
...	...	@@ -326,7 +326,9 @@ fn resolveReloc(rec: anytype, sym: *const Symbol, rel: elf.Elf64_Rela, elf_file:
326	326	}
327	327
328	328	pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void {
329		relocs_log.debug("{x}: .eh_frame", .{elf_file.shdrs.items[elf_file.eh_frame_section_index.?].sh_addr});
	329	relocs_log.debug("{x}: .eh_frame", .{
	330	elf_file.sections.items(.shdr)[elf_file.eh_frame_section_index.?].sh_addr,
	331	});
330	332
331	333	var has_reloc_errors = false;
332	334
...	...	@@ -423,7 +425,7 @@ fn emitReloc(elf_file: Elf, rec: anytype, sym: const Symbol, rel: elf.Elf64_Re
423	425	switch (sym.type(elf_file)) {
424	426	elf.STT_SECTION => {
425	427	r_addend += @intCast(sym.address(.{}, elf_file));
426		r_sym = elf_file.sectionSymbolOutputSymtabIndex(sym.outputShndx(elf_file).?);
	428	r_sym = sym.outputShndx(elf_file).?;
427	429	},
428	430	else => {
429	431	r_sym = sym.outputSymtabIndex(elf_file) orelse 0;
...	...	@@ -446,7 +448,9 @@ fn emitReloc(elf_file: Elf, rec: anytype, sym: const Symbol, rel: elf.Elf64_Re
446	448	}
447	449
448	450	pub fn writeEhFrameRelocs(elf_file: *Elf, writer: anytype) !void {
449		relocs_log.debug("{x}: .eh_frame", .{elf_file.shdrs.items[elf_file.eh_frame_section_index.?].sh_addr});
	451	relocs_log.debug("{x}: .eh_frame", .{
	452	elf_file.sections.items(.shdr)[elf_file.eh_frame_section_index.?].sh_addr,
	453	});
450	454
451	455	for (elf_file.objects.items) \|index\| {
452	456	const object = elf_file.file(index).?.object;
...	...	@@ -482,8 +486,9 @@ pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void {
482	486	try writer.writeByte(EH_PE.udata4);
483	487	try writer.writeByte(EH_PE.datarel \| EH_PE.sdata4);
484	488
485		const eh_frame_shdr = elf_file.shdrs.items[elf_file.eh_frame_section_index.?];
486		const eh_frame_hdr_shdr = elf_file.shdrs.items[elf_file.eh_frame_hdr_section_index.?];
	489	const shdrs = elf_file.sections.items(.shdr);
	490	const eh_frame_shdr = shdrs[elf_file.eh_frame_section_index.?];
	491	const eh_frame_hdr_shdr = shdrs[elf_file.eh_frame_hdr_section_index.?];
487	492	const num_fdes = @as(u32, @intCast(@divExact(eh_frame_hdr_shdr.sh_size - eh_frame_hdr_header_size, 8)));
488	493	try writer.writeInt(
489	494	u32,

src/link/Elf/merge_section.zig+2-4

...	...	@@ -29,7 +29,7 @@ pub const MergeSection = struct {
29	29	}
30	30
31	31	pub fn address(msec: MergeSection, elf_file: *Elf) i64 {
32		const shdr = elf_file.shdrs.items[msec.output_section_index];
	32	const shdr = elf_file.sections.items(.shdr)[msec.output_section_index];
33	33	return @intCast(shdr.sh_addr + msec.value);
34	34	}
35	35
...	...	@@ -108,13 +108,11 @@ pub const MergeSection = struct {
108	108	}
109	109
110	110	pub fn initOutputSection(msec: MergeSection, elf_file: Elf) !void {
111		const shndx = elf_file.sectionByName(msec.name(elf_file)) orelse try elf_file.addSection(.{
	111	msec.output_section_index = elf_file.sectionByName(msec.name(elf_file)) orelse try elf_file.addSection(.{
112	112	.name = msec.name_offset,
113	113	.type = msec.type,
114	114	.flags = msec.flags,
115	115	});
116		try elf_file.output_sections.put(elf_file.base.comp.gpa, shndx, .{});
117		msec.output_section_index = shndx;
118	116	}
119	117
120	118	pub fn addMergeSubsection(msec: *MergeSection, allocator: Allocator) !MergeSubsection.Index {

src/link/Elf/relocatable.zig+37-38

...	...	@@ -347,36 +347,36 @@ fn initComdatGroups(elf_file: *Elf) !void {
347	347	}
348	348
349	349	fn updateSectionSizes(elf_file: *Elf) !void {
350		for (elf_file.output_sections.keys(), elf_file.output_sections.values()) \|shndx, atom_list\| {
351		const shdr = &elf_file.shdrs.items[shndx];
352		for (atom_list.items) \|ref\| {
353		const atom_ptr = elf_file.atom(ref) orelse continue;
354		if (!atom_ptr.alive) continue;
355		const offset = atom_ptr.alignment.forward(shdr.sh_size);
356		const padding = offset - shdr.sh_size;
357		atom_ptr.value = @intCast(offset);
358		shdr.sh_size += padding + atom_ptr.size;
359		shdr.sh_addralign = @max(shdr.sh_addralign, atom_ptr.alignment.toByteUnits() orelse 1);
360		}
361		}
	350	const slice = elf_file.sections.slice();
	351	for (slice.items(.shdr), 0..) \|*shdr, shndx\| {
	352	const atom_list = slice.items(.atom_list)[shndx];
	353	if (shdr.sh_type != elf.SHT_RELA) {
	354	for (atom_list.items) \|ref\| {
	355	const atom_ptr = elf_file.atom(ref) orelse continue;
	356	if (!atom_ptr.alive) continue;
	357	const offset = atom_ptr.alignment.forward(shdr.sh_size);
	358	const padding = offset - shdr.sh_size;
	359	atom_ptr.value = @intCast(offset);
	360	shdr.sh_size += padding + atom_ptr.size;
	361	shdr.sh_addralign = @max(shdr.sh_addralign, atom_ptr.alignment.toByteUnits() orelse 1);
	362	}
	363	} else {
	364	for (atom_list.items) \|ref\| {
	365	const atom_ptr = elf_file.atom(ref) orelse continue;
	366	if (!atom_ptr.alive) continue;
	367	const relocs = atom_ptr.relocs(elf_file);
	368	shdr.sh_size += shdr.sh_entsize * relocs.len;
	369	}
362	370
363		for (elf_file.output_rela_sections.values()) \|sec\| {
364		const shdr = &elf_file.shdrs.items[sec.shndx];
365		for (sec.atom_list.items) \|ref\| {
366		const atom_ptr = elf_file.atom(ref) orelse continue;
367		if (!atom_ptr.alive) continue;
368		const relocs = atom_ptr.relocs(elf_file);
369		shdr.sh_size += shdr.sh_entsize * relocs.len;
	371	if (shdr.sh_size == 0) shdr.sh_offset = 0;
370	372	}
371
372		if (shdr.sh_size == 0) shdr.sh_offset = 0;
373	373	}
374	374
375	375	if (elf_file.eh_frame_section_index) \|index\| {
376		elf_file.shdrs.items[index].sh_size = try eh_frame.calcEhFrameSize(elf_file);
	376	slice.items(.shdr)[index].sh_size = try eh_frame.calcEhFrameSize(elf_file);
377	377	}
378	378	if (elf_file.eh_frame_rela_section_index) \|index\| {
379		const shdr = &elf_file.shdrs.items[index];
	379	const shdr = &slice.items(.shdr)[index];
380	380	shdr.sh_size = eh_frame.calcEhFrameRelocs(elf_file) * shdr.sh_entsize;
381	381	}
382	382
...	...	@@ -387,19 +387,18 @@ fn updateSectionSizes(elf_file: *Elf) !void {
387	387
388	388	fn updateComdatGroupsSizes(elf_file: *Elf) void {
389	389	for (elf_file.comdat_group_sections.items) \|cg\| {
390		const shdr = &elf_file.shdrs.items[cg.shndx];
	390	const shdr = &elf_file.sections.items(.shdr)[cg.shndx];
391	391	shdr.sh_size = cg.size(elf_file);
392	392	shdr.sh_link = elf_file.symtab_section_index.?;
393	393
394	394	const sym = cg.symbol(elf_file);
395		shdr.sh_info = sym.outputSymtabIndex(elf_file) orelse
396		elf_file.sectionSymbolOutputSymtabIndex(sym.outputShndx(elf_file).?);
	395	shdr.sh_info = sym.outputSymtabIndex(elf_file) orelse sym.outputShndx(elf_file).?;
397	396	}
398	397	}
399	398
400	399	/// Allocates alloc sections when merging relocatable objects files together.
401	400	fn allocateAllocSections(elf_file: *Elf) !void {
402		for (elf_file.shdrs.items) \|*shdr\| {
	401	for (elf_file.sections.items(.shdr)) \|*shdr\| {
403	402	if (shdr.sh_type == elf.SHT_NULL) continue;
404	403	if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
405	404	if (shdr.sh_type == elf.SHT_NOBITS) {
...	...	@@ -418,13 +417,13 @@ fn allocateAllocSections(elf_file: *Elf) !void {
418	417
419	418	fn writeAtoms(elf_file: *Elf) !void {
420	419	const gpa = elf_file.base.comp.gpa;
	420	const slice = elf_file.sections.slice();
421	421
422	422	// TODO iterate over `output_sections` directly
423		for (elf_file.shdrs.items, 0..) \|shdr, shndx\| {
	423	for (slice.items(.shdr), slice.items(.atom_list), 0..) \|shdr, atom_list, shndx\| {
424	424	if (shdr.sh_type == elf.SHT_NULL) continue;
425	425	if (shdr.sh_type == elf.SHT_NOBITS) continue;
426
427		const atom_list = elf_file.output_sections.get(@intCast(shndx)) orelse continue;
	426	if (shdr.sh_type == elf.SHT_RELA) continue;
428	427	if (atom_list.items.len == 0) continue;
429	428
430	429	log.debug("writing atoms in '{s}' section", .{elf_file.getShString(shdr.sh_name)});
...	...	@@ -490,18 +489,18 @@ fn writeAtoms(elf_file: *Elf) !void {
490	489
491	490	fn writeSyntheticSections(elf_file: *Elf) !void {
492	491	const gpa = elf_file.base.comp.gpa;
	492	const slice = elf_file.sections.slice();
493	493
494		for (elf_file.output_rela_sections.values()) \|sec\| {
495		if (sec.atom_list.items.len == 0) continue;
496
497		const shdr = elf_file.shdrs.items[sec.shndx];
	494	for (slice.items(.shdr), slice.items(.atom_list)) \|shdr, atom_list\| {
	495	if (shdr.sh_type != elf.SHT_RELA) continue;
	496	if (atom_list.items.len == 0) continue;
498	497
499	498	const num_relocs = math.cast(usize, @divExact(shdr.sh_size, shdr.sh_entsize)) orelse
500	499	return error.Overflow;
501	500	var relocs = try std.ArrayList(elf.Elf64_Rela).initCapacity(gpa, num_relocs);
502	501	defer relocs.deinit();
503	502
504		for (sec.atom_list.items) \|ref\| {
	503	for (atom_list.items) \|ref\| {
505	504	const atom_ptr = elf_file.atom(ref) orelse continue;
506	505	if (!atom_ptr.alive) continue;
507	506	try atom_ptr.writeRelocs(elf_file, &relocs);
...	...	@@ -527,7 +526,7 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
527	526	}
528	527
529	528	if (elf_file.eh_frame_section_index) \|shndx\| {
530		const shdr = elf_file.shdrs.items[shndx];
	529	const shdr = slice.items(.shdr)[shndx];
531	530	const sh_size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;
532	531	var buffer = try std.ArrayList(u8).initCapacity(gpa, sh_size);
533	532	defer buffer.deinit();
...	...	@@ -540,7 +539,7 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
540	539	try elf_file.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
541	540	}
542	541	if (elf_file.eh_frame_rela_section_index) \|shndx\| {
543		const shdr = elf_file.shdrs.items[shndx];
	542	const shdr = slice.items(.shdr)[shndx];
544	543	const sh_size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;
545	544	var buffer = try std.ArrayList(u8).initCapacity(gpa, sh_size);
546	545	defer buffer.deinit();
...	...	@@ -561,7 +560,7 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
561	560	fn writeComdatGroups(elf_file: *Elf) !void {
562	561	const gpa = elf_file.base.comp.gpa;
563	562	for (elf_file.comdat_group_sections.items) \|cgs\| {
564		const shdr = elf_file.shdrs.items[cgs.shndx];
	563	const shdr = elf_file.sections.items(.shdr)[cgs.shndx];
565	564	const sh_size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;
566	565	var buffer = try std.ArrayList(u8).initCapacity(gpa, sh_size);
567	566	defer buffer.deinit();

src/link/Elf/synthetic_sections.zig+30-22

...	...	@@ -95,6 +95,8 @@ pub const DynamicSection = struct {
95	95	}
96	96
97	97	pub fn write(dt: DynamicSection, elf_file: *Elf, writer: anytype) !void {
	98	const shdrs = elf_file.sections.items(.shdr);
	99
98	100	// NEEDED
99	101	for (dt.needed.items) \|off\| {
100	102	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_NEEDED, .d_val = off });
...	...	@@ -112,33 +114,33 @@ pub const DynamicSection = struct {
112	114
113	115	// INIT
114	116	if (elf_file.sectionByName(".init")) \|shndx\| {
115		const addr = elf_file.shdrs.items[shndx].sh_addr;
	117	const addr = shdrs[shndx].sh_addr;
116	118	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_INIT, .d_val = addr });
117	119	}
118	120
119	121	// FINI
120	122	if (elf_file.sectionByName(".fini")) \|shndx\| {
121		const addr = elf_file.shdrs.items[shndx].sh_addr;
	123	const addr = shdrs[shndx].sh_addr;
122	124	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_FINI, .d_val = addr });
123	125	}
124	126
125	127	// INIT_ARRAY
126	128	if (elf_file.sectionByName(".init_array")) \|shndx\| {
127		const shdr = elf_file.shdrs.items[shndx];
	129	const shdr = shdrs[shndx];
128	130	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_INIT_ARRAY, .d_val = shdr.sh_addr });
129	131	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_INIT_ARRAYSZ, .d_val = shdr.sh_size });
130	132	}
131	133
132	134	// FINI_ARRAY
133	135	if (elf_file.sectionByName(".fini_array")) \|shndx\| {
134		const shdr = elf_file.shdrs.items[shndx];
	136	const shdr = shdrs[shndx];
135	137	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_FINI_ARRAY, .d_val = shdr.sh_addr });
136	138	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_FINI_ARRAYSZ, .d_val = shdr.sh_size });
137	139	}
138	140
139	141	// RELA
140	142	if (elf_file.rela_dyn_section_index) \|shndx\| {
141		const shdr = elf_file.shdrs.items[shndx];
	143	const shdr = shdrs[shndx];
142	144	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_RELA, .d_val = shdr.sh_addr });
143	145	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_RELASZ, .d_val = shdr.sh_size });
144	146	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_RELAENT, .d_val = shdr.sh_entsize });
...	...	@@ -146,7 +148,7 @@ pub const DynamicSection = struct {
146	148
147	149	// JMPREL
148	150	if (elf_file.rela_plt_section_index) \|shndx\| {
149		const shdr = elf_file.shdrs.items[shndx];
	151	const shdr = shdrs[shndx];
150	152	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_JMPREL, .d_val = shdr.sh_addr });
151	153	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_PLTRELSZ, .d_val = shdr.sh_size });
152	154	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_PLTREL, .d_val = elf.DT_RELA });
...	...	@@ -154,18 +156,18 @@ pub const DynamicSection = struct {
154	156
155	157	// PLTGOT
156	158	if (elf_file.got_plt_section_index) \|shndx\| {
157		const addr = elf_file.shdrs.items[shndx].sh_addr;
	159	const addr = shdrs[shndx].sh_addr;
158	160	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_PLTGOT, .d_val = addr });
159	161	}
160	162
161	163	{
162	164	assert(elf_file.hash_section_index != null);
163		const addr = elf_file.shdrs.items[elf_file.hash_section_index.?].sh_addr;
	165	const addr = shdrs[elf_file.hash_section_index.?].sh_addr;
164	166	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_HASH, .d_val = addr });
165	167	}
166	168
167	169	if (elf_file.gnu_hash_section_index) \|shndx\| {
168		const addr = elf_file.shdrs.items[shndx].sh_addr;
	170	const addr = shdrs[shndx].sh_addr;
169	171	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_GNU_HASH, .d_val = addr });
170	172	}
171	173
...	...	@@ -177,7 +179,7 @@ pub const DynamicSection = struct {
177	179	// SYMTAB + SYMENT
178	180	{
179	181	assert(elf_file.dynsymtab_section_index != null);
180		const shdr = elf_file.shdrs.items[elf_file.dynsymtab_section_index.?];
	182	const shdr = shdrs[elf_file.dynsymtab_section_index.?];
181	183	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_SYMTAB, .d_val = shdr.sh_addr });
182	184	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_SYMENT, .d_val = shdr.sh_entsize });
183	185	}
...	...	@@ -185,20 +187,20 @@ pub const DynamicSection = struct {
185	187	// STRTAB + STRSZ
186	188	{
187	189	assert(elf_file.dynstrtab_section_index != null);
188		const shdr = elf_file.shdrs.items[elf_file.dynstrtab_section_index.?];
	190	const shdr = shdrs[elf_file.dynstrtab_section_index.?];
189	191	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_STRTAB, .d_val = shdr.sh_addr });
190	192	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_STRSZ, .d_val = shdr.sh_size });
191	193	}
192	194
193	195	// VERSYM
194	196	if (elf_file.versym_section_index) \|shndx\| {
195		const addr = elf_file.shdrs.items[shndx].sh_addr;
	197	const addr = shdrs[shndx].sh_addr;
196	198	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_VERSYM, .d_val = addr });
197	199	}
198	200
199	201	// VERNEED + VERNEEDNUM
200	202	if (elf_file.verneed_section_index) \|shndx\| {
201		const addr = elf_file.shdrs.items[shndx].sh_addr;
	203	const addr = shdrs[shndx].sh_addr;
202	204	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_VERNEED, .d_val = addr });
203	205	try writer.writeStruct(elf.Elf64_Dyn{
204	206	.d_tag = elf.DT_VERNEEDNUM,
...	...	@@ -259,7 +261,7 @@ pub const GotSection = struct {
259	261
260	262	pub fn address(entry: Entry, elf_file: *Elf) i64 {
261	263	const ptr_bytes = elf_file.archPtrWidthBytes();
262		const shdr = &elf_file.shdrs.items[elf_file.got_section_index.?];
	264	const shdr = &elf_file.sections.items(.shdr)[elf_file.got_section_index.?];
263	265	return @as(i64, @intCast(shdr.sh_addr)) + entry.cell_index * ptr_bytes;
264	266	}
265	267	};
...	...	@@ -759,8 +761,9 @@ pub const PltSection = struct {
759	761
760	762	const x86_64 = struct {
761	763	fn write(plt: PltSection, elf_file: *Elf, writer: anytype) !void {
762		const plt_addr = elf_file.shdrs.items[elf_file.plt_section_index.?].sh_addr;
763		const got_plt_addr = elf_file.shdrs.items[elf_file.got_plt_section_index.?].sh_addr;
	764	const shdrs = elf_file.sections.items(.shdr);
	765	const plt_addr = shdrs[elf_file.plt_section_index.?].sh_addr;
	766	const got_plt_addr = shdrs[elf_file.got_plt_section_index.?].sh_addr;
764	767	var preamble = [_]u8{
765	768	0xf3, 0x0f, 0x1e, 0xfa, // endbr64
766	769	0x41, 0x53, // push r11
...	...	@@ -794,8 +797,9 @@ pub const PltSection = struct {
794	797	const aarch64 = struct {
795	798	fn write(plt: PltSection, elf_file: *Elf, writer: anytype) !void {
796	799	{
797		const plt_addr: i64 = @intCast(elf_file.shdrs.items[elf_file.plt_section_index.?].sh_addr);
798		const got_plt_addr: i64 = @intCast(elf_file.shdrs.items[elf_file.got_plt_section_index.?].sh_addr);
	800	const shdrs = elf_file.sections.items(.shdr);
	801	const plt_addr: i64 = @intCast(shdrs[elf_file.plt_section_index.?].sh_addr);
	802	const got_plt_addr: i64 = @intCast(shdrs[elf_file.got_plt_section_index.?].sh_addr);
799	803	// TODO: relax if possible
800	804	// .got.plt[2]
801	805	const pages = try aarch64_util.calcNumberOfPages(plt_addr + 4, got_plt_addr + 16);
...	...	@@ -869,7 +873,7 @@ pub const GotPltSection = struct {
869	873	try writer.writeInt(u64, 0x0, .little);
870	874	try writer.writeInt(u64, 0x0, .little);
871	875	if (elf_file.plt_section_index) \|shndx\| {
872		const plt_addr = elf_file.shdrs.items[shndx].sh_addr;
	876	const plt_addr = elf_file.sections.items(.shdr)[shndx].sh_addr;
873	877	for (0..elf_file.plt.symbols.items.len) \|_\| {
874	878	// [N]: .plt
875	879	try writer.writeInt(u64, plt_addr, .little);
...	...	@@ -1027,7 +1031,7 @@ pub const CopyRelSection = struct {
1027	1031	}
1028	1032
1029	1033	pub fn updateSectionSize(copy_rel: CopyRelSection, shndx: u32, elf_file: *Elf) !void {
1030		const shdr = &elf_file.shdrs.items[shndx];
	1034	const shdr = &elf_file.sections.items(.shdr)[shndx];
1031	1035	for (copy_rel.symbols.items) \|ref\| {
1032	1036	const symbol = elf_file.symbol(ref).?;
1033	1037	const shared_object = symbol.file(elf_file).?.shared_object;
...	...	@@ -1487,8 +1491,12 @@ pub const ComdatGroupSection = struct {
1487	1491	elf.SHT_RELA => {
1488	1492	const atom_index = object.atoms_indexes.items[shdr.sh_info];
1489	1493	const atom = object.atom(atom_index).?;
1490		const rela = elf_file.output_rela_sections.get(atom.output_section_index).?;
1491		try writer.writeInt(u32, rela.shndx, .little);
	1494	const rela_shndx = for (elf_file.sections.items(.shdr), 0..) \|rela_shdr, rela_shndx\| {
	1495	if (rela_shdr.sh_type == elf.SHT_RELA and
	1496	atom.output_section_index == rela_shdr.sh_info)
	1497	break rela_shndx;
	1498	} else unreachable;
	1499	try writer.writeInt(u32, @intCast(rela_shndx), .little);
1492	1500	},
1493	1501	else => {
1494	1502	const atom_index = object.atoms_indexes.items[shndx];

src/link/Elf/thunks.zig+3-4

...	...	@@ -1,9 +1,8 @@
1		pub fn createThunks(shndx: u32, elf_file: *Elf) !void {
	1	pub fn createThunks(shdr: elf.Elf64_Shdr, shndx: u32, elf_file: Elf) !void {
2	2	const gpa = elf_file.base.comp.gpa;
3	3	const cpu_arch = elf_file.getTarget().cpu.arch;
4	4	const max_distance = maxAllowedDistance(cpu_arch);
5		const shdr = &elf_file.shdrs.items[shndx];
6		const atoms = elf_file.output_sections.get(shndx).?.items;
	5	const atoms = elf_file.sections.items(.atom_list)[shndx].items;
7	6	assert(atoms.len > 0);
8	7
9	8	for (atoms) \|ref\| {
...	...	@@ -89,7 +88,7 @@ pub const Thunk = struct {
89	88	}
90	89
91	90	pub fn address(thunk: Thunk, elf_file: *Elf) i64 {
92		const shdr = elf_file.shdrs.items[thunk.output_section_index];
	91	const shdr = elf_file.sections.items(.shdr)[thunk.output_section_index];
93	92	return @as(i64, @intCast(shdr.sh_addr)) + thunk.value;
94	93	}
95	94