zig/lib/std / elf.zig

const std = @import("std.zig");
const math = std.math;
const mem = std.mem;
const assert = std.debug.assert;
const native_endian = @import("builtin").target.cpu.arch.endian();

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 DF_ORIGIN = 0x00000001;

pub const DF_SYMBOLIC = 0x00000002;

pub const DF_TEXTREL = 0x00000004;

pub const DF_BIND_NOW = 0x00000008;

pub const DF_STATIC_TLS = 0x00000010;

pub const DF_1_NOW = 0x00000001;

pub const DF_1_GLOBAL = 0x00000002;

pub const DF_1_GROUP = 0x00000004;

pub const DF_1_NODELETE = 0x00000008;

pub const DF_1_LOADFLTR = 0x00000010;

pub const DF_1_INITFIRST = 0x00000020;

pub const DF_1_NOOPEN = 0x00000040;

pub const DF_1_ORIGIN = 0x00000080;

pub const DF_1_DIRECT = 0x00000100;

pub const DF_1_TRANS = 0x00000200;

pub const DF_1_INTERPOSE = 0x00000400;

pub const DF_1_NODEFLIB = 0x00000800;

pub const DF_1_NODUMP = 0x00001000;

pub const DF_1_CONFALT = 0x00002000;

pub const DF_1_ENDFILTEE = 0x00004000;

pub const DF_1_DISPRELDNE = 0x00008000;

pub const DF_1_DISPRELPND = 0x00010000;

pub const DF_1_NODIRECT = 0x00020000;

pub const DF_1_IGNMULDEF = 0x00040000;

pub const DF_1_NOKSYMS = 0x00080000;

pub const DF_1_NOHDR = 0x00100000;

pub const DF_1_EDITED = 0x00200000;

pub const DF_1_NORELOC = 0x00400000;

pub const DF_1_SYMINTPOSE = 0x00800000;

pub const DF_1_GLOBAUDIT = 0x01000000;

pub const DF_1_SINGLETON = 0x02000000;

pub const DF_1_STUB = 0x04000000;

pub const DF_1_PIE = 0x08000000;

pub const VERSYM_HIDDEN = 0x8000;

pub const VERSYM_VERSION = 0x7fff;

pub const VER_NDX_LOCAL = 0;

pub const VER_NDX_GLOBAL = 1;

pub const VER_NDX_LORESERVE = 0xff00;

pub const VER_NDX_ELIMINATE = 0xff01;

pub const VER_FLG_BASE = 1;

pub const VER_FLG_WEAK = 2;

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_LLVM_ADDRSIG = 0x6fff4c03;

pub const SHT_GNU_HASH = 0x6ffffff6;

pub const SHT_GNU_VERDEF = 0x6ffffffd;

pub const SHT_GNU_VERNEED = 0x6ffffffe;

pub const SHT_GNU_VERSYM = 0x6fffffff;

pub const SHT_HIOS = 0x6fffffff;

pub const SHT_LOPROC = 0x70000000;

pub const SHT_X86_64_UNWIND = 0x70000001;

pub const SHT_HIPROC = 0x7fffffff;

pub const SHT_LOUSER = 0x80000000;

pub const SHT_HIUSER = 0xffffffff;

// Note type for .note.gnu.build_id

pub const NT_GNU_BUILD_ID = 3;

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 MAGIC = "\x7fELF";

pub const ET = enum(u16) {
    NONE = 0,

    REL = 1,

    EXEC = 2,

    DYN = 3,

    CORE = 4,

    pub const LOPROC = 0xff00;

    pub const HIPROC = 0xffff;
};

pub const Header = struct {
    endian: std.builtin.Endian,
    machine: EM,
    is_64: bool,
    entry: u64,
    phoff: u64,
    shoff: u64,
    phentsize: u16,
    phnum: u16,
    shentsize: u16,
    shnum: u16,
    shstrndx: u16,

    pub fn program_header_iterator(self: Header, parse_source: anytype) ProgramHeaderIterator(@TypeOf(parse_source)) {
        return ProgramHeaderIterator(@TypeOf(parse_source)){
            .elf_header = self,
            .parse_source = parse_source,
        };
    }

    pub fn section_header_iterator(self: Header, parse_source: anytype) SectionHeaderIterator(@TypeOf(parse_source)) {
        return SectionHeaderIterator(@TypeOf(parse_source)){
            .elf_header = self,
            .parse_source = parse_source,
        };
    }

    pub fn read(parse_source: anytype) !Header {
        var hdr_buf: [@sizeOf(Elf64_Ehdr)]u8 align(@alignOf(Elf64_Ehdr)) = undefined;
        try parse_source.seekableStream().seekTo(0);
        try parse_source.reader().readNoEof(&hdr_buf);
        return Header.parse(&hdr_buf);
    }

    pub fn parse(hdr_buf: *align(@alignOf(Elf64_Ehdr)) const [@sizeOf(Elf64_Ehdr)]u8) !Header {
        const hdr32 = @as(*const Elf32_Ehdr, @ptrCast(hdr_buf));
        const hdr64 = @as(*const Elf64_Ehdr, @ptrCast(hdr_buf));
        if (!mem.eql(u8, hdr32.e_ident[0..4], MAGIC)) 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 != native_endian;

        const is_64 = switch (hdr32.e_ident[EI_CLASS]) {
            ELFCLASS32 => false,
            ELFCLASS64 => true,
            else => return error.InvalidElfClass,
        };

        const machine = if (need_bswap) blk: {
            const value = @intFromEnum(hdr32.e_machine);
            break :blk @as(EM, @enumFromInt(@byteSwap(value)));
        } else hdr32.e_machine;

        return @as(Header, .{
            .endian = endian,
            .machine = machine,
            .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),
        });
    }
};

pub fn ProgramHeaderIterator(comptime ParseSource: anytype) type {
    return struct {
        elf_header: Header,
        parse_source: ParseSource,
        index: usize = 0,

        pub fn next(self: *@This()) !?Elf64_Phdr {
            if (self.index >= self.elf_header.phnum) return null;
            defer self.index += 1;

            if (self.elf_header.is_64) {
                var phdr: Elf64_Phdr = undefined;
                const offset = self.elf_header.phoff + @sizeOf(@TypeOf(phdr)) * self.index;
                try self.parse_source.seekableStream().seekTo(offset);
                try self.parse_source.reader().readNoEof(mem.asBytes(&phdr));

                // ELF endianness matches native endianness.
                if (self.elf_header.endian == native_endian) return phdr;

                // Convert fields to native endianness.
                mem.byteSwapAllFields(Elf64_Phdr, &phdr);
                return phdr;
            }

            var phdr: Elf32_Phdr = undefined;
            const offset = self.elf_header.phoff + @sizeOf(@TypeOf(phdr)) * self.index;
            try self.parse_source.seekableStream().seekTo(offset);
            try self.parse_source.reader().readNoEof(mem.asBytes(&phdr));

            // ELF endianness does NOT match native endianness.
            if (self.elf_header.endian != native_endian) {
                // Convert fields to native endianness.
                mem.byteSwapAllFields(Elf32_Phdr, &phdr);
            }

            // Convert 32-bit header to 64-bit.
            return Elf64_Phdr{
                .p_type = phdr.p_type,
                .p_offset = phdr.p_offset,
                .p_vaddr = phdr.p_vaddr,
                .p_paddr = phdr.p_paddr,
                .p_filesz = phdr.p_filesz,
                .p_memsz = phdr.p_memsz,
                .p_flags = phdr.p_flags,
                .p_align = phdr.p_align,
            };
        }
    };
}

pub fn SectionHeaderIterator(comptime ParseSource: anytype) type {
    return struct {
        elf_header: Header,
        parse_source: ParseSource,
        index: usize = 0,

        pub fn next(self: *@This()) !?Elf64_Shdr {
            if (self.index >= self.elf_header.shnum) return null;
            defer self.index += 1;

            if (self.elf_header.is_64) {
                var shdr: Elf64_Shdr = undefined;
                const offset = self.elf_header.shoff + @sizeOf(@TypeOf(shdr)) * self.index;
                try self.parse_source.seekableStream().seekTo(offset);
                try self.parse_source.reader().readNoEof(mem.asBytes(&shdr));

                // ELF endianness matches native endianness.
                if (self.elf_header.endian == native_endian) return shdr;

                // Convert fields to native endianness.
                mem.byteSwapAllFields(Elf64_Shdr, &shdr);
                return shdr;
            }

            var shdr: Elf32_Shdr = undefined;
            const offset = self.elf_header.shoff + @sizeOf(@TypeOf(shdr)) * self.index;
            try self.parse_source.seekableStream().seekTo(offset);
            try self.parse_source.reader().readNoEof(mem.asBytes(&shdr));

            // ELF endianness does NOT match native endianness.
            if (self.elf_header.endian != native_endian) {
                // Convert fields to native endianness.
                mem.byteSwapAllFields(Elf32_Shdr, &shdr);
            }

            // Convert 32-bit header to 64-bit.
            return Elf64_Shdr{
                .sh_name = shdr.sh_name,
                .sh_type = shdr.sh_type,
                .sh_flags = shdr.sh_flags,
                .sh_addr = shdr.sh_addr,
                .sh_offset = shdr.sh_offset,
                .sh_size = shdr.sh_size,
                .sh_link = shdr.sh_link,
                .sh_info = shdr.sh_info,
                .sh_addralign = shdr.sh_addralign,
                .sh_entsize = shdr.sh_entsize,
            };
        }
    };
}

pub fn int(is_64: bool, need_bswap: bool, int_32: anytype, int_64: anytype) @TypeOf(int_64) {
    if (is_64) {
        if (need_bswap) {
            return @byteSwap(int_64);
        } else {
            return int_64;
        }
    } else {
        return int32(need_bswap, int_32, @TypeOf(int_64));
    }
}

pub fn int32(need_bswap: bool, int_32: anytype, comptime Int64: anytype) Int64 {
    if (need_bswap) {
        return @byteSwap(int_32);
    } else {
        return int_32;
    }
}

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: COMPRESS,
    ch_size: Elf32_Word,
    ch_addralign: Elf32_Word,
};

pub const Elf64_Chdr = extern struct {
    ch_type: COMPRESS,
    ch_reserved: Elf64_Word = 0,
    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 inline fn st_type(self: @This()) u4 {
        return @truncate(self.st_info);
    }

    pub inline fn st_bind(self: @This()) u4 {
        return @truncate(self.st_info >> 4);
    }
};

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 inline fn st_type(self: @This()) u4 {
        return @truncate(self.st_info);
    }

    pub inline fn st_bind(self: @This()) u4 {
        return @truncate(self.st_info >> 4);
    }
};

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 inline fn r_sym(self: @This()) u24 {
        return @truncate(self.r_info >> 8);
    }

    pub inline fn r_type(self: @This()) u8 {
        return @truncate(self.r_info);
    }
};

pub const Elf64_Rel = extern struct {
    r_offset: Elf64_Addr,
    r_info: Elf64_Xword,

    pub inline fn r_sym(self: @This()) u32 {
        return @truncate(self.r_info >> 32);
    }

    pub inline fn r_type(self: @This()) u32 {
        return @truncate(self.r_info);
    }
};

pub const Elf32_Rela = extern struct {
    r_offset: Elf32_Addr,
    r_info: Elf32_Word,
    r_addend: Elf32_Sword,

    pub inline fn r_sym(self: @This()) u24 {
        return @truncate(self.r_info >> 8);
    }

    pub inline fn r_type(self: @This()) u8 {
        return @truncate(self.r_info);
    }
};

pub const Elf64_Rela = extern struct {
    r_offset: Elf64_Addr,
    r_info: Elf64_Xword,
    r_addend: Elf64_Sxword,

    pub inline fn r_sym(self: @This()) u32 {
        return @truncate(self.r_info >> 32);
    }

    pub inline fn r_type(self: @This()) u32 {
        return @truncate(self.r_info);
    }
};

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 {
    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"),
};

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 Rel = switch (@sizeOf(usize)) {
    4 => Elf32_Rel,
    8 => Elf64_Rel,
    else => @compileError("expected pointer size of 32 or 64"),
};

pub const Rela = switch (@sizeOf(usize)) {
    4 => Elf32_Rela,
    8 => Elf64_Rela,
    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 Chdr = switch (@sizeOf(usize)) {
    4 => Elf32_Chdr,
    8 => Elf64_Chdr,
    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"),
};

pub const Addr = switch (@sizeOf(usize)) {
    4 => Elf32_Addr,
    8 => Elf64_Addr,
    else => @compileError("expected pointer size of 32 or 64"),
};

pub const Half = switch (@sizeOf(usize)) {
    4 => Elf32_Half,
    8 => Elf64_Half,
    else => @compileError("expected pointer size of 32 or 64"),
};

pub const EM = enum(u16) {
    NONE = 0,

    M32 = 1,

    SPARC = 2,

    @"386" = 3,

    @"68K" = 4,

    @"88K" = 5,

    IAMCU = 6,

    @"860" = 7,

    MIPS = 8,

    S370 = 9,

    MIPS_RS3_LE = 10,

    SPU_2 = 13,

    PARISC = 15,

    VPP500 = 17,

    SPARC32PLUS = 18,

    @"960" = 19,

    PPC = 20,

    PPC64 = 21,

    S390 = 22,

    SPU = 23,

    V800 = 36,

    FR20 = 37,

    RH32 = 38,

    RCE = 39,

    ARM = 40,

    ALPHA = 41,

    SH = 42,

    SPARCV9 = 43,

    TRICORE = 44,

    ARC = 45,

    H8_300 = 46,

    H8_300H = 47,

    H8S = 48,

    H8_500 = 49,

    IA_64 = 50,

    MIPS_X = 51,

    COLDFIRE = 52,

    @"68HC12" = 53,

    MMA = 54,

    PCP = 55,

    NCPU = 56,

    NDR1 = 57,

    STARCORE = 58,

    ME16 = 59,

    ST100 = 60,

    TINYJ = 61,

    X86_64 = 62,

    PDSP = 63,

    PDP10 = 64,

    PDP11 = 65,

    FX66 = 66,

    ST9PLUS = 67,

    ST7 = 68,

    @"68HC16" = 69,

    @"68HC11" = 70,

    @"68HC08" = 71,

    @"68HC05" = 72,

    SVX = 73,

    ST19 = 74,

    VAX = 75,

    CRIS = 76,

    JAVELIN = 77,

    FIREPATH = 78,

    ZSP = 79,

    MMIX = 80,

    HUANY = 81,

    PRISM = 82,

    AVR = 83,

    FR30 = 84,

    D10V = 85,

    D30V = 86,

    V850 = 87,

    M32R = 88,

    MN10300 = 89,

    MN10200 = 90,

    PJ = 91,

    OPENRISC = 92,

    ARC_COMPACT = 93,

    XTENSA = 94,

    VIDEOCORE = 95,

    TMM_GPP = 96,

    NS32K = 97,

    TPC = 98,

    SNP1K = 99,

    ST200 = 100,

    IP2K = 101,

    MAX = 102,

    CR = 103,

    F2MC16 = 104,

    MSP430 = 105,

    BLACKFIN = 106,

    SE_C33 = 107,

    SEP = 108,

    ARCA = 109,

    UNICORE = 110,

    EXCESS = 111,

    DXP = 112,

    ALTERA_NIOS2 = 113,

    CRX = 114,

    XGATE = 115,

    C166 = 116,

    M16C = 117,

    DSPIC30F = 118,

    CE = 119,

    M32C = 120,

    TSK3000 = 131,

    RS08 = 132,

    SHARC = 133,

    ECOG2 = 134,

    SCORE7 = 135,

    DSP24 = 136,

    VIDEOCORE3 = 137,

    LATTICEMICO32 = 138,

    SE_C17 = 139,

    TI_C6000 = 140,

    TI_C2000 = 141,

    TI_C5500 = 142,

    MMDSP_PLUS = 160,

    CYPRESS_M8C = 161,

    R32C = 162,

    TRIMEDIA = 163,

    HEXAGON = 164,

    @"8051" = 165,

    STXP7X = 166,

    NDS32 = 167,

    ECOG1X = 168,

    MAXQ30 = 169,

    XIMO16 = 170,

    MANIK = 171,

    CRAYNV2 = 172,

    RX = 173,

    METAG = 174,

    MCST_ELBRUS = 175,

    ECOG16 = 176,

    CR16 = 177,

    ETPU = 178,

    SLE9X = 179,

    L10M = 180,

    K10M = 181,

    AARCH64 = 183,

    AVR32 = 185,

    STM8 = 186,

    TILE64 = 187,

    TILEPRO = 188,

    CUDA = 190,

    TILEGX = 191,

    CLOUDSHIELD = 192,

    COREA_1ST = 193,

    COREA_2ND = 194,

    ARC_COMPACT2 = 195,

    OPEN8 = 196,

    RL78 = 197,

    VIDEOCORE5 = 198,

    @"78KOR" = 199,

    @"56800EX" = 200,

    BA1 = 201,

    BA2 = 202,

    XCORE = 203,

    MCHP_PIC = 204,

    INTEL205 = 205,

    INTEL206 = 206,

    INTEL207 = 207,

    INTEL208 = 208,

    INTEL209 = 209,

    KM32 = 210,

    KMX32 = 211,

    KMX16 = 212,

    KMX8 = 213,

    KVARC = 214,

    CDP = 215,

    COGE = 216,

    COOL = 217,

    NORC = 218,

    CSR_KALIMBA = 219,

    AMDGPU = 224,

    RISCV = 243,

    LANAI = 244,

    BPF = 247,

    CSKY = 252,

    FRV = 0x5441,

    _,

    pub fn toTargetCpuArch(em: EM) ?std.Target.Cpu.Arch {
        return switch (em) {
            .AVR => .avr,
            .MSP430 => .msp430,
            .ARC => .arc,
            .ARM => .arm,
            .HEXAGON => .hexagon,
            .@"68K" => .m68k,
            .MIPS => .mips,
            .MIPS_RS3_LE => .mipsel,
            .PPC => .powerpc,
            .SPARC => .sparc,
            .@"386" => .x86,
            .XCORE => .xcore,
            .CSR_KALIMBA => .kalimba,
            .LANAI => .lanai,
            .AARCH64 => .aarch64,
            .PPC64 => .powerpc64,
            .RISCV => .riscv64,
            .X86_64 => .x86_64,
            .BPF => .bpfel,
            .SPARCV9 => .sparc64,
            .S390 => .s390x,
            .SPU_2 => .spu_2,
            // there's many cases we don't (yet) handle, or will never have a
            // zig target cpu arch equivalent (such as null).
            else => null,
        };
    }
};

pub const SHF_WRITE = 0x1;

pub const SHF_ALLOC = 0x2;

pub const SHF_EXECINSTR = 0x4;

pub const SHF_MERGE = 0x10;

pub const SHF_STRINGS = 0x20;

pub const SHF_INFO_LINK = 0x40;

pub const SHF_LINK_ORDER = 0x80;

pub const SHF_OS_NONCONFORMING = 0x100;

pub const SHF_GROUP = 0x200;

pub const SHF_TLS = 0x400;

pub const SHF_COMPRESSED = 0x800;

pub const SHF_GNU_RETAIN = 0x200000;

pub const SHF_EXCLUDE = 0x80000000;

pub const SHF_MASKOS = 0x0ff00000;

pub const SHF_MASKPROC = 0xf0000000;

pub const XCORE_SHF_DP_SECTION = 0x10000000;

pub const XCORE_SHF_CP_SECTION = 0x20000000;

pub const SHF_X86_64_LARGE = 0x10000000;

pub const SHF_HEX_GPREL = 0x10000000;

pub const SHF_MIPS_NODUPES = 0x01000000;

pub const SHF_MIPS_NAMES = 0x02000000;

pub const SHF_MIPS_LOCAL = 0x04000000;

pub const SHF_MIPS_NOSTRIP = 0x08000000;

pub const SHF_MIPS_GPREL = 0x10000000;

pub const SHF_MIPS_MERGE = 0x20000000;

pub const SHF_MIPS_ADDR = 0x40000000;

pub const SHF_MIPS_STRING = 0x80000000;

pub const SHF_ARM_PURECODE = 0x2000000;

pub const PF_X = 1;

pub const PF_W = 2;

pub const PF_R = 4;

pub const PF_MASKOS = 0x0ff00000;

pub const PF_MASKPROC = 0xf0000000;

pub const SHN_UNDEF = 0;

pub const SHN_LORESERVE = 0xff00;

pub const SHN_LOPROC = 0xff00;

pub const SHN_HIPROC = 0xff1f;

pub const SHN_LIVEPATCH = 0xff20;

pub const SHN_ABS = 0xfff1;

pub const SHN_COMMON = 0xfff2;

pub const SHN_HIRESERVE = 0xffff;

// Legal values for ch_type (compression algorithm).

pub const COMPRESS = enum(u32) {
    ZLIB = 1,
    ZSTD = 2,
    LOOS = 0x60000000,
    HIOS = 0x6fffffff,
    LOPROC = 0x70000000,
    HIPROC = 0x7fffffff,
    _,
};

pub const R_X86_64_NONE = 0;

pub const R_X86_64_64 = 1;

pub const R_X86_64_PC32 = 2;

pub const R_X86_64_GOT32 = 3;

pub const R_X86_64_PLT32 = 4;

pub const R_X86_64_COPY = 5;

pub const R_X86_64_GLOB_DAT = 6;

pub const R_X86_64_JUMP_SLOT = 7;

pub const R_X86_64_RELATIVE = 8;

pub const R_X86_64_GOTPCREL = 9;

pub const R_X86_64_32 = 10;

pub const R_X86_64_32S = 11;

pub const R_X86_64_16 = 12;

pub const R_X86_64_PC16 = 13;

pub const R_X86_64_8 = 14;

pub const R_X86_64_PC8 = 15;

pub const R_X86_64_DTPMOD64 = 16;

pub const R_X86_64_DTPOFF64 = 17;

pub const R_X86_64_TPOFF64 = 18;

pub const R_X86_64_TLSGD = 19;

pub const R_X86_64_TLSLD = 20;

pub const R_X86_64_DTPOFF32 = 21;

pub const R_X86_64_GOTTPOFF = 22;

pub const R_X86_64_TPOFF32 = 23;

pub const R_X86_64_PC64 = 24;

pub const R_X86_64_GOTOFF64 = 25;

pub const R_X86_64_GOTPC32 = 26;

pub const R_X86_64_GOT64 = 27;

pub const R_X86_64_GOTPCREL64 = 28;

pub const R_X86_64_GOTPC64 = 29;

pub const R_X86_64_GOTPLT64 = 30;

pub const R_X86_64_PLTOFF64 = 31;

pub const R_X86_64_SIZE32 = 32;

pub const R_X86_64_SIZE64 = 33;

pub const R_X86_64_GOTPC32_TLSDESC = 34;

pub const R_X86_64_TLSDESC_CALL = 35;

pub const R_X86_64_TLSDESC = 36;

pub const R_X86_64_IRELATIVE = 37;

pub const R_X86_64_RELATIVE64 = 38;

pub const R_X86_64_GOTPCRELX = 41;

pub const R_X86_64_REX_GOTPCRELX = 42;

pub const R_X86_64_NUM = 43;

pub const STV = enum(u2) {
    DEFAULT = 0,
    INTERNAL = 1,
    HIDDEN = 2,
    PROTECTED = 3,
};