Commit f3309a96a7d8061f944590577c2b6c58e4cf6637 | zig

author	Jacob Young <jacobly@ziglang.org> 2025-11-10 00:10:17-05:00
committer	GitHub <noreply@github.com> 2025-11-10 00:10:17-05:00
log	f3309a96a7d8061f944590577c2b6c58e4cf6637
tree	bf0e1ea69f9a088f590316fc13c74ec22aef32ce
parent	bdbfc7de3fd3a05f338ec8beaa29894547a9df4c
parent	57889cae80310fa774b181ea9d0a8543f8437df7
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #25819 from jacobly0/elfv2-emit-obj

10 files changed, 977 insertions(+), 580 deletions(-)

lib
- std
  - c.zig
  - debug
    SelfInfo
    Elf.zig
  - dynamic_library.zig
  - elf.zig
  - os
    linux.zig
  - posix.zig
  - posix
    test.zig
  - process.zig
src
- link
  - Elf2.zig
  - MappedFile.zig

lib/std/c.zig+3-3

...	...	@@ -3971,7 +3971,7 @@ pub const dl_phdr_info = switch (native_os) {
3971	3971	/// Module name.
3972	3972	name: ?[*:0]const u8,
3973	3973	/// Pointer to module's phdr.
3974		phdr: [*]std.elf.Phdr,
	3974	phdr: [*]std.elf.ElfN.Phdr,
3975	3975	/// Number of entries in phdr.
3976	3976	phnum: u16,
3977	3977	/// Total number of loads.
...	...	@@ -3984,7 +3984,7 @@ pub const dl_phdr_info = switch (native_os) {
3984	3984	.illumos => extern struct {
3985	3985	addr: std.elf.Addr,
3986	3986	name: ?[*:0]const u8,
3987		phdr: [*]std.elf.Phdr,
	3987	phdr: [*]std.elf.ElfN.Phdr,
3988	3988	phnum: std.elf.Half,
3989	3989	/// Incremented when a new object is mapped into the process.
3990	3990	adds: u64,
...	...	@@ -3995,7 +3995,7 @@ pub const dl_phdr_info = switch (native_os) {
3995	3995	.openbsd, .haiku, .dragonfly, .netbsd, .serenity => extern struct {
3996	3996	addr: usize,
3997	3997	name: ?[*:0]const u8,
3998		phdr: [*]std.elf.Phdr,
	3998	phdr: [*]std.elf.ElfN.Phdr,
3999	3999	phnum: std.elf.Half,
4000	4000	},
4001	4001	else => void,

lib/std/debug/SelfInfo/Elf.zig+10-10

...	...	@@ -441,11 +441,11 @@ const DlIterContext = struct {
441	441
442	442	// Populate `build_id` and `gnu_eh_frame`
443	443	for (info.phdr[0..info.phnum]) \|phdr\| {
444		switch (phdr.p_type) {
445		std.elf.PT_NOTE => {
	444	switch (phdr.type) {
	445	.NOTE => {
446	446	// Look for .note.gnu.build-id
447		const segment_ptr: [*]const u8 = @ptrFromInt(info.addr + phdr.p_vaddr);
448		var r: std.Io.Reader = .fixed(segment_ptr[0..phdr.p_memsz]);
	447	const segment_ptr: [*]const u8 = @ptrFromInt(info.addr + phdr.vaddr);
	448	var r: std.Io.Reader = .fixed(segment_ptr[0..phdr.memsz]);
449	449	const name_size = r.takeInt(u32, native_endian) catch continue;
450	450	const desc_size = r.takeInt(u32, native_endian) catch continue;
451	451	const note_type = r.takeInt(u32, native_endian) catch continue;
...	...	@@ -455,9 +455,9 @@ const DlIterContext = struct {
455	455	const desc = r.take(desc_size) catch continue;
456	456	build_id = desc;
457	457	},
458		std.elf.PT_GNU_EH_FRAME => {
459		const segment_ptr: [*]const u8 = @ptrFromInt(info.addr + phdr.p_vaddr);
460		gnu_eh_frame = segment_ptr[0..phdr.p_memsz];
	458	std.elf.PT.GNU_EH_FRAME => {
	459	const segment_ptr: [*]const u8 = @ptrFromInt(info.addr + phdr.vaddr);
	460	gnu_eh_frame = segment_ptr[0..phdr.memsz];
461	461	},
462	462	else => {},
463	463	}
...	...	@@ -478,11 +478,11 @@ const DlIterContext = struct {
478	478	});
479	479
480	480	for (info.phdr[0..info.phnum]) \|phdr\| {
481		if (phdr.p_type != std.elf.PT_LOAD) continue;
	481	if (phdr.type != .LOAD) continue;
482	482	try context.si.ranges.append(gpa, .{
483	483	// Overflowing addition handles VSDOs having p_vaddr = 0xffffffffff700000
484		.start = info.addr +% phdr.p_vaddr,
485		.len = phdr.p_memsz,
	484	.start = info.addr +% phdr.vaddr,
	485	.len = phdr.memsz,
486	486	.module_index = module_index,
487	487	});
488	488	}

lib/std/dynamic_library.zig+1-2

...	...	@@ -92,8 +92,7 @@ pub fn get_DYNAMIC() ?[*]const elf.Dyn {
92	92	});
93	93	}
94	94
95		pub fn linkmap_iterator(phdrs: []const elf.Phdr) error{InvalidExe}!LinkMap.Iterator {
96		_ = phdrs;
	95	pub fn linkmap_iterator() error{InvalidExe}!LinkMap.Iterator {
97	96	const _DYNAMIC = get_DYNAMIC() orelse {
98	97	// No PT_DYNAMIC means this is a statically-linked non-PIE program.
99	98	return .{ .current = null };

lib/std/elf.zig+228-100

...	...	@@ -50,6 +50,7 @@ pub const AT_L2_CACHESIZE = 44;
50	50	pub const AT_L2_CACHEGEOMETRY = 45;
51	51	pub const AT_L3_CACHESIZE = 46;
52	52	pub const AT_L3_CACHEGEOMETRY = 47;
	53	pub const AT_MINSIGSTKSZ = 51;
53	54
54	55	pub const DT_NULL = 0;
55	56	pub const DT_NEEDED = 1;
...	...	@@ -286,105 +287,111 @@ pub const VER_FLG_BASE = 1;
286	287	/// Weak version identifier
287	288	pub const VER_FLG_WEAK = 2;
288	289
289		/// Program header table entry unused
290		pub const PT_NULL = 0;
291		/// Loadable program segment
292		pub const PT_LOAD = 1;
293		/// Dynamic linking information
294		pub const PT_DYNAMIC = 2;
295		/// Program interpreter
296		pub const PT_INTERP = 3;
297		/// Auxiliary information
298		pub const PT_NOTE = 4;
299		/// Reserved
300		pub const PT_SHLIB = 5;
301		/// Entry for header table itself
302		pub const PT_PHDR = 6;
303		/// Thread-local storage segment
304		pub const PT_TLS = 7;
305		/// Number of defined types
306		pub const PT_NUM = 8;
307		/// Start of OS-specific
308		pub const PT_LOOS = 0x60000000;
309		/// GCC .eh_frame_hdr segment
310		pub const PT_GNU_EH_FRAME = 0x6474e550;
311		/// Indicates stack executability
312		pub const PT_GNU_STACK = 0x6474e551;
313		/// Read-only after relocation
314		pub const PT_GNU_RELRO = 0x6474e552;
315		pub const PT_LOSUNW = 0x6ffffffa;
316		/// Sun specific segment
317		pub const PT_SUNWBSS = 0x6ffffffa;
318		/// Stack segment
319		pub const PT_SUNWSTACK = 0x6ffffffb;
320		pub const PT_HISUNW = 0x6fffffff;
321		/// End of OS-specific
322		pub const PT_HIOS = 0x6fffffff;
323		/// Start of processor-specific
324		pub const PT_LOPROC = 0x70000000;
325		/// End of processor-specific
326		pub const PT_HIPROC = 0x7fffffff;
	290	/// Deprecated, use `@intFromEnum(std.elf.PT.NULL)`
	291	pub const PT_NULL = @intFromEnum(std.elf.PT.NULL);
	292	/// Deprecated, use `@intFromEnum(std.elf.PT.LOAD)`
	293	pub const PT_LOAD = @intFromEnum(std.elf.PT.LOAD);
	294	/// Deprecated, use `@intFromEnum(std.elf.PT.DYNAMIC)`
	295	pub const PT_DYNAMIC = @intFromEnum(std.elf.PT.DYNAMIC);
	296	/// Deprecated, use `@intFromEnum(std.elf.PT.INTERP)`
	297	pub const PT_INTERP = @intFromEnum(std.elf.PT.INTERP);
	298	/// Deprecated, use `@intFromEnum(std.elf.PT.NOTE)`
	299	pub const PT_NOTE = @intFromEnum(std.elf.PT.NOTE);
	300	/// Deprecated, use `@intFromEnum(std.elf.PT.SHLIB)`
	301	pub const PT_SHLIB = @intFromEnum(std.elf.PT.SHLIB);
	302	/// Deprecated, use `@intFromEnum(std.elf.PT.PHDR)`
	303	pub const PT_PHDR = @intFromEnum(std.elf.PT.PHDR);
	304	/// Deprecated, use `@intFromEnum(std.elf.PT.TLS)`
	305	pub const PT_TLS = @intFromEnum(std.elf.PT.TLS);
	306	/// Deprecated, use `std.elf.PT.NUM`.
	307	pub const PT_NUM = PT.NUM;
	308	/// Deprecated, use `@intFromEnum(std.elf.PT.LOOS)`
	309	pub const PT_LOOS = @intFromEnum(std.elf.PT.LOOS);
	310	/// Deprecated, use `@intFromEnum(std.elf.PT.GNU_EH_FRAME)`
	311	pub const PT_GNU_EH_FRAME = @intFromEnum(std.elf.PT.GNU_EH_FRAME);
	312	/// Deprecated, use `@intFromEnum(std.elf.PT.GNU_STACK)`
	313	pub const PT_GNU_STACK = @intFromEnum(std.elf.PT.GNU_STACK);
	314	/// Deprecated, use `@intFromEnum(std.elf.PT.GNU_RELRO)`
	315	pub const PT_GNU_RELRO = @intFromEnum(std.elf.PT.GNU_RELRO);
	316	/// Deprecated, use `@intFromEnum(std.elf.PT.LOSUNW)`
	317	pub const PT_LOSUNW = @intFromEnum(std.elf.PT.LOSUNW);
	318	/// Deprecated, use `@intFromEnum(std.elf.PT.SUNWBSS)`
	319	pub const PT_SUNWBSS = @intFromEnum(std.elf.PT.SUNWBSS);
	320	/// Deprecated, use `@intFromEnum(std.elf.PT.SUNWSTACK)`
	321	pub const PT_SUNWSTACK = @intFromEnum(std.elf.PT.SUNWSTACK);
	322	/// Deprecated, use `@intFromEnum(std.elf.PT.HISUNW)`
	323	pub const PT_HISUNW = @intFromEnum(std.elf.PT.HISUNW);
	324	/// Deprecated, use `@intFromEnum(std.elf.PT.HIOS)`
	325	pub const PT_HIOS = @intFromEnum(std.elf.PT.HIOS);
	326	/// Deprecated, use `@intFromEnum(std.elf.PT.LOPROC)`
	327	pub const PT_LOPROC = @intFromEnum(std.elf.PT.LOPROC);
	328	/// Deprecated, use `@intFromEnum(std.elf.PT.HIPROC)`
	329	pub const PT_HIPROC = @intFromEnum(std.elf.PT.HIPROC);
327	330
328	331	pub const PN_XNUM = 0xffff;
329	332
330		/// Section header table entry unused
331		pub const SHT_NULL = 0;
332		/// Program data
333		pub const SHT_PROGBITS = 1;
334		/// Symbol table
335		pub const SHT_SYMTAB = 2;
336		/// String table
337		pub const SHT_STRTAB = 3;
338		/// Relocation entries with addends
339		pub const SHT_RELA = 4;
340		/// Symbol hash table
341		pub const SHT_HASH = 5;
342		/// Dynamic linking information
343		pub const SHT_DYNAMIC = 6;
344		/// Notes
345		pub const SHT_NOTE = 7;
346		/// Program space with no data (bss)
347		pub const SHT_NOBITS = 8;
348		/// Relocation entries, no addends
349		pub const SHT_REL = 9;
350		/// Reserved
351		pub const SHT_SHLIB = 10;
352		/// Dynamic linker symbol table
353		pub const SHT_DYNSYM = 11;
354		/// Array of constructors
355		pub const SHT_INIT_ARRAY = 14;
356		/// Array of destructors
357		pub const SHT_FINI_ARRAY = 15;
358		/// Array of pre-constructors
359		pub const SHT_PREINIT_ARRAY = 16;
360		/// Section group
361		pub const SHT_GROUP = 17;
362		/// Extended section indices
363		pub const SHT_SYMTAB_SHNDX = 18;
364		/// Start of OS-specific
365		pub const SHT_LOOS = 0x60000000;
366		/// LLVM address-significance table
367		pub const SHT_LLVM_ADDRSIG = 0x6fff4c03;
368		/// GNU hash table
369		pub const SHT_GNU_HASH = 0x6ffffff6;
370		/// GNU version definition table
371		pub const SHT_GNU_VERDEF = 0x6ffffffd;
372		/// GNU needed versions table
373		pub const SHT_GNU_VERNEED = 0x6ffffffe;
374		/// GNU symbol version table
375		pub const SHT_GNU_VERSYM = 0x6fffffff;
376		/// End of OS-specific
377		pub const SHT_HIOS = 0x6fffffff;
378		/// Start of processor-specific
379		pub const SHT_LOPROC = 0x70000000;
380		/// Unwind information
381		pub const SHT_X86_64_UNWIND = 0x70000001;
382		/// End of processor-specific
383		pub const SHT_HIPROC = 0x7fffffff;
384		/// Start of application-specific
385		pub const SHT_LOUSER = 0x80000000;
386		/// End of application-specific
387		pub const SHT_HIUSER = 0xffffffff;
	333	/// Deprecated, use `@intFromEnum(std.elf.SHT.NULL)`
	334	pub const SHT_NULL = @intFromEnum(std.elf.SHT.NULL);
	335	/// Deprecated, use `@intFromEnum(std.elf.SHT.PROGBITS)`
	336	pub const SHT_PROGBITS = @intFromEnum(std.elf.SHT.PROGBITS);
	337	/// Deprecated, use `@intFromEnum(std.elf.SHT.SYMTAB)`
	338	pub const SHT_SYMTAB = @intFromEnum(std.elf.SHT.SYMTAB);
	339	/// Deprecated, use `@intFromEnum(std.elf.SHT.STRTAB)`
	340	pub const SHT_STRTAB = @intFromEnum(std.elf.SHT.STRTAB);
	341	/// Deprecated, use `@intFromEnum(std.elf.SHT.RELA)`
	342	pub const SHT_RELA = @intFromEnum(std.elf.SHT.RELA);
	343	/// Deprecated, use `@intFromEnum(std.elf.SHT.HASH)`
	344	pub const SHT_HASH = @intFromEnum(std.elf.SHT.HASH);
	345	/// Deprecated, use `@intFromEnum(std.elf.SHT.DYNAMIC)`
	346	pub const SHT_DYNAMIC = @intFromEnum(std.elf.SHT.DYNAMIC);
	347	/// Deprecated, use `@intFromEnum(std.elf.SHT.NOTE)`
	348	pub const SHT_NOTE = @intFromEnum(std.elf.SHT.NOTE);
	349	/// Deprecated, use `@intFromEnum(std.elf.SHT.NOBITS)`
	350	pub const SHT_NOBITS = @intFromEnum(std.elf.SHT.NOBITS);
	351	/// Deprecated, use `@intFromEnum(std.elf.SHT.REL)`
	352	pub const SHT_REL = @intFromEnum(std.elf.SHT.REL);
	353	/// Deprecated, use `@intFromEnum(std.elf.SHT.SHLIB)`
	354	pub const SHT_SHLIB = @intFromEnum(std.elf.SHT.SHLIB);
	355	/// Deprecated, use `@intFromEnum(std.elf.SHT.DYNSYM)`
	356	pub const SHT_DYNSYM = @intFromEnum(std.elf.SHT.DYNSYM);
	357	/// Deprecated, use `@intFromEnum(std.elf.SHT.INIT_ARRAY)`
	358	pub const SHT_INIT_ARRAY = @intFromEnum(std.elf.SHT.INIT_ARRAY);
	359	/// Deprecated, use `@intFromEnum(std.elf.SHT.FINI_ARRAY)`
	360	pub const SHT_FINI_ARRAY = @intFromEnum(std.elf.SHT.FINI_ARRAY);
	361	/// Deprecated, use `@intFromEnum(std.elf.SHT.PREINIT_ARRAY)`
	362	pub const SHT_PREINIT_ARRAY = @intFromEnum(std.elf.SHT.PREINIT_ARRAY);
	363	/// Deprecated, use `@intFromEnum(std.elf.SHT.GROUP)`
	364	pub const SHT_GROUP = @intFromEnum(std.elf.SHT.GROUP);
	365	/// Deprecated, use `@intFromEnum(std.elf.SHT.SYMTAB_SHNDX)`
	366	pub const SHT_SYMTAB_SHNDX = @intFromEnum(std.elf.SHT.SYMTAB_SHNDX);
	367	/// Deprecated, use `@intFromEnum(std.elf.SHT.RELR)`
	368	pub const SHT_RELR = @intFromEnum(std.elf.SHT.RELR);
	369	/// Deprecated, use `std.elf.SHT.NUM`.
	370	pub const SHT_NUM = SHT.NUM;
	371	/// Deprecated, use `@intFromEnum(std.elf.SHT.LOOS)`
	372	pub const SHT_LOOS = @intFromEnum(std.elf.SHT.LOOS);
	373	/// Deprecated, use `@intFromEnum(std.elf.SHT.LLVM_ADDRSIG)`
	374	pub const SHT_LLVM_ADDRSIG = @intFromEnum(std.elf.SHT.LLVM_ADDRSIG);
	375	/// Deprecated, use `@intFromEnum(std.elf.SHT.GNU_HASH)`
	376	pub const SHT_GNU_HASH = @intFromEnum(std.elf.SHT.GNU_HASH);
	377	/// Deprecated, use `@intFromEnum(std.elf.SHT.GNU_VERDEF)`
	378	pub const SHT_GNU_VERDEF = @intFromEnum(std.elf.SHT.GNU_VERDEF);
	379	/// Deprecated, use `@intFromEnum(std.elf.SHT.GNU_VERNEED)`
	380	pub const SHT_GNU_VERNEED = @intFromEnum(std.elf.SHT.GNU_VERNEED);
	381	/// Deprecated, use `@intFromEnum(std.elf.SHT.GNU_VERSYM)`
	382	pub const SHT_GNU_VERSYM = @intFromEnum(std.elf.SHT.GNU_VERSYM);
	383	/// Deprecated, use `@intFromEnum(std.elf.SHT.HIOS)`
	384	pub const SHT_HIOS = @intFromEnum(std.elf.SHT.HIOS);
	385	/// Deprecated, use `@intFromEnum(std.elf.SHT.LOPROC)`
	386	pub const SHT_LOPROC = @intFromEnum(std.elf.SHT.LOPROC);
	387	/// Deprecated, use `@intFromEnum(std.elf.SHT.X86_64_UNWIND)`
	388	pub const SHT_X86_64_UNWIND = @intFromEnum(std.elf.SHT.X86_64_UNWIND);
	389	/// Deprecated, use `@intFromEnum(std.elf.SHT.HIPROC)`
	390	pub const SHT_HIPROC = @intFromEnum(std.elf.SHT.HIPROC);
	391	/// Deprecated, use `@intFromEnum(std.elf.SHT.LOUSER)`
	392	pub const SHT_LOUSER = @intFromEnum(std.elf.SHT.LOUSER);
	393	/// Deprecated, use `@intFromEnum(std.elf.SHT.HIUSER)`
	394	pub const SHT_HIUSER = @intFromEnum(std.elf.SHT.HIUSER);
388	395
389	396	// Note type for .note.gnu.build_id
390	397	pub const NT_GNU_BUILD_ID = 3;
...	...	@@ -454,6 +461,127 @@ pub const STT_ARM_TFUNC = @intFromEnum(STT.ARM_TFUNC);
454	461	/// Deprecated, use `@intFromEnum(std.elf.STT.ARM_16BIT)`
455	462	pub const STT_ARM_16BIT = @intFromEnum(STT.ARM_16BIT);
456	463
	464	pub const PT = enum(Word) {
	465	/// Program header table entry unused
	466	NULL = 0,
	467	/// Loadable program segment
	468	LOAD = 1,
	469	/// Dynamic linking information
	470	DYNAMIC = 2,
	471	/// Program interpreter
	472	INTERP = 3,
	473	/// Auxiliary information
	474	NOTE = 4,
	475	/// Reserved
	476	SHLIB = 5,
	477	/// Entry for header table itself
	478	PHDR = 6,
	479	/// Thread-local storage segment
	480	TLS = 7,
	481	_,
	482
	483	/// Number of defined types
	484	pub const NUM = @typeInfo(PT).@"enum".fields.len;
	485
	486	/// Start of OS-specific
	487	pub const LOOS: PT = @enumFromInt(0x60000000);
	488	/// End of OS-specific
	489	pub const HIOS: PT = @enumFromInt(0x6fffffff);
	490
	491	/// GCC .eh_frame_hdr segment
	492	pub const GNU_EH_FRAME: PT = @enumFromInt(0x6474e550);
	493	/// Indicates stack executability
	494	pub const GNU_STACK: PT = @enumFromInt(0x6474e551);
	495	/// Read-only after relocation
	496	pub const GNU_RELRO: PT = @enumFromInt(0x6474e552);
	497
	498	pub const LOSUNW: PT = @enumFromInt(0x6ffffffa);
	499	pub const HISUNW: PT = @enumFromInt(0x6fffffff);
	500
	501	/// Sun specific segment
	502	pub const SUNWBSS: PT = @enumFromInt(0x6ffffffa);
	503	/// Stack segment
	504	pub const SUNWSTACK: PT = @enumFromInt(0x6ffffffb);
	505
	506	/// Start of processor-specific
	507	pub const LOPROC: PT = @enumFromInt(0x70000000);
	508	/// End of processor-specific
	509	pub const HIPROC: PT = @enumFromInt(0x7fffffff);
	510	};
	511
	512	pub const SHT = enum(Word) {
	513	/// Section header table entry unused
	514	NULL = 0,
	515	/// Program data
	516	PROGBITS = 1,
	517	/// Symbol table
	518	SYMTAB = 2,
	519	/// String table
	520	STRTAB = 3,
	521	/// Relocation entries with addends
	522	RELA = 4,
	523	/// Symbol hash table
	524	HASH = 5,
	525	/// Dynamic linking information
	526	DYNAMIC = 6,
	527	/// Notes
	528	NOTE = 7,
	529	/// Program space with no data (bss)
	530	NOBITS = 8,
	531	/// Relocation entries, no addends
	532	REL = 9,
	533	/// Reserved
	534	SHLIB = 10,
	535	/// Dynamic linker symbol table
	536	DYNSYM = 11,
	537	/// Array of constructors
	538	INIT_ARRAY = 14,
	539	/// Array of destructors
	540	FINI_ARRAY = 15,
	541	/// Array of pre-constructors
	542	PREINIT_ARRAY = 16,
	543	/// Section group
	544	GROUP = 17,
	545	/// Extended section indices
	546	SYMTAB_SHNDX = 18,
	547	/// RELR relative relocations
	548	RELR = 19,
	549	_,
	550
	551	/// Number of defined types
	552	pub const NUM = @typeInfo(SHT).@"enum".fields.len;
	553
	554	/// Start of OS-specific
	555	pub const LOOS: SHT = @enumFromInt(0x60000000);
	556	/// End of OS-specific
	557	pub const HIOS: SHT = @enumFromInt(0x6fffffff);
	558
	559	/// LLVM address-significance table
	560	pub const LLVM_ADDRSIG: SHT = @enumFromInt(0x6fff4c03);
	561
	562	/// GNU hash table
	563	pub const GNU_HASH: SHT = @enumFromInt(0x6ffffff6);
	564	/// GNU version definition table
	565	pub const GNU_VERDEF: SHT = @enumFromInt(0x6ffffffd);
	566	/// GNU needed versions table
	567	pub const GNU_VERNEED: SHT = @enumFromInt(0x6ffffffe);
	568	/// GNU symbol version table
	569	pub const GNU_VERSYM: SHT = @enumFromInt(0x6fffffff);
	570
	571	/// Start of processor-specific
	572	pub const LOPROC: SHT = @enumFromInt(0x70000000);
	573	/// End of processor-specific
	574	pub const HIPROC: SHT = @enumFromInt(0x7fffffff);
	575
	576	/// Unwind information
	577	pub const X86_64_UNWIND: SHT = @enumFromInt(0x70000001);
	578
	579	/// Start of application-specific
	580	pub const LOUSER: SHT = @enumFromInt(0x80000000);
	581	/// End of application-specific
	582	pub const HIUSER: SHT = @enumFromInt(0xffffffff);
	583	};
	584
457	585	pub const STB = enum(u4) {
458	586	/// Local symbol
459	587	LOCAL = 0,
...	...	@@ -899,7 +1027,7 @@ pub const Elf32 = struct {
899	1027	shstrndx: Half,
900	1028	};
901	1029	pub const Phdr = extern struct {
902		type: Word,
	1030	type: PT,
903	1031	offset: Elf32.Off,
904	1032	vaddr: Elf32.Addr,
905	1033	paddr: Elf32.Addr,
...	...	@@ -910,7 +1038,7 @@ pub const Elf32 = struct {
910	1038	};
911	1039	pub const Shdr = extern struct {
912	1040	name: Word,
913		type: Word,
	1041	type: SHT,
914	1042	flags: packed struct { shf: SHF },
915	1043	addr: Elf32.Addr,
916	1044	offset: Elf32.Off,
...	...	@@ -989,7 +1117,7 @@ pub const Elf64 = struct {
989	1117	shstrndx: Half,
990	1118	};
991	1119	pub const Phdr = extern struct {
992		type: Word,
	1120	type: PT,
993	1121	flags: PF,
994	1122	offset: Elf64.Off,
995	1123	vaddr: Elf64.Addr,
...	...	@@ -1000,7 +1128,7 @@ pub const Elf64 = struct {
1000	1128	};
1001	1129	pub const Shdr = extern struct {
1002	1130	name: Word,
1003		type: Word,
	1131	type: SHT,
1004	1132	flags: packed struct { shf: SHF, unused: Word = 0 },
1005	1133	addr: Elf64.Addr,
1006	1134	offset: Elf64.Off,

lib/std/os/linux.zig+1-1

...	...	@@ -6101,7 +6101,7 @@ pub const dirent64 = extern struct {
6101	6101	pub const dl_phdr_info = extern struct {
6102	6102	addr: usize,
6103	6103	name: ?[*:0]const u8,
6104		phdr: [*]std.elf.Phdr,
	6104	phdr: [*]std.elf.ElfN.Phdr,
6105	6105	phnum: u16,
6106	6106	};
6107	6107

lib/std/posix.zig+30-39

...	...	@@ -5048,6 +5048,13 @@ pub fn nanosleep(seconds: u64, nanoseconds: u64) void {
5048	5048	}
5049	5049	}
5050	5050
	5051	pub fn getSelfPhdrs() []std.elf.ElfN.Phdr {
	5052	const getauxval = if (builtin.link_libc) std.c.getauxval else std.os.linux.getauxval;
	5053	assert(getauxval(std.elf.AT_PHENT) == @sizeOf(std.elf.ElfN.Phdr));
	5054	const phdrs: [*]std.elf.ElfN.Phdr = @ptrFromInt(getauxval(std.elf.AT_PHDR));
	5055	return phdrs[0..getauxval(std.elf.AT_PHNUM)];
	5056	}
	5057
5051	5058	pub fn dl_iterate_phdr(
5052	5059	context: anytype,
5053	5060	comptime Error: type,
...	...	@@ -5075,34 +5082,24 @@ pub fn dl_iterate_phdr(
5075	5082	}
5076	5083	}
5077	5084
5078		const elf_base = std.process.getBaseAddress();
5079		const ehdr: *elf.Ehdr = @ptrFromInt(elf_base);
5080		// Make sure the base address points to an ELF image.
5081		assert(mem.eql(u8, ehdr.e_ident[0..4], elf.MAGIC));
5082		const n_phdr = ehdr.e_phnum;
5083		const phdrs = (@as([*]elf.Phdr, @ptrFromInt(elf_base + ehdr.e_phoff)))[0..n_phdr];
5084
5085		var it = dl.linkmap_iterator(phdrs) catch unreachable;
	5085	var it = dl.linkmap_iterator() catch unreachable;
5086	5086
5087	5087	// The executable has no dynamic link segment, create a single entry for
5088	5088	// the whole ELF image.
5089	5089	if (it.end()) {
5090		// Find the base address for the ELF image, if this is a PIE the value
5091		// is non-zero.
5092		const base_address = for (phdrs) \|*phdr\| {
5093		if (phdr.p_type == elf.PT_PHDR) {
5094		break @intFromPtr(phdrs.ptr) - phdr.p_vaddr;
5095		// We could try computing the difference between _DYNAMIC and
5096		// the p_vaddr of the PT_DYNAMIC section, but using the phdr is
5097		// good enough (Is it?).
5098		}
5099		} else unreachable;
5100
5101		var info = dl_phdr_info{
5102		.addr = base_address,
5103		.name = "/proc/self/exe",
	5090	const getauxval = if (builtin.link_libc) std.c.getauxval else std.os.linux.getauxval;
	5091	const phdrs = getSelfPhdrs();
	5092	var info: dl_phdr_info = .{
	5093	.addr = for (phdrs) \|phdr\| switch (phdr.type) {
	5094	.PHDR => break @intFromPtr(phdrs.ptr) - phdr.vaddr,
	5095	else => {},
	5096	} else unreachable,
	5097	.name = switch (getauxval(std.elf.AT_EXECFN)) {
	5098	0 => "/proc/self/exe",
	5099	else => \|name\| @ptrFromInt(name),
	5100	},
5104	5101	.phdr = phdrs.ptr,
5105		.phnum = ehdr.e_phnum,
	5102	.phnum = @intCast(phdrs.len),
5106	5103	};
5107	5104
5108	5105	return callback(&info, @sizeOf(dl_phdr_info), context);
...	...	@@ -5110,24 +5107,18 @@ pub fn dl_iterate_phdr(
5110	5107
5111	5108	// Last return value from the callback function.
5112	5109	while (it.next()) \|entry\| {
5113		var phdr: [*]elf.Phdr = undefined;
5114		var phnum: u16 = undefined;
5115
5116		if (entry.l_addr != 0) {
5117		const elf_header: *elf.Ehdr = @ptrFromInt(entry.l_addr);
5118		phdr = @ptrFromInt(entry.l_addr + elf_header.e_phoff);
5119		phnum = elf_header.e_phnum;
5120		} else {
5121		// This is the running ELF image
5122		phdr = @ptrFromInt(elf_base + ehdr.e_phoff);
5123		phnum = ehdr.e_phnum;
5124		}
5125
5126		var info = dl_phdr_info{
	5110	const phdrs: []elf.ElfN.Phdr = if (entry.l_addr != 0) phdrs: {
	5111	const ehdr: *elf.ElfN.Ehdr = @ptrFromInt(entry.l_addr);
	5112	assert(mem.eql(u8, ehdr.ident[0..4], elf.MAGIC));
	5113	const phdrs: [*]elf.ElfN.Phdr = @ptrFromInt(entry.l_addr + ehdr.phoff);
	5114	break :phdrs phdrs[0..ehdr.phnum];
	5115	} else getSelfPhdrs();
	5116
	5117	var info: dl_phdr_info = .{
5127	5118	.addr = entry.l_addr,
5128	5119	.name = entry.l_name,
5129		.phdr = phdr,
5130		.phnum = phnum,
	5120	.phdr = phdrs.ptr,
	5121	.phnum = @intCast(phdrs.len),
5131	5122	};
5132	5123
5133	5124	try callback(&info, @sizeOf(dl_phdr_info), context);

lib/std/posix/test.zig+3-3

...	...	@@ -257,11 +257,11 @@ fn iter_fn(info: dl_phdr_info, size: usize, counter: usize) IterFnError!void {
257	257	while (i < info.phnum) : (i += 1) {
258	258	const phdr = info.phdr[i];
259	259
260		if (phdr.p_type != elf.PT_LOAD) continue;
	260	if (phdr.type != .LOAD) continue;
261	261
262		const reloc_addr = info.addr + phdr.p_vaddr;
	262	const reloc_addr = info.addr + phdr.vaddr;
263	263	// Find the ELF header
264		const elf_header = @as(*elf.Ehdr, @ptrFromInt(reloc_addr - phdr.p_offset));
	264	const elf_header = @as(*elf.Ehdr, @ptrFromInt(reloc_addr - phdr.offset));
265	265	// Validate the magic
266	266	if (!mem.eql(u8, elf_header.e_ident[0..4], elf.MAGIC)) return error.BadElfMagic;
267	267	// Consistency check

lib/std/process.zig+7-7

...	...	@@ -1658,13 +1658,13 @@ fn posixGetUserInfoPasswdStream(name: []const u8, reader: *std.Io.Reader) !UserI
1658	1658	pub fn getBaseAddress() usize {
1659	1659	switch (native_os) {
1660	1660	.linux => {
1661		const getauxval = if (builtin.link_libc) std.c.getauxval else std.os.linux.getauxval;
1662		const base = getauxval(std.elf.AT_BASE);
1663		if (base != 0) {
1664		return base;
1665		}
1666		const phdr = getauxval(std.elf.AT_PHDR);
1667		return phdr - @sizeOf(std.elf.Ehdr);
	1661	const phdrs = std.posix.getSelfPhdrs();
	1662	var base: usize = 0;
	1663	for (phdrs) \|phdr\| switch (phdr.type) {
	1664	.LOAD => return base + phdr.vaddr,
	1665	.PHDR => base = @intFromPtr(phdrs.ptr) - phdr.vaddr,
	1666	else => {},
	1667	} else unreachable;
1668	1668	},
1669	1669	.driverkit, .ios, .macos, .tvos, .visionos, .watchos => {
1670	1670	return @intFromPtr(&std.c._mh_execute_header);

src/link/Elf2.zig+682-390

...	...	@@ -3,6 +3,7 @@ options: link.File.OpenOptions,
3	3	mf: MappedFile,
4	4	ni: Node.Known,
5	5	nodes: std.MultiArrayList(Node),
	6	shdrs: std.ArrayList(Section),
6	7	phdrs: std.ArrayList(MappedFile.Node.Index),
7	8	si: Symbol.Known,
8	9	symtab: std.ArrayList(Symbol),
...	...	@@ -163,9 +164,29 @@ pub const Node = union(enum) {
163	164	}
164	165	};
165	166
	167	pub const Section = struct {
	168	si: Symbol.Index,
	169	rela_si: Symbol.Index,
	170	rela_free: RelIndex,
	171
	172	pub const RelIndex = enum(u32) {
	173	none,
	174	_,
	175
	176	pub fn wrap(i: ?u32) RelIndex {
	177	return @enumFromInt((i orelse return .none) + 1);
	178	}
	179	pub fn unwrap(ri: RelIndex) ?u32 {
	180	return switch (ri) {
	181	.none => null,
	182	else => @intFromEnum(ri) - 1,
	183	};
	184	}
	185	};
	186	};
	187
166	188	pub const StringTable = struct {
167	189	map: std.HashMapUnmanaged(u32, void, StringTable.Context, std.hash_map.default_max_load_percentage),
168		size: u32,
169	190
170	191	const Context = struct {
171	192	slice: []const u8,
...	...	@@ -193,14 +214,10 @@ pub const StringTable = struct {
193	214	}
194	215	};
195	216
196		pub fn get(
197		st: *StringTable,
198		gpa: std.mem.Allocator,
199		mf: *MappedFile,
200		ni: MappedFile.Node.Index,
201		key: []const u8,
202		) !u32 {
203		const slice_const = ni.sliceConst(mf);
	217	pub fn get(st: StringTable, elf: Elf, si: Symbol.Index, key: []const u8) !u32 {
	218	const gpa = elf.base.comp.gpa;
	219	const ni = si.node(elf);
	220	const slice_const = ni.sliceConst(&elf.mf);
204	221	const gop = try st.map.getOrPutContextAdapted(
205	222	gpa,
206	223	key,
...	...	@@ -208,11 +225,18 @@ pub const StringTable = struct {
208	225	.{ .slice = slice_const },
209	226	);
210	227	if (gop.found_existing) return gop.key_ptr.*;
211		const old_size = st.size;
212		const new_size: u32 = @intCast(old_size + key.len + 1);
213		st.size = new_size;
214		try ni.resize(mf, gpa, new_size);
215		const slice = ni.slice(mf)[old_size..];
	228	const old_size, const new_size = size: switch (elf.shdrPtr(si.shndx(elf))) {
	229	inline else => \|shdr\| {
	230	const old_size: u32 = @intCast(elf.targetLoad(&shdr.size));
	231	const new_size: u32 = @intCast(old_size + key.len + 1);
	232	elf.targetStore(&shdr.size, new_size);
	233	break :size .{ old_size, new_size };
	234	},
	235	};
	236	_, const node_size = ni.location(&elf.mf).resolve(&elf.mf);
	237	if (new_size > node_size)
	238	try ni.resize(&elf.mf, gpa, new_size +\| new_size / MappedFile.growth_factor);
	239	const slice = ni.slice(&elf.mf)[old_size..];
216	240	@memcpy(slice[0..key.len], key);
217	241	slice[key.len] = 0;
218	242	gop.key_ptr.* = old_size;
...	...	@@ -226,7 +250,7 @@ pub const Symbol = struct {
226	250	loc_relocs: Reloc.Index,
227	251	/// Relocations targeting this symbol
228	252	target_relocs: Reloc.Index,
229		unused: u32 = 0,
	253	unused: u32,
230	254
231	255	pub const Index = enum(u32) {
232	256	null,
...	...	@@ -252,6 +276,52 @@ pub const Symbol = struct {
252	276	return @enumFromInt(@intFromEnum(si) + 1);
253	277	}
254	278
	279	pub const Shndx = enum(Tag) {
	280	UNDEF = std.elf.SHN_UNDEF,
	281	LIVEPATCH = reserve(std.elf.SHN_LIVEPATCH),
	282	ABS = reserve(std.elf.SHN_ABS),
	283	COMMON = reserve(std.elf.SHN_COMMON),
	284	_,
	285
	286	pub const Tag = u32;
	287
	288	pub const LORESERVE: Shndx = .fromSection(std.elf.SHN_LORESERVE);
	289	pub const HIRESERVE: Shndx = .fromSection(std.elf.SHN_HIRESERVE);
	290	comptime {
	291	assert(@intFromEnum(HIRESERVE) == std.math.maxInt(Tag));
	292	}
	293
	294	fn reserve(sec: std.elf.Section) Tag {
	295	assert(sec >= std.elf.SHN_LORESERVE and sec <= std.elf.SHN_HIRESERVE);
	296	return @as(Tag, std.math.maxInt(Tag) - std.elf.SHN_HIRESERVE) + sec;
	297	}
	298
	299	pub fn fromSection(sec: std.elf.Section) Shndx {
	300	return switch (sec) {
	301	std.elf.SHN_UNDEF...std.elf.SHN_LORESERVE - 1 => @enumFromInt(sec),
	302	std.elf.SHN_LORESERVE...std.elf.SHN_HIRESERVE => @enumFromInt(reserve(sec)),
	303	};
	304	}
	305	pub fn toSection(s: Shndx) ?std.elf.Section {
	306	return switch (@intFromEnum(s)) {
	307	std.elf.SHN_UNDEF...std.elf.SHN_LORESERVE - 1 => \|sec\| @intCast(sec),
	308	std.elf.SHN_LORESERVE...reserve(std.elf.SHN_LORESERVE) - 1 => null,
	309	reserve(std.elf.SHN_LORESERVE)...reserve(std.elf.SHN_HIRESERVE) => \|sec\| @intCast(
	310	sec - reserve(std.elf.SHN_LORESERVE) + std.elf.SHN_LORESERVE,
	311	),
	312	};
	313	}
	314
	315	pub fn get(s: Shndx, elf: Elf) Section {
	316	return &elf.shdrs.items[@intFromEnum(s)];
	317	}
	318	};
	319	pub fn shndx(si: Symbol.Index, elf: *Elf) Shndx {
	320	return .fromSection(switch (elf.symPtr(si)) {
	321	inline else => \|sym\| elf.targetLoad(&sym.shndx),
	322	});
	323	}
	324
255	325	pub const InitOptions = struct {
256	326	name: []const u8 = "",
257	327	lib_name: ?[]const u8 = null,
...	...	@@ -260,48 +330,83 @@ pub const Symbol = struct {
260	330	type: std.elf.STT,
261	331	bind: std.elf.STB = .LOCAL,
262	332	visibility: std.elf.STV = .DEFAULT,
263		shndx: std.elf.Section = std.elf.SHN_UNDEF,
	333	shndx: Shndx = .UNDEF,
264	334	};
265	335	pub fn init(si: Symbol.Index, elf: *Elf, opts: InitOptions) !void {
266	336	const gpa = elf.base.comp.gpa;
267	337	const target_endian = elf.targetEndian();
268		const sym_size: usize = switch (elf.identClass()) {
269		.NONE, _ => unreachable,
270		inline else => \|class\| @sizeOf(class.ElfN().Sym),
271		};
272	338	const name_strtab_entry = try elf.string(.strtab, opts.name);
273		try elf.si.symtab.node(elf).resize(&elf.mf, gpa, sym_size * elf.symtab.items.len);
	339	switch (elf.shdrPtr(elf.si.symtab.shndx(elf))) {
	340	inline else => \|shdr\| {
	341	const old_size = elf.targetLoad(&shdr.size);
	342	const ent_size = elf.targetLoad(&shdr.entsize);
	343	const new_size = ent_size * elf.symtab.items.len;
	344	if (new_size > old_size) {
	345	elf.targetStore(&shdr.size, @intCast(new_size));
	346	const symtab_ni = elf.si.symtab.node(elf);
	347	_, const node_size = symtab_ni.location(&elf.mf).resolve(&elf.mf);
	348	if (new_size > node_size) try symtab_ni.resize(
	349	&elf.mf,
	350	gpa,
	351	new_size +\| new_size / MappedFile.growth_factor,
	352	);
	353	}
	354	},
	355	}
274	356	switch (elf.symPtr(si)) {
275	357	inline else => \|sym, class\| {
	358	const Sym = class.ElfN().Sym;
276	359	sym.* = .{
277	360	.name = name_strtab_entry,
278	361	.value = @intCast(opts.value),
279	362	.size = @intCast(opts.size),
280	363	.info = .{ .type = opts.type, .bind = opts.bind },
281	364	.other = .{ .visibility = opts.visibility },
282		.shndx = opts.shndx,
	365	.shndx = opts.shndx.toSection().?,
283	366	};
284		if (target_endian != native_endian) std.mem.byteSwapAllFields(class.ElfN().Sym, sym);
	367	if (target_endian != native_endian) std.mem.byteSwapAllFields(Sym, sym);
285	368	},
286	369	}
	370	switch (elf.shdrPtr(elf.si.symtab.shndx(elf))) {
	371	inline else => \|shdr\| elf.targetStore(&shdr.info, @max(
	372	elf.targetLoad(&shdr.info),
	373	@intFromEnum(si) + 1,
	374	)),
	375	}
287	376	if (opts.bind == .LOCAL or elf.si.dynsym == .null) return;
288	377	const dsi = elf.dynsym.items.len;
289	378	try elf.dynsym.append(gpa, si);
290		const dynsym_ni = elf.si.dynsym.node(elf);
291	379	const name_dynstr_entry = try elf.string(.dynstr, opts.name);
292		try dynsym_ni.resize(&elf.mf, gpa, sym_size * elf.dynsym.items.len);
	380	switch (elf.shdrPtr(elf.si.dynsym.shndx(elf))) {
	381	inline else => \|shdr\| {
	382	const old_size = elf.targetLoad(&shdr.size);
	383	const ent_size = elf.targetLoad(&shdr.entsize);
	384	const new_size = ent_size * elf.dynsym.items.len;
	385	if (new_size > old_size) {
	386	elf.targetStore(&shdr.size, @intCast(new_size));
	387	const dynsym_ni = elf.si.dynsym.node(elf);
	388	_, const node_size = dynsym_ni.location(&elf.mf).resolve(&elf.mf);
	389	if (new_size > node_size) try dynsym_ni.resize(
	390	&elf.mf,
	391	gpa,
	392	new_size +\| new_size / MappedFile.growth_factor,
	393	);
	394	}
	395	},
	396	}
293	397	switch (elf.dynsymSlice()) {
294		inline else => \|dynsym, class\| {
295		const dsym = &dynsym[dsi];
296		dsym.* = .{
	398	inline else => \|dynsyms, class\| {
	399	const Sym = class.ElfN().Sym;
	400	const dynsym = &dynsyms[dsi];
	401	dynsym.* = .{
297	402	.name = name_dynstr_entry,
298	403	.value = @intCast(opts.value),
299	404	.size = @intCast(opts.size),
300	405	.info = .{ .type = opts.type, .bind = opts.bind },
301	406	.other = .{ .visibility = opts.visibility },
302		.shndx = opts.shndx,
	407	.shndx = opts.shndx.toSection().?,
303	408	};
304		if (target_endian != native_endian) std.mem.byteSwapAllFields(class.ElfN().Sym, dsym);
	409	if (target_endian != native_endian) std.mem.byteSwapAllFields(Sym, dynsym);
305	410	},
306	411	}
307	412	}
...	...	@@ -321,6 +426,7 @@ pub const Symbol = struct {
321	426	}
322	427
323	428	pub fn applyLocationRelocs(si: Symbol.Index, elf: *Elf) void {
	429	if (elf.ehdrField(.type) == .REL) return;
324	430	switch (si.get(elf).loc_relocs) {
325	431	.none => {},
326	432	else => \|loc_relocs\| for (elf.relocs.items[@intFromEnum(loc_relocs)..]) \|*reloc\| {
...	...	@@ -331,6 +437,7 @@ pub const Symbol = struct {
331	437	}
332	438
333	439	pub fn applyTargetRelocs(si: Symbol.Index, elf: *Elf) void {
	440	if (elf.ehdrField(.type) == .REL) return;
334	441	var ri = si.get(elf).target_relocs;
335	442	while (ri != .none) {
336	443	const reloc = ri.get(elf);
...	...	@@ -374,7 +481,7 @@ pub const Reloc = extern struct {
374	481	next: Reloc.Index,
375	482	loc: Symbol.Index,
376	483	target: Symbol.Index,
377		unused: u32,
	484	index: Section.RelIndex,
378	485	offset: u64,
379	486	addend: i64,
380	487
...	...	@@ -384,6 +491,16 @@ pub const Reloc = extern struct {
384	491	RISCV: std.elf.R_RISCV,
385	492	PPC64: std.elf.R_PPC64,
386	493
	494	pub fn none(elf: *Elf) Reloc.Type {
	495	return switch (elf.ehdrField(.machine)) {
	496	else => unreachable,
	497	.AARCH64 => .{ .AARCH64 = .NONE },
	498	.PPC64 => .{ .PPC64 = .NONE },
	499	.RISCV => .{ .RISCV = .NONE },
	500	.X86_64 => .{ .X86_64 = .NONE },
	501	};
	502	}
	503
387	504	pub fn absAddr(elf: *Elf) Reloc.Type {
388	505	return switch (elf.ehdrField(.machine)) {
389	506	else => unreachable,
...	...	@@ -393,12 +510,35 @@ pub const Reloc = extern struct {
393	510	.X86_64 => .{ .X86_64 = .@"64" },
394	511	};
395	512	}
	513
396	514	pub fn sizeAddr(elf: *Elf) Reloc.Type {
397	515	return switch (elf.ehdrField(.machine)) {
398	516	else => unreachable,
399	517	.X86_64 => .{ .X86_64 = .SIZE64 },
400	518	};
401	519	}
	520
	521	pub fn wrap(int: u32, elf: *Elf) Reloc.Type {
	522	return switch (elf.ehdrField(.machine)) {
	523	else => unreachable,
	524	inline .AARCH64,
	525	.PPC64,
	526	.RISCV,
	527	.X86_64,
	528	=> \|machine\| @unionInit(Reloc.Type, @tagName(machine), @enumFromInt(int)),
	529	};
	530	}
	531
	532	pub fn unwrap(rt: Reloc.Type, elf: *Elf) u32 {
	533	return switch (elf.ehdrField(.machine)) {
	534	else => unreachable,
	535	inline .AARCH64,
	536	.PPC64,
	537	.RISCV,
	538	.X86_64,
	539	=> \|machine\| @intFromEnum(@field(rt, @tagName(machine))),
	540	};
	541	}
402	542	};
403	543
404	544	pub const Index = enum(u32) {
...	...	@@ -411,6 +551,7 @@ pub const Reloc = extern struct {
411	551	};
412	552
413	553	pub fn apply(reloc: const Reloc, elf: Elf) void {
	554	assert(elf.ehdrField(.type) != .REL);
414	555	const loc_ni = reloc.loc.get(elf).ni;
415	556	switch (loc_ni) {
416	557	.none => return,
...	...	@@ -462,7 +603,7 @@ pub const Reloc = extern struct {
462	603	.TPOFF32 => {
463	604	const phdr = @field(elf.phdrSlice(), @tagName(class));
464	605	const ph = &phdr[elf.getNode(elf.ni.tls).segment];
465		assert(elf.targetLoad(&ph.type) == std.elf.PT_TLS);
	606	assert(elf.targetLoad(&ph.type) == .TLS);
466	607	std.mem.writeInt(
467	608	i32,
468	609	loc_slice[0..4],
...	...	@@ -501,6 +642,33 @@ pub const Reloc = extern struct {
501	642	.none => {},
502	643	else => \|next\| next.get(elf).prev = reloc.prev,
503	644	}
	645	switch (elf.ehdrField(.type)) {
	646	.NONE, .CORE, _ => unreachable,
	647	.REL => {
	648	const sh = reloc.loc.shndx(elf).get(elf);
	649	switch (elf.shdrPtr(sh.rela_si.shndx(elf))) {
	650	inline else => \|shdr, class\| {
	651	const Rela = class.ElfN().Rela;
	652	const ent_size = elf.targetLoad(&shdr.entsize);
	653	const start = ent_size * reloc.index.unwrap().?;
	654	const rela_slice = sh.rela_si.node(elf).slice(&elf.mf);
	655	const rela: *Rela = @ptrCast(@alignCast(
	656	rela_slice[@intCast(start)..][0..@intCast(ent_size)],
	657	));
	658	rela.* = .{
	659	.offset = @intFromEnum(sh.rela_free),
	660	.info = .{
	661	.type = @intCast(Reloc.Type.none(elf).unwrap(elf)),
	662	.sym = 0,
	663	},
	664	.addend = 0,
	665	};
	666	},
	667	}
	668	sh.rela_free = reloc.index;
	669	},
	670	.EXEC, .DYN => assert(reloc.index == .none),
	671	}
504	672	reloc.* = undefined;
505	673	}
506	674
...	...	@@ -601,6 +769,7 @@ fn create(
601	769	.tls = .none,
602	770	},
603	771	.nodes = .empty,
	772	.shdrs = .empty,
604	773	.phdrs = .empty,
605	774	.si = .{
606	775	.dynsym = .null,
...	...	@@ -611,16 +780,13 @@ fn create(
611	780	.symtab = .empty,
612	781	.shstrtab = .{
613	782	.map = .empty,
614		.size = 1,
615	783	},
616	784	.strtab = .{
617	785	.map = .empty,
618		.size = 1,
619	786	},
620	787	.dynsym = .empty,
621	788	.dynstr = .{
622	789	.map = .empty,
623		.size = 1,
624	790	},
625	791	.needed = .empty,
626	792	.inputs = .empty,
...	...	@@ -650,6 +816,7 @@ pub fn deinit(elf: *Elf) void {
650	816	const gpa = elf.base.comp.gpa;
651	817	elf.mf.deinit(gpa);
652	818	elf.nodes.deinit(gpa);
	819	elf.shdrs.deinit(gpa);
653	820	elf.phdrs.deinit(gpa);
654	821	elf.symtab.deinit(gpa);
655	822	elf.shstrtab.map.deinit(gpa);
...	...	@@ -681,11 +848,10 @@ fn initHeaders(
681	848	const comp = elf.base.comp;
682	849	const gpa = comp.gpa;
683	850	const have_dynamic_section = switch (@"type") {
684		.NONE => unreachable,
	851	.NONE, .CORE, _ => unreachable,
685	852	.REL => false,
686	853	.EXEC => comp.config.link_mode == .dynamic,
687	854	.DYN => true,
688		.CORE, _ => unreachable,
689	855	};
690	856	const addr_align: std.mem.Alignment = switch (class) {
691	857	.NONE, _ => unreachable,
...	...	@@ -693,6 +859,7 @@ fn initHeaders(
693	859	.@"64" => .@"8",
694	860	};
695	861
	862	const shnum: u32 = 1;
696	863	var phnum: u32 = 0;
697	864	const phdr_phndx = phnum;
698	865	phnum += 1;
...	...	@@ -715,8 +882,17 @@ fn initHeaders(
715	882	break :phndx phnum;
716	883	} else undefined;
717	884
718		const expected_nodes_len = 5 + phnum * 2 + @as(usize, 2) * @intFromBool(have_dynamic_section);
	885	const expected_nodes_len = expected_nodes_len: switch (@"type") {
	886	.NONE, .CORE, _ => unreachable,
	887	.REL => {
	888	defer phnum = 0;
	889	break :expected_nodes_len 5 + phnum;
	890	},
	891	.EXEC, .DYN => break :expected_nodes_len 5 + phnum * 2 +
	892	@as(usize, 2) * @intFromBool(have_dynamic_section),
	893	};
719	894	try elf.nodes.ensureTotalCapacity(gpa, expected_nodes_len);
	895	try elf.shdrs.ensureTotalCapacity(gpa, shnum);
720	896	try elf.phdrs.resize(gpa, phnum);
721	897	elf.nodes.appendAssumeCapacity(.file);
722	898
...	...	@@ -751,7 +927,7 @@ fn initHeaders(
751	927	ehdr.phentsize = @sizeOf(ElfN.Phdr);
752	928	ehdr.phnum = @min(phnum, std.elf.PN_XNUM);
753	929	ehdr.shentsize = @sizeOf(ElfN.Shdr);
754		ehdr.shnum = 1;
	930	ehdr.shnum = if (shnum < std.elf.SHN_LORESERVE) shnum else 0;
755	931	ehdr.shstrndx = std.elf.SHN_UNDEF;
756	932	if (elf.targetEndian() != native_endian) std.mem.byteSwapAllFields(ElfN.Ehdr, ehdr);
757	933	},
...	...	@@ -759,181 +935,187 @@ fn initHeaders(
759	935
760	936	assert(elf.ni.shdr == try elf.mf.addLastChildNode(gpa, elf.ni.file, .{
761	937	.size = elf.ehdrField(.shentsize) * elf.ehdrField(.shnum),
762		.alignment = addr_align,
	938	.alignment = elf.mf.flags.block_size,
763	939	.moved = true,
764	940	.resized = true,
765	941	}));
766	942	elf.nodes.appendAssumeCapacity(.shdr);
767	943
768		assert(elf.ni.rodata == try elf.mf.addLastChildNode(gpa, elf.ni.file, .{
769		.alignment = elf.mf.flags.block_size,
770		.moved = true,
771		.bubbles_moved = false,
772		}));
773		elf.nodes.appendAssumeCapacity(.{ .segment = rodata_phndx });
774		elf.phdrs.items[rodata_phndx] = elf.ni.rodata;
	944	var ph_vaddr: u32 = if (@"type" != .REL) ph_vaddr: {
	945	assert(elf.ni.rodata == try elf.mf.addLastChildNode(gpa, elf.ni.file, .{
	946	.alignment = elf.mf.flags.block_size,
	947	.moved = true,
	948	.bubbles_moved = false,
	949	}));
	950	elf.nodes.appendAssumeCapacity(.{ .segment = rodata_phndx });
	951	elf.phdrs.items[rodata_phndx] = elf.ni.rodata;
775	952
776		assert(elf.ni.phdr == try elf.mf.addOnlyChildNode(gpa, elf.ni.rodata, .{
777		.size = elf.ehdrField(.phentsize) * elf.ehdrField(.phnum),
778		.alignment = addr_align,
779		.moved = true,
780		.resized = true,
781		.bubbles_moved = false,
782		}));
783		elf.nodes.appendAssumeCapacity(.{ .segment = phdr_phndx });
784		elf.phdrs.items[phdr_phndx] = elf.ni.phdr;
	953	assert(elf.ni.phdr == try elf.mf.addOnlyChildNode(gpa, elf.ni.rodata, .{
	954	.size = elf.ehdrField(.phentsize) * elf.ehdrField(.phnum),
	955	.alignment = addr_align,
	956	.moved = true,
	957	.resized = true,
	958	.bubbles_moved = false,
	959	}));
	960	elf.nodes.appendAssumeCapacity(.{ .segment = phdr_phndx });
	961	elf.phdrs.items[phdr_phndx] = elf.ni.phdr;
785	962
786		assert(elf.ni.text == try elf.mf.addLastChildNode(gpa, elf.ni.file, .{
787		.alignment = elf.mf.flags.block_size,
788		.moved = true,
789		.bubbles_moved = false,
790		}));
791		elf.nodes.appendAssumeCapacity(.{ .segment = text_phndx });
792		elf.phdrs.items[text_phndx] = elf.ni.text;
	963	assert(elf.ni.text == try elf.mf.addLastChildNode(gpa, elf.ni.file, .{
	964	.alignment = elf.mf.flags.block_size,
	965	.moved = true,
	966	.bubbles_moved = false,
	967	}));
	968	elf.nodes.appendAssumeCapacity(.{ .segment = text_phndx });
	969	elf.phdrs.items[text_phndx] = elf.ni.text;
793	970
794		assert(elf.ni.data == try elf.mf.addLastChildNode(gpa, elf.ni.file, .{
795		.alignment = elf.mf.flags.block_size,
796		.moved = true,
797		.bubbles_moved = false,
798		}));
799		elf.nodes.appendAssumeCapacity(.{ .segment = data_phndx });
800		elf.phdrs.items[data_phndx] = elf.ni.data;
801
802		var ph_vaddr: u32 = switch (elf.ehdrField(.type)) {
803		else => 0,
804		.EXEC => switch (elf.ehdrField(.machine)) {
805		.@"386" => 0x400000,
806		.AARCH64, .X86_64 => 0x200000,
807		.PPC, .PPC64 => 0x10000000,
808		.S390, .S390_OLD => 0x1000000,
809		.OLD_SPARCV9, .SPARCV9 => 0x100000,
810		else => 0x10000,
811		},
812		};
	971	assert(elf.ni.data == try elf.mf.addLastChildNode(gpa, elf.ni.file, .{
	972	.alignment = elf.mf.flags.block_size,
	973	.moved = true,
	974	.bubbles_moved = false,
	975	}));
	976	elf.nodes.appendAssumeCapacity(.{ .segment = data_phndx });
	977	elf.phdrs.items[data_phndx] = elf.ni.data;
	978
	979	break :ph_vaddr switch (elf.ehdrField(.type)) {
	980	.NONE, .CORE, _ => unreachable,
	981	.REL, .DYN => 0,
	982	.EXEC => switch (elf.ehdrField(.machine)) {
	983	.@"386" => 0x400000,
	984	.AARCH64, .X86_64 => 0x200000,
	985	.PPC, .PPC64 => 0x10000000,
	986	.S390, .S390_OLD => 0x1000000,
	987	.OLD_SPARCV9, .SPARCV9 => 0x100000,
	988	else => 0x10000,
	989	},
	990	};
	991	} else undefined;
813	992	switch (class) {
814	993	.NONE, _ => unreachable,
815	994	inline else => \|ct_class\| {
816	995	const ElfN = ct_class.ElfN();
817	996	const target_endian = elf.targetEndian();
818	997
819		const phdr: []ElfN.Phdr = @ptrCast(@alignCast(elf.ni.phdr.slice(&elf.mf)));
820		const ph_phdr = &phdr[phdr_phndx];
821		ph_phdr.* = .{
822		.type = std.elf.PT_PHDR,
823		.offset = 0,
824		.vaddr = 0,
825		.paddr = 0,
826		.filesz = 0,
827		.memsz = 0,
828		.flags = .{ .R = true },
829		.@"align" = @intCast(elf.ni.phdr.alignment(&elf.mf).toByteUnits()),
830		};
831		if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_phdr);
832
833		if (maybe_interp) \|_\| {
834		const ph_interp = &phdr[interp_phndx];
835		ph_interp.* = .{
836		.type = std.elf.PT_INTERP,
	998	if (@"type" != .REL) {
	999	const phdr: []ElfN.Phdr = @ptrCast(@alignCast(elf.ni.phdr.slice(&elf.mf)));
	1000	const ph_phdr = &phdr[phdr_phndx];
	1001	ph_phdr.* = .{
	1002	.type = .PHDR,
837	1003	.offset = 0,
838	1004	.vaddr = 0,
839	1005	.paddr = 0,
840	1006	.filesz = 0,
841	1007	.memsz = 0,
842	1008	.flags = .{ .R = true },
843		.@"align" = 1,
	1009	.@"align" = @intCast(elf.ni.phdr.alignment(&elf.mf).toByteUnits()),
844	1010	};
845		if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_interp);
846		}
847
848		_, const rodata_size = elf.ni.rodata.location(&elf.mf).resolve(&elf.mf);
849		const ph_rodata = &phdr[rodata_phndx];
850		ph_rodata.* = .{
851		.type = std.elf.PT_NULL,
852		.offset = 0,
853		.vaddr = ph_vaddr,
854		.paddr = ph_vaddr,
855		.filesz = @intCast(rodata_size),
856		.memsz = @intCast(rodata_size),
857		.flags = .{ .R = true },
858		.@"align" = @intCast(elf.ni.rodata.alignment(&elf.mf).toByteUnits()),
859		};
860		if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_rodata);
861		ph_vaddr += @intCast(rodata_size);
862
863		_, const text_size = elf.ni.text.location(&elf.mf).resolve(&elf.mf);
864		const ph_text = &phdr[text_phndx];
865		ph_text.* = .{
866		.type = std.elf.PT_NULL,
867		.offset = 0,
868		.vaddr = ph_vaddr,
869		.paddr = ph_vaddr,
870		.filesz = @intCast(text_size),
871		.memsz = @intCast(text_size),
872		.flags = .{ .R = true, .X = true },
873		.@"align" = @intCast(elf.ni.text.alignment(&elf.mf).toByteUnits()),
874		};
875		if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_text);
876		ph_vaddr += @intCast(text_size);
	1011	if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_phdr);
	1012
	1013	if (maybe_interp) \|_\| {
	1014	const ph_interp = &phdr[interp_phndx];
	1015	ph_interp.* = .{
	1016	.type = .INTERP,
	1017	.offset = 0,
	1018	.vaddr = 0,
	1019	.paddr = 0,
	1020	.filesz = 0,
	1021	.memsz = 0,
	1022	.flags = .{ .R = true },
	1023	.@"align" = 1,
	1024	};
	1025	if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_interp);
	1026	}
877	1027
878		_, const data_size = elf.ni.data.location(&elf.mf).resolve(&elf.mf);
879		const ph_data = &phdr[data_phndx];
880		ph_data.* = .{
881		.type = std.elf.PT_NULL,
882		.offset = 0,
883		.vaddr = ph_vaddr,
884		.paddr = ph_vaddr,
885		.filesz = @intCast(data_size),
886		.memsz = @intCast(data_size),
887		.flags = .{ .R = true, .W = true },
888		.@"align" = @intCast(elf.ni.data.alignment(&elf.mf).toByteUnits()),
889		};
890		if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_data);
891		ph_vaddr += @intCast(data_size);
	1028	_, const rodata_size = elf.ni.rodata.location(&elf.mf).resolve(&elf.mf);
	1029	const ph_rodata = &phdr[rodata_phndx];
	1030	ph_rodata.* = .{
	1031	.type = if (rodata_size == 0) .NULL else .LOAD,
	1032	.offset = 0,
	1033	.vaddr = ph_vaddr,
	1034	.paddr = ph_vaddr,
	1035	.filesz = @intCast(rodata_size),
	1036	.memsz = @intCast(rodata_size),
	1037	.flags = .{ .R = true },
	1038	.@"align" = @intCast(elf.ni.rodata.alignment(&elf.mf).toByteUnits()),
	1039	};
	1040	if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_rodata);
	1041	ph_vaddr += @intCast(rodata_size);
892	1042
893		if (have_dynamic_section) {
894		const ph_dynamic = &phdr[dynamic_phndx];
895		ph_dynamic.* = .{
896		.type = std.elf.PT_DYNAMIC,
	1043	_, const text_size = elf.ni.text.location(&elf.mf).resolve(&elf.mf);
	1044	const ph_text = &phdr[text_phndx];
	1045	ph_text.* = .{
	1046	.type = if (text_size == 0) .NULL else .LOAD,
897	1047	.offset = 0,
898		.vaddr = 0,
899		.paddr = 0,
900		.filesz = 0,
901		.memsz = 0,
902		.flags = .{ .R = true, .W = true },
903		.@"align" = @intCast(addr_align.toByteUnits()),
	1048	.vaddr = ph_vaddr,
	1049	.paddr = ph_vaddr,
	1050	.filesz = @intCast(text_size),
	1051	.memsz = @intCast(text_size),
	1052	.flags = .{ .R = true, .X = true },
	1053	.@"align" = @intCast(elf.ni.text.alignment(&elf.mf).toByteUnits()),
904	1054	};
905		if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_dynamic);
906		}
	1055	if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_text);
	1056	ph_vaddr += @intCast(text_size);
907	1057
908		if (comp.config.any_non_single_threaded) {
909		const ph_tls = &phdr[tls_phndx];
910		ph_tls.* = .{
911		.type = std.elf.PT_TLS,
	1058	_, const data_size = elf.ni.data.location(&elf.mf).resolve(&elf.mf);
	1059	const ph_data = &phdr[data_phndx];
	1060	ph_data.* = .{
	1061	.type = if (data_size == 0) .NULL else .LOAD,
912	1062	.offset = 0,
913		.vaddr = 0,
914		.paddr = 0,
915		.filesz = 0,
916		.memsz = 0,
917		.flags = .{ .R = true },
918		.@"align" = @intCast(elf.mf.flags.block_size.toByteUnits()),
	1063	.vaddr = ph_vaddr,
	1064	.paddr = ph_vaddr,
	1065	.filesz = @intCast(data_size),
	1066	.memsz = @intCast(data_size),
	1067	.flags = .{ .R = true, .W = true },
	1068	.@"align" = @intCast(elf.ni.data.alignment(&elf.mf).toByteUnits()),
919	1069	};
920		if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_tls);
	1070	if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_data);
	1071	ph_vaddr += @intCast(data_size);
	1072
	1073	if (have_dynamic_section) {
	1074	const ph_dynamic = &phdr[dynamic_phndx];
	1075	ph_dynamic.* = .{
	1076	.type = .DYNAMIC,
	1077	.offset = 0,
	1078	.vaddr = 0,
	1079	.paddr = 0,
	1080	.filesz = 0,
	1081	.memsz = 0,
	1082	.flags = .{ .R = true, .W = true },
	1083	.@"align" = @intCast(addr_align.toByteUnits()),
	1084	};
	1085	if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_dynamic);
	1086	}
	1087
	1088	if (comp.config.any_non_single_threaded) {
	1089	const ph_tls = &phdr[tls_phndx];
	1090	ph_tls.* = .{
	1091	.type = .TLS,
	1092	.offset = 0,
	1093	.vaddr = 0,
	1094	.paddr = 0,
	1095	.filesz = 0,
	1096	.memsz = 0,
	1097	.flags = .{ .R = true },
	1098	.@"align" = @intCast(elf.mf.flags.block_size.toByteUnits()),
	1099	};
	1100	if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_tls);
	1101	}
921	1102	}
922	1103
923		const sh_null: *ElfN.Shdr = @ptrCast(@alignCast(elf.ni.shdr.slice(&elf.mf)));
924		sh_null.* = .{
	1104	const sh_undef: *ElfN.Shdr = @ptrCast(@alignCast(elf.ni.shdr.slice(&elf.mf)));
	1105	sh_undef.* = .{
925	1106	.name = try elf.string(.shstrtab, ""),
926		.type = std.elf.SHT_NULL,
	1107	.type = .NULL,
927	1108	.flags = .{ .shf = .{} },
928	1109	.addr = 0,
929	1110	.offset = 0,
930		.size = 0,
	1111	.size = if (shnum < std.elf.SHN_LORESERVE) 0 else shnum,
931	1112	.link = 0,
932		.info = if (phnum >= std.elf.PN_XNUM) phnum else 0,
	1113	.info = if (phnum < std.elf.PN_XNUM) 0 else phnum,
933	1114	.addralign = 0,
934	1115	.entsize = 0,
935	1116	};
936		if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Shdr, sh_null);
	1117	if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Shdr, sh_undef);
	1118	elf.shdrs.appendAssumeCapacity(.{ .si = .null, .rela_si = .null, .rela_free = .none });
937	1119
938	1120	try elf.symtab.ensureTotalCapacity(gpa, 1);
939	1121	elf.symtab.addOneAssumeCapacity().* = .{
...	...	@@ -943,10 +1125,11 @@ fn initHeaders(
943	1125	.unused = 0,
944	1126	};
945	1127	assert(elf.si.symtab == try elf.addSection(elf.ni.file, .{
946		.type = std.elf.SHT_SYMTAB,
	1128	.type = .SYMTAB,
947	1129	.size = @sizeOf(ElfN.Sym) * 1,
948	1130	.addralign = addr_align,
949	1131	.entsize = @sizeOf(ElfN.Sym),
	1132	.node_align = elf.mf.flags.block_size,
950	1133	}));
951	1134	const symtab_null = @field(elf.symPtr(.null), @tagName(ct_class));
952	1135	symtab_null.* = .{
...	...	@@ -960,13 +1143,14 @@ fn initHeaders(
960	1143	if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Sym, symtab_null);
961	1144
962	1145	const ehdr = @field(elf.ehdrPtr(), @tagName(ct_class));
963		ehdr.shstrndx = ehdr.shnum;
	1146	elf.targetStore(&ehdr.shstrndx, ehdr.shnum);
964	1147	},
965	1148	}
966	1149	assert(elf.si.shstrtab == try elf.addSection(elf.ni.file, .{
967		.type = std.elf.SHT_STRTAB,
968		.addralign = elf.mf.flags.block_size,
	1150	.type = .STRTAB,
	1151	.size = 1,
969	1152	.entsize = 1,
	1153	.node_align = elf.mf.flags.block_size,
970	1154	}));
971	1155	try elf.renameSection(.symtab, ".symtab");
972	1156	try elf.renameSection(.shstrtab, ".shstrtab");
...	...	@@ -974,10 +1158,10 @@ fn initHeaders(
974	1158
975	1159	assert(elf.si.strtab == try elf.addSection(elf.ni.file, .{
976	1160	.name = ".strtab",
977		.type = std.elf.SHT_STRTAB,
	1161	.type = .STRTAB,
978	1162	.size = 1,
979		.addralign = elf.mf.flags.block_size,
980	1163	.entsize = 1,
	1164	.node_align = elf.mf.flags.block_size,
981	1165	}));
982	1166	try elf.linkSections(.symtab, .strtab);
983	1167	elf.si.strtab.node(elf).slice(&elf.mf)[0] = 0;
...	...	@@ -997,87 +1181,96 @@ fn initHeaders(
997	1181	.flags = .{ .WRITE = true, .ALLOC = true },
998	1182	.addralign = elf.mf.flags.block_size,
999	1183	}));
1000		if (maybe_interp) \|interp\| {
1001		const interp_ni = try elf.mf.addLastChildNode(gpa, elf.ni.rodata, .{
1002		.size = interp.len + 1,
1003		.moved = true,
1004		.resized = true,
1005		.bubbles_moved = false,
1006		});
1007		elf.nodes.appendAssumeCapacity(.{ .segment = interp_phndx });
1008		elf.phdrs.items[interp_phndx] = interp_ni;
1009
1010		const sec_interp_si = try elf.addSection(interp_ni, .{
1011		.name = ".interp",
1012		.flags = .{ .ALLOC = true },
1013		.size = @intCast(interp.len + 1),
1014		});
1015		const sec_interp = sec_interp_si.node(elf).slice(&elf.mf);
1016		@memcpy(sec_interp[0..interp.len], interp);
1017		sec_interp[interp.len] = 0;
1018		}
1019		if (have_dynamic_section) {
1020		const dynamic_ni = try elf.mf.addLastChildNode(gpa, elf.ni.data, .{
1021		.moved = true,
1022		.bubbles_moved = false,
1023		});
1024		elf.nodes.appendAssumeCapacity(.{ .segment = dynamic_phndx });
1025		elf.phdrs.items[dynamic_phndx] = dynamic_ni;
1026
1027		switch (class) {
1028		.NONE, _ => unreachable,
1029		inline else => \|ct_class\| {
1030		const ElfN = ct_class.ElfN();
1031		elf.si.dynsym = try elf.addSection(elf.ni.rodata, .{
1032		.name = ".dynsym",
1033		.type = std.elf.SHT_DYNSYM,
1034		.size = @sizeOf(ElfN.Sym) * 1,
1035		.addralign = addr_align,
1036		.entsize = @sizeOf(ElfN.Sym),
1037		});
1038		const dynsym_null = &@field(elf.dynsymSlice(), @tagName(ct_class))[0];
1039		dynsym_null.* = .{
1040		.name = try elf.string(.dynstr, ""),
1041		.value = 0,
1042		.size = 0,
1043		.info = .{ .type = .NOTYPE, .bind = .LOCAL },
1044		.other = .{ .visibility = .DEFAULT },
1045		.shndx = std.elf.SHN_UNDEF,
1046		};
1047		if (elf.targetEndian() != native_endian) std.mem.byteSwapAllFields(ElfN.Sym, dynsym_null);
1048		},
	1184	if (@"type" != .REL) {
	1185	if (maybe_interp) \|interp\| {
	1186	const interp_ni = try elf.mf.addLastChildNode(gpa, elf.ni.rodata, .{
	1187	.size = interp.len + 1,
	1188	.moved = true,
	1189	.resized = true,
	1190	.bubbles_moved = false,
	1191	});
	1192	elf.nodes.appendAssumeCapacity(.{ .segment = interp_phndx });
	1193	elf.phdrs.items[interp_phndx] = interp_ni;
	1194
	1195	const sec_interp_si = try elf.addSection(interp_ni, .{
	1196	.type = .PROGBITS,
	1197	.name = ".interp",
	1198	.flags = .{ .ALLOC = true },
	1199	.size = @intCast(interp.len + 1),
	1200	});
	1201	const sec_interp = sec_interp_si.node(elf).slice(&elf.mf);
	1202	@memcpy(sec_interp[0..interp.len], interp);
	1203	sec_interp[interp.len] = 0;
1049	1204	}
1050		elf.si.dynstr = try elf.addSection(elf.ni.rodata, .{
1051		.name = ".dynstr",
1052		.type = std.elf.SHT_STRTAB,
1053		.size = 1,
1054		.addralign = elf.mf.flags.block_size,
1055		.entsize = 1,
1056		});
1057		elf.si.dynamic = try elf.addSection(dynamic_ni, .{
1058		.name = ".dynamic",
1059		.type = std.elf.SHT_DYNAMIC,
1060		.flags = .{ .ALLOC = true, .WRITE = true },
1061		.addralign = addr_align,
1062		});
1063		try elf.linkSections(elf.si.dynamic, elf.si.dynstr);
1064		try elf.linkSections(elf.si.dynsym, elf.si.dynstr);
1065		}
1066		if (comp.config.any_non_single_threaded) {
1067		elf.ni.tls = try elf.mf.addLastChildNode(gpa, elf.ni.rodata, .{
1068		.alignment = elf.mf.flags.block_size,
1069		.moved = true,
1070		.bubbles_moved = false,
1071		});
1072		elf.nodes.appendAssumeCapacity(.{ .segment = tls_phndx });
1073		elf.phdrs.items[tls_phndx] = elf.ni.tls;
	1205	if (have_dynamic_section) {
	1206	const dynamic_ni = try elf.mf.addLastChildNode(gpa, elf.ni.data, .{
	1207	.moved = true,
	1208	.bubbles_moved = false,
	1209	});
	1210	elf.nodes.appendAssumeCapacity(.{ .segment = dynamic_phndx });
	1211	elf.phdrs.items[dynamic_phndx] = dynamic_ni;
1074	1212
1075		elf.si.tdata = try elf.addSection(elf.ni.tls, .{
1076		.name = ".tdata",
1077		.flags = .{ .WRITE = true, .ALLOC = true, .TLS = true },
1078		.addralign = elf.mf.flags.block_size,
1079		});
	1213	switch (class) {
	1214	.NONE, _ => unreachable,
	1215	inline else => \|ct_class\| {
	1216	const Sym = ct_class.ElfN().Sym;
	1217	elf.si.dynsym = try elf.addSection(elf.ni.rodata, .{
	1218	.name = ".dynsym",
	1219	.type = .DYNSYM,
	1220	.size = @sizeOf(Sym) * 1,
	1221	.addralign = addr_align,
	1222	.entsize = @sizeOf(Sym),
	1223	.node_align = elf.mf.flags.block_size,
	1224	});
	1225	const dynsym_null = &@field(elf.dynsymSlice(), @tagName(ct_class))[0];
	1226	dynsym_null.* = .{
	1227	.name = try elf.string(.dynstr, ""),
	1228	.value = 0,
	1229	.size = 0,
	1230	.info = .{ .type = .NOTYPE, .bind = .LOCAL },
	1231	.other = .{ .visibility = .DEFAULT },
	1232	.shndx = std.elf.SHN_UNDEF,
	1233	};
	1234	if (elf.targetEndian() != native_endian) std.mem.byteSwapAllFields(
	1235	Sym,
	1236	dynsym_null,
	1237	);
	1238	},
	1239	}
	1240	elf.si.dynstr = try elf.addSection(elf.ni.rodata, .{
	1241	.name = ".dynstr",
	1242	.type = .STRTAB,
	1243	.size = 1,
	1244	.entsize = 1,
	1245	.node_align = elf.mf.flags.block_size,
	1246	});
	1247	elf.si.dynamic = try elf.addSection(dynamic_ni, .{
	1248	.name = ".dynamic",
	1249	.type = .DYNAMIC,
	1250	.flags = .{ .ALLOC = true, .WRITE = true },
	1251	.node_align = addr_align,
	1252	});
	1253	try elf.linkSections(elf.si.dynamic, elf.si.dynstr);
	1254	try elf.linkSections(elf.si.dynsym, elf.si.dynstr);
	1255	}
	1256	if (comp.config.any_non_single_threaded) {
	1257	elf.ni.tls = try elf.mf.addLastChildNode(gpa, elf.ni.rodata, .{
	1258	.alignment = elf.mf.flags.block_size,
	1259	.moved = true,
	1260	.bubbles_moved = false,
	1261	});
	1262	elf.nodes.appendAssumeCapacity(.{ .segment = tls_phndx });
	1263	elf.phdrs.items[tls_phndx] = elf.ni.tls;
	1264	}
	1265	} else {
	1266	assert(maybe_interp == null);
	1267	assert(!have_dynamic_section);
1080	1268	}
	1269	if (comp.config.any_non_single_threaded) elf.si.tdata = try elf.addSection(elf.ni.tls, .{
	1270	.name = ".tdata",
	1271	.flags = .{ .WRITE = true, .ALLOC = true, .TLS = true },
	1272	.addralign = elf.mf.flags.block_size,
	1273	});
1081	1274	assert(elf.nodes.len == expected_nodes_len);
1082	1275	}
1083	1276
...	...	@@ -1116,7 +1309,7 @@ fn computeNodeVAddr(elf: *Elf, ni: MappedFile.Node.Index) u64 {
1116	1309	.file => return 0,
1117	1310	.ehdr, .shdr => unreachable,
1118	1311	.segment => \|phndx\| break :parent_vaddr switch (elf.phdrSlice()) {
1119		inline else => \|ph\| elf.targetLoad(&ph[phndx].vaddr),
	1312	inline else => \|phdr\| elf.targetLoad(&phdr[phndx].vaddr),
1120	1313	},
1121	1314	.section => \|si\| si,
1122	1315	.input_section => unreachable,
...	...	@@ -1202,6 +1395,7 @@ pub const PhdrSlice = union(std.elf.CLASS) {
1202	1395	@"64": []std.elf.Elf64.Phdr,
1203	1396	};
1204	1397	pub fn phdrSlice(elf: *Elf) PhdrSlice {
	1398	assert(elf.ehdrField(.type) != .REL);
1205	1399	const slice = elf.ni.phdr.slice(&elf.mf);
1206	1400	return switch (elf.identClass()) {
1207	1401	.NONE, _ => unreachable,
...	...	@@ -1230,6 +1424,17 @@ pub fn shdrSlice(elf: *Elf) ShdrSlice {
1230	1424	};
1231	1425	}
1232	1426
	1427	pub const ShdrPtr = union(std.elf.CLASS) {
	1428	NONE: noreturn,
	1429	@"32": *std.elf.Elf32.Shdr,
	1430	@"64": *std.elf.Elf64.Shdr,
	1431	};
	1432	pub fn shdrPtr(elf: *Elf, shndx: Symbol.Index.Shndx) ShdrPtr {
	1433	return switch (elf.shdrSlice()) {
	1434	inline else => \|shdrs, class\| @unionInit(ShdrPtr, @tagName(class), &shdrs[@intFromEnum(shndx)]),
	1435	};
	1436	}
	1437
1233	1438	pub const SymtabSlice = union(std.elf.CLASS) {
1234	1439	NONE: noreturn,
1235	1440	@"32": []std.elf.Elf32.Sym,
...	...	@@ -1242,7 +1447,11 @@ pub fn symtabSlice(elf: *Elf) SymtabSlice {
1242	1447	inline else => \|class\| @unionInit(
1243	1448	SymtabSlice,
1244	1449	@tagName(class),
1245		@ptrCast(@alignCast(slice)),
	1450	@ptrCast(@alignCast(slice[0..std.mem.alignBackwardAnyAlign(
	1451	usize,
	1452	slice.len,
	1453	@sizeOf(class.ElfN().Sym),
	1454	)])),
1246	1455	),
1247	1456	};
1248	1457	}
...	...	@@ -1254,7 +1463,7 @@ pub const SymPtr = union(std.elf.CLASS) {
1254	1463	};
1255	1464	pub fn symPtr(elf: *Elf, si: Symbol.Index) SymPtr {
1256	1465	return switch (elf.symtabSlice()) {
1257		inline else => \|sym, class\| @unionInit(SymPtr, @tagName(class), &sym[@intFromEnum(si)]),
	1466	inline else => \|syms, class\| @unionInit(SymPtr, @tagName(class), &syms[@intFromEnum(si)]),
1258	1467	};
1259	1468	}
1260	1469
...	...	@@ -1544,7 +1753,7 @@ fn loadObject(
1544	1753	.si = try elf.initSymbolAssumeCapacity(.{
1545	1754	.name = std.fs.path.stem(member orelse path.sub_path),
1546	1755	.type = .FILE,
1547		.shndx = std.elf.SHN_ABS,
	1756	.shndx = .ABS,
1548	1757	}),
1549	1758	};
1550	1759	const target_endian = elf.targetEndian();
...	...	@@ -1571,7 +1780,7 @@ fn loadObject(
1571	1780	};
1572	1781	try r.discardAll(ehdr.shentsize);
1573	1782	switch (section.shdr.type) {
1574		std.elf.SHT_NULL, std.elf.SHT_NOBITS => {},
	1783	.NULL, .NOBITS => {},
1575	1784	else => if (section.shdr.offset + section.shdr.size > fl.size)
1576	1785	return diags.failParse(path, "bad section location", .{}),
1577	1786	}
...	...	@@ -1580,8 +1789,7 @@ fn loadObject(
1580	1789	if (ehdr.shstrndx == std.elf.SHN_UNDEF or ehdr.shstrndx >= ehdr.shnum)
1581	1790	return diags.failParse(path, "missing section names", .{});
1582	1791	const shdr = &sections[ehdr.shstrndx].shdr;
1583		if (shdr.type != std.elf.SHT_STRTAB)
1584		return diags.failParse(path, "invalid shstrtab type", .{});
	1792	if (shdr.type != .STRTAB) return diags.failParse(path, "invalid shstrtab type", .{});
1585	1793	const shstrtab = try gpa.alloc(u8, @intCast(shdr.size));
1586	1794	errdefer gpa.free(shstrtab);
1587	1795	try fr.seekTo(fl.offset + shdr.offset);
...	...	@@ -1594,7 +1802,7 @@ fn loadObject(
1594	1802	try elf.input_sections.ensureUnusedCapacity(gpa, ehdr.shnum - 1);
1595	1803	for (sections[1..]) \|*section\| switch (section.shdr.type) {
1596	1804	else => {},
1597		std.elf.SHT_PROGBITS, std.elf.SHT_NOBITS => {
	1805	.PROGBITS, .NOBITS => {
1598	1806	if (section.shdr.name >= shstrtab.len) continue;
1599	1807	const name = std.mem.sliceTo(shstrtab[section.shdr.name..], 0);
1600	1808	const parent_si = elf.namedSection(name) orelse continue;
...	...	@@ -1611,7 +1819,7 @@ fn loadObject(
1611	1819	});
1612	1820	section.si = try elf.initSymbolAssumeCapacity(.{
1613	1821	.type = .SECTION,
1614		.shndx = elf.targetLoad(&@field(elf.symPtr(parent_si), @tagName(class)).shndx),
	1822	.shndx = parent_si.shndx(elf),
1615	1823	});
1616	1824	section.si.get(elf).ni = ni;
1617	1825	elf.input_sections.addOneAssumeCapacity().* = .{
...	...	@@ -1629,14 +1837,14 @@ fn loadObject(
1629	1837	defer symmap.deinit(gpa);
1630	1838	for (sections[1..], 1..) \|*symtab, symtab_shndx\| switch (symtab.shdr.type) {
1631	1839	else => {},
1632		std.elf.SHT_SYMTAB => {
	1840	.SYMTAB => {
1633	1841	if (symtab.shdr.entsize < @sizeOf(ElfN.Sym))
1634	1842	return diags.failParse(path, "unsupported symtab entsize", .{});
1635	1843	const strtab = strtab: {
1636	1844	if (symtab.shdr.link == std.elf.SHN_UNDEF or symtab.shdr.link >= ehdr.shnum)
1637	1845	return diags.failParse(path, "missing symbol names", .{});
1638	1846	const shdr = &sections[symtab.shdr.link].shdr;
1639		if (shdr.type != std.elf.SHT_STRTAB)
	1847	if (shdr.type != .STRTAB)
1640	1848	return diags.failParse(path, "invalid strtab type", .{});
1641	1849	const strtab = try gpa.alloc(u8, @intCast(shdr.size));
1642	1850	errdefer gpa.free(strtab);
...	...	@@ -1683,9 +1891,7 @@ fn loadObject(
1683	1891	.type = input_sym.info.type,
1684	1892	.bind = input_sym.info.bind,
1685	1893	.visibility = input_sym.other.visibility,
1686		.shndx = elf.targetLoad(switch (elf.symPtr(parent_si)) {
1687		inline else => \|parent_sym\| &parent_sym.shndx,
1688		}),
	1894	.shndx = parent_si.shndx(elf),
1689	1895	});
1690	1896	si.get(elf).ni = parent_si.get(elf).ni;
1691	1897	switch (input_sym.info.bind) {
...	...	@@ -1719,13 +1925,13 @@ fn loadObject(
1719	1925	}
1720	1926	for (sections[1..]) \|*rels\| switch (rels.shdr.type) {
1721	1927	else => {},
1722		inline std.elf.SHT_REL, std.elf.SHT_RELA => \|sht\| {
	1928	inline .REL, .RELA => \|sht\| {
1723	1929	if (rels.shdr.link != symtab_shndx or rels.shdr.info == std.elf.SHN_UNDEF or
1724	1930	rels.shdr.info >= ehdr.shnum) continue;
1725	1931	const Rel = switch (sht) {
1726	1932	else => comptime unreachable,
1727		std.elf.SHT_REL => ElfN.Rel,
1728		std.elf.SHT_RELA => ElfN.Rela,
	1933	.REL => ElfN.Rel,
	1934	.RELA => ElfN.Rela,
1729	1935	};
1730	1936	if (rels.shdr.entsize < @sizeOf(Rel))
1731	1937	return diags.failParse(path, "unsupported rel entsize", .{});
...	...	@@ -1740,7 +1946,7 @@ fn loadObject(
1740	1946	"relocation section size (0x{x}) is not a multiple of entsize (0x{x})",
1741	1947	.{ rels.shdr.size, rels.shdr.entsize },
1742	1948	);
1743		try elf.relocs.ensureUnusedCapacity(gpa, relnum);
	1949	try elf.ensureUnusedRelocCapacity(loc_sec.si, relnum);
1744	1950	try fr.seekTo(fl.offset + rels.shdr.offset);
1745	1951	for (0..relnum) \|_\| {
1746	1952	const rel = try r.peekStruct(Rel, target_endian);
...	...	@@ -1753,18 +1959,7 @@ fn loadObject(
1753	1959	rel.offset - loc_sec.shdr.addr,
1754	1960	target_si,
1755	1961	rel.addend,
1756		switch (elf.ehdrField(.machine)) {
1757		else => unreachable,
1758		inline .AARCH64,
1759		.PPC64,
1760		.RISCV,
1761		.X86_64,
1762		=> \|machine\| @unionInit(
1763		Reloc.Type,
1764		@tagName(machine),
1765		@enumFromInt(rel.info.type),
1766		),
1767		},
	1962	.wrap(rel.info.type, elf),
1768	1963	);
1769	1964	}
1770	1965	},
...	...	@@ -1800,7 +1995,7 @@ fn loadDso(elf: Elf, path: std.Build.Cache.Path, fr: std.Io.File.Reader) !void
1800	1995	try r.discardAll(ehdr.phentsize);
1801	1996	switch (ph.type) {
1802	1997	else => {},
1803		std.elf.PT_DYNAMIC => break ph,
	1998	.DYNAMIC => break ph,
1804	1999	}
1805	2000	} else return diags.failParse(path, "no dynamic segment", .{});
1806	2001	const dynnum = std.math.divExact(
...	...	@@ -1817,13 +2012,13 @@ fn loadDso(elf: Elf, path: std.Build.Cache.Path, fr: std.Io.File.Reader) !void
1817	2012	var soname: ?ElfN.Addr = null;
1818	2013	try fr.seekTo(dynamic_ph.offset);
1819	2014	for (0..dynnum) \|_\| {
1820		const key = try r.takeInt(ElfN.Addr, target_endian);
1821		const value = try r.takeInt(ElfN.Addr, target_endian);
1822		switch (key) {
	2015	const tag = try r.takeInt(ElfN.Addr, target_endian);
	2016	const val = try r.takeInt(ElfN.Addr, target_endian);
	2017	switch (tag) {
1823	2018	else => {},
1824		std.elf.DT_STRTAB => strtab = value,
1825		std.elf.DT_STRSZ => strsz = value,
1826		std.elf.DT_SONAME => soname = value,
	2019	std.elf.DT_STRTAB => strtab = val,
	2020	std.elf.DT_STRSZ => strsz = val,
	2021	std.elf.DT_SONAME => soname = val,
1827	2022	}
1828	2023	}
1829	2024	if (strtab == null or soname == null)
...	...	@@ -1836,7 +2031,7 @@ fn loadDso(elf: Elf, path: std.Build.Cache.Path, fr: std.Io.File.Reader) !void
1836	2031	try r.discardAll(ehdr.phentsize);
1837	2032	switch (ph.type) {
1838	2033	else => {},
1839		std.elf.PT_LOAD => if (strtab.? >= ph.vaddr and
	2034	.LOAD => if (strtab.? >= ph.vaddr and
1840	2035	strtab.? + (strsz orelse 0) <= ph.vaddr + ph.filesz) break ph,
1841	2036	}
1842	2037	} else return diags.failParse(path, "strtab not part of a loaded segment", .{});
...	...	@@ -1868,11 +2063,7 @@ fn prelinkInner(elf: *Elf) !void {
1868	2063	std.fs.path.stem(elf.base.emit.sub_path),
1869	2064	});
1870	2065	defer gpa.free(zcu_name);
1871		const si = try elf.initSymbolAssumeCapacity(.{
1872		.name = zcu_name,
1873		.type = .FILE,
1874		.shndx = std.elf.SHN_ABS,
1875		});
	2066	const si = try elf.initSymbolAssumeCapacity(.{ .name = zcu_name, .type = .FILE, .shndx = .ABS });
1876	2067	elf.inputs.addOneAssumeCapacity().* = .{
1877	2068	.path = elf.base.emit,
1878	2069	.member = null,
...	...	@@ -1972,63 +2163,87 @@ pub fn getVAddr(elf: *Elf, reloc_info: link.File.RelocInfo, target_si: Symbol.In
1972	2163
1973	2164	fn addSection(elf: *Elf, segment_ni: MappedFile.Node.Index, opts: struct {
1974	2165	name: []const u8 = "",
1975		type: std.elf.Word = std.elf.SHT_NULL,
	2166	type: std.elf.SHT = .NULL,
1976	2167	flags: std.elf.SHF = .{},
1977		size: std.elf.Word = 0,
	2168	size: std.elf.Xword = 0,
	2169	link: std.elf.Word = 0,
	2170	info: std.elf.Word = 0,
1978	2171	addralign: std.mem.Alignment = .@"1",
1979	2172	entsize: std.elf.Word = 0,
	2173	node_align: std.mem.Alignment = .@"1",
1980	2174	}) !Symbol.Index {
1981	2175	switch (opts.type) {
1982		std.elf.SHT_NULL => assert(opts.size == 0),
1983		std.elf.SHT_PROGBITS => assert(opts.size > 0),
	2176	.NULL => assert(opts.size == 0),
	2177	.PROGBITS => assert(opts.size > 0),
1984	2178	else => {},
1985	2179	}
1986	2180	const gpa = elf.base.comp.gpa;
1987	2181	try elf.nodes.ensureUnusedCapacity(gpa, 1);
	2182	try elf.shdrs.ensureUnusedCapacity(gpa, 1);
1988	2183	try elf.symtab.ensureUnusedCapacity(gpa, 1);
1989	2184
1990	2185	const shstrtab_entry = try elf.string(.shstrtab, opts.name);
1991		const shndx, const shdr_size = shndx: switch (elf.ehdrPtr()) {
1992		inline else => \|ehdr\| {
1993		const shndx = elf.targetLoad(&ehdr.shnum);
1994		const shnum = shndx + 1;
1995		elf.targetStore(&ehdr.shnum, shnum);
1996		break :shndx .{ shndx, elf.targetLoad(&ehdr.shentsize) * shnum };
	2186	const shndx: Symbol.Index.Shndx, const new_shdr_size = shndx: switch (elf.ehdrPtr()) {
	2187	inline else => \|ehdr, class\| {
	2188	const shndx, const shnum = alloc_shndx: switch (elf.targetLoad(&ehdr.shnum)) {
	2189	1...std.elf.SHN_LORESERVE - 2 => \|shndx\| {
	2190	const shnum = shndx + 1;
	2191	elf.targetStore(&ehdr.shnum, shnum);
	2192	break :alloc_shndx .{ shndx, shnum };
	2193	},
	2194	std.elf.SHN_LORESERVE - 1 => \|shndx\| {
	2195	const shnum = shndx + 1;
	2196	elf.targetStore(&ehdr.shnum, 0);
	2197	elf.targetStore(&@field(elf.shdrPtr(.UNDEF), @tagName(class)).size, shnum);
	2198	break :alloc_shndx .{ shndx, shnum };
	2199	},
	2200	std.elf.SHN_LORESERVE...std.elf.SHN_HIRESERVE => unreachable,
	2201	0 => {
	2202	const shnum_ptr = &@field(elf.shdrPtr(.UNDEF), @tagName(class)).size;
	2203	const shndx: u32 = @intCast(elf.targetLoad(shnum_ptr));
	2204	const shnum = shndx + 1;
	2205	elf.targetStore(shnum_ptr, shnum);
	2206	break :alloc_shndx .{ shndx, shnum };
	2207	},
	2208	};
	2209	assert(shndx < @intFromEnum(Symbol.Index.Shndx.LORESERVE));
	2210	break :shndx .{ @enumFromInt(shndx), elf.targetLoad(&ehdr.shentsize) * shnum };
1997	2211	},
1998	2212	};
1999		try elf.ni.shdr.resize(&elf.mf, gpa, shdr_size);
2000		const ni = try elf.mf.addLastChildNode(gpa, segment_ni, .{
2001		.alignment = opts.addralign,
	2213	_, const shdr_node_size = elf.ni.shdr.location(&elf.mf).resolve(&elf.mf);
	2214	if (new_shdr_size > shdr_node_size)
	2215	try elf.ni.shdr.resize(&elf.mf, gpa, new_shdr_size +\| new_shdr_size / MappedFile.growth_factor);
	2216	const ni = try elf.mf.addLastChildNode(gpa, switch (elf.ehdrField(.type)) {
	2217	.NONE, .CORE, _ => unreachable,
	2218	.REL => elf.ni.file,
	2219	.EXEC, .DYN => segment_ni,
	2220	}, .{
	2221	.alignment = opts.addralign.max(opts.node_align),
2002	2222	.size = opts.size,
2003	2223	.resized = opts.size > 0,
2004	2224	});
2005	2225	const si = elf.addSymbolAssumeCapacity();
2006	2226	elf.nodes.appendAssumeCapacity(.{ .section = si });
	2227	elf.shdrs.appendAssumeCapacity(.{ .si = si, .rela_si = .null, .rela_free = .none });
2007	2228	si.get(elf).ni = ni;
2008	2229	const addr = elf.computeNodeVAddr(ni);
2009	2230	const offset = ni.fileLocation(&elf.mf, false).offset;
2010		try si.init(elf, .{
2011		.value = addr,
2012		.size = opts.size,
2013		.type = .SECTION,
2014		.shndx = shndx,
2015		});
2016		switch (elf.shdrSlice()) {
2017		inline else => \|shdr\| {
2018		const sh = &shdr[shndx];
2019		sh.* = .{
	2231	try si.init(elf, .{ .value = addr, .type = .SECTION, .shndx = shndx });
	2232	switch (elf.shdrPtr(shndx)) {
	2233	inline else => \|shdr, class\| {
	2234	shdr.* = .{
2020	2235	.name = shstrtab_entry,
2021	2236	.type = opts.type,
2022	2237	.flags = .{ .shf = opts.flags },
2023	2238	.addr = @intCast(addr),
2024	2239	.offset = @intCast(offset),
2025		.size = opts.size,
2026		.link = 0,
2027		.info = 0,
	2240	.size = @intCast(opts.size),
	2241	.link = opts.link,
	2242	.info = opts.info,
2028	2243	.addralign = @intCast(opts.addralign.toByteUnits()),
2029	2244	.entsize = opts.entsize,
2030	2245	};
2031		if (elf.targetEndian() != native_endian) std.mem.byteSwapAllFields(@TypeOf(sh.*), sh);
	2246	if (elf.targetEndian() != native_endian) std.mem.byteSwapAllFields(class.ElfN().Shdr, shdr);
2032	2247	},
2033	2248	}
2034	2249	return si;
...	...	@@ -2036,39 +2251,27 @@ fn addSection(elf: *Elf, segment_ni: MappedFile.Node.Index, opts: struct {
2036	2251
2037	2252	fn renameSection(elf: *Elf, si: Symbol.Index, name: []const u8) !void {
2038	2253	const shstrtab_entry = try elf.string(.shstrtab, name);
2039		switch (elf.shdrSlice()) {
2040		inline else => \|shdr, class\| elf.targetStore(
2041		&shdr[elf.targetLoad(&@field(elf.symPtr(si), @tagName(class)).shndx)].name,
2042		shstrtab_entry,
2043		),
	2254	switch (elf.shdrPtr(si.shndx(elf))) {
	2255	inline else => \|shdr\| elf.targetStore(&shdr.name, shstrtab_entry),
2044	2256	}
2045	2257	}
2046	2258
2047	2259	fn linkSections(elf: *Elf, si: Symbol.Index, link_si: Symbol.Index) !void {
2048		switch (elf.shdrSlice()) {
2049		inline else => \|shdr, class\| shdr[
2050		elf.targetLoad(&@field(elf.symPtr(si), @tagName(class)).shndx)
2051		].link = @field(elf.symPtr(link_si), @tagName(class)).shndx,
	2260	switch (elf.shdrPtr(si.shndx(elf))) {
	2261	inline else => \|shdr\| elf.targetStore(&shdr.link, @intFromEnum(link_si.shndx(elf))),
2052	2262	}
2053	2263	}
2054	2264
2055	2265	fn sectionName(elf: *Elf, si: Symbol.Index) [:0]const u8 {
2056		const name = elf.si.shstrtab.node(elf).slice(&elf.mf)[switch (elf.shdrSlice()) {
2057		inline else => \|shndx, class\| elf.targetLoad(
2058		&shndx[elf.targetLoad(&@field(elf.symPtr(si), @tagName(class)).shndx)].name,
2059		),
	2266	const name = elf.si.shstrtab.node(elf).slice(&elf.mf)[switch (elf.shdrPtr(si.shndx(elf))) {
	2267	inline else => \|shdr\| elf.targetLoad(&shdr.name),
2060	2268	}..];
2061	2269	return name[0..std.mem.indexOfScalar(u8, name, 0).? :0];
2062	2270	}
2063	2271
2064	2272	fn string(elf: *Elf, comptime section: enum { shstrtab, strtab, dynstr }, key: []const u8) !u32 {
2065	2273	if (key.len == 0) return 0;
2066		return @field(elf, @tagName(section)).get(
2067		elf.base.comp.gpa,
2068		&elf.mf,
2069		@field(elf.si, @tagName(section)).node(elf),
2070		key,
2071		);
	2274	return @field(elf, @tagName(section)).get(elf, @field(elf.si, @tagName(section)), key);
2072	2275	}
2073	2276
2074	2277	pub fn addReloc(
...	...	@@ -2079,9 +2282,51 @@ pub fn addReloc(
2079	2282	addend: i64,
2080	2283	@"type": Reloc.Type,
2081	2284	) !void {
2082		try elf.relocs.ensureUnusedCapacity(elf.base.comp.gpa, 1);
	2285	try elf.ensureUnusedRelocCapacity(loc_si, 1);
2083	2286	elf.addRelocAssumeCapacity(loc_si, offset, target_si, addend, @"type");
2084	2287	}
	2288	pub fn ensureUnusedRelocCapacity(elf: *Elf, loc_si: Symbol.Index, len: usize) !void {
	2289	if (len == 0) return;
	2290	const gpa = elf.base.comp.gpa;
	2291
	2292	try elf.relocs.ensureUnusedCapacity(gpa, len);
	2293	if (elf.ehdrField(.type) != .REL) return;
	2294
	2295	const shndx = loc_si.shndx(elf);
	2296	const sh = shndx.get(elf);
	2297	if (sh.rela_si == .null) {
	2298	var stack = std.heap.stackFallback(32, gpa);
	2299	const allocator = stack.get();
	2300
	2301	const rela_name = try std.fmt.allocPrint(allocator, ".rela{s}", .{elf.sectionName(sh.si)});
	2302	defer allocator.free(rela_name);
	2303
	2304	const class = elf.identClass();
	2305	sh.rela_si = try elf.addSection(.none, .{
	2306	.name = rela_name,
	2307	.type = .RELA,
	2308	.link = @intFromEnum(elf.si.symtab.shndx(elf)),
	2309	.info = @intFromEnum(shndx),
	2310	.addralign = switch (class) {
	2311	.NONE, _ => unreachable,
	2312	.@"32" => .@"4",
	2313	.@"64" => .@"8",
	2314	},
	2315	.entsize = switch (class) {
	2316	.NONE, _ => unreachable,
	2317	inline else => \|ct_class\| @sizeOf(ct_class.ElfN().Rela),
	2318	},
	2319	.node_align = elf.mf.flags.block_size,
	2320	});
	2321	}
	2322	const rela_ni = sh.rela_si.node(elf);
	2323	_, const rela_node_size = rela_ni.location(&elf.mf).resolve(&elf.mf);
	2324	const rela_size = switch (elf.shdrPtr(sh.rela_si.shndx(elf))) {
	2325	inline else => \|shdr\| elf.targetLoad(&shdr.size) + elf.targetLoad(&shdr.entsize) * len,
	2326	};
	2327	if (rela_size > rela_node_size)
	2328	try rela_ni.resize(&elf.mf, gpa, rela_size +\| rela_size / MappedFile.growth_factor);
	2329	}
2085	2330	pub fn addRelocAssumeCapacity(
2086	2331	elf: *Elf,
2087	2332	loc_si: Symbol.Index,
...	...	@@ -2098,7 +2343,45 @@ pub fn addRelocAssumeCapacity(
2098	2343	.next = target.target_relocs,
2099	2344	.loc = loc_si,
2100	2345	.target = target_si,
2101		.unused = 0,
	2346	.index = index: switch (elf.ehdrField(.type)) {
	2347	.NONE, .CORE, _ => unreachable,
	2348	.REL => {
	2349	const sh = loc_si.shndx(elf).get(elf);
	2350	switch (elf.shdrPtr(sh.rela_si.shndx(elf))) {
	2351	inline else => \|shdr, class\| {
	2352	const Rela = class.ElfN().Rela;
	2353	const ent_size = elf.targetLoad(&shdr.entsize);
	2354	const rela_slice = sh.rela_si.node(elf).slice(&elf.mf);
	2355	const index: u32 = if (sh.rela_free.unwrap()) \|index\| alloc_index: {
	2356	const rela: *Rela = @ptrCast(@alignCast(
	2357	rela_slice[@intCast(ent_size * index)..][0..@intCast(ent_size)],
	2358	));
	2359	sh.rela_free = @enumFromInt(rela.offset);
	2360	break :alloc_index index;
	2361	} else alloc_index: {
	2362	const old_size = elf.targetLoad(&shdr.size);
	2363	const new_size = old_size + ent_size;
	2364	elf.targetStore(&shdr.size, @intCast(new_size));
	2365	break :alloc_index @intCast(@divExact(old_size, ent_size));
	2366	};
	2367	const rela: *Rela = @ptrCast(@alignCast(
	2368	rela_slice[@intCast(ent_size * index)..][0..@intCast(ent_size)],
	2369	));
	2370	rela.* = .{
	2371	.offset = @intCast(offset),
	2372	.info = .{
	2373	.type = @intCast(@"type".unwrap(elf)),
	2374	.sym = @intCast(@intFromEnum(target_si)),
	2375	},
	2376	.addend = @intCast(addend),
	2377	};
	2378	if (elf.targetEndian() != native_endian) std.mem.byteSwapAllFields(Rela, rela);
	2379	break :index .wrap(index);
	2380	},
	2381	}
	2382	},
	2383	.EXEC, .DYN => .none,
	2384	},
2102	2385	.offset = offset,
2103	2386	.addend = addend,
2104	2387	};
...	...	@@ -2464,7 +2747,8 @@ fn flushUav(
2464	2747	switch (sym.ni) {
2465	2748	.none => {
2466	2749	try elf.nodes.ensureUnusedCapacity(gpa, 1);
2467		const ni = try elf.mf.addLastChildNode(gpa, elf.si.data.node(elf), .{
	2750	const sec_si = elf.si.data;
	2751	const ni = try elf.mf.addLastChildNode(gpa, sec_si.node(elf), .{
2468	2752	.alignment = uav_align.toStdMem(),
2469	2753	.moved = true,
2470	2754	});
...	...	@@ -2472,7 +2756,7 @@ fn flushUav(
2472	2756	sym.ni = ni;
2473	2757	switch (elf.symPtr(si)) {
2474	2758	inline else => \|sym_ptr, class\| sym_ptr.shndx =
2475		@field(elf.symPtr(.data), @tagName(class)).shndx,
	2759	@field(elf.symPtr(sec_si), @tagName(class)).shndx,
2476	2760	}
2477	2761	},
2478	2762	else => {
...	...	@@ -2596,11 +2880,10 @@ fn flushFileOffset(elf: *Elf, ni: MappedFile.Node.Index) !void {
2596	2880	var child_it = ni.children(&elf.mf);
2597	2881	while (child_it.next()) \|child_ni\| try elf.flushFileOffset(child_ni);
2598	2882	},
2599		.section => \|si\| switch (elf.shdrSlice()) {
2600		inline else => \|shdr, class\| elf.targetStore(
2601		&shdr[elf.targetLoad(&@field(elf.symPtr(si), @tagName(class)).shndx)].offset,
2602		@intCast(ni.fileLocation(&elf.mf, false).offset),
2603		),
	2883	.section => \|si\| switch (elf.shdrPtr(si.shndx(elf))) {
	2884	inline else => \|shdr\| elf.targetStore(&shdr.offset, @intCast(
	2885	ni.fileLocation(&elf.mf, false).offset,
	2886	)),
2604	2887	},
2605	2888	}
2606	2889	}
...	...	@@ -2616,10 +2899,10 @@ fn flushMoved(elf: *Elf, ni: MappedFile.Node.Index) !void {
2616	2899	const ph = &phdr[phndx];
2617	2900	switch (elf.targetLoad(&ph.type)) {
2618	2901	else => unreachable,
2619		std.elf.PT_NULL, std.elf.PT_LOAD => return,
2620		std.elf.PT_DYNAMIC, std.elf.PT_INTERP => {},
2621		std.elf.PT_PHDR => @field(elf.ehdrPtr(), @tagName(class)).phoff = ph.offset,
2622		std.elf.PT_TLS => {},
	2902	.NULL, .LOAD => return,
	2903	.DYNAMIC, .INTERP => {},
	2904	.PHDR => @field(elf.ehdrPtr(), @tagName(class)).phoff = ph.offset,
	2905	.TLS => {},
2623	2906	}
2624	2907	elf.targetStore(&ph.vaddr, @intCast(elf.computeNodeVAddr(ni)));
2625	2908	ph.paddr = ph.vaddr;
...	...	@@ -2629,14 +2912,12 @@ fn flushMoved(elf: *Elf, ni: MappedFile.Node.Index) !void {
2629	2912	.section => \|si\| {
2630	2913	try elf.flushFileOffset(ni);
2631	2914	const addr = elf.computeNodeVAddr(ni);
2632		switch (elf.shdrSlice()) {
	2915	switch (elf.shdrPtr(si.shndx(elf))) {
2633	2916	inline else => \|shdr, class\| {
2634		const sym = @field(elf.symPtr(si), @tagName(class));
2635		const sh = &shdr[elf.targetLoad(&sym.shndx)];
2636		const flags = elf.targetLoad(&sh.flags).shf;
	2917	const flags = elf.targetLoad(&shdr.flags).shf;
2637	2918	if (flags.ALLOC) {
2638		elf.targetStore(&sh.addr, @intCast(addr));
2639		sym.value = sh.addr;
	2919	elf.targetStore(&shdr.addr, @intCast(addr));
	2920	@field(elf.symPtr(si), @tagName(class)).value = shdr.addr;
2640	2921	}
2641	2922	},
2642	2923	}
...	...	@@ -2684,22 +2965,18 @@ fn flushResized(elf: *Elf, ni: MappedFile.Node.Index) !void {
2684	2965	elf.targetStore(&ph.memsz, @intCast(memsz));
2685	2966	switch (elf.targetLoad(&ph.type)) {
2686	2967	else => unreachable,
2687		std.elf.PT_NULL => if (size > 0) elf.targetStore(&ph.type, std.elf.PT_LOAD),
2688		std.elf.PT_LOAD => if (size == 0) elf.targetStore(&ph.type, std.elf.PT_NULL),
2689		std.elf.PT_DYNAMIC, std.elf.PT_INTERP, std.elf.PT_PHDR => return,
2690		std.elf.PT_TLS => return ni.childrenMoved(elf.base.comp.gpa, &elf.mf),
	2968	.NULL => if (size > 0) elf.targetStore(&ph.type, .LOAD),
	2969	.LOAD => if (size == 0) elf.targetStore(&ph.type, .NULL),
	2970	.DYNAMIC, .INTERP, .PHDR => return,
	2971	.TLS => return ni.childrenMoved(elf.base.comp.gpa, &elf.mf),
2691	2972	}
2692	2973	var vaddr = elf.targetLoad(&ph.vaddr);
2693	2974	var new_phndx = phndx;
2694	2975	for (phdr[phndx + 1 ..], phndx + 1..) \|*next_ph, next_phndx\| {
2695	2976	switch (elf.targetLoad(&next_ph.type)) {
2696	2977	else => unreachable,
2697		std.elf.PT_NULL, std.elf.PT_LOAD => {},
2698		std.elf.PT_DYNAMIC,
2699		std.elf.PT_INTERP,
2700		std.elf.PT_PHDR,
2701		std.elf.PT_TLS,
2702		=> break,
	2978	.NULL, .LOAD => {},
	2979	.DYNAMIC, .INTERP, .PHDR, .TLS => break,
2703	2980	}
2704	2981	const next_vaddr = elf.targetLoad(&next_ph.vaddr);
2705	2982	if (vaddr + memsz <= next_vaddr) break;
...	...	@@ -2721,20 +2998,15 @@ fn flushResized(elf: *Elf, ni: MappedFile.Node.Index) !void {
2721	2998	}
2722	2999	},
2723	3000	},
2724		.section => \|si\| switch (elf.symPtr(si)) {
2725		inline else => \|sym, class\| {
2726		const sh = &@field(elf.shdrSlice(), @tagName(class))[elf.targetLoad(&sym.shndx)];
2727		elf.targetStore(&sh.size, @intCast(size));
2728		switch (elf.targetLoad(&sh.type)) {
	3001	.section => \|si\| switch (elf.shdrPtr(si.shndx(elf))) {
	3002	inline else => \|shdr\| {
	3003	switch (elf.targetLoad(&shdr.type)) {
2729	3004	else => unreachable,
2730		std.elf.SHT_NULL => if (size > 0) elf.targetStore(&sh.type, std.elf.SHT_PROGBITS),
2731		std.elf.SHT_PROGBITS => if (size == 0) elf.targetStore(&sh.type, std.elf.SHT_NULL),
2732		std.elf.SHT_SYMTAB, std.elf.SHT_DYNSYM => elf.targetStore(
2733		&sh.info,
2734		@intCast(@divExact(size, elf.targetLoad(&sh.entsize))),
2735		),
2736		std.elf.SHT_STRTAB, std.elf.SHT_DYNAMIC => {},
	3005	.NULL => if (size > 0) elf.targetStore(&shdr.type, .PROGBITS),
	3006	.PROGBITS => if (size == 0) elf.targetStore(&shdr.type, .NULL),
	3007	.SYMTAB, .STRTAB, .RELA, .DYNAMIC, .REL, .DYNSYM => return,
2737	3008	}
	3009	elf.targetStore(&shdr.size, @intCast(size));
2738	3010	},
2739	3011	},
2740	3012	.input_section => {},
...	...	@@ -2860,6 +3132,26 @@ pub fn printNode(
2860	3132	try w.writeAll(@tagName(node));
2861	3133	switch (node) {
2862	3134	else => {},
	3135	.segment => \|phndx\| switch (elf.phdrSlice()) {
	3136	inline else => \|phdr\| {
	3137	const ph = &phdr[phndx];
	3138	try w.writeByte('(');
	3139	const pt = elf.targetLoad(&ph.type);
	3140	if (std.enums.tagName(std.elf.PT, pt)) \|pt_name\|
	3141	try w.writeAll(pt_name)
	3142	else inline for (@typeInfo(std.elf.PT).@"enum".decls) \|decl\| {
	3143	const decl_val = @field(std.elf.PT, decl.name);
	3144	if (@TypeOf(decl_val) != std.elf.PT) continue;
	3145	if (pt == @field(std.elf.PT, decl.name)) break try w.writeAll(decl.name);
	3146	} else try w.print("0x{x}", .{pt});
	3147	try w.writeAll(", ");
	3148	const pf = elf.targetLoad(&ph.flags);
	3149	if (pf.R) try w.writeByte('R');
	3150	if (pf.W) try w.writeByte('W');
	3151	if (pf.X) try w.writeByte('X');
	3152	try w.writeByte(')');
	3153	},
	3154	},
2863	3155	.section => \|si\| try w.print("({s})", .{elf.sectionName(si)}),
2864	3156	.input_section => \|isi\| {
2865	3157	const ii = isi.input(elf);

src/link/MappedFile.zig+12-25

...	...	@@ -486,6 +486,14 @@ fn addNode(mf: *MappedFile, gpa: std.mem.Allocator, opts: struct {
486	486	break :free .{ free_ni, free_node };
487	487	},
488	488	};
	489	switch (opts.prev) {
	490	.none => opts.parent.get(mf).first = free_ni,
	491	else => \|prev_ni\| prev_ni.get(mf).next = free_ni,
	492	}
	493	switch (opts.next) {
	494	.none => opts.parent.get(mf).last = free_ni,
	495	else => \|next_ni\| next_ni.get(mf).prev = free_ni,
	496	}
489	497	free_node.* = .{
490	498	.parent = opts.parent,
491	499	.prev = opts.prev,
...	...	@@ -535,13 +543,10 @@ pub fn addOnlyChildNode(
535	543	try mf.nodes.ensureUnusedCapacity(gpa, 1);
536	544	const parent = parent_ni.get(mf);
537	545	assert(parent.first == .none and parent.last == .none);
538		const ni = try mf.addNode(gpa, .{
	546	return mf.addNode(gpa, .{
539	547	.parent = parent_ni,
540	548	.add_node = opts,
541	549	});
542		parent.first = ni;
543		parent.last = ni;
544		return ni;
545	550	}
546	551
547	552	pub fn addFirstChildNode(
...	...	@@ -552,17 +557,11 @@ pub fn addFirstChildNode(
552	557	) !Node.Index {
553	558	try mf.nodes.ensureUnusedCapacity(gpa, 1);
554	559	const parent = parent_ni.get(mf);
555		const ni = try mf.addNode(gpa, .{
	560	return mf.addNode(gpa, .{
556	561	.parent = parent_ni,
557	562	.next = parent.first,
558	563	.add_node = opts,
559	564	});
560		switch (parent.first) {
561		.none => parent.last = ni,
562		else => \|first_ni\| first_ni.get(mf).prev = ni,
563		}
564		parent.first = ni;
565		return ni;
566	565	}
567	566
568	567	pub fn addLastChildNode(
...	...	@@ -573,7 +572,7 @@ pub fn addLastChildNode(
573	572	) !Node.Index {
574	573	try mf.nodes.ensureUnusedCapacity(gpa, 1);
575	574	const parent = parent_ni.get(mf);
576		const ni = try mf.addNode(gpa, .{
	575	return mf.addNode(gpa, .{
577	576	.parent = parent_ni,
578	577	.prev = parent.last,
579	578	.offset = offset: switch (parent.last) {
...	...	@@ -585,12 +584,6 @@ pub fn addLastChildNode(
585	584	},
586	585	.add_node = opts,
587	586	});
588		switch (parent.last) {
589		.none => parent.first = ni,
590		else => \|last_ni\| last_ni.get(mf).next = ni,
591		}
592		parent.last = ni;
593		return ni;
594	587	}
595	588
596	589	pub fn addNodeAfter(
...	...	@@ -603,19 +596,13 @@ pub fn addNodeAfter(
603	596	try mf.nodes.ensureUnusedCapacity(gpa, 1);
604	597	const prev = prev_ni.get(mf);
605	598	const prev_offset, const prev_size = prev.location().resolve(mf);
606		const ni = try mf.addNode(gpa, .{
	599	return mf.addNode(gpa, .{
607	600	.parent = prev.parent,
608	601	.prev = prev_ni,
609	602	.next = prev.next,
610	603	.offset = prev_offset + prev_size,
611	604	.add_node = opts,
612	605	});
613		switch (prev.next) {
614		.none => prev.parent.get(mf).last = ni,
615		else => \|next_ni\| next_ni.get(mf).prev = ni,
616		}
617		prev.next = ni;
618		return ni;
619	606	}
620	607
621	608	fn resizeNode(mf: *MappedFile, gpa: std.mem.Allocator, ni: Node.Index, requested_size: u64) !void {