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

第 1 行

std.coff.archive_end_of_header

常量

第 6 行

std.coff.archive_signature

常量

第 5 行

std.coff.ArchiveMemberHeader

容器

第 2010 行

字段

name: [16]u8

左对齐、以 '/' 终止的成员名称

date: [12]u8

左对齐的 ASCII 十进制数:自 1970 年 1 月 1 日起的秒数

user_id: [6]u8

左对齐的 ASCII 十进制数:用户 ID

group_id: [6]u8

左对齐的 ASCII 十进制数:组标识符

file_mode: [8]u8

左对齐的 ASCII 八进制:文件模式

size: [10]u8

左对齐的 ASCII 十进制数:此头部后面的成员大小, 不包含头部自身的大小。

end_of_header: [2]u8

字面字符串 '\n'

std.coff.ArchiveMemberHeader.Kind

容器

第 2086 行

字段

first_linker
second_linker
longnames
coff
import

std.coff.ArchiveMemberHeader.parseDate

函数

第 2066 行

pub fn parseDate(self: *const ArchiveMemberHeader) !u40

参数

self: *const ArchiveMemberHeader

std.coff.ArchiveMemberHeader.parseField

函数

第 2054 行

fn parseField(field: []const u8, T: type, base: u8) !T

参数

field: []const u8
T: type
base: u8

std.coff.ArchiveMemberHeader.parseFileMode

函数

第 2078 行

pub fn parseFileMode(self: *const ArchiveMemberHeader) !u20

参数

self: *const ArchiveMemberHeader

std.coff.ArchiveMemberHeader.parseGroupId

函数

第 2074 行

pub fn parseGroupId(self: *const ArchiveMemberHeader) !u20

参数

self: *const ArchiveMemberHeader

std.coff.ArchiveMemberHeader.parseName

函数

第 2029 行

直接从头部读取成员名称,或在提供长名称成员时从其中查找名称。

pub fn parseName( self: *const ArchiveMemberHeader, opt_longnames: ?[]const u8, ) ![]const u8

参数

self: *const ArchiveMemberHeader
opt_longnames: ?[]const u8

std.coff.ArchiveMemberHeader.parseSize

函数

第 2082 行

pub fn parseSize(self: *const ArchiveMemberHeader) !u34

参数

self: *const ArchiveMemberHeader

std.coff.ArchiveMemberHeader.parseUserId

函数

第 2070 行

pub fn parseUserId(self: *const ArchiveMemberHeader) !u20

参数

self: *const ArchiveMemberHeader

std.coff.assert

别名

第 2 行

别名目标 std.debug.assert

std.coff.BaseRelocation

容器

第 271 行

字段

offset: u12

存储于 WORD 剩余的 12 位中,是相对于此块的 Page RVA 字段指定起始地址的偏移量。 此偏移量指定应用基址重定位的位置。

type: BaseRelocationType

存储在 WORD 的高 4 位中,表示应应用的基址重定位类型。

std.coff.BaseRelocationDirectoryEntry

容器

第 263 行

字段

page_rva: u32

将映像基址加上页 RVA,再加上各偏移,得到必须应用基址重定位的虚拟地址。

block_size: u32

基址重定位块的总字节数,包括 Page RVA、Block Size 字段及后续 Type/Offset 字段。

std.coff.BaseRelocationType

容器

第 280 行

字段

ABSOLUTE = 0

跳过基址重定位。此类型可用于填充块。

HIGH = 1

基址重定位将差值的高 16 位加到偏移处的 16 位字段上。该 16 位字段表示一个 32 位字的高位部分。

LOW = 2

基址重定位将差值的低 16 位加到偏移处的 16 位字段上。该 16 位字段表示一个 32 位字的低半部分。

HIGHLOW = 3

基址重定位将差值的全部 32 位应用于偏移处的 32 位字段。

HIGHADJ = 4

基址重定位将差值的高 16 位加到指定偏移量处的 16 位字段。 该 16 位字段表示一个 32 位字的高半部分。 32 位值的低 16 位存储在此基址重定位之后的 16 位字中。 这意味着该基址重定位占用两个槽位。

MIPS_JMPADDR = 5

机器类型为 MIPS 时,基址重定位应用于 MIPS 跳转指令。

RESERVED = 6

此重定位仅在机器类型为 ARM 或 Thumb 时有意义。 基址重定位将符号的 32 位地址应用于一对连续的 MOVW/MOVT 指令。 此重定位仅在机器类型为 RISC-V 时有意义。 基址重定位应用于 32 位绝对地址的高 20 位。 保留,必须为零。

THUMB_MOV32 = 7

此重定位仅在机器类型为 Thumb 时有意义。 基址重定位将符号的 32 位地址应用于一对连续的 MOVW/MOVT 指令。

RISCV_LOW12S = 8

此重定位仅在机器类型为 RISC-V 时有意义。 基址重定位作用于按 RISC-V I 型指令格式构成的 32 位绝对地址的低 12 位。 此重定位仅在机器类型为 RISC-V 时有意义。 基址重定位应用于以 RISC-V S 型指令格式构成的 32 位绝对地址的低 12 位。

MIPS_JMPADDR16 = 9

此重定位仅在机器类型为 32 位 LoongArch 时有意义。 基址重定位应用于连续两条指令构成的 32 位绝对地址。 此重定位仅在机器类型为 LoongArch 64 位时有意义。 基址重定位作用于由四条连续指令构成的 64 位绝对地址。 此重定位仅在机器类型为 MIPS 时有意义。 基址重定位应用于 MIPS16 跳转指令。

DIR64 = 10

基址重定位将差值应用于偏移处的 64 位字段。

_

std.coff.BaseType

容器

第 718 行

字段

NULL = 0

无类型信息或未知基本类型。Microsoft 工具使用此设置。

VOID = 1

无有效类型;用于 void 指针和函数

CHAR = 2

字符(有符号字节)

SHORT = 3

2 字节有符号整数

INT = 4

自然整数类型(Windows 上通常为 4 字节)。

LONG = 5

4 字节有符号整数

FLOAT = 6

四字节浮点数

DOUBLE = 7

八字节浮点数

STRUCT = 8

结构体

UNION = 9

联合体

ENUM = 10

枚举类型

MOE = 11

枚举成员(指定值)

BYTE = 12

一个字节;无符号单字节整数

WORD = 13

一个字;无符号双字节整数

UINT = 14

自然大小的无符号整数(通常为 4 字节)

DWORD = 15

无符号 4 字节整数

_

std.coff.Coff

容器

第 1018 行

字段

data: []const u8
is_loaded: bool
is_image: bool
coff_header_offset: usize
guid: [16]u8 = undefined
age: u32 = undefined

std.coff.Coff.getDataDirectories

函数

第 1144 行

pub fn getDataDirectories(self: *const Coff) []align(1) const ImageDataDirectory

参数

self: *const Coff

std.coff.Coff.getHeader

函数

第 1104 行

pub fn getHeader(self: Coff) Header

参数

self: Coff

std.coff.Coff.getImageBase

函数

第 1126 行

pub fn getImageBase(self: Coff) u64

参数

self: Coff

std.coff.Coff.getNumberOfDataDirectories

函数

第 1135 行

pub fn getNumberOfDataDirectories(self: Coff) u32

参数

self: Coff

std.coff.Coff.getOptionalHeader

函数

第 1108 行

pub fn getOptionalHeader(self: Coff) OptionalHeader

参数

self: Coff

std.coff.Coff.getOptionalHeader32

函数

第 1114 行

pub fn getOptionalHeader32(self: Coff) OptionalHeader.PE32

参数

self: Coff

std.coff.Coff.getOptionalHeader64

函数

第 1120 行

pub fn getOptionalHeader64(self: Coff) OptionalHeader.@"PE32+"

参数

self: Coff

std.coff.Coff.getPdbPath

函数

第 1057 行

pub fn getPdbPath(self: *Coff) !?[]const u8

参数

self: *Coff

std.coff.Coff.getSectionByName

函数

第 1205 行

pub fn getSectionByName(self: *const Coff, comptime name: []const u8) ?*align(1) const SectionHeader

参数

self: *const Coff
name: []const u8

std.coff.Coff.getSectionData

函数

第 1217 行

pub fn getSectionData(self: *const Coff, sec: *align(1) const SectionHeader) []const u8

参数

self: *const Coff
sec: *align(1) const SectionHeader

std.coff.Coff.getSectionDataAlloc

函数

第 1222 行

pub fn getSectionDataAlloc(self: *const Coff, sec: *align(1) const SectionHeader, allocator: mem.Allocator) ![]u8

参数

self: *const Coff
sec: *align(1) const SectionHeader
allocator: mem.Allocator

std.coff.Coff.getSectionHeaders

函数

第 1180 行

pub fn getSectionHeaders(self: *const Coff) []align(1) const SectionHeader

参数

self: *const Coff

std.coff.Coff.getSectionHeadersAlloc

函数

第 1186 行

pub fn getSectionHeadersAlloc(self: *const Coff, allocator: mem.Allocator) ![]SectionHeader

参数

self: *const Coff
allocator: mem.Allocator

std.coff.Coff.getSectionName

函数

第 1196 行

pub fn getSectionName(self: *const Coff, sect_hdr: *align(1) const SectionHeader) error{InvalidStrtabSize}![]const u8

参数

self: *const Coff
sect_hdr: *align(1) const SectionHeader

错误

InvalidStrtabSize

std.coff.Coff.getStrtab

函数

第 1164 行

pub fn getStrtab(self: *const Coff) error{InvalidStrtabSize}!?Strtab

参数

self: *const Coff

错误

InvalidStrtabSize

std.coff.Coff.getSymtab

函数

第 1155 行

pub fn getSymtab(self: *const Coff) ?Symtab

参数

self: *const Coff

std.coff.Coff.init

函数

第 1029 行

pub fn init(data: []const u8, is_loaded: bool) error{ EndOfStream, MissingPEHeader }!Coff

参数

data: []const u8
is_loaded: bool

错误

EndOfStream
MissingPEHeader

std.coff.Coff.strtabRequired

函数

第 1175 行

pub fn strtabRequired(self: *const Coff) bool

参数

self: *const Coff

std.coff.ComdatSelection

容器

第 958 行

字段

NONE = 0

不是 COMDAT 节。

NODUPLICATES = 1

若此符号已定义,链接器将报告 "multiply defined symbol" 错误。

ANY = 2

定义相同 COMDAT 符号的任何节都可链接;其余节将被移除。

SAME_SIZE = 3

链接器从此符号的各定义中任意选择一个节。 若各定义大小并非全部相同,则发出 "multiply defined symbol" 错误。

EXACT_MATCH = 4

链接器从此符号的各定义中任意选择一个节。 若各定义并非完全一致,则发出 "multiply defined symbol" 错误。

ASSOCIATIVE = 5

只有另一个特定的 COMDAT 节被链接时,才链接此节。 另一个节由此节定义的辅助符号记录中的 Number 字段指定。 对于组件分散于多个节的定义,此设置很有用, 例如代码位于一个节、数据位于另一个节,但必须作为整体链接或丢弃。 与此节关联的另一个节必须是 COMDAT 节,也可以是另一个 关联 COMDAT 节。关联 COMDAT 节的节关联链不能形成环。 节关联链最终必须到达未设置 IMAGE_COMDAT_SELECT_ASSOCIATIVE 的 COMDAT 节。

LARGEST = 6

链接器从此符号的所有定义中选择最大的定义。 若多个定义均为此大小,则任意选择其中一个。

_

std.coff.ComplexType

容器

第 770 行

字段

NULL = 0

无派生类型;该符号是简单标量变量。

POINTER = 16

此符号是指向基类型的指针。

FUNCTION = 32

该符号是返回基本类型的函数。

ARRAY = 48

此符号是基类型的数组。

_

std.coff.DebugDirectoryEntry

容器

第 343 行

字段

characteristics: u32
time_date_stamp: u32
major_version: u16
minor_version: u16
type: DebugType
size_of_data: u32
address_of_raw_data: u32
pointer_to_raw_data: u32

std.coff.DebugInfoDefinition

容器

第 992 行

字段

unused_1: [4]u8
linenumber: u16

源文件中的实际顺序行号(1、2、3 等),对应 .bf 或 .ef 记录。

unused_2: [6]u8
pointer_to_next_function: u32

下一个 .bf 符号记录的符号表索引。 若该函数是符号表中的最后一个函数,则此字段为零。 .ef 记录不使用此字段。

unused_3: [2]u8

std.coff.DebugType

容器

第 354 行

字段

UNKNOWN = 0
COFF = 1
CODEVIEW = 2
FPO = 3
MISC = 4
EXCEPTION = 5
FIXUP = 6
OMAP_TO_SRC = 7
OMAP_FROM_SRC = 8
BORLAND = 9
RESERVED10 = 10
VC_FEATURE = 12
POGO = 13
ILTCG = 14
MPX = 15
REPRO = 16
EX_DLLCHARACTERISTICS = 20
_

std.coff.DllFlags

容器

第 105 行

字段

_reserved_0: u5 = 0
HIGH_ENTROPY_VA: bool = false

映像可以处理高熵 64 位虚拟地址空间。

DYNAMIC_BASE: bool = false

DLL 可以在加载时重定位。

FORCE_INTEGRITY: bool = false

强制进行代码完整性检查。

NX_COMPAT: bool = false

映像兼容 NX。

NO_ISOLATION: bool = false

遵循隔离规则,但不隔离映像。

NO_SEH: bool = false

不使用结构化异常(SE)处理。此映像中不得调用任何 SE 处理程序。

NO_BIND: bool = false

不要绑定映像。

APPCONTAINER: bool = false

映像必须在 AppContainer 中执行。

WDM_DRIVER: bool = false

WDM 驱动程序。

GUARD_CF: bool = false

映像支持控制流防护(CFG)。

TERMINAL_SERVER_AWARE: bool = false

支持终端服务器。

std.coff.Error

错误集合

第 1008 行

错误

InvalidMachine
InvalidPEHeader
InvalidPEMagic
MissingCoffSection
MissingPEHeader
MissingStringTable

std.coff.ExportAddressTableEntry

容器

第 491 行

字段

export_or_forwarder_rva: u32

如果此地址位于导出节中,则它是导出的地址。 否则,它是一个字符串的地址,该字符串指定另一个 DLL 中的符号: <dll name>.<export name> <dll name>.#<export ordinal>

std.coff.ExportDirectoryTable

容器

第 463 行

字段

flags: u32

保留

time_date_stamp: u32

此表的创建时间

major_version: u16
minor_version: u16
name_rva: u32

包含 DLL 名称的 ASCII 字符串地址。 此地址相对于映像基址。

ordinal_base: u32

此映像中第一个导出的序号

number_of_entries: u32

导出地址表中的条目数量

number_of_names: u32

名称指针表和序号表中的条目数

export_address_table_rva: u32
name_pointer_table_rva: u32
ordinal_table_rva: u32

std.coff.ExportNamePointerTableEntry

容器

第 499 行

字段

name_rva: u32

std.coff.ExportOrdinalTableEntry

容器

第 503 行

字段

unbiased_ordinal: u16

std.coff.FileDefinition

容器

第 922 行

字段

file_name: [18]u8

给出源文件名称的 ANSI 字符串。 若小于最大长度,则以空字节填充。

std.coff.FileDefinition.getFileName

函数

第 927 行

pub fn getFileName(self: *const FileDefinition) []const u8

参数

self: *const FileDefinition

std.coff.FunctionDefinition

容器

第 881 行

字段

tag_index: u32

对应 .bf(函数开始)符号记录的符号表索引。

total_size: u32

函数本身的可执行代码大小。 若函数位于独立的节中,则节头的 SizeOfRawData 大于或等于此字段, 具体取决于对齐要求。

pointer_to_linenumber: u32

此函数的第一个 COFF 行号条目的文件偏移量;若不存在则为零。

pointer_to_next_function: u32

下一个函数记录的符号表索引。 若该函数是符号表中的最后一个函数,此字段设为零。

unused: [2]u8

std.coff.Header

容器

第 11 行

字段

machine: IMAGE.FILE.MACHINE

标识目标机器类型的编号。

number_of_sections: u16

节的数量。表示紧随各个头部之后的节表大小。

time_date_stamp: u32

自 1970 年 1 月 1 日 00:00 起经过秒数的低 32 位(C 运行时的 time_t 值),表示文件创建时间。

pointer_to_symbol_table: u32

COFF 符号表的文件偏移;若不存在 COFF 符号表,则为零。 对于映像,此值应为零,因为 COFF 调试信息已弃用。

number_of_symbols: u32

符号表中的条目数。 可用此数据定位紧随符号表之后的字符串表。 对于映像,此值应为零,因为 COFF 调试信息已弃用。

size_of_optional_header: u16

可选头的大小。可执行文件必须包含可选头,目标文件则不要求。 目标文件的此值应为零。头部格式见“可选头(仅映像)”。

flags: Header.Flags

指示文件属性的标志。

std.coff.Header.Flags

容器

第 38 行

字段

RELOCS_STRIPPED: bool = false

仅用于映像,适用于 Windows CE 以及 Microsoft Windows NT 及后续版本。 表示文件不包含基址重定位, 因此必须加载到其首选基址。 若该基址不可用,加载器将报告错误。 链接器默认从可执行文件(EXE)中 移除基址重定位。

EXECUTABLE_IMAGE: bool = false

仅用于映像。表示映像文件有效且可运行。 若未设置此标志,则表示链接器错误。

LINE_NUMS_STRIPPED: bool = false

COFF 行号已移除。此标志已弃用,应为零。

LOCAL_SYMS_STRIPPED: bool = false

已移除 COFF 符号表中的局部符号条目。 此标志已弃用,应为零。

AGGRESSIVE_WS_TRIM: bool = false

已废弃。积极裁剪工作集。 此标志在 Windows 2000 及更高版本中已弃用,必须为零。

LARGE_ADDRESS_AWARE: bool = false

应用程序可以处理大于 2 GB 的地址。

RESERVED: bool = false

此标志保留供将来使用。

BYTES_REVERSED_LO: bool = false

小端:内存中最低有效位(LSB)先于最高有效位(MSB)。 此标志已弃用,应为零。

@"32BIT_MACHINE": bool = false

机器基于 32 位字架构。

DEBUG_STRIPPED: bool = false

从映像文件中移除调试信息。

REMOVABLE_RUN_FROM_SWAP: bool = false

如果映像位于可移动介质上,则完整加载它并复制到交换文件。

NET_RUN_FROM_SWAP: bool = false

若映像位于网络介质上,完整加载它并复制到交换文件。

SYSTEM: bool = false

映像文件是系统文件,而非用户程序。

DLL: bool = false

映像文件是动态链接库 (DLL)。 虽然无法直接运行,但这类文件在几乎所有用途中均被视为可执行文件。

UP_SYSTEM_ONLY: bool = false

此文件应仅在单处理器机器上运行。

BYTES_REVERSED_HI: bool = false

大端序:最高有效字节在内存中先于最低有效字节。此标志已弃用,应为零。

std.coff.IMAGE

命名空间

第 1410 行

std.coff.IMAGE_NT_OPTIONAL_HDR32_MAGIC

常量

第 102 行

std.coff.IMAGE_NT_OPTIONAL_HDR64_MAGIC

常量

第 103 行

std.coff.IMAGE_NUMBEROF_DIRECTORY_ENTRIES

常量

第 256 行

std.coff.IMAGE.DIRECTORY_ENTRY

容器

第 1411 行

字段

EXPORT = 0

导出目录

IMPORT = 1

导入目录

RESOURCE = 2

资源目录

EXCEPTION = 3

异常目录

SECURITY = 4

安全目录

BASERELOC = 5

基址重定位表

DEBUG = 6

调试目录

ARCHITECTURE = 7

架构专用数据

GLOBALPTR = 8

GP 的 RVA

TLS = 9

TLS 目录

LOAD_CONFIG = 10

加载配置目录

BOUND_IMPORT = 11

标头中的绑定导入目录

IAT = 12

导入地址表

DELAY_IMPORT = 13

延迟加载导入描述符

COM_DESCRIPTOR = 14

COM 运行时描述符

RESERVED = 15

必须为零

_

std.coff.IMAGE.DIRECTORY_ENTRY.len

常量

第 1446 行

std.coff.IMAGE.FILE

命名空间

第 1449 行

std.coff.IMAGE.FILE.MACHINE

容器

第 1453 行

机器类型。 Machine 字段具有以下某个值,用于指定 CPU 类型。 映像文件只能在所指定机器或模拟该机器的系统上运行。

字段

UNKNOWN = 0x0

假定此字段内容适用于任何机器类型

ALPHA = 0x184

Alpha AXP,32 位地址空间

ALPHA64 = 0x284

Alpha 64,64 位地址空间

AM33 = 0x1d3

Matsushita AM33 处理器

AMD64 = 0x8664

x64

ARM = 0x1c0

ARM 小端序

ARM64 = 0xaa64

ARM64 小端序

ARM64EC = 0xA641

使原生 ARM64 与仿真的 x64 代码能够互操作的 ABI。

ARM64X = 0xA64E

允许原生 ARM64 与 ARM64EC 代码共存于同一文件的二进制格式。

ARMNT = 0x1c4

ARM Thumb-2 小端序

EBC = 0xebc

EFI 字节码

I386 = 0x14c

Intel 386 或更新处理器及兼容处理器。

IA64 = 0x200

Intel Itanium 处理器系列

LOONGARCH32 = 0x6232

LoongArch 32 位处理器系列

LOONGARCH64 = 0x6264

LoongArch 64 位处理器系列

M32R = 0x9041

Mitsubishi M32R 小端序

MIPS16 = 0x266

MIPS16

MIPSFPU = 0x366

带 FPU 的 MIPS

MIPSFPU16 = 0x466

带 FPU 的 MIPS16

POWERPC = 0x1f0

PowerPC 小端序

POWERPCFP = 0x1f1

支持浮点的 Power PC

R3000BE = 0x160

兼容 MIPS I 的 32 位大端序

R3000 = 0x162

兼容 MIPS I 的 32 位小端序

R4000 = 0x166

兼容 MIPS III 的 64 位小端序

R10000 = 0x168

兼容 MIPS IV 的 64 位小端序

RISCV32 = 0x5032

RISC-V 32 位地址空间

RISCV64 = 0x5064

RISC-V 64 位地址空间

RISCV128 = 0x5128

RISC-V 128 位地址空间

SH3 = 0x1a2

Hitachi SH3

SH3DSP = 0x1a3

Hitachi SH3 DSP

SH4 = 0x1a6

Hitachi SH4

SH5 = 0x1a8

Hitachi SH5 处理器

THUMB = 0x1c2

Thumb

WCEMIPSV2 = 0x169

MIPS 小端序 WCE v2

_

std.coff.IMAGE.FILE.MACHINE.AXP64

常量

第 1524 行

AXP 64(同 Alpha 64)

IMAGE.FILE.MACHINE

std.coff.IMAGE.FILE.MACHINE.RelocationType

类型函数

第 1526 行

pub fn RelocationType(comptime machine: IMAGE.FILE.MACHINE) type

参数

machine: IMAGE.FILE.MACHINE

std.coff.IMAGE.REL

命名空间

第 1558 行

std.coff.IMAGE.REL.AMD64

容器

第 1561 行

x64 处理器 为 x64 及兼容处理器定义了以下重定位类型标识。

字段

ABSOLUTE = 0x0000

忽略此重定位。

ADDR64 = 0x0001

重定位目标的 64 位 VA。

ADDR32 = 0x0002

重定位目标的 32 位虚拟地址。

ADDR32NB = 0x0003

不包含映像基址的 32 位地址(RVA)。

REL32 = 0x0004

相对于重定位位置之后的字节的 32 位相对地址。

REL32_1 = 0x0005

相对于重定位位置之后 1 字节处的 32 位地址。

REL32_2 = 0x0006

相对于重定位后第 2 字节位置的 32 位地址。

REL32_3 = 0x0007

相对于重定位位置之后第 3 字节的 32 位地址。

REL32_4 = 0x0008

相对于重定位位置之后 4 字节处的 32 位地址。

REL32_5 = 0x0009

相对于重定位后第 5 字节位置的 32 位地址。

SECTION = 0x000A

包含目标的节的 16 位节索引。 用于支持调试信息。

SECREL = 0x000B

目标相对于其节开头的 32 位偏移量。 用于支持调试信息和静态线程局部存储。

SECREL7 = 0x000C

相对于包含目标的节的基址的 7 位无符号偏移。

TOKEN = 0x000D

CLR 标记。

SREL32 = 0x000E

写入目标文件的 32 位有符号、依赖跨度的值。

PAIR = 0x000F

必须紧跟每个跨度相关值的一对项目。

SSPAN32 = 0x0010

在链接时应用的 32 位有符号跨度相关值。

_

std.coff.IMAGE.REL.ARM

容器

第 1603 行

ARM 处理器 为 ARM 处理器定义以下重定位类型指示符。

字段

ABSOLUTE = 0x0000

忽略此重定位。

ADDR32 = 0x0001

目标的 32 位 VA。

ADDR32NB = 0x0002

目标的 32 位 RVA。

BRANCH24 = 0x0003

指向目标的 24 位相对位移。

BRANCH11 = 0x0004

对子程序调用的引用。 该引用由两条带有 11 位偏移量的 16 位指令组成。

REL32 = 0x000A

相对于重定位位置之后的字节的 32 位相对地址。

SECTION = 0x000E

包含目标的节的 16 位节索引。 用于支持调试信息。

SECREL = 0x000F

目标相对于其节开头的 32 位偏移量。 用于支持调试信息和静态线程局部存储。

MOV32 = 0x0010

目标的 32 位虚拟地址。 此重定位先用 MOVW 指令处理低 16 位,再用 MOVT 处理高 16 位。

THUMB_MOV32 = 0x0011

目标的 32 位虚拟地址。 此重定位先用 MOVW 指令处理低 16 位,再用 MOVT 处理高 16 位。

THUMB_BRANCH20 = 0x0012

使用到 2 字节对齐目标的 21 位相对位移修补指令。 位移的最低有效位始终为零,不予存储。 此重定位对应 Thumb-2 的 32 位条件 B 指令。

Unused = 0x0013
THUMB_BRANCH24 = 0x0014

使用指向 2 字节对齐目标的 25 位相对位移修正指令。 位移的最低有效位为零,不予存储。此重定位对应 Thumb-2 B 指令。

THUMB_BLX23 = 0x0015

使用指向 4 字节对齐目标的 25 位相对位移修正指令。 位移的低 2 位为零,不予存储。 此重定位对应 Thumb-2 BLX 指令。

PAIR = 0x0016

仅当紧跟 ARM_REFHI 或 THUMB_REFHI 之后时,此重定位有效。 其 SymbolTableIndex 包含位移,而非符号表索引。

_

std.coff.IMAGE.REL.ARM64

容器

第 1649 行

ARM64 处理器 为 ARM64 处理器定义了以下重定位类型标识。

字段

ABSOLUTE = 0x0000

忽略此重定位。

ADDR32 = 0x0001

目标的 32 位 VA。

ADDR32NB = 0x0002

目标的 32 位 RVA。

BRANCH26 = 0x0003

B 和 BL 指令中到目标的 26 位相对位移。

PAGEBASE_REL21 = 0x0004

用于 ADRP 指令,表示目标的页基址。

REL21 = 0x0005

用于 ADR 指令,表示到目标的 12 位相对位移。

PAGEOFFSET_12A = 0x0006

目标的 12 位页偏移,用于移位量为零的 ADD/ADDS(立即数)指令。

PAGEOFFSET_12L = 0x0007

用于 LDR(索引寻址、无符号立即数)指令,表示目标的 12 位页内偏移量。

SECREL = 0x0008

目标相对于其节开头的 32 位偏移量。 用于支持调试信息和静态线程局部存储。

SECREL_LOW12A = 0x0009

用于移位量为零的 ADD/ADDS(立即数)指令:目标节内偏移量的第 0:11 位。

SECREL_HIGH12A = 0x000A

用于移位为零的 ADD/ADDS(立即数)指令,表示目标节内偏移量的第 12:23 位。

SECREL_LOW12L = 0x000B

用于 LDR(索引寻址、无符号立即数)指令:目标节内偏移量的第 0:11 位。

TOKEN = 0x000C

CLR 令牌。

SECTION = 0x000D

包含目标的节的 16 位节索引。 用于支持调试信息。

ADDR64 = 0x000E

重定位目标的 64 位 VA。

BRANCH19 = 0x000F

用于条件 B 指令,表示指向重定位目标的 19 位偏移量。

BRANCH14 = 0x0010

指向重定位目标的 14 位偏移,用于 TBZ 和 TBNZ 指令。

REL32 = 0x0011

相对于重定位位置之后的字节的 32 位相对地址。

_

std.coff.IMAGE.REL.I386

容器

第 1806 行

Intel 386 处理器 为 Intel 386 及兼容处理器定义以下重定位类型指示符。

字段

ABSOLUTE = 0x0000

忽略此重定位。

DIR16 = 0x0001

不支持。

REL16 = 0x0002

不支持。

DIR32 = 0x0006

目标的 32 位 VA。

DIR32NB = 0x0007

目标的 32 位 RVA。

SEG12 = 0x0009

不支持。

SECTION = 0x000A

包含目标的节的 16 位节索引。 用于支持调试信息。

SECREL = 0x000B

目标相对于其节开头的 32 位偏移量。 用于支持调试信息和静态线程局部存储。

TOKEN = 0x000C

CLR 令牌。

SECREL7 = 0x000D

相对于包含目标的节的基址的 7 位偏移量。

REL32 = 0x0014

指向目标的 32 位相对位移。 支持 x86 的相对分支和调用指令。

_

std.coff.IMAGE.REL.IA64

容器

第 1838 行

Intel Itanium 处理器系列(IPF)。 以下重定位类型指示符适用于 Intel Itanium 系列及兼容处理器。 注意,指令重定位使用指令束的偏移量与槽位编号作为重定位偏移量。

字段

ABSOLUTE = 0x0000

忽略此重定位。

IMM14 = 0x0001

指令重定位后可跟随一条 ADDEND 重定位,其值会先加到目标地址,然后再插入 IMM14 组合中的指定槽位。 重定位目标必须是绝对地址,或者映像必须固定。

IMM22 = 0x0002

指令重定位之后可以跟随 ADDEND 重定位,其值在目标地址插入 IMM22 指令束的指定槽位之前加到目标地址上。 重定位目标必须为绝对地址,或映像必须固定。

IMM64 = 0x0003

此重定位的槽位编号必须为一(1)。 其后可跟随 ADDEND 重定位,将其值加到目标地址后,再将该地址存入 IMM64 指令束的全部三个槽位。

DIR32 = 0x0004

目标的 32 位 VA。 仅 /LARGEADDRESSAWARE:NO 映像支持此项。

DIR64 = 0x0005

目标的 64 位 VA。

PCREL21B = 0x0006

使用指向 16 位对齐目标的 25 位相对位移修正指令。 位移的低 4 位为零,不予存储。

PCREL21M = 0x0007

使用指向 16 位对齐目标的 25 位相对位移修补指令。 位移的低 4 位为零,不予存储(原文如此)。

PCREL21F = 0x0008

此重定位偏移量的最低若干位必须包含槽位编号,其余位为指令束地址。 使用指向 16 位对齐目标的 25 位相对位移修正指令束。 位移的低 4 位为零,不予存储。

GPREL22 = 0x0009

此指令重定位后可跟随 ADDEND 重定位,将其值加到目标地址后,计算 22 位 GP 相对偏移,并将其应用于 GPREL22 指令束。

LTOFF22 = 0x000A

使用目标符号的字面量表条目的 22 位 GP 相对偏移修正指令。 链接器根据此重定位及其后可能存在的 ADDEND 重定位创建该字面量表条目。

SECTION = 0x000B

包含目标的节的 16 位节索引。 用于支持调试信息。

SECREL22 = 0x000C

使用目标相对于其所在节起始位置的 22 位偏移量修补该指令。 此重定位之后可以立即跟随 ADDEND 重定位,其 Value 字段包含目标相对于节起始位置的 32 位无符号偏移量。

SECREL64I = 0x000D

此重定位的槽位编号必须为一,即 1。 使用目标相对于其所在节起始位置的 64 位偏移量修补该指令。 此重定位之后可以立即跟随 ADDEND 重定位,其 Value 字段包含目标相对于节起始位置的 32 位无符号偏移量。

SECREL32 = 0x000E

待修正数据的地址,修正值为目标相对于其所在节起点的 32 位偏移。

DIR32NB = 0x0010

目标的 32 位 RVA。

SREL14 = 0x0011

应用于包含两个可重定位目标之差的有符号 14 位立即数。 这是向链接器提供的声明性字段,表示编译器已经生成此值。

SREL22 = 0x0012

应用于包含两个可重定位目标之差的有符号 22 位立即数。 这是供链接器使用的声明性字段,表示编译器已输出此值。

SREL32 = 0x0013

应用于包含两个可重定位值之差的有符号 32 位立即数。 这是供链接器使用的声明性字段,表示编译器已输出此值。

UREL32 = 0x0014

应用于包含两个可重定位值之差的无符号 32 位立即数。 这是向链接器提供的声明性字段,表示编译器已经生成此值。

PCREL60X = 0x0015

60 位 PC 相对修正,始终保持为 MLX 指令束中的 BRL 指令。

PCREL60B = 0x0016

60 位程序计数器相对修正。 若目标位移可放入有符号 25 位字段,则将整个指令束转换为 MBB 指令束:槽位 1 为 NOP.B,槽位 2 为 25 位 BR 指令,其最低 4 位全零且不存储。

PCREL60F = 0x0017

60 位 PC 相对修正项。 若目标位移能放入有符号 25 位字段,则将整个组合转换为 MFB 组合:槽位 1 放置 NOP.F,槽位 2 放置 25 位 BR 指令(最低 4 位均为零并被舍弃)。

PCREL60I = 0x0018

60 位相对于程序计数器的修补。 如果目标位移可容纳于有符号 25 位字段,则将整个指令束转为 MIB 束:槽位 1 为 NOP.I,槽位 2 为 25 位 BR 指令,最低 4 位全为零,不予存储。

PCREL60M = 0x0019

60 位程序计数器相对修正。 若目标位移可放入有符号 25 位字段,则将整个指令束转换为 MMB 指令束:槽位 1 为 NOP.M,槽位 2 为 25 位 BR 指令,其最低 4 位全零且不存储。

IMMGPREL64 = 0x001a

相对于 GP 的 64 位修正。

TOKEN = 0x001b

CLR 标记。

GPREL32 = 0x001c

32 位 GP 相对修正项。

ADDEND = 0x001F

此重定位仅在紧随以下重定位之一时有效:IMM14、IMM22、IMM64、GPREL22、LTOFF22、LTOFF64、SECREL22、SECREL64I 或 SECREL32。 其值包含应用于指令束内指令的加数,不用于数据。

_

std.coff.IMAGE.REL.M32R

容器

第 1969 行

Mitsubishi M32R 以下重定位类型标识符为 Mitsubishi M32R 处理器定义。

字段

ABSOLUTE = 0x0000

忽略此重定位。

ADDR32 = 0x0001

目标的 32 位 VA。

ADDR32NB = 0x0002

目标的 32 位 RVA。

ADDR24 = 0x0003

目标的 24 位 VA。

GPREL16 = 0x0004

目标相对于 GP 寄存器的 16 位偏移量。

PCREL24 = 0x0005

目标相对于程序计数器(PC)的 24 位偏移量,左移 2 位并进行符号扩展。

PCREL16 = 0x0006

目标相对于 PC 的 16 位偏移量,左移 2 位并进行符号扩展。

PCREL8 = 0x0007

目标相对于 PC 的 8 位偏移量,左移 2 位并进行符号扩展。

REFHALF = 0x0008

目标虚拟地址的最高 16 位。

REFHI = 0x0009

目标虚拟地址的最高 16 位,已按低位的符号扩展进行调整。 用于加载完整 32 位地址的双指令序列中的第一条指令。 此重定位后必须紧跟 PAIR 重定位,其 SymbolTableIndex 包含有符号 16 位位移,与待重定位位置取出的高 16 位相加。

REFLO = 0x000A

目标 VA 的最低 16 位。

PAIR = 0x000B

此重定位必须位于 REFHI 重定位之后。 其 SymbolTableIndex 包含位移,而非符号表索引。

SECTION = 0x000C

包含目标的节的 16 位节索引。 用于支持调试信息。

SECREL = 0x000D

目标相对于其节开头的 32 位偏移量。 用于支持调试信息和静态线程局部存储。

TOKEN = 0x000E

CLR 令牌。

_

std.coff.IMAGE.REL.MIPS

容器

第 1924 行

MIPS 处理器 以下重定位类型标识符为 MIPS 处理器定义。

字段

ABSOLUTE = 0x0000

忽略此重定位。

REFHALF = 0x0001

目标 32 位 VA 的高 16 位。

REFWORD = 0x0002

目标的 32 位 VA。

JMPADDR = 0x0003

目标虚拟地址的低 26 位。 支持 MIPS J 和 JAL 指令。

REFHI = 0x0004

目标的 32 位虚拟地址的高 16 位。 用于加载完整地址的两条指令序列中的第一条指令。 此重定位之后必须立即跟随 PAIR 重定位,其 SymbolTableIndex 包含有符号 16 位位移,将其加到从被重定位位置取得的高 16 位上。

REFLO = 0x0005

目标 VA 的低 16 位。

GPREL = 0x0006

目标相对于 GP 寄存器的 16 位有符号位移。

LITERAL = 0x0007

与 IMAGE_REL_MIPS_GPREL 相同。

SECTION = 0x000A

包含目标的节的 16 位节索引。 用于支持调试信息。

SECREL = 0x000B

目标相对于其节开头的 32 位偏移量。 用于支持调试信息和静态线程局部存储。

SECRELLO = 0x000C

目标相对于其节起点的 32 位偏移量的低 16 位。

SECRELHI = 0x000D

目标相对于所在节起始位置的 32 位偏移量的高 16 位。 其后必须紧跟 IMAGE_REL_MIPS_PAIR 重定位。 PAIR 重定位的 SymbolTableIndex 包含有符号 16 位位移,将加到从被重定位位置取得的高 16 位上。

JMPADDR16 = 0x0010

目标虚拟地址的低 26 位。 支持 MIPS16 JAL 指令。

REFWORDNB = 0x0022

目标的 32 位 RVA。

PAIR = 0x0025

仅当紧跟 REFHI 或 SECRELHI 重定位之后时,此重定位有效。 其 SymbolTableIndex 包含位移,而非符号表索引。

_

std.coff.IMAGE.REL.PPC

容器

第 1756 行

IBM PowerPC 处理器 以下重定位类型标识符为 PowerPC 处理器定义。

字段

ABSOLUTE = 0x0000

忽略此重定位。

ADDR64 = 0x0001

目标的 64 位 VA。

ADDR32 = 0x0002

目标的 32 位 VA。

ADDR24 = 0x0003

目标虚拟地址的低 24 位。 仅当目标符号为绝对符号且可通过符号扩展恢复原值时有效。

ADDR16 = 0x0004

目标 VA 的低 16 位。

ADDR14 = 0x0005

目标虚拟地址的低 14 位。 仅当目标符号为绝对符号且可通过符号扩展恢复原值时有效。

REL24 = 0x0006

指向符号位置的 24 位 PC 相对偏移量。

REL14 = 0x0007

相对于 PC、指向符号位置的 14 位偏移。

ADDR32NB = 0x000A

目标的 32 位 RVA。

SECREL = 0x000B

目标相对于其节开头的 32 位偏移量。 用于支持调试信息和静态线程局部存储。

SECTION = 0x000C

包含目标的节的 16 位节索引。 用于支持调试信息。

SECREL16 = 0x000F

目标相对于其所在节开头的 16 位偏移。 用于支持调试信息和静态线程局部存储。

REFHI = 0x0010

目标 32 位虚拟地址的高 16 位。 用于以两条指令加载完整地址的序列中的第一条指令。 此重定位之后必须紧跟 PAIR 重定位,其 SymbolTableIndex 包含有符号 16 位位移,将加到从被重定位位置取得的高 16 位上。

REFLO = 0x0011

目标 VA 的低 16 位。

PAIR = 0x0012

仅当紧随 REFHI 或 SECRELHI 重定位时才有效的重定位。 其 SymbolTableIndex 包含位移,而非符号表索引。

SECRELLO = 0x0013

目标相对于其节起点的 32 位偏移量的低 16 位。

GPREL = 0x0015

目标相对于 GP 寄存器的 16 位有符号位移。

TOKEN = 0x0016

CLR 令牌。

_

std.coff.IMAGE.REL.SH

容器

第 1694 行

Hitachi SuperH 处理器。 以下重定位类型标识符针对 SH3 和 SH4 处理器定义。 SH5 专属重定位标记为 SHM(SH Media)。

字段

@"3_ABSOLUTE" = 0x0000

忽略此重定位。

@"3_DIRECT16" = 0x0001

对包含目标符号虚拟地址的 16 位位置的引用。

@"3_DIRECT32" = 0x0002

目标符号的 32 位虚拟地址。

@"3_DIRECT8" = 0x0003

对包含目标符号虚拟地址的 8 位位置的引用。

@"3_DIRECT8_WORD" = 0x0004

对某条 8 位指令的引用,该指令包含目标符号的有效 16 位虚拟地址。

@"3_DIRECT8_LONG" = 0x0005

指向某个 8 位指令的引用,该指令包含目标符号的有效 32 位虚拟地址。

@"3_DIRECT4" = 0x0006

对某个 8 位位置的引用,其低 4 位包含目标符号的虚拟地址。

@"3_DIRECT4_WORD" = 0x0007

对 8 位指令的引用,其低 4 位包含目标符号的有效 16 位虚拟地址。

@"3_DIRECT4_LONG" = 0x0008

指向某个 8 位指令的引用,其低 4 位包含目标符号的有效 32 位虚拟地址。

@"3_PCREL8_WORD" = 0x0009

指向某个 8 位指令的引用,该指令包含目标符号的有效 16 位相对偏移。

@"3_PCREL8_LONG" = 0x000A

对包含目标符号有效 32 位相对偏移量的 8 位指令的引用。

@"3_PCREL12_WORD" = 0x000B

指向某个 16 位指令的引用,其低 12 位包含目标符号的有效 16 位相对偏移。

@"3_STARTOF_SECTION" = 0x000C

指向某个 32 位位置的引用,该位置是包含目标符号的节的虚拟地址。

@"3_SIZEOF_SECTION" = 0x000D

对一个 32 位位置的引用,该位置存放包含目标符号的节的大小。

@"3_SECTION" = 0x000E

包含目标的节的 16 位节索引。 用于支持调试信息。

@"3_SECREL" = 0x000F

目标相对于其节开头的 32 位偏移量。 用于支持调试信息和静态线程局部存储。

@"3_DIRECT32_NB" = 0x0010

目标符号的 32 位 RVA。

@"3_GPREL4_LONG" = 0x0011

GP 相对值。

@"3_TOKEN" = 0x0012

CLR 令牌。

M_PCRELPT = 0x0013

距当前指令的偏移,以长字为单位。 若未设置 NOMODE 位,将低位的反值插入位 32,以选择 PTA 或 PTB。

M_REFLO = 0x0014

32 位地址的低 16 位。

M_REFHALF = 0x0015

32 位地址的高 16 位。

M_RELLO = 0x0016

相对地址的低 16 位。

M_RELHALF = 0x0017

相对地址的高 16 位。

M_PAIR = 0x0018

此重定位仅在紧随 REFHALF、RELHALF 或 RELLO 重定位时有效。 其 SymbolTableIndex 字段包含位移,而非符号表索引。

M_NOMODE = 0x8000

重定位忽略节模式。

_

std.coff.ImageDataDirectory

容器

第 258 行

字段

virtual_address: u32
size: u32

std.coff.ImportDirectoryEntry

容器

第 406 行

字段

import_lookup_table_rva: u32

导入查找表的相对虚拟地址。 此表为每个导入项存储名称或序号。 Winnt.h 使用“Characteristics”这个名称,但它已无法准确描述此字段。

time_date_stamp: u32

映像绑定前,此时间戳为零。 映像绑定后,此字段设为 DLL 的时间/日期戳。

forwarder_chain: u32

首个转发引用的索引。

name_rva: u32

包含 DLL 名称的 ASCII 字符串地址。 此地址相对于映像基址。

import_address_table_rva: u32

导入地址表的相对虚拟地址。 在映像绑定之前,此表内容与导入查找表内容相同。

std.coff.ImportHeader

容器

第 1356 行

字段

sig1: IMAGE.FILE.MACHINE = .UNKNOWN

必须为 IMAGE_FILE_MACHINE_UNKNOWN

sig2: u16 = 0xFFFF

必须为 0xFFFF

version: u16
machine: IMAGE.FILE.MACHINE
time_date_stamp: u32
size_of_data: u32
hint: u16
types: packed struct(u16) {
    type: ImportType,
    name_type: ImportNameType,
    reserved: u11,
}

std.coff.ImportHintNameEntry

容器

第 453 行

每个名称以 NULL 字节结尾。若 NULL 字节不在 2 字节边界上,则填充条目结构以确保 2 字节对齐。

字段

hint: u16

导出名称指针表中的索引。 先尝试使用此值匹配。若失败,则在 DLL 的导出名称指针表中进行二分查找。

name: [1]u8

指向以 NULL 结尾的 ASCII 名称的指针。 长度可变……

std.coff.ImportLookupTableEntry

类型函数

第 428 行

pub fn ImportLookupTableEntry(comptime magic: std.coff.OptionalHeader.Magic) type

参数

std.coff.ImportNameType

容器

第 1383 行

字段

ORDINAL = 0

导入按序号指定。这表示导入标头的 Ordinal/Hint 字段值是导入序号。如果未指定此常量, 则应始终将 Ordinal/Hint 字段解释为导入提示。

NAME = 1

导入名称与公开符号名称相同。

NAME_NOPREFIX = 2

导入名称为公开符号名称,但跳过前导 ?、@ 或可选的 _。

NAME_UNDECORATE = 3

导入名称为公开符号名称,但省略开头的 ?、@ 或可选的 _,并在首个 @ 处截断。

NAME_EXPORTAS = 4
_

std.coff.ImportType

容器

第 1373 行

字段

CODE = 0

可执行代码。

DATA = 1

数据。

CONST = 2

在 .def 文件中指定为 CONST。

_

std.coff.LineNumber

容器

第 2095 行

字段

type: extern union {
    symbol_table_index: u32,
    virtual_address: u32,
}
line_number: u16

std.coff.LineNumber.sizeOf

函数

第 2102 行

pub fn sizeOf() comptime_int

std.coff.mem

别名

第 3 行

别名目标 std.mem

std.coff.OptionalHeader

容器

第 188 行

字段

magic: OptionalHeader.Magic
major_linker_version: u8
minor_linker_version: u8
size_of_code: u32
size_of_initialized_data: u32
size_of_uninitialized_data: u32
address_of_entry_point: u32
base_of_code: u32

std.coff.OptionalHeader.@"PE32+"

容器

第 230 行

字段

standard: OptionalHeader
image_base: u64
section_alignment: u32
file_alignment: u32
major_operating_system_version: u16
minor_operating_system_version: u16
major_image_version: u16
minor_image_version: u16
major_subsystem_version: u16
minor_subsystem_version: u16
win32_version_value: u32
size_of_image: u32
size_of_headers: u32
checksum: u32
subsystem: Subsystem
dll_flags: DllFlags
size_of_stack_reserve: u64
size_of_stack_commit: u64
size_of_heap_reserve: u64
size_of_heap_commit: u64
loader_flags: u32
number_of_rva_and_sizes: u32

std.coff.OptionalHeader.Magic

容器

第 198 行

字段

PE32 = 0x10b
@"PE32+" = 0x20b
_

std.coff.OptionalHeader.PE32

容器

第 204 行

字段

standard: OptionalHeader
base_of_data: u32
image_base: u32
section_alignment: u32
file_alignment: u32
major_operating_system_version: u16
minor_operating_system_version: u16
major_image_version: u16
minor_image_version: u16
major_subsystem_version: u16
minor_subsystem_version: u16
win32_version_value: u32
size_of_image: u32
size_of_headers: u32
checksum: u32
subsystem: Subsystem
dll_flags: DllFlags
size_of_stack_reserve: u32
size_of_stack_commit: u32
size_of_heap_reserve: u32
size_of_heap_commit: u32
loader_flags: u32
number_of_rva_and_sizes: u32

std.coff.pe_pointer_offset

常量

第 9 行

std.coff.pe_signature

常量

第 8 行

std.coff.Relocation

容器

第 1400 行

字段

virtual_address: u32
symbol_table_index: u32
type: u16

std.coff.Relocation.sizeOf

函数

第 1405 行

pub fn sizeOf() comptime_int

std.coff.SectionDefinition

容器

第 900 行

字段

length: u32

节数据的大小,与节头中的 SizeOfRawData 相同。

number_of_relocations: u16

该节的重定位条目数量。

number_of_linenumbers: u16

该节的行号条目数量。

checksum: u32

公共数据的校验和。节头中设置 IMAGE_SCN_LNK_COMDAT 标志时适用。

number: u16

关联节在节表中的从 1 开始的索引。在 COMDAT 选择设置为 5 时使用。

selection: ComdatSelection

COMDAT 选择编号。仅当该节为 COMDAT 节时适用。

unused: [3]u8

std.coff.SectionHeader

容器

第 507 行

字段

name: [8]u8
virtual_size: u32
virtual_address: u32
size_of_raw_data: u32
pointer_to_raw_data: u32
pointer_to_relocations: u32
pointer_to_linenumbers: u32
number_of_relocations: u16
number_of_linenumbers: u16
flags: SectionHeader.Flags

std.coff.SectionHeader.Flags

容器

第 549 行

字段

SCALE_INDEX: bool = false
unused1: u2 = 0
TYPE_NO_PAD: bool = false

不应将节填充到下一个边界。 此标志已废弃,由 .ALIGN = .@"1BYTES" 替代。 仅对目标文件有效。

unused4: u1 = 0
CNT_CODE: bool = false

此节包含可执行代码。

CNT_INITIALIZED_DATA: bool = false

此节包含已初始化的数据。

CNT_UNINITIALIZED_DATA: bool = false

此节包含未初始化数据。

LNK_OTHER: bool = false

预留供未来使用。

LNK_INFO: bool = false

此节包含注释或其他信息。 .drectve 节属于此类型。 仅对目标文件有效。

unused10: u1 = 0
LNK_REMOVE: bool = false

此节不会成为映像的一部分。 仅对目标文件有效。

LNK_COMDAT: bool = false

此节包含 COMDAT 数据。 更多信息见 COMDAT Sections (Object Only)。 仅对目标文件有效。

unused13: u2 = 0
union14: packed union {
    mask: u1,
    /// 此节包含通过全局指针 (GP) 引用的数据。
    GPREL: bool,
    MEM_FARDATA: bool,
} = .{ .mask = 0 }
unused15: u1 = 0
union16: packed union {
    mask: u1,
    MEM_PURGEABLE: bool,
    MEM_16BIT: bool,
} = .{ .mask = 0 }
MEM_LOCKED: bool = false

预留供未来使用。

MEM_PRELOAD: bool = false

预留供未来使用。

ALIGN: SectionHeader.Flags.Align = .NONE
LNK_NRELOC_OVFL: bool = false

此节包含扩展重定位。

MEM_DISCARDABLE: bool = false

可按需丢弃此节。

MEM_NOT_CACHED: bool = false

此节不可缓存。

MEM_NOT_PAGED: bool = false

此节不可分页。

MEM_SHARED: bool = false

此节可在内存中共享。

MEM_EXECUTE: bool = false

此节可作为代码执行。

MEM_READ: bool = false

此节可读。

MEM_WRITE: bool = false

此节可写。

std.coff.SectionHeader.Flags.Align

容器

第 638 行

字段

NONE = 0
@"1BYTES" = 1
@"2BYTES" = 2
@"4BYTES" = 3
@"8BYTES" = 4
@"16BYTES" = 5
@"32BYTES" = 6
@"64BYTES" = 7
@"128BYTES" = 8
@"256BYTES" = 9
@"512BYTES" = 10
@"1024BYTES" = 11
@"2048BYTES" = 12
@"4096BYTES" = 13
@"8192BYTES" = 14
_

std.coff.SectionHeader.Flags.Align.alignment

函数

第 666 行

pub fn alignment(a: Align) ?std.mem.Alignment

参数

a: Align

std.coff.SectionHeader.Flags.Align.fromByteUnits

函数

第 661 行

pub fn fromByteUnits(n: u16) Align

参数

n: u16

std.coff.SectionHeader.Flags.Align.toByteUnits

函数

第 656 行

pub fn toByteUnits(a: Align) ?u16

参数

a: Align

std.coff.SectionHeader.getAlignment

函数

第 533 行

仅适用于 COFF 对象中的节头。

pub fn getAlignment(self: SectionHeader) ?u16

参数

std.coff.SectionHeader.getName

函数

第 519 行

pub fn getName(self: *align(1) const SectionHeader) ?[]const u8

参数

self: *align(1) const SectionHeader

std.coff.SectionHeader.getNameOffset

函数

第 525 行

pub fn getNameOffset(self: SectionHeader) ?u32

参数

std.coff.SectionHeader.isCode

函数

第 541 行

pub fn isCode(self: SectionHeader) bool

参数

std.coff.SectionHeader.isComdat

函数

第 545 行

pub fn isComdat(self: SectionHeader) bool

参数

std.coff.SectionHeader.setAlignment

函数

第 537 行

pub fn setAlignment(self: *SectionHeader, new_alignment: u16) void

参数

self: *SectionHeader
new_alignment: u16

std.coff.SectionNumber

容器

第 698 行

字段

UNDEFINED = 0

此符号记录尚未分配节。 值为零表示引用的是在其他位置定义的外部符号。 非零值表示公共符号,其大小由该值指定。

ABSOLUTE = -1

符号具有绝对值(不可重定位),且不是地址。

DEBUG = -2

此符号提供一般类型或调试信息,但不对应某个节。 微软工具将此设置与 .file 记录(存储类 FILE)配合使用。

_

std.coff.std

别名

第 1 行

别名目标 std

std.coff.StorageClass

容器

第 786 行

字段

END_OF_FUNCTION = 0xff

用于调试、表示函数结束的特殊符号。

NULL = 0

未指定存储类。

AUTOMATIC = 1

自动(栈)变量。Value 字段指定栈帧偏移量。

EXTERNAL = 2

微软工具将此值用于外部符号。 当节编号为 IMAGE_SYM_UNDEFINED(0)时,Value 字段表示大小。 如果节编号不为零,则 Value 字段指定节内偏移量。

STATIC = 3

符号在节中的偏移。 若 Value 字段为零,则该符号表示节名。

REGISTER = 4

寄存器变量。 Value 字段指定寄存器编号。

EXTERNAL_DEF = 5

外部定义的符号。

LABEL = 6

模块内部定义的代码标签。 Value 字段指定符号在节内的偏移。

UNDEFINED_LABEL = 7

对未定义代码标签的引用。

MEMBER_OF_STRUCT = 8

结构体成员。Value 字段指定第 n 个成员。

ARGUMENT = 9

函数的形式参数。Value 字段指定第 n 个参数。

STRUCT_TAG = 10

结构体标签名条目。

MEMBER_OF_UNION = 11

联合体成员。Value 字段指定第 n 个成员。

UNION_TAG = 12

联合体标签名条目。

TYPE_DEFINITION = 13

Typedef 条目。

UNDEFINED_STATIC = 14

静态数据声明。

ENUM_TAG = 15

枚举类型标签名条目。

MEMBER_OF_ENUM = 16

枚举成员。Value 字段指定第 n 个成员。

REGISTER_PARAM = 17

寄存器参数。

BIT_FIELD = 18

位字段引用。Value 字段指定该位字段中的第 n 位。

BLOCK = 100

.bb(块开始)或 .eb(块结束)记录。 Value 字段是代码位置的可重定位地址。

FUNCTION = 101

微软工具将此值用于定义函数范围的符号记录:函数开始(.bf)、函数结束(.ef)和函数中的行(.lf)。 对于 .lf 记录,Value 字段给出函数中的源码行数。 对于 .ef 记录,Value 字段给出函数代码的大小。

END_OF_STRUCT = 102

结构结束条目。

FILE = 103

Microsoft 工具及传统 COFF 格式用于源文件符号记录的值。 该符号后跟辅助记录,给出文件名称。

SECTION = 104

节的定义(Microsoft 工具改用 STATIC 存储类)。

WEAK_EXTERNAL = 105

弱外部符号。更多信息参见辅助格式 3:弱外部符号。

CLR_TOKEN = 107

CLR 令牌符号。名称为由令牌十六进制值构成的 ASCII 字符串。 更多信息参见 CLR Token Definition (Object Only)。

_

std.coff.Strtab

容器

第 1347 行

字段

buffer: []const u8

std.coff.Strtab.get

函数

第 1350 行

pub fn get(self: Strtab, off: u32) []const u8

参数

self: Strtab
off: u32

std.coff.Subsystem

容器

第 142 行

字段

UNKNOWN = 0

未知子系统

NATIVE = 1

设备驱动程序和原生 Windows 进程

WINDOWS_GUI = 2

Windows 图形用户界面(GUI)子系统

WINDOWS_CUI = 3

Windows 字符子系统

OS2_CUI = 5

OS/2 字符子系统

POSIX_CUI = 7

Posix 字符子系统

NATIVE_WINDOWS = 8

原生 Win9x 驱动程序

WINDOWS_CE_GUI = 9

Windows CE

EFI_APPLICATION = 10

可扩展固件接口(EFI)应用程序。

EFI_BOOT_SERVICE_DRIVER = 11

具有启动服务的 EFI 驱动程序

EFI_RUNTIME_DRIVER = 12

具有运行时服务的 EFI 驱动程序

EFI_ROM = 13

EFI ROM 映像

XBOX = 14

XBOX

WINDOWS_BOOT_APPLICATION = 16

Windows 启动应用程序

_

std.coff.Symbol

容器

第 673 行

字段

name: [8]u8
value: u32
section_number: SectionNumber
type: SymType
storage_class: StorageClass
number_of_aux_symbols: u8

std.coff.Symbol.getName

函数

第 685 行

pub fn getName(self: *const Symbol) ?[]const u8

参数

self: *const Symbol

std.coff.Symbol.getNameOffset

函数

第 691 行

pub fn getNameOffset(self: Symbol) ?u32

参数

self: Symbol

std.coff.Symbol.sizeOf

函数

第 681 行

pub fn sizeOf() comptime_int

std.coff.Symtab

容器

第 1228 行

字段

buffer: []const u8

std.coff.Symtab.asDebugInfo

函数

第 1278 行

fn asDebugInfo(raw: []const u8) DebugInfoDefinition

参数

raw: []const u8

std.coff.Symtab.asFileDef

函数

第 1306 行

fn asFileDef(raw: []const u8) FileDefinition

参数

raw: []const u8

std.coff.Symtab.asFuncDef

函数

第 1288 行

fn asFuncDef(raw: []const u8) FunctionDefinition

参数

raw: []const u8

std.coff.Symtab.asSectDef

函数

第 1312 行

fn asSectDef(raw: []const u8) SectionDefinition

参数

raw: []const u8

std.coff.Symtab.asSymbol

函数

第 1267 行

fn asSymbol(raw: []const u8) Symbol

参数

raw: []const u8

std.coff.Symtab.asWeakExtDef

函数

第 1298 行

fn asWeakExtDef(raw: []const u8) WeakExternalDefinition

参数

raw: []const u8

std.coff.Symtab.at

函数

第 1254 行

存活时间与 Symtab 实例相同。

pub fn at(self: Symtab, index: usize, tag: Tag) Record

参数

self: Symtab
index: usize
tag: Tag

std.coff.Symtab.len

函数

第 1231 行

pub fn len(self: Symtab) usize

参数

self: Symtab

std.coff.Symtab.Record

容器

第 1244 行

字段

symbol: Symbol
debug_info: DebugInfoDefinition
func_def: FunctionDefinition
weak_ext: WeakExternalDefinition
file_def: FileDefinition
sect_def: SectionDefinition

std.coff.Symtab.slice

函数

第 1339 行

pub fn slice(self: Symtab, start: usize, end: ?usize) Slice

参数

self: Symtab
start: usize
end: ?usize

std.coff.Symtab.Slice

容器

第 1324 行

字段

buffer: []const u8
num: usize
count: usize = 0

std.coff.Symtab.Slice.next

函数

第 1330 行

存活时间与 Symtab 实例相同。

pub fn next(self: *Slice) ?Symbol

参数

self: *Slice

std.coff.Symtab.Tag

容器

第 1235 行

字段

symbol
debug_info
func_def
weak_ext
file_def
sect_def

std.coff.SymType

容器

第 713 行

字段

complex_type: ComplexType
base_type: BaseType

std.coff.TlsDirectoryEntry

类型函数

第 376 行

pub fn TlsDirectoryEntry(comptime magic: std.coff.OptionalHeader.Magic) type

参数

std.coff.WeakExternalDefinition

容器

第 933 行

字段

tag_index: u32

sym2 的符号表索引;找不到 sym1 时,链接到该符号。

flag: WeakExternalFlag

IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY 表示不应为 sym1 搜索库。 IMAGE_WEAK_EXTERN_SEARCH_LIBRARY 表示应为 sym1 搜索库。 IMAGE_WEAK_EXTERN_SEARCH_ALIAS 表示 sym1 是 sym2 的别名。

unused: [10]u8

std.coff.WeakExternalDefinition.sizeOf

函数

第 944 行

pub fn sizeOf() comptime_int

std.coff.WeakExternalFlag

容器

第 950 行

字段

SEARCH_NOLIBRARY = 1
SEARCH_LIBRARY = 2
SEARCH_ALIAS = 3
ANTI_DEPENDENCY = 4
_
源码

std/coff.zig

const std = @import("std.zig");
const assert = std.debug.assert;
const mem = std.mem;

pub const archive_signature = "!<arch>\n";
pub const archive_end_of_header = "`\n";

pub const pe_signature = "PE\x00\x00";
pub const pe_pointer_offset = 0x3C;

pub const Header = extern struct {
    /// 标识目标机器类型的编号。
    machine: IMAGE.FILE.MACHINE,

    /// 节的数量。表示紧随各个头部之后的节表大小。
    number_of_sections: u16,

    /// 自 1970 年 1 月 1 日 00:00 起经过秒数的低 32 位(C 运行时的 time_t 值),表示文件创建时间。
    ///
    time_date_stamp: u32,

    /// COFF 符号表的文件偏移;若不存在 COFF 符号表,则为零。
    /// 对于映像,此值应为零,因为 COFF 调试信息已弃用。
    pointer_to_symbol_table: u32,

    /// 符号表中的条目数。
    /// 可用此数据定位紧随符号表之后的字符串表。
    /// 对于映像,此值应为零,因为 COFF 调试信息已弃用。
    number_of_symbols: u32,

    /// 可选头的大小。可执行文件必须包含可选头,目标文件则不要求。
    /// 目标文件的此值应为零。头部格式见“可选头(仅映像)”。
    size_of_optional_header: u16,

    /// 指示文件属性的标志。
    flags: Header.Flags,

    pub const Flags = packed struct(u16) {
        /// 仅用于映像,适用于 Windows CE 以及 Microsoft Windows NT 及后续版本。
        /// 表示文件不包含基址重定位,
        /// 因此必须加载到其首选基址。
        /// 若该基址不可用,加载器将报告错误。
        /// 链接器默认从可执行文件(EXE)中
        /// 移除基址重定位。
        RELOCS_STRIPPED: bool = false,

        /// 仅用于映像。表示映像文件有效且可运行。
        /// 若未设置此标志,则表示链接器错误。
        EXECUTABLE_IMAGE: bool = false,

        /// COFF 行号已移除。此标志已弃用,应为零。
        LINE_NUMS_STRIPPED: bool = false,

        /// 已移除 COFF 符号表中的局部符号条目。
        /// 此标志已弃用,应为零。
        LOCAL_SYMS_STRIPPED: bool = false,

        /// 已废弃。积极裁剪工作集。
        /// 此标志在 Windows 2000 及更高版本中已弃用,必须为零。
        AGGRESSIVE_WS_TRIM: bool = false,

        /// 应用程序可以处理大于 2 GB 的地址。
        LARGE_ADDRESS_AWARE: bool = false,

        /// 此标志保留供将来使用。
        RESERVED: bool = false,

        /// 小端:内存中最低有效位(LSB)先于最高有效位(MSB)。
        /// 此标志已弃用,应为零。
        BYTES_REVERSED_LO: bool = false,

        /// 机器基于 32 位字架构。
        @"32BIT_MACHINE": bool = false,

        /// 从映像文件中移除调试信息。
        DEBUG_STRIPPED: bool = false,

        /// 如果映像位于可移动介质上,则完整加载它并复制到交换文件。
        REMOVABLE_RUN_FROM_SWAP: bool = false,

        /// 若映像位于网络介质上,完整加载它并复制到交换文件。
        NET_RUN_FROM_SWAP: bool = false,

        /// 映像文件是系统文件,而非用户程序。
        SYSTEM: bool = false,

        /// 映像文件是动态链接库 (DLL)。
        /// 虽然无法直接运行,但这类文件在几乎所有用途中均被视为可执行文件。
        ///
        DLL: bool = false,

        /// 此文件应仅在单处理器机器上运行。
        UP_SYSTEM_ONLY: bool = false,

        /// 大端序:最高有效字节在内存中先于最低有效字节。此标志已弃用,应为零。
        BYTES_REVERSED_HI: bool = false,
    };
};

// OptionalHeader.magic 的值,参见
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms680339(v=vs.85).aspx
pub const IMAGE_NT_OPTIONAL_HDR32_MAGIC = @backingInt(OptionalHeader.Magic.PE32);
pub const IMAGE_NT_OPTIONAL_HDR64_MAGIC = @backingInt(OptionalHeader.Magic.@"PE32+");

pub const DllFlags = packed struct(u16) {
    _reserved_0: u5 = 0,

    /// 映像可以处理高熵 64 位虚拟地址空间。
    HIGH_ENTROPY_VA: bool = false,

    /// DLL 可以在加载时重定位。
    DYNAMIC_BASE: bool = false,

    /// 强制进行代码完整性检查。
    FORCE_INTEGRITY: bool = false,

    /// 映像兼容 NX。
    NX_COMPAT: bool = false,

    /// 遵循隔离规则,但不隔离映像。
    NO_ISOLATION: bool = false,

    /// 不使用结构化异常(SE)处理。此映像中不得调用任何 SE 处理程序。
    NO_SEH: bool = false,

    /// 不要绑定映像。
    NO_BIND: bool = false,

    /// 映像必须在 AppContainer 中执行。
    APPCONTAINER: bool = false,

    /// WDM 驱动程序。
    WDM_DRIVER: bool = false,

    /// 映像支持控制流防护(CFG)。
    GUARD_CF: bool = false,

    /// 支持终端服务器。
    TERMINAL_SERVER_AWARE: bool = false,
};

pub const Subsystem = enum(u16) {
    /// 未知子系统
    UNKNOWN = 0,

    /// 设备驱动程序和原生 Windows 进程
    NATIVE = 1,

    /// Windows 图形用户界面(GUI)子系统
    WINDOWS_GUI = 2,

    /// Windows 字符子系统
    WINDOWS_CUI = 3,

    /// OS/2 字符子系统
    OS2_CUI = 5,

    /// Posix 字符子系统
    POSIX_CUI = 7,

    /// 原生 Win9x 驱动程序
    NATIVE_WINDOWS = 8,

    /// Windows CE
    WINDOWS_CE_GUI = 9,

    /// 可扩展固件接口(EFI)应用程序。
    EFI_APPLICATION = 10,

    /// 具有启动服务的 EFI 驱动程序
    EFI_BOOT_SERVICE_DRIVER = 11,

    /// 具有运行时服务的 EFI 驱动程序
    EFI_RUNTIME_DRIVER = 12,

    /// EFI ROM 映像
    EFI_ROM = 13,

    /// XBOX
    XBOX = 14,

    /// Windows 启动应用程序
    WINDOWS_BOOT_APPLICATION = 16,

    _,
};

pub const OptionalHeader = extern struct {
    magic: OptionalHeader.Magic,
    major_linker_version: u8,
    minor_linker_version: u8,
    size_of_code: u32,
    size_of_initialized_data: u32,
    size_of_uninitialized_data: u32,
    address_of_entry_point: u32,
    base_of_code: u32,

    pub const Magic = enum(u16) {
        PE32 = 0x10b,
        @"PE32+" = 0x20b,
        _,
    };

    pub const PE32 = extern struct {
        standard: OptionalHeader,
        base_of_data: u32,
        image_base: u32,
        section_alignment: u32,
        file_alignment: u32,
        major_operating_system_version: u16,
        minor_operating_system_version: u16,
        major_image_version: u16,
        minor_image_version: u16,
        major_subsystem_version: u16,
        minor_subsystem_version: u16,
        win32_version_value: u32,
        size_of_image: u32,
        size_of_headers: u32,
        checksum: u32,
        subsystem: Subsystem,
        dll_flags: DllFlags,
        size_of_stack_reserve: u32,
        size_of_stack_commit: u32,
        size_of_heap_reserve: u32,
        size_of_heap_commit: u32,
        loader_flags: u32,
        number_of_rva_and_sizes: u32,
    };

    pub const @"PE32+" = extern struct {
        standard: OptionalHeader,
        image_base: u64,
        section_alignment: u32,
        file_alignment: u32,
        major_operating_system_version: u16,
        minor_operating_system_version: u16,
        major_image_version: u16,
        minor_image_version: u16,
        major_subsystem_version: u16,
        minor_subsystem_version: u16,
        win32_version_value: u32,
        size_of_image: u32,
        size_of_headers: u32,
        checksum: u32,
        subsystem: Subsystem,
        dll_flags: DllFlags,
        size_of_stack_reserve: u64,
        size_of_stack_commit: u64,
        size_of_heap_reserve: u64,
        size_of_heap_commit: u64,
        loader_flags: u32,
        number_of_rva_and_sizes: u32,
    };
};

pub const IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;

pub const ImageDataDirectory = extern struct {
    virtual_address: u32,
    size: u32,
};

pub const BaseRelocationDirectoryEntry = extern struct {
    /// 将映像基址加上页 RVA,再加上各偏移,得到必须应用基址重定位的虚拟地址。
    page_rva: u32,

    /// 基址重定位块的总字节数,包括 Page RVA、Block Size 字段及后续 Type/Offset 字段。
    block_size: u32,
};

pub const BaseRelocation = packed struct(u16) {
    /// 存储于 WORD 剩余的 12 位中,是相对于此块的 Page RVA 字段指定起始地址的偏移量。
    /// 此偏移量指定应用基址重定位的位置。
    offset: u12,

    /// 存储在 WORD 的高 4 位中,表示应应用的基址重定位类型。
    type: BaseRelocationType,
};

pub const BaseRelocationType = enum(u4) {
    /// 跳过基址重定位。此类型可用于填充块。
    ABSOLUTE = 0,

    /// 基址重定位将差值的高 16 位加到偏移处的 16 位字段上。该 16 位字段表示一个 32 位字的高位部分。
    HIGH = 1,

    /// 基址重定位将差值的低 16 位加到偏移处的 16 位字段上。该 16 位字段表示一个 32 位字的低半部分。
    LOW = 2,

    /// 基址重定位将差值的全部 32 位应用于偏移处的 32 位字段。
    HIGHLOW = 3,

    /// 基址重定位将差值的高 16 位加到指定偏移量处的 16 位字段。
    /// 该 16 位字段表示一个 32 位字的高半部分。
    /// 32 位值的低 16 位存储在此基址重定位之后的 16 位字中。
    /// 这意味着该基址重定位占用两个槽位。
    HIGHADJ = 4,

    /// 机器类型为 MIPS 时,基址重定位应用于 MIPS 跳转指令。
    MIPS_JMPADDR = 5,

    /// 此重定位仅在机器类型为 ARM 或 Thumb 时有意义。
    /// 基址重定位将符号的 32 位地址应用于一对连续的 MOVW/MOVT 指令。
    // ARM_MOV32 = 5,

    /// 此重定位仅在机器类型为 RISC-V 时有意义。
    /// 基址重定位应用于 32 位绝对地址的高 20 位。
    // RISCV_HIGH20 = 5,

    /// 保留,必须为零。
    RESERVED = 6,

    /// 此重定位仅在机器类型为 Thumb 时有意义。
    /// 基址重定位将符号的 32 位地址应用于一对连续的 MOVW/MOVT 指令。
    THUMB_MOV32 = 7,

    /// 此重定位仅在机器类型为 RISC-V 时有意义。
    /// 基址重定位作用于按 RISC-V I 型指令格式构成的 32 位绝对地址的低 12 位。
    // RISCV_LOW12I = 7,

    /// 此重定位仅在机器类型为 RISC-V 时有意义。
    /// 基址重定位应用于以 RISC-V S 型指令格式构成的 32 位绝对地址的低 12 位。
    RISCV_LOW12S = 8,

    /// 此重定位仅在机器类型为 32 位 LoongArch 时有意义。
    /// 基址重定位应用于连续两条指令构成的 32 位绝对地址。
    // LOONGARCH32_MARK_LA = 8,

    /// 此重定位仅在机器类型为 LoongArch 64 位时有意义。
    /// 基址重定位作用于由四条连续指令构成的 64 位绝对地址。
    // LOONGARCH64_MARK_LA = 8,

    /// 此重定位仅在机器类型为 MIPS 时有意义。
    /// 基址重定位应用于 MIPS16 跳转指令。
    MIPS_JMPADDR16 = 9,

    /// 基址重定位将差值应用于偏移处的 64 位字段。
    DIR64 = 10,

    _,
};

pub const DebugDirectoryEntry = extern struct {
    characteristics: u32,
    time_date_stamp: u32,
    major_version: u16,
    minor_version: u16,
    type: DebugType,
    size_of_data: u32,
    address_of_raw_data: u32,
    pointer_to_raw_data: u32,
};

pub const DebugType = enum(u32) {
    UNKNOWN = 0,
    COFF = 1,
    CODEVIEW = 2,
    FPO = 3,
    MISC = 4,
    EXCEPTION = 5,
    FIXUP = 6,
    OMAP_TO_SRC = 7,
    OMAP_FROM_SRC = 8,
    BORLAND = 9,
    RESERVED10 = 10,
    VC_FEATURE = 12,
    POGO = 13,
    ILTCG = 14,
    MPX = 15,
    REPRO = 16,
    EX_DLLCHARACTERISTICS = 20,

    _,
};

pub fn TlsDirectoryEntry(comptime magic: std.coff.OptionalHeader.Magic) type {
    return switch (magic) {
        _ => comptime unreachable,
        .PE32 => extern struct {
            raw_data_start_va: u32,
            raw_data_end_va: u32,
            tls_index_va: u32,
            callbacks_va: u32,
            size_of_zero_fill: u32,
            characteristics: packed struct(u32) {
                _reserved_0: u19,
                alignment: SectionHeader.Flags.Align,
                _reserved_1: u9,
            },
        },
        .@"PE32+" => extern struct {
            raw_data_start_va: u64,
            raw_data_end_va: u64,
            tls_index_va: u64,
            callbacks_va: u64,
            size_of_zero_fill: u32,
            characteristics: packed struct(u32) {
                _reserved_0: u19,
                alignment: SectionHeader.Flags.Align,
                _reserved_1: u9,
            },
        },
    };
}

pub const ImportDirectoryEntry = extern struct {
    /// 导入查找表的相对虚拟地址。
    /// 此表为每个导入项存储名称或序号。
    /// Winnt.h 使用“Characteristics”这个名称,但它已无法准确描述此字段。
    import_lookup_table_rva: u32,

    /// 映像绑定前,此时间戳为零。
    /// 映像绑定后,此字段设为 DLL 的时间/日期戳。
    time_date_stamp: u32,

    /// 首个转发引用的索引。
    forwarder_chain: u32,

    /// 包含 DLL 名称的 ASCII 字符串地址。
    /// 此地址相对于映像基址。
    name_rva: u32,

    /// 导入地址表的相对虚拟地址。
    /// 在映像绑定之前,此表内容与导入查找表内容相同。
    import_address_table_rva: u32,
};

pub fn ImportLookupTableEntry(comptime magic: std.coff.OptionalHeader.Magic) type {
    const Payload = packed union(u31) {
        ordinal: packed struct(u31) {
            ordinal: u16,
            _: u15 = 0,
        },
        hint_name_rva: u31,
    };

    return switch (magic) {
        _ => comptime unreachable,
        .PE32 => packed struct(u32) {
            payload: Payload,
            is_ordinal: bool,
        },
        .@"PE32+" => packed struct(u64) {
            payload: Payload,
            _: u32 = 0,
            is_ordinal: bool,
        },
    };
}

/// 每个名称以 NULL 字节结尾。若 NULL 字节不在
/// 2 字节边界上,则填充条目结构以确保 2 字节对齐。
pub const ImportHintNameEntry = extern struct {
    /// 导出名称指针表中的索引。
    /// 先尝试使用此值匹配。若失败,则在 DLL 的导出名称指针表中进行二分查找。
    hint: u16,

    /// 指向以 NULL 结尾的 ASCII 名称的指针。
    /// 长度可变……
    name: [1]u8,
};

pub const ExportDirectoryTable = extern struct {
    /// 保留
    flags: u32,

    /// 此表的创建时间
    time_date_stamp: u32,

    major_version: u16,
    minor_version: u16,

    /// 包含 DLL 名称的 ASCII 字符串地址。
    /// 此地址相对于映像基址。
    name_rva: u32,

    /// 此映像中第一个导出的序号
    ordinal_base: u32,

    /// 导出地址表中的条目数量
    number_of_entries: u32,

    /// 名称指针表和序号表中的条目数
    number_of_names: u32,

    export_address_table_rva: u32,
    name_pointer_table_rva: u32,
    ordinal_table_rva: u32,
};

pub const ExportAddressTableEntry = extern struct {
    /// 如果此地址位于导出节中,则它是导出的地址。
    /// 否则,它是一个字符串的地址,该字符串指定另一个 DLL 中的符号:
    ///   <dll name>.<export name>
    ///   <dll name>.#<export ordinal>
    export_or_forwarder_rva: u32,
};

pub const ExportNamePointerTableEntry = extern struct {
    name_rva: u32,
};

pub const ExportOrdinalTableEntry = extern struct {
    unbiased_ordinal: u16,
};

pub const SectionHeader = extern struct {
    name: [8]u8,
    virtual_size: u32,
    virtual_address: u32,
    size_of_raw_data: u32,
    pointer_to_raw_data: u32,
    pointer_to_relocations: u32,
    pointer_to_linenumbers: u32,
    number_of_relocations: u16,
    number_of_linenumbers: u16,
    flags: SectionHeader.Flags,

    pub fn getName(self: *align(1) const SectionHeader) ?[]const u8 {
        if (self.name[0] == '/') return null;
        const len = std.mem.findScalar(u8, &self.name, @as(u8, 0)) orelse self.name.len;
        return self.name[0..len];
    }

    pub fn getNameOffset(self: SectionHeader) ?u32 {
        if (self.name[0] != '/') return null;
        const len = std.mem.findScalar(u8, &self.name, @as(u8, 0)) orelse self.name.len;
        const offset = std.fmt.parseInt(u32, self.name[1..len], 10) catch unreachable;
        return offset;
    }

    /// 仅适用于 COFF 对象中的节头。
    pub fn getAlignment(self: SectionHeader) ?u16 {
        return self.flags.ALIGN.toByteUnits();
    }

    pub fn setAlignment(self: *SectionHeader, new_alignment: u16) void {
        self.flags.ALIGN = .fromByteUnits(new_alignment);
    }

    pub fn isCode(self: SectionHeader) bool {
        return self.flags.CNT_CODE;
    }

    pub fn isComdat(self: SectionHeader) bool {
        return self.flags.LNK_COMDAT;
    }

    pub const Flags = packed struct(u32) {
        SCALE_INDEX: bool = false,

        unused1: u2 = 0,

        /// 不应将节填充到下一个边界。
        /// 此标志已废弃,由 `.ALIGN = .@"1BYTES"` 替代。
        /// 仅对目标文件有效。
        TYPE_NO_PAD: bool = false,

        unused4: u1 = 0,

        /// 此节包含可执行代码。
        CNT_CODE: bool = false,

        /// 此节包含已初始化的数据。
        CNT_INITIALIZED_DATA: bool = false,

        /// 此节包含未初始化数据。
        CNT_UNINITIALIZED_DATA: bool = false,

        /// 预留供未来使用。
        LNK_OTHER: bool = false,

        /// 此节包含注释或其他信息。
        /// .drectve 节属于此类型。
        /// 仅对目标文件有效。
        LNK_INFO: bool = false,

        unused10: u1 = 0,

        /// 此节不会成为映像的一部分。
        /// 仅对目标文件有效。
        LNK_REMOVE: bool = false,

        /// 此节包含 COMDAT 数据。
        /// 更多信息见 COMDAT Sections (Object Only)。
        /// 仅对目标文件有效。
        LNK_COMDAT: bool = false,

        unused13: u2 = 0,

        union14: packed union {
            mask: u1,
            /// 此节包含通过全局指针 (GP) 引用的数据。
            GPREL: bool,
            MEM_FARDATA: bool,
        } = .{ .mask = 0 },

        unused15: u1 = 0,

        union16: packed union {
            mask: u1,
            MEM_PURGEABLE: bool,
            MEM_16BIT: bool,
        } = .{ .mask = 0 },

        /// 预留供未来使用。
        MEM_LOCKED: bool = false,

        /// 预留供未来使用。
        MEM_PRELOAD: bool = false,

        ALIGN: SectionHeader.Flags.Align = .NONE,

        /// 此节包含扩展重定位。
        LNK_NRELOC_OVFL: bool = false,

        /// 可按需丢弃此节。
        MEM_DISCARDABLE: bool = false,

        /// 此节不可缓存。
        MEM_NOT_CACHED: bool = false,

        /// 此节不可分页。
        MEM_NOT_PAGED: bool = false,

        /// 此节可在内存中共享。
        MEM_SHARED: bool = false,

        /// 此节可作为代码执行。
        MEM_EXECUTE: bool = false,

        /// 此节可读。
        MEM_READ: bool = false,

        /// 此节可写。
        MEM_WRITE: bool = false,

        pub const Align = enum(u4) {
            NONE = 0,
            @"1BYTES" = 1,
            @"2BYTES" = 2,
            @"4BYTES" = 3,
            @"8BYTES" = 4,
            @"16BYTES" = 5,
            @"32BYTES" = 6,
            @"64BYTES" = 7,
            @"128BYTES" = 8,
            @"256BYTES" = 9,
            @"512BYTES" = 10,
            @"1024BYTES" = 11,
            @"2048BYTES" = 12,
            @"4096BYTES" = 13,
            @"8192BYTES" = 14,
            _,

            pub fn toByteUnits(a: Align) ?u16 {
                if (a == .NONE) return null;
                return @as(u16, 1) << (@backingInt(a) - 1);
            }

            pub fn fromByteUnits(n: u16) Align {
                std.debug.assert(std.math.isPowerOfTwo(n));
                return @fromBackingInt(@intCast(@ctz(n) + 1));
            }

            pub fn alignment(a: Align) ?std.mem.Alignment {
                return .fromByteUnitsOptional(a.toByteUnits() orelse null);
            }
        };
    };
};

pub const Symbol = extern struct {
    name: [8]u8,
    value: u32,
    section_number: SectionNumber,
    type: SymType,
    storage_class: StorageClass,
    number_of_aux_symbols: u8,

    pub fn sizeOf() comptime_int {
        return 18;
    }

    pub fn getName(self: *const Symbol) ?[]const u8 {
        if (std.mem.eql(u8, self.name[0..4], "\x00\x00\x00\x00")) return null;
        const len = std.mem.findScalar(u8, &self.name, @as(u8, 0)) orelse self.name.len;
        return self.name[0..len];
    }

    pub fn getNameOffset(self: Symbol) ?u32 {
        if (!std.mem.eql(u8, self.name[0..4], "\x00\x00\x00\x00")) return null;
        const offset = std.mem.readInt(u32, self.name[4..8], .little);
        return offset;
    }
};

pub const SectionNumber = enum(i16) {
    /// 此符号记录尚未分配节。
    /// 值为零表示引用的是在其他位置定义的外部符号。
    /// 非零值表示公共符号,其大小由该值指定。
    UNDEFINED = 0,

    /// 符号具有绝对值(不可重定位),且不是地址。
    ABSOLUTE = -1,

    /// 此符号提供一般类型或调试信息,但不对应某个节。
    /// 微软工具将此设置与 .file 记录(存储类 FILE)配合使用。
    DEBUG = -2,
    _,
};

pub const SymType = packed struct(u16) {
    complex_type: ComplexType,
    base_type: BaseType,
};

pub const BaseType = enum(u8) {
    /// 无类型信息或未知基本类型。Microsoft 工具使用此设置。
    NULL = 0,

    /// 无有效类型;用于 void 指针和函数
    VOID = 1,

    /// 字符(有符号字节)
    CHAR = 2,

    /// 2 字节有符号整数
    SHORT = 3,

    /// 自然整数类型(Windows 上通常为 4 字节)。
    INT = 4,

    /// 4 字节有符号整数
    LONG = 5,

    /// 四字节浮点数
    FLOAT = 6,

    /// 八字节浮点数
    DOUBLE = 7,

    /// 结构体
    STRUCT = 8,

    /// 联合体
    UNION = 9,

    /// 枚举类型
    ENUM = 10,

    /// 枚举成员(指定值)
    MOE = 11,

    /// 一个字节;无符号单字节整数
    BYTE = 12,

    /// 一个字;无符号双字节整数
    WORD = 13,

    /// 自然大小的无符号整数(通常为 4 字节)
    UINT = 14,

    /// 无符号 4 字节整数
    DWORD = 15,

    _,
};

pub const ComplexType = enum(u8) {
    /// 无派生类型;该符号是简单标量变量。
    NULL = 0,

    /// 此符号是指向基类型的指针。
    POINTER = 16,

    /// 该符号是返回基本类型的函数。
    FUNCTION = 32,

    /// 此符号是基类型的数组。
    ARRAY = 48,

    _,
};

pub const StorageClass = enum(u8) {
    /// 用于调试、表示函数结束的特殊符号。
    END_OF_FUNCTION = 0xff,

    /// 未指定存储类。
    NULL = 0,

    /// 自动(栈)变量。Value 字段指定栈帧偏移量。
    AUTOMATIC = 1,

    /// 微软工具将此值用于外部符号。
    /// 当节编号为 IMAGE_SYM_UNDEFINED(0)时,Value 字段表示大小。
    /// 如果节编号不为零,则 Value 字段指定节内偏移量。
    EXTERNAL = 2,

    /// 符号在节中的偏移。
    /// 若 Value 字段为零,则该符号表示节名。
    STATIC = 3,

    /// 寄存器变量。
    /// Value 字段指定寄存器编号。
    REGISTER = 4,

    /// 外部定义的符号。
    EXTERNAL_DEF = 5,

    /// 模块内部定义的代码标签。
    /// Value 字段指定符号在节内的偏移。
    LABEL = 6,

    /// 对未定义代码标签的引用。
    UNDEFINED_LABEL = 7,

    /// 结构体成员。Value 字段指定第 n 个成员。
    MEMBER_OF_STRUCT = 8,

    /// 函数的形式参数。Value 字段指定第 n 个参数。
    ARGUMENT = 9,

    /// 结构体标签名条目。
    STRUCT_TAG = 10,

    /// 联合体成员。Value 字段指定第 n 个成员。
    MEMBER_OF_UNION = 11,

    /// 联合体标签名条目。
    UNION_TAG = 12,

    /// Typedef 条目。
    TYPE_DEFINITION = 13,

    /// 静态数据声明。
    UNDEFINED_STATIC = 14,

    /// 枚举类型标签名条目。
    ENUM_TAG = 15,

    /// 枚举成员。Value 字段指定第 n 个成员。
    MEMBER_OF_ENUM = 16,

    /// 寄存器参数。
    REGISTER_PARAM = 17,

    /// 位字段引用。Value 字段指定该位字段中的第 n 位。
    BIT_FIELD = 18,

    /// .bb(块开始)或 .eb(块结束)记录。
    /// Value 字段是代码位置的可重定位地址。
    BLOCK = 100,

    /// 微软工具将此值用于定义函数范围的符号记录:函数开始(.bf)、函数结束(.ef)和函数中的行(.lf)。
    /// 对于 .lf 记录,Value 字段给出函数中的源码行数。
    /// 对于 .ef 记录,Value 字段给出函数代码的大小。
    FUNCTION = 101,

    /// 结构结束条目。
    END_OF_STRUCT = 102,

    /// Microsoft 工具及传统 COFF 格式用于源文件符号记录的值。
    /// 该符号后跟辅助记录,给出文件名称。
    FILE = 103,

    /// 节的定义(Microsoft 工具改用 STATIC 存储类)。
    SECTION = 104,

    /// 弱外部符号。更多信息参见辅助格式 3:弱外部符号。
    WEAK_EXTERNAL = 105,

    /// CLR 令牌符号。名称为由令牌十六进制值构成的 ASCII 字符串。
    /// 更多信息参见 CLR Token Definition (Object Only)。
    CLR_TOKEN = 107,

    _,
};

pub const FunctionDefinition = extern struct {
    /// 对应 .bf(函数开始)符号记录的符号表索引。
    tag_index: u32,

    /// 函数本身的可执行代码大小。
    /// 若函数位于独立的节中,则节头的 SizeOfRawData 大于或等于此字段,
    /// 具体取决于对齐要求。
    total_size: u32,

    /// 此函数的第一个 COFF 行号条目的文件偏移量;若不存在则为零。
    pointer_to_linenumber: u32,

    /// 下一个函数记录的符号表索引。
    /// 若该函数是符号表中的最后一个函数,此字段设为零。
    pointer_to_next_function: u32,

    unused: [2]u8,
};

pub const SectionDefinition = extern struct {
    /// 节数据的大小,与节头中的 SizeOfRawData 相同。
    length: u32,

    /// 该节的重定位条目数量。
    number_of_relocations: u16,

    /// 该节的行号条目数量。
    number_of_linenumbers: u16,

    /// 公共数据的校验和。节头中设置 IMAGE_SCN_LNK_COMDAT 标志时适用。
    checksum: u32,

    /// 关联节在节表中的从 1 开始的索引。在 COMDAT 选择设置为 5 时使用。
    number: u16,

    /// COMDAT 选择编号。仅当该节为 COMDAT 节时适用。
    selection: ComdatSelection,

    unused: [3]u8,
};

pub const FileDefinition = extern struct {
    /// 给出源文件名称的 ANSI 字符串。
    /// 若小于最大长度,则以空字节填充。
    file_name: [18]u8,

    pub fn getFileName(self: *const FileDefinition) []const u8 {
        const len = std.mem.findScalar(u8, &self.file_name, @as(u8, 0)) orelse self.file_name.len;
        return self.file_name[0..len];
    }
};

pub const WeakExternalDefinition = extern struct {
    /// sym2 的符号表索引;找不到 sym1 时,链接到该符号。
    tag_index: u32,

    /// IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY 表示不应为 sym1 搜索库。
    /// IMAGE_WEAK_EXTERN_SEARCH_LIBRARY 表示应为 sym1 搜索库。
    /// IMAGE_WEAK_EXTERN_SEARCH_ALIAS 表示 sym1 是 sym2 的别名。
    flag: WeakExternalFlag,

    unused: [10]u8,

    pub fn sizeOf() comptime_int {
        return 18;
    }
};

// https://github.com/tpn/winsdk-10/blob/master/Include/10.0.16299.0/km/ntimage.h
pub const WeakExternalFlag = enum(u32) {
    SEARCH_NOLIBRARY = 1,
    SEARCH_LIBRARY = 2,
    SEARCH_ALIAS = 3,
    ANTI_DEPENDENCY = 4,
    _,
};

pub const ComdatSelection = enum(u8) {
    /// 不是 COMDAT 节。
    NONE = 0,

    /// 若此符号已定义,链接器将报告 "multiply defined symbol" 错误。
    NODUPLICATES = 1,

    /// 定义相同 COMDAT 符号的任何节都可链接;其余节将被移除。
    ANY = 2,

    /// 链接器从此符号的各定义中任意选择一个节。
    /// 若各定义大小并非全部相同,则发出 "multiply defined symbol" 错误。
    SAME_SIZE = 3,

    /// 链接器从此符号的各定义中任意选择一个节。
    /// 若各定义并非完全一致,则发出 "multiply defined symbol" 错误。
    EXACT_MATCH = 4,

    /// 只有另一个特定的 COMDAT 节被链接时,才链接此节。
    /// 另一个节由此节定义的辅助符号记录中的 Number 字段指定。
    /// 对于组件分散于多个节的定义,此设置很有用,
    /// 例如代码位于一个节、数据位于另一个节,但必须作为整体链接或丢弃。
    /// 与此节关联的另一个节必须是 COMDAT 节,也可以是另一个
    /// 关联 COMDAT 节。关联 COMDAT 节的节关联链不能形成环。
    /// 节关联链最终必须到达未设置 IMAGE_COMDAT_SELECT_ASSOCIATIVE 的 COMDAT 节。
    ASSOCIATIVE = 5,

    /// 链接器从此符号的所有定义中选择最大的定义。
    /// 若多个定义均为此大小,则任意选择其中一个。
    LARGEST = 6,

    _,
};

pub const DebugInfoDefinition = extern struct {
    unused_1: [4]u8,

    /// 源文件中的实际顺序行号(1、2、3 等),对应 .bf 或 .ef 记录。
    linenumber: u16,

    unused_2: [6]u8,

    /// 下一个 .bf 符号记录的符号表索引。
    /// 若该函数是符号表中的最后一个函数,则此字段为零。
    /// .ef 记录不使用此字段。
    pointer_to_next_function: u32,

    unused_3: [2]u8,
};

pub const Error = error{
    InvalidPEMagic,
    InvalidPEHeader,
    InvalidMachine,
    MissingPEHeader,
    MissingCoffSection,
    MissingStringTable,
};

// 该格式的官方文档:https://docs.microsoft.com/en-us/windows/win32/debug/pe-format
pub const Coff = struct {
    data: []const u8,
    // 若 `data` 由加载器加载的映像提供底层存储,则设置
    is_loaded: bool,
    is_image: bool,
    coff_header_offset: usize,

    guid: [16]u8 = undefined,
    age: u32 = undefined,

    // `data` 的生存期必须长于返回的 Coff 的生存期
    pub fn init(data: []const u8, is_loaded: bool) error{ EndOfStream, MissingPEHeader }!Coff {
        if (data.len < pe_pointer_offset + 4) return error.EndOfStream;
        const header_offset = mem.readInt(u32, data[pe_pointer_offset..][0..4], .little);
        if (data.len < header_offset + 4) return error.EndOfStream;
        const is_image = mem.eql(u8, data[header_offset..][0..4], pe_signature);

        const coff: Coff = .{
            .data = data,
            .is_image = is_image,
            .is_loaded = is_loaded,
            .coff_header_offset = o: {
                if (is_image) break :o header_offset + 4;
                break :o header_offset;
            },
        };

        // 预先进行基本验证
        if (is_image) {
            const coff_header = coff.getHeader();
            if (coff_header.size_of_optional_header == 0) return error.MissingPEHeader;
        }

        // JK:过去在此处检查架构,若不是 x86 或其衍生架构则报错。
        // 但现在愿意冒险让 aarch64 也尝试运行。

        return coff;
    }

    pub fn getPdbPath(self: *Coff) !?[]const u8 {
        assert(self.is_image);

        const data_dirs = self.getDataDirectories();
        if (@backingInt(IMAGE.DIRECTORY_ENTRY.DEBUG) >= data_dirs.len) return null;

        const debug_dir = data_dirs[@backingInt(IMAGE.DIRECTORY_ENTRY.DEBUG)];
        var reader: std.Io.Reader = .fixed(self.data);

        if (self.is_loaded) {
            reader.seek = debug_dir.virtual_address;
        } else {
            // 查找 debug_dir 所在的节,以便将 RVA 转换为文件偏移量
            for (self.getSectionHeaders()) |*sect| {
                if (debug_dir.virtual_address >= sect.virtual_address and debug_dir.virtual_address < sect.virtual_address + sect.virtual_size) {
                    reader.seek = sect.pointer_to_raw_data + (debug_dir.virtual_address - sect.virtual_address);
                    break;
                }
            } else return error.InvalidDebugDirectory;
        }

        // 查找正确的 DebugDirectoryEntry 及其数据存储位置。
        // 它可能位于任意节中。
        const debug_dir_entry_count = debug_dir.size / @sizeOf(DebugDirectoryEntry);
        var i: u32 = 0;
        while (i < debug_dir_entry_count) : (i += 1) {
            const debug_dir_entry = try reader.takeStruct(DebugDirectoryEntry, .little);
            if (debug_dir_entry.type == .CODEVIEW) {
                const dir_offset = if (self.is_loaded) debug_dir_entry.address_of_raw_data else debug_dir_entry.pointer_to_raw_data;
                reader.seek = dir_offset;
                break;
            }
        } else return null;

        const code_view_signature = try reader.takeArray(4);
        // 'RSDS' 表示 lld 使用的 PDB70 格式。
        if (!mem.eql(u8, code_view_signature, "RSDS"))
            return error.InvalidPEMagic;
        try reader.readSliceAll(self.guid[0..]);
        self.age = try reader.takeInt(u32, .little);

        // 最后读取以 null 结尾的字符串。
        const start = reader.seek;
        const len = std.mem.findScalar(u8, self.data[start..], 0) orelse return null;
        return self.data[start .. start + len];
    }

    pub fn getHeader(self: Coff) Header {
        return @as(*align(1) const Header, @ptrCast(self.data[self.coff_header_offset..][0..@sizeOf(Header)])).*;
    }

    pub fn getOptionalHeader(self: Coff) OptionalHeader {
        assert(self.is_image);
        const offset = self.coff_header_offset + @sizeOf(Header);
        return @as(*align(1) const OptionalHeader, @ptrCast(self.data[offset..][0..@sizeOf(OptionalHeader)])).*;
    }

    pub fn getOptionalHeader32(self: Coff) OptionalHeader.PE32 {
        assert(self.is_image);
        const offset = self.coff_header_offset + @sizeOf(Header);
        return @as(*align(1) const OptionalHeader.PE32, @ptrCast(self.data[offset..][0..@sizeOf(OptionalHeader.PE32)])).*;
    }

    pub fn getOptionalHeader64(self: Coff) OptionalHeader.@"PE32+" {
        assert(self.is_image);
        const offset = self.coff_header_offset + @sizeOf(Header);
        return @as(*align(1) const OptionalHeader.@"PE32+", @ptrCast(self.data[offset..][0..@sizeOf(OptionalHeader.@"PE32+")])).*;
    }

    pub fn getImageBase(self: Coff) u64 {
        const hdr = self.getOptionalHeader();
        return switch (@backingInt(hdr.magic)) {
            IMAGE_NT_OPTIONAL_HDR32_MAGIC => self.getOptionalHeader32().image_base,
            IMAGE_NT_OPTIONAL_HDR64_MAGIC => self.getOptionalHeader64().image_base,
            else => unreachable, // 假定已经验证过头部。
        };
    }

    pub fn getNumberOfDataDirectories(self: Coff) u32 {
        const hdr = self.getOptionalHeader();
        return switch (@backingInt(hdr.magic)) {
            IMAGE_NT_OPTIONAL_HDR32_MAGIC => self.getOptionalHeader32().number_of_rva_and_sizes,
            IMAGE_NT_OPTIONAL_HDR64_MAGIC => self.getOptionalHeader64().number_of_rva_and_sizes,
            else => unreachable, // 假定已经验证过头部。
        };
    }

    pub fn getDataDirectories(self: *const Coff) []align(1) const ImageDataDirectory {
        const hdr = self.getOptionalHeader();
        const size: usize = switch (@backingInt(hdr.magic)) {
            IMAGE_NT_OPTIONAL_HDR32_MAGIC => @sizeOf(OptionalHeader.PE32),
            IMAGE_NT_OPTIONAL_HDR64_MAGIC => @sizeOf(OptionalHeader.@"PE32+"),
            else => unreachable, // 假定已经验证过头部。
        };
        const offset = self.coff_header_offset + @sizeOf(Header) + size;
        return @as([*]align(1) const ImageDataDirectory, @ptrCast(self.data[offset..]))[0..self.getNumberOfDataDirectories()];
    }

    pub fn getSymtab(self: *const Coff) ?Symtab {
        const coff_header = self.getHeader();
        if (coff_header.pointer_to_symbol_table == 0) return null;

        const offset = coff_header.pointer_to_symbol_table;
        const size = coff_header.number_of_symbols * Symbol.sizeOf();
        return .{ .buffer = self.data[offset..][0..size] };
    }

    pub fn getStrtab(self: *const Coff) error{InvalidStrtabSize}!?Strtab {
        const coff_header = self.getHeader();
        if (coff_header.pointer_to_symbol_table == 0) return null;

        const offset = coff_header.pointer_to_symbol_table + Symbol.sizeOf() * coff_header.number_of_symbols;
        const size = mem.readInt(u32, self.data[offset..][0..4], .little);
        if ((offset + size) > self.data.len) return error.InvalidStrtabSize;

        return Strtab{ .buffer = self.data[offset..][0..size] };
    }

    pub fn strtabRequired(self: *const Coff) bool {
        for (self.getSectionHeaders()) |*sect_hdr| if (sect_hdr.getName() == null) return true;
        return false;
    }

    pub fn getSectionHeaders(self: *const Coff) []align(1) const SectionHeader {
        const coff_header = self.getHeader();
        const offset = self.coff_header_offset + @sizeOf(Header) + coff_header.size_of_optional_header;
        return @as([*]align(1) const SectionHeader, @ptrCast(self.data.ptr + offset))[0..coff_header.number_of_sections];
    }

    pub fn getSectionHeadersAlloc(self: *const Coff, allocator: mem.Allocator) ![]SectionHeader {
        const section_headers = self.getSectionHeaders();
        const out_buff = try allocator.alloc(SectionHeader, section_headers.len);
        for (out_buff, 0..) |*section_header, i| {
            section_header.* = section_headers[i];
        }

        return out_buff;
    }

    pub fn getSectionName(self: *const Coff, sect_hdr: *align(1) const SectionHeader) error{InvalidStrtabSize}![]const u8 {
        const name = sect_hdr.getName() orelse blk: {
            const strtab = (try self.getStrtab()).?;
            const name_offset = sect_hdr.getNameOffset().?;
            break :blk strtab.get(name_offset);
        };
        return name;
    }

    pub fn getSectionByName(self: *const Coff, comptime name: []const u8) ?*align(1) const SectionHeader {
        for (self.getSectionHeaders()) |*sect| {
            const section_name = self.getSectionName(sect) catch |e| switch (e) {
                error.InvalidStrtabSize => continue, // 忽略无效(?)strtab 条目——另见 GitHub 问题 #15238
            };
            if (mem.eql(u8, section_name, name)) {
                return sect;
            }
        }
        return null;
    }

    pub fn getSectionData(self: *const Coff, sec: *align(1) const SectionHeader) []const u8 {
        const offset = if (self.is_loaded) sec.virtual_address else sec.pointer_to_raw_data;
        return self.data[offset..][0..sec.virtual_size];
    }

    pub fn getSectionDataAlloc(self: *const Coff, sec: *align(1) const SectionHeader, allocator: mem.Allocator) ![]u8 {
        const section_data = self.getSectionData(sec);
        return allocator.dupe(u8, section_data);
    }
};

pub const Symtab = struct {
    buffer: []const u8,

    pub fn len(self: Symtab) usize {
        return @divExact(self.buffer.len, Symbol.sizeOf());
    }

    pub const Tag = enum {
        symbol,
        debug_info,
        func_def,
        weak_ext,
        file_def,
        sect_def,
    };

    pub const Record = union(Tag) {
        symbol: Symbol,
        debug_info: DebugInfoDefinition,
        func_def: FunctionDefinition,
        weak_ext: WeakExternalDefinition,
        file_def: FileDefinition,
        sect_def: SectionDefinition,
    };

    /// 存活时间与 Symtab 实例相同。
    pub fn at(self: Symtab, index: usize, tag: Tag) Record {
        const offset = index * Symbol.sizeOf();
        const raw = self.buffer[offset..][0..Symbol.sizeOf()];
        return switch (tag) {
            .symbol => .{ .symbol = asSymbol(raw) },
            .debug_info => .{ .debug_info = asDebugInfo(raw) },
            .func_def => .{ .func_def = asFuncDef(raw) },
            .weak_ext => .{ .weak_ext = asWeakExtDef(raw) },
            .file_def => .{ .file_def = asFileDef(raw) },
            .sect_def => .{ .sect_def = asSectDef(raw) },
        };
    }

    fn asSymbol(raw: []const u8) Symbol {
        return .{
            .name = raw[0..8].*,
            .value = mem.readInt(u32, raw[8..12], .little),
            .section_number = @as(SectionNumber, @fromBackingInt(@intCast(mem.readInt(u16, raw[12..14], .little)))),
            .type = @as(SymType, @bitCast(mem.readInt(u16, raw[14..16], .little))),
            .storage_class = @as(StorageClass, @fromBackingInt(@intCast(raw[16]))),
            .number_of_aux_symbols = raw[17],
        };
    }

    fn asDebugInfo(raw: []const u8) DebugInfoDefinition {
        return .{
            .unused_1 = raw[0..4].*,
            .linenumber = mem.readInt(u16, raw[4..6], .little),
            .unused_2 = raw[6..12].*,
            .pointer_to_next_function = mem.readInt(u32, raw[12..16], .little),
            .unused_3 = raw[16..18].*,
        };
    }

    fn asFuncDef(raw: []const u8) FunctionDefinition {
        return .{
            .tag_index = mem.readInt(u32, raw[0..4], .little),
            .total_size = mem.readInt(u32, raw[4..8], .little),
            .pointer_to_linenumber = mem.readInt(u32, raw[8..12], .little),
            .pointer_to_next_function = mem.readInt(u32, raw[12..16], .little),
            .unused = raw[16..18].*,
        };
    }

    fn asWeakExtDef(raw: []const u8) WeakExternalDefinition {
        return .{
            .tag_index = mem.readInt(u32, raw[0..4], .little),
            .flag = @as(WeakExternalFlag, @fromBackingInt(@intCast(mem.readInt(u32, raw[4..8], .little)))),
            .unused = raw[8..18].*,
        };
    }

    fn asFileDef(raw: []const u8) FileDefinition {
        return .{
            .file_name = raw[0..18].*,
        };
    }

    fn asSectDef(raw: []const u8) SectionDefinition {
        return .{
            .length = mem.readInt(u32, raw[0..4], .little),
            .number_of_relocations = mem.readInt(u16, raw[4..6], .little),
            .number_of_linenumbers = mem.readInt(u16, raw[6..8], .little),
            .checksum = mem.readInt(u32, raw[8..12], .little),
            .number = mem.readInt(u16, raw[12..14], .little),
            .selection = @as(ComdatSelection, @fromBackingInt(@intCast(raw[14]))),
            .unused = raw[15..18].*,
        };
    }

    pub const Slice = struct {
        buffer: []const u8,
        num: usize,
        count: usize = 0,

        /// 存活时间与 Symtab 实例相同。
        pub fn next(self: *Slice) ?Symbol {
            if (self.count >= self.num) return null;
            const sym = asSymbol(self.buffer[0..Symbol.sizeOf()]);
            self.count += 1;
            self.buffer = self.buffer[Symbol.sizeOf()..];
            return sym;
        }
    };

    pub fn slice(self: Symtab, start: usize, end: ?usize) Slice {
        const offset = start * Symbol.sizeOf();
        const llen = if (end) |e| e * Symbol.sizeOf() else self.buffer.len;
        const num = @divExact(llen - offset, Symbol.sizeOf());
        return Slice{ .buffer = self.buffer[offset..][0..llen], .num = num };
    }
};

pub const Strtab = struct {
    buffer: []const u8,

    pub fn get(self: Strtab, off: u32) []const u8 {
        assert(off < self.buffer.len);
        return mem.sliceTo(@as([*:0]const u8, @ptrCast(self.buffer.ptr + off)), 0);
    }
};

pub const ImportHeader = extern struct {
    /// 必须为 IMAGE_FILE_MACHINE_UNKNOWN
    sig1: IMAGE.FILE.MACHINE = .UNKNOWN,
    /// 必须为 0xFFFF
    sig2: u16 = 0xFFFF,
    version: u16,
    machine: IMAGE.FILE.MACHINE,
    time_date_stamp: u32,
    size_of_data: u32,
    hint: u16,
    types: packed struct(u16) {
        type: ImportType,
        name_type: ImportNameType,
        reserved: u11,
    },
};

pub const ImportType = enum(u2) {
    /// 可执行代码。
    CODE = 0,
    /// 数据。
    DATA = 1,
    /// 在 .def 文件中指定为 CONST。
    CONST = 2,
    _,
};

pub const ImportNameType = enum(u3) {
    /// 导入按序号指定。这表示导入标头的 Ordinal/Hint
    /// 字段值是导入序号。如果未指定此常量,
    /// 则应始终将 Ordinal/Hint 字段解释为导入提示。
    ORDINAL = 0,
    /// 导入名称与公开符号名称相同。
    NAME = 1,
    /// 导入名称为公开符号名称,但跳过前导 ?、@ 或可选的 _。
    NAME_NOPREFIX = 2,
    /// 导入名称为公开符号名称,但省略开头的 ?、@ 或可选的 _,并在首个 @ 处截断。
    ///
    NAME_UNDECORATE = 3,
    /// https://github.com/llvm/llvm-project/pull/83211
    NAME_EXPORTAS = 4,
    _,
};

pub const Relocation = extern struct {
    virtual_address: u32,
    symbol_table_index: u32,
    type: u16,

    pub fn sizeOf() comptime_int {
        return 10;
    }
};

pub const IMAGE = struct {
    pub const DIRECTORY_ENTRY = enum(u32) {
        /// 导出目录
        EXPORT = 0,
        /// 导入目录
        IMPORT = 1,
        /// 资源目录
        RESOURCE = 2,
        /// 异常目录
        EXCEPTION = 3,
        /// 安全目录
        SECURITY = 4,
        /// 基址重定位表
        BASERELOC = 5,
        /// 调试目录
        DEBUG = 6,
        /// 架构专用数据
        ARCHITECTURE = 7,
        /// GP 的 RVA
        GLOBALPTR = 8,
        /// TLS 目录
        TLS = 9,
        /// 加载配置目录
        LOAD_CONFIG = 10,
        /// 标头中的绑定导入目录
        BOUND_IMPORT = 11,
        /// 导入地址表
        IAT = 12,
        /// 延迟加载导入描述符
        DELAY_IMPORT = 13,
        /// COM 运行时描述符
        COM_DESCRIPTOR = 14,
        /// 必须为零
        RESERVED = 15,
        _,

        pub const len = @typeInfo(IMAGE.DIRECTORY_ENTRY).@"enum".field_names.len;
    };

    pub const FILE = struct {
        /// 机器类型。
        /// Machine 字段具有以下某个值,用于指定 CPU 类型。
        /// 映像文件只能在所指定机器或模拟该机器的系统上运行。
        pub const MACHINE = enum(u16) {
            /// 假定此字段内容适用于任何机器类型
            UNKNOWN = 0x0,
            /// Alpha AXP,32 位地址空间
            ALPHA = 0x184,
            /// Alpha 64,64 位地址空间
            ALPHA64 = 0x284,
            /// Matsushita AM33 处理器
            AM33 = 0x1d3,
            /// x64
            AMD64 = 0x8664,
            /// ARM 小端序
            ARM = 0x1c0,
            /// ARM64 小端序
            ARM64 = 0xaa64,
            /// 使原生 ARM64 与仿真的 x64 代码能够互操作的 ABI。
            ARM64EC = 0xA641,
            /// 允许原生 ARM64 与 ARM64EC 代码共存于同一文件的二进制格式。
            ARM64X = 0xA64E,
            /// ARM Thumb-2 小端序
            ARMNT = 0x1c4,
            /// EFI 字节码
            EBC = 0xebc,
            /// Intel 386 或更新处理器及兼容处理器。
            I386 = 0x14c,
            /// Intel Itanium 处理器系列
            IA64 = 0x200,
            /// LoongArch 32 位处理器系列
            LOONGARCH32 = 0x6232,
            /// LoongArch 64 位处理器系列
            LOONGARCH64 = 0x6264,
            /// Mitsubishi M32R 小端序
            M32R = 0x9041,
            /// MIPS16
            MIPS16 = 0x266,
            /// 带 FPU 的 MIPS
            MIPSFPU = 0x366,
            /// 带 FPU 的 MIPS16
            MIPSFPU16 = 0x466,
            /// PowerPC 小端序
            POWERPC = 0x1f0,
            /// 支持浮点的 Power PC
            POWERPCFP = 0x1f1,
            /// 兼容 MIPS I 的 32 位大端序
            R3000BE = 0x160,
            /// 兼容 MIPS I 的 32 位小端序
            R3000 = 0x162,
            /// 兼容 MIPS III 的 64 位小端序
            R4000 = 0x166,
            /// 兼容 MIPS IV 的 64 位小端序
            R10000 = 0x168,
            /// RISC-V 32 位地址空间
            RISCV32 = 0x5032,
            /// RISC-V 64 位地址空间
            RISCV64 = 0x5064,
            /// RISC-V 128 位地址空间
            RISCV128 = 0x5128,
            /// Hitachi SH3
            SH3 = 0x1a2,
            /// Hitachi SH3 DSP
            SH3DSP = 0x1a3,
            /// Hitachi SH4
            SH4 = 0x1a6,
            /// Hitachi SH5 处理器
            SH5 = 0x1a8,
            /// Thumb
            THUMB = 0x1c2,
            /// MIPS 小端序 WCE v2
            WCEMIPSV2 = 0x169,
            _,
            /// AXP 64(同 Alpha 64)
            pub const AXP64: IMAGE.FILE.MACHINE = .ALPHA64;

            pub fn RelocationType(comptime machine: IMAGE.FILE.MACHINE) type {
                return switch (machine) {
                    .AMD64,
                    => REL.AMD64,
                    .ARM,
                    .ARMNT,
                    => REL.ARM,
                    .ARM64,
                    .ARM64EC,
                    .ARM64X,
                    => REL.ARM64,
                    .I386 => REL.I386,
                    .IA64 => REL.IA64,
                    .M32R => REL.M32R,
                    .MIPS16,
                    .MIPSFPU,
                    .MIPSFPU16,
                    => REL.MIPS,
                    .POWERPC,
                    .POWERPCFP,
                    => REL.PPC,
                    .SH3,
                    .SH3DSP,
                    .SH4,
                    .SH5,
                    => REL.SH,
                    else => void,
                };
            }
        };
    };

    pub const REL = struct {
        /// x64 处理器
        /// 为 x64 及兼容处理器定义了以下重定位类型标识。
        pub const AMD64 = enum(u16) {
            /// 忽略此重定位。
            ABSOLUTE = 0x0000,
            /// 重定位目标的 64 位 VA。
            ADDR64 = 0x0001,
            /// 重定位目标的 32 位虚拟地址。
            ADDR32 = 0x0002,
            /// 不包含映像基址的 32 位地址(RVA)。
            ADDR32NB = 0x0003,
            /// 相对于重定位位置之后的字节的 32 位相对地址。
            REL32 = 0x0004,
            /// 相对于重定位位置之后 1 字节处的 32 位地址。
            REL32_1 = 0x0005,
            /// 相对于重定位后第 2 字节位置的 32 位地址。
            REL32_2 = 0x0006,
            /// 相对于重定位位置之后第 3 字节的 32 位地址。
            REL32_3 = 0x0007,
            /// 相对于重定位位置之后 4 字节处的 32 位地址。
            REL32_4 = 0x0008,
            /// 相对于重定位后第 5 字节位置的 32 位地址。
            REL32_5 = 0x0009,
            /// 包含目标的节的 16 位节索引。
            /// 用于支持调试信息。
            SECTION = 0x000A,
            /// 目标相对于其节开头的 32 位偏移量。
            /// 用于支持调试信息和静态线程局部存储。
            SECREL = 0x000B,
            /// 相对于包含目标的节的基址的 7 位无符号偏移。
            SECREL7 = 0x000C,
            /// CLR 标记。
            TOKEN = 0x000D,
            /// 写入目标文件的 32 位有符号、依赖跨度的值。
            SREL32 = 0x000E,
            /// 必须紧跟每个跨度相关值的一对项目。
            PAIR = 0x000F,
            /// 在链接时应用的 32 位有符号跨度相关值。
            SSPAN32 = 0x0010,
            _,
        };

        /// ARM 处理器
        /// 为 ARM 处理器定义以下重定位类型指示符。
        pub const ARM = enum(u16) {
            /// 忽略此重定位。
            ABSOLUTE = 0x0000,
            /// 目标的 32 位 VA。
            ADDR32 = 0x0001,
            /// 目标的 32 位 RVA。
            ADDR32NB = 0x0002,
            /// 指向目标的 24 位相对位移。
            BRANCH24 = 0x0003,
            /// 对子程序调用的引用。
            /// 该引用由两条带有 11 位偏移量的 16 位指令组成。
            BRANCH11 = 0x0004,
            /// 相对于重定位位置之后的字节的 32 位相对地址。
            REL32 = 0x000A,
            /// 包含目标的节的 16 位节索引。
            /// 用于支持调试信息。
            SECTION = 0x000E,
            /// 目标相对于其节开头的 32 位偏移量。
            /// 用于支持调试信息和静态线程局部存储。
            SECREL = 0x000F,
            /// 目标的 32 位虚拟地址。
            /// 此重定位先用 MOVW 指令处理低 16 位,再用 MOVT 处理高 16 位。
            MOV32 = 0x0010,
            /// 目标的 32 位虚拟地址。
            /// 此重定位先用 MOVW 指令处理低 16 位,再用 MOVT 处理高 16 位。
            THUMB_MOV32 = 0x0011,
            /// 使用到 2 字节对齐目标的 21 位相对位移修补指令。
            /// 位移的最低有效位始终为零,不予存储。
            /// 此重定位对应 Thumb-2 的 32 位条件 B 指令。
            THUMB_BRANCH20 = 0x0012,
            Unused = 0x0013,
            /// 使用指向 2 字节对齐目标的 25 位相对位移修正指令。
            /// 位移的最低有效位为零,不予存储。此重定位对应 Thumb-2 B 指令。
            THUMB_BRANCH24 = 0x0014,
            /// 使用指向 4 字节对齐目标的 25 位相对位移修正指令。
            /// 位移的低 2 位为零,不予存储。
            /// 此重定位对应 Thumb-2 BLX 指令。
            THUMB_BLX23 = 0x0015,
            /// 仅当紧跟 ARM_REFHI 或 THUMB_REFHI 之后时,此重定位有效。
            /// 其 SymbolTableIndex 包含位移,而非符号表索引。
            PAIR = 0x0016,
            _,
        };

        /// ARM64 处理器
        /// 为 ARM64 处理器定义了以下重定位类型标识。
        pub const ARM64 = enum(u16) {
            /// 忽略此重定位。
            ABSOLUTE = 0x0000,
            /// 目标的 32 位 VA。
            ADDR32 = 0x0001,
            /// 目标的 32 位 RVA。
            ADDR32NB = 0x0002,
            /// B 和 BL 指令中到目标的 26 位相对位移。
            BRANCH26 = 0x0003,
            /// 用于 ADRP 指令,表示目标的页基址。
            PAGEBASE_REL21 = 0x0004,
            /// 用于 ADR 指令,表示到目标的 12 位相对位移。
            REL21 = 0x0005,
            /// 目标的 12 位页偏移,用于移位量为零的 ADD/ADDS(立即数)指令。
            PAGEOFFSET_12A = 0x0006,
            /// 用于 LDR(索引寻址、无符号立即数)指令,表示目标的 12 位页内偏移量。
            PAGEOFFSET_12L = 0x0007,
            /// 目标相对于其节开头的 32 位偏移量。
            /// 用于支持调试信息和静态线程局部存储。
            SECREL = 0x0008,
            /// 用于移位量为零的 ADD/ADDS(立即数)指令:目标节内偏移量的第 0:11 位。
            SECREL_LOW12A = 0x0009,
            /// 用于移位为零的 ADD/ADDS(立即数)指令,表示目标节内偏移量的第 12:23 位。
            SECREL_HIGH12A = 0x000A,
            /// 用于 LDR(索引寻址、无符号立即数)指令:目标节内偏移量的第 0:11 位。
            SECREL_LOW12L = 0x000B,
            /// CLR 令牌。
            TOKEN = 0x000C,
            /// 包含目标的节的 16 位节索引。
            /// 用于支持调试信息。
            SECTION = 0x000D,
            /// 重定位目标的 64 位 VA。
            ADDR64 = 0x000E,
            /// 用于条件 B 指令,表示指向重定位目标的 19 位偏移量。
            BRANCH19 = 0x000F,
            /// 指向重定位目标的 14 位偏移,用于 TBZ 和 TBNZ 指令。
            BRANCH14 = 0x0010,
            /// 相对于重定位位置之后的字节的 32 位相对地址。
            REL32 = 0x0011,
            _,
        };

        /// Hitachi SuperH 处理器。
        /// 以下重定位类型标识符针对 SH3 和 SH4 处理器定义。
        /// SH5 专属重定位标记为 SHM(SH Media)。
        pub const SH = enum(u16) {
            /// 忽略此重定位。
            @"3_ABSOLUTE" = 0x0000,
            /// 对包含目标符号虚拟地址的 16 位位置的引用。
            @"3_DIRECT16" = 0x0001,
            /// 目标符号的 32 位虚拟地址。
            @"3_DIRECT32" = 0x0002,
            /// 对包含目标符号虚拟地址的 8 位位置的引用。
            @"3_DIRECT8" = 0x0003,
            /// 对某条 8 位指令的引用,该指令包含目标符号的有效 16 位虚拟地址。
            @"3_DIRECT8_WORD" = 0x0004,
            /// 指向某个 8 位指令的引用,该指令包含目标符号的有效 32 位虚拟地址。
            @"3_DIRECT8_LONG" = 0x0005,
            /// 对某个 8 位位置的引用,其低 4 位包含目标符号的虚拟地址。
            @"3_DIRECT4" = 0x0006,
            /// 对 8 位指令的引用,其低 4 位包含目标符号的有效 16 位虚拟地址。
            @"3_DIRECT4_WORD" = 0x0007,
            /// 指向某个 8 位指令的引用,其低 4 位包含目标符号的有效 32 位虚拟地址。
            @"3_DIRECT4_LONG" = 0x0008,
            /// 指向某个 8 位指令的引用,该指令包含目标符号的有效 16 位相对偏移。
            @"3_PCREL8_WORD" = 0x0009,
            /// 对包含目标符号有效 32 位相对偏移量的 8 位指令的引用。
            @"3_PCREL8_LONG" = 0x000A,
            /// 指向某个 16 位指令的引用,其低 12 位包含目标符号的有效 16 位相对偏移。
            @"3_PCREL12_WORD" = 0x000B,
            /// 指向某个 32 位位置的引用,该位置是包含目标符号的节的虚拟地址。
            @"3_STARTOF_SECTION" = 0x000C,
            /// 对一个 32 位位置的引用,该位置存放包含目标符号的节的大小。
            @"3_SIZEOF_SECTION" = 0x000D,
            /// 包含目标的节的 16 位节索引。
            /// 用于支持调试信息。
            @"3_SECTION" = 0x000E,
            /// 目标相对于其节开头的 32 位偏移量。
            /// 用于支持调试信息和静态线程局部存储。
            @"3_SECREL" = 0x000F,
            /// 目标符号的 32 位 RVA。
            @"3_DIRECT32_NB" = 0x0010,
            /// GP 相对值。
            @"3_GPREL4_LONG" = 0x0011,
            /// CLR 令牌。
            @"3_TOKEN" = 0x0012,
            /// 距当前指令的偏移,以长字为单位。
            /// 若未设置 NOMODE 位,将低位的反值插入位 32,以选择 PTA 或 PTB。
            M_PCRELPT = 0x0013,
            /// 32 位地址的低 16 位。
            M_REFLO = 0x0014,
            /// 32 位地址的高 16 位。
            M_REFHALF = 0x0015,
            /// 相对地址的低 16 位。
            M_RELLO = 0x0016,
            /// 相对地址的高 16 位。
            M_RELHALF = 0x0017,
            /// 此重定位仅在紧随 REFHALF、RELHALF 或 RELLO 重定位时有效。
            /// 其 SymbolTableIndex 字段包含位移,而非符号表索引。
            M_PAIR = 0x0018,
            /// 重定位忽略节模式。
            M_NOMODE = 0x8000,
            _,
        };

        /// IBM PowerPC 处理器
        /// 以下重定位类型标识符为 PowerPC 处理器定义。
        pub const PPC = enum(u16) {
            /// 忽略此重定位。
            ABSOLUTE = 0x0000,
            /// 目标的 64 位 VA。
            ADDR64 = 0x0001,
            /// 目标的 32 位 VA。
            ADDR32 = 0x0002,
            /// 目标虚拟地址的低 24 位。
            /// 仅当目标符号为绝对符号且可通过符号扩展恢复原值时有效。
            ADDR24 = 0x0003,
            /// 目标 VA 的低 16 位。
            ADDR16 = 0x0004,
            /// 目标虚拟地址的低 14 位。
            /// 仅当目标符号为绝对符号且可通过符号扩展恢复原值时有效。
            ADDR14 = 0x0005,
            /// 指向符号位置的 24 位 PC 相对偏移量。
            REL24 = 0x0006,
            /// 相对于 PC、指向符号位置的 14 位偏移。
            REL14 = 0x0007,
            /// 目标的 32 位 RVA。
            ADDR32NB = 0x000A,
            /// 目标相对于其节开头的 32 位偏移量。
            /// 用于支持调试信息和静态线程局部存储。
            SECREL = 0x000B,
            /// 包含目标的节的 16 位节索引。
            /// 用于支持调试信息。
            SECTION = 0x000C,
            /// 目标相对于其所在节开头的 16 位偏移。
            /// 用于支持调试信息和静态线程局部存储。
            SECREL16 = 0x000F,
            /// 目标 32 位虚拟地址的高 16 位。
            /// 用于以两条指令加载完整地址的序列中的第一条指令。
            /// 此重定位之后必须紧跟 PAIR 重定位,其 SymbolTableIndex 包含有符号 16 位位移,将加到从被重定位位置取得的高 16 位上。
            REFHI = 0x0010,
            /// 目标 VA 的低 16 位。
            REFLO = 0x0011,
            /// 仅当紧随 REFHI 或 SECRELHI 重定位时才有效的重定位。
            /// 其 SymbolTableIndex 包含位移,而非符号表索引。
            PAIR = 0x0012,
            /// 目标相对于其节起点的 32 位偏移量的低 16 位。
            SECRELLO = 0x0013,
            /// 目标相对于 GP 寄存器的 16 位有符号位移。
            GPREL = 0x0015,
            /// CLR 令牌。
            TOKEN = 0x0016,
            _,
        };

        /// Intel 386 处理器
        /// 为 Intel 386 及兼容处理器定义以下重定位类型指示符。
        pub const I386 = enum(u16) {
            /// 忽略此重定位。
            ABSOLUTE = 0x0000,
            /// 不支持。
            DIR16 = 0x0001,
            /// 不支持。
            REL16 = 0x0002,
            /// 目标的 32 位 VA。
            DIR32 = 0x0006,
            /// 目标的 32 位 RVA。
            DIR32NB = 0x0007,
            /// 不支持。
            SEG12 = 0x0009,
            /// 包含目标的节的 16 位节索引。
            /// 用于支持调试信息。
            SECTION = 0x000A,
            /// 目标相对于其节开头的 32 位偏移量。
            /// 用于支持调试信息和静态线程局部存储。
            SECREL = 0x000B,
            /// CLR 令牌。
            TOKEN = 0x000C,
            /// 相对于包含目标的节的基址的 7 位偏移量。
            SECREL7 = 0x000D,
            /// 指向目标的 32 位相对位移。
            /// 支持 x86 的相对分支和调用指令。
            REL32 = 0x0014,
            _,
        };

        /// Intel Itanium 处理器系列(IPF)。
        /// 以下重定位类型指示符适用于 Intel Itanium 系列及兼容处理器。
        /// 注意,指令重定位使用指令束的偏移量与槽位编号作为重定位偏移量。
        pub const IA64 = enum(u16) {
            /// 忽略此重定位。
            ABSOLUTE = 0x0000,
            /// 指令重定位后可跟随一条 ADDEND 重定位,其值会先加到目标地址,然后再插入 IMM14 组合中的指定槽位。
            /// 重定位目标必须是绝对地址,或者映像必须固定。
            IMM14 = 0x0001,
            /// 指令重定位之后可以跟随 ADDEND 重定位,其值在目标地址插入 IMM22 指令束的指定槽位之前加到目标地址上。
            /// 重定位目标必须为绝对地址,或映像必须固定。
            IMM22 = 0x0002,
            /// 此重定位的槽位编号必须为一(1)。
            /// 其后可跟随 ADDEND 重定位,将其值加到目标地址后,再将该地址存入 IMM64 指令束的全部三个槽位。
            IMM64 = 0x0003,
            /// 目标的 32 位 VA。
            /// 仅 /LARGEADDRESSAWARE:NO 映像支持此项。
            DIR32 = 0x0004,
            /// 目标的 64 位 VA。
            DIR64 = 0x0005,
            /// 使用指向 16 位对齐目标的 25 位相对位移修正指令。
            /// 位移的低 4 位为零,不予存储。
            PCREL21B = 0x0006,
            /// 使用指向 16 位对齐目标的 25 位相对位移修补指令。
            /// 位移的低 4 位为零,不予存储(原文如此)。
            PCREL21M = 0x0007,
            /// 此重定位偏移量的最低若干位必须包含槽位编号,其余位为指令束地址。
            /// 使用指向 16 位对齐目标的 25 位相对位移修正指令束。
            /// 位移的低 4 位为零,不予存储。
            PCREL21F = 0x0008,
            /// 此指令重定位后可跟随 ADDEND 重定位,将其值加到目标地址后,计算 22 位 GP 相对偏移,并将其应用于 GPREL22 指令束。
            GPREL22 = 0x0009,
            /// 使用目标符号的字面量表条目的 22 位 GP 相对偏移修正指令。
            /// 链接器根据此重定位及其后可能存在的 ADDEND 重定位创建该字面量表条目。
            LTOFF22 = 0x000A,
            /// 包含目标的节的 16 位节索引。
            /// 用于支持调试信息。
            SECTION = 0x000B,
            /// 使用目标相对于其所在节起始位置的 22 位偏移量修补该指令。
            /// 此重定位之后可以立即跟随 ADDEND 重定位,其 Value 字段包含目标相对于节起始位置的 32 位无符号偏移量。
            SECREL22 = 0x000C,
            /// 此重定位的槽位编号必须为一,即 1。
            /// 使用目标相对于其所在节起始位置的 64 位偏移量修补该指令。
            /// 此重定位之后可以立即跟随 ADDEND 重定位,其 Value 字段包含目标相对于节起始位置的 32 位无符号偏移量。
            SECREL64I = 0x000D,
            /// 待修正数据的地址,修正值为目标相对于其所在节起点的 32 位偏移。
            SECREL32 = 0x000E,
            /// 目标的 32 位 RVA。
            DIR32NB = 0x0010,
            /// 应用于包含两个可重定位目标之差的有符号 14 位立即数。
            /// 这是向链接器提供的声明性字段,表示编译器已经生成此值。
            SREL14 = 0x0011,
            /// 应用于包含两个可重定位目标之差的有符号 22 位立即数。
            /// 这是供链接器使用的声明性字段,表示编译器已输出此值。
            SREL22 = 0x0012,
            /// 应用于包含两个可重定位值之差的有符号 32 位立即数。
            /// 这是供链接器使用的声明性字段,表示编译器已输出此值。
            SREL32 = 0x0013,
            /// 应用于包含两个可重定位值之差的无符号 32 位立即数。
            /// 这是向链接器提供的声明性字段,表示编译器已经生成此值。
            UREL32 = 0x0014,
            /// 60 位 PC 相对修正,始终保持为 MLX 指令束中的 BRL 指令。
            PCREL60X = 0x0015,
            /// 60 位程序计数器相对修正。
            /// 若目标位移可放入有符号 25 位字段,则将整个指令束转换为 MBB 指令束:槽位 1 为 NOP.B,槽位 2 为 25 位 BR 指令,其最低 4 位全零且不存储。
            PCREL60B = 0x0016,
            /// 60 位 PC 相对修正项。
            /// 若目标位移能放入有符号 25 位字段,则将整个组合转换为 MFB 组合:槽位 1 放置 NOP.F,槽位 2 放置 25 位 BR 指令(最低 4 位均为零并被舍弃)。
            PCREL60F = 0x0017,
            /// 60 位相对于程序计数器的修补。
            /// 如果目标位移可容纳于有符号 25 位字段,则将整个指令束转为 MIB 束:槽位 1 为 NOP.I,槽位 2 为 25 位 BR 指令,最低 4 位全为零,不予存储。
            PCREL60I = 0x0018,
            /// 60 位程序计数器相对修正。
            /// 若目标位移可放入有符号 25 位字段,则将整个指令束转换为 MMB 指令束:槽位 1 为 NOP.M,槽位 2 为 25 位 BR 指令,其最低 4 位全零且不存储。
            PCREL60M = 0x0019,
            /// 相对于 GP 的 64 位修正。
            IMMGPREL64 = 0x001a,
            /// CLR 标记。
            TOKEN = 0x001b,
            /// 32 位 GP 相对修正项。
            GPREL32 = 0x001c,
            /// 此重定位仅在紧随以下重定位之一时有效:IMM14、IMM22、IMM64、GPREL22、LTOFF22、LTOFF64、SECREL22、SECREL64I 或 SECREL32。
            /// 其值包含应用于指令束内指令的加数,不用于数据。
            ADDEND = 0x001F,
            _,
        };

        /// MIPS 处理器
        /// 以下重定位类型标识符为 MIPS 处理器定义。
        pub const MIPS = enum(u16) {
            /// 忽略此重定位。
            ABSOLUTE = 0x0000,
            /// 目标 32 位 VA 的高 16 位。
            REFHALF = 0x0001,
            /// 目标的 32 位 VA。
            REFWORD = 0x0002,
            /// 目标虚拟地址的低 26 位。
            /// 支持 MIPS J 和 JAL 指令。
            JMPADDR = 0x0003,
            /// 目标的 32 位虚拟地址的高 16 位。
            /// 用于加载完整地址的两条指令序列中的第一条指令。
            /// 此重定位之后必须立即跟随 PAIR 重定位,其 SymbolTableIndex 包含有符号 16 位位移,将其加到从被重定位位置取得的高 16 位上。
            REFHI = 0x0004,
            /// 目标 VA 的低 16 位。
            REFLO = 0x0005,
            /// 目标相对于 GP 寄存器的 16 位有符号位移。
            GPREL = 0x0006,
            /// 与 IMAGE_REL_MIPS_GPREL 相同。
            LITERAL = 0x0007,
            /// 包含目标的节的 16 位节索引。
            /// 用于支持调试信息。
            SECTION = 0x000A,
            /// 目标相对于其节开头的 32 位偏移量。
            /// 用于支持调试信息和静态线程局部存储。
            SECREL = 0x000B,
            /// 目标相对于其节起点的 32 位偏移量的低 16 位。
            SECRELLO = 0x000C,
            /// 目标相对于所在节起始位置的 32 位偏移量的高 16 位。
            /// 其后必须紧跟 IMAGE_REL_MIPS_PAIR 重定位。
            /// PAIR 重定位的 SymbolTableIndex 包含有符号 16 位位移,将加到从被重定位位置取得的高 16 位上。
            SECRELHI = 0x000D,
            /// 目标虚拟地址的低 26 位。
            /// 支持 MIPS16 JAL 指令。
            JMPADDR16 = 0x0010,
            /// 目标的 32 位 RVA。
            REFWORDNB = 0x0022,
            /// 仅当紧跟 REFHI 或 SECRELHI 重定位之后时,此重定位有效。
            /// 其 SymbolTableIndex 包含位移,而非符号表索引。
            PAIR = 0x0025,
            _,
        };

        /// Mitsubishi M32R
        /// 以下重定位类型标识符为 Mitsubishi M32R 处理器定义。
        pub const M32R = enum(u16) {
            /// 忽略此重定位。
            ABSOLUTE = 0x0000,
            /// 目标的 32 位 VA。
            ADDR32 = 0x0001,
            /// 目标的 32 位 RVA。
            ADDR32NB = 0x0002,
            /// 目标的 24 位 VA。
            ADDR24 = 0x0003,
            /// 目标相对于 GP 寄存器的 16 位偏移量。
            GPREL16 = 0x0004,
            /// 目标相对于程序计数器(PC)的 24 位偏移量,左移 2 位并进行符号扩展。
            PCREL24 = 0x0005,
            /// 目标相对于 PC 的 16 位偏移量,左移 2 位并进行符号扩展。
            PCREL16 = 0x0006,
            /// 目标相对于 PC 的 8 位偏移量,左移 2 位并进行符号扩展。
            PCREL8 = 0x0007,
            /// 目标虚拟地址的最高 16 位。
            REFHALF = 0x0008,
            /// 目标虚拟地址的最高 16 位,已按低位的符号扩展进行调整。
            /// 用于加载完整 32 位地址的双指令序列中的第一条指令。
            /// 此重定位后必须紧跟 PAIR 重定位,其 SymbolTableIndex 包含有符号 16 位位移,与待重定位位置取出的高 16 位相加。
            REFHI = 0x0009,
            /// 目标 VA 的最低 16 位。
            REFLO = 0x000A,
            /// 此重定位必须位于 REFHI 重定位之后。
            /// 其 SymbolTableIndex 包含位移,而非符号表索引。
            PAIR = 0x000B,
            /// 包含目标的节的 16 位节索引。
            /// 用于支持调试信息。
            SECTION = 0x000C,
            /// 目标相对于其节开头的 32 位偏移量。
            /// 用于支持调试信息和静态线程局部存储。
            SECREL = 0x000D,
            /// CLR 令牌。
            TOKEN = 0x000E,
            _,
        };
    };
};

pub const ArchiveMemberHeader = extern struct {
    /// 左对齐、以 '/' 终止的成员名称
    name: [16]u8,
    /// 左对齐的 ASCII 十进制数:自 1970 年 1 月 1 日起的秒数
    date: [12]u8,
    /// 左对齐的 ASCII 十进制数:用户 ID
    user_id: [6]u8,
    /// 左对齐的 ASCII 十进制数:组标识符
    group_id: [6]u8,
    /// 左对齐的 ASCII 八进制:文件模式
    file_mode: [8]u8,
    /// 左对齐的 ASCII 十进制数:此头部后面的成员大小,
    /// 不包含头部自身的大小。
    size: [10]u8,
    /// 字面字符串 '`\n'
    end_of_header: [2]u8,

    /// 直接从头部读取成员名称,或在提供长名称成员时从其中查找名称。
    ///
    pub fn parseName(
        self: *const ArchiveMemberHeader,
        opt_longnames: ?[]const u8,
    ) ![]const u8 {
        const trim = std.mem.trimEnd(u8, &self.name, &.{' '});

        if (trim.len == 0) return error.BadName;
        return if (trim[0] == '/') name: {
            if (trim.len == 1 or
                trim.len == 2 and trim[1] == '/')
                break :name trim;

            const offset = std.fmt.parseUnsigned(u50, trim[1..], 10) catch
                return error.BadName;

            if (opt_longnames) |longnames| {
                if (offset >= longnames.len) return error.BadName;
                break :name std.mem.sliceTo(longnames[@intCast(offset)..], 0);
            } else return error.NoLongNames;
        } else if (trim[trim.len - 1] == '/')
            trim[0 .. trim.len - 1]
        else
            return error.BadName;
    }

    fn parseField(field: []const u8, T: type, base: u8) !T {
        if (std.mem.allEqual(u8, field, ' ')) return 0;
        if (field[0] == '-')
            return @bitCast(try std.fmt.parseInt(
                @Int(.signed, @typeInfo(T).int.bits),
                std.mem.trimEnd(u8, field, &.{' '}),
                base,
            ));

        return std.fmt.parseUnsigned(T, std.mem.trimEnd(u8, field, &.{' '}), base);
    }

    pub fn parseDate(self: *const ArchiveMemberHeader) !u40 {
        return parseField(&self.date, u40, 10);
    }

    pub fn parseUserId(self: *const ArchiveMemberHeader) !u20 {
        return parseField(&self.user_id, u20, 10);
    }

    pub fn parseGroupId(self: *const ArchiveMemberHeader) !u20 {
        return parseField(&self.group_id, u20, 10);
    }

    pub fn parseFileMode(self: *const ArchiveMemberHeader) !u20 {
        return parseField(&self.group_id, u20, 8);
    }

    pub fn parseSize(self: *const ArchiveMemberHeader) !u34 {
        return parseField(&self.size, u34, 10);
    }

    pub const Kind = enum {
        first_linker,
        second_linker,
        longnames,
        coff,
        import,
    };
};

pub const LineNumber = extern struct {
    type: extern union {
        symbol_table_index: u32,
        virtual_address: u32,
    },
    line_number: u16,

    pub fn sizeOf() comptime_int {
        return 6;
    }
};