commit 8df04e144483ff48e506522da8269af25d0bca85 (tree)
parent 02097dff7049cecb16e301d37cd270159ef0f371
Author: Matthew Lugg <mlugg@mlugg.co.uk>
Date: Sat, 2 May 2026 11:04:28 +0100
std: actually rename `std.builtin` to `std.lang`
This is now the canonical name, and `std.builtin` is a deprecated alias.
Diffstat:
5 files changed, 1260 insertions(+), 1256 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -239,7 +239,8 @@ set(ZIG_STAGE2_SOURCES
lib/std/atomic.zig
lib/std/base64.zig
lib/std/buf_map.zig
- lib/std/builtin.zig
+ lib/std/lang.zig
+ lib/std/lang/assembly.zig
lib/std/c.zig
lib/std/coff.zig
lib/std/crypto.zig
diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
@@ -1,1254 +0,0 @@
-//! Types and values provided by the Zig language.
-
-const builtin = @import("builtin");
-const std = @import("std.zig");
-const root = @import("root");
-
-pub const assembly = @import("builtin/assembly.zig");
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const StackTrace = struct {
- index: usize,
- instruction_addresses: []usize,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const GlobalLinkage = enum(u2) {
- internal,
- strong,
- weak,
- link_once,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const SymbolVisibility = enum(u2) {
- default,
- hidden,
- protected,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const AtomicOrder = enum {
- unordered,
- monotonic,
- acquire,
- release,
- acq_rel,
- seq_cst,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const ReduceOp = enum {
- And,
- Or,
- Xor,
- Min,
- Max,
- Add,
- Mul,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const AtomicRmwOp = enum {
- /// Exchange - store the operand unmodified.
- /// Supports enums, integers, and floats.
- Xchg,
- /// Add operand to existing value.
- /// Supports integers and floats.
- /// For integers, two's complement wraparound applies.
- Add,
- /// Subtract operand from existing value.
- /// Supports integers and floats.
- /// For integers, two's complement wraparound applies.
- Sub,
- /// Perform bitwise AND on existing value with operand.
- /// Supports integers.
- And,
- /// Perform bitwise NAND on existing value with operand.
- /// Supports integers.
- Nand,
- /// Perform bitwise OR on existing value with operand.
- /// Supports integers.
- Or,
- /// Perform bitwise XOR on existing value with operand.
- /// Supports integers.
- Xor,
- /// Store operand if it is larger than the existing value.
- /// Supports integers and floats.
- Max,
- /// Store operand if it is smaller than the existing value.
- /// Supports integers and floats.
- Min,
-};
-
-/// The code model puts constraints on the location of symbols and the size of code and data.
-/// The selection of a code model is a trade off on speed and restrictions that needs to be selected on a per application basis to meet its requirements.
-/// A slightly more detailed explanation can be found in (for example) the [System V Application Binary Interface (x86_64)](https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf) 3.5.1.
-///
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const CodeModel = enum {
- default,
- extreme,
- kernel,
- large,
- medany,
- medium,
- medlow,
- medmid,
- normal,
- small,
- tiny,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const OptimizeMode = enum {
- Debug,
- ReleaseSafe,
- ReleaseFast,
- ReleaseSmall,
-};
-
-/// The calling convention of a function defines how arguments and return values are passed, as well
-/// as any other requirements which callers and callees must respect, such as register preservation
-/// and stack alignment.
-///
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const CallingConvention = union(enum(u8)) {
- pub const Tag = @typeInfo(CallingConvention).@"union".tag_type.?;
-
- /// This is an alias for the default C calling convention for this target.
- /// Functions marked as `extern` or `export` are given this calling convention by default.
- pub const c = builtin.target.cCallingConvention().?;
-
- pub const winapi: CallingConvention = switch (builtin.target.cpu.arch) {
- .x86_64 => .{ .x86_64_win = .{} },
- .x86 => .{ .x86_stdcall = .{} },
- .aarch64 => .{ .aarch64_aapcs_win = .{} },
- .thumb => .{ .arm_aapcs_vfp = .{} },
- else => unreachable,
- };
-
- pub const kernel: CallingConvention = switch (builtin.target.cpu.arch) {
- .amdgcn => .amdgcn_kernel,
- .nvptx, .nvptx64 => .nvptx_kernel,
- .spirv32, .spirv64 => .spirv_kernel,
- else => unreachable,
- };
-
- /// The default Zig calling convention when neither `export` nor `inline` is specified.
- /// This calling convention makes no guarantees about stack alignment, registers, etc.
- /// It can only be used within this Zig compilation unit.
- auto,
-
- /// The calling convention of a function that can be called with `async` syntax. An `async` call
- /// of a runtime-known function must target a function with this calling convention.
- /// Comptime-known functions with other calling conventions may be coerced to this one.
- async,
-
- /// Functions with this calling convention have no prologue or epilogue, making the function
- /// uncallable in regular Zig code. This can be useful when integrating with assembly.
- naked,
-
- /// This calling convention is exactly equivalent to using the `inline` keyword on a function
- /// definition. This function will be semantically inlined by the Zig compiler at call sites.
- /// Pointers to inline functions are comptime-only.
- @"inline",
-
- // Calling conventions for the `x86_64` architecture.
- x86_64_sysv: CommonOptions,
- x86_64_x32: CommonOptions,
- x86_64_win: CommonOptions,
- x86_64_regcall_v3_sysv: CommonOptions,
- x86_64_regcall_v4_win: CommonOptions,
- x86_64_vectorcall: CommonOptions,
- x86_64_interrupt: CommonOptions,
-
- // Calling conventions for the `x86` architecture.
- x86_sysv: X86RegparmOptions,
- x86_win: X86RegparmOptions,
- x86_stdcall: X86RegparmOptions,
- x86_fastcall: CommonOptions,
- x86_thiscall: CommonOptions,
- x86_thiscall_mingw: CommonOptions,
- x86_regcall_v3: CommonOptions,
- x86_regcall_v4_win: CommonOptions,
- x86_vectorcall: CommonOptions,
- x86_interrupt: CommonOptions,
-
- // Calling conventions for the `x86_16` architecture.
-
- x86_16_cdecl: CommonOptions,
- x86_16_stdcall: CommonOptions,
- x86_16_regparmcall: CommonOptions,
- x86_16_interrupt: CommonOptions,
-
- // Calling conventions for the `aarch64` and `aarch64_be` architectures.
- aarch64_aapcs: CommonOptions,
- aarch64_aapcs_darwin: CommonOptions,
- aarch64_aapcs_win: CommonOptions,
- aarch64_vfabi: CommonOptions,
- aarch64_vfabi_sve: CommonOptions,
-
- /// The standard `alpha` calling convention.
- alpha_osf: CommonOptions,
-
- // Calling convetions for the `arm`, `armeb`, `thumb`, and `thumbeb` architectures.
- /// ARM Architecture Procedure Call Standard
- arm_aapcs: CommonOptions,
- /// ARM Architecture Procedure Call Standard Vector Floating-Point
- arm_aapcs_vfp: CommonOptions,
- arm_interrupt: ArmInterruptOptions,
-
- // Calling conventions for the `mips64` and `mips64el` architectures.
- mips64_n64: CommonOptions,
- mips64_n32: CommonOptions,
- mips64_interrupt: MipsInterruptOptions,
-
- // Calling conventions for the `mips` and `mipsel` architectures.
- mips_o32: CommonOptions,
- mips_interrupt: MipsInterruptOptions,
-
- // Calling conventions for the `riscv64` architecture.
- riscv64_lp64: CommonOptions,
- riscv64_lp64_v: CommonOptions,
- riscv64_interrupt: RiscvInterruptOptions,
-
- // Calling conventions for the `riscv32` architecture.
- riscv32_ilp32: CommonOptions,
- riscv32_ilp32_v: CommonOptions,
- riscv32_interrupt: RiscvInterruptOptions,
-
- // Calling conventions for the `sparc64` architecture.
- sparc64_sysv: CommonOptions,
-
- // Calling conventions for the `sparc` architecture.
- sparc_sysv: CommonOptions,
-
- // Calling conventions for the `powerpc64` and `powerpc64le` architectures.
- powerpc64_elf: CommonOptions,
- powerpc64_elf_altivec: CommonOptions,
- powerpc64_elf_v2: CommonOptions,
-
- // Calling conventions for the `powerpc` and `powerpcle` architectures.
- powerpc_sysv: CommonOptions,
- powerpc_sysv_altivec: CommonOptions,
- powerpc_aix: CommonOptions,
- powerpc_aix_altivec: CommonOptions,
-
- /// The standard `wasm32` and `wasm64` calling convention, as specified in the WebAssembly Tool Conventions.
- wasm_mvp: CommonOptions,
-
- /// The standard `arc`/`arceb` calling convention.
- arc_sysv: CommonOptions,
- arc_interrupt: ArcInterruptOptions,
-
- // Calling conventions for the `avr` architecture.
- avr_gnu,
- avr_builtin,
- avr_signal,
- avr_interrupt,
-
- /// The standard `bpfel`/`bpfeb` calling convention.
- bpf_std: CommonOptions,
-
- // Calling conventions for the `csky` architecture.
- csky_sysv: CommonOptions,
- csky_interrupt: CommonOptions,
-
- // Calling conventions for the `hexagon` architecture.
- hexagon_sysv: CommonOptions,
- hexagon_sysv_hvx: CommonOptions,
-
- /// The standard `hppa` calling convention.
- hppa_elf: CommonOptions,
-
- /// The standard `hppa64` calling convention.
- hppa64_elf: CommonOptions,
-
- kvx_lp64: CommonOptions,
- kvx_ilp32: CommonOptions,
-
- /// The standard `lanai` calling convention.
- lanai_sysv: CommonOptions,
-
- /// The standard `loongarch64` calling convention.
- loongarch64_lp64: CommonOptions,
-
- /// The standard `loongarch32` calling convention.
- loongarch32_ilp32: CommonOptions,
-
- // Calling conventions for the `m68k` architecture.
- m68k_sysv: CommonOptions,
- m68k_gnu: CommonOptions,
- m68k_rtd: CommonOptions,
- m68k_interrupt: CommonOptions,
-
- /// The standard `microblaze`/`microblazeel` calling convention.
- microblaze_std: CommonOptions,
- microblaze_interrupt: MicroblazeInterruptOptions,
-
- /// The standard `msp430` calling convention.
- msp430_eabi: CommonOptions,
- msp430_interrupt: CommonOptions,
-
- /// The standard `or1k` calling convention.
- or1k_sysv: CommonOptions,
-
- /// The standard `propeller` calling convention.
- propeller_sysv: CommonOptions,
-
- // Calling conventions for the `s390x` architecture.
- s390x_sysv: CommonOptions,
- s390x_sysv_vx: CommonOptions,
-
- // Calling conventions for the `sh`/`sheb` architecture.
- sh_gnu: CommonOptions,
- sh_renesas: CommonOptions,
- sh_interrupt: ShInterruptOptions,
-
- /// The standard `ve` calling convention.
- ve_sysv: CommonOptions,
-
- // Calling conventions for the `xcore` architecture.
- xcore_xs1: CommonOptions,
- xcore_xs2: CommonOptions,
-
- // Calling conventions for the `xtensa`/`xtensaeb` architecture.
- xtensa_call0: CommonOptions,
- xtensa_windowed: CommonOptions,
-
- // Calling conventions for the `amdgcn` architecture.
- amdgcn_device: CommonOptions,
- amdgcn_kernel,
- amdgcn_cs: CommonOptions,
-
- // Calling conventions for the `nvptx` and `nvptx64` architectures.
- nvptx_device,
- nvptx_kernel,
-
- // Calling conventions for kernels and shaders on the `spirv`, `spirv32`, and `spirv64` architectures.
- spirv_device,
- spirv_kernel,
- spirv_fragment,
- spirv_vertex,
-
- // Calling conventions for the `ez80` architecture.
- ez80_cet,
- ez80_tiflags,
-
- /// Options shared across most calling conventions.
- pub const CommonOptions = struct {
- /// The boundary the stack is aligned to when the function is called.
- /// `null` means the default for this calling convention.
- incoming_stack_alignment: ?u64 = null,
- };
-
- /// Options for x86 calling conventions which support the regparm attribute to pass some
- /// arguments in registers.
- pub const X86RegparmOptions = struct {
- /// The boundary the stack is aligned to when the function is called.
- /// `null` means the default for this calling convention.
- incoming_stack_alignment: ?u64 = null,
- /// The number of arguments to pass in registers before passing the remaining arguments
- /// according to the calling convention.
- /// Equivalent to `__attribute__((regparm(x)))` in Clang and GCC.
- register_params: u2 = 0,
- };
-
- /// Options for the `arc_interrupt` calling convention.
- pub const ArcInterruptOptions = struct {
- /// The boundary the stack is aligned to when the function is called.
- /// `null` means the default for this calling convention.
- incoming_stack_alignment: ?u64 = null,
- /// The kind of interrupt being received.
- type: InterruptType,
-
- pub const InterruptType = enum(u2) {
- ilink1,
- ilink2,
- ilink,
- firq,
- };
- };
-
- /// Options for the `arm_interrupt` calling convention.
- pub const ArmInterruptOptions = struct {
- /// The boundary the stack is aligned to when the function is called.
- /// `null` means the default for this calling convention.
- incoming_stack_alignment: ?u64 = null,
- /// The kind of interrupt being received.
- type: InterruptType = .generic,
-
- pub const InterruptType = enum(u3) {
- generic,
- irq,
- fiq,
- swi,
- abort,
- undef,
- };
- };
-
- /// Options for the `microblaze_interrupt` calling convention.
- pub const MicroblazeInterruptOptions = struct {
- /// The boundary the stack is aligned to when the function is called.
- /// `null` means the default for this calling convention.
- incoming_stack_alignment: ?u64 = null,
- type: InterruptType = .regular,
-
- pub const InterruptType = enum(u2) {
- /// User exception; return with `rtsd`.
- user,
- /// Regular interrupt; return with `rtid`.
- regular,
- /// Fast interrupt; return with `rtid`.
- fast,
- /// Software breakpoint; return with `rtbd`.
- breakpoint,
- };
- };
-
- /// Options for the `mips_interrupt` and `mips64_interrupt` calling conventions.
- pub const MipsInterruptOptions = struct {
- /// The boundary the stack is aligned to when the function is called.
- /// `null` means the default for this calling convention.
- incoming_stack_alignment: ?u64 = null,
- /// The interrupt mode.
- mode: InterruptMode = .eic,
-
- pub const InterruptMode = enum(u4) {
- eic,
- sw0,
- sw1,
- hw0,
- hw1,
- hw2,
- hw3,
- hw4,
- hw5,
- };
- };
-
- /// Options for the `riscv32_interrupt` and `riscv64_interrupt` calling conventions.
- pub const RiscvInterruptOptions = struct {
- /// The boundary the stack is aligned to when the function is called.
- /// `null` means the default for this calling convention.
- incoming_stack_alignment: ?u64 = null,
- /// The privilege mode.
- mode: PrivilegeMode,
-
- pub const PrivilegeMode = enum(u2) {
- supervisor,
- machine,
- };
- };
-
- /// Options for the `sh_interrupt` calling convention.
- pub const ShInterruptOptions = struct {
- /// The boundary the stack is aligned to when the function is called.
- /// `null` means the default for this calling convention.
- incoming_stack_alignment: ?u64 = null,
- save: SaveBehavior = .full,
-
- pub const SaveBehavior = enum(u3) {
- /// Save only fpscr (if applicable).
- fpscr,
- /// Save only high-numbered registers, i.e. r0 through r7 are *not* saved.
- high,
- /// Save all registers normally.
- full,
- /// Save all registers using the CPU's fast register bank.
- bank,
- };
- };
-
- /// Returns the array of `std.Target.Cpu.Arch` to which this `CallingConvention` applies.
- /// Asserts that `cc` is not `.auto`, `.@"async"`, `.naked`, or `.@"inline"`.
- pub fn archs(cc: CallingConvention) []const std.Target.Cpu.Arch {
- return std.Target.Cpu.Arch.fromCallingConvention(cc);
- }
-
- pub fn eql(a: CallingConvention, b: CallingConvention) bool {
- return std.meta.eql(a, b);
- }
-
- pub fn withStackAlign(cc: CallingConvention, incoming_stack_alignment: u64) CallingConvention {
- const tag: CallingConvention.Tag = cc;
- var result = cc;
- @field(result, @tagName(tag)).incoming_stack_alignment = incoming_stack_alignment;
- return result;
- }
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const AddressSpace = enum(u5) {
- // CPU address spaces.
- generic,
- gs,
- fs,
- ss,
-
- // x86_16 extra address spaces.
- /// Allows addressing the entire address space by storing both segment and offset.
- far,
-
- // GPU address spaces.
- global,
- constant,
- param,
- shared,
- local,
- input,
- output,
- uniform,
- push_constant,
- storage_buffer,
- physical_storage_buffer,
-
- // AVR address spaces.
- flash,
- flash1,
- flash2,
- flash3,
- flash4,
- flash5,
-
- // Propeller address spaces.
-
- /// This address space only addresses the cog-local ram.
- cog,
-
- /// This address space only addresses shared hub ram.
- hub,
-
- /// This address space only addresses the "lookup" ram
- lut,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const SourceLocation = struct {
- /// The name chosen when compiling. Not a file path.
- module: [:0]const u8,
- /// Relative to the root directory of its module.
- file: [:0]const u8,
- fn_name: [:0]const u8,
- line: u32,
- column: u32,
-};
-
-pub const TypeId = std.meta.Tag(Type);
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const Type = union(enum) {
- type,
- void,
- bool,
- noreturn,
- int: Int,
- float: Float,
- pointer: Pointer,
- array: Array,
- @"struct": Struct,
- comptime_float,
- comptime_int,
- undefined,
- null,
- optional: Optional,
- error_union: ErrorUnion,
- error_set: ErrorSet,
- @"enum": Enum,
- @"union": Union,
- @"fn": Fn,
- @"opaque": Opaque,
- frame: Frame,
- @"anyframe": AnyFrame,
- vector: Vector,
- enum_literal,
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Int = struct {
- signedness: Signedness,
- bits: u16,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Float = struct {
- bits: u16,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Pointer = struct {
- size: Size,
- is_const: bool,
- is_volatile: bool,
- /// `null` means implicit alignment, which is equivalent to `@alignOf(child)`.
- alignment: ?usize,
- address_space: AddressSpace,
- child: type,
- is_allowzero: bool,
-
- /// The type of the sentinel is the element type of the pointer, which is
- /// the value of the `child` field in this struct. However there is no way
- /// to refer to that type here, so we use `*const anyopaque`.
- /// See also: `sentinel`
- sentinel_ptr: ?*const anyopaque,
-
- /// Loads the pointer type's sentinel value from `sentinel_ptr`.
- /// Returns `null` if the pointer type has no sentinel.
- pub inline fn sentinel(comptime ptr: Pointer) ?ptr.child {
- const sp: *const ptr.child = @ptrCast(@alignCast(ptr.sentinel_ptr orelse return null));
- return sp.*;
- }
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Size = enum(u2) {
- one,
- many,
- slice,
- c,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Attributes = struct {
- @"const": bool = false,
- @"volatile": bool = false,
- @"allowzero": bool = false,
- @"addrspace": ?AddressSpace = null,
- @"align": ?usize = null,
- };
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Array = struct {
- len: comptime_int,
- child: type,
-
- /// The type of the sentinel is the element type of the array, which is
- /// the value of the `child` field in this struct. However there is no way
- /// to refer to that type here, so we use `*const anyopaque`.
- /// See also: `sentinel`.
- sentinel_ptr: ?*const anyopaque,
-
- /// Loads the array type's sentinel value from `sentinel_ptr`.
- /// Returns `null` if the array type has no sentinel.
- pub inline fn sentinel(comptime arr: Array) ?arr.child {
- const sp: *const arr.child = @ptrCast(@alignCast(arr.sentinel_ptr orelse return null));
- return sp.*;
- }
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const ContainerLayout = enum(u2) {
- auto,
- @"extern",
- @"packed",
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const StructField = struct {
- name: [:0]const u8,
- type: type,
- /// The type of the default value is the type of this struct field, which
- /// is the value of the `type` field in this struct. However there is no
- /// way to refer to that type here, so we use `*const anyopaque`.
- /// See also: `defaultValue`.
- default_value_ptr: ?*const anyopaque,
- is_comptime: bool,
- /// `null` means the field alignment was not explicitly specified. The
- /// field will still be aligned to at least `@alignOf` its `type`.
- alignment: ?usize,
-
- /// Loads the field's default value from `default_value_ptr`.
- /// Returns `null` if the field has no default value.
- pub inline fn defaultValue(comptime sf: StructField) ?sf.type {
- const dp: *const sf.type = @ptrCast(@alignCast(sf.default_value_ptr orelse return null));
- return dp.*;
- }
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Attributes = struct {
- @"comptime": bool = false,
- @"align": ?usize = null,
- default_value_ptr: ?*const anyopaque = null,
- };
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Struct = struct {
- layout: ContainerLayout,
- /// Only valid if layout is .@"packed"
- backing_integer: ?type = null,
- fields: []const StructField,
- decls: []const Declaration,
- is_tuple: bool,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Optional = struct {
- child: type,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const ErrorUnion = struct {
- error_set: type,
- payload: type,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Error = struct {
- name: [:0]const u8,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const ErrorSet = ?[]const Error;
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const EnumField = struct {
- name: [:0]const u8,
- value: comptime_int,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Enum = struct {
- tag_type: type,
- fields: []const EnumField,
- decls: []const Declaration,
- is_exhaustive: bool,
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Mode = enum { exhaustive, nonexhaustive };
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const UnionField = struct {
- name: [:0]const u8,
- type: type,
- /// `null` means the field alignment was not explicitly specified. The
- /// field will still be aligned to at least `@alignOf` its `type`.
- alignment: ?usize,
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Attributes = struct {
- @"align": ?usize = null,
- };
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Union = struct {
- layout: ContainerLayout,
- tag_type: ?type,
- fields: []const UnionField,
- decls: []const Declaration,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Fn = struct {
- calling_convention: CallingConvention,
- is_generic: bool,
- is_var_args: bool,
- /// TODO change the language spec to make this not optional.
- return_type: ?type,
- params: []const Param,
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Param = struct {
- is_generic: bool,
- is_noalias: bool,
- type: ?type,
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Attributes = struct {
- @"noalias": bool = false,
- };
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Attributes = struct {
- @"callconv": CallingConvention = .auto,
- varargs: bool = false,
- };
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Opaque = struct {
- decls: []const Declaration,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Frame = struct {
- function: *const anyopaque,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const AnyFrame = struct {
- child: ?type,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Vector = struct {
- len: comptime_int,
- child: type,
- };
-
- /// This data structure is used by the Zig language code generation and
- /// therefore must be kept in sync with the compiler implementation.
- pub const Declaration = struct {
- name: [:0]const u8,
- };
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const FloatMode = enum {
- strict,
- optimized,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const Endian = enum {
- big,
- little,
-
- pub const native = builtin.target.cpu.arch.endian();
- pub const foreign: Endian = @enumFromInt(1 - @intFromEnum(native));
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const Signedness = enum(u1) {
- signed,
- unsigned,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const OutputMode = enum {
- Exe,
- Lib,
- Obj,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const LinkMode = enum {
- static,
- dynamic,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const UnwindTables = enum {
- none,
- sync,
- async,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const WasiExecModel = enum {
- command,
- reactor,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const CallModifier = enum {
- /// Equivalent to function call syntax.
- auto,
- /// Prevents tail call optimization. This guarantees that the return
- /// address will point to the callsite, as opposed to the callsite's
- /// callsite. If the call is otherwise required to be tail-called
- /// or inlined, a compile error is emitted instead.
- never_tail,
- /// Guarantees that the call will not be inlined. If the call is
- /// otherwise required to be inlined, a compile error is emitted instead.
- never_inline,
- /// Asserts that the function call will not suspend. This allows a
- /// non-async function to call an async function.
- no_suspend,
- /// Guarantees that the call will be generated with tail call optimization.
- /// If this is not possible, a compile error is emitted instead.
- always_tail,
- /// Guarantees that the call will be inlined at the callsite.
- /// If this is not possible, a compile error is emitted instead.
- always_inline,
- /// Evaluates the call at compile-time. If the call cannot be completed at
- /// compile-time, a compile error is emitted instead.
- compile_time,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const VaListAarch64 = extern struct {
- __stack: *anyopaque,
- __gr_top: *anyopaque,
- __vr_top: *anyopaque,
- __gr_offs: c_int,
- __vr_offs: c_int,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const VaListAlpha = extern struct {
- __base: *anyopaque,
- __offset: c_int,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const VaListArm = extern struct {
- __ap: *anyopaque,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const VaListHexagon = extern struct {
- __gpr: c_long,
- __fpr: c_long,
- __overflow_arg_area: *anyopaque,
- __reg_save_area: *anyopaque,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const VaListPowerPc = extern struct {
- gpr: u8,
- fpr: u8,
- reserved: c_ushort,
- overflow_arg_area: *anyopaque,
- reg_save_area: *anyopaque,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const VaListS390x = extern struct {
- __current_saved_reg_area_pointer: *anyopaque,
- __saved_reg_area_end_pointer: *anyopaque,
- __overflow_area_pointer: *anyopaque,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const VaListSh = extern struct {
- __va_next_o: *anyopaque,
- __va_next_o_limit: *anyopaque,
- __va_next_fp: *anyopaque,
- __va_next_fp_limit: *anyopaque,
- __va_next_stack: *anyopaque,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const VaListX86_64 = extern struct {
- gp_offset: c_uint,
- fp_offset: c_uint,
- overflow_arg_area: *anyopaque,
- reg_save_area: *anyopaque,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const VaListXtensa = extern struct {
- __va_stk: *c_int,
- __va_reg: *c_int,
- __va_ndx: c_int,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const VaList = switch (builtin.cpu.arch) {
- .amdgcn,
- .msp430,
- .nvptx,
- .nvptx64,
- .powerpc64,
- .powerpc64le,
- .x86,
- => *u8,
- .arc,
- .arceb,
- .avr,
- .bpfel,
- .bpfeb,
- .csky,
- .hppa,
- .hppa64,
- .kvx,
- .lanai,
- .loongarch32,
- .loongarch64,
- .m68k,
- .microblaze,
- .microblazeel,
- .mips,
- .mipsel,
- .mips64,
- .mips64el,
- .riscv32,
- .riscv32be,
- .riscv64,
- .riscv64be,
- .sparc,
- .sparc64,
- .spirv32,
- .spirv64,
- .ve,
- .wasm32,
- .wasm64,
- .xcore,
- => *anyopaque,
- .aarch64, .aarch64_be => switch (builtin.os.tag) {
- .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos, .windows => *u8,
- else => switch (builtin.zig_backend) {
- else => VaListAarch64,
- .stage2_llvm => @compileError("disabled due to miscompilations"),
- },
- },
- .alpha => VaListAlpha,
- .arm, .armeb, .thumb, .thumbeb => VaListArm,
- .hexagon => if (builtin.target.abi.isMusl()) VaListHexagon else *u8,
- .powerpc, .powerpcle => VaListPowerPc,
- .s390x => VaListS390x,
- .sh, .sheb => VaListSh, // This is wrong for `sh_renesas`: https://github.com/ziglang/zig/issues/24692#issuecomment-3150779829
- .x86_64 => switch (builtin.os.tag) {
- .uefi, .windows => switch (builtin.zig_backend) {
- else => *u8,
- .stage2_llvm => @compileError("disabled due to miscompilations"),
- },
- else => VaListX86_64,
- },
- .xtensa, .xtensaeb => VaListXtensa,
- else => @compileError("VaList not supported for this target yet"),
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const PrefetchOptions = struct {
- /// Whether the prefetch should prepare for a read or a write.
- rw: Rw = .read,
- /// The data's locality in an inclusive range from 0 to 3.
- ///
- /// 0 means no temporal locality. That is, the data can be immediately
- /// dropped from the cache after it is accessed.
- ///
- /// 3 means high temporal locality. That is, the data should be kept in
- /// the cache as it is likely to be accessed again soon.
- locality: u2 = 3,
- /// The cache that the prefetch should be performed on.
- cache: Cache = .data,
-
- pub const Rw = enum(u1) {
- read,
- write,
- };
-
- pub const Cache = enum(u1) {
- instruction,
- data,
- };
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const ExportOptions = struct {
- name: []const u8,
- linkage: GlobalLinkage = .strong,
- section: ?[]const u8 = null,
- visibility: SymbolVisibility = .default,
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const ExternOptions = struct {
- name: []const u8,
- library_name: ?[]const u8 = null,
- linkage: GlobalLinkage = .strong,
- visibility: SymbolVisibility = .default,
- /// Setting this to `true` makes the `@extern` a runtime value.
- is_thread_local: bool = false,
- is_dll_import: bool = false,
- relocation: Relocation = .any,
- decoration: ?Decoration = null,
-
- pub const Decoration = union(enum) {
- location: u32,
- descriptor: Descriptor,
-
- pub const Descriptor = struct {
- binding: u32,
- set: u32,
- };
- };
-
- pub const Relocation = enum(u1) {
- /// Any type of relocation is allowed.
- any,
- /// A program-counter-relative relocation is required.
- /// Using this value makes the `@extern` a runtime value.
- pcrel,
- };
-};
-
-/// This data structure is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const BranchHint = enum(u3) {
- /// Equivalent to no hint given.
- none,
- /// This branch of control flow is more likely to be reached than its peers.
- /// The optimizer should optimize for reaching it.
- likely,
- /// This branch of control flow is less likely to be reached than its peers.
- /// The optimizer should optimize for not reaching it.
- unlikely,
- /// This branch of control flow is unlikely to *ever* be reached.
- /// The optimizer may place it in a different page of memory to optimize other branches.
- cold,
- /// It is difficult to predict whether this branch of control flow will be reached.
- /// The optimizer should avoid branching behavior with expensive mispredictions.
- unpredictable,
-};
-
-/// This enum is set by the compiler and communicates which compiler backend is
-/// used to produce machine code.
-/// Think carefully before deciding to observe this value. Nearly all code should
-/// be agnostic to the backend that implements the language. The use case
-/// to use this value is to **work around problems with compiler implementations.**
-///
-/// Avoid failing the compilation if the compiler backend does not match a
-/// whitelist of backends; rather one should detect that a known problem would
-/// occur in a blacklist of backends.
-///
-/// The enum is nonexhaustive so that alternate Zig language implementations may
-/// choose a number as their tag (please use a random number generator rather
-/// than a "cute" number) and codebases can interact with these values even if
-/// this upstream enum does not have a name for the number. Of course, upstream
-/// is happy to accept pull requests to add Zig implementations to this enum.
-///
-/// This data structure is part of the Zig language specification.
-pub const CompilerBackend = enum(u64) {
- /// It is allowed for a compiler implementation to not reveal its identity,
- /// in which case this value is appropriate. Be cool and make sure your
- /// code supports `other` Zig compilers!
- other = 0,
- /// The original Zig compiler created in 2015 by Andrew Kelley. Implemented
- /// in C++. Used LLVM. Deleted from the ZSF ziglang/zig codebase on
- /// December 6th, 2022.
- stage1 = 1,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// LLVM backend.
- stage2_llvm = 2,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// backend that generates C source code.
- /// Note that one can observe whether the compilation will output C code
- /// directly with `object_format` value rather than the `compiler_backend` value.
- stage2_c = 3,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// WebAssembly backend.
- stage2_wasm = 4,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// arm backend.
- stage2_arm = 5,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// x86_64 backend.
- stage2_x86_64 = 6,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// aarch64 backend.
- stage2_aarch64 = 7,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// x86 backend.
- stage2_x86 = 8,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// riscv64 backend.
- stage2_riscv64 = 9,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// sparc64 backend.
- stage2_sparc64 = 10,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// spirv backend.
- stage2_spirv = 11,
- /// The reference implementation self-hosted compiler of Zig, using the
- /// powerpc backend.
- stage2_powerpc = 12,
-
- _,
-};
-
-/// This function type is used by the Zig language code generation and
-/// therefore must be kept in sync with the compiler implementation.
-pub const TestFn = struct {
- name: []const u8,
- func: *const fn () anyerror!void,
-};
-
-/// This namespace is used by the Zig compiler to emit various kinds of safety
-/// panics. These can be overridden by making a public `panic` namespace in the
-/// root source file.
-pub const panic: type = p: {
- if (@hasDecl(root, "panic")) {
- if (@TypeOf(root.panic) != type) {
- // Deprecated; make `panic` a namespace instead.
- break :p std.debug.FullPanic(struct {
- fn panic(msg: []const u8, ra: ?usize) noreturn {
- root.panic(msg, @errorReturnTrace(), ra);
- }
- }.panic);
- }
- break :p root.panic;
- }
- break :p switch (builtin.zig_backend) {
- .stage2_powerpc,
- .stage2_riscv64,
- => std.debug.simple_panic,
- else => std.debug.FullPanic(std.debug.defaultPanic),
- };
-};
-
-pub noinline fn returnError() void {
- @branchHint(.unlikely);
- @setRuntimeSafety(false);
- const st = @errorReturnTrace().?;
- if (st.index < st.instruction_addresses.len)
- st.instruction_addresses[st.index] = @returnAddress();
- st.index += 1;
-}
diff --git a/lib/std/lang.zig b/lib/std/lang.zig
@@ -0,0 +1,1254 @@
+//! Types and values provided by the Zig language.
+
+const builtin = @import("builtin");
+const std = @import("std.zig");
+const root = @import("root");
+
+pub const assembly = @import("lang/assembly.zig");
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const StackTrace = struct {
+ index: usize,
+ instruction_addresses: []usize,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const GlobalLinkage = enum(u2) {
+ internal,
+ strong,
+ weak,
+ link_once,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const SymbolVisibility = enum(u2) {
+ default,
+ hidden,
+ protected,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const AtomicOrder = enum {
+ unordered,
+ monotonic,
+ acquire,
+ release,
+ acq_rel,
+ seq_cst,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const ReduceOp = enum {
+ And,
+ Or,
+ Xor,
+ Min,
+ Max,
+ Add,
+ Mul,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const AtomicRmwOp = enum {
+ /// Exchange - store the operand unmodified.
+ /// Supports enums, integers, and floats.
+ Xchg,
+ /// Add operand to existing value.
+ /// Supports integers and floats.
+ /// For integers, two's complement wraparound applies.
+ Add,
+ /// Subtract operand from existing value.
+ /// Supports integers and floats.
+ /// For integers, two's complement wraparound applies.
+ Sub,
+ /// Perform bitwise AND on existing value with operand.
+ /// Supports integers.
+ And,
+ /// Perform bitwise NAND on existing value with operand.
+ /// Supports integers.
+ Nand,
+ /// Perform bitwise OR on existing value with operand.
+ /// Supports integers.
+ Or,
+ /// Perform bitwise XOR on existing value with operand.
+ /// Supports integers.
+ Xor,
+ /// Store operand if it is larger than the existing value.
+ /// Supports integers and floats.
+ Max,
+ /// Store operand if it is smaller than the existing value.
+ /// Supports integers and floats.
+ Min,
+};
+
+/// The code model puts constraints on the location of symbols and the size of code and data.
+/// The selection of a code model is a trade off on speed and restrictions that needs to be selected on a per application basis to meet its requirements.
+/// A slightly more detailed explanation can be found in (for example) the [System V Application Binary Interface (x86_64)](https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf) 3.5.1.
+///
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const CodeModel = enum {
+ default,
+ extreme,
+ kernel,
+ large,
+ medany,
+ medium,
+ medlow,
+ medmid,
+ normal,
+ small,
+ tiny,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const OptimizeMode = enum {
+ Debug,
+ ReleaseSafe,
+ ReleaseFast,
+ ReleaseSmall,
+};
+
+/// The calling convention of a function defines how arguments and return values are passed, as well
+/// as any other requirements which callers and callees must respect, such as register preservation
+/// and stack alignment.
+///
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const CallingConvention = union(enum(u8)) {
+ pub const Tag = @typeInfo(CallingConvention).@"union".tag_type.?;
+
+ /// This is an alias for the default C calling convention for this target.
+ /// Functions marked as `extern` or `export` are given this calling convention by default.
+ pub const c = builtin.target.cCallingConvention().?;
+
+ pub const winapi: CallingConvention = switch (builtin.target.cpu.arch) {
+ .x86_64 => .{ .x86_64_win = .{} },
+ .x86 => .{ .x86_stdcall = .{} },
+ .aarch64 => .{ .aarch64_aapcs_win = .{} },
+ .thumb => .{ .arm_aapcs_vfp = .{} },
+ else => unreachable,
+ };
+
+ pub const kernel: CallingConvention = switch (builtin.target.cpu.arch) {
+ .amdgcn => .amdgcn_kernel,
+ .nvptx, .nvptx64 => .nvptx_kernel,
+ .spirv32, .spirv64 => .spirv_kernel,
+ else => unreachable,
+ };
+
+ /// The default Zig calling convention when neither `export` nor `inline` is specified.
+ /// This calling convention makes no guarantees about stack alignment, registers, etc.
+ /// It can only be used within this Zig compilation unit.
+ auto,
+
+ /// The calling convention of a function that can be called with `async` syntax. An `async` call
+ /// of a runtime-known function must target a function with this calling convention.
+ /// Comptime-known functions with other calling conventions may be coerced to this one.
+ async,
+
+ /// Functions with this calling convention have no prologue or epilogue, making the function
+ /// uncallable in regular Zig code. This can be useful when integrating with assembly.
+ naked,
+
+ /// This calling convention is exactly equivalent to using the `inline` keyword on a function
+ /// definition. This function will be semantically inlined by the Zig compiler at call sites.
+ /// Pointers to inline functions are comptime-only.
+ @"inline",
+
+ // Calling conventions for the `x86_64` architecture.
+ x86_64_sysv: CommonOptions,
+ x86_64_x32: CommonOptions,
+ x86_64_win: CommonOptions,
+ x86_64_regcall_v3_sysv: CommonOptions,
+ x86_64_regcall_v4_win: CommonOptions,
+ x86_64_vectorcall: CommonOptions,
+ x86_64_interrupt: CommonOptions,
+
+ // Calling conventions for the `x86` architecture.
+ x86_sysv: X86RegparmOptions,
+ x86_win: X86RegparmOptions,
+ x86_stdcall: X86RegparmOptions,
+ x86_fastcall: CommonOptions,
+ x86_thiscall: CommonOptions,
+ x86_thiscall_mingw: CommonOptions,
+ x86_regcall_v3: CommonOptions,
+ x86_regcall_v4_win: CommonOptions,
+ x86_vectorcall: CommonOptions,
+ x86_interrupt: CommonOptions,
+
+ // Calling conventions for the `x86_16` architecture.
+
+ x86_16_cdecl: CommonOptions,
+ x86_16_stdcall: CommonOptions,
+ x86_16_regparmcall: CommonOptions,
+ x86_16_interrupt: CommonOptions,
+
+ // Calling conventions for the `aarch64` and `aarch64_be` architectures.
+ aarch64_aapcs: CommonOptions,
+ aarch64_aapcs_darwin: CommonOptions,
+ aarch64_aapcs_win: CommonOptions,
+ aarch64_vfabi: CommonOptions,
+ aarch64_vfabi_sve: CommonOptions,
+
+ /// The standard `alpha` calling convention.
+ alpha_osf: CommonOptions,
+
+ // Calling convetions for the `arm`, `armeb`, `thumb`, and `thumbeb` architectures.
+ /// ARM Architecture Procedure Call Standard
+ arm_aapcs: CommonOptions,
+ /// ARM Architecture Procedure Call Standard Vector Floating-Point
+ arm_aapcs_vfp: CommonOptions,
+ arm_interrupt: ArmInterruptOptions,
+
+ // Calling conventions for the `mips64` and `mips64el` architectures.
+ mips64_n64: CommonOptions,
+ mips64_n32: CommonOptions,
+ mips64_interrupt: MipsInterruptOptions,
+
+ // Calling conventions for the `mips` and `mipsel` architectures.
+ mips_o32: CommonOptions,
+ mips_interrupt: MipsInterruptOptions,
+
+ // Calling conventions for the `riscv64` architecture.
+ riscv64_lp64: CommonOptions,
+ riscv64_lp64_v: CommonOptions,
+ riscv64_interrupt: RiscvInterruptOptions,
+
+ // Calling conventions for the `riscv32` architecture.
+ riscv32_ilp32: CommonOptions,
+ riscv32_ilp32_v: CommonOptions,
+ riscv32_interrupt: RiscvInterruptOptions,
+
+ // Calling conventions for the `sparc64` architecture.
+ sparc64_sysv: CommonOptions,
+
+ // Calling conventions for the `sparc` architecture.
+ sparc_sysv: CommonOptions,
+
+ // Calling conventions for the `powerpc64` and `powerpc64le` architectures.
+ powerpc64_elf: CommonOptions,
+ powerpc64_elf_altivec: CommonOptions,
+ powerpc64_elf_v2: CommonOptions,
+
+ // Calling conventions for the `powerpc` and `powerpcle` architectures.
+ powerpc_sysv: CommonOptions,
+ powerpc_sysv_altivec: CommonOptions,
+ powerpc_aix: CommonOptions,
+ powerpc_aix_altivec: CommonOptions,
+
+ /// The standard `wasm32` and `wasm64` calling convention, as specified in the WebAssembly Tool Conventions.
+ wasm_mvp: CommonOptions,
+
+ /// The standard `arc`/`arceb` calling convention.
+ arc_sysv: CommonOptions,
+ arc_interrupt: ArcInterruptOptions,
+
+ // Calling conventions for the `avr` architecture.
+ avr_gnu,
+ avr_builtin,
+ avr_signal,
+ avr_interrupt,
+
+ /// The standard `bpfel`/`bpfeb` calling convention.
+ bpf_std: CommonOptions,
+
+ // Calling conventions for the `csky` architecture.
+ csky_sysv: CommonOptions,
+ csky_interrupt: CommonOptions,
+
+ // Calling conventions for the `hexagon` architecture.
+ hexagon_sysv: CommonOptions,
+ hexagon_sysv_hvx: CommonOptions,
+
+ /// The standard `hppa` calling convention.
+ hppa_elf: CommonOptions,
+
+ /// The standard `hppa64` calling convention.
+ hppa64_elf: CommonOptions,
+
+ kvx_lp64: CommonOptions,
+ kvx_ilp32: CommonOptions,
+
+ /// The standard `lanai` calling convention.
+ lanai_sysv: CommonOptions,
+
+ /// The standard `loongarch64` calling convention.
+ loongarch64_lp64: CommonOptions,
+
+ /// The standard `loongarch32` calling convention.
+ loongarch32_ilp32: CommonOptions,
+
+ // Calling conventions for the `m68k` architecture.
+ m68k_sysv: CommonOptions,
+ m68k_gnu: CommonOptions,
+ m68k_rtd: CommonOptions,
+ m68k_interrupt: CommonOptions,
+
+ /// The standard `microblaze`/`microblazeel` calling convention.
+ microblaze_std: CommonOptions,
+ microblaze_interrupt: MicroblazeInterruptOptions,
+
+ /// The standard `msp430` calling convention.
+ msp430_eabi: CommonOptions,
+ msp430_interrupt: CommonOptions,
+
+ /// The standard `or1k` calling convention.
+ or1k_sysv: CommonOptions,
+
+ /// The standard `propeller` calling convention.
+ propeller_sysv: CommonOptions,
+
+ // Calling conventions for the `s390x` architecture.
+ s390x_sysv: CommonOptions,
+ s390x_sysv_vx: CommonOptions,
+
+ // Calling conventions for the `sh`/`sheb` architecture.
+ sh_gnu: CommonOptions,
+ sh_renesas: CommonOptions,
+ sh_interrupt: ShInterruptOptions,
+
+ /// The standard `ve` calling convention.
+ ve_sysv: CommonOptions,
+
+ // Calling conventions for the `xcore` architecture.
+ xcore_xs1: CommonOptions,
+ xcore_xs2: CommonOptions,
+
+ // Calling conventions for the `xtensa`/`xtensaeb` architecture.
+ xtensa_call0: CommonOptions,
+ xtensa_windowed: CommonOptions,
+
+ // Calling conventions for the `amdgcn` architecture.
+ amdgcn_device: CommonOptions,
+ amdgcn_kernel,
+ amdgcn_cs: CommonOptions,
+
+ // Calling conventions for the `nvptx` and `nvptx64` architectures.
+ nvptx_device,
+ nvptx_kernel,
+
+ // Calling conventions for kernels and shaders on the `spirv`, `spirv32`, and `spirv64` architectures.
+ spirv_device,
+ spirv_kernel,
+ spirv_fragment,
+ spirv_vertex,
+
+ // Calling conventions for the `ez80` architecture.
+ ez80_cet,
+ ez80_tiflags,
+
+ /// Options shared across most calling conventions.
+ pub const CommonOptions = struct {
+ /// The boundary the stack is aligned to when the function is called.
+ /// `null` means the default for this calling convention.
+ incoming_stack_alignment: ?u64 = null,
+ };
+
+ /// Options for x86 calling conventions which support the regparm attribute to pass some
+ /// arguments in registers.
+ pub const X86RegparmOptions = struct {
+ /// The boundary the stack is aligned to when the function is called.
+ /// `null` means the default for this calling convention.
+ incoming_stack_alignment: ?u64 = null,
+ /// The number of arguments to pass in registers before passing the remaining arguments
+ /// according to the calling convention.
+ /// Equivalent to `__attribute__((regparm(x)))` in Clang and GCC.
+ register_params: u2 = 0,
+ };
+
+ /// Options for the `arc_interrupt` calling convention.
+ pub const ArcInterruptOptions = struct {
+ /// The boundary the stack is aligned to when the function is called.
+ /// `null` means the default for this calling convention.
+ incoming_stack_alignment: ?u64 = null,
+ /// The kind of interrupt being received.
+ type: InterruptType,
+
+ pub const InterruptType = enum(u2) {
+ ilink1,
+ ilink2,
+ ilink,
+ firq,
+ };
+ };
+
+ /// Options for the `arm_interrupt` calling convention.
+ pub const ArmInterruptOptions = struct {
+ /// The boundary the stack is aligned to when the function is called.
+ /// `null` means the default for this calling convention.
+ incoming_stack_alignment: ?u64 = null,
+ /// The kind of interrupt being received.
+ type: InterruptType = .generic,
+
+ pub const InterruptType = enum(u3) {
+ generic,
+ irq,
+ fiq,
+ swi,
+ abort,
+ undef,
+ };
+ };
+
+ /// Options for the `microblaze_interrupt` calling convention.
+ pub const MicroblazeInterruptOptions = struct {
+ /// The boundary the stack is aligned to when the function is called.
+ /// `null` means the default for this calling convention.
+ incoming_stack_alignment: ?u64 = null,
+ type: InterruptType = .regular,
+
+ pub const InterruptType = enum(u2) {
+ /// User exception; return with `rtsd`.
+ user,
+ /// Regular interrupt; return with `rtid`.
+ regular,
+ /// Fast interrupt; return with `rtid`.
+ fast,
+ /// Software breakpoint; return with `rtbd`.
+ breakpoint,
+ };
+ };
+
+ /// Options for the `mips_interrupt` and `mips64_interrupt` calling conventions.
+ pub const MipsInterruptOptions = struct {
+ /// The boundary the stack is aligned to when the function is called.
+ /// `null` means the default for this calling convention.
+ incoming_stack_alignment: ?u64 = null,
+ /// The interrupt mode.
+ mode: InterruptMode = .eic,
+
+ pub const InterruptMode = enum(u4) {
+ eic,
+ sw0,
+ sw1,
+ hw0,
+ hw1,
+ hw2,
+ hw3,
+ hw4,
+ hw5,
+ };
+ };
+
+ /// Options for the `riscv32_interrupt` and `riscv64_interrupt` calling conventions.
+ pub const RiscvInterruptOptions = struct {
+ /// The boundary the stack is aligned to when the function is called.
+ /// `null` means the default for this calling convention.
+ incoming_stack_alignment: ?u64 = null,
+ /// The privilege mode.
+ mode: PrivilegeMode,
+
+ pub const PrivilegeMode = enum(u2) {
+ supervisor,
+ machine,
+ };
+ };
+
+ /// Options for the `sh_interrupt` calling convention.
+ pub const ShInterruptOptions = struct {
+ /// The boundary the stack is aligned to when the function is called.
+ /// `null` means the default for this calling convention.
+ incoming_stack_alignment: ?u64 = null,
+ save: SaveBehavior = .full,
+
+ pub const SaveBehavior = enum(u3) {
+ /// Save only fpscr (if applicable).
+ fpscr,
+ /// Save only high-numbered registers, i.e. r0 through r7 are *not* saved.
+ high,
+ /// Save all registers normally.
+ full,
+ /// Save all registers using the CPU's fast register bank.
+ bank,
+ };
+ };
+
+ /// Returns the array of `std.Target.Cpu.Arch` to which this `CallingConvention` applies.
+ /// Asserts that `cc` is not `.auto`, `.@"async"`, `.naked`, or `.@"inline"`.
+ pub fn archs(cc: CallingConvention) []const std.Target.Cpu.Arch {
+ return std.Target.Cpu.Arch.fromCallingConvention(cc);
+ }
+
+ pub fn eql(a: CallingConvention, b: CallingConvention) bool {
+ return std.meta.eql(a, b);
+ }
+
+ pub fn withStackAlign(cc: CallingConvention, incoming_stack_alignment: u64) CallingConvention {
+ const tag: CallingConvention.Tag = cc;
+ var result = cc;
+ @field(result, @tagName(tag)).incoming_stack_alignment = incoming_stack_alignment;
+ return result;
+ }
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const AddressSpace = enum(u5) {
+ // CPU address spaces.
+ generic,
+ gs,
+ fs,
+ ss,
+
+ // x86_16 extra address spaces.
+ /// Allows addressing the entire address space by storing both segment and offset.
+ far,
+
+ // GPU address spaces.
+ global,
+ constant,
+ param,
+ shared,
+ local,
+ input,
+ output,
+ uniform,
+ push_constant,
+ storage_buffer,
+ physical_storage_buffer,
+
+ // AVR address spaces.
+ flash,
+ flash1,
+ flash2,
+ flash3,
+ flash4,
+ flash5,
+
+ // Propeller address spaces.
+
+ /// This address space only addresses the cog-local ram.
+ cog,
+
+ /// This address space only addresses shared hub ram.
+ hub,
+
+ /// This address space only addresses the "lookup" ram
+ lut,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const SourceLocation = struct {
+ /// The name chosen when compiling. Not a file path.
+ module: [:0]const u8,
+ /// Relative to the root directory of its module.
+ file: [:0]const u8,
+ fn_name: [:0]const u8,
+ line: u32,
+ column: u32,
+};
+
+pub const TypeId = std.meta.Tag(Type);
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const Type = union(enum) {
+ type,
+ void,
+ bool,
+ noreturn,
+ int: Int,
+ float: Float,
+ pointer: Pointer,
+ array: Array,
+ @"struct": Struct,
+ comptime_float,
+ comptime_int,
+ undefined,
+ null,
+ optional: Optional,
+ error_union: ErrorUnion,
+ error_set: ErrorSet,
+ @"enum": Enum,
+ @"union": Union,
+ @"fn": Fn,
+ @"opaque": Opaque,
+ frame: Frame,
+ @"anyframe": AnyFrame,
+ vector: Vector,
+ enum_literal,
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Int = struct {
+ signedness: Signedness,
+ bits: u16,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Float = struct {
+ bits: u16,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Pointer = struct {
+ size: Size,
+ is_const: bool,
+ is_volatile: bool,
+ /// `null` means implicit alignment, which is equivalent to `@alignOf(child)`.
+ alignment: ?usize,
+ address_space: AddressSpace,
+ child: type,
+ is_allowzero: bool,
+
+ /// The type of the sentinel is the element type of the pointer, which is
+ /// the value of the `child` field in this struct. However there is no way
+ /// to refer to that type here, so we use `*const anyopaque`.
+ /// See also: `sentinel`
+ sentinel_ptr: ?*const anyopaque,
+
+ /// Loads the pointer type's sentinel value from `sentinel_ptr`.
+ /// Returns `null` if the pointer type has no sentinel.
+ pub inline fn sentinel(comptime ptr: Pointer) ?ptr.child {
+ const sp: *const ptr.child = @ptrCast(@alignCast(ptr.sentinel_ptr orelse return null));
+ return sp.*;
+ }
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Size = enum(u2) {
+ one,
+ many,
+ slice,
+ c,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Attributes = struct {
+ @"const": bool = false,
+ @"volatile": bool = false,
+ @"allowzero": bool = false,
+ @"addrspace": ?AddressSpace = null,
+ @"align": ?usize = null,
+ };
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Array = struct {
+ len: comptime_int,
+ child: type,
+
+ /// The type of the sentinel is the element type of the array, which is
+ /// the value of the `child` field in this struct. However there is no way
+ /// to refer to that type here, so we use `*const anyopaque`.
+ /// See also: `sentinel`.
+ sentinel_ptr: ?*const anyopaque,
+
+ /// Loads the array type's sentinel value from `sentinel_ptr`.
+ /// Returns `null` if the array type has no sentinel.
+ pub inline fn sentinel(comptime arr: Array) ?arr.child {
+ const sp: *const arr.child = @ptrCast(@alignCast(arr.sentinel_ptr orelse return null));
+ return sp.*;
+ }
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const ContainerLayout = enum(u2) {
+ auto,
+ @"extern",
+ @"packed",
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const StructField = struct {
+ name: [:0]const u8,
+ type: type,
+ /// The type of the default value is the type of this struct field, which
+ /// is the value of the `type` field in this struct. However there is no
+ /// way to refer to that type here, so we use `*const anyopaque`.
+ /// See also: `defaultValue`.
+ default_value_ptr: ?*const anyopaque,
+ is_comptime: bool,
+ /// `null` means the field alignment was not explicitly specified. The
+ /// field will still be aligned to at least `@alignOf` its `type`.
+ alignment: ?usize,
+
+ /// Loads the field's default value from `default_value_ptr`.
+ /// Returns `null` if the field has no default value.
+ pub inline fn defaultValue(comptime sf: StructField) ?sf.type {
+ const dp: *const sf.type = @ptrCast(@alignCast(sf.default_value_ptr orelse return null));
+ return dp.*;
+ }
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Attributes = struct {
+ @"comptime": bool = false,
+ @"align": ?usize = null,
+ default_value_ptr: ?*const anyopaque = null,
+ };
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Struct = struct {
+ layout: ContainerLayout,
+ /// Only valid if layout is .@"packed"
+ backing_integer: ?type = null,
+ fields: []const StructField,
+ decls: []const Declaration,
+ is_tuple: bool,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Optional = struct {
+ child: type,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const ErrorUnion = struct {
+ error_set: type,
+ payload: type,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Error = struct {
+ name: [:0]const u8,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const ErrorSet = ?[]const Error;
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const EnumField = struct {
+ name: [:0]const u8,
+ value: comptime_int,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Enum = struct {
+ tag_type: type,
+ fields: []const EnumField,
+ decls: []const Declaration,
+ is_exhaustive: bool,
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Mode = enum { exhaustive, nonexhaustive };
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const UnionField = struct {
+ name: [:0]const u8,
+ type: type,
+ /// `null` means the field alignment was not explicitly specified. The
+ /// field will still be aligned to at least `@alignOf` its `type`.
+ alignment: ?usize,
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Attributes = struct {
+ @"align": ?usize = null,
+ };
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Union = struct {
+ layout: ContainerLayout,
+ tag_type: ?type,
+ fields: []const UnionField,
+ decls: []const Declaration,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Fn = struct {
+ calling_convention: CallingConvention,
+ is_generic: bool,
+ is_var_args: bool,
+ /// TODO change the language spec to make this not optional.
+ return_type: ?type,
+ params: []const Param,
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Param = struct {
+ is_generic: bool,
+ is_noalias: bool,
+ type: ?type,
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Attributes = struct {
+ @"noalias": bool = false,
+ };
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Attributes = struct {
+ @"callconv": CallingConvention = .auto,
+ varargs: bool = false,
+ };
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Opaque = struct {
+ decls: []const Declaration,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Frame = struct {
+ function: *const anyopaque,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const AnyFrame = struct {
+ child: ?type,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Vector = struct {
+ len: comptime_int,
+ child: type,
+ };
+
+ /// This data structure is used by the Zig language code generation and
+ /// therefore must be kept in sync with the compiler implementation.
+ pub const Declaration = struct {
+ name: [:0]const u8,
+ };
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const FloatMode = enum {
+ strict,
+ optimized,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const Endian = enum {
+ big,
+ little,
+
+ pub const native = builtin.target.cpu.arch.endian();
+ pub const foreign: Endian = @enumFromInt(1 - @intFromEnum(native));
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const Signedness = enum(u1) {
+ signed,
+ unsigned,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const OutputMode = enum {
+ Exe,
+ Lib,
+ Obj,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const LinkMode = enum {
+ static,
+ dynamic,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const UnwindTables = enum {
+ none,
+ sync,
+ async,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const WasiExecModel = enum {
+ command,
+ reactor,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const CallModifier = enum {
+ /// Equivalent to function call syntax.
+ auto,
+ /// Prevents tail call optimization. This guarantees that the return
+ /// address will point to the callsite, as opposed to the callsite's
+ /// callsite. If the call is otherwise required to be tail-called
+ /// or inlined, a compile error is emitted instead.
+ never_tail,
+ /// Guarantees that the call will not be inlined. If the call is
+ /// otherwise required to be inlined, a compile error is emitted instead.
+ never_inline,
+ /// Asserts that the function call will not suspend. This allows a
+ /// non-async function to call an async function.
+ no_suspend,
+ /// Guarantees that the call will be generated with tail call optimization.
+ /// If this is not possible, a compile error is emitted instead.
+ always_tail,
+ /// Guarantees that the call will be inlined at the callsite.
+ /// If this is not possible, a compile error is emitted instead.
+ always_inline,
+ /// Evaluates the call at compile-time. If the call cannot be completed at
+ /// compile-time, a compile error is emitted instead.
+ compile_time,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const VaListAarch64 = extern struct {
+ __stack: *anyopaque,
+ __gr_top: *anyopaque,
+ __vr_top: *anyopaque,
+ __gr_offs: c_int,
+ __vr_offs: c_int,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const VaListAlpha = extern struct {
+ __base: *anyopaque,
+ __offset: c_int,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const VaListArm = extern struct {
+ __ap: *anyopaque,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const VaListHexagon = extern struct {
+ __gpr: c_long,
+ __fpr: c_long,
+ __overflow_arg_area: *anyopaque,
+ __reg_save_area: *anyopaque,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const VaListPowerPc = extern struct {
+ gpr: u8,
+ fpr: u8,
+ reserved: c_ushort,
+ overflow_arg_area: *anyopaque,
+ reg_save_area: *anyopaque,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const VaListS390x = extern struct {
+ __current_saved_reg_area_pointer: *anyopaque,
+ __saved_reg_area_end_pointer: *anyopaque,
+ __overflow_area_pointer: *anyopaque,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const VaListSh = extern struct {
+ __va_next_o: *anyopaque,
+ __va_next_o_limit: *anyopaque,
+ __va_next_fp: *anyopaque,
+ __va_next_fp_limit: *anyopaque,
+ __va_next_stack: *anyopaque,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const VaListX86_64 = extern struct {
+ gp_offset: c_uint,
+ fp_offset: c_uint,
+ overflow_arg_area: *anyopaque,
+ reg_save_area: *anyopaque,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const VaListXtensa = extern struct {
+ __va_stk: *c_int,
+ __va_reg: *c_int,
+ __va_ndx: c_int,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const VaList = switch (builtin.cpu.arch) {
+ .amdgcn,
+ .msp430,
+ .nvptx,
+ .nvptx64,
+ .powerpc64,
+ .powerpc64le,
+ .x86,
+ => *u8,
+ .arc,
+ .arceb,
+ .avr,
+ .bpfel,
+ .bpfeb,
+ .csky,
+ .hppa,
+ .hppa64,
+ .kvx,
+ .lanai,
+ .loongarch32,
+ .loongarch64,
+ .m68k,
+ .microblaze,
+ .microblazeel,
+ .mips,
+ .mipsel,
+ .mips64,
+ .mips64el,
+ .riscv32,
+ .riscv32be,
+ .riscv64,
+ .riscv64be,
+ .sparc,
+ .sparc64,
+ .spirv32,
+ .spirv64,
+ .ve,
+ .wasm32,
+ .wasm64,
+ .xcore,
+ => *anyopaque,
+ .aarch64, .aarch64_be => switch (builtin.os.tag) {
+ .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos, .windows => *u8,
+ else => switch (builtin.zig_backend) {
+ else => VaListAarch64,
+ .stage2_llvm => @compileError("disabled due to miscompilations"),
+ },
+ },
+ .alpha => VaListAlpha,
+ .arm, .armeb, .thumb, .thumbeb => VaListArm,
+ .hexagon => if (builtin.target.abi.isMusl()) VaListHexagon else *u8,
+ .powerpc, .powerpcle => VaListPowerPc,
+ .s390x => VaListS390x,
+ .sh, .sheb => VaListSh, // This is wrong for `sh_renesas`: https://github.com/ziglang/zig/issues/24692#issuecomment-3150779829
+ .x86_64 => switch (builtin.os.tag) {
+ .uefi, .windows => switch (builtin.zig_backend) {
+ else => *u8,
+ .stage2_llvm => @compileError("disabled due to miscompilations"),
+ },
+ else => VaListX86_64,
+ },
+ .xtensa, .xtensaeb => VaListXtensa,
+ else => @compileError("VaList not supported for this target yet"),
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const PrefetchOptions = struct {
+ /// Whether the prefetch should prepare for a read or a write.
+ rw: Rw = .read,
+ /// The data's locality in an inclusive range from 0 to 3.
+ ///
+ /// 0 means no temporal locality. That is, the data can be immediately
+ /// dropped from the cache after it is accessed.
+ ///
+ /// 3 means high temporal locality. That is, the data should be kept in
+ /// the cache as it is likely to be accessed again soon.
+ locality: u2 = 3,
+ /// The cache that the prefetch should be performed on.
+ cache: Cache = .data,
+
+ pub const Rw = enum(u1) {
+ read,
+ write,
+ };
+
+ pub const Cache = enum(u1) {
+ instruction,
+ data,
+ };
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const ExportOptions = struct {
+ name: []const u8,
+ linkage: GlobalLinkage = .strong,
+ section: ?[]const u8 = null,
+ visibility: SymbolVisibility = .default,
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const ExternOptions = struct {
+ name: []const u8,
+ library_name: ?[]const u8 = null,
+ linkage: GlobalLinkage = .strong,
+ visibility: SymbolVisibility = .default,
+ /// Setting this to `true` makes the `@extern` a runtime value.
+ is_thread_local: bool = false,
+ is_dll_import: bool = false,
+ relocation: Relocation = .any,
+ decoration: ?Decoration = null,
+
+ pub const Decoration = union(enum) {
+ location: u32,
+ descriptor: Descriptor,
+
+ pub const Descriptor = struct {
+ binding: u32,
+ set: u32,
+ };
+ };
+
+ pub const Relocation = enum(u1) {
+ /// Any type of relocation is allowed.
+ any,
+ /// A program-counter-relative relocation is required.
+ /// Using this value makes the `@extern` a runtime value.
+ pcrel,
+ };
+};
+
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const BranchHint = enum(u3) {
+ /// Equivalent to no hint given.
+ none,
+ /// This branch of control flow is more likely to be reached than its peers.
+ /// The optimizer should optimize for reaching it.
+ likely,
+ /// This branch of control flow is less likely to be reached than its peers.
+ /// The optimizer should optimize for not reaching it.
+ unlikely,
+ /// This branch of control flow is unlikely to *ever* be reached.
+ /// The optimizer may place it in a different page of memory to optimize other branches.
+ cold,
+ /// It is difficult to predict whether this branch of control flow will be reached.
+ /// The optimizer should avoid branching behavior with expensive mispredictions.
+ unpredictable,
+};
+
+/// This enum is set by the compiler and communicates which compiler backend is
+/// used to produce machine code.
+/// Think carefully before deciding to observe this value. Nearly all code should
+/// be agnostic to the backend that implements the language. The use case
+/// to use this value is to **work around problems with compiler implementations.**
+///
+/// Avoid failing the compilation if the compiler backend does not match a
+/// whitelist of backends; rather one should detect that a known problem would
+/// occur in a blacklist of backends.
+///
+/// The enum is nonexhaustive so that alternate Zig language implementations may
+/// choose a number as their tag (please use a random number generator rather
+/// than a "cute" number) and codebases can interact with these values even if
+/// this upstream enum does not have a name for the number. Of course, upstream
+/// is happy to accept pull requests to add Zig implementations to this enum.
+///
+/// This data structure is part of the Zig language specification.
+pub const CompilerBackend = enum(u64) {
+ /// It is allowed for a compiler implementation to not reveal its identity,
+ /// in which case this value is appropriate. Be cool and make sure your
+ /// code supports `other` Zig compilers!
+ other = 0,
+ /// The original Zig compiler created in 2015 by Andrew Kelley. Implemented
+ /// in C++. Used LLVM. Deleted from the ZSF ziglang/zig codebase on
+ /// December 6th, 2022.
+ stage1 = 1,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// LLVM backend.
+ stage2_llvm = 2,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// backend that generates C source code.
+ /// Note that one can observe whether the compilation will output C code
+ /// directly with `object_format` value rather than the `compiler_backend` value.
+ stage2_c = 3,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// WebAssembly backend.
+ stage2_wasm = 4,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// arm backend.
+ stage2_arm = 5,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// x86_64 backend.
+ stage2_x86_64 = 6,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// aarch64 backend.
+ stage2_aarch64 = 7,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// x86 backend.
+ stage2_x86 = 8,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// riscv64 backend.
+ stage2_riscv64 = 9,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// sparc64 backend.
+ stage2_sparc64 = 10,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// spirv backend.
+ stage2_spirv = 11,
+ /// The reference implementation self-hosted compiler of Zig, using the
+ /// powerpc backend.
+ stage2_powerpc = 12,
+
+ _,
+};
+
+/// This function type is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const TestFn = struct {
+ name: []const u8,
+ func: *const fn () anyerror!void,
+};
+
+/// This namespace is used by the Zig compiler to emit various kinds of safety
+/// panics. These can be overridden by making a public `panic` namespace in the
+/// root source file.
+pub const panic: type = p: {
+ if (@hasDecl(root, "panic")) {
+ if (@TypeOf(root.panic) != type) {
+ // Deprecated; make `panic` a namespace instead.
+ break :p std.debug.FullPanic(struct {
+ fn panic(msg: []const u8, ra: ?usize) noreturn {
+ root.panic(msg, @errorReturnTrace(), ra);
+ }
+ }.panic);
+ }
+ break :p root.panic;
+ }
+ break :p switch (builtin.zig_backend) {
+ .stage2_powerpc,
+ .stage2_riscv64,
+ => std.debug.simple_panic,
+ else => std.debug.FullPanic(std.debug.defaultPanic),
+ };
+};
+
+pub noinline fn returnError() void {
+ @branchHint(.unlikely);
+ @setRuntimeSafety(false);
+ const st = @errorReturnTrace().?;
+ if (st.index < st.instruction_addresses.len)
+ st.instruction_addresses[st.index] = @returnAddress();
+ st.index += 1;
+}
diff --git a/lib/std/builtin/assembly.zig b/lib/std/lang/assembly.zig
diff --git a/lib/std/std.zig b/lib/std/std.zig
@@ -65,8 +65,11 @@ pub const array_hash_map = @import("array_hash_map.zig");
pub const atomic = @import("atomic.zig");
pub const base64 = @import("base64.zig");
pub const bit_set = @import("bit_set.zig");
+/// Deprecated; use `lang`.
+///
+/// To be removed after Zig 0.17.0.
pub const builtin = lang;
-pub const lang = @import("builtin.zig");
+pub const lang = @import("lang.zig");
pub const c = @import("c.zig");
pub const coff = @import("coff.zig");
pub const compress = @import("compress.zig");
