@isopodlabs/binary_libs 0.1.1 → 0.1.3

package/dist/mach.js

@@ -0,0 +1,1027 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FATMachFile = exports.MachFile = void 0;
+const binary = __importStar(require("@isopodlabs/binary"));
+class mach_stream extends binary.endianStream {
+    base;
+    mem;
+    constructor(base, data, be, mem) {
+        super(data, be);
+        this.base = base;
+        this.mem = mem;
+    }
+    subdata(offset, size) {
+        return this.base.subarray(offset, size && offset + size);
+    }
+    substream(offset, size) {
+        return new mach_stream(this.base, this.subdata(offset, size), this.be, this.mem);
+    }
+    getmem(address, size) {
+        return this.mem?.get(address, size);
+    }
+}
+const uint16 = binary.UINT16;
+const uint32 = binary.UINT32;
+const uint64 = binary.UINT64;
+const int32 = binary.INT32;
+const xint32 = binary.asHex(uint32);
+const xint64 = binary.asHex(uint64);
+const FILETYPE = {
+    OBJECT: 1, // Relocatable object file
+    EXECUTE: 2, // Executable file
+    FVMLIB: 3, // Fixed VM shared library file
+    CORE: 4, // Core file
+    PRELOAD: 5, // Preloaded executable file
+    DYLIB: 6, // Dynamically bound shared library
+    DYLINKER: 7, // Dynamic link editor
+    BUNDLE: 8, // Dynamically bound bundle file
+    DYLIB_STUB: 9, // Shared library stub for static linking
+    DSYM: 10, // Companion file with only debug sections
+    KEXT_BUNDLE: 11, // x86_64 kexts
+    FILESET: 12
+};
+//	Machine types known by all
+var CPU_TYPE;
+(function (CPU_TYPE) {
+    CPU_TYPE[CPU_TYPE["ANY"] = -1] = "ANY";
+    CPU_TYPE[CPU_TYPE["ARCH_MASK"] = 4278190080] = "ARCH_MASK";
+    CPU_TYPE[CPU_TYPE["ARCH_64"] = 16777216] = "ARCH_64";
+    CPU_TYPE[CPU_TYPE["VAX"] = 1] = "VAX";
+    CPU_TYPE[CPU_TYPE["MC680x0"] = 6] = "MC680x0";
+    CPU_TYPE[CPU_TYPE["X86"] = 7] = "X86";
+    CPU_TYPE[CPU_TYPE["MIPS"] = 8] = "MIPS";
+    CPU_TYPE[CPU_TYPE["MC98000"] = 10] = "MC98000";
+    CPU_TYPE[CPU_TYPE["HPPA"] = 11] = "HPPA";
+    CPU_TYPE[CPU_TYPE["ARM"] = 12] = "ARM";
+    CPU_TYPE[CPU_TYPE["MC88000"] = 13] = "MC88000";
+    CPU_TYPE[CPU_TYPE["SPARC"] = 14] = "SPARC";
+    CPU_TYPE[CPU_TYPE["I860"] = 15] = "I860";
+    CPU_TYPE[CPU_TYPE["ALPHA"] = 16] = "ALPHA";
+    CPU_TYPE[CPU_TYPE["POWERPC"] = 18] = "POWERPC";
+    CPU_TYPE[CPU_TYPE["X86_64"] = 16777223] = "X86_64";
+    CPU_TYPE[CPU_TYPE["POWERPC_64"] = 16777234] = "POWERPC_64";
+    CPU_TYPE[CPU_TYPE["ARM_64"] = 16777228] = "ARM_64";
+})(CPU_TYPE || (CPU_TYPE = {}));
+;
+const CPU_SUBTYPES = {
+    [CPU_TYPE.VAX]: {
+        VAX_ALL: 0,
+        VAX780: 1,
+        VAX785: 2,
+        VAX750: 3,
+        VAX730: 4,
+        UVAXI: 5,
+        UVAXII: 6,
+        VAX8200: 7,
+        VAX8500: 8,
+        VAX8600: 9,
+        VAX8650: 10,
+        VAX8800: 11,
+        UVAXIII: 12,
+    },
+    [CPU_TYPE.MC680x0]: {
+        MC680x0_ALL: 1,
+        MC68030: 1, // compat
+        MC68040: 2,
+        MC68030_ONLY: 3,
+    },
+    [CPU_TYPE.X86]: {
+        X86_ALL: 3,
+        X86_64_ALL: 3,
+        X86_ARCH1: 4,
+    },
+    [CPU_TYPE.MIPS]: {
+        MIPS_ALL: 0,
+        MIPS_R2300: 1,
+        MIPS_R2600: 2,
+        MIPS_R2800: 3,
+        MIPS_R2000a: 4, // pmax
+        MIPS_R2000: 5,
+        MIPS_R3000a: 6, // 3max
+        MIPS_R3000: 7,
+    },
+    [CPU_TYPE.MC98000]: {
+        MC98000_ALL: 0,
+        MC98601: 1,
+    },
+    [CPU_TYPE.HPPA]: {
+        HPPA_ALL: 0,
+        HPPA_7100: 0, // compat
+        HPPA_7100LC: 1,
+    },
+    [CPU_TYPE.ARM]: {
+        ARM_ALL: 0,
+        ARM_V4T: 5,
+        ARM_V6: 6,
+        ARM_V5TEJ: 7,
+        ARM_XSCALE: 8,
+        ARM_V7: 9,
+        ARM_V7S: 11,
+        ARM_V7K: 12,
+        ARM_V6M: 14,
+        ARM_V7M: 15,
+        ARM_V7EM: 16,
+    },
+    [CPU_TYPE.MC88000]: {
+        MC88000_ALL: 0,
+        MC88100: 1,
+        MC88110: 2,
+    },
+    [CPU_TYPE.SPARC]: {
+        SPARC_ALL: 0,
+    },
+    [CPU_TYPE.I860]: {
+        I860_ALL: 0,
+        I860_860: 1,
+    },
+    [CPU_TYPE.ALPHA]: {},
+    [CPU_TYPE.POWERPC]: {
+        POWERPC_ALL: 0,
+        POWERPC_601: 1,
+        POWERPC_602: 2,
+        POWERPC_603: 3,
+        POWERPC_603e: 4,
+        POWERPC_603ev: 5,
+        POWERPC_604: 6,
+        POWERPC_604e: 7,
+        POWERPC_620: 8,
+        POWERPC_750: 9,
+        POWERPC_7400: 10,
+        POWERPC_7450: 11,
+        POWERPC_970: 100,
+    },
+    [CPU_TYPE.X86_64]: {
+        I386_ALL: 0x03,
+        I386: 0x03,
+        I486: 0x04,
+        I486SX: 0x84,
+        I586: 0x05,
+        PENT: 0x05,
+        PENTPRO: 0x16,
+        PENTII_M3: 0x36,
+        PENTII_M5: 0x56,
+        CELERON: 0x67,
+        CELERON_MOBILE: 0x77,
+        PENTIUM_3: 0x08,
+        PENTIUM_3_M: 0x18,
+        PENTIUM_3_XEON: 0x28,
+        PENTIUM_M: 0x09,
+        PENTIUM_4: 0x0a,
+        PENTIUM_4_M: 0x1a,
+        ITANIUM: 0x0b,
+        ITANIUM_2: 0x1b,
+        XEON: 0x0c,
+        XEON_MP: 0x1c,
+    },
+    [CPU_TYPE.POWERPC_64]: {},
+    [CPU_TYPE.ARM_64]: {
+        FEATURE: 0x01000000, // mask for feature flags
+        LIB64: 0x80000000, // 64 bit libraries
+        ARM64_ALL: 0,
+        ARM64_V8: 1,
+        ARM64E: 2,
+    },
+};
+// Constants for the flags field of the header
+const HEADER_FLAGS = {
+    NOUNDEFS: 0x1, // the object file has no undefinedreferences
+    INCRLINK: 0x2, // the object file is the output of an incremental link against a base file and can't be link edited again
+    DYLDLINK: 0x4, // the object file is input for the dynamic linker and can't be staticly link edited again
+    BINDATLOAD: 0x8, // the object file's undefined references are bound by the dynamic linker when loaded.
+    PREBOUND: 0x10, // the file has its dynamic undefined references prebound.
+    SPLIT_SEGS: 0x20, // the file has its read-only and read-write segments split
+    LAZY_INIT: 0x40, // the shared library init routine is to be run lazily via catching memory faults to its writeable segments (obsolete)
+    TWOLEVEL: 0x80, // the image is using two-level name space bindings
+    FORCE_FLAT: 0x100, // the executable is forcing all images to use flat name space bindings
+    NOMULTIDEFS: 0x200, // this umbrella guarantees no multiple defintions of symbols in its sub-images so the two-level namespace hints can always be used.
+    NOFIXPREBINDING: 0x400, // do not have dyld notify the prebinding agent about this executable
+    PREBINDABLE: 0x800, // the binary is not prebound but can have its prebinding redone. only used when MH_PREBOUND is not set.
+    ALLMODSBOUND: 0x1000, // indicates that this binary binds to all two-level namespace modules of its dependent libraries. only used when MH_PREBINDABLE and MH_TWOLEVELare both set.
+    SUBSECTIONS_VIA_SYMBOLS: 0x2000, // safe to divide up the sections into sub-sections via symbols for dead code stripping
+    CANONICAL: 0x4000, // the binary has been canonicalized via the unprebind operation
+    WEAK_DEFINES: 0x8000, // the final linked image contains external weak symbols
+    BINDS_TO_WEAK: 0x10000, // the final linked image uses weak symbols
+    ALLOW_STACK_EXECUTION: 0x20000, // When this bit is set, all stacks in the task will be given stack execution privilege.	Only used in MH_EXECUTE filetypes.
+    ROOT_SAFE: 0x40000, // When this bit is set, the binary declares it is safe for use in processes with uid zero
+    SETUID_SAFE: 0x80000, // When this bit is set, the binary declares it is safe for use in processes when issetugid() is true
+    NO_REEXPORTED_DYLIBS: 0x100000, // When this bit is set on a dylib, the static linker does not need to examine dependent dylibs to see if any are re-exported
+    PIE: 0x200000, // When this bit is set, the OS will load the main executable at a random address.Only used in MH_EXECUTE filetypes.
+    DEAD_STRIPPABLE_DYLIB: 0x400000, // Only for use on dylibs.	When linking against a dylib that has this bit set, the static linker will automatically not create a LC_LOAD_DYLIBload command to the dylib if no symbols are being referenced from the dylib.
+    HAS_TLV_DESCRIPTORS: 0x800000, // Contains a section of type S_THREAD_LOCAL_VARIABLES
+    NO_HEAP_EXECUTION: 0x1000000, // When this bit is set, the OS will run the main executable with a non-executable heap even on platforms (e.g. i386) that don't require it.Only used in MH_EXECUTE filetypes.
+};
+const header = {
+    magic: uint32, // mach magic number identifier
+    cputype: binary.as(uint32, binary.Enum(CPU_TYPE)),
+    cpusubtype: binary.as(uint32, (x) => x), //binary.Enum(CPU_SUBTYPE)),
+    filetype: binary.as(uint32, binary.Enum(FILETYPE)),
+    ncmds: uint32, // number of load commands
+    sizeofcmds: uint32, // the size of all the load commands
+    flags: binary.as(uint32, binary.Flags(HEADER_FLAGS, true))
+};
+const fat_arch = {
+    cputype: binary.as(uint32, binary.Enum(CPU_TYPE)),
+    cpusubtype: binary.as(uint32, (x) => x), //binary.Enum(CPU_SUBTYPE)),
+    offset: binary.UINT32_BE, // file offset to this object file
+    size: binary.UINT32_BE, // size of this object file
+    align: binary.UINT32_BE, // alignment as a power of 2
+    contents: binary.DontRead(),
+};
+const fat_header = {
+    magic: uint32, // FAT_MAGIC
+    archs: binary.ArrayType(uint32, fat_arch)
+};
+const REQ_DYLD = 0x80000000;
+;
+const str = {
+    get(s) {
+        const off = uint32.get(s); // offset to the string
+        return binary.utils.decodeTextTo0(s.buffer_at(off - 8), 'utf8');
+    }
+};
+const index_table = {
+    first: uint32,
+    count: uint32,
+};
+const blob = {
+    get(s) {
+        const offset = uint32.get(s);
+        const size = uint32.get(s);
+        if (size)
+            return s.subdata(offset, size); //.buffer_at(offset, size);
+    }
+};
+function blobT(type) {
+    return {
+        get(s) {
+            const offset = uint32.get(s);
+            const size = uint32.get(s);
+            return {
+                data: s.subdata(offset, size),
+                contents: binary.read(s.substream(offset, size), type)
+            };
+        }
+    };
+}
+function blobArray(type) {
+    return blobT(binary.RemainingArrayType(type));
+}
+function count_table(type) {
+    return {
+        get(s) {
+            const offset = uint32.get(s);
+            const count = uint32.get(s);
+            if (count)
+                return binary.readn(s.substream(offset), type, count);
+        }
+    };
+}
+const fixed_string16 = binary.StringType(16);
+const version = binary.asFlags(uint32, { major: 0xffff0000, minor: 0xff00, patch: 0xff }, false);
+const command = {
+    cmd: binary.as(uint32, v => v),
+    cmdsize: uint32,
+};
+const SECTION_FLAGS = binary.BitFields({
+    TYPE: [8, binary.Enum({
+            REGULAR: 0x0, // regular section
+            ZEROFILL: 0x1, // zero fill on demand section
+            CSTRING_LITERALS: 0x2, // section with only literal C strings
+            LITERALS4: 0x3, // section with only 4 byte literals
+            LITERALS8: 0x4, // section with only 8 byte literals
+            LITERAL_POINTERS: 0x5, // section with only pointers to literals
+            NON_LAZY_SYMBOL_POINTERS: 0x6, // section with only non-lazy symbol pointers
+            LAZY_SYMBOL_POINTERS: 0x7, // section with only lazy symbol pointers
+            SYMBOL_STUBS: 0x8, // section with only symbol stubs, byte size of stub in	the reserved2 field
+            MOD_INIT_FUNC_POINTERS: 0x9, // section with only function pointers for initialization
+            MOD_TERM_FUNC_POINTERS: 0xa, // section with only function pointers for termination
+            COALESCED: 0xb, // section contains symbols that are to be coalesced
+            GB_ZEROFILL: 0xc, // zero fill on demand section (that can be larger than 4 gigabytes)
+            INTERPOSING: 0xd, // section with only pairs of function pointers for interposing
+            LITERALS16: 0xe, // section with only 16 byte literals
+            DTRACE_DOF: 0xf, // section contains DTrace Object Format
+            LAZY_DYLIB_SYMBOL_POINTERS: 0x10, // section with only lazy symbol pointers to lazy loaded dylibs
+            // Section types to support thread local variables
+            THREAD_LOCAL_REGULAR: 0x11, // template of initial values for TLVs
+            THREAD_LOCAL_ZEROFILL: 0x12, // template of initial values for TLVs
+            THREAD_LOCAL_VARIABLES: 0x13, // TLV descriptors
+            THREAD_LOCAL_VARIABLE_POINTERS: 0x14, // pointers to TLV descriptors
+            THREAD_LOCAL_INIT_FUNCTION_POINTERS: 0x15, // functions to call to initialize TLV values
+        })],
+    ATTRIBUTES: [24, binary.BitFields({
+            SYS: [16, binary.Flags({
+                    SOME_INSTRUCTIONS: 0x0004, // section contains some machine instructions
+                    EXT_RELOC: 0x0002, // section has external relocation entries
+                    LOC_RELOC: 0x0001, // section has local relocation entries
+                }, true)],
+            USR: [8, binary.Flags({
+                    PURE_INSTRUCTIONS: 0x80, // section contains only true machine instructions
+                    NO_TOC: 0x40, // section contains coalesced symbols that are not to be in a ranlib table of contents
+                    STRIP_STATIC_SYMS: 0x20, // ok to strip static symbols in this section in files with the MH_DYLDLINK flag
+                    NO_DEAD_STRIP: 0x10, // no dead stripping
+                    LIVE_SUPPORT: 0x08, // blocks are live if they reference live blocks
+                    SELF_MODIFYING_CODE: 0x04, // Used with i386 code stubs written on by dyld
+                    DEBUG: 0x02, // a debug section
+                }, true)],
+        })],
+});
+function section(bits) {
+    const type = binary.UINT(bits);
+    class Section extends binary.Class({
+        //data:		binary.DontRead<binary.utils.MappedMemory>(),
+        sectname: fixed_string16,
+        segname: fixed_string16,
+        addr: type, // memory address of this section
+        size: type, // size in bytes of this section
+        offset: xint32, // file offset of this section
+        align: uint32, // section alignment (power of 2)
+        reloff: xint32, // file offset of relocation entries
+        nreloc: uint32, // number of relocation entries
+        flags: binary.as(uint32, SECTION_FLAGS), // flags (section type and attributes)
+        reserved1: uint32, // reserved (for offset or index)
+        reserved2: uint32, // reserved (for count or sizeof)
+        _: binary.AlignType(bits / 8)
+    }) {
+        data;
+        constructor(s) {
+            super(s);
+            const prot = this.flags.ATTRIBUTES.SYS.SOME_INSTRUCTIONS ? 4 /* binary.MEM.EXECUTE */ : 0 /* binary.MEM.NONE */;
+            this.data = (async () => 
+            //new binary.utils.MappedMemory(await s.file.get(BigInt(this.addr), Number(this.size)), Number(this.addr), prot)
+            new binary.MappedMemory(s.subdata(+this.offset, Number(this.size)), Number(this.addr), prot))();
+        }
+    }
+    return Section;
+}
+const SEGMENT_FLAGS = {
+    HIGHVM: 0x1, // the file contents for this segment is for the high part of the VM space, the low part is zero filled (for stacks in core files)
+    FVMLIB: 0x2, // this segment is the VM that is allocated by a fixed VM library, for overlap checking in the link editor
+    NORELOC: 0x4, // this segment has nothing that was relocated in it and nothing relocated to it, that is it maybe safely replaced without relocation
+    PROTECTED_VERSION_1: 0x8, // This segment is protected.	If the segment starts at file offset 0, the first page of the segment is not protected.	All other pages of the segment are protected.
+};
+function segment(bits) {
+    const type = binary.UINT(bits);
+    const fields = {
+        data: binary.DontRead(),
+        segname: fixed_string16, // segment name
+        vmaddr: type, // memory address of this segment
+        vmsize: type, // memory size of this segment
+        fileoff: type, // file offset of this segment
+        filesize: type, // amount to map from the file
+        maxprot: uint32, // maximum VM protection
+        initprot: uint32, // initial VM protection
+        nsects: uint32, // number of sections in segment
+        flags: binary.as(uint32, binary.Flags(SEGMENT_FLAGS, true)), // flags
+        sections: binary.DontRead(), //binary.ReadType<typeof section(bits)>)),
+    };
+    return {
+        get(s) {
+            const o = binary.read(s, fields);
+            async function load() {
+                const data = await s.getmem(BigInt(Number(o.vmaddr)), Number(o.filesize)) ?? s.subdata(Number(o.fileoff), Number(o.filesize));
+                o.data = new binary.MappedMemory(data, Number(o.vmaddr), o.initprot);
+                //const sect = section(bits);
+                if (o.nsects) {
+                    o.sections = binary.objectWithNames(binary.ArrayType(o.nsects, section(bits)), binary.field('sectname')).get(s);
+                    //o.sections = Object.fromEntries(Array.from({length: o.nsects}, (_,i)=>new sect(s)).map(s => [s.sectname, s]));
+                }
+            }
+            load();
+            return o;
+        }
+    };
+}
+/*
+function segment(bits: 32|64) {
+    const type		= binary.UINT(bits);
+    return class extends binary.ReadWriteStruct({
+        segname: 	fixed_string16,	// segment name
+        vmaddr:		type,		// memory address of this segment
+        vmsize:		type,		// memory size of this segment
+        fileoff:	type,		// file offset of this segment
+        filesize:	type,		// amount to map from the file
+        maxprot:	uint32,		// maximum VM protection
+        initprot:	uint32,		// initial VM protection
+        nsects:		uint32,		// number of sections in segment
+        flags:		binary.as(uint32, binary.Flags(SEGMENT_FLAGS,true)),			// flags
+    }) {
+        data?:		binary.MappedMemory;
+        sections:	Record<string, any>	= {};
+
+        constructor(s: mach_stream) {
+            super(s);
+            this.load(s);
+        }
+        async load(s: mach_stream) {
+            const data = await s.getmem(BigInt(this.vmaddr), Number(this.filesize)) ?? s.subdata(Number(this.fileoff), Number(this.filesize));
+            this.data = new binary.MappedMemory(data, Number(this.vmaddr), this.initprot);
+
+            //const sect = section(bits);
+            if (this.nsects) {
+                this.sections = binary.objectWithNames(binary.ArrayType(this.nsects, section(bits)), binary.field('sectname')).get(s);
+                //o.sections = Object.fromEntries(Array.from({length: o.nsects}, (_,i)=>new sect(s)).map(s => [s.sectname, s]));
+            }
+
+        }
+    };
+}
+*/
+const fvmlib = {
+    name: str, // library's target pathname
+    minor_version: xint32, // library's minor version number
+    header_addr: xint32, // library's header address
+};
+const dylib = {
+    name: str,
+    timestamp: uint32,
+    current_version: version,
+    compatibility_version: version,
+};
+const thread_command = {
+    flavor: uint32, // flavor of thread state
+    count: uint32, // count of longs in thread state
+    // struct XXX_thread_state state	thread state for this flavor
+    // ...
+};
+// SYMTAB
+const nlist_flags = binary.BitFields({
+    ext: 1,
+    type: [3, binary.Enum({
+            UNDF: 0, // undefined, n_sect == NO_SECT
+            ABS: 1, // absolute, n_sect == NO_SECT
+            INDR: 5, // indirect
+            PBUD: 6, // prebound undefined (defined in a dylib)
+            SECT: 7, // defined in section number n_sect
+        })],
+    pext: 1,
+    stab: [3, binary.Enum({})],
+});
+/*
+//masks
+    //STAB	= 0xe0,		// if any of these bits set, a symbolic debugging entry
+    PEXT	= 0x10,		// private external symbol bit
+    //TYPE	= 0x0e,		// mask for the type bits
+    EXT		= 0x01,		// external symbol bit, set for external symbols
+    
+    UNDF	= 0x00,		// undefined, n_sect == NO_SECT
+    ABS		= 0x02,		// absolute, n_sect == NO_SECT
+    INDR	= 0x0a,		// indirect
+    PBUD	= 0x0c,		// prebound undefined (defined in a dylib)
+    SECT	= 0x0e,		// defined in section number n_sect
+// STAB values
+    GSYM	= 0x20,		// global symbol: name,,NO_SECT,type,0
+    FNAME	= 0x22,		// procedure name (f77 kludge): name,,NO_SECT,0,0
+    FUN		= 0x24,		// procedure: name,,n_sect,linenumber,address
+    STSYM	= 0x26,		// static symbol: name,,n_sect,type,address
+    LCSYM	= 0x28,		// .lcomm symbol: name,,n_sect,type,address
+    BNSYM	= 0x2e,		// begin nsect sym: 0,,n_sect,0,address
+    OPT		= 0x3c,		// emitted with gcc2_compiled and in gcc source
+    RSYM	= 0x40,		// register sym: name,,NO_SECT,type,register
+    SLINE	= 0x44,		// src line: 0,,n_sect,linenumber,address
+    ENSYM	= 0x4e,		// end nsect sym: 0,,n_sect,0,address
+    SSYM	= 0x60,		// structure elt: name,,NO_SECT,type,struct_offset
+    SO		= 0x64,		// source file name: name,,n_sect,0,address
+    OSO		= 0x66,		// object file name: name,,0,0,st_mtime
+    LSYM	= 0x80,		// local sym: name,,NO_SECT,type,offset
+    BINCL	= 0x82,		// include file beginning: name,,NO_SECT,0,sum
+    SOL		= 0x84,		// #included file name: name,,n_sect,0,address
+    PARAMS	= 0x86,		// compiler parameters: name,,NO_SECT,0,0
+    VERSION	= 0x88,		// compiler version: name,,NO_SECT,0,0
+    OLEVEL	= 0x8A,		// compiler -O level: name,,NO_SECT,0,0
+    PSYM	= 0xa0,		// parameter: name,,NO_SECT,type,offset
+    EINCL	= 0xa2,		// include file end: name,,NO_SECT,0,0
+    ENTRY	= 0xa4,		// alternate entry: name,,n_sect,linenumber,address
+    LBRAC	= 0xc0,		// left bracket: 0,,NO_SECT,nesting level,address
+    EXCL	= 0xc2,		// deleted include file: name,,NO_SECT,0,sum
+    RBRAC	= 0xe0,		// right bracket: 0,,NO_SECT,nesting level,address
+    BCOMM	= 0xe2,		// begin common: name,,NO_SECT,0,0
+    ECOMM	= 0xe4,		// end common: name,,n_sect,0,0
+    ECOML	= 0xe8,		// end common (local name): 0,,n_sect,0,address
+    LENG	= 0xfe,		// second stab entry with length information
+}
+*/
+const nlist_desc = binary.BitFields({
+    ref: [3, binary.Enum({
+            UNDEFINED_NON_LAZY: 0,
+            UNDEFINED_LAZY: 1,
+            DEFINED: 2,
+            PRIVATE_DEFINED: 3,
+            PRIVATE_UNDEFINED_NON_LAZY: 4,
+            PRIVATE_UNDEFINED_LAZY: 5,
+        })],
+    flags: [5, binary.Flags({
+            ARM_THUMB_DEF: 1 << 0, // symbol is a Thumb function (ARM)
+            REF_DYNAMIC: 1 << 1,
+            NO_DEAD_STRIP: 1 << 2, // symbol is not to be dead stripped
+            //DESC_DISCARDE:				1 << 2,	// symbol is discarded
+            WEAK_REF: 1 << 3, // symbol is weak referenced
+            WEAK_DEF: 1 << 4, // coalesed symbol is a weak definition
+            //REF_TO_WEA					1 << 4,	// reference to a weak symbol
+            //SYMBOL_RESOLVER:				0x0100,
+        }, true)],
+    align: 8
+    //MAX_LIBRARY_ORDINAL				= 0xfd	<< 8,
+    //DYNAMIC_LOOKUP_ORDINAL			= 0xfe	<< 8,
+    //EXECUTABLE_ORDINAL				= 0xff	<< 8,
+});
+function nlist(bits) {
+    return {
+        strx: uint32, // index into the string table
+        flags: binary.as(binary.UINT8, nlist_flags),
+        sect: binary.UINT8, // section number or NO_SECT
+        desc: binary.as(uint16, nlist_desc),
+        value: binary.UINT(bits),
+        //const char *name(const char *s) const { return s ? s + strx : ""; }
+        //FLAGS		type()	const	{ return FLAGS(flags & TYPE); }
+        //FLAGS		stab()	const	{ return FLAGS(flags & STAB); }
+    };
+}
+const symtab = {
+    get(s) {
+        const sym = binary.read(s, count_table(nlist(64)));
+        const str = binary.read(s, blob);
+        return sym?.map(v => [binary.utils.decodeTextTo0(str.subarray(v.strx), 'utf8'), v]);
+    }
+};
+// DYSYMTAB
+const INDIRECT = {
+    INDIRECT_SYMBOL_LOCAL: 0x80000000, // non-lazy symbol pointer section for a defined symbol which strip(1) has removed
+    INDIRECT_SYMBOL_ABS: 0x40000000,
+};
+const toc_entry = {
+    symbol_index: uint32, // the defined external symbol (index into the symbol table)
+    module_index: uint32, // index into the module table this symbol is defined in
+};
+function module(bits) {
+    const fields = {
+        module_name: uint32, // the module name (index into string table)
+        extdefsym: index_table, // index into externally defined symbols
+        refsym: index_table, // index into reference symbol table
+        localsym: index_table, // index into symbols for local symbols
+        extrel: index_table, // index into external relocation entries
+        init_iterm: index_table, // low 16 bits are the index into the init section, high 16 bits are the index into the term section
+    };
+    return bits == 32 ? { ...fields,
+        objc_module_info_addr: uint32, // for this module address of the start of the (__OBJC,__module_info) section
+        objc_module_info_size: uint32, // for this module size of the (__OBJC,__module_info) section
+    } : { ...fields,
+        objc_module_info_size: uint32, // for this module size of the (__OBJC, __module_info) section
+        objc_module_info_addr: uint64, // for this module address of the start of the (__OBJC, __module_info) section
+    };
+}
+const symbol_ref = binary.as(uint32, binary.BitFields({
+    symbol_index: 24, // index into the symbol table
+    flags: 8
+}));
+const hint = binary.as(uint32, binary.BitFields({
+    sub_image: 8, // index into the sub images
+    toc: 24 // index into the table of contents
+}));
+const version_min = {
+    version,
+    reserved: uint32, // zero
+};
+const REBASE = binary.BitFields({
+    immediate: 4,
+    opcode: [4, binary.Enum({
+            DONE: 0,
+            SET_TYPE_IMM: 1,
+            SET_SEGMENT_AND_OFFSET_ULEB: 2,
+            ADD_ADDR_ULEB: 3,
+            ADD_ADDR_IMM_SCALED: 4,
+            DO_REBASE_IMM_TIMES: 5,
+            DO_REBASE_ULEB_TIMES: 6,
+            DO_REBASE_ADD_ADDR_ULEB: 7,
+            DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: 8,
+        })]
+    //TYPE_POINTER							= 1,
+    //TYPE_TEXT_ABSOLUTE32					= 2,
+    //TYPE_TEXT_PCREL32						= 3,
+});
+const BIND = binary.BitFields({
+    immediate: 4,
+    opcode: [4, binary.Enum({
+            DONE: 0,
+            SET_DYLIB_ORDINAL_IMM: 1,
+            SET_DYLIB_ORDINAL_ULEB: 2,
+            SET_DYLIB_SPECIAL_IMM: 3,
+            SET_SYMBOL_TRAILING_FLAGS_IMM: 4,
+            SET_TYPE_IMM: 5,
+            SET_ADDEND_SLEB: 6,
+            SET_SEGMENT_AND_OFFSET_ULEB: 7,
+            ADD_ADDR_ULEB: 8,
+            DO_BIND: 9,
+            DO_BIND_ADD_ADDR_ULEB: 10,
+            DO_BIND_ADD_ADDR_IMM_SCALED: 11,
+            DO_BIND_ULEB_TIMES_SKIPPING_ULEB: 12,
+        })]
+    //TYPE_POINTER							= 1,
+    //TYPE_TEXT_ABSOLUTE32					= 2,
+    //TYPE_TEXT_PCREL32						= 3,
+    //SPECIAL_DYLIB_SELF					= 0,
+    //SPECIAL_DYLIB_MAIN_EXECUTABLE			= -1,
+    //SPECIAL_DYLIB_FLAT_LOOKUP				= -2,
+    //SYMBOL_FLAGS_WEAK_IMPORT				= 0x1,
+    //SYMBOL_FLAGS_NON_WEAK_DEFINITION		= 0x8,
+});
+const dyld_kind = {
+    KIND_MASK: 0x03,
+    KIND_REGULAR: 0x00,
+    KIND_THREAD_LOCAL: 0x01,
+    KIND_ABSOLUTE: 0x02,
+    WEAK_DEFINITION: 0x04,
+    REEXPORT: 0x08,
+    STUB_AND_RESOLVER: 0x10,
+};
+const dyldinfo = {
+    rebase: blob,
+    bind: blob,
+    weak_bind: blob,
+    lazy_bind: blob,
+    exprt: blob,
+};
+//BUILD_VERSION
+const TOOL = {
+    CLANG: 1,
+    SWIFT: 2,
+    LD: 3,
+    LLD: 4,
+};
+const PLATFORM = {
+    MACOS: 1,
+    IOS: 2,
+    TVOS: 3,
+    WATCHOS: 4,
+    BRIDGEOS: 5,
+    MACCATALYST: 6,
+    IOSSIMULATOR: 7,
+    TVOSSIMULATOR: 8,
+    WATCHOSSIMULATOR: 9,
+    DRIVERKIT: 10,
+};
+//DYLD_CHAINED_FIXUPS
+const dyld_chained_starts_in_segment = {
+    size: uint32, ///< Size of this, including chain_starts entries
+    page_size: uint16, ///< Page size in bytes (0x1000 or 0x4000)
+    pointer_format: binary.asEnum(uint16, {
+        ARM64E: 1,
+        '64': 2,
+        '32': 3,
+        '32_CACHE': 4,
+        '32_FIRMWARE': 5,
+        '64_OFFSET': 6,
+        ARM64E_KERNEL: 7,
+        '64_KERNEL_CACHE': 8,
+        ARM64E_USERLAND: 9,
+        ARM64E_FIRMWARE: 10,
+        X86_64_KERNEL_CACHE: 11,
+        ARM64E_USERLAND24: 12,
+    }),
+    segment_offset: xint64, // VM offset from the __TEXT segment
+    max_valid_pointer: xint32, // Values beyond this are not pointers on 32-bit
+    pages: binary.ArrayType(uint16, binary.asEnum(uint16, {
+        NONE: 0xFFFF,
+        MULTI: 0x8000, // page which has multiple starts
+        LAST: 0x8000, // last chain_start for a given page
+    }))
+};
+const dyld_chained_starts_in_image = binary.ArrayType(uint32, binary.OffsetType(uint32, dyld_chained_starts_in_segment));
+const dyld_chained_import = binary.as(uint32, binary.BitFields({
+    lib_ordinal: 8,
+    weak_import: 1,
+    name_offset: 23,
+}));
+const dyld_chained_import_addend = {
+    import: dyld_chained_import,
+    addend: int32,
+};
+const dyld_chained_import_addend64 = {
+    import: binary.as(uint64, binary.BitFields({
+        lib_ordinal: 16,
+        weak_import: 1,
+        reserved: 15,
+        name_offset: 32,
+    })),
+    addend: uint64,
+};
+class dyld_chained_fixups extends binary.ReadClass({
+    fixups_version: uint32, // currently 0
+    starts: binary.OffsetType(uint32, dyld_chained_starts_in_image),
+    imports: binary.OffsetType(uint32, binary.Remainder), // offset of imports table in chain_data
+    symbols: binary.OffsetType(uint32, binary.Remainder), // offset of symbol strings in chain_data
+    imports_count: uint32, // number of imported symbol names
+    imports_format: binary.asEnum(uint32, {
+        IMPORT: 1,
+        IMPORT_ADDEND: 2,
+        IMPORT_ADDEND64: 3
+    }),
+    symbols_format: binary.asEnum(uint32, {
+        UNCOMPRESSED: 0,
+        ZLIB: 1,
+    }),
+}) {
+    imports2;
+    constructor(s) {
+        super(s);
+        const imports = new binary.endianStream(this.imports, s.be);
+        switch (this.imports_format) {
+            case 'IMPORT': {
+                this.imports2 = binary.withNames(binary.readn(imports, dyld_chained_import, this.imports_count), imp => binary.utils.decodeTextTo0(this.symbols.subarray(Number(imp.name_offset))));
+                break;
+            }
+            case 'IMPORT_ADDEND':
+                this.imports2 = binary.withNames(binary.readn(imports, dyld_chained_import_addend, this.imports_count), imp => binary.utils.decodeTextTo0(this.symbols.subarray(Number(imp.import.name_offset))));
+                break;
+            case 'IMPORT_ADDEND64':
+                this.imports2 = binary.withNames(binary.readn(imports, dyld_chained_import_addend64, this.imports_count), imp => binary.utils.decodeTextTo0(this.symbols.subarray(Number(imp.import.name_offset))));
+                break;
+        }
+    }
+}
+const dyld_chained_ptr_64_bind = binary.as(uint64, binary.BitFields({
+    ordinal: 24,
+    addend: 8,
+    reserved: 19,
+    next: 12,
+    bind: 1, // set to 1
+}));
+const dyld_chained_ptr_64_rebase = binary.as(uint64, binary.BitFields({
+    target: 36,
+    high8: 8,
+    reserved: 7,
+    next: 12,
+    bind: 1, // set to 0
+}));
+//DATA_IN_CODE
+const data_in_code_entry = {
+    offset: xint32, // from header to start of data range
+    length: uint16, // number of bytes in data range
+    kind: binary.as(uint16, binary.Enum({
+        DATA: 0x0001,
+        JUMP_TABLE8: 0x0002,
+        JUMP_TABLE16: 0x0003,
+        JUMP_TABLE32: 0x0004,
+        ABS_JUMP_TABLE32: 0x0005,
+    })),
+};
+// Sections of type S_THREAD_LOCAL_VARIABLES contain an array of tlv_descriptor structures.
+/*
+const tlv_descriptor = {
+    void*			(*thunk)(tlv_descriptor*);
+    unsigned long	key;
+    unsigned long	offset;
+};
+*/
+function routines(bits) {
+    const type = binary.UINT(bits);
+    return {
+        init_address: type, // address of initialization routine
+        init_module: type, // index into the module table that the init routine is defined in
+        reserved1: type,
+        reserved2: type,
+        reserved3: type,
+        reserved4: type,
+        reserved5: type,
+        reserved6: type,
+    };
+}
+//const cmd_table : {[K in CMD]?: binary.TypeReader2} = {
+const cmd_table = {
+    [1 /* CMD.SEGMENT */]: segment(32),
+    [25 /* CMD.SEGMENT_64 */]: segment(64),
+    [6 /* CMD.LOADFVMLIB */]: fvmlib,
+    [7 /* CMD.IDFVMLIB */]: fvmlib,
+    [12 /* CMD.LOAD_DYLIB */]: dylib,
+    [13 /* CMD.ID_DYLIB */]: dylib,
+    [2147483672 /* CMD.LOAD_WEAK_DYLIB */]: dylib,
+    [2147483679 /* CMD.REEXPORT_DYLIB */]: dylib,
+    [32 /* CMD.LAZY_LOAD_DYLIB */]: dylib,
+    [2147483683 /* CMD.LOAD_UPWARD_DYLIB */]: dylib,
+    [18 /* CMD.SUB_FRAMEWORK */]: str,
+    [19 /* CMD.SUB_UMBRELLA */]: str,
+    [20 /* CMD.SUB_CLIENT */]: str,
+    [21 /* CMD.SUB_LIBRARY */]: str,
+    [14 /* CMD.LOAD_DYLINKER */]: str,
+    [15 /* CMD.ID_DYLINKER */]: str,
+    [39 /* CMD.DYLD_ENVIRONMENT */]: str,
+    [2147483676 /* CMD.RPATH */]: str,
+    [16 /* CMD.PREBOUND_DYLIB */]: {
+        name: str,
+        nmodules: uint32,
+        linked_modules: str,
+    },
+    [4 /* CMD.THREAD */]: thread_command,
+    [5 /* CMD.UNIXTHREAD */]: thread_command,
+    [17 /* CMD.ROUTINES */]: routines(32),
+    [26 /* CMD.ROUTINES_64 */]: routines(64),
+    [2 /* CMD.SYMTAB */]: symtab,
+    [22 /* CMD.TWOLEVEL_HINTS */]: count_table(hint),
+    [23 /* CMD.PREBIND_CKSUM */]: {
+        cksum: uint32,
+    },
+    [27 /* CMD.UUID */]: {
+        uuid: binary.Buffer(16),
+    },
+    [29 /* CMD.CODE_SIGNATURE */]: blob,
+    [30 /* CMD.SEGMENT_SPLIT_INFO */]: blob,
+    [38 /* CMD.FUNCTION_STARTS */]: blobArray(binary.ULEB128),
+    [41 /* CMD.DATA_IN_CODE */]: blobArray(data_in_code_entry),
+    [43 /* CMD.DYLIB_CODE_SIGN_DRS */]: blob,
+    [46 /* CMD.LINKER_OPTIMIZATION_HINT */]: blob,
+    [2147483699 /* CMD.DYLD_EXPORTS_TRIE */]: blob,
+    [2147483700 /* CMD.DYLD_CHAINED_FIXUPS */]: blob, //blobT(dyld_chained_fixups),
+    [33 /* CMD.ENCRYPTION_INFO */]: {
+        cryptoff: uint32, // file offset of encrypted range
+        cryptsize: uint32, // file size of encrypted range
+        cryptid: uint32, // which enryption system, 0 means not-encrypted yet
+    },
+    [44 /* CMD.ENCRYPTION_INFO_64 */]: {
+        cryptoff: uint32, // file offset of encrypted range
+        cryptsize: uint32, // file size of encrypted range
+        cryptid: uint32, // which enryption system, 0 means not-encrypted yet
+        pad: uint32, // must be zero
+    },
+    [36 /* CMD.VERSION_MIN_MACOSX */]: version_min,
+    [37 /* CMD.VERSION_MIN_IPHONEOS */]: version_min,
+    [47 /* CMD.VERSION_MIN_TVOS */]: version_min,
+    [48 /* CMD.VERSION_MIN_WATCHOS */]: version_min,
+    [34 /* CMD.DYLD_INFO */]: dyldinfo,
+    [2147483682 /* CMD.DYLD_INFO_ONLY */]: dyldinfo,
+    [3 /* CMD.SYMSEG */]: blob, //OBSOLETE
+    //	[CMD.IDENT]:					{},//OBSOLETE
+    [9 /* CMD.FVMFILE */]: {
+        name: str,
+        header_addr: uint32,
+    },
+    [2147483688 /* CMD.MAIN */]: {
+        entryoff: uint32, // file (__TEXT) offset of entry point
+        stacksize: uint32, // if not zero, initialize stack size
+    },
+    [42 /* CMD.SOURCE_VERSION */]: {
+        version: binary.as(binary.UINT64_BE, binary.BitFields({ a: 24, b: 10, c: 10, d: 10, e: 10 })) // A.B.C.D.E packed as a24.b10.c10.d10.e10
+    },
+    [50 /* CMD.BUILD_VERSION */]: {
+        platform: binary.asEnum(uint32, PLATFORM),
+        minos: version,
+        sdk: version,
+        tools: binary.objectWithNames(binary.ArrayType(uint32, { tool: binary.as(uint32, binary.Enum(TOOL)), version }), binary.field('tool')),
+    },
+    [45 /* CMD.LINKER_OPTION */]: {
+        count: uint32, // number of strings following
+    },
+    [49 /* CMD.NOTE */]: {
+        data_owner: fixed_string16, // owner name for this LC_NOTE
+        data: blob
+    },
+    //	[CMD.PREPAGE]:					{},
+    [11 /* CMD.DYSYMTAB */]: {
+        localsym: index_table, // local symbols
+        extdefsym: index_table, // externally defined symbols
+        undefsym: index_table, // undefined symbols
+        toc: count_table(toc_entry), // table of contents
+        modtab: count_table(module(64)), // module table
+        extrefsym: count_table(symbol_ref), // referenced symbol table
+        indirectsym: count_table(symbol_ref), // indirect symbol table
+        extrel: count_table({ address: uint32, symbol_ref }), // external relocation entries
+        locrel: count_table({ address: uint32, symbol_ref }), // local relocation entries
+    },
+};
+class MachFile {
+    header;
+    commands = [];
+    ready;
+    static check(data) {
+        switch (binary.UINT32_BE.get(new binary.stream(data))) {
+            case 0xfeedface:
+            case 0xcefaedfe:
+            case 0xfeedfacf:
+            case 0xcffaedfe:
+                return true;
+            default:
+                return false;
+        }
+    }
+    constructor(data, mem) {
+        const magic = binary.UINT32_LE.get(new binary.stream(data));
+        switch (magic) {
+            case 0xfeedface:
+                this.ready = this.load(data, false, 32, mem);
+                break;
+            case 0xcefaedfe:
+                this.ready = this.load(data, true, 32, mem);
+                break;
+            case 0xfeedfacf:
+                this.ready = this.load(data, false, 64, mem);
+                break;
+            case 0xcffaedfe:
+                this.ready = this.load(data, true, 64, mem);
+                break;
+            default: throw new Error('not a mach file');
+        }
+    }
+    async load(data, be, bits, mem) {
+        const file = new binary.endianStream(data, be);
+        const h = binary.read(file, header);
+        const cpu = CPU_TYPE[h.cputype];
+        h.cpusubtype = binary.Enum(CPU_SUBTYPES[cpu])(+h.cpusubtype);
+        if (bits === 64)
+            file.skip(4);
+        for (let i = 0; i < h.ncmds; ++i) {
+            const cmd = binary.read(file, command);
+            const file2 = new mach_stream(data, file.read_buffer(cmd.cmdsize - 8), file.be, mem);
+            const result = await binary.read(file2, cmd_table[cmd.cmd] ?? {});
+            this.commands.push({ cmd: cmd.cmd, data: result });
+        }
+        this.header = h;
+        const funcs = this.getCommand(38 /* CMD.FUNCTION_STARTS */);
+        if (funcs) {
+            const array = funcs.contents;
+            const text = await this.getSegment('__TEXT');
+            let acc = BigInt(text?.vmaddr ?? 0);
+            for (const i in array)
+                array[i] = (acc += BigInt(array[i]));
+        }
+    }
+    getCommand(cmd) {
+        for (const i of this.commands) {
+            if (i.cmd === cmd)
+                return i.data;
+        }
+    }
+    getSegment(name) {
+        for (const i of this.commands) {
+            if (i.cmd === 1 /* CMD.SEGMENT */ && i.data.segname === name)
+                return i.data;
+            if (i.cmd === 25 /* CMD.SEGMENT_64 */ && i.data.segname === name)
+                return i.data;
+            ;
+        }
+    }
+}
+exports.MachFile = MachFile;
+const FAT_MAGIC = 0xcafebabe;
+const FAT_CIGAM = 0xbebafeca;
+class FATMachFile {
+    archs = [];
+    static check(data) {
+        switch (binary.UINT32_BE.get(new binary.stream(data))) {
+            case FAT_MAGIC:
+            case FAT_CIGAM:
+                return true;
+            default:
+                return false;
+        }
+    }
+    constructor(data, mem) {
+        switch (binary.UINT32_BE.get(new binary.stream(data))) {
+            case FAT_MAGIC:
+                this.load(new binary.endianStream(data, false), mem);
+                break;
+            case FAT_CIGAM:
+                this.load(new binary.endianStream(data, true), mem);
+                break;
+            default:
+                throw new Error('not a fat mach file');
+        }
+    }
+    load(file, mem) {
+        const header = binary.read(file, fat_header);
+        this.archs = header.archs;
+        for (const arch of header.archs) {
+            const cpu = CPU_TYPE[arch.cputype];
+            const data = file.buffer_at(arch.offset, arch.size);
+            arch.cpusubtype = binary.Enum(CPU_SUBTYPES[cpu])(+arch.cpusubtype);
+            arch.contents = new MachFile(data, mem);
+        }
+    }
+}
+exports.FATMachFile = FATMachFile;
+/*
+export function freestanding<T extends CMD>(s: binary.stream, cmd: T) : binary.ReadType<typeof cmd_table[T]>;
+export function freestanding(s: binary.stream, cmd: CMD) {
+    return binary.read(s, cmd_table[cmd]);
+}
+*/