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

第 1 行

执行代码的机器的全部详细信息。 与可能将部分项保留为“default”或“host”的 Query 不同, 此数据已完全解析为具体的操作系统版本、处理器特性 等。

字段

cpu: Cpu
os: Os
abi: Abi
ofmt: ObjectFormat
dynamic_linker: DynamicLinker = DynamicLinker.none

std.Target.aarch64

别名

第 775 行

别名目标 std.Target.aarch64

std.Target.Abi

容器

第 811 行

字段

none
gnu
gnuabin32
gnuabi64
gnueabi
gnueabihf
gnuf32
gnusf
gnux32
eabi
eabihf
abin32
x32
ilp32
android
androideabi
musl
muslabin32
muslabi64
musleabi
musleabihf
muslf32
muslsf
muslx32
msvc
itanium
simulator
ohos
ohoseabi
call0

std.Target.Abi.default

函数

第 843 行

pub fn default(arch: Cpu.Arch, os_tag: Os.Tag) Abi

参数

arch: Cpu.Arch
os_tag: Os.Tag

std.Target.Abi.float

函数

第 1039 行

pub inline fn float(abi: Abi) Float

参数

abi: Abi

std.Target.Abi.Float

容器

第 1034 行

字段

hard
soft

std.Target.Abi.isAndroid

函数

第 1027 行

pub inline fn isAndroid(abi: Abi) bool

参数

abi: Abi

std.Target.Abi.isGnu

函数

第 990 行

pub inline fn isGnu(abi: Abi) bool

参数

abi: Abi

std.Target.Abi.isMusl

函数

第 1005 行

pub inline fn isMusl(abi: Abi) bool

参数

abi: Abi

std.Target.Abi.isOpenHarmony

函数

第 1020 行

pub inline fn isOpenHarmony(abi: Abi) bool

参数

abi: Abi

std.Target.AddressSpaceContext

容器

第 2366 行

用户可以指定地址空间属性的位置

字段

function

指定将函数置于特定地址空间。

variable

指定将某个(全局)变量放入特定地址空间。 与 .constant 不同,这些值(因此也包括放置它们的地址空间) 必须可变。

constant

指定将某个(全局)常量值放入特定地址空间。 与 .variable 不同,放入此地址空间的值不要求可变。

pointer

指针被标注为指向某个地址空间。

std.Target.Allocator

别名

第 3798 行

别名目标 std.mem.Allocator

std.Target.alpha

别名

第 776 行

别名目标 std.Target.alpha

std.Target.amdgcn

别名

第 777 行

别名目标 std.Target.amdgcn

std.Target.arc

别名

第 778 行

别名目标 std.Target.arc

std.Target.arm

别名

第 779 行

别名目标 std.Target.arm

std.Target.assert

别名

第 3799 行

别名目标 std.debug.assert

std.Target.avr

别名

第 780 行

别名目标 std.Target.avr

std.Target.bpf

别名

第 781 行

别名目标 std.Target.bpf

std.Target.builtin

常量

第 3797 行

std.Target.cCallingConvention

函数

第 3714 行

pub fn cCallingConvention(target: *const Target) ?std.builtin.CallingConvention

参数

target: *const Target

std.Target.cCharSignedness

函数

第 3180 行

此目标的本机 C 编译器中,char 默认是否有符号。 注意,char 的符号属性由实现定义,且许多编译器提供 覆盖默认符号属性的选项,例如 GCC 的 -funsigned-char / -fsigned-char。 如果未为此目标定义 C ABI,则返回 null。

pub fn cCharSignedness(target: *const Target) ?std.builtin.Signedness

参数

target: *const Target

std.Target.cMaxIntAlignment

函数

第 3635 行

pub fn cMaxIntAlignment(target: *const Target) u16

参数

target: *const Target

std.Target.Cpu

容器

第 1217 行

字段

arch: Arch

架构

model: *const Model

目标 CPU 型号。它具有一组特性, 可由 features 字段覆盖。

features: Feature.Set

明确列出完整 CPU 特性集。它可能不同于具体 CPU 型号的特性。

std.Target.Cpu.Arch

容器

第 1372 行

字段

aarch64
aarch64_be
alpha
amdgcn
arc
arceb
arm
armeb
avr
bpfeb
bpfel
csky
ez80
hexagon
hppa
hppa64
kalimba
kvx
lanai
loongarch32
loongarch64
m68k
m88k
microblaze
microblazeel
mips
mipsel
mips64
mips64el
msp430
nvptx
nvptx64
or1k
powerpc
powerpcle
powerpc64
powerpc64le
propeller
riscv32
riscv32be
riscv64
riscv64be
s390x
sh
sheb
sparc
sparc64
spork8
spirv32
spirv64
thumb
thumbeb
ve
wasm32
wasm64
x86_16
x86
x86_64
xcore
xtensa
xtensaeb

std.Target.Cpu.Arch.allCpuModels

函数

第 1798 行

Zig 已知的所有处理器,按名称字典序排列。

pub fn allCpuModels(arch: Arch) []const *const Cpu.Model

参数

arch: Arch

std.Target.Cpu.Arch.allCpusFromDecls

函数

第 1804 行

fn allCpusFromDecls(comptime cpus: type) []const *const Cpu.Model

参数

cpus: type

std.Target.Cpu.Arch.allFeaturesList

函数

第 1791 行

Zig 已知的所有 CPU 特性,按名称字典序排列。

pub fn allFeaturesList(arch: Arch) []const Cpu.Feature

参数

arch: Arch

std.Target.Cpu.Arch.endian

函数

第 1718 行

pub fn endian(arch: Arch) std.builtin.Endian

参数

arch: Arch

std.Target.Cpu.Arch.family

函数

第 1476 行

pub inline fn family(arch: Arch) Family

参数

arch: Arch

std.Target.Cpu.Arch.Family

容器

第 1438 行

一个架构族可涵盖多个由 Arch 表示的架构。 对于给定架构族标签,保证存在 std.Target.<tag> 命名空间, 其中包含 CPU 型号和特性数据。

字段

std.Target.Cpu.Arch.fromCallingConvention

函数

第 1841 行

返回特定 std.builtin.CallingConvention 适用的 Arch 数组。 断言 cc 不是 .auto、.@"async"、.naked 或 .@"inline"。

pub fn fromCallingConvention(cc: std.builtin.CallingConvention.Tag) []const Arch

参数

std.Target.Cpu.Arch.isAarch64

函数

第 1541 行

pub inline fn isAarch64(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isAARCH64

别名

第 1539 行

已弃用;将在 0.18.0 中移除。请改用 isAarch64。

别名目标 std.Target.Cpu.Arch.isAarch64

std.Target.Cpu.Arch.isArc

函数

第 1548 行

pub inline fn isArc(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isArm

函数

第 1524 行

注意,此处包含 Thumb。

pub inline fn isArm(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isBpf

函数

第 1688 行

pub inline fn isBpf(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isHppa

函数

第 1555 行

pub inline fn isHppa(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isLoongarch

函数

第 1572 行

pub inline fn isLoongarch(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isLoongArch

别名

第 1570 行

已弃用;将在 0.18.0 中移除。请改用 isLoongarch。

别名目标 std.Target.Cpu.Arch.isLoongarch

std.Target.Cpu.Arch.isMicroblaze

函数

第 1600 行

pub inline fn isMicroblaze(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isMips

函数

第 1610 行

pub inline fn isMips(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isMIPS

别名

第 1608 行

已弃用;将在 0.18.0 中移除。请改用 isMips。

别名目标 std.Target.Cpu.Arch.isMips

std.Target.Cpu.Arch.isMips32

函数

第 1617 行

pub inline fn isMips32(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isMIPS32

别名

第 1615 行

已弃用;将在 0.18.0 中移除。请改用 isMips32。

别名目标 std.Target.Cpu.Arch.isMips32

std.Target.Cpu.Arch.isMips64

函数

第 1627 行

pub inline fn isMips64(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isMIPS64

别名

第 1625 行

已弃用;将在 0.18.0 中移除。请改用 isMips64。

别名目标 std.Target.Cpu.Arch.isMips64

std.Target.Cpu.Arch.isNvptx

函数

第 1695 行

pub inline fn isNvptx(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isPowerpc

函数

第 1637 行

pub inline fn isPowerpc(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isPowerPC

别名

第 1635 行

已弃用;将在 0.18.0 中移除。请改用 isPowerpc。

别名目标 std.Target.Cpu.Arch.isPowerpc

std.Target.Cpu.Arch.isPowerpc32

函数

第 1644 行

pub inline fn isPowerpc32(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isPowerPC32

别名

第 1642 行

已弃用;将在 0.18.0 中移除。请改用 isPowerpc32。

别名目标 std.Target.Cpu.Arch.isPowerpc32

std.Target.Cpu.Arch.isPowerpc64

函数

第 1654 行

pub inline fn isPowerpc64(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isPowerPC64

别名

第 1652 行

已弃用;将在 0.18.0 中移除。请改用 isPowerpc64。

别名目标 std.Target.Cpu.Arch.isPowerpc64

std.Target.Cpu.Arch.isRiscv

函数

第 1582 行

pub inline fn isRiscv(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isRISCV

别名

第 1580 行

已弃用;将在 0.18.0 中移除。请改用 isRiscv。

别名目标 std.Target.Cpu.Arch.isRiscv

std.Target.Cpu.Arch.isRiscv32

函数

第 1586 行

pub inline fn isRiscv32(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isRiscv64

函数

第 1593 行

pub inline fn isRiscv64(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isSh

函数

第 1681 行

pub inline fn isSh(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isSparc

函数

第 1664 行

pub inline fn isSparc(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isSPARC

别名

第 1662 行

已弃用;将在 0.18.0 中移除。请改用 isSparc。

别名目标 std.Target.Cpu.Arch.isSparc

std.Target.Cpu.Arch.isSpirv

函数

第 1674 行

pub inline fn isSpirv(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isSpirV

别名

第 1672 行

已弃用;将在 0.18.0 中移除。请改用 isSpirv。

别名目标 std.Target.Cpu.Arch.isSpirv

std.Target.Cpu.Arch.isThumb

函数

第 1531 行

pub inline fn isThumb(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isWasm

函数

第 1562 行

pub inline fn isWasm(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isX86

函数

第 1516 行

pub inline fn isX86(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.isXtensa

函数

第 1702 行

pub inline fn isXtensa(arch: Arch) bool

参数

arch: Arch

std.Target.Cpu.Arch.parseCpuModel

函数

第 1709 行

pub fn parseCpuModel(arch: Arch, cpu_name: []const u8) ?*const Cpu.Model

参数

arch: Arch
cpu_name: []const u8

std.Target.Cpu.Arch.plan9Ext

函数

第 1825 行

0c spim 小端序 MIPS 3000 系列 1c 68000 Motorola MC68000 2c 68020 Motorola MC68020 5c arm 小端序 ARM 6c amd64 AMD64 及兼容处理器,例如 Intel EM64T 7c arm64 ARM64(ARMv8) 8c 386 Intel x86、i486、Pentium 等 kc sparc Sun SPARC qc power Power PC vc mips 大端序 MIPS 3000 系列

pub fn plan9Ext(arch: Cpu.Arch) [:0]const u8

参数

arch: Cpu.Arch

std.Target.Cpu.baseline

函数

第 2182 行

交叉编译的“默认”CPU 特性集。这是一组保守特性,预期绝大多数可用硬件都支持。

pub fn baseline(arch: Arch, os: Os) Cpu

参数

arch: Arch
os: Os

std.Target.Cpu.Feature

容器

第 1228 行

字段

index: Set.Index = undefined

Set 中的位索引。默认值为 undefined, 因为规范结构通过编译期逻辑填充。

name: []const u8 = undefined

默认值为 undefined, 因为规范结构由编译时逻辑填充。

llvm_name: ?[:0]const u8

若对应 LLVM 识别的特性,则填充此值; 否则为 null。

description: []const u8

便于人阅读的 UTF-8 文本。

dependencies: Set

所依赖特性的稀疏 Set。

std.Target.Cpu.Feature.FeatureSetFns

类型函数

第 1337 行

pub fn FeatureSetFns(comptime F: type) type

参数

F: type

std.Target.Cpu.Feature.FeatureSetFns.featureSet

函数

第 1340 行

只填充指定的特性位。

pub fn featureSet(features: []const F) Set

参数

features: []const F

std.Target.Cpu.Feature.FeatureSetFns.featureSetHas

函数

第 1349 行

若指定特性已启用,则返回 true。

pub fn featureSetHas(set: Set, feature: F) bool

参数

set: Set
feature: F

std.Target.Cpu.Feature.FeatureSetFns.featureSetHasAll

函数

第 1362 行

若所有指定特性均已启用,则返回 true。

pub fn featureSetHasAll(set: Set, features: anytype) bool

参数

set: Set

std.Target.Cpu.Feature.FeatureSetFns.featureSetHasAny

函数

第 1354 行

如果任意指定特性已启用,则返回 true。

pub fn featureSetHasAny(set: Set, features: anytype) bool

参数

set: Set

std.Target.Cpu.Feature.Set

容器

第 1251 行

所有特性的位集合。

给定 Target.Cpu.Arch 对应的带类型特性可在 @field(Target, @tagName(arch.family())) 中找到。

字段

ints: [usize_count]usize

std.Target.Cpu.Feature.Set.addFeature

函数

第 1281 行

添加指定特性,但不添加其依赖。

pub fn addFeature(set: *Set, arch_feature_index: Index) void

参数

set: *Set
arch_feature_index: Index

std.Target.Cpu.Feature.Set.addFeatureSet

函数

第 1288 行

添加指定特性集,但不添加其依赖。

pub fn addFeatureSet(set: *Set, other_set: Set) void

参数

set: *Set
other_set: Set

std.Target.Cpu.Feature.Set.asBytes

函数

第 1321 行

pub fn asBytes(set: *const Set) *const [byte_count]u8

参数

set: *const Set

std.Target.Cpu.Feature.Set.byte_count

常量

第 1255 行

std.Target.Cpu.Feature.Set.count

函数

第 1268 行

pub fn count(set: Set) std.math.IntFittingRange(0, needed_bit_count)

参数

set: Set

std.Target.Cpu.Feature.Set.empty

常量

第 1260 行

Set

std.Target.Cpu.Feature.Set.eql

函数

第 1325 行

pub fn eql(set: Set, other_set: Set) bool

参数

set: Set
other_set: Set

std.Target.Cpu.Feature.Set.Index

类型

第 1257 行

std.Target.Cpu.Feature.Set.isEmpty

函数

第 1262 行

pub fn isEmpty(set: Set) bool

参数

set: Set

std.Target.Cpu.Feature.Set.isEnabled

函数

第 1274 行

pub fn isEnabled(set: Set, arch_feature_index: Index) bool

参数

set: Set
arch_feature_index: Index

std.Target.Cpu.Feature.Set.isSuperSetOf

函数

第 1329 行

pub fn isSuperSetOf(set: Set, other_set: Set) bool

参数

set: Set
other_set: Set

std.Target.Cpu.Feature.Set.needed_bit_count

常量

第 1254 行

std.Target.Cpu.Feature.Set.populateDependencies

函数

第 1304 行

pub fn populateDependencies(set: *Set, all_features_list: []const Cpu.Feature) void

参数

set: *Set
all_features_list: []const Cpu.Feature

std.Target.Cpu.Feature.Set.removeFeature

函数

第 1293 行

移除指定特性,但不移除依赖它的特性。

pub fn removeFeature(set: *Set, arch_feature_index: Index) void

参数

set: *Set
arch_feature_index: Index

std.Target.Cpu.Feature.Set.removeFeatureSet

函数

第 1300 行

移除指定特性,但不移除依赖它的特性。

pub fn removeFeatureSet(set: *Set, other_set: Set) void

参数

set: *Set
other_set: Set

std.Target.Cpu.Feature.Set.ShiftInt

类型

第 1258 行

std.Target.Cpu.Feature.Set.usize_count

常量

第 1256 行

std.Target.Cpu.has

函数

第 2187 行

若 feature 已启用,则返回 true。

pub fn has(cpu: Cpu, comptime family: Arch.Family, feature: @field(Target, @tagName(family)).Feature) bool

参数

cpu: Cpu
family: Arch.Family
feature: @field(Target, @tagName(family)).Feature

std.Target.Cpu.hasAll

函数

第 2202 行

若 features 中的所有特性均已启用,则返回 true。

pub fn hasAll(cpu: Cpu, comptime family: Arch.Family, features: []const @field(Target, @tagName(family)).Feature) bool

参数

cpu: Cpu
family: Arch.Family
features: []const @field(Target, @tagName(family)).Feature

std.Target.Cpu.hasAny

函数

第 2193 行

若 features 中任一特性已启用,则返回 true。

pub fn hasAny(cpu: Cpu, comptime family: Arch.Family, features: []const @field(Target, @tagName(family)).Feature) bool

参数

cpu: Cpu
family: Arch.Family
features: []const @field(Target, @tagName(family)).Feature

std.Target.Cpu.Model

容器

第 2043 行

字段

name: []const u8
llvm_name: ?[:0]const u8
features: Feature.Set

std.Target.Cpu.Model.baseline

函数

第 2097 行

返回 arch 的保守 CPU 型号,预期兼容 绝大多数现有硬件。与 generic 不同,此函数保证返回的 CPU 型号 同时为 LLVM 和 Clang 所识别。

对于某些 os 值,此函数还会将基线提高到 高于仅由 arch 决定的水平;例如,aarch64-macos 的 基线视为 apple_m1。要完全避免此行为,请传入 Os.Tag.freestanding。

pub fn baseline(arch: Arch, os: Os) *const Model

参数

arch: Arch
os: Os

std.Target.Cpu.Model.generic

函数

第 2061 行

返回适用于 arch 的最基础 CPU 型号。注意,此函数 可能返回 LLVM 能识别、但 Clang 无法识别的 CPU 型号。 如果需要兼容 Clang,请考虑改用 baseline。

pub fn generic(arch: Arch) *const Model

参数

arch: Arch

std.Target.Cpu.Model.toCpu

函数

第 2048 行

pub fn toCpu(model: *const Model, arch: Arch) Cpu

参数

model: *const Model
arch: Arch

std.Target.csky

别名

第 782 行

别名目标 std.Target.csky

std.Target.CType

容器

第 3218 行

字段

char
short
ushort
int
uint
long
ulong
longlong
ulonglong
float
double
longdouble

std.Target.cTypeAlignment

函数

第 3525 行

若此目标未定义 C ABI,则返回 null。

pub fn cTypeAlignment(target: *const Target, c_type: CType) ?u16

参数

target: *const Target
c_type: CType

std.Target.cTypeBitSize

函数

第 3260 行

若此目标未定义 C ABI,则返回 null。

pub fn cTypeBitSize(target: *const Target, c_type: CType) ?u16

参数

target: *const Target
c_type: CType

std.Target.cTypeByteSize

函数

第 3234 行

若此目标未定义 C ABI,则返回 null。

pub fn cTypeByteSize(t: *const Target, c_type: CType) ?u16

参数

t: *const Target
c_type: CType

std.Target.dynamicLibSuffix

函数

第 2243 行

pub fn dynamicLibSuffix(target: *const Target) [:0]const u8

参数

target: *const Target

std.Target.DynamicLinker

容器

第 2416 行

字段

buffer: [255]u8

包含用于存储动态链接器路径的内存。 不应直接使用此字段,参见 get 和 set。 此字段使该 API 无需分配器。

len: u8

用于构造动态链接器路径。不应直接使用此字段。 参见 get 和 set。

std.Target.DynamicLinker.eql

函数

第 2458 行

pub fn eql(lhs: DynamicLinker, rhs: DynamicLinker) bool

参数

std.Target.DynamicLinker.get

函数

第 2442 行

返回内存的生命周期与 DynamicLinker 相同。

pub fn get(dl: *const DynamicLinker) ?[]const u8

参数

dl: *const DynamicLinker

std.Target.DynamicLinker.init

函数

第 2429 行

断言长度不超过 255 字节。

pub fn init(maybe_path: ?[]const u8) DynamicLinker

参数

maybe_path: ?[]const u8

std.Target.DynamicLinker.initFmt

函数

第 2435 行

pub fn initFmt(comptime fmt_str: []const u8, args: anytype) !DynamicLinker

参数

fmt_str: []const u8

std.Target.DynamicLinker.kind

函数

第 2471 行

pub fn kind(os: Os.Tag) Kind

参数

os: Os.Tag

std.Target.DynamicLinker.Kind

容器

第 2462 行

字段

none

没有动态链接器。

arch_os

动态链接器路径由架构及操作系统组成部分决定。

arch_os_abi

动态链接器路径由架构、操作系统及 ABI 组成部分决定。

std.Target.DynamicLinker.none

常量

第 2426 行

DynamicLinker

std.Target.DynamicLinker.set

函数

第 2447 行

断言长度不超过 255 字节。

pub fn set(dl: *DynamicLinker, maybe_path: ?[]const u8) void

参数

dl: *DynamicLinker
maybe_path: ?[]const u8

std.Target.DynamicLinker.setFmt

函数

第 2454 行

断言长度不超过 255 字节。

pub fn setFmt(dl: *DynamicLinker, comptime fmt_str: []const u8, args: anytype) !void

参数

dl: *DynamicLinker
fmt_str: []const u8

std.Target.DynamicLinker.standard

函数

第 2553 行

此函数的严格程度由 kind(os.tag) 决定:

  • .none:忽略所有参数,仅返回 none。
  • .arch_os:忽略 abi,返回与 cpu 和 os 匹配的动态链接器。
  • .arch_os_abi:返回与 cpu、os 和 abi 匹配的动态链接器。

尤其在 .arch_os 情况下,调用方应注意:返回有效动态链接器,仅表示 cpu + os 组合对应一个实际存在的平台,且它具有不随 ABI 变化的既定动态链接器路径;并不一定表示 abi 对该平台有意义。此时,调用方负责判断 abi 是否有效。可使用 Abi.default() 为此类平台尽力选择默认 ABI。

pub fn standard(cpu: Cpu, os: Os.Tag, abi: Abi) DynamicLinker

参数

cpu: Cpu
os: Os.Tag
abi: Abi

std.Target.exeFileExt

函数

第 2235 行

pub fn exeFileExt(target: *const Target) [:0]const u8

参数

target: *const Target

std.Target.hexagon

别名

第 783 行

别名目标 std.Target.hexagon

std.Target.hppa

别名

第 784 行

别名目标 std.Target.hppa

std.Target.hurdTuple

函数

第 2221 行

已弃用;将在 0.18.0 中移除。请改用 std.zig.target.hurdTuple。

pub fn hurdTuple(target: *const Target, allocator: Allocator) ![]u8

参数

target: *const Target
allocator: Allocator

std.Target.hurdTupleSimple

函数

第 2216 行

已弃用;将在 0.18.0 中移除。请改用 std.zig.target.hurdTupleSimple。

pub fn hurdTupleSimple(allocator: Allocator, arch: Cpu.Arch, abi: Abi) ![]u8

参数

allocator: Allocator
arch: Cpu.Arch
abi: Abi

std.Target.isBionicLibC

函数

第 2266 行

pub inline fn isBionicLibC(target: *const Target) bool

参数

target: *const Target

std.Target.isDarwinLibC

函数

第 2270 行

pub inline fn isDarwinLibC(target: *const Target) bool

参数

target: *const Target

std.Target.isFreeBSDLibC

函数

第 2277 行

pub inline fn isFreeBSDLibC(target: *const Target) bool

参数

target: *const Target

std.Target.isGnuLibC

函数

第 2255 行

pub inline fn isGnuLibC(target: *const Target) bool

参数

target: *const Target

std.Target.isMinGW

函数

第 2251 行

pub inline fn isMinGW(target: *const Target) bool

参数

target: *const Target

std.Target.isMuslLibC

函数

第 2262 行

pub inline fn isMuslLibC(target: *const Target) bool

参数

target: *const Target

std.Target.isNetBSDLibC

函数

第 2284 行

pub inline fn isNetBSDLibC(target: *const Target) bool

参数

target: *const Target

std.Target.isOpenBSDLibC

函数

第 2291 行

pub inline fn isOpenBSDLibC(target: *const Target) bool

参数

target: *const Target

std.Target.isWasiLibC

函数

第 2298 行

pub inline fn isWasiLibC(target: *const Target) bool

参数

target: *const Target

std.Target.kalimba

别名

第 785 行

别名目标 std.Target.generic

std.Target.kvx

别名

第 786 行

别名目标 std.Target.kvx

std.Target.lanai

别名

第 787 行

别名目标 std.Target.lanai

std.Target.libPrefix

函数

第 2247 行

pub fn libPrefix(target: *const Target) [:0]const u8

参数

target: *const Target

std.Target.linuxTriple

函数

第 2231 行

已弃用;将在 0.18.0 中移除。请改用 std.zig.target.linuxTriple。

pub fn linuxTriple(target: *const Target, allocator: Allocator) ![]u8

参数

target: *const Target
allocator: Allocator

std.Target.linuxTripleSimple

函数

第 2226 行

已弃用;将在 0.18.0 中移除。请改用 std.zig.target.linuxTripleSimple。

pub fn linuxTripleSimple(allocator: Allocator, arch: Cpu.Arch, os_tag: Os.Tag, abi: Abi) ![]u8

参数

allocator: Allocator
arch: Cpu.Arch
os_tag: Os.Tag
abi: Abi

std.Target.loongarch

别名

第 788 行

别名目标 std.Target.loongarch

std.Target.m68k

别名

第 789 行

别名目标 std.Target.m68k

std.Target.m88k

别名

第 790 行

别名目标 std.Target.generic

std.Target.microblaze

别名

第 791 行

别名目标 std.Target.generic

std.Target.mips

别名

第 792 行

别名目标 std.Target.mips

std.Target.msp430

别名

第 793 行

别名目标 std.Target.msp430

std.Target.nvptx

别名

第 794 行

别名目标 std.Target.nvptx

std.Target.ObjectFormat

容器

第 1054 行

字段

c

C 源代码。

coff

Windows 和 UEFI 使用的通用对象文件格式。

elf

许多 Unix 系统使用的可执行与可链接格式。

hex

Intel HEX 格式,用于以 ASCII 文本存储二进制代码。

macho

macOS 及其他 Apple 平台使用的 Mach 对象格式。

plan9

Bell Labs 的 Plan 9 使用的 a.out 格式。

raw

不含元数据的机器代码。

spirv

Khronos Group 的标准可移植中间表示 V。

wasm

WebAssembly 二进制格式。

std.Target.ObjectFormat.default

函数

第 1086 行

pub fn default(os_tag: Os.Tag, arch: Cpu.Arch) ObjectFormat

参数

os_tag: Os.Tag
arch: Cpu.Arch

std.Target.ObjectFormat.fileExt

函数

第 1074 行

pub fn fileExt(of: ObjectFormat, arch: Cpu.Arch) [:0]const u8

参数

of: ObjectFormat
arch: Cpu.Arch

std.Target.or1k

别名

第 795 行

别名目标 std.Target.generic

std.Target.Os

容器

第 14 行

字段

tag: Tag
version_range: VersionRange

std.Target.Os.HurdVersionRange

容器

第 332 行

字段

std.Target.Os.HurdVersionRange.includesVersion

函数

第 336 行

pub inline fn includesVersion(range: HurdVersionRange, ver: std.SemanticVersion) bool

参数

std.Target.Os.HurdVersionRange.isAtLeast

函数

第 342 行

检查系统是否保证至少为 version,或早于 version。 若需要运行期检查,则返回 null。

pub inline fn isAtLeast(range: HurdVersionRange, ver: std.SemanticVersion) ?bool

参数

std.Target.Os.isAtLeast

函数

第 759 行

检查系统是否保证至少为 version,或早于 version。 若需要运行期检查,则返回 null。

pub inline fn isAtLeast(os: Os, comptime tag: Tag, ver: switch (tag.versionRangeTag()) { .none => void, .semver, .hurd, .linux => std.SemanticVersion, .windows => WindowsVersion, }) ?bool

参数

os: Os
tag: Tag
ver: switch (tag.versionRangeTag()) {
    .none => void,
    .semver, .hurd, .linux => std.SemanticVersion,
    .windows => WindowsVersion,
}

std.Target.Os.LinuxVersionRange

容器

第 347 行

字段

range: std.SemanticVersion.Range
glibc: std.SemanticVersion
android: u32

Android API 级别。

std.Target.Os.LinuxVersionRange.includesVersion

函数

第 353 行

pub inline fn includesVersion(range: LinuxVersionRange, ver: std.SemanticVersion) bool

参数

std.Target.Os.LinuxVersionRange.isAtLeast

函数

第 359 行

检查系统是否保证至少为 version,或早于 version。 若需要运行期检查,则返回 null。

pub inline fn isAtLeast(range: LinuxVersionRange, ver: std.SemanticVersion) ?bool

参数

std.Target.Os.Tag

容器

第 18 行

字段

freestanding
other
contiki
fuchsia
hermit
managarm
haiku
hurd
illumos
linux
plan9
rtems
serenity
dragonfly
freebsd
netbsd
openbsd
driverkit
ios
maccatalyst
macos
tvos
visionos
watchos
windows
uefi
@"3ds"
wiiu
@"switch"
gba
psx
ps3
ps4
ps5
psp
vita
emscripten
wasi
amdhsa
amdpal
cuda
mesa3d
nvcl
opencl
opengl
vulkan
tios
ashetos

std.Target.Os.Tag.defaultVersionRange

函数

第 149 行

pub fn defaultVersionRange(tag: Tag, arch: Cpu.Arch, abi: Abi) Os

参数

tag: Tag
arch: Cpu.Arch
abi: Abi

std.Target.Os.Tag.dynamicLibSuffix

函数

第 124 行

pub fn dynamicLibSuffix(tag: Tag) [:0]const u8

参数

tag: Tag

std.Target.Os.Tag.exeFileExt

函数

第 101 行

pub fn exeFileExt(tag: Tag, arch: Cpu.Arch) [:0]const u8

参数

tag: Tag
arch: Cpu.Arch

std.Target.Os.Tag.isBSD

函数

第 94 行

已弃用;将在 0.18.0 中移除。请改为检查相关标签。

pub inline fn isBSD(tag: Tag) bool

参数

tag: Tag

std.Target.Os.Tag.isDarwin

函数

第 79 行

pub inline fn isDarwin(tag: Tag) bool

参数

tag: Tag

std.Target.Os.Tag.libPrefix

函数

第 139 行

pub fn libPrefix(tag: Os.Tag, abi: Abi) [:0]const u8

参数

tag: Os.Tag
abi: Abi

std.Target.Os.Tag.staticLibSuffix

函数

第 114 行

pub fn staticLibSuffix(tag: Tag, abi: Abi) [:0]const u8

参数

tag: Tag
abi: Abi

std.Target.Os.Tag.versionRangeTag

函数

第 156 行

pub inline fn versionRangeTag(tag: Tag) @typeInfo(TaggedVersionRange).@"union".tag_type.?

参数

tag: Tag

std.Target.Os.TaggedVersionRange

容器

第 729 行

字段

std.Target.Os.TaggedVersionRange.gnuLibCVersion

函数

第 736 行

pub fn gnuLibCVersion(range: TaggedVersionRange) ?std.SemanticVersion

参数

std.Target.Os.versionRange

函数

第 747 行

提供标签联合体。Target 不存储标签,因为标签与操作系统标签重复;此函数将这部分抽象出来。

pub inline fn versionRange(os: Os) TaggedVersionRange

参数

os: Os

std.Target.Os.VersionRange

容器

第 388 行

此处的版本范围表示受支持操作系统版本的下限和上限。默认值表示 Zig 标准库构建其抽象时所依据的版本范围。

对于目标平台,通常主要调整范围的最低版本。目标操作系统的最高版本一般保持默认值,即该操作系统最新发布的版本。

若要在编译期判断目标平台是否保证支持某项操作系统特性,应检查版本范围的最低版本是否大于或等于该特性引入的版本。

若要在编译期判断目标平台是否肯定不支持某项操作系统特性,应检查版本范围的最高版本是否低于该特性引入的版本。

如果两种情况都不成立,则应在运行期检查目标平台是否支持该特性。

使用指定最高版本构建的二进制文件仍可在更新的操作系统版本上运行。但此类二进制文件可能无法充分利用较新操作系统提供的 API。

另见 Os.isAtLeast。

字段

std.Target.Os.VersionRange.default

函数

第 397 行

默认 VersionRange 表示 Zig 标准库 建立抽象时所基于的版本范围。

pub fn default(arch: Cpu.Arch, tag: Tag, abi: Abi) VersionRange

参数

arch: Cpu.Arch
tag: Tag
abi: Abi

std.Target.Os.WindowsVersion

容器

第 232 行

字段

nt4 = 0x04000000
win2k = 0x05000000
xp = 0x05010000
ws2003 = 0x05020000
vista = 0x06000000
win7 = 0x06010000
win8 = 0x06020000
win8_1 = 0x06030000
win10 = 0x0A000000
win10_th2 = 0x0A000001
win10_rs1 = 0x0A000002
win10_rs2 = 0x0A000003
win10_rs3 = 0x0A000004
win10_rs4 = 0x0A000005
win10_rs5 = 0x0A000006
win10_19h1 = 0x0A000007
win10_vb = 0x0A000008
win10_mn = 0x0A000009
win10_fe = 0x0A00000A
win10_co = 0x0A00000B
win10_ni = 0x0A00000C
win10_cu = 0x0A00000D
win11_zn = 0x0A00000E
win11_ga = 0x0A00000F
win11_ge = 0x0A000010
win11_dt = 0x0A000011
win11_br = 0x0A000012
win11_kr = 0x0A000013
_

std.Target.Os.WindowsVersion.format

函数

第 322 行

此函数用于将该类型序列化为 Zig 源码表示, 解析此表示时将反序列化出相同的数据。

pub fn format(wv: WindowsVersion, w: *std.Io.Writer) std.Io.Writer.Error!void

参数

错误

WriteFailed

详细诊断信息见 Writer 实现。

std.Target.Os.WindowsVersion.isAtLeast

函数

第 292 行

返回第一个版本 ver 是否不早于(大于或等于)第二个版本 ver。

pub inline fn isAtLeast(ver: WindowsVersion, min_ver: WindowsVersion) bool

参数

std.Target.Os.WindowsVersion.known_win10_build_numbers

常量

第 268 行

与运行时报告的构建号比较,以区分 Windows 10 版本;其中 0x0A000000 + index 对应 WindowsVersion 的 u32 值。

std.Target.Os.WindowsVersion.latest

常量

第 264 行

Zig 标准库已知的最新 Windows 版本

std.Target.Os.WindowsVersion.parse

函数

第 314 行

pub fn parse(str: []const u8) !WindowsVersion

参数

str: []const u8

std.Target.Os.WindowsVersion.Range

容器

第 296 行

字段

std.Target.Os.WindowsVersion.Range.includesVersion

函数

第 300 行

pub inline fn includesVersion(range: Range, ver: WindowsVersion) bool

参数

range: Range
ver: WindowsVersion

std.Target.Os.WindowsVersion.Range.isAtLeast

函数

第 307 行

检查系统是否保证至少为 version,或早于 version。 若需要运行期检查,则返回 null。

pub inline fn isAtLeast(range: Range, min_ver: WindowsVersion) ?bool

参数

range: Range
min_ver: WindowsVersion

std.Target.powerpc

别名

第 796 行

别名目标 std.Target.powerpc

std.Target.propeller

别名

第 797 行

别名目标 std.Target.propeller

std.Target.ptrBitWidth

函数

第 3083 行

pub fn ptrBitWidth(target: *const Target) u16

参数

target: *const Target

std.Target.ptrBitWidth_arch_abi

函数

第 2998 行

pub fn ptrBitWidth_arch_abi(cpu_arch: Cpu.Arch, abi: Abi) u16

参数

cpu_arch: Cpu.Arch
abi: Abi

std.Target.ptrBitWidth_cpu_abi

函数

第 2994 行

pub fn ptrBitWidth_cpu_abi(cpu: Cpu, abi: Abi) u16

参数

cpu: Cpu
abi: Abi

std.Target.Query

别名

第 12 行

别名目标 std.Target.Query

std.Target.requiresLibC

函数

第 2304 行

此目标是否必须链接 libc?例如,目标系统调用接口 不稳定时可能有此要求。

pub fn requiresLibC(target: *const Target) bool

参数

target: *const Target

std.Target.riscv

别名

第 798 行

别名目标 std.Target.riscv

std.Target.s390x

别名

第 799 行

别名目标 std.Target.s390x

std.Target.sh

别名

第 800 行

别名目标 std.Target.generic

std.Target.sparc

别名

第 801 行

别名目标 std.Target.sparc

std.Target.spirv

别名

第 802 行

别名目标 std.Target.spirv

std.Target.spork8

别名

第 803 行

别名目标 std.Target.generic

std.Target.stackAlignment

函数

第 3087 行

pub fn stackAlignment(target: *const Target) u16

参数

target: *const Target

std.Target.stackGrowth

函数

第 3162 行

pub fn stackGrowth(target: *const Target) StackGrowth

参数

target: *const Target

std.Target.StackGrowth

容器

第 3157 行

字段

down
up

std.Target.standardDynamicLinkerPath

函数

第 2990 行

pub fn standardDynamicLinkerPath(target: *const Target) DynamicLinker

参数

target: *const Target

std.Target.staticLibSuffix

函数

第 2239 行

pub fn staticLibSuffix(target: *const Target) [:0]const u8

参数

target: *const Target

std.Target.std

别名

第 3796 行

别名目标 std

std.Target.supportsAddressSpace

函数

第 2384 行

返回此目标是否支持 address_space。若 context 为 null, 此函数仅回答目标是否具备 address_space 概念 这一一般问题;若非 null,则还会检查 address_space 在该上下文中是否有效。

pub fn supportsAddressSpace( target: Target, address_space: std.builtin.AddressSpace, context: ?AddressSpaceContext, ) bool

参数

target: Target
address_space: std.builtin.AddressSpace
context: ?AddressSpaceContext

std.Target.Target

别名

第 3795 行

别名目标 std.Target

std.Target.toCoffMachine

函数

第 1149 行

pub fn toCoffMachine(target: *const Target) std.coff.IMAGE.FILE.MACHINE

参数

target: *const Target

std.Target.toElfMachine

函数

第 1101 行

pub fn toElfMachine(target: *const Target) std.elf.EM

参数

target: *const Target

std.Target.ve

别名

第 804 行

别名目标 std.Target.ve

std.Target.wasm

别名

第 805 行

别名目标 std.Target.wasm

std.Target.x86

别名

第 806 行

别名目标 std.Target.x86

std.Target.xcore

别名

第 807 行

别名目标 std.Target.xcore

std.Target.xtensa

别名

第 808 行

别名目标 std.Target.xtensa

std.Target.z80

别名

第 809 行

别名目标 std.Target.generic

std.Target.zigTriple

函数

第 2211 行

pub fn zigTriple(target: *const Target, allocator: Allocator) Allocator.Error![]u8

参数

target: *const Target
allocator: Allocator

错误

OutOfMemory
源码

std/Target.zig

//! 执行代码的机器的全部详细信息。
//! 与可能将部分项保留为“default”或“host”的 `Query` 不同,
//! 此数据已完全解析为具体的操作系统版本、处理器特性
//! 等。

cpu: Cpu,
os: Os,
abi: Abi,
ofmt: ObjectFormat,
dynamic_linker: DynamicLinker = DynamicLinker.none,

pub const Query = @import("Target/Query.zig");

pub const Os = struct {
    tag: Tag,
    version_range: VersionRange,

    pub const Tag = enum {
        freestanding,
        other,

        contiki,
        fuchsia,
        hermit,
        managarm,

        haiku,
        hurd,
        illumos,
        linux,
        plan9,
        rtems,
        serenity,

        dragonfly,
        freebsd,
        netbsd,
        openbsd,

        driverkit,
        ios,
        maccatalyst,
        macos,
        tvos,
        visionos,
        watchos,

        windows,
        uefi,

        @"3ds",
        wiiu,
        @"switch",
        gba,

        psx,
        ps3,
        ps4,
        ps5,
        psp,
        vita,

        emscripten,
        wasi,

        amdhsa,
        amdpal,
        cuda,
        mesa3d,
        nvcl,
        opencl,
        opengl,
        vulkan,

        tios,

        ashetos,

        pub inline fn isDarwin(tag: Tag) bool {
            return switch (tag) {
                .driverkit,
                .ios,
                .maccatalyst,
                .macos,
                .tvos,
                .visionos,
                .watchos,
                => true,
                else => false,
            };
        }

        /// 已弃用;将在 0.18.0 中移除。请改为检查相关标签。
        pub inline fn isBSD(tag: Tag) bool {
            return tag.isDarwin() or switch (tag) {
                .freebsd, .openbsd, .netbsd, .dragonfly => true,
                else => false,
            };
        }

        pub fn exeFileExt(tag: Tag, arch: Cpu.Arch) [:0]const u8 {
            return switch (tag) {
                .windows => ".exe",
                .uefi => ".efi",
                .plan9 => arch.plan9Ext(),
                else => switch (arch) {
                    .wasm32, .wasm64 => ".wasm",
                    .spork8 => ".bin",
                    else => "",
                },
            };
        }

        pub fn staticLibSuffix(tag: Tag, abi: Abi) [:0]const u8 {
            return switch (abi) {
                .msvc, .itanium => ".lib",
                else => switch (tag) {
                    .windows, .uefi => ".lib",
                    else => ".a",
                },
            };
        }

        pub fn dynamicLibSuffix(tag: Tag) [:0]const u8 {
            return switch (tag) {
                .windows, .uefi => ".dll",
                .driverkit,
                .ios,
                .maccatalyst,
                .macos,
                .tvos,
                .visionos,
                .watchos,
                => ".dylib",
                else => ".so",
            };
        }

        pub fn libPrefix(tag: Os.Tag, abi: Abi) [:0]const u8 {
            return switch (abi) {
                .msvc, .itanium => "",
                else => switch (tag) {
                    .windows, .uefi => "",
                    else => "lib",
                },
            };
        }

        pub fn defaultVersionRange(tag: Tag, arch: Cpu.Arch, abi: Abi) Os {
            return .{
                .tag = tag,
                .version_range = .default(arch, tag, abi),
            };
        }

        pub inline fn versionRangeTag(tag: Tag) @typeInfo(TaggedVersionRange).@"union".tag_type.? {
            return switch (tag) {
                .freestanding,
                .other,

                .managarm,

                .haiku,
                .illumos,
                .plan9,
                .serenity,

                .psx,
                .ps3,
                .ps4,
                .ps5,
                .gba,

                .emscripten,

                .mesa3d,

                .ashetos,
                => .none,

                .contiki,
                .fuchsia,
                .hermit,

                .rtems,

                .dragonfly,
                .freebsd,
                .netbsd,
                .openbsd,

                .driverkit,
                .ios,
                .maccatalyst,
                .macos,
                .tvos,
                .visionos,
                .watchos,

                .uefi,

                .@"3ds",
                .wiiu,
                .@"switch",

                .psp,
                .vita,

                .wasi,

                .amdhsa,
                .amdpal,
                .cuda,
                .nvcl,
                .opencl,
                .opengl,
                .vulkan,

                .tios,
                => .semver,

                .hurd => .hurd,
                .linux => .linux,

                .windows => .windows,
            };
        }
    };

    /// 基于以下来源的 NTDDI 版本常量:
    /// https://docs.microsoft.com/en-us/cpp/porting/modifying-winver-and-win32-winnt
    pub const WindowsVersion = enum(u32) {
        nt4 = 0x04000000,
        win2k = 0x05000000,
        xp = 0x05010000,
        ws2003 = 0x05020000,
        vista = 0x06000000,
        win7 = 0x06010000,
        win8 = 0x06020000,
        win8_1 = 0x06030000,
        win10 = 0x0A000000, // 又称 win10_th1
        win10_th2 = 0x0A000001,
        win10_rs1 = 0x0A000002,
        win10_rs2 = 0x0A000003,
        win10_rs3 = 0x0A000004,
        win10_rs4 = 0x0A000005,
        win10_rs5 = 0x0A000006,
        win10_19h1 = 0x0A000007,
        win10_vb = 0x0A000008, // 又称 win10_19h2
        win10_mn = 0x0A000009, // 也称 win10_20h1
        win10_fe = 0x0A00000A, // 又称 win10_20h2
        win10_co = 0x0A00000B, // 又称 win10_21h1
        win10_ni = 0x0A00000C, // 也称 win10_21h2
        win10_cu = 0x0A00000D, // 又称 win10_22h2
        win11_zn = 0x0A00000E, // 又称 win11_21h2
        win11_ga = 0x0A00000F, // 也称 win11_22h2
        win11_ge = 0x0A000010, // 又称 win11_23h2
        win11_dt = 0x0A000011, // 又称 win11_24h2
        win11_br = 0x0A000012, // 也称 win11_25h2
        win11_kr = 0x0A000013, // 又称 win11_26h1
        _,

        /// Zig 标准库已知的最新 Windows 版本
        pub const latest = WindowsVersion.win11_kr;

        /// 与运行时报告的构建号比较,以区分 Windows 10 版本;其中 0x0A000000 + index 对应 WindowsVersion 的 u32 值。
        ///
        pub const known_win10_build_numbers = [_]u32{
            10240, // win10 又称 win10_th1
            10586, // win10_th2
            14393, // win10_rs1
            15063, // win10_rs2
            16299, // win10_rs3
            17134, // win10_rs4
            17763, // win10_rs5
            18362, // win10_19h1
            18363, // win10_vb,也称 win10_19h2
            19041, // win10_mn 又称 win10_20h1
            19042, // win10_fe 又称 win10_20h2
            19043, // win10_co,也称 win10_21h1
            19044, // win10_ni 又称 win10_21h2
            19045, // win10_cu 又称 win10_22h2
            22000, // win11_zn,也称 win11_21h2
            22621, // win11_ga 又称 win11_22h2
            22631, // win11_ge 又称 win11_23h2
            26100, // win11_dt,也称 win11_24h2
            26200, // win11_br 又称 win11_25h2
            28000, // win11_kr 又称 win11_26h1
        };

        /// 返回第一个版本 `ver` 是否不早于(大于或等于)第二个版本 `ver`。
        pub inline fn isAtLeast(ver: WindowsVersion, min_ver: WindowsVersion) bool {
            return @backingInt(ver) >= @backingInt(min_ver);
        }

        pub const Range = struct {
            min: WindowsVersion,
            max: WindowsVersion,

            pub inline fn includesVersion(range: Range, ver: WindowsVersion) bool {
                return @backingInt(ver) >= @backingInt(range.min) and
                    @backingInt(ver) <= @backingInt(range.max);
            }

            /// 检查系统是否保证至少为 `version`,或早于 `version`。
            /// 若需要运行期检查,则返回 `null`。
            pub inline fn isAtLeast(range: Range, min_ver: WindowsVersion) ?bool {
                if (@backingInt(range.min) >= @backingInt(min_ver)) return true;
                if (@backingInt(range.max) < @backingInt(min_ver)) return false;
                return null;
            }
        };

        pub fn parse(str: []const u8) !WindowsVersion {
            return std.meta.stringToEnum(WindowsVersion, str) orelse
                @fromBackingInt(@intCast(std.fmt.parseInt(u32, str, 0) catch
                    return error.InvalidOperatingSystemVersion));
        }

        /// 此函数用于将该类型序列化为 Zig 源码表示,
        /// 解析此表示时将反序列化出相同的数据。
        pub fn format(wv: WindowsVersion, w: *std.Io.Writer) std.Io.Writer.Error!void {
            if (std.enums.tagName(WindowsVersion, wv)) |name| {
                var vecs: [2][]const u8 = .{ ".", name };
                return w.writeVecAll(&vecs);
            } else {
                return w.print("@fromBackingInt(0x{X:0>8})", .{wv});
            }
        }
    };

    pub const HurdVersionRange = struct {
        range: std.SemanticVersion.Range,
        glibc: std.SemanticVersion,

        pub inline fn includesVersion(range: HurdVersionRange, ver: std.SemanticVersion) bool {
            return range.range.includesVersion(ver);
        }

        /// 检查系统是否保证至少为 `version`,或早于 `version`。
        /// 若需要运行期检查,则返回 `null`。
        pub inline fn isAtLeast(range: HurdVersionRange, ver: std.SemanticVersion) ?bool {
            return range.range.isAtLeast(ver);
        }
    };

    pub const LinuxVersionRange = struct {
        range: std.SemanticVersion.Range,
        glibc: std.SemanticVersion,
        /// Android API 级别。
        android: u32,

        pub inline fn includesVersion(range: LinuxVersionRange, ver: std.SemanticVersion) bool {
            return range.range.includesVersion(ver);
        }

        /// 检查系统是否保证至少为 `version`,或早于 `version`。
        /// 若需要运行期检查,则返回 `null`。
        pub inline fn isAtLeast(range: LinuxVersionRange, ver: std.SemanticVersion) ?bool {
            return range.range.isAtLeast(ver);
        }
    };

    /// 此处的版本范围表示受支持操作系统版本的下限和上限。默认值表示 Zig 标准库构建其抽象时所依据的版本范围。
    ///
    /// 对于目标平台,通常主要调整范围的最低版本。目标操作系统的最高版本一般保持默认值,即该操作系统最新发布的版本。
    ///
    /// 若要在编译期判断目标平台是否保证支持某项操作系统特性,应检查版本范围的最低版本是否大于或等于该特性引入的版本。
    ///
    /// 若要在编译期判断目标平台是否肯定不支持某项操作系统特性,应检查版本范围的最高版本是否低于该特性引入的版本。
    ///
    /// 如果两种情况都不成立,则应在运行期检查目标平台是否支持该特性。
    ///
    /// 使用指定最高版本构建的二进制文件仍可在更新的操作系统版本上运行。但此类二进制文件可能无法充分利用较新操作系统提供的 API。
    ///
    /// 另见 `Os.isAtLeast`。
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    pub const VersionRange = union {
        none: void,
        semver: std.SemanticVersion.Range,
        hurd: HurdVersionRange,
        linux: LinuxVersionRange,
        windows: WindowsVersion.Range,

        /// 默认 `VersionRange` 表示 Zig 标准库
        /// 建立抽象时所基于的版本范围。
        pub fn default(arch: Cpu.Arch, tag: Tag, abi: Abi) VersionRange {
            return switch (tag) {
                .freestanding,
                .other,

                .managarm,

                .haiku,
                .illumos,
                .plan9,
                .serenity,

                .psx,
                .ps3,
                .ps4,
                .ps5,
                .gba,

                .emscripten,

                .mesa3d,

                .ashetos,
                => .{ .none = {} },

                .contiki => .{
                    .semver = .{
                        .min = .{ .major = 5, .minor = 0, .patch = 0 },
                        .max = .{ .major = 5, .minor = 1, .patch = 0 },
                    },
                },
                .fuchsia => .{
                    .semver = .{
                        .min = .{ .major = 27, .minor = 0, .patch = 0 },
                        .max = .{ .major = 30, .minor = 0, .patch = 0 },
                    },
                },
                .hermit => .{
                    .semver = .{
                        .min = .{ .major = 0, .minor = 8, .patch = 0 },
                        .max = .{ .major = 0, .minor = 13, .patch = 2 },
                    },
                },

                .hurd => .{
                    .hurd = .{
                        .range = .{
                            .min = .{ .major = 0, .minor = 9, .patch = 0 },
                            .max = .{ .major = 0, .minor = 9, .patch = 0 },
                        },
                        .glibc = .{ .major = 2, .minor = 31, .patch = 0 },
                    },
                },
                .linux => .{
                    .linux = .{
                        .range = .{
                            .min = blk: {
                                const default_min: std.SemanticVersion = .{ .major = 5, .minor = 10, .patch = 0 };

                                for (std.zig.target.available_libcs) |libc| {
                                    if (libc.arch != arch or libc.os != tag or libc.abi != abi) continue;

                                    if (libc.os_ver) |min| {
                                        if (min.order(default_min) == .gt) break :blk min;
                                    }
                                }

                                break :blk default_min;
                            },
                            .max = .{ .major = 7, .minor = 2, .patch = 0 },
                        },
                        .glibc = blk: {
                            //
                            const default_min: std.SemanticVersion = switch (arch) {
                                // 对于传统上使用 32 位时间表示的 32 位目标,
                                // 完整支持 64 位时间需要 2.34。对于其他目标,
                                // 只需要 2.31。
                                .arm,
                                .armeb,
                                .csky,
                                .m68k,
                                .mips,
                                .mipsel,
                                .powerpc,
                                .sparc,
                                .x86,
                                => .{ .major = 2, .minor = 34, .patch = 0 },
                                .mips64,
                                .mips64el,
                                => if (abi == .gnuabin32)
                                    .{ .major = 2, .minor = 34, .patch = 0 }
                                else
                                    .{ .major = 2, .minor = 31, .patch = 0 },
                                // 需要 2.32,因为这是第一个完整支持 IEEE 128 位
                                // `long double`(通过 `-mabi=ieeelongdouble`)的版本。
                                .powerpc64le,
                                => .{ .major = 2, .minor = 32, .patch = 0 },
                                else => .{ .major = 2, .minor = 31, .patch = 0 },
                            };

                            for (std.zig.target.available_libcs) |libc| {
                                if (libc.os != tag or libc.arch != arch or libc.abi != abi) continue;

                                if (libc.glibc_min) |min| {
                                    if (min.order(default_min) == .gt) break :blk min;
                                }
                            }

                            break :blk default_min;
                        },
                        .android = switch (arch) {
                            .riscv64 => 35,
                            else => 29,
                        },
                    },
                },
                .rtems => .{
                    .semver = .{
                        .min = .{ .major = 5, .minor = 3, .patch = 0 },
                        .max = .{ .major = 6, .minor = 2, .patch = 0 },
                    },
                },

                .dragonfly => .{
                    .semver = .{
                        .min = .{ .major = 6, .minor = 4, .patch = 0 },
                        .max = .{ .major = 6, .minor = 4, .patch = 2 },
                    },
                },
                .freebsd => .{
                    .semver = .{
                        .min = blk: {
                            const default_min: std.SemanticVersion = .{ .major = 14, .minor = 0, .patch = 0 };

                            for (std.zig.target.available_libcs) |libc| {
                                if (libc.arch != arch or libc.os != tag or libc.abi != abi) continue;

                                if (libc.os_ver) |min| {
                                    if (min.order(default_min) == .gt) break :blk min;
                                }
                            }

                            break :blk default_min;
                        },
                        .max = .{ .major = 15, .minor = 1, .patch = 0 },
                    },
                },
                .netbsd => .{
                    .semver = .{
                        .min = blk: {
                            const default_min: std.SemanticVersion = .{ .major = 10, .minor = 1, .patch = 0 };

                            for (std.zig.target.available_libcs) |libc| {
                                if (libc.arch != arch or libc.os != tag or libc.abi != abi) continue;

                                if (libc.os_ver) |min| {
                                    if (min.order(default_min) == .gt) break :blk min;
                                }
                            }

                            break :blk default_min;
                        },
                        .max = .{ .major = 11, .minor = 0, .patch = 0 },
                    },
                },
                .openbsd => .{
                    .semver = .{
                        .min = blk: {
                            const default_min: std.SemanticVersion = .{ .major = 7, .minor = 8, .patch = 0 };

                            for (std.zig.target.available_libcs) |libc| {
                                if (libc.arch != arch or libc.os != tag or libc.abi != abi) continue;

                                if (libc.os_ver) |min| {
                                    if (min.order(default_min) == .gt) break :blk min;
                                }
                            }

                            break :blk default_min;
                        },
                        .max = .{ .major = 7, .minor = 9, .patch = 0 },
                    },
                },

                .driverkit => .{
                    .semver = .{
                        .min = .{ .major = 21, .minor = 0, .patch = 0 },
                        .max = .{ .major = 27, .minor = 0, .patch = 0 },
                    },
                },
                .macos => .{
                    .semver = .{
                        .min = .{ .major = 15, .minor = 0, .patch = 0 },
                        .max = .{ .major = 27, .minor = 0, .patch = 0 },
                    },
                },
                .ios, .maccatalyst => .{
                    .semver = .{
                        .min = .{ .major = 18, .minor = 0, .patch = 0 },
                        .max = .{ .major = 27, .minor = 0, .patch = 0 },
                    },
                },
                .tvos => .{
                    .semver = .{
                        .min = .{ .major = 26, .minor = 0, .patch = 0 },
                        .max = .{ .major = 27, .minor = 0, .patch = 0 },
                    },
                },
                .visionos => .{
                    .semver = .{
                        .min = .{ .major = 27, .minor = 0, .patch = 0 },
                        .max = .{ .major = 27, .minor = 0, .patch = 0 },
                    },
                },
                .watchos => .{
                    .semver = .{
                        .min = .{ .major = 11, .minor = 0, .patch = 0 },
                        .max = .{ .major = 27, .minor = 0, .patch = 0 },
                    },
                },

                .windows => .{
                    .windows = .{
                        .min = .win10,
                        .max = WindowsVersion.latest,
                    },
                },
                .uefi => .{
                    .semver = .{
                        .min = .{ .major = 2, .minor = 0, .patch = 0 },
                        .max = .{ .major = 2, .minor = 11, .patch = 0 },
                    },
                },

                .@"3ds" => .{
                    .semver = .{
                        // 这些值表示发行版本(https://www.3dbrew.org/wiki/NCCH/Extended_Header#ARM11_Kernel_Capabilities),
                        // 不同于面向用户的系统版本(https://www.3dbrew.org/wiki/Home_Menu#System_Versions_List)。
                        //
                        // 多个系统版本可能对应同一个发行版本。
                        // 注释中的最小值表示引入该发行版本的系统版本,最大值表示最新的系统版本。
                        .min = .{ .major = 2, .minor = 27, .patch = 0 }, // 1.0.0-0
                        .max = .{ .major = 2, .minor = 58, .patch = 0 }, // 11.17.0-50
                    },
                },

                .wiiu => .{
                    .semver = .{
                        .min = .{ .major = 5, .minor = 5, .patch = 5 }, // 最新全球发行版本
                        .max = .{ .major = 5, .minor = 5, .patch = 6 }, // 最新的仅美国发行版本
                    },
                },

                .@"switch" => .{
                    .semver = .{
                        .min = .{ .major = 1, .minor = 0, .patch = 0 },
                        .max = .{ .major = 22, .minor = 5, .patch = 0 },
                    },
                },

                .psp => .{
                    .semver = .{
                        // https://www.psdevwiki.com/psp/Official_Firmware_(OFW)#1.XX_Kernel
                        // 内核在 1.XX 时似乎最初采用语义化版本号,之后的版本改为 MAJ.MINPATCH(例如 3.60、6.61)。
                        .min = .{ .major = 1, .minor = 0, .patch = 3 },
                        .max = .{ .major = 6, .minor = 61, .patch = 0 },
                    },
                },

                .vita => .{
                    .semver = .{
                        // 1.3 是首个公开发行版
                        .min = .{ .major = 1, .minor = 3, .patch = 0 },
                        .max = .{ .major = 3, .minor = 60, .patch = 0 },
                    },
                },

                .wasi => .{
                    .semver = .{
                        .min = .{ .major = 0, .minor = 1, .patch = 0 },
                        .max = .{ .major = 0, .minor = 3, .patch = 0 },
                    },
                },

                .amdhsa => .{
                    .semver = .{
                        .min = .{ .major = 6, .minor = 1, .patch = 0 },
                        .max = .{ .major = 7, .minor = 2, .patch = 3 },
                    },
                },
                .amdpal => .{
                    .semver = .{
                        .min = .{ .major = 1, .minor = 1, .patch = 0 },
                        .max = .{ .major = 3, .minor = 5, .patch = 0 },
                    },
                },
                .cuda => .{
                    .semver = .{
                        .min = .{ .major = 12, .minor = 5, .patch = 0 },
                        .max = .{ .major = 13, .minor = 2, .patch = 0 },
                    },
                },
                .nvcl,
                .opencl,
                => .{
                    .semver = .{
                        .min = .{ .major = 2, .minor = 2, .patch = 0 },
                        .max = .{ .major = 3, .minor = 0, .patch = 19 },
                    },
                },
                .opengl => .{
                    .semver = .{
                        .min = .{ .major = 4, .minor = 5, .patch = 0 },
                        .max = .{ .major = 4, .minor = 6, .patch = 0 },
                    },
                },
                .tios => .{
                    .semver = .{
                        .min = .{ .major = 5, .minor = 0, .patch = 0 },
                        .max = .{ .major = 5, .minor = 8, .patch = 4 },
                    },
                },
                .vulkan => .{
                    .semver = .{
                        .min = .{ .major = 1, .minor = 2, .patch = 0 },
                        .max = .{ .major = 1, .minor = 4, .patch = 352 },
                    },
                },
            };
        }
    };

    pub const TaggedVersionRange = union(enum) {
        none: void,
        semver: std.SemanticVersion.Range,
        hurd: HurdVersionRange,
        linux: LinuxVersionRange,
        windows: WindowsVersion.Range,

        pub fn gnuLibCVersion(range: TaggedVersionRange) ?std.SemanticVersion {
            return switch (range) {
                .none, .semver, .windows => null,
                .hurd => |h| h.glibc,
                .linux => |l| l.glibc,
            };
        }
    };

    /// 提供标签联合体。`Target` 不存储标签,因为标签与操作系统标签重复;此函数将这部分抽象出来。
    ///
    pub inline fn versionRange(os: Os) TaggedVersionRange {
        return switch (os.tag.versionRangeTag()) {
            .none => .{ .none = {} },
            .semver => .{ .semver = os.version_range.semver },
            .hurd => .{ .hurd = os.version_range.hurd },
            .linux => .{ .linux = os.version_range.linux },
            .windows => .{ .windows = os.version_range.windows },
        };
    }

    /// 检查系统是否保证至少为 `version`,或早于 `version`。
    /// 若需要运行期检查,则返回 `null`。
    pub inline fn isAtLeast(os: Os, comptime tag: Tag, ver: switch (tag.versionRangeTag()) {
        .none => void,
        .semver, .hurd, .linux => std.SemanticVersion,
        .windows => WindowsVersion,
    }) ?bool {
        return if (os.tag != tag) false else switch (tag.versionRangeTag()) {
            .none => true,
            inline .semver,
            .hurd,
            .linux,
            .windows,
            => |field| @field(os.version_range, @tagName(field)).isAtLeast(ver),
        };
    }
};

pub const aarch64 = @import("Target/aarch64.zig");
pub const alpha = @import("Target/alpha.zig");
pub const amdgcn = @import("Target/amdgcn.zig");
pub const arc = @import("Target/arc.zig");
pub const arm = @import("Target/arm.zig");
pub const avr = @import("Target/avr.zig");
pub const bpf = @import("Target/bpf.zig");
pub const csky = @import("Target/csky.zig");
pub const hexagon = @import("Target/hexagon.zig");
pub const hppa = @import("Target/hppa.zig");
pub const kalimba = @import("Target/generic.zig");
pub const kvx = @import("Target/kvx.zig");
pub const lanai = @import("Target/lanai.zig");
pub const loongarch = @import("Target/loongarch.zig");
pub const m68k = @import("Target/m68k.zig");
pub const m88k = @import("Target/generic.zig");
pub const microblaze = @import("Target/generic.zig");
pub const mips = @import("Target/mips.zig");
pub const msp430 = @import("Target/msp430.zig");
pub const nvptx = @import("Target/nvptx.zig");
pub const or1k = @import("Target/generic.zig");
pub const powerpc = @import("Target/powerpc.zig");
pub const propeller = @import("Target/propeller.zig");
pub const riscv = @import("Target/riscv.zig");
pub const s390x = @import("Target/s390x.zig");
pub const sh = @import("Target/generic.zig");
pub const sparc = @import("Target/sparc.zig");
pub const spirv = @import("Target/spirv.zig");
pub const spork8 = @import("Target/generic.zig");
pub const ve = @import("Target/ve.zig");
pub const wasm = @import("Target/wasm.zig");
pub const x86 = @import("Target/x86.zig");
pub const xcore = @import("Target/xcore.zig");
pub const xtensa = @import("Target/xtensa.zig");
pub const z80 = @import("Target/generic.zig");

pub const Abi = enum {
    none,
    gnu,
    gnuabin32,
    gnuabi64,
    gnueabi,
    gnueabihf,
    gnuf32,
    gnusf,
    gnux32,
    eabi,
    eabihf,
    abin32,
    x32,
    ilp32,
    android,
    androideabi,
    musl,
    muslabin32,
    muslabi64,
    musleabi,
    musleabihf,
    muslf32,
    muslsf,
    muslx32,
    msvc,
    itanium,
    simulator,
    ohos,
    ohoseabi,
    call0,

    pub fn default(arch: Cpu.Arch, os_tag: Os.Tag) Abi {
        return switch (os_tag) {
            .freestanding, .other => switch (arch) {
                // 软浮点通常是独立运行环境的合理默认值。
                .arm,
                .armeb,
                .csky,
                .hppa,
                .mips,
                .mipsel,
                .powerpc,
                .powerpcle,
                .sh,
                .sheb,
                .thumb,
                .thumbeb,
                => .eabi,
                else => .none,
            },
            .fuchsia => switch (arch) {
                .arm,
                .thumb,
                => .eabihf,
                else => .none,
            },
            .haiku => switch (arch) {
                .arm => .eabihf,
                else => .none,
            },
            .hurd => .gnu,
            .linux => switch (arch) {
                .arm,
                .armeb,
                .powerpc,
                .powerpcle,
                .sh,
                .sheb,
                .thumb,
                .thumbeb,
                => .musleabihf,
                .mips,
                .mipsel,
                => .musleabi,
                .mips64,
                .mips64el,
                => .muslabi64,

                // 不支持 musl。
                .alpha,
                .arc,
                .arceb,
                .loongarch32,
                .sparc,
                .sparc64,
                => .gnu,
                .csky,
                => .gnueabi,
                .hppa,
                => .gnueabihf,

                // 不支持 glibc 或 musl。
                .xtensa,
                .xtensaeb,
                => .none,
                .hppa64,
                => .eabihf,

                else => .musl,
            },
            .rtems => switch (arch) {
                .arm,
                .armeb,
                .thumb,
                .thumbeb,
                .mips,
                .mipsel,
                => .eabi,
                .powerpc,
                => .eabihf,
                else => .none,
            },
            .freebsd => switch (arch) {
                .arm,
                => .eabihf,
                else => .none,
            },
            .netbsd => switch (arch) {
                .arm,
                .armeb,
                .powerpc,
                => .eabihf,
                // MIPS 更常使用软浮点。
                .mips,
                .mipsel,
                => .eabi,
                else => .none,
            },
            .openbsd => switch (arch) {
                .arm,
                => .eabi,
                .powerpc,
                => .eabihf,
                else => .none,
            },
            .windows => .gnu,
            .uefi => .msvc,
            .@"3ds" => .eabihf,
            .wiiu => .eabihf,
            .gba => .eabi,
            .psx => .eabi,
            .ps3 => .ilp32,
            .psp => .eabihf,
            .vita => .eabihf,
            .wasi, .emscripten => .musl,

            .ashetos => .eabi,

            .contiki,
            .hermit,
            .illumos,
            .managarm,
            .plan9,
            .serenity,
            .dragonfly,
            .driverkit,
            .ios,
            .maccatalyst,
            .macos,
            .tvos,
            .visionos,
            .watchos,
            .@"switch",
            .ps4,
            .ps5,
            .amdhsa,
            .amdpal,
            .cuda,
            .mesa3d,
            .nvcl,
            .opencl,
            .opengl,
            .vulkan,
            .tios,
            => .none,
        };
    }

    pub inline fn isGnu(abi: Abi) bool {
        return switch (abi) {
            .gnu,
            .gnuabin32,
            .gnuabi64,
            .gnueabi,
            .gnueabihf,
            .gnuf32,
            .gnusf,
            .gnux32,
            => true,
            else => false,
        };
    }

    pub inline fn isMusl(abi: Abi) bool {
        return switch (abi) {
            .musl,
            .muslabin32,
            .muslabi64,
            .musleabi,
            .musleabihf,
            .muslf32,
            .muslsf,
            .muslx32,
            => true,
            else => abi.isOpenHarmony(),
        };
    }

    pub inline fn isOpenHarmony(abi: Abi) bool {
        return switch (abi) {
            .ohos, .ohoseabi => true,
            else => false,
        };
    }

    pub inline fn isAndroid(abi: Abi) bool {
        return switch (abi) {
            .android, .androideabi => true,
            else => false,
        };
    }

    pub const Float = enum {
        hard,
        soft,
    };

    pub inline fn float(abi: Abi) Float {
        return switch (abi) {
            .androideabi,
            .eabi,
            .gnueabi,
            .musleabi,
            .gnusf,
            .muslsf,
            .ohoseabi,
            => .soft,
            else => .hard,
        };
    }
};

pub const ObjectFormat = enum {
    /// C 源代码。
    c,
    /// Windows 和 UEFI 使用的通用对象文件格式。
    coff,
    /// 许多 Unix 系统使用的可执行与可链接格式。
    elf,
    /// Intel HEX 格式,用于以 ASCII 文本存储二进制代码。
    hex,
    /// macOS 及其他 Apple 平台使用的 Mach 对象格式。
    macho,
    /// Bell Labs 的 Plan 9 使用的 a.out 格式。
    plan9,
    /// 不含元数据的机器代码。
    raw,
    /// Khronos Group 的标准可移植中间表示 V。
    spirv,
    /// WebAssembly 二进制格式。
    wasm,

    pub fn fileExt(of: ObjectFormat, arch: Cpu.Arch) [:0]const u8 {
        return switch (of) {
            .c => ".c",
            .coff => ".obj",
            .elf, .macho, .wasm => ".o",
            .hex => ".ihex",
            .plan9 => arch.plan9Ext(),
            .raw => ".bin",
            .spirv => ".spv",
        };
    }

    pub fn default(os_tag: Os.Tag, arch: Cpu.Arch) ObjectFormat {
        return switch (os_tag) {
            .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => .macho,
            .plan9 => .plan9,
            .uefi, .windows => .coff,
            else => switch (arch) {
                .spirv32, .spirv64 => .spirv,
                .wasm32, .wasm64 => .wasm,
                .spork8 => .raw,
                else => .elf,
            },
        };
    }
};

pub fn toElfMachine(target: *const Target) std.elf.EM {
    return switch (target.cpu.arch) {
        .aarch64, .aarch64_be => .AARCH64,
        .alpha => .ALPHA,
        .amdgcn => .AMDGPU,
        .arc, .arceb => .ARC_COMPACT2,
        .arm, .armeb, .thumb, .thumbeb => .ARM,
        .avr => .AVR,
        .bpfeb, .bpfel => .BPF,
        .csky => .CSKY,
        .ez80 => .Z80,
        .hexagon => .QDSP6,
        .hppa, .hppa64 => .PARISC,
        .kalimba => .CSR_KALIMBA,
        .kvx => .KVX,
        .lanai => .LANAI,
        .loongarch32, .loongarch64 => .LOONGARCH,
        .m88k => .@"88K",
        .m68k => .@"68K",
        .microblaze, .microblazeel => .MICROBLAZE,
        .mips, .mips64, .mipsel, .mips64el => .MIPS,
        .msp430 => .MSP430,
        .or1k => .OR1K,
        .powerpc, .powerpcle => .PPC,
        .powerpc64, .powerpc64le => .PPC64,
        .propeller => .PROPELLER,
        .riscv32, .riscv32be, .riscv64, .riscv64be => .RISCV,
        .s390x => .S390,
        .sh, .sheb => .SH,
        .sparc => if (target.cpu.hasAny(.sparc, &.{ .v8plus, .v9 })) .SPARC32PLUS else .SPARC,
        .sparc64 => .SPARCV9,
        .ve => .VE,
        .x86_16, .x86 => .@"386",
        .x86_64 => .X86_64,
        .xcore => .XCORE,
        .xtensa, .xtensaeb => .XTENSA,

        .nvptx,
        .nvptx64,
        .spirv32,
        .spirv64,
        .wasm32,
        .wasm64,
        .spork8,
        => .NONE,
    };
}

pub fn toCoffMachine(target: *const Target) std.coff.IMAGE.FILE.MACHINE {
    return switch (target.cpu.arch) {
        .alpha => .ALPHA64,
        .arm => .ARM,
        .thumb => .ARMNT,
        .aarch64 => .ARM64,
        .loongarch32 => .LOONGARCH32,
        .loongarch64 => .LOONGARCH64,
        .mips => .R3000BE,
        .mipsel => .R3000,
        .mips64el => .R4000,
        .powerpcle => .POWERPC,
        .riscv32 => .RISCV32,
        .riscv64 => .RISCV64,
        .sh => .SH3,
        .x86 => .I386,
        .x86_64 => .AMD64,

        .aarch64_be,
        .amdgcn,
        .arc,
        .arceb,
        .armeb,
        .avr,
        .bpfeb,
        .bpfel,
        .csky,
        .ez80,
        .hexagon,
        .hppa,
        .hppa64,
        .kalimba,
        .kvx,
        .lanai,
        .m88k,
        .m68k,
        .microblaze,
        .microblazeel,
        .mips64,
        .msp430,
        .nvptx,
        .nvptx64,
        .or1k,
        .powerpc,
        .powerpc64,
        .powerpc64le,
        .propeller,
        .riscv32be,
        .riscv64be,
        .s390x,
        .sheb,
        .sparc,
        .sparc64,
        .spirv32,
        .spirv64,
        .thumbeb,
        .ve,
        .wasm32,
        .wasm64,
        .x86_16,
        .xcore,
        .xtensa,
        .xtensaeb,
        .spork8,
        => .UNKNOWN,
    };
}

pub const Cpu = struct {
    /// 架构
    arch: Arch,

    /// 目标 CPU 型号。它具有一组特性,
    /// 可由 `features` 字段覆盖。
    model: *const Model,

    /// 明确列出完整 CPU 特性集。它可能不同于具体 CPU 型号的特性。
    features: Feature.Set,

    pub const Feature = struct {
        /// `Set` 中的位索引。默认值为 `undefined`,
        /// 因为规范结构通过编译期逻辑填充。
        index: Set.Index = undefined,

        /// 默认值为 `undefined`,
        /// 因为规范结构由编译时逻辑填充。
        name: []const u8 = undefined,

        /// 若对应 LLVM 识别的特性,则填充此值;
        /// 否则为 null。
        llvm_name: ?[:0]const u8,

        /// 便于人阅读的 UTF-8 文本。
        description: []const u8,

        /// 所依赖特性的稀疏 `Set`。
        dependencies: Set,

        /// 所有特性的位集合。
        ///
        /// 给定 `Target.Cpu.Arch` 对应的带类型特性可在
        /// `@field(Target, @tagName(arch.family()))` 中找到。
        pub const Set = struct {
            ints: [usize_count]usize,

            pub const needed_bit_count = 347;
            pub const byte_count = @divCeil(needed_bit_count, 8);
            pub const usize_count = (byte_count + (@sizeOf(usize) - 1)) / @sizeOf(usize);
            pub const Index = std.math.Log2Int(@Int(.unsigned, usize_count * @bitSizeOf(usize)));
            pub const ShiftInt = std.math.Log2Int(usize);

            pub const empty: Set = .{ .ints = @splat(0) };

            pub fn isEmpty(set: Set) bool {
                return for (set.ints) |x| {
                    if (x != 0) break false;
                } else true;
            }

            pub fn count(set: Set) std.math.IntFittingRange(0, needed_bit_count) {
                var sum: usize = 0;
                for (set.ints) |x| sum += @popCount(x);
                return @intCast(sum);
            }

            pub fn isEnabled(set: Set, arch_feature_index: Index) bool {
                const usize_index = arch_feature_index / @bitSizeOf(usize);
                const bit_index: ShiftInt = @intCast(arch_feature_index % @bitSizeOf(usize));
                return (set.ints[usize_index] & (@as(usize, 1) << bit_index)) != 0;
            }

            /// 添加指定特性,但不添加其依赖。
            pub fn addFeature(set: *Set, arch_feature_index: Index) void {
                const usize_index = arch_feature_index / @bitSizeOf(usize);
                const bit_index: ShiftInt = @intCast(arch_feature_index % @bitSizeOf(usize));
                set.ints[usize_index] |= @as(usize, 1) << bit_index;
            }

            /// 添加指定特性集,但不添加其依赖。
            pub fn addFeatureSet(set: *Set, other_set: Set) void {
                set.ints = @as(@Vector(usize_count, usize), set.ints) | @as(@Vector(usize_count, usize), other_set.ints);
            }

            /// 移除指定特性,但不移除依赖它的特性。
            pub fn removeFeature(set: *Set, arch_feature_index: Index) void {
                const usize_index = arch_feature_index / @bitSizeOf(usize);
                const bit_index: ShiftInt = @intCast(arch_feature_index % @bitSizeOf(usize));
                set.ints[usize_index] &= ~(@as(usize, 1) << bit_index);
            }

            /// 移除指定特性,但不移除依赖它的特性。
            pub fn removeFeatureSet(set: *Set, other_set: Set) void {
                set.ints = @as(@Vector(usize_count, usize), set.ints) & ~@as(@Vector(usize_count, usize), other_set.ints);
            }

            pub fn populateDependencies(set: *Set, all_features_list: []const Cpu.Feature) void {
                @setEvalBranchQuota(1000000);

                var old = set.ints;
                while (true) {
                    for (all_features_list, 0..) |feature, index_usize| {
                        const index: Index = @intCast(index_usize);
                        if (set.isEnabled(index)) {
                            set.addFeatureSet(feature.dependencies);
                        }
                    }
                    const nothing_changed = std.mem.eql(usize, &old, &set.ints);
                    if (nothing_changed) return;
                    old = set.ints;
                }
            }

            pub fn asBytes(set: *const Set) *const [byte_count]u8 {
                return std.mem.sliceAsBytes(&set.ints)[0..byte_count];
            }

            pub fn eql(set: Set, other_set: Set) bool {
                return std.mem.eql(usize, &set.ints, &other_set.ints);
            }

            pub fn isSuperSetOf(set: Set, other_set: Set) bool {
                const V = @Vector(usize_count, usize);
                const set_v: V = set.ints;
                const other_v: V = other_set.ints;
                return @reduce(.And, (set_v & other_v) == other_v);
            }
        };

        pub fn FeatureSetFns(comptime F: type) type {
            return struct {
                /// 只填充指定的特性位。
                pub fn featureSet(features: []const F) Set {
                    var x = Set.empty;
                    for (features) |feature| {
                        x.addFeature(@backingInt(feature));
                    }
                    return x;
                }

                /// 若指定特性已启用,则返回 true。
                pub fn featureSetHas(set: Set, feature: F) bool {
                    return set.isEnabled(@backingInt(feature));
                }

                /// 如果任意指定特性已启用,则返回 true。
                pub fn featureSetHasAny(set: Set, features: anytype) bool {
                    inline for (features) |feature| {
                        if (set.isEnabled(@backingInt(@as(F, feature)))) return true;
                    }
                    return false;
                }

                /// 若所有指定特性均已启用,则返回 true。
                pub fn featureSetHasAll(set: Set, features: anytype) bool {
                    inline for (features) |feature| {
                        if (!set.isEnabled(@backingInt(@as(F, feature)))) return false;
                    }
                    return true;
                }
            };
        }
    };

    pub const Arch = enum {
        aarch64,
        aarch64_be,
        alpha,
        amdgcn,
        arc,
        arceb,
        arm,
        armeb,
        avr,
        bpfeb,
        bpfel,
        csky,
        ez80,
        hexagon,
        hppa,
        hppa64,
        kalimba,
        kvx,
        lanai,
        loongarch32,
        loongarch64,
        m68k,
        m88k,
        microblaze,
        microblazeel,
        mips,
        mipsel,
        mips64,
        mips64el,
        msp430,
        nvptx,
        nvptx64,
        or1k,
        powerpc,
        powerpcle,
        powerpc64,
        powerpc64le,
        propeller,
        riscv32,
        riscv32be,
        riscv64,
        riscv64be,
        s390x,
        sh,
        sheb,
        sparc,
        sparc64,
        spork8,
        spirv32,
        spirv64,
        thumb,
        thumbeb,
        ve,
        wasm32,
        wasm64,
        x86_16,
        x86,
        x86_64,
        xcore,
        xtensa,
        xtensaeb,

        /// 一个架构族可涵盖多个由 `Arch` 表示的架构。
        /// 对于给定架构族标签,保证存在 `std.Target.<tag>` 命名空间,
        /// 其中包含 CPU 型号和特性数据。
        pub const Family = enum {
            aarch64,
            alpha,
            amdgcn,
            arc,
            arm,
            avr,
            bpf,
            csky,
            hexagon,
            hppa,
            kalimba,
            kvx,
            lanai,
            loongarch,
            m68k,
            m88k,
            microblaze,
            mips,
            msp430,
            nvptx,
            or1k,
            powerpc,
            propeller,
            riscv,
            s390x,
            sh,
            sparc,
            spirv,
            ve,
            wasm,
            x86,
            xcore,
            xtensa,
            z80,
            spork8,
        };

        pub inline fn family(arch: Arch) Family {
            return switch (arch) {
                .aarch64, .aarch64_be => .aarch64,
                .alpha => .alpha,
                .amdgcn => .amdgcn,
                .arc, .arceb => .arc,
                .arm, .armeb, .thumb, .thumbeb => .arm,
                .avr => .avr,
                .bpfeb, .bpfel => .bpf,
                .csky => .csky,
                .ez80 => .z80,
                .hexagon => .hexagon,
                .hppa, .hppa64 => .hppa,
                .kalimba => .kalimba,
                .kvx => .kvx,
                .lanai => .lanai,
                .loongarch32, .loongarch64 => .loongarch,
                .m68k => .m68k,
                .m88k => .m88k,
                .microblaze, .microblazeel => .microblaze,
                .mips, .mipsel, .mips64, .mips64el => .mips,
                .msp430 => .msp430,
                .or1k => .or1k,
                .nvptx, .nvptx64 => .nvptx,
                .powerpc, .powerpcle, .powerpc64, .powerpc64le => .powerpc,
                .propeller => .propeller,
                .riscv32, .riscv32be, .riscv64, .riscv64be => .riscv,
                .s390x => .s390x,
                .sh, .sheb => .sh,
                .sparc, .sparc64 => .sparc,
                .spirv32, .spirv64 => .spirv,
                .ve => .ve,
                .wasm32, .wasm64 => .wasm,
                .x86_16, .x86, .x86_64 => .x86,
                .xcore => .xcore,
                .xtensa, .xtensaeb => .xtensa,
                .spork8 => .spork8,
            };
        }

        pub inline fn isX86(arch: Arch) bool {
            return switch (arch) {
                .x86_16, .x86, .x86_64 => true,
                else => false,
            };
        }

        /// 注意,此处包含 Thumb。
        pub inline fn isArm(arch: Arch) bool {
            return switch (arch) {
                .arm, .armeb => true,
                else => arch.isThumb(),
            };
        }

        pub inline fn isThumb(arch: Arch) bool {
            return switch (arch) {
                .thumb, .thumbeb => true,
                else => false,
            };
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isAarch64`。
        pub const isAARCH64 = isAarch64;

        pub inline fn isAarch64(arch: Arch) bool {
            return switch (arch) {
                .aarch64, .aarch64_be => true,
                else => false,
            };
        }

        pub inline fn isArc(arch: Arch) bool {
            return switch (arch) {
                .arc, .arceb => true,
                else => false,
            };
        }

        pub inline fn isHppa(arch: Arch) bool {
            return switch (arch) {
                .hppa, .hppa64 => true,
                else => false,
            };
        }

        pub inline fn isWasm(arch: Arch) bool {
            return switch (arch) {
                .wasm32, .wasm64 => true,
                else => false,
            };
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isLoongarch`。
        pub const isLoongArch = isLoongarch;

        pub inline fn isLoongarch(arch: Arch) bool {
            return switch (arch) {
                .loongarch32, .loongarch64 => true,
                else => false,
            };
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isRiscv`。
        pub const isRISCV = isRiscv;

        pub inline fn isRiscv(arch: Arch) bool {
            return arch.isRiscv32() or arch.isRiscv64();
        }

        pub inline fn isRiscv32(arch: Arch) bool {
            return switch (arch) {
                .riscv32, .riscv32be => true,
                else => false,
            };
        }

        pub inline fn isRiscv64(arch: Arch) bool {
            return switch (arch) {
                .riscv64, .riscv64be => true,
                else => false,
            };
        }

        pub inline fn isMicroblaze(arch: Arch) bool {
            return switch (arch) {
                .microblaze, .microblazeel => true,
                else => false,
            };
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isMips`。
        pub const isMIPS = isMips;

        pub inline fn isMips(arch: Arch) bool {
            return arch.isMips32() or arch.isMips64();
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isMips32`。
        pub const isMIPS32 = isMips32;

        pub inline fn isMips32(arch: Arch) bool {
            return switch (arch) {
                .mips, .mipsel => true,
                else => false,
            };
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isMips64`。
        pub const isMIPS64 = isMips64;

        pub inline fn isMips64(arch: Arch) bool {
            return switch (arch) {
                .mips64, .mips64el => true,
                else => false,
            };
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isPowerpc`。
        pub const isPowerPC = isPowerpc;

        pub inline fn isPowerpc(arch: Arch) bool {
            return arch.isPowerpc32() or arch.isPowerpc64();
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isPowerpc32`。
        pub const isPowerPC32 = isPowerpc32;

        pub inline fn isPowerpc32(arch: Arch) bool {
            return switch (arch) {
                .powerpc, .powerpcle => true,
                else => false,
            };
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isPowerpc64`。
        pub const isPowerPC64 = isPowerpc64;

        pub inline fn isPowerpc64(arch: Arch) bool {
            return switch (arch) {
                .powerpc64, .powerpc64le => true,
                else => false,
            };
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isSparc`。
        pub const isSPARC = isSparc;

        pub inline fn isSparc(arch: Arch) bool {
            return switch (arch) {
                .sparc, .sparc64 => true,
                else => false,
            };
        }

        /// 已弃用;将在 0.18.0 中移除。请改用 `isSpirv`。
        pub const isSpirV = isSpirv;

        pub inline fn isSpirv(arch: Arch) bool {
            return switch (arch) {
                .spirv32, .spirv64 => true,
                else => false,
            };
        }

        pub inline fn isSh(arch: Arch) bool {
            return switch (arch) {
                .sh, .sheb => true,
                else => false,
            };
        }

        pub inline fn isBpf(arch: Arch) bool {
            return switch (arch) {
                .bpfel, .bpfeb => true,
                else => false,
            };
        }

        pub inline fn isNvptx(arch: Arch) bool {
            return switch (arch) {
                .nvptx, .nvptx64 => true,
                else => false,
            };
        }

        pub inline fn isXtensa(arch: Arch) bool {
            return switch (arch) {
                .xtensa, .xtensaeb => true,
                else => false,
            };
        }

        pub fn parseCpuModel(arch: Arch, cpu_name: []const u8) ?*const Cpu.Model {
            for (arch.allCpuModels()) |cpu| {
                if (std.mem.eql(u8, cpu_name, cpu.name)) {
                    return cpu;
                }
            }
            return null;
        }

        pub fn endian(arch: Arch) std.builtin.Endian {
            return switch (arch) {
                .aarch64,
                .alpha,
                .arm,
                .arc,
                .avr,
                .bpfel,
                .csky,
                .hexagon,
                .kalimba,
                .kvx,
                .loongarch32,
                .loongarch64,
                .microblazeel,
                .mipsel,
                .mips64el,
                .msp430,
                .powerpcle,
                .powerpc64le,
                .propeller,
                .riscv32,
                .riscv64,
                .sh,
                .thumb,
                .ve,
                .wasm32,
                .wasm64,
                .x86_16,
                .x86,
                .x86_64,
                .xcore,
                .xtensa,
                .ez80,
                => .little,

                .aarch64_be,
                .arceb,
                .armeb,
                .bpfeb,
                .hppa,
                .hppa64,
                .lanai,
                .m68k,
                .m88k,
                .microblaze,
                .mips,
                .mips64,
                .or1k,
                .powerpc,
                .powerpc64,
                .riscv32be,
                .riscv64be,
                .s390x,
                .sheb,
                .thumbeb,
                .sparc,
                .sparc64,
                .xtensaeb,
                .spork8,
                => .big,

                // GPU 字节序不透明。目前假定为小端序。
                .amdgcn,
                .nvptx,
                .nvptx64,
                .spirv32,
                .spirv64,
                => .little,
            };
        }

        /// Zig 已知的所有 CPU 特性,按名称字典序排列。
        pub fn allFeaturesList(arch: Arch) []const Cpu.Feature {
            return switch (arch.family()) {
                inline else => |f| &@field(Target, @tagName(f)).all_features,
            };
        }

        /// Zig 已知的所有处理器,按名称字典序排列。
        pub fn allCpuModels(arch: Arch) []const *const Cpu.Model {
            return switch (arch.family()) {
                inline else => |f| comptime allCpusFromDecls(@field(Target, @tagName(f)).cpu),
            };
        }

        fn allCpusFromDecls(comptime cpus: type) []const *const Cpu.Model {
            @setEvalBranchQuota(2000);
            const decl_names = @typeInfo(cpus).@"struct".decl_names;
            var array: [decl_names.len]*const Cpu.Model = undefined;
            for (decl_names, 0..) |decl_name, i| {
                array[i] = &@field(cpus, decl_name);
            }
            const finalized = array;
            return &finalized;
        }

        /// 0c spim    小端序 MIPS 3000 系列
        /// 1c 68000   Motorola MC68000
        /// 2c 68020   Motorola MC68020
        /// 5c arm     小端序 ARM
        /// 6c amd64   AMD64 及兼容处理器,例如 Intel EM64T
        /// 7c arm64   ARM64(ARMv8)
        /// 8c 386     Intel x86、i486、Pentium 等
        /// kc sparc   Sun SPARC
        /// qc power   Power PC
        /// vc mips    大端序 MIPS 3000 系列
        pub fn plan9Ext(arch: Cpu.Arch) [:0]const u8 {
            return switch (arch) {
                .arm => ".5",
                .x86_64 => ".6",
                .aarch64 => ".7",
                .x86 => ".8",
                .sparc => ".k",
                .powerpc, .powerpcle => ".q",
                .mips, .mipsel => ".v",
                // 没有指定字符的 ISA 使用“X”,因为没有更好的选项。
                else => ".X",
            };
        }

        /// 返回特定 `std.builtin.CallingConvention` 适用的 `Arch` 数组。
        /// 断言 `cc` 不是 `.auto`、`.@"async"`、`.naked` 或 `.@"inline"`。
        pub fn fromCallingConvention(cc: std.builtin.CallingConvention.Tag) []const Arch {
            return switch (cc) {
                .auto,
                .async,
                .naked,
                .@"inline",
                => unreachable,

                .x86_64_sysv,
                .x86_64_x32,
                .x86_64_win,
                .x86_64_regcall_v3_sysv,
                .x86_64_regcall_v4_win,
                .x86_64_vectorcall,
                .x86_64_interrupt,
                .x86_64_preserve_none,
                => &.{.x86_64},

                .x86_sysv,
                .x86_win,
                .x86_mingw,
                .x86_stdcall,
                .x86_fastcall,
                .x86_thiscall,
                .x86_thiscall_mingw,
                .x86_regcall_v3,
                .x86_regcall_v4_win,
                .x86_vectorcall,
                .x86_interrupt,
                => &.{.x86},

                .x86_16_cdecl,
                .x86_16_stdcall,
                .x86_16_regparmcall,
                .x86_16_interrupt,
                => &.{.x86_16},

                .aarch64_aapcs,
                .aarch64_aapcs_darwin,
                .aarch64_aapcs_win,
                .aarch64_vfabi,
                .aarch64_vfabi_sve,
                .aarch64_preserve_none,
                => &.{ .aarch64, .aarch64_be },

                .alpha_osf,
                => &.{.alpha},

                .arm_aapcs,
                .arm_aapcs_vfp,
                .arm_interrupt,
                => &.{ .arm, .armeb, .thumb, .thumbeb },

                .mips64_n64,
                .mips64_n32,
                .mips64_interrupt,
                => &.{ .mips64, .mips64el },

                .mips_o32,
                .mips_interrupt,
                => &.{ .mips, .mipsel },

                .riscv64_lp64,
                .riscv64_lp64_v,
                .riscv64_interrupt,
                => &.{ .riscv64, .riscv64be },

                .riscv32_ilp32,
                .riscv32_ilp32_v,
                .riscv32_interrupt,
                => &.{ .riscv32, .riscv32be },

                .sparc64_sysv,
                => &.{.sparc64},

                .sparc_sysv,
                => &.{.sparc},

                .powerpc64_elf,
                .powerpc64_elf_altivec,
                .powerpc64_elf_v2,
                => &.{ .powerpc64, .powerpc64le },

                .powerpc_sysv,
                .powerpc_sysv_altivec,
                .powerpc_aix,
                .powerpc_aix_altivec,
                => &.{ .powerpc, .powerpcle },

                .wasm_mvp,
                => &.{ .wasm64, .wasm32 },

                .arc_sysv,
                .arc_interrupt,
                => &.{ .arc, .arceb },

                .avr_gnu,
                .avr_builtin,
                .avr_signal,
                .avr_interrupt,
                => &.{.avr},

                .bpf_std,
                => &.{ .bpfel, .bpfeb },

                .csky_sysv,
                .csky_interrupt,
                => &.{.csky},

                .hexagon_sysv,
                .hexagon_sysv_hvx,
                => &.{.hexagon},

                .hppa_elf,
                => &.{.hppa},

                .hppa64_elf,
                => &.{.hppa64},

                .kvx_lp64,
                .kvx_ilp32,
                => &.{.kvx},

                .lanai_sysv,
                => &.{.lanai},

                .loongarch64_lp64,
                => &.{.loongarch64},

                .loongarch32_ilp32,
                => &.{.loongarch32},

                .m68k_sysv,
                .m68k_gnu,
                .m68k_rtd,
                .m68k_interrupt,
                => &.{.m68k},

                .m88k_sysv,
                => &.{.m88k},

                .microblaze_std,
                .microblaze_interrupt,
                => &.{ .microblaze, .microblazeel },

                .msp430_eabi,
                .msp430_interrupt,
                => &.{.msp430},

                .or1k_sysv,
                => &.{.or1k},

                .propeller_sysv,
                => &.{.propeller},

                .s390x_sysv,
                .s390x_sysv_vx,
                => &.{.s390x},

                .sh_gnu,
                .sh_renesas,
                .sh_interrupt,
                => &.{ .sh, .sheb },

                .ve_sysv,
                => &.{.ve},

                .xcore_xs1,
                .xcore_xs2,
                => &.{.xcore},

                .xtensa_call0,
                .xtensa_windowed,
                => &.{ .xtensa, .xtensaeb },

                .amdgcn_device,
                .amdgcn_kernel,
                .amdgcn_cs,
                => &.{.amdgcn},

                .nvptx_device,
                .nvptx_kernel,
                => &.{ .nvptx, .nvptx64 },

                .spirv_device,
                .spirv_kernel,
                .spirv_fragment,
                .spirv_vertex,
                .spirv_task,
                .spirv_mesh,
                => &.{ .spirv32, .spirv64 },

                .ez80_cet,
                .ez80_tiflags,
                => &.{.ez80},

                .spork8,
                => &.{.spork8},
            };
        }
    };

    pub const Model = struct {
        name: []const u8,
        llvm_name: ?[:0]const u8,
        features: Feature.Set,

        pub fn toCpu(model: *const Model, arch: Arch) Cpu {
            var features = model.features;
            features.populateDependencies(arch.allFeaturesList());
            return .{
                .arch = arch,
                .model = model,
                .features = features,
            };
        }

        /// 返回适用于 `arch` 的最基础 CPU 型号。注意,此函数
        /// 可能返回 LLVM 能识别、但 Clang *无法*识别的 CPU 型号。
        /// 如果需要兼容 Clang,请考虑改用 `baseline`。
        pub fn generic(arch: Arch) *const Model {
            return switch (arch) {
                .alpha => &alpha.cpu.ev4,
                .amdgcn => &amdgcn.cpu.gfx600,
                .avr => &avr.cpu.avr1,
                .hppa => &hppa.cpu.ts_1,
                .hppa64 => &hppa.cpu.pa_8000,
                .kvx => &kvx.cpu.coolidge_v1,
                .loongarch32 => &loongarch.cpu.generic_la32,
                .loongarch64 => &loongarch.cpu.generic_la64,
                .mips, .mipsel => &mips.cpu.mips32,
                .mips64, .mips64el => &mips.cpu.mips64,
                .nvptx, .nvptx64 => &nvptx.cpu.sm_20,
                .powerpc, .powerpcle => &powerpc.cpu.ppc,
                .powerpc64, .powerpc64le => &powerpc.cpu.ppc64,
                .propeller => &propeller.cpu.p1,
                .riscv32, .riscv32be => &riscv.cpu.generic_rv32,
                .riscv64, .riscv64be => &riscv.cpu.generic_rv64,
                .sparc => &sparc.cpu.v8,
                .sparc64 => &sparc.cpu.v9, // SPARC 从 v9 起才支持 64 位。
                .wasm32, .wasm64 => &wasm.cpu.mvp,
                .x86_16 => &x86.cpu.i86,
                .x86 => &x86.cpu.i386,
                .x86_64 => &x86.cpu.x86_64,
                inline else => |a| &@field(Target, @tagName(a.family())).cpu.generic,
            };
        }

        /// 返回 `arch` 的保守 CPU 型号,预期兼容
        /// 绝大多数现有硬件。与 `generic` 不同,此函数保证返回的 CPU 型号
        /// 同时为 LLVM 和 Clang 所识别。
        ///
        /// 对于某些 `os` 值,此函数还会将基线提高到
        /// 高于仅由 `arch` 决定的水平;例如,`aarch64-macos` 的
        /// 基线视为 `apple_m1`。要完全避免此行为,请传入
        /// `Os.Tag.freestanding`。
        pub fn baseline(arch: Arch, os: Os) *const Model {
            return switch (arch) {
                .alpha => &alpha.cpu.ev6,
                .amdgcn => &amdgcn.cpu.gfx906,
                .arm => switch (os.tag) {
                    .@"3ds" => &arm.cpu.mpcore,
                    .vita => &arm.cpu.cortex_a9,
                    .gba => &arm.cpu.arm7tdmi,
                    else => &arm.cpu.baseline,
                },
                .thumb => switch (os.tag) {
                    .vita => &arm.cpu.cortex_a9,
                    .gba => &arm.cpu.arm7tdmi,
                    else => &arm.cpu.baseline,
                },
                .armeb, .thumbeb => &arm.cpu.baseline,
                .aarch64 => switch (os.tag) {
                    .haiku => &aarch64.cpu.cortex_a55,
                    .driverkit, .maccatalyst, .macos => &aarch64.cpu.apple_m1,
                    .ios, .tvos => &aarch64.cpu.apple_a7,
                    .visionos => &aarch64.cpu.apple_m2,
                    .watchos => &aarch64.cpu.apple_s4,
                    .@"switch" => &aarch64.cpu.cortex_a57,
                    else => generic(arch),
                },
                .avr => &avr.cpu.avr2,
                .bpfel, .bpfeb => &bpf.cpu.v3,
                .csky => &csky.cpu.ck810, // gcc/clang 没有通用 csky 模型。
                .hexagon => &hexagon.cpu.hexagonv68, // gcc/clang 没有通用 hexagon 型号。
                .hppa => &hppa.cpu.pa_7300lc,
                .kvx => &kvx.cpu.coolidge_v2,
                .lanai => &lanai.cpu.v11, // clang 没有通用 lanai 模型。
                .loongarch32 => &loongarch.cpu.la32v1_0,
                .loongarch64 => &loongarch.cpu.la64v1_0,
                .m68k => &m68k.cpu.M68030,
                .mips => &mips.cpu.mips32r2,
                .mipsel => switch (os.tag) {
                    .psx => &mips.cpu.r3000a,
                    .psp => &mips.cpu.allegrex,
                    else => &mips.cpu.mips32r2,
                },
                .mips64 => switch (os.tag) {
                    .openbsd => &mips.cpu.octeon,
                    else => &mips.cpu.mips64r2,
                },
                .mips64el => &mips.cpu.mips64r2,
                .msp430 => &msp430.cpu.msp430,
                .nvptx, .nvptx64 => &nvptx.cpu.sm_52,
                .powerpc => switch (os.tag) {
                    .openbsd, .wiiu => &powerpc.cpu.@"750",
                    else => generic(arch),
                },
                .powerpc64 => switch (os.tag) {
                    .linux, .freebsd => &powerpc.cpu.pwr8,
                    .openbsd => &powerpc.cpu.pwr9,
                    else => generic(arch),
                },
                .powerpc64le => &powerpc.cpu.ppc64le,
                .riscv32, .riscv32be => &riscv.cpu.baseline_rv32,
                .riscv64, .riscv64be => &riscv.cpu.baseline_rv64,
                .s390x => &s390x.cpu.arch11,
                .sparc => switch (os.tag) {
                    .linux => &sparc.cpu.v9, // glibc 无法与纯 v8 配合使用。
                    else => generic(arch),
                },
                .sparc64 => &sparc.cpu.ultrasparc,
                .x86 => &x86.cpu.pentium4,
                .x86_64 => switch (os.tag) {
                    .driverkit, .maccatalyst => &x86.cpu.nehalem,
                    .macos => &x86.cpu.core2,
                    .ps4 => &x86.cpu.btver2,
                    .ps5 => &x86.cpu.znver2,
                    else => generic(arch),
                },
                .xcore => &xcore.cpu.xs1b_generic,
                .xtensa => &xtensa.cpu.esp32,
                .wasm32, .wasm64 => &wasm.cpu.lime1,

                else => generic(arch),
            };
        }
    };

    /// 交叉编译的“默认”CPU 特性集。这是一组保守特性,预期绝大多数可用硬件都支持。
    ///
    pub fn baseline(arch: Arch, os: Os) Cpu {
        return Model.baseline(arch, os).toCpu(arch);
    }

    /// 若 `feature` 已启用,则返回 true。
    pub fn has(cpu: Cpu, comptime family: Arch.Family, feature: @field(Target, @tagName(family)).Feature) bool {
        if (family != cpu.arch.family()) return false;
        return cpu.features.isEnabled(@backingInt(feature));
    }

    /// 若 `features` 中任一特性已启用,则返回 true。
    pub fn hasAny(cpu: Cpu, comptime family: Arch.Family, features: []const @field(Target, @tagName(family)).Feature) bool {
        if (family != cpu.arch.family()) return false;
        for (features) |feature| {
            if (cpu.features.isEnabled(@backingInt(feature))) return true;
        }
        return false;
    }

    /// 若 `features` 中的所有特性均已启用,则返回 true。
    pub fn hasAll(cpu: Cpu, comptime family: Arch.Family, features: []const @field(Target, @tagName(family)).Feature) bool {
        if (family != cpu.arch.family()) return false;
        for (features) |feature| {
            if (!cpu.features.isEnabled(@backingInt(feature))) return false;
        }
        return true;
    }
};

pub fn zigTriple(target: *const Target, allocator: Allocator) Allocator.Error![]u8 {
    return Query.fromTarget(target).zigTriple(allocator);
}

/// 已弃用;将在 0.18.0 中移除。请改用 `std.zig.target.hurdTupleSimple`。
pub fn hurdTupleSimple(allocator: Allocator, arch: Cpu.Arch, abi: Abi) ![]u8 {
    return std.fmt.allocPrint(allocator, "{s}-{s}", .{ @tagName(arch), @tagName(abi) });
}

/// 已弃用;将在 0.18.0 中移除。请改用 `std.zig.target.hurdTuple`。
pub fn hurdTuple(target: *const Target, allocator: Allocator) ![]u8 {
    return hurdTupleSimple(allocator, target.cpu.arch, target.abi);
}

/// 已弃用;将在 0.18.0 中移除。请改用 `std.zig.target.linuxTripleSimple`。
pub fn linuxTripleSimple(allocator: Allocator, arch: Cpu.Arch, os_tag: Os.Tag, abi: Abi) ![]u8 {
    return std.fmt.allocPrint(allocator, "{s}-{s}-{s}", .{ @tagName(arch), @tagName(os_tag), @tagName(abi) });
}

/// 已弃用;将在 0.18.0 中移除。请改用 `std.zig.target.linuxTriple`。
pub fn linuxTriple(target: *const Target, allocator: Allocator) ![]u8 {
    return linuxTripleSimple(allocator, target.cpu.arch, target.os.tag, target.abi);
}

pub fn exeFileExt(target: *const Target) [:0]const u8 {
    return target.os.tag.exeFileExt(target.cpu.arch);
}

pub fn staticLibSuffix(target: *const Target) [:0]const u8 {
    return target.os.tag.staticLibSuffix(target.abi);
}

pub fn dynamicLibSuffix(target: *const Target) [:0]const u8 {
    return target.os.tag.dynamicLibSuffix();
}

pub fn libPrefix(target: *const Target) [:0]const u8 {
    return target.os.tag.libPrefix(target.abi);
}

pub inline fn isMinGW(target: *const Target) bool {
    return target.os.tag == .windows and target.abi.isGnu();
}

pub inline fn isGnuLibC(target: *const Target) bool {
    return switch (target.os.tag) {
        .hurd, .linux => target.abi.isGnu(),
        else => false,
    };
}

pub inline fn isMuslLibC(target: *const Target) bool {
    return target.os.tag == .linux and target.abi.isMusl();
}

pub inline fn isBionicLibC(target: *const Target) bool {
    return target.os.tag == .linux and target.abi.isAndroid();
}

pub inline fn isDarwinLibC(target: *const Target) bool {
    return switch (target.abi) {
        .none, .simulator => target.os.tag.isDarwin(),
        else => false,
    };
}

pub inline fn isFreeBSDLibC(target: *const Target) bool {
    return switch (target.abi) {
        .none, .eabihf => target.os.tag == .freebsd,
        else => false,
    };
}

pub inline fn isNetBSDLibC(target: *const Target) bool {
    return switch (target.abi) {
        .none, .eabi, .eabihf => target.os.tag == .netbsd,
        else => false,
    };
}

pub inline fn isOpenBSDLibC(target: *const Target) bool {
    return switch (target.abi) {
        .none, .eabi, .eabihf => target.os.tag == .openbsd,
        else => false,
    };
}

pub inline fn isWasiLibC(target: *const Target) bool {
    return target.os.tag == .wasi and target.abi.isMusl();
}

/// 此目标是否必须链接 libc?例如,目标系统调用接口
/// 不稳定时可能有此要求。
pub fn requiresLibC(target: *const Target) bool {
    return switch (target.os.tag) {
        .illumos,
        .driverkit,
        .ios,
        .maccatalyst,
        .macos,
        .tvos,
        .watchos,
        .visionos,
        .dragonfly,
        .haiku,
        .serenity,
        .emscripten,
        => true,

        // Android 29 之前的 API 级别不原生支持 TLS。这些 API 级别通过
        // 调用 `__emutls_get_address` 实现 TLS。我们在 compiler-rt
        // 提供此函数,但它通过 `pthread_key_create` 等函数实现,
        // 因此要求链接 libc。
        .linux => target.abi.isAndroid() and target.os.version_range.linux.android < 29,

        .windows,
        .freebsd,
        .netbsd,
        .openbsd,
        .freestanding,
        .fuchsia,
        .managarm,
        .rtems,
        .cuda,
        .nvcl,
        .amdhsa,
        .psx,
        .ps3,
        .ps4,
        .ps5,
        .gba,
        .psp,
        .vita,
        .mesa3d,
        .contiki,
        .amdpal,
        .hermit,
        .hurd,
        .wasi,
        .uefi,
        .opencl,
        .opengl,
        .vulkan,
        .plan9,
        .other,
        .@"3ds",
        .wiiu,
        .@"switch",
        .tios,
        .ashetos,
        => false,
    };
}

/// 用户可以指定地址空间属性的位置
pub const AddressSpaceContext = enum {
    /// 指定将函数置于特定地址空间。
    function,
    /// 指定将某个(全局)变量放入特定地址空间。
    /// 与 `.constant` 不同,这些值(因此也包括放置它们的地址空间)
    /// 必须可变。
    variable,
    /// 指定将某个(全局)常量值放入特定地址空间。
    /// 与 `.variable` 不同,放入此地址空间的值不要求可变。
    constant,
    /// 指针被标注为指向某个地址空间。
    pointer,
};

/// 返回此目标是否支持 `address_space`。若 `context` 为 `null`,
/// 此函数仅回答目标是否具备 `address_space` 概念
/// 这一一般问题;若非 `null`,则还会检查
/// `address_space` 在该上下文中是否有效。
pub fn supportsAddressSpace(
    target: Target,
    address_space: std.builtin.AddressSpace,
    context: ?AddressSpaceContext,
) bool {
    const arch = target.cpu.arch;

    const is_nvptx = arch.isNvptx();
    const is_spirv = arch.isSpirV();
    const is_gpu = is_nvptx or is_spirv or arch == .amdgcn;

    return switch (address_space) {
        .generic => true,
        .fs, .gs, .ss => (arch == .x86_64 or arch == .x86 or arch == .x86_16) and (context == null or context == .pointer),
        // 严格而言,x86 可以使用分段……
        .far => (arch == .x86_16),

        .flash, .flash1, .flash2, .flash3, .flash4, .flash5 => arch == .avr, // TODO: 此处还应检查 CPU 具有多少个闪存存储体
        .cog, .hub => arch == .propeller,
        .lut => arch == .propeller and std.Target.propeller.featureSetHas(target.cpu.features, .p2),

        .global, .local, .shared => is_gpu,
        .private => is_spirv,
        .constant => (is_gpu and (context == null or context == .constant)) or
            (is_spirv and (context == null or context == .constant or context == .pointer)),
        .param => is_nvptx,
        .input, .output, .uniform, .push_constant, .storage_buffer => is_spirv,
        .physical_storage_buffer => arch == .spirv64,
        .externref, .funcref => target.cpu.has(.wasm, .reference_types),
    };
}

pub const DynamicLinker = struct {
    /// 包含用于存储动态链接器路径的内存。
    /// 不应直接使用此字段,参见 `get` 和 `set`。
    /// 此字段使该 API 无需分配器。
    buffer: [255]u8,

    /// 用于构造动态链接器路径。不应直接使用此字段。
    /// 参见 `get` 和 `set`。
    len: u8,

    pub const none: DynamicLinker = .{ .buffer = undefined, .len = 0 };

    /// 断言长度不超过 255 字节。
    pub fn init(maybe_path: ?[]const u8) DynamicLinker {
        var dl: DynamicLinker = undefined;
        dl.set(maybe_path);
        return dl;
    }

    pub fn initFmt(comptime fmt_str: []const u8, args: anytype) !DynamicLinker {
        var dl: DynamicLinker = undefined;
        try dl.setFmt(fmt_str, args);
        return dl;
    }

    /// 返回内存的生命周期与 `DynamicLinker` 相同。
    pub fn get(dl: *const DynamicLinker) ?[]const u8 {
        return if (dl.len > 0) dl.buffer[0..dl.len] else null;
    }

    /// 断言长度不超过 255 字节。
    pub fn set(dl: *DynamicLinker, maybe_path: ?[]const u8) void {
        const path = maybe_path orelse "";
        @memcpy(dl.buffer[0..path.len], path);
        dl.len = @intCast(path.len);
    }

    /// 断言长度不超过 255 字节。
    pub fn setFmt(dl: *DynamicLinker, comptime fmt_str: []const u8, args: anytype) !void {
        dl.len = @intCast((try std.mem.print(&dl.buffer, fmt_str, args)).len);
    }

    pub fn eql(lhs: DynamicLinker, rhs: DynamicLinker) bool {
        return std.mem.eql(u8, lhs.buffer[0..lhs.len], rhs.buffer[0..rhs.len]);
    }

    pub const Kind = enum {
        /// 没有动态链接器。
        none,
        /// 动态链接器路径由架构及操作系统组成部分决定。
        arch_os,
        /// 动态链接器路径由架构、操作系统及 ABI 组成部分决定。
        arch_os_abi,
    };

    pub fn kind(os: Os.Tag) Kind {
        return switch (os) {
            .fuchsia,
            .managarm,

            .haiku,
            .illumos,
            .serenity,

            .dragonfly,
            .freebsd,
            .netbsd,
            .openbsd,

            .driverkit,
            .ios,
            .maccatalyst,
            .macos,
            .tvos,
            .visionos,
            .watchos,

            .ps4,
            .ps5,
            => .arch_os,

            .hurd,
            .linux,
            => .arch_os_abi,

            .freestanding,
            .other,

            .contiki,
            .hermit,

            .plan9,
            .rtems,

            .uefi,
            .windows,

            .@"3ds",
            .wiiu,
            .@"switch",
            .gba,

            .psx,
            .ps3,
            .psp,
            .vita,

            .emscripten,
            .wasi,

            .amdhsa,
            .amdpal,
            .cuda,
            .mesa3d,
            .nvcl,
            .opencl,
            .opengl,
            .vulkan,

            .tios,
            .ashetos,
            => .none,
        };
    }

    /// 此函数的严格程度由 `kind(os.tag)` 决定:
    ///
    /// * `.none`:忽略所有参数,仅返回 `none`。
    /// * `.arch_os`:忽略 `abi`,返回与 `cpu` 和 `os` 匹配的动态链接器。
    /// * `.arch_os_abi`:返回与 `cpu`、`os` 和 `abi` 匹配的动态链接器。
    ///
    /// 尤其在 `.arch_os` 情况下,调用方应注意:返回有效动态链接器,仅表示 `cpu` + `os` 组合对应一个实际存在的平台,且它具有不随 ABI 变化的既定动态链接器路径;并不一定表示 `abi` 对该平台有意义。此时,调用方负责判断 `abi` 是否有效。可使用 `Abi.default()` 为此类平台尽力选择默认 ABI。
    ///
    ///
    ///
    ///
    ///
    pub fn standard(cpu: Cpu, os: Os.Tag, abi: Abi) DynamicLinker {
        return switch (os) {
            .fuchsia => switch (cpu.arch) {
                .arm,
                .aarch64,
                .riscv64,
                .thumb,
                .x86_64,
                => init("ld.so.1"), // Fuchsia 的特殊之处在于 `DT_INTERP` 仅为基本文件名。
                else => none,
            },

            .managarm => switch (cpu.arch) {
                .aarch64 => init("/lib/aarch64-managarm-mlibc-ld.so"),
                .riscv64 => init("/lib/riscv64-managarm-mlibc-ld.so"),
                .x86_64 => init("/lib/x86_64-managarm-mlibc-ld.so"),
                else => none,
            },

            .haiku => switch (cpu.arch) {
                .arm,
                .aarch64,
                .riscv64,
                .x86,
                .x86_64,
                => init("/system/runtime_loader"),
                else => none,
            },

            .hurd => switch (cpu.arch) {
                .aarch64,
                .aarch64_be,
                => |arch| if (abi == .gnu) initFmt("/lib/ld-{s}.so.1", .{@tagName(arch)}) else none,

                .x86 => if (abi == .gnu) init("/lib/ld.so.1") else none,
                .x86_64 => initFmt("/lib/ld-{s}.so.1", .{switch (abi) {
                    .gnu => "x86-64",
                    .gnux32 => "x32",
                    else => return none,
                }}),

                else => none,
            },

            .illumos,
            => switch (cpu.arch) {
                .x86,
                .x86_64,
                => initFmt("/lib/{s}ld.so.1", .{if (ptrBitWidth_cpu_abi(cpu, .none) == 64) "64/" else ""}),
                else => none,
            },

            .linux => if (abi.isAndroid())
                switch (cpu.arch) {
                    .arm => if (abi == .androideabi) init("/system/bin/linker") else none,

                    .aarch64,
                    .riscv64,
                    .x86,
                    .x86_64,
                    => if (abi == .android) initFmt("/system/bin/linker{s}", .{
                        if (ptrBitWidth_cpu_abi(cpu, abi) == 64) "64" else "",
                    }) else none,

                    else => none,
                }
            else if (abi.isOpenHarmony())
                switch (cpu.arch) {
                    .aarch64,
                    .x86_64,
                    => |arch| if (abi == .ohos) initFmt("/lib/ld-musl-{s}.so.1", .{@tagName(arch)}) else none,

                    .arm => if (abi == .ohoseabi) init("/lib/ld-musl-arm.so.1") else none,

                    else => none,
                }
            else if (abi.isMusl())
                switch (cpu.arch) {
                    .arm,
                    .armeb,
                    .thumb,
                    .thumbeb,
                    => |arch| initFmt("/lib/ld-musl-arm{s}{s}.so.1", .{
                        if (arch == .armeb or arch == .thumbeb) "eb" else "",
                        switch (abi) {
                            .musleabi => "",
                            .musleabihf => "hf",
                            else => return none,
                        },
                    }),

                    .loongarch32,
                    .loongarch64,
                    => |arch| initFmt("/lib/ld-musl-{s}{s}.so.1", .{
                        @tagName(arch),
                        switch (abi) {
                            .musl => "",
                            .muslf32 => "-sp",
                            .muslsf => "-sf",
                            else => return none,
                        },
                    }),

                    .aarch64,
                    .aarch64_be,
                    .hexagon,
                    .kvx,
                    .m68k,
                    .microblaze,
                    .microblazeel,
                    .or1k,
                    .powerpc64,
                    .powerpc64le,
                    .s390x,
                    => |arch| if (abi == .musl) initFmt("/lib/ld-musl-{s}.so.1", .{@tagName(arch)}) else none,

                    .mips,
                    .mipsel,
                    => |arch| initFmt("/lib/ld-musl-mips{s}{s}{s}.so.1", .{
                        if (cpu.has(.mips, .mips32r6)) "r6" else "",
                        if (arch == .mipsel) "el" else "",
                        switch (abi) {
                            .musleabi => "-sf",
                            .musleabihf => "",
                            else => return none,
                        },
                    }),

                    .mips64,
                    .mips64el,
                    => |arch| initFmt("/lib/ld-musl-mips{s}{s}{s}.so.1", .{
                        switch (abi) {
                            .muslabi64 => "64",
                            .muslabin32 => "n32",
                            else => return none,
                        },
                        if (cpu.has(.mips, .mips64r6)) "r6" else "",
                        if (arch == .mips64el) "el" else "",
                    }),

                    .powerpc => initFmt("/lib/ld-musl-powerpc{s}.so.1", .{switch (abi) {
                        .musleabi => "-sf",
                        .musleabihf => "",
                        else => return none,
                    }}),

                    .sh,
                    .sheb,
                    => |arch| initFmt("/lib/ld-musl-{t}{s}.so.1", .{
                        arch,
                        switch (abi) {
                            .musleabi => "-nofpu",
                            .musleabihf => "",
                            else => return none,
                        },
                    }),

                    .riscv32,
                    .riscv64,
                    => |arch| if (abi == .musl) initFmt("/lib/ld-musl-{s}{s}.so.1", .{
                        @tagName(arch),
                        if (cpu.has(.riscv, .d))
                            ""
                        else if (cpu.has(.riscv, .f))
                            "-sp"
                        else
                            "-sf",
                    }) else none,

                    .x86 => if (abi == .musl) init("/lib/ld-musl-i386.so.1") else none,

                    .x86_64 => initFmt("/lib/ld-musl-{s}.so.1", .{switch (abi) {
                        .musl => "x86_64",
                        .muslx32 => "x32",
                        else => return none,
                    }}),

                    else => none,
                }
            else if (abi.isGnu())
                switch (cpu.arch) {
                    .arc,
                    .arceb,
                    => |arch| if (abi == .gnu) initFmt("/lib/ld-linux-{t}.so.2", .{arch}) else none,

                    .arm,
                    .armeb,
                    => initFmt("/lib/ld-linux{s}.so.3", .{switch (abi) {
                        .gnueabi => "",
                        .gnueabihf => "-armhf",
                        else => return none,
                    }}),

                    .aarch64,
                    .aarch64_be,
                    .or1k,
                    => |arch| if (abi == .gnu) initFmt("/lib/ld-linux-{s}.so.1", .{@tagName(arch)}) else none,

                    .csky => initFmt("/lib/ld-linux-cskyv2{s}.so.1", .{switch (abi) {
                        .gnueabi => "",
                        .gnueabihf => "-hf",
                        else => return none,
                    }}),

                    .loongarch32,
                    .loongarch64,
                    => |arch| initFmt("/lib{s}/ld-linux-{s}{s}.so.1", .{
                        switch (arch) {
                            .loongarch32 => "32",
                            .loongarch64 => "64",
                            else => unreachable,
                        },
                        switch (arch) {
                            .loongarch32 => "loongarch-ilp32",
                            .loongarch64 => "loongarch-lp64",
                            else => unreachable,
                        },
                        switch (abi) {
                            .gnu => "d",
                            .gnuf32 => "f",
                            .gnusf => "s",
                            else => return none,
                        },
                    }),

                    .m68k,
                    .microblaze,
                    .microblazeel,
                    .xtensa,
                    .xtensaeb,
                    => if (abi == .gnu) init("/lib/ld.so.1") else none,

                    .mips,
                    .mipsel,
                    => switch (abi) {
                        .gnueabi,
                        .gnueabihf,
                        => initFmt("/lib/ld{s}.so.1", .{
                            if (cpu.has(.mips, .nan2008)) "-linux-mipsn8" else "",
                        }),
                        else => none,
                    },

                    .mips64,
                    .mips64el,
                    => initFmt("/lib{s}/ld{s}.so.1", .{
                        switch (abi) {
                            .gnuabi64 => "64",
                            .gnuabin32 => "32",
                            else => return none,
                        },
                        if (cpu.has(.mips, .nan2008)) "-linux-mipsn8" else "",
                    }),

                    .hppa,
                    .powerpc,
                    => switch (abi) {
                        .gnueabi,
                        .gnueabihf,
                        => init("/lib/ld.so.1"),
                        else => none,
                    },

                    .powerpc64 => if (abi == .gnu) init("/lib64/ld64.so.1") else none,
                    .powerpc64le => if (abi == .gnu) init("/lib64/ld64.so.2") else none,

                    .riscv32,
                    .riscv64,
                    => |arch| if (abi == .gnu) initFmt("/lib/ld-linux-{s}{s}.so.1", .{
                        switch (arch) {
                            .riscv32 => "riscv32-ilp32",
                            .riscv64 => "riscv64-lp64",
                            else => unreachable,
                        },
                        if (cpu.has(.riscv, .d))
                            "d"
                        else if (cpu.has(.riscv, .f))
                            "f"
                        else
                            "",
                    }) else none,

                    .s390x => if (abi == .gnu) init("/lib/ld64.so.1") else none,

                    .sh,
                    .sheb,
                    => switch (abi) {
                        .gnueabi,
                        .gnueabihf,
                        => init("/lib/ld-linux.so.2"),
                        else => none,
                    },

                    .alpha,
                    .sparc,
                    .x86,
                    => if (abi == .gnu) init("/lib/ld-linux.so.2") else none,

                    .sparc64 => if (abi == .gnu) init("/lib64/ld-linux.so.2") else none,

                    .x86_64 => switch (abi) {
                        .gnu => init("/lib64/ld-linux-x86-64.so.2"),
                        .gnux32 => init("/libx32/ld-linux-x32.so.2"),
                        else => none,
                    },

                    else => none,
                }
            else
                none, // 不是已知的 Linux libc。

            .serenity => switch (cpu.arch) {
                .aarch64,
                .riscv64,
                .x86_64,
                => init("/usr/lib/Loader.so"),
                else => none,
            },

            .dragonfly => if (cpu.arch == .x86_64) init("/libexec/ld-elf.so.2") else none,

            .freebsd => switch (cpu.arch) {
                .arm,
                .aarch64,
                .powerpc,
                .powerpc64,
                .powerpc64le,
                .riscv64,
                .x86,
                .x86_64,
                => init("/libexec/ld-elf.so.1"),
                else => none,
            },

            .netbsd => switch (cpu.arch) {
                .alpha,
                .arm,
                .armeb,
                .aarch64,
                .aarch64_be,
                .hppa,
                .m68k,
                .mips,
                .mipsel,
                .mips64,
                .mips64el,
                .powerpc,
                .riscv32,
                .riscv64,
                .sh,
                .sheb,
                .sparc,
                .sparc64,
                .x86,
                .x86_64,
                => init("/libexec/ld.elf_so"),
                else => none,
            },

            .openbsd => switch (cpu.arch) {
                .alpha,
                .arm,
                .aarch64,
                .hppa,
                .m88k,
                .mips64,
                .mips64el,
                .powerpc,
                .powerpc64,
                .riscv64,
                .sh,
                .sparc64,
                .x86,
                .x86_64,
                => init("/usr/libexec/ld.so"),
                else => none,
            },

            .driverkit,
            .ios,
            .maccatalyst,
            .macos,
            .tvos,
            .visionos,
            .watchos,
            => switch (cpu.arch) {
                .aarch64,
                .x86_64,
                => init("/usr/lib/dyld"),
                else => none,
            },

            .ps4,
            .ps5,
            => if (cpu.arch == .x86_64) init("/libexec/ld-elf.so.1") else none,

            .freestanding,
            .other,

            .contiki,
            .hermit,

            .plan9,
            .rtems,

            .uefi,
            .windows,

            .@"3ds",
            .wiiu,
            .@"switch",
            .gba,

            .psx,
            .ps3,
            .psp,
            .vita,

            .emscripten,
            .wasi,

            .amdhsa,
            .amdpal,
            .cuda,
            .mesa3d,
            .nvcl,
            .opencl,
            .opengl,
            .vulkan,

            .tios,
            .ashetos,
            => none,
        } catch unreachable;
    }
};

pub fn standardDynamicLinkerPath(target: *const Target) DynamicLinker {
    return DynamicLinker.standard(target.cpu, target.os.tag, target.abi);
}

pub fn ptrBitWidth_cpu_abi(cpu: Cpu, abi: Abi) u16 {
    return ptrBitWidth_arch_abi(cpu.arch, abi);
}

pub fn ptrBitWidth_arch_abi(cpu_arch: Cpu.Arch, abi: Abi) u16 {
    switch (abi) {
        .gnux32,
        .muslx32,
        .x32,
        .gnuabin32,
        .muslabin32,
        .abin32,
        .ilp32,
        => return 32,
        else => {},
    }

    return switch (cpu_arch) {
        .avr,
        .msp430,
        .x86_16,
        .spork8,
        => 16,

        .ez80,
        => 24,

        .arc,
        .arceb,
        .arm,
        .armeb,
        .csky,
        .hexagon,
        .hppa,
        .kalimba,
        .lanai,
        .loongarch32,
        .m68k,
        .m88k,
        .microblaze,
        .microblazeel,
        .mips,
        .mipsel,
        .nvptx,
        .or1k,
        .powerpc,
        .powerpcle,
        .propeller,
        .riscv32,
        .riscv32be,
        .sh,
        .sheb,
        .sparc,
        .spirv32,
        .thumb,
        .thumbeb,
        .wasm32,
        .x86,
        .xcore,
        .xtensa,
        .xtensaeb,
        => 32,

        .aarch64,
        .aarch64_be,
        .alpha,
        .amdgcn,
        .bpfeb,
        .bpfel,
        .hppa64,
        .kvx,
        .loongarch64,
        .mips64,
        .mips64el,
        .nvptx64,
        .powerpc64,
        .powerpc64le,
        .riscv64,
        .riscv64be,
        .s390x,
        .sparc64,
        .spirv64,
        .ve,
        .wasm64,
        .x86_64,
        => 64,
    };
}

pub fn ptrBitWidth(target: *const Target) u16 {
    return ptrBitWidth_cpu_abi(target.cpu, target.abi);
}

pub fn stackAlignment(target: *const Target) u16 {
    // 栈对齐不等于指针位宽时使用的覆盖设置。
    switch (target.cpu.arch) {
        .avr,
        .ez80,
        => return 1,

        .m68k => if (target.os.tag != .netbsd) return 2,

        .amdgcn => return 4,

        .arm,
        .armeb,
        .hexagon,
        .hppa,
        .lanai,
        .mips,
        .mipsel,
        .sparc,
        .thumb,
        .thumbeb,
        => return 8,

        .aarch64,
        .aarch64_be,
        .alpha,
        .bpfeb,
        .bpfel,
        .hppa64,
        .loongarch32,
        .loongarch64,
        .m88k,
        .mips64,
        .mips64el,
        .powerpc,
        .powerpcle,
        .powerpc64,
        .powerpc64le,
        .sparc64,
        .ve,
        .wasm32,
        .wasm64,
        .x86_64,
        .xtensa,
        .xtensaeb,
        => return 16,

        .riscv32,
        .riscv32be,
        .riscv64,
        .riscv64be,
        => if (!target.cpu.has(.riscv, .e)) return 16,

        .x86 => switch (target.os.tag) {
            .hurd,
            .linux,
            => return 16,
            else => {},
        },

        .kvx => return 32,

        .spork8 => return 256,

        else => {},
    }

    return @divExact(target.ptrBitWidth(), 8);
}

pub const StackGrowth = enum {
    down,
    up,
};

pub fn stackGrowth(target: *const Target) StackGrowth {
    // 严格来说,多数架构本身并不定义栈增长方向;
    // 完全可以认为这是 ABI 的属性。但现实中
    // 并非如此。此外,我们也没有指示不同
    // 栈增长 ABI 的机制,也无迫切用例需要创建这样的机制。
    return switch (target.cpu.arch) {
        .hppa,
        .hppa64,
        .spork8,
        => .up,
        else => .down,
    };
}

/// 此目标的本机 C 编译器中,`char` 默认是否有符号。
/// 注意,char 的符号属性由实现定义,且许多编译器提供
/// 覆盖默认符号属性的选项,例如 GCC 的 -funsigned-char / -fsigned-char。
/// 如果未为此目标定义 C ABI,则返回 `null`。
pub fn cCharSignedness(target: *const Target) ?std.builtin.Signedness {
    return switch (target.os.tag) {
        .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => .signed,
        .windows, .uefi => .signed,
        .ps3, .vita => .signed,
        .opengl => null,
        else => switch (target.cpu.arch) {
            .aarch64,
            .aarch64_be,
            .arm,
            .armeb,
            .arc,
            .arceb,
            .csky,
            .ez80,
            .hexagon,
            .msp430,
            .powerpc,
            .powerpcle,
            .powerpc64,
            .powerpc64le,
            .propeller,
            .s390x,
            .riscv32,
            .riscv32be,
            .riscv64,
            .riscv64be,
            .thumb,
            .thumbeb,
            .xcore,
            .xtensa,
            .xtensaeb,
            => .unsigned,
            else => .signed,
        },
    };
}

pub const CType = enum {
    char,
    short,
    ushort,
    int,
    uint,
    long,
    ulong,
    longlong,
    ulonglong,
    float,
    double,
    longdouble,
};

/// 若此目标未定义 C ABI,则返回 `null`。
pub fn cTypeByteSize(t: *const Target, c_type: CType) ?u16 {
    return switch (c_type) {
        .char,
        .short,
        .ushort,
        .int,
        .uint,
        .long,
        .ulong,
        .longlong,
        .ulonglong,
        .float,
        .double,
        => @divExact(cTypeBitSize(t, c_type) orelse return null, 8),

        .longdouble => switch (cTypeBitSize(t, c_type) orelse return null) {
            32 => 4,
            64 => 8,
            80 => @intCast(std.mem.alignForward(usize, 10, cTypeAlignment(t, c_type).?)),
            128 => 16,
            else => unreachable,
        },
    };
}

/// 若此目标未定义 C ABI,则返回 `null`。
pub fn cTypeBitSize(target: *const Target, c_type: CType) ?u16 {
    return switch (target.os.tag) {
        .freestanding,
        .other,
        .ashetos,
        .tios,
        => switch (target.cpu.arch) {
            .msp430,
            .x86_16,
            => switch (c_type) {
                .char => 8,
                .short, .ushort, .int, .uint => 16,
                .float, .long, .ulong => 32,
                .longlong, .ulonglong, .double, .longdouble => 64,
            },
            .avr => switch (c_type) {
                .char => 8,
                .short, .ushort, .int, .uint => 16,
                .long, .ulong, .float, .double, .longdouble => 32,
                .longlong, .ulonglong => 64,
            },
            // https://github.com/benanderman/spork-8/blob/main/Programming.md
            .spork8 => switch (c_type) {
                .char => 8,
                .short, .ushort, .int, .uint => 16,
                .long, .ulong, .float => 32,
                .double, .longdouble, .longlong, .ulonglong => 64,
            },
            .ez80 => switch (c_type) {
                .char => 8,
                .short, .ushort => 16,
                .int, .uint => 24,
                .long, .ulong, .float, .double => 32,
                .longlong, .ulonglong, .longdouble => 64,
            },
            else => switch (c_type) {
                .char => 8,
                .short, .ushort => 16,
                .int, .uint, .float => 32,
                .long, .ulong => target.ptrBitWidth(),
                .longlong, .ulonglong, .double => 64,
                .longdouble => switch (target.cpu.arch) {
                    else => 64,

                    .x86,
                    .x86_64,
                    => 80,

                    .alpha,
                    .riscv32,
                    .riscv32be,
                    .riscv64,
                    .riscv64be,
                    .aarch64,
                    .aarch64_be,
                    .mips64,
                    .mips64el,
                    .powerpc,
                    .powerpcle,
                    .powerpc64,
                    .powerpc64le,
                    .s390x,
                    .sparc,
                    .sparc64,
                    .wasm32,
                    .wasm64,
                    .loongarch32,
                    .loongarch64,
                    .ve,
                    => 128,
                },
            },
        },

        .fuchsia,
        .hermit,
        .managarm,

        .haiku,
        .hurd,
        .illumos,
        .linux,
        .plan9,
        .rtems,
        .serenity,

        .freebsd,
        .dragonfly,
        .netbsd,
        .openbsd,

        .wasi,
        .emscripten,
        => switch (c_type) {
            .char => 8,
            .short, .ushort => 16,
            .int, .uint, .float => 32,
            .long, .ulong => switch (target.os.tag) {
                .plan9 => 32, // 这确实是一种取舍。
                else => target.ptrBitWidth(),
            },
            .longlong, .ulonglong, .double => 64,
            .longdouble => switch (target.cpu.arch) {
                .x86,
                .x86_64,
                => switch (target.abi) {
                    .android, .ohos => 64,
                    else => 80,
                },

                .powerpc,
                .powerpcle,
                => switch (target.abi) {
                    .musleabi, .musleabihf => 64,
                    else => switch (target.os.tag) {
                        .netbsd,
                        .openbsd,
                        => 64,
                        else => 128,
                    },
                },

                .powerpc64,
                .powerpc64le,
                => switch (target.abi) {
                    .musl => 64,
                    else => switch (target.os.tag) {
                        .freebsd,
                        .openbsd,
                        => 64,
                        else => 128,
                    },
                },

                .alpha => switch (target.os.tag) {
                    .netbsd,
                    .openbsd,
                    => 64,
                    else => 128,
                },

                .riscv32,
                .riscv32be,
                .riscv64,
                .riscv64be,
                .aarch64,
                .aarch64_be,
                .s390x,
                .mips64,
                .mips64el,
                .sparc,
                .sparc64,
                .wasm32,
                .wasm64,
                .loongarch32,
                .loongarch64,
                .ve,
                => 128,

                else => 64,
            },
        },

        .windows, .uefi => switch (target.cpu.arch) {
            .x86 => switch (c_type) {
                .char => 8,
                .short, .ushort => 16,
                .int, .uint, .float => 32,
                .long, .ulong => 32,
                .longlong, .ulonglong, .double => 64,
                .longdouble => switch (target.abi) {
                    .gnu => 80,
                    else => 64,
                },
            },
            .x86_64 => switch (c_type) {
                .char => 8,
                .short, .ushort => 16,
                .int, .uint, .float => 32,
                .long, .ulong => 32,
                .longlong, .ulonglong, .double => 64,
                .longdouble => switch (target.abi) {
                    .gnu => 80,
                    else => 64,
                },
            },
            else => switch (c_type) {
                .char => 8,
                .short, .ushort => 16,
                .int, .uint, .float => 32,
                .long, .ulong => 32,
                .longlong, .ulonglong, .double => 64,
                .longdouble => 64,
            },
        },

        .driverkit,
        .ios,
        .maccatalyst,
        .macos,
        .tvos,
        .visionos,
        .watchos,
        => switch (c_type) {
            .char => 8,
            .short, .ushort => 16,
            .int, .uint, .float => 32,
            .long, .ulong => switch (target.cpu.arch) {
                .x86_64 => 64,
                else => switch (target.abi) {
                    .ilp32 => 32,
                    else => 64,
                },
            },
            .longlong, .ulonglong, .double => 64,
            .longdouble => switch (target.cpu.arch) {
                .x86_64 => 80,
                else => 64,
            },
        },

        .cuda, .amdhsa, .amdpal, .mesa3d, .nvcl, .opencl, .vulkan => switch (c_type) {
            .char => 8,
            .short, .ushort => 16,
            .int, .uint, .float => 32,
            .long, .ulong => target.ptrBitWidth(),
            .longlong, .ulonglong, .double, .longdouble => 64,
        },

        .gba, .@"3ds", .wiiu => switch (c_type) {
            .char => 8,
            .short, .ushort => 16,
            .int, .uint, .float, .long, .ulong => 32,
            .longlong, .ulonglong, .double, .longdouble => 64,
        },
        .@"switch" => switch (c_type) {
            .char => 8,
            .short, .ushort => 16,
            .int, .uint, .float => 32,
            .long, .ulong, .longlong, .ulonglong, .double => 64,
            .longdouble => 128,
        },

        .psx, .ps3, .psp, .vita => switch (c_type) {
            .char => 8,
            .short, .ushort => 16,
            .int, .uint, .long, .ulong, .float => 32,
            .longlong, .ulonglong, .double, .longdouble => 64,
        },
        .ps4, .ps5 => switch (c_type) {
            .char => 8,
            .short, .ushort => 16,
            .int, .uint, .float => 32,
            .long, .ulong, .longlong, .ulonglong, .double => 64,
            .longdouble => 80,
        },

        .opengl => null,

        .contiki,
        => @panic("specify the C integer and float type sizes for this OS"),
    };
}

/// 若此目标未定义 C ABI,则返回 `null`。
pub fn cTypeAlignment(target: *const Target, c_type: CType) ?u16 {
    // 特殊对齐要求的覆盖配置
    switch (target.cpu.arch) {
        .avr,
        .ez80,
        .spork8,
        => return 1,
        .x86 => switch (target.os.tag) {
            .windows, .uefi => switch (c_type) {
                .longlong, .ulonglong, .double => return 8,
                .longdouble => switch (target.abi) {
                    .gnu => return 4,
                    else => return 8,
                },
                else => {},
            },
            else => {},
        },
        .m68k => switch (c_type) {
            .int, .uint, .long, .ulong => return 2,
            else => {},
        },
        .wasm32, .wasm64 => switch (target.os.tag) {
            .emscripten => switch (c_type) {
                .longdouble => return 8,
                else => {},
            },
            else => {},
        },
        else => {},
    }

    // 对齐到下一个二的幂,但不超过最大值。
    return @min(
        std.math.ceilPowerOfTwoAssert(u16, ((cTypeBitSize(target, c_type) orelse return null) + 7) / 8),
        @as(u16, switch (target.cpu.arch) {
            .msp430,
            .x86_16,
            => 2,

            .arc,
            .arceb,
            .csky,
            .kalimba,
            .microblaze,
            .microblazeel,
            .or1k,
            .propeller,
            .sh,
            .sheb,
            .x86,
            .xcore,
            => 4,

            .amdgcn,
            .arm,
            .armeb,
            .bpfeb,
            .bpfel,
            .hexagon,
            .hppa,
            .lanai,
            .m68k,
            .m88k,
            .mips,
            .mipsel,
            .nvptx,
            .nvptx64,
            .s390x,
            .sparc,
            .thumb,
            .thumbeb,
            .xtensa,
            .xtensaeb,
            => 8,

            .aarch64,
            .aarch64_be,
            .alpha,
            .hppa64,
            .kvx,
            .loongarch32,
            .loongarch64,
            .mips64,
            .mips64el,
            .powerpc,
            .powerpcle,
            .powerpc64,
            .powerpc64le,
            .riscv32,
            .riscv32be,
            .riscv64,
            .riscv64be,
            .sparc64,
            .spirv32,
            .spirv64,
            .ve,
            .wasm32,
            .wasm64,
            .x86_64,
            => 16,

            .avr,
            .ez80,
            .spork8,
            => unreachable, // 已在上方处理。
        }),
    );
}

pub fn cMaxIntAlignment(target: *const Target) u16 {
    return switch (target.cpu.arch) {
        .avr,
        .ez80,
        .spork8,
        => 1,

        .msp430,
        .x86_16,
        => 2,

        .arc,
        .arceb,
        .csky,
        .kalimba,
        .microblaze,
        .microblazeel,
        .or1k,
        .propeller,
        .sh,
        .sheb,
        .xcore,
        => 4,

        .x86 => switch (target.os.tag) {
            else => 4,
            .uefi, .windows => 8,
        },

        .arm,
        .armeb,
        .hexagon,
        .hppa,
        .lanai,
        .loongarch32,
        .m68k,
        .m88k,
        .mips,
        .mipsel,
        .powerpc,
        .powerpcle,
        .riscv32,
        .riscv32be,
        .s390x,
        .sparc,
        .thumb,
        .thumbeb,
        .xtensa,
        .xtensaeb,
        => 8,

        .aarch64,
        .aarch64_be,
        .alpha,
        .amdgcn,
        .bpfel,
        .bpfeb,
        .hppa64,
        .kvx,
        .loongarch64,
        .mips64,
        .mips64el,
        .nvptx,
        .nvptx64,
        .powerpc64,
        .powerpc64le,
        .riscv64,
        .riscv64be,
        .sparc64,
        .spirv32,
        .spirv64,
        .ve,
        .wasm32,
        .wasm64,
        .x86_64,
        => 16,
    };
}

pub fn cCallingConvention(target: *const Target) ?std.builtin.CallingConvention {
    return switch (target.cpu.arch) {
        .x86_64 => switch (target.os.tag) {
            .windows, .uefi => .{ .x86_64_win = .{} },
            else => switch (target.abi) {
                .gnux32, .muslx32, .x32 => .{ .x86_64_x32 = .{} },
                else => .{ .x86_64_sysv = .{} },
            },
        },
        .x86 => switch (target.os.tag) {
            .windows, .uefi => if (target.isMinGW()) .{ .x86_mingw = .{} } else .{ .x86_win = .{} },
            else => .{ .x86_sysv = .{} },
        },
        .x86_16 => .{ .x86_16_cdecl = .{} },
        .aarch64, .aarch64_be => if (target.os.tag.isDarwin())
            .{ .aarch64_aapcs_darwin = .{} }
        else switch (target.os.tag) {
            .windows => .{ .aarch64_aapcs_win = .{} },
            else => .{ .aarch64_aapcs = .{} },
        },
        .alpha => .{ .alpha_osf = .{} },
        .arm, .armeb, .thumb, .thumbeb => switch (target.abi.float()) {
            .soft => .{ .arm_aapcs = .{} },
            .hard => .{ .arm_aapcs_vfp = .{} },
        },
        .mips64, .mips64el => switch (target.abi) {
            .gnuabin32, .muslabin32, .abin32 => .{ .mips64_n32 = .{} },
            else => .{ .mips64_n64 = .{} },
        },
        .mips, .mipsel => .{ .mips_o32 = .{} },
        .riscv64, .riscv64be => .{ .riscv64_lp64 = .{} },
        .riscv32, .riscv32be => .{ .riscv32_ilp32 = .{} },
        .sparc64 => .{ .sparc64_sysv = .{} },
        .sparc => .{ .sparc_sysv = .{} },
        .powerpc64 => if (target.os.tag == .ps3 or target.abi.isGnu())
            .{ .powerpc64_elf = .{} }
        else
            .{ .powerpc64_elf_v2 = .{} },
        .powerpc64le => .{ .powerpc64_elf_v2 = .{} },
        .powerpc, .powerpcle => .{ .powerpc_sysv = .{} },
        .wasm32, .wasm64 => .{ .wasm_mvp = .{} },
        .arc, .arceb => .{ .arc_sysv = .{} },
        .avr => .avr_gnu,
        .bpfel, .bpfeb => .{ .bpf_std = .{} },
        .csky => .{ .csky_sysv = .{} },
        .hexagon => .{ .hexagon_sysv = .{} },
        .hppa => .{ .hppa_elf = .{} },
        .hppa64 => .{ .hppa64_elf = .{} },
        .kalimba => null,
        .kvx => switch (target.abi) {
            .ilp32 => .{ .kvx_ilp32 = .{} },
            else => .{ .kvx_lp64 = .{} },
        },
        .lanai => .{ .lanai_sysv = .{} },
        .loongarch64 => .{ .loongarch64_lp64 = .{} },
        .loongarch32 => .{ .loongarch32_ilp32 = .{} },
        .m68k => switch (target.os.tag) {
            .netbsd => .{ .m68k_sysv = .{} },
            else => .{ .m68k_gnu = .{} },
        },
        .m88k => .{ .m88k_sysv = .{} },
        .microblaze, .microblazeel => .{ .microblaze_std = .{} },
        .msp430 => .{ .msp430_eabi = .{} },
        .or1k => .{ .or1k_sysv = .{} },
        .propeller => .{ .propeller_sysv = .{} },
        .s390x => .{ .s390x_sysv = .{} },
        .sh, .sheb => .{ .sh_gnu = .{} },
        .ve => .{ .ve_sysv = .{} },
        .xcore => .{ .xcore_xs1 = .{} },
        .xtensa, .xtensaeb => switch (target.abi) {
            .call0 => .{ .xtensa_call0 = .{} },
            else => .{ .xtensa_windowed = .{} },
        },
        .amdgcn => .{ .amdgcn_device = .{} },
        .nvptx, .nvptx64 => .nvptx_device,
        .spirv32, .spirv64 => .spirv_device,
        .ez80 => .ez80_cet,
        .spork8 => .spork8,
    };
}

const Target = @This();
const std = @import("std.zig");
const builtin = @import("builtin");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;

test {
    std.testing.refAllDecls(Cpu.Arch);
}