执行代码的机器的全部详细信息。
与可能将部分项保留为“default”或“host”的 Query 不同,
此数据已完全解析为具体的操作系统版本、处理器特性
等。
字段
QueryOsaarch64alphaamdgcnarcarmavrbpfcskyhexagonhppakalimbakvxlanailoongarchm68km88kmicroblazemipsmsp430nvptxor1kpowerpcpropellerriscvs390xshsparcspirvspork8vewasmx86xcorextensaz80AbiObjectFormattoElfMachinetoCoffMachineCpuzigTriplehurdTupleSimplehurdTuplelinuxTripleSimplelinuxTripleexeFileExtstaticLibSuffixdynamicLibSuffixlibPrefixisMinGWisGnuLibCisMuslLibCisBionicLibCisDarwinLibCisFreeBSDLibCisNetBSDLibCisOpenBSDLibCisWasiLibCrequiresLibCAddressSpaceContextsupportsAddressSpaceDynamicLinkerstandardDynamicLinkerPathptrBitWidth_cpu_abiptrBitWidth_arch_abiptrBitWidthstackAlignmentStackGrowthstackGrowthcCharSignednessCTypecTypeByteSizecTypeBitSizecTypeAlignmentcMaxIntAlignmentcCallingConventionTargetstdbuiltinAllocatorassert
std.Target.aarch64
别名
别名目标 std.Target.aarch64
std.Target.Abi
容器
字段
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
函数
pub fn default(arch: Cpu.Arch, os_tag: Os.Tag) Abi
参数
std.Target.Abi.float
函数
pub inline fn float(abi: Abi) Float
参数
abi: Abi
std.Target.Abi.Float
容器
字段
hard
soft
std.Target.Abi.isAndroid
函数
pub inline fn isAndroid(abi: Abi) bool
参数
abi: Abi
std.Target.Abi.isGnu
函数
pub inline fn isGnu(abi: Abi) bool
参数
abi: Abi
std.Target.Abi.isMusl
函数
pub inline fn isMusl(abi: Abi) bool
参数
abi: Abi
std.Target.Abi.isOpenHarmony
函数
pub inline fn isOpenHarmony(abi: Abi) bool
参数
abi: Abi
std.Target.AddressSpaceContext
容器
用户可以指定地址空间属性的位置
字段
function指定将函数置于特定地址空间。
variable指定将某个(全局)变量放入特定地址空间。
与 .constant 不同,这些值(因此也包括放置它们的地址空间)
必须可变。
constant指定将某个(全局)常量值放入特定地址空间。
与 .variable 不同,放入此地址空间的值不要求可变。
pointer指针被标注为指向某个地址空间。
std.Target.Allocator
别名
别名目标 std.mem.Allocator
std.Target.alpha
别名
别名目标 std.Target.alpha
std.Target.amdgcn
别名
别名目标 std.Target.amdgcn
std.Target.arc
别名
别名目标 std.Target.arc
std.Target.arm
别名
别名目标 std.Target.arm
std.Target.assert
别名
别名目标 std.debug.assert
std.Target.avr
别名
别名目标 std.Target.avr
std.Target.bpf
别名
别名目标 std.Target.bpf
std.Target.builtin
常量
std.Target.cCallingConvention
函数
pub fn cCallingConvention(target: *const Target) ?std.builtin.CallingConvention
参数
target: *const Target
std.Target.cCharSignedness
函数
此目标的本机 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
函数
pub fn cMaxIntAlignment(target: *const Target) u16
参数
target: *const Target
std.Target.Cpu
容器
字段
std.Target.Cpu.Arch
容器
字段
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
FamilyfamilyisX86isArmisThumbisAARCH64isAarch64isArcisHppaisWasmisLoongArchisLoongarchisRISCVisRiscvisRiscv32isRiscv64isMicroblazeisMIPSisMipsisMIPS32isMips32isMIPS64isMips64isPowerPCisPowerpcisPowerPC32isPowerpc32isPowerPC64isPowerpc64isSPARCisSparcisSpirVisSpirvisShisBpfisNvptxisXtensaparseCpuModelendianallFeaturesListallCpuModelsallCpusFromDeclsplan9ExtfromCallingConvention
std.Target.Cpu.Arch.allCpuModels
函数
Zig 已知的所有处理器,按名称字典序排列。
pub fn allCpuModels(arch: Arch) []const *const Cpu.Model
参数
arch: Arch
std.Target.Cpu.Arch.allCpusFromDecls
函数
fn allCpusFromDecls(comptime cpus: type) []const *const Cpu.Model
参数
cpus: type
std.Target.Cpu.Arch.allFeaturesList
函数
Zig 已知的所有 CPU 特性,按名称字典序排列。
pub fn allFeaturesList(arch: Arch) []const Cpu.Feature
参数
arch: Arch
std.Target.Cpu.Arch.endian
函数
pub fn endian(arch: Arch) std.builtin.Endian
参数
arch: Arch
std.Target.Cpu.Arch.family
函数
pub inline fn family(arch: Arch) Family
参数
arch: Arch
std.Target.Cpu.Arch.Family
容器
一个架构族可涵盖多个由 Arch 表示的架构。
对于给定架构族标签,保证存在 std.Target.<tag> 命名空间,
其中包含 CPU 型号和特性数据。
字段
std.Target.Cpu.Arch.fromCallingConvention
函数
返回特定 std.builtin.CallingConvention 适用的 Arch 数组。
断言 cc 不是 .auto、.@"async"、.naked 或 .@"inline"。
pub fn fromCallingConvention(cc: std.builtin.CallingConvention.Tag) []const Arch
参数
std.Target.Cpu.Arch.isAarch64
函数
pub inline fn isAarch64(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isAARCH64
别名
已弃用;将在 0.18.0 中移除。请改用 isAarch64。
std.Target.Cpu.Arch.isArc
函数
pub inline fn isArc(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isArm
函数
注意,此处包含 Thumb。
pub inline fn isArm(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isBpf
函数
pub inline fn isBpf(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isHppa
函数
pub inline fn isHppa(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isLoongarch
函数
pub inline fn isLoongarch(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isLoongArch
别名
已弃用;将在 0.18.0 中移除。请改用 isLoongarch。
std.Target.Cpu.Arch.isMicroblaze
函数
pub inline fn isMicroblaze(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isMips
函数
pub inline fn isMips(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isMIPS
别名
已弃用;将在 0.18.0 中移除。请改用 isMips。
std.Target.Cpu.Arch.isMips32
函数
pub inline fn isMips32(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isMIPS32
别名
已弃用;将在 0.18.0 中移除。请改用 isMips32。
std.Target.Cpu.Arch.isMips64
函数
pub inline fn isMips64(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isMIPS64
别名
已弃用;将在 0.18.0 中移除。请改用 isMips64。
std.Target.Cpu.Arch.isNvptx
函数
pub inline fn isNvptx(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isPowerpc
函数
pub inline fn isPowerpc(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isPowerPC
别名
已弃用;将在 0.18.0 中移除。请改用 isPowerpc。
std.Target.Cpu.Arch.isPowerpc32
函数
pub inline fn isPowerpc32(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isPowerPC32
别名
已弃用;将在 0.18.0 中移除。请改用 isPowerpc32。
std.Target.Cpu.Arch.isPowerpc64
函数
pub inline fn isPowerpc64(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isPowerPC64
别名
已弃用;将在 0.18.0 中移除。请改用 isPowerpc64。
std.Target.Cpu.Arch.isRiscv
函数
pub inline fn isRiscv(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isRISCV
别名
已弃用;将在 0.18.0 中移除。请改用 isRiscv。
std.Target.Cpu.Arch.isRiscv32
函数
pub inline fn isRiscv32(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isRiscv64
函数
pub inline fn isRiscv64(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isSh
函数
pub inline fn isSh(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isSparc
函数
pub inline fn isSparc(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isSPARC
别名
已弃用;将在 0.18.0 中移除。请改用 isSparc。
std.Target.Cpu.Arch.isSpirv
函数
pub inline fn isSpirv(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isSpirV
别名
已弃用;将在 0.18.0 中移除。请改用 isSpirv。
std.Target.Cpu.Arch.isThumb
函数
pub inline fn isThumb(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isWasm
函数
pub inline fn isWasm(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isX86
函数
pub inline fn isX86(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.isXtensa
函数
pub inline fn isXtensa(arch: Arch) bool
参数
arch: Arch
std.Target.Cpu.Arch.parseCpuModel
函数
pub fn parseCpuModel(arch: Arch, cpu_name: []const u8) ?*const Cpu.Model
参数
arch: Arch
cpu_name: []const u8
std.Target.Cpu.Arch.plan9Ext
函数
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
参数
std.Target.Cpu.baseline
函数
交叉编译的“默认”CPU 特性集。这是一组保守特性,预期绝大多数可用硬件都支持。
pub fn baseline(arch: Arch, os: Os) Cpu
参数
std.Target.Cpu.Feature
容器
字段
std.Target.Cpu.Feature.FeatureSetFns
类型函数
pub fn FeatureSetFns(comptime F: type) type
参数
F: type
std.Target.Cpu.Feature.FeatureSetFns.featureSet
函数
只填充指定的特性位。
pub fn featureSet(features: []const F) Set
参数
features: []const F
std.Target.Cpu.Feature.FeatureSetFns.featureSetHas
函数
若指定特性已启用,则返回 true。
pub fn featureSetHas(set: Set, feature: F) bool
参数
set: Set
feature: F
std.Target.Cpu.Feature.FeatureSetFns.featureSetHasAll
函数
若所有指定特性均已启用,则返回 true。
pub fn featureSetHasAll(set: Set, features: anytype) bool
参数
set: Set
std.Target.Cpu.Feature.FeatureSetFns.featureSetHasAny
函数
如果任意指定特性已启用,则返回 true。
pub fn featureSetHasAny(set: Set, features: anytype) bool
参数
set: Set
std.Target.Cpu.Feature.Set
容器
包含全部功能的位集合。
字段
ints: [usize_count]usize
std.Target.Cpu.Feature.Set.addFeature
函数
添加指定特性,但不添加其依赖。
pub fn addFeature(set: *Set, arch_feature_index: Index) void
参数
std.Target.Cpu.Feature.Set.addFeatureSet
函数
添加指定特性集,但不添加其依赖。
pub fn addFeatureSet(set: *Set, other_set: Set) void
参数
std.Target.Cpu.Feature.Set.asBytes
函数
pub fn asBytes(set: *const Set) *const [byte_count]u8
参数
set: *const Set
std.Target.Cpu.Feature.Set.byte_count
常量
std.Target.Cpu.Feature.Set.count
函数
pub fn count(set: Set) std.math.IntFittingRange(0, needed_bit_count)
参数
set: Set
std.Target.Cpu.Feature.Set.empty
常量
Set
std.Target.Cpu.Feature.Set.eql
函数
pub fn eql(set: Set, other_set: Set) bool
参数
std.Target.Cpu.Feature.Set.Index
类型
std.Target.Cpu.Feature.Set.isEmpty
函数
pub fn isEmpty(set: Set) bool
参数
set: Set
std.Target.Cpu.Feature.Set.isEnabled
函数
pub fn isEnabled(set: Set, arch_feature_index: Index) bool
参数
std.Target.Cpu.Feature.Set.isSuperSetOf
函数
pub fn isSuperSetOf(set: Set, other_set: Set) bool
参数
std.Target.Cpu.Feature.Set.needed_bit_count
常量
std.Target.Cpu.Feature.Set.populateDependencies
函数
pub fn populateDependencies(set: *Set, all_features_list: []const Cpu.Feature) void
参数
std.Target.Cpu.Feature.Set.removeFeature
函数
移除指定特性,但不移除依赖它的特性。
pub fn removeFeature(set: *Set, arch_feature_index: Index) void
参数
std.Target.Cpu.Feature.Set.removeFeatureSet
函数
移除指定特性,但不移除依赖它的特性。
pub fn removeFeatureSet(set: *Set, other_set: Set) void
参数
std.Target.Cpu.Feature.Set.ShiftInt
类型
std.Target.Cpu.Feature.Set.usize_count
常量
std.Target.Cpu.has
函数
若 feature 已启用,则返回 true。
pub fn has(cpu: Cpu, comptime family: Arch.Family, feature: @field(Target, @tagName(family)).Feature) bool
参数
std.Target.Cpu.hasAll
函数
若 features 中的所有特性均已启用,则返回 true。
pub fn hasAll(cpu: Cpu, comptime family: Arch.Family, features: []const @field(Target, @tagName(family)).Feature) bool
参数
std.Target.Cpu.hasAny
函数
若 features 中任一特性已启用,则返回 true。
pub fn hasAny(cpu: Cpu, comptime family: Arch.Family, features: []const @field(Target, @tagName(family)).Feature) bool
参数
std.Target.Cpu.Model
容器
字段
std.Target.Cpu.Model.baseline
函数
返回 arch 的保守 CPU 型号,预期兼容
绝大多数现有硬件。与 generic 不同,此函数保证返回的 CPU 型号
同时为 LLVM 和 Clang 所识别。
对于某些 os 值,此函数还会将基线提高到
高于仅由 arch 决定的水平;例如,aarch64-macos 的
基线视为 apple_m1。要完全避免此行为,请传入
Os.Tag.freestanding。
pub fn baseline(arch: Arch, os: Os) *const Model
参数
std.Target.Cpu.Model.generic
函数
返回适用于 arch 的最基础 CPU 型号。注意,此函数
可能返回 LLVM 能识别、但 Clang 无法识别的 CPU 型号。
如果需要兼容 Clang,请考虑改用 baseline。
pub fn generic(arch: Arch) *const Model
参数
arch: Arch
std.Target.Cpu.Model.toCpu
函数
pub fn toCpu(model: *const Model, arch: Arch) Cpu
参数
std.Target.csky
别名
别名目标 std.Target.csky
std.Target.CType
容器
字段
char
short
ushort
int
uint
long
ulong
longlong
ulonglong
float
double
longdouble
std.Target.cTypeAlignment
函数
若此目标未定义 C ABI,则返回 null。
pub fn cTypeAlignment(target: *const Target, c_type: CType) ?u16
参数
std.Target.cTypeBitSize
函数
若此目标未定义 C ABI,则返回 null。
pub fn cTypeBitSize(target: *const Target, c_type: CType) ?u16
参数
std.Target.cTypeByteSize
函数
若此目标未定义 C ABI,则返回 null。
pub fn cTypeByteSize(t: *const Target, c_type: CType) ?u16
参数
std.Target.dynamicLibSuffix
函数
pub fn dynamicLibSuffix(target: *const Target) [:0]const u8
参数
target: *const Target
std.Target.DynamicLinker
容器
字段
buffer: [255]u8
len: u8
std.Target.DynamicLinker.eql
函数
pub fn eql(lhs: DynamicLinker, rhs: DynamicLinker) bool
参数
lhs: DynamicLinker
rhs: DynamicLinker
std.Target.DynamicLinker.get
函数
返回内存的生命周期与 DynamicLinker 相同。
pub fn get(dl: *const DynamicLinker) ?[]const u8
参数
dl: *const DynamicLinker
std.Target.DynamicLinker.init
函数
断言长度不超过 255 字节。
pub fn init(maybe_path: ?[]const u8) DynamicLinker
参数
maybe_path: ?[]const u8
std.Target.DynamicLinker.initFmt
函数
pub fn initFmt(comptime fmt_str: []const u8, args: anytype) !DynamicLinker
参数
fmt_str: []const u8
std.Target.DynamicLinker.kind
函数
pub fn kind(os: Os.Tag) Kind
参数
std.Target.DynamicLinker.Kind
容器
字段
std.Target.DynamicLinker.none
常量
DynamicLinker
std.Target.DynamicLinker.set
函数
断言长度不超过 255 字节。
pub fn set(dl: *DynamicLinker, maybe_path: ?[]const u8) void
参数
dl: *DynamicLinker
maybe_path: ?[]const u8
std.Target.DynamicLinker.setFmt
函数
断言长度不超过 255 字节。
pub fn setFmt(dl: *DynamicLinker, comptime fmt_str: []const u8, args: anytype) !void
参数
dl: *DynamicLinker
fmt_str: []const u8
std.Target.DynamicLinker.standard
函数
此函数的严格程度由 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
参数
std.Target.exeFileExt
函数
pub fn exeFileExt(target: *const Target) [:0]const u8
参数
target: *const Target
std.Target.hexagon
别名
别名目标 std.Target.hexagon
std.Target.hppa
别名
别名目标 std.Target.hppa
std.Target.hurdTuple
函数
已弃用;将在 0.18.0 中移除。请改用 std.zig.target.hurdTuple。
pub fn hurdTuple(target: *const Target, allocator: Allocator) ![]u8
参数
std.Target.hurdTupleSimple
函数
已弃用;将在 0.18.0 中移除。请改用 std.zig.target.hurdTupleSimple。
pub fn hurdTupleSimple(allocator: Allocator, arch: Cpu.Arch, abi: Abi) ![]u8
参数
std.Target.isBionicLibC
函数
pub inline fn isBionicLibC(target: *const Target) bool
参数
target: *const Target
std.Target.isDarwinLibC
函数
pub inline fn isDarwinLibC(target: *const Target) bool
参数
target: *const Target
std.Target.isFreeBSDLibC
函数
pub inline fn isFreeBSDLibC(target: *const Target) bool
参数
target: *const Target
std.Target.isGnuLibC
函数
pub inline fn isGnuLibC(target: *const Target) bool
参数
target: *const Target
std.Target.isMinGW
函数
pub inline fn isMinGW(target: *const Target) bool
参数
target: *const Target
std.Target.isMuslLibC
函数
pub inline fn isMuslLibC(target: *const Target) bool
参数
target: *const Target
std.Target.isNetBSDLibC
函数
pub inline fn isNetBSDLibC(target: *const Target) bool
参数
target: *const Target
std.Target.isOpenBSDLibC
函数
pub inline fn isOpenBSDLibC(target: *const Target) bool
参数
target: *const Target
std.Target.isWasiLibC
函数
pub inline fn isWasiLibC(target: *const Target) bool
参数
target: *const Target
std.Target.kalimba
别名
别名目标 std.Target.generic
std.Target.kvx
别名
别名目标 std.Target.kvx
std.Target.lanai
别名
别名目标 std.Target.lanai
std.Target.libPrefix
函数
pub fn libPrefix(target: *const Target) [:0]const u8
参数
target: *const Target
std.Target.linuxTriple
函数
已弃用;将在 0.18.0 中移除。请改用 std.zig.target.linuxTriple。
pub fn linuxTriple(target: *const Target, allocator: Allocator) ![]u8
参数
std.Target.linuxTripleSimple
函数
已弃用;将在 0.18.0 中移除。请改用 std.zig.target.linuxTripleSimple。
pub fn linuxTripleSimple(allocator: Allocator, arch: Cpu.Arch, os_tag: Os.Tag, abi: Abi) ![]u8
参数
std.Target.loongarch
别名
别名目标 std.Target.loongarch
std.Target.m68k
别名
别名目标 std.Target.m68k
std.Target.m88k
别名
别名目标 std.Target.generic
std.Target.microblaze
别名
别名目标 std.Target.generic
std.Target.mips
别名
别名目标 std.Target.mips
std.Target.msp430
别名
别名目标 std.Target.msp430
std.Target.nvptx
别名
别名目标 std.Target.nvptx
std.Target.ObjectFormat
容器
字段
std.Target.ObjectFormat.default
函数
pub fn default(os_tag: Os.Tag, arch: Cpu.Arch) ObjectFormat
参数
std.Target.ObjectFormat.fileExt
函数
pub fn fileExt(of: ObjectFormat, arch: Cpu.Arch) [:0]const u8
参数
of: ObjectFormat
arch: Cpu.Arch
std.Target.or1k
别名
别名目标 std.Target.generic
std.Target.Os
容器
字段
tag: Tag
version_range: VersionRange
std.Target.Os.HurdVersionRange
容器
字段
range: std.SemanticVersion.Range
glibc: std.SemanticVersion
std.Target.Os.HurdVersionRange.includesVersion
函数
pub inline fn includesVersion(range: HurdVersionRange, ver: std.SemanticVersion) bool
参数
range: HurdVersionRange
ver: std.SemanticVersion
std.Target.Os.HurdVersionRange.isAtLeast
函数
检查系统是否保证至少为 version,或早于 version。
若需要运行期检查,则返回 null。
pub inline fn isAtLeast(range: HurdVersionRange, ver: std.SemanticVersion) ?bool
参数
range: HurdVersionRange
ver: std.SemanticVersion
std.Target.Os.isAtLeast
函数
检查系统是否保证至少为 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
容器
字段
std.Target.Os.LinuxVersionRange.includesVersion
函数
pub inline fn includesVersion(range: LinuxVersionRange, ver: std.SemanticVersion) bool
参数
range: LinuxVersionRange
ver: std.SemanticVersion
std.Target.Os.LinuxVersionRange.isAtLeast
函数
检查系统是否保证至少为 version,或早于 version。
若需要运行期检查,则返回 null。
pub inline fn isAtLeast(range: LinuxVersionRange, ver: std.SemanticVersion) ?bool
参数
range: LinuxVersionRange
ver: std.SemanticVersion
std.Target.Os.Tag
容器
字段
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
函数
pub fn defaultVersionRange(tag: Tag, arch: Cpu.Arch, abi: Abi) Os
参数
std.Target.Os.Tag.dynamicLibSuffix
函数
pub fn dynamicLibSuffix(tag: Tag) [:0]const u8
参数
tag: Tag
std.Target.Os.Tag.exeFileExt
函数
pub fn exeFileExt(tag: Tag, arch: Cpu.Arch) [:0]const u8
参数
std.Target.Os.Tag.isBSD
函数
已弃用;将在 0.18.0 中移除。请改为检查相关标签。
pub inline fn isBSD(tag: Tag) bool
参数
tag: Tag
std.Target.Os.Tag.isDarwin
函数
pub inline fn isDarwin(tag: Tag) bool
参数
tag: Tag
std.Target.Os.Tag.libPrefix
函数
pub fn libPrefix(tag: Os.Tag, abi: Abi) [:0]const u8
参数
std.Target.Os.Tag.staticLibSuffix
函数
pub fn staticLibSuffix(tag: Tag, abi: Abi) [:0]const u8
参数
std.Target.Os.Tag.versionRangeTag
函数
pub inline fn versionRangeTag(tag: Tag) @typeInfo(TaggedVersionRange).@"union".tag_type.?
参数
tag: Tag
std.Target.Os.TaggedVersionRange
容器
字段
none: void
semver: std.SemanticVersion.Range
hurd: HurdVersionRange
linux: LinuxVersionRange
windows: WindowsVersion.Range
std.Target.Os.TaggedVersionRange.gnuLibCVersion
函数
pub fn gnuLibCVersion(range: TaggedVersionRange) ?std.SemanticVersion
参数
range: TaggedVersionRange
std.Target.Os.versionRange
函数
提供标签联合体。Target 不存储标签,因为标签与操作系统标签重复;此函数将这部分抽象出来。
pub inline fn versionRange(os: Os) TaggedVersionRange
参数
os: Os
std.Target.Os.VersionRange
容器
此处的版本范围表示受支持操作系统版本的下限和上限。默认值表示 Zig 标准库构建其抽象时所依据的版本范围。
对于目标平台,通常主要调整范围的最低版本。目标操作系统的最高版本一般保持默认值,即该操作系统最新发布的版本。
若要在编译期判断目标平台是否保证支持某项操作系统特性,应检查版本范围的最低版本是否大于或等于该特性引入的版本。
若要在编译期判断目标平台是否肯定不支持某项操作系统特性,应检查版本范围的最高版本是否低于该特性引入的版本。
如果两种情况都不成立,则应在运行期检查目标平台是否支持该特性。
使用指定最高版本构建的二进制文件仍可在更新的操作系统版本上运行。但此类二进制文件可能无法充分利用较新操作系统提供的 API。
另见 Os.isAtLeast。
字段
none: void
semver: std.SemanticVersion.Range
hurd: HurdVersionRange
linux: LinuxVersionRange
windows: WindowsVersion.Range
std.Target.Os.VersionRange.default
函数
默认 VersionRange 表示 Zig 标准库
建立抽象时所基于的版本范围。
pub fn default(arch: Cpu.Arch, tag: Tag, abi: Abi) VersionRange
参数
std.Target.Os.WindowsVersion
容器
基于以下来源的 NTDDI 版本常量: https://docs.microsoft.com/en-us/cpp/porting/modifying-winver-and-win32-winnt
字段
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
函数
此函数用于将该类型序列化为 Zig 源码表示, 解析此表示时将反序列化出相同的数据。
pub fn format(wv: WindowsVersion, w: *std.Io.Writer) std.Io.Writer.Error!void
参数
wv: WindowsVersion
w: *std.Io.Writer
错误
- WriteFailed
详细诊断信息见
Writer实现。
std.Target.Os.WindowsVersion.isAtLeast
函数
返回第一个版本 ver 是否不早于(大于或等于)第二个版本 ver。
pub inline fn isAtLeast(ver: WindowsVersion, min_ver: WindowsVersion) bool
参数
ver: WindowsVersion
min_ver: WindowsVersion
std.Target.Os.WindowsVersion.known_win10_build_numbers
常量
与运行时报告的构建号比较,以区分 Windows 10 版本;其中 0x0A000000 + index 对应 WindowsVersion 的 u32 值。
std.Target.Os.WindowsVersion.latest
常量
Zig 标准库已知的最新 Windows 版本
std.Target.Os.WindowsVersion.parse
函数
pub fn parse(str: []const u8) !WindowsVersion
参数
str: []const u8
std.Target.Os.WindowsVersion.Range
容器
字段
min: WindowsVersion
max: WindowsVersion
std.Target.Os.WindowsVersion.Range.includesVersion
函数
pub inline fn includesVersion(range: Range, ver: WindowsVersion) bool
参数
range: Range
ver: WindowsVersion
std.Target.Os.WindowsVersion.Range.isAtLeast
函数
检查系统是否保证至少为 version,或早于 version。
若需要运行期检查,则返回 null。
pub inline fn isAtLeast(range: Range, min_ver: WindowsVersion) ?bool
参数
range: Range
min_ver: WindowsVersion
std.Target.powerpc
别名
别名目标 std.Target.powerpc
std.Target.propeller
别名
别名目标 std.Target.propeller
std.Target.ptrBitWidth
函数
pub fn ptrBitWidth(target: *const Target) u16
参数
target: *const Target
std.Target.ptrBitWidth_arch_abi
函数
pub fn ptrBitWidth_arch_abi(cpu_arch: Cpu.Arch, abi: Abi) u16
参数
std.Target.ptrBitWidth_cpu_abi
函数
pub fn ptrBitWidth_cpu_abi(cpu: Cpu, abi: Abi) u16
参数
std.Target.Query
别名
别名目标 std.Target.Query
std.Target.requiresLibC
函数
此目标是否必须链接 libc?例如,目标系统调用接口 不稳定时可能有此要求。
pub fn requiresLibC(target: *const Target) bool
参数
target: *const Target
std.Target.riscv
别名
别名目标 std.Target.riscv
std.Target.s390x
别名
别名目标 std.Target.s390x
std.Target.sh
别名
别名目标 std.Target.generic
std.Target.sparc
别名
别名目标 std.Target.sparc
std.Target.spirv
别名
别名目标 std.Target.spirv
std.Target.spork8
别名
别名目标 std.Target.generic
std.Target.stackAlignment
函数
pub fn stackAlignment(target: *const Target) u16
参数
target: *const Target
std.Target.stackGrowth
函数
pub fn stackGrowth(target: *const Target) StackGrowth
参数
target: *const Target
std.Target.StackGrowth
容器
字段
down
up
std.Target.standardDynamicLinkerPath
函数
pub fn standardDynamicLinkerPath(target: *const Target) DynamicLinker
参数
target: *const Target
std.Target.staticLibSuffix
函数
pub fn staticLibSuffix(target: *const Target) [:0]const u8
参数
target: *const Target
std.Target.std
别名
别名目标 std
std.Target.supportsAddressSpace
函数
返回此目标是否支持 address_space。若 context 为 null,
此函数仅回答目标是否具备 address_space 概念
这一一般问题;若非 null,则还会检查
address_space 在该上下文中是否有效。
pub fn supportsAddressSpace( target: Target, address_space: std.builtin.AddressSpace, context: ?AddressSpaceContext, ) bool
参数
std.Target.Target
别名
别名目标 std.Target
std.Target.toCoffMachine
函数
pub fn toCoffMachine(target: *const Target) std.coff.IMAGE.FILE.MACHINE
参数
target: *const Target
std.Target.toElfMachine
函数
pub fn toElfMachine(target: *const Target) std.elf.EM
参数
target: *const Target
std.Target.ve
别名
别名目标 std.Target.ve
std.Target.wasm
别名
别名目标 std.Target.wasm
std.Target.x86
别名
别名目标 std.Target.x86
std.Target.xcore
别名
别名目标 std.Target.xcore
std.Target.xtensa
别名
别名目标 std.Target.xtensa
std.Target.z80
别名
别名目标 std.Target.generic
std.Target.zigTriple
函数
pub fn zigTriple(target: *const Target, allocator: Allocator) Allocator.Error![]u8
参数
错误
- 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: {
// 对于传统上使用 32 位时间的 32 位目标,完整支持
// 64 位时间需要 glibc 2.34。其他所有目标仅
// 要求 glibc 2.31。
const default_min: std.SemanticVersion = switch (arch) {
.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 },
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,
.thumb,
.thumbeb,
=> .musleabihf,
.mips,
.mipsel,
=> .musleabi,
.mips64,
.mips64el,
=> .muslabi64,
// 不支持 musl。
.alpha,
.arc,
.arceb,
.or1k,
.sparc,
.sparc64,
=> .gnu,
.csky,
=> .gnueabi,
.hppa,
.sh,
.sheb,
=> .gnueabihf,
// 不支持 glibc 或 musl。
.xtensa,
.xtensaeb,
=> .none,
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,
.psp => .eabihf,
.vita => .eabihf,
.wasi, .emscripten => .musl,
.ashetos => .eabi,
.contiki,
.hermit,
.illumos,
.managarm,
.plan9,
.serenity,
.dragonfly,
.driverkit,
.ios,
.maccatalyst,
.macos,
.tvos,
.visionos,
.watchos,
.@"switch",
.ps3,
.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,
/// 包含全部功能的位集合。
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,
.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,
.haiku,
.illumos,
.serenity,
.dragonfly,
.freebsd,
.netbsd,
.openbsd,
.driverkit,
.ios,
.maccatalyst,
.macos,
.tvos,
.visionos,
.watchos,
=> .arch_os,
.hurd,
.linux,
=> .arch_os_abi,
.freestanding,
.other,
.contiki,
.hermit,
.managarm, // 需要再次核对。
.plan9,
.rtems,
.uefi,
.windows,
.@"3ds",
.wiiu,
.@"switch",
.gba,
.emscripten,
.wasi,
.amdhsa,
.amdpal,
.cuda,
.mesa3d,
.nvcl,
.opencl,
.opengl,
.vulkan,
.psx,
.ps3,
.ps4,
.ps5,
.psp,
.vita,
.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,
},
.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.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,
},
}),
.hppa,
.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 "",
}),
.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,
},
// 此列表中的操作系统已确认没有标准
// 动态链接器路径。
.freestanding,
.other,
.contiki,
.hermit,
.plan9,
.rtems,
.uefi,
.windows,
.@"3ds",
.wiiu,
.@"switch",
.gba,
.psx,
.psp,
.vita,
.emscripten,
.wasi,
.amdhsa,
.amdpal,
.cuda,
.mesa3d,
.nvcl,
.opencl,
.opengl,
.vulkan,
.tios,
.ashetos,
=> none,
// TODO: 逐项检查此列表,或移到上方列表,
// 或为其实现标准动态链接器路径代码。
.managarm,
.ps3,
.ps4,
.ps5,
=> 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) {
.ez80 => return 1,
.m68k => return 2,
.amdgcn => return 4,
.arm,
.armeb,
.hppa,
.lanai,
.mips,
.mipsel,
.sparc,
.thumb,
.thumbeb,
=> return 8,
.aarch64,
.aarch64_be,
.alpha,
.bpfeb,
.bpfel,
.hppa64,
.loongarch32,
.loongarch64,
.mips64,
.mips64el,
.sparc64,
.ve,
.wasm32,
.wasm64,
.x86_64,
=> return 16,
// 以下部分分支实际上应检查 ABI,但当前的 `Abi` 枚举
// 尚无法表达如此细致的差别。
.powerpc64,
.powerpc64le,
=> if (target.os.tag == .linux) return 16,
.riscv32,
.riscv32be,
.riscv64,
.riscv64be,
=> if (!target.cpu.has(.riscv, .e)) return 16,
.x86 => if (target.os.tag != .windows and target.os.tag != .uefi) return 16,
.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 {
switch (target.os.tag) {
.opengl => return null,
else => {},
}
if (target.os.tag.isDarwin() or target.os.tag == .windows or target.os.tag == .uefi) return .signed;
return switch (target.cpu.arch) {
.aarch64,
.aarch64_be,
.arm,
.armeb,
.arc,
.arceb,
.csky,
.ez80,
.hexagon,
.msp430,
.powerpc,
.powerpcle,
.powerpc64,
.powerpc64le,
.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) {
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,
=> 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,
},
.mips64,
.mips64el,
=> switch (c_type) {
.char => 8,
.short, .ushort => 16,
.int, .uint, .float => 32,
.long, .ulong => switch (target.abi) {
.abin32 => 32,
else => 64,
},
.longlong, .ulonglong, .double => 64,
.longdouble => 128,
},
.x86_64 => switch (c_type) {
.char => 8,
.short, .ushort => 16,
.int, .uint, .float => 32,
.long, .ulong => switch (target.abi) {
.x32 => 32,
else => 64,
},
.longlong, .ulonglong, .double => 64,
.longdouble => 80,
},
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) {
.x86 => 80,
.alpha,
.riscv32,
.riscv32be,
.riscv64,
.riscv64be,
.aarch64,
.aarch64_be,
.powerpc,
.powerpcle,
.powerpc64,
.powerpc64le,
.s390x,
.sparc64,
.wasm32,
.wasm64,
.loongarch32,
.loongarch64,
.ve,
=> 128,
else => 64,
},
},
},
.fuchsia,
.hermit,
.haiku,
.hurd,
.illumos,
.linux,
.plan9,
.rtems,
.serenity,
.freebsd,
.dragonfly,
.netbsd,
.openbsd,
.wasi,
.emscripten,
=> switch (target.cpu.arch) {
.mips64,
.mips64el,
=> switch (c_type) {
.char => 8,
.short, .ushort => 16,
.int, .uint, .float => 32,
.long, .ulong => switch (target.abi) {
.gnuabin32, .muslabin32, .abin32 => 32,
else => 64,
},
.longlong, .ulonglong, .double => 64,
.longdouble => 128,
},
.x86_64 => switch (c_type) {
.char => 8,
.short, .ushort => 16,
.int, .uint, .float => 32,
.long, .ulong => switch (target.abi) {
.gnux32, .muslx32, .x32 => 32,
else => 64,
},
.longlong, .ulonglong, .double => 64,
.longdouble => 80,
},
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) {
.x86 => switch (target.abi) {
.android => 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,
.riscv32,
.riscv32be,
.riscv64,
.riscv64be,
.aarch64,
.aarch64_be,
.s390x,
.mips64,
.mips64el,
.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,
},
},
.nvcl, .cuda => switch (c_type) {
.char => 8,
.short, .ushort => 16,
.int, .uint, .float => 32,
.long, .ulong => switch (target.cpu.arch) {
.nvptx => 32,
.nvptx64 => 64,
else => 64,
},
.longlong, .ulonglong, .double => 64,
.longdouble => 64,
},
.amdhsa, .amdpal, .mesa3d => switch (c_type) {
.char => 8,
.short, .ushort => 16,
.int, .uint, .float => 32,
.long, .ulong, .longlong, .ulonglong, .double => 64,
.longdouble => 128,
},
.opencl, .vulkan => switch (c_type) {
.char => 8,
.short, .ushort => 16,
.int, .uint, .float => 32,
.long, .ulong, .double => 64,
.longlong, .ulonglong => 128,
// 注:OpenCL 规范未保证 long double 的具体大小,
// 但 clang 使用 128 位。
.longdouble => 128,
},
.@"3ds" => switch (c_type) {
.char => 8,
.short, .ushort => 16,
.int, .uint, .float, .long, .ulong => 32,
.longlong, .ulonglong, .double, .longdouble => 64,
},
.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,
},
.gba => switch (c_type) {
.char => return 8,
.short, .ushort => return 16,
.int, .uint, .long, .ulong, .float => return 32,
.longlong, .ulonglong, .double, .longdouble => return 64,
},
.psx => 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 => 64,
.longlong, .ulonglong, .double => 64,
.longdouble => 80,
},
.psp, .vita => switch (c_type) {
.char => 8,
.short, .ushort => 16,
.int, .uint, .float => 32,
.long, .ulong => 64,
.longlong, .ulonglong, .double, .longdouble => 64,
},
.tios => switch (c_type) {
.char => 8,
.short, .ushort => 16,
.int, .uint => 24,
.long, .ulong, .float, .double => 32,
.longlong, .ulonglong, .longdouble => 64,
},
.opengl => null,
.ps3,
.contiki,
.managarm,
=> @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,
.xtensa,
.xtensaeb,
=> 4,
.amdgcn,
.arm,
.armeb,
.bpfeb,
.bpfel,
.hexagon,
.hppa,
.lanai,
.m68k,
.m88k,
.mips,
.mipsel,
.nvptx,
.nvptx64,
.s390x,
.sparc,
.thumb,
.thumbeb,
=> 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 => .{ .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 => .{ .xtensa_call0 = .{} },
.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);
}