Commit 5e53203e82bdeb0273160db156050164c5c69267 | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-10-11 10:34:17-07:00
committer	GitHub <noreply@github.com> 2024-10-11 10:34:17-07:00
log	5e53203e82bdeb0273160db156050164c5c69267
tree	9a4d6065238993c49299e16fbdbab420822cc35b
parent	41dbd0d0da0989495a97e99fb9269a49ac302768
parent	38458c6f70322c7eb0ac1434019f1bbdc3c89a57
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #21666 from ziglang/reduce-flush

link.Elf: fix phdr_gnu_stack_index not included in sortPhdrs

12 files changed, 818 insertions(+), 749 deletions(-)

CMakeLists.txt
lib
- std
  - multi_array_list.zig
src
- link
  - Elf.zig
  - Elf
    LinkerDefined.zig
    Merge.zig
    Object.zig
    Symbol.zig
    ZigObject.zig
    eh_frame.zig
    merge_section.zig
    relocatable.zig
    synthetic_sections.zig

CMakeLists.txt+2-2

...	...	@@ -603,18 +603,18 @@ set(ZIG_STAGE2_SOURCES
603	603	src/link/Elf/AtomList.zig
604	604	src/link/Elf/LdScript.zig
605	605	src/link/Elf/LinkerDefined.zig
	606	src/link/Elf/Merge.zig
606	607	src/link/Elf/Object.zig
607	608	src/link/Elf/SharedObject.zig
608	609	src/link/Elf/Symbol.zig
	610	src/link/Elf/Thunk.zig
609	611	src/link/Elf/ZigObject.zig
610	612	src/link/Elf/eh_frame.zig
611	613	src/link/Elf/file.zig
612	614	src/link/Elf/gc.zig
613		src/link/Elf/merge_section.zig
614	615	src/link/Elf/relocatable.zig
615	616	src/link/Elf/relocation.zig
616	617	src/link/Elf/synthetic_sections.zig
617		src/link/Elf/Thunk.zig
618	618	src/link/MachO.zig
619	619	src/link/MachO/Archive.zig
620	620	src/link/MachO/Atom.zig

lib/std/multi_array_list.zig+7-1

...	...	@@ -23,6 +23,12 @@ pub fn MultiArrayList(comptime T: type) type {
23	23	len: usize = 0,
24	24	capacity: usize = 0,
25	25
	26	pub const empty: Self = .{
	27	.bytes = undefined,
	28	.len = 0,
	29	.capacity = 0,
	30	};
	31
26	32	const Elem = switch (@typeInfo(T)) {
27	33	.@"struct" => T,
28	34	.@"union" => \|u\| struct {
...	...	@@ -474,7 +480,7 @@ pub fn MultiArrayList(comptime T: type) type {
474	480	pub fn swap(sc: @This(), a_index: usize, b_index: usize) void {
475	481	inline for (fields, 0..) \|field_info, i\| {
476	482	if (@sizeOf(field_info.type) != 0) {
477		const field = @as(Field, @enumFromInt(i));
	483	const field: Field = @enumFromInt(i);
478	484	const ptr = sc.slice.items(field);
479	485	mem.swap(field_info.type, &ptr[a_index], &ptr[b_index]);
480	486	}

src/link/Elf.zig+377-333

...	...	@@ -1,3 +1,5 @@
	1	pub const Atom = @import("Elf/Atom.zig");
	2
1	3	base: link.File,
2	4	rpath_table: std.StringArrayHashMapUnmanaged(void),
3	5	image_base: u64,
...	...	@@ -53,26 +55,11 @@ shdr_table_offset: ?u64 = null,
53	55
54	56	/// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
55	57	/// Same order as in the file.
56		phdrs: std.ArrayListUnmanaged(elf.Elf64_Phdr) = .empty,
57
58		/// Special program headers
59		/// PT_PHDR
60		phdr_table_index: ?u16 = null,
61		/// PT_LOAD for PHDR table
62		/// We add this special load segment to ensure the EHDR and PHDR table are always
63		/// loaded into memory.
64		phdr_table_load_index: ?u16 = null,
65		/// PT_INTERP
66		phdr_interp_index: ?u16 = null,
67		/// PT_DYNAMIC
68		phdr_dynamic_index: ?u16 = null,
69		/// PT_GNU_EH_FRAME
70		phdr_gnu_eh_frame_index: ?u16 = null,
71		/// PT_GNU_STACK
72		phdr_gnu_stack_index: ?u16 = null,
73		/// PT_TLS
74		/// TODO I think ELF permits multiple TLS segments but for now, assume one per file.
75		phdr_tls_index: ?u16 = null,
	58	phdrs: ProgramHeaderList = .empty,
	59
	60	/// Special program headers.
	61	phdr_indexes: ProgramHeaderIndexes = .{},
	62	section_indexes: SectionIndexes = .{},
76	63
77	64	page_size: u32,
78	65	default_sym_version: elf.Elf64_Versym,
...	...	@@ -115,29 +102,6 @@ rela_plt: std.ArrayListUnmanaged(elf.Elf64_Rela) = .empty,
115	102	/// Applies only to a relocatable.
116	103	comdat_group_sections: std.ArrayListUnmanaged(ComdatGroupSection) = .empty,
117	104
118		copy_rel_section_index: ?u32 = null,
119		dynamic_section_index: ?u32 = null,
120		dynstrtab_section_index: ?u32 = null,
121		dynsymtab_section_index: ?u32 = null,
122		eh_frame_section_index: ?u32 = null,
123		eh_frame_rela_section_index: ?u32 = null,
124		eh_frame_hdr_section_index: ?u32 = null,
125		hash_section_index: ?u32 = null,
126		gnu_hash_section_index: ?u32 = null,
127		got_section_index: ?u32 = null,
128		got_plt_section_index: ?u32 = null,
129		interp_section_index: ?u32 = null,
130		plt_section_index: ?u32 = null,
131		plt_got_section_index: ?u32 = null,
132		rela_dyn_section_index: ?u32 = null,
133		rela_plt_section_index: ?u32 = null,
134		versym_section_index: ?u32 = null,
135		verneed_section_index: ?u32 = null,
136
137		shstrtab_section_index: ?u32 = null,
138		strtab_section_index: ?u32 = null,
139		symtab_section_index: ?u32 = null,
140
141	105	resolver: SymbolResolver = .{},
142	106
143	107	has_text_reloc: bool = false,
...	...	@@ -147,11 +111,87 @@ num_ifunc_dynrelocs: usize = 0,
147	111	thunks: std.ArrayListUnmanaged(Thunk) = .empty,
148	112
149	113	/// List of output merge sections with deduped contents.
150		merge_sections: std.ArrayListUnmanaged(MergeSection) = .empty,
151		comment_merge_section_index: ?MergeSection.Index = null,
	114	merge_sections: std.ArrayListUnmanaged(Merge.Section) = .empty,
	115	comment_merge_section_index: ?Merge.Section.Index = null,
152	116
153	117	first_eflags: ?elf.Elf64_Word = null,
154	118
	119	const SectionIndexes = struct {
	120	copy_rel: ?u32 = null,
	121	dynamic: ?u32 = null,
	122	dynstrtab: ?u32 = null,
	123	dynsymtab: ?u32 = null,
	124	eh_frame: ?u32 = null,
	125	eh_frame_rela: ?u32 = null,
	126	eh_frame_hdr: ?u32 = null,
	127	hash: ?u32 = null,
	128	gnu_hash: ?u32 = null,
	129	got: ?u32 = null,
	130	got_plt: ?u32 = null,
	131	interp: ?u32 = null,
	132	plt: ?u32 = null,
	133	plt_got: ?u32 = null,
	134	rela_dyn: ?u32 = null,
	135	rela_plt: ?u32 = null,
	136	versym: ?u32 = null,
	137	verneed: ?u32 = null,
	138
	139	shstrtab: ?u32 = null,
	140	strtab: ?u32 = null,
	141	symtab: ?u32 = null,
	142	};
	143
	144	const ProgramHeaderList = std.ArrayListUnmanaged(elf.Elf64_Phdr);
	145
	146	const OptionalProgramHeaderIndex = enum(u16) {
	147	none = std.math.maxInt(u16),
	148	_,
	149
	150	fn unwrap(i: OptionalProgramHeaderIndex) ?ProgramHeaderIndex {
	151	if (i == .none) return null;
	152	return @enumFromInt(@intFromEnum(i));
	153	}
	154
	155	fn int(i: OptionalProgramHeaderIndex) ?u16 {
	156	if (i == .none) return null;
	157	return @intFromEnum(i);
	158	}
	159	};
	160
	161	const ProgramHeaderIndex = enum(u16) {
	162	_,
	163
	164	fn toOptional(i: ProgramHeaderIndex) OptionalProgramHeaderIndex {
	165	const result: OptionalProgramHeaderIndex = @enumFromInt(@intFromEnum(i));
	166	assert(result != .none);
	167	return result;
	168	}
	169
	170	fn int(i: ProgramHeaderIndex) u16 {
	171	return @intFromEnum(i);
	172	}
	173	};
	174
	175	const ProgramHeaderIndexes = struct {
	176	/// PT_PHDR
	177	table: OptionalProgramHeaderIndex = .none,
	178	/// PT_LOAD for PHDR table
	179	/// We add this special load segment to ensure the EHDR and PHDR table are always
	180	/// loaded into memory.
	181	table_load: OptionalProgramHeaderIndex = .none,
	182	/// PT_INTERP
	183	interp: OptionalProgramHeaderIndex = .none,
	184	/// PT_DYNAMIC
	185	dynamic: OptionalProgramHeaderIndex = .none,
	186	/// PT_GNU_EH_FRAME
	187	gnu_eh_frame: OptionalProgramHeaderIndex = .none,
	188	/// PT_GNU_STACK
	189	gnu_stack: OptionalProgramHeaderIndex = .none,
	190	/// PT_TLS
	191	/// TODO I think ELF permits multiple TLS segments but for now, assume one per file.
	192	tls: OptionalProgramHeaderIndex = .none,
	193	};
	194
155	195	/// When allocating, the ideal_capacity is calculated by
156	196	/// actual_capacity + (actual_capacity / ideal_factor)
157	197	const ideal_factor = 3;
...	...	@@ -358,7 +398,7 @@ pub fn createEmpty(
358	398	};
359	399	const max_nphdrs = comptime getMaxNumberOfPhdrs();
360	400	const reserved: u64 = mem.alignForward(u64, padToIdeal(max_nphdrs * phsize), self.page_size);
361		self.phdr_table_index = try self.addPhdr(.{
	401	self.phdr_indexes.table = (try self.addPhdr(.{
362	402	.type = elf.PT_PHDR,
363	403	.flags = elf.PF_R,
364	404	.@"align" = p_align,
...	...	@@ -366,8 +406,8 @@ pub fn createEmpty(
366	406	.offset = ehsize,
367	407	.filesz = reserved,
368	408	.memsz = reserved,
369		});
370		self.phdr_table_load_index = try self.addPhdr(.{
	409	})).toOptional();
	410	self.phdr_indexes.table_load = (try self.addPhdr(.{
371	411	.type = elf.PT_LOAD,
372	412	.flags = elf.PF_R,
373	413	.@"align" = self.page_size,
...	...	@@ -375,7 +415,7 @@ pub fn createEmpty(
375	415	.offset = 0,
376	416	.filesz = reserved + ehsize,
377	417	.memsz = reserved + ehsize,
378		});
	418	})).toOptional();
379	419	}
380	420
381	421	if (opt_zcu) \|zcu\| {
...	...	@@ -952,7 +992,16 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
952	992	// Generate and emit synthetic sections.
953	993	try self.initSyntheticSections();
954	994	try self.initSpecialPhdrs();
955		try self.sortShdrs();
	995	try sortShdrs(
	996	gpa,
	997	&self.section_indexes,
	998	&self.sections,
	999	self.shstrtab.items,
	1000	self.merge_sections.items,
	1001	self.comdat_group_sections.items,
	1002	self.zigObjectPtr(),
	1003	self.files,
	1004	);
956	1005
957	1006	try self.setDynamicSection(self.rpath_table.keys());
958	1007	self.sortDynamicSymtab();
...	...	@@ -966,7 +1015,7 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
966	1015	try self.addLoadPhdrs();
967	1016	try self.allocatePhdrTable();
968	1017	try self.allocateAllocSections();
969		try self.sortPhdrs();
	1018	try sortPhdrs(gpa, &self.phdrs, &self.phdr_indexes, self.sections.items(.phndx));
970	1019	try self.allocateNonAllocSections();
971	1020	self.allocateSpecialPhdrs();
972	1021	if (self.linkerDefinedPtr()) \|obj\| {
...	...	@@ -2461,7 +2510,7 @@ fn writePhdrTable(self: *Elf) !void {
2461	2510	const gpa = self.base.comp.gpa;
2462	2511	const target_endian = self.getTarget().cpu.arch.endian();
2463	2512	const foreign_endian = target_endian != builtin.cpu.arch.endian();
2464		const phdr_table = &self.phdrs.items[self.phdr_table_index.?];
	2513	const phdr_table = &self.phdrs.items[self.phdr_indexes.table.int().?];
2465	2514
2466	2515	log.debug("writing program headers from 0x{x} to 0x{x}", .{
2467	2516	phdr_table.p_offset,
...	...	@@ -2573,18 +2622,18 @@ pub fn writeElfHeader(self: *Elf) !void {
2573	2622	const entry_sym = obj.entrySymbol(self) orelse break :blk 0;
2574	2623	break :blk @intCast(entry_sym.address(.{}, self));
2575	2624	} else 0;
2576		const phdr_table_offset = if (self.phdr_table_index) \|phndx\| self.phdrs.items[phndx].p_offset else 0;
	2625	const phdr_table_offset = if (self.phdr_indexes.table.int()) \|phndx\| self.phdrs.items[phndx].p_offset else 0;
2577	2626	switch (self.ptr_width) {
2578	2627	.p32 => {
2579		mem.writeInt(u32, hdr_buf[index..][0..4], @as(u32, @intCast(e_entry)), endian);
	2628	mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(e_entry), endian);
2580	2629	index += 4;
2581	2630
2582	2631	// e_phoff
2583		mem.writeInt(u32, hdr_buf[index..][0..4], @as(u32, @intCast(phdr_table_offset)), endian);
	2632	mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(phdr_table_offset), endian);
2584	2633	index += 4;
2585	2634
2586	2635	// e_shoff
2587		mem.writeInt(u32, hdr_buf[index..][0..4], @as(u32, @intCast(self.shdr_table_offset.?)), endian);
	2636	mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(self.shdr_table_offset.?), endian);
2588	2637	index += 4;
2589	2638	},
2590	2639	.p64 => {
...	...	@@ -2631,11 +2680,11 @@ pub fn writeElfHeader(self: *Elf) !void {
2631	2680	mem.writeInt(u16, hdr_buf[index..][0..2], e_shentsize, endian);
2632	2681	index += 2;
2633	2682
2634		const e_shnum = @as(u16, @intCast(self.sections.items(.shdr).len));
	2683	const e_shnum: u16 = @intCast(self.sections.items(.shdr).len);
2635	2684	mem.writeInt(u16, hdr_buf[index..][0..2], e_shnum, endian);
2636	2685	index += 2;
2637	2686
2638		mem.writeInt(u16, hdr_buf[index..][0..2], @intCast(self.shstrtab_section_index.?), endian);
	2687	mem.writeInt(u16, hdr_buf[index..][0..2], @intCast(self.section_indexes.shstrtab.?), endian);
2639	2688	index += 2;
2640	2689
2641	2690	assert(index == e_ehsize);
...	...	@@ -2853,8 +2902,8 @@ fn initSyntheticSections(self: *Elf) !void {
2853	2902	} else false;
2854	2903	};
2855	2904	if (needs_eh_frame) {
2856		if (self.eh_frame_section_index == null) {
2857		self.eh_frame_section_index = self.sectionByName(".eh_frame") orelse try self.addSection(.{
	2905	if (self.section_indexes.eh_frame == null) {
	2906	self.section_indexes.eh_frame = self.sectionByName(".eh_frame") orelse try self.addSection(.{
2858	2907	.name = try self.insertShString(".eh_frame"),
2859	2908	.type = if (target.cpu.arch == .x86_64)
2860	2909	elf.SHT_X86_64_UNWIND
...	...	@@ -2864,8 +2913,8 @@ fn initSyntheticSections(self: *Elf) !void {
2864	2913	.addralign = ptr_size,
2865	2914	});
2866	2915	}
2867		if (comp.link_eh_frame_hdr and self.eh_frame_hdr_section_index == null) {
2868		self.eh_frame_hdr_section_index = try self.addSection(.{
	2916	if (comp.link_eh_frame_hdr and self.section_indexes.eh_frame_hdr == null) {
	2917	self.section_indexes.eh_frame_hdr = try self.addSection(.{
2869	2918	.name = try self.insertShString(".eh_frame_hdr"),
2870	2919	.type = elf.SHT_PROGBITS,
2871	2920	.flags = elf.SHF_ALLOC,
...	...	@@ -2874,8 +2923,8 @@ fn initSyntheticSections(self: *Elf) !void {
2874	2923	}
2875	2924	}
2876	2925
2877		if (self.got.entries.items.len > 0 and self.got_section_index == null) {
2878		self.got_section_index = try self.addSection(.{
	2926	if (self.got.entries.items.len > 0 and self.section_indexes.got == null) {
	2927	self.section_indexes.got = try self.addSection(.{
2879	2928	.name = try self.insertShString(".got"),
2880	2929	.type = elf.SHT_PROGBITS,
2881	2930	.flags = elf.SHF_ALLOC \| elf.SHF_WRITE,
...	...	@@ -2883,8 +2932,8 @@ fn initSyntheticSections(self: *Elf) !void {
2883	2932	});
2884	2933	}
2885	2934
2886		if (self.got_plt_section_index == null) {
2887		self.got_plt_section_index = try self.addSection(.{
	2935	if (self.section_indexes.got_plt == null) {
	2936	self.section_indexes.got_plt = try self.addSection(.{
2888	2937	.name = try self.insertShString(".got.plt"),
2889	2938	.type = elf.SHT_PROGBITS,
2890	2939	.flags = elf.SHF_ALLOC \| elf.SHF_WRITE,
...	...	@@ -2903,8 +2952,8 @@ fn initSyntheticSections(self: *Elf) !void {
2903	2952	}
2904	2953	break :blk false;
2905	2954	};
2906		if (needs_rela_dyn and self.rela_dyn_section_index == null) {
2907		self.rela_dyn_section_index = try self.addSection(.{
	2955	if (needs_rela_dyn and self.section_indexes.rela_dyn == null) {
	2956	self.section_indexes.rela_dyn = try self.addSection(.{
2908	2957	.name = try self.insertShString(".rela.dyn"),
2909	2958	.type = elf.SHT_RELA,
2910	2959	.flags = elf.SHF_ALLOC,
...	...	@@ -2914,16 +2963,16 @@ fn initSyntheticSections(self: *Elf) !void {
2914	2963	}
2915	2964
2916	2965	if (self.plt.symbols.items.len > 0) {
2917		if (self.plt_section_index == null) {
2918		self.plt_section_index = try self.addSection(.{
	2966	if (self.section_indexes.plt == null) {
	2967	self.section_indexes.plt = try self.addSection(.{
2919	2968	.name = try self.insertShString(".plt"),
2920	2969	.type = elf.SHT_PROGBITS,
2921	2970	.flags = elf.SHF_ALLOC \| elf.SHF_EXECINSTR,
2922	2971	.addralign = 16,
2923	2972	});
2924	2973	}
2925		if (self.rela_plt_section_index == null) {
2926		self.rela_plt_section_index = try self.addSection(.{
	2974	if (self.section_indexes.rela_plt == null) {
	2975	self.section_indexes.rela_plt = try self.addSection(.{
2927	2976	.name = try self.insertShString(".rela.plt"),
2928	2977	.type = elf.SHT_RELA,
2929	2978	.flags = elf.SHF_ALLOC,
...	...	@@ -2933,8 +2982,8 @@ fn initSyntheticSections(self: *Elf) !void {
2933	2982	}
2934	2983	}
2935	2984
2936		if (self.plt_got.symbols.items.len > 0 and self.plt_got_section_index == null) {
2937		self.plt_got_section_index = try self.addSection(.{
	2985	if (self.plt_got.symbols.items.len > 0 and self.section_indexes.plt_got == null) {
	2986	self.section_indexes.plt_got = try self.addSection(.{
2938	2987	.name = try self.insertShString(".plt.got"),
2939	2988	.type = elf.SHT_PROGBITS,
2940	2989	.flags = elf.SHF_ALLOC \| elf.SHF_EXECINSTR,
...	...	@@ -2942,8 +2991,8 @@ fn initSyntheticSections(self: *Elf) !void {
2942	2991	});
2943	2992	}
2944	2993
2945		if (self.copy_rel.symbols.items.len > 0 and self.copy_rel_section_index == null) {
2946		self.copy_rel_section_index = try self.addSection(.{
	2994	if (self.copy_rel.symbols.items.len > 0 and self.section_indexes.copy_rel == null) {
	2995	self.section_indexes.copy_rel = try self.addSection(.{
2947	2996	.name = try self.insertShString(".copyrel"),
2948	2997	.type = elf.SHT_NOBITS,
2949	2998	.flags = elf.SHF_ALLOC \| elf.SHF_WRITE,
...	...	@@ -2959,8 +3008,8 @@ fn initSyntheticSections(self: *Elf) !void {
2959	3008	if (self.base.isStatic() and !comp.config.pie) break :blk false;
2960	3009	break :blk target.dynamic_linker.get() != null;
2961	3010	};
2962		if (needs_interp and self.interp_section_index == null) {
2963		self.interp_section_index = try self.addSection(.{
	3011	if (needs_interp and self.section_indexes.interp == null) {
	3012	self.section_indexes.interp = try self.addSection(.{
2964	3013	.name = try self.insertShString(".interp"),
2965	3014	.type = elf.SHT_PROGBITS,
2966	3015	.flags = elf.SHF_ALLOC,
...	...	@@ -2969,8 +3018,8 @@ fn initSyntheticSections(self: *Elf) !void {
2969	3018	}
2970	3019
2971	3020	if (self.isEffectivelyDynLib() or self.shared_objects.items.len > 0 or comp.config.pie) {
2972		if (self.dynstrtab_section_index == null) {
2973		self.dynstrtab_section_index = try self.addSection(.{
	3021	if (self.section_indexes.dynstrtab == null) {
	3022	self.section_indexes.dynstrtab = try self.addSection(.{
2974	3023	.name = try self.insertShString(".dynstr"),
2975	3024	.flags = elf.SHF_ALLOC,
2976	3025	.type = elf.SHT_STRTAB,
...	...	@@ -2978,8 +3027,8 @@ fn initSyntheticSections(self: *Elf) !void {
2978	3027	.addralign = 1,
2979	3028	});
2980	3029	}
2981		if (self.dynamic_section_index == null) {
2982		self.dynamic_section_index = try self.addSection(.{
	3030	if (self.section_indexes.dynamic == null) {
	3031	self.section_indexes.dynamic = try self.addSection(.{
2983	3032	.name = try self.insertShString(".dynamic"),
2984	3033	.flags = elf.SHF_ALLOC \| elf.SHF_WRITE,
2985	3034	.type = elf.SHT_DYNAMIC,
...	...	@@ -2987,8 +3036,8 @@ fn initSyntheticSections(self: *Elf) !void {
2987	3036	.addralign = @alignOf(elf.Elf64_Dyn),
2988	3037	});
2989	3038	}
2990		if (self.dynsymtab_section_index == null) {
2991		self.dynsymtab_section_index = try self.addSection(.{
	3039	if (self.section_indexes.dynsymtab == null) {
	3040	self.section_indexes.dynsymtab = try self.addSection(.{
2992	3041	.name = try self.insertShString(".dynsym"),
2993	3042	.flags = elf.SHF_ALLOC,
2994	3043	.type = elf.SHT_DYNSYM,
...	...	@@ -2997,8 +3046,8 @@ fn initSyntheticSections(self: *Elf) !void {
2997	3046	.info = 1,
2998	3047	});
2999	3048	}
3000		if (self.hash_section_index == null) {
3001		self.hash_section_index = try self.addSection(.{
	3049	if (self.section_indexes.hash == null) {
	3050	self.section_indexes.hash = try self.addSection(.{
3002	3051	.name = try self.insertShString(".hash"),
3003	3052	.flags = elf.SHF_ALLOC,
3004	3053	.type = elf.SHT_HASH,
...	...	@@ -3006,8 +3055,8 @@ fn initSyntheticSections(self: *Elf) !void {
3006	3055	.entsize = 4,
3007	3056	});
3008	3057	}
3009		if (self.gnu_hash_section_index == null) {
3010		self.gnu_hash_section_index = try self.addSection(.{
	3058	if (self.section_indexes.gnu_hash == null) {
	3059	self.section_indexes.gnu_hash = try self.addSection(.{
3011	3060	.name = try self.insertShString(".gnu.hash"),
3012	3061	.flags = elf.SHF_ALLOC,
3013	3062	.type = elf.SHT_GNU_HASH,
...	...	@@ -3020,8 +3069,8 @@ fn initSyntheticSections(self: *Elf) !void {
3020	3069	if (sym.flags.import and sym.version_index & elf.VERSYM_VERSION > elf.VER_NDX_GLOBAL) break true;
3021	3070	} else false;
3022	3071	if (needs_versions) {
3023		if (self.versym_section_index == null) {
3024		self.versym_section_index = try self.addSection(.{
	3072	if (self.section_indexes.versym == null) {
	3073	self.section_indexes.versym = try self.addSection(.{
3025	3074	.name = try self.insertShString(".gnu.version"),
3026	3075	.flags = elf.SHF_ALLOC,
3027	3076	.type = elf.SHT_GNU_VERSYM,
...	...	@@ -3029,8 +3078,8 @@ fn initSyntheticSections(self: *Elf) !void {
3029	3078	.entsize = @sizeOf(elf.Elf64_Versym),
3030	3079	});
3031	3080	}
3032		if (self.verneed_section_index == null) {
3033		self.verneed_section_index = try self.addSection(.{
	3081	if (self.section_indexes.verneed == null) {
	3082	self.section_indexes.verneed = try self.addSection(.{
3034	3083	.name = try self.insertShString(".gnu.version_r"),
3035	3084	.flags = elf.SHF_ALLOC,
3036	3085	.type = elf.SHT_GNU_VERNEED,
...	...	@@ -3049,16 +3098,16 @@ pub fn initSymtab(self: *Elf) !void {
3049	3098	.p32 => true,
3050	3099	.p64 => false,
3051	3100	};
3052		if (self.symtab_section_index == null) {
3053		self.symtab_section_index = try self.addSection(.{
	3101	if (self.section_indexes.symtab == null) {
	3102	self.section_indexes.symtab = try self.addSection(.{
3054	3103	.name = try self.insertShString(".symtab"),
3055	3104	.type = elf.SHT_SYMTAB,
3056	3105	.addralign = if (small_ptr) @alignOf(elf.Elf32_Sym) else @alignOf(elf.Elf64_Sym),
3057	3106	.entsize = if (small_ptr) @sizeOf(elf.Elf32_Sym) else @sizeOf(elf.Elf64_Sym),
3058	3107	});
3059	3108	}
3060		if (self.strtab_section_index == null) {
3061		self.strtab_section_index = try self.addSection(.{
	3109	if (self.section_indexes.strtab == null) {
	3110	self.section_indexes.strtab = try self.addSection(.{
3062	3111	.name = try self.insertShString(".strtab"),
3063	3112	.type = elf.SHT_STRTAB,
3064	3113	.entsize = 1,
...	...	@@ -3068,8 +3117,8 @@ pub fn initSymtab(self: *Elf) !void {
3068	3117	}
3069	3118
3070	3119	pub fn initShStrtab(self: *Elf) !void {
3071		if (self.shstrtab_section_index == null) {
3072		self.shstrtab_section_index = try self.addSection(.{
	3120	if (self.section_indexes.shstrtab == null) {
	3121	self.section_indexes.shstrtab = try self.addSection(.{
3073	3122	.name = try self.insertShString(".shstrtab"),
3074	3123	.type = elf.SHT_STRTAB,
3075	3124	.entsize = 1,
...	...	@@ -3081,43 +3130,43 @@ pub fn initShStrtab(self: *Elf) !void {
3081	3130	fn initSpecialPhdrs(self: *Elf) !void {
3082	3131	comptime assert(max_number_of_special_phdrs == 5);
3083	3132
3084		if (self.interp_section_index != null and self.phdr_interp_index == null) {
3085		self.phdr_interp_index = try self.addPhdr(.{
	3133	if (self.section_indexes.interp != null and self.phdr_indexes.interp == .none) {
	3134	self.phdr_indexes.interp = (try self.addPhdr(.{
3086	3135	.type = elf.PT_INTERP,
3087	3136	.flags = elf.PF_R,
3088	3137	.@"align" = 1,
3089		});
	3138	})).toOptional();
3090	3139	}
3091		if (self.dynamic_section_index != null and self.phdr_dynamic_index == null) {
3092		self.phdr_dynamic_index = try self.addPhdr(.{
	3140	if (self.section_indexes.dynamic != null and self.phdr_indexes.dynamic == .none) {
	3141	self.phdr_indexes.dynamic = (try self.addPhdr(.{
3093	3142	.type = elf.PT_DYNAMIC,
3094	3143	.flags = elf.PF_R \| elf.PF_W,
3095		});
	3144	})).toOptional();
3096	3145	}
3097		if (self.eh_frame_hdr_section_index != null and self.phdr_gnu_eh_frame_index == null) {
3098		self.phdr_gnu_eh_frame_index = try self.addPhdr(.{
	3146	if (self.section_indexes.eh_frame_hdr != null and self.phdr_indexes.gnu_eh_frame == .none) {
	3147	self.phdr_indexes.gnu_eh_frame = (try self.addPhdr(.{
3099	3148	.type = elf.PT_GNU_EH_FRAME,
3100	3149	.flags = elf.PF_R,
3101		});
	3150	})).toOptional();
3102	3151	}
3103		if (self.phdr_gnu_stack_index == null) {
3104		self.phdr_gnu_stack_index = try self.addPhdr(.{
	3152	if (self.phdr_indexes.gnu_stack == .none) {
	3153	self.phdr_indexes.gnu_stack = (try self.addPhdr(.{
3105	3154	.type = elf.PT_GNU_STACK,
3106	3155	.flags = elf.PF_W \| elf.PF_R,
3107	3156	.memsz = self.base.stack_size,
3108	3157	.@"align" = 1,
3109		});
	3158	})).toOptional();
3110	3159	}
3111	3160
3112	3161	const has_tls = for (self.sections.items(.shdr)) \|shdr\| {
3113	3162	if (shdr.sh_flags & elf.SHF_TLS != 0) break true;
3114	3163	} else false;
3115		if (has_tls and self.phdr_tls_index == null) {
3116		self.phdr_tls_index = try self.addPhdr(.{
	3164	if (has_tls and self.phdr_indexes.tls == .none) {
	3165	self.phdr_indexes.tls = (try self.addPhdr(.{
3117	3166	.type = elf.PT_TLS,
3118	3167	.flags = elf.PF_R,
3119	3168	.@"align" = 1,
3120		});
	3169	})).toOptional();
3121	3170	}
3122	3171	}
3123	3172
...	...	@@ -3202,7 +3251,7 @@ fn sortInitFini(self: *Elf) !void {
3202	3251	}
3203	3252
3204	3253	fn setDynamicSection(self: *Elf, rpaths: []const []const u8) !void {
3205		if (self.dynamic_section_index == null) return;
	3254	if (self.section_indexes.dynamic == null) return;
3206	3255
3207	3256	for (self.shared_objects.items) \|index\| {
3208	3257	const shared_object = self.file(index).?.shared_object;
...	...	@@ -3220,13 +3269,13 @@ fn setDynamicSection(self: *Elf, rpaths: []const []const u8) !void {
3220	3269	}
3221	3270
3222	3271	fn sortDynamicSymtab(self: *Elf) void {
3223		if (self.gnu_hash_section_index == null) return;
	3272	if (self.section_indexes.gnu_hash == null) return;
3224	3273	self.dynsym.sort(self);
3225	3274	}
3226	3275
3227	3276	fn setVersionSymtab(self: *Elf) !void {
3228	3277	const gpa = self.base.comp.gpa;
3229		if (self.versym_section_index == null) return;
	3278	if (self.section_indexes.versym == null) return;
3230	3279	try self.versym.resize(gpa, self.dynsym.count());
3231	3280	self.versym.items[0] = elf.VER_NDX_LOCAL;
3232	3281	for (self.dynsym.entries.items, 1..) \|entry, i\| {
...	...	@@ -3234,7 +3283,7 @@ fn setVersionSymtab(self: *Elf) !void {
3234	3283	self.versym.items[i] = sym.version_index;
3235	3284	}
3236	3285
3237		if (self.verneed_section_index) \|shndx\| {
	3286	if (self.section_indexes.verneed) \|shndx\| {
3238	3287	try self.verneed.generate(self);
3239	3288	const shdr = &self.sections.items(.shdr)[shndx];
3240	3289	shdr.sh_info = @as(u32, @intCast(self.verneed.verneed.items.len));
...	...	@@ -3242,34 +3291,39 @@ fn setVersionSymtab(self: *Elf) !void {
3242	3291	}
3243	3292
3244	3293	fn setHashSections(self: *Elf) !void {
3245		if (self.hash_section_index != null) {
	3294	if (self.section_indexes.hash != null) {
3246	3295	try self.hash.generate(self);
3247	3296	}
3248		if (self.gnu_hash_section_index != null) {
	3297	if (self.section_indexes.gnu_hash != null) {
3249	3298	try self.gnu_hash.calcSize(self);
3250	3299	}
3251	3300	}
3252	3301
3253	3302	fn phdrRank(phdr: elf.Elf64_Phdr) u8 {
3254		switch (phdr.p_type) {
3255		elf.PT_NULL => return 0,
3256		elf.PT_PHDR => return 1,
3257		elf.PT_INTERP => return 2,
3258		elf.PT_LOAD => return 3,
3259		elf.PT_DYNAMIC, elf.PT_TLS => return 4,
3260		elf.PT_GNU_EH_FRAME => return 5,
3261		elf.PT_GNU_STACK => return 6,
3262		else => return 7,
3263		}
	3303	return switch (phdr.p_type) {
	3304	elf.PT_NULL => 0,
	3305	elf.PT_PHDR => 1,
	3306	elf.PT_INTERP => 2,
	3307	elf.PT_LOAD => 3,
	3308	elf.PT_DYNAMIC, elf.PT_TLS => 4,
	3309	elf.PT_GNU_EH_FRAME => 5,
	3310	elf.PT_GNU_STACK => 6,
	3311	else => 7,
	3312	};
3264	3313	}
3265	3314
3266		fn sortPhdrs(self: *Elf) error{OutOfMemory}!void {
	3315	fn sortPhdrs(
	3316	gpa: Allocator,
	3317	phdrs: *ProgramHeaderList,
	3318	special_indexes: *ProgramHeaderIndexes,
	3319	section_indexes: []OptionalProgramHeaderIndex,
	3320	) error{OutOfMemory}!void {
3267	3321	const Entry = struct {
3268	3322	phndx: u16,
3269	3323
3270		pub fn lessThan(elf_file: *Elf, lhs: @This(), rhs: @This()) bool {
3271		const lhs_phdr = elf_file.phdrs.items[lhs.phndx];
3272		const rhs_phdr = elf_file.phdrs.items[rhs.phndx];
	3324	pub fn lessThan(program_headers: []const elf.Elf64_Phdr, lhs: @This(), rhs: @This()) bool {
	3325	const lhs_phdr = program_headers[lhs.phndx];
	3326	const rhs_phdr = program_headers[rhs.phndx];
3273	3327	const lhs_rank = phdrRank(lhs_phdr);
3274	3328	const rhs_rank = phdrRank(rhs_phdr);
3275	3329	if (lhs_rank == rhs_rank) return lhs_phdr.p_vaddr < rhs_phdr.p_vaddr;
...	...	@@ -3277,52 +3331,41 @@ fn sortPhdrs(self: *Elf) error{OutOfMemory}!void {
3277	3331	}
3278	3332	};
3279	3333
3280		const gpa = self.base.comp.gpa;
3281		var entries = try std.ArrayList(Entry).initCapacity(gpa, self.phdrs.items.len);
3282		defer entries.deinit();
3283		for (0..self.phdrs.items.len) \|phndx\| {
3284		entries.appendAssumeCapacity(.{ .phndx = @as(u16, @intCast(phndx)) });
	3334	const entries = try gpa.alloc(Entry, phdrs.items.len);
	3335	defer gpa.free(entries);
	3336	for (entries, 0..) \|*entry, phndx\| {
	3337	entry.* = .{ .phndx = @intCast(phndx) };
3285	3338	}
3286	3339
3287		mem.sort(Entry, entries.items, self, Entry.lessThan);
	3340	// The `@as` here works around a bug in the C backend.
	3341	mem.sort(Entry, entries, @as([]const elf.Elf64_Phdr, phdrs.items), Entry.lessThan);
3288	3342
3289		const backlinks = try gpa.alloc(u16, entries.items.len);
	3343	const backlinks = try gpa.alloc(u16, entries.len);
3290	3344	defer gpa.free(backlinks);
3291		for (entries.items, 0..) \|entry, i\| {
3292		backlinks[entry.phndx] = @as(u16, @intCast(i));
3293		}
3294
3295		const slice = try self.phdrs.toOwnedSlice(gpa);
	3345	const slice = try phdrs.toOwnedSlice(gpa);
3296	3346	defer gpa.free(slice);
	3347	try phdrs.resize(gpa, slice.len);
3297	3348
3298		try self.phdrs.ensureTotalCapacityPrecise(gpa, slice.len);
3299		for (entries.items) \|sorted\| {
3300		self.phdrs.appendAssumeCapacity(slice[sorted.phndx]);
	3349	for (entries, phdrs.items, 0..) \|entry, *phdr, i\| {
	3350	backlinks[entry.phndx] = @intCast(i);
	3351	phdr.* = slice[entry.phndx];
3301	3352	}
3302	3353
3303		for (&[_]*?u16{
3304		&self.phdr_table_index,
3305		&self.phdr_table_load_index,
3306		&self.phdr_interp_index,
3307		&self.phdr_dynamic_index,
3308		&self.phdr_gnu_eh_frame_index,
3309		&self.phdr_tls_index,
3310		}) \|maybe_index\| {
3311		if (maybe_index.) \|index\| {
3312		index.* = backlinks[index.*];
	3354	inline for (@typeInfo(ProgramHeaderIndexes).@"struct".fields) \|field\| {
	3355	if (@field(special_indexes, field.name).int()) \|special_index\| {
	3356	@field(special_indexes, field.name) = @enumFromInt(backlinks[special_index]);
3313	3357	}
3314	3358	}
3315	3359
3316		for (self.sections.items(.phndx)) \|*maybe_phndx\| {
3317		if (maybe_phndx.) \|index\| {
3318		index.* = backlinks[index.*];
	3360	for (section_indexes) \|*opt_phndx\| {
	3361	if (opt_phndx.int()) \|index\| {
	3362	opt_phndx.* = @enumFromInt(backlinks[index]);
3319	3363	}
3320	3364	}
3321	3365	}
3322	3366
3323		fn shdrRank(self: *Elf, shndx: u32) u8 {
3324		const shdr = self.sections.items(.shdr)[shndx];
3325		const name = self.getShString(shdr.sh_name);
	3367	fn shdrRank(shdr: elf.Elf64_Shdr, shstrtab: []const u8) u8 {
	3368	const name = shString(shstrtab, shdr.sh_name);
3326	3369	const flags = shdr.sh_flags;
3327	3370
3328	3371	switch (shdr.sh_type) {
...	...	@@ -3371,145 +3414,138 @@ fn shdrRank(self: *Elf, shndx: u32) u8 {
3371	3414	}
3372	3415	}
3373	3416
3374		pub fn sortShdrs(self: *Elf) !void {
	3417	pub fn sortShdrs(
	3418	gpa: Allocator,
	3419	section_indexes: *SectionIndexes,
	3420	sections: *std.MultiArrayList(Section),
	3421	shstrtab: []const u8,
	3422	merge_sections: []Merge.Section,
	3423	comdat_group_sections: []ComdatGroupSection,
	3424	zig_object_ptr: ?*ZigObject,
	3425	files: std.MultiArrayList(File.Entry),
	3426	) !void {
3375	3427	const Entry = struct {
3376	3428	shndx: u32,
3377	3429
3378		pub fn lessThan(elf_file: *Elf, lhs: @This(), rhs: @This()) bool {
3379		return elf_file.shdrRank(lhs.shndx) < elf_file.shdrRank(rhs.shndx);
	3430	const Context = struct {
	3431	shdrs: []const elf.Elf64_Shdr,
	3432	shstrtab: []const u8,
	3433	};
	3434
	3435	pub fn lessThan(ctx: Context, lhs: @This(), rhs: @This()) bool {
	3436	return shdrRank(ctx.shdrs[lhs.shndx], ctx.shstrtab) <
	3437	shdrRank(ctx.shdrs[rhs.shndx], ctx.shstrtab);
3380	3438	}
3381	3439	};
3382	3440
3383		const gpa = self.base.comp.gpa;
3384		var entries = try std.ArrayList(Entry).initCapacity(gpa, self.sections.items(.shdr).len);
3385		defer entries.deinit();
3386		for (0..self.sections.items(.shdr).len) \|shndx\| {
3387		entries.appendAssumeCapacity(.{ .shndx = @intCast(shndx) });
	3441	const shdrs = sections.items(.shdr);
	3442
	3443	const entries = try gpa.alloc(Entry, shdrs.len);
	3444	defer gpa.free(entries);
	3445	for (entries, 0..shdrs.len) \|*entry, shndx\| {
	3446	entry.* = .{ .shndx = @intCast(shndx) };
3388	3447	}
3389	3448
3390		mem.sort(Entry, entries.items, self, Entry.lessThan);
	3449	const sort_context: Entry.Context = .{
	3450	.shdrs = shdrs,
	3451	.shstrtab = shstrtab,
	3452	};
	3453	mem.sort(Entry, entries, sort_context, Entry.lessThan);
3391	3454
3392		const backlinks = try gpa.alloc(u32, entries.items.len);
	3455	const backlinks = try gpa.alloc(u32, entries.len);
3393	3456	defer gpa.free(backlinks);
3394		for (entries.items, 0..) \|entry, i\| {
3395		backlinks[entry.shndx] = @intCast(i);
3396		}
3397
3398		var slice = self.sections.toOwnedSlice();
3399		defer slice.deinit(gpa);
3400
3401		try self.sections.ensureTotalCapacity(gpa, slice.len);
3402		for (entries.items) \|sorted\| {
3403		self.sections.appendAssumeCapacity(slice.get(sorted.shndx));
3404		}
3405
3406		self.resetShdrIndexes(backlinks);
3407		}
3408
3409		fn resetShdrIndexes(self: *Elf, backlinks: []const u32) void {
3410		for (&[_]*?u32{
3411		&self.eh_frame_section_index,
3412		&self.eh_frame_rela_section_index,
3413		&self.eh_frame_hdr_section_index,
3414		&self.got_section_index,
3415		&self.symtab_section_index,
3416		&self.strtab_section_index,
3417		&self.shstrtab_section_index,
3418		&self.interp_section_index,
3419		&self.dynamic_section_index,
3420		&self.dynsymtab_section_index,
3421		&self.dynstrtab_section_index,
3422		&self.hash_section_index,
3423		&self.gnu_hash_section_index,
3424		&self.plt_section_index,
3425		&self.got_plt_section_index,
3426		&self.plt_got_section_index,
3427		&self.rela_dyn_section_index,
3428		&self.rela_plt_section_index,
3429		&self.copy_rel_section_index,
3430		&self.versym_section_index,
3431		&self.verneed_section_index,
3432		}) \|maybe_index\| {
3433		if (maybe_index.) \|index\| {
3434		index.* = backlinks[index.*];
	3457	{
	3458	var slice = sections.toOwnedSlice();
	3459	defer slice.deinit(gpa);
	3460	try sections.resize(gpa, slice.len);
	3461
	3462	for (entries, 0..) \|entry, i\| {
	3463	backlinks[entry.shndx] = @intCast(i);
	3464	sections.set(i, slice.get(entry.shndx));
3435	3465	}
3436	3466	}
3437	3467
3438		for (self.merge_sections.items) \|*msec\| {
	3468	inline for (@typeInfo(SectionIndexes).@"struct".fields) \|field\| {
	3469	if (@field(section_indexes, field.name)) \|special_index\| {
	3470	@field(section_indexes, field.name) = backlinks[special_index];
	3471	}
	3472	}
	3473
	3474	for (merge_sections) \|*msec\| {
3439	3475	msec.output_section_index = backlinks[msec.output_section_index];
3440	3476	}
3441	3477
3442		const slice = self.sections.slice();
	3478	const slice = sections.slice();
3443	3479	for (slice.items(.shdr), slice.items(.atom_list_2)) \|shdr, atom_list\| {
3444	3480	atom_list.output_section_index = backlinks[atom_list.output_section_index];
3445	3481	for (atom_list.atoms.keys()) \|ref\| {
3446		self.atom(ref).?.output_section_index = atom_list.output_section_index;
	3482	fileLookup(files, ref.file).?.atom(ref.index).?.output_section_index = atom_list.output_section_index;
3447	3483	}
3448	3484	if (shdr.sh_type == elf.SHT_RELA) {
3449	3485	// FIXME:JK we should spin up .symtab potentially earlier, or set all non-dynamic RELA sections
3450	3486	// to point at symtab
3451	3487	// shdr.sh_link = backlinks[shdr.sh_link];
3452		shdr.sh_link = self.symtab_section_index.?;
	3488	shdr.sh_link = section_indexes.symtab.?;
3453	3489	shdr.sh_info = backlinks[shdr.sh_info];
3454	3490	}
3455	3491	}
3456	3492
3457		if (self.zigObjectPtr()) \|zo\| zo.resetShdrIndexes(backlinks);
	3493	if (zig_object_ptr) \|zo\| zo.resetShdrIndexes(backlinks);
3458	3494
3459		for (self.comdat_group_sections.items) \|*cg\| {
	3495	for (comdat_group_sections) \|*cg\| {
3460	3496	cg.shndx = backlinks[cg.shndx];
3461	3497	}
3462	3498
3463		if (self.symtab_section_index) \|index\| {
	3499	if (section_indexes.symtab) \|index\| {
3464	3500	const shdr = &slice.items(.shdr)[index];
3465		shdr.sh_link = self.strtab_section_index.?;
	3501	shdr.sh_link = section_indexes.strtab.?;
3466	3502	}
3467	3503
3468		if (self.dynamic_section_index) \|index\| {
	3504	if (section_indexes.dynamic) \|index\| {
3469	3505	const shdr = &slice.items(.shdr)[index];
3470		shdr.sh_link = self.dynstrtab_section_index.?;
	3506	shdr.sh_link = section_indexes.dynstrtab.?;
3471	3507	}
3472	3508
3473		if (self.dynsymtab_section_index) \|index\| {
	3509	if (section_indexes.dynsymtab) \|index\| {
3474	3510	const shdr = &slice.items(.shdr)[index];
3475		shdr.sh_link = self.dynstrtab_section_index.?;
	3511	shdr.sh_link = section_indexes.dynstrtab.?;
3476	3512	}
3477	3513
3478		if (self.hash_section_index) \|index\| {
	3514	if (section_indexes.hash) \|index\| {
3479	3515	const shdr = &slice.items(.shdr)[index];
3480		shdr.sh_link = self.dynsymtab_section_index.?;
	3516	shdr.sh_link = section_indexes.dynsymtab.?;
3481	3517	}
3482	3518
3483		if (self.gnu_hash_section_index) \|index\| {
	3519	if (section_indexes.gnu_hash) \|index\| {
3484	3520	const shdr = &slice.items(.shdr)[index];
3485		shdr.sh_link = self.dynsymtab_section_index.?;
	3521	shdr.sh_link = section_indexes.dynsymtab.?;
3486	3522	}
3487	3523
3488		if (self.versym_section_index) \|index\| {
	3524	if (section_indexes.versym) \|index\| {
3489	3525	const shdr = &slice.items(.shdr)[index];
3490		shdr.sh_link = self.dynsymtab_section_index.?;
	3526	shdr.sh_link = section_indexes.dynsymtab.?;
3491	3527	}
3492	3528
3493		if (self.verneed_section_index) \|index\| {
	3529	if (section_indexes.verneed) \|index\| {
3494	3530	const shdr = &slice.items(.shdr)[index];
3495		shdr.sh_link = self.dynstrtab_section_index.?;
	3531	shdr.sh_link = section_indexes.dynstrtab.?;
3496	3532	}
3497	3533
3498		if (self.rela_dyn_section_index) \|index\| {
	3534	if (section_indexes.rela_dyn) \|index\| {
3499	3535	const shdr = &slice.items(.shdr)[index];
3500		shdr.sh_link = self.dynsymtab_section_index orelse 0;
	3536	shdr.sh_link = section_indexes.dynsymtab orelse 0;
3501	3537	}
3502	3538
3503		if (self.rela_plt_section_index) \|index\| {
	3539	if (section_indexes.rela_plt) \|index\| {
3504	3540	const shdr = &slice.items(.shdr)[index];
3505		shdr.sh_link = self.dynsymtab_section_index.?;
3506		shdr.sh_info = self.plt_section_index.?;
	3541	shdr.sh_link = section_indexes.dynsymtab.?;
	3542	shdr.sh_info = section_indexes.plt.?;
3507	3543	}
3508	3544
3509		if (self.eh_frame_rela_section_index) \|index\| {
	3545	if (section_indexes.eh_frame_rela) \|index\| {
3510	3546	const shdr = &slice.items(.shdr)[index];
3511		shdr.sh_link = self.symtab_section_index.?;
3512		shdr.sh_info = self.eh_frame_section_index.?;
	3547	shdr.sh_link = section_indexes.symtab.?;
	3548	shdr.sh_info = section_indexes.eh_frame.?;
3513	3549	}
3514	3550	}
3515	3551
...	...	@@ -3543,31 +3579,31 @@ fn updateSectionSizes(self: *Elf) !void {
3543	3579	}
3544	3580
3545	3581	const shdrs = slice.items(.shdr);
3546		if (self.eh_frame_section_index) \|index\| {
	3582	if (self.section_indexes.eh_frame) \|index\| {
3547	3583	shdrs[index].sh_size = try eh_frame.calcEhFrameSize(self);
3548	3584	}
3549	3585
3550		if (self.eh_frame_hdr_section_index) \|index\| {
	3586	if (self.section_indexes.eh_frame_hdr) \|index\| {
3551	3587	shdrs[index].sh_size = eh_frame.calcEhFrameHdrSize(self);
3552	3588	}
3553	3589
3554		if (self.got_section_index) \|index\| {
	3590	if (self.section_indexes.got) \|index\| {
3555	3591	shdrs[index].sh_size = self.got.size(self);
3556	3592	}
3557	3593
3558		if (self.plt_section_index) \|index\| {
	3594	if (self.section_indexes.plt) \|index\| {
3559	3595	shdrs[index].sh_size = self.plt.size(self);
3560	3596	}
3561	3597
3562		if (self.got_plt_section_index) \|index\| {
	3598	if (self.section_indexes.got_plt) \|index\| {
3563	3599	shdrs[index].sh_size = self.got_plt.size(self);
3564	3600	}
3565	3601
3566		if (self.plt_got_section_index) \|index\| {
	3602	if (self.section_indexes.plt_got) \|index\| {
3567	3603	shdrs[index].sh_size = self.plt_got.size(self);
3568	3604	}
3569	3605
3570		if (self.rela_dyn_section_index) \|shndx\| {
	3606	if (self.section_indexes.rela_dyn) \|shndx\| {
3571	3607	var num = self.got.numRela(self) + self.copy_rel.numRela();
3572	3608	if (self.zigObjectPtr()) \|zig_object\| {
3573	3609	num += zig_object.num_dynrelocs;
...	...	@@ -3578,43 +3614,43 @@ fn updateSectionSizes(self: *Elf) !void {
3578	3614	shdrs[shndx].sh_size = num * @sizeOf(elf.Elf64_Rela);
3579	3615	}
3580	3616
3581		if (self.rela_plt_section_index) \|index\| {
	3617	if (self.section_indexes.rela_plt) \|index\| {
3582	3618	shdrs[index].sh_size = self.plt.numRela() * @sizeOf(elf.Elf64_Rela);
3583	3619	}
3584	3620
3585		if (self.copy_rel_section_index) \|index\| {
	3621	if (self.section_indexes.copy_rel) \|index\| {
3586	3622	try self.copy_rel.updateSectionSize(index, self);
3587	3623	}
3588	3624
3589		if (self.interp_section_index) \|index\| {
	3625	if (self.section_indexes.interp) \|index\| {
3590	3626	shdrs[index].sh_size = self.getTarget().dynamic_linker.get().?.len + 1;
3591	3627	}
3592	3628
3593		if (self.hash_section_index) \|index\| {
	3629	if (self.section_indexes.hash) \|index\| {
3594	3630	shdrs[index].sh_size = self.hash.size();
3595	3631	}
3596	3632
3597		if (self.gnu_hash_section_index) \|index\| {
	3633	if (self.section_indexes.gnu_hash) \|index\| {
3598	3634	shdrs[index].sh_size = self.gnu_hash.size();
3599	3635	}
3600	3636
3601		if (self.dynamic_section_index) \|index\| {
	3637	if (self.section_indexes.dynamic) \|index\| {
3602	3638	shdrs[index].sh_size = self.dynamic.size(self);
3603	3639	}
3604	3640
3605		if (self.dynsymtab_section_index) \|index\| {
	3641	if (self.section_indexes.dynsymtab) \|index\| {
3606	3642	shdrs[index].sh_size = self.dynsym.size();
3607	3643	}
3608	3644
3609		if (self.dynstrtab_section_index) \|index\| {
	3645	if (self.section_indexes.dynstrtab) \|index\| {
3610	3646	shdrs[index].sh_size = self.dynstrtab.items.len;
3611	3647	}
3612	3648
3613		if (self.versym_section_index) \|index\| {
	3649	if (self.section_indexes.versym) \|index\| {
3614	3650	shdrs[index].sh_size = self.versym.items.len * @sizeOf(elf.Elf64_Versym);
3615	3651	}
3616	3652
3617		if (self.verneed_section_index) \|index\| {
	3653	if (self.section_indexes.verneed) \|index\| {
3618	3654	shdrs[index].sh_size = self.verneed.size();
3619	3655	}
3620	3656
...	...	@@ -3624,7 +3660,7 @@ fn updateSectionSizes(self: *Elf) !void {
3624	3660
3625	3661	// FIXME:JK this is very much obsolete, remove!
3626	3662	pub fn updateShStrtabSize(self: *Elf) void {
3627		if (self.shstrtab_section_index) \|index\| {
	3663	if (self.section_indexes.shstrtab) \|index\| {
3628	3664	self.sections.items(.shdr)[index].sh_size = self.shstrtab.items.len;
3629	3665	}
3630	3666	}
...	...	@@ -3656,7 +3692,7 @@ fn addLoadPhdrs(self: *Elf) error{OutOfMemory}!void {
3656	3692	if (shdr.sh_type == elf.SHT_NULL) continue;
3657	3693	if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
3658	3694	const flags = shdrToPhdrFlags(shdr.sh_flags);
3659		if (self.getPhdr(.{ .flags = flags, .type = elf.PT_LOAD }) == null) {
	3695	if (self.getPhdr(.{ .flags = flags, .type = elf.PT_LOAD }) == .none) {
3660	3696	_ = try self.addPhdr(.{ .flags = flags, .type = elf.PT_LOAD });
3661	3697	}
3662	3698	}
...	...	@@ -3664,8 +3700,8 @@ fn addLoadPhdrs(self: *Elf) error{OutOfMemory}!void {
3664	3700
3665	3701	/// Allocates PHDR table in virtual memory and in file.
3666	3702	fn allocatePhdrTable(self: *Elf) error{OutOfMemory}!void {
3667		const phdr_table = &self.phdrs.items[self.phdr_table_index.?];
3668		const phdr_table_load = &self.phdrs.items[self.phdr_table_load_index.?];
	3703	const phdr_table = &self.phdrs.items[self.phdr_indexes.table.int().?];
	3704	const phdr_table_load = &self.phdrs.items[self.phdr_indexes.table_load.int().?];
3669	3705
3670	3706	const ehsize: u64 = switch (self.ptr_width) {
3671	3707	.p32 => @sizeOf(elf.Elf32_Ehdr),
...	...	@@ -3757,7 +3793,7 @@ pub fn allocateAllocSections(self: *Elf) !void {
3757	3793	// When allocating we first find the largest required alignment
3758	3794	// of any section that is contained in a cover and use it to align
3759	3795	// the start address of the segement (and first section).
3760		const phdr_table = &self.phdrs.items[self.phdr_table_load_index.?];
	3796	const phdr_table = &self.phdrs.items[self.phdr_indexes.table_load.int().?];
3761	3797	var addr = phdr_table.p_vaddr + phdr_table.p_memsz;
3762	3798
3763	3799	for (covers) \|cover\| {
...	...	@@ -3817,8 +3853,8 @@ pub fn allocateAllocSections(self: *Elf) !void {
3817	3853	}
3818	3854
3819	3855	const first = slice.items(.shdr)[cover.items[0]];
3820		const phndx = self.getPhdr(.{ .type = elf.PT_LOAD, .flags = shdrToPhdrFlags(first.sh_flags) }).?;
3821		const phdr = &self.phdrs.items[phndx];
	3856	const phndx = self.getPhdr(.{ .type = elf.PT_LOAD, .flags = shdrToPhdrFlags(first.sh_flags) }).unwrap().?;
	3857	const phdr = &self.phdrs.items[phndx.int()];
3822	3858	const allocated_size = self.allocatedSize(phdr.p_offset);
3823	3859	if (filesz > allocated_size) {
3824	3860	const old_offset = phdr.p_offset;
...	...	@@ -3830,7 +3866,7 @@ pub fn allocateAllocSections(self: *Elf) !void {
3830	3866
3831	3867	for (cover.items) \|shndx\| {
3832	3868	const shdr = &slice.items(.shdr)[shndx];
3833		slice.items(.phndx)[shndx] = phndx;
	3869	slice.items(.phndx)[shndx] = phndx.toOptional();
3834	3870	if (shdr.sh_type == elf.SHT_NOBITS) {
3835	3871	shdr.sh_offset = 0;
3836	3872	continue;
...	...	@@ -3906,12 +3942,12 @@ pub fn allocateNonAllocSections(self: *Elf) !void {
3906	3942	fn allocateSpecialPhdrs(self: *Elf) void {
3907	3943	const slice = self.sections.slice();
3908	3944
3909		for (&[_]struct { ?u16, ?u32 }{
3910		.{ self.phdr_interp_index, self.interp_section_index },
3911		.{ self.phdr_dynamic_index, self.dynamic_section_index },
3912		.{ self.phdr_gnu_eh_frame_index, self.eh_frame_hdr_section_index },
	3945	for (&[_]struct { OptionalProgramHeaderIndex, ?u32 }{
	3946	.{ self.phdr_indexes.interp, self.section_indexes.interp },
	3947	.{ self.phdr_indexes.dynamic, self.section_indexes.dynamic },
	3948	.{ self.phdr_indexes.gnu_eh_frame, self.section_indexes.eh_frame_hdr },
3913	3949	}) \|pair\| {
3914		if (pair[0]) \|index\| {
	3950	if (pair[0].int()) \|index\| {
3915	3951	const shdr = slice.items(.shdr)[pair[1].?];
3916	3952	const phdr = &self.phdrs.items[index];
3917	3953	phdr.p_align = shdr.sh_addralign;
...	...	@@ -3926,7 +3962,7 @@ fn allocateSpecialPhdrs(self: *Elf) void {
3926	3962	// Set the TLS segment boundaries.
3927	3963	// We assume TLS sections are laid out contiguously and that there is
3928	3964	// a single TLS segment.
3929		if (self.phdr_tls_index) \|index\| {
	3965	if (self.phdr_indexes.tls.int()) \|index\| {
3930	3966	const shdrs = slice.items(.shdr);
3931	3967	const phdr = &self.phdrs.items[index];
3932	3968	var shndx: u32 = 0;
...	...	@@ -4046,7 +4082,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
4046	4082	strsize += ctx.strsize;
4047	4083	}
4048	4084
4049		if (self.got_section_index) \|_\| {
	4085	if (self.section_indexes.got) \|_\| {
4050	4086	self.got.output_symtab_ctx.reset();
4051	4087	self.got.output_symtab_ctx.ilocal = nlocals;
4052	4088	self.got.updateSymtabSize(self);
...	...	@@ -4054,7 +4090,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
4054	4090	strsize += self.got.output_symtab_ctx.strsize;
4055	4091	}
4056	4092
4057		if (self.plt_section_index) \|_\| {
	4093	if (self.section_indexes.plt) \|_\| {
4058	4094	self.plt.output_symtab_ctx.reset();
4059	4095	self.plt.output_symtab_ctx.ilocal = nlocals;
4060	4096	self.plt.updateSymtabSize(self);
...	...	@@ -4062,7 +4098,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
4062	4098	strsize += self.plt.output_symtab_ctx.strsize;
4063	4099	}
4064	4100
4065		if (self.plt_got_section_index) \|_\| {
	4101	if (self.section_indexes.plt_got) \|_\| {
4066	4102	self.plt_got.output_symtab_ctx.reset();
4067	4103	self.plt_got.output_symtab_ctx.ilocal = nlocals;
4068	4104	self.plt_got.updateSymtabSize(self);
...	...	@@ -4079,9 +4115,9 @@ pub fn updateSymtabSize(self: *Elf) !void {
4079	4115	}
4080	4116
4081	4117	const slice = self.sections.slice();
4082		const symtab_shdr = &slice.items(.shdr)[self.symtab_section_index.?];
	4118	const symtab_shdr = &slice.items(.shdr)[self.section_indexes.symtab.?];
4083	4119	symtab_shdr.sh_info = nlocals;
4084		symtab_shdr.sh_link = self.strtab_section_index.?;
	4120	symtab_shdr.sh_link = self.section_indexes.strtab.?;
4085	4121
4086	4122	const sym_size: u64 = switch (self.ptr_width) {
4087	4123	.p32 => @sizeOf(elf.Elf32_Sym),
...	...	@@ -4090,7 +4126,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
4090	4126	const needed_size = (nlocals + nglobals) * sym_size;
4091	4127	symtab_shdr.sh_size = needed_size;
4092	4128
4093		const strtab = &slice.items(.shdr)[self.strtab_section_index.?];
	4129	const strtab = &slice.items(.shdr)[self.section_indexes.strtab.?];
4094	4130	strtab.sh_size = strsize + 1;
4095	4131	}
4096	4132
...	...	@@ -4098,7 +4134,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4098	4134	const gpa = self.base.comp.gpa;
4099	4135	const slice = self.sections.slice();
4100	4136
4101		if (self.interp_section_index) \|shndx\| {
	4137	if (self.section_indexes.interp) \|shndx\| {
4102	4138	var buffer: [256]u8 = undefined;
4103	4139	const interp = self.getTarget().dynamic_linker.get().?;
4104	4140	@memcpy(buffer[0..interp.len], interp);
...	...	@@ -4109,12 +4145,12 @@ fn writeSyntheticSections(self: *Elf) !void {
4109	4145	try self.base.file.?.pwriteAll(contents, shdr.sh_offset);
4110	4146	}
4111	4147
4112		if (self.hash_section_index) \|shndx\| {
	4148	if (self.section_indexes.hash) \|shndx\| {
4113	4149	const shdr = slice.items(.shdr)[shndx];
4114	4150	try self.base.file.?.pwriteAll(self.hash.buffer.items, shdr.sh_offset);
4115	4151	}
4116	4152
4117		if (self.gnu_hash_section_index) \|shndx\| {
	4153	if (self.section_indexes.gnu_hash) \|shndx\| {
4118	4154	const shdr = slice.items(.shdr)[shndx];
4119	4155	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.gnu_hash.size());
4120	4156	defer buffer.deinit();
...	...	@@ -4122,12 +4158,12 @@ fn writeSyntheticSections(self: *Elf) !void {
4122	4158	try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
4123	4159	}
4124	4160
4125		if (self.versym_section_index) \|shndx\| {
	4161	if (self.section_indexes.versym) \|shndx\| {
4126	4162	const shdr = slice.items(.shdr)[shndx];
4127	4163	try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.versym.items), shdr.sh_offset);
4128	4164	}
4129	4165
4130		if (self.verneed_section_index) \|shndx\| {
	4166	if (self.section_indexes.verneed) \|shndx\| {
4131	4167	const shdr = slice.items(.shdr)[shndx];
4132	4168	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.verneed.size());
4133	4169	defer buffer.deinit();
...	...	@@ -4135,7 +4171,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4135	4171	try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
4136	4172	}
4137	4173
4138		if (self.dynamic_section_index) \|shndx\| {
	4174	if (self.section_indexes.dynamic) \|shndx\| {
4139	4175	const shdr = slice.items(.shdr)[shndx];
4140	4176	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.dynamic.size(self));
4141	4177	defer buffer.deinit();
...	...	@@ -4143,7 +4179,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4143	4179	try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
4144	4180	}
4145	4181
4146		if (self.dynsymtab_section_index) \|shndx\| {
	4182	if (self.section_indexes.dynsymtab) \|shndx\| {
4147	4183	const shdr = slice.items(.shdr)[shndx];
4148	4184	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.dynsym.size());
4149	4185	defer buffer.deinit();
...	...	@@ -4151,12 +4187,12 @@ fn writeSyntheticSections(self: *Elf) !void {
4151	4187	try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
4152	4188	}
4153	4189
4154		if (self.dynstrtab_section_index) \|shndx\| {
	4190	if (self.section_indexes.dynstrtab) \|shndx\| {
4155	4191	const shdr = slice.items(.shdr)[shndx];
4156	4192	try self.base.file.?.pwriteAll(self.dynstrtab.items, shdr.sh_offset);
4157	4193	}
4158	4194
4159		if (self.eh_frame_section_index) \|shndx\| {
	4195	if (self.section_indexes.eh_frame) \|shndx\| {
4160	4196	const existing_size = existing_size: {
4161	4197	const zo = self.zigObjectPtr() orelse break :existing_size 0;
4162	4198	const sym = zo.symbol(zo.eh_frame_index orelse break :existing_size 0);
...	...	@@ -4171,7 +4207,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4171	4207	try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset + existing_size);
4172	4208	}
4173	4209
4174		if (self.eh_frame_hdr_section_index) \|shndx\| {
	4210	if (self.section_indexes.eh_frame_hdr) \|shndx\| {
4175	4211	const shdr = slice.items(.shdr)[shndx];
4176	4212	const sh_size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;
4177	4213	var buffer = try std.ArrayList(u8).initCapacity(gpa, sh_size);
...	...	@@ -4180,7 +4216,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4180	4216	try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
4181	4217	}
4182	4218
4183		if (self.got_section_index) \|index\| {
	4219	if (self.section_indexes.got) \|index\| {
4184	4220	const shdr = slice.items(.shdr)[index];
4185	4221	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.got.size(self));
4186	4222	defer buffer.deinit();
...	...	@@ -4188,7 +4224,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4188	4224	try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
4189	4225	}
4190	4226
4191		if (self.rela_dyn_section_index) \|shndx\| {
	4227	if (self.section_indexes.rela_dyn) \|shndx\| {
4192	4228	const shdr = slice.items(.shdr)[shndx];
4193	4229	try self.got.addRela(self);
4194	4230	try self.copy_rel.addRela(self);
...	...	@@ -4196,7 +4232,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4196	4232	try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.rela_dyn.items), shdr.sh_offset);
4197	4233	}
4198	4234
4199		if (self.plt_section_index) \|shndx\| {
	4235	if (self.section_indexes.plt) \|shndx\| {
4200	4236	const shdr = slice.items(.shdr)[shndx];
4201	4237	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.plt.size(self));
4202	4238	defer buffer.deinit();
...	...	@@ -4204,7 +4240,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4204	4240	try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
4205	4241	}
4206	4242
4207		if (self.got_plt_section_index) \|shndx\| {
	4243	if (self.section_indexes.got_plt) \|shndx\| {
4208	4244	const shdr = slice.items(.shdr)[shndx];
4209	4245	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.got_plt.size(self));
4210	4246	defer buffer.deinit();
...	...	@@ -4212,7 +4248,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4212	4248	try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
4213	4249	}
4214	4250
4215		if (self.plt_got_section_index) \|shndx\| {
	4251	if (self.section_indexes.plt_got) \|shndx\| {
4216	4252	const shdr = slice.items(.shdr)[shndx];
4217	4253	var buffer = try std.ArrayList(u8).initCapacity(gpa, self.plt_got.size(self));
4218	4254	defer buffer.deinit();
...	...	@@ -4220,7 +4256,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4220	4256	try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
4221	4257	}
4222	4258
4223		if (self.rela_plt_section_index) \|shndx\| {
	4259	if (self.section_indexes.rela_plt) \|shndx\| {
4224	4260	const shdr = slice.items(.shdr)[shndx];
4225	4261	try self.plt.addRela(self);
4226	4262	try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.rela_plt.items), shdr.sh_offset);
...	...	@@ -4232,7 +4268,7 @@ fn writeSyntheticSections(self: *Elf) !void {
4232	4268
4233	4269	// FIXME:JK again, why is this needed?
4234	4270	pub fn writeShStrtab(self: *Elf) !void {
4235		if (self.shstrtab_section_index) \|index\| {
	4271	if (self.section_indexes.shstrtab) \|index\| {
4236	4272	const shdr = self.sections.items(.shdr)[index];
4237	4273	log.debug("writing .shstrtab from 0x{x} to 0x{x}", .{ shdr.sh_offset, shdr.sh_offset + shdr.sh_size });
4238	4274	try self.base.file.?.pwriteAll(self.shstrtab.items, shdr.sh_offset);
...	...	@@ -4242,8 +4278,8 @@ pub fn writeShStrtab(self: *Elf) !void {
4242	4278	pub fn writeSymtab(self: *Elf) !void {
4243	4279	const gpa = self.base.comp.gpa;
4244	4280	const slice = self.sections.slice();
4245		const symtab_shdr = slice.items(.shdr)[self.symtab_section_index.?];
4246		const strtab_shdr = slice.items(.shdr)[self.strtab_section_index.?];
	4281	const symtab_shdr = slice.items(.shdr)[self.section_indexes.symtab.?];
	4282	const strtab_shdr = slice.items(.shdr)[self.section_indexes.strtab.?];
4247	4283	const sym_size: u64 = switch (self.ptr_width) {
4248	4284	.p32 => @sizeOf(elf.Elf32_Sym),
4249	4285	.p64 => @sizeOf(elf.Elf64_Sym),
...	...	@@ -4301,15 +4337,15 @@ pub fn writeSymtab(self: *Elf) !void {
4301	4337	obj.asFile().writeSymtab(self);
4302	4338	}
4303	4339
4304		if (self.got_section_index) \|_\| {
	4340	if (self.section_indexes.got) \|_\| {
4305	4341	self.got.writeSymtab(self);
4306	4342	}
4307	4343
4308		if (self.plt_section_index) \|_\| {
	4344	if (self.section_indexes.plt) \|_\| {
4309	4345	self.plt.writeSymtab(self);
4310	4346	}
4311	4347
4312		if (self.plt_got_section_index) \|_\| {
	4348	if (self.section_indexes.plt_got) \|_\| {
4313	4349	self.plt_got.writeSymtab(self);
4314	4350	}
4315	4351
...	...	@@ -4482,14 +4518,15 @@ pub fn isEffectivelyDynLib(self: Elf) bool {
4482	4518	fn getPhdr(self: *Elf, opts: struct {
4483	4519	type: u32 = 0,
4484	4520	flags: u32 = 0,
4485		}) ?u16 {
	4521	}) OptionalProgramHeaderIndex {
4486	4522	for (self.phdrs.items, 0..) \|phdr, phndx\| {
4487		if (self.phdr_table_load_index) \|index\| {
	4523	if (self.phdr_indexes.table_load.int()) \|index\| {
4488	4524	if (phndx == index) continue;
4489	4525	}
4490		if (phdr.p_type == opts.type and phdr.p_flags == opts.flags) return @intCast(phndx);
	4526	if (phdr.p_type == opts.type and phdr.p_flags == opts.flags)
	4527	return @enumFromInt(phndx);
4491	4528	}
4492		return null;
	4529	return .none;
4493	4530	}
4494	4531
4495	4532	fn addPhdr(self: *Elf, opts: struct {
...	...	@@ -4500,9 +4537,9 @@ fn addPhdr(self: *Elf, opts: struct {
4500	4537	addr: u64 = 0,
4501	4538	filesz: u64 = 0,
4502	4539	memsz: u64 = 0,
4503		}) error{OutOfMemory}!u16 {
	4540	}) error{OutOfMemory}!ProgramHeaderIndex {
4504	4541	const gpa = self.base.comp.gpa;
4505		const index = @as(u16, @intCast(self.phdrs.items.len));
	4542	const index: ProgramHeaderIndex = @enumFromInt(self.phdrs.items.len);
4506	4543	try self.phdrs.append(gpa, .{
4507	4544	.p_type = opts.type,
4508	4545	.p_flags = opts.flags,
...	...	@@ -4667,13 +4704,17 @@ pub fn thunk(self: Elf, index: Thunk.Index) Thunk {
4667	4704	}
4668	4705
4669	4706	pub fn file(self: *Elf, index: File.Index) ?File {
4670		const tag = self.files.items(.tags)[index];
	4707	return fileLookup(self.files, index);
	4708	}
	4709
	4710	fn fileLookup(files: std.MultiArrayList(File.Entry), index: File.Index) ?File {
	4711	const tag = files.items(.tags)[index];
4671	4712	return switch (tag) {
4672	4713	.null => null,
4673		.linker_defined => .{ .linker_defined = &self.files.items(.data)[index].linker_defined },
4674		.zig_object => .{ .zig_object = &self.files.items(.data)[index].zig_object },
4675		.object => .{ .object = &self.files.items(.data)[index].object },
4676		.shared_object => .{ .shared_object = &self.files.items(.data)[index].shared_object },
	4714	.linker_defined => .{ .linker_defined = &files.items(.data)[index].linker_defined },
	4715	.zig_object => .{ .zig_object = &files.items(.data)[index].zig_object },
	4716	.object => .{ .object = &files.items(.data)[index].object },
	4717	.shared_object => .{ .shared_object = &files.items(.data)[index].shared_object },
4677	4718	};
4678	4719	}
4679	4720
...	...	@@ -4718,7 +4759,7 @@ pub fn linkerDefinedPtr(self: Elf) ?LinkerDefined {
4718	4759	return self.file(index).?.linker_defined;
4719	4760	}
4720	4761
4721		pub fn getOrCreateMergeSection(self: *Elf, name: [:0]const u8, flags: u64, @"type": u32) !MergeSection.Index {
	4762	pub fn getOrCreateMergeSection(self: *Elf, name: [:0]const u8, flags: u64, @"type": u32) !Merge.Section.Index {
4722	4763	const gpa = self.base.comp.gpa;
4723	4764	const out_name = name: {
4724	4765	if (self.base.isRelocatable()) break :name name;
...	...	@@ -4731,7 +4772,7 @@ pub fn getOrCreateMergeSection(self: *Elf, name: [:0]const u8, flags: u64, @"typ
4731	4772	}
4732	4773	const out_off = try self.insertShString(out_name);
4733	4774	const out_flags = flags & ~@as(u64, elf.SHF_COMPRESSED \| elf.SHF_GROUP);
4734		const index = @as(MergeSection.Index, @intCast(self.merge_sections.items.len));
	4775	const index: Merge.Section.Index = @intCast(self.merge_sections.items.len);
4735	4776	const msec = try self.merge_sections.addOne(gpa);
4736	4777	msec.* = .{
4737	4778	.name_offset = out_off,
...	...	@@ -4741,22 +4782,22 @@ pub fn getOrCreateMergeSection(self: *Elf, name: [:0]const u8, flags: u64, @"typ
4741	4782	return index;
4742	4783	}
4743	4784
4744		pub fn mergeSection(self: Elf, index: MergeSection.Index) MergeSection {
	4785	pub fn mergeSection(self: Elf, index: Merge.Section.Index) Merge.Section {
4745	4786	assert(index < self.merge_sections.items.len);
4746	4787	return &self.merge_sections.items[index];
4747	4788	}
4748	4789
4749	4790	pub fn gotAddress(self: *Elf) i64 {
4750	4791	const shndx = blk: {
4751		if (self.getTarget().cpu.arch == .x86_64 and self.got_plt_section_index != null)
4752		break :blk self.got_plt_section_index.?;
4753		break :blk if (self.got_section_index) \|shndx\| shndx else null;
	4792	if (self.getTarget().cpu.arch == .x86_64 and self.section_indexes.got_plt != null)
	4793	break :blk self.section_indexes.got_plt.?;
	4794	break :blk if (self.section_indexes.got) \|shndx\| shndx else null;
4754	4795	};
4755	4796	return if (shndx) \|index\| @intCast(self.sections.items(.shdr)[index].sh_addr) else 0;
4756	4797	}
4757	4798
4758	4799	pub fn tpAddress(self: *Elf) i64 {
4759		const index = self.phdr_tls_index orelse return 0;
	4800	const index = self.phdr_indexes.tls.int() orelse return 0;
4760	4801	const phdr = self.phdrs.items[index];
4761	4802	const addr = switch (self.getTarget().cpu.arch) {
4762	4803	.x86_64 => mem.alignForward(u64, phdr.p_vaddr + phdr.p_memsz, phdr.p_align),
...	...	@@ -4768,20 +4809,27 @@ pub fn tpAddress(self: *Elf) i64 {
4768	4809	}
4769	4810
4770	4811	pub fn dtpAddress(self: *Elf) i64 {
4771		const index = self.phdr_tls_index orelse return 0;
	4812	const index = self.phdr_indexes.tls.int() orelse return 0;
4772	4813	const phdr = self.phdrs.items[index];
4773	4814	return @intCast(phdr.p_vaddr);
4774	4815	}
4775	4816
4776	4817	pub fn tlsAddress(self: *Elf) i64 {
4777		const index = self.phdr_tls_index orelse return 0;
	4818	const index = self.phdr_indexes.tls.int() orelse return 0;
4778	4819	const phdr = self.phdrs.items[index];
4779	4820	return @intCast(phdr.p_vaddr);
4780	4821	}
4781	4822
4782	4823	pub fn getShString(self: Elf, off: u32) [:0]const u8 {
4783		assert(off < self.shstrtab.items.len);
4784		return mem.sliceTo(@as([*:0]const u8, @ptrCast(self.shstrtab.items.ptr + off)), 0);
	4824	return shString(self.shstrtab.items, off);
	4825	}
	4826
	4827	fn shString(
	4828	shstrtab: []const u8,
	4829	off: u32,
	4830	) [:0]const u8 {
	4831	const slice = shstrtab[off..];
	4832	return slice[0..std.mem.indexOfScalar(u8, slice, 0).? :0];
4785	4833	}
4786	4834
4787	4835	pub fn insertShString(self: *Elf, name: [:0]const u8) error{OutOfMemory}!u32 {
...	...	@@ -5393,7 +5441,7 @@ const Section = struct {
5393	5441	shdr: elf.Elf64_Shdr,
5394	5442
5395	5443	/// Assigned program header index if any.
5396		phndx: ?u32 = null,
	5444	phndx: OptionalProgramHeaderIndex = .none,
5397	5445
5398	5446	/// List of atoms contributing to this section.
5399	5447	/// TODO currently this is only used for relocations tracking in relocatable mode
...	...	@@ -5533,6 +5581,9 @@ const relocs_log = std.log.scoped(.link_relocs);
5533	5581	const state_log = std.log.scoped(.link_state);
5534	5582	const math = std.math;
5535	5583	const mem = std.mem;
	5584	const Allocator = std.mem.Allocator;
	5585	const Cache = std.Build.Cache;
	5586	const Hash = std.hash.Wyhash;
5536	5587
5537	5588	const codegen = @import("../codegen.zig");
5538	5589	const dev = @import("../dev.zig");
...	...	@@ -5540,7 +5591,6 @@ const eh_frame = @import("Elf/eh_frame.zig");
5540	5591	const gc = @import("Elf/gc.zig");
5541	5592	const glibc = @import("../glibc.zig");
5542	5593	const link = @import("../link.zig");
5543		const merge_section = @import("Elf/merge_section.zig");
5544	5594	const musl = @import("../musl.zig");
5545	5595	const relocatable = @import("Elf/relocatable.zig");
5546	5596	const relocation = @import("Elf/relocation.zig");
...	...	@@ -5548,12 +5598,10 @@ const target_util = @import("../target.zig");
5548	5598	const trace = @import("../tracy.zig").trace;
5549	5599	const synthetic_sections = @import("Elf/synthetic_sections.zig");
5550	5600
	5601	const Merge = @import("Elf/Merge.zig");
5551	5602	const Air = @import("../Air.zig");
5552		const Allocator = std.mem.Allocator;
5553	5603	const Archive = @import("Elf/Archive.zig");
5554		pub const Atom = @import("Elf/Atom.zig");
5555	5604	const AtomList = @import("Elf/AtomList.zig");
5556		const Cache = std.Build.Cache;
5557	5605	const Path = Cache.Path;
5558	5606	const Compilation = @import("../Compilation.zig");
5559	5607	const ComdatGroupSection = synthetic_sections.ComdatGroupSection;
...	...	@@ -5566,15 +5614,11 @@ const File = @import("Elf/file.zig").File;
5566	5614	const GnuHashSection = synthetic_sections.GnuHashSection;
5567	5615	const GotSection = synthetic_sections.GotSection;
5568	5616	const GotPltSection = synthetic_sections.GotPltSection;
5569		const Hash = std.hash.Wyhash;
5570	5617	const HashSection = synthetic_sections.HashSection;
5571		const InputMergeSection = merge_section.InputMergeSection;
5572	5618	const LdScript = @import("Elf/LdScript.zig");
5573	5619	const LinkerDefined = @import("Elf/LinkerDefined.zig");
5574	5620	const Liveness = @import("../Liveness.zig");
5575	5621	const LlvmObject = @import("../codegen/llvm.zig").Object;
5576		const MergeSection = merge_section.MergeSection;
5577		const MergeSubsection = merge_section.MergeSubsection;
5578	5622	const Zcu = @import("../Zcu.zig");
5579	5623	const Object = @import("Elf/Object.zig");
5580	5624	const InternPool = @import("../InternPool.zig");

src/link/Elf/LinkerDefined.zig+6-6

...	...	@@ -205,7 +205,7 @@ pub fn allocateSymbols(self: LinkerDefined, elf_file: Elf) void {
205	205	}.allocSymbol;
206	206
207	207	// _DYNAMIC
208		if (elf_file.dynamic_section_index) \|shndx\| {
	208	if (elf_file.section_indexes.dynamic) \|shndx\| {
209	209	const shdr = shdrs[shndx];
210	210	allocSymbol(self, self.dynamic_index.?, shdr.sh_addr, shndx, elf_file);
211	211	}
...	...	@@ -236,19 +236,19 @@ pub fn allocateSymbols(self: LinkerDefined, elf_file: Elf) void {
236	236
237	237	// _GLOBAL_OFFSET_TABLE_
238	238	if (elf_file.getTarget().cpu.arch == .x86_64) {
239		if (elf_file.got_plt_section_index) \|shndx\| {
	239	if (elf_file.section_indexes.got_plt) \|shndx\| {
240	240	const shdr = shdrs[shndx];
241	241	allocSymbol(self, self.got_index.?, shdr.sh_addr, shndx, elf_file);
242	242	}
243	243	} else {
244		if (elf_file.got_section_index) \|shndx\| {
	244	if (elf_file.section_indexes.got) \|shndx\| {
245	245	const shdr = shdrs[shndx];
246	246	allocSymbol(self, self.got_index.?, shdr.sh_addr, shndx, elf_file);
247	247	}
248	248	}
249	249
250	250	// _PROCEDURE_LINKAGE_TABLE_
251		if (elf_file.plt_section_index) \|shndx\| {
	251	if (elf_file.section_indexes.plt) \|shndx\| {
252	252	const shdr = shdrs[shndx];
253	253	allocSymbol(self, self.plt_index.?, shdr.sh_addr, shndx, elf_file);
254	254	}
...	...	@@ -262,13 +262,13 @@ pub fn allocateSymbols(self: LinkerDefined, elf_file: Elf) void {
262	262	}
263	263
264	264	// __GNU_EH_FRAME_HDR
265		if (elf_file.eh_frame_hdr_section_index) \|shndx\| {
	265	if (elf_file.section_indexes.eh_frame_hdr) \|shndx\| {
266	266	const shdr = shdrs[shndx];
267	267	allocSymbol(self, self.gnu_eh_frame_hdr_index.?, shdr.sh_addr, shndx, elf_file);
268	268	}
269	269
270	270	// __rela_iplt_start, __rela_iplt_end
271		if (elf_file.rela_dyn_section_index) \|shndx\| blk: {
	271	if (elf_file.section_indexes.rela_dyn) \|shndx\| blk: {
272	272	if (link_mode != .static or comp.config.pie) break :blk;
273	273	const shdr = shdrs[shndx];
274	274	const end_addr = shdr.sh_addr + shdr.sh_size;

src/link/Elf/Merge.zig created+341

...	...	@@ -0,0 +1,341 @@
	1	pub const Section = struct {
	2	value: u64 = 0,
	3	size: u64 = 0,
	4	alignment: Atom.Alignment = .@"1",
	5	entsize: u32 = 0,
	6	name_offset: u32 = 0,
	7	type: u32 = 0,
	8	flags: u64 = 0,
	9	output_section_index: u32 = 0,
	10	bytes: std.ArrayListUnmanaged(u8) = .empty,
	11	table: std.HashMapUnmanaged(
	12	String,
	13	Subsection.Index,
	14	IndexContext,
	15	std.hash_map.default_max_load_percentage,
	16	) = .{},
	17	subsections: std.ArrayListUnmanaged(Subsection) = .empty,
	18	finalized_subsections: std.ArrayListUnmanaged(Subsection.Index) = .empty,
	19
	20	pub fn deinit(msec: *Section, allocator: Allocator) void {
	21	msec.bytes.deinit(allocator);
	22	msec.table.deinit(allocator);
	23	msec.subsections.deinit(allocator);
	24	msec.finalized_subsections.deinit(allocator);
	25	}
	26
	27	pub fn name(msec: Section, elf_file: *Elf) [:0]const u8 {
	28	return elf_file.getShString(msec.name_offset);
	29	}
	30
	31	pub fn address(msec: Section, elf_file: *Elf) i64 {
	32	const shdr = elf_file.sections.items(.shdr)[msec.output_section_index];
	33	return @intCast(shdr.sh_addr + msec.value);
	34	}
	35
	36	const InsertResult = struct {
	37	found_existing: bool,
	38	key: String,
	39	sub: *Subsection.Index,
	40	};
	41
	42	pub fn insert(msec: *Section, allocator: Allocator, string: []const u8) !InsertResult {
	43	const gop = try msec.table.getOrPutContextAdapted(
	44	allocator,
	45	string,
	46	IndexAdapter{ .bytes = msec.bytes.items },
	47	IndexContext{ .bytes = msec.bytes.items },
	48	);
	49	if (!gop.found_existing) {
	50	const index: u32 = @intCast(msec.bytes.items.len);
	51	try msec.bytes.appendSlice(allocator, string);
	52	gop.key_ptr.* = .{ .pos = index, .len = @intCast(string.len) };
	53	}
	54	return .{ .found_existing = gop.found_existing, .key = gop.key_ptr.*, .sub = gop.value_ptr };
	55	}
	56
	57	pub fn insertZ(msec: *Section, allocator: Allocator, string: []const u8) !InsertResult {
	58	const with_null = try allocator.alloc(u8, string.len + 1);
	59	defer allocator.free(with_null);
	60	@memcpy(with_null[0..string.len], string);
	61	with_null[string.len] = 0;
	62	return msec.insert(allocator, with_null);
	63	}
	64
	65	/// Finalizes the merge section and clears hash table.
	66	/// Sorts all owned subsections.
	67	pub fn finalize(msec: *Section, allocator: Allocator) !void {
	68	try msec.finalized_subsections.ensureTotalCapacityPrecise(allocator, msec.subsections.items.len);
	69
	70	var it = msec.table.iterator();
	71	while (it.next()) \|entry\| {
	72	const msub = msec.mergeSubsection(entry.value_ptr.*);
	73	if (!msub.alive) continue;
	74	msec.finalized_subsections.appendAssumeCapacity(entry.value_ptr.*);
	75	}
	76	msec.table.clearAndFree(allocator);
	77
	78	const sortFn = struct {
	79	pub fn sortFn(ctx: *Section, lhs: Subsection.Index, rhs: Subsection.Index) bool {
	80	const lhs_msub = ctx.mergeSubsection(lhs);
	81	const rhs_msub = ctx.mergeSubsection(rhs);
	82	if (lhs_msub.alignment.compareStrict(.eq, rhs_msub.alignment)) {
	83	if (lhs_msub.size == rhs_msub.size) {
	84	const lhs_string = ctx.bytes.items[lhs_msub.string_index..][0..lhs_msub.size];
	85	const rhs_string = ctx.bytes.items[rhs_msub.string_index..][0..rhs_msub.size];
	86	return mem.order(u8, lhs_string, rhs_string) == .lt;
	87	}
	88	return lhs_msub.size < rhs_msub.size;
	89	}
	90	return lhs_msub.alignment.compareStrict(.lt, rhs_msub.alignment);
	91	}
	92	}.sortFn;
	93
	94	std.mem.sort(Subsection.Index, msec.finalized_subsections.items, msec, sortFn);
	95	}
	96
	97	pub fn updateSize(msec: *Section) void {
	98	// TODO a 'stale' flag would be better here perhaps?
	99	msec.size = 0;
	100	msec.alignment = .@"1";
	101	msec.entsize = 0;
	102	for (msec.finalized_subsections.items) \|msub_index\| {
	103	const msub = msec.mergeSubsection(msub_index);
	104	assert(msub.alive);
	105	const offset = msub.alignment.forward(msec.size);
	106	const padding = offset - msec.size;
	107	msub.value = @intCast(offset);
	108	msec.size += padding + msub.size;
	109	msec.alignment = msec.alignment.max(msub.alignment);
	110	msec.entsize = if (msec.entsize == 0) msub.entsize else @min(msec.entsize, msub.entsize);
	111	}
	112	}
	113
	114	pub fn initOutputSection(msec: Section, elf_file: Elf) !void {
	115	msec.output_section_index = elf_file.sectionByName(msec.name(elf_file)) orelse try elf_file.addSection(.{
	116	.name = msec.name_offset,
	117	.type = msec.type,
	118	.flags = msec.flags,
	119	});
	120	}
	121
	122	pub fn addMergeSubsection(msec: *Section, allocator: Allocator) !Subsection.Index {
	123	const index: Subsection.Index = @intCast(msec.subsections.items.len);
	124	const msub = try msec.subsections.addOne(allocator);
	125	msub.* = .{};
	126	return index;
	127	}
	128
	129	pub fn mergeSubsection(msec: Section, index: Subsection.Index) Subsection {
	130	assert(index < msec.subsections.items.len);
	131	return &msec.subsections.items[index];
	132	}
	133
	134	pub const IndexContext = struct {
	135	bytes: []const u8,
	136
	137	pub fn eql(_: @This(), a: String, b: String) bool {
	138	return a.pos == b.pos;
	139	}
	140
	141	pub fn hash(ctx: @This(), key: String) u64 {
	142	const str = ctx.bytes[key.pos..][0..key.len];
	143	return std.hash_map.hashString(str);
	144	}
	145	};
	146
	147	pub const IndexAdapter = struct {
	148	bytes: []const u8,
	149
	150	pub fn eql(ctx: @This(), a: []const u8, b: String) bool {
	151	const str = ctx.bytes[b.pos..][0..b.len];
	152	return mem.eql(u8, a, str);
	153	}
	154
	155	pub fn hash(_: @This(), adapted_key: []const u8) u64 {
	156	return std.hash_map.hashString(adapted_key);
	157	}
	158	};
	159
	160	pub fn format(
	161	msec: Section,
	162	comptime unused_fmt_string: []const u8,
	163	options: std.fmt.FormatOptions,
	164	writer: anytype,
	165	) !void {
	166	_ = msec;
	167	_ = unused_fmt_string;
	168	_ = options;
	169	_ = writer;
	170	@compileError("do not format directly");
	171	}
	172
	173	pub fn fmt(msec: Section, elf_file: *Elf) std.fmt.Formatter(format2) {
	174	return .{ .data = .{
	175	.msec = msec,
	176	.elf_file = elf_file,
	177	} };
	178	}
	179
	180	const FormatContext = struct {
	181	msec: Section,
	182	elf_file: *Elf,
	183	};
	184
	185	pub fn format2(
	186	ctx: FormatContext,
	187	comptime unused_fmt_string: []const u8,
	188	options: std.fmt.FormatOptions,
	189	writer: anytype,
	190	) !void {
	191	_ = options;
	192	_ = unused_fmt_string;
	193	const msec = ctx.msec;
	194	const elf_file = ctx.elf_file;
	195	try writer.print("{s} : @{x} : size({x}) : align({x}) : entsize({x}) : type({x}) : flags({x})\n", .{
	196	msec.name(elf_file),
	197	msec.address(elf_file),
	198	msec.size,
	199	msec.alignment.toByteUnits() orelse 0,
	200	msec.entsize,
	201	msec.type,
	202	msec.flags,
	203	});
	204	for (msec.subsections.items) \|msub\| {
	205	try writer.print(" {}\n", .{msub.fmt(elf_file)});
	206	}
	207	}
	208
	209	pub const Index = u32;
	210	};
	211
	212	pub const Subsection = struct {
	213	value: i64 = 0,
	214	merge_section_index: Section.Index = 0,
	215	string_index: u32 = 0,
	216	size: u32 = 0,
	217	alignment: Atom.Alignment = .@"1",
	218	entsize: u32 = 0,
	219	alive: bool = false,
	220
	221	pub fn address(msub: Subsection, elf_file: *Elf) i64 {
	222	return msub.mergeSection(elf_file).address(elf_file) + msub.value;
	223	}
	224
	225	pub fn mergeSection(msub: Subsection, elf_file: Elf) Section {
	226	return elf_file.mergeSection(msub.merge_section_index);
	227	}
	228
	229	pub fn getString(msub: Subsection, elf_file: *Elf) []const u8 {
	230	const msec = msub.mergeSection(elf_file);
	231	return msec.bytes.items[msub.string_index..][0..msub.size];
	232	}
	233
	234	pub fn format(
	235	msub: Subsection,
	236	comptime unused_fmt_string: []const u8,
	237	options: std.fmt.FormatOptions,
	238	writer: anytype,
	239	) !void {
	240	_ = msub;
	241	_ = unused_fmt_string;
	242	_ = options;
	243	_ = writer;
	244	@compileError("do not format directly");
	245	}
	246
	247	pub fn fmt(msub: Subsection, elf_file: *Elf) std.fmt.Formatter(format2) {
	248	return .{ .data = .{
	249	.msub = msub,
	250	.elf_file = elf_file,
	251	} };
	252	}
	253
	254	const FormatContext = struct {
	255	msub: Subsection,
	256	elf_file: *Elf,
	257	};
	258
	259	pub fn format2(
	260	ctx: FormatContext,
	261	comptime unused_fmt_string: []const u8,
	262	options: std.fmt.FormatOptions,
	263	writer: anytype,
	264	) !void {
	265	_ = options;
	266	_ = unused_fmt_string;
	267	const msub = ctx.msub;
	268	const elf_file = ctx.elf_file;
	269	try writer.print("@{x} : align({x}) : size({x})", .{
	270	msub.address(elf_file),
	271	msub.alignment,
	272	msub.size,
	273	});
	274	if (!msub.alive) try writer.writeAll(" : [*]");
	275	}
	276
	277	pub const Index = u32;
	278	};
	279
	280	pub const InputSection = struct {
	281	merge_section_index: Section.Index = 0,
	282	atom_index: Atom.Index = 0,
	283	offsets: std.ArrayListUnmanaged(u32) = .empty,
	284	subsections: std.ArrayListUnmanaged(Subsection.Index) = .empty,
	285	bytes: std.ArrayListUnmanaged(u8) = .empty,
	286	strings: std.ArrayListUnmanaged(String) = .empty,
	287
	288	pub fn deinit(imsec: *InputSection, allocator: Allocator) void {
	289	imsec.offsets.deinit(allocator);
	290	imsec.subsections.deinit(allocator);
	291	imsec.bytes.deinit(allocator);
	292	imsec.strings.deinit(allocator);
	293	}
	294
	295	pub fn clearAndFree(imsec: *InputSection, allocator: Allocator) void {
	296	imsec.bytes.clearAndFree(allocator);
	297	// TODO: imsec.strings.clearAndFree(allocator);
	298	}
	299
	300	const FindSubsectionResult = struct {
	301	msub_index: Subsection.Index,
	302	offset: u32,
	303	};
	304
	305	pub fn findSubsection(imsec: InputSection, offset: u32) ?FindSubsectionResult {
	306	// TODO: binary search
	307	for (imsec.offsets.items, 0..) \|off, index\| {
	308	if (offset < off) return .{
	309	.msub_index = imsec.subsections.items[index - 1],
	310	.offset = offset - imsec.offsets.items[index - 1],
	311	};
	312	}
	313	const last = imsec.offsets.items.len - 1;
	314	const last_off = imsec.offsets.items[last];
	315	const last_len = imsec.strings.items[last].len;
	316	if (offset < last_off + last_len) return .{
	317	.msub_index = imsec.subsections.items[last],
	318	.offset = offset - last_off,
	319	};
	320	return null;
	321	}
	322
	323	pub fn insert(imsec: *InputSection, allocator: Allocator, string: []const u8) !void {
	324	const index: u32 = @intCast(imsec.bytes.items.len);
	325	try imsec.bytes.appendSlice(allocator, string);
	326	try imsec.strings.append(allocator, .{ .pos = index, .len = @intCast(string.len) });
	327	}
	328
	329	pub const Index = u32;
	330	};
	331
	332	const String = struct { pos: u32, len: u32 };
	333
	334	const assert = std.debug.assert;
	335	const mem = std.mem;
	336	const std = @import("std");
	337
	338	const Allocator = mem.Allocator;
	339	const Atom = @import("Atom.zig");
	340	const Elf = @import("../Elf.zig");
	341	const Merge = @This();

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

...	...	@@ -23,8 +23,8 @@ atoms_extra: std.ArrayListUnmanaged(u32) = .empty,
23	23	comdat_groups: std.ArrayListUnmanaged(Elf.ComdatGroup) = .empty,
24	24	comdat_group_data: std.ArrayListUnmanaged(u32) = .empty,
25	25
26		input_merge_sections: std.ArrayListUnmanaged(InputMergeSection) = .empty,
27		input_merge_sections_indexes: std.ArrayListUnmanaged(InputMergeSection.Index) = .empty,
	26	input_merge_sections: std.ArrayListUnmanaged(Merge.InputSection) = .empty,
	27	input_merge_sections_indexes: std.ArrayListUnmanaged(Merge.InputSection.Index) = .empty,
28	28
29	29	fdes: std.ArrayListUnmanaged(Fde) = .empty,
30	30	cies: std.ArrayListUnmanaged(Cie) = .empty,
...	...	@@ -927,7 +927,7 @@ pub fn initRelaSections(self: Object, elf_file: Elf) !void {
927	927	for (self.atoms_indexes.items) \|atom_index\| {
928	928	const atom_ptr = self.atom(atom_index) orelse continue;
929	929	if (!atom_ptr.alive) continue;
930		if (atom_ptr.output_section_index == elf_file.eh_frame_section_index) continue;
	930	if (atom_ptr.output_section_index == elf_file.section_indexes.eh_frame) continue;
931	931	const shndx = atom_ptr.relocsShndx() orelse continue;
932	932	const shdr = self.shdrs.items[shndx];
933	933	const out_shndx = try elf_file.initOutputSection(.{
...	...	@@ -947,7 +947,7 @@ pub fn addAtomsToRelaSections(self: Object, elf_file: Elf) !void {
947	947	for (self.atoms_indexes.items) \|atom_index\| {
948	948	const atom_ptr = self.atom(atom_index) orelse continue;
949	949	if (!atom_ptr.alive) continue;
950		if (atom_ptr.output_section_index == elf_file.eh_frame_section_index) continue;
	950	if (atom_ptr.output_section_index == elf_file.section_indexes.eh_frame) continue;
951	951	const shndx = blk: {
952	952	const shndx = atom_ptr.relocsShndx() orelse continue;
953	953	const shdr = self.shdrs.items[shndx];
...	...	@@ -960,7 +960,7 @@ pub fn addAtomsToRelaSections(self: Object, elf_file: Elf) !void {
960	960	const slice = elf_file.sections.slice();
961	961	const shdr = &slice.items(.shdr)[shndx];
962	962	shdr.sh_info = atom_ptr.output_section_index;
963		shdr.sh_link = elf_file.symtab_section_index.?;
	963	shdr.sh_link = elf_file.section_indexes.symtab.?;
964	964	const gpa = elf_file.base.comp.gpa;
965	965	const atom_list = &elf_file.sections.items(.atom_list)[shndx];
966	966	try atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
...	...	@@ -1305,14 +1305,14 @@ fn setAtomFields(o: Object, atom_ptr: Atom, opts: Atom.Extra.AsOptionals) void
1305	1305	o.setAtomExtra(atom_ptr.extra_index, extras);
1306	1306	}
1307	1307
1308		fn addInputMergeSection(self: *Object, allocator: Allocator) !InputMergeSection.Index {
1309		const index: InputMergeSection.Index = @intCast(self.input_merge_sections.items.len);
	1308	fn addInputMergeSection(self: *Object, allocator: Allocator) !Merge.InputSection.Index {
	1309	const index: Merge.InputSection.Index = @intCast(self.input_merge_sections.items.len);
1310	1310	const msec = try self.input_merge_sections.addOne(allocator);
1311	1311	msec.* = .{};
1312	1312	return index;
1313	1313	}
1314	1314
1315		fn inputMergeSection(self: Object, index: InputMergeSection.Index) ?InputMergeSection {
	1315	fn inputMergeSection(self: Object, index: Merge.InputSection.Index) ?Merge.InputSection {
1316	1316	if (index == 0) return null;
1317	1317	return &self.input_merge_sections.items[index];
1318	1318	}
...	...	@@ -1522,6 +1522,6 @@ const Cie = eh_frame.Cie;
1522	1522	const Elf = @import("../Elf.zig");
1523	1523	const Fde = eh_frame.Fde;
1524	1524	const File = @import("file.zig").File;
1525		const InputMergeSection = @import("merge_section.zig").InputMergeSection;
	1525	const Merge = @import("Merge.zig");
1526	1526	const Symbol = @import("Symbol.zig");
1527	1527	const Alignment = Atom.Alignment;

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

...	...	@@ -74,7 +74,7 @@ pub fn atom(symbol: Symbol, elf_file: Elf) ?Atom {
74	74	return file_ptr.atom(symbol.ref.index);
75	75	}
76	76
77		pub fn mergeSubsection(symbol: Symbol, elf_file: Elf) ?MergeSubsection {
	77	pub fn mergeSubsection(symbol: Symbol, elf_file: Elf) ?Merge.Subsection {
78	78	if (!symbol.flags.merge_subsection) return null;
79	79	const msec = elf_file.mergeSection(symbol.ref.file);
80	80	return msec.mergeSubsection(symbol.ref.index);
...	...	@@ -128,7 +128,7 @@ pub fn address(symbol: Symbol, opts: struct { plt: bool = true, trampoline: bool
128	128	if (mem.eql(u8, atom_ptr.name(elf_file), ".eh_frame")) {
129	129	const sym_name = symbol.name(elf_file);
130	130	const sh_addr, const sh_size = blk: {
131		const shndx = elf_file.eh_frame_section_index orelse break :blk .{ 0, 0 };
	131	const shndx = elf_file.section_indexes.eh_frame orelse break :blk .{ 0, 0 };
132	132	const shdr = elf_file.sections.items(.shdr)[shndx];
133	133	break :blk .{ shdr.sh_addr, shdr.sh_size };
134	134	};
...	...	@@ -176,7 +176,7 @@ pub fn gotAddress(symbol: Symbol, elf_file: *Elf) i64 {
176	176	pub fn pltGotAddress(symbol: Symbol, elf_file: *Elf) i64 {
177	177	if (!symbol.flags.has_pltgot) return 0;
178	178	const extras = symbol.extra(elf_file);
179		const shdr = elf_file.sections.items(.shdr)[elf_file.plt_got_section_index.?];
	179	const shdr = elf_file.sections.items(.shdr)[elf_file.section_indexes.plt_got.?];
180	180	const cpu_arch = elf_file.getTarget().cpu.arch;
181	181	return @intCast(shdr.sh_addr + extras.plt_got * PltGotSection.entrySize(cpu_arch));
182	182	}
...	...	@@ -184,7 +184,7 @@ pub fn pltGotAddress(symbol: Symbol, elf_file: *Elf) i64 {
184	184	pub fn pltAddress(symbol: Symbol, elf_file: *Elf) i64 {
185	185	if (!symbol.flags.has_plt) return 0;
186	186	const extras = symbol.extra(elf_file);
187		const shdr = elf_file.sections.items(.shdr)[elf_file.plt_section_index.?];
	187	const shdr = elf_file.sections.items(.shdr)[elf_file.section_indexes.plt.?];
188	188	const cpu_arch = elf_file.getTarget().cpu.arch;
189	189	return @intCast(shdr.sh_addr + extras.plt * PltSection.entrySize(cpu_arch) + PltSection.preambleSize(cpu_arch));
190	190	}
...	...	@@ -192,13 +192,13 @@ pub fn pltAddress(symbol: Symbol, elf_file: *Elf) i64 {
192	192	pub fn gotPltAddress(symbol: Symbol, elf_file: *Elf) i64 {
193	193	if (!symbol.flags.has_plt) return 0;
194	194	const extras = symbol.extra(elf_file);
195		const shdr = elf_file.sections.items(.shdr)[elf_file.got_plt_section_index.?];
	195	const shdr = elf_file.sections.items(.shdr)[elf_file.section_indexes.got_plt.?];
196	196	return @intCast(shdr.sh_addr + extras.plt * 8 + GotPltSection.preamble_size);
197	197	}
198	198
199	199	pub fn copyRelAddress(symbol: Symbol, elf_file: *Elf) i64 {
200	200	if (!symbol.flags.has_copy_rel) return 0;
201		const shdr = elf_file.sections.items(.shdr)[elf_file.copy_rel_section_index.?];
	201	const shdr = elf_file.sections.items(.shdr)[elf_file.section_indexes.copy_rel.?];
202	202	return @as(i64, @intCast(shdr.sh_addr)) + symbol.value;
203	203	}
204	204
...	...	@@ -289,7 +289,7 @@ pub fn setOutputSym(symbol: Symbol, elf_file: Elf, out: elf.Elf64_Sym) void {
289	289	break :blk esym.st_bind();
290	290	};
291	291	const st_shndx: u16 = blk: {
292		if (symbol.flags.has_copy_rel) break :blk @intCast(elf_file.copy_rel_section_index.?);
	292	if (symbol.flags.has_copy_rel) break :blk @intCast(elf_file.section_indexes.copy_rel.?);
293	293	if (file_ptr == .shared_object or esym.st_shndx == elf.SHN_UNDEF) break :blk elf.SHN_UNDEF;
294	294	if (elf_file.base.isRelocatable() and esym.st_shndx == elf.SHN_COMMON) break :blk elf.SHN_COMMON;
295	295	if (symbol.mergeSubsection(elf_file)) \|msub\| break :blk @intCast(msub.mergeSection(elf_file).output_section_index);
...	...	@@ -493,7 +493,7 @@ const File = @import("file.zig").File;
493	493	const GotSection = synthetic_sections.GotSection;
494	494	const GotPltSection = synthetic_sections.GotPltSection;
495	495	const LinkerDefined = @import("LinkerDefined.zig");
496		const MergeSubsection = @import("merge_section.zig").MergeSubsection;
	496	const Merge = @import("Merge.zig");
497	497	const Object = @import("Object.zig");
498	498	const PltSection = synthetic_sections.PltSection;
499	499	const PltGotSection = synthetic_sections.PltGotSection;

src/link/Elf/ZigObject.zig+4-4

...	...	@@ -791,7 +791,7 @@ pub fn initRelaSections(self: ZigObject, elf_file: Elf) !void {
791	791	for (self.atoms_indexes.items) \|atom_index\| {
792	792	const atom_ptr = self.atom(atom_index) orelse continue;
793	793	if (!atom_ptr.alive) continue;
794		if (atom_ptr.output_section_index == elf_file.eh_frame_section_index) continue;
	794	if (atom_ptr.output_section_index == elf_file.section_indexes.eh_frame) continue;
795	795	const rela_shndx = atom_ptr.relocsShndx() orelse continue;
796	796	// TODO this check will become obsolete when we rework our relocs mechanism at the ZigObject level
797	797	if (self.relocs.items[rela_shndx].items.len == 0) continue;
...	...	@@ -812,7 +812,7 @@ pub fn addAtomsToRelaSections(self: ZigObject, elf_file: Elf) !void {
812	812	for (self.atoms_indexes.items) \|atom_index\| {
813	813	const atom_ptr = self.atom(atom_index) orelse continue;
814	814	if (!atom_ptr.alive) continue;
815		if (atom_ptr.output_section_index == elf_file.eh_frame_section_index) continue;
	815	if (atom_ptr.output_section_index == elf_file.section_indexes.eh_frame) continue;
816	816	const rela_shndx = atom_ptr.relocsShndx() orelse continue;
817	817	// TODO this check will become obsolete when we rework our relocs mechanism at the ZigObject level
818	818	if (self.relocs.items[rela_shndx].items.len == 0) continue;
...	...	@@ -826,7 +826,7 @@ pub fn addAtomsToRelaSections(self: ZigObject, elf_file: Elf) !void {
826	826	const out_rela_shndx = elf_file.sectionByName(rela_sect_name).?;
827	827	const out_rela_shdr = &elf_file.sections.items(.shdr)[out_rela_shndx];
828	828	out_rela_shdr.sh_info = out_shndx;
829		out_rela_shdr.sh_link = elf_file.symtab_section_index.?;
	829	out_rela_shdr.sh_link = elf_file.section_indexes.symtab.?;
830	830	const atom_list = &elf_file.sections.items(.atom_list)[out_rela_shndx];
831	831	try atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
832	832	}
...	...	@@ -2027,7 +2027,7 @@ pub fn allocateAtom(self: ZigObject, atom_ptr: Atom, requires_padding: bool, e
2027	2027	log.debug(" prev {?}, next {?}", .{ atom_ptr.prev_atom_ref, atom_ptr.next_atom_ref });
2028	2028	}
2029	2029
2030		pub fn resetShdrIndexes(self: *ZigObject, backlinks: anytype) void {
	2030	pub fn resetShdrIndexes(self: *ZigObject, backlinks: []const u32) void {
2031	2031	for (self.atoms_indexes.items) \|atom_index\| {
2032	2032	const atom_ptr = self.atom(atom_index) orelse continue;
2033	2033	atom_ptr.output_section_index = backlinks[atom_ptr.output_section_index];

src/link/Elf/eh_frame.zig+6-6

...	...	@@ -12,7 +12,7 @@ pub const Fde = struct {
12	12	out_offset: u64 = 0,
13	13
14	14	pub fn address(fde: Fde, elf_file: *Elf) u64 {
15		const base: u64 = if (elf_file.eh_frame_section_index) \|shndx\|
	15	const base: u64 = if (elf_file.section_indexes.eh_frame) \|shndx\|
16	16	elf_file.sections.items(.shdr)[shndx].sh_addr
17	17	else
18	18	0;
...	...	@@ -111,7 +111,7 @@ pub const Cie = struct {
111	111	alive: bool = false,
112	112
113	113	pub fn address(cie: Cie, elf_file: *Elf) u64 {
114		const base: u64 = if (elf_file.eh_frame_section_index) \|shndx\|
	114	const base: u64 = if (elf_file.section_indexes.eh_frame) \|shndx\|
115	115	elf_file.sections.items(.shdr)[shndx].sh_addr
116	116	else
117	117	0;
...	...	@@ -337,7 +337,7 @@ fn resolveReloc(rec: anytype, sym: *const Symbol, rel: elf.Elf64_Rela, elf_file:
337	337
338	338	pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void {
339	339	relocs_log.debug("{x}: .eh_frame", .{
340		elf_file.sections.items(.shdr)[elf_file.eh_frame_section_index.?].sh_addr,
	340	elf_file.sections.items(.shdr)[elf_file.section_indexes.eh_frame.?].sh_addr,
341	341	});
342	342
343	343	var has_reloc_errors = false;
...	...	@@ -458,7 +458,7 @@ fn emitReloc(elf_file: Elf, r_offset: u64, sym: const Symbol, rel: elf.Elf64_R
458	458
459	459	pub fn writeEhFrameRelocs(elf_file: *Elf, writer: anytype) !void {
460	460	relocs_log.debug("{x}: .eh_frame", .{
461		elf_file.sections.items(.shdr)[elf_file.eh_frame_section_index.?].sh_addr,
	461	elf_file.sections.items(.shdr)[elf_file.section_indexes.eh_frame.?].sh_addr,
462	462	});
463	463
464	464	if (elf_file.zigObjectPtr()) \|zo\| zo: {
...	...	@@ -511,8 +511,8 @@ pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void {
511	511	try writer.writeByte(DW_EH_PE.datarel \| DW_EH_PE.sdata4);
512	512
513	513	const shdrs = elf_file.sections.items(.shdr);
514		const eh_frame_shdr = shdrs[elf_file.eh_frame_section_index.?];
515		const eh_frame_hdr_shdr = shdrs[elf_file.eh_frame_hdr_section_index.?];
	514	const eh_frame_shdr = shdrs[elf_file.section_indexes.eh_frame.?];
	515	const eh_frame_hdr_shdr = shdrs[elf_file.section_indexes.eh_frame_hdr.?];
516	516	const num_fdes = @as(u32, @intCast(@divExact(eh_frame_hdr_shdr.sh_size - eh_frame_hdr_header_size, 8)));
517	517	const existing_size = existing_size: {
518	518	const zo = elf_file.zigObjectPtr() orelse break :existing_size 0;

src/link/Elf/merge_section.zig deleted-340

...	...	@@ -1,340 +0,0 @@
1		pub const MergeSection = struct {
2		value: u64 = 0,
3		size: u64 = 0,
4		alignment: Atom.Alignment = .@"1",
5		entsize: u32 = 0,
6		name_offset: u32 = 0,
7		type: u32 = 0,
8		flags: u64 = 0,
9		output_section_index: u32 = 0,
10		bytes: std.ArrayListUnmanaged(u8) = .empty,
11		table: std.HashMapUnmanaged(
12		String,
13		MergeSubsection.Index,
14		IndexContext,
15		std.hash_map.default_max_load_percentage,
16		) = .{},
17		subsections: std.ArrayListUnmanaged(MergeSubsection) = .empty,
18		finalized_subsections: std.ArrayListUnmanaged(MergeSubsection.Index) = .empty,
19
20		pub fn deinit(msec: *MergeSection, allocator: Allocator) void {
21		msec.bytes.deinit(allocator);
22		msec.table.deinit(allocator);
23		msec.subsections.deinit(allocator);
24		msec.finalized_subsections.deinit(allocator);
25		}
26
27		pub fn name(msec: MergeSection, elf_file: *Elf) [:0]const u8 {
28		return elf_file.getShString(msec.name_offset);
29		}
30
31		pub fn address(msec: MergeSection, elf_file: *Elf) i64 {
32		const shdr = elf_file.sections.items(.shdr)[msec.output_section_index];
33		return @intCast(shdr.sh_addr + msec.value);
34		}
35
36		const InsertResult = struct {
37		found_existing: bool,
38		key: String,
39		sub: *MergeSubsection.Index,
40		};
41
42		pub fn insert(msec: *MergeSection, allocator: Allocator, string: []const u8) !InsertResult {
43		const gop = try msec.table.getOrPutContextAdapted(
44		allocator,
45		string,
46		IndexAdapter{ .bytes = msec.bytes.items },
47		IndexContext{ .bytes = msec.bytes.items },
48		);
49		if (!gop.found_existing) {
50		const index: u32 = @intCast(msec.bytes.items.len);
51		try msec.bytes.appendSlice(allocator, string);
52		gop.key_ptr.* = .{ .pos = index, .len = @intCast(string.len) };
53		}
54		return .{ .found_existing = gop.found_existing, .key = gop.key_ptr.*, .sub = gop.value_ptr };
55		}
56
57		pub fn insertZ(msec: *MergeSection, allocator: Allocator, string: []const u8) !InsertResult {
58		const with_null = try allocator.alloc(u8, string.len + 1);
59		defer allocator.free(with_null);
60		@memcpy(with_null[0..string.len], string);
61		with_null[string.len] = 0;
62		return msec.insert(allocator, with_null);
63		}
64
65		/// Finalizes the merge section and clears hash table.
66		/// Sorts all owned subsections.
67		pub fn finalize(msec: *MergeSection, allocator: Allocator) !void {
68		try msec.finalized_subsections.ensureTotalCapacityPrecise(allocator, msec.subsections.items.len);
69
70		var it = msec.table.iterator();
71		while (it.next()) \|entry\| {
72		const msub = msec.mergeSubsection(entry.value_ptr.*);
73		if (!msub.alive) continue;
74		msec.finalized_subsections.appendAssumeCapacity(entry.value_ptr.*);
75		}
76		msec.table.clearAndFree(allocator);
77
78		const sortFn = struct {
79		pub fn sortFn(ctx: *MergeSection, lhs: MergeSubsection.Index, rhs: MergeSubsection.Index) bool {
80		const lhs_msub = ctx.mergeSubsection(lhs);
81		const rhs_msub = ctx.mergeSubsection(rhs);
82		if (lhs_msub.alignment.compareStrict(.eq, rhs_msub.alignment)) {
83		if (lhs_msub.size == rhs_msub.size) {
84		const lhs_string = ctx.bytes.items[lhs_msub.string_index..][0..lhs_msub.size];
85		const rhs_string = ctx.bytes.items[rhs_msub.string_index..][0..rhs_msub.size];
86		return mem.order(u8, lhs_string, rhs_string) == .lt;
87		}
88		return lhs_msub.size < rhs_msub.size;
89		}
90		return lhs_msub.alignment.compareStrict(.lt, rhs_msub.alignment);
91		}
92		}.sortFn;
93
94		std.mem.sort(MergeSubsection.Index, msec.finalized_subsections.items, msec, sortFn);
95		}
96
97		pub fn updateSize(msec: *MergeSection) void {
98		// TODO a 'stale' flag would be better here perhaps?
99		msec.size = 0;
100		msec.alignment = .@"1";
101		msec.entsize = 0;
102		for (msec.finalized_subsections.items) \|msub_index\| {
103		const msub = msec.mergeSubsection(msub_index);
104		assert(msub.alive);
105		const offset = msub.alignment.forward(msec.size);
106		const padding = offset - msec.size;
107		msub.value = @intCast(offset);
108		msec.size += padding + msub.size;
109		msec.alignment = msec.alignment.max(msub.alignment);
110		msec.entsize = if (msec.entsize == 0) msub.entsize else @min(msec.entsize, msub.entsize);
111		}
112		}
113
114		pub fn initOutputSection(msec: MergeSection, elf_file: Elf) !void {
115		msec.output_section_index = elf_file.sectionByName(msec.name(elf_file)) orelse try elf_file.addSection(.{
116		.name = msec.name_offset,
117		.type = msec.type,
118		.flags = msec.flags,
119		});
120		}
121
122		pub fn addMergeSubsection(msec: *MergeSection, allocator: Allocator) !MergeSubsection.Index {
123		const index: MergeSubsection.Index = @intCast(msec.subsections.items.len);
124		const msub = try msec.subsections.addOne(allocator);
125		msub.* = .{};
126		return index;
127		}
128
129		pub fn mergeSubsection(msec: MergeSection, index: MergeSubsection.Index) MergeSubsection {
130		assert(index < msec.subsections.items.len);
131		return &msec.subsections.items[index];
132		}
133
134		pub const IndexContext = struct {
135		bytes: []const u8,
136
137		pub fn eql(_: @This(), a: String, b: String) bool {
138		return a.pos == b.pos;
139		}
140
141		pub fn hash(ctx: @This(), key: String) u64 {
142		const str = ctx.bytes[key.pos..][0..key.len];
143		return std.hash_map.hashString(str);
144		}
145		};
146
147		pub const IndexAdapter = struct {
148		bytes: []const u8,
149
150		pub fn eql(ctx: @This(), a: []const u8, b: String) bool {
151		const str = ctx.bytes[b.pos..][0..b.len];
152		return mem.eql(u8, a, str);
153		}
154
155		pub fn hash(_: @This(), adapted_key: []const u8) u64 {
156		return std.hash_map.hashString(adapted_key);
157		}
158		};
159
160		pub fn format(
161		msec: MergeSection,
162		comptime unused_fmt_string: []const u8,
163		options: std.fmt.FormatOptions,
164		writer: anytype,
165		) !void {
166		_ = msec;
167		_ = unused_fmt_string;
168		_ = options;
169		_ = writer;
170		@compileError("do not format MergeSection directly");
171		}
172
173		pub fn fmt(msec: MergeSection, elf_file: *Elf) std.fmt.Formatter(format2) {
174		return .{ .data = .{
175		.msec = msec,
176		.elf_file = elf_file,
177		} };
178		}
179
180		const FormatContext = struct {
181		msec: MergeSection,
182		elf_file: *Elf,
183		};
184
185		pub fn format2(
186		ctx: FormatContext,
187		comptime unused_fmt_string: []const u8,
188		options: std.fmt.FormatOptions,
189		writer: anytype,
190		) !void {
191		_ = options;
192		_ = unused_fmt_string;
193		const msec = ctx.msec;
194		const elf_file = ctx.elf_file;
195		try writer.print("{s} : @{x} : size({x}) : align({x}) : entsize({x}) : type({x}) : flags({x})\n", .{
196		msec.name(elf_file),
197		msec.address(elf_file),
198		msec.size,
199		msec.alignment.toByteUnits() orelse 0,
200		msec.entsize,
201		msec.type,
202		msec.flags,
203		});
204		for (msec.subsections.items) \|msub\| {
205		try writer.print(" {}\n", .{msub.fmt(elf_file)});
206		}
207		}
208
209		pub const Index = u32;
210		};
211
212		pub const MergeSubsection = struct {
213		value: i64 = 0,
214		merge_section_index: MergeSection.Index = 0,
215		string_index: u32 = 0,
216		size: u32 = 0,
217		alignment: Atom.Alignment = .@"1",
218		entsize: u32 = 0,
219		alive: bool = false,
220
221		pub fn address(msub: MergeSubsection, elf_file: *Elf) i64 {
222		return msub.mergeSection(elf_file).address(elf_file) + msub.value;
223		}
224
225		pub fn mergeSection(msub: MergeSubsection, elf_file: Elf) MergeSection {
226		return elf_file.mergeSection(msub.merge_section_index);
227		}
228
229		pub fn getString(msub: MergeSubsection, elf_file: *Elf) []const u8 {
230		const msec = msub.mergeSection(elf_file);
231		return msec.bytes.items[msub.string_index..][0..msub.size];
232		}
233
234		pub fn format(
235		msub: MergeSubsection,
236		comptime unused_fmt_string: []const u8,
237		options: std.fmt.FormatOptions,
238		writer: anytype,
239		) !void {
240		_ = msub;
241		_ = unused_fmt_string;
242		_ = options;
243		_ = writer;
244		@compileError("do not format MergeSubsection directly");
245		}
246
247		pub fn fmt(msub: MergeSubsection, elf_file: *Elf) std.fmt.Formatter(format2) {
248		return .{ .data = .{
249		.msub = msub,
250		.elf_file = elf_file,
251		} };
252		}
253
254		const FormatContext = struct {
255		msub: MergeSubsection,
256		elf_file: *Elf,
257		};
258
259		pub fn format2(
260		ctx: FormatContext,
261		comptime unused_fmt_string: []const u8,
262		options: std.fmt.FormatOptions,
263		writer: anytype,
264		) !void {
265		_ = options;
266		_ = unused_fmt_string;
267		const msub = ctx.msub;
268		const elf_file = ctx.elf_file;
269		try writer.print("@{x} : align({x}) : size({x})", .{
270		msub.address(elf_file),
271		msub.alignment,
272		msub.size,
273		});
274		if (!msub.alive) try writer.writeAll(" : [*]");
275		}
276
277		pub const Index = u32;
278		};
279
280		pub const InputMergeSection = struct {
281		merge_section_index: MergeSection.Index = 0,
282		atom_index: Atom.Index = 0,
283		offsets: std.ArrayListUnmanaged(u32) = .empty,
284		subsections: std.ArrayListUnmanaged(MergeSubsection.Index) = .empty,
285		bytes: std.ArrayListUnmanaged(u8) = .empty,
286		strings: std.ArrayListUnmanaged(String) = .empty,
287
288		pub fn deinit(imsec: *InputMergeSection, allocator: Allocator) void {
289		imsec.offsets.deinit(allocator);
290		imsec.subsections.deinit(allocator);
291		imsec.bytes.deinit(allocator);
292		imsec.strings.deinit(allocator);
293		}
294
295		pub fn clearAndFree(imsec: *InputMergeSection, allocator: Allocator) void {
296		imsec.bytes.clearAndFree(allocator);
297		// TODO: imsec.strings.clearAndFree(allocator);
298		}
299
300		const FindSubsectionResult = struct {
301		msub_index: MergeSubsection.Index,
302		offset: u32,
303		};
304
305		pub fn findSubsection(imsec: InputMergeSection, offset: u32) ?FindSubsectionResult {
306		// TODO: binary search
307		for (imsec.offsets.items, 0..) \|off, index\| {
308		if (offset < off) return .{
309		.msub_index = imsec.subsections.items[index - 1],
310		.offset = offset - imsec.offsets.items[index - 1],
311		};
312		}
313		const last = imsec.offsets.items.len - 1;
314		const last_off = imsec.offsets.items[last];
315		const last_len = imsec.strings.items[last].len;
316		if (offset < last_off + last_len) return .{
317		.msub_index = imsec.subsections.items[last],
318		.offset = offset - last_off,
319		};
320		return null;
321		}
322
323		pub fn insert(imsec: *InputMergeSection, allocator: Allocator, string: []const u8) !void {
324		const index: u32 = @intCast(imsec.bytes.items.len);
325		try imsec.bytes.appendSlice(allocator, string);
326		try imsec.strings.append(allocator, .{ .pos = index, .len = @intCast(string.len) });
327		}
328
329		pub const Index = u32;
330		};
331
332		const String = struct { pos: u32, len: u32 };
333
334		const assert = std.debug.assert;
335		const mem = std.mem;
336		const std = @import("std");
337
338		const Allocator = mem.Allocator;
339		const Atom = @import("Atom.zig");
340		const Elf = @import("../Elf.zig");

src/link/Elf/relocatable.zig+31-13

...	...	@@ -32,7 +32,16 @@ pub fn flushStaticLib(elf_file: Elf, comp: Compilation, module_obj_path: ?Path
32	32	zig_object.claimUnresolvedRelocatable(elf_file);
33	33
34	34	try initSections(elf_file);
35		try elf_file.sortShdrs();
	35	try Elf.sortShdrs(
	36	gpa,
	37	&elf_file.section_indexes,
	38	&elf_file.sections,
	39	elf_file.shstrtab.items,
	40	elf_file.merge_sections.items,
	41	elf_file.comdat_group_sections.items,
	42	elf_file.zigObjectPtr(),
	43	elf_file.files,
	44	);
36	45	try zig_object.addAtomsToRelaSections(elf_file);
37	46	try elf_file.updateMergeSectionSizes();
38	47	try updateSectionSizes(elf_file);
...	...	@@ -171,7 +180,16 @@ pub fn flushObject(elf_file: Elf, comp: Compilation, module_obj_path: ?Path) l
171	180	claimUnresolved(elf_file);
172	181
173	182	try initSections(elf_file);
174		try elf_file.sortShdrs();
	183	try Elf.sortShdrs(
	184	comp.gpa,
	185	&elf_file.section_indexes,
	186	&elf_file.sections,
	187	elf_file.shstrtab.items,
	188	elf_file.merge_sections.items,
	189	elf_file.comdat_group_sections.items,
	190	elf_file.zigObjectPtr(),
	191	elf_file.files,
	192	);
175	193	if (elf_file.zigObjectPtr()) \|zig_object\| {
176	194	try zig_object.addAtomsToRelaSections(elf_file);
177	195	}
...	...	@@ -288,8 +306,8 @@ fn initSections(elf_file: *Elf) !void {
288	306	} else false;
289	307	};
290	308	if (needs_eh_frame) {
291		if (elf_file.eh_frame_section_index == null) {
292		elf_file.eh_frame_section_index = elf_file.sectionByName(".eh_frame") orelse
	309	if (elf_file.section_indexes.eh_frame == null) {
	310	elf_file.section_indexes.eh_frame = elf_file.sectionByName(".eh_frame") orelse
293	311	try elf_file.addSection(.{
294	312	.name = try elf_file.insertShString(".eh_frame"),
295	313	.type = if (elf_file.getTarget().cpu.arch == .x86_64)
...	...	@@ -300,10 +318,10 @@ fn initSections(elf_file: *Elf) !void {
300	318	.addralign = elf_file.ptrWidthBytes(),
301	319	});
302	320	}
303		elf_file.eh_frame_rela_section_index = elf_file.sectionByName(".rela.eh_frame") orelse
	321	elf_file.section_indexes.eh_frame_rela = elf_file.sectionByName(".rela.eh_frame") orelse
304	322	try elf_file.addRelaShdr(
305	323	try elf_file.insertShString(".rela.eh_frame"),
306		elf_file.eh_frame_section_index.?,
	324	elf_file.section_indexes.eh_frame.?,
307	325	);
308	326	}
309	327
...	...	@@ -346,7 +364,7 @@ fn updateSectionSizes(elf_file: *Elf) !void {
346	364	for (slice.items(.shdr), 0..) \|*shdr, shndx\| {
347	365	const atom_list = slice.items(.atom_list)[shndx];
348	366	if (shdr.sh_type != elf.SHT_RELA) continue;
349		if (@as(u32, @intCast(shndx)) == elf_file.eh_frame_section_index) continue;
	367	if (@as(u32, @intCast(shndx)) == elf_file.section_indexes.eh_frame) continue;
350	368	for (atom_list.items) \|ref\| {
351	369	const atom_ptr = elf_file.atom(ref) orelse continue;
352	370	if (!atom_ptr.alive) continue;
...	...	@@ -357,10 +375,10 @@ fn updateSectionSizes(elf_file: *Elf) !void {
357	375	if (shdr.sh_size == 0) shdr.sh_offset = 0;
358	376	}
359	377
360		if (elf_file.eh_frame_section_index) \|index\| {
	378	if (elf_file.section_indexes.eh_frame) \|index\| {
361	379	slice.items(.shdr)[index].sh_size = try eh_frame.calcEhFrameSize(elf_file);
362	380	}
363		if (elf_file.eh_frame_rela_section_index) \|index\| {
	381	if (elf_file.section_indexes.eh_frame_rela) \|index\| {
364	382	const shdr = &slice.items(.shdr)[index];
365	383	shdr.sh_size = eh_frame.calcEhFrameRelocs(elf_file) * shdr.sh_entsize;
366	384	}
...	...	@@ -374,7 +392,7 @@ fn updateComdatGroupsSizes(elf_file: *Elf) void {
374	392	for (elf_file.comdat_group_sections.items) \|cg\| {
375	393	const shdr = &elf_file.sections.items(.shdr)[cg.shndx];
376	394	shdr.sh_size = cg.size(elf_file);
377		shdr.sh_link = elf_file.symtab_section_index.?;
	395	shdr.sh_link = elf_file.section_indexes.symtab.?;
378	396
379	397	const sym = cg.symbol(elf_file);
380	398	shdr.sh_info = sym.outputSymtabIndex(elf_file) orelse sym.outputShndx(elf_file).?;
...	...	@@ -439,7 +457,7 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
439	457	for (slice.items(.shdr), slice.items(.atom_list), 0..) \|shdr, atom_list, shndx\| {
440	458	if (shdr.sh_type != elf.SHT_RELA) continue;
441	459	if (atom_list.items.len == 0) continue;
442		if (@as(u32, @intCast(shndx)) == elf_file.eh_frame_section_index) continue;
	460	if (@as(u32, @intCast(shndx)) == elf_file.section_indexes.eh_frame) continue;
443	461
444	462	const num_relocs = math.cast(usize, @divExact(shdr.sh_size, shdr.sh_entsize)) orelse
445	463	return error.Overflow;
...	...	@@ -471,7 +489,7 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
471	489	try elf_file.base.file.?.pwriteAll(mem.sliceAsBytes(relocs.items), shdr.sh_offset);
472	490	}
473	491
474		if (elf_file.eh_frame_section_index) \|shndx\| {
	492	if (elf_file.section_indexes.eh_frame) \|shndx\| {
475	493	const existing_size = existing_size: {
476	494	const zo = elf_file.zigObjectPtr() orelse break :existing_size 0;
477	495	const sym = zo.symbol(zo.eh_frame_index orelse break :existing_size 0);
...	...	@@ -489,7 +507,7 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
489	507	assert(buffer.items.len == sh_size - existing_size);
490	508	try elf_file.base.file.?.pwriteAll(buffer.items, shdr.sh_offset + existing_size);
491	509	}
492		if (elf_file.eh_frame_rela_section_index) \|shndx\| {
	510	if (elf_file.section_indexes.eh_frame_rela) \|shndx\| {
493	511	const shdr = slice.items(.shdr)[shndx];
494	512	const sh_size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;
495	513	var buffer = try std.ArrayList(u8).initCapacity(gpa, sh_size);

src/link/Elf/synthetic_sections.zig+27-27

...	...	@@ -75,18 +75,18 @@ pub const DynamicSection = struct {
75	75	if (elf_file.sectionByName(".fini") != null) nentries += 1; // FINI
76	76	if (elf_file.sectionByName(".init_array") != null) nentries += 2; // INIT_ARRAY
77	77	if (elf_file.sectionByName(".fini_array") != null) nentries += 2; // FINI_ARRAY
78		if (elf_file.rela_dyn_section_index != null) nentries += 3; // RELA
79		if (elf_file.rela_plt_section_index != null) nentries += 3; // JMPREL
80		if (elf_file.got_plt_section_index != null) nentries += 1; // PLTGOT
	78	if (elf_file.section_indexes.rela_dyn != null) nentries += 3; // RELA
	79	if (elf_file.section_indexes.rela_plt != null) nentries += 3; // JMPREL
	80	if (elf_file.section_indexes.got_plt != null) nentries += 1; // PLTGOT
81	81	nentries += 1; // HASH
82		if (elf_file.gnu_hash_section_index != null) nentries += 1; // GNU_HASH
	82	if (elf_file.section_indexes.gnu_hash != null) nentries += 1; // GNU_HASH
83	83	if (elf_file.has_text_reloc) nentries += 1; // TEXTREL
84	84	nentries += 1; // SYMTAB
85	85	nentries += 1; // SYMENT
86	86	nentries += 1; // STRTAB
87	87	nentries += 1; // STRSZ
88		if (elf_file.versym_section_index != null) nentries += 1; // VERSYM
89		if (elf_file.verneed_section_index != null) nentries += 2; // VERNEED
	88	if (elf_file.section_indexes.versym != null) nentries += 1; // VERSYM
	89	if (elf_file.section_indexes.verneed != null) nentries += 2; // VERNEED
90	90	if (dt.getFlags(elf_file) != null) nentries += 1; // FLAGS
91	91	if (dt.getFlags1(elf_file) != null) nentries += 1; // FLAGS_1
92	92	if (!elf_file.isEffectivelyDynLib()) nentries += 1; // DEBUG
...	...	@@ -139,7 +139,7 @@ pub const DynamicSection = struct {
139	139	}
140	140
141	141	// RELA
142		if (elf_file.rela_dyn_section_index) \|shndx\| {
	142	if (elf_file.section_indexes.rela_dyn) \|shndx\| {
143	143	const shdr = shdrs[shndx];
144	144	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_RELA, .d_val = shdr.sh_addr });
145	145	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_RELASZ, .d_val = shdr.sh_size });
...	...	@@ -147,7 +147,7 @@ pub const DynamicSection = struct {
147	147	}
148	148
149	149	// JMPREL
150		if (elf_file.rela_plt_section_index) \|shndx\| {
	150	if (elf_file.section_indexes.rela_plt) \|shndx\| {
151	151	const shdr = shdrs[shndx];
152	152	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_JMPREL, .d_val = shdr.sh_addr });
153	153	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_PLTRELSZ, .d_val = shdr.sh_size });
...	...	@@ -155,18 +155,18 @@ pub const DynamicSection = struct {
155	155	}
156	156
157	157	// PLTGOT
158		if (elf_file.got_plt_section_index) \|shndx\| {
	158	if (elf_file.section_indexes.got_plt) \|shndx\| {
159	159	const addr = shdrs[shndx].sh_addr;
160	160	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_PLTGOT, .d_val = addr });
161	161	}
162	162
163	163	{
164		assert(elf_file.hash_section_index != null);
165		const addr = shdrs[elf_file.hash_section_index.?].sh_addr;
	164	assert(elf_file.section_indexes.hash != null);
	165	const addr = shdrs[elf_file.section_indexes.hash.?].sh_addr;
166	166	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_HASH, .d_val = addr });
167	167	}
168	168
169		if (elf_file.gnu_hash_section_index) \|shndx\| {
	169	if (elf_file.section_indexes.gnu_hash) \|shndx\| {
170	170	const addr = shdrs[shndx].sh_addr;
171	171	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_GNU_HASH, .d_val = addr });
172	172	}
...	...	@@ -178,28 +178,28 @@ pub const DynamicSection = struct {
178	178
179	179	// SYMTAB + SYMENT
180	180	{
181		assert(elf_file.dynsymtab_section_index != null);
182		const shdr = shdrs[elf_file.dynsymtab_section_index.?];
	181	assert(elf_file.section_indexes.dynsymtab != null);
	182	const shdr = shdrs[elf_file.section_indexes.dynsymtab.?];
183	183	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_SYMTAB, .d_val = shdr.sh_addr });
184	184	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_SYMENT, .d_val = shdr.sh_entsize });
185	185	}
186	186
187	187	// STRTAB + STRSZ
188	188	{
189		assert(elf_file.dynstrtab_section_index != null);
190		const shdr = shdrs[elf_file.dynstrtab_section_index.?];
	189	assert(elf_file.section_indexes.dynstrtab != null);
	190	const shdr = shdrs[elf_file.section_indexes.dynstrtab.?];
191	191	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_STRTAB, .d_val = shdr.sh_addr });
192	192	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_STRSZ, .d_val = shdr.sh_size });
193	193	}
194	194
195	195	// VERSYM
196		if (elf_file.versym_section_index) \|shndx\| {
	196	if (elf_file.section_indexes.versym) \|shndx\| {
197	197	const addr = shdrs[shndx].sh_addr;
198	198	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_VERSYM, .d_val = addr });
199	199	}
200	200
201	201	// VERNEED + VERNEEDNUM
202		if (elf_file.verneed_section_index) \|shndx\| {
	202	if (elf_file.section_indexes.verneed) \|shndx\| {
203	203	const addr = shdrs[shndx].sh_addr;
204	204	try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_VERNEED, .d_val = addr });
205	205	try writer.writeStruct(elf.Elf64_Dyn{
...	...	@@ -261,7 +261,7 @@ pub const GotSection = struct {
261	261
262	262	pub fn address(entry: Entry, elf_file: *Elf) i64 {
263	263	const ptr_bytes = elf_file.archPtrWidthBytes();
264		const shdr = &elf_file.sections.items(.shdr)[elf_file.got_section_index.?];
	264	const shdr = &elf_file.sections.items(.shdr)[elf_file.section_indexes.got.?];
265	265	return @as(i64, @intCast(shdr.sh_addr)) + entry.cell_index * ptr_bytes;
266	266	}
267	267	};
...	...	@@ -599,7 +599,7 @@ pub const GotSection = struct {
599	599	.st_name = st_name,
600	600	.st_info = elf.STT_OBJECT,
601	601	.st_other = 0,
602		.st_shndx = @intCast(elf_file.got_section_index.?),
	602	.st_shndx = @intCast(elf_file.section_indexes.got.?),
603	603	.st_value = @intCast(st_value),
604	604	.st_size = st_size,
605	605	};
...	...	@@ -742,7 +742,7 @@ pub const PltSection = struct {
742	742	.st_name = st_name,
743	743	.st_info = elf.STT_FUNC,
744	744	.st_other = 0,
745		.st_shndx = @intCast(elf_file.plt_section_index.?),
	745	.st_shndx = @intCast(elf_file.section_indexes.plt.?),
746	746	.st_value = @intCast(sym.pltAddress(elf_file)),
747	747	.st_size = entrySize(cpu_arch),
748	748	};
...	...	@@ -784,8 +784,8 @@ pub const PltSection = struct {
784	784	const x86_64 = struct {
785	785	fn write(plt: PltSection, elf_file: *Elf, writer: anytype) !void {
786	786	const shdrs = elf_file.sections.items(.shdr);
787		const plt_addr = shdrs[elf_file.plt_section_index.?].sh_addr;
788		const got_plt_addr = shdrs[elf_file.got_plt_section_index.?].sh_addr;
	787	const plt_addr = shdrs[elf_file.section_indexes.plt.?].sh_addr;
	788	const got_plt_addr = shdrs[elf_file.section_indexes.got_plt.?].sh_addr;
789	789	var preamble = [_]u8{
790	790	0xf3, 0x0f, 0x1e, 0xfa, // endbr64
791	791	0x41, 0x53, // push r11
...	...	@@ -820,8 +820,8 @@ pub const PltSection = struct {
820	820	fn write(plt: PltSection, elf_file: *Elf, writer: anytype) !void {
821	821	{
822	822	const shdrs = elf_file.sections.items(.shdr);
823		const plt_addr: i64 = @intCast(shdrs[elf_file.plt_section_index.?].sh_addr);
824		const got_plt_addr: i64 = @intCast(shdrs[elf_file.got_plt_section_index.?].sh_addr);
	823	const plt_addr: i64 = @intCast(shdrs[elf_file.section_indexes.plt.?].sh_addr);
	824	const got_plt_addr: i64 = @intCast(shdrs[elf_file.section_indexes.got_plt.?].sh_addr);
825	825	// TODO: relax if possible
826	826	// .got.plt[2]
827	827	const pages = try aarch64_util.calcNumberOfPages(plt_addr + 4, got_plt_addr + 16);
...	...	@@ -894,7 +894,7 @@ pub const GotPltSection = struct {
894	894	// [2]: 0x0
895	895	try writer.writeInt(u64, 0x0, .little);
896	896	try writer.writeInt(u64, 0x0, .little);
897		if (elf_file.plt_section_index) \|shndx\| {
	897	if (elf_file.section_indexes.plt) \|shndx\| {
898	898	const plt_addr = elf_file.sections.items(.shdr)[shndx].sh_addr;
899	899	for (0..elf_file.plt.symbols.items.len) \|_\| {
900	900	// [N]: .plt
...	...	@@ -962,7 +962,7 @@ pub const PltGotSection = struct {
962	962	.st_name = st_name,
963	963	.st_info = elf.STT_FUNC,
964	964	.st_other = 0,
965		.st_shndx = @intCast(elf_file.plt_got_section_index.?),
	965	.st_shndx = @intCast(elf_file.section_indexes.plt_got.?),
966	966	.st_value = @intCast(sym.pltGotAddress(elf_file)),
967	967	.st_size = 16,
968	968	};