zig/lib/std / macho.zig

const std = @import("std");
const builtin = @import("builtin");
const assert = std.debug.assert;
const io = std.io;
const mem = std.mem;
const meta = std.meta;
const testing = std.testing;

const Allocator = mem.Allocator;

pub const cpu_type_t = c_int;

pub const cpu_subtype_t = c_int;

pub const vm_prot_t = c_int;

pub const mach_header = extern struct {
    magic: u32,
    cputype: cpu_type_t,
    cpusubtype: cpu_subtype_t,
    filetype: u32,
    ncmds: u32,
    sizeofcmds: u32,
    flags: u32,
};

pub const mach_header_64 = extern struct {
    magic: u32 = MH_MAGIC_64,
    cputype: cpu_type_t = 0,
    cpusubtype: cpu_subtype_t = 0,
    filetype: u32 = 0,
    ncmds: u32 = 0,
    sizeofcmds: u32 = 0,
    flags: u32 = 0,
    reserved: u32 = 0,
};

pub const fat_header = extern struct {
    magic: u32,
    nfat_arch: u32,
};

pub const fat_arch = extern struct {
    cputype: cpu_type_t,
    cpusubtype: cpu_subtype_t,
    offset: u32,
    size: u32,
    @"align": u32,
};

pub const load_command = extern struct {
    cmd: LC,
    cmdsize: u32,
};

pub const uuid_command = extern struct {
    cmd: LC = .UUID,

    cmdsize: u32 = @sizeOf(uuid_command),

    uuid: [16]u8 = undefined,
};

pub const version_min_command = extern struct {
    cmd: LC,

    cmdsize: u32 = @sizeOf(version_min_command),

    version: u32,

    sdk: u32,
};

pub const source_version_command = extern struct {
    cmd: LC = .SOURCE_VERSION,

    cmdsize: u32 = @sizeOf(source_version_command),

    version: u64,
};

pub const build_version_command = extern struct {
    cmd: LC = .BUILD_VERSION,

    cmdsize: u32,

    platform: PLATFORM,

    minos: u32,

    sdk: u32,

    ntools: u32,
};

pub const build_tool_version = extern struct {
    tool: TOOL,

    version: u32,
};

pub const PLATFORM = enum(u32) {
    MACOS = 0x1,
    IOS = 0x2,
    TVOS = 0x3,
    WATCHOS = 0x4,
    BRIDGEOS = 0x5,
    MACCATALYST = 0x6,
    IOSSIMULATOR = 0x7,
    TVOSSIMULATOR = 0x8,
    WATCHOSSIMULATOR = 0x9,
    DRIVERKIT = 0x10,
    _,
};

pub const TOOL = enum(u32) {
    CLANG = 0x1,
    SWIFT = 0x2,
    LD = 0x3,
    LLD = 0x4, // LLVM's stock LLD linker
    ZIG = 0x5, // Unofficially Zig
    _,
};

pub const entry_point_command = extern struct {
    cmd: LC = .MAIN,

    cmdsize: u32 = @sizeOf(entry_point_command),

    entryoff: u64 = 0,

    stacksize: u64 = 0,
};

pub const symtab_command = extern struct {
    cmd: LC = .SYMTAB,

    cmdsize: u32 = @sizeOf(symtab_command),

    symoff: u32 = 0,

    nsyms: u32 = 0,

    stroff: u32 = 0,

    strsize: u32 = 0,
};

pub const dysymtab_command = extern struct {
    cmd: LC = .DYSYMTAB,

    cmdsize: u32 = @sizeOf(dysymtab_command),

    // The symbols indicated by symoff and nsyms of the LC_SYMTAB load command
    // are grouped into the following three groups:
    //    local symbols (further grouped by the module they are from)
    //    defined external symbols (further grouped by the module they are from)
    //    undefined symbols
    //
    // The local symbols are used only for debugging.  The dynamic binding
    // process may have to use them to indicate to the debugger the local
    // symbols for a module that is being bound.
    //
    // The last two groups are used by the dynamic binding process to do the
    // binding (indirectly through the module table and the reference symbol
    // table when this is a dynamically linked shared library file).

    ilocalsym: u32 = 0,

    nlocalsym: u32 = 0,

    iextdefsym: u32 = 0,

    nextdefsym: u32 = 0,

    iundefsym: u32 = 0,

    nundefsym: u32 = 0,

    // For the for the dynamic binding process to find which module a symbol
    // is defined in the table of contents is used (analogous to the ranlib
    // structure in an archive) which maps defined external symbols to modules
    // they are defined in.  This exists only in a dynamically linked shared
    // library file.  For executable and object modules the defined external
    // symbols are sorted by name and is use as the table of contents.

    tocoff: u32 = 0,

    ntoc: u32 = 0,

    // To support dynamic binding of "modules" (whole object files) the symbol
    // table must reflect the modules that the file was created from.  This is
    // done by having a module table that has indexes and counts into the merged
    // tables for each module.  The module structure that these two entries
    // refer to is described below.  This exists only in a dynamically linked
    // shared library file.  For executable and object modules the file only
    // contains one module so everything in the file belongs to the module.

    modtaboff: u32 = 0,

    nmodtab: u32 = 0,

    // To support dynamic module binding the module structure for each module
    // indicates the external references (defined and undefined) each module
    // makes.  For each module there is an offset and a count into the
    // reference symbol table for the symbols that the module references.
    // This exists only in a dynamically linked shared library file.  For
    // executable and object modules the defined external symbols and the
    // undefined external symbols indicates the external references.

    extrefsymoff: u32 = 0,

    nextrefsyms: u32 = 0,

    // The sections that contain "symbol pointers" and "routine stubs" have
    // indexes and (implied counts based on the size of the section and fixed
    // size of the entry) into the "indirect symbol" table for each pointer
    // and stub.  For every section of these two types the index into the
    // indirect symbol table is stored in the section header in the field
    // reserved1.  An indirect symbol table entry is simply a 32bit index into
    // the symbol table to the symbol that the pointer or stub is referring to.
    // The indirect symbol table is ordered to match the entries in the section.

    indirectsymoff: u32 = 0,

    nindirectsyms: u32 = 0,

    // To support relocating an individual module in a library file quickly the
    // external relocation entries for each module in the library need to be
    // accessed efficiently.  Since the relocation entries can't be accessed
    // through the section headers for a library file they are separated into
    // groups of local and external entries further grouped by module.  In this
    // case the presents of this load command who's extreloff, nextrel,
    // locreloff and nlocrel fields are non-zero indicates that the relocation
    // entries of non-merged sections are not referenced through the section
    // structures (and the reloff and nreloc fields in the section headers are
    // set to zero).
    //
    // Since the relocation entries are not accessed through the section headers
    // this requires the r_address field to be something other than a section
    // offset to identify the item to be relocated.  In this case r_address is
    // set to the offset from the vmaddr of the first LC_SEGMENT command.
    // For MH_SPLIT_SEGS images r_address is set to the the offset from the
    // vmaddr of the first read-write LC_SEGMENT command.
    //
    // The relocation entries are grouped by module and the module table
    // entries have indexes and counts into them for the group of external
    // relocation entries for that the module.
    //
    // For sections that are merged across modules there must not be any
    // remaining external relocation entries for them (for merged sections
    // remaining relocation entries must be local).

    extreloff: u32 = 0,

    nextrel: u32 = 0,

    // All the local relocation entries are grouped together (they are not
    // grouped by their module since they are only used if the object is moved
    // from its statically link edited address).

    locreloff: u32 = 0,

    nlocrel: u32 = 0,
};

pub const linkedit_data_command = extern struct {
    cmd: LC,

    cmdsize: u32 = @sizeOf(linkedit_data_command),

    dataoff: u32 = 0,

    datasize: u32 = 0,
};

pub const dyld_info_command = extern struct {
    cmd: LC = .DYLD_INFO_ONLY,

    cmdsize: u32 = @sizeOf(dyld_info_command),

    // Dyld rebases an image whenever dyld loads it at an address different
    // from its preferred address.  The rebase information is a stream
    // of byte sized opcodes whose symbolic names start with REBASE_OPCODE_.
    // Conceptually the rebase information is a table of tuples:
    //    
    // The opcodes are a compressed way to encode the table by only
    // encoding when a column changes.  In addition simple patterns
    // like "every n'th offset for m times" can be encoded in a few
    // bytes.

    rebase_off: u32 = 0,

    rebase_size: u32 = 0,

    // Dyld binds an image during the loading process, if the image
    // requires any pointers to be initialized to symbols in other images.
    // The bind information is a stream of byte sized
    // opcodes whose symbolic names start with BIND_OPCODE_.
    // Conceptually the bind information is a table of tuples:
    //    
    // The opcodes are a compressed way to encode the table by only
    // encoding when a column changes.  In addition simple patterns
    // like for runs of pointers initialized to the same value can be
    // encoded in a few bytes.

    bind_off: u32 = 0,

    bind_size: u32 = 0,

    // Some C++ programs require dyld to unique symbols so that all
    // images in the process use the same copy of some code/data.
    // This step is done after binding. The content of the weak_bind
    // info is an opcode stream like the bind_info.  But it is sorted
    // alphabetically by symbol name.  This enable dyld to walk
    // all images with weak binding information in order and look
    // for collisions.  If there are no collisions, dyld does
    // no updating.  That means that some fixups are also encoded
    // in the bind_info.  For instance, all calls to "operator new"
    // are first bound to libstdc++.dylib using the information
    // in bind_info.  Then if some image overrides operator new
    // that is detected when the weak_bind information is processed
    // and the call to operator new is then rebound.

    weak_bind_off: u32 = 0,

    weak_bind_size: u32 = 0,

    // Some uses of external symbols do not need to be bound immediately.
    // Instead they can be lazily bound on first use.  The lazy_bind
    // are contains a stream of BIND opcodes to bind all lazy symbols.
    // Normal use is that dyld ignores the lazy_bind section when
    // loading an image.  Instead the static linker arranged for the
    // lazy pointer to initially point to a helper function which
    // pushes the offset into the lazy_bind area for the symbol
    // needing to be bound, then jumps to dyld which simply adds
    // the offset to lazy_bind_off to get the information on what
    // to bind.

    lazy_bind_off: u32 = 0,

    lazy_bind_size: u32 = 0,

    // The symbols exported by a dylib are encoded in a trie.  This
    // is a compact representation that factors out common prefixes.
    // It also reduces LINKEDIT pages in RAM because it encodes all
    // information (name, address, flags) in one small, contiguous range.
    // The export area is a stream of nodes.  The first node sequentially
    // is the start node for the trie.
    //
    // Nodes for a symbol start with a uleb128 that is the length of
    // the exported symbol information for the string so far.
    // If there is no exported symbol, the node starts with a zero byte.
    // If there is exported info, it follows the length.
    //
    // First is a uleb128 containing flags. Normally, it is followed by
    // a uleb128 encoded offset which is location of the content named
    // by the symbol from the mach_header for the image.  If the flags
    // is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is
    // a uleb128 encoded library ordinal, then a zero terminated
    // UTF8 string.  If the string is zero length, then the symbol
    // is re-export from the specified dylib with the same name.
    // If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following
    // the flags is two uleb128s: the stub offset and the resolver offset.
    // The stub is used by non-lazy pointers.  The resolver is used
    // by lazy pointers and must be called to get the actual address to use.
    //
    // After the optional exported symbol information is a byte of
    // how many edges (0-255) that this node has leaving it,
    // followed by each edge.
    // Each edge is a zero terminated UTF8 of the addition chars
    // in the symbol, followed by a uleb128 offset for the node that
    // edge points to.

    export_off: u32 = 0,

    export_size: u32 = 0,
};

pub const dylinker_command = extern struct {
    cmd: LC,

    cmdsize: u32,

    name: u32,
};

pub const dylib_command = extern struct {
    cmd: LC,

    cmdsize: u32,

    dylib: dylib,
};

pub const dylib = extern struct {
    name: u32,

    timestamp: u32,

    current_version: u32,

    compatibility_version: u32,
};

pub const rpath_command = extern struct {
    cmd: LC = .RPATH,

    cmdsize: u32,

    path: u32,
};

pub const segment_command = extern struct {
    cmd: LC = .SEGMENT,

    cmdsize: u32,

    segname: [16]u8,

    vmaddr: u32,

    vmsize: u32,

    fileoff: u32,

    filesize: u32,

    maxprot: vm_prot_t,

    initprot: vm_prot_t,

    nsects: u32,
    flags: u32,
};

pub const segment_command_64 = extern struct {
    cmd: LC = .SEGMENT_64,

    cmdsize: u32,
    // TODO lazy values in stage2
    // cmdsize: u32 = @sizeOf(segment_command_64),

    segname: [16]u8,

    vmaddr: u64 = 0,

    vmsize: u64 = 0,

    fileoff: u64 = 0,

    filesize: u64 = 0,

    maxprot: vm_prot_t = PROT.NONE,

    initprot: vm_prot_t = PROT.NONE,

    nsects: u32 = 0,
    flags: u32 = 0,

    pub fn segName(seg: *const segment_command_64) []const u8 {
        return parseName(&seg.segname);
    }

    pub fn isWriteable(seg: segment_command_64) bool {
        return seg.initprot & PROT.WRITE != 0;
    }
};

pub const PROT = struct {
    pub const NONE: vm_prot_t = 0x00;
    pub const READ: vm_prot_t = 0x01;
    pub const WRITE: vm_prot_t = 0x02;
    pub const EXEC: vm_prot_t = 0x04;
    pub const COPY: vm_prot_t = 0x10;
};

pub const section = extern struct {
    sectname: [16]u8,

    segname: [16]u8,

    addr: u32,

    size: u32,

    offset: u32,

    @"align": u32,

    reloff: u32,

    nreloc: u32,

    flags: u32,

    reserved1: u32,

    reserved2: u32,
};

pub const section_64 = extern struct {
    sectname: [16]u8,

    segname: [16]u8,

    addr: u64 = 0,

    size: u64 = 0,

    offset: u32 = 0,

    @"align": u32 = 0,

    reloff: u32 = 0,

    nreloc: u32 = 0,

    flags: u32 = S_REGULAR,

    reserved1: u32 = 0,

    reserved2: u32 = 0,

    reserved3: u32 = 0,

    pub fn sectName(sect: *const section_64) []const u8 {
        return parseName(§.sectname);
    }

    pub fn segName(sect: *const section_64) []const u8 {
        return parseName(§.segname);
    }

    pub fn @"type"(sect: section_64) u8 {
        return @as(u8, @truncate(sect.flags & 0xff));
    }

    pub fn attrs(sect: section_64) u32 {
        return sect.flags & 0xffffff00;
    }

    pub fn isCode(sect: section_64) bool {
        const attr = sect.attrs();
        return attr & S_ATTR_PURE_INSTRUCTIONS != 0 or attr & S_ATTR_SOME_INSTRUCTIONS != 0;
    }

    pub fn isZerofill(sect: section_64) bool {
        const tt = sect.type();
        return tt == S_ZEROFILL or tt == S_GB_ZEROFILL or tt == S_THREAD_LOCAL_ZEROFILL;
    }

    pub fn isSymbolStubs(sect: section_64) bool {
        const tt = sect.type();
        return tt == S_SYMBOL_STUBS;
    }

    pub fn isDebug(sect: section_64) bool {
        return sect.attrs() & S_ATTR_DEBUG != 0;
    }

    pub fn isDontDeadStrip(sect: section_64) bool {
        return sect.attrs() & S_ATTR_NO_DEAD_STRIP != 0;
    }

    pub fn isDontDeadStripIfReferencesLive(sect: section_64) bool {
        return sect.attrs() & S_ATTR_LIVE_SUPPORT != 0;
    }
};

fn parseName(name: *const [16]u8) []const u8 {
    const len = mem.indexOfScalar(u8, name, @as(u8, 0)) orelse name.len;
    return name[0..len];
}

pub const nlist = extern struct {
    n_strx: u32,
    n_type: u8,
    n_sect: u8,
    n_desc: i16,
    n_value: u32,
};

pub const nlist_64 = extern struct {
    n_strx: u32,
    n_type: u8,
    n_sect: u8,
    n_desc: u16,
    n_value: u64,

    pub fn stab(sym: nlist_64) bool {
        return (N_STAB & sym.n_type) != 0;
    }

    pub fn pext(sym: nlist_64) bool {
        return (N_PEXT & sym.n_type) != 0;
    }

    pub fn ext(sym: nlist_64) bool {
        return (N_EXT & sym.n_type) != 0;
    }

    pub fn sect(sym: nlist_64) bool {
        const type_ = N_TYPE & sym.n_type;
        return type_ == N_SECT;
    }

    pub fn undf(sym: nlist_64) bool {
        const type_ = N_TYPE & sym.n_type;
        return type_ == N_UNDF;
    }

    pub fn indr(sym: nlist_64) bool {
        const type_ = N_TYPE & sym.n_type;
        return type_ == N_INDR;
    }

    pub fn abs(sym: nlist_64) bool {
        const type_ = N_TYPE & sym.n_type;
        return type_ == N_ABS;
    }

    pub fn weakDef(sym: nlist_64) bool {
        return (sym.n_desc & N_WEAK_DEF) != 0;
    }

    pub fn weakRef(sym: nlist_64) bool {
        return (sym.n_desc & N_WEAK_REF) != 0;
    }

    pub fn discarded(sym: nlist_64) bool {
        return (sym.n_desc & N_DESC_DISCARDED) != 0;
    }

    pub fn tentative(sym: nlist_64) bool {
        if (!sym.undf()) return false;
        return sym.n_value != 0;
    }
};

pub const relocation_info = packed struct {
    r_address: i32,

    r_symbolnum: u24,

    r_pcrel: u1,

    r_length: u2,

    r_extern: u1,

    r_type: u4,
};

pub const LC_REQ_DYLD = 0x80000000;

pub const LC = enum(u32) {
    NONE = 0x0,

    SEGMENT = 0x1,

    SYMTAB = 0x2,

    SYMSEG = 0x3,

    THREAD = 0x4,

    UNIXTHREAD = 0x5,

    LOADFVMLIB = 0x6,

    IDFVMLIB = 0x7,

    IDENT = 0x8,

    FVMFILE = 0x9,

    PREPAGE = 0xa,

    DYSYMTAB = 0xb,

    LOAD_DYLIB = 0xc,

    ID_DYLIB = 0xd,

    LOAD_DYLINKER = 0xe,

    ID_DYLINKER = 0xf,

    PREBOUND_DYLIB = 0x10,

    ROUTINES = 0x11,

    SUB_FRAMEWORK = 0x12,

    SUB_UMBRELLA = 0x13,

    SUB_CLIENT = 0x14,

    SUB_LIBRARY = 0x15,

    TWOLEVEL_HINTS = 0x16,

    PREBIND_CKSUM = 0x17,

    LOAD_WEAK_DYLIB = (0x18 | LC_REQ_DYLD),

    SEGMENT_64 = 0x19,

    ROUTINES_64 = 0x1a,

    UUID = 0x1b,

    RPATH = (0x1c | LC_REQ_DYLD),

    CODE_SIGNATURE = 0x1d,

    SEGMENT_SPLIT_INFO = 0x1e,

    REEXPORT_DYLIB = (0x1f | LC_REQ_DYLD),

    LAZY_LOAD_DYLIB = 0x20,

    ENCRYPTION_INFO = 0x21,

    DYLD_INFO = 0x22,

    DYLD_INFO_ONLY = (0x22 | LC_REQ_DYLD),

    LOAD_UPWARD_DYLIB = (0x23 | LC_REQ_DYLD),

    VERSION_MIN_MACOSX = 0x24,

    VERSION_MIN_IPHONEOS = 0x25,

    FUNCTION_STARTS = 0x26,

    DYLD_ENVIRONMENT = 0x27,

    MAIN = (0x28 | LC_REQ_DYLD),

    DATA_IN_CODE = 0x29,

    SOURCE_VERSION = 0x2A,

    DYLIB_CODE_SIGN_DRS = 0x2B,

    ENCRYPTION_INFO_64 = 0x2C,

    LINKER_OPTION = 0x2D,

    LINKER_OPTIMIZATION_HINT = 0x2E,

    VERSION_MIN_TVOS = 0x2F,

    VERSION_MIN_WATCHOS = 0x30,

    NOTE = 0x31,

    BUILD_VERSION = 0x32,

    _,
};

pub const MH_MAGIC = 0xfeedface;

pub const MH_CIGAM = 0xcefaedfe;

pub const MH_MAGIC_64 = 0xfeedfacf;

pub const MH_CIGAM_64 = 0xcffaedfe;

pub const MH_OBJECT = 0x1;

pub const MH_EXECUTE = 0x2;

pub const MH_FVMLIB = 0x3;

pub const MH_CORE = 0x4;

pub const MH_PRELOAD = 0x5;

pub const MH_DYLIB = 0x6;

pub const MH_DYLINKER = 0x7;

pub const MH_BUNDLE = 0x8;

pub const MH_DYLIB_STUB = 0x9;

pub const MH_DSYM = 0xa;

pub const MH_KEXT_BUNDLE = 0xb;

// Constants for the flags field of the mach_header

pub const MH_NOUNDEFS = 0x1;

pub const MH_INCRLINK = 0x2;

pub const MH_DYLDLINK = 0x4;

pub const MH_BINDATLOAD = 0x8;

pub const MH_PREBOUND = 0x10;

pub const MH_SPLIT_SEGS = 0x20;

pub const MH_LAZY_INIT = 0x40;

pub const MH_TWOLEVEL = 0x80;

pub const MH_FORCE_FLAT = 0x100;

pub const MH_NOMULTIDEFS = 0x200;

pub const MH_NOFIXPREBINDING = 0x400;

pub const MH_PREBINDABLE = 0x800;

pub const MH_ALLMODSBOUND = 0x1000;

pub const MH_SUBSECTIONS_VIA_SYMBOLS = 0x2000;

pub const MH_CANONICAL = 0x4000;

pub const MH_WEAK_DEFINES = 0x8000;

pub const MH_BINDS_TO_WEAK = 0x10000;

pub const MH_ALLOW_STACK_EXECUTION = 0x20000;

pub const MH_ROOT_SAFE = 0x40000;

pub const MH_SETUID_SAFE = 0x80000;

pub const MH_NO_REEXPORTED_DYLIBS = 0x100000;

pub const MH_PIE = 0x200000;

pub const MH_DEAD_STRIPPABLE_DYLIB = 0x400000;

pub const MH_HAS_TLV_DESCRIPTORS = 0x800000;

pub const MH_NO_HEAP_EXECUTION = 0x1000000;

pub const MH_APP_EXTENSION_SAFE = 0x02000000;

pub const MH_NLIST_OUTOFSYNC_WITH_DYLDINFO = 0x04000000;

// Constants for the flags field of the fat_header

pub const FAT_MAGIC = 0xcafebabe;

pub const FAT_CIGAM = 0xbebafeca;

pub const FAT_MAGIC_64 = 0xcafebabf;

pub const FAT_CIGAM_64 = 0xbfbafeca;

pub const SECTION_TYPE = 0x000000ff;

pub const SECTION_ATTRIBUTES = 0xffffff00;

pub const S_REGULAR = 0x0;

pub const S_ZEROFILL = 0x1;

pub const S_CSTRING_LITERALS = 0x2;

pub const S_4BYTE_LITERALS = 0x3;

pub const S_8BYTE_LITERALS = 0x4;

pub const S_LITERAL_POINTERS = 0x5;

pub const N_STAB = 0xe0;

pub const N_PEXT = 0x10;

pub const N_TYPE = 0x0e;

pub const N_EXT = 0x01;

pub const N_UNDF = 0x0;

pub const N_ABS = 0x2;

pub const N_SECT = 0xe;

pub const N_PBUD = 0xc;

pub const N_INDR = 0xa;

pub const N_GSYM = 0x20;

pub const N_FNAME = 0x22;

pub const N_FUN = 0x24;

pub const N_STSYM = 0x26;

pub const N_LCSYM = 0x28;

pub const N_BNSYM = 0x2e;

pub const N_AST = 0x32;

pub const N_OPT = 0x3c;

pub const N_RSYM = 0x40;

pub const N_SLINE = 0x44;

pub const N_ENSYM = 0x4e;

pub const N_SSYM = 0x60;

pub const N_SO = 0x64;

pub const N_OSO = 0x66;

pub const N_LSYM = 0x80;

pub const N_BINCL = 0x82;

pub const N_SOL = 0x84;

pub const N_PARAMS = 0x86;

pub const N_VERSION = 0x88;

pub const N_OLEVEL = 0x8A;

pub const N_PSYM = 0xa0;

pub const N_EINCL = 0xa2;

pub const N_ENTRY = 0xa4;

pub const N_LBRAC = 0xc0;

pub const N_EXCL = 0xc2;

pub const N_RBRAC = 0xe0;

pub const N_BCOMM = 0xe2;

pub const N_ECOMM = 0xe4;

pub const N_ECOML = 0xe8;

pub const N_LENG = 0xfe;

// For the two types of symbol pointers sections and the symbol stubs section
// they have indirect symbol table entries.  For each of the entries in the
// section the indirect symbol table entries, in corresponding order in the
// indirect symbol table, start at the index stored in the reserved1 field
// of the section structure.  Since the indirect symbol table entries
// correspond to the entries in the section the number of indirect symbol table
// entries is inferred from the size of the section divided by the size of the
// entries in the section.  For symbol pointers sections the size of the entries
// in the section is 4 bytes and for symbol stubs sections the byte size of the
// stubs is stored in the reserved2 field of the section structure.

pub const S_NON_LAZY_SYMBOL_POINTERS = 0x6;

pub const S_LAZY_SYMBOL_POINTERS = 0x7;

pub const S_SYMBOL_STUBS = 0x8;

pub const S_MOD_INIT_FUNC_POINTERS = 0x9;

pub const S_MOD_TERM_FUNC_POINTERS = 0xa;

pub const S_COALESCED = 0xb;

pub const S_GB_ZEROFILL = 0xc;

pub const S_INTERPOSING = 0xd;

pub const S_16BYTE_LITERALS = 0xe;

pub const S_DTRACE_DOF = 0xf;

pub const S_LAZY_DYLIB_SYMBOL_POINTERS = 0x10;

// If a segment contains any sections marked with S_ATTR_DEBUG then all
// sections in that segment must have this attribute.  No section other than
// a section marked with this attribute may reference the contents of this
// section.  A section with this attribute may contain no symbols and must have
// a section type S_REGULAR.  The static linker will not copy section contents
// from sections with this attribute into its output file.  These sections
// generally contain DWARF debugging info.

pub const S_ATTR_DEBUG = 0x02000000;

pub const S_ATTR_PURE_INSTRUCTIONS = 0x80000000;

pub const S_ATTR_NO_TOC = 0x40000000;

pub const S_ATTR_STRIP_STATIC_SYMS = 0x20000000;

pub const S_ATTR_NO_DEAD_STRIP = 0x10000000;

pub const S_ATTR_LIVE_SUPPORT = 0x8000000;

pub const S_ATTR_SELF_MODIFYING_CODE = 0x4000000;

pub const S_ATTR_SOME_INSTRUCTIONS = 0x400;

pub const S_ATTR_EXT_RELOC = 0x200;

pub const S_ATTR_LOC_RELOC = 0x100;

pub const S_THREAD_LOCAL_REGULAR = 0x11;

pub const S_THREAD_LOCAL_ZEROFILL = 0x12;

pub const S_THREAD_LOCAL_VARIABLES = 0x13;

pub const S_THREAD_LOCAL_VARIABLE_POINTERS = 0x14;

pub const S_THREAD_LOCAL_INIT_FUNCTION_POINTERS = 0x15;

pub const S_INIT_FUNC_OFFSETS = 0x16;

pub const CPU_TYPE_X86_64: cpu_type_t = 0x01000007;

pub const CPU_TYPE_ARM64: cpu_type_t = 0x0100000C;

pub const CPU_SUBTYPE_X86_64_ALL: cpu_subtype_t = 0x3;

pub const CPU_SUBTYPE_ARM_ALL: cpu_subtype_t = 0x0;

// The following are used to encode rebasing information

pub const REBASE_TYPE_POINTER: u8 = 1;

pub const REBASE_TYPE_TEXT_ABSOLUTE32: u8 = 2;

pub const REBASE_TYPE_TEXT_PCREL32: u8 = 3;

pub const REBASE_OPCODE_MASK: u8 = 0xF0;

pub const REBASE_IMMEDIATE_MASK: u8 = 0x0F;

pub const REBASE_OPCODE_DONE: u8 = 0x00;

pub const REBASE_OPCODE_SET_TYPE_IMM: u8 = 0x10;

pub const REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: u8 = 0x20;

pub const REBASE_OPCODE_ADD_ADDR_ULEB: u8 = 0x30;

pub const REBASE_OPCODE_ADD_ADDR_IMM_SCALED: u8 = 0x40;

pub const REBASE_OPCODE_DO_REBASE_IMM_TIMES: u8 = 0x50;

pub const REBASE_OPCODE_DO_REBASE_ULEB_TIMES: u8 = 0x60;

pub const REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: u8 = 0x70;

pub const REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: u8 = 0x80;

// The following are used to encode binding information

pub const BIND_TYPE_POINTER: u8 = 1;

pub const BIND_TYPE_TEXT_ABSOLUTE32: u8 = 2;

pub const BIND_TYPE_TEXT_PCREL32: u8 = 3;

pub const BIND_SPECIAL_DYLIB_SELF: i8 = 0;

pub const BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE: i8 = -1;

pub const BIND_SPECIAL_DYLIB_FLAT_LOOKUP: i8 = -2;

pub const BIND_SYMBOL_FLAGS_WEAK_IMPORT: u8 = 0x1;

pub const BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION: u8 = 0x8;

pub const BIND_OPCODE_MASK: u8 = 0xf0;

pub const BIND_IMMEDIATE_MASK: u8 = 0x0f;

pub const BIND_OPCODE_DONE: u8 = 0x00;

pub const BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: u8 = 0x10;

pub const BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: u8 = 0x20;

pub const BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: u8 = 0x30;

pub const BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: u8 = 0x40;

pub const BIND_OPCODE_SET_TYPE_IMM: u8 = 0x50;

pub const BIND_OPCODE_SET_ADDEND_SLEB: u8 = 0x60;

pub const BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: u8 = 0x70;

pub const BIND_OPCODE_ADD_ADDR_ULEB: u8 = 0x80;

pub const BIND_OPCODE_DO_BIND: u8 = 0x90;

pub const BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: u8 = 0xa0;

pub const BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: u8 = 0xb0;

pub const BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: u8 = 0xc0;

pub const reloc_type_x86_64 = enum(u4) {
    X86_64_RELOC_UNSIGNED = 0,

    X86_64_RELOC_SIGNED,

    X86_64_RELOC_BRANCH,

    X86_64_RELOC_GOT_LOAD,

    X86_64_RELOC_GOT,

    X86_64_RELOC_SUBTRACTOR,

    X86_64_RELOC_SIGNED_1,

    X86_64_RELOC_SIGNED_2,

    X86_64_RELOC_SIGNED_4,

    X86_64_RELOC_TLV,
};

pub const reloc_type_arm64 = enum(u4) {
    ARM64_RELOC_UNSIGNED = 0,

    ARM64_RELOC_SUBTRACTOR,

    ARM64_RELOC_BRANCH26,

    ARM64_RELOC_PAGE21,

    ARM64_RELOC_PAGEOFF12,

    ARM64_RELOC_GOT_LOAD_PAGE21,

    ARM64_RELOC_GOT_LOAD_PAGEOFF12,

    ARM64_RELOC_POINTER_TO_GOT,

    ARM64_RELOC_TLVP_LOAD_PAGE21,

    ARM64_RELOC_TLVP_LOAD_PAGEOFF12,

    ARM64_RELOC_ADDEND,
};

pub const REFERENCE_FLAG_UNDEFINED_NON_LAZY: u16 = 0x0;

pub const REFERENCE_FLAG_UNDEFINED_LAZY: u16 = 0x1;

pub const REFERENCE_FLAG_DEFINED: u16 = 0x2;

pub const REFERENCE_FLAG_PRIVATE_DEFINED: u16 = 3;

pub const REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY: u16 = 4;

pub const REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY: u16 = 5;

pub const REFERENCED_DYNAMICALLY: u16 = 0x10;

pub const N_DESC_DISCARDED: u16 = 0x20;

pub const N_WEAK_REF: u16 = 0x40;

pub const N_WEAK_DEF: u16 = 0x80;

pub const N_SYMBOL_RESOLVER: u16 = 0x100;

// The following are used on the flags byte of a terminal node in the export information.

pub const EXPORT_SYMBOL_FLAGS_KIND_MASK: u8 = 0x03;

pub const EXPORT_SYMBOL_FLAGS_KIND_REGULAR: u8 = 0x00;

pub const EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL: u8 = 0x01;

pub const EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE: u8 = 0x02;

pub const EXPORT_SYMBOL_FLAGS_KIND_WEAK_DEFINITION: u8 = 0x04;

pub const EXPORT_SYMBOL_FLAGS_REEXPORT: u8 = 0x08;

pub const EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER: u8 = 0x10;

// An indirect symbol table entry is simply a 32bit index into the symbol table
// to the symbol that the pointer or stub is referring to.  Unless it is for a
// non-lazy symbol pointer section for a defined symbol which strip(1) as
// removed.  In which case it has the value INDIRECT_SYMBOL_LOCAL.  If the
// symbol was also absolute INDIRECT_SYMBOL_ABS is or'ed with that.

pub const INDIRECT_SYMBOL_LOCAL: u32 = 0x80000000;

pub const INDIRECT_SYMBOL_ABS: u32 = 0x40000000;

// Codesign consts and structs taken from:
// https://opensource.apple.com/source/xnu/xnu-6153.81.5/osfmk/kern/cs_blobs.h.auto.html

pub const CSMAGIC_REQUIREMENT: u32 = 0xfade0c00;

pub const CSMAGIC_REQUIREMENTS: u32 = 0xfade0c01;

pub const CSMAGIC_CODEDIRECTORY: u32 = 0xfade0c02;

pub const CSMAGIC_EMBEDDED_SIGNATURE: u32 = 0xfade0cc0;

pub const CSMAGIC_EMBEDDED_SIGNATURE_OLD: u32 = 0xfade0b02;

pub const CSMAGIC_EMBEDDED_ENTITLEMENTS: u32 = 0xfade7171;

pub const CSMAGIC_EMBEDDED_DER_ENTITLEMENTS: u32 = 0xfade7172;

pub const CSMAGIC_DETACHED_SIGNATURE: u32 = 0xfade0cc1;

pub const CSMAGIC_BLOBWRAPPER: u32 = 0xfade0b01;

pub const CS_SUPPORTSSCATTER: u32 = 0x20100;

pub const CS_SUPPORTSTEAMID: u32 = 0x20200;

pub const CS_SUPPORTSCODELIMIT64: u32 = 0x20300;

pub const CS_SUPPORTSEXECSEG: u32 = 0x20400;

pub const CSSLOT_CODEDIRECTORY: u32 = 0;

pub const CSSLOT_INFOSLOT: u32 = 1;

pub const CSSLOT_REQUIREMENTS: u32 = 2;

pub const CSSLOT_RESOURCEDIR: u32 = 3;

pub const CSSLOT_APPLICATION: u32 = 4;

pub const CSSLOT_ENTITLEMENTS: u32 = 5;

pub const CSSLOT_DER_ENTITLEMENTS: u32 = 7;

pub const CSSLOT_ALTERNATE_CODEDIRECTORIES: u32 = 0x1000;

pub const CSSLOT_ALTERNATE_CODEDIRECTORY_MAX: u32 = 5;

pub const CSSLOT_ALTERNATE_CODEDIRECTORY_LIMIT: u32 = CSSLOT_ALTERNATE_CODEDIRECTORIES + CSSLOT_ALTERNATE_CODEDIRECTORY_MAX;

pub const CSSLOT_SIGNATURESLOT: u32 = 0x10000;

pub const CSSLOT_IDENTIFICATIONSLOT: u32 = 0x10001;

pub const CSSLOT_TICKETSLOT: u32 = 0x10002;

pub const CSTYPE_INDEX_REQUIREMENTS: u32 = 0x00000002;

pub const CSTYPE_INDEX_ENTITLEMENTS: u32 = 0x00000005;

pub const CS_HASHTYPE_SHA1: u8 = 1;

pub const CS_HASHTYPE_SHA256: u8 = 2;

pub const CS_HASHTYPE_SHA256_TRUNCATED: u8 = 3;

pub const CS_HASHTYPE_SHA384: u8 = 4;

pub const CS_SHA1_LEN: u32 = 20;

pub const CS_SHA256_LEN: u32 = 32;

pub const CS_SHA256_TRUNCATED_LEN: u32 = 20;

pub const CS_CDHASH_LEN: u32 = 20;

pub const CS_HASH_MAX_SIZE: u32 = 48;

pub const CS_SIGNER_TYPE_UNKNOWN: u32 = 0;

pub const CS_SIGNER_TYPE_LEGACYVPN: u32 = 5;

pub const CS_SIGNER_TYPE_MAC_APP_STORE: u32 = 6;

pub const CS_ADHOC: u32 = 0x2;

pub const CS_LINKER_SIGNED: u32 = 0x20000;

pub const CS_EXECSEG_MAIN_BINARY: u32 = 0x1;

pub const CodeDirectory = extern struct {
    magic: u32,

    length: u32,

    version: u32,

    flags: u32,

    hashOffset: u32,

    identOffset: u32,

    nSpecialSlots: u32,

    nCodeSlots: u32,

    codeLimit: u32,

    hashSize: u8,

    hashType: u8,

    platform: u8,

    pageSize: u8,

    spare2: u32,

    scatterOffset: u32,

    teamOffset: u32,

    spare3: u32,

    codeLimit64: u64,

    execSegBase: u64,

    execSegLimit: u64,

    execSegFlags: u64,
};

pub const BlobIndex = extern struct {
    type: u32,

    offset: u32,
};

pub const SuperBlob = extern struct {
    magic: u32,

    length: u32,

    count: u32,
};

pub const GenericBlob = extern struct {
    magic: u32,

    length: u32,
};

pub const data_in_code_entry = extern struct {
    offset: u32,

    length: u16,

    kind: u16,
};

pub const LoadCommandIterator = struct {
    ncmds: usize,
    buffer: []const u8,
    index: usize = 0,

    pub const LoadCommand = struct {
        hdr: load_command,
        data: []const u8,

        pub fn cmd(lc: LoadCommand) LC {
            return lc.hdr.cmd;
        }

        pub fn cmdsize(lc: LoadCommand) u32 {
            return lc.hdr.cmdsize;
        }

        pub fn cast(lc: LoadCommand, comptime Cmd: type) ?Cmd {
            if (lc.data.len < @sizeOf(Cmd)) return null;
            return @as(*const Cmd, @ptrCast(@alignCast(&lc.data[0]))).*;
        }

        pub fn getSections(lc: LoadCommand) []const section_64 {
            const segment_lc = lc.cast(segment_command_64).?;
            if (segment_lc.nsects == 0) return &[0]section_64{};
            const data = lc.data[@sizeOf(segment_command_64)..];
            const sections = @as(
                [*]const section_64,
                @ptrCast(@alignCast(&data[0])),
            )[0..segment_lc.nsects];
            return sections;
        }

        pub fn getDylibPathName(lc: LoadCommand) []const u8 {
            const dylib_lc = lc.cast(dylib_command).?;
            const data = lc.data[dylib_lc.dylib.name..];
            return mem.sliceTo(data, 0);
        }

        pub fn getRpathPathName(lc: LoadCommand) []const u8 {
            const rpath_lc = lc.cast(rpath_command).?;
            const data = lc.data[rpath_lc.path..];
            return mem.sliceTo(data, 0);
        }

        pub fn getBuildVersionTools(lc: LoadCommand) []const build_tool_version {
            const build_lc = lc.cast(build_version_command).?;
            const ntools = build_lc.ntools;
            if (ntools == 0) return &[0]build_tool_version{};
            const data = lc.data[@sizeOf(build_version_command)..];
            const tools = @as([*]const build_tool_version, @ptrCast(@alignCast(&data[0])))[0..ntools];
            return tools;
        }
    };

    pub fn next(it: *LoadCommandIterator) ?LoadCommand {
        if (it.index >= it.ncmds) return null;

        const hdr = @as(
            *const load_command,
            @ptrCast(@alignCast(&it.buffer[0])),
        ).*;
        const cmd = LoadCommand{
            .hdr = hdr,
            .data = it.buffer[0..hdr.cmdsize],
        };

        it.buffer = @alignCast(it.buffer[hdr.cmdsize..]);
        it.index += 1;

        return cmd;
    }
};

pub const compact_unwind_encoding_t = u32;

// Relocatable object files: __LD,__compact_unwind

pub const compact_unwind_entry = extern struct {
    rangeStart: u64,
    rangeLength: u32,
    compactUnwindEncoding: u32,
    personalityFunction: u64,
    lsda: u64,
};

// Final linked images: __TEXT,__unwind_info
// The __TEXT,__unwind_info section is laid out for an efficient two level lookup.
// The header of the section contains a coarse index that maps function address
// to the page (4096 byte block) containing the unwind info for that function.

pub const UNWIND_SECTION_VERSION = 1;

pub const unwind_info_section_header = extern struct {
    version: u32 = UNWIND_SECTION_VERSION,
    commonEncodingsArraySectionOffset: u32,
    commonEncodingsArrayCount: u32,
    personalityArraySectionOffset: u32,
    personalityArrayCount: u32,
    indexSectionOffset: u32,
    indexCount: u32,
    // compact_unwind_encoding_t[]
    // uint32_t personalities[]
    // unwind_info_section_header_index_entry[]
    // unwind_info_section_header_lsda_index_entry[]
};

pub const unwind_info_section_header_index_entry = extern struct {
    functionOffset: u32,

    secondLevelPagesSectionOffset: u32,

    lsdaIndexArraySectionOffset: u32,
};

pub const unwind_info_section_header_lsda_index_entry = extern struct {
    functionOffset: u32,
    lsdaOffset: u32,
};

// There are two kinds of second level index pages: regular and compressed.
// A compressed page can hold up to 1021 entries, but it cannot be used if
// too many different encoding types are used. The regular page holds 511
// entries.

pub const unwind_info_regular_second_level_entry = extern struct {
    functionOffset: u32,
    encoding: compact_unwind_encoding_t,
};

pub const UNWIND_SECOND_LEVEL = enum(u32) {
    REGULAR = 2,
    COMPRESSED = 3,
    _,
};

pub const unwind_info_regular_second_level_page_header = extern struct {
    kind: UNWIND_SECOND_LEVEL = .REGULAR,

    entryPageOffset: u16,
    entryCount: u16,
    // entry array
};

pub const unwind_info_compressed_second_level_page_header = extern struct {
    kind: UNWIND_SECOND_LEVEL = .COMPRESSED,

    entryPageOffset: u16,
    entryCount: u16,
    encodingsPageOffset: u16,
    encodingsCount: u16,
    // 32bit entry array
    // encodings array
};

pub const UnwindInfoCompressedEntry = packed struct {
    funcOffset: u24,
    encodingIndex: u8,
};

pub const UNWIND_IS_NOT_FUNCTION_START: u32 = 0x80000000;

pub const UNWIND_HAS_LSDA: u32 = 0x40000000;

pub const UNWIND_PERSONALITY_MASK: u32 = 0x30000000;

// x86_64

pub const UNWIND_X86_64_MODE_MASK: u32 = 0x0F000000;

pub const UNWIND_X86_64_MODE = enum(u4) {
    OLD = 0,
    RBP_FRAME = 1,
    STACK_IMMD = 2,
    STACK_IND = 3,
    DWARF = 4,
};

pub const UNWIND_X86_64_RBP_FRAME_REGISTERS: u32 = 0x00007FFF;

pub const UNWIND_X86_64_RBP_FRAME_OFFSET: u32 = 0x00FF0000;

pub const UNWIND_X86_64_FRAMELESS_STACK_SIZE: u32 = 0x00FF0000;

pub const UNWIND_X86_64_FRAMELESS_STACK_ADJUST: u32 = 0x0000E000;

pub const UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT: u32 = 0x00001C00;

pub const UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION: u32 = 0x000003FF;

pub const UNWIND_X86_64_DWARF_SECTION_OFFSET: u32 = 0x00FFFFFF;

pub const UNWIND_X86_64_REG = enum(u3) {
    NONE = 0,
    RBX = 1,
    R12 = 2,
    R13 = 3,
    R14 = 4,
    R15 = 5,
    RBP = 6,
};

// arm64

pub const UNWIND_ARM64_MODE_MASK: u32 = 0x0F000000;

pub const UNWIND_ARM64_MODE = enum(u4) {
    OLD = 0,
    FRAMELESS = 2,
    DWARF = 3,
    FRAME = 4,
};

pub const UNWIND_ARM64_FRAME_X19_X20_PAIR: u32 = 0x00000001;

pub const UNWIND_ARM64_FRAME_X21_X22_PAIR: u32 = 0x00000002;

pub const UNWIND_ARM64_FRAME_X23_X24_PAIR: u32 = 0x00000004;

pub const UNWIND_ARM64_FRAME_X25_X26_PAIR: u32 = 0x00000008;

pub const UNWIND_ARM64_FRAME_X27_X28_PAIR: u32 = 0x00000010;

pub const UNWIND_ARM64_FRAME_D8_D9_PAIR: u32 = 0x00000100;

pub const UNWIND_ARM64_FRAME_D10_D11_PAIR: u32 = 0x00000200;

pub const UNWIND_ARM64_FRAME_D12_D13_PAIR: u32 = 0x00000400;

pub const UNWIND_ARM64_FRAME_D14_D15_PAIR: u32 = 0x00000800;

pub const UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK: u32 = 0x00FFF000;

pub const UNWIND_ARM64_DWARF_SECTION_OFFSET: u32 = 0x00FFFFFF;

pub const CompactUnwindEncoding = packed struct(u32) {
    value: packed union {
        x86_64: packed union {
            frame: packed struct(u24) {
                reg4: u3,
                reg3: u3,
                reg2: u3,
                reg1: u3,
                reg0: u3,
                unused: u1 = 0,
                frame_offset: u8,
            },
            frameless: packed struct(u24) {
                stack_reg_permutation: u10,
                stack_reg_count: u3,
                stack: packed union {
                    direct: packed struct(u11) {
                        _: u3,
                        stack_size: u8,
                    },
                    indirect: packed struct(u11) {
                        stack_adjust: u3,
                        sub_offset: u8,
                    },
                },
            },
            dwarf: u24,
        },
        arm64: packed union {
            frame: packed struct(u24) {
                x_reg_pairs: packed struct(u5) {
                    x19_x20: u1,
                    x21_x22: u1,
                    x23_x24: u1,
                    x25_x26: u1,
                    x27_x28: u1,
                },
                d_reg_pairs: packed struct(u4) {
                    d8_d9: u1,
                    d10_d11: u1,
                    d12_d13: u1,
                    d14_d15: u1,
                },
                _: u15,
            },
            frameless: packed struct(u24) {
                _: u12 = 0,
                stack_size: u12,
            },
            dwarf: u24,
        },
    },
    mode: packed union {
        x86_64: UNWIND_X86_64_MODE,
        arm64: UNWIND_ARM64_MODE,
    },
    personality_index: u2,
    has_lsda: u1,
    start: u1,
};