const std = @import("std.zig"); const builtin = std.builtin; const io = std.io; const os = std.os; const math = std.math; const mem = std.mem; const debug = std.debug; const InStream = std.stream.InStream; const File = std.fs.File; pub const AT_NULL = 0; pub const AT_IGNORE = 1; pub const AT_EXECFD = 2; pub const AT_PHDR = 3; pub const AT_PHENT = 4; pub const AT_PHNUM = 5; pub const AT_PAGESZ = 6; pub const AT_BASE = 7; pub const AT_FLAGS = 8; pub const AT_ENTRY = 9; pub const AT_NOTELF = 10; pub const AT_UID = 11; pub const AT_EUID = 12; pub const AT_GID = 13; pub const AT_EGID = 14; pub const AT_CLKTCK = 17; pub const AT_PLATFORM = 15; pub const AT_HWCAP = 16; pub const AT_FPUCW = 18; pub const AT_DCACHEBSIZE = 19; pub const AT_ICACHEBSIZE = 20; pub const AT_UCACHEBSIZE = 21; pub const AT_IGNOREPPC = 22; pub const AT_SECURE = 23; pub const AT_BASE_PLATFORM = 24; pub const AT_RANDOM = 25; pub const AT_HWCAP2 = 26; pub const AT_EXECFN = 31; pub const AT_SYSINFO = 32; pub const AT_SYSINFO_EHDR = 33; pub const AT_L1I_CACHESHAPE = 34; pub const AT_L1D_CACHESHAPE = 35; pub const AT_L2_CACHESHAPE = 36; pub const AT_L3_CACHESHAPE = 37; pub const AT_L1I_CACHESIZE = 40; pub const AT_L1I_CACHEGEOMETRY = 41; pub const AT_L1D_CACHESIZE = 42; pub const AT_L1D_CACHEGEOMETRY = 43; pub const AT_L2_CACHESIZE = 44; pub const AT_L2_CACHEGEOMETRY = 45; pub const AT_L3_CACHESIZE = 46; pub const AT_L3_CACHEGEOMETRY = 47; pub const DT_NULL = 0; pub const DT_NEEDED = 1; pub const DT_PLTRELSZ = 2; pub const DT_PLTGOT = 3; pub const DT_HASH = 4; pub const DT_STRTAB = 5; pub const DT_SYMTAB = 6; pub const DT_RELA = 7; pub const DT_RELASZ = 8; pub const DT_RELAENT = 9; pub const DT_STRSZ = 10; pub const DT_SYMENT = 11; pub const DT_INIT = 12; pub const DT_FINI = 13; pub const DT_SONAME = 14; pub const DT_RPATH = 15; pub const DT_SYMBOLIC = 16; pub const DT_REL = 17; pub const DT_RELSZ = 18; pub const DT_RELENT = 19; pub const DT_PLTREL = 20; pub const DT_DEBUG = 21; pub const DT_TEXTREL = 22; pub const DT_JMPREL = 23; pub const DT_BIND_NOW = 24; pub const DT_INIT_ARRAY = 25; pub const DT_FINI_ARRAY = 26; pub const DT_INIT_ARRAYSZ = 27; pub const DT_FINI_ARRAYSZ = 28; pub const DT_RUNPATH = 29; pub const DT_FLAGS = 30; pub const DT_ENCODING = 32; pub const DT_PREINIT_ARRAY = 32; pub const DT_PREINIT_ARRAYSZ = 33; pub const DT_SYMTAB_SHNDX = 34; pub const DT_NUM = 35; pub const DT_LOOS = 0x6000000d; pub const DT_HIOS = 0x6ffff000; pub const DT_LOPROC = 0x70000000; pub const DT_HIPROC = 0x7fffffff; pub const DT_PROCNUM = DT_MIPS_NUM; pub const DT_VALRNGLO = 0x6ffffd00; pub const DT_GNU_PRELINKED = 0x6ffffdf5; pub const DT_GNU_CONFLICTSZ = 0x6ffffdf6; pub const DT_GNU_LIBLISTSZ = 0x6ffffdf7; pub const DT_CHECKSUM = 0x6ffffdf8; pub const DT_PLTPADSZ = 0x6ffffdf9; pub const DT_MOVEENT = 0x6ffffdfa; pub const DT_MOVESZ = 0x6ffffdfb; pub const DT_FEATURE_1 = 0x6ffffdfc; pub const DT_POSFLAG_1 = 0x6ffffdfd; pub const DT_SYMINSZ = 0x6ffffdfe; pub const DT_SYMINENT = 0x6ffffdff; pub const DT_VALRNGHI = 0x6ffffdff; pub const DT_VALNUM = 12; pub const DT_ADDRRNGLO = 0x6ffffe00; pub const DT_GNU_HASH = 0x6ffffef5; pub const DT_TLSDESC_PLT = 0x6ffffef6; pub const DT_TLSDESC_GOT = 0x6ffffef7; pub const DT_GNU_CONFLICT = 0x6ffffef8; pub const DT_GNU_LIBLIST = 0x6ffffef9; pub const DT_CONFIG = 0x6ffffefa; pub const DT_DEPAUDIT = 0x6ffffefb; pub const DT_AUDIT = 0x6ffffefc; pub const DT_PLTPAD = 0x6ffffefd; pub const DT_MOVETAB = 0x6ffffefe; pub const DT_SYMINFO = 0x6ffffeff; pub const DT_ADDRRNGHI = 0x6ffffeff; pub const DT_ADDRNUM = 11; pub const DT_VERSYM = 0x6ffffff0; pub const DT_RELACOUNT = 0x6ffffff9; pub const DT_RELCOUNT = 0x6ffffffa; pub const DT_FLAGS_1 = 0x6ffffffb; pub const DT_VERDEF = 0x6ffffffc; pub const DT_VERDEFNUM = 0x6ffffffd; pub const DT_VERNEED = 0x6ffffffe; pub const DT_VERNEEDNUM = 0x6fffffff; pub const DT_VERSIONTAGNUM = 16; pub const DT_AUXILIARY = 0x7ffffffd; pub const DT_FILTER = 0x7fffffff; pub const DT_EXTRANUM = 3; pub const DT_SPARC_REGISTER = 0x70000001; pub const DT_SPARC_NUM = 2; pub const DT_MIPS_RLD_VERSION = 0x70000001; pub const DT_MIPS_TIME_STAMP = 0x70000002; pub const DT_MIPS_ICHECKSUM = 0x70000003; pub const DT_MIPS_IVERSION = 0x70000004; pub const DT_MIPS_FLAGS = 0x70000005; pub const DT_MIPS_BASE_ADDRESS = 0x70000006; pub const DT_MIPS_MSYM = 0x70000007; pub const DT_MIPS_CONFLICT = 0x70000008; pub const DT_MIPS_LIBLIST = 0x70000009; pub const DT_MIPS_LOCAL_GOTNO = 0x7000000a; pub const DT_MIPS_CONFLICTNO = 0x7000000b; pub const DT_MIPS_LIBLISTNO = 0x70000010; pub const DT_MIPS_SYMTABNO = 0x70000011; pub const DT_MIPS_UNREFEXTNO = 0x70000012; pub const DT_MIPS_GOTSYM = 0x70000013; pub const DT_MIPS_HIPAGENO = 0x70000014; pub const DT_MIPS_RLD_MAP = 0x70000016; pub const DT_MIPS_DELTA_CLASS = 0x70000017; pub const DT_MIPS_DELTA_CLASS_NO = 0x70000018; pub const DT_MIPS_DELTA_INSTANCE = 0x70000019; pub const DT_MIPS_DELTA_INSTANCE_NO = 0x7000001a; pub const DT_MIPS_DELTA_RELOC = 0x7000001b; pub const DT_MIPS_DELTA_RELOC_NO = 0x7000001c; pub const DT_MIPS_DELTA_SYM = 0x7000001d; pub const DT_MIPS_DELTA_SYM_NO = 0x7000001e; pub const DT_MIPS_DELTA_CLASSSYM = 0x70000020; pub const DT_MIPS_DELTA_CLASSSYM_NO = 0x70000021; pub const DT_MIPS_CXX_FLAGS = 0x70000022; pub const DT_MIPS_PIXIE_INIT = 0x70000023; pub const DT_MIPS_SYMBOL_LIB = 0x70000024; pub const DT_MIPS_LOCALPAGE_GOTIDX = 0x70000025; pub const DT_MIPS_LOCAL_GOTIDX = 0x70000026; pub const DT_MIPS_HIDDEN_GOTIDX = 0x70000027; pub const DT_MIPS_PROTECTED_GOTIDX = 0x70000028; pub const DT_MIPS_OPTIONS = 0x70000029; pub const DT_MIPS_INTERFACE = 0x7000002a; pub const DT_MIPS_DYNSTR_ALIGN = 0x7000002b; pub const DT_MIPS_INTERFACE_SIZE = 0x7000002c; pub const DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 0x7000002d; pub const DT_MIPS_PERF_SUFFIX = 0x7000002e; pub const DT_MIPS_COMPACT_SIZE = 0x7000002f; pub const DT_MIPS_GP_VALUE = 0x70000030; pub const DT_MIPS_AUX_DYNAMIC = 0x70000031; pub const DT_MIPS_PLTGOT = 0x70000032; pub const DT_MIPS_RWPLT = 0x70000034; pub const DT_MIPS_RLD_MAP_REL = 0x70000035; pub const DT_MIPS_NUM = 0x36; pub const DT_ALPHA_PLTRO = (DT_LOPROC + 0); pub const DT_ALPHA_NUM = 1; pub const DT_PPC_GOT = (DT_LOPROC + 0); pub const DT_PPC_OPT = (DT_LOPROC + 1); pub const DT_PPC_NUM = 2; pub const DT_PPC64_GLINK = (DT_LOPROC + 0); pub const DT_PPC64_OPD = (DT_LOPROC + 1); pub const DT_PPC64_OPDSZ = (DT_LOPROC + 2); pub const DT_PPC64_OPT = (DT_LOPROC + 3); pub const DT_PPC64_NUM = 4; pub const DT_IA_64_PLT_RESERVE = (DT_LOPROC + 0); pub const DT_IA_64_NUM = 1; pub const DT_NIOS2_GP = 0x70000002; pub const PT_NULL = 0; pub const PT_LOAD = 1; pub const PT_DYNAMIC = 2; pub const PT_INTERP = 3; pub const PT_NOTE = 4; pub const PT_SHLIB = 5; pub const PT_PHDR = 6; pub const PT_TLS = 7; pub const PT_NUM = 8; pub const PT_LOOS = 0x60000000; pub const PT_GNU_EH_FRAME = 0x6474e550; pub const PT_GNU_STACK = 0x6474e551; pub const PT_GNU_RELRO = 0x6474e552; pub const PT_LOSUNW = 0x6ffffffa; pub const PT_SUNWBSS = 0x6ffffffa; pub const PT_SUNWSTACK = 0x6ffffffb; pub const PT_HISUNW = 0x6fffffff; pub const PT_HIOS = 0x6fffffff; pub const PT_LOPROC = 0x70000000; pub const PT_HIPROC = 0x7fffffff; pub const SHT_NULL = 0; pub const SHT_PROGBITS = 1; pub const SHT_SYMTAB = 2; pub const SHT_STRTAB = 3; pub const SHT_RELA = 4; pub const SHT_HASH = 5; pub const SHT_DYNAMIC = 6; pub const SHT_NOTE = 7; pub const SHT_NOBITS = 8; pub const SHT_REL = 9; pub const SHT_SHLIB = 10; pub const SHT_DYNSYM = 11; pub const SHT_INIT_ARRAY = 14; pub const SHT_FINI_ARRAY = 15; pub const SHT_PREINIT_ARRAY = 16; pub const SHT_GROUP = 17; pub const SHT_SYMTAB_SHNDX = 18; pub const SHT_LOOS = 0x60000000; pub const SHT_HIOS = 0x6fffffff; pub const SHT_LOPROC = 0x70000000; pub const SHT_HIPROC = 0x7fffffff; pub const SHT_LOUSER = 0x80000000; pub const SHT_HIUSER = 0xffffffff; pub const STB_LOCAL = 0; pub const STB_GLOBAL = 1; pub const STB_WEAK = 2; pub const STB_NUM = 3; pub const STB_LOOS = 10; pub const STB_GNU_UNIQUE = 10; pub const STB_HIOS = 12; pub const STB_LOPROC = 13; pub const STB_HIPROC = 15; pub const STB_MIPS_SPLIT_COMMON = 13; pub const STT_NOTYPE = 0; pub const STT_OBJECT = 1; pub const STT_FUNC = 2; pub const STT_SECTION = 3; pub const STT_FILE = 4; pub const STT_COMMON = 5; pub const STT_TLS = 6; pub const STT_NUM = 7; pub const STT_LOOS = 10; pub const STT_GNU_IFUNC = 10; pub const STT_HIOS = 12; pub const STT_LOPROC = 13; pub const STT_HIPROC = 15; pub const STT_SPARC_REGISTER = 13; pub const STT_PARISC_MILLICODE = 13; pub const STT_HP_OPAQUE = (STT_LOOS + 0x1); pub const STT_HP_STUB = (STT_LOOS + 0x2); pub const STT_ARM_TFUNC = STT_LOPROC; pub const STT_ARM_16BIT = STT_HIPROC; pub const VER_FLG_BASE = 0x1; pub const VER_FLG_WEAK = 0x2; /// File types pub const ET = extern enum(u16) { /// No file type NONE = 0, /// Relocatable file REL = 1, /// Executable file EXEC = 2, /// Shared object file DYN = 3, /// Core file CORE = 4, /// Beginning of processor-specific codes pub const LOPROC = 0xff00; /// Processor-specific pub const HIPROC = 0xffff; }; /// All integers are native endian. const Header = struct { endian: builtin.Endian, is_64: bool, entry: u64, phoff: u64, shoff: u64, phentsize: u16, phnum: u16, shentsize: u16, shnum: u16, shstrndx: u16, }; pub fn readHeader(file: File) !Header { var hdr_buf: [@sizeOf(Elf64_Ehdr)]u8 align(@alignOf(Elf64_Ehdr)) = undefined; try preadNoEof(file, &hdr_buf, 0); const hdr32 = @ptrCast(*Elf32_Ehdr, &hdr_buf); const hdr64 = @ptrCast(*Elf64_Ehdr, &hdr_buf); if (!mem.eql(u8, hdr32.e_ident[0..4], "\x7fELF")) return error.InvalidElfMagic; if (hdr32.e_ident[EI_VERSION] != 1) return error.InvalidElfVersion; const endian: std.builtin.Endian = switch (hdr32.e_ident[EI_DATA]) { ELFDATA2LSB => .Little, ELFDATA2MSB => .Big, else => return error.InvalidElfEndian, }; const need_bswap = endian != std.builtin.endian; const is_64 = switch (hdr32.e_ident[EI_CLASS]) { ELFCLASS32 => false, ELFCLASS64 => true, else => return error.InvalidElfClass, }; return @as(Header, .{ .endian = endian, .is_64 = is_64, .entry = int(is_64, need_bswap, hdr32.e_entry, hdr64.e_entry), .phoff = int(is_64, need_bswap, hdr32.e_phoff, hdr64.e_phoff), .shoff = int(is_64, need_bswap, hdr32.e_shoff, hdr64.e_shoff), .phentsize = int(is_64, need_bswap, hdr32.e_phentsize, hdr64.e_phentsize), .phnum = int(is_64, need_bswap, hdr32.e_phnum, hdr64.e_phnum), .shentsize = int(is_64, need_bswap, hdr32.e_shentsize, hdr64.e_shentsize), .shnum = int(is_64, need_bswap, hdr32.e_shnum, hdr64.e_shnum), .shstrndx = int(is_64, need_bswap, hdr32.e_shstrndx, hdr64.e_shstrndx), }); } /// All integers are native endian. pub const AllHeaders = struct { header: Header, section_headers: []Elf64_Shdr, program_headers: []Elf64_Phdr, allocator: *mem.Allocator, }; pub fn readAllHeaders(allocator: *mem.Allocator, file: File) !AllHeaders { var hdrs: AllHeaders = .{ .allocator = allocator, .header = try readHeader(file), .section_headers = undefined, .program_headers = undefined, }; const is_64 = hdrs.header.is_64; const need_bswap = hdrs.header.endian != std.builtin.endian; hdrs.section_headers = try allocator.alloc(Elf64_Shdr, hdrs.header.shnum); errdefer allocator.free(hdrs.section_headers); hdrs.program_headers = try allocator.alloc(Elf64_Phdr, hdrs.header.phnum); errdefer allocator.free(hdrs.program_headers); // If the ELF file is 64-bit and same-endianness, then all we have to do is // yeet the bytes into memory. // If only the endianness is different, they can be simply byte swapped. if (is_64) { const shdr_buf = std.mem.sliceAsBytes(hdrs.section_headers); const phdr_buf = std.mem.sliceAsBytes(hdrs.program_headers); try preadNoEof(file, shdr_buf, hdrs.header.shoff); try preadNoEof(file, phdr_buf, hdrs.header.phoff); if (need_bswap) { for (hdrs.section_headers) |*shdr| { shdr.* = .{ .sh_name = @byteSwap(@TypeOf(shdr.sh_name), shdr.sh_name), .sh_type = @byteSwap(@TypeOf(shdr.sh_type), shdr.sh_type), .sh_flags = @byteSwap(@TypeOf(shdr.sh_flags), shdr.sh_flags), .sh_addr = @byteSwap(@TypeOf(shdr.sh_addr), shdr.sh_addr), .sh_offset = @byteSwap(@TypeOf(shdr.sh_offset), shdr.sh_offset), .sh_size = @byteSwap(@TypeOf(shdr.sh_size), shdr.sh_size), .sh_link = @byteSwap(@TypeOf(shdr.sh_link), shdr.sh_link), .sh_info = @byteSwap(@TypeOf(shdr.sh_info), shdr.sh_info), .sh_addralign = @byteSwap(@TypeOf(shdr.sh_addralign), shdr.sh_addralign), .sh_entsize = @byteSwap(@TypeOf(shdr.sh_entsize), shdr.sh_entsize), }; } for (hdrs.program_headers) |*phdr| { phdr.* = .{ .p_type = @byteSwap(@TypeOf(phdr.p_type), phdr.p_type), .p_offset = @byteSwap(@TypeOf(phdr.p_offset), phdr.p_offset), .p_vaddr = @byteSwap(@TypeOf(phdr.p_vaddr), phdr.p_vaddr), .p_paddr = @byteSwap(@TypeOf(phdr.p_paddr), phdr.p_paddr), .p_filesz = @byteSwap(@TypeOf(phdr.p_filesz), phdr.p_filesz), .p_memsz = @byteSwap(@TypeOf(phdr.p_memsz), phdr.p_memsz), .p_flags = @byteSwap(@TypeOf(phdr.p_flags), phdr.p_flags), .p_align = @byteSwap(@TypeOf(phdr.p_align), phdr.p_align), }; } } return hdrs; } const shdrs_32 = try allocator.alloc(Elf32_Shdr, hdrs.header.shnum); defer allocator.free(shdrs_32); const phdrs_32 = try allocator.alloc(Elf32_Phdr, hdrs.header.phnum); defer allocator.free(phdrs_32); const shdr_buf = std.mem.sliceAsBytes(shdrs_32); const phdr_buf = std.mem.sliceAsBytes(phdrs_32); try preadNoEof(file, shdr_buf, hdrs.header.shoff); try preadNoEof(file, phdr_buf, hdrs.header.phoff); if (need_bswap) { for (hdrs.section_headers) |*shdr, i| { const o = shdrs_32[i]; shdr.* = .{ .sh_name = @byteSwap(@TypeOf(o.sh_name), o.sh_name), .sh_type = @byteSwap(@TypeOf(o.sh_type), o.sh_type), .sh_flags = @byteSwap(@TypeOf(o.sh_flags), o.sh_flags), .sh_addr = @byteSwap(@TypeOf(o.sh_addr), o.sh_addr), .sh_offset = @byteSwap(@TypeOf(o.sh_offset), o.sh_offset), .sh_size = @byteSwap(@TypeOf(o.sh_size), o.sh_size), .sh_link = @byteSwap(@TypeOf(o.sh_link), o.sh_link), .sh_info = @byteSwap(@TypeOf(o.sh_info), o.sh_info), .sh_addralign = @byteSwap(@TypeOf(o.sh_addralign), o.sh_addralign), .sh_entsize = @byteSwap(@TypeOf(o.sh_entsize), o.sh_entsize), }; } for (hdrs.program_headers) |*phdr, i| { const o = phdrs_32[i]; phdr.* = .{ .p_type = @byteSwap(@TypeOf(o.p_type), o.p_type), .p_offset = @byteSwap(@TypeOf(o.p_offset), o.p_offset), .p_vaddr = @byteSwap(@TypeOf(o.p_vaddr), o.p_vaddr), .p_paddr = @byteSwap(@TypeOf(o.p_paddr), o.p_paddr), .p_filesz = @byteSwap(@TypeOf(o.p_filesz), o.p_filesz), .p_memsz = @byteSwap(@TypeOf(o.p_memsz), o.p_memsz), .p_flags = @byteSwap(@TypeOf(o.p_flags), o.p_flags), .p_align = @byteSwap(@TypeOf(o.p_align), o.p_align), }; } } else { for (hdrs.section_headers) |*shdr, i| { const o = shdrs_32[i]; shdr.* = .{ .sh_name = o.sh_name, .sh_type = o.sh_type, .sh_flags = o.sh_flags, .sh_addr = o.sh_addr, .sh_offset = o.sh_offset, .sh_size = o.sh_size, .sh_link = o.sh_link, .sh_info = o.sh_info, .sh_addralign = o.sh_addralign, .sh_entsize = o.sh_entsize, }; } for (hdrs.program_headers) |*phdr, i| { const o = phdrs_32[i]; phdr.* = .{ .p_type = o.p_type, .p_offset = o.p_offset, .p_vaddr = o.p_vaddr, .p_paddr = o.p_paddr, .p_filesz = o.p_filesz, .p_memsz = o.p_memsz, .p_flags = o.p_flags, .p_align = o.p_align, }; } } return hdrs; } pub fn int(is_64: bool, need_bswap: bool, int_32: var, int_64: var) @TypeOf(int_64) { if (is_64) { if (need_bswap) { return @byteSwap(@TypeOf(int_64), int_64); } else { return int_64; } } else { return int32(need_bswap, int_32, @TypeOf(int_64)); } } pub fn int32(need_bswap: bool, int_32: var, comptime Int64: var) Int64 { if (need_bswap) { return @byteSwap(@TypeOf(int_32), int_32); } else { return int_32; } } fn preadNoEof(file: std.fs.File, buf: []u8, offset: u64) !void { var i: u64 = 0; while (i < buf.len) { const len = file.pread(buf[i .. buf.len - i], offset + i) catch |err| switch (err) { error.SystemResources => return error.SystemResources, error.IsDir => return error.UnableToReadElfFile, error.OperationAborted => return error.UnableToReadElfFile, error.BrokenPipe => return error.UnableToReadElfFile, error.Unseekable => return error.UnableToReadElfFile, error.ConnectionResetByPeer => return error.UnableToReadElfFile, error.InputOutput => return error.FileSystem, error.Unexpected => return error.Unexpected, error.WouldBlock => return error.Unexpected, }; if (len == 0) return error.UnexpectedEndOfFile; i += len; } } pub const EI_NIDENT = 16; pub const EI_CLASS = 4; pub const ELFCLASSNONE = 0; pub const ELFCLASS32 = 1; pub const ELFCLASS64 = 2; pub const ELFCLASSNUM = 3; pub const EI_DATA = 5; pub const ELFDATANONE = 0; pub const ELFDATA2LSB = 1; pub const ELFDATA2MSB = 2; pub const ELFDATANUM = 3; pub const EI_VERSION = 6; pub const Elf32_Half = u16; pub const Elf64_Half = u16; pub const Elf32_Word = u32; pub const Elf32_Sword = i32; pub const Elf64_Word = u32; pub const Elf64_Sword = i32; pub const Elf32_Xword = u64; pub const Elf32_Sxword = i64; pub const Elf64_Xword = u64; pub const Elf64_Sxword = i64; pub const Elf32_Addr = u32; pub const Elf64_Addr = u64; pub const Elf32_Off = u32; pub const Elf64_Off = u64; pub const Elf32_Section = u16; pub const Elf64_Section = u16; pub const Elf32_Versym = Elf32_Half; pub const Elf64_Versym = Elf64_Half; pub const Elf32_Ehdr = extern struct { e_ident: [EI_NIDENT]u8, e_type: ET, e_machine: EM, e_version: Elf32_Word, e_entry: Elf32_Addr, e_phoff: Elf32_Off, e_shoff: Elf32_Off, e_flags: Elf32_Word, e_ehsize: Elf32_Half, e_phentsize: Elf32_Half, e_phnum: Elf32_Half, e_shentsize: Elf32_Half, e_shnum: Elf32_Half, e_shstrndx: Elf32_Half, }; pub const Elf64_Ehdr = extern struct { e_ident: [EI_NIDENT]u8, e_type: ET, e_machine: EM, e_version: Elf64_Word, e_entry: Elf64_Addr, e_phoff: Elf64_Off, e_shoff: Elf64_Off, e_flags: Elf64_Word, e_ehsize: Elf64_Half, e_phentsize: Elf64_Half, e_phnum: Elf64_Half, e_shentsize: Elf64_Half, e_shnum: Elf64_Half, e_shstrndx: Elf64_Half, }; pub const Elf32_Phdr = extern struct { p_type: Elf32_Word, p_offset: Elf32_Off, p_vaddr: Elf32_Addr, p_paddr: Elf32_Addr, p_filesz: Elf32_Word, p_memsz: Elf32_Word, p_flags: Elf32_Word, p_align: Elf32_Word, }; pub const Elf64_Phdr = extern struct { p_type: Elf64_Word, p_flags: Elf64_Word, p_offset: Elf64_Off, p_vaddr: Elf64_Addr, p_paddr: Elf64_Addr, p_filesz: Elf64_Xword, p_memsz: Elf64_Xword, p_align: Elf64_Xword, }; pub const Elf32_Shdr = extern struct { sh_name: Elf32_Word, sh_type: Elf32_Word, sh_flags: Elf32_Word, sh_addr: Elf32_Addr, sh_offset: Elf32_Off, sh_size: Elf32_Word, sh_link: Elf32_Word, sh_info: Elf32_Word, sh_addralign: Elf32_Word, sh_entsize: Elf32_Word, }; pub const Elf64_Shdr = extern struct { sh_name: Elf64_Word, sh_type: Elf64_Word, sh_flags: Elf64_Xword, sh_addr: Elf64_Addr, sh_offset: Elf64_Off, sh_size: Elf64_Xword, sh_link: Elf64_Word, sh_info: Elf64_Word, sh_addralign: Elf64_Xword, sh_entsize: Elf64_Xword, }; pub const Elf32_Chdr = extern struct { ch_type: Elf32_Word, ch_size: Elf32_Word, ch_addralign: Elf32_Word, }; pub const Elf64_Chdr = extern struct { ch_type: Elf64_Word, ch_reserved: Elf64_Word, ch_size: Elf64_Xword, ch_addralign: Elf64_Xword, }; pub const Elf32_Sym = extern struct { st_name: Elf32_Word, st_value: Elf32_Addr, st_size: Elf32_Word, st_info: u8, st_other: u8, st_shndx: Elf32_Section, }; pub const Elf64_Sym = extern struct { st_name: Elf64_Word, st_info: u8, st_other: u8, st_shndx: Elf64_Section, st_value: Elf64_Addr, st_size: Elf64_Xword, }; pub const Elf32_Syminfo = extern struct { si_boundto: Elf32_Half, si_flags: Elf32_Half, }; pub const Elf64_Syminfo = extern struct { si_boundto: Elf64_Half, si_flags: Elf64_Half, }; pub const Elf32_Rel = extern struct { r_offset: Elf32_Addr, r_info: Elf32_Word, }; pub const Elf64_Rel = extern struct { r_offset: Elf64_Addr, r_info: Elf64_Xword, }; pub const Elf32_Rela = extern struct { r_offset: Elf32_Addr, r_info: Elf32_Word, r_addend: Elf32_Sword, }; pub const Elf64_Rela = extern struct { r_offset: Elf64_Addr, r_info: Elf64_Xword, r_addend: Elf64_Sxword, }; pub const Elf32_Dyn = extern struct { d_tag: Elf32_Sword, d_val: Elf32_Addr, }; pub const Elf64_Dyn = extern struct { d_tag: Elf64_Sxword, d_val: Elf64_Addr, }; pub const Elf32_Verdef = extern struct { vd_version: Elf32_Half, vd_flags: Elf32_Half, vd_ndx: Elf32_Half, vd_cnt: Elf32_Half, vd_hash: Elf32_Word, vd_aux: Elf32_Word, vd_next: Elf32_Word, }; pub const Elf64_Verdef = extern struct { vd_version: Elf64_Half, vd_flags: Elf64_Half, vd_ndx: Elf64_Half, vd_cnt: Elf64_Half, vd_hash: Elf64_Word, vd_aux: Elf64_Word, vd_next: Elf64_Word, }; pub const Elf32_Verdaux = extern struct { vda_name: Elf32_Word, vda_next: Elf32_Word, }; pub const Elf64_Verdaux = extern struct { vda_name: Elf64_Word, vda_next: Elf64_Word, }; pub const Elf32_Verneed = extern struct { vn_version: Elf32_Half, vn_cnt: Elf32_Half, vn_file: Elf32_Word, vn_aux: Elf32_Word, vn_next: Elf32_Word, }; pub const Elf64_Verneed = extern struct { vn_version: Elf64_Half, vn_cnt: Elf64_Half, vn_file: Elf64_Word, vn_aux: Elf64_Word, vn_next: Elf64_Word, }; pub const Elf32_Vernaux = extern struct { vna_hash: Elf32_Word, vna_flags: Elf32_Half, vna_other: Elf32_Half, vna_name: Elf32_Word, vna_next: Elf32_Word, }; pub const Elf64_Vernaux = extern struct { vna_hash: Elf64_Word, vna_flags: Elf64_Half, vna_other: Elf64_Half, vna_name: Elf64_Word, vna_next: Elf64_Word, }; pub const Elf32_auxv_t = extern struct { a_type: u32, a_un: extern union { a_val: u32, }, }; pub const Elf64_auxv_t = extern struct { a_type: u64, a_un: extern union { a_val: u64, }, }; pub const Elf32_Nhdr = extern struct { n_namesz: Elf32_Word, n_descsz: Elf32_Word, n_type: Elf32_Word, }; pub const Elf64_Nhdr = extern struct { n_namesz: Elf64_Word, n_descsz: Elf64_Word, n_type: Elf64_Word, }; pub const Elf32_Move = extern struct { m_value: Elf32_Xword, m_info: Elf32_Word, m_poffset: Elf32_Word, m_repeat: Elf32_Half, m_stride: Elf32_Half, }; pub const Elf64_Move = extern struct { m_value: Elf64_Xword, m_info: Elf64_Xword, m_poffset: Elf64_Xword, m_repeat: Elf64_Half, m_stride: Elf64_Half, }; pub const Elf32_gptab = extern union { gt_header: extern struct { gt_current_g_value: Elf32_Word, gt_unused: Elf32_Word, }, gt_entry: extern struct { gt_g_value: Elf32_Word, gt_bytes: Elf32_Word, }, }; pub const Elf32_RegInfo = extern struct { ri_gprmask: Elf32_Word, ri_cprmask: [4]Elf32_Word, ri_gp_value: Elf32_Sword, }; pub const Elf_Options = extern struct { kind: u8, size: u8, @"section": Elf32_Section, info: Elf32_Word, }; pub const Elf_Options_Hw = extern struct { hwp_flags1: Elf32_Word, hwp_flags2: Elf32_Word, }; pub const Elf32_Lib = extern struct { l_name: Elf32_Word, l_time_stamp: Elf32_Word, l_checksum: Elf32_Word, l_version: Elf32_Word, l_flags: Elf32_Word, }; pub const Elf64_Lib = extern struct { l_name: Elf64_Word, l_time_stamp: Elf64_Word, l_checksum: Elf64_Word, l_version: Elf64_Word, l_flags: Elf64_Word, }; pub const Elf32_Conflict = Elf32_Addr; pub const Elf_MIPS_ABIFlags_v0 = extern struct { version: Elf32_Half, isa_level: u8, isa_rev: u8, gpr_size: u8, cpr1_size: u8, cpr2_size: u8, fp_abi: u8, isa_ext: Elf32_Word, ases: Elf32_Word, flags1: Elf32_Word, flags2: Elf32_Word, }; comptime { debug.assert(@sizeOf(Elf32_Ehdr) == 52); debug.assert(@sizeOf(Elf64_Ehdr) == 64); debug.assert(@sizeOf(Elf32_Phdr) == 32); debug.assert(@sizeOf(Elf64_Phdr) == 56); debug.assert(@sizeOf(Elf32_Shdr) == 40); debug.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"), }; pub const Ehdr = switch (@sizeOf(usize)) { 4 => Elf32_Ehdr, 8 => Elf64_Ehdr, else => @compileError("expected pointer size of 32 or 64"), }; pub const Phdr = switch (@sizeOf(usize)) { 4 => Elf32_Phdr, 8 => Elf64_Phdr, else => @compileError("expected pointer size of 32 or 64"), }; pub const Dyn = switch (@sizeOf(usize)) { 4 => Elf32_Dyn, 8 => Elf64_Dyn, else => @compileError("expected pointer size of 32 or 64"), }; pub const Shdr = switch (@sizeOf(usize)) { 4 => Elf32_Shdr, 8 => Elf64_Shdr, else => @compileError("expected pointer size of 32 or 64"), }; pub const Sym = switch (@sizeOf(usize)) { 4 => Elf32_Sym, 8 => Elf64_Sym, else => @compileError("expected pointer size of 32 or 64"), }; pub const Verdef = switch (@sizeOf(usize)) { 4 => Elf32_Verdef, 8 => Elf64_Verdef, else => @compileError("expected pointer size of 32 or 64"), }; pub const Verdaux = switch (@sizeOf(usize)) { 4 => Elf32_Verdaux, 8 => Elf64_Verdaux, else => @compileError("expected pointer size of 32 or 64"), }; /// Machine architectures /// See current registered ELF machine architectures at: /// http://www.uxsglobal.com/developers/gabi/latest/ch4.eheader.html /// The underscore prefix is because many of these start with numbers. pub const EM = extern enum(u16) { /// No machine _NONE = 0, /// AT&T WE 32100 _M32 = 1, /// SPARC _SPARC = 2, /// Intel 386 _386 = 3, /// Motorola 68000 _68K = 4, /// Motorola 88000 _88K = 5, /// Intel MCU _IAMCU = 6, /// Intel 80860 _860 = 7, /// MIPS R3000 _MIPS = 8, /// IBM System/370 _S370 = 9, /// MIPS RS3000 Little-endian _MIPS_RS3_LE = 10, /// Hewlett-Packard PA-RISC _PARISC = 15, /// Fujitsu VPP500 _VPP500 = 17, /// Enhanced instruction set SPARC _SPARC32PLUS = 18, /// Intel 80960 _960 = 19, /// PowerPC _PPC = 20, /// PowerPC64 _PPC64 = 21, /// IBM System/390 _S390 = 22, /// IBM SPU/SPC _SPU = 23, /// NEC V800 _V800 = 36, /// Fujitsu FR20 _FR20 = 37, /// TRW RH-32 _RH32 = 38, /// Motorola RCE _RCE = 39, /// ARM _ARM = 40, /// DEC Alpha _ALPHA = 41, /// Hitachi SH _SH = 42, /// SPARC V9 _SPARCV9 = 43, /// Siemens TriCore _TRICORE = 44, /// Argonaut RISC Core _ARC = 45, /// Hitachi H8/300 _H8_300 = 46, /// Hitachi H8/300H _H8_300H = 47, /// Hitachi H8S _H8S = 48, /// Hitachi H8/500 _H8_500 = 49, /// Intel IA-64 processor architecture _IA_64 = 50, /// Stanford MIPS-X _MIPS_X = 51, /// Motorola ColdFire _COLDFIRE = 52, /// Motorola M68HC12 _68HC12 = 53, /// Fujitsu MMA Multimedia Accelerator _MMA = 54, /// Siemens PCP _PCP = 55, /// Sony nCPU embedded RISC processor _NCPU = 56, /// Denso NDR1 microprocessor _NDR1 = 57, /// Motorola Star*Core processor _STARCORE = 58, /// Toyota ME16 processor _ME16 = 59, /// STMicroelectronics ST100 processor _ST100 = 60, /// Advanced Logic Corp. TinyJ embedded processor family _TINYJ = 61, /// AMD x86-64 architecture _X86_64 = 62, /// Sony DSP Processor _PDSP = 63, /// Digital Equipment Corp. PDP-10 _PDP10 = 64, /// Digital Equipment Corp. PDP-11 _PDP11 = 65, /// Siemens FX66 microcontroller _FX66 = 66, /// STMicroelectronics ST9+ 8/16 bit microcontroller _ST9PLUS = 67, /// STMicroelectronics ST7 8-bit microcontroller _ST7 = 68, /// Motorola MC68HC16 Microcontroller _68HC16 = 69, /// Motorola MC68HC11 Microcontroller _68HC11 = 70, /// Motorola MC68HC08 Microcontroller _68HC08 = 71, /// Motorola MC68HC05 Microcontroller _68HC05 = 72, /// Silicon Graphics SVx _SVX = 73, /// STMicroelectronics ST19 8-bit microcontroller _ST19 = 74, /// Digital VAX _VAX = 75, /// Axis Communications 32-bit embedded processor _CRIS = 76, /// Infineon Technologies 32-bit embedded processor _JAVELIN = 77, /// Element 14 64-bit DSP Processor _FIREPATH = 78, /// LSI Logic 16-bit DSP Processor _ZSP = 79, /// Donald Knuth's educational 64-bit processor _MMIX = 80, /// Harvard University machine-independent object files _HUANY = 81, /// SiTera Prism _PRISM = 82, /// Atmel AVR 8-bit microcontroller _AVR = 83, /// Fujitsu FR30 _FR30 = 84, /// Mitsubishi D10V _D10V = 85, /// Mitsubishi D30V _D30V = 86, /// NEC v850 _V850 = 87, /// Mitsubishi M32R _M32R = 88, /// Matsushita MN10300 _MN10300 = 89, /// Matsushita MN10200 _MN10200 = 90, /// picoJava _PJ = 91, /// OpenRISC 32-bit embedded processor _OPENRISC = 92, /// ARC International ARCompact processor (old spelling/synonym: EM_ARC_A5) _ARC_COMPACT = 93, /// Tensilica Xtensa Architecture _XTENSA = 94, /// Alphamosaic VideoCore processor _VIDEOCORE = 95, /// Thompson Multimedia General Purpose Processor _TMM_GPP = 96, /// National Semiconductor 32000 series _NS32K = 97, /// Tenor Network TPC processor _TPC = 98, /// Trebia SNP 1000 processor _SNP1K = 99, /// STMicroelectronics (www.st.com) ST200 _ST200 = 100, /// Ubicom IP2xxx microcontroller family _IP2K = 101, /// MAX Processor _MAX = 102, /// National Semiconductor CompactRISC microprocessor _CR = 103, /// Fujitsu F2MC16 _F2MC16 = 104, /// Texas Instruments embedded microcontroller msp430 _MSP430 = 105, /// Analog Devices Blackfin (DSP) processor _BLACKFIN = 106, /// S1C33 Family of Seiko Epson processors _SE_C33 = 107, /// Sharp embedded microprocessor _SEP = 108, /// Arca RISC Microprocessor _ARCA = 109, /// Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University _UNICORE = 110, /// eXcess: 16/32/64-bit configurable embedded CPU _EXCESS = 111, /// Icera Semiconductor Inc. Deep Execution Processor _DXP = 112, /// Altera Nios II soft-core processor _ALTERA_NIOS2 = 113, /// National Semiconductor CompactRISC CRX _CRX = 114, /// Motorola XGATE embedded processor _XGATE = 115, /// Infineon C16x/XC16x processor _C166 = 116, /// Renesas M16C series microprocessors _M16C = 117, /// Microchip Technology dsPIC30F Digital Signal Controller _DSPIC30F = 118, /// Freescale Communication Engine RISC core _CE = 119, /// Renesas M32C series microprocessors _M32C = 120, /// Altium TSK3000 core _TSK3000 = 131, /// Freescale RS08 embedded processor _RS08 = 132, /// Analog Devices SHARC family of 32-bit DSP processors _SHARC = 133, /// Cyan Technology eCOG2 microprocessor _ECOG2 = 134, /// Sunplus S+core7 RISC processor _SCORE7 = 135, /// New Japan Radio (NJR) 24-bit DSP Processor _DSP24 = 136, /// Broadcom VideoCore III processor _VIDEOCORE3 = 137, /// RISC processor for Lattice FPGA architecture _LATTICEMICO32 = 138, /// Seiko Epson C17 family _SE_C17 = 139, /// The Texas Instruments TMS320C6000 DSP family _TI_C6000 = 140, /// The Texas Instruments TMS320C2000 DSP family _TI_C2000 = 141, /// The Texas Instruments TMS320C55x DSP family _TI_C5500 = 142, /// STMicroelectronics 64bit VLIW Data Signal Processor _MMDSP_PLUS = 160, /// Cypress M8C microprocessor _CYPRESS_M8C = 161, /// Renesas R32C series microprocessors _R32C = 162, /// NXP Semiconductors TriMedia architecture family _TRIMEDIA = 163, /// Qualcomm Hexagon processor _HEXAGON = 164, /// Intel 8051 and variants _8051 = 165, /// STMicroelectronics STxP7x family of configurable and extensible RISC processors _STXP7X = 166, /// Andes Technology compact code size embedded RISC processor family _NDS32 = 167, /// Cyan Technology eCOG1X family _ECOG1X = 168, /// Dallas Semiconductor MAXQ30 Core Micro-controllers _MAXQ30 = 169, /// New Japan Radio (NJR) 16-bit DSP Processor _XIMO16 = 170, /// M2000 Reconfigurable RISC Microprocessor _MANIK = 171, /// Cray Inc. NV2 vector architecture _CRAYNV2 = 172, /// Renesas RX family _RX = 173, /// Imagination Technologies META processor architecture _METAG = 174, /// MCST Elbrus general purpose hardware architecture _MCST_ELBRUS = 175, /// Cyan Technology eCOG16 family _ECOG16 = 176, /// National Semiconductor CompactRISC CR16 16-bit microprocessor _CR16 = 177, /// Freescale Extended Time Processing Unit _ETPU = 178, /// Infineon Technologies SLE9X core _SLE9X = 179, /// Intel L10M _L10M = 180, /// Intel K10M _K10M = 181, /// ARM AArch64 _AARCH64 = 183, /// Atmel Corporation 32-bit microprocessor family _AVR32 = 185, /// STMicroeletronics STM8 8-bit microcontroller _STM8 = 186, /// Tilera TILE64 multicore architecture family _TILE64 = 187, /// Tilera TILEPro multicore architecture family _TILEPRO = 188, /// NVIDIA CUDA architecture _CUDA = 190, /// Tilera TILE-Gx multicore architecture family _TILEGX = 191, /// CloudShield architecture family _CLOUDSHIELD = 192, /// KIPO-KAIST Core-A 1st generation processor family _COREA_1ST = 193, /// KIPO-KAIST Core-A 2nd generation processor family _COREA_2ND = 194, /// Synopsys ARCompact V2 _ARC_COMPACT2 = 195, /// Open8 8-bit RISC soft processor core _OPEN8 = 196, /// Renesas RL78 family _RL78 = 197, /// Broadcom VideoCore V processor _VIDEOCORE5 = 198, /// Renesas 78KOR family _78KOR = 199, /// Freescale 56800EX Digital Signal Controller (DSC) _56800EX = 200, /// Beyond BA1 CPU architecture _BA1 = 201, /// Beyond BA2 CPU architecture _BA2 = 202, /// XMOS xCORE processor family _XCORE = 203, /// Microchip 8-bit PIC(r) family _MCHP_PIC = 204, /// Reserved by Intel _INTEL205 = 205, /// Reserved by Intel _INTEL206 = 206, /// Reserved by Intel _INTEL207 = 207, /// Reserved by Intel _INTEL208 = 208, /// Reserved by Intel _INTEL209 = 209, /// KM211 KM32 32-bit processor _KM32 = 210, /// KM211 KMX32 32-bit processor _KMX32 = 211, /// KM211 KMX16 16-bit processor _KMX16 = 212, /// KM211 KMX8 8-bit processor _KMX8 = 213, /// KM211 KVARC processor _KVARC = 214, /// Paneve CDP architecture family _CDP = 215, /// Cognitive Smart Memory Processor _COGE = 216, /// iCelero CoolEngine _COOL = 217, /// Nanoradio Optimized RISC _NORC = 218, /// CSR Kalimba architecture family _CSR_KALIMBA = 219, /// AMD GPU architecture _AMDGPU = 224, /// RISC-V _RISCV = 243, /// Lanai 32-bit processor _LANAI = 244, /// Linux kernel bpf virtual machine _BPF = 247, }; /// Section data should be writable during execution. pub const SHF_WRITE = 0x1; /// Section occupies memory during program execution. pub const SHF_ALLOC = 0x2; /// Section contains executable machine instructions. pub const SHF_EXECINSTR = 0x4; /// The data in this section may be merged. pub const SHF_MERGE = 0x10; /// The data in this section is null-terminated strings. pub const SHF_STRINGS = 0x20; /// A field in this section holds a section header table index. pub const SHF_INFO_LINK = 0x40; /// Adds special ordering requirements for link editors. pub const SHF_LINK_ORDER = 0x80; /// This section requires special OS-specific processing to avoid incorrect /// behavior. pub const SHF_OS_NONCONFORMING = 0x100; /// This section is a member of a section group. pub const SHF_GROUP = 0x200; /// This section holds Thread-Local Storage. pub const SHF_TLS = 0x400; /// Identifies a section containing compressed data. pub const SHF_COMPRESSED = 0x800; /// This section is excluded from the final executable or shared library. pub const SHF_EXCLUDE = 0x80000000; /// Start of target-specific flags. pub const SHF_MASKOS = 0x0ff00000; /// Bits indicating processor-specific flags. pub const SHF_MASKPROC = 0xf0000000; /// 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. pub const XCORE_SHF_DP_SECTION = 0x10000000; /// 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. pub const XCORE_SHF_CP_SECTION = 0x20000000; /// 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. pub const SHF_X86_64_LARGE = 0x10000000; /// All sections with the GPREL flag are grouped into a global data area /// for faster accesses pub const SHF_HEX_GPREL = 0x10000000; /// Section contains text/data which may be replicated in other sections. /// Linker must retain only one copy. pub const SHF_MIPS_NODUPES = 0x01000000; /// Linker must generate implicit hidden weak names. pub const SHF_MIPS_NAMES = 0x02000000; /// Section data local to process. pub const SHF_MIPS_LOCAL = 0x04000000; /// Do not strip this section. pub const SHF_MIPS_NOSTRIP = 0x08000000; /// Section must be part of global data area. pub const SHF_MIPS_GPREL = 0x10000000; /// This section should be merged. pub const SHF_MIPS_MERGE = 0x20000000; /// Address size to be inferred from section entry size. pub const SHF_MIPS_ADDR = 0x40000000; /// Section data is string data by default. pub const SHF_MIPS_STRING = 0x80000000; /// Make code section unreadable when in execute-only mode pub const SHF_ARM_PURECODE = 0x2000000; /// Execute pub const PF_X = 1; /// Write pub const PF_W = 2; /// Read pub const PF_R = 4; /// Bits for operating system-specific semantics. pub const PF_MASKOS = 0x0ff00000; /// Bits for processor-specific semantics. pub const PF_MASKPROC = 0xf0000000;