跳转到内容
标准库Zig 0.17.0官方原文
源码std/macho.zig

第 1 行

std.macho.Allocator

别名

第 8 行

别名目标 std.mem.Allocator

std.macho.ARFMAG

常量

第 2222 行

每个头部末尾 ar_fmag 中的字符串。

std.macho.ARMAG

常量

第 2220 行

归档文件的起始字符串。

std.macho.assert

别名

第 3 行

别名目标 std.debug.assert

std.macho.BIND_IMMEDIATE_MASK

常量

第 1603 行

u8

std.macho.BIND_OPCODE_ADD_ADDR_ULEB

常量

第 1612 行

u8

std.macho.BIND_OPCODE_DO_BIND

常量

第 1613 行

u8

std.macho.BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED

常量

第 1615 行

u8

std.macho.BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB

常量

第 1614 行

u8

std.macho.BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB

常量

第 1616 行

u8

std.macho.BIND_OPCODE_DONE

常量

第 1604 行

u8

std.macho.BIND_OPCODE_MASK

常量

第 1602 行

u8

std.macho.BIND_OPCODE_SET_ADDEND_SLEB

常量

第 1610 行

u8

std.macho.BIND_OPCODE_SET_DYLIB_ORDINAL_IMM

常量

第 1605 行

u8

std.macho.BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB

常量

第 1606 行

u8

std.macho.BIND_OPCODE_SET_DYLIB_SPECIAL_IMM

常量

第 1607 行

u8

std.macho.BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB

常量

第 1611 行

u8

std.macho.BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM

常量

第 1608 行

u8

std.macho.BIND_OPCODE_SET_TYPE_IMM

常量

第 1609 行

u8

std.macho.BIND_SPECIAL_DYLIB_FLAT_LOOKUP

常量

第 1597 行

i8

std.macho.BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE

常量

第 1596 行

i8

std.macho.BIND_SPECIAL_DYLIB_SELF

常量

第 1595 行

i8

std.macho.BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION

常量

第 1600 行

u8

std.macho.BIND_SYMBOL_FLAGS_WEAK_IMPORT

常量

第 1599 行

u8

std.macho.BIND_TYPE_POINTER

常量

第 1591 行

u8

std.macho.BIND_TYPE_TEXT_ABSOLUTE32

常量

第 1592 行

u8

std.macho.BIND_TYPE_TEXT_PCREL32

常量

第 1593 行

u8

std.macho.BlobIndex

容器

第 1894 行

嵌入式签名 SuperBlob 的结构

字段

type: u32

条目类型

offset: u32

条目的偏移量

std.macho.build_tool_version

容器

第 131 行

字段

tool: TOOL

工具对应的枚举

version: u32

工具的版本号

std.macho.build_version_command

容器

第 110 行

build_version_command 包含此二进制文件针对其平台构建时, 所要求的最低操作系统版本。后面列出已知平台 及工具值。

字段

cmd: LC = .BUILD_VERSION

LC_BUILD_VERSION

cmdsize: u32

sizeof(struct build_version_command) 加上 ntools * sizeof(struct build_version_command)

platform: PLATFORM

平台

minos: u32

X.Y.Z 以半字节格式 xxxx.yy.zz 编码

sdk: u32

X.Y.Z 以半字节格式 xxxx.yy.zz 编码

ntools: u32

后续工具条目的数量

std.macho.builtin

常量

第 2 行

std.macho.CodeDirectory

容器

第 1828 行

此 CodeDirectory 专门针对版本 0x20400。

字段

magic: u32

魔数(CSMAGIC_CODEDIRECTORY)

length: u32

CodeDirectory blob 总长度

version: u32

兼容版本

flags: u32

设置与模式标志

hashOffset: u32

索引为零的哈希槽元素的偏移量

identOffset: u32

标识符字符串的偏移量

nSpecialSlots: u32

特殊哈希槽数量

nCodeSlots: u32

普通(代码)哈希槽的数量

codeLimit: u32

限制在主映像签名范围内

hashSize: u8

每个哈希的字节大小

hashType: u8

哈希类型(cdHashType* 常量)

platform: u8

平台标识符;若非平台二进制文件,则为零。

pageSize: u8

log2(页大小,单位为字节);0 => 无穷大

spare2: u32

未使用(必须为零)

scatterOffset: u32
teamOffset: u32
spare3: u32
codeLimit64: u64
execSegBase: u64

可执行段的偏移

execSegLimit: u64

可执行段的界限

execSegFlags: u64

可执行段标志

std.macho.compact_unwind_encoding_t

类型

第 2009 行

std.macho.compact_unwind_entry

容器

第 2013 行

字段

rangeStart: u64
rangeLength: u32
compactUnwindEncoding: u32
personalityFunction: u64
lsda: u64

std.macho.CompactUnwindEncoding

容器

第 2155 行

字段

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

std.macho.CPU_SUBTYPE_ARM_ALL

常量

第 1571 行

所有基于 ARM 的 Mac

cpu_subtype_t

std.macho.cpu_subtype_t

类型

第 11 行

std.macho.CPU_SUBTYPE_X86_64_ALL

常量

第 1568 行

所有基于 Intel 的 Mac

cpu_subtype_t

std.macho.CPU_TYPE_ARM64

常量

第 1565 行

面向基于 64 位 ARM 处理器的 Mac 的 CPU 类型

cpu_type_t

std.macho.cpu_type_t

类型

第 10 行

std.macho.CPU_TYPE_X86_64

常量

第 1562 行

面向基于 64 位 Intel 处理器的 Mac 的 CPU 类型

cpu_type_t

std.macho.CS_ADHOC

常量

第 1822 行

u32

std.macho.CS_CDHASH_LEN

常量

第 1814 行

始终如此 - 较大的哈希会被截断

u32

std.macho.CS_EXECSEG_MAIN_BINARY

常量

第 1825 行

u32

std.macho.CS_HASH_MAX_SIZE

常量

第 1816 行

支持的哈希值最大长度

u32

std.macho.CS_HASHTYPE_SHA1

常量

第 1804 行

u8

std.macho.CS_HASHTYPE_SHA256

常量

第 1805 行

u8

std.macho.CS_HASHTYPE_SHA256_TRUNCATED

常量

第 1806 行

u8

std.macho.CS_HASHTYPE_SHA384

常量

第 1807 行

u8

std.macho.CS_LINKER_SIGNED

常量

第 1823 行

u32

std.macho.CS_SHA1_LEN

常量

第 1809 行

u32

std.macho.CS_SHA256_LEN

常量

第 1810 行

u32

std.macho.CS_SHA256_TRUNCATED_LEN

常量

第 1811 行

u32

std.macho.CS_SIGNER_TYPE_LEGACYVPN

常量

第 1819 行

u32

std.macho.CS_SIGNER_TYPE_MAC_APP_STORE

常量

第 1820 行

u32

std.macho.CS_SIGNER_TYPE_UNKNOWN

常量

第 1818 行

u32

std.macho.CS_SUPPORTSCODELIMIT64

常量

第 1775 行

u32

std.macho.CS_SUPPORTSEXECSEG

常量

第 1776 行

u32

std.macho.CS_SUPPORTSSCATTER

常量

第 1773 行

u32

std.macho.CS_SUPPORTSTEAMID

常量

第 1774 行

u32

std.macho.CSMAGIC_BLOBWRAPPER

常量

第 1771 行

包含 CMS 签名等内容

u32

std.macho.CSMAGIC_CODEDIRECTORY

常量

第 1759 行

CodeDirectory 数据块

u32

std.macho.CSMAGIC_DETACHED_SIGNATURE

常量

第 1769 行

包含多种架构的嵌入签名集合

u32

std.macho.CSMAGIC_EMBEDDED_DER_ENTITLEMENTS

常量

第 1767 行

嵌入的 DER 编码权限

u32

std.macho.CSMAGIC_EMBEDDED_ENTITLEMENTS

常量

第 1765 行

嵌入的授权信息

u32

std.macho.CSMAGIC_EMBEDDED_SIGNATURE

常量

第 1761 行

签名数据的嵌入形式

u32

std.macho.CSMAGIC_EMBEDDED_SIGNATURE_OLD

常量

第 1763 行

XXX

u32

std.macho.CSMAGIC_REQUIREMENT

常量

第 1755 行

单一 Requirement blob

u32

std.macho.CSMAGIC_REQUIREMENTS

常量

第 1757 行

要求向量(内部要求)

u32

std.macho.CSSLOT_ALTERNATE_CODEDIRECTORIES

常量

第 1788 行

首个备用 CodeDirectory,若存在

u32

std.macho.CSSLOT_ALTERNATE_CODEDIRECTORY_LIMIT

常量

第 1792 行

最后一个之后的位置

u32

std.macho.CSSLOT_ALTERNATE_CODEDIRECTORY_MAX

常量

第 1790 行

备用 CD 槽的最大数量

u32

std.macho.CSSLOT_APPLICATION

常量

第 1783 行

u32

std.macho.CSSLOT_CODEDIRECTORY

常量

第 1779 行

CodeDirectory 的槽索引

u32

std.macho.CSSLOT_DER_ENTITLEMENTS

常量

第 1785 行

u32

std.macho.CSSLOT_ENTITLEMENTS

常量

第 1784 行

u32

std.macho.CSSLOT_IDENTIFICATIONSLOT

常量

第 1796 行

u32

std.macho.CSSLOT_INFOSLOT

常量

第 1780 行

u32

std.macho.CSSLOT_REQUIREMENTS

常量

第 1781 行

u32

std.macho.CSSLOT_RESOURCEDIR

常量

第 1782 行

u32

std.macho.CSSLOT_SIGNATURESLOT

常量

第 1795 行

CMS 签名

u32

std.macho.CSSLOT_TICKETSLOT

常量

第 1797 行

u32

std.macho.CSTYPE_INDEX_ENTITLEMENTS

常量

第 1802 行

与 amfi 兼容

u32

std.macho.CSTYPE_INDEX_REQUIREMENTS

常量

第 1800 行

与 amfi 兼容

u32

std.macho.data_in_code_entry

容器

第 1926 行

LC_DATA_IN_CODE 加载命令使用 linkedit_data_command 指向 data_in_code_entry 条目数组。每个条目 描述代码节中的一段数据。

字段

offset: u32

从 mach_header 到数据范围起始位置。

length: u16

数据范围中的字节数。

kind: u16

一个 DICE_KIND 值。

std.macho.dyld_info_command

容器

第 404 行

dyld_info_command 包含 dyld 加载映像所需信息的新压缩形式的文件偏移量与大小。Mac OS X 10.6 及更高版本上的 dyld 使用此信息。 此命令指向的全部信息都以字节流编码,因此解释它们时无需交换字节序。

字段

cmd: LC = .DYLD_INFO_ONLY

LC_DYLD_INFO or LC_DYLD_INFO_ONLY

cmdsize: u32 = @sizeOf(dyld_info_command)

sizeof(struct dyld_info_command)

rebase_off: u32 = 0

重基信息的文件偏移

rebase_size: u32 = 0

重基信息的大小

bind_off: u32 = 0

绑定信息的文件偏移量

bind_size: u32 = 0

绑定信息的大小

weak_bind_off: u32 = 0

弱绑定信息的文件偏移

weak_bind_size: u32 = 0

弱绑定信息的大小

lazy_bind_off: u32 = 0

延迟绑定信息在文件中的偏移量

lazy_bind_size: u32 = 0

延迟绑定信息的大小

export_off: u32 = 0

延迟绑定信息在文件中的偏移量

export_size: u32 = 0

延迟绑定信息的大小

std.macho.dylib

容器

第 564 行

动态链接共享库由两项信息标识: 路径名,即执行时找到的库名称, 以及兼容版本号。路径名必须匹配,使用该库的程序记录的 兼容版本号必须大于或等于 实际使用的库的版本号。时间戳用于记录库构建 并被复制进使用方的时刻,以便判断运行时使用的库 是否与构建程序时所用的库完全相同。

字段

name: u32

库的路径名(指向 dylib_command 末尾的偏移)

timestamp: u32

库的构建时间戳

current_version: u32

库当前的版本号

compatibility_version: u32

库的兼容性版本号

std.macho.dylib_command

容器

第 546 行

动态链接的共享库,即 mach 头部中 filetype == MH_DYLIB 的文件, 包含一个 dylib_command,cmd == LC_ID_DYLIB,用于标识该库。 使用动态链接共享库的目标文件,对每个使用的库也包含 一个 dylib_command,其 cmd 为 LC_LOAD_DYLIB、LC_LOAD_WEAK_DYLIB 或 LC_REEXPORT_DYLIB。

字段

cmd: LC

取值为 LC_ID_DYLIB、LC_LOAD_WEAK_DYLIB、LC_LOAD_DYLIB、LC_REEXPORT_DYLIB

cmdsize: u32

包含路径名字符串

dylib: dylib

库标识

std.macho.dylinker_command

容器

第 525 行

使用动态链接器的程序包含 dylinker_command,以标识 动态链接器名称,即 LC_LOAD_DYLINKER。动态链接器自身 也包含 dylinker_command,以标识自身,即 LC_ID_DYLINKER。 一个文件至多包含其中一个命令。 此结构体也用于 LC_DYLD_ENVIRONMENT 加载命令, 包含供 dyld 按环境变量处理的字符串。

字段

cmd: LC

取值为 LC_ID_DYLINKER、LC_LOAD_DYLINKER 或 LC_DYLD_ENVIRONMENT

cmdsize: u32

包含路径名字符串

name: u32

加载命令中的变长字符串由 lc_str 联合体表示。字符串存储在加载命令结构体之后, 偏移量相对于加载命令结构体的起始位置。字符串 大小计入加载命令的 cmdsize 字段。 同样,为使 cmdsize 成为 4 字节整数倍 而添加的填充字节必须为零。

std.macho.dysymtab_command

容器

第 244 行

这是第二组符号信息,用于支持 动态链接编辑器的数据结构。

存在此加载命令时,也必须存在 symtab_command 中 包含符号表和字符串表的原始符号信息。 此加载命令存在时,符号表分为三组: 本地符号(静态符号和调试符号),按模块分组; 已定义的外部符号,按模块分组(非库时按名称排序); 未定义的外部符号;未设置 MH_BINDATLOAD 时按名称排序, 设置 MH_BINDATLOAD 时按静态链接器发现它们的顺序排序。 此加载命令保存三组符号各自的偏移量 和数量。

此加载命令还保存以下新增 符号信息表的偏移量和大小: 目录表; 模块表; 引用符号表; 间接符号表。 仅当文件是动态链接的共享库时, 才存在前三个表(目录表、模块表和 引用符号表)。对于只包含一个模块的可执行文件 和目标模块,这三个表所描述的 信息可按以下方式确定: 目录表:已定义的外部符号按名称排序; 模块表:文件只包含一个模块,因此文件内全部内容 均属于该模块; 引用符号表:已定义和未定义的外部符号。

对于动态链接共享库文件,此加载命令还保存所有节 的重定位条目池的偏移量和大小, 并将其分为两组: 外部重定位条目; 本地重定位条目。 对于可执行文件和目标模块,重定位条目仍然 附属于节结构。

字段

cmd: LC = .DYSYMTAB

LC_DYSYMTAB

cmdsize: u32 = @sizeOf(dysymtab_command)

sizeof(struct dysymtab_command)

ilocalsym: u32 = 0

本地符号索引

nlocalsym: u32 = 0

局部符号数量

iextdefsym: u32 = 0

指向外部定义符号的索引

nextdefsym: u32 = 0

外部定义符号的数量

iundefsym: u32 = 0

未定义符号的索引

nundefsym: u32 = 0

未定义符号的数量

tocoff: u32 = 0

目录表在文件中的偏移量

ntoc: u32 = 0

目录表中的条目数

modtaboff: u32 = 0

模块表在文件中的偏移量

nmodtab: u32 = 0

模块表条目的数量

extrefsymoff: u32 = 0

被引用符号表的偏移量

nextrefsyms: u32 = 0

被引用的符号表条目数量

indirectsymoff: u32 = 0

间接符号表的文件偏移量

nindirectsyms: u32 = 0

间接符号表条目数量

extreloff: u32 = 0

外部重定位条目的偏移

nextrel: u32 = 0

外部重定位条目的数量

locreloff: u32 = 0

局部重定位条目的偏移量

nlocrel: u32 = 0

本地重定位条目数

std.macho.encryption_info_command

容器

第 591 行

字段

cmd: LC = .ENCRYPTION_INFO
cmdsize: u32 = @sizeOf(encryption_info_command)
cryptoff: u32
cryptsize: u32
cryptid: u32 = 0

std.macho.encryption_info_command_64

容器

第 600 行

字段

cmd: LC = .ENCRYPTION_INFO_64
cmdsize: u32 = @sizeOf(encryption_info_command_64)
cryptoff: u32
cryptsize: u32
cryptid: u32 = 0
_pad: u32 = 0

std.macho.entry_point_command

容器

第 170 行

entry_point_command 是 thread_command 的替代形式。 主可执行文件使用它指定 main() 的位置(文件偏移量)。 若链接时使用了 -stack_size,则 stacksize 字段 包含主线程所需的栈大小。

字段

cmd: LC = .MAIN

LC_MAIN 仅用于 MH_EXECUTE 文件类型

cmdsize: u32 = @sizeOf(entry_point_command)

sizeof(struct entry_point_command)

entryoff: u64 = 0

main() 的文件(__TEXT)偏移

stacksize: u64 = 0

若非零,则为初始栈大小

std.macho.EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE

常量

第 1738 行

u8

std.macho.EXPORT_SYMBOL_FLAGS_KIND_MASK

常量

第 1735 行

u8

std.macho.EXPORT_SYMBOL_FLAGS_KIND_REGULAR

常量

第 1736 行

u8

std.macho.EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL

常量

第 1737 行

u8

std.macho.EXPORT_SYMBOL_FLAGS_REEXPORT

常量

第 1740 行

u8

std.macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER

常量

第 1741 行

u8

std.macho.EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION

常量

第 1739 行

u8

std.macho.fat_arch

容器

第 52 行

字段

cputype: cpu_type_t
cpusubtype: cpu_subtype_t
offset: u32
size: u32
@"align": u32

std.macho.FAT_CIGAM

常量

第 1287 行

NXSwapLong(FAT_MAGIC)

u32

std.macho.FAT_CIGAM_64

常量

第 1293 行

NXSwapLong(FAT_MAGIC_64)

u32

std.macho.fat_header

容器

第 47 行

字段

magic: u32
nfat_arch: u32

std.macho.FAT_MAGIC

常量

第 1284 行

通用二进制的魔数

u32

std.macho.FAT_MAGIC_64

常量

第 1290 行

64 位 fat 魔数

u32

std.macho.GenericBlob

容器

第 1915 行

字段

magic: u32

魔数

length: u32

blob 的总长度

std.macho.INDIRECT_SYMBOL_ABS

常量

第 1749 行

u32

std.macho.INDIRECT_SYMBOL_LOCAL

常量

第 1748 行

u32

std.macho.LC

容器

第 980 行

字段

NONE = 0x0

没有加载命令 - 无效

SEGMENT = 0x1

待映射的此文件的段

SYMTAB = 0x2

链接编辑的 stab 符号表信息

SYMSEG = 0x3

链接编辑器的 gdb 符号表信息(已过时)

THREAD = 0x4

线程

UNIXTHREAD = 0x5

unix 线程(包含栈)

LOADFVMLIB = 0x6

加载指定的固定 VM 共享库

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

子 umbrella

SUB_CLIENT = 0x14

子客户端

SUB_LIBRARY = 0x15

子库

TWOLEVEL_HINTS = 0x16

两级命名空间查找提示

PREBIND_CKSUM = 0x17

预绑定校验和

LOAD_WEAK_DYLIB = 0x18 | LC_REQ_DYLD

加载允许缺失的动态链接共享库 (所有符号均以弱导入方式导入)。

SEGMENT_64 = 0x19

待映射的此文件的 64 位段

ROUTINES_64 = 0x1a

64 位映像例程

UUID = 0x1b

该 UUID

RPATH = 0x1c | LC_REQ_DYLD

runpath 添加项

CODE_SIGNATURE = 0x1d

代码签名的位置

SEGMENT_SPLIT_INFO = 0x1e

用于拆分段的信息位置

REEXPORT_DYLIB = 0x1f | LC_REQ_DYLD

加载并重新导出 dylib

LAZY_LOAD_DYLIB = 0x20

首次使用时延迟加载 dylib

ENCRYPTION_INFO = 0x21

加密段信息

DYLD_INFO = 0x22

压缩的 dyld 信息

DYLD_INFO_ONLY = 0x22 | LC_REQ_DYLD

仅含压缩的 dyld 信息

LOAD_UPWARD_DYLIB = 0x23 | LC_REQ_DYLD

加载向上依赖的 dylib

VERSION_MIN_MACOSX = 0x24

构建 MacOSX 所需的最低操作系统版本

VERSION_MIN_IPHONEOS = 0x25

构建 iPhoneOS 所需的最低操作系统版本

FUNCTION_STARTS = 0x26

函数起始地址的压缩表

DYLD_ENVIRONMENT = 0x27

供 dyld 当作环境变量处理的字符串

MAIN = 0x28 | LC_REQ_DYLD

LC_UNIXTHREAD 的替代项

DATA_IN_CODE = 0x29

__text 中的非指令表

SOURCE_VERSION = 0x2A

用于构建二进制文件的源版本

DYLIB_CODE_SIGN_DRS = 0x2B

从链接的 dylib 复制的代码签名 DR

ENCRYPTION_INFO_64 = 0x2C

64 位加密段信息

LINKER_OPTION = 0x2D

MH_OBJECT 文件中的链接器选项

LINKER_OPTIMIZATION_HINT = 0x2E

MH_OBJECT 文件中的优化提示

VERSION_MIN_TVOS = 0x2F

构建 AppleTV 所需的最低操作系统版本

VERSION_MIN_WATCHOS = 0x30

构建所针对的 Watch 最低操作系统版本

NOTE = 0x31

Mach-O 文件中包含的任意数据

BUILD_VERSION = 0x32

针对平台最低操作系统版本构建

DYLD_EXPORTS_TRIE = 0x33 | LC_REQ_DYLD

与 linkedit_data_command 一起使用,载荷为 trie

DYLD_CHAINED_FIXUPS = 0x34 | LC_REQ_DYLD

与 linkedit_data_command 配合使用

_

std.macho.LC_REQ_DYLD

常量

第 978 行

从 MacOS X 10.1 之后开始,若新增加载命令必须被动态链接器理解,映像才能正确执行,则会将 LC_REQ_DYLD 位按位或入该加载命令常量。 若动态链接器遇到不认识的此类加载命令,会报告“unknown load command required for execution”错误,并拒绝使用该映像。 其他未设置此位且不被理解的加载命令会被直接忽略。

std.macho.linkedit_data_command

容器

第 384 行

linkedit_data_command 包含 __LINKEDIT 段中 某个数据块的偏移量和大小。

字段

cmd: LC

取值为 LC_CODE_SIGNATURE、LC_SEGMENT_SPLIT_INFO、LC_FUNCTION_STARTS、LC_DATA_IN_CODE、LC_DYLIB_CODE_SIGN_DRS 或 LC_LINKER_OPTIMIZATION_HINT。

cmdsize: u32 = @sizeOf(linkedit_data_command)

sizeof(struct linkedit_data_command)

dataoff: u32 = 0

数据在 __LINKEDIT 段中的文件偏移量

datasize: u32 = 0

__LINKEDIT 段中数据的文件大小

std.macho.load_command

容器

第 60 行

字段

cmd: LC
cmdsize: u32

std.macho.LoadCommandIterator

容器

第 1935 行

字段

next_index: usize
ncmds: usize
r: std.Io.Reader

std.macho.LoadCommandIterator.init

函数

第 1997 行

pub fn init(hdr: *const mach_header_64, cmds_buf_overlong: []const u8) error{InvalidMachO}!LoadCommandIterator

参数

hdr: *const mach_header_64
cmds_buf_overlong: []const u8

错误

InvalidMachO

std.macho.LoadCommandIterator.LoadCommand

容器

第 1940 行

字段

hdr: load_command
data: []const u8

std.macho.LoadCommandIterator.LoadCommand.cast

函数

第 1944 行

pub fn cast(lc: LoadCommand, comptime Cmd: type) ?Cmd

参数

lc: LoadCommand
Cmd: type

std.macho.LoadCommandIterator.LoadCommand.getBuildVersionTools

函数

第 1974 行

断言 LoadCommand 的类型为 build_version_command。 若本机字节序不是 .little,则调用者必须交换 build_tool_version 值的字节序。

pub fn getBuildVersionTools(lc: LoadCommand) []align(1) const build_tool_version

参数

std.macho.LoadCommandIterator.LoadCommand.getDylibPathName

函数

第 1961 行

断言 LoadCommand 的类型为 dylib_command。

pub fn getDylibPathName(lc: LoadCommand) []const u8

参数

std.macho.LoadCommandIterator.LoadCommand.getRpathPathName

函数

第 1967 行

断言 LoadCommand 的类型为 rpath_command。

pub fn getRpathPathName(lc: LoadCommand) []const u8

参数

std.macho.LoadCommandIterator.LoadCommand.getSections

函数

第 1954 行

断言 LoadCommand 的类型为 segment_command_64。 若本机字节序不是 .little,调用者必须交换 section_64 值的字节序。

pub fn getSections(lc: LoadCommand) []align(1) const section_64

参数

std.macho.LoadCommandIterator.next

函数

第 1981 行

pub fn next(it: *LoadCommandIterator) error{InvalidMachO}!?LoadCommand

参数

错误

InvalidMachO

std.macho.mach_header

容器

第 26 行

字段

magic: u32
cputype: cpu_type_t
cpusubtype: cpu_subtype_t
filetype: u32
ncmds: u32
sizeofcmds: u32
flags: u32

std.macho.mach_header_64

容器

第 36 行

字段

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

std.macho.mem

别名

第 4 行

别名目标 std.mem

std.macho.meta

别名

第 5 行

别名目标 std.meta

std.macho.MH_ALLMODSBOUND

常量

第 1231 行

表示此二进制文件绑定到依赖库中所有采用两级命名空间的模块。仅在同时设置 MH_PREBINDABLE 和 MH_TWOLEVEL 时使用。

std.macho.MH_ALLOW_STACK_EXECUTION

常量

第 1246 行

设置此位时,任务中的所有栈都会获得执行权限。仅用于 MH_EXECUTE 文件类型。

std.macho.MH_APP_EXTENSION_SAFE

常量

第 1270 行

代码已链接为供应用扩展使用。

std.macho.MH_BINDATLOAD

常量

第 1204 行

目标文件的未定义引用由动态链接器在加载时绑定。

std.macho.MH_BINDS_TO_WEAK

常量

第 1243 行

最终链接映像使用弱符号

std.macho.MH_BUNDLE

常量

第 1181 行

动态绑定的捆绑文件

std.macho.MH_CANONICAL

常量

第 1237 行

二进制文件已通过取消预绑定操作进行规范化

std.macho.MH_CIGAM

常量

第 1151 行

NXSwapInt(MH_MAGIC)

u32

std.macho.MH_CIGAM_64

常量

第 1157 行

NXSwapInt(MH_MAGIC_64)

u32

std.macho.MH_CORE

常量

第 1169 行

核心转储文件

std.macho.MH_DEAD_STRIPPABLE_DYLIB

常量

第 1261 行

仅用于动态库。链接一个设置了此位的动态库时,若未引用其中任何符号,静态链接器会自动省略指向该动态库的 LC_LOAD_DYLIB 加载命令。

std.macho.MH_DSYM

常量

第 1187 行

仅含调试节的配套文件

std.macho.MH_DYLDLINK

常量

第 1201 行

此对象文件是动态链接器的输入,不能再由静态链接器编辑

std.macho.MH_DYLIB

常量

第 1175 行

动态绑定的共享库

std.macho.MH_DYLIB_IN_CACHE

常量

第 1279 行

仅用于动态库。设置此位时,动态库属于 dyld 共享缓存,而非独立存放于文件系统。

std.macho.MH_DYLIB_STUB

常量

第 1184 行

仅用于静态链接的共享库桩,不含节内容。

std.macho.MH_DYLINKER

常量

第 1178 行

动态链接编辑器

std.macho.MH_EXECUTE

常量

第 1163 行

按需调页的可执行文件

std.macho.MH_FORCE_FLAT

常量

第 1219 行

此可执行文件强制所有映像使用平坦命名空间绑定。

std.macho.MH_FVMLIB

常量

第 1166 行

固定虚拟内存共享库文件

std.macho.MH_HAS_TLV_DESCRIPTORS

常量

第 1264 行

包含 S_THREAD_LOCAL_VARIABLES 类型的节

std.macho.MH_INCRLINK

常量

第 1198 行

此目标文件是针对基础文件进行增量链接的输出,无法再次进行链接编辑。

std.macho.MH_KEXT_BUNDLE

常量

第 1190 行

x86_64 内核扩展

std.macho.MH_LAZY_INIT

常量

第 1213 行

共享库初始化例程通过捕获对其可写段的内存故障来延迟执行(已过时)

std.macho.MH_MAGIC

常量

第 1148 行

Mach 魔数

u32

std.macho.MH_MAGIC_64

常量

第 1154 行

64 位 mach 魔数

u32

std.macho.MH_NLIST_OUTOFSYNC_WITH_DYLDINFO

常量

第 1273 行

nlist 符号表列出的外部符号未涵盖 dyld 信息中列出的全部符号。

std.macho.MH_NO_HEAP_EXECUTION

常量

第 1267 行

设置此位时,即使平台本身没有要求,例如 x86,操作系统也会使用不可执行堆运行主可执行文件。仅用于 MH_EXECUTE 文件类型。

std.macho.MH_NO_REEXPORTED_DYLIBS

常量

第 1255 行

在动态库上设置此位后,静态链接器无需检查其依赖的动态库是否被重新导出。

std.macho.MH_NOFIXPREBINDING

常量

第 1225 行

禁止 dyld 将此可执行文件通知给预绑定代理

std.macho.MH_NOMULTIDEFS

常量

第 1222 行

此伞状映像保证其子映像中不存在符号多重定义,因此始终可使用两级命名空间提示。

std.macho.MH_NOUNDEFS

常量

第 1195 行

目标文件没有未定义引用

std.macho.MH_OBJECT

常量

第 1160 行

可重定位目标文件

std.macho.MH_PIE

常量

第 1258 行

设置此位时,操作系统会将主可执行文件加载到随机地址。仅用于 MH_EXECUTE 文件类型。

std.macho.MH_PREBINDABLE

常量

第 1228 行

此二进制文件未预绑定,但可重新进行预绑定。仅在未设置 MH_PREBOUND 时使用。

std.macho.MH_PREBOUND

常量

第 1207 行

此文件的动态未定义引用已预绑定。

std.macho.MH_PRELOAD

常量

第 1172 行

预加载的可执行文件

std.macho.MH_ROOT_SAFE

常量

第 1249 行

设置此位后,二进制文件声明其可安全用于 uid 为零的进程。

std.macho.MH_SETUID_SAFE

常量

第 1252 行

设置此位时,二进制文件声明其可安全用于 issetugid() 为真的进程。

std.macho.MH_SIM_SUPPORT

常量

第 1276 行

允许 LC_MIN_VERSION_MACOS,以及平台为 macOS、iOSMac、iOSSimulator、tvOSSimulator 或 watchOSSimulator 的 LC_BUILD_VERSION 加载命令。

std.macho.MH_SPLIT_SEGS

常量

第 1210 行

此文件的只读段与读写段已分离。

std.macho.MH_SUBSECTIONS_VIA_SYMBOLS

常量

第 1234 行

可安全地通过符号将节划分为子节,以便剔除死代码。

std.macho.MH_TWOLEVEL

常量

第 1216 行

映像使用两级名称空间绑定

std.macho.MH_WEAK_DEFINES

常量

第 1240 行

最终链接映像包含外部弱符号

std.macho.N_ABS

常量

第 1355 行

符号是绝对符号

std.macho.N_AST

常量

第 1388 行

AST 文件路径:name,,NO_SECT,0,0

std.macho.N_BCOMM

常量

第 1448 行

公共符号开始:name,,NO_SECT,0,0

std.macho.N_BINCL

常量

第 1415 行

包含文件开始:name,,NO_SECT,0,sum

std.macho.N_BNSYM

常量

第 1385 行

nsect 符号开始:0,,n_sect,0,address

std.macho.N_DESC_DISCARDED

常量

第 1716 行

供动态链接器在运行时使用。不要设置此位。

u16

std.macho.N_ECOML

常量

第 1454 行

公共块结束(本地名称):0,,n_sect,0,address

std.macho.N_ECOMM

常量

第 1451 行

公共块结束:name,,n_sect,0,0

std.macho.N_EINCL

常量

第 1433 行

包含文件结束:name,,NO_SECT,0,0

std.macho.N_ENSYM

常量

第 1400 行

end nsect sym: 0,,n_sect,0,address

std.macho.N_ENTRY

常量

第 1436 行

备用条目:name,,n_sect,linenumber,address

std.macho.N_EXCL

常量

第 1442 行

已删除的包含文件:name,,NO_SECT,0,sum

std.macho.N_EXT

常量

第 1349 行

外部符号位,针对外部符号置位

std.macho.N_FNAME

常量

第 1373 行

过程名(f77 变通处理):name,,NO_SECT,0,0

std.macho.N_FUN

常量

第 1376 行

过程:name,,n_sect,linenumber,address

std.macho.N_GSYM

常量

第 1370 行

全局符号:name,,NO_SECT,type,0

std.macho.N_INDR

常量

第 1367 行

符号被定义为与另一个符号相同;n_value 字段 是字符串表索引,指定 另一个符号的名称。

std.macho.N_LBRAC

常量

第 1439 行

左括号:0,,NO_SECT,nesting level,address

std.macho.N_LCSYM

常量

第 1382 行

.lcomm 符号:name,,n_sect,type,address

std.macho.N_LENG

常量

第 1457 行

包含长度信息的第二个 stab 条目

std.macho.N_LSYM

常量

第 1412 行

局部符号:name,,NO_SECT,type,offset

std.macho.N_NO_DEAD_STRIP

常量

第 1713 行

n_desc 字段的 N_NO_DEAD_STRIP 位仅出现在 可重定位 .o 文件中,即 MH_OBJECT 文件类型;它用于通知 静态链接编辑器,绝不可将此符号作为死代码剔除。

u16

std.macho.N_OLEVEL

常量

第 1427 行

编译器 -O 级别:name,,NO_SECT,0,0

std.macho.N_OPT

常量

第 1391 行

随 gcc2_compiled 一同发出,并存在于 gcc 源码中

std.macho.N_OSO

常量

第 1409 行

目标文件名:name,,0,0,st_mtime

std.macho.N_PARAMS

常量

第 1421 行

编译器参数:name,,NO_SECT,0,0

std.macho.N_PBUD

常量

第 1362 行

符号未定义,映像正在使用该符号的 预绑定值

std.macho.N_PEXT

常量

第 1343 行

私有外部符号位

std.macho.N_PSYM

常量

第 1430 行

参数:name,,NO_SECT,type,offset

std.macho.N_RBRAC

常量

第 1445 行

右括号:0,,NO_SECT,nesting level,address

std.macho.N_RSYM

常量

第 1394 行

寄存器符号:name,,NO_SECT,type,register

std.macho.N_SECT

常量

第 1358 行

符号定义于 n_sect 给出的节编号中

std.macho.N_SLINE

常量

第 1397 行

源代码行:0,,n_sect,linenumber,address

std.macho.N_SO

常量

第 1406 行

源文件名:name,,n_sect,0,address

std.macho.N_SOL

常量

第 1418 行

#include 文件名:name,,n_sect,0,address

std.macho.N_SSYM

常量

第 1403 行

结构体元素:name,,NO_SECT,type,struct_offset

std.macho.N_STAB

常量

第 1340 行

若设置了这些位中的任意一位,则为符号调试条目。

std.macho.N_STSYM

常量

第 1379 行

静态符号:name,,n_sect,type,address

std.macho.N_SYMBOL_RESOLVER

常量

第 1732 行

n_desc 字段中的 N_SYMBOL_RESOLVER 位表示该 函数实际上是一个解析器函数,应当调用它来获取要使用的 真实函数地址。 此位仅适用于 .o 文件(MH_OBJECT 文件类型)。

u16

std.macho.N_TYPE

常量

第 1346 行

类型位掩码

std.macho.N_UNDF

常量

第 1352 行

符号未定义

std.macho.N_VERSION

常量

第 1424 行

编译器版本:name,,NO_SECT,0,0

std.macho.N_WEAK_DEF

常量

第 1726 行

表示此符号是弱定义。如果静态或动态链接器发现此符号的 另一个(非弱)定义,则忽略弱定义。只有合并节(第 23 页)中的符号才能标记为弱定义。

u16

std.macho.N_WEAK_REF

常量

第 1721 行

表示此符号是弱引用。如果动态链接器找不到该符号的 定义,则将其地址设为 0。提供相应弱链接标志时, 静态链接器会设置此符号。

u16

std.macho.nlist

容器

第 863 行

字段

n_strx: u32
n_type: u8
n_sect: u8
n_desc: i16
n_value: u32

std.macho.nlist_64

容器

第 871 行

字段

n_strx: u32
n_type: packed union(u8) {
    bits: packed struct(u8) {
        ext: bool,
        type: enum(u3) {
            undf = 0,
            abs = 1,
            sect = 7,
            pbud = 6,
            indr = 5,
            _,
        },
        pext: bool,
        /// 任何非零值均表示这是 stab,因此应使用 `stab` 字段。
        is_stab: u3,
    },
    stab: enum(u8) {
        gsym = N_GSYM,
        fname = N_FNAME,
        fun = N_FUN,
        stsym = N_STSYM,
        lcsym = N_LCSYM,
        bnsym = N_BNSYM,
        ast = N_AST,
        opt = N_OPT,
        rsym = N_RSYM,
        sline = N_SLINE,
        ensym = N_ENSYM,
        ssym = N_SSYM,
        so = N_SO,
        oso = N_OSO,
        lsym = N_LSYM,
        bincl = N_BINCL,
        sol = N_SOL,
        params = N_PARAMS,
        version = N_VERSION,
        olevel = N_OLEVEL,
        psym = N_PSYM,
        eincl = N_EINCL,
        entry = N_ENTRY,
        lbrac = N_LBRAC,
        excl = N_EXCL,
        rbrac = N_RBRAC,
        bcomm = N_BCOMM,
        ecomm = N_ECOMM,
        ecoml = N_ECOML,
        leng = N_LENG,
        _,
    },
}
n_sect: u8
n_desc: packed struct(u16) {
    _pad0: u3 = 0,
    arm_thumb_def: bool,
    referenced_dynamically: bool,
    /// 此位的含义取决于上下文。
    /// 另见 `N_DESC_DISCARDED` 和 `N_NO_DEAD_STRIP`。
    discarded_or_no_dead_strip: bool,
    weak_ref: bool,
    /// 此位的含义取决于上下文。
    /// 参见 `N_WEAK_DEF` 和 `N_REF_TO_WEAK`。
    weak_def_or_ref_to_weak: bool,
    symbol_resolver: bool,
    alt_entry: bool,
    _pad2: u6 = 0,
}
n_value: u64

std.macho.nlist_64.tentative

函数

第 940 行

pub fn tentative(sym: nlist_64) bool

参数

sym: nlist_64

std.macho.parseName

函数

第 858 行

fn parseName(name: *const [16]u8) []const u8

参数

name: *const [16]u8

std.macho.PLATFORM

容器

第 139 行

字段

UNKNOWN = 0
ANY = 0xffffffff
MACOS = 1
IOS = 2
TVOS = 3
WATCHOS = 4
BRIDGEOS = 5
MACCATALYST = 6
IOSSIMULATOR = 7
TVOSSIMULATOR = 8
WATCHOSSIMULATOR = 9
DRIVERKIT = 10
VISIONOS = 11
VISIONOSSIMULATOR = 12
_

std.macho.PROT

命名空间

第 700 行

std.macho.PROT.COPY

常量

第 714 行

调用者无法取得映射条目的写权限时,可以使用以下标志。 该条目将被标记为“需要复制”,从而通过写时复制实际复制对象,并在关联条目的最大保护权限中增加写权限。

vm_prot_t

std.macho.PROT.EXEC

常量

第 708 行

[MC2] 页可执行

vm_prot_t

std.macho.PROT.NONE

常量

第 702 行

[MC2] 无权限

vm_prot_t

std.macho.PROT.READ

常量

第 704 行

[MC2] 页面可读取

vm_prot_t

std.macho.PROT.WRITE

常量

第 706 行

[MC2] 页面可以写入

vm_prot_t

std.macho.REBASE_IMMEDIATE_MASK

常量

第 1579 行

u8

std.macho.REBASE_OPCODE_ADD_ADDR_IMM_SCALED

常量

第 1584 行

u8

std.macho.REBASE_OPCODE_ADD_ADDR_ULEB

常量

第 1583 行

u8

std.macho.REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB

常量

第 1587 行

u8

std.macho.REBASE_OPCODE_DO_REBASE_IMM_TIMES

常量

第 1585 行

u8

std.macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES

常量

第 1586 行

u8

std.macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB

常量

第 1588 行

u8

std.macho.REBASE_OPCODE_DONE

常量

第 1580 行

u8

std.macho.REBASE_OPCODE_MASK

常量

第 1578 行

u8

std.macho.REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB

常量

第 1582 行

u8

std.macho.REBASE_OPCODE_SET_TYPE_IMM

常量

第 1581 行

u8

std.macho.REBASE_TYPE_POINTER

常量

第 1574 行

u8

std.macho.REBASE_TYPE_TEXT_ABSOLUTE32

常量

第 1575 行

u8

std.macho.REBASE_TYPE_TEXT_PCREL32

常量

第 1576 行

u8

std.macho.REFERENCE_FLAG_DEFINED

常量

第 1692 行

此符号在此模块中定义。

u16

std.macho.REFERENCE_FLAG_PRIVATE_DEFINED

常量

第 1695 行

此符号定义于本模块,仅对此共享库内的模块可见。

u16

std.macho.REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY

常量

第 1703 行

此符号定义于本文件的另一模块中,是延迟(函数)符号,且仅对该共享库中的模块可见。

u16

std.macho.REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY

常量

第 1699 行

此符号定义于本文件的另一个模块,是非延迟的(数据)符号,且仅 对此共享库内的模块可见。

u16

std.macho.REFERENCE_FLAG_UNDEFINED_LAZY

常量

第 1689 行

此符号引用外部延迟符号,即函数调用。

u16

std.macho.REFERENCE_FLAG_UNDEFINED_NON_LAZY

常量

第 1686 行

此符号是对外部非延迟(数据)符号的引用。

u16

std.macho.REFERENCED_DYNAMICALLY

常量

第 1708 行

对于由动态加载器 API,如 dlsym 和 NSLookupSymbolInImage 引用,而非 由普通未定义符号引用所引用的已定义符号,必须设置此位。strip 工具用此位 避免移除必须存在的符号:设置此位的符号不会被 strip 剥离。

u16

std.macho.reloc_type_arm64

容器

第 1650 行

字段

ARM64_RELOC_UNSIGNED = 0

用于指针。

ARM64_RELOC_SUBTRACTOR

后面必须跟随 ARM64_RELOC_UNSIGNED。

ARM64_RELOC_BRANCH26

具有 26 位位移的 B/BL 指令。

ARM64_RELOC_PAGE21

到目标所在页的 PC 相对距离。

ARM64_RELOC_PAGEOFF12

页内偏移量,按 r_length 缩放。

ARM64_RELOC_GOT_LOAD_PAGE21

到 GOT 槽所在页的 PC 相对距离。

ARM64_RELOC_GOT_LOAD_PAGEOFF12

GOT 槽位的页内偏移量,按 r_length 缩放。

ARM64_RELOC_POINTER_TO_GOT

指向 GOT 槽的指针。

ARM64_RELOC_TLVP_LOAD_PAGE21

到 TLVP 槽所在页的 PC 相对距离。

ARM64_RELOC_TLVP_LOAD_PAGEOFF12

TLVP 槽在页内的偏移,以 r_length 为缩放因子。

ARM64_RELOC_ADDEND

后面必须紧跟 PAGE21 或 PAGEOFF12。

std.macho.reloc_type_x86_64

容器

第 1618 行

字段

X86_64_RELOC_UNSIGNED = 0

用于绝对地址

X86_64_RELOC_SIGNED

用于有符号 32 位位移

X86_64_RELOC_BRANCH

带 32 位位移的 CALL/JMP 指令。

X86_64_RELOC_GOT_LOAD

用 MOVQ 加载 GOT 条目

X86_64_RELOC_GOT

其他 GOT 引用

X86_64_RELOC_SUBTRACTOR

后面必须紧跟 X86_64_RELOC_UNSIGNED

X86_64_RELOC_SIGNED_1

用于附加数为 -1 的 32 位有符号位移

X86_64_RELOC_SIGNED_2

用于带 -2 加数的有符号 32 位位移

X86_64_RELOC_SIGNED_4

用于具有 -4 加数的有符号 32 位位移。

X86_64_RELOC_TLV

用于线程局部变量

std.macho.relocation_info

容器

第 951 行

Mach-O 文件重定位条目的格式,修改自 4.3BSD 格式。相较于原始格式,修改内容是改变 “局部”重定位条目,即 r_extern == 0 时的 r_symbolnum 字段值。 此更改用于支持任意数量节中的符号, 而不限于 4.3BSD 文件中的三个节,即 text、data 和 bss。 此外,末尾 4 位增加了 r_type 标签。

字段

r_address: i32

待重定位内容在节中的偏移

r_symbolnum: u24

r_extern == 1 时为符号索引,r_extern == 0 时为节序号。

r_pcrel: u1

之前已使用相对于程序计数器的方式重定位

r_length: u2

0=字节,1=字,2=长字,3=四字

r_extern: u1

不包含被引用符号的值

r_type: u4

若非 0,则为机器专用重定位类型

std.macho.rpath_command

容器

第 580 行

rpath_command 包含一个路径,运行时应将其添加到当前运行路径,以查找以 @rpath 为前缀的动态库。

字段

cmd: LC = .RPATH

LC_RPATH

cmdsize: u32

包含字符串

path: u32

要添加到运行路径的路径

std.macho.S_16BYTE_LITERALS

常量

第 1495 行

仅含 16 字节字面量的节

std.macho.S_4BYTE_LITERALS

常量

第 1331 行

仅含 4 字节字面量的节

std.macho.S_8BYTE_LITERALS

常量

第 1334 行

仅包含八字节字面量的节

std.macho.S_ATTR_DEBUG

常量

第 1512 行

调试节

std.macho.S_ATTR_EXT_RELOC

常量

第 1538 行

此节含有外部重定位条目

std.macho.S_ATTR_LIVE_SUPPORT

常量

第 1529 行

引用存活块的块也存活

std.macho.S_ATTR_LOC_RELOC

常量

第 1541 行

此节包含局部重定位条目

std.macho.S_ATTR_NO_DEAD_STRIP

常量

第 1526 行

不进行无用代码剥离

std.macho.S_ATTR_NO_TOC

常量

第 1519 行

节包含不应出现在 ranlib 目录中的 合并符号

std.macho.S_ATTR_PURE_INSTRUCTIONS

常量

第 1515 行

此节仅包含实际机器指令

std.macho.S_ATTR_SELF_MODIFYING_CODE

常量

第 1532 行

与由 dyld 写入的 x86 代码桩一起使用

std.macho.S_ATTR_SOME_INSTRUCTIONS

常量

第 1535 行

节包含一些机器指令

std.macho.S_ATTR_STRIP_STATIC_SYMS

常量

第 1523 行

在带有 MH_DYLDLINK 标志的文件中,可以剥离此节的静态符号

std.macho.S_COALESCED

常量

第 1486 行

此节包含需要合并的符号

std.macho.S_CSTRING_LITERALS

常量

第 1328 行

仅包含 C 字符串字面量的节

std.macho.S_DTRACE_DOF

常量

第 1498 行

此节包含 DTrace 对象格式数据

std.macho.S_GB_ZEROFILL

常量

第 1489 行

按需填零的节(可大于 4 GB)

std.macho.S_INIT_FUNC_OFFSETS

常量

第 1559 行

指向初始化器的 32 位偏移

std.macho.S_INTERPOSING

常量

第 1492 行

仅包含用于符号替换的函数指针对的节

std.macho.S_LAZY_DYLIB_SYMBOL_POINTERS

常量

第 1501 行

仅包含指向延迟加载动态库的延迟符号指针的节

std.macho.S_LAZY_SYMBOL_POINTERS

常量

第 1474 行

仅包含惰性符号指针的节

std.macho.S_LITERAL_POINTERS

常量

第 1337 行

仅包含指向下列对象的指针的节

std.macho.S_MOD_INIT_FUNC_POINTERS

常量

第 1480 行

仅包含初始化函数指针的节。

std.macho.S_MOD_TERM_FUNC_POINTERS

常量

第 1483 行

仅包含终止函数指针的节

std.macho.S_NON_LAZY_SYMBOL_POINTERS

常量

第 1471 行

仅包含非惰性符号指针的节

std.macho.S_REGULAR

常量

第 1322 行

常规节

std.macho.S_SYMBOL_STUBS

常量

第 1477 行

仅包含符号桩的节,桩的字节大小位于 reserved2 字段

std.macho.S_THREAD_LOCAL_INIT_FUNCTION_POINTERS

常量

第 1556 行

为初始化 TLV 值而调用的函数

std.macho.S_THREAD_LOCAL_REGULAR

常量

第 1544 行

TLV 的初始值模板

std.macho.S_THREAD_LOCAL_VARIABLE_POINTERS

常量

第 1553 行

指向 TLV 描述符的指针

std.macho.S_THREAD_LOCAL_VARIABLES

常量

第 1550 行

TLV 描述符

std.macho.S_THREAD_LOCAL_ZEROFILL

常量

第 1547 行

TLV 的初始值模板

std.macho.S_ZEROFILL

常量

第 1325 行

按需零填充节

std.macho.section

容器

第 742 行

段由零个或多个节组成。链接编辑器生成非 MH_OBJECT 文件时,每个段都含有适当的节,并填充到指定的段对齐边界。MH_EXECUTE 和 MH_FVMLIB 格式文件的第一个段,在第一个节之前包含目标文件的 mach_header 与加载命令。所有格式中,零填充节始终位于所在段的末尾,因此段中已清零的填充区域可以映射到零填充节所在的内存位置。以吉字节计的零填充节,即节类型为 S_GB_ZEROFILL 的节,只能与同类型节处于同一段中。这些段会放在所有其他段之后。

为保持紧凑,MH_OBJECT 格式将所有节放在一个段中。不填充到指定段边界,mach_header 和加载命令也不属于该段。

进入同一段 segname、且节名称 sectname 相同的节,会由链接编辑器合并。结果节按所有被合并节中的最大对齐要求对齐,该值成为新节的对齐要求。各原始节在合并后的节内部仍按各自原有的对齐要求对齐。为满足指定对齐要求而添加的填充字节均置零。

Mach 目标文件中,由节结构的 reloff 与 nreloc 字段引用的重定位条目格式,在头文件 <reloc.h> 中描述。

字段

sectname: [16]u8

此节的名称

segname: [16]u8

此节所属的段

addr: u32

此节的内存地址

size: u32

此节的字节大小

offset: u32

此节在文件中的偏移量

@"align": u32

节对齐(2 的幂)

reloff: u32

重定位条目的文件偏移

nreloc: u32

重定位条目数量

flags: u32

标志(节类型与属性)

reserved1: u32

预留(用作偏移或索引)

reserved2: u32

保留(用于计数或 sizeof)

std.macho.section_64

容器

第 777 行

字段

sectname: [16]u8

此节的名称

segname: [16]u8

此节所属的段

addr: u64 = 0

此节的内存地址

size: u64 = 0

此节的字节大小

offset: u32 = 0

此节在文件中的偏移量

@"align": u32 = 0

节对齐(2 的幂)

reloff: u32 = 0

重定位条目的文件偏移

nreloc: u32 = 0

重定位条目数量

flags: u32 = S_REGULAR

标志(节类型与属性)

reserved1: u32 = 0

预留(用作偏移或索引)

reserved2: u32 = 0

保留(用于计数或 sizeof)

reserved3: u32 = 0

保留

std.macho.section_64.@"type"

函数

第 822 行

pub fn @"type"(sect: section_64) u8

参数

sect: section_64

std.macho.section_64.attrs

函数

第 826 行

pub fn attrs(sect: section_64) u32

参数

sect: section_64

std.macho.section_64.isCode

函数

第 830 行

pub fn isCode(sect: section_64) bool

参数

sect: section_64

std.macho.section_64.isDebug

函数

第 845 行

pub fn isDebug(sect: section_64) bool

参数

sect: section_64

std.macho.section_64.isDontDeadStrip

函数

第 849 行

pub fn isDontDeadStrip(sect: section_64) bool

参数

sect: section_64

std.macho.section_64.isDontDeadStripIfReferencesLive

函数

第 853 行

pub fn isDontDeadStripIfReferencesLive(sect: section_64) bool

参数

sect: section_64

std.macho.section_64.isSymbolStubs

函数

第 840 行

pub fn isSymbolStubs(sect: section_64) bool

参数

sect: section_64

std.macho.section_64.isZerofill

函数

第 835 行

pub fn isZerofill(sect: section_64) bool

参数

sect: section_64

std.macho.section_64.sectName

函数

第 814 行

pub fn sectName(sect: *const section_64) []const u8

参数

sect: *const section_64

std.macho.section_64.segName

函数

第 818 行

pub fn segName(sect: *const section_64) []const u8

参数

sect: *const section_64

std.macho.SECTION_ATTRIBUTES

常量

第 1319 行

24 个节属性

std.macho.SECTION_TYPE

常量

第 1316 行

节结构的 flags 字段分为节类型和节属性两部分。 节类型互斥,即只能有一种类型; 节属性则不互斥,即可具有多个属性。

共有 256 种节类型。

std.macho.segment_command

容器

第 620 行

段加载命令表示应将此文件的一部分 映射到任务的地址空间。该段在内存中的大小 vmsize 可以等于或大于从文件映射的大小 filesize。文件从 fileoff 开始映射至 内存中该段的起始地址 vmaddr。该段剩余的内存 若存在,则按需分配并填零。段的最大虚拟 内存保护和初始虚拟内存保护分别由 maxprot 和 initprot 字段指定。如果段包含节, 则节结构体紧随段命令之后,其大小 计入 cmdsize。

字段

cmd: LC = .SEGMENT

LC_SEGMENT

cmdsize: u32

包含节结构体的 sizeof

segname: [16]u8

段名称

vmaddr: u32

此段的内存地址

vmsize: u32

此段的内存大小

fileoff: u32

此段在文件中的偏移量

filesize: u32

从文件映射的大小

maxprot: vm_prot_t

最大虚拟内存保护权限

initprot: vm_prot_t

初始虚拟内存保护

nsects: u32

段内节的数量

flags: u32

std.macho.segment_command_64

容器

第 657 行

64 位段加载命令表示将此文件的一部分 映射到 64 位任务的地址空间。若此 64 位段包含节, 则 section_64 结构紧随 64 位段命令之后, 其大小计入 cmdsize。

字段

cmd: LC = .SEGMENT_64

LC_SEGMENT_64

cmdsize: u32

包括 section_64 结构体的 sizeof

segname: [16]u8

段名称

vmaddr: u64 = 0

此段的内存地址

vmsize: u64 = 0

此段的内存大小

fileoff: u64 = 0

此段在文件中的偏移量

filesize: u64 = 0

从文件映射的大小

maxprot: vm_prot_t = .{}

最大虚拟内存保护权限

initprot: vm_prot_t = .{}

初始虚拟内存保护

nsects: u32 = 0

段内节的数量

flags: u32 = 0

std.macho.segment_command_64.isWriteable

函数

第 695 行

pub fn isWriteable(seg: segment_command_64) bool

参数

std.macho.segment_command_64.segName

函数

第 691 行

pub fn segName(seg: *const segment_command_64) []const u8

参数

seg: *const segment_command_64

std.macho.SG_FVMLIB

常量

第 1301 行

此段是固定 VM 库分配的虚拟内存,供 链接编辑器检查重叠。

std.macho.SG_HIGHVM

常量

第 1298 行

段标志。 此段的文件内容对应虚拟内存空间高地址部分, 低地址部分填零,用于核心文件中的栈。

std.macho.SG_NORELOC

常量

第 1304 行

此段中没有发生重定位的内容,也没有任何内容被重定位到此段,因此可安全替换而无需重定位。

std.macho.SG_PROTECTED_VERSION_1

常量

第 1307 行

此段受保护。若段从文件偏移 0 开始, 则其第一页不受保护。此段的所有其他页均受保护。

std.macho.SG_READ_ONLY

常量

第 1309 行

此段在完成修正后设为只读

std.macho.source_version_command

容器

第 96 行

source_version_command 是可选加载命令, 包含构建该二进制所用源码的版本。

字段

cmd: LC = .SOURCE_VERSION

LC_SOURCE_VERSION

cmdsize: u32 = @sizeOf(source_version_command)

sizeof(source_version_command)

version: u64

将 A.B.C.D.E 打包为 a24.b10.c10.d10.e10

std.macho.std

别名

第 1 行

别名目标 std

std.macho.SuperBlob

容器

第 1904 行

此结构后跟 GenericBlobs, 其顺序不固定,由 index 中的偏移量指示。

字段

magic: u32

魔数

length: u32

SuperBlob 的总长度

count: u32

此结构体之后的 BlobIndex 索引条目数量

std.macho.symtab_command

容器

第 187 行

symtab_command 包含 link-edit 4.3BSD "stab" 风格 符号表信息的偏移和大小,其格式由头文件 <nlist.h> 和 <stab.h> 描述。

字段

cmd: LC = .SYMTAB

LC_SYMTAB

cmdsize: u32 = @sizeOf(symtab_command)

sizeof(struct symtab_command)

symoff: u32 = 0

符号表偏移量

nsyms: u32 = 0

符号表条目数量

stroff: u32 = 0

字符串表偏移量

strsize: u32 = 0

字符串表大小,单位为字节

std.macho.testing

别名

第 6 行

别名目标 std.testing

std.macho.TOOL

容器

第 157 行

字段

CLANG = 0x1
SWIFT = 0x2
LD = 0x3
LLD = 0x4
ZIG = 0x5
_

std.macho.UNWIND_ARM64_DWARF_SECTION_OFFSET

常量

第 2153 行

u32

std.macho.UNWIND_ARM64_FRAME_D10_D11_PAIR

常量

第 2148 行

u32

std.macho.UNWIND_ARM64_FRAME_D12_D13_PAIR

常量

第 2149 行

u32

std.macho.UNWIND_ARM64_FRAME_D14_D15_PAIR

常量

第 2150 行

u32

std.macho.UNWIND_ARM64_FRAME_D8_D9_PAIR

常量

第 2147 行

u32

std.macho.UNWIND_ARM64_FRAME_X19_X20_PAIR

常量

第 2142 行

u32

std.macho.UNWIND_ARM64_FRAME_X21_X22_PAIR

常量

第 2143 行

u32

std.macho.UNWIND_ARM64_FRAME_X23_X24_PAIR

常量

第 2144 行

u32

std.macho.UNWIND_ARM64_FRAME_X25_X26_PAIR

常量

第 2145 行

u32

std.macho.UNWIND_ARM64_FRAME_X27_X28_PAIR

常量

第 2146 行

u32

std.macho.UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK

常量

第 2152 行

u32

std.macho.UNWIND_ARM64_MODE

容器

第 2135 行

字段

OLD = 0
FRAMELESS = 2
DWARF = 3
FRAME = 4

std.macho.UNWIND_ARM64_MODE_MASK

常量

第 2134 行

u32

std.macho.UNWIND_HAS_LSDA

常量

第 2101 行

u32

std.macho.unwind_info_compressed_second_level_page_header

容器

第 2083 行

字段

kind: UNWIND_SECOND_LEVEL = .COMPRESSED

UNWIND_SECOND_LEVEL_COMPRESSED

entryPageOffset: u16
entryCount: u16
encodingsPageOffset: u16
encodingsCount: u16

std.macho.unwind_info_regular_second_level_entry

容器

第 2063 行

字段

functionOffset: u32
encoding: compact_unwind_encoding_t

std.macho.unwind_info_regular_second_level_page_header

容器

第 2074 行

字段

kind: UNWIND_SECOND_LEVEL = .REGULAR

UNWIND_SECOND_LEVEL_REGULAR

entryPageOffset: u16
entryCount: u16

std.macho.unwind_info_section_header

容器

第 2028 行

字段

version: u32 = UNWIND_SECTION_VERSION

UNWIND_SECTION_VERSION

commonEncodingsArraySectionOffset: u32
commonEncodingsArrayCount: u32
personalityArraySectionOffset: u32
personalityArrayCount: u32
indexSectionOffset: u32
indexCount: u32

std.macho.unwind_info_section_header_index_entry

容器

第 2043 行

字段

functionOffset: u32
secondLevelPagesSectionOffset: u32

常规页或压缩页起点相对于节的偏移

lsdaIndexArraySectionOffset: u32

此范围的 lsda_index 数组起点相对于节的偏移

std.macho.unwind_info_section_header_lsda_index_entry

容器

第 2053 行

字段

functionOffset: u32
lsdaOffset: u32

std.macho.UNWIND_IS_NOT_FUNCTION_START

常量

第 2100 行

u32

std.macho.UNWIND_PERSONALITY_MASK

常量

第 2102 行

u32

std.macho.UNWIND_SECOND_LEVEL

容器

第 2068 行

字段

REGULAR = 2
COMPRESSED = 3
_

std.macho.UNWIND_SECTION_VERSION

常量

第 2026 行

std.macho.UNWIND_X86_64_DWARF_SECTION_OFFSET

常量

第 2121 行

u32

std.macho.UNWIND_X86_64_FRAMELESS_STACK_ADJUST

常量

第 2117 行

u32

std.macho.UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT

常量

第 2118 行

u32

std.macho.UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION

常量

第 2119 行

u32

std.macho.UNWIND_X86_64_FRAMELESS_STACK_SIZE

常量

第 2116 行

u32

std.macho.UNWIND_X86_64_MODE

容器

第 2106 行

字段

OLD = 0
RBP_FRAME = 1
STACK_IMMD = 2
STACK_IND = 3
DWARF = 4

std.macho.UNWIND_X86_64_MODE_MASK

常量

第 2105 行

u32

std.macho.UNWIND_X86_64_RBP_FRAME_OFFSET

常量

第 2114 行

u32

std.macho.UNWIND_X86_64_RBP_FRAME_REGISTERS

常量

第 2113 行

u32

std.macho.UNWIND_X86_64_REG

容器

第 2123 行

字段

NONE = 0
RBX = 1
R12 = 2
R13 = 3
R14 = 4
R15 = 5
RBP = 6

std.macho.UnwindInfoCompressedEntry

容器

第 2095 行

字段

funcOffset: u24
encodingIndex: u8

std.macho.uuid_command

容器

第 67 行

uuid 加载命令包含一个 128 位唯一随机数,用于标识静态链接器生成的对象。

字段

cmd: LC = .UUID

LC_UUID

cmdsize: u32 = @sizeOf(uuid_command)

sizeof(struct uuid_command)

uuid: [16]u8 = undefined

128 位 UUID

std.macho.version_min_command

容器

第 80 行

version_min_command 包含此二进制文件构建时要求运行的 最低操作系统版本。

字段

cmd: LC

LC_VERSION_MIN_MACOSX 或 LC_VERSION_MIN_IPHONEOS 或 LC_VERSION_MIN_WATCHOS 或 LC_VERSION_MIN_TVOS

cmdsize: u32 = @sizeOf(version_min_command)

sizeof(struct version_min_command)

version: u32

X.Y.Z 以半字节格式 xxxx.yy.zz 编码

sdk: u32

X.Y.Z 以半字节格式 xxxx.yy.zz 编码

std.macho.vm_prot_t

容器

第 12 行

字段

READ: bool = false
WRITE: bool = false
EXEC: bool = false
_: u1 = 0
COPY: bool = false

调用者无法取得映射条目的写权限时,可以使用以下标志。 该条目将被标记为“需要复制”,从而通过写时复制实际复制对象,并在关联条目的最大保护权限中增加写权限。

__: u27 = 0
源码

std/macho.zig

const std = @import("std");
const builtin = @import("builtin");
const assert = std.debug.assert;
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 = packed struct(u32) {
    READ: bool = false,
    WRITE: bool = false,
    EXEC: bool = false,
    _: u1 = 0,
    /// 调用者无法取得映射条目的写权限时,可以使用以下标志。
    /// 该条目将被标记为“需要复制”,从而通过写时复制实际复制对象,并在关联条目的最大保护权限中增加写权限。
    ///
    ///
    ///
    COPY: bool = false,
    __: u27 = 0,
};

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,
};

/// uuid 加载命令包含一个 128 位唯一随机数,用于标识静态链接器生成的对象。
///
pub const uuid_command = extern struct {
    /// LC_UUID
    cmd: LC = .UUID,

    /// sizeof(struct uuid_command)
    cmdsize: u32 = @sizeOf(uuid_command),

    /// 128 位 UUID
    uuid: [16]u8 = undefined,
};

/// version_min_command 包含此二进制文件构建时要求运行的
/// 最低操作系统版本。
pub const version_min_command = extern struct {
    /// LC_VERSION_MIN_MACOSX 或 LC_VERSION_MIN_IPHONEOS 或 LC_VERSION_MIN_WATCHOS 或 LC_VERSION_MIN_TVOS
    cmd: LC,

    /// sizeof(struct version_min_command)
    cmdsize: u32 = @sizeOf(version_min_command),

    /// X.Y.Z 以半字节格式 xxxx.yy.zz 编码
    version: u32,

    /// X.Y.Z 以半字节格式 xxxx.yy.zz 编码
    sdk: u32,
};

/// source_version_command 是可选加载命令,
/// 包含构建该二进制所用源码的版本。
pub const source_version_command = extern struct {
    /// LC_SOURCE_VERSION
    cmd: LC = .SOURCE_VERSION,

    /// sizeof(source_version_command)
    cmdsize: u32 = @sizeOf(source_version_command),

    /// 将 A.B.C.D.E 打包为 a24.b10.c10.d10.e10
    version: u64,
};

/// build_version_command 包含此二进制文件针对其平台构建时,
/// 所要求的最低操作系统版本。后面列出已知平台
/// 及工具值。
pub const build_version_command = extern struct {
    /// LC_BUILD_VERSION
    cmd: LC = .BUILD_VERSION,

    /// sizeof(struct build_version_command) 加上
    /// ntools * sizeof(struct build_version_command)
    cmdsize: u32,

    /// 平台
    platform: PLATFORM,

    /// X.Y.Z 以半字节格式 xxxx.yy.zz 编码
    minos: u32,

    /// X.Y.Z 以半字节格式 xxxx.yy.zz 编码
    sdk: u32,

    /// 后续工具条目的数量
    ntools: u32,
};

pub const build_tool_version = extern struct {
    /// 工具对应的枚举
    tool: TOOL,

    /// 工具的版本号
    version: u32,
};

pub const PLATFORM = enum(u32) {
    UNKNOWN = 0,
    ANY = 0xffffffff,
    MACOS = 1,
    IOS = 2,
    TVOS = 3,
    WATCHOS = 4,
    BRIDGEOS = 5,
    MACCATALYST = 6,
    IOSSIMULATOR = 7,
    TVOSSIMULATOR = 8,
    WATCHOSSIMULATOR = 9,
    DRIVERKIT = 10,
    VISIONOS = 11,
    VISIONOSSIMULATOR = 12,
    _,
};

pub const TOOL = enum(u32) {
    CLANG = 0x1,
    SWIFT = 0x2,
    LD = 0x3,
    LLD = 0x4, // LLVM 自带的 LLD 链接器
    ZIG = 0x5, // 非官方的 Zig
    _,
};

/// entry_point_command 是 thread_command 的替代形式。
/// 主可执行文件使用它指定 main() 的位置(文件偏移量)。
/// 若链接时使用了 -stack_size,则 stacksize 字段
/// 包含主线程所需的栈大小。
pub const entry_point_command = extern struct {
    /// LC_MAIN 仅用于 MH_EXECUTE 文件类型
    cmd: LC = .MAIN,

    /// sizeof(struct entry_point_command)
    cmdsize: u32 = @sizeOf(entry_point_command),

    /// main() 的文件(__TEXT)偏移
    entryoff: u64 = 0,

    /// 若非零,则为初始栈大小
    stacksize: u64 = 0,
};

/// symtab_command 包含 link-edit 4.3BSD "stab" 风格
/// 符号表信息的偏移和大小,其格式由头文件
/// <nlist.h> 和 <stab.h> 描述。
pub const symtab_command = extern struct {
    /// LC_SYMTAB
    cmd: LC = .SYMTAB,

    /// sizeof(struct symtab_command)
    cmdsize: u32 = @sizeOf(symtab_command),

    /// 符号表偏移量
    symoff: u32 = 0,

    /// 符号表条目数量
    nsyms: u32 = 0,

    /// 字符串表偏移量
    stroff: u32 = 0,

    /// 字符串表大小,单位为字节
    strsize: u32 = 0,
};

/// 这是第二组符号信息,用于支持
/// 动态链接编辑器的数据结构。
///
/// 存在此加载命令时,也必须存在 symtab_command 中
/// 包含符号表和字符串表的原始符号信息。
/// 此加载命令存在时,符号表分为三组:
///  本地符号(静态符号和调试符号),按模块分组;
///  已定义的外部符号,按模块分组(非库时按名称排序);
///  未定义的外部符号;未设置 MH_BINDATLOAD 时按名称排序,
///  设置 MH_BINDATLOAD 时按静态链接器发现它们的顺序排序。
/// 此加载命令保存三组符号各自的偏移量
/// 和数量。
///
/// 此加载命令还保存以下新增
/// 符号信息表的偏移量和大小:
///  目录表;
///  模块表;
///  引用符号表;
///  间接符号表。
/// 仅当文件是动态链接的共享库时,
/// 才存在前三个表(目录表、模块表和
/// 引用符号表)。对于只包含一个模块的可执行文件
/// 和目标模块,这三个表所描述的
/// 信息可按以下方式确定:
///  目录表:已定义的外部符号按名称排序;
///  模块表:文件只包含一个模块,因此文件内全部内容
///  均属于该模块;
///  引用符号表:已定义和未定义的外部符号。
///
/// 对于动态链接共享库文件,此加载命令还保存所有节
/// 的重定位条目池的偏移量和大小,
/// 并将其分为两组:
///  外部重定位条目;
///  本地重定位条目。
/// 对于可执行文件和目标模块,重定位条目仍然
/// 附属于节结构。
///
pub const dysymtab_command = extern struct {
    /// LC_DYSYMTAB
    cmd: LC = .DYSYMTAB,

    /// sizeof(struct dysymtab_command)
    cmdsize: u32 = @sizeOf(dysymtab_command),

    // LC_SYMTAB 加载命令中由 symoff 和 nsyms 指定的符号,分为以下三组:
    //    局部符号,再按所属模块分组。
    //    已定义的外部符号,再按所属模块分组。
    //    未定义符号。
    //
    // 局部符号仅用于调试。动态绑定过程可能需要使用它们,向调试器告知正在绑定模块的局部符号。
    //
    // 后两组用于动态绑定过程中的绑定;若文件是动态链接共享库,则通过模块表和引用符号表间接完成。
    //
    //
    //
    //
    //

    /// 本地符号索引
    ilocalsym: u32 = 0,

    /// 局部符号数量
    nlocalsym: u32 = 0,

    /// 指向外部定义符号的索引
    iextdefsym: u32 = 0,

    /// 外部定义符号的数量
    nextdefsym: u32 = 0,

    /// 未定义符号的索引
    iundefsym: u32 = 0,

    /// 未定义符号的数量
    nundefsym: u32 = 0,

    // 动态绑定过程中,为找到符号定义于哪个模块,
    // 使用类似归档中 ranlib 结构的目录表,
    // 将已定义外部符号映射到其所属模块。
    // 它仅存在于动态链接的共享
    // 库文件中。对于可执行文件和目标模块,已定义外部
    // 符号按名称排序,并用作目录表。

    /// 目录表在文件中的偏移量
    tocoff: u32 = 0,

    /// 目录表中的条目数
    ntoc: u32 = 0,

    // 为了支持“模块”,即整个目标文件的动态绑定,符号
    // 表必须反映生成文件所使用的模块。
    // 为此,通过模块表记录每个模块在合并后的
    // 各表中的索引和计数。这两个条目引用的
    // 模块结构体在下文说明。它仅存在于动态链接的
    // 共享库文件中。对于可执行文件和目标模块,文件只
    // 包含一个模块,因此文件中的全部内容都属于该模块。

    /// 模块表在文件中的偏移量
    modtaboff: u32 = 0,

    /// 模块表条目的数量
    nmodtab: u32 = 0,

    // 为支持动态模块绑定,每个模块的模块结构体
    // 会标明该模块进行的外部引用,包括已定义和未定义的引用。
    // 每个模块都有指向引用符号表的偏移量和计数,
    // 用于表示该模块引用的符号。
    // 它仅存在于动态链接的共享库文件中。
    // 对于可执行文件和目标模块,已定义外部符号及
    // 未定义外部符号即表示外部引用。

    /// 被引用符号表的偏移量
    extrefsymoff: u32 = 0,

    /// 被引用的符号表条目数量
    nextrefsyms: u32 = 0,

    // 包含“符号指针”和“例程桩”的节,对每个指针和桩都保存指向“间接符号”表的索引;条目数量由节大小和固定条目大小隐含确定。
    // 对于这两类节,间接符号表索引存储在节头的 reserved1 字段中。
    // 间接符号表条目只是一个 32 位符号表索引,指向该指针或桩引用的符号。
    // 间接符号表的顺序与节内条目一致。
    //
    //
    //
    //

    /// 间接符号表的文件偏移量
    indirectsymoff: u32 = 0,

    /// 间接符号表条目数量
    nindirectsyms: u32 = 0,

    // 为支持快速重定位库文件中的单个模块,
    // 必须能够高效访问库中每个模块
    // 的外部重定位条目。由于库文件不能通过
    // 节头访问这些条目,因此将其分为
    // 本地条目和外部条目两组,再按模块分组。此时,
    // 如果存在此加载命令,且其 extreloff、nextrel、
    // locreloff 和 nlocrel 字段非零,便表示非合并节的重定位
    // 条目不再通过节结构引用,
    // 且节头中的 reloff 和 nreloc 字段
    // 设置为零。
    //
    // 由于不通过节头访问重定位条目,
    // r_address 字段必须使用节内偏移之外的其他含义,
    // 以标识待重定位项目。此时 r_address
    // 设为相对于第一个 LC_SEGMENT 命令的 vmaddr 的偏移量。
    // 对于 MH_SPLIT_SEGS 映像,r_address 设为相对于
    // 第一个可读写 LC_SEGMENT 命令的 vmaddr 的偏移量。
    //
    // 重定位条目按模块分组;模块表
    // 中的条目保存该模块外部重定位条目组
    // 的索引和数量。
    //
    // 对于跨模块合并的节,不得保留任何
    // 外部重定位条目;合并节中保留的
    // 重定位条目必须是本地条目。

    /// 外部重定位条目的偏移
    extreloff: u32 = 0,

    /// 外部重定位条目的数量
    nextrel: u32 = 0,

    // 所有本地重定位条目集中存放;不按模块分组,
    // 因为仅在对象移离静态链接编辑后的位置时
    // 才会使用它们。

    /// 局部重定位条目的偏移量
    locreloff: u32 = 0,

    /// 本地重定位条目数
    nlocrel: u32 = 0,
};

/// linkedit_data_command 包含 __LINKEDIT 段中
/// 某个数据块的偏移量和大小。
pub const linkedit_data_command = extern struct {
    /// 取值为 LC_CODE_SIGNATURE、LC_SEGMENT_SPLIT_INFO、LC_FUNCTION_STARTS、LC_DATA_IN_CODE、LC_DYLIB_CODE_SIGN_DRS 或 LC_LINKER_OPTIMIZATION_HINT。
    cmd: LC,

    /// sizeof(struct linkedit_data_command)
    cmdsize: u32 = @sizeOf(linkedit_data_command),

    /// 数据在 __LINKEDIT 段中的文件偏移量
    dataoff: u32 = 0,

    /// __LINKEDIT 段中数据的文件大小
    datasize: u32 = 0,
};

/// dyld_info_command 包含 dyld 加载映像所需信息的新压缩形式的文件偏移量与大小。Mac OS X 10.6 及更高版本上的 dyld 使用此信息。
/// 此命令指向的全部信息都以字节流编码,因此解释它们时无需交换字节序。
///
///
///
///
pub const dyld_info_command = extern struct {
    /// LC_DYLD_INFO or LC_DYLD_INFO_ONLY
    cmd: LC = .DYLD_INFO_ONLY,

    /// sizeof(struct dyld_info_command)
    cmdsize: u32 = @sizeOf(dyld_info_command),

    // dyld 将映像加载到不同于首选地址的位置时,会对映像执行重基址。重基址信息是单字节操作码流,其符号名称以 REBASE_OPCODE_ 开头。
    // 从概念上说,重基址信息是由以下元组组成的表:
    //    <seg-index, seg-offset, type>
    // 操作码仅在某列发生变化时编码,以压缩方式表示该表。此外,“每隔 n 个偏移重复 m 次”等简单模式,也可以用少量字节编码。
    //
    //
    //
    //
    //

    /// 重基信息的文件偏移
    rebase_off: u32 = 0,

    /// 重基信息的大小
    rebase_size: u32 = 0,

    // 若某个映像需要将指针初始化为其他映像中的符号,dyld 会在加载过程中绑定该映像。
    // 绑定信息是由单字节操作码组成的流,其符号名称以 BIND_OPCODE_ 开头。
    // 从概念上说,绑定信息是由以下元组组成的表:
    //    <seg-index, seg-offset, type, symbol-library-ordinal, symbol-name, addend>
    // 操作码仅在某列发生变化时编码,以压缩方式表示该表。此外,将一连串指针初始化为相同值等简单模式,也可以用少量字节编码。
    //
    //
    //
    //
    //

    /// 绑定信息的文件偏移量
    bind_off: u32 = 0,

    /// 绑定信息的大小
    bind_size: u32 = 0,

    // 某些 C++ 程序要求 dyld 对符号去重,使进程中的所有映像使用同一份代码或数据。此步骤在绑定之后执行。weak_bind 信息与 bind_info 一样是操作码流,但按符号名的字母顺序排序,使 dyld 能依次遍历所有包含弱绑定信息的映像并查找冲突。若没有冲突,dyld 不执行任何更新。
    // 这意味着某些修复项也会编码在 bind_info 中。例如,所有对“operator new”的调用都会先根据 bind_info 中的信息绑定到 libstdc++.dylib。随后,若某个映像覆盖了 operator new,处理 weak_bind 信息时就会检测到这一点,并重新绑定对 operator new 的调用。
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //

    /// 弱绑定信息的文件偏移
    weak_bind_off: u32 = 0,

    /// 弱绑定信息的大小
    weak_bind_size: u32 = 0,

    // 某些外部符号的使用不需要立即绑定,
    // 可以在首次使用时延迟绑定。lazy_bind
    // 区域包含用于绑定所有延迟符号的 BIND 操作码流。
    // 通常,dyld 加载映像时会忽略 lazy_bind 段。
    // 静态链接器会安排延迟指针最初
    // 指向一个辅助函数,该函数压入待绑定符号在
    // lazy_bind 区域中的偏移量,然后跳转到 dyld。
    // dyld 只需将此偏移量加到 lazy_bind_off 上,
    // 即可获得需要绑定的
    // 符号信息。

    /// 延迟绑定信息在文件中的偏移量
    lazy_bind_off: u32 = 0,

    /// 延迟绑定信息的大小
    lazy_bind_size: u32 = 0,

    // 动态库导出的符号以字典树编码。这是一种提取公共前缀的紧凑表示。由于名称、地址和标志等全部信息都编码在一段较小的连续区域中,还能减少内存中的 LINKEDIT 页。
    // 导出区域是节点流,其中顺序排列的第一个节点是字典树的起始节点。
    //
    // 符号节点首先包含一个 uleb128,表示当前已匹配字符串对应的导出符号信息长度。若没有导出符号,节点以零字节开头;若存在导出信息,则紧随长度字段之后。
    //
    // 导出信息首先是包含标志的 uleb128。通常,其后是 uleb128 编码的偏移量,表示符号所指内容相对于该映像 mach_header 的位置。
    // 若标志为 EXPORT_SYMBOL_FLAGS_REEXPORT,则标志后依次为 uleb128 编码的库序号,以及以零结尾的 UTF8 字符串。若字符串长度为零,则表示以相同名称从指定动态库重新导出该符号。
    // 若标志为 EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER,则标志后跟两个 uleb128,分别是桩偏移量与解析器偏移量。非惰性指针使用桩;惰性指针使用解析器,并且必须调用解析器才能获得实际使用的地址。
    //
    // 可选的导出符号信息之后是一个字节,表示该节点的出边数量(0–255),随后是各条边。
    // 每条边包含一个以零结尾的 UTF8 字符串,表示符号名新增的字符,随后是该边所指节点的 uleb128 偏移量。
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //

    /// 延迟绑定信息在文件中的偏移量
    export_off: u32 = 0,

    /// 延迟绑定信息的大小
    export_size: u32 = 0,
};

/// 使用动态链接器的程序包含 dylinker_command,以标识
/// 动态链接器名称,即 LC_LOAD_DYLINKER。动态链接器自身
/// 也包含 dylinker_command,以标识自身,即 LC_ID_DYLINKER。
/// 一个文件至多包含其中一个命令。
/// 此结构体也用于 LC_DYLD_ENVIRONMENT 加载命令,
/// 包含供 dyld 按环境变量处理的字符串。
pub const dylinker_command = extern struct {
    /// 取值为 LC_ID_DYLINKER、LC_LOAD_DYLINKER 或 LC_DYLD_ENVIRONMENT
    cmd: LC,

    /// 包含路径名字符串
    cmdsize: u32,

    /// 加载命令中的变长字符串由 lc_str
    /// 联合体表示。字符串存储在加载命令结构体之后,
    /// 偏移量相对于加载命令结构体的起始位置。字符串
    /// 大小计入加载命令的 cmdsize 字段。
    /// 同样,为使 cmdsize 成为 4 字节整数倍
    /// 而添加的填充字节必须为零。
    name: u32,
};

/// 动态链接的共享库,即 mach 头部中 filetype == MH_DYLIB 的文件,
/// 包含一个 dylib_command,cmd == LC_ID_DYLIB,用于标识该库。
/// 使用动态链接共享库的目标文件,对每个使用的库也包含
/// 一个 dylib_command,其 cmd 为 LC_LOAD_DYLIB、LC_LOAD_WEAK_DYLIB 或
/// LC_REEXPORT_DYLIB。
pub const dylib_command = extern struct {
    /// 取值为 LC_ID_DYLIB、LC_LOAD_WEAK_DYLIB、LC_LOAD_DYLIB、LC_REEXPORT_DYLIB
    cmd: LC,

    /// 包含路径名字符串
    cmdsize: u32,

    /// 库标识
    dylib: dylib,
};

/// 动态链接共享库由两项信息标识:
/// 路径名,即执行时找到的库名称,
/// 以及兼容版本号。路径名必须匹配,使用该库的程序记录的
/// 兼容版本号必须大于或等于
/// 实际使用的库的版本号。时间戳用于记录库构建
/// 并被复制进使用方的时刻,以便判断运行时使用的库
/// 是否与构建程序时所用的库完全相同。
pub const dylib = extern struct {
    /// 库的路径名(指向 dylib_command 末尾的偏移)
    name: u32,

    /// 库的构建时间戳
    timestamp: u32,

    /// 库当前的版本号
    current_version: u32,

    /// 库的兼容性版本号
    compatibility_version: u32,
};

/// rpath_command 包含一个路径,运行时应将其添加到当前运行路径,以查找以 @rpath 为前缀的动态库。
///
pub const rpath_command = extern struct {
    /// LC_RPATH
    cmd: LC = .RPATH,

    /// 包含字符串
    cmdsize: u32,

    /// 要添加到运行路径的路径
    path: u32,
};

pub const encryption_info_command = extern struct {
    cmd: LC = .ENCRYPTION_INFO,
    cmdsize: u32 = @sizeOf(encryption_info_command),

    cryptoff: u32,
    cryptsize: u32,
    cryptid: u32 = 0,
};

pub const encryption_info_command_64 = extern struct {
    cmd: LC = .ENCRYPTION_INFO_64,
    cmdsize: u32 = @sizeOf(encryption_info_command_64),

    cryptoff: u32,
    cryptsize: u32,
    cryptid: u32 = 0,
    _pad: u32 = 0,
};

/// 段加载命令表示应将此文件的一部分
/// 映射到任务的地址空间。该段在内存中的大小
/// vmsize 可以等于或大于从文件映射的大小
/// filesize。文件从 fileoff 开始映射至
/// 内存中该段的起始地址 vmaddr。该段剩余的内存
/// 若存在,则按需分配并填零。段的最大虚拟
/// 内存保护和初始虚拟内存保护分别由
/// maxprot 和 initprot 字段指定。如果段包含节,
/// 则节结构体紧随段命令之后,其大小
/// 计入 cmdsize。
pub const segment_command = extern struct {
    /// LC_SEGMENT
    cmd: LC = .SEGMENT,

    /// 包含节结构体的 sizeof
    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,
};

/// 64 位段加载命令表示将此文件的一部分
/// 映射到 64 位任务的地址空间。若此 64 位段包含节,
/// 则 section_64 结构紧随 64 位段命令之后,
/// 其大小计入 cmdsize。
pub const segment_command_64 = extern struct {
    /// LC_SEGMENT_64
    cmd: LC = .SEGMENT_64,

    /// 包括 section_64 结构体的 sizeof
    cmdsize: u32,
    // TODO: 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 = .{},

    /// 初始虚拟内存保护
    initprot: vm_prot_t = .{},

    /// 段内节的数量
    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.write;
    }
};

pub const PROT = struct {
    /// [MC2] 无权限
    pub const NONE: vm_prot_t = 0x00;
    /// [MC2] 页面可读取
    pub const READ: vm_prot_t = 0x01;
    /// [MC2] 页面可以写入
    pub const WRITE: vm_prot_t = 0x02;
    /// [MC2] 页可执行
    pub const EXEC: vm_prot_t = 0x04;
    /// 调用者无法取得映射条目的写权限时,可以使用以下标志。
    /// 该条目将被标记为“需要复制”,从而通过写时复制实际复制对象,并在关联条目的最大保护权限中增加写权限。
    ///
    ///
    ///
    pub const COPY: vm_prot_t = 0x10;
};

/// 段由零个或多个节组成。链接编辑器生成非 MH_OBJECT 文件时,每个段都含有适当的节,并填充到指定的段对齐边界。MH_EXECUTE 和 MH_FVMLIB 格式文件的第一个段,在第一个节之前包含目标文件的 mach_header 与加载命令。所有格式中,零填充节始终位于所在段的末尾,因此段中已清零的填充区域可以映射到零填充节所在的内存位置。以吉字节计的零填充节,即节类型为 S_GB_ZEROFILL 的节,只能与同类型节处于同一段中。这些段会放在所有其他段之后。
///
/// 为保持紧凑,MH_OBJECT 格式将所有节放在一个段中。不填充到指定段边界,mach_header 和加载命令也不属于该段。
///
/// 进入同一段 segname、且节名称 sectname 相同的节,会由链接编辑器合并。结果节按所有被合并节中的最大对齐要求对齐,该值成为新节的对齐要求。各原始节在合并后的节内部仍按各自原有的对齐要求对齐。为满足指定对齐要求而添加的填充字节均置零。
///
/// Mach 目标文件中,由节结构的 reloff 与 nreloc 字段引用的重定位条目格式,在头文件 <reloc.h> 中描述。
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
pub const section = extern struct {
    /// 此节的名称
    sectname: [16]u8,

    /// 此节所属的段
    segname: [16]u8,

    /// 此节的内存地址
    addr: u32,

    /// 此节的字节大小
    size: u32,

    /// 此节在文件中的偏移量
    offset: u32,

    /// 节对齐(2 的幂)
    @"align": u32,

    /// 重定位条目的文件偏移
    reloff: u32,

    /// 重定位条目数量
    nreloc: u32,

    /// 标志(节类型与属性)
    flags: u32,

    /// 预留(用作偏移或索引)
    reserved1: u32,

    /// 保留(用于计数或 sizeof)
    reserved2: u32,
};

pub const section_64 = extern struct {
    /// 此节的名称
    sectname: [16]u8,

    /// 此节所属的段
    segname: [16]u8,

    /// 此节的内存地址
    addr: u64 = 0,

    /// 此节的字节大小
    size: u64 = 0,

    /// 此节在文件中的偏移量
    offset: u32 = 0,

    /// 节对齐(2 的幂)
    @"align": u32 = 0,

    /// 重定位条目的文件偏移
    reloff: u32 = 0,

    /// 重定位条目数量
    nreloc: u32 = 0,

    /// 标志(节类型与属性)
    flags: u32 = S_REGULAR,

    /// 预留(用作偏移或索引)
    reserved1: u32 = 0,

    /// 保留(用于计数或 sizeof)
    reserved2: u32 = 0,

    /// 保留
    reserved3: u32 = 0,

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

    pub fn segName(sect: *const section_64) []const u8 {
        return parseName(&sect.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.findScalar(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: packed union(u8) {
        bits: packed struct(u8) {
            ext: bool,
            type: enum(u3) {
                undf = 0,
                abs = 1,
                sect = 7,
                pbud = 6,
                indr = 5,
                _,
            },
            pext: bool,
            /// 任何非零值均表示这是 stab,因此应使用 `stab` 字段。
            is_stab: u3,
        },
        stab: enum(u8) {
            gsym = N_GSYM,
            fname = N_FNAME,
            fun = N_FUN,
            stsym = N_STSYM,
            lcsym = N_LCSYM,
            bnsym = N_BNSYM,
            ast = N_AST,
            opt = N_OPT,
            rsym = N_RSYM,
            sline = N_SLINE,
            ensym = N_ENSYM,
            ssym = N_SSYM,
            so = N_SO,
            oso = N_OSO,
            lsym = N_LSYM,
            bincl = N_BINCL,
            sol = N_SOL,
            params = N_PARAMS,
            version = N_VERSION,
            olevel = N_OLEVEL,
            psym = N_PSYM,
            eincl = N_EINCL,
            entry = N_ENTRY,
            lbrac = N_LBRAC,
            excl = N_EXCL,
            rbrac = N_RBRAC,
            bcomm = N_BCOMM,
            ecomm = N_ECOMM,
            ecoml = N_ECOML,
            leng = N_LENG,
            _,
        },
    },
    n_sect: u8,
    n_desc: packed struct(u16) {
        _pad0: u3 = 0,
        arm_thumb_def: bool,
        referenced_dynamically: bool,
        /// 此位的含义取决于上下文。
        /// 另见 `N_DESC_DISCARDED` 和 `N_NO_DEAD_STRIP`。
        discarded_or_no_dead_strip: bool,
        weak_ref: bool,
        /// 此位的含义取决于上下文。
        /// 参见 `N_WEAK_DEF` 和 `N_REF_TO_WEAK`。
        weak_def_or_ref_to_weak: bool,
        symbol_resolver: bool,
        alt_entry: bool,
        _pad2: u6 = 0,
    },
    n_value: u64,

    pub fn tentative(sym: nlist_64) bool {
        return sym.n_type.bits.type == .undf and sym.n_value != 0;
    }
};

/// Mach-O 文件重定位条目的格式,修改自 4.3BSD
/// 格式。相较于原始格式,修改内容是改变
/// “局部”重定位条目,即 r_extern == 0 时的 r_symbolnum 字段值。
/// 此更改用于支持任意数量节中的符号,
/// 而不限于 4.3BSD 文件中的三个节,即 text、data 和 bss。
/// 此外,末尾 4 位增加了 r_type 标签。
pub const relocation_info = packed struct {
    /// 待重定位内容在节中的偏移
    r_address: i32,

    /// r_extern == 1 时为符号索引,r_extern == 0 时为节序号。
    r_symbolnum: u24,

    /// 之前已使用相对于程序计数器的方式重定位
    r_pcrel: u1,

    /// 0=字节,1=字,2=长字,3=四字
    r_length: u2,

    /// 不包含被引用符号的值
    r_extern: u1,

    /// 若非 0,则为机器专用重定位类型
    r_type: u4,
};

/// 从 MacOS X 10.1 之后开始,若新增加载命令必须被动态链接器理解,映像才能正确执行,则会将 LC_REQ_DYLD 位按位或入该加载命令常量。
/// 若动态链接器遇到不认识的此类加载命令,会报告“unknown load command required for execution”错误,并拒绝使用该映像。
/// 其他未设置此位且不被理解的加载命令会被直接忽略。
///
///
///
///
pub const LC_REQ_DYLD = 0x80000000;

pub const LC = enum(u32) {
    /// 没有加载命令 - 无效
    NONE = 0x0,

    /// 待映射的此文件的段
    SEGMENT = 0x1,

    /// 链接编辑的 stab 符号表信息
    SYMTAB = 0x2,

    /// 链接编辑器的 gdb 符号表信息(已过时)
    SYMSEG = 0x3,

    /// 线程
    THREAD = 0x4,

    /// unix 线程(包含栈)
    UNIXTHREAD = 0x5,

    /// 加载指定的固定 VM 共享库
    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,

    /// 子 umbrella
    SUB_UMBRELLA = 0x13,

    /// 子客户端
    SUB_CLIENT = 0x14,

    /// 子库
    SUB_LIBRARY = 0x15,

    /// 两级命名空间查找提示
    TWOLEVEL_HINTS = 0x16,

    /// 预绑定校验和
    PREBIND_CKSUM = 0x17,

    /// 加载允许缺失的动态链接共享库
    /// (所有符号均以弱导入方式导入)。
    LOAD_WEAK_DYLIB = 0x18 | LC_REQ_DYLD,

    /// 待映射的此文件的 64 位段
    SEGMENT_64 = 0x19,

    /// 64 位映像例程
    ROUTINES_64 = 0x1a,

    /// 该 UUID
    UUID = 0x1b,

    /// runpath 添加项
    RPATH = 0x1c | LC_REQ_DYLD,

    /// 代码签名的位置
    CODE_SIGNATURE = 0x1d,

    /// 用于拆分段的信息位置
    SEGMENT_SPLIT_INFO = 0x1e,

    /// 加载并重新导出 dylib
    REEXPORT_DYLIB = 0x1f | LC_REQ_DYLD,

    /// 首次使用时延迟加载 dylib
    LAZY_LOAD_DYLIB = 0x20,

    /// 加密段信息
    ENCRYPTION_INFO = 0x21,

    /// 压缩的 dyld 信息
    DYLD_INFO = 0x22,

    /// 仅含压缩的 dyld 信息
    DYLD_INFO_ONLY = 0x22 | LC_REQ_DYLD,

    /// 加载向上依赖的 dylib
    LOAD_UPWARD_DYLIB = 0x23 | LC_REQ_DYLD,

    /// 构建 MacOSX 所需的最低操作系统版本
    VERSION_MIN_MACOSX = 0x24,

    /// 构建 iPhoneOS 所需的最低操作系统版本
    VERSION_MIN_IPHONEOS = 0x25,

    /// 函数起始地址的压缩表
    FUNCTION_STARTS = 0x26,

    /// 供 dyld 当作环境变量处理的字符串
    DYLD_ENVIRONMENT = 0x27,

    /// LC_UNIXTHREAD 的替代项
    MAIN = 0x28 | LC_REQ_DYLD,

    /// __text 中的非指令表
    DATA_IN_CODE = 0x29,

    /// 用于构建二进制文件的源版本
    SOURCE_VERSION = 0x2A,

    /// 从链接的 dylib 复制的代码签名 DR
    DYLIB_CODE_SIGN_DRS = 0x2B,

    /// 64 位加密段信息
    ENCRYPTION_INFO_64 = 0x2C,

    /// MH_OBJECT 文件中的链接器选项
    LINKER_OPTION = 0x2D,

    /// MH_OBJECT 文件中的优化提示
    LINKER_OPTIMIZATION_HINT = 0x2E,

    /// 构建 AppleTV 所需的最低操作系统版本
    VERSION_MIN_TVOS = 0x2F,

    /// 构建所针对的 Watch 最低操作系统版本
    VERSION_MIN_WATCHOS = 0x30,

    /// Mach-O 文件中包含的任意数据
    NOTE = 0x31,

    /// 针对平台最低操作系统版本构建
    BUILD_VERSION = 0x32,

    /// 与 linkedit_data_command 一起使用,载荷为 trie
    DYLD_EXPORTS_TRIE = 0x33 | LC_REQ_DYLD,

    /// 与 linkedit_data_command 配合使用
    DYLD_CHAINED_FIXUPS = 0x34 | LC_REQ_DYLD,

    _,
};

/// Mach 魔数
pub const MH_MAGIC: u32 = 0xfeedface;

/// NXSwapInt(MH_MAGIC)
pub const MH_CIGAM: u32 = 0xcefaedfe;

/// 64 位 mach 魔数
pub const MH_MAGIC_64: u32 = 0xfeedfacf;

/// NXSwapInt(MH_MAGIC_64)
pub const MH_CIGAM_64: u32 = 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;

/// x86_64 内核扩展
pub const MH_KEXT_BUNDLE = 0xb;

// mach_header 的 flags 字段所用常量。

/// 目标文件没有未定义引用
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;

/// 禁止 dyld 将此可执行文件通知给预绑定代理
pub const MH_NOFIXPREBINDING = 0x400;

/// 此二进制文件未预绑定,但可重新进行预绑定。仅在未设置 MH_PREBOUND 时使用。
pub const MH_PREBINDABLE = 0x800;

/// 表示此二进制文件绑定到依赖库中所有采用两级命名空间的模块。仅在同时设置 MH_PREBINDABLE 和 MH_TWOLEVEL 时使用。
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;

/// 设置此位时,任务中的所有栈都会获得执行权限。仅用于 MH_EXECUTE 文件类型。
pub const MH_ALLOW_STACK_EXECUTION = 0x20000;

/// 设置此位后,二进制文件声明其可安全用于 uid 为零的进程。
pub const MH_ROOT_SAFE = 0x40000;

/// 设置此位时,二进制文件声明其可安全用于 issetugid() 为真的进程。
pub const MH_SETUID_SAFE = 0x80000;

/// 在动态库上设置此位后,静态链接器无需检查其依赖的动态库是否被重新导出。
pub const MH_NO_REEXPORTED_DYLIBS = 0x100000;

/// 设置此位时,操作系统会将主可执行文件加载到随机地址。仅用于 MH_EXECUTE 文件类型。
pub const MH_PIE = 0x200000;

/// 仅用于动态库。链接一个设置了此位的动态库时,若未引用其中任何符号,静态链接器会自动省略指向该动态库的 LC_LOAD_DYLIB 加载命令。
pub const MH_DEAD_STRIPPABLE_DYLIB = 0x400000;

/// 包含 S_THREAD_LOCAL_VARIABLES 类型的节
pub const MH_HAS_TLV_DESCRIPTORS = 0x800000;

/// 设置此位时,即使平台本身没有要求,例如 x86,操作系统也会使用不可执行堆运行主可执行文件。仅用于 MH_EXECUTE 文件类型。
pub const MH_NO_HEAP_EXECUTION = 0x1000000;

/// 代码已链接为供应用扩展使用。
pub const MH_APP_EXTENSION_SAFE = 0x02000000;

/// nlist 符号表列出的外部符号未涵盖 dyld 信息中列出的全部符号。
pub const MH_NLIST_OUTOFSYNC_WITH_DYLDINFO = 0x04000000;

/// 允许 LC_MIN_VERSION_MACOS,以及平台为 macOS、iOSMac、iOSSimulator、tvOSSimulator 或 watchOSSimulator 的 LC_BUILD_VERSION 加载命令。
pub const MH_SIM_SUPPORT = 0x08000000;

/// 仅用于动态库。设置此位时,动态库属于 dyld 共享缓存,而非独立存放于文件系统。
pub const MH_DYLIB_IN_CACHE = 0x80000000;

// fat_header 的 flags 字段常量

/// 通用二进制的魔数
pub const FAT_MAGIC: u32 = 0xcafebabe;

/// NXSwapLong(FAT_MAGIC)
pub const FAT_CIGAM: u32 = 0xbebafeca;

/// 64 位 fat 魔数
pub const FAT_MAGIC_64: u32 = 0xcafebabf;

/// NXSwapLong(FAT_MAGIC_64)
pub const FAT_CIGAM_64: u32 = 0xbfbafeca;

/// 段标志。
/// 此段的文件内容对应虚拟内存空间高地址部分,
/// 低地址部分填零,用于核心文件中的栈。
pub const SG_HIGHVM = 0x1;
/// 此段是固定 VM 库分配的虚拟内存,供
/// 链接编辑器检查重叠。
pub const SG_FVMLIB = 0x2;
/// 此段中没有发生重定位的内容,也没有任何内容被重定位到此段,因此可安全替换而无需重定位。
///
pub const SG_NORELOC = 0x4;
/// 此段受保护。若段从文件偏移 0 开始,
/// 则其第一页不受保护。此段的所有其他页均受保护。
pub const SG_PROTECTED_VERSION_1 = 0x8;
/// 此段在完成修正后设为只读
pub const SG_READ_ONLY = 0x10;

/// 节结构的 flags 字段分为节类型和节属性两部分。
/// 节类型互斥,即只能有一种类型;
/// 节属性则不互斥,即可具有多个属性。
///
/// 共有 256 种节类型。
pub const SECTION_TYPE = 0x000000ff;

/// 24 个节属性
pub const SECTION_ATTRIBUTES = 0xffffff00;

/// 常规节
pub const S_REGULAR = 0x0;

/// 按需零填充节
pub const S_ZEROFILL = 0x1;

/// 仅包含 C 字符串字面量的节
pub const S_CSTRING_LITERALS = 0x2;

/// 仅含 4 字节字面量的节
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;

/// 符号定义于 n_sect 给出的节编号中
pub const N_SECT = 0xe;

/// 符号未定义,映像正在使用该符号的
/// 预绑定值
pub const N_PBUD = 0xc;

/// 符号被定义为与另一个符号相同;n_value 字段
/// 是字符串表索引,指定
/// 另一个符号的名称。
pub const N_INDR = 0xa;

/// 全局符号:name,,NO_SECT,type,0
pub const N_GSYM = 0x20;

/// 过程名(f77 变通处理):name,,NO_SECT,0,0
pub const N_FNAME = 0x22;

/// 过程:name,,n_sect,linenumber,address
pub const N_FUN = 0x24;

/// 静态符号:name,,n_sect,type,address
pub const N_STSYM = 0x26;

/// .lcomm 符号:name,,n_sect,type,address
pub const N_LCSYM = 0x28;

/// nsect 符号开始:0,,n_sect,0,address
pub const N_BNSYM = 0x2e;

/// AST 文件路径:name,,NO_SECT,0,0
pub const N_AST = 0x32;

/// 随 gcc2_compiled 一同发出,并存在于 gcc 源码中
pub const N_OPT = 0x3c;

/// 寄存器符号:name,,NO_SECT,type,register
pub const N_RSYM = 0x40;

/// 源代码行:0,,n_sect,linenumber,address
pub const N_SLINE = 0x44;

/// end nsect sym: 0,,n_sect,0,address
pub const N_ENSYM = 0x4e;

/// 结构体元素:name,,NO_SECT,type,struct_offset
pub const N_SSYM = 0x60;

/// 源文件名:name,,n_sect,0,address
pub const N_SO = 0x64;

/// 目标文件名:name,,0,0,st_mtime
pub const N_OSO = 0x66;

/// 局部符号:name,,NO_SECT,type,offset
pub const N_LSYM = 0x80;

/// 包含文件开始:name,,NO_SECT,0,sum
pub const N_BINCL = 0x82;

/// #include 文件名:name,,n_sect,0,address
pub const N_SOL = 0x84;

/// 编译器参数:name,,NO_SECT,0,0
pub const N_PARAMS = 0x86;

/// 编译器版本:name,,NO_SECT,0,0
pub const N_VERSION = 0x88;

/// 编译器 -O 级别:name,,NO_SECT,0,0
pub const N_OLEVEL = 0x8A;

/// 参数:name,,NO_SECT,type,offset
pub const N_PSYM = 0xa0;

/// 包含文件结束:name,,NO_SECT,0,0
pub const N_EINCL = 0xa2;

/// 备用条目:name,,n_sect,linenumber,address
pub const N_ENTRY = 0xa4;

/// 左括号:0,,NO_SECT,nesting level,address
pub const N_LBRAC = 0xc0;

/// 已删除的包含文件:name,,NO_SECT,0,sum
pub const N_EXCL = 0xc2;

/// 右括号:0,,NO_SECT,nesting level,address
pub const N_RBRAC = 0xe0;

/// 公共符号开始:name,,NO_SECT,0,0
pub const N_BCOMM = 0xe2;

/// 公共块结束:name,,n_sect,0,0
pub const N_ECOMM = 0xe4;

/// 公共块结束(本地名称):0,,n_sect,0,address
pub const N_ECOML = 0xe8;

/// 包含长度信息的第二个 stab 条目
pub const N_LENG = 0xfe;

// 两类符号指针节和符号桩节都有对应的间接符号表条目。对于节中的每个条目,间接符号表按相同顺序保存对应条目,起始索引存储在节结构的 reserved1 字段中。
// 由于间接符号表条目与节内条目一一对应,其数量可用节大小除以节内条目大小推得。对于符号指针节,每个条目为 4 字节;对于符号桩节,桩的字节大小存储在节结构的 reserved2 字段中。
//
//
//
//
//
//
//
//

/// 仅包含非惰性符号指针的节
pub const S_NON_LAZY_SYMBOL_POINTERS = 0x6;

/// 仅包含惰性符号指针的节
pub const S_LAZY_SYMBOL_POINTERS = 0x7;

/// 仅包含符号桩的节,桩的字节大小位于 reserved2 字段
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;

/// 按需填零的节(可大于 4 GB)
pub const S_GB_ZEROFILL = 0xc;

/// 仅包含用于符号替换的函数指针对的节
pub const S_INTERPOSING = 0xd;

/// 仅含 16 字节字面量的节
pub const S_16BYTE_LITERALS = 0xe;

/// 此节包含 DTrace 对象格式数据
pub const S_DTRACE_DOF = 0xf;

/// 仅包含指向延迟加载动态库的延迟符号指针的节
pub const S_LAZY_DYLIB_SYMBOL_POINTERS = 0x10;

// 若某个段包含标记为 S_ATTR_DEBUG 的节,则该段全部节都必须具有此属性。
// 除同样标记该属性的节外,其他节不得引用此节内容。
// 具有此属性的节可以不含符号,且节类型必须为 S_REGULAR。
// 静态链接器不会将具有此属性的节的内容复制到输出文件中。
// 这些节通常包含 DWARF 调试信息。
//
//

/// 调试节
pub const S_ATTR_DEBUG = 0x02000000;

/// 此节仅包含实际机器指令
pub const S_ATTR_PURE_INSTRUCTIONS = 0x80000000;

/// 节包含不应出现在 ranlib 目录中的
/// 合并符号
pub const S_ATTR_NO_TOC = 0x40000000;

/// 在带有 MH_DYLDLINK 标志的文件中,可以剥离此节的静态符号
///
pub const S_ATTR_STRIP_STATIC_SYMS = 0x20000000;

/// 不进行无用代码剥离
pub const S_ATTR_NO_DEAD_STRIP = 0x10000000;

/// 引用存活块的块也存活
pub const S_ATTR_LIVE_SUPPORT = 0x8000000;

/// 与由 dyld 写入的 x86 代码桩一起使用
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;

/// TLV 的初始值模板
pub const S_THREAD_LOCAL_REGULAR = 0x11;

/// TLV 的初始值模板
pub const S_THREAD_LOCAL_ZEROFILL = 0x12;

/// TLV 描述符
pub const S_THREAD_LOCAL_VARIABLES = 0x13;

/// 指向 TLV 描述符的指针
pub const S_THREAD_LOCAL_VARIABLE_POINTERS = 0x14;

/// 为初始化 TLV 值而调用的函数
pub const S_THREAD_LOCAL_INIT_FUNCTION_POINTERS = 0x15;

/// 指向初始化器的 32 位偏移
pub const S_INIT_FUNC_OFFSETS = 0x16;

/// 面向基于 64 位 Intel 处理器的 Mac 的 CPU 类型
pub const CPU_TYPE_X86_64: cpu_type_t = 0x01000007;

/// 面向基于 64 位 ARM 处理器的 Mac 的 CPU 类型
pub const CPU_TYPE_ARM64: cpu_type_t = 0x0100000C;

/// 所有基于 Intel 的 Mac
pub const CPU_SUBTYPE_X86_64_ALL: cpu_subtype_t = 0x3;

/// 所有基于 ARM 的 Mac
pub const CPU_SUBTYPE_ARM_ALL: cpu_subtype_t = 0x0;

// 以下内容用于编码基址重定位信息。
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;

// 以下内容用于编码绑定信息
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,

    /// 用于有符号 32 位位移
    X86_64_RELOC_SIGNED,

    /// 带 32 位位移的 CALL/JMP 指令。
    X86_64_RELOC_BRANCH,

    /// 用 MOVQ 加载 GOT 条目
    X86_64_RELOC_GOT_LOAD,

    /// 其他 GOT 引用
    X86_64_RELOC_GOT,

    /// 后面必须紧跟 X86_64_RELOC_UNSIGNED
    X86_64_RELOC_SUBTRACTOR,

    /// 用于附加数为 -1 的 32 位有符号位移
    X86_64_RELOC_SIGNED_1,

    /// 用于带 -2 加数的有符号 32 位位移
    X86_64_RELOC_SIGNED_2,

    /// 用于具有 -4 加数的有符号 32 位位移。
    X86_64_RELOC_SIGNED_4,

    /// 用于线程局部变量
    X86_64_RELOC_TLV,
};

pub const reloc_type_arm64 = enum(u4) {
    /// 用于指针。
    ARM64_RELOC_UNSIGNED = 0,

    /// 后面必须跟随 ARM64_RELOC_UNSIGNED。
    ARM64_RELOC_SUBTRACTOR,

    /// 具有 26 位位移的 B/BL 指令。
    ARM64_RELOC_BRANCH26,

    /// 到目标所在页的 PC 相对距离。
    ARM64_RELOC_PAGE21,

    /// 页内偏移量,按 r_length 缩放。
    ARM64_RELOC_PAGEOFF12,

    /// 到 GOT 槽所在页的 PC 相对距离。
    ARM64_RELOC_GOT_LOAD_PAGE21,

    /// GOT 槽位的页内偏移量,按 r_length 缩放。
    ARM64_RELOC_GOT_LOAD_PAGEOFF12,

    /// 指向 GOT 槽的指针。
    ARM64_RELOC_POINTER_TO_GOT,

    /// 到 TLVP 槽所在页的 PC 相对距离。
    ARM64_RELOC_TLVP_LOAD_PAGE21,

    /// TLVP 槽在页内的偏移,以 r_length 为缩放因子。
    ARM64_RELOC_TLVP_LOAD_PAGEOFF12,

    /// 后面必须紧跟 PAGE21 或 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;

/// 对于由动态加载器 API,如 dlsym 和 NSLookupSymbolInImage 引用,而非
/// 由普通未定义符号引用所引用的已定义符号,必须设置此位。strip 工具用此位
/// 避免移除必须存在的符号:设置此位的符号不会被 strip 剥离。
pub const REFERENCED_DYNAMICALLY: u16 = 0x10;

/// n_desc 字段的 N_NO_DEAD_STRIP 位仅出现在
/// 可重定位 .o 文件中,即 MH_OBJECT 文件类型;它用于通知
/// 静态链接编辑器,绝不可将此符号作为死代码剔除。
pub const N_NO_DEAD_STRIP: u16 = 0x20;

/// 供动态链接器在运行时使用。不要设置此位。
pub const N_DESC_DISCARDED: u16 = 0x20;

/// 表示此符号是弱引用。如果动态链接器找不到该符号的
/// 定义,则将其地址设为 0。提供相应弱链接标志时,
/// 静态链接器会设置此符号。
pub const N_WEAK_REF: u16 = 0x40;

/// 表示此符号是弱定义。如果静态或动态链接器发现此符号的
/// 另一个(非弱)定义,则忽略弱定义。只有合并节(第 23 页)中的符号才能标记为弱定义。
///
pub const N_WEAK_DEF: u16 = 0x80;

/// n_desc 字段中的 N_SYMBOL_RESOLVER 位表示该
/// 函数实际上是一个解析器函数,应当调用它来获取要使用的
/// 真实函数地址。
/// 此位仅适用于 .o 文件(MH_OBJECT 文件类型)。
pub const N_SYMBOL_RESOLVER: u16 = 0x100;

// 以下项目用于导出信息中终端节点的 flags 字节。
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_WEAK_DEFINITION: u8 = 0x04;
pub const EXPORT_SYMBOL_FLAGS_REEXPORT: u8 = 0x08;
pub const EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER: u8 = 0x10;

// 间接符号表条目通常是一个 32 位符号表索引,指向指针或桩引用的符号。
// 例外是非惰性符号指针节中引用的已定义符号已被 strip(1) 移除,此时条目值为 INDIRECT_SYMBOL_LOCAL。
// 若该符号同时为绝对符号,还要将 INDIRECT_SYMBOL_ABS 按位或入该值。
//
//
pub const INDIRECT_SYMBOL_LOCAL: u32 = 0x80000000;
pub const INDIRECT_SYMBOL_ABS: u32 = 0x40000000;

// 代码签名常量及结构体取自:
// https://opensource.apple.com/source/xnu/xnu-6153.81.5/osfmk/kern/cs_blobs.h.auto.html

/// 单一 Requirement blob
pub const CSMAGIC_REQUIREMENT: u32 = 0xfade0c00;
/// 要求向量(内部要求)
pub const CSMAGIC_REQUIREMENTS: u32 = 0xfade0c01;
/// CodeDirectory 数据块
pub const CSMAGIC_CODEDIRECTORY: u32 = 0xfade0c02;
/// 签名数据的嵌入形式
pub const CSMAGIC_EMBEDDED_SIGNATURE: u32 = 0xfade0cc0;
/// XXX
pub const CSMAGIC_EMBEDDED_SIGNATURE_OLD: u32 = 0xfade0b02;
/// 嵌入的授权信息
pub const CSMAGIC_EMBEDDED_ENTITLEMENTS: u32 = 0xfade7171;
/// 嵌入的 DER 编码权限
pub const CSMAGIC_EMBEDDED_DER_ENTITLEMENTS: u32 = 0xfade7172;
/// 包含多种架构的嵌入签名集合
pub const CSMAGIC_DETACHED_SIGNATURE: u32 = 0xfade0cc1;
/// 包含 CMS 签名等内容
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;

/// CodeDirectory 的槽索引
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;

/// 首个备用 CodeDirectory,若存在
pub const CSSLOT_ALTERNATE_CODEDIRECTORIES: u32 = 0x1000;
/// 备用 CD 槽的最大数量
pub const CSSLOT_ALTERNATE_CODEDIRECTORY_MAX: u32 = 5;
/// 最后一个之后的位置
pub const CSSLOT_ALTERNATE_CODEDIRECTORY_LIMIT: u32 = CSSLOT_ALTERNATE_CODEDIRECTORIES + CSSLOT_ALTERNATE_CODEDIRECTORY_MAX;

/// CMS 签名
pub const CSSLOT_SIGNATURESLOT: u32 = 0x10000;
pub const CSSLOT_IDENTIFICATIONSLOT: u32 = 0x10001;
pub const CSSLOT_TICKETSLOT: u32 = 0x10002;

/// 与 amfi 兼容
pub const CSTYPE_INDEX_REQUIREMENTS: u32 = 0x00000002;
/// 与 amfi 兼容
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;

/// 此 CodeDirectory 专门针对版本 0x20400。
pub const CodeDirectory = extern struct {
    /// 魔数(CSMAGIC_CODEDIRECTORY)
    magic: u32,

    /// CodeDirectory blob 总长度
    length: u32,

    /// 兼容版本
    version: u32,

    /// 设置与模式标志
    flags: u32,

    /// 索引为零的哈希槽元素的偏移量
    hashOffset: u32,

    /// 标识符字符串的偏移量
    identOffset: u32,

    /// 特殊哈希槽数量
    nSpecialSlots: u32,

    /// 普通(代码)哈希槽的数量
    nCodeSlots: u32,

    /// 限制在主映像签名范围内
    codeLimit: u32,

    /// 每个哈希的字节大小
    hashSize: u8,

    /// 哈希类型(cdHashType* 常量)
    hashType: u8,

    /// 平台标识符;若非平台二进制文件,则为零。
    platform: u8,

    /// log2(页大小,单位为字节);0 => 无穷大
    pageSize: u8,

    /// 未使用(必须为零)
    spare2: u32,

    ///
    scatterOffset: u32,

    ///
    teamOffset: u32,

    ///
    spare3: u32,

    ///
    codeLimit64: u64,

    /// 可执行段的偏移
    execSegBase: u64,

    /// 可执行段的界限
    execSegLimit: u64,

    /// 可执行段标志
    execSegFlags: u64,
};

/// 嵌入式签名 SuperBlob 的结构
pub const BlobIndex = extern struct {
    /// 条目类型
    type: u32,

    /// 条目的偏移量
    offset: u32,
};

/// 此结构后跟 GenericBlobs,
/// 其顺序不固定,由 index 中的偏移量指示。
pub const SuperBlob = extern struct {
    /// 魔数
    magic: u32,

    /// SuperBlob 的总长度
    length: u32,

    /// 此结构体之后的 BlobIndex 索引条目数量
    count: u32,
};

pub const GenericBlob = extern struct {
    /// 魔数
    magic: u32,

    /// blob 的总长度
    length: u32,
};

/// LC_DATA_IN_CODE 加载命令使用 linkedit_data_command
/// 指向 data_in_code_entry 条目数组。每个条目
/// 描述代码节中的一段数据。
pub const data_in_code_entry = extern struct {
    /// 从 mach_header 到数据范围起始位置。
    offset: u32,
    /// 数据范围中的字节数。
    length: u16,
    /// 一个 DICE_KIND 值。
    kind: u16,
};

pub const LoadCommandIterator = struct {
    next_index: usize,
    ncmds: usize,
    r: std.Io.Reader,

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

        pub fn cast(lc: LoadCommand, comptime Cmd: type) ?Cmd {
            if (lc.data.len < @sizeOf(Cmd)) return null;
            const ptr: *align(1) const Cmd = @ptrCast(lc.data.ptr);
            var cmd = ptr.*;
            if (builtin.cpu.arch.endian() != .little) std.mem.byteSwapAllFields(Cmd, &cmd);
            return cmd;
        }

        /// 断言 LoadCommand 的类型为 segment_command_64。
        /// 若本机字节序不是 `.little`,调用者必须交换 `section_64` 值的字节序。
        pub fn getSections(lc: LoadCommand) []align(1) const section_64 {
            const segment_lc = lc.cast(segment_command_64).?;
            const sects_ptr: [*]align(1) const section_64 = @ptrCast(lc.data[@sizeOf(segment_command_64)..]);
            return sects_ptr[0..segment_lc.nsects];
        }

        /// 断言 LoadCommand 的类型为 dylib_command。
        pub fn getDylibPathName(lc: LoadCommand) []const u8 {
            const dylib_lc = lc.cast(dylib_command).?;
            return mem.sliceTo(lc.data[dylib_lc.dylib.name..], 0);
        }

        /// 断言 LoadCommand 的类型为 rpath_command。
        pub fn getRpathPathName(lc: LoadCommand) []const u8 {
            const rpath_lc = lc.cast(rpath_command).?;
            return mem.sliceTo(lc.data[rpath_lc.path..], 0);
        }

        /// 断言 LoadCommand 的类型为 build_version_command。
        /// 若本机字节序不是 `.little`,则调用者必须交换 `build_tool_version` 值的字节序。
        pub fn getBuildVersionTools(lc: LoadCommand) []align(1) const build_tool_version {
            const build_lc = lc.cast(build_version_command).?;
            const tools_ptr: [*]align(1) const build_tool_version = @ptrCast(lc.data[@sizeOf(build_version_command)..]);
            return tools_ptr[0..build_lc.ntools];
        }
    };

    pub fn next(it: *LoadCommandIterator) error{InvalidMachO}!?LoadCommand {
        if (it.next_index >= it.ncmds) return null;

        const hdr = it.r.peekStruct(load_command, .little) catch |err| switch (err) {
            error.ReadFailed => unreachable,
            error.EndOfStream => return error.InvalidMachO,
        };
        const data = it.r.take(hdr.cmdsize) catch |err| switch (err) {
            error.ReadFailed => unreachable,
            error.EndOfStream => return error.InvalidMachO,
        };

        it.next_index += 1;
        return .{ .hdr = hdr, .data = data };
    }

    pub fn init(hdr: *const mach_header_64, cmds_buf_overlong: []const u8) error{InvalidMachO}!LoadCommandIterator {
        if (cmds_buf_overlong.len < hdr.sizeofcmds) return error.InvalidMachO;
        if (hdr.ncmds > 0 and hdr.sizeofcmds < @sizeOf(load_command)) return error.InvalidMachO;
        const cmds_buf = cmds_buf_overlong[0..hdr.sizeofcmds];
        return .{
            .next_index = 0,
            .ncmds = hdr.ncmds,
            .r = .fixed(cmds_buf),
        };
    }
};

pub const compact_unwind_encoding_t = u32;

// 可重定位对象文件:__LD,__compact_unwind

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

// 最终链接映像:__TEXT,__unwind_info。
// __TEXT,__unwind_info 节采用适合高效两级查找的布局。
// 节头包含粗粒度索引,将函数地址映射到包含该函数展开信息的页,即 4096 字节块。
//

pub const UNWIND_SECTION_VERSION = 1;

pub const unwind_info_section_header = extern struct {
    /// UNWIND_SECTION_VERSION
    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,

    /// 此范围的 lsda_index 数组起点相对于节的偏移
    lsdaIndexArraySectionOffset: u32,
};

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

// 二级索引页有常规页和压缩页两种。
// 压缩页最多容纳 1021 个条目,但若使用了过多
// 不同编码类型,则无法使用。常规页容纳 511 个
// 条目。

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 {
    /// UNWIND_SECOND_LEVEL_REGULAR
    kind: UNWIND_SECOND_LEVEL = .REGULAR,

    entryPageOffset: u16,
    entryCount: u16,
    // 条目数组
};

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

    entryPageOffset: u16,
    entryCount: u16,
    encodingsPageOffset: u16,
    encodingsCount: u16,
    // 32 位条目数组
    // 编码数组
};

pub const UnwindInfoCompressedEntry = packed struct(u32) {
    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,
};

// 归档文件以 ARMAG 标识字符串开头。对于每个成员文件,随后是
// `struct ar_hdr',以及由其 `ar_size'
// 成员指示字节数的成员文件数据。
/// 归档文件的起始字符串。
pub const ARMAG = "!<arch>\n";
/// 每个头部末尾 ar_fmag 中的字符串。
pub const ARFMAG = "`\n";