Commit f58200e3f2
Changed files (45)
lib
compiler_rt
std
src
arch
riscv64
codegen
aarch64
Compilation
link
test
ci/x86_64-linux-debug-llvm.sh
lib/compiler_rt/fma.zig
@@ -203,7 +203,7 @@ fn add_adjusted(a: f64, b: f64) f64 {
if (uhii & 1 == 0) {
// hibits += copysign(1.0, sum.hi, sum.lo)
const uloi: u64 = @bitCast(sum.lo);
- uhii += 1 - ((uhii ^ uloi) >> 62);
+ uhii = uhii + 1 - ((uhii ^ uloi) >> 62);
sum.hi = @bitCast(uhii);
}
}
@@ -217,7 +217,7 @@ fn add_and_denorm(a: f64, b: f64, scale: i32) f64 {
const bits_lost = -@as(i32, @intCast((uhii >> 52) & 0x7FF)) - scale + 1;
if ((bits_lost != 1) == (uhii & 1 != 0)) {
const uloi: u64 = @bitCast(sum.lo);
- uhii += 1 - (((uhii ^ uloi) >> 62) & 2);
+ uhii = uhii + 1 - (((uhii ^ uloi) >> 62) & 2);
sum.hi = @bitCast(uhii);
}
}
@@ -259,7 +259,7 @@ fn add_adjusted128(a: f128, b: f128) f128 {
if (uhii & 1 == 0) {
// hibits += copysign(1.0, sum.hi, sum.lo)
const uloi: u128 = @bitCast(sum.lo);
- uhii += 1 - ((uhii ^ uloi) >> 126);
+ uhii = uhii + 1 - ((uhii ^ uloi) >> 126);
sum.hi = @bitCast(uhii);
}
}
@@ -284,7 +284,7 @@ fn add_and_denorm128(a: f128, b: f128, scale: i32) f128 {
const bits_lost = -@as(i32, @intCast((uhii >> 112) & 0x7FFF)) - scale + 1;
if ((bits_lost != 1) == (uhii & 1 != 0)) {
const uloi: u128 = @bitCast(sum.lo);
- uhii += 1 - (((uhii ^ uloi) >> 126) & 2);
+ uhii = uhii + 1 - (((uhii ^ uloi) >> 126) & 2);
sum.hi = @bitCast(uhii);
}
}
lib/std/Build/Step/Compile.zig
@@ -192,6 +192,7 @@ want_lto: ?bool = null,
use_llvm: ?bool,
use_lld: ?bool,
+use_new_linker: ?bool,
/// Corresponds to the `-fallow-so-scripts` / `-fno-allow-so-scripts` CLI
/// flags, overriding the global user setting provided to the `zig build`
@@ -441,6 +442,7 @@ pub fn create(owner: *std.Build, options: Options) *Compile {
.use_llvm = options.use_llvm,
.use_lld = options.use_lld,
+ .use_new_linker = null,
.zig_process = null,
};
@@ -1096,6 +1098,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
try addFlag(&zig_args, "llvm", compile.use_llvm);
try addFlag(&zig_args, "lld", compile.use_lld);
+ try addFlag(&zig_args, "new-linker", compile.use_new_linker);
if (compile.root_module.resolved_target.?.query.ofmt) |ofmt| {
try zig_args.append(try std.fmt.allocPrint(arena, "-ofmt={s}", .{@tagName(ofmt)}));
lib/std/zig/system.zig
@@ -516,15 +516,15 @@ pub fn abiAndDynamicLinkerFromFile(
const hdr32: *elf.Elf32_Ehdr = @ptrCast(&hdr_buf);
const hdr64: *elf.Elf64_Ehdr = @ptrCast(&hdr_buf);
if (!mem.eql(u8, hdr32.e_ident[0..4], elf.MAGIC)) return error.InvalidElfMagic;
- const elf_endian: std.builtin.Endian = switch (hdr32.e_ident[elf.EI_DATA]) {
+ const elf_endian: std.builtin.Endian = switch (hdr32.e_ident[elf.EI.DATA]) {
elf.ELFDATA2LSB => .little,
elf.ELFDATA2MSB => .big,
else => return error.InvalidElfEndian,
};
const need_bswap = elf_endian != native_endian;
- if (hdr32.e_ident[elf.EI_VERSION] != 1) return error.InvalidElfVersion;
+ if (hdr32.e_ident[elf.EI.VERSION] != 1) return error.InvalidElfVersion;
- const is_64 = switch (hdr32.e_ident[elf.EI_CLASS]) {
+ const is_64 = switch (hdr32.e_ident[elf.EI.CLASS]) {
elf.ELFCLASS32 => false,
elf.ELFCLASS64 => true,
else => return error.InvalidElfClass,
@@ -920,15 +920,15 @@ fn glibcVerFromSoFile(file: fs.File) !std.SemanticVersion {
const hdr32: *elf.Elf32_Ehdr = @ptrCast(&hdr_buf);
const hdr64: *elf.Elf64_Ehdr = @ptrCast(&hdr_buf);
if (!mem.eql(u8, hdr32.e_ident[0..4], elf.MAGIC)) return error.InvalidElfMagic;
- const elf_endian: std.builtin.Endian = switch (hdr32.e_ident[elf.EI_DATA]) {
+ const elf_endian: std.builtin.Endian = switch (hdr32.e_ident[elf.EI.DATA]) {
elf.ELFDATA2LSB => .little,
elf.ELFDATA2MSB => .big,
else => return error.InvalidElfEndian,
};
const need_bswap = elf_endian != native_endian;
- if (hdr32.e_ident[elf.EI_VERSION] != 1) return error.InvalidElfVersion;
+ if (hdr32.e_ident[elf.EI.VERSION] != 1) return error.InvalidElfVersion;
- const is_64 = switch (hdr32.e_ident[elf.EI_CLASS]) {
+ const is_64 = switch (hdr32.e_ident[elf.EI.CLASS]) {
elf.ELFCLASS32 => false,
elf.ELFCLASS64 => true,
else => return error.InvalidElfClass,
lib/std/elf.zig
@@ -323,6 +323,8 @@ pub const PT_LOPROC = 0x70000000;
/// End of processor-specific
pub const PT_HIPROC = 0x7fffffff;
+pub const PN_XNUM = 0xffff;
+
/// Section header table entry unused
pub const SHT_NULL = 0;
/// Program data
@@ -385,63 +387,149 @@ pub const SHT_HIUSER = 0xffffffff;
// Note type for .note.gnu.build_id
pub const NT_GNU_BUILD_ID = 3;
-/// Local symbol
-pub const STB_LOCAL = 0;
-/// Global symbol
-pub const STB_GLOBAL = 1;
-/// Weak symbol
-pub const STB_WEAK = 2;
-/// Number of defined types
-pub const STB_NUM = 3;
-/// Start of OS-specific
-pub const STB_LOOS = 10;
-/// Unique symbol
-pub const STB_GNU_UNIQUE = 10;
-/// End of OS-specific
-pub const STB_HIOS = 12;
-/// Start of processor-specific
-pub const STB_LOPROC = 13;
-/// End of processor-specific
-pub const STB_HIPROC = 15;
-
-pub const STB_MIPS_SPLIT_COMMON = 13;
-
-/// Symbol type is unspecified
-pub const STT_NOTYPE = 0;
-/// Symbol is a data object
-pub const STT_OBJECT = 1;
-/// Symbol is a code object
-pub const STT_FUNC = 2;
-/// Symbol associated with a section
-pub const STT_SECTION = 3;
-/// Symbol's name is file name
-pub const STT_FILE = 4;
-/// Symbol is a common data object
-pub const STT_COMMON = 5;
-/// Symbol is thread-local data object
-pub const STT_TLS = 6;
-/// Number of defined types
-pub const STT_NUM = 7;
-/// Start of OS-specific
-pub const STT_LOOS = 10;
-/// Symbol is indirect code object
-pub const STT_GNU_IFUNC = 10;
-/// End of OS-specific
-pub const STT_HIOS = 12;
-/// Start of processor-specific
-pub const STT_LOPROC = 13;
-/// End of processor-specific
-pub const STT_HIPROC = 15;
+/// Deprecated, use `@intFromEnum(std.elf.STB.LOCAL)`
+pub const STB_LOCAL = @intFromEnum(STB.LOCAL);
+/// Deprecated, use `@intFromEnum(std.elf.STB.GLOBAL)`
+pub const STB_GLOBAL = @intFromEnum(STB.GLOBAL);
+/// Deprecated, use `@intFromEnum(std.elf.STB.WEAK)`
+pub const STB_WEAK = @intFromEnum(STB.WEAK);
+/// Deprecated, use `std.elf.STB.NUM`
+pub const STB_NUM = STB.NUM;
+/// Deprecated, use `@intFromEnum(std.elf.STB.LOOS)`
+pub const STB_LOOS = @intFromEnum(STB.LOOS);
+/// Deprecated, use `@intFromEnum(std.elf.STB.GNU_UNIQUE)`
+pub const STB_GNU_UNIQUE = @intFromEnum(STB.GNU_UNIQUE);
+/// Deprecated, use `@intFromEnum(std.elf.STB.HIOS)`
+pub const STB_HIOS = @intFromEnum(STB.HIOS);
+/// Deprecated, use `@intFromEnum(std.elf.STB.LOPROC)`
+pub const STB_LOPROC = @intFromEnum(STB.LOPROC);
+/// Deprecated, use `@intFromEnum(std.elf.STB.HIPROC)`
+pub const STB_HIPROC = @intFromEnum(STB.HIPROC);
+
+/// Deprecated, use `@intFromEnum(std.elf.STB.MIPS_SPLIT_COMMON)`
+pub const STB_MIPS_SPLIT_COMMON = @intFromEnum(STB.MIBS_SPLIT_COMMON);
+
+/// Deprecated, use `@intFromEnum(std.elf.STT.NOTYPE)`
+pub const STT_NOTYPE = @intFromEnum(STT.NOTYPE);
+/// Deprecated, use `@intFromEnum(std.elf.STT.OBJECT)`
+pub const STT_OBJECT = @intFromEnum(STT.OBJECT);
+/// Deprecated, use `@intFromEnum(std.elf.STT.FUNC)`
+pub const STT_FUNC = @intFromEnum(STT.FUNC);
+/// Deprecated, use `@intFromEnum(std.elf.STT.SECTION)`
+pub const STT_SECTION = @intFromEnum(STT.SECTION);
+/// Deprecated, use `@intFromEnum(std.elf.STT.FILE)`
+pub const STT_FILE = @intFromEnum(STT.FILE);
+/// Deprecated, use `@intFromEnum(std.elf.STT.COMMON)`
+pub const STT_COMMON = @intFromEnum(STT.COMMON);
+/// Deprecated, use `@intFromEnum(std.elf.STT.TLS)`
+pub const STT_TLS = @intFromEnum(STT.TLS);
+/// Deprecated, use `std.elf.STT.NUM`
+pub const STT_NUM = STT.NUM;
+/// Deprecated, use `@intFromEnum(std.elf.STT.LOOS)`
+pub const STT_LOOS = @intFromEnum(STT.LOOS);
+/// Deprecated, use `@intFromEnum(std.elf.STT.GNU_IFUNC)`
+pub const STT_GNU_IFUNC = @intFromEnum(STT.GNU_IFUNC);
+/// Deprecated, use `@intFromEnum(std.elf.STT.HIOS)`
+pub const STT_HIOS = @intFromEnum(STT.HIOS);
+/// Deprecated, use `@intFromEnum(std.elf.STT.LOPROC)`
+pub const STT_LOPROC = @intFromEnum(STT.LOPROC);
+/// Deprecated, use `@intFromEnum(std.elf.STT.HIPROC)`
+pub const STT_HIPROC = @intFromEnum(STT.HIPROC);
+
+/// Deprecated, use `@intFromEnum(std.elf.STT.SPARC_REGISTER)`
+pub const STT_SPARC_REGISTER = @intFromEnum(STT.SPARC_REGISTER);
+
+/// Deprecated, use `@intFromEnum(std.elf.STT.PARISC_MILLICODE)`
+pub const STT_PARISC_MILLICODE = @intFromEnum(STT.PARISC_MILLICODE);
+
+/// Deprecated, use `@intFromEnum(std.elf.STT.HP_OPAQUE)`
+pub const STT_HP_OPAQUE = @intFromEnum(STT.HP_OPAQUE);
+/// Deprecated, use `@intFromEnum(std.elf.STT.HP_STUB)`
+pub const STT_HP_STUB = @intFromEnum(STT.HP_STUB);
+
+/// Deprecated, use `@intFromEnum(std.elf.STT.ARM_TFUNC)`
+pub const STT_ARM_TFUNC = @intFromEnum(STT.ARM_TFUNC);
+/// Deprecated, use `@intFromEnum(std.elf.STT.ARM_16BIT)`
+pub const STT_ARM_16BIT = @intFromEnum(STT.ARM_16BIT);
+
+pub const STB = enum(u4) {
+ /// Local symbol
+ LOCAL = 0,
+ /// Global symbol
+ GLOBAL = 1,
+ /// Weak symbol
+ WEAK = 2,
+ _,
+
+ /// Number of defined types
+ pub const NUM = @typeInfo(STB).@"enum".fields.len;
+
+ /// Start of OS-specific
+ pub const LOOS: STB = @enumFromInt(10);
+ /// End of OS-specific
+ pub const HIOS: STB = @enumFromInt(12);
+
+ /// Unique symbol
+ pub const GNU_UNIQUE: STB = @enumFromInt(@intFromEnum(LOOS) + 0);
+
+ /// Start of processor-specific
+ pub const LOPROC: STB = @enumFromInt(13);
+ /// End of processor-specific
+ pub const HIPROC: STB = @enumFromInt(15);
+
+ pub const MIPS_SPLIT_COMMON: STB = @enumFromInt(@intFromEnum(LOPROC) + 0);
+};
+
+pub const STT = enum(u4) {
+ /// Symbol type is unspecified
+ NOTYPE = 0,
+ /// Symbol is a data object
+ OBJECT = 1,
+ /// Symbol is a code object
+ FUNC = 2,
+ /// Symbol associated with a section
+ SECTION = 3,
+ /// Symbol's name is file name
+ FILE = 4,
+ /// Symbol is a common data object
+ COMMON = 5,
+ /// Symbol is thread-local data object
+ TLS = 6,
+ _,
+
+ /// Number of defined types
+ pub const NUM = @typeInfo(STT).@"enum".fields.len;
+
+ /// Start of OS-specific
+ pub const LOOS: STT = @enumFromInt(10);
+ /// End of OS-specific
+ pub const HIOS: STT = @enumFromInt(12);
-pub const STT_SPARC_REGISTER = 13;
+ /// Symbol is indirect code object
+ pub const GNU_IFUNC: STT = @enumFromInt(@intFromEnum(LOOS) + 0);
-pub const STT_PARISC_MILLICODE = 13;
+ pub const HP_OPAQUE: STT = @enumFromInt(@intFromEnum(LOOS) + 1);
+ pub const HP_STUB: STT = @enumFromInt(@intFromEnum(LOOS) + 2);
-pub const STT_HP_OPAQUE = (STT_LOOS + 0x1);
-pub const STT_HP_STUB = (STT_LOOS + 0x2);
+ /// Start of processor-specific
+ pub const LOPROC: STT = @enumFromInt(13);
+ /// End of processor-specific
+ pub const HIPROC: STT = @enumFromInt(15);
-pub const STT_ARM_TFUNC = STT_LOPROC;
-pub const STT_ARM_16BIT = STT_HIPROC;
+ pub const SPARC_REGISTER: STT = @enumFromInt(@intFromEnum(LOPROC) + 0);
+
+ pub const PARISC_MILLICODE: STT = @enumFromInt(@intFromEnum(LOPROC) + 0);
+
+ pub const ARM_TFUNC: STT = @enumFromInt(@intFromEnum(LOPROC) + 0);
+ pub const ARM_16BIT: STT = @enumFromInt(@intFromEnum(HIPROC) + 2);
+};
+
+pub const STV = enum(u3) {
+ DEFAULT = 0,
+ INTERNAL = 1,
+ HIDDEN = 2,
+ PROTECTED = 3,
+};
pub const MAGIC = "\x7fELF";
@@ -534,15 +622,15 @@ pub const Header = struct {
const buf = try r.peek(@sizeOf(Elf64_Ehdr));
if (!mem.eql(u8, buf[0..4], MAGIC)) return error.InvalidElfMagic;
- if (buf[EI_VERSION] != 1) return error.InvalidElfVersion;
+ if (buf[EI.VERSION] != 1) return error.InvalidElfVersion;
- const endian: std.builtin.Endian = switch (buf[EI_DATA]) {
+ const endian: std.builtin.Endian = switch (buf[EI.DATA]) {
ELFDATA2LSB => .little,
ELFDATA2MSB => .big,
else => return error.InvalidElfEndian,
};
- return switch (buf[EI_CLASS]) {
+ return switch (buf[EI.CLASS]) {
ELFCLASS32 => .init(try r.takeStruct(Elf32_Ehdr, endian), endian),
ELFCLASS64 => .init(try r.takeStruct(Elf64_Ehdr, endian), endian),
else => return error.InvalidElfClass,
@@ -559,8 +647,8 @@ pub const Header = struct {
else => @compileError("bad type"),
},
.endian = endian,
- .os_abi = @enumFromInt(hdr.e_ident[EI_OSABI]),
- .abi_version = hdr.e_ident[EI_ABIVERSION],
+ .os_abi = @enumFromInt(hdr.e_ident[EI.OSABI]),
+ .abi_version = hdr.e_ident[EI.ABIVERSION],
.type = hdr.e_type,
.machine = hdr.e_machine,
.entry = hdr.e_entry,
@@ -683,38 +771,200 @@ fn takeShdr(reader: *std.Io.Reader, elf_header: Header) !?Elf64_Shdr {
};
}
-pub const ELFCLASSNONE = 0;
-pub const ELFCLASS32 = 1;
-pub const ELFCLASS64 = 2;
-pub const ELFCLASSNUM = 3;
-
-pub const ELFDATANONE = 0;
-pub const ELFDATA2LSB = 1;
-pub const ELFDATA2MSB = 2;
-pub const ELFDATANUM = 3;
-
-pub const EI_CLASS = 4;
-pub const EI_DATA = 5;
-pub const EI_VERSION = 6;
-pub const EI_OSABI = 7;
-pub const EI_ABIVERSION = 8;
-pub const EI_PAD = 9;
-
-pub const EI_NIDENT = 16;
+pub const EI = struct {
+ pub const CLASS = 4;
+ pub const DATA = 5;
+ pub const VERSION = 6;
+ pub const OSABI = 7;
+ pub const ABIVERSION = 8;
+ pub const PAD = 9;
+ pub const NIDENT = 16;
+};
+
+/// Deprecated, use `std.elf.EI.CLASS`
+pub const EI_CLASS = EI.CLASS;
+/// Deprecated, use `std.elf.EI.DATA`
+pub const EI_DATA = EI.DATA;
+/// Deprecated, use `std.elf.EI.VERSION`
+pub const EI_VERSION = EI.VERSION;
+/// Deprecated, use `std.elf.EI.OSABI`
+pub const EI_OSABI = EI.OSABI;
+/// Deprecated, use `std.elf.EI.ABIVERSION`
+pub const EI_ABIVERSION = EI.ABIVERSION;
+/// Deprecated, use `std.elf.EI.PAD`
+pub const EI_PAD = EI.PAD;
+/// Deprecated, use `std.elf.EI.NIDENT`
+pub const EI_NIDENT = EI.NIDENT;
pub const Half = u16;
pub const Word = u32;
pub const Sword = i32;
-pub const Elf32_Xword = u64;
-pub const Elf32_Sxword = i64;
-pub const Elf64_Xword = u64;
+pub const Xword = u64;
+pub const Sxword = i64;
+pub const Section = u16;
+pub const Elf32 = struct {
+ pub const Addr = u32;
+ pub const Off = u32;
+ pub const Ehdr = extern struct {
+ ident: [EI.NIDENT]u8,
+ type: ET,
+ machine: EM,
+ version: Word,
+ entry: Elf32.Addr,
+ phoff: Elf32.Off,
+ shoff: Elf32.Off,
+ flags: Word,
+ ehsize: Half,
+ phentsize: Half,
+ phnum: Half,
+ shentsize: Half,
+ shnum: Half,
+ shstrndx: Half,
+ };
+ pub const Phdr = extern struct {
+ type: Word,
+ offset: Elf32.Off,
+ vaddr: Elf32.Addr,
+ paddr: Elf32.Addr,
+ filesz: Word,
+ memsz: Word,
+ flags: PF,
+ @"align": Word,
+ };
+ pub const Shdr = extern struct {
+ name: Word,
+ type: Word,
+ flags: packed struct { shf: SHF },
+ addr: Elf32.Addr,
+ offset: Elf32.Off,
+ size: Word,
+ link: Word,
+ info: Word,
+ addralign: Word,
+ entsize: Word,
+ };
+ pub const Chdr = extern struct {
+ type: COMPRESS,
+ size: Word,
+ addralign: Word,
+ };
+ pub const Sym = extern struct {
+ name: Word,
+ value: Elf32.Addr,
+ size: Word,
+ info: Info,
+ other: Other,
+ shndx: Section,
+
+ pub const Info = packed struct(u8) {
+ type: STT,
+ bind: STB,
+ };
+
+ pub const Other = packed struct(u8) {
+ visibility: STV,
+ unused: u5 = 0,
+ };
+ };
+ comptime {
+ assert(@sizeOf(Elf32.Ehdr) == 52);
+ assert(@sizeOf(Elf32.Phdr) == 32);
+ assert(@sizeOf(Elf32.Shdr) == 40);
+ assert(@sizeOf(Elf32.Sym) == 16);
+ }
+};
+pub const Elf64 = struct {
+ pub const Addr = u64;
+ pub const Off = u64;
+ pub const Ehdr = extern struct {
+ ident: [EI.NIDENT]u8,
+ type: ET,
+ machine: EM,
+ version: Word,
+ entry: Elf64.Addr,
+ phoff: Elf64.Off,
+ shoff: Elf64.Off,
+ flags: Word,
+ ehsize: Half,
+ phentsize: Half,
+ phnum: Half,
+ shentsize: Half,
+ shnum: Half,
+ shstrndx: Half,
+ };
+ pub const Phdr = extern struct {
+ type: Word,
+ flags: PF,
+ offset: Elf64.Off,
+ vaddr: Elf64.Addr,
+ paddr: Elf64.Addr,
+ filesz: Xword,
+ memsz: Xword,
+ @"align": Xword,
+ };
+ pub const Shdr = extern struct {
+ name: Word,
+ type: Word,
+ flags: packed struct { shf: SHF, unused: Word = 0 },
+ addr: Elf64.Addr,
+ offset: Elf64.Off,
+ size: Xword,
+ link: Word,
+ info: Word,
+ addralign: Xword,
+ entsize: Xword,
+ };
+ pub const Chdr = extern struct {
+ type: COMPRESS,
+ reserved: Word = 0,
+ size: Xword,
+ addralign: Xword,
+ };
+ pub const Sym = extern struct {
+ name: Word,
+ info: Info,
+ other: Other,
+ shndx: Section,
+ value: Elf64.Addr,
+ size: Xword,
+
+ pub const Info = Elf32.Sym.Info;
+ pub const Other = Elf32.Sym.Other;
+ };
+ comptime {
+ assert(@sizeOf(Elf64.Ehdr) == 64);
+ assert(@sizeOf(Elf64.Phdr) == 56);
+ assert(@sizeOf(Elf64.Shdr) == 64);
+ assert(@sizeOf(Elf64.Sym) == 24);
+ }
+};
+pub const ElfN = switch (@sizeOf(usize)) {
+ 4 => Elf32,
+ 8 => Elf64,
+ else => @compileError("expected pointer size of 32 or 64"),
+};
+
+/// Deprecated, use `std.elf.Xword`
+pub const Elf32_Xword = Xword;
+/// Deprecated, use `std.elf.Sxword`
+pub const Elf32_Sxword = Sxword;
+/// Deprecated, use `std.elf.Xword`
+pub const Elf64_Xword = Xword;
+/// Deprecated, use `std.elf.Sxword`
pub const Elf64_Sxword = i64;
+/// Deprecated, use `std.elf.Elf32.Addr`
pub const Elf32_Addr = u32;
+/// Deprecated, use `std.elf.Elf64.Addr`
pub const Elf64_Addr = u64;
+/// Deprecated, use `std.elf.Elf32.Off`
pub const Elf32_Off = u32;
+/// Deprecated, use `std.elf.Elf64.Off`
pub const Elf64_Off = u64;
+/// Deprecated, use `std.elf.Section`
pub const Elf32_Section = u16;
+/// Deprecated, use `std.elf.Section`
pub const Elf64_Section = u16;
+/// Deprecated, use `std.elf.Elf32.Ehdr`
pub const Elf32_Ehdr = extern struct {
e_ident: [EI_NIDENT]u8,
e_type: ET,
@@ -731,8 +981,9 @@ pub const Elf32_Ehdr = extern struct {
e_shnum: Half,
e_shstrndx: Half,
};
+/// Deprecated, use `std.elf.Elf64.Ehdr`
pub const Elf64_Ehdr = extern struct {
- e_ident: [EI_NIDENT]u8,
+ e_ident: [EI.NIDENT]u8,
e_type: ET,
e_machine: EM,
e_version: Word,
@@ -747,6 +998,7 @@ pub const Elf64_Ehdr = extern struct {
e_shnum: Half,
e_shstrndx: Half,
};
+/// Deprecated, use `std.elf.Elf32.Phdr`
pub const Elf32_Phdr = extern struct {
p_type: Word,
p_offset: Elf32_Off,
@@ -757,6 +1009,7 @@ pub const Elf32_Phdr = extern struct {
p_flags: Word,
p_align: Word,
};
+/// Deprecated, use `std.elf.Elf64.Phdr`
pub const Elf64_Phdr = extern struct {
p_type: Word,
p_flags: Word,
@@ -767,6 +1020,7 @@ pub const Elf64_Phdr = extern struct {
p_memsz: Elf64_Xword,
p_align: Elf64_Xword,
};
+/// Deprecated, use `std.elf.Elf32.Shdr`
pub const Elf32_Shdr = extern struct {
sh_name: Word,
sh_type: Word,
@@ -779,6 +1033,7 @@ pub const Elf32_Shdr = extern struct {
sh_addralign: Word,
sh_entsize: Word,
};
+/// Deprecated, use `std.elf.Elf64.Shdr`
pub const Elf64_Shdr = extern struct {
sh_name: Word,
sh_type: Word,
@@ -791,17 +1046,20 @@ pub const Elf64_Shdr = extern struct {
sh_addralign: Elf64_Xword,
sh_entsize: Elf64_Xword,
};
+/// Deprecated, use `std.elf.Elf32.Chdr`
pub const Elf32_Chdr = extern struct {
ch_type: COMPRESS,
ch_size: Word,
ch_addralign: Word,
};
+/// Deprecated, use `std.elf.Elf64.Chdr`
pub const Elf64_Chdr = extern struct {
ch_type: COMPRESS,
ch_reserved: Word = 0,
ch_size: Elf64_Xword,
ch_addralign: Elf64_Xword,
};
+/// Deprecated, use `std.elf.Elf32.Sym`
pub const Elf32_Sym = extern struct {
st_name: Word,
st_value: Elf32_Addr,
@@ -817,6 +1075,7 @@ pub const Elf32_Sym = extern struct {
return @truncate(self.st_info >> 4);
}
};
+/// Deprecated, use `std.elf.Elf64.Sym`
pub const Elf64_Sym = extern struct {
st_name: Word,
st_info: u8,
@@ -1020,27 +1279,18 @@ pub const Elf_MIPS_ABIFlags_v0 = extern struct {
flags2: Word,
};
-comptime {
- assert(@sizeOf(Elf32_Ehdr) == 52);
- assert(@sizeOf(Elf64_Ehdr) == 64);
-
- assert(@sizeOf(Elf32_Phdr) == 32);
- assert(@sizeOf(Elf64_Phdr) == 56);
-
- assert(@sizeOf(Elf32_Shdr) == 40);
- assert(@sizeOf(Elf64_Shdr) == 64);
-}
-
pub const Auxv = switch (@sizeOf(usize)) {
4 => Elf32_auxv_t,
8 => Elf64_auxv_t,
else => @compileError("expected pointer size of 32 or 64"),
};
+/// Deprecated, use `std.elf.ElfN.Ehdr`
pub const Ehdr = switch (@sizeOf(usize)) {
4 => Elf32_Ehdr,
8 => Elf64_Ehdr,
else => @compileError("expected pointer size of 32 or 64"),
};
+/// Deprecated, use `std.elf.ElfN.Phdr`
pub const Phdr = switch (@sizeOf(usize)) {
4 => Elf32_Phdr,
8 => Elf64_Phdr,
@@ -1071,20 +1321,53 @@ pub const Shdr = switch (@sizeOf(usize)) {
8 => Elf64_Shdr,
else => @compileError("expected pointer size of 32 or 64"),
};
+/// Deprecated, use `std.elf.ElfN.Chdr`
pub const Chdr = switch (@sizeOf(usize)) {
4 => Elf32_Chdr,
8 => Elf64_Chdr,
else => @compileError("expected pointer size of 32 or 64"),
};
+/// Deprecated, use `std.elf.ElfN.Sym`
pub const Sym = switch (@sizeOf(usize)) {
4 => Elf32_Sym,
8 => Elf64_Sym,
else => @compileError("expected pointer size of 32 or 64"),
};
-pub const Addr = switch (@sizeOf(usize)) {
- 4 => Elf32_Addr,
- 8 => Elf64_Addr,
- else => @compileError("expected pointer size of 32 or 64"),
+/// Deprecated, use `std.elf.ElfN.Addr`
+pub const Addr = ElfN.Addr;
+
+/// Deprecated, use `@intFromEnum(std.elf.CLASS.NONE)`
+pub const ELFCLASSNONE = @intFromEnum(CLASS.NONE);
+/// Deprecated, use `@intFromEnum(std.elf.CLASS.@"32")`
+pub const ELFCLASS32 = @intFromEnum(CLASS.@"32");
+/// Deprecated, use `@intFromEnum(std.elf.CLASS.@"64")`
+pub const ELFCLASS64 = @intFromEnum(CLASS.@"64");
+/// Deprecated, use `@intFromEnum(std.elf.CLASS.NUM)`
+pub const ELFCLASSNUM = CLASS.NUM;
+pub const CLASS = enum(u8) {
+ NONE = 0,
+ @"32" = 1,
+ @"64" = 2,
+ _,
+
+ pub const NUM = @typeInfo(CLASS).@"enum".fields.len;
+};
+
+/// Deprecated, use `@intFromEnum(std.elf.DATA.NONE)`
+pub const ELFDATANONE = @intFromEnum(DATA.NONE);
+/// Deprecated, use `@intFromEnum(std.elf.DATA.@"2LSB")`
+pub const ELFDATA2LSB = @intFromEnum(DATA.@"2LSB");
+/// Deprecated, use `@intFromEnum(std.elf.DATA.@"2MSB")`
+pub const ELFDATA2MSB = @intFromEnum(DATA.@"2MSB");
+/// Deprecated, use `@intFromEnum(std.elf.DATA.NUM)`
+pub const ELFDATANUM = DATA.NUM;
+pub const DATA = enum(u8) {
+ NONE = 0,
+ @"2LSB" = 1,
+ @"2MSB" = 2,
+ _,
+
+ pub const NUM = @typeInfo(DATA).@"enum".fields.len;
};
pub const OSABI = enum(u8) {
@@ -1718,6 +2001,108 @@ pub const SHF_MIPS_STRING = 0x80000000;
/// Make code section unreadable when in execute-only mode
pub const SHF_ARM_PURECODE = 0x2000000;
+pub const SHF = packed struct(Word) {
+ /// Section data should be writable during execution.
+ WRITE: bool = false,
+ /// Section occupies memory during program execution.
+ ALLOC: bool = false,
+ /// Section contains executable machine instructions.
+ EXECINSTR: bool = false,
+ unused3: u1 = 0,
+ /// The data in this section may be merged.
+ MERGE: bool = false,
+ /// The data in this section is null-terminated strings.
+ STRINGS: bool = false,
+ /// A field in this section holds a section header table index.
+ INFO_LINK: bool = false,
+ /// Adds special ordering requirements for link editors.
+ LINK_ORDER: bool = false,
+ /// This section requires special OS-specific processing to avoid incorrect behavior.
+ OS_NONCONFORMING: bool = false,
+ /// This section is a member of a section group.
+ GROUP: bool = false,
+ /// This section holds Thread-Local Storage.
+ TLS: bool = false,
+ /// Identifies a section containing compressed data.
+ COMPRESSED: bool = false,
+ unused12: u8 = 0,
+ OS: packed union {
+ MASK: u8,
+ GNU: packed struct(u8) {
+ unused0: u1 = 0,
+ /// Not to be GCed by the linker
+ RETAIN: bool = false,
+ unused2: u6 = 0,
+ },
+ MIPS: packed struct(u8) {
+ unused0: u4 = 0,
+ /// Section contains text/data which may be replicated in other sections.
+ /// Linker must retain only one copy.
+ NODUPES: bool = false,
+ /// Linker must generate implicit hidden weak names.
+ NAMES: bool = false,
+ /// Section data local to process.
+ LOCAL: bool = false,
+ /// Do not strip this section.
+ NOSTRIP: bool = false,
+ },
+ ARM: packed struct(u8) {
+ unused0: u5 = 0,
+ /// Make code section unreadable when in execute-only mode
+ PURECODE: bool = false,
+ unused6: u2 = 0,
+ },
+ } = .{ .MASK = 0 },
+ PROC: packed union {
+ MASK: u4,
+ XCORE: packed struct(u4) {
+ /// All sections with the "d" flag are grouped together by the linker to form
+ /// the data section and the dp register is set to the start of the section by
+ /// the boot code.
+ DP_SECTION: bool = false,
+ /// All sections with the "c" flag are grouped together by the linker to form
+ /// the constant pool and the cp register is set to the start of the constant
+ /// pool by the boot code.
+ CP_SECTION: bool = false,
+ unused2: u1 = 0,
+ /// This section is excluded from the final executable or shared library.
+ EXCLUDE: bool = false,
+ },
+ X86_64: packed struct(u4) {
+ /// If an object file section does not have this flag set, then it may not hold
+ /// more than 2GB and can be freely referred to in objects using smaller code
+ /// models. Otherwise, only objects using larger code models can refer to them.
+ /// For example, a medium code model object can refer to data in a section that
+ /// sets this flag besides being able to refer to data in a section that does
+ /// not set it; likewise, a small code model object can refer only to code in a
+ /// section that does not set this flag.
+ LARGE: bool = false,
+ unused1: u2 = 0,
+ /// This section is excluded from the final executable or shared library.
+ EXCLUDE: bool = false,
+ },
+ HEX: packed struct(u4) {
+ /// All sections with the GPREL flag are grouped into a global data area
+ /// for faster accesses
+ GPREL: bool = false,
+ unused1: u2 = 0,
+ /// This section is excluded from the final executable or shared library.
+ EXCLUDE: bool = false,
+ },
+ MIPS: packed struct(u4) {
+ /// All sections with the GPREL flag are grouped into a global data area
+ /// for faster accesses
+ GPREL: bool = false,
+ /// This section should be merged.
+ MERGE: bool = false,
+ /// Address size to be inferred from section entry size.
+ ADDR: bool = false,
+ /// Section data is string data by default.
+ STRING: bool = false,
+ },
+ } = .{ .MASK = 0 },
+};
+
/// Execute
pub const PF_X = 1;
@@ -1733,6 +2118,19 @@ pub const PF_MASKOS = 0x0ff00000;
/// Bits for processor-specific semantics.
pub const PF_MASKPROC = 0xf0000000;
+pub const PF = packed struct(Word) {
+ X: bool = false,
+ W: bool = false,
+ R: bool = false,
+ unused3: u17 = 0,
+ OS: packed union {
+ MASK: u8,
+ } = .{ .MASK = 0 },
+ PROC: packed union {
+ MASK: u4,
+ } = .{ .MASK = 0 },
+};
+
/// Undefined section
pub const SHN_UNDEF = 0;
/// Start of reserved indices
@@ -2303,13 +2701,6 @@ pub const R_PPC64 = enum(u32) {
_,
};
-pub const STV = enum(u3) {
- DEFAULT = 0,
- INTERNAL = 1,
- HIDDEN = 2,
- PROTECTED = 3,
-};
-
pub const ar_hdr = extern struct {
/// Member file name, sometimes / terminated.
ar_name: [16]u8,
src/arch/riscv64/CodeGen.zig
@@ -858,9 +858,11 @@ pub fn generateLazy(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
lazy_sym: link.File.LazySymbol,
- code: *std.ArrayListUnmanaged(u8),
+ atom_index: u32,
+ w: *std.Io.Writer,
debug_output: link.File.DebugInfoOutput,
-) CodeGenError!void {
+) (CodeGenError || std.Io.Writer.Error)!void {
+ _ = atom_index;
const comp = bin_file.comp;
const gpa = comp.gpa;
const mod = comp.root_mod;
@@ -914,7 +916,7 @@ pub fn generateLazy(
},
.bin_file = bin_file,
.debug_output = debug_output,
- .code = code,
+ .w = w,
.prev_di_pc = undefined, // no debug info yet
.prev_di_line = undefined, // no debug info yet
.prev_di_column = undefined, // no debug info yet
src/arch/riscv64/Emit.zig
@@ -3,7 +3,7 @@
bin_file: *link.File,
lower: Lower,
debug_output: link.File.DebugInfoOutput,
-code: *std.ArrayListUnmanaged(u8),
+w: *std.Io.Writer,
prev_di_line: u32,
prev_di_column: u32,
@@ -13,7 +13,7 @@ prev_di_pc: usize,
code_offset_mapping: std.AutoHashMapUnmanaged(Mir.Inst.Index, usize) = .empty,
relocs: std.ArrayListUnmanaged(Reloc) = .empty,
-pub const Error = Lower.Error || error{
+pub const Error = Lower.Error || std.Io.Writer.Error || error{
EmitFail,
};
@@ -25,13 +25,13 @@ pub fn emitMir(emit: *Emit) Error!void {
try emit.code_offset_mapping.putNoClobber(
emit.lower.allocator,
mir_index,
- @intCast(emit.code.items.len),
+ @intCast(emit.w.end),
);
const lowered = try emit.lower.lowerMir(mir_index, .{ .allow_frame_locs = true });
var lowered_relocs = lowered.relocs;
for (lowered.insts, 0..) |lowered_inst, lowered_index| {
- const start_offset: u32 = @intCast(emit.code.items.len);
- std.mem.writeInt(u32, try emit.code.addManyAsArray(gpa, 4), lowered_inst.toU32(), .little);
+ const start_offset: u32 = @intCast(emit.w.end);
+ try emit.w.writeInt(u32, lowered_inst.toU32(), .little);
while (lowered_relocs.len > 0 and
lowered_relocs[0].lowered_inst_index == lowered_index) : ({
@@ -175,7 +175,7 @@ fn fixupRelocs(emit: *Emit) Error!void {
return emit.fail("relocation target not found!", .{});
const disp = @as(i32, @intCast(target)) - @as(i32, @intCast(reloc.source));
- const code: *[4]u8 = emit.code.items[reloc.source + reloc.offset ..][0..4];
+ const code = emit.w.buffered()[reloc.source + reloc.offset ..][0..4];
switch (reloc.fmt) {
.J => riscv_util.writeInstJ(code, @bitCast(disp)),
@@ -187,7 +187,7 @@ fn fixupRelocs(emit: *Emit) Error!void {
fn dbgAdvancePCAndLine(emit: *Emit, line: u32, column: u32) Error!void {
const delta_line = @as(i33, line) - @as(i33, emit.prev_di_line);
- const delta_pc: usize = emit.code.items.len - emit.prev_di_pc;
+ const delta_pc: usize = emit.w.end - emit.prev_di_pc;
log.debug(" (advance pc={d} and line={d})", .{ delta_pc, delta_line });
switch (emit.debug_output) {
.dwarf => |dw| {
@@ -196,7 +196,7 @@ fn dbgAdvancePCAndLine(emit: *Emit, line: u32, column: u32) Error!void {
try dw.advancePCAndLine(delta_line, delta_pc);
emit.prev_di_line = line;
emit.prev_di_column = column;
- emit.prev_di_pc = emit.code.items.len;
+ emit.prev_di_pc = emit.w.end;
},
.none => {},
}
src/arch/riscv64/Mir.zig
@@ -109,9 +109,11 @@ pub fn emit(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
func_index: InternPool.Index,
- code: *std.ArrayListUnmanaged(u8),
+ atom_index: u32,
+ w: *std.Io.Writer,
debug_output: link.File.DebugInfoOutput,
-) codegen.CodeGenError!void {
+) (codegen.CodeGenError || std.Io.Writer.Error)!void {
+ _ = atom_index;
const zcu = pt.zcu;
const comp = zcu.comp;
const gpa = comp.gpa;
@@ -132,7 +134,7 @@ pub fn emit(
},
.bin_file = lf,
.debug_output = debug_output,
- .code = code,
+ .w = w,
.prev_di_pc = 0,
.prev_di_line = func.lbrace_line,
.prev_di_column = func.lbrace_column,
src/arch/sparc64/Emit.zig
@@ -21,7 +21,7 @@ debug_output: link.File.DebugInfoOutput,
target: *const std.Target,
err_msg: ?*ErrorMsg = null,
src_loc: Zcu.LazySrcLoc,
-code: *std.ArrayListUnmanaged(u8),
+w: *std.Io.Writer,
prev_di_line: u32,
prev_di_column: u32,
@@ -40,7 +40,7 @@ branch_forward_origins: std.AutoHashMapUnmanaged(Mir.Inst.Index, std.ArrayListUn
/// instruction
code_offset_mapping: std.AutoHashMapUnmanaged(Mir.Inst.Index, usize) = .empty,
-const InnerError = error{
+const InnerError = std.Io.Writer.Error || error{
OutOfMemory,
EmitFail,
};
@@ -292,7 +292,7 @@ fn mirConditionalBranch(emit: *Emit, inst: Mir.Inst.Index) !void {
.bpcc => switch (tag) {
.bpcc => {
const branch_predict_int = emit.mir.instructions.items(.data)[inst].branch_predict_int;
- const offset = @as(i64, @intCast(emit.code_offset_mapping.get(branch_predict_int.inst).?)) - @as(i64, @intCast(emit.code.items.len));
+ const offset = @as(i64, @intCast(emit.code_offset_mapping.get(branch_predict_int.inst).?)) - @as(i64, @intCast(emit.w.end));
log.debug("mirConditionalBranch: {} offset={}", .{ inst, offset });
try emit.writeInstruction(
@@ -310,7 +310,7 @@ fn mirConditionalBranch(emit: *Emit, inst: Mir.Inst.Index) !void {
.bpr => switch (tag) {
.bpr => {
const branch_predict_reg = emit.mir.instructions.items(.data)[inst].branch_predict_reg;
- const offset = @as(i64, @intCast(emit.code_offset_mapping.get(branch_predict_reg.inst).?)) - @as(i64, @intCast(emit.code.items.len));
+ const offset = @as(i64, @intCast(emit.code_offset_mapping.get(branch_predict_reg.inst).?)) - @as(i64, @intCast(emit.w.end));
log.debug("mirConditionalBranch: {} offset={}", .{ inst, offset });
try emit.writeInstruction(
@@ -494,13 +494,13 @@ fn branchTarget(emit: *Emit, inst: Mir.Inst.Index) Mir.Inst.Index {
fn dbgAdvancePCAndLine(emit: *Emit, line: u32, column: u32) !void {
const delta_line = @as(i32, @intCast(line)) - @as(i32, @intCast(emit.prev_di_line));
- const delta_pc: usize = emit.code.items.len - emit.prev_di_pc;
+ const delta_pc: usize = emit.w.end - emit.prev_di_pc;
switch (emit.debug_output) {
.dwarf => |dbg_out| {
try dbg_out.advancePCAndLine(delta_line, delta_pc);
emit.prev_di_line = line;
emit.prev_di_column = column;
- emit.prev_di_pc = emit.code.items.len;
+ emit.prev_di_pc = emit.w.end;
},
else => {},
}
@@ -675,13 +675,8 @@ fn optimalBranchType(emit: *Emit, tag: Mir.Inst.Tag, offset: i64) !BranchType {
}
fn writeInstruction(emit: *Emit, instruction: Instruction) !void {
- const comp = emit.bin_file.comp;
- const gpa = comp.gpa;
-
// SPARCv9 instructions are always arranged in BE regardless of the
// endianness mode the CPU is running in (Section 3.1 of the ISA specification).
// This is to ease porting in case someone wants to do a LE SPARCv9 backend.
- const endian: Endian = .big;
-
- std.mem.writeInt(u32, try emit.code.addManyAsArray(gpa, 4), instruction.toU32(), endian);
+ try emit.w.writeInt(u32, instruction.toU32(), .big);
}
src/arch/sparc64/Mir.zig
@@ -380,9 +380,11 @@ pub fn emit(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
func_index: InternPool.Index,
- code: *std.ArrayListUnmanaged(u8),
+ atom_index: u32,
+ w: *std.Io.Writer,
debug_output: link.File.DebugInfoOutput,
-) codegen.CodeGenError!void {
+) (codegen.CodeGenError || std.Io.Writer.Error)!void {
+ _ = atom_index;
const zcu = pt.zcu;
const func = zcu.funcInfo(func_index);
const nav = func.owner_nav;
@@ -393,7 +395,7 @@ pub fn emit(
.debug_output = debug_output,
.target = &mod.resolved_target.result,
.src_loc = src_loc,
- .code = code,
+ .w = w,
.prev_di_pc = 0,
.prev_di_line = func.lbrace_line,
.prev_di_column = func.lbrace_column,
src/arch/x86_64/bits.zig
@@ -727,6 +727,14 @@ pub const FrameIndex = enum(u32) {
pub fn isNamed(fi: FrameIndex) bool {
return @intFromEnum(fi) < named_count;
}
+
+ pub fn format(fi: FrameIndex, writer: *std.Io.Writer) std.Io.Writer.Error!void {
+ if (fi.isNamed()) {
+ try writer.print("FrameIndex.{t}", .{fi});
+ } else {
+ try writer.print("FrameIndex({d})", .{@intFromEnum(fi)});
+ }
+ }
};
pub const FrameAddr = struct { index: FrameIndex, off: i32 = 0 };
src/arch/x86_64/CodeGen.zig
@@ -550,9 +550,9 @@ pub const MCValue = union(enum) {
@tagName(pl.reg),
}),
.indirect => |pl| try w.print("[{s} + 0x{x}]", .{ @tagName(pl.reg), pl.off }),
- .indirect_load_frame => |pl| try w.print("[[{} + 0x{x}]]", .{ pl.index, pl.off }),
- .load_frame => |pl| try w.print("[{} + 0x{x}]", .{ pl.index, pl.off }),
- .lea_frame => |pl| try w.print("{} + 0x{x}", .{ pl.index, pl.off }),
+ .indirect_load_frame => |pl| try w.print("[[{f} + 0x{x}]]", .{ pl.index, pl.off }),
+ .load_frame => |pl| try w.print("[{f} + 0x{x}]", .{ pl.index, pl.off }),
+ .lea_frame => |pl| try w.print("{f} + 0x{x}", .{ pl.index, pl.off }),
.load_nav => |pl| try w.print("[nav:{d}]", .{@intFromEnum(pl)}),
.lea_nav => |pl| try w.print("nav:{d}", .{@intFromEnum(pl)}),
.load_uav => |pl| try w.print("[uav:{d}]", .{@intFromEnum(pl.val)}),
@@ -561,10 +561,10 @@ pub const MCValue = union(enum) {
.lea_lazy_sym => |pl| try w.print("lazy:{s}:{d}", .{ @tagName(pl.kind), @intFromEnum(pl.ty) }),
.load_extern_func => |pl| try w.print("[extern:{d}]", .{@intFromEnum(pl)}),
.lea_extern_func => |pl| try w.print("extern:{d}", .{@intFromEnum(pl)}),
- .elementwise_args => |pl| try w.print("elementwise:{d}:[{} + 0x{x}]", .{
+ .elementwise_args => |pl| try w.print("elementwise:{d}:[{f} + 0x{x}]", .{
pl.regs, pl.frame_index, pl.frame_off,
}),
- .reserved_frame => |pl| try w.print("(dead:{})", .{pl}),
+ .reserved_frame => |pl| try w.print("(dead:{f})", .{pl}),
.air_ref => |pl| try w.print("(air:0x{x})", .{@intFromEnum(pl)}),
}
}
@@ -1038,7 +1038,8 @@ pub fn generateLazy(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
lazy_sym: link.File.LazySymbol,
- code: *std.ArrayListUnmanaged(u8),
+ atom_index: u32,
+ w: *std.Io.Writer,
debug_output: link.File.DebugInfoOutput,
) codegen.CodeGenError!void {
const gpa = pt.zcu.gpa;
@@ -1081,7 +1082,7 @@ pub fn generateLazy(
else => |e| return e,
};
- try function.getTmpMir().emitLazy(bin_file, pt, src_loc, lazy_sym, code, debug_output);
+ try function.getTmpMir().emitLazy(bin_file, pt, src_loc, lazy_sym, atom_index, w, debug_output);
}
const FormatNavData = struct {
@@ -2022,7 +2023,7 @@ fn gen(
.{},
);
self.ret_mcv.long = .{ .load_frame = .{ .index = frame_index } };
- tracking_log.debug("spill {f} to {}", .{ self.ret_mcv.long, frame_index });
+ tracking_log.debug("spill {f} to {f}", .{ self.ret_mcv.long, frame_index });
},
else => unreachable,
}
src/arch/x86_64/Emit.zig
@@ -6,7 +6,7 @@ pt: Zcu.PerThread,
pic: bool,
atom_index: u32,
debug_output: link.File.DebugInfoOutput,
-code: *std.ArrayListUnmanaged(u8),
+w: *std.Io.Writer,
prev_di_loc: Loc,
/// Relative to the beginning of `code`.
@@ -18,7 +18,8 @@ table_relocs: std.ArrayListUnmanaged(TableReloc),
pub const Error = Lower.Error || error{
EmitFail,
-} || link.File.UpdateDebugInfoError;
+ NotFile,
+} || std.posix.MMapError || std.posix.MRemapError || link.File.UpdateDebugInfoError;
pub fn emitMir(emit: *Emit) Error!void {
const comp = emit.bin_file.comp;
@@ -29,12 +30,12 @@ pub fn emitMir(emit: *Emit) Error!void {
var local_index: usize = 0;
for (0..emit.lower.mir.instructions.len) |mir_i| {
const mir_index: Mir.Inst.Index = @intCast(mir_i);
- emit.code_offset_mapping.items[mir_index] = @intCast(emit.code.items.len);
+ emit.code_offset_mapping.items[mir_index] = @intCast(emit.w.end);
const lowered = try emit.lower.lowerMir(mir_index);
var lowered_relocs = lowered.relocs;
lowered_inst: for (lowered.insts, 0..) |lowered_inst, lowered_index| {
if (lowered_inst.prefix == .directive) {
- const start_offset: u32 = @intCast(emit.code.items.len);
+ const start_offset: u32 = @intCast(emit.w.end);
switch (emit.debug_output) {
.dwarf => |dwarf| switch (lowered_inst.encoding.mnemonic) {
.@".cfi_def_cfa" => try dwarf.genDebugFrame(start_offset, .{ .def_cfa = .{
@@ -164,6 +165,8 @@ pub fn emitMir(emit: *Emit) Error!void {
.index = if (emit.bin_file.cast(.elf)) |elf_file|
elf_file.zigObjectPtr().?.getOrCreateMetadataForLazySymbol(elf_file, emit.pt, lazy_sym) catch |err|
return emit.fail("{s} creating lazy symbol", .{@errorName(err)})
+ else if (emit.bin_file.cast(.elf2)) |elf|
+ @intFromEnum(try elf.lazySymbol(lazy_sym))
else if (emit.bin_file.cast(.macho)) |macho_file|
macho_file.getZigObject().?.getOrCreateMetadataForLazySymbol(macho_file, emit.pt, lazy_sym) catch |err|
return emit.fail("{s} creating lazy symbol", .{@errorName(err)})
@@ -180,12 +183,15 @@ pub fn emitMir(emit: *Emit) Error!void {
.extern_func => |extern_func| .{
.index = if (emit.bin_file.cast(.elf)) |elf_file|
try elf_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, null)
- else if (emit.bin_file.cast(.macho)) |macho_file|
+ else if (emit.bin_file.cast(.elf2)) |elf| @intFromEnum(try elf.globalSymbol(.{
+ .name = extern_func.toSlice(&emit.lower.mir).?,
+ .type = .FUNC,
+ })) else if (emit.bin_file.cast(.macho)) |macho_file|
try macho_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, null)
else if (emit.bin_file.cast(.coff)) |coff_file|
try coff_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, "compiler_rt")
else
- return emit.fail("external symbols unimplemented for {s}", .{@tagName(emit.bin_file.tag)}),
+ return emit.fail("external symbol unimplemented for {s}", .{@tagName(emit.bin_file.tag)}),
.is_extern = true,
.type = .symbol,
},
@@ -205,7 +211,7 @@ pub fn emitMir(emit: *Emit) Error!void {
},
else => {},
}
- if (emit.bin_file.cast(.elf)) |_| {
+ if (emit.bin_file.cast(.elf) != null or emit.bin_file.cast(.elf2) != null) {
if (!emit.pic) switch (lowered_inst.encoding.mnemonic) {
.lea => try emit.encodeInst(try .new(.none, .mov, &.{
lowered_inst.ops[0],
@@ -315,7 +321,7 @@ pub fn emitMir(emit: *Emit) Error!void {
},
.branch, .tls => unreachable,
.tlv => {
- if (emit.bin_file.cast(.elf)) |elf_file| {
+ if (emit.bin_file.cast(.elf) != null or emit.bin_file.cast(.elf2) != null) {
// TODO handle extern TLS vars, i.e., emit GD model
if (emit.pic) switch (lowered_inst.encoding.mnemonic) {
.lea, .mov => {
@@ -337,7 +343,12 @@ pub fn emitMir(emit: *Emit) Error!void {
}, emit.lower.target), &.{.{
.op_index = 0,
.target = .{
- .index = try elf_file.getGlobalSymbol("__tls_get_addr", null),
+ .index = if (emit.bin_file.cast(.elf)) |elf_file|
+ try elf_file.getGlobalSymbol("__tls_get_addr", null)
+ else if (emit.bin_file.cast(.elf2)) |elf| @intFromEnum(try elf.globalSymbol(.{
+ .name = "__tls_get_addr",
+ .type = .FUNC,
+ })) else unreachable,
.is_extern = true,
.type = .branch,
},
@@ -441,7 +452,7 @@ pub fn emitMir(emit: *Emit) Error!void {
log.debug("mirDbgEnterBlock (line={d}, col={d})", .{
emit.prev_di_loc.line, emit.prev_di_loc.column,
});
- try dwarf.enterBlock(emit.code.items.len);
+ try dwarf.enterBlock(emit.w.end);
},
.none => {},
},
@@ -450,7 +461,7 @@ pub fn emitMir(emit: *Emit) Error!void {
log.debug("mirDbgLeaveBlock (line={d}, col={d})", .{
emit.prev_di_loc.line, emit.prev_di_loc.column,
});
- try dwarf.leaveBlock(emit.code.items.len);
+ try dwarf.leaveBlock(emit.w.end);
},
.none => {},
},
@@ -459,7 +470,7 @@ pub fn emitMir(emit: *Emit) Error!void {
log.debug("mirDbgEnterInline (line={d}, col={d})", .{
emit.prev_di_loc.line, emit.prev_di_loc.column,
});
- try dwarf.enterInlineFunc(mir_inst.data.ip_index, emit.code.items.len, emit.prev_di_loc.line, emit.prev_di_loc.column);
+ try dwarf.enterInlineFunc(mir_inst.data.ip_index, emit.w.end, emit.prev_di_loc.line, emit.prev_di_loc.column);
},
.none => {},
},
@@ -468,7 +479,7 @@ pub fn emitMir(emit: *Emit) Error!void {
log.debug("mirDbgLeaveInline (line={d}, col={d})", .{
emit.prev_di_loc.line, emit.prev_di_loc.column,
});
- try dwarf.leaveInlineFunc(mir_inst.data.ip_index, emit.code.items.len);
+ try dwarf.leaveInlineFunc(mir_inst.data.ip_index, emit.w.end);
},
.none => {},
},
@@ -634,7 +645,7 @@ pub fn emitMir(emit: *Emit) Error!void {
for (emit.relocs.items) |reloc| {
const target = emit.code_offset_mapping.items[reloc.target];
const disp = @as(i64, @intCast(target)) - @as(i64, @intCast(reloc.inst_offset + reloc.inst_length)) + reloc.target_offset;
- const inst_bytes = emit.code.items[reloc.inst_offset..][0..reloc.inst_length];
+ const inst_bytes = emit.w.buffered()[reloc.inst_offset..][0..reloc.inst_length];
switch (reloc.source_length) {
else => unreachable,
inline 1, 4 => |source_length| std.mem.writeInt(
@@ -646,12 +657,12 @@ pub fn emitMir(emit: *Emit) Error!void {
}
}
if (emit.lower.mir.table.len > 0) {
+ const ptr_size = @divExact(emit.lower.target.ptrBitWidth(), 8);
+ var table_offset = std.mem.alignForward(u32, @intCast(emit.w.end), ptr_size);
if (emit.bin_file.cast(.elf)) |elf_file| {
const zo = elf_file.zigObjectPtr().?;
const atom = zo.symbol(emit.atom_index).atom(elf_file).?;
- const ptr_size = @divExact(emit.lower.target.ptrBitWidth(), 8);
- var table_offset = std.mem.alignForward(u32, @intCast(emit.code.items.len), ptr_size);
for (emit.table_relocs.items) |table_reloc| try atom.addReloc(gpa, .{
.r_offset = table_reloc.source_offset,
.r_info = @as(u64, emit.atom_index) << 32 | @intFromEnum(std.elf.R_X86_64.@"32"),
@@ -665,7 +676,26 @@ pub fn emitMir(emit: *Emit) Error!void {
}, zo);
table_offset += ptr_size;
}
- try emit.code.appendNTimes(gpa, 0, table_offset - emit.code.items.len);
+ try emit.w.splatByteAll(0, table_offset - emit.w.end);
+ } else if (emit.bin_file.cast(.elf2)) |elf| {
+ for (emit.table_relocs.items) |table_reloc| try elf.addReloc(
+ @enumFromInt(emit.atom_index),
+ table_reloc.source_offset,
+ @enumFromInt(emit.atom_index),
+ @as(i64, table_offset) + table_reloc.target_offset,
+ .{ .x86_64 = .@"32" },
+ );
+ for (emit.lower.mir.table) |entry| {
+ try elf.addReloc(
+ @enumFromInt(emit.atom_index),
+ table_offset,
+ @enumFromInt(emit.atom_index),
+ emit.code_offset_mapping.items[entry],
+ .{ .x86_64 = .@"64" },
+ );
+ table_offset += ptr_size;
+ }
+ try emit.w.splatByteAll(0, table_offset - emit.w.end);
} else unreachable;
}
}
@@ -696,16 +726,12 @@ const RelocInfo = struct {
fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocInfo) Error!void {
const comp = emit.bin_file.comp;
const gpa = comp.gpa;
- const start_offset: u32 = @intCast(emit.code.items.len);
- {
- var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, emit.code);
- defer emit.code.* = aw.toArrayList();
- lowered_inst.encode(&aw.writer, .{}) catch |err| switch (err) {
- error.WriteFailed => return error.OutOfMemory,
- else => |e| return e,
- };
- }
- const end_offset: u32 = @intCast(emit.code.items.len);
+ const start_offset: u32 = @intCast(emit.w.end);
+ lowered_inst.encode(emit.w, .{}) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ const end_offset: u32 = @intCast(emit.w.end);
for (reloc_info) |reloc| switch (reloc.target.type) {
.inst => {
const inst_length: u4 = @intCast(end_offset - start_offset);
@@ -769,7 +795,13 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI
.symbolnum = @intCast(reloc.target.index),
},
});
- } else if (emit.bin_file.cast(.coff)) |coff_file| {
+ } else if (emit.bin_file.cast(.elf2)) |elf| try elf.addReloc(
+ @enumFromInt(emit.atom_index),
+ end_offset - 4,
+ @enumFromInt(reloc.target.index),
+ reloc.off,
+ .{ .x86_64 = .@"32" },
+ ) else if (emit.bin_file.cast(.coff)) |coff_file| {
const atom_index = coff_file.getAtomIndexForSymbol(
.{ .sym_index = emit.atom_index, .file = null },
).?;
@@ -794,7 +826,13 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI
.r_info = @as(u64, reloc.target.index) << 32 | @intFromEnum(r_type),
.r_addend = reloc.off - 4,
}, zo);
- } else if (emit.bin_file.cast(.macho)) |macho_file| {
+ } else if (emit.bin_file.cast(.elf2)) |elf| try elf.addReloc(
+ @enumFromInt(emit.atom_index),
+ end_offset - 4,
+ @enumFromInt(reloc.target.index),
+ reloc.off - 4,
+ .{ .x86_64 = .PC32 },
+ ) else if (emit.bin_file.cast(.macho)) |macho_file| {
const zo = macho_file.getZigObject().?;
const atom = zo.symbols.items[emit.atom_index].getAtom(macho_file).?;
try atom.addReloc(macho_file, .{
@@ -849,7 +887,13 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI
.r_info = @as(u64, reloc.target.index) << 32 | @intFromEnum(r_type),
.r_addend = reloc.off,
}, zo);
- } else if (emit.bin_file.cast(.macho)) |macho_file| {
+ } else if (emit.bin_file.cast(.elf2)) |elf| try elf.addReloc(
+ @enumFromInt(emit.atom_index),
+ end_offset - 4,
+ @enumFromInt(reloc.target.index),
+ reloc.off,
+ .{ .x86_64 = .TPOFF32 },
+ ) else if (emit.bin_file.cast(.macho)) |macho_file| {
const zo = macho_file.getZigObject().?;
const atom = zo.symbols.items[emit.atom_index].getAtom(macho_file).?;
try atom.addReloc(macho_file, .{
@@ -908,7 +952,7 @@ const Loc = struct {
fn dbgAdvancePCAndLine(emit: *Emit, loc: Loc) Error!void {
const delta_line = @as(i33, loc.line) - @as(i33, emit.prev_di_loc.line);
- const delta_pc: usize = emit.code.items.len - emit.prev_di_pc;
+ const delta_pc: usize = emit.w.end - emit.prev_di_pc;
log.debug(" (advance pc={d} and line={d})", .{ delta_pc, delta_line });
switch (emit.debug_output) {
.dwarf => |dwarf| {
@@ -916,7 +960,7 @@ fn dbgAdvancePCAndLine(emit: *Emit, loc: Loc) Error!void {
if (loc.column != emit.prev_di_loc.column) try dwarf.setColumn(loc.column);
try dwarf.advancePCAndLine(delta_line, delta_pc);
emit.prev_di_loc = loc;
- emit.prev_di_pc = emit.code.items.len;
+ emit.prev_di_pc = emit.w.end;
},
.none => {},
}
src/arch/x86_64/encoder.zig
@@ -259,7 +259,7 @@ pub const Instruction = struct {
switch (sib.base) {
.none => any = false,
.reg => |reg| try w.print("{s}", .{@tagName(reg)}),
- .frame => |frame_index| try w.print("{}", .{frame_index}),
+ .frame => |frame_index| try w.print("{f}", .{frame_index}),
.table => try w.print("Table", .{}),
.rip_inst => |inst_index| try w.print("RipInst({d})", .{inst_index}),
.nav => |nav| try w.print("Nav({d})", .{@intFromEnum(nav)}),
src/arch/x86_64/Mir.zig
@@ -1976,7 +1976,8 @@ pub fn emit(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
func_index: InternPool.Index,
- code: *std.ArrayListUnmanaged(u8),
+ atom_index: u32,
+ w: *std.Io.Writer,
debug_output: link.File.DebugInfoOutput,
) codegen.CodeGenError!void {
const zcu = pt.zcu;
@@ -1997,17 +1998,9 @@ pub fn emit(
.bin_file = lf,
.pt = pt,
.pic = mod.pic,
- .atom_index = sym: {
- if (lf.cast(.elf)) |ef| break :sym try ef.zigObjectPtr().?.getOrCreateMetadataForNav(zcu, nav);
- if (lf.cast(.macho)) |mf| break :sym try mf.getZigObject().?.getOrCreateMetadataForNav(mf, nav);
- if (lf.cast(.coff)) |cf| {
- const atom = try cf.getOrCreateAtomForNav(nav);
- break :sym cf.getAtom(atom).getSymbolIndex().?;
- }
- unreachable;
- },
+ .atom_index = atom_index,
.debug_output = debug_output,
- .code = code,
+ .w = w,
.prev_di_loc = .{
.line = func.lbrace_line,
@@ -2037,7 +2030,8 @@ pub fn emitLazy(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
lazy_sym: link.File.LazySymbol,
- code: *std.ArrayListUnmanaged(u8),
+ atom_index: u32,
+ w: *std.Io.Writer,
debug_output: link.File.DebugInfoOutput,
) codegen.CodeGenError!void {
const zcu = pt.zcu;
@@ -2055,20 +2049,9 @@ pub fn emitLazy(
.bin_file = lf,
.pt = pt,
.pic = mod.pic,
- .atom_index = sym: {
- if (lf.cast(.elf)) |ef| break :sym ef.zigObjectPtr().?.getOrCreateMetadataForLazySymbol(ef, pt, lazy_sym) catch |err|
- return zcu.codegenFailType(lazy_sym.ty, "{s} creating lazy symbol", .{@errorName(err)});
- if (lf.cast(.macho)) |mf| break :sym mf.getZigObject().?.getOrCreateMetadataForLazySymbol(mf, pt, lazy_sym) catch |err|
- return zcu.codegenFailType(lazy_sym.ty, "{s} creating lazy symbol", .{@errorName(err)});
- if (lf.cast(.coff)) |cf| {
- const atom = cf.getOrCreateAtomForLazySymbol(pt, lazy_sym) catch |err|
- return zcu.codegenFailType(lazy_sym.ty, "{s} creating lazy symbol", .{@errorName(err)});
- break :sym cf.getAtom(atom).getSymbolIndex().?;
- }
- unreachable;
- },
+ .atom_index = atom_index,
.debug_output = debug_output,
- .code = code,
+ .w = w,
.prev_di_loc = undefined,
.prev_di_pc = undefined,
src/codegen/aarch64/Mir.zig
@@ -56,13 +56,13 @@ pub fn emit(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
func_index: InternPool.Index,
- code: *std.ArrayListUnmanaged(u8),
+ atom_index: u32,
+ w: *std.Io.Writer,
debug_output: link.File.DebugInfoOutput,
) !void {
_ = debug_output;
const zcu = pt.zcu;
const ip = &zcu.intern_pool;
- const gpa = zcu.gpa;
const func = zcu.funcInfo(func_index);
const nav = ip.getNav(func.owner_nav);
const mod = zcu.navFileScope(func.owner_nav).mod.?;
@@ -81,20 +81,19 @@ pub fn emit(
@as(u5, @intCast(func_align.minStrict(.@"16").toByteUnits().?)),
Instruction.size,
) - 1);
- try code.ensureUnusedCapacity(gpa, Instruction.size *
- (code_len + literals_align_gap + mir.literals.len));
- emitInstructionsForward(code, mir.prologue);
- emitInstructionsBackward(code, mir.body);
- const body_end: u32 = @intCast(code.items.len);
- emitInstructionsBackward(code, mir.epilogue);
- code.appendNTimesAssumeCapacity(0, Instruction.size * literals_align_gap);
- code.appendSliceAssumeCapacity(@ptrCast(mir.literals));
+ try w.rebase(w.end, Instruction.size * (code_len + literals_align_gap + mir.literals.len));
+ emitInstructionsForward(w, mir.prologue) catch unreachable;
+ emitInstructionsBackward(w, mir.body) catch unreachable;
+ const body_end: u32 = @intCast(w.end);
+ emitInstructionsBackward(w, mir.epilogue) catch unreachable;
+ w.splatByteAll(0, Instruction.size * literals_align_gap) catch unreachable;
+ w.writeAll(@ptrCast(mir.literals)) catch unreachable;
mir_log.debug("", .{});
for (mir.nav_relocs) |nav_reloc| try emitReloc(
lf,
zcu,
- func.owner_nav,
+ atom_index,
switch (try @import("../../codegen.zig").genNavRef(
lf,
pt,
@@ -112,7 +111,7 @@ pub fn emit(
for (mir.uav_relocs) |uav_reloc| try emitReloc(
lf,
zcu,
- func.owner_nav,
+ atom_index,
switch (try lf.lowerUav(
pt,
uav_reloc.uav.val,
@@ -129,7 +128,7 @@ pub fn emit(
for (mir.lazy_relocs) |lazy_reloc| try emitReloc(
lf,
zcu,
- func.owner_nav,
+ atom_index,
if (lf.cast(.elf)) |ef|
ef.zigObjectPtr().?.getOrCreateMetadataForLazySymbol(ef, pt, lazy_reloc.symbol) catch |err|
return zcu.codegenFail(func.owner_nav, "{s} creating lazy symbol", .{@errorName(err)})
@@ -150,7 +149,7 @@ pub fn emit(
for (mir.global_relocs) |global_reloc| try emitReloc(
lf,
zcu,
- func.owner_nav,
+ atom_index,
if (lf.cast(.elf)) |ef|
try ef.getGlobalSymbol(std.mem.span(global_reloc.name), null)
else if (lf.cast(.macho)) |mf|
@@ -168,30 +167,30 @@ pub fn emit(
var instruction = mir.body[literal_reloc.label];
instruction.load_store.register_literal.group.imm19 += literal_reloc_offset;
instruction.write(
- code.items[body_end - Instruction.size * (1 + literal_reloc.label) ..][0..Instruction.size],
+ w.buffered()[body_end - Instruction.size * (1 + literal_reloc.label) ..][0..Instruction.size],
);
}
}
-fn emitInstructionsForward(code: *std.ArrayListUnmanaged(u8), instructions: []const Instruction) void {
- for (instructions) |instruction| emitInstruction(code, instruction);
+fn emitInstructionsForward(w: *std.Io.Writer, instructions: []const Instruction) !void {
+ for (instructions) |instruction| try emitInstruction(w, instruction);
}
-fn emitInstructionsBackward(code: *std.ArrayListUnmanaged(u8), instructions: []const Instruction) void {
+fn emitInstructionsBackward(w: *std.Io.Writer, instructions: []const Instruction) !void {
var instruction_index = instructions.len;
while (instruction_index > 0) {
instruction_index -= 1;
- emitInstruction(code, instructions[instruction_index]);
+ try emitInstruction(w, instructions[instruction_index]);
}
}
-fn emitInstruction(code: *std.ArrayListUnmanaged(u8), instruction: Instruction) void {
+fn emitInstruction(w: *std.Io.Writer, instruction: Instruction) !void {
mir_log.debug(" {f}", .{instruction});
- instruction.write(code.addManyAsArrayAssumeCapacity(Instruction.size));
+ instruction.write(try w.writableArray(Instruction.size));
}
fn emitReloc(
lf: *link.File,
zcu: *Zcu,
- owner_nav: InternPool.Nav.Index,
+ atom_index: u32,
sym_index: u32,
instruction: Instruction,
offset: u32,
@@ -202,7 +201,7 @@ fn emitReloc(
else => unreachable,
.data_processing_immediate => |decoded| if (lf.cast(.elf)) |ef| {
const zo = ef.zigObjectPtr().?;
- const atom = zo.symbol(try zo.getOrCreateMetadataForNav(zcu, owner_nav)).atom(ef).?;
+ const atom = zo.symbol(atom_index).atom(ef).?;
const r_type: std.elf.R_AARCH64 = switch (decoded.decode()) {
else => unreachable,
.pc_relative_addressing => |pc_relative_addressing| switch (pc_relative_addressing.group.op) {
@@ -221,7 +220,7 @@ fn emitReloc(
}, zo);
} else if (lf.cast(.macho)) |mf| {
const zo = mf.getZigObject().?;
- const atom = zo.symbols.items[try zo.getOrCreateMetadataForNav(mf, owner_nav)].getAtom(mf).?;
+ const atom = zo.symbols.items[atom_index].getAtom(mf).?;
switch (decoded.decode()) {
else => unreachable,
.pc_relative_addressing => |pc_relative_addressing| switch (pc_relative_addressing.group.op) {
@@ -260,7 +259,7 @@ fn emitReloc(
},
.branch_exception_generating_system => |decoded| if (lf.cast(.elf)) |ef| {
const zo = ef.zigObjectPtr().?;
- const atom = zo.symbol(try zo.getOrCreateMetadataForNav(zcu, owner_nav)).atom(ef).?;
+ const atom = zo.symbol(atom_index).atom(ef).?;
const r_type: std.elf.R_AARCH64 = switch (decoded.decode().unconditional_branch_immediate.group.op) {
.b => .JUMP26,
.bl => .CALL26,
@@ -272,7 +271,7 @@ fn emitReloc(
}, zo);
} else if (lf.cast(.macho)) |mf| {
const zo = mf.getZigObject().?;
- const atom = zo.symbols.items[try zo.getOrCreateMetadataForNav(mf, owner_nav)].getAtom(mf).?;
+ const atom = zo.symbols.items[atom_index].getAtom(mf).?;
try atom.addReloc(mf, .{
.tag = .@"extern",
.offset = offset,
@@ -289,7 +288,7 @@ fn emitReloc(
},
.load_store => |decoded| if (lf.cast(.elf)) |ef| {
const zo = ef.zigObjectPtr().?;
- const atom = zo.symbol(try zo.getOrCreateMetadataForNav(zcu, owner_nav)).atom(ef).?;
+ const atom = zo.symbol(atom_index).atom(ef).?;
const r_type: std.elf.R_AARCH64 = switch (decoded.decode().register_unsigned_immediate.decode()) {
.integer => |integer| switch (integer.decode()) {
.unallocated, .prfm => unreachable,
@@ -316,7 +315,7 @@ fn emitReloc(
}, zo);
} else if (lf.cast(.macho)) |mf| {
const zo = mf.getZigObject().?;
- const atom = zo.symbols.items[try zo.getOrCreateMetadataForNav(mf, owner_nav)].getAtom(mf).?;
+ const atom = zo.symbols.items[atom_index].getAtom(mf).?;
try atom.addReloc(mf, .{
.tag = .@"extern",
.offset = offset,
src/Compilation/Config.zig
@@ -49,6 +49,8 @@ use_lib_llvm: bool,
use_lld: bool,
c_frontend: CFrontend,
lto: std.zig.LtoMode,
+use_new_linker: bool,
+incremental: bool,
/// WASI-only. Type of WASI execution model ("command" or "reactor").
/// Always set to `command` for non-WASI targets.
wasi_exec_model: std.builtin.WasiExecModel,
@@ -104,6 +106,8 @@ pub const Options = struct {
use_lld: ?bool = null,
use_clang: ?bool = null,
lto: ?std.zig.LtoMode = null,
+ use_new_linker: ?bool = null,
+ incremental: bool = false,
/// WASI-only. Type of WASI execution model ("command" or "reactor").
wasi_exec_model: ?std.builtin.WasiExecModel = null,
import_memory: ?bool = null,
@@ -147,6 +151,8 @@ pub const ResolveError = error{
LldUnavailable,
ClangUnavailable,
DllExportFnsRequiresWindows,
+ NewLinkerIncompatibleWithLld,
+ NewLinkerIncompatibleObjectFormat,
};
pub fn resolve(options: Options) ResolveError!Config {
@@ -458,6 +464,22 @@ pub fn resolve(options: Options) ResolveError!Config {
break :b .none;
};
+ const use_new_linker = b: {
+ if (use_lld) {
+ if (options.use_new_linker == true) return error.NewLinkerIncompatibleWithLld;
+ break :b false;
+ }
+
+ if (!target_util.hasNewLinkerSupport(target.ofmt)) {
+ if (options.use_new_linker == true) return error.NewLinkerIncompatibleObjectFormat;
+ break :b false;
+ }
+
+ if (options.use_new_linker) |x| break :b x;
+
+ break :b options.incremental;
+ };
+
const root_strip = b: {
if (options.root_strip) |x| break :b x;
if (root_optimize_mode == .ReleaseSmall) break :b true;
@@ -531,6 +553,8 @@ pub fn resolve(options: Options) ResolveError!Config {
.root_error_tracing = root_error_tracing,
.pie = pie,
.lto = lto,
+ .use_new_linker = use_new_linker,
+ .incremental = options.incremental,
.import_memory = import_memory,
.export_memory = export_memory,
.shared_memory = shared_memory,
src/link/Elf/LinkerDefined.zig
@@ -47,7 +47,7 @@ fn newSymbolAssumeCapacity(self: *LinkerDefined, name_off: u32, elf_file: *Elf)
const esym = self.symtab.addOneAssumeCapacity();
esym.* = .{
.st_name = name_off,
- .st_info = elf.STB_WEAK << 4,
+ .st_info = @as(u8, elf.STB_WEAK) << 4,
.st_other = @intFromEnum(elf.STV.HIDDEN),
.st_shndx = elf.SHN_ABS,
.st_value = 0,
src/link/Elf/ZigObject.zig
@@ -277,8 +277,8 @@ pub fn flush(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !void {
pt,
.{ .kind = .code, .ty = .anyerror_type },
metadata.text_symbol_index,
- ) catch |err| return switch (err) {
- error.CodegenFail => error.LinkFailure,
+ ) catch |err| switch (err) {
+ error.CodegenFail => return error.LinkFailure,
else => |e| return e,
};
if (metadata.rodata_state != .unused) self.updateLazySymbol(
@@ -286,8 +286,8 @@ pub fn flush(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !void {
pt,
.{ .kind = .const_data, .ty = .anyerror_type },
metadata.rodata_symbol_index,
- ) catch |err| return switch (err) {
- error.CodegenFail => error.LinkFailure,
+ ) catch |err| switch (err) {
+ error.CodegenFail => return error.LinkFailure,
else => |e| return e,
};
}
@@ -1533,22 +1533,26 @@ pub fn updateFunc(
const sym_index = try self.getOrCreateMetadataForNav(zcu, func.owner_nav);
self.atom(self.symbol(sym_index).ref.index).?.freeRelocs(self);
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(gpa);
+ var aw: std.Io.Writer.Allocating = .init(gpa);
+ defer aw.deinit();
var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav(pt, func.owner_nav, sym_index) else null;
defer if (debug_wip_nav) |*wip_nav| wip_nav.deinit();
- try codegen.emitFunction(
+ codegen.emitFunction(
&elf_file.base,
pt,
zcu.navSrcLoc(func.owner_nav),
func_index,
+ sym_index,
mir,
- &code_buffer,
+ &aw.writer,
if (debug_wip_nav) |*dn| .{ .dwarf = dn } else .none,
- );
- const code = code_buffer.items;
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ const code = aw.written();
const shndx = try self.getNavShdrIndex(elf_file, zcu, func.owner_nav, sym_index, code);
log.debug("setting shdr({x},{s}) for {f}", .{
@@ -1663,21 +1667,24 @@ pub fn updateNav(
const sym_index = try self.getOrCreateMetadataForNav(zcu, nav_index);
self.symbol(sym_index).atom(elf_file).?.freeRelocs(self);
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(zcu.gpa);
+ var aw: std.Io.Writer.Allocating = .init(zcu.gpa);
+ defer aw.deinit();
var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav(pt, nav_index, sym_index) else null;
defer if (debug_wip_nav) |*wip_nav| wip_nav.deinit();
- try codegen.generateSymbol(
+ codegen.generateSymbol(
&elf_file.base,
pt,
zcu.navSrcLoc(nav_index),
Value.fromInterned(nav_init),
- &code_buffer,
+ &aw.writer,
.{ .atom_index = sym_index },
- );
- const code = code_buffer.items;
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ const code = aw.written();
const shndx = try self.getNavShdrIndex(elf_file, zcu, nav_index, sym_index, code);
log.debug("setting shdr({x},{s}) for {f}", .{
@@ -1722,8 +1729,8 @@ fn updateLazySymbol(
const gpa = zcu.gpa;
var required_alignment: InternPool.Alignment = .none;
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(gpa);
+ var aw: std.Io.Writer.Allocating = .init(gpa);
+ defer aw.deinit();
const name_str_index = blk: {
const name = try std.fmt.allocPrint(gpa, "__lazy_{s}_{f}", .{
@@ -1734,18 +1741,20 @@ fn updateLazySymbol(
break :blk try self.strtab.insert(gpa, name);
};
- const src = Type.fromInterned(sym.ty).srcLocOrNull(zcu) orelse Zcu.LazySrcLoc.unneeded;
- try codegen.generateLazySymbol(
+ codegen.generateLazySymbol(
&elf_file.base,
pt,
- src,
+ Type.fromInterned(sym.ty).srcLocOrNull(zcu) orelse .unneeded,
sym,
&required_alignment,
- &code_buffer,
+ &aw.writer,
.none,
.{ .atom_index = symbol_index },
- );
- const code = code_buffer.items;
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ const code = aw.written();
const output_section_index = switch (sym.kind) {
.code => if (self.text_index) |sym_index|
@@ -1807,21 +1816,24 @@ fn lowerConst(
) !codegen.SymbolResult {
const gpa = pt.zcu.gpa;
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(gpa);
+ var aw: std.Io.Writer.Allocating = .init(gpa);
+ defer aw.deinit();
const name_off = try self.addString(gpa, name);
const sym_index = try self.newSymbolWithAtom(gpa, name_off);
- try codegen.generateSymbol(
+ codegen.generateSymbol(
&elf_file.base,
pt,
src_loc,
val,
- &code_buffer,
+ &aw.writer,
.{ .atom_index = sym_index },
- );
- const code = code_buffer.items;
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ const code = aw.written();
const local_sym = self.symbol(sym_index);
const local_esym = &self.symtab.items(.elf_sym)[local_sym.esym_index];
src/link/MachO/ZigObject.zig
@@ -784,22 +784,26 @@ pub fn updateFunc(
const sym_index = try self.getOrCreateMetadataForNav(macho_file, func.owner_nav);
self.symbols.items[sym_index].getAtom(macho_file).?.freeRelocs(macho_file);
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(gpa);
+ var aw: std.Io.Writer.Allocating = .init(gpa);
+ defer aw.deinit();
var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav(pt, func.owner_nav, sym_index) else null;
defer if (debug_wip_nav) |*wip_nav| wip_nav.deinit();
- try codegen.emitFunction(
+ codegen.emitFunction(
&macho_file.base,
pt,
zcu.navSrcLoc(func.owner_nav),
func_index,
+ sym_index,
mir,
- &code_buffer,
+ &aw.writer,
if (debug_wip_nav) |*wip_nav| .{ .dwarf = wip_nav } else .none,
- );
- const code = code_buffer.items;
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ const code = aw.written();
const sect_index = try self.getNavOutputSection(macho_file, zcu, func.owner_nav, code);
const old_rva, const old_alignment = blk: {
@@ -895,21 +899,24 @@ pub fn updateNav(
const sym_index = try self.getOrCreateMetadataForNav(macho_file, nav_index);
self.symbols.items[sym_index].getAtom(macho_file).?.freeRelocs(macho_file);
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(zcu.gpa);
+ var aw: std.Io.Writer.Allocating = .init(zcu.gpa);
+ defer aw.deinit();
var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav(pt, nav_index, sym_index) else null;
defer if (debug_wip_nav) |*wip_nav| wip_nav.deinit();
- try codegen.generateSymbol(
+ codegen.generateSymbol(
&macho_file.base,
pt,
zcu.navSrcLoc(nav_index),
Value.fromInterned(nav_init),
- &code_buffer,
+ &aw.writer,
.{ .atom_index = sym_index },
- );
- const code = code_buffer.items;
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ const code = aw.written();
const sect_index = try self.getNavOutputSection(macho_file, zcu, nav_index, code);
if (isThreadlocal(macho_file, nav_index))
@@ -1198,21 +1205,24 @@ fn lowerConst(
) !codegen.SymbolResult {
const gpa = macho_file.base.comp.gpa;
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(gpa);
+ var aw: std.Io.Writer.Allocating = .init(gpa);
+ defer aw.deinit();
const name_str = try self.addString(gpa, name);
const sym_index = try self.newSymbolWithAtom(gpa, name_str, macho_file);
- try codegen.generateSymbol(
+ codegen.generateSymbol(
&macho_file.base,
pt,
src_loc,
val,
- &code_buffer,
+ &aw.writer,
.{ .atom_index = sym_index },
- );
- const code = code_buffer.items;
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ const code = aw.written();
const sym = &self.symbols.items[sym_index];
sym.out_n_sect = output_section_index;
@@ -1349,8 +1359,8 @@ fn updateLazySymbol(
const gpa = zcu.gpa;
var required_alignment: Atom.Alignment = .none;
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(gpa);
+ var aw: std.Io.Writer.Allocating = .init(gpa);
+ defer aw.deinit();
const name_str = blk: {
const name = try std.fmt.allocPrint(gpa, "__lazy_{s}_{f}", .{
@@ -1368,11 +1378,11 @@ fn updateLazySymbol(
src,
lazy_sym,
&required_alignment,
- &code_buffer,
+ &aw.writer,
.none,
.{ .atom_index = symbol_index },
);
- const code = code_buffer.items;
+ const code = aw.written();
const output_section_index = switch (lazy_sym.kind) {
.code => macho_file.zig_text_sect_index.?,
src/link/Coff.zig
@@ -953,7 +953,7 @@ fn writeOffsetTableEntry(coff: *Coff, index: usize) !void {
}
fn markRelocsDirtyByTarget(coff: *Coff, target: SymbolWithLoc) void {
- if (!coff.base.comp.incremental) return;
+ if (!coff.base.comp.config.incremental) return;
// TODO: reverse-lookup might come in handy here
for (coff.relocs.values()) |*relocs| {
for (relocs.items) |*reloc| {
@@ -964,7 +964,7 @@ fn markRelocsDirtyByTarget(coff: *Coff, target: SymbolWithLoc) void {
}
fn markRelocsDirtyByAddress(coff: *Coff, addr: u32) void {
- if (!coff.base.comp.incremental) return;
+ if (!coff.base.comp.config.incremental) return;
const got_moved = blk: {
const sect_id = coff.got_section_index orelse break :blk false;
break :blk coff.sections.items(.header)[sect_id].virtual_address >= addr;
@@ -1111,20 +1111,24 @@ pub fn updateFunc(
coff.navs.getPtr(func.owner_nav).?.section = coff.text_section_index.?;
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(gpa);
+ var aw: std.Io.Writer.Allocating = .init(gpa);
+ defer aw.deinit();
- try codegen.emitFunction(
+ codegen.emitFunction(
&coff.base,
pt,
zcu.navSrcLoc(nav_index),
func_index,
+ coff.getAtom(atom_index).getSymbolIndex().?,
mir,
- &code_buffer,
+ &aw.writer,
.none,
- );
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
- try coff.updateNavCode(pt, nav_index, code_buffer.items, .FUNCTION);
+ try coff.updateNavCode(pt, nav_index, aw.written(), .FUNCTION);
// Exports will be updated by `Zcu.processExports` after the update.
}
@@ -1145,18 +1149,18 @@ fn lowerConst(
) !LowerConstResult {
const gpa = coff.base.comp.gpa;
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(gpa);
+ var aw: std.Io.Writer.Allocating = .init(gpa);
+ defer aw.deinit();
const atom_index = try coff.createAtom();
const sym = coff.getAtom(atom_index).getSymbolPtr(coff);
try coff.setSymbolName(sym, name);
sym.section_number = @as(coff_util.SectionNumber, @enumFromInt(sect_id + 1));
- try codegen.generateSymbol(&coff.base, pt, src_loc, val, &code_buffer, .{
+ try codegen.generateSymbol(&coff.base, pt, src_loc, val, &aw.writer, .{
.atom_index = coff.getAtom(atom_index).getSymbolIndex().?,
});
- const code = code_buffer.items;
+ const code = aw.written();
const atom = coff.getAtomPtr(atom_index);
atom.size = @intCast(code.len);
@@ -1170,7 +1174,7 @@ fn lowerConst(
log.debug("allocated atom for {s} at 0x{x}", .{ name, atom.getSymbol(coff).value });
log.debug(" (required alignment 0x{x})", .{required_alignment});
- try coff.writeAtom(atom_index, code, coff.base.comp.incremental);
+ try coff.writeAtom(atom_index, code, coff.base.comp.config.incremental);
return .{ .ok = atom_index };
}
@@ -1214,19 +1218,22 @@ pub fn updateNav(
coff.navs.getPtr(nav_index).?.section = coff.getNavOutputSection(nav_index);
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(gpa);
+ var aw: std.Io.Writer.Allocating = .init(gpa);
+ defer aw.deinit();
- try codegen.generateSymbol(
+ codegen.generateSymbol(
&coff.base,
pt,
zcu.navSrcLoc(nav_index),
nav_init,
- &code_buffer,
+ &aw.writer,
.{ .atom_index = atom.getSymbolIndex().? },
- );
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
- try coff.updateNavCode(pt, nav_index, code_buffer.items, .NULL);
+ try coff.updateNavCode(pt, nav_index, aw.written(), .NULL);
}
// Exports will be updated by `Zcu.processExports` after the update.
@@ -1244,8 +1251,8 @@ fn updateLazySymbolAtom(
const gpa = comp.gpa;
var required_alignment: InternPool.Alignment = .none;
- var code_buffer: std.ArrayListUnmanaged(u8) = .empty;
- defer code_buffer.deinit(gpa);
+ var aw: std.Io.Writer.Allocating = .init(gpa);
+ defer aw.deinit();
const name = try allocPrint(gpa, "__lazy_{s}_{f}", .{
@tagName(sym.kind),
@@ -1262,11 +1269,11 @@ fn updateLazySymbolAtom(
src,
sym,
&required_alignment,
- &code_buffer,
+ &aw.writer,
.none,
.{ .atom_index = local_sym_index },
);
- const code = code_buffer.items;
+ const code = aw.written();
const atom = coff.getAtomPtr(atom_index);
const symbol = atom.getSymbolPtr(coff);
@@ -1285,7 +1292,7 @@ fn updateLazySymbolAtom(
symbol.value = vaddr;
try coff.addGotEntry(.{ .sym_index = local_sym_index });
- try coff.writeAtom(atom_index, code, coff.base.comp.incremental);
+ try coff.writeAtom(atom_index, code, coff.base.comp.config.incremental);
}
pub fn getOrCreateAtomForLazySymbol(
@@ -1437,7 +1444,7 @@ fn updateNavCode(
};
}
- coff.writeAtom(atom_index, code, coff.base.comp.incremental) catch |err| switch (err) {
+ coff.writeAtom(atom_index, code, coff.base.comp.config.incremental) catch |err| switch (err) {
error.OutOfMemory => return error.OutOfMemory,
else => |e| return coff.base.cgFail(nav_index, "failed to write atom: {s}", .{@errorName(e)}),
};
@@ -1539,14 +1546,12 @@ pub fn updateExports(
sym.section_number = @as(coff_util.SectionNumber, @enumFromInt(metadata.section + 1));
sym.type = atom.getSymbol(coff).type;
- switch (exp.opts.linkage) {
- .strong => {
- sym.storage_class = .EXTERNAL;
- },
- .internal => @panic("TODO Internal"),
+ sym.storage_class = switch (exp.opts.linkage) {
+ .internal => .EXTERNAL,
+ .strong => .EXTERNAL,
.weak => @panic("TODO WeakExternal"),
else => unreachable,
- }
+ };
try coff.resolveGlobalSymbol(sym_loc);
}
src/link/Dwarf.zig
@@ -2126,19 +2126,22 @@ pub const WipNav = struct {
const size = if (ty.hasRuntimeBits(wip_nav.pt.zcu)) ty.abiSize(wip_nav.pt.zcu) else 0;
try diw.writeUleb128(size);
if (size == 0) return;
- var bytes = wip_nav.debug_info.toArrayList();
- defer wip_nav.debug_info = .fromArrayList(wip_nav.dwarf.gpa, &bytes);
- const old_len = bytes.items.len;
+ const old_end = wip_nav.debug_info.writer.end;
try codegen.generateSymbol(
wip_nav.dwarf.bin_file,
wip_nav.pt,
src_loc,
val,
- &bytes,
+ &wip_nav.debug_info.writer,
.{ .debug_output = .{ .dwarf = wip_nav } },
);
- if (old_len + size != bytes.items.len) {
- std.debug.print("{f} [{}]: {} != {}\n", .{ ty.fmt(wip_nav.pt), ty.toIntern(), size, bytes.items.len - old_len });
+ if (old_end + size != wip_nav.debug_info.writer.end) {
+ std.debug.print("{f} [{}]: {} != {}\n", .{
+ ty.fmt(wip_nav.pt),
+ ty.toIntern(),
+ size,
+ wip_nav.debug_info.writer.end - old_end,
+ });
unreachable;
}
}
@@ -6429,7 +6432,7 @@ fn sleb128Bytes(value: anytype) u32 {
/// overrides `-fno-incremental` for testing incremental debug info until `-fincremental` is functional
const force_incremental = false;
inline fn incremental(dwarf: Dwarf) bool {
- return force_incremental or dwarf.bin_file.comp.incremental;
+ return force_incremental or dwarf.bin_file.comp.config.incremental;
}
const Allocator = std.mem.Allocator;
src/link/Elf2.zig
@@ -0,0 +1,2036 @@
+base: link.File,
+mf: MappedFile,
+nodes: std.MultiArrayList(Node),
+symtab: std.ArrayList(Symbol),
+shstrtab: StringTable,
+strtab: StringTable,
+globals: std.AutoArrayHashMapUnmanaged(u32, Symbol.Index),
+navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, Symbol.Index),
+uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Symbol.Index),
+lazy: std.EnumArray(link.File.LazySymbol.Kind, struct {
+ map: std.AutoArrayHashMapUnmanaged(InternPool.Index, Symbol.Index),
+ pending_index: u32,
+}),
+pending_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, struct {
+ alignment: InternPool.Alignment,
+ src_loc: Zcu.LazySrcLoc,
+}),
+relocs: std.ArrayList(Reloc),
+/// This is hiding actual bugs with global symbols! Reconsider once they are implemented correctly.
+entry_hack: Symbol.Index,
+
+pub const Node = union(enum) {
+ file,
+ ehdr,
+ shdr,
+ segment: u32,
+ section: Symbol.Index,
+ nav: InternPool.Nav.Index,
+ uav: InternPool.Index,
+ lazy_code: InternPool.Index,
+ lazy_const_data: InternPool.Index,
+
+ pub const Tag = @typeInfo(Node).@"union".tag_type.?;
+
+ const known_count = @typeInfo(@TypeOf(known)).@"struct".fields.len;
+ const known = known: {
+ const Known = enum {
+ file,
+ seg_rodata,
+ ehdr,
+ phdr,
+ shdr,
+ seg_text,
+ seg_data,
+ };
+ var mut_known: std.enums.EnumFieldStruct(
+ Known,
+ MappedFile.Node.Index,
+ null,
+ ) = undefined;
+ for (@typeInfo(Known).@"enum".fields) |field|
+ @field(mut_known, field.name) = @enumFromInt(field.value);
+ break :known mut_known;
+ };
+
+ comptime {
+ if (!std.debug.runtime_safety) std.debug.assert(@sizeOf(Node) == 8);
+ }
+};
+
+pub const StringTable = struct {
+ map: std.HashMapUnmanaged(u32, void, StringTable.Context, std.hash_map.default_max_load_percentage),
+ size: u32,
+
+ const Context = struct {
+ slice: []const u8,
+
+ pub fn eql(_: Context, lhs_key: u32, rhs_key: u32) bool {
+ return lhs_key == rhs_key;
+ }
+
+ pub fn hash(ctx: Context, key: u32) u64 {
+ return std.hash_map.hashString(std.mem.sliceTo(ctx.slice[key..], 0));
+ }
+ };
+
+ const Adapter = struct {
+ slice: []const u8,
+
+ pub fn eql(adapter: Adapter, lhs_key: []const u8, rhs_key: u32) bool {
+ return std.mem.startsWith(u8, adapter.slice[rhs_key..], lhs_key) and
+ adapter.slice[rhs_key + lhs_key.len] == 0;
+ }
+
+ pub fn hash(_: Adapter, key: []const u8) u64 {
+ assert(std.mem.indexOfScalar(u8, key, 0) == null);
+ return std.hash_map.hashString(key);
+ }
+ };
+
+ pub fn get(
+ st: *StringTable,
+ gpa: std.mem.Allocator,
+ mf: *MappedFile,
+ ni: MappedFile.Node.Index,
+ key: []const u8,
+ ) !u32 {
+ const slice_const = ni.sliceConst(mf);
+ const gop = try st.map.getOrPutContextAdapted(
+ gpa,
+ key,
+ StringTable.Adapter{ .slice = slice_const },
+ .{ .slice = slice_const },
+ );
+ if (gop.found_existing) return gop.key_ptr.*;
+ const old_size = st.size;
+ const new_size: u32 = @intCast(old_size + key.len + 1);
+ st.size = new_size;
+ try ni.resize(mf, gpa, new_size);
+ const slice = ni.slice(mf)[old_size..];
+ @memcpy(slice[0..key.len], key);
+ slice[key.len] = 0;
+ gop.key_ptr.* = old_size;
+ return old_size;
+ }
+};
+
+pub const Symbol = struct {
+ ni: MappedFile.Node.Index,
+ /// Relocations contained within this symbol
+ loc_relocs: Reloc.Index,
+ /// Relocations targeting this symbol
+ target_relocs: Reloc.Index,
+ unused: u32 = 0,
+
+ pub const Index = enum(u32) {
+ null,
+ symtab,
+ shstrtab,
+ strtab,
+ rodata,
+ text,
+ data,
+ tdata,
+ _,
+
+ pub fn get(si: Symbol.Index, elf: *Elf) *Symbol {
+ return &elf.symtab.items[@intFromEnum(si)];
+ }
+
+ pub fn node(si: Symbol.Index, elf: *Elf) MappedFile.Node.Index {
+ const ni = si.get(elf).ni;
+ assert(ni != .none);
+ return ni;
+ }
+
+ pub const InitOptions = struct {
+ name: []const u8 = "",
+ size: std.elf.Word = 0,
+ type: std.elf.STT,
+ bind: std.elf.STB = .LOCAL,
+ visibility: std.elf.STV = .DEFAULT,
+ shndx: std.elf.Section = std.elf.SHN_UNDEF,
+ };
+ pub fn init(si: Symbol.Index, elf: *Elf, opts: InitOptions) !void {
+ const name_entry = try elf.string(.strtab, opts.name);
+ try Symbol.Index.symtab.node(elf).resize(
+ &elf.mf,
+ elf.base.comp.gpa,
+ @as(usize, switch (elf.identClass()) {
+ .NONE, _ => unreachable,
+ .@"32" => @sizeOf(std.elf.Elf32.Sym),
+ .@"64" => @sizeOf(std.elf.Elf64.Sym),
+ }) * elf.symtab.items.len,
+ );
+ switch (elf.symPtr(si)) {
+ inline else => |sym| sym.* = .{
+ .name = name_entry,
+ .value = 0,
+ .size = opts.size,
+ .info = .{
+ .type = opts.type,
+ .bind = opts.bind,
+ },
+ .other = .{
+ .visibility = opts.visibility,
+ },
+ .shndx = opts.shndx,
+ },
+ }
+ }
+
+ pub fn applyLocationRelocs(si: Symbol.Index, elf: *Elf) void {
+ for (elf.relocs.items[@intFromEnum(si.get(elf).loc_relocs)..]) |*reloc| {
+ if (reloc.loc != si) break;
+ reloc.apply(elf);
+ }
+ }
+
+ pub fn applyTargetRelocs(si: Symbol.Index, elf: *Elf) void {
+ var ri = si.get(elf).target_relocs;
+ while (ri != .none) {
+ const reloc = ri.get(elf);
+ assert(reloc.target == si);
+ reloc.apply(elf);
+ ri = reloc.next;
+ }
+ }
+
+ pub fn deleteLocationRelocs(si: Symbol.Index, elf: *Elf) void {
+ const sym = si.get(elf);
+ for (elf.relocs.items[@intFromEnum(sym.loc_relocs)..]) |*reloc| {
+ if (reloc.loc != si) break;
+ reloc.delete(elf);
+ }
+ sym.loc_relocs = .none;
+ }
+ };
+
+ comptime {
+ if (!std.debug.runtime_safety) std.debug.assert(@sizeOf(Symbol) == 16);
+ }
+};
+
+pub const Reloc = extern struct {
+ type: Reloc.Type,
+ prev: Reloc.Index,
+ next: Reloc.Index,
+ loc: Symbol.Index,
+ target: Symbol.Index,
+ unused: u32,
+ offset: u64,
+ addend: i64,
+
+ pub const Type = extern union {
+ x86_64: std.elf.R_X86_64,
+ aarch64: std.elf.R_AARCH64,
+ riscv: std.elf.R_RISCV,
+ ppc64: std.elf.R_PPC64,
+ };
+
+ pub const Index = enum(u32) {
+ none = std.math.maxInt(u32),
+ _,
+
+ pub fn get(si: Reloc.Index, elf: *Elf) *Reloc {
+ return &elf.relocs.items[@intFromEnum(si)];
+ }
+ };
+
+ pub fn apply(reloc: *const Reloc, elf: *Elf) void {
+ const target_endian = elf.endian();
+ switch (reloc.loc.get(elf).ni) {
+ .none => return,
+ else => |ni| if (ni.hasMoved(&elf.mf)) return,
+ }
+ switch (reloc.target.get(elf).ni) {
+ .none => return,
+ else => |ni| if (ni.hasMoved(&elf.mf)) return,
+ }
+ switch (elf.shdrSlice()) {
+ inline else => |shdr, class| {
+ const sym = @field(elf.symSlice(), @tagName(class));
+ const loc_sym = &sym[@intFromEnum(reloc.loc)];
+ const loc_shndx =
+ std.mem.toNative(@TypeOf(loc_sym.shndx), loc_sym.shndx, target_endian);
+ assert(loc_shndx != std.elf.SHN_UNDEF);
+ const loc_sh = &shdr[loc_shndx];
+ const loc_value = std.mem.toNative(
+ @TypeOf(loc_sym.value),
+ loc_sym.value,
+ target_endian,
+ ) + reloc.offset;
+ const loc_sh_addr =
+ std.mem.toNative(@TypeOf(loc_sh.addr), loc_sh.addr, target_endian);
+ const loc_sh_offset =
+ std.mem.toNative(@TypeOf(loc_sh.offset), loc_sh.offset, target_endian);
+ const loc_file_offset: usize = @intCast(loc_value - loc_sh_addr + loc_sh_offset);
+ const target_sym = &sym[@intFromEnum(reloc.target)];
+ const target_value = std.mem.toNative(
+ @TypeOf(target_sym.value),
+ target_sym.value,
+ target_endian,
+ ) +% @as(u64, @bitCast(reloc.addend));
+ switch (elf.ehdrField(.machine)) {
+ else => |machine| @panic(@tagName(machine)),
+ .X86_64 => switch (reloc.type.x86_64) {
+ else => |kind| @panic(@tagName(kind)),
+ .@"64" => std.mem.writeInt(
+ u64,
+ elf.mf.contents[loc_file_offset..][0..8],
+ target_value,
+ target_endian,
+ ),
+ .PC32 => std.mem.writeInt(
+ i32,
+ elf.mf.contents[loc_file_offset..][0..4],
+ @intCast(@as(i64, @bitCast(target_value -% loc_value))),
+ target_endian,
+ ),
+ .@"32" => std.mem.writeInt(
+ u32,
+ elf.mf.contents[loc_file_offset..][0..4],
+ @intCast(target_value),
+ target_endian,
+ ),
+ .TPOFF32 => {
+ const phdr = @field(elf.phdrSlice(), @tagName(class));
+ const ph = &phdr[4];
+ assert(std.mem.toNative(
+ @TypeOf(ph.type),
+ ph.type,
+ target_endian,
+ ) == std.elf.PT_TLS);
+ std.mem.writeInt(
+ i32,
+ elf.mf.contents[loc_file_offset..][0..4],
+ @intCast(@as(i64, @bitCast(target_value -% std.mem.toNative(
+ @TypeOf(ph.memsz),
+ ph.memsz,
+ target_endian,
+ )))),
+ target_endian,
+ );
+ },
+ },
+ }
+ },
+ }
+ }
+
+ pub fn delete(reloc: *Reloc, elf: *Elf) void {
+ switch (reloc.prev) {
+ .none => {
+ const target = reloc.target.get(elf);
+ assert(target.target_relocs.get(elf) == reloc);
+ target.target_relocs = reloc.next;
+ },
+ else => |prev| prev.get(elf).next = reloc.next,
+ }
+ switch (reloc.next) {
+ .none => {},
+ else => |next| next.get(elf).prev = reloc.prev,
+ }
+ reloc.* = undefined;
+ }
+
+ comptime {
+ if (!std.debug.runtime_safety) std.debug.assert(@sizeOf(Reloc) == 40);
+ }
+};
+
+pub fn open(
+ arena: std.mem.Allocator,
+ comp: *Compilation,
+ path: std.Build.Cache.Path,
+ options: link.File.OpenOptions,
+) !*Elf {
+ return create(arena, comp, path, options);
+}
+pub fn createEmpty(
+ arena: std.mem.Allocator,
+ comp: *Compilation,
+ path: std.Build.Cache.Path,
+ options: link.File.OpenOptions,
+) !*Elf {
+ return create(arena, comp, path, options);
+}
+fn create(
+ arena: std.mem.Allocator,
+ comp: *Compilation,
+ path: std.Build.Cache.Path,
+ options: link.File.OpenOptions,
+) !*Elf {
+ _ = options;
+ const target = &comp.root_mod.resolved_target.result;
+ assert(target.ofmt == .elf);
+ const class: std.elf.CLASS = switch (target.ptrBitWidth()) {
+ 0...32 => .@"32",
+ 33...64 => .@"64",
+ else => return error.UnsupportedELFArchitecture,
+ };
+ const data: std.elf.DATA = switch (target.cpu.arch.endian()) {
+ .little => .@"2LSB",
+ .big => .@"2MSB",
+ };
+ const osabi: std.elf.OSABI = switch (target.os.tag) {
+ else => .NONE,
+ .freestanding, .other => .STANDALONE,
+ .netbsd => .NETBSD,
+ .solaris => .SOLARIS,
+ .aix => .AIX,
+ .freebsd => .FREEBSD,
+ .cuda => .CUDA,
+ .amdhsa => .AMDGPU_HSA,
+ .amdpal => .AMDGPU_PAL,
+ .mesa3d => .AMDGPU_MESA3D,
+ };
+ const @"type": std.elf.ET = switch (comp.config.output_mode) {
+ .Exe => if (comp.config.pie or target.os.tag == .haiku) .DYN else .EXEC,
+ .Lib => switch (comp.config.link_mode) {
+ .static => .REL,
+ .dynamic => .DYN,
+ },
+ .Obj => .REL,
+ };
+ const machine: std.elf.EM = switch (target.cpu.arch) {
+ .spirv32, .spirv64, .wasm32, .wasm64 => .NONE,
+ .sparc => .SPARC,
+ .x86 => .@"386",
+ .m68k => .@"68K",
+ .mips, .mipsel, .mips64, .mips64el => .MIPS,
+ .powerpc, .powerpcle => .PPC,
+ .powerpc64, .powerpc64le => .PPC64,
+ .s390x => .S390,
+ .arm, .armeb, .thumb, .thumbeb => .ARM,
+ .hexagon => .SH,
+ .sparc64 => .SPARCV9,
+ .arc => .ARC,
+ .x86_64 => .X86_64,
+ .or1k => .OR1K,
+ .xtensa => .XTENSA,
+ .msp430 => .MSP430,
+ .avr => .AVR,
+ .nvptx, .nvptx64 => .CUDA,
+ .kalimba => .CSR_KALIMBA,
+ .aarch64, .aarch64_be => .AARCH64,
+ .xcore => .XCORE,
+ .amdgcn => .AMDGPU,
+ .riscv32, .riscv32be, .riscv64, .riscv64be => .RISCV,
+ .lanai => .LANAI,
+ .bpfel, .bpfeb => .BPF,
+ .ve => .VE,
+ .csky => .CSKY,
+ .loongarch32, .loongarch64 => .LOONGARCH,
+ .propeller => if (target.cpu.has(.propeller, .p2)) .PROPELLER2 else .PROPELLER,
+ };
+ const maybe_interp = switch (comp.config.output_mode) {
+ .Exe, .Lib => switch (comp.config.link_mode) {
+ .static => null,
+ .dynamic => target.dynamic_linker.get(),
+ },
+ .Obj => null,
+ };
+
+ const elf = try arena.create(Elf);
+ const file = try path.root_dir.handle.createFile(path.sub_path, .{
+ .read = true,
+ .mode = link.File.determineMode(comp.config.output_mode, comp.config.link_mode),
+ });
+ errdefer file.close();
+ elf.* = .{
+ .base = .{
+ .tag = .elf2,
+
+ .comp = comp,
+ .emit = path,
+
+ .file = file,
+ .gc_sections = false,
+ .print_gc_sections = false,
+ .build_id = .none,
+ .allow_shlib_undefined = false,
+ .stack_size = 0,
+ },
+ .mf = try .init(file, comp.gpa),
+ .nodes = .empty,
+ .symtab = .empty,
+ .shstrtab = .{
+ .map = .empty,
+ .size = 1,
+ },
+ .strtab = .{
+ .map = .empty,
+ .size = 1,
+ },
+ .globals = .empty,
+ .navs = .empty,
+ .uavs = .empty,
+ .lazy = .initFill(.{
+ .map = .empty,
+ .pending_index = 0,
+ }),
+ .pending_uavs = .empty,
+ .relocs = .empty,
+ .entry_hack = .null,
+ };
+ errdefer elf.deinit();
+
+ switch (class) {
+ .NONE, _ => unreachable,
+ inline .@"32", .@"64" => |ct_class| try elf.initHeaders(
+ ct_class,
+ data,
+ osabi,
+ @"type",
+ machine,
+ maybe_interp,
+ ),
+ }
+
+ return elf;
+}
+
+pub fn deinit(elf: *Elf) void {
+ const gpa = elf.base.comp.gpa;
+ elf.mf.deinit(gpa);
+ elf.nodes.deinit(gpa);
+ elf.symtab.deinit(gpa);
+ elf.shstrtab.map.deinit(gpa);
+ elf.strtab.map.deinit(gpa);
+ elf.globals.deinit(gpa);
+ elf.navs.deinit(gpa);
+ elf.uavs.deinit(gpa);
+ for (&elf.lazy.values) |*lazy| lazy.map.deinit(gpa);
+ elf.pending_uavs.deinit(gpa);
+ elf.relocs.deinit(gpa);
+ elf.* = undefined;
+}
+
+fn initHeaders(
+ elf: *Elf,
+ comptime class: std.elf.CLASS,
+ data: std.elf.DATA,
+ osabi: std.elf.OSABI,
+ @"type": std.elf.ET,
+ machine: std.elf.EM,
+ maybe_interp: ?[]const u8,
+) !void {
+ const comp = elf.base.comp;
+ const gpa = comp.gpa;
+ const ElfN = switch (class) {
+ .NONE, _ => comptime unreachable,
+ .@"32" => std.elf.Elf32,
+ .@"64" => std.elf.Elf64,
+ };
+ const addr_align: std.mem.Alignment = comptime .fromByteUnits(@sizeOf(ElfN.Addr));
+ const target_endian: std.builtin.Endian = switch (data) {
+ .NONE, _ => unreachable,
+ .@"2LSB" => .little,
+ .@"2MSB" => .big,
+ };
+
+ var phnum: u32 = 0;
+ const phdr_phndx = phnum;
+ phnum += 1;
+ const interp_phndx = if (maybe_interp) |_| phndx: {
+ defer phnum += 1;
+ break :phndx phnum;
+ } else undefined;
+ const rodata_phndx = phnum;
+ phnum += 1;
+ const text_phndx = phnum;
+ phnum += 1;
+ const data_phndx = phnum;
+ phnum += 1;
+ const tls_phndx = if (comp.config.any_non_single_threaded) phndx: {
+ defer phnum += 1;
+ break :phndx phnum;
+ } else undefined;
+
+ try elf.nodes.ensureTotalCapacity(gpa, Node.known_count);
+ elf.nodes.appendAssumeCapacity(.file);
+
+ const seg_rodata_ni = Node.known.seg_rodata;
+ assert(seg_rodata_ni == try elf.mf.addOnlyChildNode(gpa, .root, .{
+ .alignment = elf.mf.flags.block_size,
+ .fixed = true,
+ .moved = true,
+ }));
+ elf.nodes.appendAssumeCapacity(.{ .segment = rodata_phndx });
+
+ const ehdr_ni = Node.known.ehdr;
+ assert(ehdr_ni == try elf.mf.addOnlyChildNode(gpa, seg_rodata_ni, .{
+ .size = @sizeOf(ElfN.Ehdr),
+ .alignment = addr_align,
+ .fixed = true,
+ }));
+ elf.nodes.appendAssumeCapacity(.ehdr);
+
+ const ehdr: *ElfN.Ehdr = @ptrCast(@alignCast(ehdr_ni.slice(&elf.mf)));
+ const EI = std.elf.EI;
+ @memcpy(ehdr.ident[0..std.elf.MAGIC.len], std.elf.MAGIC);
+ ehdr.ident[EI.CLASS] = @intFromEnum(class);
+ ehdr.ident[EI.DATA] = @intFromEnum(data);
+ ehdr.ident[EI.VERSION] = 1;
+ ehdr.ident[EI.OSABI] = @intFromEnum(osabi);
+ ehdr.ident[EI.ABIVERSION] = 0;
+ @memset(ehdr.ident[EI.PAD..], 0);
+ ehdr.type = @"type";
+ ehdr.machine = machine;
+ ehdr.version = 1;
+ ehdr.entry = 0;
+ ehdr.phoff = 0;
+ ehdr.shoff = 0;
+ ehdr.flags = 0;
+ ehdr.ehsize = @sizeOf(ElfN.Ehdr);
+ ehdr.phentsize = @sizeOf(ElfN.Phdr);
+ ehdr.phnum = @min(phnum, std.elf.PN_XNUM);
+ ehdr.shentsize = @sizeOf(ElfN.Shdr);
+ ehdr.shnum = 1;
+ ehdr.shstrndx = 0;
+ if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Ehdr, ehdr);
+
+ const phdr_ni = Node.known.phdr;
+ assert(phdr_ni == try elf.mf.addLastChildNode(gpa, seg_rodata_ni, .{
+ .size = @sizeOf(ElfN.Phdr) * phnum,
+ .alignment = addr_align,
+ .moved = true,
+ .resized = true,
+ }));
+ elf.nodes.appendAssumeCapacity(.{ .segment = phdr_phndx });
+
+ const shdr_ni = Node.known.shdr;
+ assert(shdr_ni == try elf.mf.addLastChildNode(gpa, seg_rodata_ni, .{
+ .size = @sizeOf(ElfN.Shdr),
+ .alignment = addr_align,
+ }));
+ elf.nodes.appendAssumeCapacity(.shdr);
+
+ const seg_text_ni = Node.known.seg_text;
+ assert(seg_text_ni == try elf.mf.addLastChildNode(gpa, .root, .{
+ .alignment = elf.mf.flags.block_size,
+ .moved = true,
+ }));
+ elf.nodes.appendAssumeCapacity(.{ .segment = text_phndx });
+
+ const seg_data_ni = Node.known.seg_data;
+ assert(seg_data_ni == try elf.mf.addLastChildNode(gpa, .root, .{
+ .alignment = elf.mf.flags.block_size,
+ .moved = true,
+ }));
+ elf.nodes.appendAssumeCapacity(.{ .segment = data_phndx });
+
+ assert(elf.nodes.len == Node.known_count);
+
+ {
+ const phdr: []ElfN.Phdr = @ptrCast(@alignCast(phdr_ni.slice(&elf.mf)));
+ const ph_phdr = &phdr[phdr_phndx];
+ ph_phdr.* = .{
+ .type = std.elf.PT_PHDR,
+ .offset = 0,
+ .vaddr = 0,
+ .paddr = 0,
+ .filesz = 0,
+ .memsz = 0,
+ .flags = .{ .R = true },
+ .@"align" = @intCast(phdr_ni.alignment(&elf.mf).toByteUnits()),
+ };
+ if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_phdr);
+
+ if (maybe_interp) |_| {
+ const ph_interp = &phdr[interp_phndx];
+ ph_interp.* = .{
+ .type = std.elf.PT_INTERP,
+ .offset = 0,
+ .vaddr = 0,
+ .paddr = 0,
+ .filesz = 0,
+ .memsz = 0,
+ .flags = .{ .R = true },
+ .@"align" = 1,
+ };
+ if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_interp);
+ }
+
+ const ph_rodata = &phdr[rodata_phndx];
+ ph_rodata.* = .{
+ .type = std.elf.PT_NULL,
+ .offset = 0,
+ .vaddr = 0,
+ .paddr = 0,
+ .filesz = 0,
+ .memsz = 0,
+ .flags = .{ .R = true },
+ .@"align" = @intCast(seg_rodata_ni.alignment(&elf.mf).toByteUnits()),
+ };
+ if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_rodata);
+
+ const ph_text = &phdr[text_phndx];
+ ph_text.* = .{
+ .type = std.elf.PT_NULL,
+ .offset = 0,
+ .vaddr = 0,
+ .paddr = 0,
+ .filesz = 0,
+ .memsz = 0,
+ .flags = .{ .R = true, .X = true },
+ .@"align" = @intCast(seg_text_ni.alignment(&elf.mf).toByteUnits()),
+ };
+ if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_text);
+
+ const ph_data = &phdr[data_phndx];
+ ph_data.* = .{
+ .type = std.elf.PT_NULL,
+ .offset = 0,
+ .vaddr = 0,
+ .paddr = 0,
+ .filesz = 0,
+ .memsz = 0,
+ .flags = .{ .R = true, .W = true },
+ .@"align" = @intCast(seg_data_ni.alignment(&elf.mf).toByteUnits()),
+ };
+ if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_data);
+
+ if (comp.config.any_non_single_threaded) {
+ const ph_tls = &phdr[tls_phndx];
+ ph_tls.* = .{
+ .type = std.elf.PT_TLS,
+ .offset = 0,
+ .vaddr = 0,
+ .paddr = 0,
+ .filesz = 0,
+ .memsz = 0,
+ .flags = .{ .R = true },
+ .@"align" = @intCast(elf.mf.flags.block_size.toByteUnits()),
+ };
+ if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Phdr, ph_tls);
+ }
+
+ const sh_null: *ElfN.Shdr = @ptrCast(@alignCast(shdr_ni.slice(&elf.mf)));
+ sh_null.* = .{
+ .name = try elf.string(.shstrtab, ""),
+ .type = std.elf.SHT_NULL,
+ .flags = .{ .shf = .{} },
+ .addr = 0,
+ .offset = 0,
+ .size = 0,
+ .link = 0,
+ .info = if (phnum >= std.elf.PN_XNUM) phnum else 0,
+ .addralign = 0,
+ .entsize = 0,
+ };
+ if (target_endian != native_endian) std.mem.byteSwapAllFields(ElfN.Shdr, sh_null);
+ }
+
+ try elf.symtab.ensureTotalCapacity(gpa, 1);
+ elf.symtab.addOneAssumeCapacity().* = .{
+ .ni = .none,
+ .loc_relocs = .none,
+ .target_relocs = .none,
+ .unused = 0,
+ };
+ assert(try elf.addSection(seg_rodata_ni, .{
+ .type = std.elf.SHT_SYMTAB,
+ .addralign = addr_align,
+ .entsize = @sizeOf(ElfN.Sym),
+ }) == .symtab);
+ const symtab: *ElfN.Sym = @ptrCast(@alignCast(Symbol.Index.symtab.node(elf).slice(&elf.mf)));
+ symtab.* = .{
+ .name = try elf.string(.strtab, ""),
+ .value = 0,
+ .size = 0,
+ .info = .{
+ .type = .NOTYPE,
+ .bind = .LOCAL,
+ },
+ .other = .{
+ .visibility = .DEFAULT,
+ },
+ .shndx = std.elf.SHN_UNDEF,
+ };
+ ehdr.shstrndx = ehdr.shnum;
+ assert(try elf.addSection(seg_rodata_ni, .{
+ .type = std.elf.SHT_STRTAB,
+ .addralign = elf.mf.flags.block_size,
+ .entsize = 1,
+ }) == .shstrtab);
+ assert(try elf.addSection(seg_rodata_ni, .{
+ .type = std.elf.SHT_STRTAB,
+ .addralign = elf.mf.flags.block_size,
+ .entsize = 1,
+ }) == .strtab);
+ try elf.renameSection(.symtab, ".symtab");
+ try elf.renameSection(.shstrtab, ".shstrtab");
+ try elf.renameSection(.strtab, ".strtab");
+ try elf.linkSections(.symtab, .strtab);
+ Symbol.Index.shstrtab.node(elf).slice(&elf.mf)[0] = 0;
+ Symbol.Index.strtab.node(elf).slice(&elf.mf)[0] = 0;
+
+ assert(try elf.addSection(seg_rodata_ni, .{
+ .name = ".rodata",
+ .flags = .{ .ALLOC = true },
+ .addralign = elf.mf.flags.block_size,
+ }) == .rodata);
+ assert(try elf.addSection(seg_text_ni, .{
+ .name = ".text",
+ .flags = .{ .ALLOC = true, .EXECINSTR = true },
+ .addralign = elf.mf.flags.block_size,
+ }) == .text);
+ assert(try elf.addSection(seg_data_ni, .{
+ .name = ".data",
+ .flags = .{ .WRITE = true, .ALLOC = true },
+ .addralign = elf.mf.flags.block_size,
+ }) == .data);
+ if (comp.config.any_non_single_threaded) {
+ try elf.nodes.ensureUnusedCapacity(gpa, 1);
+ const seg_tls_ni = try elf.mf.addLastChildNode(gpa, seg_data_ni, .{
+ .alignment = elf.mf.flags.block_size,
+ .moved = true,
+ });
+ elf.nodes.appendAssumeCapacity(.{ .segment = tls_phndx });
+
+ assert(try elf.addSection(seg_tls_ni, .{
+ .name = ".tdata",
+ .flags = .{ .WRITE = true, .ALLOC = true, .TLS = true },
+ .addralign = elf.mf.flags.block_size,
+ }) == .tdata);
+ }
+ if (maybe_interp) |interp| {
+ try elf.nodes.ensureUnusedCapacity(gpa, 1);
+ const seg_interp_ni = try elf.mf.addLastChildNode(gpa, seg_rodata_ni, .{
+ .size = interp.len + 1,
+ .moved = true,
+ .resized = true,
+ });
+ elf.nodes.appendAssumeCapacity(.{ .segment = interp_phndx });
+
+ const sec_interp_si = try elf.addSection(seg_interp_ni, .{
+ .name = ".interp",
+ .size = @intCast(interp.len + 1),
+ .flags = .{ .ALLOC = true },
+ });
+ const sec_interp = sec_interp_si.node(elf).slice(&elf.mf);
+ @memcpy(sec_interp[0..interp.len], interp);
+ sec_interp[interp.len] = 0;
+ }
+}
+
+fn getNode(elf: *Elf, ni: MappedFile.Node.Index) Node {
+ return elf.nodes.get(@intFromEnum(ni));
+}
+
+pub const EhdrPtr = union(std.elf.CLASS) {
+ NONE: noreturn,
+ @"32": *std.elf.Elf32.Ehdr,
+ @"64": *std.elf.Elf64.Ehdr,
+};
+pub fn ehdrPtr(elf: *Elf) EhdrPtr {
+ const slice = Node.known.ehdr.slice(&elf.mf);
+ return switch (elf.identClass()) {
+ .NONE, _ => unreachable,
+ inline .@"32", .@"64" => |class| @unionInit(
+ EhdrPtr,
+ @tagName(class),
+ @ptrCast(@alignCast(slice)),
+ ),
+ };
+}
+pub fn ehdrField(
+ elf: *Elf,
+ comptime field: enum { type, machine },
+) @FieldType(std.elf.Elf32.Ehdr, @tagName(field)) {
+ const Field = @FieldType(std.elf.Elf32.Ehdr, @tagName(field));
+ comptime assert(@FieldType(std.elf.Elf64.Ehdr, @tagName(field)) == Field);
+ return @enumFromInt(std.mem.toNative(
+ @typeInfo(Field).@"enum".tag_type,
+ @intFromEnum(switch (elf.ehdrPtr()) {
+ inline else => |ehdr| @field(ehdr, @tagName(field)),
+ }),
+ elf.endian(),
+ ));
+}
+
+pub fn identClass(elf: *Elf) std.elf.CLASS {
+ return @enumFromInt(elf.mf.contents[std.elf.EI.CLASS]);
+}
+
+pub fn identData(elf: *Elf) std.elf.DATA {
+ return @enumFromInt(elf.mf.contents[std.elf.EI.DATA]);
+}
+fn endianForData(data: std.elf.DATA) std.builtin.Endian {
+ return switch (data) {
+ .NONE, _ => unreachable,
+ .@"2LSB" => .little,
+ .@"2MSB" => .big,
+ };
+}
+pub fn endian(elf: *Elf) std.builtin.Endian {
+ return endianForData(elf.identData());
+}
+
+fn baseAddrForType(@"type": std.elf.ET) u64 {
+ return switch (@"type") {
+ else => 0,
+ .EXEC => 0x1000000,
+ };
+}
+pub fn baseAddr(elf: *Elf) u64 {
+ return baseAddrForType(elf.ehdrField(.type));
+}
+
+pub const PhdrSlice = union(std.elf.CLASS) {
+ NONE: noreturn,
+ @"32": []std.elf.Elf32.Phdr,
+ @"64": []std.elf.Elf64.Phdr,
+};
+pub fn phdrSlice(elf: *Elf) PhdrSlice {
+ const slice = Node.known.phdr.slice(&elf.mf);
+ return switch (elf.identClass()) {
+ .NONE, _ => unreachable,
+ inline .@"32", .@"64" => |class| @unionInit(
+ PhdrSlice,
+ @tagName(class),
+ @ptrCast(@alignCast(slice)),
+ ),
+ };
+}
+
+pub const ShdrSlice = union(std.elf.CLASS) {
+ NONE: noreturn,
+ @"32": []std.elf.Elf32.Shdr,
+ @"64": []std.elf.Elf64.Shdr,
+};
+pub fn shdrSlice(elf: *Elf) ShdrSlice {
+ const slice = Node.known.shdr.slice(&elf.mf);
+ return switch (elf.identClass()) {
+ .NONE, _ => unreachable,
+ inline .@"32", .@"64" => |class| @unionInit(
+ ShdrSlice,
+ @tagName(class),
+ @ptrCast(@alignCast(slice)),
+ ),
+ };
+}
+
+pub const SymSlice = union(std.elf.CLASS) {
+ NONE: noreturn,
+ @"32": []std.elf.Elf32.Sym,
+ @"64": []std.elf.Elf64.Sym,
+};
+pub fn symSlice(elf: *Elf) SymSlice {
+ const slice = Symbol.Index.symtab.node(elf).slice(&elf.mf);
+ return switch (elf.identClass()) {
+ .NONE, _ => unreachable,
+ inline .@"32", .@"64" => |class| @unionInit(
+ SymSlice,
+ @tagName(class),
+ @ptrCast(@alignCast(slice)),
+ ),
+ };
+}
+
+pub const SymPtr = union(std.elf.CLASS) {
+ NONE: noreturn,
+ @"32": *std.elf.Elf32.Sym,
+ @"64": *std.elf.Elf64.Sym,
+};
+pub fn symPtr(elf: *Elf, si: Symbol.Index) SymPtr {
+ return switch (elf.symSlice()) {
+ inline else => |sym, class| @unionInit(SymPtr, @tagName(class), &sym[@intFromEnum(si)]),
+ };
+}
+
+fn addSymbolAssumeCapacity(elf: *Elf) !Symbol.Index {
+ defer elf.symtab.addOneAssumeCapacity().* = .{
+ .ni = .none,
+ .loc_relocs = .none,
+ .target_relocs = .none,
+ .unused = 0,
+ };
+ return @enumFromInt(elf.symtab.items.len);
+}
+
+fn initSymbolAssumeCapacity(elf: *Elf, opts: Symbol.Index.InitOptions) !Symbol.Index {
+ const si = try elf.addSymbolAssumeCapacity();
+ try si.init(elf, opts);
+ return si;
+}
+
+pub fn globalSymbol(
+ elf: *Elf,
+ opts: struct {
+ name: []const u8,
+ type: std.elf.STT,
+ bind: std.elf.STB = .GLOBAL,
+ visibility: std.elf.STV = .DEFAULT,
+ },
+) !Symbol.Index {
+ const gpa = elf.base.comp.gpa;
+ try elf.symtab.ensureUnusedCapacity(gpa, 1);
+ const sym_gop = try elf.globals.getOrPut(gpa, try elf.string(.strtab, opts.name));
+ if (!sym_gop.found_existing) sym_gop.value_ptr.* = try elf.initSymbolAssumeCapacity(.{
+ .name = opts.name,
+ .type = opts.type,
+ .bind = opts.bind,
+ .visibility = opts.visibility,
+ });
+ return sym_gop.value_ptr.*;
+}
+
+fn navType(
+ ip: *const InternPool,
+ nav_status: @FieldType(InternPool.Nav, "status"),
+ any_non_single_threaded: bool,
+) std.elf.STT {
+ return switch (nav_status) {
+ .unresolved => unreachable,
+ .type_resolved => |tr| if (any_non_single_threaded and tr.is_threadlocal)
+ .TLS
+ else if (ip.isFunctionType(tr.type))
+ .FUNC
+ else
+ .OBJECT,
+ .fully_resolved => |fr| switch (ip.indexToKey(fr.val)) {
+ else => .OBJECT,
+ .variable => |variable| if (any_non_single_threaded and variable.is_threadlocal)
+ .TLS
+ else
+ .OBJECT,
+ .@"extern" => |@"extern"| if (any_non_single_threaded and @"extern".is_threadlocal)
+ .TLS
+ else if (ip.isFunctionType(@"extern".ty))
+ .FUNC
+ else
+ .OBJECT,
+ .func => .FUNC,
+ },
+ };
+}
+pub fn navSymbol(elf: *Elf, zcu: *Zcu, nav_index: InternPool.Nav.Index) !Symbol.Index {
+ const gpa = zcu.gpa;
+ const ip = &zcu.intern_pool;
+ const nav = ip.getNav(nav_index);
+ if (nav.getExtern(ip)) |@"extern"| return elf.globalSymbol(.{
+ .name = @"extern".name.toSlice(ip),
+ .type = navType(ip, nav.status, elf.base.comp.config.any_non_single_threaded),
+ .bind = switch (@"extern".linkage) {
+ .internal => .LOCAL,
+ .strong => .GLOBAL,
+ .weak => .WEAK,
+ .link_once => return error.LinkOnceUnsupported,
+ },
+ .visibility = switch (@"extern".visibility) {
+ .default => .DEFAULT,
+ .hidden => .HIDDEN,
+ .protected => .PROTECTED,
+ },
+ });
+ try elf.symtab.ensureUnusedCapacity(gpa, 1);
+ const sym_gop = try elf.navs.getOrPut(gpa, nav_index);
+ if (!sym_gop.found_existing) {
+ sym_gop.value_ptr.* = try elf.initSymbolAssumeCapacity(.{
+ .name = nav.fqn.toSlice(ip),
+ .type = navType(ip, nav.status, elf.base.comp.config.any_non_single_threaded),
+ });
+ }
+ return sym_gop.value_ptr.*;
+}
+
+pub fn uavSymbol(elf: *Elf, uav_val: InternPool.Index) !Symbol.Index {
+ const gpa = elf.base.comp.gpa;
+ try elf.symtab.ensureUnusedCapacity(gpa, 1);
+ const sym_gop = try elf.uavs.getOrPut(gpa, uav_val);
+ if (!sym_gop.found_existing)
+ sym_gop.value_ptr.* = try elf.initSymbolAssumeCapacity(.{ .type = .OBJECT });
+ return sym_gop.value_ptr.*;
+}
+
+pub fn lazySymbol(elf: *Elf, lazy: link.File.LazySymbol) !Symbol.Index {
+ const gpa = elf.base.comp.gpa;
+ try elf.symtab.ensureUnusedCapacity(gpa, 1);
+ const sym_gop = try elf.lazy.getPtr(lazy.kind).map.getOrPut(gpa, lazy.ty);
+ if (!sym_gop.found_existing) {
+ sym_gop.value_ptr.* = try elf.initSymbolAssumeCapacity(.{
+ .type = switch (lazy.kind) {
+ .code => .FUNC,
+ .const_data => .OBJECT,
+ },
+ });
+ elf.base.comp.link_lazy_prog_node.increaseEstimatedTotalItems(1);
+ }
+ return sym_gop.value_ptr.*;
+}
+
+pub fn getNavVAddr(
+ elf: *Elf,
+ pt: Zcu.PerThread,
+ nav: InternPool.Nav.Index,
+ reloc_info: link.File.RelocInfo,
+) !u64 {
+ return elf.getVAddr(reloc_info, try elf.navSymbol(pt.zcu, nav));
+}
+
+pub fn getUavVAddr(
+ elf: *Elf,
+ uav: InternPool.Index,
+ reloc_info: link.File.RelocInfo,
+) !u64 {
+ return elf.getVAddr(reloc_info, try elf.uavSymbol(uav));
+}
+
+pub fn getVAddr(elf: *Elf, reloc_info: link.File.RelocInfo, target_si: Symbol.Index) !u64 {
+ try elf.addReloc(
+ @enumFromInt(reloc_info.parent.atom_index),
+ reloc_info.offset,
+ target_si,
+ reloc_info.addend,
+ switch (elf.ehdrField(.machine)) {
+ else => unreachable,
+ .X86_64 => .{ .x86_64 = switch (elf.identClass()) {
+ .NONE, _ => unreachable,
+ .@"32" => .@"32",
+ .@"64" => .@"64",
+ } },
+ },
+ );
+ return 0;
+}
+
+fn addSection(elf: *Elf, segment_ni: MappedFile.Node.Index, opts: struct {
+ name: []const u8 = "",
+ type: std.elf.Word = std.elf.SHT_NULL,
+ size: std.elf.Word = 0,
+ flags: std.elf.SHF = .{},
+ addralign: std.mem.Alignment = .@"1",
+ entsize: std.elf.Word = 0,
+}) !Symbol.Index {
+ const gpa = elf.base.comp.gpa;
+ const target_endian = elf.endian();
+ try elf.nodes.ensureUnusedCapacity(gpa, 1);
+ try elf.symtab.ensureUnusedCapacity(gpa, 1);
+
+ const shstrtab_entry = try elf.string(.shstrtab, opts.name);
+ const shndx, const shdr_size = shndx: switch (elf.ehdrPtr()) {
+ inline else => |ehdr| {
+ const shentsize = std.mem.toNative(@TypeOf(ehdr.shentsize), ehdr.shentsize, target_endian);
+ const shndx = std.mem.toNative(@TypeOf(ehdr.shnum), ehdr.shnum, target_endian);
+ const shnum = shndx + 1;
+ ehdr.shnum = std.mem.nativeTo(@TypeOf(ehdr.shnum), shnum, target_endian);
+ break :shndx .{ shndx, shentsize * shnum };
+ },
+ };
+ try Node.known.shdr.resize(&elf.mf, gpa, shdr_size);
+ const ni = try elf.mf.addLastChildNode(gpa, segment_ni, .{
+ .alignment = opts.addralign,
+ .size = opts.size,
+ .moved = true,
+ });
+ const si = try elf.addSymbolAssumeCapacity();
+ elf.nodes.appendAssumeCapacity(.{ .section = si });
+ si.get(elf).ni = ni;
+ try si.init(elf, .{
+ .name = opts.name,
+ .size = opts.size,
+ .type = .SECTION,
+ .shndx = shndx,
+ });
+ switch (elf.shdrSlice()) {
+ inline else => |shdr| {
+ const sh = &shdr[shndx];
+ sh.* = .{
+ .name = shstrtab_entry,
+ .type = opts.type,
+ .flags = .{ .shf = opts.flags },
+ .addr = 0,
+ .offset = 0,
+ .size = opts.size,
+ .link = 0,
+ .info = 0,
+ .addralign = @intCast(opts.addralign.toByteUnits()),
+ .entsize = opts.entsize,
+ };
+ if (target_endian != native_endian) std.mem.byteSwapAllFields(@TypeOf(sh.*), sh);
+ },
+ }
+ return si;
+}
+
+fn renameSection(elf: *Elf, si: Symbol.Index, name: []const u8) !void {
+ const strtab_entry = try elf.string(.strtab, name);
+ const shstrtab_entry = try elf.string(.shstrtab, name);
+ const target_endian = elf.endian();
+ switch (elf.shdrSlice()) {
+ inline else => |shdr, class| {
+ const sym = @field(elf.symPtr(si), @tagName(class));
+ sym.name = std.mem.nativeTo(@TypeOf(sym.name), strtab_entry, target_endian);
+ const shndx = std.mem.toNative(@TypeOf(sym.shndx), sym.shndx, target_endian);
+ const sh = &shdr[shndx];
+ sh.name = std.mem.nativeTo(@TypeOf(sh.name), shstrtab_entry, target_endian);
+ },
+ }
+}
+
+fn linkSections(elf: *Elf, si: Symbol.Index, link_si: Symbol.Index) !void {
+ const target_endian = elf.endian();
+ switch (elf.shdrSlice()) {
+ inline else => |shdr, class| {
+ const sym = @field(elf.symPtr(si), @tagName(class));
+ const shndx = std.mem.toNative(@TypeOf(sym.shndx), sym.shndx, target_endian);
+ shdr[shndx].link = @field(elf.symPtr(link_si), @tagName(class)).shndx;
+ },
+ }
+}
+
+fn sectionName(elf: *Elf, si: Symbol.Index) [:0]const u8 {
+ const target_endian = elf.endian();
+ const name = Symbol.Index.shstrtab.node(elf).slice(&elf.mf)[name: switch (elf.shdrSlice()) {
+ inline else => |shndx, class| {
+ const sym = @field(elf.symPtr(si), @tagName(class));
+ const sh = &shndx[std.mem.toNative(@TypeOf(sym.shndx), sym.shndx, target_endian)];
+ break :name std.mem.toNative(@TypeOf(sh.name), sh.name, target_endian);
+ },
+ }..];
+ return name[0..std.mem.indexOfScalar(u8, name, 0).? :0];
+}
+
+fn string(elf: *Elf, comptime section: enum { shstrtab, strtab }, key: []const u8) !u32 {
+ if (key.len == 0) return 0;
+ return @field(elf, @tagName(section)).get(
+ elf.base.comp.gpa,
+ &elf.mf,
+ @field(Symbol.Index, @tagName(section)).node(elf),
+ key,
+ );
+}
+
+pub fn addReloc(
+ elf: *Elf,
+ loc_si: Symbol.Index,
+ offset: u64,
+ target_si: Symbol.Index,
+ addend: i64,
+ @"type": Reloc.Type,
+) !void {
+ const gpa = elf.base.comp.gpa;
+ const target = target_si.get(elf);
+ const ri: link.File.Elf2.Reloc.Index = @enumFromInt(elf.relocs.items.len);
+ (try elf.relocs.addOne(gpa)).* = .{
+ .type = @"type",
+ .prev = .none,
+ .next = target.target_relocs,
+ .loc = loc_si,
+ .target = target_si,
+ .unused = 0,
+ .offset = offset,
+ .addend = addend,
+ };
+ switch (target.target_relocs) {
+ .none => {},
+ else => |target_ri| target_ri.get(elf).prev = ri,
+ }
+ target.target_relocs = ri;
+}
+
+pub fn prelink(elf: *Elf, prog_node: std.Progress.Node) void {
+ _ = elf;
+ _ = prog_node;
+}
+
+pub fn updateNav(elf: *Elf, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !void {
+ elf.updateNavInner(pt, nav_index) catch |err| switch (err) {
+ error.OutOfMemory,
+ error.Overflow,
+ error.RelocationNotByteAligned,
+ => |e| return e,
+ else => |e| return elf.base.cgFail(nav_index, "linker failed to update variable: {t}", .{e}),
+ };
+}
+fn updateNavInner(elf: *Elf, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !void {
+ const comp = elf.base.comp;
+ const zcu = pt.zcu;
+ const gpa = zcu.gpa;
+ const ip = &zcu.intern_pool;
+
+ const nav = ip.getNav(nav_index);
+ const nav_val = nav.status.fully_resolved.val;
+ const nav_init, const is_threadlocal = switch (ip.indexToKey(nav_val)) {
+ else => .{ nav_val, false },
+ .variable => |variable| .{ variable.init, variable.is_threadlocal },
+ .@"extern" => return,
+ .func => .{ .none, false },
+ };
+ if (nav_init == .none or !Type.fromInterned(ip.typeOf(nav_init)).hasRuntimeBits(zcu)) return;
+
+ const si = try elf.navSymbol(zcu, nav_index);
+ const ni = ni: {
+ const sym = si.get(elf);
+ switch (sym.ni) {
+ .none => {
+ try elf.nodes.ensureUnusedCapacity(gpa, 1);
+ const sec_si: Symbol.Index =
+ if (is_threadlocal and comp.config.any_non_single_threaded) .tdata else .data;
+ const ni = try elf.mf.addLastChildNode(gpa, sec_si.node(elf), .{
+ .alignment = pt.navAlignment(nav_index).toStdMem(),
+ .moved = true,
+ });
+ elf.nodes.appendAssumeCapacity(.{ .nav = nav_index });
+ sym.ni = ni;
+ switch (elf.symPtr(si)) {
+ inline else => |sym_ptr, class| sym_ptr.shndx =
+ @field(elf.symPtr(sec_si), @tagName(class)).shndx,
+ }
+ },
+ else => si.deleteLocationRelocs(elf),
+ }
+ assert(sym.loc_relocs == .none);
+ sym.loc_relocs = @enumFromInt(elf.relocs.items.len);
+ break :ni sym.ni;
+ };
+
+ const size = size: {
+ var nw: MappedFile.Node.Writer = undefined;
+ ni.writer(&elf.mf, gpa, &nw);
+ defer nw.deinit();
+ codegen.generateSymbol(
+ &elf.base,
+ pt,
+ zcu.navSrcLoc(nav_index),
+ .fromInterned(nav_init),
+ &nw.interface,
+ .{ .atom_index = @intFromEnum(si) },
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ break :size nw.interface.end;
+ };
+
+ const target_endian = elf.endian();
+ switch (elf.symPtr(si)) {
+ inline else => |sym| sym.size =
+ std.mem.nativeTo(@TypeOf(sym.size), @intCast(size), target_endian),
+ }
+ si.applyLocationRelocs(elf);
+}
+
+pub fn lowerUav(
+ elf: *Elf,
+ pt: Zcu.PerThread,
+ uav_val: InternPool.Index,
+ uav_align: InternPool.Alignment,
+ src_loc: Zcu.LazySrcLoc,
+) !codegen.SymbolResult {
+ const zcu = pt.zcu;
+ const gpa = zcu.gpa;
+
+ try elf.pending_uavs.ensureUnusedCapacity(gpa, 1);
+ const si = elf.uavSymbol(uav_val) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ else => |e| return .{ .fail = try Zcu.ErrorMsg.create(
+ gpa,
+ src_loc,
+ "linker failed to update constant: {s}",
+ .{@errorName(e)},
+ ) },
+ };
+ if (switch (si.get(elf).ni) {
+ .none => true,
+ else => |ni| uav_align.toStdMem().order(ni.alignment(&elf.mf)).compare(.gt),
+ }) {
+ const gop = elf.pending_uavs.getOrPutAssumeCapacity(uav_val);
+ if (gop.found_existing) {
+ gop.value_ptr.alignment = gop.value_ptr.alignment.max(uav_align);
+ } else {
+ gop.value_ptr.* = .{
+ .alignment = uav_align,
+ .src_loc = src_loc,
+ };
+ elf.base.comp.link_uav_prog_node.increaseEstimatedTotalItems(1);
+ }
+ }
+ return .{ .sym_index = @intFromEnum(si) };
+}
+
+pub fn updateFunc(
+ elf: *Elf,
+ pt: Zcu.PerThread,
+ func_index: InternPool.Index,
+ mir: *const codegen.AnyMir,
+) !void {
+ elf.updateFuncInner(pt, func_index, mir) catch |err| switch (err) {
+ error.OutOfMemory,
+ error.Overflow,
+ error.RelocationNotByteAligned,
+ error.CodegenFail,
+ => |e| return e,
+ else => |e| return elf.base.cgFail(
+ pt.zcu.funcInfo(func_index).owner_nav,
+ "linker failed to update function: {s}",
+ .{@errorName(e)},
+ ),
+ };
+}
+fn updateFuncInner(
+ elf: *Elf,
+ pt: Zcu.PerThread,
+ func_index: InternPool.Index,
+ mir: *const codegen.AnyMir,
+) !void {
+ const zcu = pt.zcu;
+ const gpa = zcu.gpa;
+ const ip = &zcu.intern_pool;
+ const func = zcu.funcInfo(func_index);
+ const nav = ip.getNav(func.owner_nav);
+
+ const si = try elf.navSymbol(zcu, func.owner_nav);
+ log.debug("updateFunc({f}) = {d}", .{ nav.fqn.fmt(ip), si });
+ const ni = ni: {
+ const sym = si.get(elf);
+ switch (sym.ni) {
+ .none => {
+ try elf.nodes.ensureUnusedCapacity(gpa, 1);
+ const mod = zcu.navFileScope(func.owner_nav).mod.?;
+ const target = &mod.resolved_target.result;
+ const ni = try elf.mf.addLastChildNode(gpa, Symbol.Index.text.node(elf), .{
+ .alignment = switch (nav.status.fully_resolved.alignment) {
+ .none => switch (mod.optimize_mode) {
+ .Debug,
+ .ReleaseSafe,
+ .ReleaseFast,
+ => target_util.defaultFunctionAlignment(target),
+ .ReleaseSmall => target_util.minFunctionAlignment(target),
+ },
+ else => |a| a.maxStrict(target_util.minFunctionAlignment(target)),
+ }.toStdMem(),
+ .moved = true,
+ });
+ elf.nodes.appendAssumeCapacity(.{ .nav = func.owner_nav });
+ sym.ni = ni;
+ switch (elf.symPtr(si)) {
+ inline else => |sym_ptr, class| sym_ptr.shndx =
+ @field(elf.symPtr(.text), @tagName(class)).shndx,
+ }
+ },
+ else => si.deleteLocationRelocs(elf),
+ }
+ assert(sym.loc_relocs == .none);
+ sym.loc_relocs = @enumFromInt(elf.relocs.items.len);
+ break :ni sym.ni;
+ };
+
+ const size = size: {
+ var nw: MappedFile.Node.Writer = undefined;
+ ni.writer(&elf.mf, gpa, &nw);
+ defer nw.deinit();
+ codegen.emitFunction(
+ &elf.base,
+ pt,
+ zcu.navSrcLoc(func.owner_nav),
+ func_index,
+ @intFromEnum(si),
+ mir,
+ &nw.interface,
+ .none,
+ ) catch |err| switch (err) {
+ error.WriteFailed => return nw.err.?,
+ else => |e| return e,
+ };
+ break :size nw.interface.end;
+ };
+
+ const target_endian = elf.endian();
+ switch (elf.symPtr(si)) {
+ inline else => |sym| sym.size =
+ std.mem.nativeTo(@TypeOf(sym.size), @intCast(size), target_endian),
+ }
+ si.applyLocationRelocs(elf);
+}
+
+pub fn updateErrorData(elf: *Elf, pt: Zcu.PerThread) !void {
+ const si = elf.lazy.getPtr(.const_data).map.get(.anyerror_type) orelse return;
+ elf.flushLazy(pt, .{ .kind = .const_data, .ty = .anyerror_type }, si) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ error.CodegenFail => return error.LinkFailure,
+ else => |e| return elf.base.comp.link_diags.fail("updateErrorData failed {t}", .{e}),
+ };
+}
+
+pub fn flush(
+ elf: *Elf,
+ arena: std.mem.Allocator,
+ tid: Zcu.PerThread.Id,
+ prog_node: std.Progress.Node,
+) !void {
+ _ = arena;
+ _ = prog_node;
+ while (try elf.idle(tid)) {}
+}
+
+pub fn idle(elf: *Elf, tid: Zcu.PerThread.Id) !bool {
+ const comp = elf.base.comp;
+ task: {
+ while (elf.pending_uavs.pop()) |pending_uav| {
+ const sub_prog_node =
+ elf.idleProgNode(
+ tid,
+ comp.link_uav_prog_node,
+ .{ .uav = pending_uav.key },
+ );
+ defer sub_prog_node.end();
+ break :task elf.flushUav(
+ .{ .zcu = elf.base.comp.zcu.?, .tid = tid },
+ pending_uav.key,
+ pending_uav.value.alignment,
+ pending_uav.value.src_loc,
+ ) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ else => |e| return elf.base.comp.link_diags.fail(
+ "linker failed to lower constant: {t}",
+ .{e},
+ ),
+ };
+ }
+ var lazy_it = elf.lazy.iterator();
+ while (lazy_it.next()) |lazy| for (
+ lazy.value.map.keys()[lazy.value.pending_index..],
+ lazy.value.map.values()[lazy.value.pending_index..],
+ ) |ty, si| {
+ lazy.value.pending_index += 1;
+ const pt: Zcu.PerThread = .{ .zcu = elf.base.comp.zcu.?, .tid = tid };
+ const kind = switch (lazy.key) {
+ .code => "code",
+ .const_data => "data",
+ };
+ var name: [std.Progress.Node.max_name_len]u8 = undefined;
+ const sub_prog_node = comp.link_lazy_prog_node.start(
+ std.fmt.bufPrint(&name, "lazy {s} for {f}", .{
+ kind,
+ Type.fromInterned(ty).fmt(pt),
+ }) catch &name,
+ 0,
+ );
+ defer sub_prog_node.end();
+ break :task elf.flushLazy(pt, .{
+ .kind = lazy.key,
+ .ty = ty,
+ }, si) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ else => |e| return elf.base.comp.link_diags.fail(
+ "linker failed to lower lazy {s}: {t}",
+ .{ kind, e },
+ ),
+ };
+ };
+ while (elf.mf.updates.pop()) |ni| {
+ const clean_moved = ni.cleanMoved(&elf.mf);
+ const clean_resized = ni.cleanResized(&elf.mf);
+ if (clean_moved or clean_resized) {
+ const sub_prog_node = elf.idleProgNode(tid, elf.mf.update_prog_node, elf.getNode(ni));
+ defer sub_prog_node.end();
+ if (clean_moved) try elf.flushMoved(ni);
+ if (clean_resized) try elf.flushResized(ni);
+ break :task;
+ } else elf.mf.update_prog_node.completeOne();
+ }
+ }
+ if (elf.pending_uavs.count() > 0) return true;
+ for (&elf.lazy.values) |lazy| if (lazy.map.count() > lazy.pending_index) return true;
+ if (elf.mf.updates.items.len > 0) return true;
+ return false;
+}
+
+fn idleProgNode(
+ elf: *Elf,
+ tid: Zcu.PerThread.Id,
+ prog_node: std.Progress.Node,
+ node: Node,
+) std.Progress.Node {
+ var name: [std.Progress.Node.max_name_len]u8 = undefined;
+ return prog_node.start(name: switch (node) {
+ else => |tag| @tagName(tag),
+ .section => |si| elf.sectionName(si),
+ .nav => |nav| {
+ const ip = &elf.base.comp.zcu.?.intern_pool;
+ break :name ip.getNav(nav).fqn.toSlice(ip);
+ },
+ .uav => |uav| std.fmt.bufPrint(&name, "{f}", .{
+ Value.fromInterned(uav).fmtValue(.{ .zcu = elf.base.comp.zcu.?, .tid = tid }),
+ }) catch &name,
+ }, 0);
+}
+
+fn flushUav(
+ elf: *Elf,
+ pt: Zcu.PerThread,
+ uav_val: InternPool.Index,
+ uav_align: InternPool.Alignment,
+ src_loc: Zcu.LazySrcLoc,
+) !void {
+ const zcu = pt.zcu;
+ const gpa = zcu.gpa;
+
+ const si = try elf.uavSymbol(uav_val);
+ const ni = ni: {
+ const sym = si.get(elf);
+ switch (sym.ni) {
+ .none => {
+ try elf.nodes.ensureUnusedCapacity(gpa, 1);
+ const ni = try elf.mf.addLastChildNode(gpa, Symbol.Index.data.node(elf), .{
+ .alignment = uav_align.toStdMem(),
+ .moved = true,
+ });
+ elf.nodes.appendAssumeCapacity(.{ .uav = uav_val });
+ sym.ni = ni;
+ switch (elf.symPtr(si)) {
+ inline else => |sym_ptr, class| sym_ptr.shndx =
+ @field(elf.symPtr(.data), @tagName(class)).shndx,
+ }
+ },
+ else => {
+ if (sym.ni.alignment(&elf.mf).order(uav_align.toStdMem()).compare(.gte)) return;
+ si.deleteLocationRelocs(elf);
+ },
+ }
+ assert(sym.loc_relocs == .none);
+ sym.loc_relocs = @enumFromInt(elf.relocs.items.len);
+ break :ni sym.ni;
+ };
+
+ const size = size: {
+ var nw: MappedFile.Node.Writer = undefined;
+ ni.writer(&elf.mf, gpa, &nw);
+ defer nw.deinit();
+ codegen.generateSymbol(
+ &elf.base,
+ pt,
+ src_loc,
+ .fromInterned(uav_val),
+ &nw.interface,
+ .{ .atom_index = @intFromEnum(si) },
+ ) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ break :size nw.interface.end;
+ };
+
+ const target_endian = elf.endian();
+ switch (elf.symPtr(si)) {
+ inline else => |sym| sym.size =
+ std.mem.nativeTo(@TypeOf(sym.size), @intCast(size), target_endian),
+ }
+ si.applyLocationRelocs(elf);
+}
+
+fn flushLazy(elf: *Elf, pt: Zcu.PerThread, lazy: link.File.LazySymbol, si: Symbol.Index) !void {
+ const zcu = pt.zcu;
+ const gpa = zcu.gpa;
+
+ const ni = ni: {
+ const sym = si.get(elf);
+ switch (sym.ni) {
+ .none => {
+ try elf.nodes.ensureUnusedCapacity(gpa, 1);
+ const sec_si: Symbol.Index = switch (lazy.kind) {
+ .code => .text,
+ .const_data => .rodata,
+ };
+ const ni = try elf.mf.addLastChildNode(gpa, sec_si.node(elf), .{ .moved = true });
+ elf.nodes.appendAssumeCapacity(switch (lazy.kind) {
+ .code => .{ .lazy_code = lazy.ty },
+ .const_data => .{ .lazy_const_data = lazy.ty },
+ });
+ sym.ni = ni;
+ switch (elf.symPtr(si)) {
+ inline else => |sym_ptr, class| sym_ptr.shndx =
+ @field(elf.symPtr(sec_si), @tagName(class)).shndx,
+ }
+ },
+ else => si.deleteLocationRelocs(elf),
+ }
+ assert(sym.loc_relocs == .none);
+ sym.loc_relocs = @enumFromInt(elf.relocs.items.len);
+ break :ni sym.ni;
+ };
+
+ const size = size: {
+ var required_alignment: InternPool.Alignment = .none;
+ var nw: MappedFile.Node.Writer = undefined;
+ ni.writer(&elf.mf, gpa, &nw);
+ defer nw.deinit();
+ try codegen.generateLazySymbol(
+ &elf.base,
+ pt,
+ Type.fromInterned(lazy.ty).srcLocOrNull(pt.zcu) orelse .unneeded,
+ lazy,
+ &required_alignment,
+ &nw.interface,
+ .none,
+ .{ .atom_index = @intFromEnum(si) },
+ );
+ break :size nw.interface.end;
+ };
+
+ const target_endian = elf.endian();
+ switch (elf.symPtr(si)) {
+ inline else => |sym| sym.size =
+ std.mem.nativeTo(@TypeOf(sym.size), @intCast(size), target_endian),
+ }
+ si.applyLocationRelocs(elf);
+}
+
+fn flushMoved(elf: *Elf, ni: MappedFile.Node.Index) !void {
+ const target_endian = elf.endian();
+ const file_offset = ni.fileLocation(&elf.mf, false).offset;
+ const node = elf.getNode(ni);
+ switch (node) {
+ else => |tag| @panic(@tagName(tag)),
+ .ehdr => assert(file_offset == 0),
+ .shdr => switch (elf.ehdrPtr()) {
+ inline else => |ehdr| ehdr.shoff =
+ std.mem.nativeTo(@TypeOf(ehdr.shoff), @intCast(file_offset), target_endian),
+ },
+ .segment => |phndx| switch (elf.phdrSlice()) {
+ inline else => |phdr, class| {
+ const ph = &phdr[phndx];
+ switch (std.mem.toNative(@TypeOf(ph.type), ph.type, target_endian)) {
+ else => unreachable,
+ std.elf.PT_NULL, std.elf.PT_LOAD, std.elf.PT_DYNAMIC, std.elf.PT_INTERP => {},
+ std.elf.PT_PHDR => {
+ const ehdr = @field(elf.ehdrPtr(), @tagName(class));
+ ehdr.phoff =
+ std.mem.nativeTo(@TypeOf(ehdr.phoff), @intCast(file_offset), target_endian);
+ },
+ std.elf.PT_TLS => {},
+ }
+ ph.offset = std.mem.nativeTo(@TypeOf(ph.offset), @intCast(file_offset), target_endian);
+ ph.vaddr = std.mem.nativeTo(
+ @TypeOf(ph.vaddr),
+ @intCast(elf.baseAddr() + file_offset),
+ target_endian,
+ );
+ ph.paddr = ph.vaddr;
+ },
+ },
+ .section => |si| switch (elf.shdrSlice()) {
+ inline else => |shdr, class| {
+ const sym = @field(elf.symPtr(si), @tagName(class));
+ const shndx = std.mem.toNative(@TypeOf(sym.shndx), sym.shndx, target_endian);
+ const sh = &shdr[shndx];
+ const flags: @TypeOf(sh.flags) = @bitCast(std.mem.toNative(
+ @typeInfo(@TypeOf(sh.flags)).@"struct".backing_integer.?,
+ @bitCast(sh.flags),
+ target_endian,
+ ));
+ if (flags.shf.ALLOC) {
+ sym.value = std.mem.nativeTo(
+ @TypeOf(sym.value),
+ @intCast(elf.baseAddr() + file_offset),
+ target_endian,
+ );
+ sh.addr = sym.value;
+ }
+ sh.offset = std.mem.nativeTo(@TypeOf(sh.offset), @intCast(file_offset), target_endian);
+ },
+ },
+ .nav, .uav, .lazy_code, .lazy_const_data => {
+ const si = switch (node) {
+ else => unreachable,
+ .nav => |nav| elf.navs.get(nav),
+ .uav => |uav| elf.uavs.get(uav),
+ .lazy_code => |ty| elf.lazy.getPtr(.code).map.get(ty),
+ .lazy_const_data => |ty| elf.lazy.getPtr(.const_data).map.get(ty),
+ }.?;
+ switch (elf.shdrSlice()) {
+ inline else => |shdr, class| {
+ const sym = @field(elf.symPtr(si), @tagName(class));
+ const sh = &shdr[std.mem.toNative(@TypeOf(sym.shndx), sym.shndx, target_endian)];
+ const flags: @TypeOf(sh.flags) = @bitCast(std.mem.toNative(
+ @typeInfo(@TypeOf(sh.flags)).@"struct".backing_integer.?,
+ @bitCast(sh.flags),
+ target_endian,
+ ));
+ const sh_addr = if (flags.shf.TLS)
+ 0
+ else
+ std.mem.toNative(@TypeOf(sh.addr), sh.addr, target_endian);
+ const sh_offset = std.mem.toNative(@TypeOf(sh.offset), sh.offset, target_endian);
+ sym.value = std.mem.nativeTo(
+ @TypeOf(sym.value),
+ @intCast(file_offset - sh_offset + sh_addr),
+ target_endian,
+ );
+ if (si == elf.entry_hack) @field(elf.ehdrPtr(), @tagName(class)).entry = sym.value;
+ },
+ }
+ si.applyLocationRelocs(elf);
+ si.applyTargetRelocs(elf);
+ },
+ }
+ try ni.childrenMoved(elf.base.comp.gpa, &elf.mf);
+}
+
+fn flushResized(elf: *Elf, ni: MappedFile.Node.Index) !void {
+ const target_endian = elf.endian();
+ _, const size = ni.location(&elf.mf).resolve(&elf.mf);
+ const node = elf.getNode(ni);
+ switch (node) {
+ else => |tag| @panic(@tagName(tag)),
+ .file, .shdr => {},
+ .segment => |phndx| switch (elf.phdrSlice()) {
+ inline else => |phdr| {
+ const ph = &phdr[phndx];
+ ph.filesz = std.mem.nativeTo(@TypeOf(ph.filesz), @intCast(size), target_endian);
+ ph.memsz = ph.filesz;
+ switch (std.mem.toNative(@TypeOf(ph.type), ph.type, target_endian)) {
+ else => unreachable,
+ std.elf.PT_NULL => {
+ if (size > 0) ph.type = std.mem.nativeTo(
+ @TypeOf(ph.type),
+ std.elf.PT_LOAD,
+ target_endian,
+ );
+ },
+ std.elf.PT_LOAD => {
+ if (size == 0) ph.type = std.mem.nativeTo(
+ @TypeOf(ph.type),
+ std.elf.PT_NULL,
+ target_endian,
+ );
+ },
+ std.elf.PT_DYNAMIC, std.elf.PT_INTERP, std.elf.PT_PHDR => {},
+ std.elf.PT_TLS => try ni.childrenMoved(elf.base.comp.gpa, &elf.mf),
+ }
+ },
+ },
+ .section => |si| switch (elf.shdrSlice()) {
+ inline else => |shdr, class| {
+ const sym = @field(elf.symPtr(si), @tagName(class));
+ const shndx = std.mem.toNative(@TypeOf(sym.shndx), sym.shndx, target_endian);
+ const sh = &shdr[shndx];
+ switch (std.mem.toNative(@TypeOf(sh.type), sh.type, target_endian)) {
+ else => unreachable,
+ std.elf.SHT_NULL => {
+ if (size > 0) sh.type = std.mem.nativeTo(
+ @TypeOf(sh.type),
+ std.elf.SHT_PROGBITS,
+ target_endian,
+ );
+ },
+ std.elf.SHT_PROGBITS => {
+ if (size == 0) sh.type = std.mem.nativeTo(
+ @TypeOf(sh.type),
+ std.elf.SHT_NULL,
+ target_endian,
+ );
+ },
+ std.elf.SHT_SYMTAB => sh.info = std.mem.nativeTo(
+ @TypeOf(sh.info),
+ @intCast(@divExact(
+ size,
+ std.mem.toNative(@TypeOf(sh.entsize), sh.entsize, target_endian),
+ )),
+ target_endian,
+ ),
+ std.elf.SHT_STRTAB => {},
+ }
+ sh.size = std.mem.nativeTo(@TypeOf(sh.size), @intCast(size), target_endian);
+ },
+ },
+ .nav, .uav, .lazy_code, .lazy_const_data => {},
+ }
+}
+
+pub fn updateExports(
+ elf: *Elf,
+ pt: Zcu.PerThread,
+ exported: Zcu.Exported,
+ export_indices: []const Zcu.Export.Index,
+) !void {
+ return elf.updateExportsInner(pt, exported, export_indices) catch |err| switch (err) {
+ error.OutOfMemory => error.OutOfMemory,
+ error.LinkFailure => error.AnalysisFail,
+ else => |e| switch (elf.base.comp.link_diags.fail(
+ "linker failed to update exports: {t}",
+ .{e},
+ )) {
+ error.LinkFailure => return error.AnalysisFail,
+ },
+ };
+}
+fn updateExportsInner(
+ elf: *Elf,
+ pt: Zcu.PerThread,
+ exported: Zcu.Exported,
+ export_indices: []const Zcu.Export.Index,
+) !void {
+ const zcu = pt.zcu;
+ const gpa = zcu.gpa;
+ const ip = &zcu.intern_pool;
+
+ switch (exported) {
+ .nav => |nav| log.debug("updateExports({f})", .{ip.getNav(nav).fqn.fmt(ip)}),
+ .uav => |uav| log.debug("updateExports(@as({f}, {f}))", .{
+ Type.fromInterned(ip.typeOf(uav)).fmt(pt),
+ Value.fromInterned(uav).fmtValue(pt),
+ }),
+ }
+ try elf.symtab.ensureUnusedCapacity(gpa, export_indices.len);
+ const exported_si: Symbol.Index, const @"type": std.elf.STT = switch (exported) {
+ .nav => |nav| .{
+ try elf.navSymbol(zcu, nav),
+ navType(ip, ip.getNav(nav).status, elf.base.comp.config.any_non_single_threaded),
+ },
+ .uav => |uav| .{ @enumFromInt(switch (try elf.lowerUav(
+ pt,
+ uav,
+ Type.fromInterned(ip.typeOf(uav)).abiAlignment(zcu),
+ export_indices[0].ptr(zcu).src,
+ )) {
+ .sym_index => |si| si,
+ .fail => |em| {
+ defer em.destroy(gpa);
+ return elf.base.comp.link_diags.fail("{s}", .{em.msg});
+ },
+ }), .OBJECT },
+ };
+ while (try elf.idle(pt.tid)) {}
+ const exported_ni = exported_si.node(elf);
+ const value, const size, const shndx = switch (elf.symPtr(exported_si)) {
+ inline else => |exported_sym| .{ exported_sym.value, exported_sym.size, exported_sym.shndx },
+ };
+ for (export_indices) |export_index| {
+ const @"export" = export_index.ptr(zcu);
+ const name = @"export".opts.name.toSlice(ip);
+ const export_si = try elf.globalSymbol(.{
+ .name = name,
+ .type = @"type",
+ .bind = switch (@"export".opts.linkage) {
+ .internal => .LOCAL,
+ .strong => .GLOBAL,
+ .weak => .WEAK,
+ .link_once => return error.LinkOnceUnsupported,
+ },
+ .visibility = switch (@"export".opts.visibility) {
+ .default => .DEFAULT,
+ .hidden => .HIDDEN,
+ .protected => .PROTECTED,
+ },
+ });
+ export_si.get(elf).ni = exported_ni;
+ switch (elf.symPtr(export_si)) {
+ inline else => |export_sym| {
+ export_sym.value = @intCast(value);
+ export_sym.size = @intCast(size);
+ export_sym.shndx = shndx;
+ },
+ }
+ export_si.applyTargetRelocs(elf);
+ if (std.mem.eql(u8, name, "_start")) {
+ elf.entry_hack = exported_si;
+ switch (elf.ehdrPtr()) {
+ inline else => |ehdr| ehdr.entry = @intCast(value),
+ }
+ }
+ }
+}
+
+pub fn deleteExport(elf: *Elf, exported: Zcu.Exported, name: InternPool.NullTerminatedString) void {
+ _ = elf;
+ _ = exported;
+ _ = name;
+}
+
+pub fn dump(elf: *Elf, tid: Zcu.PerThread.Id) void {
+ const w = std.debug.lockStderrWriter(&.{});
+ defer std.debug.unlockStderrWriter();
+ elf.printNode(tid, w, .root, 0) catch {};
+}
+
+pub fn printNode(
+ elf: *Elf,
+ tid: Zcu.PerThread.Id,
+ w: *std.Io.Writer,
+ ni: MappedFile.Node.Index,
+ indent: usize,
+) !void {
+ const node = elf.getNode(ni);
+ const mf_node = &elf.mf.nodes.items[@intFromEnum(ni)];
+ const off, const size = mf_node.location().resolve(&elf.mf);
+ try w.splatByteAll(' ', indent);
+ try w.writeAll(@tagName(node));
+ switch (node) {
+ else => {},
+ .section => |si| try w.print("({s})", .{elf.sectionName(si)}),
+ .nav => |nav_index| {
+ const zcu = elf.base.comp.zcu.?;
+ const ip = &zcu.intern_pool;
+ const nav = ip.getNav(nav_index);
+ try w.print("({f}, {f})", .{
+ Type.fromInterned(nav.typeOf(ip)).fmt(.{ .zcu = zcu, .tid = tid }),
+ nav.fqn.fmt(ip),
+ });
+ },
+ .uav => |uav| {
+ const zcu = elf.base.comp.zcu.?;
+ const val: Value = .fromInterned(uav);
+ try w.print("({f}, {f})", .{
+ val.typeOf(zcu).fmt(.{ .zcu = zcu, .tid = tid }),
+ val.fmtValue(.{ .zcu = zcu, .tid = tid }),
+ });
+ },
+ }
+ try w.print(" index={d} offset=0x{x} size=0x{x} align=0x{x}{s}{s}{s}{s}\n", .{
+ @intFromEnum(ni),
+ off,
+ size,
+ mf_node.flags.alignment.toByteUnits(),
+ if (mf_node.flags.fixed) " fixed" else "",
+ if (mf_node.flags.moved) " moved" else "",
+ if (mf_node.flags.resized) " resized" else "",
+ if (mf_node.flags.has_content) " has_content" else "",
+ });
+ var child_ni = mf_node.first;
+ switch (child_ni) {
+ .none => {
+ const file_loc = ni.fileLocation(&elf.mf, false);
+ if (file_loc.size == 0) return;
+ var address = file_loc.offset;
+ const line_len = 0x10;
+ var line_it = std.mem.window(
+ u8,
+ elf.mf.contents[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)],
+ line_len,
+ line_len,
+ );
+ while (line_it.next()) |line_bytes| : (address += line_len) {
+ try w.splatByteAll(' ', indent + 1);
+ try w.print("{x:0>8}", .{address});
+ for (line_bytes) |byte| try w.print(" {x:0>2}", .{byte});
+ try w.writeByte('\n');
+ }
+ },
+ else => while (child_ni != .none) {
+ try elf.printNode(tid, w, child_ni, indent + 1);
+ child_ni = elf.mf.nodes.items[@intFromEnum(child_ni)].next;
+ },
+ }
+}
+
+const assert = std.debug.assert;
+const builtin = @import("builtin");
+const codegen = @import("../codegen.zig");
+const Compilation = @import("../Compilation.zig");
+const Elf = @This();
+const InternPool = @import("../InternPool.zig");
+const link = @import("../link.zig");
+const log = std.log.scoped(.link);
+const MappedFile = @import("MappedFile.zig");
+const native_endian = builtin.cpu.arch.endian();
+const std = @import("std");
+const target_util = @import("../target.zig");
+const Type = @import("../Type.zig");
+const Value = @import("../Value.zig");
+const Zcu = @import("../Zcu.zig");
src/link/MappedFile.zig
@@ -0,0 +1,929 @@
+file: std.fs.File,
+flags: packed struct {
+ block_size: std.mem.Alignment,
+ copy_file_range_unsupported: bool,
+ fallocate_punch_hole_unsupported: bool,
+ fallocate_insert_range_unsupported: bool,
+},
+section: if (is_windows) windows.HANDLE else void,
+contents: []align(std.heap.page_size_min) u8,
+nodes: std.ArrayList(Node),
+free_ni: Node.Index,
+large: std.ArrayList(u64),
+updates: std.ArrayList(Node.Index),
+update_prog_node: std.Progress.Node,
+writers: std.SinglyLinkedList,
+
+pub const Error = std.posix.MMapError ||
+ std.posix.MRemapError ||
+ std.fs.File.SetEndPosError ||
+ std.fs.File.CopyRangeError ||
+ error{NotFile};
+
+pub fn init(file: std.fs.File, gpa: std.mem.Allocator) !MappedFile {
+ var mf: MappedFile = .{
+ .file = file,
+ .flags = undefined,
+ .section = if (is_windows) windows.INVALID_HANDLE_VALUE else {},
+ .contents = &.{},
+ .nodes = .empty,
+ .free_ni = .none,
+ .large = .empty,
+ .updates = .empty,
+ .update_prog_node = .none,
+ .writers = .{},
+ };
+ errdefer mf.deinit(gpa);
+ const size: u64, const blksize = if (is_windows)
+ .{ try windows.GetFileSizeEx(file.handle), 1 }
+ else stat: {
+ const stat = try std.posix.fstat(mf.file.handle);
+ if (!std.posix.S.ISREG(stat.mode)) return error.PathAlreadyExists;
+ break :stat .{ @bitCast(stat.size), stat.blksize };
+ };
+ mf.flags = .{
+ .block_size = .fromByteUnits(
+ std.math.ceilPowerOfTwoAssert(usize, @max(std.heap.pageSize(), blksize)),
+ ),
+ .copy_file_range_unsupported = false,
+ .fallocate_insert_range_unsupported = false,
+ .fallocate_punch_hole_unsupported = false,
+ };
+ try mf.nodes.ensureUnusedCapacity(gpa, 1);
+ assert(try mf.addNode(gpa, .{
+ .add_node = .{
+ .size = size,
+ .fixed = true,
+ },
+ }) == Node.Index.root);
+ try mf.ensureTotalCapacity(@intCast(size));
+ return mf;
+}
+
+pub fn deinit(mf: *MappedFile, gpa: std.mem.Allocator) void {
+ mf.unmap();
+ mf.nodes.deinit(gpa);
+ mf.large.deinit(gpa);
+ mf.updates.deinit(gpa);
+ mf.update_prog_node.end();
+ assert(mf.writers.first == null);
+ mf.* = undefined;
+}
+
+pub const Node = extern struct {
+ parent: Node.Index,
+ prev: Node.Index,
+ next: Node.Index,
+ first: Node.Index,
+ last: Node.Index,
+ flags: Flags,
+ location_payload: Location.Payload,
+
+ pub const Flags = packed struct(u32) {
+ location_tag: Location.Tag,
+ alignment: std.mem.Alignment,
+ /// Whether this node can be moved.
+ fixed: bool,
+ /// Whether this node has been moved.
+ moved: bool,
+ /// Whether this node has been resized.
+ resized: bool,
+ /// Whether this node might contain non-zero bytes.
+ has_content: bool,
+ unused: @Type(.{ .int = .{
+ .signedness = .unsigned,
+ .bits = 32 - @bitSizeOf(std.mem.Alignment) - 5,
+ } }) = 0,
+ };
+
+ pub const Location = union(enum(u1)) {
+ small: extern struct {
+ /// Relative to `parent`.
+ offset: u32,
+ size: u32,
+ },
+ large: extern struct {
+ index: usize,
+ unused: @Type(.{ .int = .{
+ .signedness = .unsigned,
+ .bits = 64 - @bitSizeOf(usize),
+ } }) = 0,
+ },
+
+ pub const Tag = @typeInfo(Location).@"union".tag_type.?;
+ pub const Payload = @Type(.{ .@"union" = .{
+ .layout = .@"extern",
+ .tag_type = null,
+ .fields = @typeInfo(Location).@"union".fields,
+ .decls = &.{},
+ } });
+
+ pub fn resolve(loc: Location, mf: *const MappedFile) [2]u64 {
+ return switch (loc) {
+ .small => |small| .{ small.offset, small.size },
+ .large => |large| mf.large.items[large.index..][0..2].*,
+ };
+ }
+ };
+
+ pub const Index = enum(u32) {
+ none,
+ _,
+
+ pub const root: Node.Index = .none;
+
+ fn get(ni: Node.Index, mf: *const MappedFile) *Node {
+ return &mf.nodes.items[@intFromEnum(ni)];
+ }
+
+ pub fn childrenMoved(ni: Node.Index, gpa: std.mem.Allocator, mf: *MappedFile) !void {
+ var child_ni = ni.get(mf).last;
+ while (child_ni != .none) {
+ try child_ni.moved(gpa, mf);
+ child_ni = child_ni.get(mf).prev;
+ }
+ }
+
+ pub fn hasMoved(ni: Node.Index, mf: *const MappedFile) bool {
+ var parent_ni = ni;
+ while (parent_ni != .none) {
+ const parent = parent_ni.get(mf);
+ if (parent.flags.moved) return true;
+ parent_ni = parent.parent;
+ }
+ return false;
+ }
+ pub fn moved(ni: Node.Index, gpa: std.mem.Allocator, mf: *MappedFile) !void {
+ try mf.updates.ensureUnusedCapacity(gpa, 1);
+ ni.movedAssumeCapacity(mf);
+ }
+ pub fn cleanMoved(ni: Node.Index, mf: *const MappedFile) bool {
+ const node_moved = &ni.get(mf).flags.moved;
+ defer node_moved.* = false;
+ return node_moved.*;
+ }
+ fn movedAssumeCapacity(ni: Node.Index, mf: *MappedFile) void {
+ var parent_ni = ni;
+ while (parent_ni != .none) {
+ const parent_node = parent_ni.get(mf);
+ if (parent_node.flags.moved) return;
+ parent_ni = parent_node.parent;
+ }
+ const node = ni.get(mf);
+ node.flags.moved = true;
+ if (node.flags.resized) return;
+ mf.updates.appendAssumeCapacity(ni);
+ mf.update_prog_node.increaseEstimatedTotalItems(1);
+ }
+
+ pub fn hasResized(ni: Node.Index, mf: *const MappedFile) bool {
+ return ni.get(mf).flags.resized;
+ }
+ pub fn resized(ni: Node.Index, gpa: std.mem.Allocator, mf: *MappedFile) !void {
+ try mf.updates.ensureUnusedCapacity(gpa, 1);
+ ni.resizedAssumeCapacity(mf);
+ }
+ pub fn cleanResized(ni: Node.Index, mf: *const MappedFile) bool {
+ const node_resized = &ni.get(mf).flags.resized;
+ defer node_resized.* = false;
+ return node_resized.*;
+ }
+ fn resizedAssumeCapacity(ni: Node.Index, mf: *MappedFile) void {
+ const node = ni.get(mf);
+ if (node.flags.resized) return;
+ node.flags.resized = true;
+ if (node.flags.moved) return;
+ mf.updates.appendAssumeCapacity(ni);
+ mf.update_prog_node.increaseEstimatedTotalItems(1);
+ }
+
+ pub fn alignment(ni: Node.Index, mf: *const MappedFile) std.mem.Alignment {
+ return ni.get(mf).flags.alignment;
+ }
+
+ fn setLocationAssumeCapacity(ni: Node.Index, mf: *MappedFile, offset: u64, size: u64) void {
+ const node = ni.get(mf);
+ if (size == 0) node.flags.has_content = false;
+ switch (node.location()) {
+ .small => |small| {
+ if (small.offset != offset) ni.movedAssumeCapacity(mf);
+ if (small.size != size) ni.resizedAssumeCapacity(mf);
+ if (std.math.cast(u32, offset)) |small_offset| {
+ if (std.math.cast(u32, size)) |small_size| {
+ node.location_payload.small = .{
+ .offset = small_offset,
+ .size = small_size,
+ };
+ return;
+ }
+ }
+ defer mf.large.appendSliceAssumeCapacity(&.{ offset, size });
+ node.flags.location_tag = .large;
+ node.location_payload = .{ .large = .{ .index = mf.large.items.len } };
+ },
+ .large => |large| {
+ const large_items = mf.large.items[large.index..][0..2];
+ if (large_items[0] != offset) ni.movedAssumeCapacity(mf);
+ if (large_items[1] != size) ni.resizedAssumeCapacity(mf);
+ large_items.* = .{ offset, size };
+ },
+ }
+ }
+
+ pub fn location(ni: Node.Index, mf: *const MappedFile) Location {
+ return ni.get(mf).location();
+ }
+
+ pub fn fileLocation(
+ ni: Node.Index,
+ mf: *const MappedFile,
+ set_has_content: bool,
+ ) struct { offset: u64, size: u64 } {
+ var offset, const size = ni.location(mf).resolve(mf);
+ var parent_ni = ni;
+ while (true) {
+ const parent = parent_ni.get(mf);
+ if (set_has_content) parent.flags.has_content = true;
+ if (parent_ni == .none) break;
+ parent_ni = parent.parent;
+ offset += parent_ni.location(mf).resolve(mf)[0];
+ }
+ return .{ .offset = offset, .size = size };
+ }
+
+ pub fn slice(ni: Node.Index, mf: *const MappedFile) []u8 {
+ const file_loc = ni.fileLocation(mf, true);
+ return mf.contents[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)];
+ }
+
+ pub fn sliceConst(ni: Node.Index, mf: *const MappedFile) []const u8 {
+ const file_loc = ni.fileLocation(mf, false);
+ return mf.contents[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)];
+ }
+
+ pub fn resize(ni: Node.Index, mf: *MappedFile, gpa: std.mem.Allocator, size: u64) !void {
+ try mf.resizeNode(gpa, ni, size);
+ var writers_it = mf.writers.first;
+ while (writers_it) |writer_node| : (writers_it = writer_node.next) {
+ const w: *Node.Writer = @fieldParentPtr("writer_node", writer_node);
+ w.interface.buffer = w.ni.slice(mf);
+ }
+ }
+
+ pub fn writer(ni: Node.Index, mf: *MappedFile, gpa: std.mem.Allocator, w: *Writer) void {
+ w.* = .{
+ .gpa = gpa,
+ .mf = mf,
+ .writer_node = .{},
+ .ni = ni,
+ .interface = .{
+ .buffer = ni.slice(mf),
+ .vtable = &Writer.vtable,
+ },
+ .err = null,
+ };
+ mf.writers.prepend(&w.writer_node);
+ }
+ };
+
+ pub fn location(node: *const Node) Location {
+ return switch (node.flags.location_tag) {
+ inline else => |tag| @unionInit(
+ Location,
+ @tagName(tag),
+ @field(node.location_payload, @tagName(tag)),
+ ),
+ };
+ }
+
+ pub const Writer = struct {
+ gpa: std.mem.Allocator,
+ mf: *MappedFile,
+ writer_node: std.SinglyLinkedList.Node,
+ ni: Node.Index,
+ interface: std.Io.Writer,
+ err: ?Error,
+
+ pub fn deinit(w: *Writer) void {
+ assert(w.mf.writers.popFirst() == &w.writer_node);
+ w.* = undefined;
+ }
+
+ const vtable: std.Io.Writer.VTable = .{
+ .drain = drain,
+ .sendFile = sendFile,
+ .flush = std.Io.Writer.noopFlush,
+ .rebase = growingRebase,
+ };
+
+ fn drain(
+ interface: *std.Io.Writer,
+ data: []const []const u8,
+ splat: usize,
+ ) std.Io.Writer.Error!usize {
+ const pattern = data[data.len - 1];
+ const splat_len = pattern.len * splat;
+ const start_len = interface.end;
+ assert(data.len != 0);
+ for (data) |bytes| {
+ try growingRebase(interface, interface.end, bytes.len + splat_len + 1);
+ @memcpy(interface.buffer[interface.end..][0..bytes.len], bytes);
+ interface.end += bytes.len;
+ }
+ if (splat == 0) {
+ interface.end -= pattern.len;
+ } else switch (pattern.len) {
+ 0 => {},
+ 1 => {
+ @memset(interface.buffer[interface.end..][0 .. splat - 1], pattern[0]);
+ interface.end += splat - 1;
+ },
+ else => for (0..splat - 1) |_| {
+ @memcpy(interface.buffer[interface.end..][0..pattern.len], pattern);
+ interface.end += pattern.len;
+ },
+ }
+ return interface.end - start_len;
+ }
+
+ fn sendFile(
+ interface: *std.Io.Writer,
+ file_reader: *std.fs.File.Reader,
+ limit: std.Io.Limit,
+ ) std.Io.Writer.FileError!usize {
+ if (limit == .nothing) return 0;
+ const pos = file_reader.logicalPos();
+ const additional = if (file_reader.getSize()) |size| size - pos else |_| std.atomic.cache_line;
+ if (additional == 0) return error.EndOfStream;
+ try growingRebase(interface, interface.end, limit.minInt64(additional));
+ switch (file_reader.mode) {
+ .positional => {
+ const fr_buf = file_reader.interface.buffered();
+ const buf_copy_size = interface.write(fr_buf) catch unreachable;
+ file_reader.interface.toss(buf_copy_size);
+ if (buf_copy_size < fr_buf.len) return buf_copy_size;
+ assert(file_reader.logicalPos() == file_reader.pos);
+
+ const w: *Writer = @fieldParentPtr("interface", interface);
+ const copy_size: usize = @intCast(w.mf.copyFileRange(
+ file_reader.file,
+ file_reader.pos,
+ w.ni.fileLocation(w.mf, true).offset + interface.end,
+ limit.minInt(interface.unusedCapacityLen()),
+ ) catch |err| {
+ w.err = err;
+ return error.WriteFailed;
+ });
+ interface.end += copy_size;
+ return copy_size;
+ },
+ .streaming,
+ .streaming_reading,
+ .positional_reading,
+ .failure,
+ => {
+ const dest = limit.slice(interface.unusedCapacitySlice());
+ const n = try file_reader.read(dest);
+ interface.end += n;
+ return n;
+ },
+ }
+ }
+
+ fn growingRebase(
+ interface: *std.Io.Writer,
+ preserve: usize,
+ unused_capacity: usize,
+ ) std.Io.Writer.Error!void {
+ _ = preserve;
+ const total_capacity = interface.end + unused_capacity;
+ if (interface.buffer.len >= total_capacity) return;
+ const w: *Writer = @fieldParentPtr("interface", interface);
+ w.ni.resize(w.mf, w.gpa, total_capacity +| total_capacity / 2) catch |err| {
+ w.err = err;
+ return error.WriteFailed;
+ };
+ }
+ };
+
+ comptime {
+ if (!std.debug.runtime_safety) std.debug.assert(@sizeOf(Node) == 32);
+ }
+};
+
+fn addNode(mf: *MappedFile, gpa: std.mem.Allocator, opts: struct {
+ parent: Node.Index = .none,
+ prev: Node.Index = .none,
+ next: Node.Index = .none,
+ offset: u64 = 0,
+ add_node: AddNodeOptions,
+}) !Node.Index {
+ if (opts.add_node.moved or opts.add_node.resized) try mf.updates.ensureUnusedCapacity(gpa, 1);
+ const offset = opts.add_node.alignment.forward(@intCast(opts.offset));
+ const location_tag: Node.Location.Tag, const location_payload: Node.Location.Payload = location: {
+ if (std.math.cast(u32, offset)) |small_offset| break :location .{ .small, .{
+ .small = .{ .offset = small_offset, .size = 0 },
+ } };
+ try mf.large.ensureUnusedCapacity(gpa, 2);
+ defer mf.large.appendSliceAssumeCapacity(&.{ offset, 0 });
+ break :location .{ .large, .{ .large = .{ .index = mf.large.items.len } } };
+ };
+ const free_ni: Node.Index, const free_node = free: switch (mf.free_ni) {
+ .none => .{ @enumFromInt(mf.nodes.items.len), mf.nodes.addOneAssumeCapacity() },
+ else => |free_ni| {
+ const free_node = free_ni.get(mf);
+ mf.free_ni = free_node.next;
+ break :free .{ free_ni, free_node };
+ },
+ };
+ free_node.* = .{
+ .parent = opts.parent,
+ .prev = opts.prev,
+ .next = opts.next,
+ .first = .none,
+ .last = .none,
+ .flags = .{
+ .location_tag = location_tag,
+ .alignment = opts.add_node.alignment,
+ .fixed = opts.add_node.fixed,
+ .moved = true,
+ .resized = true,
+ .has_content = false,
+ },
+ .location_payload = location_payload,
+ };
+ {
+ defer {
+ free_node.flags.moved = false;
+ free_node.flags.resized = false;
+ }
+ if (offset > opts.parent.location(mf).resolve(mf)[1]) try opts.parent.resize(mf, gpa, offset);
+ try free_ni.resize(mf, gpa, opts.add_node.size);
+ }
+ if (opts.add_node.moved) free_ni.movedAssumeCapacity(mf);
+ if (opts.add_node.resized) free_ni.resizedAssumeCapacity(mf);
+ return free_ni;
+}
+
+pub const AddNodeOptions = struct {
+ size: u64 = 0,
+ alignment: std.mem.Alignment = .@"1",
+ fixed: bool = false,
+ moved: bool = false,
+ resized: bool = false,
+};
+
+pub fn addOnlyChildNode(
+ mf: *MappedFile,
+ gpa: std.mem.Allocator,
+ parent_ni: Node.Index,
+ opts: AddNodeOptions,
+) !Node.Index {
+ try mf.nodes.ensureUnusedCapacity(gpa, 1);
+ const parent = parent_ni.get(mf);
+ assert(parent.first == .none and parent.last == .none);
+ const ni = try mf.addNode(gpa, .{
+ .parent = parent_ni,
+ .add_node = opts,
+ });
+ parent.first = ni;
+ parent.last = ni;
+ return ni;
+}
+
+pub fn addLastChildNode(
+ mf: *MappedFile,
+ gpa: std.mem.Allocator,
+ parent_ni: Node.Index,
+ opts: AddNodeOptions,
+) !Node.Index {
+ try mf.nodes.ensureUnusedCapacity(gpa, 1);
+ const parent = parent_ni.get(mf);
+ const ni = try mf.addNode(gpa, .{
+ .parent = parent_ni,
+ .prev = parent.last,
+ .offset = offset: switch (parent.last) {
+ .none => 0,
+ else => |last_ni| {
+ const last_offset, const last_size = last_ni.location(mf).resolve(mf);
+ break :offset last_offset + last_size;
+ },
+ },
+ .add_node = opts,
+ });
+ switch (parent.last) {
+ .none => parent.first = ni,
+ else => |last_ni| last_ni.get(mf).next = ni,
+ }
+ parent.last = ni;
+ return ni;
+}
+
+pub fn addNodeAfter(
+ mf: *MappedFile,
+ gpa: std.mem.Allocator,
+ prev_ni: Node.Index,
+ opts: AddNodeOptions,
+) !Node.Index {
+ assert(prev_ni != .none);
+ try mf.nodes.ensureUnusedCapacity(gpa, 1);
+ const prev = prev_ni.get(mf);
+ const prev_offset, const prev_size = prev.location().resolve(mf);
+ const ni = try mf.addNode(gpa, .{
+ .parent = prev.parent,
+ .prev = prev_ni,
+ .next = prev.next,
+ .offset = prev_offset + prev_size,
+ .add_node = opts,
+ });
+ switch (prev.next) {
+ .none => prev.parent.get(mf).last = ni,
+ else => |next_ni| next_ni.get(mf).prev = ni,
+ }
+ prev.next = ni;
+ return ni;
+}
+
+fn resizeNode(mf: *MappedFile, gpa: std.mem.Allocator, ni: Node.Index, requested_size: u64) !void {
+ const node = ni.get(mf);
+ var old_offset, const old_size = node.location().resolve(mf);
+ const new_size = node.flags.alignment.forward(@intCast(requested_size));
+ // Resize the entire file
+ if (ni == Node.Index.root) {
+ try mf.file.setEndPos(new_size);
+ try mf.ensureTotalCapacity(@intCast(new_size));
+ try mf.ensureCapacityForSetLocation(gpa);
+ ni.setLocationAssumeCapacity(mf, old_offset, new_size);
+ return;
+ }
+ while (true) {
+ const parent = node.parent.get(mf);
+ _, const old_parent_size = parent.location().resolve(mf);
+ const trailing_end = switch (node.next) {
+ .none => parent.location().resolve(mf)[1],
+ else => |next_ni| next_ni.location(mf).resolve(mf)[0],
+ };
+ assert(old_offset + old_size <= trailing_end);
+ // Expand the node into available trailing free space
+ if (old_offset + new_size <= trailing_end) {
+ try mf.ensureCapacityForSetLocation(gpa);
+ ni.setLocationAssumeCapacity(mf, old_offset, new_size);
+ return;
+ }
+ // Ask the filesystem driver to insert an extent into the file without copying any data
+ if (is_linux and !mf.flags.fallocate_insert_range_unsupported and
+ node.flags.alignment.order(mf.flags.block_size).compare(.gte))
+ insert_range: {
+ const last_offset, const last_size = parent.last.location(mf).resolve(mf);
+ const last_end = last_offset + last_size;
+ assert(last_end <= old_parent_size);
+ const range_size =
+ node.flags.alignment.forward(@intCast(requested_size +| requested_size / 2)) - old_size;
+ const new_parent_size = last_end + range_size;
+ if (new_parent_size > old_parent_size) {
+ try mf.resizeNode(gpa, node.parent, new_parent_size +| new_parent_size / 2);
+ continue;
+ }
+ const range_file_offset = ni.fileLocation(mf, false).offset + old_size;
+ retry: while (true) {
+ switch (linux.E.init(linux.fallocate(
+ mf.file.handle,
+ linux.FALLOC.FL_INSERT_RANGE,
+ @intCast(range_file_offset),
+ @intCast(range_size),
+ ))) {
+ .SUCCESS => {
+ var enclosing_ni = ni;
+ while (enclosing_ni != .none) {
+ try mf.ensureCapacityForSetLocation(gpa);
+ const enclosing = enclosing_ni.get(mf);
+ const enclosing_offset, const enclosing_size =
+ enclosing.location().resolve(mf);
+ enclosing_ni.setLocationAssumeCapacity(
+ mf,
+ enclosing_offset,
+ enclosing_size + range_size,
+ );
+ var after_ni = enclosing.next;
+ while (after_ni != .none) {
+ try mf.ensureCapacityForSetLocation(gpa);
+ const after = after_ni.get(mf);
+ const after_offset, const after_size = after.location().resolve(mf);
+ after_ni.setLocationAssumeCapacity(
+ mf,
+ range_size + after_offset,
+ after_size,
+ );
+ after_ni = after.next;
+ }
+ enclosing_ni = enclosing.parent;
+ }
+ return;
+ },
+ .INTR => continue :retry,
+ .BADF, .FBIG, .INVAL => unreachable,
+ .IO => return error.InputOutput,
+ .NODEV => return error.NotFile,
+ .NOSPC => return error.NoSpaceLeft,
+ .NOSYS, .OPNOTSUPP => {
+ mf.flags.fallocate_insert_range_unsupported = true;
+ break :insert_range;
+ },
+ .PERM => return error.PermissionDenied,
+ .SPIPE => return error.Unseekable,
+ .TXTBSY => return error.FileBusy,
+ else => |e| return std.posix.unexpectedErrno(e),
+ }
+ }
+ }
+ switch (node.next) {
+ .none => {
+ // As this is the last node, we simply need more space in the parent
+ const new_parent_size = old_offset + new_size;
+ try mf.resizeNode(gpa, node.parent, new_parent_size +| new_parent_size / 2);
+ },
+ else => |*next_ni_ptr| switch (node.flags.fixed) {
+ false => {
+ // Make space at the end of the parent for this floating node
+ const last = parent.last.get(mf);
+ const last_offset, const last_size = last.location().resolve(mf);
+ const new_offset = node.flags.alignment.forward(@intCast(last_offset + last_size));
+ const new_parent_size = new_offset + new_size;
+ if (new_parent_size > old_parent_size) {
+ try mf.resizeNode(
+ gpa,
+ node.parent,
+ new_parent_size +| new_parent_size / 2,
+ );
+ continue;
+ }
+ const next_ni = next_ni_ptr.*;
+ next_ni.get(mf).prev = node.prev;
+ switch (node.prev) {
+ .none => parent.first = next_ni,
+ else => |prev_ni| prev_ni.get(mf).next = next_ni,
+ }
+ last.next = ni;
+ node.prev = parent.last;
+ next_ni_ptr.* = .none;
+ parent.last = ni;
+ if (node.flags.has_content) {
+ const parent_file_offset = node.parent.fileLocation(mf, false).offset;
+ try mf.moveRange(
+ parent_file_offset + old_offset,
+ parent_file_offset + new_offset,
+ old_size,
+ );
+ }
+ old_offset = new_offset;
+ },
+ true => {
+ // Move the next floating node to make space for this fixed node
+ const next_ni = next_ni_ptr.*;
+ const next = next_ni.get(mf);
+ assert(!next.flags.fixed);
+ const next_offset, const next_size = next.location().resolve(mf);
+ const last = parent.last.get(mf);
+ const last_offset, const last_size = last.location().resolve(mf);
+ const new_offset = next.flags.alignment.forward(@intCast(
+ @max(old_offset + new_size, last_offset + last_size),
+ ));
+ const new_parent_size = new_offset + next_size;
+ if (new_parent_size > old_parent_size) {
+ try mf.resizeNode(
+ gpa,
+ node.parent,
+ new_parent_size +| new_parent_size / 2,
+ );
+ continue;
+ }
+ try mf.ensureCapacityForSetLocation(gpa);
+ next.prev = parent.last;
+ parent.last = next_ni;
+ last.next = next_ni;
+ next_ni_ptr.* = next.next;
+ switch (next.next) {
+ .none => {},
+ else => |next_next_ni| next_next_ni.get(mf).prev = ni,
+ }
+ next.next = .none;
+ if (node.flags.has_content) {
+ const parent_file_offset = node.parent.fileLocation(mf, false).offset;
+ try mf.moveRange(
+ parent_file_offset + next_offset,
+ parent_file_offset + new_offset,
+ next_size,
+ );
+ }
+ next_ni.setLocationAssumeCapacity(mf, new_offset, next_size);
+ },
+ },
+ }
+ }
+}
+
+fn moveRange(mf: *MappedFile, old_file_offset: u64, new_file_offset: u64, size: u64) !void {
+ // make a copy of this node at the new location
+ try mf.copyRange(old_file_offset, new_file_offset, size);
+ // delete the copy of this node at the old location
+ if (is_linux and !mf.flags.fallocate_punch_hole_unsupported and
+ size >= mf.flags.block_size.toByteUnits() * 2 - 1) while (true)
+ {
+ switch (linux.E.init(linux.fallocate(
+ mf.file.handle,
+ linux.FALLOC.FL_PUNCH_HOLE | linux.FALLOC.FL_KEEP_SIZE,
+ @intCast(old_file_offset),
+ @intCast(size),
+ ))) {
+ .SUCCESS => return,
+ .INTR => continue,
+ .BADF, .FBIG, .INVAL => unreachable,
+ .IO => return error.InputOutput,
+ .NODEV => return error.NotFile,
+ .NOSPC => return error.NoSpaceLeft,
+ .NOSYS, .OPNOTSUPP => {
+ mf.flags.fallocate_punch_hole_unsupported = true;
+ break;
+ },
+ .PERM => return error.PermissionDenied,
+ .SPIPE => return error.Unseekable,
+ .TXTBSY => return error.FileBusy,
+ else => |e| return std.posix.unexpectedErrno(e),
+ }
+ };
+ @memset(mf.contents[@intCast(old_file_offset)..][0..@intCast(size)], 0);
+}
+
+fn copyRange(mf: *MappedFile, old_file_offset: u64, new_file_offset: u64, size: u64) !void {
+ const copy_size = try mf.copyFileRange(mf.file, old_file_offset, new_file_offset, size);
+ if (copy_size < size) @memcpy(
+ mf.contents[@intCast(new_file_offset + copy_size)..][0..@intCast(size - copy_size)],
+ mf.contents[@intCast(old_file_offset + copy_size)..][0..@intCast(size - copy_size)],
+ );
+}
+
+fn copyFileRange(
+ mf: *MappedFile,
+ old_file: std.fs.File,
+ old_file_offset: u64,
+ new_file_offset: u64,
+ size: u64,
+) !u64 {
+ var remaining_size = size;
+ if (is_linux and !mf.flags.copy_file_range_unsupported) {
+ var old_file_offset_mut: i64 = @intCast(old_file_offset);
+ var new_file_offset_mut: i64 = @intCast(new_file_offset);
+ while (remaining_size >= mf.flags.block_size.toByteUnits() * 2 - 1) {
+ const copy_len = linux.copy_file_range(
+ old_file.handle,
+ &old_file_offset_mut,
+ mf.file.handle,
+ &new_file_offset_mut,
+ @intCast(remaining_size),
+ 0,
+ );
+ switch (linux.E.init(copy_len)) {
+ .SUCCESS => {
+ if (copy_len == 0) break;
+ remaining_size -= copy_len;
+ if (remaining_size == 0) break;
+ },
+ .INTR => continue,
+ .BADF, .FBIG, .INVAL, .OVERFLOW => unreachable,
+ .IO => return error.InputOutput,
+ .ISDIR => return error.IsDir,
+ .NOMEM => return error.SystemResources,
+ .NOSPC => return error.NoSpaceLeft,
+ .NOSYS, .OPNOTSUPP, .XDEV => {
+ mf.flags.copy_file_range_unsupported = true;
+ break;
+ },
+ .PERM => return error.PermissionDenied,
+ .TXTBSY => return error.FileBusy,
+ else => |e| return std.posix.unexpectedErrno(e),
+ }
+ }
+ }
+ return size - remaining_size;
+}
+
+fn ensureCapacityForSetLocation(mf: *MappedFile, gpa: std.mem.Allocator) !void {
+ try mf.large.ensureUnusedCapacity(gpa, 2);
+ try mf.updates.ensureUnusedCapacity(gpa, 1);
+}
+
+pub fn ensureTotalCapacity(mf: *MappedFile, new_capacity: usize) !void {
+ if (mf.contents.len >= new_capacity) return;
+ try mf.ensureTotalCapacityPrecise(new_capacity +| new_capacity / 2);
+}
+
+pub fn ensureTotalCapacityPrecise(mf: *MappedFile, new_capacity: usize) !void {
+ if (mf.contents.len >= new_capacity) return;
+ const aligned_capacity = mf.flags.block_size.forward(new_capacity);
+ if (!is_linux) mf.unmap() else if (mf.contents.len > 0) {
+ mf.contents = try std.posix.mremap(
+ mf.contents.ptr,
+ mf.contents.len,
+ aligned_capacity,
+ .{ .MAYMOVE = true },
+ null,
+ );
+ return;
+ }
+ if (is_windows) {
+ if (mf.section == windows.INVALID_HANDLE_VALUE) switch (windows.ntdll.NtCreateSection(
+ &mf.section,
+ windows.STANDARD_RIGHTS_REQUIRED | windows.SECTION_QUERY |
+ windows.SECTION_MAP_WRITE | windows.SECTION_MAP_READ | windows.SECTION_EXTEND_SIZE,
+ null,
+ @constCast(&@as(i64, @intCast(aligned_capacity))),
+ windows.PAGE_READWRITE,
+ windows.SEC_COMMIT,
+ mf.file.handle,
+ )) {
+ .SUCCESS => {},
+ else => return error.MemoryMappingNotSupported,
+ };
+ var contents_ptr: ?[*]align(std.heap.page_size_min) u8 = null;
+ var contents_len = aligned_capacity;
+ switch (windows.ntdll.NtMapViewOfSection(
+ mf.section,
+ windows.GetCurrentProcess(),
+ @ptrCast(&contents_ptr),
+ null,
+ 0,
+ null,
+ &contents_len,
+ .ViewUnmap,
+ 0,
+ windows.PAGE_READWRITE,
+ )) {
+ .SUCCESS => mf.contents = contents_ptr.?[0..contents_len],
+ else => return error.MemoryMappingNotSupported,
+ }
+ } else mf.contents = try std.posix.mmap(
+ null,
+ aligned_capacity,
+ std.posix.PROT.READ | std.posix.PROT.WRITE,
+ .{ .TYPE = if (is_linux) .SHARED_VALIDATE else .SHARED },
+ mf.file.handle,
+ 0,
+ );
+}
+
+pub fn unmap(mf: *MappedFile) void {
+ if (mf.contents.len == 0) return;
+ if (is_windows)
+ _ = windows.ntdll.NtUnmapViewOfSection(windows.GetCurrentProcess(), mf.contents.ptr)
+ else
+ std.posix.munmap(mf.contents);
+ mf.contents = &.{};
+ if (is_windows and mf.section != windows.INVALID_HANDLE_VALUE) {
+ windows.CloseHandle(mf.section);
+ mf.section = windows.INVALID_HANDLE_VALUE;
+ }
+}
+
+fn verify(mf: *MappedFile) void {
+ const root = Node.Index.root.get(mf);
+ assert(root.parent == .none);
+ assert(root.prev == .none);
+ assert(root.next == .none);
+ mf.verifyNode(Node.Index.root);
+}
+
+fn verifyNode(mf: *MappedFile, parent_ni: Node.Index) void {
+ const parent = parent_ni.get(mf);
+ const parent_offset, const parent_size = parent.location().resolve(mf);
+ var prev_ni: Node.Index = .none;
+ var prev_end: u64 = 0;
+ var ni = parent.first;
+ while (true) {
+ if (ni == .none) {
+ assert(parent.last == prev_ni);
+ return;
+ }
+ const node = ni.get(mf);
+ assert(node.parent == parent_ni);
+ const offset, const size = node.location().resolve(mf);
+ assert(node.flags.alignment.check(@intCast(offset)));
+ assert(node.flags.alignment.check(@intCast(size)));
+ const end = offset + size;
+ assert(end <= parent_offset + parent_size);
+ assert(offset >= prev_end);
+ assert(node.prev == prev_ni);
+ mf.verifyNode(ni);
+ prev_ni = ni;
+ prev_end = end;
+ ni = node.next;
+ }
+}
+
+const assert = std.debug.assert;
+const builtin = @import("builtin");
+const is_linux = builtin.os.tag == .linux;
+const is_windows = builtin.os.tag == .windows;
+const linux = std.os.linux;
+const MappedFile = @This();
+const std = @import("std");
+const windows = std.os.windows;
src/link/Queue.zig
@@ -22,17 +22,17 @@ prelink_wait_count: u32,
/// Prelink tasks which have been enqueued and are not yet owned by the worker thread.
/// Allocated into `gpa`, guarded by `mutex`.
-queued_prelink: std.ArrayListUnmanaged(PrelinkTask),
+queued_prelink: std.ArrayList(PrelinkTask),
/// The worker thread moves items from `queued_prelink` into this array in order to process them.
/// Allocated into `gpa`, accessed only by the worker thread.
-wip_prelink: std.ArrayListUnmanaged(PrelinkTask),
+wip_prelink: std.ArrayList(PrelinkTask),
/// Like `queued_prelink`, but for ZCU tasks.
/// Allocated into `gpa`, guarded by `mutex`.
-queued_zcu: std.ArrayListUnmanaged(ZcuTask),
+queued_zcu: std.ArrayList(ZcuTask),
/// Like `wip_prelink`, but for ZCU tasks.
/// Allocated into `gpa`, accessed only by the worker thread.
-wip_zcu: std.ArrayListUnmanaged(ZcuTask),
+wip_zcu: std.ArrayList(ZcuTask),
/// When processing ZCU link tasks, we might have to block due to unpopulated MIR. When this
/// happens, some tasks in `wip_zcu` have been run, and some are still pending. This is the
@@ -213,32 +213,41 @@ pub fn enqueueZcu(q: *Queue, comp: *Compilation, task: ZcuTask) Allocator.Error!
fn flushTaskQueue(tid: usize, q: *Queue, comp: *Compilation) void {
q.flush_safety.lock(); // every `return` site should unlock this before unlocking `q.mutex`
-
if (std.debug.runtime_safety) {
q.mutex.lock();
defer q.mutex.unlock();
assert(q.state == .running);
}
+
+ var have_idle_tasks = true;
prelink: while (true) {
assert(q.wip_prelink.items.len == 0);
- {
- q.mutex.lock();
- defer q.mutex.unlock();
- std.mem.swap(std.ArrayListUnmanaged(PrelinkTask), &q.queued_prelink, &q.wip_prelink);
- if (q.wip_prelink.items.len == 0) {
- if (q.prelink_wait_count == 0) {
- break :prelink; // prelink is done
- } else {
+ swap_queues: while (true) {
+ {
+ q.mutex.lock();
+ defer q.mutex.unlock();
+ std.mem.swap(std.ArrayList(PrelinkTask), &q.queued_prelink, &q.wip_prelink);
+ if (q.wip_prelink.items.len > 0) break :swap_queues;
+ if (q.prelink_wait_count == 0) break :prelink; // prelink is done
+ if (!have_idle_tasks) {
// We're expecting more prelink tasks so can't move on to ZCU tasks.
q.state = .finished;
q.flush_safety.unlock();
return;
}
}
+ have_idle_tasks = link.doIdleTask(comp, tid) catch |err| switch (err) {
+ error.OutOfMemory => have_idle_tasks: {
+ comp.link_diags.setAllocFailure();
+ break :have_idle_tasks false;
+ },
+ error.LinkFailure => false,
+ };
}
for (q.wip_prelink.items) |task| {
link.doPrelinkTask(comp, task);
}
+ have_idle_tasks = true;
q.wip_prelink.clearRetainingCapacity();
}
@@ -256,17 +265,29 @@ fn flushTaskQueue(tid: usize, q: *Queue, comp: *Compilation) void {
// Now we can run ZCU tasks.
while (true) {
- if (q.wip_zcu.items.len == q.wip_zcu_idx) {
+ if (q.wip_zcu.items.len == q.wip_zcu_idx) swap_queues: {
q.wip_zcu.clearRetainingCapacity();
q.wip_zcu_idx = 0;
- q.mutex.lock();
- defer q.mutex.unlock();
- std.mem.swap(std.ArrayListUnmanaged(ZcuTask), &q.queued_zcu, &q.wip_zcu);
- if (q.wip_zcu.items.len == 0) {
- // We've exhausted all available tasks.
- q.state = .finished;
- q.flush_safety.unlock();
- return;
+ while (true) {
+ {
+ q.mutex.lock();
+ defer q.mutex.unlock();
+ std.mem.swap(std.ArrayList(ZcuTask), &q.queued_zcu, &q.wip_zcu);
+ if (q.wip_zcu.items.len > 0) break :swap_queues;
+ if (!have_idle_tasks) {
+ // We've exhausted all available tasks.
+ q.state = .finished;
+ q.flush_safety.unlock();
+ return;
+ }
+ }
+ have_idle_tasks = link.doIdleTask(comp, tid) catch |err| switch (err) {
+ error.OutOfMemory => have_idle_tasks: {
+ comp.link_diags.setAllocFailure();
+ break :have_idle_tasks false;
+ },
+ error.LinkFailure => false,
+ };
}
}
const task = q.wip_zcu.items[q.wip_zcu_idx];
@@ -274,8 +295,18 @@ fn flushTaskQueue(tid: usize, q: *Queue, comp: *Compilation) void {
pending: {
if (task != .link_func) break :pending;
const status_ptr = &task.link_func.mir.status;
- // First check without the mutex to optimize for the common case where MIR is ready.
- if (status_ptr.load(.acquire) != .pending) break :pending;
+ while (true) {
+ // First check without the mutex to optimize for the common case where MIR is ready.
+ if (status_ptr.load(.acquire) != .pending) break :pending;
+ if (have_idle_tasks) have_idle_tasks = link.doIdleTask(comp, tid) catch |err| switch (err) {
+ error.OutOfMemory => have_idle_tasks: {
+ comp.link_diags.setAllocFailure();
+ break :have_idle_tasks false;
+ },
+ error.LinkFailure => false,
+ };
+ if (!have_idle_tasks) break;
+ }
q.mutex.lock();
defer q.mutex.unlock();
if (status_ptr.load(.acquire) != .pending) break :pending;
@@ -298,6 +329,7 @@ fn flushTaskQueue(tid: usize, q: *Queue, comp: *Compilation) void {
}
}
q.wip_zcu_idx += 1;
+ have_idle_tasks = true;
}
}
src/link/Wasm.zig
@@ -4257,7 +4257,14 @@ fn lowerZcuData(wasm: *Wasm, pt: Zcu.PerThread, ip_index: InternPool.Index) !Zcu
const func_table_fixups_start: u32 = @intCast(wasm.func_table_fixups.items.len);
wasm.string_bytes_lock.lock();
- try codegen.generateSymbol(&wasm.base, pt, .unneeded, .fromInterned(ip_index), &wasm.string_bytes, .none);
+ {
+ var aw: std.Io.Writer.Allocating = .fromArrayList(wasm.base.comp.gpa, &wasm.string_bytes);
+ defer wasm.string_bytes = aw.toArrayList();
+ codegen.generateSymbol(&wasm.base, pt, .unneeded, .fromInterned(ip_index), &aw.writer, .none) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ else => |e| return e,
+ };
+ }
const code_len: u32 = @intCast(wasm.string_bytes.items.len - code_start);
const relocs_len: u32 = @intCast(wasm.out_relocs.len - relocs_start);
src/Zcu/PerThread.zig
@@ -1815,7 +1815,7 @@ fn createFileRootStruct(
wip_ty.setName(ip, try file.internFullyQualifiedName(pt), .none);
ip.namespacePtr(namespace_index).owner_type = wip_ty.index;
- if (zcu.comp.incremental) {
+ if (zcu.comp.config.incremental) {
try pt.addDependency(.wrap(.{ .type = wip_ty.index }), .{ .src_hash = tracked_inst });
}
src/codegen.zig
@@ -6,7 +6,6 @@ const link = @import("link.zig");
const log = std.log.scoped(.codegen);
const mem = std.mem;
const math = std.math;
-const ArrayList = std.ArrayList;
const target_util = @import("target.zig");
const trace = @import("tracy.zig").trace;
@@ -179,10 +178,11 @@ pub fn emitFunction(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
func_index: InternPool.Index,
+ atom_index: u32,
any_mir: *const AnyMir,
- code: *ArrayList(u8),
+ w: *std.Io.Writer,
debug_output: link.File.DebugInfoOutput,
-) CodeGenError!void {
+) (CodeGenError || std.Io.Writer.Error)!void {
const zcu = pt.zcu;
const func = zcu.funcInfo(func_index);
const target = &zcu.navFileScope(func.owner_nav).mod.?.resolved_target.result;
@@ -195,7 +195,7 @@ pub fn emitFunction(
=> |backend| {
dev.check(devFeatureForBackend(backend));
const mir = &@field(any_mir, AnyMir.tag(backend));
- return mir.emit(lf, pt, src_loc, func_index, code, debug_output);
+ return mir.emit(lf, pt, src_loc, func_index, atom_index, w, debug_output);
},
}
}
@@ -205,9 +205,10 @@ pub fn generateLazyFunction(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
lazy_sym: link.File.LazySymbol,
- code: *ArrayList(u8),
+ atom_index: u32,
+ w: *std.Io.Writer,
debug_output: link.File.DebugInfoOutput,
-) CodeGenError!void {
+) (CodeGenError || std.Io.Writer.Error)!void {
const zcu = pt.zcu;
const target = if (Type.fromInterned(lazy_sym.ty).typeDeclInstAllowGeneratedTag(zcu)) |inst_index|
&zcu.fileByIndex(inst_index.resolveFile(&zcu.intern_pool)).mod.?.resolved_target.result
@@ -217,19 +218,11 @@ pub fn generateLazyFunction(
else => unreachable,
inline .stage2_riscv64, .stage2_x86_64 => |backend| {
dev.check(devFeatureForBackend(backend));
- return importBackend(backend).generateLazy(lf, pt, src_loc, lazy_sym, code, debug_output);
+ return importBackend(backend).generateLazy(lf, pt, src_loc, lazy_sym, atom_index, w, debug_output);
},
}
}
-fn writeFloat(comptime F: type, f: F, target: *const std.Target, endian: std.builtin.Endian, code: []u8) void {
- _ = target;
- const bits = @typeInfo(F).float.bits;
- const Int = @Type(.{ .int = .{ .signedness = .unsigned, .bits = bits } });
- const int: Int = @bitCast(f);
- mem.writeInt(Int, code[0..@divExact(bits, 8)], int, endian);
-}
-
pub fn generateLazySymbol(
bin_file: *link.File,
pt: Zcu.PerThread,
@@ -237,17 +230,14 @@ pub fn generateLazySymbol(
lazy_sym: link.File.LazySymbol,
// TODO don't use an "out" parameter like this; put it in the result instead
alignment: *Alignment,
- code: *ArrayList(u8),
+ w: *std.Io.Writer,
debug_output: link.File.DebugInfoOutput,
reloc_parent: link.File.RelocInfo.Parent,
-) CodeGenError!void {
- _ = reloc_parent;
-
+) (CodeGenError || std.Io.Writer.Error)!void {
const tracy = trace(@src());
defer tracy.end();
const comp = bin_file.comp;
- const gpa = comp.gpa;
const zcu = pt.zcu;
const ip = &zcu.intern_pool;
const target = &comp.root_mod.resolved_target.result;
@@ -260,37 +250,36 @@ pub fn generateLazySymbol(
if (lazy_sym.kind == .code) {
alignment.* = target_util.defaultFunctionAlignment(target);
- return generateLazyFunction(bin_file, pt, src_loc, lazy_sym, code, debug_output);
+ return generateLazyFunction(bin_file, pt, src_loc, lazy_sym, reloc_parent.atom_index, w, debug_output);
}
if (lazy_sym.ty == .anyerror_type) {
alignment.* = .@"4";
const err_names = ip.global_error_set.getNamesFromMainThread();
- var offset_index: u32 = @intCast(code.items.len);
- var string_index: u32 = @intCast(4 * (1 + err_names.len + @intFromBool(err_names.len > 0)));
- try code.resize(gpa, offset_index + string_index);
- mem.writeInt(u32, code.items[offset_index..][0..4], @intCast(err_names.len), endian);
+ const strings_start: u32 = @intCast(4 * (1 + err_names.len + @intFromBool(err_names.len > 0)));
+ var string_index = strings_start;
+ try w.rebase(w.end, string_index);
+ w.writeInt(u32, @intCast(err_names.len), endian) catch unreachable;
if (err_names.len == 0) return;
- offset_index += 4;
for (err_names) |err_name_nts| {
- const err_name = err_name_nts.toSlice(ip);
- mem.writeInt(u32, code.items[offset_index..][0..4], string_index, endian);
- offset_index += 4;
- try code.ensureUnusedCapacity(gpa, err_name.len + 1);
- code.appendSliceAssumeCapacity(err_name);
- code.appendAssumeCapacity(0);
- string_index += @intCast(err_name.len + 1);
+ w.writeInt(u32, string_index, endian) catch unreachable;
+ string_index += @intCast(err_name_nts.toSlice(ip).len + 1);
+ }
+ w.writeInt(u32, string_index, endian) catch unreachable;
+ try w.rebase(w.end, string_index - strings_start);
+ for (err_names) |err_name_nts| {
+ w.writeAll(err_name_nts.toSlice(ip)) catch unreachable;
+ w.writeByte(0) catch unreachable;
}
- mem.writeInt(u32, code.items[offset_index..][0..4], string_index, endian);
} else if (Type.fromInterned(lazy_sym.ty).zigTypeTag(zcu) == .@"enum") {
alignment.* = .@"1";
const enum_ty = Type.fromInterned(lazy_sym.ty);
const tag_names = enum_ty.enumFields(zcu);
for (0..tag_names.len) |tag_index| {
const tag_name = tag_names.get(ip)[tag_index].toSlice(ip);
- try code.ensureUnusedCapacity(gpa, tag_name.len + 1);
- code.appendSliceAssumeCapacity(tag_name);
- code.appendAssumeCapacity(0);
+ try w.rebase(w.end, tag_name.len + 1);
+ w.writeAll(tag_name) catch unreachable;
+ w.writeByte(0) catch unreachable;
}
} else {
return zcu.codegenFailType(lazy_sym.ty, "TODO implement generateLazySymbol for {s} {f}", .{
@@ -312,14 +301,13 @@ pub fn generateSymbol(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
val: Value,
- code: *ArrayList(u8),
+ w: *std.Io.Writer,
reloc_parent: link.File.RelocInfo.Parent,
-) GenerateSymbolError!void {
+) (GenerateSymbolError || std.Io.Writer.Error)!void {
const tracy = trace(@src());
defer tracy.end();
const zcu = pt.zcu;
- const gpa = zcu.gpa;
const ip = &zcu.intern_pool;
const ty = val.typeOf(zcu);
@@ -330,7 +318,7 @@ pub fn generateSymbol(
if (val.isUndef(zcu)) {
const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
- try code.appendNTimes(gpa, 0xaa, abi_size);
+ try w.splatByteAll(0xaa, abi_size);
return;
}
@@ -360,7 +348,7 @@ pub fn generateSymbol(
.null => unreachable, // non-runtime value
.@"unreachable" => unreachable, // non-runtime value
.empty_tuple => return,
- .false, .true => try code.append(gpa, switch (simple_value) {
+ .false, .true => try w.writeByte(switch (simple_value) {
.false => 0,
.true => 1,
else => unreachable,
@@ -376,11 +364,11 @@ pub fn generateSymbol(
const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
var space: Value.BigIntSpace = undefined;
const int_val = val.toBigInt(&space, zcu);
- int_val.writeTwosComplement(try code.addManyAsSlice(gpa, abi_size), endian);
+ int_val.writeTwosComplement(try w.writableSlice(abi_size), endian);
},
.err => |err| {
const int = try pt.getErrorValue(err.name);
- mem.writeInt(u16, try code.addManyAsArray(gpa, 2), @intCast(int), endian);
+ try w.writeInt(u16, @intCast(int), endian);
},
.error_union => |error_union| {
const payload_ty = ty.errorUnionPayload(zcu);
@@ -390,7 +378,7 @@ pub fn generateSymbol(
};
if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
- mem.writeInt(u16, try code.addManyAsArray(gpa, 2), err_val, endian);
+ try w.writeInt(u16, err_val, endian);
return;
}
@@ -400,63 +388,63 @@ pub fn generateSymbol(
// error value first when its type is larger than the error union's payload
if (error_align.order(payload_align) == .gt) {
- mem.writeInt(u16, try code.addManyAsArray(gpa, 2), err_val, endian);
+ try w.writeInt(u16, err_val, endian);
}
// emit payload part of the error union
{
- const begin = code.items.len;
+ const begin = w.end;
try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(switch (error_union.val) {
.err_name => try pt.intern(.{ .undef = payload_ty.toIntern() }),
.payload => |payload| payload,
- }), code, reloc_parent);
- const unpadded_end = code.items.len - begin;
+ }), w, reloc_parent);
+ const unpadded_end = w.end - begin;
const padded_end = abi_align.forward(unpadded_end);
const padding = math.cast(usize, padded_end - unpadded_end) orelse return error.Overflow;
if (padding > 0) {
- try code.appendNTimes(gpa, 0, padding);
+ try w.splatByteAll(0, padding);
}
}
// Payload size is larger than error set, so emit our error set last
if (error_align.compare(.lte, payload_align)) {
- const begin = code.items.len;
- mem.writeInt(u16, try code.addManyAsArray(gpa, 2), err_val, endian);
- const unpadded_end = code.items.len - begin;
+ const begin = w.end;
+ try w.writeInt(u16, err_val, endian);
+ const unpadded_end = w.end - begin;
const padded_end = abi_align.forward(unpadded_end);
const padding = math.cast(usize, padded_end - unpadded_end) orelse return error.Overflow;
if (padding > 0) {
- try code.appendNTimes(gpa, 0, padding);
+ try w.splatByteAll(0, padding);
}
}
},
.enum_tag => |enum_tag| {
const int_tag_ty = ty.intTagType(zcu);
- try generateSymbol(bin_file, pt, src_loc, try pt.getCoerced(Value.fromInterned(enum_tag.int), int_tag_ty), code, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, try pt.getCoerced(Value.fromInterned(enum_tag.int), int_tag_ty), w, reloc_parent);
},
.float => |float| storage: switch (float.storage) {
- .f16 => |f16_val| writeFloat(f16, f16_val, target, endian, try code.addManyAsArray(gpa, 2)),
- .f32 => |f32_val| writeFloat(f32, f32_val, target, endian, try code.addManyAsArray(gpa, 4)),
- .f64 => |f64_val| writeFloat(f64, f64_val, target, endian, try code.addManyAsArray(gpa, 8)),
+ .f16 => |f16_val| try w.writeInt(u16, @bitCast(f16_val), endian),
+ .f32 => |f32_val| try w.writeInt(u32, @bitCast(f32_val), endian),
+ .f64 => |f64_val| try w.writeInt(u64, @bitCast(f64_val), endian),
.f80 => |f80_val| {
- writeFloat(f80, f80_val, target, endian, try code.addManyAsArray(gpa, 10));
+ try w.writeInt(u80, @bitCast(f80_val), endian);
const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
- try code.appendNTimes(gpa, 0, abi_size - 10);
+ try w.splatByteAll(0, abi_size - 10);
},
.f128 => |f128_val| switch (Type.fromInterned(float.ty).floatBits(target)) {
else => unreachable,
16 => continue :storage .{ .f16 = @floatCast(f128_val) },
32 => continue :storage .{ .f32 = @floatCast(f128_val) },
64 => continue :storage .{ .f64 = @floatCast(f128_val) },
- 128 => writeFloat(f128, f128_val, target, endian, try code.addManyAsArray(gpa, 16)),
+ 128 => try w.writeInt(u128, @bitCast(f128_val), endian),
},
},
- .ptr => try lowerPtr(bin_file, pt, src_loc, val.toIntern(), code, reloc_parent, 0),
+ .ptr => try lowerPtr(bin_file, pt, src_loc, val.toIntern(), w, reloc_parent, 0),
.slice => |slice| {
- try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(slice.ptr), code, reloc_parent);
- try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(slice.len), code, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(slice.ptr), w, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(slice.len), w, reloc_parent);
},
.opt => {
const payload_type = ty.optionalChild(zcu);
@@ -465,9 +453,9 @@ pub fn generateSymbol(
if (ty.optionalReprIsPayload(zcu)) {
if (payload_val) |value| {
- try generateSymbol(bin_file, pt, src_loc, value, code, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, value, w, reloc_parent);
} else {
- try code.appendNTimes(gpa, 0, abi_size);
+ try w.splatByteAll(0, abi_size);
}
} else {
const padding = abi_size - (math.cast(usize, payload_type.abiSize(zcu)) orelse return error.Overflow) - 1;
@@ -475,15 +463,15 @@ pub fn generateSymbol(
const value = payload_val orelse Value.fromInterned(try pt.intern(.{
.undef = payload_type.toIntern(),
}));
- try generateSymbol(bin_file, pt, src_loc, value, code, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, value, w, reloc_parent);
}
- try code.append(gpa, @intFromBool(payload_val != null));
- try code.appendNTimes(gpa, 0, padding);
+ try w.writeByte(@intFromBool(payload_val != null));
+ try w.splatByteAll(0, padding);
}
},
.aggregate => |aggregate| switch (ip.indexToKey(ty.toIntern())) {
.array_type => |array_type| switch (aggregate.storage) {
- .bytes => |bytes| try code.appendSlice(gpa, bytes.toSlice(array_type.lenIncludingSentinel(), ip)),
+ .bytes => |bytes| try w.writeAll(bytes.toSlice(array_type.lenIncludingSentinel(), ip)),
.elems, .repeated_elem => {
var index: u64 = 0;
while (index < array_type.lenIncludingSentinel()) : (index += 1) {
@@ -494,14 +482,14 @@ pub fn generateSymbol(
elem
else
array_type.sentinel,
- }), code, reloc_parent);
+ }), w, reloc_parent);
}
},
},
.vector_type => |vector_type| {
const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
if (vector_type.child == .bool_type) {
- const bytes = try code.addManyAsSlice(gpa, abi_size);
+ const bytes = try w.writableSlice(abi_size);
@memset(bytes, 0xaa);
var index: usize = 0;
const len = math.cast(usize, vector_type.len) orelse return error.Overflow;
@@ -540,7 +528,7 @@ pub fn generateSymbol(
}
} else {
switch (aggregate.storage) {
- .bytes => |bytes| try code.appendSlice(gpa, bytes.toSlice(vector_type.len, ip)),
+ .bytes => |bytes| try w.writeAll(bytes.toSlice(vector_type.len, ip)),
.elems, .repeated_elem => {
var index: u64 = 0;
while (index < vector_type.len) : (index += 1) {
@@ -550,7 +538,7 @@ pub fn generateSymbol(
math.cast(usize, index) orelse return error.Overflow
],
.repeated_elem => |elem| elem,
- }), code, reloc_parent);
+ }), w, reloc_parent);
}
},
}
@@ -558,11 +546,11 @@ pub fn generateSymbol(
const padding = abi_size -
(math.cast(usize, Type.fromInterned(vector_type.child).abiSize(zcu) * vector_type.len) orelse
return error.Overflow);
- if (padding > 0) try code.appendNTimes(gpa, 0, padding);
+ if (padding > 0) try w.splatByteAll(0, padding);
}
},
.tuple_type => |tuple| {
- const struct_begin = code.items.len;
+ const struct_begin = w.end;
for (
tuple.types.get(ip),
tuple.values.get(ip),
@@ -580,8 +568,8 @@ pub fn generateSymbol(
.repeated_elem => |elem| elem,
};
- try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), code, reloc_parent);
- const unpadded_field_end = code.items.len - struct_begin;
+ try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), w, reloc_parent);
+ const unpadded_field_end = w.end - struct_begin;
// Pad struct members if required
const padded_field_end = ty.structFieldOffset(index + 1, zcu);
@@ -589,7 +577,7 @@ pub fn generateSymbol(
return error.Overflow;
if (padding > 0) {
- try code.appendNTimes(gpa, 0, padding);
+ try w.splatByteAll(0, padding);
}
}
},
@@ -598,8 +586,9 @@ pub fn generateSymbol(
switch (struct_type.layout) {
.@"packed" => {
const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
- const current_pos = code.items.len;
- try code.appendNTimes(gpa, 0, abi_size);
+ const start = w.end;
+ const buffer = try w.writableSlice(abi_size);
+ @memset(buffer, 0);
var bits: u16 = 0;
for (struct_type.field_types.get(ip), 0..) |field_ty, index| {
@@ -619,22 +608,20 @@ pub fn generateSymbol(
error.DivisionByZero => unreachable,
error.UnexpectedRemainder => return error.RelocationNotByteAligned,
};
- code.items.len = current_pos + field_offset;
- // TODO: code.lockPointers();
+ w.end = start + field_offset;
defer {
- assert(code.items.len == current_pos + field_offset + @divExact(target.ptrBitWidth(), 8));
- // TODO: code.unlockPointers();
- code.items.len = current_pos + abi_size;
+ assert(w.end == start + field_offset + @divExact(target.ptrBitWidth(), 8));
+ w.end = start + abi_size;
}
- try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), code, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), w, reloc_parent);
} else {
- Value.fromInterned(field_val).writeToPackedMemory(Type.fromInterned(field_ty), pt, code.items[current_pos..], bits) catch unreachable;
+ Value.fromInterned(field_val).writeToPackedMemory(.fromInterned(field_ty), pt, buffer, bits) catch unreachable;
}
bits += @intCast(Type.fromInterned(field_ty).bitSize(zcu));
}
},
.auto, .@"extern" => {
- const struct_begin = code.items.len;
+ const struct_begin = w.end;
const field_types = struct_type.field_types.get(ip);
const offsets = struct_type.offsets.get(ip);
@@ -654,11 +641,11 @@ pub fn generateSymbol(
const padding = math.cast(
usize,
- offsets[field_index] - (code.items.len - struct_begin),
+ offsets[field_index] - (w.end - struct_begin),
) orelse return error.Overflow;
- if (padding > 0) try code.appendNTimes(gpa, 0, padding);
+ if (padding > 0) try w.splatByteAll(0, padding);
- try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), code, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), w, reloc_parent);
}
const size = struct_type.sizeUnordered(ip);
@@ -666,10 +653,9 @@ pub fn generateSymbol(
const padding = math.cast(
usize,
- std.mem.alignForward(u64, size, @max(alignment, 1)) -
- (code.items.len - struct_begin),
+ std.mem.alignForward(u64, size, @max(alignment, 1)) - (w.end - struct_begin),
) orelse return error.Overflow;
- if (padding > 0) try code.appendNTimes(gpa, 0, padding);
+ if (padding > 0) try w.splatByteAll(0, padding);
},
}
},
@@ -679,12 +665,12 @@ pub fn generateSymbol(
const layout = ty.unionGetLayout(zcu);
if (layout.payload_size == 0) {
- return generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), code, reloc_parent);
+ return generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), w, reloc_parent);
}
// Check if we should store the tag first.
if (layout.tag_size > 0 and layout.tag_align.compare(.gte, layout.payload_align)) {
- try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), code, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), w, reloc_parent);
}
const union_obj = zcu.typeToUnion(ty).?;
@@ -692,24 +678,24 @@ pub fn generateSymbol(
const field_index = ty.unionTagFieldIndex(Value.fromInterned(un.tag), zcu).?;
const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
if (!field_ty.hasRuntimeBits(zcu)) {
- try code.appendNTimes(gpa, 0xaa, math.cast(usize, layout.payload_size) orelse return error.Overflow);
+ try w.splatByteAll(0xaa, math.cast(usize, layout.payload_size) orelse return error.Overflow);
} else {
- try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.val), code, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.val), w, reloc_parent);
const padding = math.cast(usize, layout.payload_size - field_ty.abiSize(zcu)) orelse return error.Overflow;
if (padding > 0) {
- try code.appendNTimes(gpa, 0, padding);
+ try w.splatByteAll(0, padding);
}
}
} else {
- try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.val), code, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.val), w, reloc_parent);
}
if (layout.tag_size > 0 and layout.tag_align.compare(.lt, layout.payload_align)) {
- try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), code, reloc_parent);
+ try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), w, reloc_parent);
if (layout.padding > 0) {
- try code.appendNTimes(gpa, 0, layout.padding);
+ try w.splatByteAll(0, layout.padding);
}
}
},
@@ -722,30 +708,30 @@ fn lowerPtr(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
ptr_val: InternPool.Index,
- code: *ArrayList(u8),
+ w: *std.Io.Writer,
reloc_parent: link.File.RelocInfo.Parent,
prev_offset: u64,
-) GenerateSymbolError!void {
+) (GenerateSymbolError || std.Io.Writer.Error)!void {
const zcu = pt.zcu;
const ptr = zcu.intern_pool.indexToKey(ptr_val).ptr;
const offset: u64 = prev_offset + ptr.byte_offset;
return switch (ptr.base_addr) {
- .nav => |nav| try lowerNavRef(bin_file, pt, nav, code, reloc_parent, offset),
- .uav => |uav| try lowerUavRef(bin_file, pt, src_loc, uav, code, reloc_parent, offset),
- .int => try generateSymbol(bin_file, pt, src_loc, try pt.intValue(Type.usize, offset), code, reloc_parent),
+ .nav => |nav| try lowerNavRef(bin_file, pt, nav, w, reloc_parent, offset),
+ .uav => |uav| try lowerUavRef(bin_file, pt, src_loc, uav, w, reloc_parent, offset),
+ .int => try generateSymbol(bin_file, pt, src_loc, try pt.intValue(Type.usize, offset), w, reloc_parent),
.eu_payload => |eu_ptr| try lowerPtr(
bin_file,
pt,
src_loc,
eu_ptr,
- code,
+ w,
reloc_parent,
offset + errUnionPayloadOffset(
Value.fromInterned(eu_ptr).typeOf(zcu).childType(zcu).errorUnionPayload(zcu),
zcu,
),
),
- .opt_payload => |opt_ptr| try lowerPtr(bin_file, pt, src_loc, opt_ptr, code, reloc_parent, offset),
+ .opt_payload => |opt_ptr| try lowerPtr(bin_file, pt, src_loc, opt_ptr, w, reloc_parent, offset),
.field => |field| {
const base_ptr = Value.fromInterned(field.base);
const base_ty = base_ptr.typeOf(zcu).childType(zcu);
@@ -764,7 +750,7 @@ fn lowerPtr(
},
else => unreachable,
};
- return lowerPtr(bin_file, pt, src_loc, field.base, code, reloc_parent, offset + field_off);
+ return lowerPtr(bin_file, pt, src_loc, field.base, w, reloc_parent, offset + field_off);
},
.arr_elem, .comptime_field, .comptime_alloc => unreachable,
};
@@ -775,12 +761,11 @@ fn lowerUavRef(
pt: Zcu.PerThread,
src_loc: Zcu.LazySrcLoc,
uav: InternPool.Key.Ptr.BaseAddr.Uav,
- code: *ArrayList(u8),
+ w: *std.Io.Writer,
reloc_parent: link.File.RelocInfo.Parent,
offset: u64,
-) GenerateSymbolError!void {
+) (GenerateSymbolError || std.Io.Writer.Error)!void {
const zcu = pt.zcu;
- const gpa = zcu.gpa;
const ip = &zcu.intern_pool;
const comp = lf.comp;
const target = &comp.root_mod.resolved_target.result;
@@ -790,10 +775,9 @@ fn lowerUavRef(
const is_fn_body = uav_ty.zigTypeTag(zcu) == .@"fn";
log.debug("lowerUavRef: ty = {f}", .{uav_ty.fmt(pt)});
- try code.ensureUnusedCapacity(gpa, ptr_width_bytes);
if (!is_fn_body and !uav_ty.hasRuntimeBits(zcu)) {
- code.appendNTimesAssumeCapacity(0xaa, ptr_width_bytes);
+ try w.splatByteAll(0xaa, ptr_width_bytes);
return;
}
@@ -804,29 +788,32 @@ fn lowerUavRef(
dev.check(link.File.Tag.wasm.devFeature());
const wasm = lf.cast(.wasm).?;
assert(reloc_parent == .none);
- try wasm.addUavReloc(code.items.len, uav.val, uav.orig_ty, @intCast(offset));
- code.appendNTimesAssumeCapacity(0, ptr_width_bytes);
+ try wasm.addUavReloc(w.end, uav.val, uav.orig_ty, @intCast(offset));
+ try w.splatByteAll(0, ptr_width_bytes);
return;
},
else => {},
}
- const uav_align = ip.indexToKey(uav.orig_ty).ptr_type.flags.alignment;
+ const uav_align = Type.fromInterned(uav.orig_ty).ptrAlignment(zcu);
switch (try lf.lowerUav(pt, uav_val, uav_align, src_loc)) {
.sym_index => {},
.fail => |em| std.debug.panic("TODO rework lowerUav. internal error: {s}", .{em.msg}),
}
- const vaddr = try lf.getUavVAddr(uav_val, .{
+ const vaddr = lf.getUavVAddr(uav_val, .{
.parent = reloc_parent,
- .offset = code.items.len,
+ .offset = w.end,
.addend = @intCast(offset),
- });
+ }) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ else => |e| std.debug.panic("TODO rework lowerUav. internal error: {t}", .{e}),
+ };
const endian = target.cpu.arch.endian();
switch (ptr_width_bytes) {
- 2 => mem.writeInt(u16, code.addManyAsArrayAssumeCapacity(2), @intCast(vaddr), endian),
- 4 => mem.writeInt(u32, code.addManyAsArrayAssumeCapacity(4), @intCast(vaddr), endian),
- 8 => mem.writeInt(u64, code.addManyAsArrayAssumeCapacity(8), vaddr, endian),
+ 2 => try w.writeInt(u16, @intCast(vaddr), endian),
+ 4 => try w.writeInt(u32, @intCast(vaddr), endian),
+ 8 => try w.writeInt(u64, vaddr, endian),
else => unreachable,
}
}
@@ -835,10 +822,10 @@ fn lowerNavRef(
lf: *link.File,
pt: Zcu.PerThread,
nav_index: InternPool.Nav.Index,
- code: *ArrayList(u8),
+ w: *std.Io.Writer,
reloc_parent: link.File.RelocInfo.Parent,
offset: u64,
-) GenerateSymbolError!void {
+) (GenerateSymbolError || std.Io.Writer.Error)!void {
const zcu = pt.zcu;
const gpa = zcu.gpa;
const ip = &zcu.intern_pool;
@@ -848,10 +835,8 @@ fn lowerNavRef(
const nav_ty = Type.fromInterned(ip.getNav(nav_index).typeOf(ip));
const is_fn_body = nav_ty.zigTypeTag(zcu) == .@"fn";
- try code.ensureUnusedCapacity(gpa, ptr_width_bytes);
-
if (!is_fn_body and !nav_ty.hasRuntimeBits(zcu)) {
- code.appendNTimesAssumeCapacity(0xaa, ptr_width_bytes);
+ try w.splatByteAll(0xaa, ptr_width_bytes);
return;
}
@@ -870,13 +855,13 @@ fn lowerNavRef(
} else {
try wasm.func_table_fixups.append(gpa, .{
.table_index = @enumFromInt(gop.index),
- .offset = @intCast(code.items.len),
+ .offset = @intCast(w.end),
});
}
} else {
if (is_obj) {
try wasm.out_relocs.append(gpa, .{
- .offset = @intCast(code.items.len),
+ .offset = @intCast(w.end),
.pointee = .{ .symbol_index = try wasm.navSymbolIndex(nav_index) },
.tag = if (ptr_width_bytes == 4) .memory_addr_i32 else .memory_addr_i64,
.addend = @intCast(offset),
@@ -885,12 +870,12 @@ fn lowerNavRef(
try wasm.nav_fixups.ensureUnusedCapacity(gpa, 1);
wasm.nav_fixups.appendAssumeCapacity(.{
.navs_exe_index = try wasm.refNavExe(nav_index),
- .offset = @intCast(code.items.len),
+ .offset = @intCast(w.end),
.addend = @intCast(offset),
});
}
}
- code.appendNTimesAssumeCapacity(0, ptr_width_bytes);
+ try w.splatByteAll(0, ptr_width_bytes);
return;
},
else => {},
@@ -898,14 +883,14 @@ fn lowerNavRef(
const vaddr = lf.getNavVAddr(pt, nav_index, .{
.parent = reloc_parent,
- .offset = code.items.len,
+ .offset = w.end,
.addend = @intCast(offset),
}) catch @panic("TODO rework getNavVAddr");
const endian = target.cpu.arch.endian();
switch (ptr_width_bytes) {
- 2 => mem.writeInt(u16, code.addManyAsArrayAssumeCapacity(2), @intCast(vaddr), endian),
- 4 => mem.writeInt(u32, code.addManyAsArrayAssumeCapacity(4), @intCast(vaddr), endian),
- 8 => mem.writeInt(u64, code.addManyAsArrayAssumeCapacity(8), vaddr, endian),
+ 2 => try w.writeInt(u16, @intCast(vaddr), endian),
+ 4 => try w.writeInt(u32, @intCast(vaddr), endian),
+ 8 => try w.writeInt(u64, vaddr, endian),
else => unreachable,
}
}
@@ -962,6 +947,16 @@ pub fn genNavRef(
},
.link_once => unreachable,
}
+ } else if (lf.cast(.elf2)) |elf| {
+ return .{ .sym_index = @intFromEnum(elf.navSymbol(zcu, nav_index) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ else => |e| return .{ .fail = try ErrorMsg.create(
+ zcu.gpa,
+ src_loc,
+ "linker failed to create a nav: {t}",
+ .{e},
+ ) },
+ }) };
} else if (lf.cast(.macho)) |macho_file| {
const zo = macho_file.getZigObject().?;
switch (linkage) {
src/Compilation.zig
@@ -177,7 +177,6 @@ debug_compiler_runtime_libs: bool,
debug_compile_errors: bool,
/// Do not check this field directly. Instead, use the `debugIncremental` wrapper function.
debug_incremental: bool,
-incremental: bool,
alloc_failure_occurred: bool = false,
last_update_was_cache_hit: bool = false,
@@ -256,7 +255,9 @@ mutex: if (builtin.single_threaded) struct {
test_filters: []const []const u8,
link_task_wait_group: WaitGroup = .{},
-link_prog_node: std.Progress.Node = std.Progress.Node.none,
+link_prog_node: std.Progress.Node = .none,
+link_uav_prog_node: std.Progress.Node = .none,
+link_lazy_prog_node: std.Progress.Node = .none,
llvm_opt_bisect_limit: c_int,
@@ -1746,7 +1747,6 @@ pub const CreateOptions = struct {
debug_compiler_runtime_libs: bool = false,
debug_compile_errors: bool = false,
debug_incremental: bool = false,
- incremental: bool = false,
/// Normally when you create a `Compilation`, Zig will automatically build
/// and link in required dependencies, such as compiler-rt and libc. When
/// building such dependencies themselves, this flag must be set to avoid
@@ -1982,6 +1982,7 @@ pub fn create(gpa: Allocator, arena: Allocator, diag: *CreateDiagnostic, options
};
if (have_zcu and (!need_llvm or use_llvm)) {
if (output_mode == .Obj) break :s .zcu;
+ if (options.config.use_new_linker) break :s .zcu;
switch (target_util.zigBackend(target, use_llvm)) {
else => {},
.stage2_aarch64, .stage2_x86_64 => if (target.ofmt == .coff) {
@@ -2188,8 +2189,8 @@ pub fn create(gpa: Allocator, arena: Allocator, diag: *CreateDiagnostic, options
.inherited = .{},
.global = options.config,
.parent = options.root_mod,
- }) catch |err| return switch (err) {
- error.OutOfMemory => |e| return e,
+ }) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
// None of these are possible because the configuration matches the root module
// which already passed these checks.
error.ValgrindUnsupportedOnTarget => unreachable,
@@ -2266,7 +2267,6 @@ pub fn create(gpa: Allocator, arena: Allocator, diag: *CreateDiagnostic, options
.debug_compiler_runtime_libs = options.debug_compiler_runtime_libs,
.debug_compile_errors = options.debug_compile_errors,
.debug_incremental = options.debug_incremental,
- .incremental = options.incremental,
.root_name = root_name,
.sysroot = sysroot,
.windows_libs = .empty,
@@ -2409,6 +2409,8 @@ pub fn create(gpa: Allocator, arena: Allocator, diag: *CreateDiagnostic, options
// Synchronize with other matching comments: ZigOnlyHashStuff
hash.add(use_llvm);
hash.add(options.config.use_lib_llvm);
+ hash.add(options.config.use_lld);
+ hash.add(options.config.use_new_linker);
hash.add(options.config.dll_export_fns);
hash.add(options.config.is_test);
hash.addListOfBytes(options.test_filters);
@@ -3075,14 +3077,29 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
// The linker progress node is set up here instead of in `performAllTheWork`, because
// we also want it around during `flush`.
- const have_link_node = comp.bin_file != null;
- if (have_link_node) {
+ if (comp.bin_file) |lf| {
comp.link_prog_node = main_progress_node.start("Linking", 0);
+ if (lf.cast(.elf2)) |elf| {
+ comp.link_prog_node.increaseEstimatedTotalItems(3);
+ comp.link_uav_prog_node = comp.link_prog_node.start("Constants", 0);
+ comp.link_lazy_prog_node = comp.link_prog_node.start("Synthetics", 0);
+ elf.mf.update_prog_node = comp.link_prog_node.start("Relocations", elf.mf.updates.items.len);
+ }
}
- defer if (have_link_node) {
+ defer {
comp.link_prog_node.end();
comp.link_prog_node = .none;
- };
+ comp.link_uav_prog_node.end();
+ comp.link_uav_prog_node = .none;
+ comp.link_lazy_prog_node.end();
+ comp.link_lazy_prog_node = .none;
+ if (comp.bin_file) |lf| {
+ if (lf.cast(.elf2)) |elf| {
+ elf.mf.update_prog_node.end();
+ elf.mf.update_prog_node = .none;
+ }
+ }
+ }
try comp.performAllTheWork(main_progress_node);
@@ -3100,6 +3117,8 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
try pt.populateTestFunctions();
}
+ link.updateErrorData(pt);
+
try pt.processExports();
}
@@ -3474,6 +3493,8 @@ fn addNonIncrementalStuffToCacheManifest(
man.hash.add(comp.config.use_llvm);
man.hash.add(comp.config.use_lib_llvm);
+ man.hash.add(comp.config.use_lld);
+ man.hash.add(comp.config.use_new_linker);
man.hash.add(comp.config.is_test);
man.hash.add(comp.config.import_memory);
man.hash.add(comp.config.export_memory);
@@ -4073,7 +4094,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
defer sorted_failed_analysis.deinit(gpa);
var added_any_analysis_error = false;
for (sorted_failed_analysis.items(.key), sorted_failed_analysis.items(.value)) |anal_unit, error_msg| {
- if (comp.incremental) {
+ if (comp.config.incremental) {
const refs = try zcu.resolveReferences();
if (!refs.contains(anal_unit)) continue;
}
@@ -4240,7 +4261,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
// TODO: eventually, this should be behind `std.debug.runtime_safety`. But right now, this is a
// very common way for incremental compilation bugs to manifest, so let's always check it.
- if (comp.zcu) |zcu| if (comp.incremental and bundle.root_list.items.len == 0) {
+ if (comp.zcu) |zcu| if (comp.config.incremental and bundle.root_list.items.len == 0) {
for (zcu.transitive_failed_analysis.keys()) |failed_unit| {
const refs = try zcu.resolveReferences();
var ref = refs.get(failed_unit) orelse continue;
@@ -4949,7 +4970,7 @@ fn performAllTheWork(
tr.stats.n_reachable_files = @intCast(zcu.alive_files.count());
}
- if (comp.incremental) {
+ if (comp.config.incremental) {
const update_zir_refs_node = main_progress_node.start("Update ZIR References", 0);
defer update_zir_refs_node.end();
try pt.updateZirRefs();
src/dev.zig
@@ -97,6 +97,7 @@ pub const Env = enum {
.lld_linker,
.coff_linker,
.elf_linker,
+ .elf2_linker,
.macho_linker,
.c_linker,
.wasm_linker,
@@ -163,6 +164,7 @@ pub const Env = enum {
.incremental,
.aarch64_backend,
.elf_linker,
+ .elf2_linker,
=> true,
else => Env.sema.supports(feature),
},
@@ -210,6 +212,7 @@ pub const Env = enum {
.legalize,
.x86_64_backend,
.elf_linker,
+ .elf2_linker,
=> true,
else => Env.sema.supports(feature),
},
@@ -282,6 +285,7 @@ pub const Feature = enum {
lld_linker,
coff_linker,
elf_linker,
+ elf2_linker,
macho_linker,
c_linker,
wasm_linker,
src/InternPool.zig
@@ -6424,14 +6424,25 @@ pub const Alignment = enum(u6) {
return n + 1;
}
+ pub fn toStdMem(a: Alignment) std.mem.Alignment {
+ assert(a != .none);
+ return @enumFromInt(@intFromEnum(a));
+ }
+
+ pub fn fromStdMem(a: std.mem.Alignment) Alignment {
+ const r: Alignment = @enumFromInt(@intFromEnum(a));
+ assert(r != .none);
+ return r;
+ }
+
const LlvmBuilderAlignment = std.zig.llvm.Builder.Alignment;
- pub fn toLlvm(this: @This()) LlvmBuilderAlignment {
- return @enumFromInt(@intFromEnum(this));
+ pub fn toLlvm(a: Alignment) LlvmBuilderAlignment {
+ return @enumFromInt(@intFromEnum(a));
}
- pub fn fromLlvm(other: LlvmBuilderAlignment) @This() {
- return @enumFromInt(@intFromEnum(other));
+ pub fn fromLlvm(a: LlvmBuilderAlignment) Alignment {
+ return @enumFromInt(@intFromEnum(a));
}
};
src/link.zig
@@ -219,6 +219,7 @@ pub const Diags = struct {
}
pub fn addError(diags: *Diags, comptime format: []const u8, args: anytype) void {
+ @branchHint(.cold);
return addErrorSourceLocation(diags, .none, format, args);
}
@@ -529,7 +530,7 @@ pub const File = struct {
const lld: *Lld = try .createEmpty(arena, comp, emit, options);
return &lld.base;
}
- switch (Tag.fromObjectFormat(comp.root_mod.resolved_target.result.ofmt)) {
+ switch (Tag.fromObjectFormat(comp.root_mod.resolved_target.result.ofmt, comp.config.use_new_linker)) {
.plan9 => return error.UnsupportedObjectFormat,
inline else => |tag| {
dev.check(tag.devFeature());
@@ -552,7 +553,7 @@ pub const File = struct {
const lld: *Lld = try .createEmpty(arena, comp, emit, options);
return &lld.base;
}
- switch (Tag.fromObjectFormat(comp.root_mod.resolved_target.result.ofmt)) {
+ switch (Tag.fromObjectFormat(comp.root_mod.resolved_target.result.ofmt, comp.config.use_new_linker)) {
.plan9 => return error.UnsupportedObjectFormat,
inline else => |tag| {
dev.check(tag.devFeature());
@@ -579,7 +580,8 @@ pub const File = struct {
const emit = base.emit;
if (base.child_pid) |pid| {
if (builtin.os.tag == .windows) {
- base.cast(.coff).?.ptraceAttach(pid) catch |err| {
+ const coff_file = base.cast(.coff).?;
+ coff_file.ptraceAttach(pid) catch |err| {
log.warn("attaching failed with error: {s}", .{@errorName(err)});
};
} else {
@@ -597,8 +599,11 @@ pub const File = struct {
.linux => std.posix.ptrace(std.os.linux.PTRACE.ATTACH, pid, 0, 0) catch |err| {
log.warn("ptrace failure: {s}", .{@errorName(err)});
},
- .macos => base.cast(.macho).?.ptraceAttach(pid) catch |err| {
- log.warn("attaching failed with error: {s}", .{@errorName(err)});
+ .macos => {
+ const macho_file = base.cast(.macho).?;
+ macho_file.ptraceAttach(pid) catch |err| {
+ log.warn("attaching failed with error: {s}", .{@errorName(err)});
+ };
},
.windows => unreachable,
else => return error.HotSwapUnavailableOnHostOperatingSystem,
@@ -613,6 +618,20 @@ pub const File = struct {
.mode = determineMode(output_mode, link_mode),
});
},
+ .elf2 => {
+ const elf = base.cast(.elf2).?;
+ if (base.file == null) {
+ elf.mf.file = try base.emit.root_dir.handle.createFile(base.emit.sub_path, .{
+ .truncate = false,
+ .read = true,
+ .mode = determineMode(comp.config.output_mode, comp.config.link_mode),
+ });
+ base.file = elf.mf.file;
+ try elf.mf.ensureTotalCapacity(
+ @intCast(elf.mf.nodes.items[0].location().resolve(&elf.mf)[1]),
+ );
+ }
+ },
.c, .spirv => dev.checkAny(&.{ .c_linker, .spirv_linker }),
.plan9 => unreachable,
}
@@ -669,14 +688,30 @@ pub const File = struct {
if (base.child_pid) |pid| {
switch (builtin.os.tag) {
- .macos => base.cast(.macho).?.ptraceDetach(pid) catch |err| {
- log.warn("detaching failed with error: {s}", .{@errorName(err)});
+ .macos => {
+ const macho_file = base.cast(.macho).?;
+ macho_file.ptraceDetach(pid) catch |err| {
+ log.warn("detaching failed with error: {s}", .{@errorName(err)});
+ };
+ },
+ .windows => {
+ const coff_file = base.cast(.coff).?;
+ coff_file.ptraceDetach(pid);
},
- .windows => base.cast(.coff).?.ptraceDetach(pid),
else => return error.HotSwapUnavailableOnHostOperatingSystem,
}
}
},
+ .elf2 => {
+ const elf = base.cast(.elf2).?;
+ if (base.file) |f| {
+ elf.mf.unmap();
+ assert(elf.mf.file.handle == f.handle);
+ elf.mf.file = undefined;
+ f.close();
+ base.file = null;
+ }
+ },
.c, .spirv => dev.checkAny(&.{ .c_linker, .spirv_linker }),
.plan9 => unreachable,
}
@@ -793,6 +828,7 @@ pub const File = struct {
.spirv => {},
.goff, .xcoff => {},
.plan9 => unreachable,
+ .elf2 => {},
inline else => |tag| {
dev.check(tag.devFeature());
return @as(*tag.Type(), @fieldParentPtr("base", base)).updateLineNumber(pt, ti_id);
@@ -825,6 +861,26 @@ pub const File = struct {
}
}
+ pub fn idle(base: *File, tid: Zcu.PerThread.Id) !bool {
+ switch (base.tag) {
+ else => return false,
+ inline .elf2 => |tag| {
+ dev.check(tag.devFeature());
+ return @as(*tag.Type(), @fieldParentPtr("base", base)).idle(tid);
+ },
+ }
+ }
+
+ pub fn updateErrorData(base: *File, pt: Zcu.PerThread) !void {
+ switch (base.tag) {
+ else => {},
+ inline .elf2 => |tag| {
+ dev.check(tag.devFeature());
+ return @as(*tag.Type(), @fieldParentPtr("base", base)).updateErrorData(pt);
+ },
+ }
+ }
+
pub const FlushError = error{
/// Indicates an error will be present in `Compilation.link_diags`.
LinkFailure,
@@ -1099,7 +1155,7 @@ pub const File = struct {
if (base.zcu_object_basename != null) return;
switch (base.tag) {
- inline .wasm => |tag| {
+ inline .elf2, .wasm => |tag| {
dev.check(tag.devFeature());
return @as(*tag.Type(), @fieldParentPtr("base", base)).prelink(base.comp.link_prog_node);
},
@@ -1110,6 +1166,7 @@ pub const File = struct {
pub const Tag = enum {
coff,
elf,
+ elf2,
macho,
c,
wasm,
@@ -1123,6 +1180,7 @@ pub const File = struct {
return switch (tag) {
.coff => Coff,
.elf => Elf,
+ .elf2 => Elf2,
.macho => MachO,
.c => C,
.wasm => Wasm,
@@ -1134,10 +1192,10 @@ pub const File = struct {
};
}
- fn fromObjectFormat(ofmt: std.Target.ObjectFormat) Tag {
+ fn fromObjectFormat(ofmt: std.Target.ObjectFormat, use_new_linker: bool) Tag {
return switch (ofmt) {
.coff => .coff,
- .elf => .elf,
+ .elf => if (use_new_linker) .elf2 else .elf,
.macho => .macho,
.wasm => .wasm,
.plan9 => .plan9,
@@ -1223,6 +1281,7 @@ pub const File = struct {
pub const C = @import("link/C.zig");
pub const Coff = @import("link/Coff.zig");
pub const Elf = @import("link/Elf.zig");
+ pub const Elf2 = @import("link/Elf2.zig");
pub const MachO = @import("link/MachO.zig");
pub const SpirV = @import("link/SpirV.zig");
pub const Wasm = @import("link/Wasm.zig");
@@ -1548,6 +1607,9 @@ pub fn doZcuTask(comp: *Compilation, tid: usize, task: ZcuTask) void {
}
}
}
+pub fn doIdleTask(comp: *Compilation, tid: usize) error{ OutOfMemory, LinkFailure }!bool {
+ return if (comp.bin_file) |lf| lf.idle(@enumFromInt(tid)) else false;
+}
/// After the main pipeline is done, but before flush, the compilation may need to link one final
/// `Nav` into the binary: the `builtin.test_functions` value. Since the link thread isn't running
/// by then, we expose this function which can be called directly.
@@ -1573,6 +1635,13 @@ pub fn linkTestFunctionsNav(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index)
};
}
}
+pub fn updateErrorData(pt: Zcu.PerThread) void {
+ const comp = pt.zcu.comp;
+ if (comp.bin_file) |lf| lf.updateErrorData(pt) catch |err| switch (err) {
+ error.OutOfMemory => comp.link_diags.setAllocFailure(),
+ error.LinkFailure => {},
+ };
+}
/// Provided by the CLI, processed into `LinkInput` instances at the start of
/// the compilation pipeline.
src/main.zig
@@ -904,7 +904,6 @@ fn buildOutputType(
var mingw_unicode_entry_point: bool = false;
var enable_link_snapshots: bool = false;
var debug_compiler_runtime_libs = false;
- var opt_incremental: ?bool = null;
var install_name: ?[]const u8 = null;
var hash_style: link.File.Lld.Elf.HashStyle = .both;
var entitlements: ?[]const u8 = null;
@@ -1374,9 +1373,9 @@ fn buildOutputType(
}
} else if (mem.eql(u8, arg, "-fincremental")) {
dev.check(.incremental);
- opt_incremental = true;
+ create_module.opts.incremental = true;
} else if (mem.eql(u8, arg, "-fno-incremental")) {
- opt_incremental = false;
+ create_module.opts.incremental = false;
} else if (mem.eql(u8, arg, "--entitlements")) {
entitlements = args_iter.nextOrFatal();
} else if (mem.eql(u8, arg, "-fcompiler-rt")) {
@@ -1479,6 +1478,10 @@ fn buildOutputType(
create_module.opts.use_lld = true;
} else if (mem.eql(u8, arg, "-fno-lld")) {
create_module.opts.use_lld = false;
+ } else if (mem.eql(u8, arg, "-fnew-linker")) {
+ create_module.opts.use_new_linker = true;
+ } else if (mem.eql(u8, arg, "-fno-new-linker")) {
+ create_module.opts.use_new_linker = false;
} else if (mem.eql(u8, arg, "-fclang")) {
create_module.opts.use_clang = true;
} else if (mem.eql(u8, arg, "-fno-clang")) {
@@ -3371,7 +3374,7 @@ fn buildOutputType(
else => false,
};
- const incremental = opt_incremental orelse false;
+ const incremental = create_module.resolved_options.incremental;
if (debug_incremental and !incremental) {
fatal("--debug-incremental requires -fincremental", .{});
}
@@ -3502,7 +3505,6 @@ fn buildOutputType(
.subsystem = subsystem,
.debug_compile_errors = debug_compile_errors,
.debug_incremental = debug_incremental,
- .incremental = incremental,
.enable_link_snapshots = enable_link_snapshots,
.install_name = install_name,
.entitlements = entitlements,
@@ -4016,6 +4018,8 @@ fn createModule(
error.LldUnavailable => fatal("zig was compiled without LLD libraries", .{}),
error.ClangUnavailable => fatal("zig was compiled without Clang libraries", .{}),
error.DllExportFnsRequiresWindows => fatal("only Windows OS targets support DLLs", .{}),
+ error.NewLinkerIncompatibleObjectFormat => fatal("using the new linker to link {s} files is unsupported", .{@tagName(target.ofmt)}),
+ error.NewLinkerIncompatibleWithLld => fatal("using the new linker is incompatible with using lld", .{}),
};
}
src/Sema.zig
@@ -3032,7 +3032,7 @@ fn zirStructDecl(
});
errdefer pt.destroyNamespace(new_namespace_index);
- if (pt.zcu.comp.incremental) {
+ if (pt.zcu.comp.config.incremental) {
try pt.addDependency(.wrap(.{ .type = wip_ty.index }), .{ .src_hash = tracked_inst });
}
@@ -3430,7 +3430,7 @@ fn zirUnionDecl(
});
errdefer pt.destroyNamespace(new_namespace_index);
- if (pt.zcu.comp.incremental) {
+ if (pt.zcu.comp.config.incremental) {
try pt.addDependency(.wrap(.{ .type = wip_ty.index }), .{ .src_hash = tracked_inst });
}
@@ -6217,7 +6217,7 @@ fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
if (ptr_info.byte_offset != 0) {
return sema.fail(block, ptr_src, "TODO: export pointer in middle of value", .{});
}
- if (options.linkage == .internal) return;
+ if (zcu.llvm_object != null and options.linkage == .internal) return;
const export_ty = Value.fromInterned(uav.val).typeOf(zcu);
if (!try sema.validateExternType(export_ty, .other)) {
return sema.failWithOwnedErrorMsg(block, msg: {
@@ -6256,7 +6256,7 @@ pub fn analyzeExport(
const zcu = pt.zcu;
const ip = &zcu.intern_pool;
- if (options.linkage == .internal)
+ if (zcu.llvm_object != null and options.linkage == .internal)
return;
try sema.ensureNavResolved(block, src, orig_nav_index, .fully);
@@ -7709,7 +7709,7 @@ fn analyzeCall(
// TODO: comptime call memoization is currently not supported under incremental compilation
// since dependencies are not marked on callers. If we want to keep this around (we should
// check that it's worthwhile first!), each memoized call needs an `AnalUnit`.
- if (zcu.comp.incremental) break :m false;
+ if (zcu.comp.config.incremental) break :m false;
if (!block.isComptime()) break :m false;
for (args) |a| {
const val = (try sema.resolveValue(a)).?;
@@ -31208,7 +31208,7 @@ fn addReferenceEntry(
.func => |f| assert(ip.unwrapCoercedFunc(f) == f), // for `.{ .func = f }`, `f` must be uncoerced
else => {},
}
- if (!zcu.comp.incremental and zcu.comp.reference_trace == 0) return;
+ if (!zcu.comp.config.incremental and zcu.comp.reference_trace == 0) return;
const gop = try sema.references.getOrPut(sema.gpa, referenced_unit);
if (gop.found_existing) return;
try zcu.addUnitReference(sema.owner, referenced_unit, src, inline_frame: {
@@ -31225,7 +31225,7 @@ pub fn addTypeReferenceEntry(
referenced_type: InternPool.Index,
) !void {
const zcu = sema.pt.zcu;
- if (!zcu.comp.incremental and zcu.comp.reference_trace == 0) return;
+ if (!zcu.comp.config.incremental and zcu.comp.reference_trace == 0) return;
const gop = try sema.type_references.getOrPut(sema.gpa, referenced_type);
if (gop.found_existing) return;
try zcu.addTypeReference(sema.owner, referenced_type, src);
@@ -36875,7 +36875,7 @@ fn isKnownZigType(sema: *Sema, ref: Air.Inst.Ref, tag: std.builtin.TypeId) bool
pub fn declareDependency(sema: *Sema, dependee: InternPool.Dependee) !void {
const pt = sema.pt;
- if (!pt.zcu.comp.incremental) return;
+ if (!pt.zcu.comp.config.incremental) return;
const gop = try sema.dependencies.getOrPut(sema.gpa, dependee);
if (gop.found_existing) return;
src/target.zig
@@ -231,6 +231,13 @@ pub fn hasLldSupport(ofmt: std.Target.ObjectFormat) bool {
};
}
+pub fn hasNewLinkerSupport(ofmt: std.Target.ObjectFormat) bool {
+ return switch (ofmt) {
+ .elf => true,
+ else => false,
+ };
+}
+
/// The set of targets that our own self-hosted backends have robust support for.
/// Used to select between LLVM backend and self-hosted backend when compiling in
/// debug mode. A given target should only return true here if it is passing greater
src/Value.zig
@@ -23,7 +23,7 @@ pub fn format(val: Value, writer: *std.Io.Writer) !void {
/// This is a debug function. In order to print values in a meaningful way
/// we also need access to the type.
-pub fn dump(start_val: Value, w: std.Io.Writer) std.Io.Writer.Error!void {
+pub fn dump(start_val: Value, w: *std.Io.Writer) std.Io.Writer.Error!void {
try w.print("(interned: {})", .{start_val.toIntern()});
}
src/Zcu.zig
@@ -3166,7 +3166,7 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
}
pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {
- if (!zcu.comp.incremental) return null;
+ if (!zcu.comp.config.incremental) return null;
if (zcu.outdated.count() == 0) {
// Any units in `potentially_outdated` must just be stuck in loops with one another: none of those
test/incremental/change_exports
@@ -1,4 +1,4 @@
-//#target=x86_64-linux-selfhosted
+#target=x86_64-linux-selfhosted
#target=x86_64-linux-cbe
#target=x86_64-windows-cbe
test/incremental/change_panic_handler
@@ -1,3 +1,4 @@
+#target=x86_64-linux-selfhosted
#target=x86_64-linux-cbe
#target=x86_64-windows-cbe
#update=initial version
test/incremental/change_panic_handler_explicit
@@ -1,3 +1,4 @@
+#target=x86_64-linux-selfhosted
#target=x86_64-linux-cbe
#target=x86_64-windows-cbe
#update=initial version
test/incremental/change_struct_same_fields
@@ -1,4 +1,4 @@
-//#target=x86_64-linux-selfhosted
+#target=x86_64-linux-selfhosted
#target=x86_64-linux-cbe
#target=x86_64-windows-cbe
#target=wasm32-wasi-selfhosted
test/incremental/type_becomes_comptime_only
@@ -1,3 +1,4 @@
+#target=x86_64-linux-selfhosted
#target=x86_64-linux-cbe
#target=x86_64-windows-cbe
#target=wasm32-wasi-selfhosted
build.zig
@@ -202,6 +202,7 @@ pub fn build(b: *std.Build) !void {
});
exe.pie = pie;
exe.entitlements = entitlements;
+ exe.use_new_linker = b.option(bool, "new-linker", "Use the new linker");
const use_llvm = b.option(bool, "use-llvm", "Use the llvm backend");
exe.use_llvm = use_llvm;
CMakeLists.txt
@@ -583,6 +583,7 @@ set(ZIG_STAGE2_SOURCES
src/link/Elf/relocatable.zig
src/link/Elf/relocation.zig
src/link/Elf/synthetic_sections.zig
+ src/link/Elf2.zig
src/link/Goff.zig
src/link/LdScript.zig
src/link/Lld.zig
@@ -612,6 +613,7 @@ set(ZIG_STAGE2_SOURCES
src/link/MachO/synthetic.zig
src/link/MachO/Thunk.zig
src/link/MachO/uuid.zig
+ src/link/MappedFile.zig
src/link/Queue.zig
src/link/StringTable.zig
src/link/Wasm.zig