stdassertmemarchive_signaturearchive_end_of_headerpe_signaturepe_pointer_offsetHeaderIMAGE_NT_OPTIONAL_HDR32_MAGICIMAGE_NT_OPTIONAL_HDR64_MAGICDllFlagsSubsystemOptionalHeaderIMAGE_NUMBEROF_DIRECTORY_ENTRIESImageDataDirectoryBaseRelocationDirectoryEntryBaseRelocationBaseRelocationTypeDebugDirectoryEntryDebugTypeTlsDirectoryEntryImportDirectoryEntryImportLookupTableEntryImportHintNameEntryExportDirectoryTableExportAddressTableEntryExportNamePointerTableEntryExportOrdinalTableEntrySectionHeaderSymbolSectionNumberSymTypeBaseTypeComplexTypeStorageClassFunctionDefinitionSectionDefinitionFileDefinitionWeakExternalDefinitionWeakExternalFlagComdatSelectionDebugInfoDefinitionErrorCoffSymtabStrtabImportHeaderImportTypeImportNameTypeRelocationIMAGEArchiveMemberHeaderLineNumber
std.coff.archive_end_of_header
常量
std.coff.archive_signature
常量
std.coff.ArchiveMemberHeader
容器
字段
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
容器
字段
first_linker
second_linker
longnames
coff
import
std.coff.ArchiveMemberHeader.parseDate
函数
pub fn parseDate(self: *const ArchiveMemberHeader) !u40
参数
self: *const ArchiveMemberHeader
std.coff.ArchiveMemberHeader.parseField
函数
fn parseField(field: []const u8, T: type, base: u8) !T
参数
field: []const u8
T: type
base: u8
std.coff.ArchiveMemberHeader.parseFileMode
函数
pub fn parseFileMode(self: *const ArchiveMemberHeader) !u20
参数
self: *const ArchiveMemberHeader
std.coff.ArchiveMemberHeader.parseGroupId
函数
pub fn parseGroupId(self: *const ArchiveMemberHeader) !u20
参数
self: *const ArchiveMemberHeader
std.coff.ArchiveMemberHeader.parseName
函数
直接从头部读取成员名称,或在提供长名称成员时从其中查找名称。
pub fn parseName( self: *const ArchiveMemberHeader, opt_longnames: ?[]const u8, ) ![]const u8
参数
self: *const ArchiveMemberHeader
opt_longnames: ?[]const u8
std.coff.ArchiveMemberHeader.parseSize
函数
pub fn parseSize(self: *const ArchiveMemberHeader) !u34
参数
self: *const ArchiveMemberHeader
std.coff.ArchiveMemberHeader.parseUserId
函数
pub fn parseUserId(self: *const ArchiveMemberHeader) !u20
参数
self: *const ArchiveMemberHeader
std.coff.assert
别名
别名目标 std.debug.assert
std.coff.BaseRelocation
容器
字段
offset: u12存储于 WORD 剩余的 12 位中,是相对于此块的 Page RVA 字段指定起始地址的偏移量。 此偏移量指定应用基址重定位的位置。
type: BaseRelocationType存储在 WORD 的高 4 位中,表示应应用的基址重定位类型。
std.coff.BaseRelocationDirectoryEntry
容器
字段
page_rva: u32将映像基址加上页 RVA,再加上各偏移,得到必须应用基址重定位的虚拟地址。
block_size: u32基址重定位块的总字节数,包括 Page RVA、Block Size 字段及后续 Type/Offset 字段。
std.coff.BaseRelocationType
容器
字段
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
容器
字段
NULL = 0无类型信息或未知基本类型。Microsoft 工具使用此设置。
VOID = 1无有效类型;用于 void 指针和函数
CHAR = 2字符(有符号字节)
SHORT = 32 字节有符号整数
INT = 4自然整数类型(Windows 上通常为 4 字节)。
LONG = 54 字节有符号整数
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
容器
字段
data: []const u8
is_loaded: bool
is_image: bool
coff_header_offset: usize
guid: [16]u8 = undefined
age: u32 = undefined
std.coff.Coff.getDataDirectories
函数
pub fn getDataDirectories(self: *const Coff) []align(1) const ImageDataDirectory
参数
self: *const Coff
std.coff.Coff.getHeader
函数
pub fn getHeader(self: Coff) Header
参数
self: Coff
std.coff.Coff.getImageBase
函数
pub fn getImageBase(self: Coff) u64
参数
self: Coff
std.coff.Coff.getNumberOfDataDirectories
函数
pub fn getNumberOfDataDirectories(self: Coff) u32
参数
self: Coff
std.coff.Coff.getOptionalHeader
函数
pub fn getOptionalHeader(self: Coff) OptionalHeader
参数
self: Coff
std.coff.Coff.getOptionalHeader32
函数
pub fn getOptionalHeader32(self: Coff) OptionalHeader.PE32
参数
self: Coff
std.coff.Coff.getOptionalHeader64
函数
pub fn getOptionalHeader64(self: Coff) OptionalHeader.@"PE32+"
参数
self: Coff
std.coff.Coff.getPdbPath
函数
pub fn getPdbPath(self: *Coff) !?[]const u8
参数
self: *Coff
std.coff.Coff.getSectionByName
函数
pub fn getSectionByName(self: *const Coff, comptime name: []const u8) ?*align(1) const SectionHeader
参数
self: *const Coff
name: []const u8
std.coff.Coff.getSectionData
函数
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
函数
pub fn getSectionDataAlloc(self: *const Coff, sec: *align(1) const SectionHeader, allocator: mem.Allocator) ![]u8
参数
std.coff.Coff.getSectionHeaders
函数
pub fn getSectionHeaders(self: *const Coff) []align(1) const SectionHeader
参数
self: *const Coff
std.coff.Coff.getSectionHeadersAlloc
函数
pub fn getSectionHeadersAlloc(self: *const Coff, allocator: mem.Allocator) ![]SectionHeader
参数
std.coff.Coff.getSectionName
函数
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
函数
pub fn getStrtab(self: *const Coff) error{InvalidStrtabSize}!?Strtab
参数
self: *const Coff
错误
- InvalidStrtabSize
std.coff.Coff.getSymtab
函数
pub fn getSymtab(self: *const Coff) ?Symtab
参数
self: *const Coff
std.coff.Coff.init
函数
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
函数
pub fn strtabRequired(self: *const Coff) bool
参数
self: *const Coff
std.coff.ComdatSelection
容器
字段
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
容器
字段
NULL = 0无派生类型;该符号是简单标量变量。
POINTER = 16此符号是指向基类型的指针。
FUNCTION = 32该符号是返回基本类型的函数。
ARRAY = 48此符号是基类型的数组。
_
std.coff.DebugDirectoryEntry
容器
字段
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
容器
字段
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
容器
字段
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
容器
字段
_reserved_0: u5 = 0
HIGH_ENTROPY_VA: bool = false映像可以处理高熵 64 位虚拟地址空间。
DYNAMIC_BASE: bool = falseDLL 可以在加载时重定位。
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 = falseWDM 驱动程序。
GUARD_CF: bool = false映像支持控制流防护(CFG)。
TERMINAL_SERVER_AWARE: bool = false支持终端服务器。
std.coff.Error
错误集合
错误
- InvalidMachine
- InvalidPEHeader
- InvalidPEMagic
- MissingCoffSection
- MissingPEHeader
- MissingStringTable
std.coff.ExportAddressTableEntry
容器
字段
export_or_forwarder_rva: u32如果此地址位于导出节中,则它是导出的地址。 否则,它是一个字符串的地址,该字符串指定另一个 DLL 中的符号: <dll name>.<export name> <dll name>.#<export ordinal>
std.coff.ExportDirectoryTable
容器
字段
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
容器
字段
name_rva: u32
std.coff.ExportOrdinalTableEntry
容器
字段
unbiased_ordinal: u16
std.coff.FileDefinition
容器
字段
file_name: [18]u8给出源文件名称的 ANSI 字符串。 若小于最大长度,则以空字节填充。
std.coff.FileDefinition.getFileName
函数
pub fn getFileName(self: *const FileDefinition) []const u8
参数
self: *const FileDefinition
std.coff.FunctionDefinition
容器
字段
tag_index: u32对应 .bf(函数开始)符号记录的符号表索引。
total_size: u32函数本身的可执行代码大小。 若函数位于独立的节中,则节头的 SizeOfRawData 大于或等于此字段, 具体取决于对齐要求。
pointer_to_linenumber: u32此函数的第一个 COFF 行号条目的文件偏移量;若不存在则为零。
pointer_to_next_function: u32下一个函数记录的符号表索引。 若该函数是符号表中的最后一个函数,此字段设为零。
unused: [2]u8
std.coff.Header
容器
字段
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: u32COFF 符号表的文件偏移;若不存在 COFF 符号表,则为零。 对于映像,此值应为零,因为 COFF 调试信息已弃用。
number_of_symbols: u32符号表中的条目数。 可用此数据定位紧随符号表之后的字符串表。 对于映像,此值应为零,因为 COFF 调试信息已弃用。
size_of_optional_header: u16可选头的大小。可执行文件必须包含可选头,目标文件则不要求。 目标文件的此值应为零。头部格式见“可选头(仅映像)”。
flags: Header.Flags指示文件属性的标志。
std.coff.Header.Flags
容器
字段
RELOCS_STRIPPED: bool = false仅用于映像,适用于 Windows CE 以及 Microsoft Windows NT 及后续版本。 表示文件不包含基址重定位, 因此必须加载到其首选基址。 若该基址不可用,加载器将报告错误。 链接器默认从可执行文件(EXE)中 移除基址重定位。
EXECUTABLE_IMAGE: bool = false仅用于映像。表示映像文件有效且可运行。 若未设置此标志,则表示链接器错误。
LINE_NUMS_STRIPPED: bool = falseCOFF 行号已移除。此标志已弃用,应为零。
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
命名空间
std.coff.IMAGE_NT_OPTIONAL_HDR32_MAGIC
常量
std.coff.IMAGE_NT_OPTIONAL_HDR64_MAGIC
常量
std.coff.IMAGE_NUMBEROF_DIRECTORY_ENTRIES
常量
std.coff.IMAGE.DIRECTORY_ENTRY
容器
字段
EXPORT = 0导出目录
IMPORT = 1导入目录
RESOURCE = 2资源目录
EXCEPTION = 3异常目录
SECURITY = 4安全目录
BASERELOC = 5基址重定位表
DEBUG = 6调试目录
ARCHITECTURE = 7架构专用数据
GLOBALPTR = 8GP 的 RVA
TLS = 9TLS 目录
LOAD_CONFIG = 10加载配置目录
BOUND_IMPORT = 11标头中的绑定导入目录
IAT = 12导入地址表
DELAY_IMPORT = 13延迟加载导入描述符
COM_DESCRIPTOR = 14COM 运行时描述符
RESERVED = 15必须为零
_
std.coff.IMAGE.DIRECTORY_ENTRY.len
常量
std.coff.IMAGE.FILE
命名空间
std.coff.IMAGE.FILE.MACHINE
容器
机器类型。 Machine 字段具有以下某个值,用于指定 CPU 类型。 映像文件只能在所指定机器或模拟该机器的系统上运行。
字段
UNKNOWN = 0x0假定此字段内容适用于任何机器类型
ALPHA = 0x184Alpha AXP,32 位地址空间
ALPHA64 = 0x284Alpha 64,64 位地址空间
AM33 = 0x1d3Matsushita AM33 处理器
AMD64 = 0x8664x64
ARM = 0x1c0ARM 小端序
ARM64 = 0xaa64ARM64 小端序
ARM64EC = 0xA641使原生 ARM64 与仿真的 x64 代码能够互操作的 ABI。
ARM64X = 0xA64E允许原生 ARM64 与 ARM64EC 代码共存于同一文件的二进制格式。
ARMNT = 0x1c4ARM Thumb-2 小端序
EBC = 0xebcEFI 字节码
I386 = 0x14cIntel 386 或更新处理器及兼容处理器。
IA64 = 0x200Intel Itanium 处理器系列
LOONGARCH32 = 0x6232LoongArch 32 位处理器系列
LOONGARCH64 = 0x6264LoongArch 64 位处理器系列
M32R = 0x9041Mitsubishi M32R 小端序
MIPS16 = 0x266MIPS16
MIPSFPU = 0x366带 FPU 的 MIPS
MIPSFPU16 = 0x466带 FPU 的 MIPS16
POWERPC = 0x1f0PowerPC 小端序
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 = 0x5032RISC-V 32 位地址空间
RISCV64 = 0x5064RISC-V 64 位地址空间
RISCV128 = 0x5128RISC-V 128 位地址空间
SH3 = 0x1a2Hitachi SH3
SH3DSP = 0x1a3Hitachi SH3 DSP
SH4 = 0x1a6Hitachi SH4
SH5 = 0x1a8Hitachi SH5 处理器
THUMB = 0x1c2Thumb
WCEMIPSV2 = 0x169MIPS 小端序 WCE v2
_
std.coff.IMAGE.FILE.MACHINE.AXP64
常量
AXP 64(同 Alpha 64)
IMAGE.FILE.MACHINE
std.coff.IMAGE.FILE.MACHINE.RelocationType
类型函数
pub fn RelocationType(comptime machine: IMAGE.FILE.MACHINE) type
参数
std.coff.IMAGE.REL
命名空间
std.coff.IMAGE.REL.AMD64
容器
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 = 0x000DCLR 标记。
SREL32 = 0x000E写入目标文件的 32 位有符号、依赖跨度的值。
PAIR = 0x000F必须紧跟每个跨度相关值的一对项目。
SSPAN32 = 0x0010在链接时应用的 32 位有符号跨度相关值。
_
std.coff.IMAGE.REL.ARM
容器
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
容器
ARM64 处理器 为 ARM64 处理器定义了以下重定位类型标识。
字段
ABSOLUTE = 0x0000忽略此重定位。
ADDR32 = 0x0001目标的 32 位 VA。
ADDR32NB = 0x0002目标的 32 位 RVA。
BRANCH26 = 0x0003B 和 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 = 0x000CCLR 令牌。
SECTION = 0x000D包含目标的节的 16 位节索引。 用于支持调试信息。
ADDR64 = 0x000E重定位目标的 64 位 VA。
BRANCH19 = 0x000F用于条件 B 指令,表示指向重定位目标的 19 位偏移量。
BRANCH14 = 0x0010指向重定位目标的 14 位偏移,用于 TBZ 和 TBNZ 指令。
REL32 = 0x0011相对于重定位位置之后的字节的 32 位相对地址。
_
std.coff.IMAGE.REL.I386
容器
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 = 0x000CCLR 令牌。
SECREL7 = 0x000D相对于包含目标的节的基址的 7 位偏移量。
REL32 = 0x0014指向目标的 32 位相对位移。 支持 x86 的相对分支和调用指令。
_
std.coff.IMAGE.REL.IA64
容器
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 = 0x001560 位 PC 相对修正,始终保持为 MLX 指令束中的 BRL 指令。
PCREL60B = 0x001660 位程序计数器相对修正。 若目标位移可放入有符号 25 位字段,则将整个指令束转换为 MBB 指令束:槽位 1 为 NOP.B,槽位 2 为 25 位 BR 指令,其最低 4 位全零且不存储。
PCREL60F = 0x001760 位 PC 相对修正项。 若目标位移能放入有符号 25 位字段,则将整个组合转换为 MFB 组合:槽位 1 放置 NOP.F,槽位 2 放置 25 位 BR 指令(最低 4 位均为零并被舍弃)。
PCREL60I = 0x001860 位相对于程序计数器的修补。 如果目标位移可容纳于有符号 25 位字段,则将整个指令束转为 MIB 束:槽位 1 为 NOP.I,槽位 2 为 25 位 BR 指令,最低 4 位全为零,不予存储。
PCREL60M = 0x001960 位程序计数器相对修正。 若目标位移可放入有符号 25 位字段,则将整个指令束转换为 MMB 指令束:槽位 1 为 NOP.M,槽位 2 为 25 位 BR 指令,其最低 4 位全零且不存储。
IMMGPREL64 = 0x001a相对于 GP 的 64 位修正。
TOKEN = 0x001bCLR 标记。
GPREL32 = 0x001c32 位 GP 相对修正项。
ADDEND = 0x001F此重定位仅在紧随以下重定位之一时有效:IMM14、IMM22、IMM64、GPREL22、LTOFF22、LTOFF64、SECREL22、SECREL64I 或 SECREL32。 其值包含应用于指令束内指令的加数,不用于数据。
_
std.coff.IMAGE.REL.M32R
容器
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 = 0x000ECLR 令牌。
_
std.coff.IMAGE.REL.MIPS
容器
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
容器
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 = 0x0016CLR 令牌。
_
std.coff.IMAGE.REL.SH
容器
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" = 0x0011GP 相对值。
@"3_TOKEN" = 0x0012CLR 令牌。
M_PCRELPT = 0x0013距当前指令的偏移,以长字为单位。 若未设置 NOMODE 位,将低位的反值插入位 32,以选择 PTA 或 PTB。
M_REFLO = 0x001432 位地址的低 16 位。
M_REFHALF = 0x001532 位地址的高 16 位。
M_RELLO = 0x0016相对地址的低 16 位。
M_RELHALF = 0x0017相对地址的高 16 位。
M_PAIR = 0x0018此重定位仅在紧随 REFHALF、RELHALF 或 RELLO 重定位时有效。 其 SymbolTableIndex 字段包含位移,而非符号表索引。
M_NOMODE = 0x8000重定位忽略节模式。
_
std.coff.ImageDataDirectory
容器
字段
virtual_address: u32
size: u32
std.coff.ImportDirectoryEntry
容器
字段
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
容器
字段
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
容器
每个名称以 NULL 字节结尾。若 NULL 字节不在 2 字节边界上,则填充条目结构以确保 2 字节对齐。
字段
hint: u16导出名称指针表中的索引。 先尝试使用此值匹配。若失败,则在 DLL 的导出名称指针表中进行二分查找。
name: [1]u8指向以 NULL 结尾的 ASCII 名称的指针。 长度可变……
std.coff.ImportLookupTableEntry
类型函数
pub fn ImportLookupTableEntry(comptime magic: std.coff.OptionalHeader.Magic) type
参数
magic: std.coff.OptionalHeader.Magic
std.coff.ImportNameType
容器
字段
ORDINAL = 0导入按序号指定。这表示导入标头的 Ordinal/Hint 字段值是导入序号。如果未指定此常量, 则应始终将 Ordinal/Hint 字段解释为导入提示。
NAME = 1导入名称与公开符号名称相同。
NAME_NOPREFIX = 2导入名称为公开符号名称,但跳过前导 ?、@ 或可选的 _。
NAME_UNDECORATE = 3导入名称为公开符号名称,但省略开头的 ?、@ 或可选的 _,并在首个 @ 处截断。
NAME_EXPORTAS = 4
_
std.coff.ImportType
容器
字段
CODE = 0可执行代码。
DATA = 1数据。
CONST = 2在 .def 文件中指定为 CONST。
_
std.coff.LineNumber
容器
字段
type: extern union {
symbol_table_index: u32,
virtual_address: u32,
}
line_number: u16
std.coff.LineNumber.sizeOf
函数
pub fn sizeOf() comptime_int
std.coff.mem
别名
别名目标 std.mem
std.coff.OptionalHeader
容器
字段
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+"
容器
字段
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
容器
字段
std.coff.OptionalHeader.PE32
容器
字段
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
常量
std.coff.pe_signature
常量
std.coff.Relocation
容器
字段
virtual_address: u32
symbol_table_index: u32
type: u16
std.coff.Relocation.sizeOf
函数
pub fn sizeOf() comptime_int
std.coff.SectionDefinition
容器
字段
length: u32节数据的大小,与节头中的 SizeOfRawData 相同。
number_of_relocations: u16该节的重定位条目数量。
number_of_linenumbers: u16该节的行号条目数量。
checksum: u32公共数据的校验和。节头中设置 IMAGE_SCN_LNK_COMDAT 标志时适用。
number: u16关联节在节表中的从 1 开始的索引。在 COMDAT 选择设置为 5 时使用。
selection: ComdatSelectionCOMDAT 选择编号。仅当该节为 COMDAT 节时适用。
unused: [3]u8
std.coff.SectionHeader
容器
字段
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
容器
字段
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
容器
字段
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
函数
pub fn alignment(a: Align) ?std.mem.Alignment
参数
a: Align
std.coff.SectionHeader.Flags.Align.fromByteUnits
函数
pub fn fromByteUnits(n: u16) Align
参数
n: u16
std.coff.SectionHeader.Flags.Align.toByteUnits
函数
pub fn toByteUnits(a: Align) ?u16
参数
a: Align
std.coff.SectionHeader.getAlignment
函数
仅适用于 COFF 对象中的节头。
pub fn getAlignment(self: SectionHeader) ?u16
参数
self: SectionHeader
std.coff.SectionHeader.getName
函数
pub fn getName(self: *align(1) const SectionHeader) ?[]const u8
参数
self: *align(1) const SectionHeader
std.coff.SectionHeader.getNameOffset
函数
pub fn getNameOffset(self: SectionHeader) ?u32
参数
self: SectionHeader
std.coff.SectionHeader.isCode
函数
pub fn isCode(self: SectionHeader) bool
参数
self: SectionHeader
std.coff.SectionHeader.isComdat
函数
pub fn isComdat(self: SectionHeader) bool
参数
self: SectionHeader
std.coff.SectionHeader.setAlignment
函数
pub fn setAlignment(self: *SectionHeader, new_alignment: u16) void
参数
self: *SectionHeader
new_alignment: u16
std.coff.SectionNumber
容器
字段
UNDEFINED = 0此符号记录尚未分配节。 值为零表示引用的是在其他位置定义的外部符号。 非零值表示公共符号,其大小由该值指定。
ABSOLUTE = -1符号具有绝对值(不可重定位),且不是地址。
DEBUG = -2此符号提供一般类型或调试信息,但不对应某个节。 微软工具将此设置与 .file 记录(存储类 FILE)配合使用。
_
std.coff.std
别名
别名目标 std
std.coff.StorageClass
容器
字段
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 = 13Typedef 条目。
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 = 103Microsoft 工具及传统 COFF 格式用于源文件符号记录的值。 该符号后跟辅助记录,给出文件名称。
SECTION = 104节的定义(Microsoft 工具改用 STATIC 存储类)。
WEAK_EXTERNAL = 105弱外部符号。更多信息参见辅助格式 3:弱外部符号。
CLR_TOKEN = 107CLR 令牌符号。名称为由令牌十六进制值构成的 ASCII 字符串。 更多信息参见 CLR Token Definition (Object Only)。
_
std.coff.Strtab
容器
字段
buffer: []const u8
std.coff.Strtab.get
函数
pub fn get(self: Strtab, off: u32) []const u8
参数
self: Strtab
off: u32
std.coff.Subsystem
容器
字段
UNKNOWN = 0未知子系统
NATIVE = 1设备驱动程序和原生 Windows 进程
WINDOWS_GUI = 2Windows 图形用户界面(GUI)子系统
WINDOWS_CUI = 3Windows 字符子系统
OS2_CUI = 5OS/2 字符子系统
POSIX_CUI = 7Posix 字符子系统
NATIVE_WINDOWS = 8原生 Win9x 驱动程序
WINDOWS_CE_GUI = 9Windows CE
EFI_APPLICATION = 10可扩展固件接口(EFI)应用程序。
EFI_BOOT_SERVICE_DRIVER = 11具有启动服务的 EFI 驱动程序
EFI_RUNTIME_DRIVER = 12具有运行时服务的 EFI 驱动程序
EFI_ROM = 13EFI ROM 映像
XBOX = 14XBOX
WINDOWS_BOOT_APPLICATION = 16Windows 启动应用程序
_
std.coff.Symbol
容器
字段
name: [8]u8
value: u32
section_number: SectionNumber
type: SymType
storage_class: StorageClass
number_of_aux_symbols: u8
std.coff.Symbol.getName
函数
pub fn getName(self: *const Symbol) ?[]const u8
参数
self: *const Symbol
std.coff.Symbol.getNameOffset
函数
pub fn getNameOffset(self: Symbol) ?u32
参数
self: Symbol
std.coff.Symbol.sizeOf
函数
pub fn sizeOf() comptime_int
std.coff.Symtab
容器
字段
buffer: []const u8
std.coff.Symtab.asDebugInfo
函数
fn asDebugInfo(raw: []const u8) DebugInfoDefinition
参数
raw: []const u8
std.coff.Symtab.asFileDef
函数
fn asFileDef(raw: []const u8) FileDefinition
参数
raw: []const u8
std.coff.Symtab.asFuncDef
函数
fn asFuncDef(raw: []const u8) FunctionDefinition
参数
raw: []const u8
std.coff.Symtab.asSectDef
函数
fn asSectDef(raw: []const u8) SectionDefinition
参数
raw: []const u8
std.coff.Symtab.asSymbol
函数
fn asSymbol(raw: []const u8) Symbol
参数
raw: []const u8
std.coff.Symtab.asWeakExtDef
函数
fn asWeakExtDef(raw: []const u8) WeakExternalDefinition
参数
raw: []const u8
std.coff.Symtab.at
函数
存活时间与 Symtab 实例相同。
pub fn at(self: Symtab, index: usize, tag: Tag) Record
参数
std.coff.Symtab.len
函数
pub fn len(self: Symtab) usize
参数
self: Symtab
std.coff.Symtab.Record
容器
字段
symbol: Symbol
debug_info: DebugInfoDefinition
func_def: FunctionDefinition
weak_ext: WeakExternalDefinition
file_def: FileDefinition
sect_def: SectionDefinition
std.coff.Symtab.slice
函数
pub fn slice(self: Symtab, start: usize, end: ?usize) Slice
参数
std.coff.Symtab.Slice
容器
字段
buffer: []const u8
num: usize
count: usize = 0
std.coff.Symtab.Slice.next
函数
存活时间与 Symtab 实例相同。
pub fn next(self: *Slice) ?Symbol
参数
self: *Slice
std.coff.Symtab.Tag
容器
字段
symbol
debug_info
func_def
weak_ext
file_def
sect_def
std.coff.SymType
容器
字段
complex_type: ComplexType
base_type: BaseType
std.coff.TlsDirectoryEntry
类型函数
pub fn TlsDirectoryEntry(comptime magic: std.coff.OptionalHeader.Magic) type
参数
magic: std.coff.OptionalHeader.Magic
std.coff.WeakExternalDefinition
容器
字段
tag_index: u32sym2 的符号表索引;找不到 sym1 时,链接到该符号。
flag: WeakExternalFlagIMAGE_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
函数
pub fn sizeOf() comptime_int
std.coff.WeakExternalFlag
容器
字段
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;
}
};