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

第 1 行

可执行与可链接格式。

std.elf.Addr

常量

第 1737 行

已弃用,请使用 std.elf.ElfN.Addr

std.elf.ar_hdr

容器

第 3374 行

字段

ar_name: [16]u8

成员文件名,有时以 / 终止。

ar_date: [12]u8

文件日期,自纪元起的十进制秒数。

ar_uid: [6]u8

ASCII 格式的用户 ID。

ar_gid: [6]u8

ASCII 格式的组 ID。

ar_mode: [8]u8

文件模式,以 ASCII 八进制表示。

ar_size: [10]u8

文件大小,以 ASCII 十进制表示。

ar_fmag: [2]u8

始终包含 ARFMAG。

std.elf.ar_hdr.date

函数

第 3396 行

pub fn date(self: ar_hdr) std.fmt.ParseIntError!u64

参数

self: ar_hdr

错误

InvalidCharacter

输入为空或包含无效字符。

Overflow

结果无法由指定类型容纳。

std.elf.ar_hdr.isStrtab

函数

第 3406 行

pub fn isStrtab(self: ar_hdr) bool

参数

self: ar_hdr

std.elf.ar_hdr.isSymdef

函数

第 3418 行

pub fn isSymdef(self: ar_hdr) bool

参数

self: ar_hdr

std.elf.ar_hdr.isSymdefSorted

函数

第 3422 行

pub fn isSymdefSorted(self: ar_hdr) bool

参数

self: ar_hdr

std.elf.ar_hdr.isSymtab

函数

第 3410 行

pub fn isSymtab(self: ar_hdr) bool

参数

self: ar_hdr

std.elf.ar_hdr.isSymtab64

函数

第 3414 行

pub fn isSymtab64(self: ar_hdr) bool

参数

self: ar_hdr

std.elf.ar_hdr.name

函数

第 3426 行

pub fn name(self: *const ar_hdr) ?[]const u8

参数

self: *const ar_hdr

std.elf.ar_hdr.nameOffset

函数

第 3433 行

pub fn nameOffset(self: ar_hdr) std.fmt.ParseIntError!?u32

参数

self: ar_hdr

错误

InvalidCharacter

输入为空或包含无效字符。

Overflow

结果无法由指定类型容纳。

std.elf.ar_hdr.size

函数

第 3401 行

pub fn size(self: ar_hdr) std.fmt.ParseIntError!u32

参数

self: ar_hdr

错误

InvalidCharacter

输入为空或包含无效字符。

Overflow

结果无法由指定类型容纳。

std.elf.ARFMAG

常量

第 3455 行

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

std.elf.ARMAG

常量

第 3451 行

归档文件的起始字符串。

std.elf.ARMAG_THIN

常量

第 3453 行

精简归档文件的起始字符串。

std.elf.assert

别名

第 8 行

别名目标 std.debug.assert

std.elf.AT

类型

第 14 行

std.elf.AT.ARGC

常量

第 69 行

std.elf.AT.ARGV

常量

第 70 行

std.elf.AT.BASE

常量

第 23 行

std.elf.AT.BASE

常量

第 48 行

std.elf.AT.BASE

常量

第 90 行

std.elf.AT.BASE

常量

第 116 行

std.elf.AT.BASE

常量

第 165 行

std.elf.AT.BASE

常量

第 204 行

std.elf.AT.BASE

常量

第 230 行

std.elf.AT.BASE_PLATFORM

常量

第 133 行

std.elf.AT.BASE_PLATFORM

常量

第 215 行

std.elf.AT.BSDFLAGS

常量

第 68 行

std.elf.AT.CANARY

常量

第 32 行

std.elf.AT.CANARY

常量

第 57 行

std.elf.AT.CANARY

常量

第 99 行

std.elf.AT.CANARYLEN

常量

第 33 行

std.elf.AT.CANARYLEN

常量

第 58 行

std.elf.AT.CANARYLEN

常量

第 100 行

std.elf.AT.CHERI_STATS

常量

第 78 行

std.elf.AT.CLKTCK

常量

第 124 行

std.elf.AT.CLKTCK

常量

第 213 行

std.elf.AT.DCACHEBSIZE

常量

第 128 行

std.elf.AT.DCACHEBSIZE

常量

第 169 行

std.elf.AT.EGID

常量

第 30 行

std.elf.AT.EGID

常量

第 55 行

std.elf.AT.EGID

常量

第 97 行

std.elf.AT.EGID

常量

第 123 行

std.elf.AT.EGID

常量

第 175 行

std.elf.AT.EHDRFLAGS

常量

第 65 行

std.elf.AT.ENTRY

常量

第 25 行

std.elf.AT.ENTRY

常量

第 50 行

std.elf.AT.ENTRY

常量

第 92 行

std.elf.AT.ENTRY

常量

第 118 行

std.elf.AT.ENTRY

常量

第 167 行

std.elf.AT.ENTRY

常量

第 206 行

std.elf.AT.ENTRY

常量

第 232 行

std.elf.AT.ENVC

常量

第 71 行

std.elf.AT.ENVV

常量

第 72 行

std.elf.AT.EUID

常量

第 28 行

std.elf.AT.EUID

常量

第 53 行

std.elf.AT.EUID

常量

第 95 行

std.elf.AT.EUID

常量

第 121 行

std.elf.AT.EUID

常量

第 173 行

std.elf.AT.EUID

常量

第 209 行

std.elf.AT.EXE_BASE

常量

第 219 行

std.elf.AT.EXE_SIZE

常量

第 220 行

std.elf.AT.EXECFD

常量

第 18 行

std.elf.AT.EXECFD

常量

第 43 行

std.elf.AT.EXECFD

常量

第 85 行

std.elf.AT.EXECFD

常量

第 111 行

std.elf.AT.EXECFD

常量

第 160 行

std.elf.AT.EXECFD

常量

第 199 行

std.elf.AT.EXECFD

常量

第 225 行

std.elf.AT.EXECFN

常量

第 140 行

std.elf.AT.EXECFN

常量

第 218 行

std.elf.AT.EXECPATH

常量

第 31 行

std.elf.AT.EXECPATH

常量

第 56 行

std.elf.AT.EXECPATH

常量

第 98 行

std.elf.AT.FLAGS

常量

第 24 行

std.elf.AT.FLAGS

常量

第 49 行

std.elf.AT.FLAGS

常量

第 91 行

std.elf.AT.FLAGS

常量

第 117 行

std.elf.AT.FLAGS

常量

第 166 行

std.elf.AT.FLAGS

常量

第 205 行

std.elf.AT.FLAGS

常量

第 231 行

std.elf.AT.FPUCW

常量

第 127 行

std.elf.AT.FXRNG

常量

第 74 行

std.elf.AT.GID

常量

第 29 行

std.elf.AT.GID

常量

第 54 行

std.elf.AT.GID

常量

第 96 行

std.elf.AT.GID

常量

第 122 行

std.elf.AT.GID

常量

第 210 行

std.elf.AT.HWCAP

常量

第 66 行

std.elf.AT.HWCAP

常量

第 126 行

std.elf.AT.HWCAP

常量

第 193 行

std.elf.AT.HWCAP

常量

第 212 行

std.elf.AT.HWCAP2

常量

第 67 行

std.elf.AT.HWCAP2

常量

第 135 行

std.elf.AT.HWCAP2

常量

第 194 行

std.elf.AT.HWCAP2

常量

第 217 行

std.elf.AT.HWCAP3

常量

第 79 行

std.elf.AT.HWCAP3

常量

第 138 行

std.elf.AT.HWCAP4

常量

第 80 行

std.elf.AT.HWCAP4

常量

第 139 行

std.elf.AT.ICACHEBSIZE

常量

第 129 行

std.elf.AT.ICACHEBSIZE

常量

第 170 行

std.elf.AT.IGNORE

常量

第 17 行

std.elf.AT.IGNORE

常量

第 42 行

std.elf.AT.IGNORE

常量

第 84 行

std.elf.AT.IGNORE

常量

第 110 行

std.elf.AT.IGNORE

常量

第 159 行

std.elf.AT.IGNORE

常量

第 191 行

std.elf.AT.IGNORE

常量

第 198 行

std.elf.AT.IGNORE

常量

第 224 行

std.elf.AT.IGNOREPPC

常量

第 131 行

std.elf.AT.KPRELOAD

常量

第 75 行

std.elf.AT.L1D_CACHEGEOMETRY

常量

第 150 行

std.elf.AT.L1D_CACHESHAPE

常量

第 144 行

std.elf.AT.L1D_CACHESIZE

常量

第 149 行

std.elf.AT.L1I_CACHEGEOMETRY

常量

第 148 行

std.elf.AT.L1I_CACHESHAPE

常量

第 143 行

std.elf.AT.L1I_CACHESIZE

常量

第 147 行

std.elf.AT.L2_CACHEGEOMETRY

常量

第 152 行

std.elf.AT.L2_CACHESHAPE

常量

第 145 行

std.elf.AT.L2_CACHESIZE

常量

第 151 行

std.elf.AT.L3_CACHEGEOMETRY

常量

第 154 行

std.elf.AT.L3_CACHESHAPE

常量

第 146 行

std.elf.AT.L3_CACHESIZE

常量

第 153 行

std.elf.AT.MINSIGSTKSZ

常量

第 155 行

std.elf.AT.MIPS_NOTELF

常量

第 168 行

std.elf.AT.NCPUS

常量

第 35 行

std.elf.AT.NCPUS

常量

第 60 行

std.elf.AT.NCPUS

常量

第 102 行

std.elf.AT.NOTELF

常量

第 26 行

std.elf.AT.NOTELF

常量

第 51 行

std.elf.AT.NOTELF

常量

第 93 行

std.elf.AT.NOTELF

常量

第 119 行

std.elf.AT.NOTELF

常量

第 207 行

std.elf.AT.NOTELF

常量

第 233 行

std.elf.AT.NULL

常量

第 16 行

std.elf.AT.NULL

常量

第 41 行

std.elf.AT.NULL

常量

第 83 行

std.elf.AT.NULL

常量

第 109 行

std.elf.AT.NULL

常量

第 158 行

std.elf.AT.NULL

常量

第 190 行

std.elf.AT.NULL

常量

第 197 行

std.elf.AT.NULL

常量

第 223 行

std.elf.AT.OSRELDATE

常量

第 34 行

std.elf.AT.OSRELDATE

常量

第 59 行

std.elf.AT.OSRELDATE

常量

第 101 行

std.elf.AT.PAGESIZES

常量

第 36 行

std.elf.AT.PAGESIZES

常量

第 61 行

std.elf.AT.PAGESIZES

常量

第 103 行

std.elf.AT.PAGESIZESLEN

常量

第 37 行

std.elf.AT.PAGESIZESLEN

常量

第 62 行

std.elf.AT.PAGESIZESLEN

常量

第 104 行

std.elf.AT.PAGESZ

常量

第 22 行

std.elf.AT.PAGESZ

常量

第 47 行

std.elf.AT.PAGESZ

常量

第 89 行

std.elf.AT.PAGESZ

常量

第 115 行

std.elf.AT.PAGESZ

常量

第 164 行

std.elf.AT.PAGESZ

常量

第 192 行

std.elf.AT.PAGESZ

常量

第 203 行

std.elf.AT.PAGESZ

常量

第 229 行

std.elf.AT.PHDR

常量

第 19 行

std.elf.AT.PHDR

常量

第 44 行

std.elf.AT.PHDR

常量

第 86 行

std.elf.AT.PHDR

常量

第 112 行

std.elf.AT.PHDR

常量

第 161 行

std.elf.AT.PHDR

常量

第 200 行

std.elf.AT.PHDR

常量

第 226 行

std.elf.AT.PHENT

常量

第 20 行

std.elf.AT.PHENT

常量

第 45 行

std.elf.AT.PHENT

常量

第 87 行

std.elf.AT.PHENT

常量

第 113 行

std.elf.AT.PHENT

常量

第 162 行

std.elf.AT.PHENT

常量

第 201 行

std.elf.AT.PHENT

常量

第 227 行

std.elf.AT.PHNUM

常量

第 21 行

std.elf.AT.PHNUM

常量

第 46 行

std.elf.AT.PHNUM

常量

第 88 行

std.elf.AT.PHNUM

常量

第 114 行

std.elf.AT.PHNUM

常量

第 163 行

std.elf.AT.PHNUM

常量

第 202 行

std.elf.AT.PHNUM

常量

第 228 行

std.elf.AT.PLATFORM

常量

第 125 行

std.elf.AT.PLATFORM

常量

第 211 行

std.elf.AT.PS_STRINGS

常量

第 73 行

std.elf.AT.RANDOM

常量

第 134 行

std.elf.AT.RANDOM

常量

第 216 行

std.elf.AT.RGID

常量

第 176 行

std.elf.AT.RSEQ_ALIGN

常量

第 137 行

std.elf.AT.RSEQ_FEATURE_SIZE

常量

第 136 行

std.elf.AT.RUID

常量

第 174 行

std.elf.AT.SECURE

常量

第 132 行

std.elf.AT.SECURE

常量

第 214 行

std.elf.AT.STACKBASE

常量

第 172 行

std.elf.AT.STACKPROT

常量

第 38 行

std.elf.AT.STACKPROT

常量

第 64 行

std.elf.AT.STACKPROT

常量

第 106 行

std.elf.AT.SUN_CPU

常量

第 184 行

std.elf.AT.SUN_EMUL_ENTRY

常量

第 185 行

std.elf.AT.SUN_EMUL_EXECFD

常量

第 186 行

std.elf.AT.SUN_EXECNAME

常量

第 187 行

std.elf.AT.SUN_HWCAP

常量

第 182 行

std.elf.AT.SUN_IFLUSH

常量

第 183 行

std.elf.AT.SUN_LDELF

常量

第 177 行

std.elf.AT.SUN_LDNAME

常量

第 179 行

std.elf.AT.SUN_LDSHDR

常量

第 178 行

std.elf.AT.SUN_LPGSIZE

常量

第 180 行

std.elf.AT.SUN_PLATFORM

常量

第 181 行

std.elf.AT.SYSINFO

常量

第 141 行

std.elf.AT.SYSINFO_EHDR

常量

第 142 行

std.elf.AT.TIMEKEEP

常量

第 63 行

std.elf.AT.TIMEKEEP

常量

第 105 行

std.elf.AT.UCACHEBSIZE

常量

第 130 行

std.elf.AT.UCACHEBSIZE

常量

第 171 行

std.elf.AT.UID

常量

第 27 行

std.elf.AT.UID

常量

第 52 行

std.elf.AT.UID

常量

第 94 行

std.elf.AT.UID

常量

第 120 行

std.elf.AT.UID

常量

第 208 行

std.elf.AT.USRSTACKBASE

常量

第 76 行

std.elf.AT.USRSTACKLIM

常量

第 77 行

std.elf.Auxv

类型

第 1688 行

std.elf.builtin

常量

第 3 行

std.elf.Chdr

类型

第 1725 行

已弃用,请使用 std.elf.ElfN.Chdr

std.elf.CLASS

容器

第 1761 行

字段

NONE = 0
@"32" = 1
@"64" = 2
_

std.elf.CLASS.ElfN

类型函数

第 1777 行

pub fn ElfN(comptime class: CLASS) type

参数

class: CLASS

std.elf.CLASS.NUM

常量

第 1767 行

std.elf.CLASS.size

函数

第 1769 行

pub inline fn size(class: CLASS) u8

参数

class: CLASS

std.elf.COMPRESS

容器

第 2593 行

字段

ZLIB = 1
ZSTD = 2
LOOS = 0x60000000
HIOS = 0x6fffffff
LOPROC = 0x70000000
HIPROC = 0x7fffffff
_

std.elf.DATA

容器

第 1794 行

字段

NONE = 0
@"2LSB" = 1
@"2MSB" = 2
_

std.elf.DATA.endian

函数

第 1802 行

pub inline fn endian(data: DATA) std.lang.Endian

参数

data: DATA

std.elf.DATA.NUM

常量

第 1800 行

std.elf.DF_1_CONFALT

常量

第 433 行

std.elf.DF_1_DIRECT

常量

第 428 行

std.elf.DF_1_DISPRELDNE

常量

第 435 行

std.elf.DF_1_DISPRELPND

常量

第 436 行

std.elf.DF_1_EDITED

常量

第 441 行

std.elf.DF_1_ENDFILTEE

常量

第 434 行

std.elf.DF_1_GLOBAL

常量

第 421 行

std.elf.DF_1_GLOBAUDIT

常量

第 444 行

std.elf.DF_1_GROUP

常量

第 422 行

std.elf.DF_1_IGNMULDEF

常量

第 438 行

std.elf.DF_1_INITFIRST

常量

第 425 行

std.elf.DF_1_INTERPOSE

常量

第 430 行

std.elf.DF_1_LOADFLTR

常量

第 424 行

std.elf.DF_1_NODEFLIB

常量

第 431 行

std.elf.DF_1_NODELETE

常量

第 423 行

std.elf.DF_1_NODIRECT

常量

第 437 行

std.elf.DF_1_NODUMP

常量

第 432 行

std.elf.DF_1_NOHDR

常量

第 440 行

std.elf.DF_1_NOKSYMS

常量

第 439 行

std.elf.DF_1_NOOPEN

常量

第 426 行

std.elf.DF_1_NORELOC

常量

第 442 行

std.elf.DF_1_NOW

常量

第 420 行

std.elf.DF_1_ORIGIN

常量

第 427 行

std.elf.DF_1_PIE

常量

第 447 行

std.elf.DF_1_SINGLETON

常量

第 445 行

std.elf.DF_1_STUB

常量

第 446 行

std.elf.DF_1_SYMINTPOSE

常量

第 443 行

std.elf.DF_1_TRANS

常量

第 429 行

std.elf.DF_BIND_NOW

常量

第 417 行

std.elf.DF_ORIGIN

常量

第 414 行

std.elf.DF_STATIC_TLS

常量

第 418 行

std.elf.DF_SYMBOLIC

常量

第 415 行

std.elf.DF_TEXTREL

常量

第 416 行

std.elf.DT_ADDRNUM

常量

第 311 行

std.elf.DT_ADDRRNGHI

常量

第 310 行

std.elf.DT_ADDRRNGLO

常量

第 298 行

std.elf.DT_ALPHA_NUM

常量

第 394 行

std.elf.DT_ALPHA_PLTRO

常量

第 393 行

std.elf.DT_AUDIT

常量

第 306 行

std.elf.DT_AUXILIARY

常量

第 327 行

std.elf.DT_BIND_NOW

常量

第 261 行

std.elf.DT_CHECKSUM

常量

第 286 行

std.elf.DT_CONFIG

常量

第 304 行

std.elf.DT_DEBUG

常量

第 258 行

std.elf.DT_DEPAUDIT

常量

第 305 行

std.elf.DT_ENCODING

常量

第 268 行

std.elf.DT_EXTRANUM

常量

第 329 行

std.elf.DT_FEATURE_1

常量

第 290 行

std.elf.DT_FILTER

常量

第 328 行

std.elf.DT_FINI

常量

第 250 行

std.elf.DT_FINI_ARRAY

常量

第 263 行

std.elf.DT_FINI_ARRAYSZ

常量

第 265 行

std.elf.DT_FLAGS

常量

第 267 行

std.elf.DT_FLAGS_1

常量

第 318 行

std.elf.DT_GNU_CONFLICT

常量

第 302 行

std.elf.DT_GNU_CONFLICTSZ

常量

第 284 行

std.elf.DT_GNU_HASH

常量

第 299 行

std.elf.DT_GNU_LIBLIST

常量

第 303 行

std.elf.DT_GNU_LIBLISTSZ

常量

第 285 行

std.elf.DT_GNU_PRELINKED

常量

第 283 行

std.elf.DT_HASH

常量

第 241 行

std.elf.DT_HIOS

常量

第 277 行

std.elf.DT_HIPROC

常量

第 279 行

std.elf.DT_IA_64_NUM

常量

第 407 行

std.elf.DT_IA_64_PLT_RESERVE

常量

第 406 行

std.elf.DT_INIT

常量

第 249 行

std.elf.DT_INIT_ARRAY

常量

第 262 行

std.elf.DT_INIT_ARRAYSZ

常量

第 264 行

std.elf.DT_JMPREL

常量

第 260 行

std.elf.DT_LOOS

常量

第 276 行

std.elf.DT_LOPROC

常量

第 278 行

std.elf.DT_MIPS_AUX_DYNAMIC

常量

第 385 行

std.elf.DT_MIPS_BASE_ADDRESS

常量

第 339 行

std.elf.DT_MIPS_COMPACT_SIZE

常量

第 383 行

std.elf.DT_MIPS_CONFLICT

常量

第 341 行

std.elf.DT_MIPS_CONFLICTNO

常量

第 344 行

std.elf.DT_MIPS_CXX_FLAGS

常量

第 368 行

std.elf.DT_MIPS_DELTA_CLASS

常量

第 351 行

std.elf.DT_MIPS_DELTA_CLASS_NO

常量

第 352 行

std.elf.DT_MIPS_DELTA_CLASSSYM

常量

第 364 行

std.elf.DT_MIPS_DELTA_CLASSSYM_NO

常量

第 366 行

std.elf.DT_MIPS_DELTA_INSTANCE

常量

第 354 行

std.elf.DT_MIPS_DELTA_INSTANCE_NO

常量

第 355 行

std.elf.DT_MIPS_DELTA_RELOC

常量

第 357 行

std.elf.DT_MIPS_DELTA_RELOC_NO

常量

第 358 行

std.elf.DT_MIPS_DELTA_SYM

常量

第 360 行

std.elf.DT_MIPS_DELTA_SYM_NO

常量

第 362 行

std.elf.DT_MIPS_DYNSTR_ALIGN

常量

第 377 行

std.elf.DT_MIPS_FLAGS

常量

第 338 行

std.elf.DT_MIPS_GOTSYM

常量

第 348 行

std.elf.DT_MIPS_GP_VALUE

常量

第 384 行

std.elf.DT_MIPS_HIDDEN_GOTIDX

常量

第 373 行

std.elf.DT_MIPS_HIPAGENO

常量

第 349 行

std.elf.DT_MIPS_ICHECKSUM

常量

第 336 行

std.elf.DT_MIPS_INTERFACE

常量

第 376 行

std.elf.DT_MIPS_INTERFACE_SIZE

常量

第 378 行

std.elf.DT_MIPS_IVERSION

常量

第 337 行

std.elf.DT_MIPS_LIBLIST

常量

第 342 行

std.elf.DT_MIPS_LIBLISTNO

常量

第 345 行

std.elf.DT_MIPS_LOCAL_GOTIDX

常量

第 372 行

std.elf.DT_MIPS_LOCAL_GOTNO

常量

第 343 行

std.elf.DT_MIPS_LOCALPAGE_GOTIDX

常量

第 371 行

std.elf.DT_MIPS_MSYM

常量

第 340 行

std.elf.DT_MIPS_NUM

常量

第 391 行

std.elf.DT_MIPS_OPTIONS

常量

第 375 行

std.elf.DT_MIPS_PERF_SUFFIX

常量

第 381 行

std.elf.DT_MIPS_PIXIE_INIT

常量

第 369 行

std.elf.DT_MIPS_PLTGOT

常量

第 387 行

std.elf.DT_MIPS_PROTECTED_GOTIDX

常量

第 374 行

std.elf.DT_MIPS_RLD_MAP

常量

第 350 行

std.elf.DT_MIPS_RLD_MAP_REL

常量

第 390 行

std.elf.DT_MIPS_RLD_TEXT_RESOLVE_ADDR

常量

第 379 行

std.elf.DT_MIPS_RLD_VERSION

常量

第 334 行

std.elf.DT_MIPS_RWPLT

常量

第 389 行

std.elf.DT_MIPS_SYMBOL_LIB

常量

第 370 行

std.elf.DT_MIPS_SYMTABNO

常量

第 346 行

std.elf.DT_MIPS_TIME_STAMP

常量

第 335 行

std.elf.DT_MIPS_UNREFEXTNO

常量

第 347 行

std.elf.DT_MOVEENT

常量

第 288 行

std.elf.DT_MOVESZ

常量

第 289 行

std.elf.DT_MOVETAB

常量

第 308 行

std.elf.DT_NEEDED

常量

第 238 行

std.elf.DT_NIOS2_GP

常量

第 412 行

std.elf.DT_NULL

常量

第 237 行

std.elf.DT_NUM

常量

第 275 行

std.elf.DT_PLTGOT

常量

第 240 行

std.elf.DT_PLTPAD

常量

第 307 行

std.elf.DT_PLTPADSZ

常量

第 287 行

std.elf.DT_PLTREL

常量

第 257 行

std.elf.DT_PLTRELSZ

常量

第 239 行

std.elf.DT_POSFLAG_1

常量

第 291 行

std.elf.DT_PPC_GOT

常量

第 396 行

std.elf.DT_PPC_NUM

常量

第 398 行

std.elf.DT_PPC_OPT

常量

第 397 行

std.elf.DT_PPC64_GLINK

常量

第 400 行

std.elf.DT_PPC64_NUM

常量

第 404 行

std.elf.DT_PPC64_OPD

常量

第 401 行

std.elf.DT_PPC64_OPDSZ

常量

第 402 行

std.elf.DT_PPC64_OPT

常量

第 403 行

std.elf.DT_PREINIT_ARRAY

常量

第 269 行

std.elf.DT_PREINIT_ARRAYSZ

常量

第 270 行

std.elf.DT_PROCNUM

别名

第 280 行

别名目标 std.elf.DT_MIPS_NUM

std.elf.DT_REL

常量

第 254 行

std.elf.DT_RELA

常量

第 244 行

std.elf.DT_RELACOUNT

常量

第 315 行

std.elf.DT_RELAENT

常量

第 246 行

std.elf.DT_RELASZ

常量

第 245 行

std.elf.DT_RELCOUNT

常量

第 316 行

std.elf.DT_RELENT

常量

第 256 行

std.elf.DT_RELR

常量

第 273 行

std.elf.DT_RELRENT

常量

第 274 行

std.elf.DT_RELRSZ

常量

第 272 行

std.elf.DT_RELSZ

常量

第 255 行

std.elf.DT_RPATH

常量

第 252 行

std.elf.DT_RUNPATH

常量

第 266 行

std.elf.DT_SONAME

常量

第 251 行

std.elf.DT_SPARC_NUM

常量

第 332 行

std.elf.DT_SPARC_REGISTER

常量

第 331 行

std.elf.DT_STRSZ

常量

第 247 行

std.elf.DT_STRTAB

常量

第 242 行

std.elf.DT_SYMBOLIC

常量

第 253 行

std.elf.DT_SYMENT

常量

第 248 行

std.elf.DT_SYMINENT

常量

第 294 行

std.elf.DT_SYMINFO

常量

第 309 行

std.elf.DT_SYMINSZ

常量

第 293 行

std.elf.DT_SYMTAB

常量

第 243 行

std.elf.DT_SYMTAB_SHNDX

常量

第 271 行

std.elf.DT_TEXTREL

常量

第 259 行

std.elf.DT_TLSDESC_GOT

常量

第 301 行

std.elf.DT_TLSDESC_PLT

常量

第 300 行

std.elf.DT_VALNUM

常量

第 296 行

std.elf.DT_VALRNGHI

常量

第 295 行

std.elf.DT_VALRNGLO

常量

第 282 行

std.elf.DT_VERDEF

常量

第 319 行

std.elf.DT_VERDEFNUM

常量

第 321 行

std.elf.DT_VERNEED

常量

第 322 行

std.elf.DT_VERNEEDNUM

常量

第 324 行

std.elf.DT_VERSIONTAGNUM

常量

第 325 行

std.elf.DT_VERSYM

常量

第 313 行

std.elf.DT_XTENSA_GOT_LOC_OFF

常量

第 409 行

std.elf.DT_XTENSA_GOT_LOC_SZ

常量

第 410 行

std.elf.Dyn

类型

第 1699 行

std.elf.DynamicSectionBufferIterator

容器

第 1125 行

字段

is_64: bool
endian: Endian
offset: u64
end_offset: u64
buf: []const u8

std.elf.DynamicSectionBufferIterator.next

函数

第 1133 行

pub fn next(it: *DynamicSectionBufferIterator) !?Elf64_Dyn

参数

std.elf.DynamicSectionIterator

容器

第 1108 行

字段

is_64: bool
endian: Endian
offset: u64
end_offset: u64
file_reader: *Io.File.Reader

std.elf.DynamicSectionIterator.next

函数

第 1116 行

pub fn next(it: *DynamicSectionIterator) !?Elf64_Dyn

参数

std.elf.Ehdr

类型

第 1694 行

已弃用,使用 std.elf.ElfN.Ehdr

std.elf.EhdrFlags

容器

第 3546 行

字段

int: u32
loongarch: Loongarch
sparc: Sparc

std.elf.EhdrFlags.Loongarch

容器

第 3551 行

字段

base_abi_modifier: BaseAbiModifier
abi_extension: AbiExtension
abi_version: u2
reserved: u24 = 0

std.elf.EhdrFlags.Loongarch.AbiExtension

容器

第 3563 行

字段

base = 0
_

std.elf.EhdrFlags.Loongarch.BaseAbiModifier

容器

第 3557 行

字段

s = 1
f = 2
d = 3
_

std.elf.EhdrFlags.Sparc

容器

第 3566 行

字段

mm: MemoryModel
_reserved1: u6 = 0
ext: Extensions
_reserved2: u8 = 0

std.elf.EhdrFlags.Sparc.Extensions

容器

第 3581 行

字段

@"32plus": bool

在 SPARC v9 上使用 SPARC v8 ABI(32 位指针),也称为 v8+。

sun_us1: bool

使用 Sun UltraSPARC 扩展。

hal_r1: bool

使用 HaL R1 扩展。

sun_us3: bool

使用 Sun UltraSPARC III 扩展。

_reserved: u11 = 0
le_data: bool

使用小端序数据(SPARC v9+)。

std.elf.EhdrFlags.Sparc.MemoryModel

容器

第 3572 行

字段

tso = 0

全存储定序

pso = 1

部分存储顺序

rmo = 2

宽松内存序

std.elf.EI

命名空间

第 1155 行

std.elf.EI_ABIVERSION

别名

第 1174 行

已弃用,请使用 std.elf.EI.ABIVERSION

别名目标 std.elf.EI.ABIVERSION

std.elf.EI_CLASS

别名

第 1166 行

已弃用,请使用 std.elf.EI.CLASS

别名目标 std.elf.EI.CLASS

std.elf.EI_DATA

别名

第 1168 行

已弃用,请使用 std.elf.EI.DATA

别名目标 std.elf.EI.DATA

std.elf.EI_NIDENT

别名

第 1178 行

已弃用,请使用 std.elf.EI.NIDENT

别名目标 std.elf.EI.NIDENT

std.elf.EI_OSABI

别名

第 1172 行

已弃用,请使用 std.elf.EI.OSABI

别名目标 std.elf.EI.OSABI

std.elf.EI_PAD

别名

第 1176 行

已弃用,请使用 std.elf.EI.PAD

别名目标 std.elf.EI.PAD

std.elf.EI_VERSION

别名

第 1170 行

已弃用,请使用 std.elf.EI.VERSION

别名目标 std.elf.EI.VERSION

std.elf.EI.ABIVERSION

常量

第 1160 行

std.elf.EI.CLASS

常量

第 1156 行

std.elf.EI.DATA

常量

第 1157 行

std.elf.EI.NIDENT

常量

第 1162 行

std.elf.EI.OSABI

常量

第 1159 行

std.elf.EI.PAD

常量

第 1161 行

std.elf.EI.VERSION

常量

第 1158 行

std.elf.Elf_MIPS_ABIFlags_v0

容器

第 1674 行

字段

version: Half
isa_level: u8
isa_rev: u8
gpr_size: u8
cpr1_size: u8
cpr2_size: u8
fp_abi: u8
isa_ext: Word
ases: Word
flags1: Word
flags2: Word

std.elf.Elf_Options

容器

第 1649 行

字段

kind: u8
size: u8
section: Elf32_Section
info: Word

std.elf.Elf_Options_Hw

容器

第 1655 行

字段

hwp_flags1: Word
hwp_flags2: Word

std.elf.Elf32

命名空间

第 1186 行

std.elf.Elf32_Addr

类型

第 1375 行

已弃用,请使用 std.elf.Elf32.Addr

std.elf.Elf32_auxv_t

容器

第 1598 行

字段

a_type: u32
a_un: extern union {
    a_val: u32,
}

std.elf.Elf32_Chdr

容器

第 1447 行

已弃用,请使用 std.elf.Elf32.Chdr

字段

ch_type: COMPRESS
ch_size: Word
ch_addralign: Word

std.elf.Elf32_Conflict

别名

第 1673 行

别名目标 std.elf.Elf32_Addr

std.elf.Elf32_Dyn

容器

第 1547 行

字段

d_tag: Sword
d_val: Elf32_Addr

std.elf.Elf32_Ehdr

容器

第 1387 行

已弃用,请使用 std.elf.Elf32.Ehdr

字段

e_ident: [EI_NIDENT]u8
e_type: ET
e_machine: EM
e_version: Word
e_entry: Elf32_Addr
e_phoff: Elf32_Off
e_shoff: Elf32_Off
e_flags: Word
e_ehsize: Half
e_phentsize: Half
e_phnum: Half
e_shentsize: Half
e_shnum: Half
e_shstrndx: Half

std.elf.Elf32_gptab

容器

第 1634 行

字段

gt_header: extern struct {
    gt_current_g_value: Word,
    gt_unused: Word,
}
gt_entry: extern struct {
    gt_g_value: Word,
    gt_bytes: Word,
}

std.elf.Elf32_Lib

容器

第 1659 行

字段

l_name: Word
l_time_stamp: Word
l_checksum: Word
l_version: Word
l_flags: Word

std.elf.Elf32_Move

容器

第 1620 行

字段

m_value: Elf32_Xword
m_info: Word
m_poffset: Word
m_repeat: Half
m_stride: Half

std.elf.Elf32_Nhdr

容器

第 1610 行

字段

n_namesz: Word
n_descsz: Word
n_type: Word

std.elf.Elf32_Off

类型

第 1379 行

已弃用,请使用 std.elf.Elf32.Off

std.elf.Elf32_RegInfo

容器

第 1644 行

字段

ri_gprmask: Word
ri_cprmask: [4]Word
ri_gp_value: Sword

std.elf.Elf32_Rel

容器

第 1499 行

字段

r_offset: Elf32_Addr
r_info: Word

std.elf.Elf32_Rel.r_sym

函数

第 1503 行

pub inline fn r_sym(self: @This()) u24

参数

self: @This()

std.elf.Elf32_Rel.r_type

函数

第 1506 行

pub inline fn r_type(self: @This()) u8

参数

self: @This()

std.elf.Elf32_Rela

容器

第 1521 行

字段

r_offset: Elf32_Addr
r_info: Word
r_addend: Sword

std.elf.Elf32_Rela.r_sym

函数

第 1526 行

pub inline fn r_sym(self: @This()) u24

参数

self: @This()

std.elf.Elf32_Rela.r_type

函数

第 1529 行

pub inline fn r_type(self: @This()) u8

参数

self: @This()

std.elf.Elf32_Relr

别名

第 1545 行

别名目标 std.elf.Word

std.elf.Elf32_Section

类型

第 1383 行

已弃用,使用 std.elf.Section

std.elf.Elf32_Shdr

容器

第 1421 行

已弃用,使用 std.elf.Elf32.Shdr

字段

sh_name: Word
sh_type: Word
sh_flags: Word
sh_addr: Elf32_Addr
sh_offset: Elf32_Off
sh_size: Word
sh_link: Word
sh_info: Word
sh_addralign: Word
sh_entsize: Word

std.elf.Elf32_Sxword

别名

第 1369 行

已弃用,使用 std.elf.Sxword

别名目标 std.elf.Sxword

std.elf.Elf32_Sym

容器

第 1460 行

已弃用,请使用 std.elf.Elf32.Sym

字段

st_name: Word
st_value: Elf32_Addr
st_size: Word
st_info: u8
st_other: u8
st_shndx: Elf32_Section

std.elf.Elf32_Sym.st_bind

函数

第 1471 行

pub inline fn st_bind(self: @This()) u4

参数

self: @This()

std.elf.Elf32_Sym.st_type

函数

第 1468 行

pub inline fn st_type(self: @This()) u4

参数

self: @This()

std.elf.Elf32_Syminfo

容器

第 1491 行

字段

si_boundto: Half
si_flags: Half

std.elf.Elf32_Verneed

容器

第 1569 行

已弃用,请使用 std.elf.Verneed

字段

vn_version: Half
vn_cnt: Half
vn_file: Word
vn_aux: Word
vn_next: Word

std.elf.Elf32_Xword

别名

第 1367 行

已弃用,请使用 std.elf.Xword

别名目标 std.elf.Xword

std.elf.Elf32.Addr

类型

第 1187 行

std.elf.Elf32.Chdr

容器

第 1227 行

字段

type: COMPRESS
size: Word
addralign: Word

std.elf.Elf32.Ehdr

容器

第 1189 行

字段

ident: Ident
type: ET
machine: EM
version: Word
entry: Elf32.Addr
phoff: Elf32.Off
shoff: Elf32.Off
flags: EhdrFlags
ehsize: Half
phentsize: Half
phnum: Half
shentsize: Half
shnum: Half
shstrndx: Half

std.elf.Elf32.Off

类型

第 1188 行

std.elf.Elf32.Phdr

容器

第 1205 行

字段

type: PT
offset: Elf32.Off
vaddr: Elf32.Addr
paddr: Elf32.Addr
filesz: Word
memsz: Word
flags: PF
@"align": Word

std.elf.Elf32.Rel

容器

第 1250 行

字段

offset: Elf32.Addr
info: Info
addend: u0 = 0

std.elf.Elf32.Rel.Info

容器

第 1255 行

字段

type: u8
sym: u24

std.elf.Elf32.Rela

容器

第 1260 行

字段

offset: Elf32.Addr
info: Info
addend: i32

std.elf.Elf32.Rela.Info

别名

第 1265 行

别名目标 std.elf.Elf32.Rel.Info

std.elf.Elf32.Shdr

容器

第 1215 行

字段

name: Word
type: SHT
flags: packed struct(Word) { shf: SHF }
addr: Elf32.Addr
offset: Elf32.Off
size: Word
link: Word
info: Word
addralign: Word
entsize: Word

std.elf.Elf32.Sym

容器

第 1232 行

字段

name: Word
value: Elf32.Addr
size: Word
info: Info
other: Other
shndx: Section

std.elf.Elf32.Sym.Info

容器

第 1240 行

字段

type: STT
bind: STB

std.elf.Elf32.Sym.Other

容器

第 1245 行

字段

visibility: STV
unused: u5 = 0

std.elf.Elf64

命名空间

第 1276 行

std.elf.Elf64_Addr

类型

第 1377 行

已弃用,使用 std.elf.Elf64.Addr

std.elf.Elf64_auxv_t

容器

第 1604 行

字段

a_type: u64
a_un: extern union {
    a_val: u64,
}

std.elf.Elf64_Chdr

容器

第 1453 行

已弃用,使用 std.elf.Elf64.Chdr

字段

ch_type: COMPRESS
ch_reserved: Word = 0
ch_size: Elf64_Xword
ch_addralign: Elf64_Xword

std.elf.Elf64_Dyn

容器

第 1551 行

字段

d_tag: Elf64_Sxword
d_val: Elf64_Addr

std.elf.Elf64_Ehdr

容器

第 1404 行

已弃用,请使用 std.elf.Elf64.Ehdr

字段

e_ident: [EI.NIDENT]u8
e_type: ET
e_machine: EM
e_version: Word
e_entry: Elf64_Addr
e_phoff: Elf64_Off
e_shoff: Elf64_Off
e_flags: Word
e_ehsize: Half
e_phentsize: Half
e_phnum: Half
e_shentsize: Half
e_shnum: Half
e_shstrndx: Half

std.elf.Elf64_Lib

容器

第 1666 行

字段

l_name: Word
l_time_stamp: Word
l_checksum: Word
l_version: Word
l_flags: Word

std.elf.Elf64_Move

容器

第 1627 行

字段

m_value: Elf64_Xword
m_info: Elf64_Xword
m_poffset: Elf64_Xword
m_repeat: Half
m_stride: Half

std.elf.Elf64_Nhdr

容器

第 1615 行

字段

n_namesz: Word
n_descsz: Word
n_type: Word

std.elf.Elf64_Off

类型

第 1381 行

已弃用,使用 std.elf.Elf64.Off

std.elf.Elf64_Rel

容器

第 1510 行

字段

r_offset: Elf64_Addr
r_info: Elf64_Xword

std.elf.Elf64_Rel.r_sym

函数

第 1514 行

pub inline fn r_sym(self: @This()) u32

参数

self: @This()

std.elf.Elf64_Rel.r_type

函数

第 1517 行

pub inline fn r_type(self: @This()) u32

参数

self: @This()

std.elf.Elf64_Rela

容器

第 1533 行

字段

r_offset: Elf64_Addr
r_info: Elf64_Xword
r_addend: Elf64_Sxword

std.elf.Elf64_Rela.r_sym

函数

第 1538 行

pub inline fn r_sym(self: @This()) u32

参数

self: @This()

std.elf.Elf64_Rela.r_type

函数

第 1541 行

pub inline fn r_type(self: @This()) u32

参数

self: @This()

std.elf.Elf64_Relr

别名

第 1546 行

别名目标 std.elf.Elf64_Xword

std.elf.Elf64_Section

类型

第 1385 行

已弃用,使用 std.elf.Section

std.elf.Elf64_Shdr

容器

第 1434 行

已弃用,请使用 std.elf.Elf64.Shdr

字段

sh_name: Word
sh_type: Word
sh_flags: Elf64_Xword
sh_addr: Elf64_Addr
sh_offset: Elf64_Off
sh_size: Elf64_Xword
sh_link: Word
sh_info: Word
sh_addralign: Elf64_Xword
sh_entsize: Elf64_Xword

std.elf.Elf64_Sxword

类型

第 1373 行

已弃用,使用 std.elf.Sxword

std.elf.Elf64_Sym

容器

第 1476 行

已弃用,请使用 std.elf.Elf64.Sym

字段

st_name: Word
st_info: u8
st_other: u8
st_shndx: Elf64_Section
st_value: Elf64_Addr
st_size: Elf64_Xword

std.elf.Elf64_Sym.st_bind

函数

第 1487 行

pub inline fn st_bind(self: @This()) u4

参数

self: @This()

std.elf.Elf64_Sym.st_type

函数

第 1484 行

pub inline fn st_type(self: @This()) u4

参数

self: @This()

std.elf.Elf64_Syminfo

容器

第 1495 行

字段

si_boundto: Half
si_flags: Half

std.elf.Elf64_Verneed

容器

第 1577 行

已弃用,请使用 std.elf.Verneed

字段

vn_version: Half
vn_cnt: Half
vn_file: Word
vn_aux: Word
vn_next: Word

std.elf.Elf64_Xword

别名

第 1371 行

已弃用,请使用 std.elf.Xword

别名目标 std.elf.Xword

std.elf.Elf64.Addr

类型

第 1277 行

std.elf.Elf64.Chdr

容器

第 1317 行

字段

type: COMPRESS
reserved: Word = 0
size: Xword
addralign: Xword

std.elf.Elf64.Ehdr

容器

第 1279 行

字段

ident: Ident
type: ET
machine: EM
version: Word
entry: Elf64.Addr
phoff: Elf64.Off
shoff: Elf64.Off
flags: EhdrFlags
ehsize: Half
phentsize: Half
phnum: Half
shentsize: Half
shnum: Half
shstrndx: Half

std.elf.Elf64.Off

类型

第 1278 行

std.elf.Elf64.Phdr

容器

第 1295 行

字段

type: PT
flags: PF
offset: Elf64.Off
vaddr: Elf64.Addr
paddr: Elf64.Addr
filesz: Xword
memsz: Xword
@"align": Xword

std.elf.Elf64.Rel

容器

第 1334 行

字段

offset: Elf64.Addr
info: Info
addend: u0 = 0

std.elf.Elf64.Rel.Info

容器

第 1339 行

字段

type: u32
sym: u32

std.elf.Elf64.Rela

容器

第 1344 行

字段

offset: Elf64.Addr
info: Info
addend: i64

std.elf.Elf64.Rela.Info

别名

第 1349 行

别名目标 std.elf.Elf64.Rel.Info

std.elf.Elf64.Shdr

容器

第 1305 行

字段

name: Word
type: SHT
flags: packed struct(Xword) { shf: SHF, unused: Word = 0 }
addr: Elf64.Addr
offset: Elf64.Off
size: Xword
link: Word
info: Word
addralign: Xword
entsize: Xword

std.elf.Elf64.Sym

容器

第 1323 行

字段

name: Word
info: Info
other: Other
shndx: Section
value: Elf64.Addr
size: Xword

std.elf.Elf64.Sym.Info

别名

第 1331 行

别名目标 std.elf.Elf32.Sym.Info

std.elf.Elf64.Sym.Other

别名

第 1332 行

别名目标 std.elf.Elf32.Sym.Other

std.elf.ELFCLASS32

常量

第 1756 行

已弃用,请使用 @intFromEnum(std.elf.CLASS.@"32")

std.elf.ELFCLASS64

常量

第 1758 行

已弃用,请使用 @intFromEnum(std.elf.CLASS.@"64")

std.elf.ELFCLASSNONE

常量

第 1754 行

已弃用,请使用 @intFromEnum(std.elf.CLASS.NONE)

std.elf.ELFCLASSNUM

别名

第 1760 行

已弃用,请使用 @intFromEnum(std.elf.CLASS.NUM)

别名目标 std.elf.CLASS.NUM

std.elf.ELFDATA2LSB

常量

第 1789 行

已弃用,请使用 @intFromEnum(std.elf.DATA.@"2LSB")

std.elf.ELFDATA2MSB

常量

第 1791 行

已弃用,请使用 @intFromEnum(std.elf.DATA.@"2MSB")。

std.elf.ELFDATANONE

常量

第 1787 行

已弃用,请使用 @intFromEnum(std.elf.DATA.NONE)

std.elf.ELFDATANUM

别名

第 1793 行

已弃用,请使用 @intFromEnum(std.elf.DATA.NUM)

别名目标 std.elf.DATA.NUM

std.elf.ElfN

类型

第 1360 行

std.elf.EM

容器

第 1866 行

机器架构。

当前已注册的 ELF 机器架构参见: http://www.sco.com/developers/gabi/latest/ch4.eheader.html

字段

NONE = 0

无机器类型

M32 = 1

AT&T WE 32100

SPARC = 2

SUN SPARC

@"386" = 3

Intel 80386

@"68K" = 4

Motorola m68k 系列

@"88K" = 5

Motorola m88k 系列

IAMCU = 6

Intel 微控制器

@"860" = 7

Intel 80860

MIPS = 8

MIPS R3000(官方仅支持大端序)

S370 = 9

IBM System/370

MIPS_RS3_LE = 10

MIPS R3000(及 R4000)小端序,1993 年 10 月 4 日草案(已弃用)。

OLD_SPARCV9 = 11

ABI 制定之前的旧版 Sparc v9(非 gABI 分配)。

PARISC = 15

HPPA

VPP500 = 17

富士通 VPP500(也是 PowerPC 的旧值,但未由 gABI 分配)

SPARC32PLUS = 18

Sun 的“v8plus”

@"960" = 19

Intel 80960

PPC = 20

PowerPC

PPC64 = 21

64 位 PowerPC

S390 = 22

IBM S/390

SPU = 23

Sony/Toshiba/IBM 的 SPU

V800 = 36

NEC V800 系列

FR20 = 37

Fujitsu FR20

RH32 = 38

TRW RH32

MCORE = 39

Motorola M*Core,又称 RCE(也是旧 Fujitsu MMA 的值,该值未获 gABI 分配)

ARM = 40

ARM

OLD_ALPHA = 41

Digital Alpha

SH = 42

Renesas(原 Hitachi)/ SuperH SH 架构

SPARCV9 = 43

SPARC v9 64 位

TRICORE = 44

Siemens Tricore 嵌入式处理器

ARC = 45

ARC Cores

H8_300 = 46

Renesas(前身为 Hitachi)H8/300

H8_300H = 47

Renesas(前身为 Hitachi)H8/300H

H8S = 48

Renesas(原 Hitachi)H8S

H8_500 = 49

Renesas(原 Hitachi)H8/500 处理器

IA_64 = 50

Intel IA-64 处理器

MIPS_X = 51

Stanford MIPS-X

COLDFIRE = 52

Motorola Coldfire 处理器

@"68HC12" = 53

Motorola M68HC12

MMA = 54

Fujitsu 多媒体加速器

PCP = 55

Siemens PCP

NCPU = 56

Sony nCPU 嵌入式 RISC 处理器

NDR1 = 57

Denso NDR1 微处理器

STARCORE = 58

Motorola Star*Core 处理器

ME16 = 59

Toyota ME16 处理器

ST100 = 60

STMicroelectronics ST100 处理器

TINYJ = 61

Advanced Logic Corp. TinyJ 嵌入式处理器

X86_64 = 62

Advanced Micro Devices X86-64 处理器

PDSP = 63

Sony DSP 处理器

PDP10 = 64

Digital Equipment Corp. 的 PDP-10

PDP11 = 65

Digital Equipment Corp. PDP-11

FX66 = 66

Siemens FX66 微控制器

ST9PLUS = 67

意法半导体 ST9+ 8/16 位微控制器

ST7 = 68

STMicroelectronics ST7 八位微控制器

@"68HC16" = 69

Motorola MC68HC16 微控制器

@"68HC11" = 70

Motorola MC68HC11 微控制器

@"68HC08" = 71

Motorola MC68HC08 微控制器

@"68HC05" = 72

Motorola MC68HC05 微控制器

SVX = 73

Silicon Graphics SVx

ST19 = 74

STMicroelectronics ST19 8 位 cpu

VAX = 75

Digital VAX

CRIS = 76

Axis Communications 32 位嵌入式处理器

JAVELIN = 77

Infineon Technologies 32 位嵌入式 CPU

FIREPATH = 78

Element 14 的 64 位 DSP 处理器

ZSP = 79

LSI Logic 的 16 位 DSP 处理器

MMIX = 80

Donald Knuth 用于教学的 64 位处理器

HUANY = 81

Harvard 的机器无关格式

PRISM = 82

SiTera Prism

AVR = 83

Atmel AVR 八位微控制器

FR30 = 84

Fujitsu FR30

D10V = 85

Mitsubishi D10V

D30V = 86

Mitsubishi D30V 处理器

V850 = 87

Renesas V850(原 NEC V850)

M32R = 88

Renesas M32R(原 Mitsubishi M32R)处理器

MN10300 = 89

Matsushita MN10300

MN10200 = 90

Matsushita MN10200 处理器

PJ = 91

picoJava

OR1K = 92

OpenRISC 1000 32 位嵌入式处理器

ARC_COMPACT = 93

ARC International ARCompact 处理器

XTENSA = 94

Tensilica Xtensa 架构

VIDEOCORE = 95

Alphamosaic VideoCore 处理器(也是旧 Sunplus S+core7 后端的魔数,该值未获 gABI 分配)

TMM_GPP = 96

Thompson Multimedia 通用处理器

NS32K = 97

National Semiconductor 32000 系列

TPC = 98

Tenor Network TPC 处理器

SNP1K = 99

Trebia SNP 1000 处理器(也是 picoJava 曾用值,但未由 gABI 分配)

ST200 = 100

STMicroelectronics ST200 微控制器

IP2K = 101

Ubicom IP2022 微控制器

MAX = 102

MAX 处理器

CR = 103

美国国家半导体 CompactRISC

F2MC16 = 104

Fujitsu F2MC16

MSP430 = 105

TI msp430 微控制器

BLACKFIN = 106

ADI Blackfin

SE_C33 = 107

Seiko Epson 的 S1C33 处理器系列

SEP = 108

Sharp 嵌入式微处理器

ARCA = 109

Arca RISC 微处理器

UNICORE = 110

北京大学众志与北京大学微处理器研究开发中心的微处理器系列

EXCESS = 111

eXcess:可配置 16/32/64 位的嵌入式 CPU

DXP = 112

Icera Semiconductor Inc. 深度执行处理器。

ALTERA_NIOS2 = 113

Altera Nios II 软核处理器

CRX = 114

National Semiconductor CRX 处理器

XGATE = 115

Motorola XGATE 嵌入式处理器(也是 National Semiconductor CompactRISC 的旧值,该值未获 gABI 分配)

C166 = 116

Infineon C16x/XC16x 处理器

M16C = 117

Renesas M16C 系列微处理器

DSPIC30F = 118

微芯科技 dsPIC30F 数字信号控制器

CE = 119

Freescale 通信引擎 RISC 核心

M32C = 120

Renesas M32C 系列微处理器

TSK3000 = 131

Altium TSK3000 核心

RS08 = 132

Freescale RS08 嵌入式处理器

SHARC = 133

Analog Devices SHARC 系列 32 位 DSP 处理器

ECOG2 = 134

Cyan Technology eCOG2 微处理器

SCORE = 135

Sunplus S+core(及 S+core7)RISC 处理器

DSP24 = 136

New Japan Radio(NJR)24 位 DSP 处理器

VIDEOCORE3 = 137

Broadcom VideoCore III 处理器

LATTICEMICO32 = 138

Lattice FPGA 架构的 RISC 处理器

SE_C17 = 139

Seiko Epson C17 系列

TI_C6000 = 140

Texas Instruments TMS320C6000 数字信号处理器系列

TI_C2000 = 141

Texas Instruments TMS320C2000 DSP 系列

TI_C5500 = 142

Texas Instruments TMS320C55x DSP 系列

TI_ARP32 = 143

Texas Instruments 专用 RISC 处理器,32 位取指。

TI_PRU = 144

Texas Instruments 可编程实时单元

MMDSP_PLUS = 160

STMicroelectronics 64 位 VLIW 数据信号处理器。

CYPRESS_M8C = 161

Cypress M8C 微处理器

R32C = 162

Renesas R32C 系列微处理器

TRIMEDIA = 163

恩智浦半导体 TriMedia 架构系列

QDSP6 = 164

QUALCOMM DSP6 处理器

@"8051" = 165

Intel 8051 及其变体

STXP7X = 166

STMicroelectronics STxP7x 系列

NDS32 = 167

晶心科技面向紧凑代码大小的嵌入式 RISC 处理器系列

ECOG1X = 168

Cyan Technology eCOG1X 系列

MAXQ30 = 169

Dallas Semiconductor 的 MAXQ30 内核微控制器

XIMO16 = 170

New Japan Radio(NJR)16 位 DSP 处理器

MANIK = 171

M2000 可重配置 RISC 微处理器

CRAYNV2 = 172

Cray Inc. NV2 向量架构

RX = 173

Renesas RX 系列

METAG = 174

Imagination Technologies 的 Meta 处理器架构

MCST_ELBRUS = 175

MCST Elbrus 通用硬件架构

ECOG16 = 176

Cyan Technology eCOG16 系列

CR16 = 177

National Semiconductor CompactRISC 16 位处理器

ETPU = 178

Freescale 扩展时间处理单元

SLE9X = 179

Infineon Technologies SLE9X 内核

L10M = 180

Intel L10M

K10M = 181

Intel K10M

AARCH64 = 183

ARM 64 位架构

AVR32 = 185

Atmel Corporation 的 32 位微处理器系列。

STM8 = 186

STMicroeletronics STM8 八位微控制器

TILE64 = 187

Tilera TILE64 多核架构系列

TILEPRO = 188

Tilera TILEPro 多核架构系列

MICROBLAZE = 189

Xilinx MicroBlaze 32 位 RISC 软处理器内核

CUDA = 190

NVIDIA CUDA 架构

TILEGX = 191

Tilera TILE-Gx 多核架构系列

CLOUDSHIELD = 192

CloudShield 架构系列

COREA_1ST = 193

KIPO-KAIST Core-A 第一代处理器系列。

COREA_2ND = 194

KIPO-KAIST Core-A 第二代处理器系列

ARC_COMPACT2 = 195

Synopsys ARCompact V2

OPEN8 = 196

Open8 8 位 RISC 软处理器核心

RL78 = 197

Renesas RL78 系列

VIDEOCORE5 = 198

Broadcom VideoCore V 处理器

@"78K0R" = 199

Renesas 78K0R

@"56800EX" = 200

Freescale 56800EX 数字信号控制器 (DSC)

BA1 = 201

Beyond BA1 CPU 架构

BA2 = 202

Beyond BA2 CPU 架构

XCORE = 203

XMOS xCORE 处理器系列

MCHP_PIC = 204

Microchip 8 位 PIC(r) 系列

INTELGT = 205

英特尔图形技术

KM32 = 210

KM211 KM32 32 位处理器

KMX32 = 211

KM211 KMX32 32 位处理器

KMX16 = 212

KM211 KMX16 16 位处理器

KMX8 = 213

KM211 KMX8 8 位处理器

KVARC = 214

KM211 KVARC 处理器

CDP = 215

Paneve CDP 架构系列

COGE = 216

Cognitive 智能内存处理器

COOL = 217

Bluechip Systems 的 CoolEngine

NORC = 218

Nanoradio 优化 RISC 架构

CSR_KALIMBA = 219

CSR Kalimba 架构系列

Z80 = 220

Zilog Z80

VISIUM = 221

Controls and Data Services 的 VISIUMcore 处理器。

FT32 = 222

FTDI Chip FT32 高性能 32 位 RISC 架构。

MOXIE = 223

Moxie 处理器系列

AMDGPU = 224

AMD GPU 架构

RISCV = 243

RISC-V

LANAI = 244

Lanai 32 位处理器

CEVA = 245

CEVA 处理器架构系列

CEVA_X2 = 246

CEVA X2 处理器系列

BPF = 247

Linux BPF - 内核内虚拟机

GRAPHCORE_IPU = 248

Graphcore 智能处理单元(IPU)

IMG1 = 249

Imagination Technologies

NFP = 250

Netronome 流处理器

VE = 251

NEC 向量引擎

CSKY = 252

C-SKY 处理器系列

ARC_COMPACT3_64 = 253

Synopsys ARCv2.3 的 64 位架构

MCS6502 = 254

MOS Technology MCS 6502 处理器

ARC_COMPACT3 = 255

Synopsys ARCv2.3 32 位处理器

KVX = 256

MPPA 处理器系列的 Kalray VLIW 核心

@"65816" = 257

WDC 65816/65C816

LOONGARCH = 258

LoongArch

KF32 = 259

ChipON KungFu32

U16_U8CORE = 260

LAPIS nX-U16/U8

TACHYUM = 261

Tachyum

@"56800EF" = 262

NXP 56800EF 数字信号控制器(DSC)

SBF = 263

Solana 字节码格式

AIENGINE = 264

AMD/Xilinx AIEngine 架构

SIMA_MLA = 265

SiMa MLA

BANG = 266

Cambricon BANG

LOONGGPU = 267

龙芯 LoongGPU

SW64 = 268

无锡先进技术研究院 SW64

AIECTRLCODE = 269

AMD/Xilinx AIEngine 控制代码

PPU = 270

T-Head PPU

AVR_OLD = 0x1057

AVR

MSP430_OLD = 0x1059

MSP430

MT = 0x2530

Morpho MT

CYGNUS_FR30 = 0x3330

FR30

WEBASSEMBLY = 0x4157

WebAssembly(LLVM 所用格式)

XC16X = 0x4688

英飞凌科技采用 C166-V2 内核的 16 位微控制器

S12Z = 0x4def

Freescale S12Z

DLX = 0x5aa5

DLX

CYGNUS_FRV = 0x5441

FRV

CYGNUS_D10V = 0x7650

D10V

CYGNUS_D30V = 0x7676

D30V

IP2K_OLD = 0x8217

Ubicom IP2xxx

CYGNUS_POWERPC = 0x9025

Cygnus PowerPC ELF

ALPHA = 0x9026

Alpha

CYGNUS_M32R = 0x9041

Cygnus M32R ELF

CYGNUS_V850 = 0x9080

V850

S390_OLD = 0xa390

旧版 S/390

XTENSA_OLD = 0xabc7

Xtensa 的旧非官方值

XSTORMY16 = 0xad45

Xstormy16

CYGNUS_MN10300 = 0xbeef

MN10300

CYGNUS_MN10200 = 0xdead

MN10200

M32C_OLD = 0xfeb0

Renesas M32C 和 M16C 处理器

IQ2000 = 0xfeba

Vitesse IQ2000

NIOS32 = 0xfebb

NIOS

CYGNUS_MEP = 0xf00d

Toshiba MeP

MOXIE_OLD = 0xfeed

Moxie 的旧非官方取值

MICROBLAZE_OLD = 0xbaab

旧版 MicroBlaze

ADAPTEVA_EPIPHANY = 0x1223

Adapteva 的 Epiphany 架构

PROPELLER = 0x5072

Parallax Propeller(P1)。 此值是非官方 ELF 值,用于:https://github.com/parallaxinc/propgcc

PROPELLER2 = 300

Parallax Propeller 2(P2)。 这是非正式 ELF 值,使用于:https://github.com/ne75/llvm-project

_

std.elf.Endian

别名

第 9 行

别名目标 std.lang.Endian

std.elf.ET

容器

第 811 行

文件类型

字段

NONE = 0

无文件类型

REL = 1

可重定位文件

EXEC = 2

可执行文件

DYN = 3

共享对象文件

CORE = 4

核心转储文件

_

std.elf.ET.HIOS

常量

第 833 行

操作系统专用代码的结束位置

std.elf.ET.HIPROC

常量

第 839 行

处理器专用代码的结束位置

std.elf.ET.LOOS

常量

第 830 行

操作系统专用编码的起点

std.elf.ET.LOPROC

常量

第 836 行

特定于处理器代码的起始位置

std.elf.genSpecialMemberName

函数

第 3441 行

fn genSpecialMemberName(comptime name: []const u8) *const [16]u8

参数

name: []const u8

std.elf.gnu_hash

命名空间

第 3465 行

std.elf.gnu_hash.calculate

函数

第 3483 行

计算名称对应的哈希值

pub fn calculate(name: []const u8) u32

参数

name: []const u8

用法示例

test calculate {
    try std.testing.expectEqual(0x00001505, calculate(""));
    try std.testing.expectEqual(0x156b2bb8, calculate("printf"));
    try std.testing.expectEqual(0x7c967e3f, calculate("exit"));
    try std.testing.expectEqual(0xbac212a0, calculate("syscall"));
    try std.testing.expectEqual(0x8ae9f18e, calculate("flapenguin.me"));
}

std.elf.gnu_hash.ChainEntry

容器

第 3476 行

字段

end_of_chain: bool
hash: u31

包含哈希值的最高位。

std.elf.gnu_hash.Header

容器

第 3469 行

字段

nbuckets: u32
symoffset: u32
bloom_size: u32
bloom_shift: u32

std.elf.GRP_COMDAT

常量

第 2347 行

std.elf.Half

类型

第 1180 行

std.elf.hash

命名空间

第 3506 行

std.elf.hash.calculate

函数

第 3507 行

pub fn calculate(name: []const u8) u32

参数

name: []const u8

std.elf.hash.Header32

容器

第 3530 行

多数架构上 SHT.HASH 节的头部,其后紧跟:

  • buckets: [nbucket]u32
  • chains: [nchain]u32

名为 name 的符号所在桶为 std.elf.hash.calculate(name) % nbuckets。

buckets[b] 是桶 b 中第一个符号的索引。若桶 b 为空,则值为 0(STN_UNDEF)。

chain[sym_index] 是与 sym_index 同桶的下一个符号的索引。若 sym_index 为桶内最后一个符号,则值为 0(STN_UNDEF)。

另见 Header64。

字段

nbucket: u32
nchain: u32

std.elf.hash.Header64

容器

第 3540 行

alpha 和 s390x 上 SHT.HASH 节的头部。紧接着是:

  • buckets: [nbucket]u64
  • chains: [nchain]u64

另请参见 Header32。

字段

nbucket: u64
nchain: u64

std.elf.Header

容器

第 843 行

所有整数均为本机字节序。

字段

is_64: bool
endian: Endian
os_abi: OSABI
abi_version: u8

此值的含义取决于 os_abi。

type: ET
machine: EM
entry: u64
phoff: u64
shoff: u64
phentsize: u16
phnum: u16
shentsize: u16
shnum: u16
shstrndx: u16

std.elf.Header.init

函数

第 957 行

pub fn init(hdr: anytype, endian: Endian) Header

参数

endian: Endian

std.elf.Header.iterateDynamicSection

函数

第 900 行

pub fn iterateDynamicSection( h: *const Header, file_reader: *Io.File.Reader, offset: u64, size: u64, ) DynamicSectionIterator

参数

h: *const Header
file_reader: *Io.File.Reader
offset: u64
size: u64

std.elf.Header.iterateDynamicSectionBuffer

函数

第 915 行

pub fn iterateDynamicSectionBuffer( h: *const Header, buf: []const u8, offset: u64, size: u64, ) DynamicSectionBufferIterator

参数

h: *const Header
buf: []const u8
offset: u64
size: u64

std.elf.Header.iterateProgramHeaders

函数

第 860 行

pub fn iterateProgramHeaders(h: *const Header, file_reader: *Io.File.Reader) ProgramHeaderIterator

参数

h: *const Header
file_reader: *Io.File.Reader

std.elf.Header.iterateProgramHeadersBuffer

函数

第 870 行

pub fn iterateProgramHeadersBuffer(h: *const Header, buf: []const u8) ProgramHeaderBufferIterator

参数

h: *const Header
buf: []const u8

std.elf.Header.iterateSectionHeaders

函数

第 880 行

pub fn iterateSectionHeaders(h: *const Header, file_reader: *Io.File.Reader) SectionHeaderIterator

参数

h: *const Header
file_reader: *Io.File.Reader

std.elf.Header.iterateSectionHeadersBuffer

函数

第 890 行

pub fn iterateSectionHeadersBuffer(h: *const Header, buf: []const u8) SectionHeaderBufferIterator

参数

h: *const Header
buf: []const u8

std.elf.Header.read

函数

第 938 行

如果此函数失败,r 的定位位置不变。

pub fn read(r: *Io.Reader) ReadError!Header

参数

r: *Io.Reader

错误

EndOfStream Error
InvalidElfClass
InvalidElfEndian
InvalidElfMagic
InvalidElfVersion
ReadFailed Error

详细诊断参见 Reader 的实现。

std.elf.Header.ReadError

错误集合

第 930 行

错误

EndOfStream Error
InvalidElfClass
InvalidElfEndian
InvalidElfMagic
InvalidElfVersion
ReadFailed Error

详细诊断参见 Reader 的实现。

std.elf.Ident

容器

第 1739 行

字段

magic: [MAGIC.len]u8 = MAGIC.*
class: CLASS
data: DATA
version: u8
osabi: OSABI
abiversion: u8
pad: [7]u8 = @splat(0)

std.elf.Io

别名

第 5 行

别名目标 std.Io

std.elf.MAGIC

常量

第 808 行

std.elf.math

别名

第 6 行

别名目标 std.math

std.elf.mem

别名

第 7 行

别名目标 std.mem

std.elf.native_endian

常量

第 11 行

std.elf.native_os

常量

第 12 行

std.elf.NT_GNU_BUILD_ID

常量

第 541 行

std.elf.OSABI

容器

第 1811 行

字段

NONE = 0

UNIX System V ABI

HPUX = 1

HP-UX 操作系统

NETBSD = 2

NetBSD

GNU = 3

GNU (Hurd/Linux)

SOLARIS = 6

Solaris

AIX = 7

AIX

IRIX = 8

IRIX

FREEBSD = 9

FreeBSD

TRU64 = 10

TRU64 UNIX

MODESTO = 11

Novell Modesto

OPENBSD = 12

OpenBSD

OPENVMS = 13

OpenVMS

NSK = 14

Hewlett-Packard Non-Stop 内核

AROS = 15

AROS

FENIXOS = 16

FenixOS

CLOUDABI = 17

Nuxi CloudABI

OPENVOS = 18

Stratus Technologies OpenVOS

CUDA = 51

NVIDIA CUDA 架构(非 gABI 分配)

AMDGPU_HSA = 64

AMD HSA 运行时(非 gABI 分配)

AMDGPU_PAL = 65

AMD PAL 运行时(未由 gABI 分配)

AMDGPU_MESA3D = 66

AMD Mesa3D 运行时(非 gABI 分配)

ARM = 97

ARM(非 gABI 分配)

STANDALONE = 255

独立(嵌入式)应用程序(非 gABI 分配)。

_

std.elf.PF

容器

第 2563 行

字段

X: bool = false
W: bool = false
R: bool = false
unused3: u17 = 0
OS: packed union {
    MASK: u8,
} = .{ .MASK = 0 }
PROC: packed union {
    MASK: u4,
} = .{ .MASK = 0 }

std.elf.PF_MASKOS

常量

第 2558 行

用于操作系统专用语义的位。

std.elf.PF_MASKPROC

常量

第 2561 行

用于处理器专用语义的位。

std.elf.PF_R

常量

第 2555 行

读取

std.elf.PF_W

常量

第 2552 行

写入

std.elf.PF_X

常量

第 2549 行

执行

std.elf.PN_XNUM

常量

第 475 行

std.elf.ProgramHeaderBufferIterator

容器

第 1004 行

字段

is_64: bool
endian: Endian
phnum: u16
phoff: u64
buf: []const u8
index: usize = 0

std.elf.ProgramHeaderBufferIterator.next

函数

第 1013 行

pub fn next(it: *ProgramHeaderBufferIterator) !?Elf64.Phdr

参数

std.elf.ProgramHeaderIterator

容器

第 983 行

字段

is_64: bool
endian: Endian
phnum: u16
phoff: u64
file_reader: *Io.File.Reader
index: usize = 0

std.elf.ProgramHeaderIterator.next

函数

第 992 行

pub fn next(it: *ProgramHeaderIterator) !?Elf64.Phdr

参数

std.elf.PT

容器

第 608 行

字段

NULL = 0

程序头表条目未使用

LOAD = 1

可加载程序段

DYNAMIC = 2

动态链接信息

INTERP = 3

程序解释器

NOTE = 4

辅助信息

SHLIB = 5

保留

PHDR = 6

头表自身的条目

TLS = 7

线程局部存储段

_

std.elf.PT.GNU_EH_FRAME

常量

第 636 行

GCC .eh_frame_hdr 段

PT

std.elf.PT.GNU_RELRO

常量

第 640 行

重定位后只读

PT

std.elf.PT.GNU_STACK

常量

第 638 行

指示栈是否可执行

PT

std.elf.PT.HIOS

常量

第 633 行

操作系统专用范围的终点

PT

std.elf.PT.HIPROC

常量

第 653 行

处理器专用范围的结束位置

PT

std.elf.PT.HISUNW

常量

第 643 行

PT

std.elf.PT.LOOS

常量

第 631 行

操作系统专用范围的起点

PT

std.elf.PT.LOPROC

常量

第 651 行

处理器专用范围的起点

PT

std.elf.PT.LOSUNW

常量

第 642 行

PT

std.elf.PT.NUM

常量

第 628 行

已定义类型的数量

std.elf.PT.SUNWBSS

常量

第 646 行

Sun 专用段

PT

std.elf.PT.SUNWSTACK

常量

第 648 行

栈段

PT

std.elf.R_AARCH64

容器

第 2693 行

AArch64 重定位。

字段

NONE = 0

无重定位。

P32_ABS32 = 1

ILP32 AArch64 重定位。 直接 32 位。

P32_COPY = 180

在运行时复制符号。

P32_GLOB_DAT = 181

创建 GOT 条目。

P32_JUMP_SLOT = 182

创建 PLT 条目。

P32_RELATIVE = 183

按程序基址调整。

P32_TLS_DTPMOD = 184

32 位模块编号。

P32_TLS_DTPREL = 185

相对于模块的偏移量,32 位。

P32_TLS_TPREL = 186

相对于 TP 的偏移量,32 位。

P32_TLSDESC = 187

TLS 描述符。

P32_IRELATIVE = 188

STT_GNU_IFUNC 重定位。

ABS64 = 257

LP64 AArch64 重定位。 直接寻址 64 位值。

ABS32 = 258

直接 32 位。

ABS16 = 259

直接寻址 16 位值。

PREL64 = 260

PC 相对 64 位值。

PREL32 = 261

相对于程序计数器的 32 位值。

PREL16 = 262

PC 相对 16 位。

MOVW_UABS_G0 = 263

直接 MOVZ 立即数,取位 15:0。

MOVW_UABS_G0_NC = 264

同样适用于 MOVK;不检查。

MOVW_UABS_G1 = 265

直接寻址 MOVZ 立即数,取位 31:16。

MOVW_UABS_G1_NC = 266

同样适用于 MOVK;不检查。

MOVW_UABS_G2 = 267

直接 MOVZ 立即数,取位 47:32。

MOVW_UABS_G2_NC = 268

同样适用于 MOVK;不检查。

MOVW_UABS_G3 = 269

直接 MOV{K,Z} 立即数,取自 63:48 位。

MOVW_SABS_G0 = 270

直接 MOV{N,Z} 立即数,取自 15:0 位。

MOVW_SABS_G1 = 271

直接寻址 MOV{N,Z} 立即数,取位 31:16。

MOVW_SABS_G2 = 272

直接 MOV{N,Z} 立即数,取位 47:32。

LD_PREL_LO19 = 273

PC 相对 LD 立即数,取自 20:2 位。

ADR_PREL_LO21 = 274

PC 相对 ADR 立即数,取自 20:0 位。

ADR_PREL_PG_HI21 = 275

页相对 ADRP 立即数,取位 32:12。

ADR_PREL_PG_HI21_NC = 276

同上;不检查溢出。

ADD_ABS_LO12_NC = 277

直接寻址 ADD 立即数,取位 11:0。

LDST8_ABS_LO12_NC = 278

同样适用于 LD/ST;不检查。

TSTBR14 = 279

PC 相对 TBZ/TBNZ 立即数,取位 15:2。

CONDBR19 = 280

PC 相对条件分支立即数,取位 20:2。

JUMP26 = 282

PC 相对 B 立即数,取自 27:2 位。

CALL26 = 283

同样适用于 CALL。

LDST16_ABS_LO12_NC = 284

直接 ADD 立即数,取自 11:1 位。

LDST32_ABS_LO12_NC = 285

位 11:2 同理。

LDST64_ABS_LO12_NC = 286

位 11:3 同理。

MOVW_PREL_G0 = 287

相对于程序计数器的 MOV{N,Z} 立即数,取位 15:0。

MOVW_PREL_G0_NC = 288

同样适用于 MOVK;不检查。

MOVW_PREL_G1 = 289

PC 相对 MOV{N,Z} 立即数,取位 31:16。

MOVW_PREL_G1_NC = 290

同样适用于 MOVK;不检查。

MOVW_PREL_G2 = 291

PC 相对 MOV{N,Z} 立即数,取自 47:32 位。

MOVW_PREL_G2_NC = 292

同样适用于 MOVK;不检查。

MOVW_PREL_G3 = 293

PC 相对 MOV{N,Z} 立即数,取位 63:48。

LDST128_ABS_LO12_NC = 299

直接寻址 ADD 立即数,取位 11:4。

MOVW_GOTOFF_G0 = 300

GOT 相对偏移,MOV{N,Z} 立即数取位 15:0。

MOVW_GOTOFF_G0_NC = 301

同样适用于 MOVK;不检查。

MOVW_GOTOFF_G1 = 302

GOT 相对偏移量,MOV{N,Z} 立即数,取自 31:16 位。

MOVW_GOTOFF_G1_NC = 303

同样适用于 MOVK;不检查。

MOVW_GOTOFF_G2 = 304

GOT 相对偏移,MOV{N,Z} 立即数取位 47:32。

MOVW_GOTOFF_G2_NC = 305

同样适用于 MOVK;不检查。

MOVW_GOTOFF_G3 = 306

相对于 GOT 的偏移,MOV{N,Z} 立即数取位 63:48。

GOTREL64 = 307

GOT 相对 64 位。

GOTREL32 = 308

GOT 相对 32 位值。

GOT_LD_PREL19 = 309

PC 相对 GOT 偏移量加载立即数,取自 20:2 位。

LD64_GOTOFF_LO15 = 310

GOT 相对偏移,LD/ST 立即数取位 14:3。

ADR_GOT_PAGE = 311

相对 P 页的 GOT 偏移,ADRP 取位 32:12。

LD64_GOT_LO12_NC = 312

直接 GOT 偏移,LD/ST 立即数取位 11:3。

LD64_GOTPAGE_LO15 = 313

GOT 页相对偏移量,LD/ST 取自 14:3 位

TLSGD_ADR_PREL21 = 512

PC 相对 ADR 立即数,取位 20:0。

TLSGD_ADR_PAGE21 = 513

页相对 ADRP 立即数,取位 32:12。

TLSGD_ADD_LO12_NC = 514

直接 ADD 立即数,取位 11:0。

TLSGD_MOVW_G1 = 515

相对于 GOT 的 MOV{N,Z},取位 31:16。

TLSGD_MOVW_G0_NC = 516

GOT 相对 MOVK 立即数,取位 15:0。

TLSLD_ADR_PREL21 = 517

与 512 类似;局部动态模型。

TLSLD_ADR_PAGE21 = 518

与 513 类似;局部动态模型。

TLSLD_ADD_LO12_NC = 519

类似于 514;本地动态模型。

TLSLD_MOVW_G1 = 520

与 515 类似;局部动态模型。

TLSLD_MOVW_G0_NC = 521

与 516 类似;局部动态模型。

TLSLD_LD_PREL19 = 522

TLS PC 相对加载立即数,取位 20:2。

TLSLD_MOVW_DTPREL_G2 = 523

TLS DTP 相对 MOV{N,Z},取位 47:32。

TLSLD_MOVW_DTPREL_G1 = 524

相对于 TLS DTP 的 MOV{N,Z},取位 31:16。

TLSLD_MOVW_DTPREL_G1_NC = 525

同上;MOVK;不检查。

TLSLD_MOVW_DTPREL_G0 = 526

TLS DTP 相对 MOV{N,Z},取位 15:0。

TLSLD_MOVW_DTPREL_G0_NC = 527

同上;MOVK;不检查。

TLSLD_ADD_DTPREL_HI12 = 528

相对于 DTP 的 ADD 立即数,取位 23:12。

TLSLD_ADD_DTPREL_LO12 = 529

DTP 相对 ADD 立即数,取位 11:0。

TLSLD_ADD_DTPREL_LO12_NC = 530

同上;不检查溢出。

TLSLD_LDST8_DTPREL_LO12 = 531

DTP 相对 LD/ST 立即数,取位 11:0。

TLSLD_LDST8_DTPREL_LO12_NC = 532

同上;不检查。

TLSLD_LDST16_DTPREL_LO12 = 533

DTP 相对 LD/ST 立即数,取位 11:1。

TLSLD_LDST16_DTPREL_LO12_NC = 534

同上;不检查。

TLSLD_LDST32_DTPREL_LO12 = 535

相对于 DTP 的 LD/ST 立即数,取位 11:2。

TLSLD_LDST32_DTPREL_LO12_NC = 536

同上;不检查。

TLSLD_LDST64_DTPREL_LO12 = 537

DTP 相对 LD/ST 立即数,取位 11:3。

TLSLD_LDST64_DTPREL_LO12_NC = 538

同上;不检查。

TLSIE_MOVW_GOTTPREL_G1 = 539

相对于 GOT 的 MOV{N,Z},取位 31:16。

TLSIE_MOVW_GOTTPREL_G0_NC = 540

相对于 GOT 的 MOVK,取位 15:0。

TLSIE_ADR_GOTTPREL_PAGE21 = 541

页相对 ADRP,取位 32:12。

TLSIE_LD64_GOTTPREL_LO12_NC = 542

直接 LD 偏移,取位 11:3。

TLSIE_LD_GOTTPREL_PREL19 = 543

相对于程序计数器的加载立即数,取位 20:2。

TLSLE_MOVW_TPREL_G2 = 544

相对于 TLS TP 的 MOV{N,Z},取位 47:32。

TLSLE_MOVW_TPREL_G1 = 545

TLS TP 相对 MOV{N,Z},取位 31:16。

TLSLE_MOVW_TPREL_G1_NC = 546

同上;MOVK;不检查。

TLSLE_MOVW_TPREL_G0 = 547

TLS TP 相对 MOV{N,Z},取位 15:0。

TLSLE_MOVW_TPREL_G0_NC = 548

同上;MOVK;不检查。

TLSLE_ADD_TPREL_HI12 = 549

TP 相对 ADD 立即数,取位 23:12。

TLSLE_ADD_TPREL_LO12 = 550

TP 相对 ADD 立即数,取位 11:0。

TLSLE_ADD_TPREL_LO12_NC = 551

同上;不检查溢出。

TLSLE_LDST8_TPREL_LO12 = 552

TP 相对 LD/ST 偏移,取位 11:0。

TLSLE_LDST8_TPREL_LO12_NC = 553

同上;不检查溢出。

TLSLE_LDST16_TPREL_LO12 = 554

相对于 TP 的 LD/ST 偏移,取位 11:1。

TLSLE_LDST16_TPREL_LO12_NC = 555

同上;不检查。

TLSLE_LDST32_TPREL_LO12 = 556

TP 相对 LD/ST 偏移量,取位 11:2。

TLSLE_LDST32_TPREL_LO12_NC = 557

同上;不检查。

TLSLE_LDST64_TPREL_LO12 = 558

TP 相对 LD/ST 偏移,取位 11:3。

TLSLE_LDST64_TPREL_LO12_NC = 559

同上;不检查。

TLSDESC_LD_PREL19 = 560

PC 相对加载立即数,取位 20:2。

TLSDESC_ADR_PREL21 = 561

PC 相对 ADR 立即数,取位 20:0。

TLSDESC_ADR_PAGE21 = 562

页相对 ADRP 立即数,取位 32:12。

TLSDESC_LD64_LO12 = 563

直接寻址 LD 偏移,取位 11:3。

TLSDESC_ADD_LO12 = 564

直接 ADD 立即数,取位 11:0。

TLSDESC_OFF_G1 = 565

GOT 相对 MOV{N,Z} 立即数,取自 31:16 位。

TLSDESC_OFF_G0_NC = 566

相对于 GOT 的 MOVK 立即数,取位 15:0;不检查。

TLSDESC_LDR = 567

松弛 LDR。

TLSDESC_ADD = 568

松弛 ADD。

TLSDESC_CALL = 569

松弛 BLR。

TLSLE_LDST128_TPREL_LO12 = 570

相对于 TP 的 LD/ST 偏移,取位 11:4。

TLSLE_LDST128_TPREL_LO12_NC = 571

同上;不检查。

TLSLD_LDST128_DTPREL_LO12 = 572

相对于 DTP 的 LD/ST 立即数,取位 11:4。

TLSLD_LDST128_DTPREL_LO12_NC = 573

同上;不检查。

COPY = 1024

在运行时复制符号。

GLOB_DAT = 1025

创建 GOT 条目。

JUMP_SLOT = 1026

创建 PLT 条目。

RELATIVE = 1027

按程序基址调整。

TLS_DTPMOD = 1028

模块编号,64 位。

TLS_DTPREL = 1029

相对于模块的偏移量,64 位。

TLS_TPREL = 1030

相对于 TP 的偏移量,64 位。

TLSDESC = 1031

TLS 描述符。

IRELATIVE = 1032

STT_GNU_IFUNC 重定位。

_

std.elf.R_LARCH

容器

第 3147 行

截至 ABI 规范 v2.50 的 LoongArch 重定位。

字段

NONE = 0
@"32" = 1
@"64" = 2
RELATIVE = 3
COPY = 4
JUMP_SLOT = 5
TLS_DTPMOD32 = 6
TLS_DTPMOD64 = 7
TLS_DTPREL32 = 8
TLS_DTPREL64 = 9
TLS_TPREL32 = 10
TLS_TPREL64 = 11
IRELATIVE = 12
TLS_DESC32 = 13
TLS_DESC64 = 14
MARK_LA = 20
MARK_PCREL = 21
SOP_PUSH_PCREL = 22
SOP_PUSH_ABSOLUTE = 23
SOP_PUSH_DUP = 24
SOP_PUSH_GPREL = 25
SOP_PUSH_TLS_TPREL = 26
SOP_PUSH_TLS_GOT = 27
SOP_PUSH_TLS_GD = 28
SOP_PUSH_PLT_PCREL = 29
SOP_ASSERT = 30
SOP_NOT = 31
SOP_SUB = 32
SOP_SL = 33
SOP_SR = 34
SOP_ADD = 35
SOP_AND = 36
SOP_IF_ELSE = 37
SOP_POP_32_S_10_5 = 38
SOP_POP_32_U_10_12 = 39
SOP_POP_32_S_10_12 = 40
SOP_POP_32_S_10_16 = 41
SOP_POP_32_S_10_16_S2 = 42
SOP_POP_32_S_5_20 = 43
SOP_POP_32_S_0_5_10_16_S2 = 44
SOP_POP_32_S_0_10_10_16_S2 = 45
SOP_POP_32_U = 46
ADD8 = 47
ADD16 = 48
ADD24 = 49
ADD32 = 50
ADD64 = 51
SUB8 = 52
SUB16 = 53
SUB24 = 54
SUB32 = 55
SUB64 = 56
GNU_VTINHERIT = 57
GNU_VTENTRY = 58
B16 = 64
B21 = 65
B26 = 66
ABS_HI20 = 67
ABS_LO12 = 68
ABS64_LO20 = 69
ABS64_HI12 = 70
PCALA_HI20 = 71
PCALA_LO12 = 72
PCALA64_LO20 = 73
PCALA64_HI12 = 74
GOT_PC_HI20 = 75
GOT_PC_LO12 = 76
GOT64_PC_LO20 = 77
GOT64_PC_HI12 = 78
GOT_HI20 = 79
GOT_LO12 = 80
GOT64_LO20 = 81
GOT64_HI12 = 82
TLS_LE_HI20 = 83
TLS_LE_LO12 = 84
TLS_LE64_LO20 = 85
TLS_LE64_HI12 = 86
TLS_IE_PC_HI20 = 87
TLS_IE_PC_LO12 = 88
TLS_IE64_PC_LO20 = 89
TLS_IE64_PC_HI12 = 90
TLS_IE_HI20 = 91
TLS_IE_LO12 = 92
TLS_IE64_LO20 = 93
TLS_IE64_HI12 = 94
TLS_LD_PC_HI20 = 95
TLS_LD_HI20 = 96
TLS_GD_PC_HI20 = 97
TLS_GD_HI20 = 98
@"32_PCREL" = 99
RELAX = 100
DELETE = 101
ALIGN = 102
PCREL20_S2 = 103
CFA = 104
ADD6 = 105
SUB6 = 106
ADD_ULEB128 = 107
SUB_ULEB128 = 108
@"64_PCREL" = 109
CALL36 = 110
TLS_DESC_PC_HI20 = 111
TLS_DESC_PC_LO12 = 112
TLS_DESC64_PC_LO20 = 113
TLS_DESC64_PC_HI12 = 114
TLS_DESC_HI20 = 115
TLS_DESC_LO12 = 116
TLS_DESC64_LO20 = 117
TLS_DESC64_HI12 = 118
TLS_DESC_LD = 119
TLS_DESC_CALL = 120
TLS_LE_HI20_R = 121
TLS_LE_ADD_R = 122
TLS_LE_LO12_R = 123
TLS_LD_PCREL20_S2 = 124
TLS_GD_PCREL20_S2 = 125
TLS_DESC_PCREL20_S2 = 126
CALL30 = 127
PCADD_HI20 = 128
PCADD_LO12 = 129
GOT_PCADD_HI20 = 130
GOT_PCADD_LO12 = 131
TLS_IE_PCADD_HI20 = 132
TLS_IE_PCADD_LO12 = 133
TLS_LD_PCADD_HI20 = 134
TLS_LD_PCADD_LO12 = 135
TLS_GD_PCADD_HI20 = 136
TLS_GD_PCADD_LO12 = 137
TLS_DESC_PCADD_HI20 = 138
TLS_DESC_PCADD_LO12 = 139
_

std.elf.R_PPC64

容器

第 3030 行

PowerPC64 重定位。

字段

NONE = 0
ADDR32 = 1
ADDR24 = 2
ADDR16 = 3
ADDR16_LO = 4
ADDR16_HI = 5
ADDR16_HA = 6
ADDR14 = 7
ADDR14_BRTAKEN = 8
ADDR14_BRNTAKEN = 9
REL24 = 10
REL14 = 11
REL14_BRTAKEN = 12
REL14_BRNTAKEN = 13
GOT16 = 14
GOT16_LO = 15
GOT16_HI = 16
GOT16_HA = 17
COPY = 19
GLOB_DAT = 20
JMP_SLOT = 21
RELATIVE = 22
REL32 = 26
PLT16_LO = 29
PLT16_HI = 30
PLT16_HA = 31
ADDR64 = 38
ADDR16_HIGHER = 39
ADDR16_HIGHERA = 40
ADDR16_HIGHEST = 41
ADDR16_HIGHESTA = 42
REL64 = 44
TOC16 = 47
TOC16_LO = 48
TOC16_HI = 49
TOC16_HA = 50
TOC = 51
ADDR16_DS = 56
ADDR16_LO_DS = 57
GOT16_DS = 58
GOT16_LO_DS = 59
PLT16_LO_DS = 60
TOC16_DS = 63
TOC16_LO_DS = 64
TLS = 67
DTPMOD64 = 68
TPREL16 = 69
TPREL16_LO = 70
TPREL16_HI = 71
TPREL16_HA = 72
TPREL64 = 73
DTPREL16 = 74
DTPREL16_LO = 75
DTPREL16_HI = 76
DTPREL16_HA = 77
DTPREL64 = 78
GOT_TLSGD16 = 79
GOT_TLSGD16_LO = 80
GOT_TLSGD16_HI = 81
GOT_TLSGD16_HA = 82
GOT_TLSLD16 = 83
GOT_TLSLD16_LO = 84
GOT_TLSLD16_HI = 85
GOT_TLSLD16_HA = 86
GOT_TPREL16_DS = 87
GOT_TPREL16_LO_DS = 88
GOT_TPREL16_HI = 89
GOT_TPREL16_HA = 90
GOT_DTPREL16_DS = 91
GOT_DTPREL16_LO_DS = 92
GOT_DTPREL16_HI = 93
GOT_DTPREL16_HA = 94
TPREL16_DS = 95
TPREL16_LO_DS = 96
TPREL16_HIGHER = 97
TPREL16_HIGHERA = 98
TPREL16_HIGHEST = 99
TPREL16_HIGHESTA = 100
DTPREL16_DS = 101
DTPREL16_LO_DS = 102
DTPREL16_HIGHER = 103
DTPREL16_HIGHERA = 104
DTPREL16_HIGHEST = 105
DTPREL16_HIGHESTA = 106
TLSGD = 107
TLSLD = 108
ADDR16_HIGH = 110
ADDR16_HIGHA = 111
TPREL16_HIGH = 112
TPREL16_HIGHA = 113
DTPREL16_HIGH = 114
DTPREL16_HIGHA = 115
REL24_NOTOC = 116
PLTSEQ = 119
PLTCALL = 120
PLTSEQ_NOTOC = 121
PLTCALL_NOTOC = 122
PCREL_OPT = 123
PCREL34 = 132
GOT_PCREL34 = 133
PLT_PCREL34 = 134
PLT_PCREL34_NOTOC = 135
TPREL34 = 146
DTPREL34 = 147
GOT_TLSGD_PCREL34 = 148
GOT_TLSLD_PCREL34 = 149
GOT_TPREL_PCREL34 = 150
IRELATIVE = 248
REL16 = 249
REL16_LO = 250
REL16_HI = 251
REL16_HA = 252
_

std.elf.R_RISCV

容器

第 2966 行

RISC-V 重定位。

字段

NONE = 0
@"32" = 1
@"64" = 2
RELATIVE = 3
COPY = 4
JUMP_SLOT = 5
TLS_DTPMOD32 = 6
TLS_DTPMOD64 = 7
TLS_DTPREL32 = 8
TLS_DTPREL64 = 9
TLS_TPREL32 = 10
TLS_TPREL64 = 11
TLSDESC = 12
BRANCH = 16
JAL = 17
CALL = 18
CALL_PLT = 19
GOT_HI20 = 20
TLS_GOT_HI20 = 21
TLS_GD_HI20 = 22
PCREL_HI20 = 23
PCREL_LO12_I = 24
PCREL_LO12_S = 25
HI20 = 26
LO12_I = 27
LO12_S = 28
TPREL_HI20 = 29
TPREL_LO12_I = 30
TPREL_LO12_S = 31
TPREL_ADD = 32
ADD8 = 33
ADD16 = 34
ADD32 = 35
ADD64 = 36
SUB8 = 37
SUB16 = 38
SUB32 = 39
SUB64 = 40
GNU_VTINHERIT = 41
GNU_VTENTRY = 42
ALIGN = 43
RVC_BRANCH = 44
RVC_JUMP = 45
RVC_LUI = 46
GPREL_I = 47
GPREL_S = 48
TPREL_I = 49
TPREL_S = 50
RELAX = 51
SUB6 = 52
SET6 = 53
SET8 = 54
SET16 = 55
SET32 = 56
@"32_PCREL" = 57
IRELATIVE = 58
PLT32 = 59
SET_ULEB128 = 60
SUB_ULEB128 = 61
_

std.elf.R_SPARC

容器

第 3281 行

字段

NONE = 0
@"8" = 1
@"16" = 2
@"32" = 3
DISP8 = 4
DISP16 = 5
DISP32 = 6
WDISP30 = 7
WDISP22 = 8
HI22 = 9
@"22" = 10
@"13" = 11
LO10 = 12
GOT10 = 13
GOT13 = 14
GOT22 = 15
PC10 = 16
PC22 = 17
WPLT30 = 18
COPY = 19
GLOB_DAT = 20
JMP_SLOT = 21
RELATIVE = 22
UA32 = 23
PLT32 = 24
HIPLT22 = 25
LOPLT10 = 26
PCPLT32 = 27
PCPLT22 = 28
PCPLT10 = 29
@"10" = 30
@"11" = 31
@"64" = 32
OLO10 = 33
HH22 = 34
HM10 = 35
LM22 = 36
PC_HH22 = 37
PC_HM10 = 38
PC_LM22 = 39
WDISP16 = 40
WDISP19 = 41
@"7" = 43
@"5" = 44
@"6" = 45
DISP64 = 46
PLT64 = 47
HIX22 = 48
LOX10 = 49
H44 = 50
M44 = 51
L44 = 52
REGISTER = 53
UA64 = 54
UA16 = 55
TLS_GD_HI22 = 56
TLS_GD_LO10 = 57
TLS_GD_ADD = 58
TLS_GD_CALL = 59
TLS_LDM_HI22 = 60
TLS_LDM_LO10 = 61
TLS_LDM_ADD = 62
TLS_LDM_CALL = 63
TLS_LDO_HIX22 = 64
TLS_LDO_LOX10 = 65
TLS_LDO_ADD = 66
TLS_IE_HI22 = 67
TLS_IE_LO10 = 68
TLS_IE_LD = 69
TLS_IE_LDX = 70
TLS_IE_ADD = 71
TLS_LE_HIX22 = 72
TLS_LE_LOX10 = 73
TLS_DTPMOD32 = 74
TLS_DTPMOD64 = 75
TLS_DTPOFF32 = 76
TLS_DTPOFF64 = 77
TLS_TPOFF32 = 78
TLS_TPOFF64 = 79
GOTDATA_HIX22 = 80
GOTDATA_LOX10 = 81
GOTDATA_OP_HIX22 = 82
GOTDATA_OP_LOX10 = 83
GOTDATA_OP = 84
H34 = 85
SIZE32 = 86
SIZE64 = 87
WDISP10 = 88
IRELATIVE = 249
_

std.elf.R_X86_64

容器

第 2604 行

AMD x86-64 重定位。

字段

NONE = 0

无重定位

@"64" = 1

直接寻址 64 位值

PC32 = 2

相对于程序计数器的 32 位有符号值

GOT32 = 3

32 位 GOT 条目

PLT32 = 4

32 位 PLT 地址

COPY = 5

在运行时复制符号

GLOB_DAT = 6

创建 GOT 条目

JUMP_SLOT = 7

创建 PLT 条目

RELATIVE = 8

按程序基址调整

GOTPCREL = 9

到 GOT 的 32 位有符号 PC 相对偏移

@"32" = 10

直接寻址的 32 位零扩展值

@"32S" = 11

直接 32 位符号扩展值

@"16" = 12

直接 16 位零扩展

PC16 = 13

16 位符号扩展的 PC 相对值

@"8" = 14

直接 8 位符号扩展值

PC8 = 15

8 位符号扩展的程序计数器相对值

DTPMOD64 = 16

包含符号的模块 ID

DTPOFF64 = 17

模块 TLS 块中的偏移

TPOFF64 = 18

初始 TLS 块中的偏移

TLSGD = 19

GD 符号的两个 GOT 条目的 32 位有符号 PC 相对偏移

TLSLD = 20

指向 LD 符号的两个 GOT 条目的 32 位有符号 PC 相对偏移量。

DTPOFF32 = 21

TLS 块内偏移量

GOTTPOFF = 22

相对于 PC、指向 IE 符号 GOT 条目的 32 位有符号偏移

TPOFF32 = 23

初始 TLS 块中的偏移

PC64 = 24

PC 相对 64 位值

GOTOFF64 = 25

到 GOT 的 64 位偏移

GOTPC32 = 26

相对于程序计数器的 32 位有符号 GOT 偏移量

GOT64 = 27

64 位 GOT 条目偏移量

GOTPCREL64 = 28

到 GOT 条目的 64 位 PC 相对偏移

GOTPC64 = 29

相对于程序计数器的 GOT 64 位偏移量

GOTPLT64 = 30

与 GOT64 类似,表示需要 PLT 条目

PLTOFF64 = 31

PLT 条目的 64 位 GOT 相对偏移量

SIZE32 = 32

符号大小加上 32 位加数

SIZE64 = 33

符号大小加 64 位加数

GOTPC32_TLSDESC = 34

TLS 描述符的 GOT 偏移

TLSDESC_CALL = 35

通过 TLS 描述符调用的标记

TLSDESC = 36

TLS 描述符

IRELATIVE = 37

按程序基址进行间接调整

RELATIVE64 = 38

按程序基址进行 64 位调整

GOTPCRELX = 41

39 保留,原为 PC32_BND 40 保留,原为 PLT32_BND 从不带 REX 前缀的 32 位有符号 PC 相对偏移加载 GOT 条目,可放宽

REX_GOTPCRELX = 42

使用 REX 前缀,从 GOT 条目加载基于 32 位有符号 PC 相对偏移的值;可放宽

_

std.elf.Rel

类型

第 1704 行

std.elf.Rela

类型

第 1709 行

std.elf.Relr

常量

第 1714 行

std.elf.Section

类型

第 1185 行

std.elf.SectionHeaderBufferIterator

容器

第 1065 行

字段

is_64: bool
endian: Endian
shnum: u16
shoff: u64
buf: []const u8
index: usize = 0

std.elf.SectionHeaderBufferIterator.next

函数

第 1074 行

pub fn next(it: *SectionHeaderBufferIterator) !?Elf64_Shdr

参数

std.elf.SectionHeaderIterator

容器

第 1044 行

字段

is_64: bool
endian: Endian
shnum: u16
shoff: u64
file_reader: *Io.File.Reader
index: usize = 0

std.elf.SectionHeaderIterator.next

函数

第 1053 行

pub fn next(it: *SectionHeaderIterator) !?Elf64_Shdr

参数

std.elf.Shdr

类型

第 1719 行

std.elf.SHF

容器

第 2446 行

字段

WRITE: bool = false

节数据在执行期间应可写。

ALLOC: bool = false

程序执行期间,该节占用内存。

EXECINSTR: bool = false

该节包含可执行机器指令。

unused3: u1 = 0
MERGE: bool = false

此节中的数据可以合并。

STRINGS: bool = false

此节中的数据为以空字符结尾的字符串。

INFO_LINK: bool = false

此节中的某个字段保存节头表索引。

LINK_ORDER: bool = false

为链接编辑器添加特殊的排序要求。

OS_NONCONFORMING: bool = false

此节需要操作系统专用的特殊处理,以避免不正确行为。

GROUP: bool = false

此节是某个节组的成员。

TLS: bool = false

此节存储线程局部存储数据。

COMPRESSED: bool = false

标识包含压缩数据的节。

unused12: u8 = 0
OS: packed union {
    MASK: u8,
    GNU: packed struct(u8) {
        unused0: u1 = 0,
        /// 链接器不得将其作为垃圾回收
        RETAIN: bool = false,
        unused2: u6 = 0,
    },
    MIPS: packed struct(u8) {
        unused0: u4 = 0,
        /// 节包含可能在其他节中重复的文本/数据。
        /// 链接器必须仅保留一份。
        NODUPES: bool = false,
        /// 链接器必须生成隐含的隐藏弱名称。
        NAMES: bool = false,
        /// 节数据为进程本地数据。
        LOCAL: bool = false,
        /// 不要剥离此节。
        NOSTRIP: bool = false,
    },
    ARM: packed struct(u8) {
        unused0: u5 = 0,
        /// 在仅执行模式下,使代码节不可读。
        PURECODE: bool = false,
        unused6: u2 = 0,
    },
} = .{ .MASK = 0 }
PROC: packed union {
    MASK: u4,
    XCORE: packed struct(u4) {
        /// 链接器将所有带“d”标志的节组合成
        /// 数据节,启动代码将 dp 寄存器设为
        /// 该节的起始位置。
        DP_SECTION: bool = false,
        /// 链接器将所有带“c”标志的节组合成
        /// 常量池,启动代码将 cp 寄存器设为常量池的
        /// 起始地址。
        CP_SECTION: bool = false,
        unused2: u1 = 0,
        /// 此节不包含于最终可执行文件或共享库。
        EXCLUDE: bool = false,
    },
    X86_64: packed struct(u4) {
        /// 目标文件的节未设置此标志时,其大小不得
        /// 超过 2GB,使用较小代码模型的目标文件可以自由引用它。
        /// 否则,只有使用较大代码模型的目标文件才能引用。
        /// 例如,中型代码模型目标文件既能引用设置此标志的节中
        /// 的数据,也能引用未设置此标志的节中的
        /// 数据;同理,小型代码模型目标文件只能引用
        /// 未设置此标志的节中的代码。
        LARGE: bool = false,
        unused1: u2 = 0,
        /// 此节不包含于最终可执行文件或共享库。
        EXCLUDE: bool = false,
    },
    HEX: packed struct(u4) {
        /// 所有带 GPREL 标志的节均归入全局数据区,
        /// 以便更快访问。
        GPREL: bool = false,
        unused1: u2 = 0,
        /// 此节不包含于最终可执行文件或共享库。
        EXCLUDE: bool = false,
    },
    MIPS: packed struct(u4) {
        /// 所有带 GPREL 标志的节均归入全局数据区,
        /// 以便更快访问。
        GPREL: bool = false,
        /// 应合并此节。
        MERGE: bool = false,
        /// 根据节条目大小推断地址大小。
        ADDR: bool = false,
        /// 节数据默认是字符串数据。
        STRING: bool = false,
    },
} = .{ .MASK = 0 }

std.elf.SHF_ALLOC

常量

第 2353 行

程序执行期间,该节占用内存。

std.elf.SHF_ARM_PURECODE

常量

第 2444 行

在仅执行模式下,使代码节不可读。

std.elf.SHF_COMPRESSED

常量

第 2381 行

标识包含压缩数据的节。

std.elf.SHF_EXCLUDE

常量

第 2387 行

此节不包含于最终可执行文件或共享库。

std.elf.SHF_EXECINSTR

常量

第 2356 行

该节包含可执行机器指令。

std.elf.SHF_GNU_RETAIN

常量

第 2384 行

链接器不得将其作为垃圾回收

std.elf.SHF_GROUP

常量

第 2375 行

此节是某个节组的成员。

std.elf.SHF_HEX_GPREL

常量

第 2416 行

所有带 GPREL 标志的节均归入全局数据区, 以便更快访问。

std.elf.SHF_INFO_LINK

常量

第 2365 行

此节中的某个字段保存节头表索引。

std.elf.SHF_LINK_ORDER

常量

第 2368 行

为链接编辑器添加特殊的排序要求。

std.elf.SHF_MASKOS

常量

第 2390 行

目标平台专用标志的起始位置。

std.elf.SHF_MASKPROC

常量

第 2393 行

表示处理器专用标志的位。

std.elf.SHF_MERGE

常量

第 2359 行

此节中的数据可以合并。

std.elf.SHF_MIPS_ADDR

常量

第 2438 行

根据节条目大小推断地址大小。

std.elf.SHF_MIPS_GPREL

常量

第 2432 行

此节必须属于全局数据区。

std.elf.SHF_MIPS_LOCAL

常量

第 2426 行

节数据为进程本地数据。

std.elf.SHF_MIPS_MERGE

常量

第 2435 行

应合并此节。

std.elf.SHF_MIPS_NAMES

常量

第 2423 行

链接器必须生成隐含的隐藏弱名称。

std.elf.SHF_MIPS_NODUPES

常量

第 2420 行

节包含可能在其他节中重复的文本/数据。 链接器必须仅保留一份。

std.elf.SHF_MIPS_NOSTRIP

常量

第 2429 行

不要剥离此节。

std.elf.SHF_MIPS_STRING

常量

第 2441 行

节数据默认是字符串数据。

std.elf.SHF_OS_NONCONFORMING

常量

第 2372 行

此节需要进行特殊的操作系统专属处理,以避免行为错误。

std.elf.SHF_STRINGS

常量

第 2362 行

此节中的数据为以空字符结尾的字符串。

std.elf.SHF_TLS

常量

第 2378 行

此节存储线程局部存储数据。

std.elf.SHF_WRITE

常量

第 2350 行

节数据在执行期间应可写。

std.elf.SHF_X86_64_LARGE

常量

第 2412 行

目标文件的节未设置此标志时,其大小不得 超过 2GB,使用较小代码模型的目标文件可以自由引用它。 否则,只有使用较大代码模型的目标文件才能引用。 例如,中型代码模型目标文件既能引用设置此标志的节中 的数据,也能引用未设置此标志的节中的 数据;同理,小型代码模型目标文件只能引用 未设置此标志的节中的代码。

std.elf.SHN_ABS

常量

第 2586 行

关联符号为绝对符号

std.elf.SHN_COMMON

常量

第 2588 行

关联符号为公共符号

std.elf.SHN_HIPROC

常量

第 2583 行

处理器专用范围的结束位置

std.elf.SHN_HIRESERVE

常量

第 2590 行

预留索引的结束位置

std.elf.SHN_LIVEPATCH

常量

第 2584 行

std.elf.SHN_LOPROC

常量

第 2581 行

处理器专用范围的起点

std.elf.SHN_LORESERVE

常量

第 2579 行

预留索引的起始位置

std.elf.SHN_UNDEF

常量

第 2577 行

未定义节

std.elf.SHT

容器

第 656 行

字段

NULL = 0

未使用的节头表条目

PROGBITS = 1

程序数据

SYMTAB = 2

符号表

STRTAB = 3

字符串表

RELA = 4

包含加数的重定位条目

HASH = 5

符号哈希表

DYNAMIC = 6

动态链接信息

NOTE = 7

说明

NOBITS = 8

不含数据的程序空间(bss)

REL = 9

不含加数的重定位条目

SHLIB = 10

保留

DYNSYM = 11

动态链接器符号表

INIT_ARRAY = 14

构造函数数组

FINI_ARRAY = 15

析构函数数组

PREINIT_ARRAY = 16

预构造函数数组

GROUP = 17

节组

SYMTAB_SHNDX = 18

扩展节索引

RELR = 19

RELR 相对重定位

_

std.elf.SHT_DYNAMIC

常量

第 490 行

已弃用,请使用 @intFromEnum(std.elf.SHT.DYNAMIC)

std.elf.SHT_DYNSYM

常量

第 500 行

已弃用,请使用 @intFromEnum(std.elf.SHT.DYNSYM)。

std.elf.SHT_FINI_ARRAY

常量

第 504 行

已弃用,请使用 @intFromEnum(std.elf.SHT.FINI_ARRAY)

std.elf.SHT_GNU_HASH

常量

第 520 行

已弃用,请使用 @intFromEnum(std.elf.SHT.GNU_HASH)

std.elf.SHT_GNU_VERDEF

常量

第 522 行

已弃用,请使用 @intFromEnum(std.elf.SHT.GNU_VERDEF)。

std.elf.SHT_GNU_VERNEED

常量

第 524 行

已弃用,请使用 @intFromEnum(std.elf.SHT.GNU_VERNEED)

std.elf.SHT_GNU_VERSYM

常量

第 526 行

已弃用,请使用 @intFromEnum(std.elf.SHT.GNU_VERSYM)

std.elf.SHT_GROUP

常量

第 508 行

已弃用,请使用 @intFromEnum(std.elf.SHT.GROUP)

std.elf.SHT_HASH

常量

第 488 行

已弃用,请使用 @intFromEnum(std.elf.SHT.HASH)

std.elf.SHT_HIOS

常量

第 528 行

已弃用,请使用 @intFromEnum(std.elf.SHT.HIOS)

std.elf.SHT_HIPROC

常量

第 534 行

已弃用,请使用 @intFromEnum(std.elf.SHT.HIPROC)

std.elf.SHT_HIUSER

常量

第 538 行

已弃用,请使用 @intFromEnum(std.elf.SHT.HIUSER)

std.elf.SHT_INIT_ARRAY

常量

第 502 行

已弃用,请使用 @intFromEnum(std.elf.SHT.INIT_ARRAY)

std.elf.SHT_LLVM_ADDRSIG

常量

第 518 行

已弃用,请使用 @intFromEnum(std.elf.SHT.LLVM_ADDRSIG)

std.elf.SHT_LOOS

常量

第 516 行

已弃用,请使用 @intFromEnum(std.elf.SHT.LOOS)

std.elf.SHT_LOPROC

常量

第 530 行

已弃用,请使用 @intFromEnum(std.elf.SHT.LOPROC)

std.elf.SHT_LOUSER

常量

第 536 行

已弃用,请使用 @intFromEnum(std.elf.SHT.LOUSER)。

std.elf.SHT_NOBITS

常量

第 494 行

已弃用,请使用 @intFromEnum(std.elf.SHT.NOBITS)

std.elf.SHT_NOTE

常量

第 492 行

已弃用,请使用 @intFromEnum(std.elf.SHT.NOTE)

std.elf.SHT_NULL

常量

第 478 行

已弃用,请使用 @intFromEnum(std.elf.SHT.NULL)

std.elf.SHT_NUM

别名

第 514 行

已弃用,请使用 std.elf.SHT.NUM。

别名目标 std.elf.SHT.NUM

std.elf.SHT_PREINIT_ARRAY

常量

第 506 行

已弃用,请使用 @intFromEnum(std.elf.SHT.PREINIT_ARRAY)

std.elf.SHT_PROGBITS

常量

第 480 行

已弃用,请使用 @intFromEnum(std.elf.SHT.PROGBITS)。

std.elf.SHT_REL

常量

第 496 行

已弃用,请使用 @intFromEnum(std.elf.SHT.REL)。

std.elf.SHT_RELA

常量

第 486 行

已弃用,请使用 @intFromEnum(std.elf.SHT.RELA)。

std.elf.SHT_RELR

常量

第 512 行

已弃用,请使用 @intFromEnum(std.elf.SHT.RELR)。

std.elf.SHT_SHLIB

常量

第 498 行

已弃用,请使用 @intFromEnum(std.elf.SHT.SHLIB)

std.elf.SHT_STRTAB

常量

第 484 行

已弃用,请使用 @intFromEnum(std.elf.SHT.STRTAB)

std.elf.SHT_SYMTAB

常量

第 482 行

已弃用,请使用 @intFromEnum(std.elf.SHT.SYMTAB)。

std.elf.SHT_SYMTAB_SHNDX

常量

第 510 行

已弃用,请使用 @intFromEnum(std.elf.SHT.SYMTAB_SHNDX)

std.elf.SHT_X86_64_UNWIND

常量

第 532 行

已弃用,请使用 @intFromEnum(std.elf.SHT.X86_64_UNWIND)

std.elf.SHT.GNU_HASH

常量

第 707 行

GNU 哈希表

SHT

std.elf.SHT.GNU_VERDEF

常量

第 709 行

GNU 版本定义表

SHT

std.elf.SHT.GNU_VERNEED

常量

第 711 行

GNU 所需版本表

SHT

std.elf.SHT.GNU_VERSYM

常量

第 713 行

GNU 符号版本表

SHT

std.elf.SHT.HIOS

常量

第 701 行

操作系统专用范围的终点

SHT

std.elf.SHT.HIPROC

常量

第 718 行

处理器专用范围的结束位置

SHT

std.elf.SHT.HIUSER

常量

第 726 行

应用程序专用范围的终点

SHT

std.elf.SHT.LLVM_ADDRSIG

常量

第 704 行

LLVM 地址显著性表

SHT

std.elf.SHT.LOOS

常量

第 699 行

操作系统专用范围的起点

SHT

std.elf.SHT.LOPROC

常量

第 716 行

处理器专用范围的起点

SHT

std.elf.SHT.LOUSER

常量

第 724 行

应用程序专用范围的起始位置

SHT

std.elf.SHT.NUM

常量

第 696 行

已定义类型的数量

std.elf.SHT.X86_64_UNWIND

常量

第 721 行

栈展开信息

SHT

std.elf.STB

容器

第 729 行

字段

LOCAL = 0

局部符号

GLOBAL = 1

全局符号

WEAK = 2

弱符号

_

std.elf.STB_GLOBAL

常量

第 546 行

已弃用,请使用 @intFromEnum(std.elf.STB.GLOBAL)

std.elf.STB_GNU_UNIQUE

常量

第 554 行

已弃用,请使用 @intFromEnum(std.elf.STB.GNU_UNIQUE)

std.elf.STB_HIOS

常量

第 556 行

已弃用,请使用 @intFromEnum(std.elf.STB.HIOS)

std.elf.STB_HIPROC

常量

第 560 行

已弃用,请使用 @intFromEnum(std.elf.STB.HIPROC)

std.elf.STB_LOCAL

常量

第 544 行

已弃用,请使用 @intFromEnum(std.elf.STB.LOCAL)。

std.elf.STB_LOOS

常量

第 552 行

已弃用,请使用 @intFromEnum(std.elf.STB.LOOS)

std.elf.STB_LOPROC

常量

第 558 行

已弃用,请使用 @intFromEnum(std.elf.STB.LOPROC)。

std.elf.STB_MIPS_SPLIT_COMMON

常量

第 563 行

已弃用,请使用 @intFromEnum(std.elf.STB.MIPS_SPLIT_COMMON)

std.elf.STB_NUM

别名

第 550 行

已弃用,请使用 std.elf.STB.NUM

别名目标 std.elf.STB.NUM

std.elf.STB_WEAK

常量

第 548 行

已弃用,请使用 @intFromEnum(std.elf.STB.WEAK)。

std.elf.STB.GNU_UNIQUE

常量

第 747 行

唯一符号

STB

std.elf.STB.HIOS

常量

第 744 行

操作系统专用范围的终点

STB

std.elf.STB.HIPROC

常量

第 752 行

处理器专用范围的结束位置

STB

std.elf.STB.LOOS

常量

第 742 行

操作系统专用范围的起点

STB

std.elf.STB.LOPROC

常量

第 750 行

处理器专用范围的起点

STB

std.elf.STB.MIPS_SPLIT_COMMON

常量

第 754 行

STB

std.elf.STB.NUM

常量

第 739 行

已定义类型的数量

std.elf.std

别名

第 4 行

别名目标 std

std.elf.STRNAME

常量

第 3459 行

Strtab 标识符

std.elf.STT

容器

第 757 行

字段

NOTYPE = 0

未指定符号类型

OBJECT = 1

符号为数据对象

FUNC = 2

符号是代码对象

SECTION = 3

与节关联的符号

FILE = 4

符号名为文件名

COMMON = 5

符号为公共数据对象

TLS = 6

符号是线程局部数据对象

_

std.elf.STT_ARM_16BIT

常量

第 606 行

已弃用,请使用 @intFromEnum(std.elf.STT.ARM_16BIT)

std.elf.STT_ARM_TFUNC

常量

第 604 行

已弃用,请使用 @intFromEnum(std.elf.STT.ARM_TFUNC)

std.elf.STT_COMMON

常量

第 576 行

已弃用,请使用 @intFromEnum(std.elf.STT.COMMON)

std.elf.STT_FILE

常量

第 574 行

已弃用,请使用 @intFromEnum(std.elf.STT.FILE)

std.elf.STT_FUNC

常量

第 570 行

已弃用,请使用 @intFromEnum(std.elf.STT.FUNC)。

std.elf.STT_GNU_IFUNC

常量

第 584 行

已弃用,请使用 @intFromEnum(std.elf.STT.GNU_IFUNC)

std.elf.STT_HIOS

常量

第 586 行

已弃用,请使用 @intFromEnum(std.elf.STT.HIOS)。

std.elf.STT_HIPROC

常量

第 590 行

已弃用,请使用 @intFromEnum(std.elf.STT.HIPROC)。

std.elf.STT_HP_OPAQUE

常量

第 599 行

已弃用,请使用 @intFromEnum(std.elf.STT.HP_OPAQUE)。

std.elf.STT_HP_STUB

常量

第 601 行

已弃用,请使用 @intFromEnum(std.elf.STT.HP_STUB)。

std.elf.STT_LOOS

常量

第 582 行

已弃用,请使用 @intFromEnum(std.elf.STT.LOOS)

std.elf.STT_LOPROC

常量

第 588 行

已弃用,请使用 @intFromEnum(std.elf.STT.LOPROC)

std.elf.STT_NOTYPE

常量

第 566 行

已弃用,请使用 @intFromEnum(std.elf.STT.NOTYPE)

std.elf.STT_NUM

别名

第 580 行

已弃用,请使用 std.elf.STT.NUM

别名目标 std.elf.STT.NUM

std.elf.STT_OBJECT

常量

第 568 行

已弃用,请使用 @intFromEnum(std.elf.STT.OBJECT)。

std.elf.STT_PARISC_MILLICODE

常量

第 596 行

已弃用,请使用 @intFromEnum(std.elf.STT.PARISC_MILLICODE)

std.elf.STT_SECTION

常量

第 572 行

已弃用,请使用 @intFromEnum(std.elf.STT.SECTION)

std.elf.STT_SPARC_REGISTER

常量

第 593 行

已弃用,请使用 @intFromEnum(std.elf.STT.SPARC_REGISTER)

std.elf.STT_TLS

常量

第 578 行

已弃用,请使用 @intFromEnum(std.elf.STT.TLS)

std.elf.STT.ARM_16BIT

常量

第 798 行

STT

std.elf.STT.ARM_TFUNC

常量

第 797 行

STT

std.elf.STT.GNU_IFUNC

常量

第 783 行

符号是间接代码对象

STT

std.elf.STT.HIOS

常量

第 780 行

操作系统专用范围的终点

STT

std.elf.STT.HIPROC

常量

第 791 行

处理器专用范围的结束位置

STT

std.elf.STT.HP_OPAQUE

常量

第 785 行

STT

std.elf.STT.HP_STUB

常量

第 786 行

STT

std.elf.STT.LOOS

常量

第 778 行

操作系统专用范围的起点

STT

std.elf.STT.LOPROC

常量

第 789 行

处理器专用范围的起点

STT

std.elf.STT.NUM

常量

第 775 行

已定义类型的数量

std.elf.STT.PARISC_MILLICODE

常量

第 795 行

STT

std.elf.STT.SPARC_REGISTER

常量

第 793 行

STT

std.elf.STV

容器

第 801 行

字段

DEFAULT = 0
INTERNAL = 1
HIDDEN = 2
PROTECTED = 3

std.elf.Sword

类型

第 1182 行

std.elf.Sxword

类型

第 1184 行

std.elf.Sym

类型

第 1731 行

已弃用,使用 std.elf.ElfN.Sym

std.elf.SYM64NAME

常量

第 3461 行

64 位符号表标识符

std.elf.SYMDEFNAME

常量

第 3462 行

std.elf.SYMDEFSORTEDNAME

常量

第 3463 行

std.elf.SYMNAME

常量

第 3457 行

32 位符号表标识符

std.elf.takeDynamicSection

函数

第 1142 行

pub fn takeDynamicSection(reader: *Io.Reader, is_64: bool, endian: Endian) !Elf64_Dyn

参数

reader: *Io.Reader
is_64: bool
endian: Endian

std.elf.takeProgramHeader

函数

第 1025 行

pub fn takeProgramHeader(reader: *Io.Reader, is_64: bool, endian: Endian) !Elf64.Phdr

参数

reader: *Io.Reader
is_64: bool
endian: Endian

std.elf.takeSectionHeader

函数

第 1087 行

pub fn takeSectionHeader(reader: *Io.Reader, is_64: bool, endian: Endian) !Elf64_Shdr

参数

reader: *Io.Reader
is_64: bool
endian: Endian

std.elf.VER_FLG_BASE

常量

第 471 行

文件自身的版本定义

std.elf.VER_FLG_WEAK

常量

第 473 行

弱版本标识符

std.elf.VER_NDX

容器

第 457 行

字段

LOCAL = 0

符号为局部符号

GLOBAL = 1

符号为全局符号

LORESERVE = 0xff00

预留条目的起始位置

ELIMINATE = 0xff01

应消除此符号

UNSPECIFIED = 0xffff
_

std.elf.Verdaux

容器

第 1564 行

字段

name: Word
next: Word

std.elf.Verdef

容器

第 1555 行

字段

version: Half
flags: Half
ndx: VER_NDX
cnt: Half
hash: Word
aux: Word
next: Word

std.elf.Vernaux

容器

第 1591 行

字段

hash: Word
flags: Half
other: Half
name: Word
next: Word

std.elf.Verneed

容器

第 1584 行

字段

version: Half
cnt: Half
file: Word
aux: Word
next: Word

std.elf.Versym

容器

第 449 行

字段

VERSION: u15
HIDDEN: bool

std.elf.Versym.GLOBAL

常量

第 454 行

Versym

std.elf.Versym.LOCAL

常量

第 453 行

Versym

std.elf.Word

类型

第 1181 行

std.elf.XCORE_SHF_CP_SECTION

常量

第 2403 行

链接器将所有带“c”标志的节组合成 常量池,启动代码将 cp 寄存器设为常量池的 起始地址。

std.elf.XCORE_SHF_DP_SECTION

常量

第 2398 行

链接器将所有带“d”标志的节组合成 数据节,启动代码将 dp 寄存器设为 该节的起始位置。

std.elf.Xword

类型

第 1183 行

源码

std/elf.zig

//! 可执行与可链接格式。

const builtin = @import("builtin");
const std = @import("std.zig");
const Io = std.Io;
const math = std.math;
const mem = std.mem;
const assert = std.debug.assert;
const Endian = std.builtin.Endian;

const native_endian = builtin.target.cpu.arch.endian();
const native_os = builtin.target.os.tag;

pub const AT = switch (native_os) {
    .dragonfly => struct {
        pub const NULL = 0;
        pub const IGNORE = 1;
        pub const EXECFD = 2;
        pub const PHDR = 3;
        pub const PHENT = 4;
        pub const PHNUM = 5;
        pub const PAGESZ = 6;
        pub const BASE = 7;
        pub const FLAGS = 8;
        pub const ENTRY = 9;
        pub const NOTELF = 10;
        pub const UID = 11;
        pub const EUID = 12;
        pub const GID = 13;
        pub const EGID = 14;
        pub const EXECPATH = 15;
        pub const CANARY = 16;
        pub const CANARYLEN = 17;
        pub const OSRELDATE = 18;
        pub const NCPUS = 19;
        pub const PAGESIZES = 20;
        pub const PAGESIZESLEN = 21;
        pub const STACKPROT = 23;
    },
    .freebsd => struct {
        pub const NULL = 0;
        pub const IGNORE = 1;
        pub const EXECFD = 2;
        pub const PHDR = 3;
        pub const PHENT = 4;
        pub const PHNUM = 5;
        pub const PAGESZ = 6;
        pub const BASE = 7;
        pub const FLAGS = 8;
        pub const ENTRY = 9;
        pub const NOTELF = 10;
        pub const UID = 11;
        pub const EUID = 12;
        pub const GID = 13;
        pub const EGID = 14;
        pub const EXECPATH = 15;
        pub const CANARY = 16;
        pub const CANARYLEN = 17;
        pub const OSRELDATE = 18;
        pub const NCPUS = 19;
        pub const PAGESIZES = 20;
        pub const PAGESIZESLEN = 21;
        pub const TIMEKEEP = 22;
        pub const STACKPROT = 23;
        pub const EHDRFLAGS = 24;
        pub const HWCAP = 25;
        pub const HWCAP2 = 26;
        pub const BSDFLAGS = 27;
        pub const ARGC = 28;
        pub const ARGV = 29;
        pub const ENVC = 30;
        pub const ENVV = 31;
        pub const PS_STRINGS = 32;
        pub const FXRNG = 33;
        pub const KPRELOAD = 34;
        pub const USRSTACKBASE = 35;
        pub const USRSTACKLIM = 36;
        pub const CHERI_STATS = 37;
        pub const HWCAP3 = 38;
        pub const HWCAP4 = 39;
    },
    .illumos => struct {
        pub const NULL = 0;
        pub const IGNORE = 1;
        pub const EXECFD = 2;
        pub const PHDR = 3;
        pub const PHENT = 4;
        pub const PHNUM = 5;
        pub const PAGESZ = 6;
        pub const BASE = 7;
        pub const FLAGS = 8;
        pub const ENTRY = 9;
        pub const NOTELF = 10;
        pub const UID = 11;
        pub const EUID = 12;
        pub const GID = 13;
        pub const EGID = 14;
        pub const EXECPATH = 15;
        pub const CANARY = 16;
        pub const CANARYLEN = 17;
        pub const OSRELDATE = 18;
        pub const NCPUS = 19;
        pub const PAGESIZES = 20;
        pub const PAGESIZESLEN = 21;
        pub const TIMEKEEP = 22;
        pub const STACKPROT = 23;
    },
    .linux => struct {
        pub const NULL = 0;
        pub const IGNORE = 1;
        pub const EXECFD = 2;
        pub const PHDR = 3;
        pub const PHENT = 4;
        pub const PHNUM = 5;
        pub const PAGESZ = 6;
        pub const BASE = 7;
        pub const FLAGS = 8;
        pub const ENTRY = 9;
        pub const NOTELF = 10;
        pub const UID = 11;
        pub const EUID = 12;
        pub const GID = 13;
        pub const EGID = 14;
        pub const CLKTCK = 17;
        pub const PLATFORM = 15;
        pub const HWCAP = 16;
        pub const FPUCW = 18;
        pub const DCACHEBSIZE = 19;
        pub const ICACHEBSIZE = 20;
        pub const UCACHEBSIZE = 21;
        pub const IGNOREPPC = 22;
        pub const SECURE = 23;
        pub const BASE_PLATFORM = 24;
        pub const RANDOM = 25;
        pub const HWCAP2 = 26;
        pub const RSEQ_FEATURE_SIZE = 27;
        pub const RSEQ_ALIGN = 28;
        pub const HWCAP3 = 29;
        pub const HWCAP4 = 30;
        pub const EXECFN = 31;
        pub const SYSINFO = 32;
        pub const SYSINFO_EHDR = 33;
        pub const L1I_CACHESHAPE = 34;
        pub const L1D_CACHESHAPE = 35;
        pub const L2_CACHESHAPE = 36;
        pub const L3_CACHESHAPE = 37;
        pub const L1I_CACHESIZE = 40;
        pub const L1I_CACHEGEOMETRY = 41;
        pub const L1D_CACHESIZE = 42;
        pub const L1D_CACHEGEOMETRY = 43;
        pub const L2_CACHESIZE = 44;
        pub const L2_CACHEGEOMETRY = 45;
        pub const L3_CACHESIZE = 46;
        pub const L3_CACHEGEOMETRY = 47;
        pub const MINSIGSTKSZ = 51;
    },
    .netbsd => struct {
        pub const NULL = 0;
        pub const IGNORE = 1;
        pub const EXECFD = 2;
        pub const PHDR = 3;
        pub const PHENT = 4;
        pub const PHNUM = 5;
        pub const PAGESZ = 6;
        pub const BASE = 7;
        pub const FLAGS = 8;
        pub const ENTRY = 9;
        pub const MIPS_NOTELF = 10;
        pub const DCACHEBSIZE = 10;
        pub const ICACHEBSIZE = 11;
        pub const UCACHEBSIZE = 12;
        pub const STACKBASE = 13;
        pub const EUID = 2000;
        pub const RUID = 2001;
        pub const EGID = 2002;
        pub const RGID = 2003;
        pub const SUN_LDELF = 2004;
        pub const SUN_LDSHDR = 2005;
        pub const SUN_LDNAME = 2006;
        pub const SUN_LPGSIZE = 2007;
        pub const SUN_PLATFORM = 2008;
        pub const SUN_HWCAP = 2009;
        pub const SUN_IFLUSH = 2010;
        pub const SUN_CPU = 2011;
        pub const SUN_EMUL_ENTRY = 2012;
        pub const SUN_EMUL_EXECFD = 2013;
        pub const SUN_EXECNAME = 2014;
    },
    .openbsd => struct {
        pub const NULL = 0;
        pub const IGNORE = 1;
        pub const PAGESZ = 6;
        pub const HWCAP = 25;
        pub const HWCAP2 = 26;
    },
    .serenity => struct {
        pub const NULL = 0;
        pub const IGNORE = 1;
        pub const EXECFD = 2;
        pub const PHDR = 3;
        pub const PHENT = 4;
        pub const PHNUM = 5;
        pub const PAGESZ = 6;
        pub const BASE = 7;
        pub const FLAGS = 8;
        pub const ENTRY = 9;
        pub const NOTELF = 10;
        pub const UID = 11;
        pub const EUID = 12;
        pub const GID = 13;
        pub const PLATFORM = 15;
        pub const HWCAP = 16;
        pub const CLKTCK = 17;
        pub const SECURE = 23;
        pub const BASE_PLATFORM = 24;
        pub const RANDOM = 25;
        pub const HWCAP2 = 26;
        pub const EXECFN = 31;
        pub const EXE_BASE = 32;
        pub const EXE_SIZE = 33;
    },
    else => struct {
        pub const NULL = 0;
        pub const IGNORE = 1;
        pub const EXECFD = 2;
        pub const PHDR = 3;
        pub const PHENT = 4;
        pub const PHNUM = 5;
        pub const PAGESZ = 6;
        pub const BASE = 7;
        pub const FLAGS = 8;
        pub const ENTRY = 9;
        pub const NOTELF = 10;
    },
};

pub const DT_NULL = 0;
pub const DT_NEEDED = 1;
pub const DT_PLTRELSZ = 2;
pub const DT_PLTGOT = 3;
pub const DT_HASH = 4;
pub const DT_STRTAB = 5;
pub const DT_SYMTAB = 6;
pub const DT_RELA = 7;
pub const DT_RELASZ = 8;
pub const DT_RELAENT = 9;
pub const DT_STRSZ = 10;
pub const DT_SYMENT = 11;
pub const DT_INIT = 12;
pub const DT_FINI = 13;
pub const DT_SONAME = 14;
pub const DT_RPATH = 15;
pub const DT_SYMBOLIC = 16;
pub const DT_REL = 17;
pub const DT_RELSZ = 18;
pub const DT_RELENT = 19;
pub const DT_PLTREL = 20;
pub const DT_DEBUG = 21;
pub const DT_TEXTREL = 22;
pub const DT_JMPREL = 23;
pub const DT_BIND_NOW = 24;
pub const DT_INIT_ARRAY = 25;
pub const DT_FINI_ARRAY = 26;
pub const DT_INIT_ARRAYSZ = 27;
pub const DT_FINI_ARRAYSZ = 28;
pub const DT_RUNPATH = 29;
pub const DT_FLAGS = 30;
pub const DT_ENCODING = 32;
pub const DT_PREINIT_ARRAY = 32;
pub const DT_PREINIT_ARRAYSZ = 33;
pub const DT_SYMTAB_SHNDX = 34;
pub const DT_RELRSZ = 35;
pub const DT_RELR = 36;
pub const DT_RELRENT = 37;
pub const DT_NUM = 38;
pub const DT_LOOS = 0x6000000d;
pub const DT_HIOS = 0x6ffff000;
pub const DT_LOPROC = 0x70000000;
pub const DT_HIPROC = 0x7fffffff;
pub const DT_PROCNUM = DT_MIPS_NUM;

pub const DT_VALRNGLO = 0x6ffffd00;
pub const DT_GNU_PRELINKED = 0x6ffffdf5;
pub const DT_GNU_CONFLICTSZ = 0x6ffffdf6;
pub const DT_GNU_LIBLISTSZ = 0x6ffffdf7;
pub const DT_CHECKSUM = 0x6ffffdf8;
pub const DT_PLTPADSZ = 0x6ffffdf9;
pub const DT_MOVEENT = 0x6ffffdfa;
pub const DT_MOVESZ = 0x6ffffdfb;
pub const DT_FEATURE_1 = 0x6ffffdfc;
pub const DT_POSFLAG_1 = 0x6ffffdfd;

pub const DT_SYMINSZ = 0x6ffffdfe;
pub const DT_SYMINENT = 0x6ffffdff;
pub const DT_VALRNGHI = 0x6ffffdff;
pub const DT_VALNUM = 12;

pub const DT_ADDRRNGLO = 0x6ffffe00;
pub const DT_GNU_HASH = 0x6ffffef5;
pub const DT_TLSDESC_PLT = 0x6ffffef6;
pub const DT_TLSDESC_GOT = 0x6ffffef7;
pub const DT_GNU_CONFLICT = 0x6ffffef8;
pub const DT_GNU_LIBLIST = 0x6ffffef9;
pub const DT_CONFIG = 0x6ffffefa;
pub const DT_DEPAUDIT = 0x6ffffefb;
pub const DT_AUDIT = 0x6ffffefc;
pub const DT_PLTPAD = 0x6ffffefd;
pub const DT_MOVETAB = 0x6ffffefe;
pub const DT_SYMINFO = 0x6ffffeff;
pub const DT_ADDRRNGHI = 0x6ffffeff;
pub const DT_ADDRNUM = 11;

pub const DT_VERSYM = 0x6ffffff0;

pub const DT_RELACOUNT = 0x6ffffff9;
pub const DT_RELCOUNT = 0x6ffffffa;

pub const DT_FLAGS_1 = 0x6ffffffb;
pub const DT_VERDEF = 0x6ffffffc;

pub const DT_VERDEFNUM = 0x6ffffffd;
pub const DT_VERNEED = 0x6ffffffe;

pub const DT_VERNEEDNUM = 0x6fffffff;
pub const DT_VERSIONTAGNUM = 16;

pub const DT_AUXILIARY = 0x7ffffffd;
pub const DT_FILTER = 0x7fffffff;
pub const DT_EXTRANUM = 3;

pub const DT_SPARC_REGISTER = 0x70000001;
pub const DT_SPARC_NUM = 2;

pub const DT_MIPS_RLD_VERSION = 0x70000001;
pub const DT_MIPS_TIME_STAMP = 0x70000002;
pub const DT_MIPS_ICHECKSUM = 0x70000003;
pub const DT_MIPS_IVERSION = 0x70000004;
pub const DT_MIPS_FLAGS = 0x70000005;
pub const DT_MIPS_BASE_ADDRESS = 0x70000006;
pub const DT_MIPS_MSYM = 0x70000007;
pub const DT_MIPS_CONFLICT = 0x70000008;
pub const DT_MIPS_LIBLIST = 0x70000009;
pub const DT_MIPS_LOCAL_GOTNO = 0x7000000a;
pub const DT_MIPS_CONFLICTNO = 0x7000000b;
pub const DT_MIPS_LIBLISTNO = 0x70000010;
pub const DT_MIPS_SYMTABNO = 0x70000011;
pub const DT_MIPS_UNREFEXTNO = 0x70000012;
pub const DT_MIPS_GOTSYM = 0x70000013;
pub const DT_MIPS_HIPAGENO = 0x70000014;
pub const DT_MIPS_RLD_MAP = 0x70000016;
pub const DT_MIPS_DELTA_CLASS = 0x70000017;
pub const DT_MIPS_DELTA_CLASS_NO = 0x70000018;

pub const DT_MIPS_DELTA_INSTANCE = 0x70000019;
pub const DT_MIPS_DELTA_INSTANCE_NO = 0x7000001a;

pub const DT_MIPS_DELTA_RELOC = 0x7000001b;
pub const DT_MIPS_DELTA_RELOC_NO = 0x7000001c;

pub const DT_MIPS_DELTA_SYM = 0x7000001d;

pub const DT_MIPS_DELTA_SYM_NO = 0x7000001e;

pub const DT_MIPS_DELTA_CLASSSYM = 0x70000020;

pub const DT_MIPS_DELTA_CLASSSYM_NO = 0x70000021;

pub const DT_MIPS_CXX_FLAGS = 0x70000022;
pub const DT_MIPS_PIXIE_INIT = 0x70000023;
pub const DT_MIPS_SYMBOL_LIB = 0x70000024;
pub const DT_MIPS_LOCALPAGE_GOTIDX = 0x70000025;
pub const DT_MIPS_LOCAL_GOTIDX = 0x70000026;
pub const DT_MIPS_HIDDEN_GOTIDX = 0x70000027;
pub const DT_MIPS_PROTECTED_GOTIDX = 0x70000028;
pub const DT_MIPS_OPTIONS = 0x70000029;
pub const DT_MIPS_INTERFACE = 0x7000002a;
pub const DT_MIPS_DYNSTR_ALIGN = 0x7000002b;
pub const DT_MIPS_INTERFACE_SIZE = 0x7000002c;
pub const DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 0x7000002d;

pub const DT_MIPS_PERF_SUFFIX = 0x7000002e;

pub const DT_MIPS_COMPACT_SIZE = 0x7000002f;
pub const DT_MIPS_GP_VALUE = 0x70000030;
pub const DT_MIPS_AUX_DYNAMIC = 0x70000031;

pub const DT_MIPS_PLTGOT = 0x70000032;

pub const DT_MIPS_RWPLT = 0x70000034;
pub const DT_MIPS_RLD_MAP_REL = 0x70000035;
pub const DT_MIPS_NUM = 0x36;

pub const DT_ALPHA_PLTRO = (DT_LOPROC + 0);
pub const DT_ALPHA_NUM = 1;

pub const DT_PPC_GOT = (DT_LOPROC + 0);
pub const DT_PPC_OPT = (DT_LOPROC + 1);
pub const DT_PPC_NUM = 2;

pub const DT_PPC64_GLINK = (DT_LOPROC + 0);
pub const DT_PPC64_OPD = (DT_LOPROC + 1);
pub const DT_PPC64_OPDSZ = (DT_LOPROC + 2);
pub const DT_PPC64_OPT = (DT_LOPROC + 3);
pub const DT_PPC64_NUM = 4;

pub const DT_IA_64_PLT_RESERVE = (DT_LOPROC + 0);
pub const DT_IA_64_NUM = 1;

pub const DT_XTENSA_GOT_LOC_OFF = 0x70000000;
pub const DT_XTENSA_GOT_LOC_SZ = 0x70000001;

pub const DT_NIOS2_GP = 0x70000002;

pub const DF_ORIGIN = 0x00000001;
pub const DF_SYMBOLIC = 0x00000002;
pub const DF_TEXTREL = 0x00000004;
pub const DF_BIND_NOW = 0x00000008;
pub const DF_STATIC_TLS = 0x00000010;

pub const DF_1_NOW = 0x00000001;
pub const DF_1_GLOBAL = 0x00000002;
pub const DF_1_GROUP = 0x00000004;
pub const DF_1_NODELETE = 0x00000008;
pub const DF_1_LOADFLTR = 0x00000010;
pub const DF_1_INITFIRST = 0x00000020;
pub const DF_1_NOOPEN = 0x00000040;
pub const DF_1_ORIGIN = 0x00000080;
pub const DF_1_DIRECT = 0x00000100;
pub const DF_1_TRANS = 0x00000200;
pub const DF_1_INTERPOSE = 0x00000400;
pub const DF_1_NODEFLIB = 0x00000800;
pub const DF_1_NODUMP = 0x00001000;
pub const DF_1_CONFALT = 0x00002000;
pub const DF_1_ENDFILTEE = 0x00004000;
pub const DF_1_DISPRELDNE = 0x00008000;
pub const DF_1_DISPRELPND = 0x00010000;
pub const DF_1_NODIRECT = 0x00020000;
pub const DF_1_IGNMULDEF = 0x00040000;
pub const DF_1_NOKSYMS = 0x00080000;
pub const DF_1_NOHDR = 0x00100000;
pub const DF_1_EDITED = 0x00200000;
pub const DF_1_NORELOC = 0x00400000;
pub const DF_1_SYMINTPOSE = 0x00800000;
pub const DF_1_GLOBAUDIT = 0x01000000;
pub const DF_1_SINGLETON = 0x02000000;
pub const DF_1_STUB = 0x04000000;
pub const DF_1_PIE = 0x08000000;

pub const Versym = packed struct(u16) {
    VERSION: u15,
    HIDDEN: bool,

    pub const LOCAL: Versym = @bitCast(@backingInt(VER_NDX.LOCAL));
    pub const GLOBAL: Versym = @bitCast(@backingInt(VER_NDX.GLOBAL));
};

pub const VER_NDX = enum(u16) {
    /// 符号为局部符号
    LOCAL = 0,
    /// 符号为全局符号
    GLOBAL = 1,
    /// 预留条目的起始位置
    LORESERVE = 0xff00,
    /// 应消除此符号
    ELIMINATE = 0xff01,
    UNSPECIFIED = 0xffff,
    _,
};

/// 文件自身的版本定义
pub const VER_FLG_BASE = 1;
/// 弱版本标识符
pub const VER_FLG_WEAK = 2;

pub const PN_XNUM = 0xffff;

/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.NULL)`
pub const SHT_NULL = @backingInt(std.elf.SHT.NULL);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.PROGBITS)`。
pub const SHT_PROGBITS = @backingInt(std.elf.SHT.PROGBITS);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.SYMTAB)`。
pub const SHT_SYMTAB = @backingInt(std.elf.SHT.SYMTAB);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.STRTAB)`
pub const SHT_STRTAB = @backingInt(std.elf.SHT.STRTAB);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.RELA)`。
pub const SHT_RELA = @backingInt(std.elf.SHT.RELA);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.HASH)`
pub const SHT_HASH = @backingInt(std.elf.SHT.HASH);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.DYNAMIC)`
pub const SHT_DYNAMIC = @backingInt(std.elf.SHT.DYNAMIC);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.NOTE)`
pub const SHT_NOTE = @backingInt(std.elf.SHT.NOTE);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.NOBITS)`
pub const SHT_NOBITS = @backingInt(std.elf.SHT.NOBITS);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.REL)`。
pub const SHT_REL = @backingInt(std.elf.SHT.REL);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.SHLIB)`
pub const SHT_SHLIB = @backingInt(std.elf.SHT.SHLIB);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.DYNSYM)`。
pub const SHT_DYNSYM = @backingInt(std.elf.SHT.DYNSYM);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.INIT_ARRAY)`
pub const SHT_INIT_ARRAY = @backingInt(std.elf.SHT.INIT_ARRAY);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.FINI_ARRAY)`
pub const SHT_FINI_ARRAY = @backingInt(std.elf.SHT.FINI_ARRAY);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.PREINIT_ARRAY)`
pub const SHT_PREINIT_ARRAY = @backingInt(std.elf.SHT.PREINIT_ARRAY);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.GROUP)`
pub const SHT_GROUP = @backingInt(std.elf.SHT.GROUP);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.SYMTAB_SHNDX)`
pub const SHT_SYMTAB_SHNDX = @backingInt(std.elf.SHT.SYMTAB_SHNDX);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.RELR)`。
pub const SHT_RELR = @backingInt(std.elf.SHT.RELR);
/// 已弃用,请使用 `std.elf.SHT.NUM`。
pub const SHT_NUM = SHT.NUM;
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.LOOS)`
pub const SHT_LOOS = @backingInt(std.elf.SHT.LOOS);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.LLVM_ADDRSIG)`
pub const SHT_LLVM_ADDRSIG = @backingInt(std.elf.SHT.LLVM_ADDRSIG);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.GNU_HASH)`
pub const SHT_GNU_HASH = @backingInt(std.elf.SHT.GNU_HASH);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.GNU_VERDEF)`。
pub const SHT_GNU_VERDEF = @backingInt(std.elf.SHT.GNU_VERDEF);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.GNU_VERNEED)`
pub const SHT_GNU_VERNEED = @backingInt(std.elf.SHT.GNU_VERNEED);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.GNU_VERSYM)`
pub const SHT_GNU_VERSYM = @backingInt(std.elf.SHT.GNU_VERSYM);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.HIOS)`
pub const SHT_HIOS = @backingInt(std.elf.SHT.HIOS);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.LOPROC)`
pub const SHT_LOPROC = @backingInt(std.elf.SHT.LOPROC);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.X86_64_UNWIND)`
pub const SHT_X86_64_UNWIND = @backingInt(std.elf.SHT.X86_64_UNWIND);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.HIPROC)`
pub const SHT_HIPROC = @backingInt(std.elf.SHT.HIPROC);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.LOUSER)`。
pub const SHT_LOUSER = @backingInt(std.elf.SHT.LOUSER);
/// 已弃用,请使用 `@intFromEnum(std.elf.SHT.HIUSER)`
pub const SHT_HIUSER = @backingInt(std.elf.SHT.HIUSER);

// .note.gnu.build_id 的注释类型
pub const NT_GNU_BUILD_ID = 3;

/// 已弃用,请使用 `@intFromEnum(std.elf.STB.LOCAL)`。
pub const STB_LOCAL = @backingInt(STB.LOCAL);
/// 已弃用,请使用 `@intFromEnum(std.elf.STB.GLOBAL)`
pub const STB_GLOBAL = @backingInt(STB.GLOBAL);
/// 已弃用,请使用 `@intFromEnum(std.elf.STB.WEAK)`。
pub const STB_WEAK = @backingInt(STB.WEAK);
/// 已弃用,请使用 `std.elf.STB.NUM`
pub const STB_NUM = STB.NUM;
/// 已弃用,请使用 `@intFromEnum(std.elf.STB.LOOS)`
pub const STB_LOOS = @backingInt(STB.LOOS);
/// 已弃用,请使用 `@intFromEnum(std.elf.STB.GNU_UNIQUE)`
pub const STB_GNU_UNIQUE = @backingInt(STB.GNU_UNIQUE);
/// 已弃用,请使用 `@intFromEnum(std.elf.STB.HIOS)`
pub const STB_HIOS = @backingInt(STB.HIOS);
/// 已弃用,请使用 `@intFromEnum(std.elf.STB.LOPROC)`。
pub const STB_LOPROC = @backingInt(STB.LOPROC);
/// 已弃用,请使用 `@intFromEnum(std.elf.STB.HIPROC)`
pub const STB_HIPROC = @backingInt(STB.HIPROC);

/// 已弃用,请使用 `@intFromEnum(std.elf.STB.MIPS_SPLIT_COMMON)`
pub const STB_MIPS_SPLIT_COMMON = @backingInt(STB.MIBS_SPLIT_COMMON);

/// 已弃用,请使用 `@intFromEnum(std.elf.STT.NOTYPE)`
pub const STT_NOTYPE = @backingInt(STT.NOTYPE);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.OBJECT)`。
pub const STT_OBJECT = @backingInt(STT.OBJECT);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.FUNC)`。
pub const STT_FUNC = @backingInt(STT.FUNC);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.SECTION)`
pub const STT_SECTION = @backingInt(STT.SECTION);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.FILE)`
pub const STT_FILE = @backingInt(STT.FILE);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.COMMON)`
pub const STT_COMMON = @backingInt(STT.COMMON);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.TLS)`
pub const STT_TLS = @backingInt(STT.TLS);
/// 已弃用,请使用 `std.elf.STT.NUM`
pub const STT_NUM = STT.NUM;
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.LOOS)`
pub const STT_LOOS = @backingInt(STT.LOOS);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.GNU_IFUNC)`
pub const STT_GNU_IFUNC = @backingInt(STT.GNU_IFUNC);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.HIOS)`。
pub const STT_HIOS = @backingInt(STT.HIOS);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.LOPROC)`
pub const STT_LOPROC = @backingInt(STT.LOPROC);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.HIPROC)`。
pub const STT_HIPROC = @backingInt(STT.HIPROC);

/// 已弃用,请使用 `@intFromEnum(std.elf.STT.SPARC_REGISTER)`
pub const STT_SPARC_REGISTER = @backingInt(STT.SPARC_REGISTER);

/// 已弃用,请使用 `@intFromEnum(std.elf.STT.PARISC_MILLICODE)`
pub const STT_PARISC_MILLICODE = @backingInt(STT.PARISC_MILLICODE);

/// 已弃用,请使用 `@intFromEnum(std.elf.STT.HP_OPAQUE)`。
pub const STT_HP_OPAQUE = @backingInt(STT.HP_OPAQUE);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.HP_STUB)`。
pub const STT_HP_STUB = @backingInt(STT.HP_STUB);

/// 已弃用,请使用 `@intFromEnum(std.elf.STT.ARM_TFUNC)`
pub const STT_ARM_TFUNC = @backingInt(STT.ARM_TFUNC);
/// 已弃用,请使用 `@intFromEnum(std.elf.STT.ARM_16BIT)`
pub const STT_ARM_16BIT = @backingInt(STT.ARM_16BIT);

pub const PT = enum(Word) {
    /// 程序头表条目未使用
    NULL = 0,
    /// 可加载程序段
    LOAD = 1,
    /// 动态链接信息
    DYNAMIC = 2,
    /// 程序解释器
    INTERP = 3,
    /// 辅助信息
    NOTE = 4,
    /// 保留
    SHLIB = 5,
    /// 头表自身的条目
    PHDR = 6,
    /// 线程局部存储段
    TLS = 7,
    _,

    /// 已定义类型的数量
    pub const NUM = @typeInfo(PT).@"enum".field_names.len;

    /// 操作系统专用范围的起点
    pub const LOOS: PT = @fromBackingInt(@intCast(0x60000000));
    /// 操作系统专用范围的终点
    pub const HIOS: PT = @fromBackingInt(@intCast(0x6fffffff));

    /// GCC .eh_frame_hdr 段
    pub const GNU_EH_FRAME: PT = @fromBackingInt(@intCast(0x6474e550));
    /// 指示栈是否可执行
    pub const GNU_STACK: PT = @fromBackingInt(@intCast(0x6474e551));
    /// 重定位后只读
    pub const GNU_RELRO: PT = @fromBackingInt(@intCast(0x6474e552));

    pub const LOSUNW: PT = @fromBackingInt(@intCast(0x6ffffffa));
    pub const HISUNW: PT = @fromBackingInt(@intCast(0x6fffffff));

    /// Sun 专用段
    pub const SUNWBSS: PT = @fromBackingInt(@intCast(0x6ffffffa));
    /// 栈段
    pub const SUNWSTACK: PT = @fromBackingInt(@intCast(0x6ffffffb));

    /// 处理器专用范围的起点
    pub const LOPROC: PT = @fromBackingInt(@intCast(0x70000000));
    /// 处理器专用范围的结束位置
    pub const HIPROC: PT = @fromBackingInt(@intCast(0x7fffffff));
};

pub const SHT = enum(Word) {
    /// 未使用的节头表条目
    NULL = 0,
    /// 程序数据
    PROGBITS = 1,
    /// 符号表
    SYMTAB = 2,
    /// 字符串表
    STRTAB = 3,
    /// 包含加数的重定位条目
    RELA = 4,
    /// 符号哈希表
    HASH = 5,
    /// 动态链接信息
    DYNAMIC = 6,
    /// 说明
    NOTE = 7,
    /// 不含数据的程序空间(bss)
    NOBITS = 8,
    /// 不含加数的重定位条目
    REL = 9,
    /// 保留
    SHLIB = 10,
    /// 动态链接器符号表
    DYNSYM = 11,
    /// 构造函数数组
    INIT_ARRAY = 14,
    /// 析构函数数组
    FINI_ARRAY = 15,
    /// 预构造函数数组
    PREINIT_ARRAY = 16,
    /// 节组
    GROUP = 17,
    /// 扩展节索引
    SYMTAB_SHNDX = 18,
    /// RELR 相对重定位
    RELR = 19,
    _,

    /// 已定义类型的数量
    pub const NUM = @typeInfo(SHT).@"enum".field_names.len;

    /// 操作系统专用范围的起点
    pub const LOOS: SHT = @fromBackingInt(@intCast(0x60000000));
    /// 操作系统专用范围的终点
    pub const HIOS: SHT = @fromBackingInt(@intCast(0x6fffffff));

    /// LLVM 地址显著性表
    pub const LLVM_ADDRSIG: SHT = @fromBackingInt(@intCast(0x6fff4c03));

    /// GNU 哈希表
    pub const GNU_HASH: SHT = @fromBackingInt(@intCast(0x6ffffff6));
    /// GNU 版本定义表
    pub const GNU_VERDEF: SHT = @fromBackingInt(@intCast(0x6ffffffd));
    /// GNU 所需版本表
    pub const GNU_VERNEED: SHT = @fromBackingInt(@intCast(0x6ffffffe));
    /// GNU 符号版本表
    pub const GNU_VERSYM: SHT = @fromBackingInt(@intCast(0x6fffffff));

    /// 处理器专用范围的起点
    pub const LOPROC: SHT = @fromBackingInt(@intCast(0x70000000));
    /// 处理器专用范围的结束位置
    pub const HIPROC: SHT = @fromBackingInt(@intCast(0x7fffffff));

    /// 栈展开信息
    pub const X86_64_UNWIND: SHT = @fromBackingInt(@intCast(0x70000001));

    /// 应用程序专用范围的起始位置
    pub const LOUSER: SHT = @fromBackingInt(@intCast(0x80000000));
    /// 应用程序专用范围的终点
    pub const HIUSER: SHT = @fromBackingInt(@intCast(0xffffffff));
};

pub const STB = enum(u4) {
    /// 局部符号
    LOCAL = 0,
    /// 全局符号
    GLOBAL = 1,
    /// 弱符号
    WEAK = 2,
    _,

    /// 已定义类型的数量
    pub const NUM = @typeInfo(STB).@"enum".field_names.len;

    /// 操作系统专用范围的起点
    pub const LOOS: STB = @fromBackingInt(@intCast(10));
    /// 操作系统专用范围的终点
    pub const HIOS: STB = @fromBackingInt(@intCast(12));

    /// 唯一符号
    pub const GNU_UNIQUE: STB = @fromBackingInt(@intCast(@backingInt(LOOS) + 0));

    /// 处理器专用范围的起点
    pub const LOPROC: STB = @fromBackingInt(@intCast(13));
    /// 处理器专用范围的结束位置
    pub const HIPROC: STB = @fromBackingInt(@intCast(15));

    pub const MIPS_SPLIT_COMMON: STB = @fromBackingInt(@intCast(@backingInt(LOPROC) + 0));
};

pub const STT = enum(u4) {
    /// 未指定符号类型
    NOTYPE = 0,
    /// 符号为数据对象
    OBJECT = 1,
    /// 符号是代码对象
    FUNC = 2,
    /// 与节关联的符号
    SECTION = 3,
    /// 符号名为文件名
    FILE = 4,
    /// 符号为公共数据对象
    COMMON = 5,
    /// 符号是线程局部数据对象
    TLS = 6,
    _,

    /// 已定义类型的数量
    pub const NUM = @typeInfo(STT).@"enum".field_names.len;

    /// 操作系统专用范围的起点
    pub const LOOS: STT = @fromBackingInt(@intCast(10));
    /// 操作系统专用范围的终点
    pub const HIOS: STT = @fromBackingInt(@intCast(12));

    /// 符号是间接代码对象
    pub const GNU_IFUNC: STT = @fromBackingInt(@intCast(@backingInt(LOOS) + 0));

    pub const HP_OPAQUE: STT = @fromBackingInt(@intCast(@backingInt(LOOS) + 1));
    pub const HP_STUB: STT = @fromBackingInt(@intCast(@backingInt(LOOS) + 2));

    /// 处理器专用范围的起点
    pub const LOPROC: STT = @fromBackingInt(@intCast(13));
    /// 处理器专用范围的结束位置
    pub const HIPROC: STT = @fromBackingInt(@intCast(15));

    pub const SPARC_REGISTER: STT = @fromBackingInt(@intCast(@backingInt(LOPROC) + 0));

    pub const PARISC_MILLICODE: STT = @fromBackingInt(@intCast(@backingInt(LOPROC) + 0));

    pub const ARM_TFUNC: STT = @fromBackingInt(@intCast(@backingInt(LOPROC) + 0));
    pub const ARM_16BIT: STT = @fromBackingInt(@intCast(@backingInt(HIPROC) + 2));
};

pub const STV = enum(u3) {
    DEFAULT = 0,
    INTERNAL = 1,
    HIDDEN = 2,
    PROTECTED = 3,
};

pub const MAGIC = "\x7fELF";

/// 文件类型
pub const ET = enum(u16) {
    /// 无文件类型
    NONE = 0,

    /// 可重定位文件
    REL = 1,

    /// 可执行文件
    EXEC = 2,

    /// 共享对象文件
    DYN = 3,

    /// 核心转储文件
    CORE = 4,

    _,

    /// 操作系统专用编码的起点
    pub const LOOS = 0xfe00;

    /// 操作系统专用代码的结束位置
    pub const HIOS = 0xfeff;

    /// 特定于处理器代码的起始位置
    pub const LOPROC = 0xff00;

    /// 处理器专用代码的结束位置
    pub const HIPROC = 0xffff;
};

/// 所有整数均为本机字节序。
pub const Header = struct {
    is_64: bool,
    endian: Endian,
    os_abi: OSABI,
    /// 此值的含义取决于 `os_abi`。
    abi_version: u8,
    type: ET,
    machine: EM,
    entry: u64,
    phoff: u64,
    shoff: u64,
    phentsize: u16,
    phnum: u16,
    shentsize: u16,
    shnum: u16,
    shstrndx: u16,

    pub fn iterateProgramHeaders(h: *const Header, file_reader: *Io.File.Reader) ProgramHeaderIterator {
        return .{
            .is_64 = h.is_64,
            .endian = h.endian,
            .phnum = h.phnum,
            .phoff = h.phoff,
            .file_reader = file_reader,
        };
    }

    pub fn iterateProgramHeadersBuffer(h: *const Header, buf: []const u8) ProgramHeaderBufferIterator {
        return .{
            .is_64 = h.is_64,
            .endian = h.endian,
            .phnum = h.phnum,
            .phoff = h.phoff,
            .buf = buf,
        };
    }

    pub fn iterateSectionHeaders(h: *const Header, file_reader: *Io.File.Reader) SectionHeaderIterator {
        return .{
            .is_64 = h.is_64,
            .endian = h.endian,
            .shnum = h.shnum,
            .shoff = h.shoff,
            .file_reader = file_reader,
        };
    }

    pub fn iterateSectionHeadersBuffer(h: *const Header, buf: []const u8) SectionHeaderBufferIterator {
        return .{
            .is_64 = h.is_64,
            .endian = h.endian,
            .shnum = h.shnum,
            .shoff = h.shoff,
            .buf = buf,
        };
    }

    pub fn iterateDynamicSection(
        h: *const Header,
        file_reader: *Io.File.Reader,
        offset: u64,
        size: u64,
    ) DynamicSectionIterator {
        return .{
            .is_64 = h.is_64,
            .endian = h.endian,
            .offset = offset,
            .end_offset = offset + size,
            .file_reader = file_reader,
        };
    }

    pub fn iterateDynamicSectionBuffer(
        h: *const Header,
        buf: []const u8,
        offset: u64,
        size: u64,
    ) DynamicSectionBufferIterator {
        return .{
            .is_64 = h.is_64,
            .endian = h.endian,
            .offset = offset,
            .end_offset = offset + size,
            .buf = buf,
        };
    }

    pub const ReadError = Io.Reader.Error || error{
        InvalidElfMagic,
        InvalidElfVersion,
        InvalidElfClass,
        InvalidElfEndian,
    };

    /// 如果此函数失败,`r` 的定位位置不变。
    pub fn read(r: *Io.Reader) ReadError!Header {
        const buf = try r.peek(@sizeOf(Elf64_Ehdr));

        if (!mem.eql(u8, buf[0..4], MAGIC)) return error.InvalidElfMagic;
        if (buf[EI.VERSION] != 1) return error.InvalidElfVersion;

        const endian: Endian = switch (buf[EI.DATA]) {
            ELFDATA2LSB => .little,
            ELFDATA2MSB => .big,
            else => return error.InvalidElfEndian,
        };

        return switch (buf[EI.CLASS]) {
            ELFCLASS32 => .init(try r.takeStruct(Elf32_Ehdr, endian), endian),
            ELFCLASS64 => .init(try r.takeStruct(Elf64_Ehdr, endian), endian),
            else => return error.InvalidElfClass,
        };
    }

    pub fn init(hdr: anytype, endian: Endian) Header {
        // 使用 `@enumFromInt` 将整数转换为穷尽枚举可能触发 panic。
        comptime assert(@typeInfo(OSABI).@"enum".mode == .nonexhaustive);
        return .{
            .is_64 = switch (@TypeOf(hdr)) {
                Elf32_Ehdr => false,
                Elf64_Ehdr => true,
                else => @compileError("bad type"),
            },
            .endian = endian,
            .os_abi = @fromBackingInt(@intCast(hdr.e_ident[EI.OSABI])),
            .abi_version = hdr.e_ident[EI.ABIVERSION],
            .type = hdr.e_type,
            .machine = hdr.e_machine,
            .entry = hdr.e_entry,
            .phoff = hdr.e_phoff,
            .shoff = hdr.e_shoff,
            .phentsize = hdr.e_phentsize,
            .phnum = hdr.e_phnum,
            .shentsize = hdr.e_shentsize,
            .shnum = hdr.e_shnum,
            .shstrndx = hdr.e_shstrndx,
        };
    }
};

pub const ProgramHeaderIterator = struct {
    is_64: bool,
    endian: Endian,
    phnum: u16,
    phoff: u64,

    file_reader: *Io.File.Reader,
    index: usize = 0,

    pub fn next(it: *ProgramHeaderIterator) !?Elf64.Phdr {
        if (it.index >= it.phnum) return null;
        defer it.index += 1;

        const size: u64 = if (it.is_64) @sizeOf(Elf64.Phdr) else @sizeOf(Elf32.Phdr);
        const offset = it.phoff + size * it.index;
        try it.file_reader.seekTo(offset);

        return try takeProgramHeader(&it.file_reader.interface, it.is_64, it.endian);
    }
};

pub const ProgramHeaderBufferIterator = struct {
    is_64: bool,
    endian: Endian,
    phnum: u16,
    phoff: u64,

    buf: []const u8,
    index: usize = 0,

    pub fn next(it: *ProgramHeaderBufferIterator) !?Elf64.Phdr {
        if (it.index >= it.phnum) return null;
        defer it.index += 1;

        const size: usize = if (it.is_64) @sizeOf(Elf64.Phdr) else @sizeOf(Elf32.Phdr);
        const offset = @as(usize, @intCast(it.phoff)) + size * it.index;
        var reader = Io.Reader.fixed(it.buf[offset..]);

        return try takeProgramHeader(&reader, it.is_64, it.endian);
    }
};

pub fn takeProgramHeader(reader: *Io.Reader, is_64: bool, endian: Endian) !Elf64.Phdr {
    if (is_64) {
        const phdr = try reader.takeStruct(Elf64.Phdr, endian);
        return phdr;
    }

    const phdr = try reader.takeStruct(Elf32.Phdr, endian);
    return .{
        .type = phdr.type,
        .offset = phdr.offset,
        .vaddr = phdr.vaddr,
        .paddr = phdr.paddr,
        .filesz = phdr.filesz,
        .memsz = phdr.memsz,
        .flags = phdr.flags,
        .@"align" = phdr.@"align",
    };
}

pub const SectionHeaderIterator = struct {
    is_64: bool,
    endian: Endian,
    shnum: u16,
    shoff: u64,

    file_reader: *Io.File.Reader,
    index: usize = 0,

    pub fn next(it: *SectionHeaderIterator) !?Elf64_Shdr {
        if (it.index >= it.shnum) return null;
        defer it.index += 1;

        const size: u64 = if (it.is_64) @sizeOf(Elf64_Shdr) else @sizeOf(Elf32_Shdr);
        const offset = it.shoff + size * it.index;
        try it.file_reader.seekTo(offset);

        return try takeSectionHeader(&it.file_reader.interface, it.is_64, it.endian);
    }
};

pub const SectionHeaderBufferIterator = struct {
    is_64: bool,
    endian: Endian,
    shnum: u16,
    shoff: u64,

    buf: []const u8,
    index: usize = 0,

    pub fn next(it: *SectionHeaderBufferIterator) !?Elf64_Shdr {
        if (it.index >= it.shnum) return null;
        defer it.index += 1;

        const size: u64 = if (it.is_64) @sizeOf(Elf64_Shdr) else @sizeOf(Elf32_Shdr);
        const offset = it.shoff + size * it.index;
        if (offset > it.buf.len) return error.EndOfStream;
        var reader = Io.Reader.fixed(it.buf[@intCast(offset)..]);

        return try takeSectionHeader(&reader, it.is_64, it.endian);
    }
};

pub fn takeSectionHeader(reader: *Io.Reader, is_64: bool, endian: Endian) !Elf64_Shdr {
    if (is_64) {
        const shdr = try reader.takeStruct(Elf64_Shdr, endian);
        return shdr;
    }

    const shdr = try reader.takeStruct(Elf32_Shdr, endian);
    return .{
        .sh_name = shdr.sh_name,
        .sh_type = shdr.sh_type,
        .sh_flags = shdr.sh_flags,
        .sh_addr = shdr.sh_addr,
        .sh_offset = shdr.sh_offset,
        .sh_size = shdr.sh_size,
        .sh_link = shdr.sh_link,
        .sh_info = shdr.sh_info,
        .sh_addralign = shdr.sh_addralign,
        .sh_entsize = shdr.sh_entsize,
    };
}

pub const DynamicSectionIterator = struct {
    is_64: bool,
    endian: Endian,
    offset: u64,
    end_offset: u64,

    file_reader: *Io.File.Reader,

    pub fn next(it: *DynamicSectionIterator) !?Elf64_Dyn {
        if (it.offset >= it.end_offset) return null;
        const size: u64 = if (it.is_64) @sizeOf(Elf64_Dyn) else @sizeOf(Elf32_Dyn);
        defer it.offset += size;
        try it.file_reader.seekTo(it.offset);
        return try takeDynamicSection(&it.file_reader.interface, it.is_64, it.endian);
    }
};

pub const DynamicSectionBufferIterator = struct {
    is_64: bool,
    endian: Endian,
    offset: u64,
    end_offset: u64,

    buf: []const u8,

    pub fn next(it: *DynamicSectionBufferIterator) !?Elf64_Dyn {
        if (it.offset >= it.end_offset) return null;
        const size: u64 = if (it.is_64) @sizeOf(Elf64_Dyn) else @sizeOf(Elf32_Dyn);
        defer it.offset += size;
        var reader: std.Io.Reader = .fixed(it.buf[it.offset..]);
        return try takeDynamicSection(&reader, it.is_64, it.endian);
    }
};

pub fn takeDynamicSection(reader: *Io.Reader, is_64: bool, endian: Endian) !Elf64_Dyn {
    if (is_64) {
        const dyn = try reader.takeStruct(Elf64_Dyn, endian);
        return dyn;
    }

    const dyn = try reader.takeStruct(Elf32_Dyn, endian);
    return .{
        .d_tag = dyn.d_tag,
        .d_val = dyn.d_val,
    };
}

pub const EI = struct {
    pub const CLASS = 4;
    pub const DATA = 5;
    pub const VERSION = 6;
    pub const OSABI = 7;
    pub const ABIVERSION = 8;
    pub const PAD = 9;
    pub const NIDENT = 16;
};

/// 已弃用,请使用 `std.elf.EI.CLASS`
pub const EI_CLASS = EI.CLASS;
/// 已弃用,请使用 `std.elf.EI.DATA`
pub const EI_DATA = EI.DATA;
/// 已弃用,请使用 `std.elf.EI.VERSION`
pub const EI_VERSION = EI.VERSION;
/// 已弃用,请使用 `std.elf.EI.OSABI`
pub const EI_OSABI = EI.OSABI;
/// 已弃用,请使用 `std.elf.EI.ABIVERSION`
pub const EI_ABIVERSION = EI.ABIVERSION;
/// 已弃用,请使用 `std.elf.EI.PAD`
pub const EI_PAD = EI.PAD;
/// 已弃用,请使用 `std.elf.EI.NIDENT`
pub const EI_NIDENT = EI.NIDENT;

pub const Half = u16;
pub const Word = u32;
pub const Sword = i32;
pub const Xword = u64;
pub const Sxword = i64;
pub const Section = u16;
pub const Elf32 = struct {
    pub const Addr = u32;
    pub const Off = u32;
    pub const Ehdr = extern struct {
        ident: Ident,
        type: ET,
        machine: EM,
        version: Word,
        entry: Elf32.Addr,
        phoff: Elf32.Off,
        shoff: Elf32.Off,
        flags: EhdrFlags,
        ehsize: Half,
        phentsize: Half,
        phnum: Half,
        shentsize: Half,
        shnum: Half,
        shstrndx: Half,
    };
    pub const Phdr = extern struct {
        type: PT,
        offset: Elf32.Off,
        vaddr: Elf32.Addr,
        paddr: Elf32.Addr,
        filesz: Word,
        memsz: Word,
        flags: PF,
        @"align": Word,
    };
    pub const Shdr = extern struct {
        name: Word,
        type: SHT,
        flags: packed struct(Word) { shf: SHF },
        addr: Elf32.Addr,
        offset: Elf32.Off,
        size: Word,
        link: Word,
        info: Word,
        addralign: Word,
        entsize: Word,
    };
    pub const Chdr = extern struct {
        type: COMPRESS,
        size: Word,
        addralign: Word,
    };
    pub const Sym = extern struct {
        name: Word,
        value: Elf32.Addr,
        size: Word,
        info: Info,
        other: Other,
        shndx: Section,

        pub const Info = packed struct(u8) {
            type: STT,
            bind: STB,
        };

        pub const Other = packed struct(u8) {
            visibility: STV,
            unused: u5 = 0,
        };
    };
    pub const Rel = extern struct {
        offset: Elf32.Addr,
        info: Info,
        addend: u0 = 0,

        pub const Info = packed struct(u32) {
            type: u8,
            sym: u24,
        };
    };
    pub const Rela = extern struct {
        offset: Elf32.Addr,
        info: Info,
        addend: i32,

        pub const Info = Elf32.Rel.Info;
    };
    comptime {
        assert(@sizeOf(Elf32.Ehdr) == 52);
        assert(@sizeOf(Elf32.Phdr) == 32);
        assert(@sizeOf(Elf32.Shdr) == 40);
        assert(@sizeOf(Elf32.Sym) == 16);
        assert(@sizeOf(Elf32.Rel) == 8);
        assert(@sizeOf(Elf32.Rela) == 12);
    }
};
pub const Elf64 = struct {
    pub const Addr = u64;
    pub const Off = u64;
    pub const Ehdr = extern struct {
        ident: Ident,
        type: ET,
        machine: EM,
        version: Word,
        entry: Elf64.Addr,
        phoff: Elf64.Off,
        shoff: Elf64.Off,
        flags: EhdrFlags,
        ehsize: Half,
        phentsize: Half,
        phnum: Half,
        shentsize: Half,
        shnum: Half,
        shstrndx: Half,
    };
    pub const Phdr = extern struct {
        type: PT,
        flags: PF,
        offset: Elf64.Off,
        vaddr: Elf64.Addr,
        paddr: Elf64.Addr,
        filesz: Xword,
        memsz: Xword,
        @"align": Xword,
    };
    pub const Shdr = extern struct {
        name: Word,
        type: SHT,
        flags: packed struct(Xword) { shf: SHF, unused: Word = 0 },
        addr: Elf64.Addr,
        offset: Elf64.Off,
        size: Xword,
        link: Word,
        info: Word,
        addralign: Xword,
        entsize: Xword,
    };
    pub const Chdr = extern struct {
        type: COMPRESS,
        reserved: Word = 0,
        size: Xword,
        addralign: Xword,
    };
    pub const Sym = extern struct {
        name: Word,
        info: Info,
        other: Other,
        shndx: Section,
        value: Elf64.Addr,
        size: Xword,

        pub const Info = Elf32.Sym.Info;
        pub const Other = Elf32.Sym.Other;
    };
    pub const Rel = extern struct {
        offset: Elf64.Addr,
        info: Info,
        addend: u0 = 0,

        pub const Info = packed struct(u64) {
            type: u32,
            sym: u32,
        };
    };
    pub const Rela = extern struct {
        offset: Elf64.Addr,
        info: Info,
        addend: i64,

        pub const Info = Elf64.Rel.Info;
    };
    comptime {
        assert(@sizeOf(Elf64.Ehdr) == 64);
        assert(@sizeOf(Elf64.Phdr) == 56);
        assert(@sizeOf(Elf64.Shdr) == 64);
        assert(@sizeOf(Elf64.Sym) == 24);
        assert(@sizeOf(Elf64.Rel) == 16);
        assert(@sizeOf(Elf64.Rela) == 24);
    }
};
pub const ElfN = switch (@sizeOf(usize)) {
    4 => Elf32,
    8 => Elf64,
    else => @compileError("expected pointer size of 32 or 64"),
};

/// 已弃用,请使用 `std.elf.Xword`
pub const Elf32_Xword = Xword;
/// 已弃用,使用 `std.elf.Sxword`
pub const Elf32_Sxword = Sxword;
/// 已弃用,请使用 `std.elf.Xword`
pub const Elf64_Xword = Xword;
/// 已弃用,使用 `std.elf.Sxword`
pub const Elf64_Sxword = i64;
/// 已弃用,请使用 `std.elf.Elf32.Addr`
pub const Elf32_Addr = u32;
/// 已弃用,使用 `std.elf.Elf64.Addr`
pub const Elf64_Addr = u64;
/// 已弃用,请使用 `std.elf.Elf32.Off`
pub const Elf32_Off = u32;
/// 已弃用,使用 `std.elf.Elf64.Off`
pub const Elf64_Off = u64;
/// 已弃用,使用 `std.elf.Section`
pub const Elf32_Section = u16;
/// 已弃用,使用 `std.elf.Section`
pub const Elf64_Section = u16;
/// 已弃用,请使用 `std.elf.Elf32.Ehdr`
pub const Elf32_Ehdr = extern struct {
    e_ident: [EI_NIDENT]u8,
    e_type: ET,
    e_machine: EM,
    e_version: Word,
    e_entry: Elf32_Addr,
    e_phoff: Elf32_Off,
    e_shoff: Elf32_Off,
    e_flags: Word,
    e_ehsize: Half,
    e_phentsize: Half,
    e_phnum: Half,
    e_shentsize: Half,
    e_shnum: Half,
    e_shstrndx: Half,
};
/// 已弃用,请使用 `std.elf.Elf64.Ehdr`
pub const Elf64_Ehdr = extern struct {
    e_ident: [EI.NIDENT]u8,
    e_type: ET,
    e_machine: EM,
    e_version: Word,
    e_entry: Elf64_Addr,
    e_phoff: Elf64_Off,
    e_shoff: Elf64_Off,
    e_flags: Word,
    e_ehsize: Half,
    e_phentsize: Half,
    e_phnum: Half,
    e_shentsize: Half,
    e_shnum: Half,
    e_shstrndx: Half,
};
/// 已弃用,使用 `std.elf.Elf32.Shdr`
pub const Elf32_Shdr = extern struct {
    sh_name: Word,
    sh_type: Word,
    sh_flags: Word,
    sh_addr: Elf32_Addr,
    sh_offset: Elf32_Off,
    sh_size: Word,
    sh_link: Word,
    sh_info: Word,
    sh_addralign: Word,
    sh_entsize: Word,
};
/// 已弃用,请使用 `std.elf.Elf64.Shdr`
pub const Elf64_Shdr = extern struct {
    sh_name: Word,
    sh_type: Word,
    sh_flags: Elf64_Xword,
    sh_addr: Elf64_Addr,
    sh_offset: Elf64_Off,
    sh_size: Elf64_Xword,
    sh_link: Word,
    sh_info: Word,
    sh_addralign: Elf64_Xword,
    sh_entsize: Elf64_Xword,
};
/// 已弃用,请使用 `std.elf.Elf32.Chdr`
pub const Elf32_Chdr = extern struct {
    ch_type: COMPRESS,
    ch_size: Word,
    ch_addralign: Word,
};
/// 已弃用,使用 `std.elf.Elf64.Chdr`
pub const Elf64_Chdr = extern struct {
    ch_type: COMPRESS,
    ch_reserved: Word = 0,
    ch_size: Elf64_Xword,
    ch_addralign: Elf64_Xword,
};
/// 已弃用,请使用 `std.elf.Elf32.Sym`
pub const Elf32_Sym = extern struct {
    st_name: Word,
    st_value: Elf32_Addr,
    st_size: Word,
    st_info: u8,
    st_other: u8,
    st_shndx: Elf32_Section,

    pub inline fn st_type(self: @This()) u4 {
        return @truncate(self.st_info);
    }
    pub inline fn st_bind(self: @This()) u4 {
        return @truncate(self.st_info >> 4);
    }
};
/// 已弃用,请使用 `std.elf.Elf64.Sym`
pub const Elf64_Sym = extern struct {
    st_name: Word,
    st_info: u8,
    st_other: u8,
    st_shndx: Elf64_Section,
    st_value: Elf64_Addr,
    st_size: Elf64_Xword,

    pub inline fn st_type(self: @This()) u4 {
        return @truncate(self.st_info);
    }
    pub inline fn st_bind(self: @This()) u4 {
        return @truncate(self.st_info >> 4);
    }
};
pub const Elf32_Syminfo = extern struct {
    si_boundto: Half,
    si_flags: Half,
};
pub const Elf64_Syminfo = extern struct {
    si_boundto: Half,
    si_flags: Half,
};
pub const Elf32_Rel = extern struct {
    r_offset: Elf32_Addr,
    r_info: Word,

    pub inline fn r_sym(self: @This()) u24 {
        return @truncate(self.r_info >> 8);
    }
    pub inline fn r_type(self: @This()) u8 {
        return @truncate(self.r_info);
    }
};
pub const Elf64_Rel = extern struct {
    r_offset: Elf64_Addr,
    r_info: Elf64_Xword,

    pub inline fn r_sym(self: @This()) u32 {
        return @truncate(self.r_info >> 32);
    }
    pub inline fn r_type(self: @This()) u32 {
        return @truncate(self.r_info);
    }
};
pub const Elf32_Rela = extern struct {
    r_offset: Elf32_Addr,
    r_info: Word,
    r_addend: Sword,

    pub inline fn r_sym(self: @This()) u24 {
        return @truncate(self.r_info >> 8);
    }
    pub inline fn r_type(self: @This()) u8 {
        return @truncate(self.r_info);
    }
};
pub const Elf64_Rela = extern struct {
    r_offset: Elf64_Addr,
    r_info: Elf64_Xword,
    r_addend: Elf64_Sxword,

    pub inline fn r_sym(self: @This()) u32 {
        return @truncate(self.r_info >> 32);
    }
    pub inline fn r_type(self: @This()) u32 {
        return @truncate(self.r_info);
    }
};
pub const Elf32_Relr = Word;
pub const Elf64_Relr = Elf64_Xword;
pub const Elf32_Dyn = extern struct {
    d_tag: Sword,
    d_val: Elf32_Addr,
};
pub const Elf64_Dyn = extern struct {
    d_tag: Elf64_Sxword,
    d_val: Elf64_Addr,
};
pub const Verdef = extern struct {
    version: Half,
    flags: Half,
    ndx: VER_NDX,
    cnt: Half,
    hash: Word,
    aux: Word,
    next: Word,
};
pub const Verdaux = extern struct {
    name: Word,
    next: Word,
};
/// 已弃用,请使用 `std.elf.Verneed`
pub const Elf32_Verneed = extern struct {
    vn_version: Half,
    vn_cnt: Half,
    vn_file: Word,
    vn_aux: Word,
    vn_next: Word,
};
/// 已弃用,请使用 `std.elf.Verneed`
pub const Elf64_Verneed = extern struct {
    vn_version: Half,
    vn_cnt: Half,
    vn_file: Word,
    vn_aux: Word,
    vn_next: Word,
};
pub const Verneed = extern struct {
    version: Half,
    cnt: Half,
    file: Word,
    aux: Word,
    next: Word,
};
pub const Vernaux = extern struct {
    hash: Word,
    flags: Half,
    other: Half,
    name: Word,
    next: Word,
};
pub const Elf32_auxv_t = extern struct {
    a_type: u32,
    a_un: extern union {
        a_val: u32,
    },
};
pub const Elf64_auxv_t = extern struct {
    a_type: u64,
    a_un: extern union {
        a_val: u64,
    },
};
pub const Elf32_Nhdr = extern struct {
    n_namesz: Word,
    n_descsz: Word,
    n_type: Word,
};
pub const Elf64_Nhdr = extern struct {
    n_namesz: Word,
    n_descsz: Word,
    n_type: Word,
};
pub const Elf32_Move = extern struct {
    m_value: Elf32_Xword,
    m_info: Word,
    m_poffset: Word,
    m_repeat: Half,
    m_stride: Half,
};
pub const Elf64_Move = extern struct {
    m_value: Elf64_Xword,
    m_info: Elf64_Xword,
    m_poffset: Elf64_Xword,
    m_repeat: Half,
    m_stride: Half,
};
pub const Elf32_gptab = extern union {
    gt_header: extern struct {
        gt_current_g_value: Word,
        gt_unused: Word,
    },
    gt_entry: extern struct {
        gt_g_value: Word,
        gt_bytes: Word,
    },
};
pub const Elf32_RegInfo = extern struct {
    ri_gprmask: Word,
    ri_cprmask: [4]Word,
    ri_gp_value: Sword,
};
pub const Elf_Options = extern struct {
    kind: u8,
    size: u8,
    section: Elf32_Section,
    info: Word,
};
pub const Elf_Options_Hw = extern struct {
    hwp_flags1: Word,
    hwp_flags2: Word,
};
pub const Elf32_Lib = extern struct {
    l_name: Word,
    l_time_stamp: Word,
    l_checksum: Word,
    l_version: Word,
    l_flags: Word,
};
pub const Elf64_Lib = extern struct {
    l_name: Word,
    l_time_stamp: Word,
    l_checksum: Word,
    l_version: Word,
    l_flags: Word,
};
pub const Elf32_Conflict = Elf32_Addr;
pub const Elf_MIPS_ABIFlags_v0 = extern struct {
    version: Half,
    isa_level: u8,
    isa_rev: u8,
    gpr_size: u8,
    cpr1_size: u8,
    cpr2_size: u8,
    fp_abi: u8,
    isa_ext: Word,
    ases: Word,
    flags1: Word,
    flags2: Word,
};

pub const Auxv = switch (@sizeOf(usize)) {
    4 => Elf32_auxv_t,
    8 => Elf64_auxv_t,
    else => @compileError("expected pointer size of 32 or 64"),
};
/// 已弃用,使用 `std.elf.ElfN.Ehdr`
pub const Ehdr = switch (@sizeOf(usize)) {
    4 => Elf32_Ehdr,
    8 => Elf64_Ehdr,
    else => @compileError("expected pointer size of 32 or 64"),
};
pub const Dyn = switch (@sizeOf(usize)) {
    4 => Elf32_Dyn,
    8 => Elf64_Dyn,
    else => @compileError("expected pointer size of 32 or 64"),
};
pub const Rel = switch (@sizeOf(usize)) {
    4 => Elf32_Rel,
    8 => Elf64_Rel,
    else => @compileError("expected pointer size of 32 or 64"),
};
pub const Rela = switch (@sizeOf(usize)) {
    4 => Elf32_Rela,
    8 => Elf64_Rela,
    else => @compileError("expected pointer size of 32 or 64"),
};
pub const Relr = switch (@sizeOf(usize)) {
    4 => Elf32_Relr,
    8 => Elf64_Relr,
    else => @compileError("expected pointer size of 32 or 64"),
};
pub const Shdr = switch (@sizeOf(usize)) {
    4 => Elf32_Shdr,
    8 => Elf64_Shdr,
    else => @compileError("expected pointer size of 32 or 64"),
};
/// 已弃用,请使用 `std.elf.ElfN.Chdr`
pub const Chdr = switch (@sizeOf(usize)) {
    4 => Elf32_Chdr,
    8 => Elf64_Chdr,
    else => @compileError("expected pointer size of 32 or 64"),
};
/// 已弃用,使用 `std.elf.ElfN.Sym`
pub const Sym = switch (@sizeOf(usize)) {
    4 => Elf32_Sym,
    8 => Elf64_Sym,
    else => @compileError("expected pointer size of 32 or 64"),
};
/// 已弃用,请使用 `std.elf.ElfN.Addr`
pub const Addr = ElfN.Addr;

pub const Ident = extern struct {
    magic: [MAGIC.len]u8 = MAGIC.*,
    class: CLASS,
    data: DATA,
    version: u8,
    osabi: OSABI,
    abiversion: u8,
    pad: [7]u8 = @splat(0),

    comptime {
        assert(@sizeOf(Ident) == EI.NIDENT);
    }
};

/// 已弃用,请使用 `@intFromEnum(std.elf.CLASS.NONE)`
pub const ELFCLASSNONE = @backingInt(CLASS.NONE);
/// 已弃用,请使用 `@intFromEnum(std.elf.CLASS.@"32")`
pub const ELFCLASS32 = @backingInt(CLASS.@"32");
/// 已弃用,请使用 `@intFromEnum(std.elf.CLASS.@"64")`
pub const ELFCLASS64 = @backingInt(CLASS.@"64");
/// 已弃用,请使用 `@intFromEnum(std.elf.CLASS.NUM)`
pub const ELFCLASSNUM = CLASS.NUM;
pub const CLASS = enum(u8) {
    NONE = 0,
    @"32" = 1,
    @"64" = 2,
    _,

    pub const NUM = @typeInfo(CLASS).@"enum".field_names.len;

    pub inline fn size(class: CLASS) u8 {
        return switch (class) {
            .NONE, _ => unreachable,
            .@"32" => 4,
            .@"64" => 8,
        };
    }

    pub fn ElfN(comptime class: CLASS) type {
        return switch (class) {
            .NONE, _ => comptime unreachable,
            .@"32" => Elf32,
            .@"64" => Elf64,
        };
    }
};

/// 已弃用,请使用 `@intFromEnum(std.elf.DATA.NONE)`
pub const ELFDATANONE = @backingInt(DATA.NONE);
/// 已弃用,请使用 `@intFromEnum(std.elf.DATA.@"2LSB")`
pub const ELFDATA2LSB = @backingInt(DATA.@"2LSB");
/// 已弃用,请使用 `@intFromEnum(std.elf.DATA.@"2MSB")`。
pub const ELFDATA2MSB = @backingInt(DATA.@"2MSB");
/// 已弃用,请使用 `@intFromEnum(std.elf.DATA.NUM)`
pub const ELFDATANUM = DATA.NUM;
pub const DATA = enum(u8) {
    NONE = 0,
    @"2LSB" = 1,
    @"2MSB" = 2,
    _,

    pub const NUM = @typeInfo(DATA).@"enum".field_names.len;

    pub inline fn endian(data: DATA) std.lang.Endian {
        return switch (data) {
            .NONE, _ => unreachable,
            .@"2LSB" => .little,
            .@"2MSB" => .big,
        };
    }
};

pub const OSABI = enum(u8) {
    /// UNIX System V ABI
    NONE = 0,
    /// HP-UX 操作系统
    HPUX = 1,
    /// NetBSD
    NETBSD = 2,
    /// GNU (Hurd/Linux)
    GNU = 3,
    /// Solaris
    SOLARIS = 6,
    /// AIX
    AIX = 7,
    /// IRIX
    IRIX = 8,
    /// FreeBSD
    FREEBSD = 9,
    /// TRU64 UNIX
    TRU64 = 10,
    /// Novell Modesto
    MODESTO = 11,
    /// OpenBSD
    OPENBSD = 12,
    /// OpenVMS
    OPENVMS = 13,
    /// Hewlett-Packard Non-Stop 内核
    NSK = 14,
    /// AROS
    AROS = 15,
    /// FenixOS
    FENIXOS = 16,
    /// Nuxi CloudABI
    CLOUDABI = 17,
    /// Stratus Technologies OpenVOS
    OPENVOS = 18,
    /// NVIDIA CUDA 架构(非 gABI 分配)
    CUDA = 51,
    /// AMD HSA 运行时(非 gABI 分配)
    AMDGPU_HSA = 64,
    /// AMD PAL 运行时(未由 gABI 分配)
    AMDGPU_PAL = 65,
    /// AMD Mesa3D 运行时(非 gABI 分配)
    AMDGPU_MESA3D = 66,
    /// ARM(非 gABI 分配)
    ARM = 97,
    /// 独立(嵌入式)应用程序(非 gABI 分配)。
    STANDALONE = 255,

    _,
};

/// 机器架构。
///
/// 当前已注册的 ELF 机器架构参见:
/// http://www.sco.com/developers/gabi/latest/ch4.eheader.html
pub const EM = enum(u16) {
    /// 无机器类型
    NONE = 0,
    /// AT&T WE 32100
    M32 = 1,
    /// SUN SPARC
    SPARC = 2,
    /// Intel 80386
    @"386" = 3,
    /// Motorola m68k 系列
    @"68K" = 4,
    /// Motorola m88k 系列
    @"88K" = 5,
    /// Intel 微控制器
    IAMCU = 6,
    /// Intel 80860
    @"860" = 7,
    /// MIPS R3000(官方仅支持大端序)
    MIPS = 8,
    /// IBM System/370
    S370 = 9,
    /// MIPS R3000(及 R4000)小端序,1993 年 10 月 4 日草案(已弃用)。
    MIPS_RS3_LE = 10,
    /// ABI 制定之前的旧版 Sparc v9(非 gABI 分配)。
    OLD_SPARCV9 = 11,
    /// HPPA
    PARISC = 15,
    /// 富士通 VPP500(也是 PowerPC 的旧值,但未由 gABI 分配)
    VPP500 = 17,
    /// Sun 的“v8plus”
    SPARC32PLUS = 18,
    /// Intel 80960
    @"960" = 19,
    /// PowerPC
    PPC = 20,
    /// 64 位 PowerPC
    PPC64 = 21,
    /// IBM S/390
    S390 = 22,
    /// Sony/Toshiba/IBM 的 SPU
    SPU = 23,
    /// NEC V800 系列
    V800 = 36,
    /// Fujitsu FR20
    FR20 = 37,
    /// TRW RH32
    RH32 = 38,
    /// Motorola M*Core,又称 RCE(也是旧 Fujitsu MMA 的值,该值未获 gABI 分配)
    MCORE = 39,
    /// ARM
    ARM = 40,
    /// Digital Alpha
    OLD_ALPHA = 41,
    /// Renesas(原 Hitachi)/ SuperH SH 架构
    SH = 42,
    /// SPARC v9 64 位
    SPARCV9 = 43,
    /// Siemens Tricore 嵌入式处理器
    TRICORE = 44,
    /// ARC Cores
    ARC = 45,
    /// Renesas(前身为 Hitachi)H8/300
    H8_300 = 46,
    /// Renesas(前身为 Hitachi)H8/300H
    H8_300H = 47,
    /// Renesas(原 Hitachi)H8S
    H8S = 48,
    /// Renesas(原 Hitachi)H8/500 处理器
    H8_500 = 49,
    /// Intel IA-64 处理器
    IA_64 = 50,
    /// Stanford MIPS-X
    MIPS_X = 51,
    /// Motorola Coldfire 处理器
    COLDFIRE = 52,
    /// Motorola M68HC12
    @"68HC12" = 53,
    /// Fujitsu 多媒体加速器
    MMA = 54,
    /// Siemens PCP
    PCP = 55,
    /// Sony nCPU 嵌入式 RISC 处理器
    NCPU = 56,
    /// Denso NDR1 微处理器
    NDR1 = 57,
    /// Motorola Star*Core 处理器
    STARCORE = 58,
    /// Toyota ME16 处理器
    ME16 = 59,
    /// STMicroelectronics ST100 处理器
    ST100 = 60,
    /// Advanced Logic Corp. TinyJ 嵌入式处理器
    TINYJ = 61,
    /// Advanced Micro Devices X86-64 处理器
    X86_64 = 62,
    /// Sony DSP 处理器
    PDSP = 63,
    /// Digital Equipment Corp. 的 PDP-10
    PDP10 = 64,
    /// Digital Equipment Corp. PDP-11
    PDP11 = 65,
    /// Siemens FX66 微控制器
    FX66 = 66,
    /// 意法半导体 ST9+ 8/16 位微控制器
    ST9PLUS = 67,
    /// STMicroelectronics ST7 八位微控制器
    ST7 = 68,
    /// Motorola MC68HC16 微控制器
    @"68HC16" = 69,
    /// Motorola MC68HC11 微控制器
    @"68HC11" = 70,
    /// Motorola MC68HC08 微控制器
    @"68HC08" = 71,
    /// Motorola MC68HC05 微控制器
    @"68HC05" = 72,
    /// Silicon Graphics SVx
    SVX = 73,
    /// STMicroelectronics ST19 8 位 cpu
    ST19 = 74,
    /// Digital VAX
    VAX = 75,
    /// Axis Communications 32 位嵌入式处理器
    CRIS = 76,
    /// Infineon Technologies 32 位嵌入式 CPU
    JAVELIN = 77,
    /// Element 14 的 64 位 DSP 处理器
    FIREPATH = 78,
    /// LSI Logic 的 16 位 DSP 处理器
    ZSP = 79,
    /// Donald Knuth 用于教学的 64 位处理器
    MMIX = 80,
    /// Harvard 的机器无关格式
    HUANY = 81,
    /// SiTera Prism
    PRISM = 82,
    /// Atmel AVR 八位微控制器
    AVR = 83,
    /// Fujitsu FR30
    FR30 = 84,
    /// Mitsubishi D10V
    D10V = 85,
    /// Mitsubishi D30V 处理器
    D30V = 86,
    /// Renesas V850(原 NEC V850)
    V850 = 87,
    /// Renesas M32R(原 Mitsubishi M32R)处理器
    M32R = 88,
    /// Matsushita MN10300
    MN10300 = 89,
    /// Matsushita MN10200 处理器
    MN10200 = 90,
    /// picoJava
    PJ = 91,
    /// OpenRISC 1000 32 位嵌入式处理器
    OR1K = 92,
    /// ARC International ARCompact 处理器
    ARC_COMPACT = 93,
    /// Tensilica Xtensa 架构
    XTENSA = 94,
    /// Alphamosaic VideoCore 处理器(也是旧 Sunplus S+core7 后端的魔数,该值未获 gABI 分配)
    VIDEOCORE = 95,
    /// Thompson Multimedia 通用处理器
    TMM_GPP = 96,
    /// National Semiconductor 32000 系列
    NS32K = 97,
    /// Tenor Network TPC 处理器
    TPC = 98,
    /// Trebia SNP 1000 处理器(也是 picoJava 曾用值,但未由 gABI 分配)
    SNP1K = 99,
    /// STMicroelectronics ST200 微控制器
    ST200 = 100,
    /// Ubicom IP2022 微控制器
    IP2K = 101,
    /// MAX 处理器
    MAX = 102,
    /// 美国国家半导体 CompactRISC
    CR = 103,
    /// Fujitsu F2MC16
    F2MC16 = 104,
    /// TI msp430 微控制器
    MSP430 = 105,
    /// ADI Blackfin
    BLACKFIN = 106,
    /// Seiko Epson 的 S1C33 处理器系列
    SE_C33 = 107,
    /// Sharp 嵌入式微处理器
    SEP = 108,
    /// Arca RISC 微处理器
    ARCA = 109,
    /// 北京大学众志与北京大学微处理器研究开发中心的微处理器系列
    UNICORE = 110,
    /// eXcess:可配置 16/32/64 位的嵌入式 CPU
    EXCESS = 111,
    /// Icera Semiconductor Inc. 深度执行处理器。
    DXP = 112,
    /// Altera Nios II 软核处理器
    ALTERA_NIOS2 = 113,
    /// National Semiconductor CRX 处理器
    CRX = 114,
    /// Motorola XGATE 嵌入式处理器(也是 National Semiconductor CompactRISC 的旧值,该值未获 gABI 分配)
    XGATE = 115,
    /// Infineon C16x/XC16x 处理器
    C166 = 116,
    /// Renesas M16C 系列微处理器
    M16C = 117,
    /// 微芯科技 dsPIC30F 数字信号控制器
    DSPIC30F = 118,
    /// Freescale 通信引擎 RISC 核心
    CE = 119,
    /// Renesas M32C 系列微处理器
    M32C = 120,
    /// Altium TSK3000 核心
    TSK3000 = 131,
    /// Freescale RS08 嵌入式处理器
    RS08 = 132,
    /// Analog Devices SHARC 系列 32 位 DSP 处理器
    SHARC = 133,
    /// Cyan Technology eCOG2 微处理器
    ECOG2 = 134,
    /// Sunplus S+core(及 S+core7)RISC 处理器
    SCORE = 135,
    /// New Japan Radio(NJR)24 位 DSP 处理器
    DSP24 = 136,
    /// Broadcom VideoCore III 处理器
    VIDEOCORE3 = 137,
    /// Lattice FPGA 架构的 RISC 处理器
    LATTICEMICO32 = 138,
    /// Seiko Epson C17 系列
    SE_C17 = 139,
    /// Texas Instruments TMS320C6000 数字信号处理器系列
    TI_C6000 = 140,
    /// Texas Instruments TMS320C2000 DSP 系列
    TI_C2000 = 141,
    /// Texas Instruments TMS320C55x DSP 系列
    TI_C5500 = 142,
    /// Texas Instruments 专用 RISC 处理器,32 位取指。
    TI_ARP32 = 143,
    /// Texas Instruments 可编程实时单元
    TI_PRU = 144,
    /// STMicroelectronics 64 位 VLIW 数据信号处理器。
    MMDSP_PLUS = 160,
    /// Cypress M8C 微处理器
    CYPRESS_M8C = 161,
    /// Renesas R32C 系列微处理器
    R32C = 162,
    /// 恩智浦半导体 TriMedia 架构系列
    TRIMEDIA = 163,
    /// QUALCOMM DSP6 处理器
    QDSP6 = 164,
    /// Intel 8051 及其变体
    @"8051" = 165,
    /// STMicroelectronics STxP7x 系列
    STXP7X = 166,
    /// 晶心科技面向紧凑代码大小的嵌入式 RISC 处理器系列
    NDS32 = 167,
    /// Cyan Technology eCOG1X 系列
    ECOG1X = 168,
    /// Dallas Semiconductor 的 MAXQ30 内核微控制器
    MAXQ30 = 169,
    /// New Japan Radio(NJR)16 位 DSP 处理器
    XIMO16 = 170,
    /// M2000 可重配置 RISC 微处理器
    MANIK = 171,
    /// Cray Inc. NV2 向量架构
    CRAYNV2 = 172,
    /// Renesas RX 系列
    RX = 173,
    /// Imagination Technologies 的 Meta 处理器架构
    METAG = 174,
    /// MCST Elbrus 通用硬件架构
    MCST_ELBRUS = 175,
    /// Cyan Technology eCOG16 系列
    ECOG16 = 176,
    /// National Semiconductor CompactRISC 16 位处理器
    CR16 = 177,
    /// Freescale 扩展时间处理单元
    ETPU = 178,
    /// Infineon Technologies SLE9X 内核
    SLE9X = 179,
    /// Intel L10M
    L10M = 180,
    /// Intel K10M
    K10M = 181,
    /// ARM 64 位架构
    AARCH64 = 183,
    /// Atmel Corporation 的 32 位微处理器系列。
    AVR32 = 185,
    /// STMicroeletronics STM8 八位微控制器
    STM8 = 186,
    /// Tilera TILE64 多核架构系列
    TILE64 = 187,
    /// Tilera TILEPro 多核架构系列
    TILEPRO = 188,
    /// Xilinx MicroBlaze 32 位 RISC 软处理器内核
    MICROBLAZE = 189,
    /// NVIDIA CUDA 架构
    CUDA = 190,
    /// Tilera TILE-Gx 多核架构系列
    TILEGX = 191,
    /// CloudShield 架构系列
    CLOUDSHIELD = 192,
    /// KIPO-KAIST Core-A 第一代处理器系列。
    COREA_1ST = 193,
    /// KIPO-KAIST Core-A 第二代处理器系列
    COREA_2ND = 194,
    /// Synopsys ARCompact V2
    ARC_COMPACT2 = 195,
    /// Open8 8 位 RISC 软处理器核心
    OPEN8 = 196,
    /// Renesas RL78 系列
    RL78 = 197,
    /// Broadcom VideoCore V 处理器
    VIDEOCORE5 = 198,
    /// Renesas 78K0R
    @"78K0R" = 199,
    /// Freescale 56800EX 数字信号控制器 (DSC)
    @"56800EX" = 200,
    /// Beyond BA1 CPU 架构
    BA1 = 201,
    /// Beyond BA2 CPU 架构
    BA2 = 202,
    /// XMOS xCORE 处理器系列
    XCORE = 203,
    /// Microchip 8 位 PIC(r) 系列
    MCHP_PIC = 204,
    /// 英特尔图形技术
    INTELGT = 205,
    /// KM211 KM32 32 位处理器
    KM32 = 210,
    /// KM211 KMX32 32 位处理器
    KMX32 = 211,
    /// KM211 KMX16 16 位处理器
    KMX16 = 212,
    /// KM211 KMX8 8 位处理器
    KMX8 = 213,
    /// KM211 KVARC 处理器
    KVARC = 214,
    /// Paneve CDP 架构系列
    CDP = 215,
    /// Cognitive 智能内存处理器
    COGE = 216,
    /// Bluechip Systems 的 CoolEngine
    COOL = 217,
    /// Nanoradio 优化 RISC 架构
    NORC = 218,
    /// CSR Kalimba 架构系列
    CSR_KALIMBA = 219,
    /// Zilog Z80
    Z80 = 220,
    /// Controls and Data Services 的 VISIUMcore 处理器。
    VISIUM = 221,
    /// FTDI Chip FT32 高性能 32 位 RISC 架构。
    FT32 = 222,
    /// Moxie 处理器系列
    MOXIE = 223,
    /// AMD GPU 架构
    AMDGPU = 224,
    /// RISC-V
    RISCV = 243,
    /// Lanai 32 位处理器
    LANAI = 244,
    /// CEVA 处理器架构系列
    CEVA = 245,
    /// CEVA X2 处理器系列
    CEVA_X2 = 246,
    /// Linux BPF - 内核内虚拟机
    BPF = 247,
    /// Graphcore 智能处理单元(IPU)
    GRAPHCORE_IPU = 248,
    /// Imagination Technologies
    IMG1 = 249,
    /// Netronome 流处理器
    NFP = 250,
    /// NEC 向量引擎
    VE = 251,
    /// C-SKY 处理器系列
    CSKY = 252,
    /// Synopsys ARCv2.3 的 64 位架构
    ARC_COMPACT3_64 = 253,
    /// MOS Technology MCS 6502 处理器
    MCS6502 = 254,
    /// Synopsys ARCv2.3 32 位处理器
    ARC_COMPACT3 = 255,
    /// MPPA 处理器系列的 Kalray VLIW 核心
    KVX = 256,
    /// WDC 65816/65C816
    @"65816" = 257,
    /// LoongArch
    LOONGARCH = 258,
    /// ChipON KungFu32
    KF32 = 259,
    /// LAPIS nX-U16/U8
    U16_U8CORE = 260,
    /// Tachyum
    TACHYUM = 261,
    /// NXP 56800EF 数字信号控制器(DSC)
    @"56800EF" = 262,
    /// Solana 字节码格式
    SBF = 263,
    /// AMD/Xilinx AIEngine 架构
    AIENGINE = 264,
    /// SiMa MLA
    SIMA_MLA = 265,
    /// Cambricon BANG
    BANG = 266,
    /// 龙芯 LoongGPU
    LOONGGPU = 267,
    /// 无锡先进技术研究院 SW64
    SW64 = 268,
    /// AMD/Xilinx AIEngine 控制代码
    AIECTRLCODE = 269,
    /// T-Head PPU
    PPU = 270,
    /// AVR
    AVR_OLD = 0x1057,
    /// MSP430
    MSP430_OLD = 0x1059,
    /// Morpho MT
    MT = 0x2530,
    /// FR30
    CYGNUS_FR30 = 0x3330,
    /// WebAssembly(LLVM 所用格式)
    WEBASSEMBLY = 0x4157,
    /// 英飞凌科技采用 C166-V2 内核的 16 位微控制器
    XC16X = 0x4688,
    /// Freescale S12Z
    S12Z = 0x4def,
    /// DLX
    DLX = 0x5aa5,
    /// FRV
    CYGNUS_FRV = 0x5441,
    /// D10V
    CYGNUS_D10V = 0x7650,
    /// D30V
    CYGNUS_D30V = 0x7676,
    /// Ubicom IP2xxx
    IP2K_OLD = 0x8217,
    /// Cygnus PowerPC ELF
    CYGNUS_POWERPC = 0x9025,
    /// Alpha
    ALPHA = 0x9026,
    /// Cygnus M32R ELF
    CYGNUS_M32R = 0x9041,
    /// V850
    CYGNUS_V850 = 0x9080,
    /// 旧版 S/390
    S390_OLD = 0xa390,
    /// Xtensa 的旧非官方值
    XTENSA_OLD = 0xabc7,
    /// Xstormy16
    XSTORMY16 = 0xad45,
    /// MN10300
    CYGNUS_MN10300 = 0xbeef,
    /// MN10200
    CYGNUS_MN10200 = 0xdead,
    /// Renesas M32C 和 M16C 处理器
    M32C_OLD = 0xfeb0,
    /// Vitesse IQ2000
    IQ2000 = 0xfeba,
    /// NIOS
    NIOS32 = 0xfebb,
    /// Toshiba MeP
    CYGNUS_MEP = 0xf00d,
    /// Moxie 的旧非官方取值
    MOXIE_OLD = 0xfeed,
    /// 旧版 MicroBlaze
    MICROBLAZE_OLD = 0xbaab,
    /// Adapteva 的 Epiphany 架构
    ADAPTEVA_EPIPHANY = 0x1223,

    /// Parallax Propeller(P1)。
    /// 此值是非官方 ELF 值,用于:https://github.com/parallaxinc/propgcc
    PROPELLER = 0x5072,

    /// Parallax Propeller 2(P2)。
    /// 这是非正式 ELF 值,使用于:https://github.com/ne75/llvm-project
    PROPELLER2 = 300,

    _,
};

pub const GRP_COMDAT = 1;

/// 节数据在执行期间应可写。
pub const SHF_WRITE = 0x1;

/// 程序执行期间,该节占用内存。
pub const SHF_ALLOC = 0x2;

/// 该节包含可执行机器指令。
pub const SHF_EXECINSTR = 0x4;

/// 此节中的数据可以合并。
pub const SHF_MERGE = 0x10;

/// 此节中的数据为以空字符结尾的字符串。
pub const SHF_STRINGS = 0x20;

/// 此节中的某个字段保存节头表索引。
pub const SHF_INFO_LINK = 0x40;

/// 为链接编辑器添加特殊的排序要求。
pub const SHF_LINK_ORDER = 0x80;

/// 此节需要进行特殊的操作系统专属处理,以避免行为错误。
///
pub const SHF_OS_NONCONFORMING = 0x100;

/// 此节是某个节组的成员。
pub const SHF_GROUP = 0x200;

/// 此节存储线程局部存储数据。
pub const SHF_TLS = 0x400;

/// 标识包含压缩数据的节。
pub const SHF_COMPRESSED = 0x800;

/// 链接器不得将其作为垃圾回收
pub const SHF_GNU_RETAIN = 0x200000;

/// 此节不包含于最终可执行文件或共享库。
pub const SHF_EXCLUDE = 0x80000000;

/// 目标平台专用标志的起始位置。
pub const SHF_MASKOS = 0x0ff00000;

/// 表示处理器专用标志的位。
pub const SHF_MASKPROC = 0xf0000000;

/// 链接器将所有带“d”标志的节组合成
/// 数据节,启动代码将 dp 寄存器设为
/// 该节的起始位置。
pub const XCORE_SHF_DP_SECTION = 0x10000000;

/// 链接器将所有带“c”标志的节组合成
/// 常量池,启动代码将 cp 寄存器设为常量池的
/// 起始地址。
pub const XCORE_SHF_CP_SECTION = 0x20000000;

/// 目标文件的节未设置此标志时,其大小不得
/// 超过 2GB,使用较小代码模型的目标文件可以自由引用它。
/// 否则,只有使用较大代码模型的目标文件才能引用。
/// 例如,中型代码模型目标文件既能引用设置此标志的节中
/// 的数据,也能引用未设置此标志的节中的
/// 数据;同理,小型代码模型目标文件只能引用
/// 未设置此标志的节中的代码。
pub const SHF_X86_64_LARGE = 0x10000000;

/// 所有带 GPREL 标志的节均归入全局数据区,
/// 以便更快访问。
pub const SHF_HEX_GPREL = 0x10000000;

/// 节包含可能在其他节中重复的文本/数据。
/// 链接器必须仅保留一份。
pub const SHF_MIPS_NODUPES = 0x01000000;

/// 链接器必须生成隐含的隐藏弱名称。
pub const SHF_MIPS_NAMES = 0x02000000;

/// 节数据为进程本地数据。
pub const SHF_MIPS_LOCAL = 0x04000000;

/// 不要剥离此节。
pub const SHF_MIPS_NOSTRIP = 0x08000000;

/// 此节必须属于全局数据区。
pub const SHF_MIPS_GPREL = 0x10000000;

/// 应合并此节。
pub const SHF_MIPS_MERGE = 0x20000000;

/// 根据节条目大小推断地址大小。
pub const SHF_MIPS_ADDR = 0x40000000;

/// 节数据默认是字符串数据。
pub const SHF_MIPS_STRING = 0x80000000;

/// 在仅执行模式下,使代码节不可读。
pub const SHF_ARM_PURECODE = 0x2000000;

pub const SHF = packed struct(Word) {
    /// 节数据在执行期间应可写。
    WRITE: bool = false,
    /// 程序执行期间,该节占用内存。
    ALLOC: bool = false,
    /// 该节包含可执行机器指令。
    EXECINSTR: bool = false,
    unused3: u1 = 0,
    /// 此节中的数据可以合并。
    MERGE: bool = false,
    /// 此节中的数据为以空字符结尾的字符串。
    STRINGS: bool = false,
    /// 此节中的某个字段保存节头表索引。
    INFO_LINK: bool = false,
    /// 为链接编辑器添加特殊的排序要求。
    LINK_ORDER: bool = false,
    /// 此节需要操作系统专用的特殊处理,以避免不正确行为。
    OS_NONCONFORMING: bool = false,
    /// 此节是某个节组的成员。
    GROUP: bool = false,
    /// 此节存储线程局部存储数据。
    TLS: bool = false,
    /// 标识包含压缩数据的节。
    COMPRESSED: bool = false,
    unused12: u8 = 0,
    OS: packed union {
        MASK: u8,
        GNU: packed struct(u8) {
            unused0: u1 = 0,
            /// 链接器不得将其作为垃圾回收
            RETAIN: bool = false,
            unused2: u6 = 0,
        },
        MIPS: packed struct(u8) {
            unused0: u4 = 0,
            /// 节包含可能在其他节中重复的文本/数据。
            /// 链接器必须仅保留一份。
            NODUPES: bool = false,
            /// 链接器必须生成隐含的隐藏弱名称。
            NAMES: bool = false,
            /// 节数据为进程本地数据。
            LOCAL: bool = false,
            /// 不要剥离此节。
            NOSTRIP: bool = false,
        },
        ARM: packed struct(u8) {
            unused0: u5 = 0,
            /// 在仅执行模式下,使代码节不可读。
            PURECODE: bool = false,
            unused6: u2 = 0,
        },
    } = .{ .MASK = 0 },
    PROC: packed union {
        MASK: u4,
        XCORE: packed struct(u4) {
            /// 链接器将所有带“d”标志的节组合成
            /// 数据节,启动代码将 dp 寄存器设为
            /// 该节的起始位置。
            DP_SECTION: bool = false,
            /// 链接器将所有带“c”标志的节组合成
            /// 常量池,启动代码将 cp 寄存器设为常量池的
            /// 起始地址。
            CP_SECTION: bool = false,
            unused2: u1 = 0,
            /// 此节不包含于最终可执行文件或共享库。
            EXCLUDE: bool = false,
        },
        X86_64: packed struct(u4) {
            /// 目标文件的节未设置此标志时,其大小不得
            /// 超过 2GB,使用较小代码模型的目标文件可以自由引用它。
            /// 否则,只有使用较大代码模型的目标文件才能引用。
            /// 例如,中型代码模型目标文件既能引用设置此标志的节中
            /// 的数据,也能引用未设置此标志的节中的
            /// 数据;同理,小型代码模型目标文件只能引用
            /// 未设置此标志的节中的代码。
            LARGE: bool = false,
            unused1: u2 = 0,
            /// 此节不包含于最终可执行文件或共享库。
            EXCLUDE: bool = false,
        },
        HEX: packed struct(u4) {
            /// 所有带 GPREL 标志的节均归入全局数据区,
            /// 以便更快访问。
            GPREL: bool = false,
            unused1: u2 = 0,
            /// 此节不包含于最终可执行文件或共享库。
            EXCLUDE: bool = false,
        },
        MIPS: packed struct(u4) {
            /// 所有带 GPREL 标志的节均归入全局数据区,
            /// 以便更快访问。
            GPREL: bool = false,
            /// 应合并此节。
            MERGE: bool = false,
            /// 根据节条目大小推断地址大小。
            ADDR: bool = false,
            /// 节数据默认是字符串数据。
            STRING: bool = false,
        },
    } = .{ .MASK = 0 },
};

/// 执行
pub const PF_X = 1;

/// 写入
pub const PF_W = 2;

/// 读取
pub const PF_R = 4;

/// 用于操作系统专用语义的位。
pub const PF_MASKOS = 0x0ff00000;

/// 用于处理器专用语义的位。
pub const PF_MASKPROC = 0xf0000000;

pub const PF = packed struct(Word) {
    X: bool = false,
    W: bool = false,
    R: bool = false,
    unused3: u17 = 0,
    OS: packed union {
        MASK: u8,
    } = .{ .MASK = 0 },
    PROC: packed union {
        MASK: u4,
    } = .{ .MASK = 0 },
};

/// 未定义节
pub const SHN_UNDEF = 0;
/// 预留索引的起始位置
pub const SHN_LORESERVE = 0xff00;
/// 处理器专用范围的起点
pub const SHN_LOPROC = 0xff00;
/// 处理器专用范围的结束位置
pub const SHN_HIPROC = 0xff1f;
pub const SHN_LIVEPATCH = 0xff20;
/// 关联符号为绝对符号
pub const SHN_ABS = 0xfff1;
/// 关联符号为公共符号
pub const SHN_COMMON = 0xfff2;
/// 预留索引的结束位置
pub const SHN_HIRESERVE = 0xffff;

// ch_type(压缩算法)的合法值。
pub const COMPRESS = enum(u32) {
    ZLIB = 1,
    ZSTD = 2,
    LOOS = 0x60000000,
    HIOS = 0x6fffffff,
    LOPROC = 0x70000000,
    HIPROC = 0x7fffffff,
    _,
};

/// AMD x86-64 重定位。
pub const R_X86_64 = enum(u32) {
    /// 无重定位
    NONE = 0,
    /// 直接寻址 64 位值
    @"64" = 1,
    /// 相对于程序计数器的 32 位有符号值
    PC32 = 2,
    /// 32 位 GOT 条目
    GOT32 = 3,
    /// 32 位 PLT 地址
    PLT32 = 4,
    /// 在运行时复制符号
    COPY = 5,
    /// 创建 GOT 条目
    GLOB_DAT = 6,
    /// 创建 PLT 条目
    JUMP_SLOT = 7,
    /// 按程序基址调整
    RELATIVE = 8,
    /// 到 GOT 的 32 位有符号 PC 相对偏移
    GOTPCREL = 9,
    /// 直接寻址的 32 位零扩展值
    @"32" = 10,
    /// 直接 32 位符号扩展值
    @"32S" = 11,
    /// 直接 16 位零扩展
    @"16" = 12,
    /// 16 位符号扩展的 PC 相对值
    PC16 = 13,
    /// 直接 8 位符号扩展值
    @"8" = 14,
    /// 8 位符号扩展的程序计数器相对值
    PC8 = 15,
    /// 包含符号的模块 ID
    DTPMOD64 = 16,
    /// 模块 TLS 块中的偏移
    DTPOFF64 = 17,
    /// 初始 TLS 块中的偏移
    TPOFF64 = 18,
    /// GD 符号的两个 GOT 条目的 32 位有符号 PC 相对偏移
    TLSGD = 19,
    /// 指向 LD 符号的两个 GOT 条目的 32 位有符号 PC 相对偏移量。
    TLSLD = 20,
    /// TLS 块内偏移量
    DTPOFF32 = 21,
    /// 相对于 PC、指向 IE 符号 GOT 条目的 32 位有符号偏移
    GOTTPOFF = 22,
    /// 初始 TLS 块中的偏移
    TPOFF32 = 23,
    /// PC 相对 64 位值
    PC64 = 24,
    /// 到 GOT 的 64 位偏移
    GOTOFF64 = 25,
    /// 相对于程序计数器的 32 位有符号 GOT 偏移量
    GOTPC32 = 26,
    /// 64 位 GOT 条目偏移量
    GOT64 = 27,
    /// 到 GOT 条目的 64 位 PC 相对偏移
    GOTPCREL64 = 28,
    /// 相对于程序计数器的 GOT 64 位偏移量
    GOTPC64 = 29,
    /// 与 GOT64 类似,表示需要 PLT 条目
    GOTPLT64 = 30,
    /// PLT 条目的 64 位 GOT 相对偏移量
    PLTOFF64 = 31,
    /// 符号大小加上 32 位加数
    SIZE32 = 32,
    /// 符号大小加 64 位加数
    SIZE64 = 33,
    /// TLS 描述符的 GOT 偏移
    GOTPC32_TLSDESC = 34,
    /// 通过 TLS 描述符调用的标记
    TLSDESC_CALL = 35,
    /// TLS 描述符
    TLSDESC = 36,
    /// 按程序基址进行间接调整
    IRELATIVE = 37,
    /// 按程序基址进行 64 位调整
    RELATIVE64 = 38,
    /// 39 保留,原为 PC32_BND
    /// 40 保留,原为 PLT32_BND
    /// 从不带 REX 前缀的 32 位有符号 PC 相对偏移加载 GOT 条目,可放宽
    GOTPCRELX = 41,
    /// 使用 REX 前缀,从 GOT 条目加载基于 32 位有符号 PC 相对偏移的值;可放宽
    REX_GOTPCRELX = 42,
    _,
};

/// AArch64 重定位。
pub const R_AARCH64 = enum(u32) {
    /// 无重定位。
    NONE = 0,
    /// ILP32 AArch64 重定位。
    /// 直接 32 位。
    P32_ABS32 = 1,
    /// 在运行时复制符号。
    P32_COPY = 180,
    /// 创建 GOT 条目。
    P32_GLOB_DAT = 181,
    /// 创建 PLT 条目。
    P32_JUMP_SLOT = 182,
    /// 按程序基址调整。
    P32_RELATIVE = 183,
    /// 32 位模块编号。
    P32_TLS_DTPMOD = 184,
    /// 相对于模块的偏移量,32 位。
    P32_TLS_DTPREL = 185,
    /// 相对于 TP 的偏移量,32 位。
    P32_TLS_TPREL = 186,
    /// TLS 描述符。
    P32_TLSDESC = 187,
    /// STT_GNU_IFUNC 重定位。
    P32_IRELATIVE = 188,
    /// LP64 AArch64 重定位。
    /// 直接寻址 64 位值。
    ABS64 = 257,
    /// 直接 32 位。
    ABS32 = 258,
    /// 直接寻址 16 位值。
    ABS16 = 259,
    /// PC 相对 64 位值。
    PREL64 = 260,
    /// 相对于程序计数器的 32 位值。
    PREL32 = 261,
    /// PC 相对 16 位。
    PREL16 = 262,
    /// 直接 MOVZ 立即数,取位 15:0。
    MOVW_UABS_G0 = 263,
    /// 同样适用于 MOVK;不检查。
    MOVW_UABS_G0_NC = 264,
    /// 直接寻址 MOVZ 立即数,取位 31:16。
    MOVW_UABS_G1 = 265,
    /// 同样适用于 MOVK;不检查。
    MOVW_UABS_G1_NC = 266,
    /// 直接 MOVZ 立即数,取位 47:32。
    MOVW_UABS_G2 = 267,
    /// 同样适用于 MOVK;不检查。
    MOVW_UABS_G2_NC = 268,
    /// 直接 MOV{K,Z} 立即数,取自 63:48 位。
    MOVW_UABS_G3 = 269,
    /// 直接 MOV{N,Z} 立即数,取自 15:0 位。
    MOVW_SABS_G0 = 270,
    /// 直接寻址 MOV{N,Z} 立即数,取位 31:16。
    MOVW_SABS_G1 = 271,
    /// 直接 MOV{N,Z} 立即数,取位 47:32。
    MOVW_SABS_G2 = 272,
    /// PC 相对 LD 立即数,取自 20:2 位。
    LD_PREL_LO19 = 273,
    /// PC 相对 ADR 立即数,取自 20:0 位。
    ADR_PREL_LO21 = 274,
    /// 页相对 ADRP 立即数,取位 32:12。
    ADR_PREL_PG_HI21 = 275,
    /// 同上;不检查溢出。
    ADR_PREL_PG_HI21_NC = 276,
    /// 直接寻址 ADD 立即数,取位 11:0。
    ADD_ABS_LO12_NC = 277,
    /// 同样适用于 LD/ST;不检查。
    LDST8_ABS_LO12_NC = 278,
    /// PC 相对 TBZ/TBNZ 立即数,取位 15:2。
    TSTBR14 = 279,
    /// PC 相对条件分支立即数,取位 20:2。
    CONDBR19 = 280,
    /// PC 相对 B 立即数,取自 27:2 位。
    JUMP26 = 282,
    /// 同样适用于 CALL。
    CALL26 = 283,
    /// 直接 ADD 立即数,取自 11:1 位。
    LDST16_ABS_LO12_NC = 284,
    /// 位 11:2 同理。
    LDST32_ABS_LO12_NC = 285,
    /// 位 11:3 同理。
    LDST64_ABS_LO12_NC = 286,
    /// 相对于程序计数器的 MOV{N,Z} 立即数,取位 15:0。
    MOVW_PREL_G0 = 287,
    /// 同样适用于 MOVK;不检查。
    MOVW_PREL_G0_NC = 288,
    /// PC 相对 MOV{N,Z} 立即数,取位 31:16。
    MOVW_PREL_G1 = 289,
    /// 同样适用于 MOVK;不检查。
    MOVW_PREL_G1_NC = 290,
    /// PC 相对 MOV{N,Z} 立即数,取自 47:32 位。
    MOVW_PREL_G2 = 291,
    /// 同样适用于 MOVK;不检查。
    MOVW_PREL_G2_NC = 292,
    /// PC 相对 MOV{N,Z} 立即数,取位 63:48。
    MOVW_PREL_G3 = 293,
    /// 直接寻址 ADD 立即数,取位 11:4。
    LDST128_ABS_LO12_NC = 299,
    /// GOT 相对偏移,MOV{N,Z} 立即数取位 15:0。
    MOVW_GOTOFF_G0 = 300,
    /// 同样适用于 MOVK;不检查。
    MOVW_GOTOFF_G0_NC = 301,
    /// GOT 相对偏移量,MOV{N,Z} 立即数,取自 31:16 位。
    MOVW_GOTOFF_G1 = 302,
    /// 同样适用于 MOVK;不检查。
    MOVW_GOTOFF_G1_NC = 303,
    /// GOT 相对偏移,MOV{N,Z} 立即数取位 47:32。
    MOVW_GOTOFF_G2 = 304,
    /// 同样适用于 MOVK;不检查。
    MOVW_GOTOFF_G2_NC = 305,
    /// 相对于 GOT 的偏移,MOV{N,Z} 立即数取位 63:48。
    MOVW_GOTOFF_G3 = 306,
    /// GOT 相对 64 位。
    GOTREL64 = 307,
    /// GOT 相对 32 位值。
    GOTREL32 = 308,
    /// PC 相对 GOT 偏移量加载立即数,取自 20:2 位。
    GOT_LD_PREL19 = 309,
    /// GOT 相对偏移,LD/ST 立即数取位 14:3。
    LD64_GOTOFF_LO15 = 310,
    /// 相对 P 页的 GOT 偏移,ADRP 取位 32:12。
    ADR_GOT_PAGE = 311,
    /// 直接 GOT 偏移,LD/ST 立即数取位 11:3。
    LD64_GOT_LO12_NC = 312,
    /// GOT 页相对偏移量,LD/ST 取自 14:3 位
    LD64_GOTPAGE_LO15 = 313,
    /// PC 相对 ADR 立即数,取位 20:0。
    TLSGD_ADR_PREL21 = 512,
    /// 页相对 ADRP 立即数,取位 32:12。
    TLSGD_ADR_PAGE21 = 513,
    /// 直接 ADD 立即数,取位 11:0。
    TLSGD_ADD_LO12_NC = 514,
    /// 相对于 GOT 的 MOV{N,Z},取位 31:16。
    TLSGD_MOVW_G1 = 515,
    /// GOT 相对 MOVK 立即数,取位 15:0。
    TLSGD_MOVW_G0_NC = 516,
    /// 与 512 类似;局部动态模型。
    TLSLD_ADR_PREL21 = 517,
    /// 与 513 类似;局部动态模型。
    TLSLD_ADR_PAGE21 = 518,
    /// 类似于 514;本地动态模型。
    TLSLD_ADD_LO12_NC = 519,
    /// 与 515 类似;局部动态模型。
    TLSLD_MOVW_G1 = 520,
    /// 与 516 类似;局部动态模型。
    TLSLD_MOVW_G0_NC = 521,
    /// TLS PC 相对加载立即数,取位 20:2。
    TLSLD_LD_PREL19 = 522,
    /// TLS DTP 相对 MOV{N,Z},取位 47:32。
    TLSLD_MOVW_DTPREL_G2 = 523,
    /// 相对于 TLS DTP 的 MOV{N,Z},取位 31:16。
    TLSLD_MOVW_DTPREL_G1 = 524,
    /// 同上;MOVK;不检查。
    TLSLD_MOVW_DTPREL_G1_NC = 525,
    /// TLS DTP 相对 MOV{N,Z},取位 15:0。
    TLSLD_MOVW_DTPREL_G0 = 526,
    /// 同上;MOVK;不检查。
    TLSLD_MOVW_DTPREL_G0_NC = 527,
    /// 相对于 DTP 的 ADD 立即数,取位 23:12。
    TLSLD_ADD_DTPREL_HI12 = 528,
    /// DTP 相对 ADD 立即数,取位 11:0。
    TLSLD_ADD_DTPREL_LO12 = 529,
    /// 同上;不检查溢出。
    TLSLD_ADD_DTPREL_LO12_NC = 530,
    /// DTP 相对 LD/ST 立即数,取位 11:0。
    TLSLD_LDST8_DTPREL_LO12 = 531,
    /// 同上;不检查。
    TLSLD_LDST8_DTPREL_LO12_NC = 532,
    /// DTP 相对 LD/ST 立即数,取位 11:1。
    TLSLD_LDST16_DTPREL_LO12 = 533,
    /// 同上;不检查。
    TLSLD_LDST16_DTPREL_LO12_NC = 534,
    /// 相对于 DTP 的 LD/ST 立即数,取位 11:2。
    TLSLD_LDST32_DTPREL_LO12 = 535,
    /// 同上;不检查。
    TLSLD_LDST32_DTPREL_LO12_NC = 536,
    /// DTP 相对 LD/ST 立即数,取位 11:3。
    TLSLD_LDST64_DTPREL_LO12 = 537,
    /// 同上;不检查。
    TLSLD_LDST64_DTPREL_LO12_NC = 538,
    /// 相对于 GOT 的 MOV{N,Z},取位 31:16。
    TLSIE_MOVW_GOTTPREL_G1 = 539,
    /// 相对于 GOT 的 MOVK,取位 15:0。
    TLSIE_MOVW_GOTTPREL_G0_NC = 540,
    /// 页相对 ADRP,取位 32:12。
    TLSIE_ADR_GOTTPREL_PAGE21 = 541,
    /// 直接 LD 偏移,取位 11:3。
    TLSIE_LD64_GOTTPREL_LO12_NC = 542,
    /// 相对于程序计数器的加载立即数,取位 20:2。
    TLSIE_LD_GOTTPREL_PREL19 = 543,
    /// 相对于 TLS TP 的 MOV{N,Z},取位 47:32。
    TLSLE_MOVW_TPREL_G2 = 544,
    /// TLS TP 相对 MOV{N,Z},取位 31:16。
    TLSLE_MOVW_TPREL_G1 = 545,
    /// 同上;MOVK;不检查。
    TLSLE_MOVW_TPREL_G1_NC = 546,
    /// TLS TP 相对 MOV{N,Z},取位 15:0。
    TLSLE_MOVW_TPREL_G0 = 547,
    /// 同上;MOVK;不检查。
    TLSLE_MOVW_TPREL_G0_NC = 548,
    /// TP 相对 ADD 立即数,取位 23:12。
    TLSLE_ADD_TPREL_HI12 = 549,
    /// TP 相对 ADD 立即数,取位 11:0。
    TLSLE_ADD_TPREL_LO12 = 550,
    /// 同上;不检查溢出。
    TLSLE_ADD_TPREL_LO12_NC = 551,
    /// TP 相对 LD/ST 偏移,取位 11:0。
    TLSLE_LDST8_TPREL_LO12 = 552,
    /// 同上;不检查溢出。
    TLSLE_LDST8_TPREL_LO12_NC = 553,
    /// 相对于 TP 的 LD/ST 偏移,取位 11:1。
    TLSLE_LDST16_TPREL_LO12 = 554,
    /// 同上;不检查。
    TLSLE_LDST16_TPREL_LO12_NC = 555,
    /// TP 相对 LD/ST 偏移量,取位 11:2。
    TLSLE_LDST32_TPREL_LO12 = 556,
    /// 同上;不检查。
    TLSLE_LDST32_TPREL_LO12_NC = 557,
    /// TP 相对 LD/ST 偏移,取位 11:3。
    TLSLE_LDST64_TPREL_LO12 = 558,
    /// 同上;不检查。
    TLSLE_LDST64_TPREL_LO12_NC = 559,
    /// PC 相对加载立即数,取位 20:2。
    TLSDESC_LD_PREL19 = 560,
    /// PC 相对 ADR 立即数,取位 20:0。
    TLSDESC_ADR_PREL21 = 561,
    /// 页相对 ADRP 立即数,取位 32:12。
    TLSDESC_ADR_PAGE21 = 562,
    /// 直接寻址 LD 偏移,取位 11:3。
    TLSDESC_LD64_LO12 = 563,
    /// 直接 ADD 立即数,取位 11:0。
    TLSDESC_ADD_LO12 = 564,
    /// GOT 相对 MOV{N,Z} 立即数,取自 31:16 位。
    TLSDESC_OFF_G1 = 565,
    /// 相对于 GOT 的 MOVK 立即数,取位 15:0;不检查。
    TLSDESC_OFF_G0_NC = 566,
    /// 松弛 LDR。
    TLSDESC_LDR = 567,
    /// 松弛 ADD。
    TLSDESC_ADD = 568,
    /// 松弛 BLR。
    TLSDESC_CALL = 569,
    /// 相对于 TP 的 LD/ST 偏移,取位 11:4。
    TLSLE_LDST128_TPREL_LO12 = 570,
    /// 同上;不检查。
    TLSLE_LDST128_TPREL_LO12_NC = 571,
    /// 相对于 DTP 的 LD/ST 立即数,取位 11:4。
    TLSLD_LDST128_DTPREL_LO12 = 572,
    /// 同上;不检查。
    TLSLD_LDST128_DTPREL_LO12_NC = 573,
    /// 在运行时复制符号。
    COPY = 1024,
    /// 创建 GOT 条目。
    GLOB_DAT = 1025,
    /// 创建 PLT 条目。
    JUMP_SLOT = 1026,
    /// 按程序基址调整。
    RELATIVE = 1027,
    /// 模块编号,64 位。
    TLS_DTPMOD = 1028,
    /// 相对于模块的偏移量,64 位。
    TLS_DTPREL = 1029,
    /// 相对于 TP 的偏移量,64 位。
    TLS_TPREL = 1030,
    /// TLS 描述符。
    TLSDESC = 1031,
    /// STT_GNU_IFUNC 重定位。
    IRELATIVE = 1032,
    _,
};

/// RISC-V 重定位。
pub const R_RISCV = enum(u32) {
    NONE = 0,
    @"32" = 1,
    @"64" = 2,
    RELATIVE = 3,
    COPY = 4,
    JUMP_SLOT = 5,
    TLS_DTPMOD32 = 6,
    TLS_DTPMOD64 = 7,
    TLS_DTPREL32 = 8,
    TLS_DTPREL64 = 9,
    TLS_TPREL32 = 10,
    TLS_TPREL64 = 11,
    TLSDESC = 12,
    BRANCH = 16,
    JAL = 17,
    CALL = 18,
    CALL_PLT = 19,
    GOT_HI20 = 20,
    TLS_GOT_HI20 = 21,
    TLS_GD_HI20 = 22,
    PCREL_HI20 = 23,
    PCREL_LO12_I = 24,
    PCREL_LO12_S = 25,
    HI20 = 26,
    LO12_I = 27,
    LO12_S = 28,
    TPREL_HI20 = 29,
    TPREL_LO12_I = 30,
    TPREL_LO12_S = 31,
    TPREL_ADD = 32,
    ADD8 = 33,
    ADD16 = 34,
    ADD32 = 35,
    ADD64 = 36,
    SUB8 = 37,
    SUB16 = 38,
    SUB32 = 39,
    SUB64 = 40,
    GNU_VTINHERIT = 41,
    GNU_VTENTRY = 42,
    ALIGN = 43,
    RVC_BRANCH = 44,
    RVC_JUMP = 45,
    RVC_LUI = 46,
    GPREL_I = 47,
    GPREL_S = 48,
    TPREL_I = 49,
    TPREL_S = 50,
    RELAX = 51,
    SUB6 = 52,
    SET6 = 53,
    SET8 = 54,
    SET16 = 55,
    SET32 = 56,
    @"32_PCREL" = 57,
    IRELATIVE = 58,
    PLT32 = 59,
    SET_ULEB128 = 60,
    SUB_ULEB128 = 61,
    _,
};

/// PowerPC64 重定位。
pub const R_PPC64 = enum(u32) {
    NONE = 0,
    ADDR32 = 1,
    ADDR24 = 2,
    ADDR16 = 3,
    ADDR16_LO = 4,
    ADDR16_HI = 5,
    ADDR16_HA = 6,
    ADDR14 = 7,
    ADDR14_BRTAKEN = 8,
    ADDR14_BRNTAKEN = 9,
    REL24 = 10,
    REL14 = 11,
    REL14_BRTAKEN = 12,
    REL14_BRNTAKEN = 13,
    GOT16 = 14,
    GOT16_LO = 15,
    GOT16_HI = 16,
    GOT16_HA = 17,
    COPY = 19,
    GLOB_DAT = 20,
    JMP_SLOT = 21,
    RELATIVE = 22,
    REL32 = 26,
    PLT16_LO = 29,
    PLT16_HI = 30,
    PLT16_HA = 31,
    ADDR64 = 38,
    ADDR16_HIGHER = 39,
    ADDR16_HIGHERA = 40,
    ADDR16_HIGHEST = 41,
    ADDR16_HIGHESTA = 42,
    REL64 = 44,
    TOC16 = 47,
    TOC16_LO = 48,
    TOC16_HI = 49,
    TOC16_HA = 50,
    TOC = 51,
    ADDR16_DS = 56,
    ADDR16_LO_DS = 57,
    GOT16_DS = 58,
    GOT16_LO_DS = 59,
    PLT16_LO_DS = 60,
    TOC16_DS = 63,
    TOC16_LO_DS = 64,
    TLS = 67,
    DTPMOD64 = 68,
    TPREL16 = 69,
    TPREL16_LO = 70,
    TPREL16_HI = 71,
    TPREL16_HA = 72,
    TPREL64 = 73,
    DTPREL16 = 74,
    DTPREL16_LO = 75,
    DTPREL16_HI = 76,
    DTPREL16_HA = 77,
    DTPREL64 = 78,
    GOT_TLSGD16 = 79,
    GOT_TLSGD16_LO = 80,
    GOT_TLSGD16_HI = 81,
    GOT_TLSGD16_HA = 82,
    GOT_TLSLD16 = 83,
    GOT_TLSLD16_LO = 84,
    GOT_TLSLD16_HI = 85,
    GOT_TLSLD16_HA = 86,
    GOT_TPREL16_DS = 87,
    GOT_TPREL16_LO_DS = 88,
    GOT_TPREL16_HI = 89,
    GOT_TPREL16_HA = 90,
    GOT_DTPREL16_DS = 91,
    GOT_DTPREL16_LO_DS = 92,
    GOT_DTPREL16_HI = 93,
    GOT_DTPREL16_HA = 94,
    TPREL16_DS = 95,
    TPREL16_LO_DS = 96,
    TPREL16_HIGHER = 97,
    TPREL16_HIGHERA = 98,
    TPREL16_HIGHEST = 99,
    TPREL16_HIGHESTA = 100,
    DTPREL16_DS = 101,
    DTPREL16_LO_DS = 102,
    DTPREL16_HIGHER = 103,
    DTPREL16_HIGHERA = 104,
    DTPREL16_HIGHEST = 105,
    DTPREL16_HIGHESTA = 106,
    TLSGD = 107,
    TLSLD = 108,
    ADDR16_HIGH = 110,
    ADDR16_HIGHA = 111,
    TPREL16_HIGH = 112,
    TPREL16_HIGHA = 113,
    DTPREL16_HIGH = 114,
    DTPREL16_HIGHA = 115,
    REL24_NOTOC = 116,
    PLTSEQ = 119,
    PLTCALL = 120,
    PLTSEQ_NOTOC = 121,
    PLTCALL_NOTOC = 122,
    PCREL_OPT = 123,
    PCREL34 = 132,
    GOT_PCREL34 = 133,
    PLT_PCREL34 = 134,
    PLT_PCREL34_NOTOC = 135,
    TPREL34 = 146,
    DTPREL34 = 147,
    GOT_TLSGD_PCREL34 = 148,
    GOT_TLSLD_PCREL34 = 149,
    GOT_TPREL_PCREL34 = 150,
    IRELATIVE = 248,
    REL16 = 249,
    REL16_LO = 250,
    REL16_HI = 251,
    REL16_HA = 252,
    _,
};

/// 截至 ABI 规范 v2.50 的 LoongArch 重定位。
pub const R_LARCH = enum(u32) {
    NONE = 0,
    @"32" = 1,
    @"64" = 2,
    RELATIVE = 3,
    COPY = 4,
    JUMP_SLOT = 5,
    TLS_DTPMOD32 = 6,
    TLS_DTPMOD64 = 7,
    TLS_DTPREL32 = 8,
    TLS_DTPREL64 = 9,
    TLS_TPREL32 = 10,
    TLS_TPREL64 = 11,
    IRELATIVE = 12,
    TLS_DESC32 = 13,
    TLS_DESC64 = 14,
    MARK_LA = 20,
    MARK_PCREL = 21,
    SOP_PUSH_PCREL = 22,
    SOP_PUSH_ABSOLUTE = 23,
    SOP_PUSH_DUP = 24,
    SOP_PUSH_GPREL = 25,
    SOP_PUSH_TLS_TPREL = 26,
    SOP_PUSH_TLS_GOT = 27,
    SOP_PUSH_TLS_GD = 28,
    SOP_PUSH_PLT_PCREL = 29,
    SOP_ASSERT = 30,
    SOP_NOT = 31,
    SOP_SUB = 32,
    SOP_SL = 33,
    SOP_SR = 34,
    SOP_ADD = 35,
    SOP_AND = 36,
    SOP_IF_ELSE = 37,
    SOP_POP_32_S_10_5 = 38,
    SOP_POP_32_U_10_12 = 39,
    SOP_POP_32_S_10_12 = 40,
    SOP_POP_32_S_10_16 = 41,
    SOP_POP_32_S_10_16_S2 = 42,
    SOP_POP_32_S_5_20 = 43,
    SOP_POP_32_S_0_5_10_16_S2 = 44,
    SOP_POP_32_S_0_10_10_16_S2 = 45,
    SOP_POP_32_U = 46,
    ADD8 = 47,
    ADD16 = 48,
    ADD24 = 49,
    ADD32 = 50,
    ADD64 = 51,
    SUB8 = 52,
    SUB16 = 53,
    SUB24 = 54,
    SUB32 = 55,
    SUB64 = 56,
    GNU_VTINHERIT = 57,
    GNU_VTENTRY = 58,
    B16 = 64,
    B21 = 65,
    B26 = 66,
    ABS_HI20 = 67,
    ABS_LO12 = 68,
    ABS64_LO20 = 69,
    ABS64_HI12 = 70,
    PCALA_HI20 = 71,
    PCALA_LO12 = 72,
    PCALA64_LO20 = 73,
    PCALA64_HI12 = 74,
    GOT_PC_HI20 = 75,
    GOT_PC_LO12 = 76,
    GOT64_PC_LO20 = 77,
    GOT64_PC_HI12 = 78,
    GOT_HI20 = 79,
    GOT_LO12 = 80,
    GOT64_LO20 = 81,
    GOT64_HI12 = 82,
    TLS_LE_HI20 = 83,
    TLS_LE_LO12 = 84,
    TLS_LE64_LO20 = 85,
    TLS_LE64_HI12 = 86,
    TLS_IE_PC_HI20 = 87,
    TLS_IE_PC_LO12 = 88,
    TLS_IE64_PC_LO20 = 89,
    TLS_IE64_PC_HI12 = 90,
    TLS_IE_HI20 = 91,
    TLS_IE_LO12 = 92,
    TLS_IE64_LO20 = 93,
    TLS_IE64_HI12 = 94,
    TLS_LD_PC_HI20 = 95,
    TLS_LD_HI20 = 96,
    TLS_GD_PC_HI20 = 97,
    TLS_GD_HI20 = 98,
    @"32_PCREL" = 99,
    RELAX = 100,
    DELETE = 101,
    ALIGN = 102,
    PCREL20_S2 = 103,
    CFA = 104,
    ADD6 = 105,
    SUB6 = 106,
    ADD_ULEB128 = 107,
    SUB_ULEB128 = 108,
    @"64_PCREL" = 109,
    CALL36 = 110,
    TLS_DESC_PC_HI20 = 111,
    TLS_DESC_PC_LO12 = 112,
    TLS_DESC64_PC_LO20 = 113,
    TLS_DESC64_PC_HI12 = 114,
    TLS_DESC_HI20 = 115,
    TLS_DESC_LO12 = 116,
    TLS_DESC64_LO20 = 117,
    TLS_DESC64_HI12 = 118,
    TLS_DESC_LD = 119,
    TLS_DESC_CALL = 120,
    TLS_LE_HI20_R = 121,
    TLS_LE_ADD_R = 122,
    TLS_LE_LO12_R = 123,
    TLS_LD_PCREL20_S2 = 124,
    TLS_GD_PCREL20_S2 = 125,
    TLS_DESC_PCREL20_S2 = 126,
    CALL30 = 127,
    PCADD_HI20 = 128,
    PCADD_LO12 = 129,
    GOT_PCADD_HI20 = 130,
    GOT_PCADD_LO12 = 131,
    TLS_IE_PCADD_HI20 = 132,
    TLS_IE_PCADD_LO12 = 133,
    TLS_LD_PCADD_HI20 = 134,
    TLS_LD_PCADD_LO12 = 135,
    TLS_GD_PCADD_HI20 = 136,
    TLS_GD_PCADD_LO12 = 137,
    TLS_DESC_PCADD_HI20 = 138,
    TLS_DESC_PCADD_LO12 = 139,
    _,
};

pub const R_SPARC = enum(u32) {
    NONE = 0,
    @"8" = 1,
    @"16" = 2,
    @"32" = 3,
    DISP8 = 4,
    DISP16 = 5,
    DISP32 = 6,
    WDISP30 = 7,
    WDISP22 = 8,
    HI22 = 9,
    @"22" = 10,
    @"13" = 11,
    LO10 = 12,
    GOT10 = 13,
    GOT13 = 14,
    GOT22 = 15,
    PC10 = 16,
    PC22 = 17,
    WPLT30 = 18,
    COPY = 19,
    GLOB_DAT = 20,
    JMP_SLOT = 21,
    RELATIVE = 22,
    UA32 = 23,
    PLT32 = 24,
    HIPLT22 = 25,
    LOPLT10 = 26,
    PCPLT32 = 27,
    PCPLT22 = 28,
    PCPLT10 = 29,
    @"10" = 30,
    @"11" = 31,
    @"64" = 32,
    OLO10 = 33,
    HH22 = 34,
    HM10 = 35,
    LM22 = 36,
    PC_HH22 = 37,
    PC_HM10 = 38,
    PC_LM22 = 39,
    WDISP16 = 40,
    WDISP19 = 41,
    @"7" = 43,
    @"5" = 44,
    @"6" = 45,
    DISP64 = 46,
    PLT64 = 47,
    HIX22 = 48,
    LOX10 = 49,
    H44 = 50,
    M44 = 51,
    L44 = 52,
    REGISTER = 53,
    UA64 = 54,
    UA16 = 55,
    TLS_GD_HI22 = 56,
    TLS_GD_LO10 = 57,
    TLS_GD_ADD = 58,
    TLS_GD_CALL = 59,
    TLS_LDM_HI22 = 60,
    TLS_LDM_LO10 = 61,
    TLS_LDM_ADD = 62,
    TLS_LDM_CALL = 63,
    TLS_LDO_HIX22 = 64,
    TLS_LDO_LOX10 = 65,
    TLS_LDO_ADD = 66,
    TLS_IE_HI22 = 67,
    TLS_IE_LO10 = 68,
    TLS_IE_LD = 69,
    TLS_IE_LDX = 70,
    TLS_IE_ADD = 71,
    TLS_LE_HIX22 = 72,
    TLS_LE_LOX10 = 73,
    TLS_DTPMOD32 = 74,
    TLS_DTPMOD64 = 75,
    TLS_DTPOFF32 = 76,
    TLS_DTPOFF64 = 77,
    TLS_TPOFF32 = 78,
    TLS_TPOFF64 = 79,
    GOTDATA_HIX22 = 80,
    GOTDATA_LOX10 = 81,
    GOTDATA_OP_HIX22 = 82,
    GOTDATA_OP_LOX10 = 83,
    GOTDATA_OP = 84,
    H34 = 85,
    SIZE32 = 86,
    SIZE64 = 87,
    WDISP10 = 88,
    IRELATIVE = 249,
    _,
};

pub const ar_hdr = extern struct {
    /// 成员文件名,有时以 / 终止。
    ar_name: [16]u8,

    /// 文件日期,自纪元起的十进制秒数。
    ar_date: [12]u8,

    /// ASCII 格式的用户 ID。
    ar_uid: [6]u8,

    /// ASCII 格式的组 ID。
    ar_gid: [6]u8,

    /// 文件模式,以 ASCII 八进制表示。
    ar_mode: [8]u8,

    /// 文件大小,以 ASCII 十进制表示。
    ar_size: [10]u8,

    /// 始终包含 ARFMAG。
    ar_fmag: [2]u8,

    pub fn date(self: ar_hdr) std.fmt.ParseIntError!u64 {
        const value = mem.trimEnd(u8, &self.ar_date, " ");
        return std.fmt.parseInt(u64, value, 10);
    }

    pub fn size(self: ar_hdr) std.fmt.ParseIntError!u32 {
        const value = mem.trimEnd(u8, &self.ar_size, " ");
        return std.fmt.parseInt(u32, value, 10);
    }

    pub fn isStrtab(self: ar_hdr) bool {
        return mem.eql(u8, &self.ar_name, STRNAME);
    }

    pub fn isSymtab(self: ar_hdr) bool {
        return mem.eql(u8, &self.ar_name, SYMNAME);
    }

    pub fn isSymtab64(self: ar_hdr) bool {
        return mem.eql(u8, &self.ar_name, SYM64NAME);
    }

    pub fn isSymdef(self: ar_hdr) bool {
        return mem.eql(u8, &self.ar_name, SYMDEFNAME);
    }

    pub fn isSymdefSorted(self: ar_hdr) bool {
        return mem.eql(u8, &self.ar_name, SYMDEFSORTEDNAME);
    }

    pub fn name(self: *const ar_hdr) ?[]const u8 {
        const value = &self.ar_name;
        if (value[0] == '/') return null;
        const sentinel = mem.findScalar(u8, value, '/') orelse value.len;
        return value[0..sentinel];
    }

    pub fn nameOffset(self: ar_hdr) std.fmt.ParseIntError!?u32 {
        const value = &self.ar_name;
        if (value[0] != '/') return null;
        const trimmed = mem.trimEnd(u8, value, " ");
        return try std.fmt.parseInt(u32, trimmed[1..], 10);
    }
};

fn genSpecialMemberName(comptime name: []const u8) *const [16]u8 {
    assert(name.len <= 16);
    const padding = 16 - name.len;
    return name ++ @as([padding]u8, @splat(' '));
}

// 归档文件以 ARMAG 标识字符串开头。对于每个成员文件,随后是
// `struct ar_hdr',以及由其 `ar_size'
// 成员指示字节数的成员文件数据。
/// 归档文件的起始字符串。
pub const ARMAG = "!<arch>\n";
/// 精简归档文件的起始字符串。
pub const ARMAG_THIN = "!<thin>\n";
/// 每个头部末尾 ar_fmag 中的字符串。
pub const ARFMAG = "`\n";
/// 32 位符号表标识符
pub const SYMNAME = genSpecialMemberName("/");
/// Strtab 标识符
pub const STRNAME = genSpecialMemberName("//");
/// 64 位符号表标识符
pub const SYM64NAME = genSpecialMemberName("/SYM64/");
pub const SYMDEFNAME = genSpecialMemberName("__.SYMDEF");
pub const SYMDEFSORTEDNAME = genSpecialMemberName("__.SYMDEF SORTED");

pub const gnu_hash = struct {

    // 参见 https://flapenguin.me/elf-dt-gnu-hash

    pub const Header = extern struct {
        nbuckets: u32,
        symoffset: u32,
        bloom_size: u32,
        bloom_shift: u32,
    };

    pub const ChainEntry = packed struct(u32) {
        end_of_chain: bool,
        /// 包含哈希值的最高位。
        hash: u31,
    };

    /// 计算名称对应的哈希值
    pub fn calculate(name: []const u8) u32 {
        var h: u32 = 5381;
        for (name) |char| {
            h = (h << 5) +% h +% char;
        }
        return h;
    }

    test calculate {
        try std.testing.expectEqual(0x00001505, calculate(""));
        try std.testing.expectEqual(0x156b2bb8, calculate("printf"));
        try std.testing.expectEqual(0x7c967e3f, calculate("exit"));
        try std.testing.expectEqual(0xbac212a0, calculate("syscall"));
        try std.testing.expectEqual(0x8ae9f18e, calculate("flapenguin.me"));
    }
};

/// 用于 `SHT.HASH` 节类型的相关内容。
///
/// 资料:
/// * https://refspecs.linuxfoundation.org/elf/gabi4+/ch5.dynamic.html#hash
/// * https://flapenguin.me/elf-dt-hash
/// * https://github.com/IBM/s390x-abi
pub const hash = struct {
    pub fn calculate(name: []const u8) u32 {
        var h: u32 = 0;
        for (name) |c| {
            h = (h << 4) +% c;
            const g = h & 0xF000_0000;
            h = (h ^ (g >> 24)) & ~g;
        }
        return h;
    }

    /// 多数架构上 `SHT.HASH` 节的头部,其后紧跟:
    /// * `buckets: [nbucket]u32`
    /// * `chains: [nchain]u32`
    ///
    /// 名为 `name` 的符号所在桶为 `std.elf.hash.calculate(name) % nbuckets`。
    ///
    /// `buckets[b]` 是桶 `b` 中第一个符号的索引。若桶 `b` 为空,则值为 0(`STN_UNDEF`)。
    ///
    /// `chain[sym_index]` 是与 `sym_index` 同桶的下一个符号的索引。若 `sym_index` 为桶内最后一个符号,则值为 0(`STN_UNDEF`)。
    ///
    /// 另见 `Header64`。
    ///
    ///
    pub const Header32 = extern struct {
        nbucket: u32,
        nchain: u32,
    };

    /// alpha 和 s390x 上 `SHT.HASH` 节的头部。紧接着是:
    /// * `buckets: [nbucket]u64`
    /// * `chains: [nchain]u64`
    ///
    /// 另请参见 `Header32`。
    pub const Header64 = extern struct {
        nbucket: u64,
        nchain: u64,
    };
};

pub const EhdrFlags = packed union(Word) {
    int: u32,
    loongarch: Loongarch,
    sparc: Sparc,

    pub const Loongarch = packed struct(u32) {
        base_abi_modifier: BaseAbiModifier,
        abi_extension: AbiExtension,
        abi_version: u2,
        reserved: u24 = 0,

        pub const BaseAbiModifier = enum(u3) {
            s = 1,
            f = 2,
            d = 3,
            _,
        };
        pub const AbiExtension = enum(u3) { base = 0, _ };
    };

    pub const Sparc = packed struct(u32) {
        mm: MemoryModel,
        _reserved1: u6 = 0,
        ext: Extensions,
        _reserved2: u8 = 0,

        pub const MemoryModel = enum(u2) {
            /// 全存储定序
            tso = 0,
            /// 部分存储顺序
            pso = 1,
            /// 宽松内存序
            rmo = 2,
        };

        pub const Extensions = packed struct(u16) {
            /// 在 SPARC v9 上使用 SPARC v8 ABI(32 位指针),也称为 v8+。
            @"32plus": bool,
            /// 使用 Sun UltraSPARC 扩展。
            sun_us1: bool,
            /// 使用 HaL R1 扩展。
            hal_r1: bool,
            /// 使用 Sun UltraSPARC III 扩展。
            sun_us3: bool,
            _reserved: u11 = 0,
            /// 使用小端序数据(SPARC v9+)。
            le_data: bool,
        };
    };
};