commit 7eb79daffb16426d1ed78316d5fdf9ff0d015a83 (tree) parent ebff436985c9410d2a2759c69a277fcb30831a87 Author: mlugg <mlugg@noreply.codeberg.org> Date: Wed, 6 May 2026 10:10:44 +0200 Merge pull request '`std.builtin` -> `std.lang` migration progress' (#32182) from compiler-std-lang into master Reviewed-on: https://codeberg.org/ziglang/zig/pulls/32182 Diffstat:
76 files changed, 2086 insertions(+), 2086 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/build.zig b/build.zig @@ -1,5 +1,4 @@ const std = @import("std"); -const builtin = std.builtin; const BufMap = std.BufMap; const mem = std.mem; const fs = std.fs; @@ -191,7 +190,7 @@ pub fn build(b: *std.Build) !void { const valgrind = b.option(bool, "valgrind", "Enable valgrind integration"); const pie = b.option(bool, "pie", "Produce a Position Independent Executable"); const io_mode = b.option(IoMode, "io-mode", "How the compiler performs IO") orelse .threaded; - const value_interpret_mode = b.option(ValueInterpretMode, "value-interpret-mode", "How the compiler translates between 'std.builtin' types and its internal datastructures") orelse .direct; + const value_interpret_mode = b.option(ValueInterpretMode, "value-interpret-mode", "How the compiler translates between 'std.lang' types and its internal datastructures") orelse .direct; const value_tracing = b.option(bool, "value-tracing", "Enable extra state tracking to help troubleshoot bugs in the compiler (using the std.debug.Trace API)") orelse false; const mem_leak_frames: u32 = b.option(u32, "mem-leak-frames", "How many stack frames to print when a memory leak occurs. Tests get 2x this amount.") orelse blk: { @@ -398,22 +397,22 @@ pub fn build(b: *std.Build) !void { const test_target_filters = b.option([]const []const u8, "test-target-filter", "Skip tests whose target triple do not match any filter") orelse &[0][]const u8{}; const test_extra_targets = b.option(bool, "test-extra-targets", "Enable running module tests for additional targets") orelse false; - var chosen_opt_modes_buf: [4]builtin.OptimizeMode = undefined; + var chosen_opt_modes_buf: [4]std.lang.OptimizeMode = undefined; var chosen_mode_index: usize = 0; if (!skip_debug) { - chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.Debug; + chosen_opt_modes_buf[chosen_mode_index] = .Debug; chosen_mode_index += 1; } if (!skip_release_safe) { - chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseSafe; + chosen_opt_modes_buf[chosen_mode_index] = .ReleaseSafe; chosen_mode_index += 1; } if (!skip_release_fast) { - chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseFast; + chosen_opt_modes_buf[chosen_mode_index] = .ReleaseFast; chosen_mode_index += 1; } if (!skip_release_small) { - chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseSmall; + chosen_opt_modes_buf[chosen_mode_index] = .ReleaseSmall; chosen_mode_index += 1; } const optimize_modes = chosen_opt_modes_buf[0..chosen_mode_index]; @@ -706,11 +705,11 @@ fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void { // // * We lose a small amount of performance. This is essentially irrelevant for zig1. // - // * We lose the ability to perform trivial renames on certain `std.builtin` types without + // * We lose the ability to perform trivial renames on certain `std.lang` types without // zig1.wasm updates. For instance, we cannot rename an enum from PascalCase fields to // snake_case fields without an update. // - // * We gain the ability to add and remove fields to and from `std.builtin` types without + // * We gain the ability to add and remove fields to and from `std.lang` types without // zig1.wasm updates. For instance, we can add a new tag to `CallingConvention` without // an update. // @@ -740,7 +739,7 @@ fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void { } const AddCompilerModOptions = struct { - optimize: std.builtin.OptimizeMode, + optimize: std.lang.OptimizeMode, target: std.Build.ResolvedTarget, strip: ?bool = null, valgrind: ?bool = null, @@ -1029,7 +1028,7 @@ fn addCMakeLibraryList(mod: *std.Build.Module, list: []const u8) void { } const CMakeConfig = struct { - llvm_linkage: std.builtin.LinkMode, + llvm_linkage: std.lang.LinkMode, cmake_binary_dir: []const u8, cmake_prefix_path: []const u8, cmake_static_library_prefix: []const u8, diff --git a/doc/langref.html.in b/doc/langref.html.in @@ -3771,7 +3771,7 @@ void do_a_thing(struct Foo *foo) { <tr> <th scope="row">{#syntax#}@Int(x, y){#endsyntax#}</th> <td>-</td> - <td>{#syntax#}x{#endsyntax#} is a {#syntax#}std.builtin.Signedness{#endsyntax#}, {#syntax#}y{#endsyntax#} is a {#syntax#}u16{#endsyntax#}</td> + <td>{#syntax#}x{#endsyntax#} is a {#syntax#}std.lang.Signedness{#endsyntax#}, {#syntax#}y{#endsyntax#} is a {#syntax#}u16{#endsyntax#}</td> </tr> <tr> <th scope="row">{#syntax#}@typeInfo(x){#endsyntax#}</th> @@ -4381,7 +4381,7 @@ comptime { {#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float, an integer, an enum, or a packed struct. </p> - <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p> + <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").lang.AtomicOrder{#endsyntax#}.</p> {#see_also|@atomicStore|@atomicRmw||@cmpxchgWeak|@cmpxchgStrong#} {#header_close#} @@ -4395,8 +4395,8 @@ comptime { {#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float, an integer, an enum, or a packed struct. </p> - <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p> - <p>{#syntax#}AtomicRmwOp{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicRmwOp{#endsyntax#}.</p> + <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").lang.AtomicOrder{#endsyntax#}.</p> + <p>{#syntax#}AtomicRmwOp{#endsyntax#} can be found with {#syntax#}@import("std").lang.AtomicRmwOp{#endsyntax#}.</p> {#see_also|@atomicStore|@atomicLoad|@cmpxchgWeak|@cmpxchgStrong#} {#header_close#} @@ -4409,7 +4409,7 @@ comptime { {#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float, an integer, an enum, or a packed struct. </p> - <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p> + <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").lang.AtomicOrder{#endsyntax#}.</p> {#see_also|@atomicLoad|@atomicRmw|@cmpxchgWeak|@cmpxchgStrong#} {#header_close#} @@ -4467,7 +4467,7 @@ comptime { {#header_open|@branchHint#} <pre>{#syntax#}@branchHint(hint: BranchHint) void{#endsyntax#}</pre> <p>Hints to the optimizer how likely a given branch of control flow is to be reached.</p> - <p>{#syntax#}BranchHint{#endsyntax#} can be found with {#syntax#}@import("std").builtin.BranchHint{#endsyntax#}.</p> + <p>{#syntax#}BranchHint{#endsyntax#} can be found with {#syntax#}@import("std").lang.BranchHint{#endsyntax#}.</p> <p>This function is only valid as the first statement in a control flow branch, or the first statement in a function.</p> {#header_close#} @@ -4534,7 +4534,7 @@ comptime { {#header_close#} {#header_open|@call#} - <pre>{#syntax#}@call(modifier: std.builtin.CallModifier, function: anytype, args: anytype) anytype{#endsyntax#}</pre> + <pre>{#syntax#}@call(modifier: std.lang.CallModifier, function: anytype, args: anytype) anytype{#endsyntax#}</pre> <p> Calls a function, in the same way that invoking an expression with parentheses does: </p> @@ -4544,7 +4544,7 @@ comptime { {#syntax#}@call{#endsyntax#} allows more flexibility than normal function call syntax does. The {#syntax#}CallModifier{#endsyntax#} enum is reproduced here: </p> - {#code|builtin.CallModifier struct.zig#} + {#code|lang.CallModifier struct.zig#} {#header_close#} @@ -4584,7 +4584,7 @@ comptime { an integer, an enum, or a packed struct. </p> <p>{#syntax#}@typeInfo(@TypeOf(ptr)).pointer.alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p> - <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p> + <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").lang.AtomicOrder{#endsyntax#}.</p> {#see_also|@atomicStore|@atomicLoad|@atomicRmw|@cmpxchgWeak#} {#header_close#} @@ -4616,7 +4616,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val an integer, an enum, or a packed struct. </p> <p>{#syntax#}@typeInfo(@TypeOf(ptr)).pointer.alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p> - <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").builtin.AtomicOrder{#endsyntax#}.</p> + <p>{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("std").lang.AtomicOrder{#endsyntax#}.</p> {#see_also|@atomicStore|@atomicLoad|@atomicRmw|@cmpxchgStrong#} {#header_close#} @@ -4678,28 +4678,28 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_close#} {#header_open|@cVaArg#} - <pre>{#syntax#}@cVaArg(operand: *std.builtin.VaList, comptime T: type) T{#endsyntax#}</pre> + <pre>{#syntax#}@cVaArg(operand: *std.lang.VaList, comptime T: type) T{#endsyntax#}</pre> <p> Implements the C macro {#syntax#}va_arg{#endsyntax#}. </p> {#see_also|@cVaCopy|@cVaEnd|@cVaStart#} {#header_close#} {#header_open|@cVaCopy#} - <pre>{#syntax#}@cVaCopy(src: *std.builtin.VaList) std.builtin.VaList{#endsyntax#}</pre> + <pre>{#syntax#}@cVaCopy(src: *std.lang.VaList) std.lang.VaList{#endsyntax#}</pre> <p> Implements the C macro {#syntax#}va_copy{#endsyntax#}. </p> {#see_also|@cVaArg|@cVaEnd|@cVaStart#} {#header_close#} {#header_open|@cVaEnd#} - <pre>{#syntax#}@cVaEnd(src: *std.builtin.VaList) void{#endsyntax#}</pre> + <pre>{#syntax#}@cVaEnd(src: *std.lang.VaList) void{#endsyntax#}</pre> <p> Implements the C macro {#syntax#}va_end{#endsyntax#}. </p> {#see_also|@cVaArg|@cVaCopy|@cVaStart#} {#header_close#} {#header_open|@cVaStart#} - <pre>{#syntax#}@cVaStart() std.builtin.VaList{#endsyntax#}</pre> + <pre>{#syntax#}@cVaStart() std.lang.VaList{#endsyntax#}</pre> <p> Implements the C macro {#syntax#}va_start{#endsyntax#}. Only valid inside a variadic function. </p> @@ -4808,7 +4808,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_close#} {#header_open|@errorReturnTrace#} - <pre>{#syntax#}@errorReturnTrace() ?*builtin.StackTrace{#endsyntax#}</pre> + <pre>{#syntax#}@errorReturnTrace() ?*std.lang.StackTrace{#endsyntax#}</pre> <p> If the binary is built with error return tracing, and this function is invoked in a function that calls a function with an error or error union return type, returns a @@ -4826,7 +4826,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_close#} {#header_open|@export#} - <pre>{#syntax#}@export(comptime ptr: *const anyopaque, comptime options: std.builtin.ExportOptions) void{#endsyntax#}</pre> + <pre>{#syntax#}@export(comptime ptr: *const anyopaque, comptime options: std.lang.ExportOptions) void{#endsyntax#}</pre> <p>Creates a symbol in the output object file which refers to the target of <code>ptr</code>.</p> <p><code>ptr</code> must point to a global variable or a comptime-known constant.</p> <p> @@ -4852,7 +4852,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_close#} {#header_open|@extern#} - <pre>{#syntax#}@extern(T: type, comptime options: std.builtin.ExternOptions) T{#endsyntax#}</pre> + <pre>{#syntax#}@extern(T: type, comptime options: std.lang.ExternOptions) T{#endsyntax#}</pre> <p> Creates a reference to an external symbol in the output object file. T must be a pointer type. @@ -5173,8 +5173,8 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val <p> Invokes the panic handler function. By default the panic handler function calls the public {#syntax#}panic{#endsyntax#} function exposed in the root source file, or - if there is not one specified, the {#syntax#}std.builtin.default_panic{#endsyntax#} - function from {#syntax#}std/builtin.zig{#endsyntax#}. + if there is not one specified, the {#syntax#}std.lang.default_panic{#endsyntax#} + function from {#syntax#}std/lang.zig{#endsyntax#}. </p> <p>Generally it is better to use {#syntax#}@import("std").debug.panic{#endsyntax#}. However, {#syntax#}@panic{#endsyntax#} can be useful for 2 scenarios: @@ -5213,7 +5213,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no Illegal Behavior will result. </p> - <p>{#syntax#}PrefetchOptions{#endsyntax#} can be found with {#syntax#}@import("std").builtin.PrefetchOptions{#endsyntax#}.</p> + <p>{#syntax#}PrefetchOptions{#endsyntax#} can be found with {#syntax#}@import("std").lang.PrefetchOptions{#endsyntax#}.</p> {#header_close#} {#header_open|@ptrCast#} @@ -5336,7 +5336,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block. </p> - <p>{#syntax#}FloatMode{#endsyntax#} can be found with {#syntax#}@import("std").builtin.FloatMode{#endsyntax#}.</p> + <p>{#syntax#}FloatMode{#endsyntax#} can be found with {#syntax#}@import("std").lang.FloatMode{#endsyntax#}.</p> {#see_also|Floating Point Operations#} {#header_close#} @@ -5472,7 +5472,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_close#} {#header_open|@reduce#} - <pre>{#syntax#}@reduce(comptime op: std.builtin.ReduceOp, value: anytype) E{#endsyntax#}</pre> + <pre>{#syntax#}@reduce(comptime op: std.lang.ReduceOp, value: anytype) E{#endsyntax#}</pre> <p> Transforms a {#link|vector|Vectors#} into a scalar value (of type <code>E</code>) by performing a sequential horizontal reduction of its elements using the @@ -5502,7 +5502,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_close#} {#header_open|@src#} - <pre>{#syntax#}@src() std.builtin.SourceLocation{#endsyntax#}</pre> + <pre>{#syntax#}@src() std.lang.SourceLocation{#endsyntax#}</pre> <p> Returns a {#syntax#}SourceLocation{#endsyntax#} struct representing the function's name and location in the source code. This must be called in a function. </p> @@ -5729,7 +5729,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_close#} {#header_open|@Int#} - <pre>{#syntax#}@Int(comptime signedness: std.builtin.Signedness, comptime bits: u16) type{#endsyntax#}</pre> + <pre>{#syntax#}@Int(comptime signedness: std.lang.Signedness, comptime bits: u16) type{#endsyntax#}</pre> <p>Returns an integer type with the given signedness and bit width.</p> <p>For instance, {#syntax#}@Int(.unsigned, 18){#endsyntax#} returns the type {#syntax#}u18{#endsyntax#}.</p> {#header_close#} @@ -5741,8 +5741,8 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_open|@Pointer#} <pre>{#syntax#}@Pointer( - comptime size: std.builtin.Type.Pointer.Size, - comptime attrs: std.builtin.Type.Pointer.Attributes, + comptime size: std.lang.Type.Pointer.Size, + comptime attrs: std.lang.Type.Pointer.Attributes, comptime Element: type, comptime sentinel: ?Element, ) type{#endsyntax#}</pre> @@ -5752,32 +5752,32 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_open|@Fn#} <pre>{#syntax#}@Fn( comptime param_types: []const type, - comptime param_attrs: *const [param_types.len]std.builtin.Type.Fn.Param.Attributes, + comptime param_attrs: *const [param_types.len]std.lang.Type.Fn.Param.Attributes, comptime ReturnType: type, - comptime attrs: std.builtin.Type.Fn.Attributes, + comptime attrs: std.lang.Type.Fn.Attributes, ) type{#endsyntax#}</pre> <p>Returns a {#link|function|Functions#} type with the properties specified by the arguments.</p> {#header_close#} {#header_open|@Struct#} <pre>{#syntax#}@Struct( - comptime layout: std.builtin.Type.ContainerLayout, + comptime layout: std.lang.Type.ContainerLayout, comptime BackingInt: ?type, comptime field_names: []const []const u8, comptime field_types: *const [field_names.len]type, - comptime field_attrs: *const [field_names.len]std.builtin.Type.StructField.Attributes, + comptime field_attrs: *const [field_names.len]std.lang.Type.StructField.Attributes, ) type{#endsyntax#}</pre> <p>Returns a {#link|struct#} type with the properties specified by the arguments.</p> {#header_close#} {#header_open|@Union#} <pre>{#syntax#}@Union( - comptime layout: std.builtin.Type.ContainerLayout, + comptime layout: std.lang.Type.ContainerLayout, /// Either the integer tag type, or the integer backing type, depending on `layout`. comptime ArgType: ?type, comptime field_names: []const []const u8, comptime field_types: *const [field_names.len]type, - comptime field_attrs: *const [field_names.len]std.builtin.Type.UnionField.Attributes, + comptime field_attrs: *const [field_names.len]std.lang.Type.UnionField.Attributes, ) type{#endsyntax#}</pre> <p>Returns a {#link|union#} type with the properties specified by the arguments.</p> {#header_close#} @@ -5785,7 +5785,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_open|@Enum#} <pre>{#syntax#}@Enum( comptime TagInt: type, - comptime mode: std.builtin.Type.Enum.Mode, + comptime mode: std.lang.Type.Enum.Mode, comptime field_names: []const []const u8, comptime field_values: *const [field_names.len]TagInt, ) type{#endsyntax#}</pre> @@ -5793,7 +5793,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_close#} {#header_open|@typeInfo#} - <pre>{#syntax#}@typeInfo(comptime T: type) std.builtin.Type{#endsyntax#}</pre> + <pre>{#syntax#}@typeInfo(comptime T: type) std.lang.Type{#endsyntax#}</pre> <p> Provides type reflection. </p> diff --git a/doc/langref/builtin.CallModifier struct.zig b/doc/langref/lang.CallModifier struct.zig diff --git a/doc/langref/test_noreturn_from_exit.zig b/doc/langref/test_noreturn_from_exit.zig @@ -1,10 +1,7 @@ const std = @import("std"); -const builtin = @import("builtin"); -const native_arch = builtin.cpu.arch; const expectEqual = std.testing.expectEqual; -const WINAPI: std.builtin.CallingConvention = if (native_arch == .x86) .{ .x86_stdcall = .{} } else .c; -extern "kernel32" fn ExitProcess(exit_code: c_uint) callconv(WINAPI) noreturn; +extern "kernel32" fn ExitProcess(exit_code: c_uint) callconv(.winapi) noreturn; test "foo" { const value = bar() catch ExitProcess(1); 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"); diff --git a/lib/std/zig.zig b/lib/std/zig.zig @@ -876,7 +876,7 @@ pub const SimpleComptimeReason = enum(u32) { casted_to_comptime_enum, casted_to_comptime_int, casted_to_comptime_float, - std_builtin_decl, + std_lang_decl, pub fn message(r: SimpleComptimeReason) []const u8 { return switch (r) { @@ -959,7 +959,7 @@ pub const SimpleComptimeReason = enum(u32) { .casted_to_comptime_enum => "value casted to enum with 'comptime_int' tag type must be comptime-known", .casted_to_comptime_int => "value casted to 'comptime_int' must be comptime-known", .casted_to_comptime_float => "value casted to 'comptime_float' must be comptime-known", - .std_builtin_decl => "'std.builtin' declaration values must be comptime-known", + .std_lang_decl => "'std.lang' declaration values must be comptime-known", // zig fmt: on }; } diff --git a/lib/std/zig/Ast.zig b/lib/std/zig/Ast.zig @@ -2103,7 +2103,7 @@ fn fullFnProtoComponents(tree: Ast, info: full.FnProto.Components) full.FnProto } fn fullPtrTypeComponents(tree: Ast, info: full.PtrType.Components) full.PtrType { - const size: std.builtin.Type.Pointer.Size = switch (tree.tokenTag(info.main_token)) { + const size: std.lang.Type.Pointer.Size = switch (tree.tokenTag(info.main_token)) { .asterisk => .one, .l_bracket => switch (tree.tokenTag(info.main_token + 1)) { .asterisk => if (tree.tokenTag(info.main_token + 2) == .identifier) .c else .many, @@ -2726,7 +2726,7 @@ pub const full = struct { }; pub const PtrType = struct { - size: std.builtin.Type.Pointer.Size, + size: std.lang.Type.Pointer.Size, allowzero_token: ?TokenIndex, const_token: ?TokenIndex, volatile_token: ?TokenIndex, diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig @@ -1398,12 +1398,12 @@ fn fnProtoExprInner( try comptimeExpr( &block_scope, scope, - .{ .rl = .{ .coerced_ty = try block_scope.addBuiltinValue(callconv_expr, .calling_convention) } }, + .{ .rl = .{ .coerced_ty = try block_scope.addStdLangValue(callconv_expr, .calling_convention) } }, callconv_expr, .@"callconv", ) else if (implicit_ccc) - try block_scope.addBuiltinValue(node, .calling_convention_c) + try block_scope.addStdLangValue(node, .calling_convention_c) else .none; @@ -3782,7 +3782,7 @@ fn ptrType( gz.astgen.source_line = source_line; gz.astgen.source_column = source_column; - const addrspace_ty = try gz.addBuiltinValue(addrspace_node, .address_space); + const addrspace_ty = try gz.addStdLangValue(addrspace_node, .address_space); addrspace_ref = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = addrspace_ty } }, addrspace_node, .@"addrspace"); trailing_count += 1; } @@ -4077,7 +4077,7 @@ fn fnDecl( if (fn_proto.ast.addrspace_expr.unwrap()) |addrspace_expr| { astgen.restoreSourceCursor(saved_cursor); - const addrspace_ty = try addrspace_gz.addBuiltinValue(addrspace_expr, .address_space); + const addrspace_ty = try addrspace_gz.addStdLangValue(addrspace_expr, .address_space); const inst = try expr(&addrspace_gz, &addrspace_gz.base, .{ .rl = .{ .coerced_ty = addrspace_ty } }, addrspace_expr); _ = try addrspace_gz.addBreakWithSrcNode(.break_inline, decl_inst, inst, decl_node); } @@ -4285,7 +4285,7 @@ fn fnDeclInner( const inst = try expr( &cc_gz, scope, - .{ .rl = .{ .coerced_ty = try cc_gz.addBuiltinValue(callconv_expr, .calling_convention) } }, + .{ .rl = .{ .coerced_ty = try cc_gz.addStdLangValue(callconv_expr, .calling_convention) } }, callconv_expr, ); if (cc_gz.instructionsSlice().len == 0) { @@ -4295,7 +4295,7 @@ fn fnDeclInner( _ = try cc_gz.addBreak(.break_inline, @enumFromInt(0), inst); break :blk inst; } else if (has_inline_keyword) { - const inst = try cc_gz.addBuiltinValue(decl_node, .calling_convention_inline); + const inst = try cc_gz.addStdLangValue(decl_node, .calling_convention_inline); _ = try cc_gz.addBreak(.break_inline, @enumFromInt(0), inst); break :blk inst; } else { @@ -4493,7 +4493,7 @@ fn globalVarDecl( defer addrspace_gz.unstack(); if (var_decl.ast.addrspace_node.unwrap()) |addrspace_node| { - const addrspace_ty = try addrspace_gz.addBuiltinValue(addrspace_node, .address_space); + const addrspace_ty = try addrspace_gz.addStdLangValue(addrspace_node, .address_space); const addrspace_inst = try expr(&addrspace_gz, &addrspace_gz.base, .{ .rl = .{ .coerced_ty = addrspace_ty } }, addrspace_node); _ = try addrspace_gz.addBreakWithSrcNode(.break_inline, decl_inst, addrspace_inst, node); } @@ -4815,7 +4815,7 @@ fn structDeclInner( scope: *Scope, node: Ast.Node.Index, container_decl: Ast.full.ContainerDecl, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, maybe_backing_int_node: Ast.Node.OptionalIndex, name_strat: Zir.Inst.NameStrategy, ) InnerError!Zir.Inst.Ref { @@ -5020,7 +5020,7 @@ fn tupleDecl( scope: *Scope, node: Ast.Node.Index, container_decl: Ast.full.ContainerDecl, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, backing_int_node: Ast.Node.OptionalIndex, ) InnerError!Zir.Inst.Ref { const astgen = gz.astgen; @@ -5117,7 +5117,7 @@ fn unionDeclInner( scope: *Scope, node: Ast.Node.Index, members: []const Ast.Node.Index, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, opt_arg_node: Ast.Node.OptionalIndex, auto_enum_tok: ?Ast.TokenIndex, name_strat: Zir.Inst.NameStrategy, @@ -5324,7 +5324,7 @@ fn containerDecl( switch (tree.tokenTag(container_decl.ast.main_token)) { .keyword_struct => { - const layout: std.builtin.Type.ContainerLayout = if (container_decl.layout_token) |t| switch (tree.tokenTag(t)) { + const layout: std.lang.Type.ContainerLayout = if (container_decl.layout_token) |t| switch (tree.tokenTag(t)) { .keyword_packed => .@"packed", .keyword_extern => .@"extern", else => unreachable, @@ -5334,7 +5334,7 @@ fn containerDecl( return rvalue(gz, ri, result, node); }, .keyword_union => { - const layout: std.builtin.Type.ContainerLayout = if (container_decl.layout_token) |t| switch (tree.tokenTag(t)) { + const layout: std.lang.Type.ContainerLayout = if (container_decl.layout_token) |t| switch (tree.tokenTag(t)) { .keyword_packed => .@"packed", .keyword_extern => .@"extern", else => unreachable, @@ -8060,7 +8060,7 @@ fn identifier( int_type: { if (ident_name_raw.len < 2) break :int_type; - const signedness: std.builtin.Signedness = switch (ident_name_raw[0]) { + const signedness: std.lang.Signedness = switch (ident_name_raw[0]) { 'u' => .unsigned, 'i' => .signed, else => break :int_type, @@ -8650,7 +8650,7 @@ fn asmExpr( const clobbers: Zir.Inst.Ref = if (full.ast.clobbers.unwrap()) |clobbers_node| try comptimeExpr(gz, scope, .{ .rl = .{ - .coerced_ty = try gz.addBuiltinValue(clobbers_node, .clobbers), + .coerced_ty = try gz.addStdLangValue(clobbers_node, .clobbers), } }, clobbers_node, .clobber) else .none; @@ -8992,7 +8992,7 @@ fn builtinCall( if (!allow_branch_hint) { return astgen.failNode(node, "'@branchHint' must appear as the first statement in a function or conditional branch", .{}); } - const hint_ty = try gz.addBuiltinValue(node, .branch_hint); + const hint_ty = try gz.addStdLangValue(node, .branch_hint); const hint_val = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = hint_ty } }, params[0], .operand_branchHint); _ = try gz.addExtendedPayload(.branch_hint, Zir.Inst.UnNode{ .node = gz.nodeIndexToRelative(node), @@ -9090,7 +9090,7 @@ fn builtinCall( .@"export" => { const exported = try expr(gz, scope, .{ .rl = .none }, params[0]); - const export_options_ty = try gz.addBuiltinValue(node, .export_options); + const export_options_ty = try gz.addStdLangValue(node, .export_options); const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = export_options_ty } }, params[1], .export_options); _ = try gz.addPlNode(.@"export", node, Zir.Inst.Export{ .exported = exported, @@ -9100,7 +9100,7 @@ fn builtinCall( }, .@"extern" => { const type_inst = try typeExpr(gz, scope, params[0]); - const extern_options_ty = try gz.addBuiltinValue(node, .extern_options); + const extern_options_ty = try gz.addStdLangValue(node, .extern_options); const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = extern_options_ty } }, params[1], .extern_options); const result = try gz.addExtendedPayload(.builtin_extern, Zir.Inst.BinNode{ .node = gz.nodeIndexToRelative(node), @@ -9110,7 +9110,7 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .set_float_mode => { - const float_mode_ty = try gz.addBuiltinValue(node, .float_mode); + const float_mode_ty = try gz.addStdLangValue(node, .float_mode); const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = float_mode_ty } }, params[0]); _ = try gz.addExtendedPayload(.set_float_mode, Zir.Inst.UnNode{ .node = gz.nodeIndexToRelative(node), @@ -9196,7 +9196,7 @@ fn builtinCall( .EnumLiteral => return rvalue(gz, ri, .enum_literal_type, node), .Int => { - const signedness_ty = try gz.addBuiltinValue(node, .signedness); + const signedness_ty = try gz.addStdLangValue(node, .signedness); const result = try gz.addPlNode(.reify_int, node, Zir.Inst.Bin{ .lhs = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = signedness_ty } }, params[0], .int_signedness), .rhs = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .u16_type } }, params[1], .int_bit_width), @@ -9211,8 +9211,8 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .Pointer => { - const ptr_size_ty = try gz.addBuiltinValue(node, .pointer_size); - const ptr_attrs_ty = try gz.addBuiltinValue(node, .pointer_attributes); + const ptr_size_ty = try gz.addStdLangValue(node, .pointer_size); + const ptr_attrs_ty = try gz.addStdLangValue(node, .pointer_attributes); const size = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = ptr_size_ty } }, params[0], .pointer_size); const attrs = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = ptr_attrs_ty } }, params[1], .pointer_attrs); const elem_ty = try typeExpr(gz, scope, params[2]); @@ -9231,7 +9231,7 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .Fn => { - const fn_attrs_ty = try gz.addBuiltinValue(node, .fn_attributes); + const fn_attrs_ty = try gz.addStdLangValue(node, .fn_attributes); const param_types = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_type_type } }, params[0], .fn_param_types); const param_attrs_ty = try gz.addExtendedPayloadSmall( .reify_slice_arg_ty, @@ -9251,7 +9251,7 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .Struct => { - const container_layout_ty = try gz.addBuiltinValue(node, .container_layout); + const container_layout_ty = try gz.addStdLangValue(node, .container_layout); const layout = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = container_layout_ty } }, params[0], .struct_layout); const backing_ty = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .optional_type_type } }, params[1], .type); const field_names = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_slice_const_u8_type } }, params[2], .struct_field_names); @@ -9279,7 +9279,7 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .Union => { - const container_layout_ty = try gz.addBuiltinValue(node, .container_layout); + const container_layout_ty = try gz.addStdLangValue(node, .container_layout); const layout = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = container_layout_ty } }, params[0], .union_layout); const arg_ty = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .optional_type_type } }, params[1], .type); const field_names = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_slice_const_u8_type } }, params[2], .union_field_names); @@ -9307,7 +9307,7 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .Enum => { - const enum_mode_ty = try gz.addBuiltinValue(node, .enum_mode); + const enum_mode_ty = try gz.addStdLangValue(node, .enum_mode); const tag_ty = try typeExpr(gz, scope, params[0]); const mode = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = enum_mode_ty } }, params[1], .type); const field_names = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_slice_const_u8_type } }, params[2], .enum_field_names); @@ -9425,7 +9425,7 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .reduce => { - const reduce_op_ty = try gz.addBuiltinValue(node, .reduce_op); + const reduce_op_ty = try gz.addStdLangValue(node, .reduce_op); const op = try expr(gz, scope, .{ .rl = .{ .coerced_ty = reduce_op_ty } }, params[0]); const scalar = try expr(gz, scope, .{ .rl = .none }, params[1]); const result = try gz.addPlNode(.reduce, node, Zir.Inst.Bin{ @@ -9441,7 +9441,7 @@ fn builtinCall( .shl_with_overflow => return overflowArithmetic(gz, scope, ri, node, params, .shl_with_overflow), .atomic_load => { - const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order); + const atomic_order_type = try gz.addStdLangValue(node, .atomic_order); const result = try gz.addPlNode(.atomic_load, node, Zir.Inst.AtomicLoad{ // zig fmt: off .elem_type = try typeExpr(gz, scope, params[0]), @@ -9452,8 +9452,8 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .atomic_rmw => { - const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order); - const atomic_rmw_op_type = try gz.addBuiltinValue(node, .atomic_rmw_op); + const atomic_order_type = try gz.addStdLangValue(node, .atomic_order); + const atomic_rmw_op_type = try gz.addStdLangValue(node, .atomic_rmw_op); const int_type = try typeExpr(gz, scope, params[0]); const result = try gz.addPlNode(.atomic_rmw, node, Zir.Inst.AtomicRmw{ // zig fmt: off @@ -9466,7 +9466,7 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .atomic_store => { - const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order); + const atomic_order_type = try gz.addStdLangValue(node, .atomic_order); const int_type = try typeExpr(gz, scope, params[0]); _ = try gz.addPlNode(.atomic_store, node, Zir.Inst.AtomicStore{ // zig fmt: off @@ -9490,7 +9490,7 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .call => { - const call_modifier_ty = try gz.addBuiltinValue(node, .call_modifier); + const call_modifier_ty = try gz.addStdLangValue(node, .call_modifier); const modifier = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = call_modifier_ty } }, params[0], .call_modifier); const callee = try expr(gz, scope, .{ .rl = .none }, params[1]); const args = try expr(gz, scope, .{ .rl = .none }, params[2]); @@ -9567,7 +9567,7 @@ fn builtinCall( return rvalue(gz, ri, result, node); }, .prefetch => { - const prefetch_options_ty = try gz.addBuiltinValue(node, .prefetch_options); + const prefetch_options_ty = try gz.addStdLangValue(node, .prefetch_options); const ptr = try expr(gz, scope, .{ .rl = .none }, params[0]); const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = prefetch_options_ty } }, params[1], .prefetch_options); _ = try gz.addExtendedPayload(.prefetch, Zir.Inst.BinNode{ @@ -9800,7 +9800,7 @@ fn cmpxchg( small: u16, ) InnerError!Zir.Inst.Ref { const int_type = try typeExpr(gz, scope, params[0]); - const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order); + const atomic_order_type = try gz.addStdLangValue(node, .atomic_order); const result = try gz.addExtendedPayloadSmall(.cmpxchg, small, Zir.Inst.Cmpxchg{ // zig fmt: off .node = gz.nodeIndexToRelative(node), @@ -9925,7 +9925,7 @@ fn callExpr( const astgen = gz.astgen; const callee = try calleeExpr(gz, scope, ri.rl, override_decl_literal_type, call.ast.fn_expr); - const modifier: std.builtin.CallModifier = blk: { + const modifier: std.lang.CallModifier = blk: { if (gz.nosuspend_node != .none) { break :blk .no_suspend; } @@ -11801,8 +11801,8 @@ const GenZir = struct { return new_index; } - fn addBuiltinValue(gz: *GenZir, src_node: Ast.Node.Index, val: Zir.Inst.BuiltinValue) !Zir.Inst.Ref { - return addExtendedNodeSmall(gz, .builtin_value, src_node, @intFromEnum(val)); + fn addStdLangValue(gz: *GenZir, src_node: Ast.Node.Index, val: Zir.Inst.StdLangValue) !Zir.Inst.Ref { + return addExtendedNodeSmall(gz, .std_lang_value, src_node, @intFromEnum(val)); } fn addExtendedPayload(gz: *GenZir, opcode: Zir.Inst.Extended, extra: anytype) !Zir.Inst.Ref { @@ -12350,7 +12350,7 @@ const GenZir = struct { fn setStruct(gz: *GenZir, inst: Zir.Inst.Index, args: struct { src_node: Ast.Node.Index, name_strat: Zir.Inst.NameStrategy, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, backing_int_type_body_len: ?u32, decls_len: u32, fields_len: u32, diff --git a/lib/std/zig/LibCInstallation.zig b/lib/std/zig/LibCInstallation.zig @@ -708,8 +708,8 @@ pub const CrtBasenames = struct { pub const GetArgs = struct { target: *const std.Target, link_libc: bool, - output_mode: std.builtin.OutputMode, - link_mode: std.builtin.LinkMode, + output_mode: std.lang.OutputMode, + link_mode: std.lang.LinkMode, pie: bool, }; diff --git a/lib/std/zig/Zir.zig b/lib/std/zig/Zir.zig @@ -2119,10 +2119,10 @@ pub const Inst = struct { /// Guaranteed to not have the `ptr_cast` flag. /// Uses the `pl_node` union field with payload `FieldParentPtr`. field_parent_ptr, - /// Get a type or value from `std.builtin`. + /// Get a type or value from `std.lang`. /// `operand` is `src_node: Ast.Node.Offset`. - /// `small` is an `Inst.BuiltinValue`. - builtin_value, + /// `small` is an `Inst.StdLangValue`. + std_lang_value, /// Provide a `@branchHint` for the current block. /// `operand` is payload index to `UnNode`. /// `small` is unused. @@ -2418,7 +2418,7 @@ pub const Inst = struct { has_bit_range: bool, _: u1 = 0, }, - size: std.builtin.Type.Pointer.Size, + size: std.lang.Type.Pointer.Size, /// Index into extra. See `PtrType`. payload_index: u32, }, @@ -2426,7 +2426,7 @@ pub const Inst = struct { /// Offset from Decl AST node index. /// `Tag` determines which kind of AST node this points to. src_node: Ast.Node.Offset, - signedness: std.builtin.Signedness, + signedness: std.lang.Signedness, bit_count: u16, }, @"unreachable": struct { @@ -3051,7 +3051,7 @@ pub const Inst = struct { callee: Ref, pub const Flags = packed struct { - /// std.builtin.CallModifier in packed form + /// std.lang.CallModifier in packed form pub const PackedModifier = u3; pub const PackedArgsLen = u27; @@ -3063,7 +3063,7 @@ pub const Inst = struct { comptime { if (@sizeOf(Flags) != 4 or @bitSizeOf(Flags) != 32) @compileError("Layout of Call.Flags needs to be updated!"); - if (@bitSizeOf(std.builtin.CallModifier) != @bitSizeOf(PackedModifier)) + if (@bitSizeOf(std.lang.CallModifier) != @bitSizeOf(PackedModifier)) @compileError("Call.Flags.PackedModifier needs to be updated!"); } }; @@ -3186,7 +3186,7 @@ pub const Inst = struct { pub const ReifySliceArgInfo = enum(u16) { /// Input element type is `type`. - /// Output element type is `std.builtin.Type.Fn.Param.Attributes`. + /// Output element type is `std.lang.Type.Fn.Param.Attributes`. type_to_fn_param_attrs, /// Input element type is `[]const u8`. /// Output element type is `type`. @@ -3194,10 +3194,10 @@ pub const Inst = struct { /// Identical to `string_to_struct_field_type` aside from emitting slightly different error messages. string_to_union_field_type, /// Input element type is `[]const u8`. - /// Output element type is `std.builtin.Type.StructField.Attributes`. + /// Output element type is `std.lang.Type.StructField.Attributes`. string_to_struct_field_attrs, /// Input element type is `[]const u8`. - /// Output element type is `std.builtin.Type.UnionField.Attributes`. + /// Output element type is `std.lang.Type.UnionField.Attributes`. string_to_union_field_attrs, }; @@ -3468,7 +3468,7 @@ pub const Inst = struct { has_decls_len: bool, has_fields_len: bool, name_strategy: NameStrategy, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, /// Always `false` if `layout != .@"packed"`. has_backing_int_type: bool, any_field_aligns: bool, @@ -3564,7 +3564,7 @@ pub const Inst = struct { } }; - pub const BuiltinValue = enum(u16) { + pub const StdLangValue = enum(u16) { // Types atomic_order, atomic_rmw_op, @@ -3688,7 +3688,7 @@ pub const Inst = struct { }; } - pub fn layout(k: Kind) std.builtin.Type.ContainerLayout { + pub fn layout(k: Kind) std.lang.Type.ContainerLayout { return switch (k) { .auto, .tagged_explicit, .tagged_enum, .tagged_enum_explicit => .auto, .@"extern" => .@"extern", @@ -4368,7 +4368,7 @@ fn findTrackableInner( .restore_err_ret_index, .closure_get, .field_parent_ptr, - .builtin_value, + .std_lang_value, .branch_hint, .inplace_arith_result_ty, .tuple_decl, @@ -5286,7 +5286,7 @@ pub const UnwrappedStructDecl = struct { decls: []const Inst.Index, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, backing_int_type_body: ?[]const Inst.Index, field_names: []const NullTerminatedString, diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig @@ -1830,7 +1830,7 @@ pub const Visibility = enum(u2) { hidden = 1, protected = 2, - pub fn fromSymbolVisibility(sv: std.builtin.SymbolVisibility) Visibility { + pub fn fromSymbolVisibility(sv: std.lang.SymbolVisibility) Visibility { return switch (sv) { .default => .default, .hidden => .hidden, diff --git a/src/Air.zig b/src/Air.zig @@ -1260,17 +1260,17 @@ pub const Inst = struct { }, atomic_load: struct { ptr: Ref, - order: std.builtin.AtomicOrder, + order: std.lang.AtomicOrder, }, prefetch: struct { ptr: Ref, - rw: std.builtin.PrefetchOptions.Rw, + rw: std.lang.PrefetchOptions.Rw, locality: u2, - cache: std.builtin.PrefetchOptions.Cache, + cache: std.lang.PrefetchOptions.Cache, }, reduce: struct { operand: Ref, - operation: std.builtin.ReduceOp, + operation: std.lang.ReduceOp, }, ty_nav: struct { ty: InternPool.Index, @@ -1332,8 +1332,8 @@ pub const CondBr = struct { else_body_len: u32, branch_hints: BranchHints, pub const BranchHints = packed struct(u32) { - true: std.builtin.BranchHint = .none, - false: std.builtin.BranchHint = .none, + true: std.lang.BranchHint = .none, + false: std.lang.BranchHint = .none, then_cov: CoveragePoint = .none, else_cov: CoveragePoint = .none, _: u24 = 0, @@ -1481,7 +1481,7 @@ pub const Asm = struct { /// Length of the assembly source in bytes. source_len: u32, inputs_len: u32, - /// A comptime `std.builtin.assembly.Clobbers` value for the target architecture. + /// A comptime `std.lang.assembly.Clobbers` value for the target architecture. clobbers: InternPool.Index, flags: Flags, @@ -1499,11 +1499,11 @@ pub const Cmpxchg = struct { /// 0b00000000000000000000000000XXX000 - failure_order flags: u32, - pub fn successOrder(self: Cmpxchg) std.builtin.AtomicOrder { + pub fn successOrder(self: Cmpxchg) std.lang.AtomicOrder { return @enumFromInt(@as(u3, @truncate(self.flags))); } - pub fn failureOrder(self: Cmpxchg) std.builtin.AtomicOrder { + pub fn failureOrder(self: Cmpxchg) std.lang.AtomicOrder { return @enumFromInt(@as(u3, @intCast(self.flags >> 3))); } }; @@ -1514,11 +1514,11 @@ pub const AtomicRmw = struct { /// 0b0000000000000000000000000XXXX000 - op flags: u32, - pub fn ordering(self: AtomicRmw) std.builtin.AtomicOrder { + pub fn ordering(self: AtomicRmw) std.lang.AtomicOrder { return @enumFromInt(@as(u3, @truncate(self.flags))); } - pub fn op(self: AtomicRmw) std.builtin.AtomicRmwOp { + pub fn op(self: AtomicRmw) std.lang.AtomicRmwOp { return @enumFromInt(@as(u4, @intCast(self.flags >> 3))); } }; @@ -2077,14 +2077,14 @@ pub const UnwrappedSwitch = struct { cases_start: u32, /// Asserts that `case_idx < us.cases_len`. - pub fn getHint(us: UnwrappedSwitch, case_idx: u32) std.builtin.BranchHint { + pub fn getHint(us: UnwrappedSwitch, case_idx: u32) std.lang.BranchHint { assert(case_idx < us.cases_len); return us.getHintInner(case_idx); } - pub fn getElseHint(us: UnwrappedSwitch) std.builtin.BranchHint { + pub fn getElseHint(us: UnwrappedSwitch) std.lang.BranchHint { return us.getHintInner(us.cases_len); } - fn getHintInner(us: UnwrappedSwitch, idx: u32) std.builtin.BranchHint { + fn getHintInner(us: UnwrappedSwitch, idx: u32) std.lang.BranchHint { const bag = us.air.extra.items[us.branch_hints_start..][idx / 10]; const bits: u3 = @truncate(bag >> @intCast(3 * (idx % 10))); return @enumFromInt(bits); @@ -2630,7 +2630,7 @@ pub const CompilerRtFunc = enum(u32) { }; } - pub fn @"callconv"(f: CompilerRtFunc, target: *const std.Target) std.builtin.CallingConvention { + pub fn @"callconv"(f: CompilerRtFunc, target: *const std.Target) std.lang.CallingConvention { const use_gnu_f16_abi = switch (target.cpu.arch) { .wasm32, .wasm64, diff --git a/src/Air/Legalize.zig b/src/Air/Legalize.zig @@ -2644,7 +2644,7 @@ const Block = struct { }); return; } - const panic_fn_val = zcu.builtin_decl_values.get(panic_id.toBuiltin()); + const panic_fn_val = zcu.std_lang_decl_values.get(panic_id.toStdLangDecl()); _ = b.add(l, .{ .tag = .call, .data = .{ .pl_op = .{ diff --git a/src/Air/print.zig b/src/Air/print.zig @@ -625,7 +625,7 @@ const Writer = struct { w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index, - order: std.builtin.AtomicOrder, + order: std.lang.AtomicOrder, ) Error!void { const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; try w.writeOperand(s, inst, 0, bin_op.lhs); diff --git a/src/Builtin.zig b/src/Builtin.zig @@ -1,13 +1,13 @@ target: std.Target, -zig_backend: std.builtin.CompilerBackend, -output_mode: std.builtin.OutputMode, -link_mode: std.builtin.LinkMode, -unwind_tables: std.builtin.UnwindTables, +zig_backend: std.lang.CompilerBackend, +output_mode: std.lang.OutputMode, +link_mode: std.lang.LinkMode, +unwind_tables: std.lang.UnwindTables, is_test: bool, single_threaded: bool, link_libc: bool, link_libcpp: bool, -optimize_mode: std.builtin.OptimizeMode, +optimize_mode: std.lang.OptimizeMode, error_tracing: bool, valgrind: bool, sanitize_thread: bool, @@ -15,9 +15,9 @@ fuzz: bool, pic: bool, pie: bool, strip: bool, -code_model: std.builtin.CodeModel, +code_model: std.lang.CodeModel, omit_frame_pointer: bool, -wasi_exec_model: std.builtin.WasiExecModel, +wasi_exec_model: std.lang.WasiExecModel, /// Compute an abstract hash representing this `Builtin`. This is *not* a hash /// of the resulting file contents. @@ -57,11 +57,11 @@ pub fn append(opts: @This(), buffer: *std.array_list.Managed(u8)) Allocator.Erro \\/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks. \\pub const zig_version = std.SemanticVersion.parse(zig_version_string) catch unreachable; \\pub const zig_version_string = "{s}"; - \\pub const zig_backend = std.builtin.CompilerBackend.{f}; + \\pub const zig_backend = std.lang.CompilerBackend.{f}; \\ - \\pub const output_mode: std.builtin.OutputMode = .{f}; - \\pub const link_mode: std.builtin.LinkMode = .{f}; - \\pub const unwind_tables: std.builtin.UnwindTables = .{f}; + \\pub const output_mode: std.lang.OutputMode = .{f}; + \\pub const link_mode: std.lang.LinkMode = .{f}; + \\pub const unwind_tables: std.lang.UnwindTables = .{f}; \\pub const is_test = {}; \\pub const single_threaded = {}; \\pub const abi: std.Target.Abi = .{f}; @@ -239,7 +239,7 @@ pub fn append(opts: @This(), buffer: *std.array_list.Managed(u8)) Allocator.Erro try buffer.print( \\pub const object_format: std.Target.ObjectFormat = .{f}; - \\pub const mode: std.builtin.OptimizeMode = .{f}; + \\pub const mode: std.lang.OptimizeMode = .{f}; \\pub const link_libc = {}; \\pub const link_libcpp = {}; \\pub const have_error_return_tracing = {}; @@ -249,7 +249,7 @@ pub fn append(opts: @This(), buffer: *std.array_list.Managed(u8)) Allocator.Erro \\pub const position_independent_code = {}; \\pub const position_independent_executable = {}; \\pub const strip_debug_info = {}; - \\pub const code_model: std.builtin.CodeModel = .{f}; + \\pub const code_model: std.lang.CodeModel = .{f}; \\pub const omit_frame_pointer = {}; \\ , .{ @@ -270,14 +270,14 @@ pub fn append(opts: @This(), buffer: *std.array_list.Managed(u8)) Allocator.Erro if (target.os.tag == .wasi) { try buffer.print( - \\pub const wasi_exec_model: std.builtin.WasiExecModel = .{f}; + \\pub const wasi_exec_model: std.lang.WasiExecModel = .{f}; \\ , .{std.zig.fmtIdPU(@tagName(opts.wasi_exec_model))}); } if (opts.is_test) { try buffer.appendSlice( - \\pub var test_functions: []const std.builtin.TestFn = &.{}; // overwritten later + \\pub var test_functions: []const std.lang.TestFn = &.{}; // overwritten later \\ ); } diff --git a/src/Compilation.zig b/src/Compilation.zig @@ -177,7 +177,7 @@ verbose_link: bool, link_depfile: ?[]const u8, disable_c_depfile: bool, stack_report: bool, -debug_compiler_runtime_libs: ?std.builtin.OptimizeMode, +debug_compiler_runtime_libs: ?std.lang.OptimizeMode, debug_compile_errors: bool, /// Do not check this field directly. Instead, use the `debugIncremental` wrapper function. debug_incremental: bool, @@ -1676,7 +1676,7 @@ pub const CreateOptions = struct { verbose_llvm_bc: ?[]const u8 = null, link_depfile: ?[]const u8 = null, verbose_llvm_cpu_features: bool = false, - debug_compiler_runtime_libs: ?std.builtin.OptimizeMode = null, + debug_compiler_runtime_libs: ?std.lang.OptimizeMode = null, debug_compile_errors: bool = false, debug_incremental: bool = false, /// Normally when you create a `Compilation`, Zig will automatically build @@ -4928,8 +4928,8 @@ fn workerDocsWasmFallible(comp: *Compilation, prog_node: std.Progress.Node) SubU defer arena_allocator.deinit(); const arena = arena_allocator.allocator(); - const optimize_mode = std.builtin.OptimizeMode.ReleaseSmall; - const output_mode = std.builtin.OutputMode.Exe; + const optimize_mode = std.lang.OptimizeMode.ReleaseSmall; + const output_mode = std.lang.OutputMode.Exe; const resolved_target: Package.Module.ResolvedTarget = .{ .result = std.zig.system.resolveTargetQuery(io, .{ .cpu_arch = .wasm32, @@ -5285,8 +5285,8 @@ fn buildRt( comp: *Compilation, root_source_name: []const u8, root_name: []const u8, - output_mode: std.builtin.OutputMode, - link_mode: std.builtin.LinkMode, + output_mode: std.lang.OutputMode, + link_mode: std.lang.LinkMode, misc_task: MiscTask, prog_node: std.Progress.Node, options: RtOptions, @@ -7260,7 +7260,7 @@ fn dumpArgvWriter(w: *Io.Writer, argv: []const []const u8) Io.Writer.Error!void try w.writeByte('\n'); } -pub fn getZigBackend(comp: Compilation) std.builtin.CompilerBackend { +pub fn getZigBackend(comp: Compilation) std.lang.CompilerBackend { const target = &comp.root_mod.resolved_target.result; return target_util.zigBackend(target, comp.config.use_llvm); } @@ -7302,8 +7302,8 @@ fn buildOutputFromZig( comp: *Compilation, src_basename: []const u8, root_name: []const u8, - output_mode: std.builtin.OutputMode, - link_mode: std.builtin.LinkMode, + output_mode: std.lang.OutputMode, + link_mode: std.lang.LinkMode, misc_task_tag: MiscTask, prog_node: std.Progress.Node, options: RtOptions, @@ -7433,7 +7433,7 @@ pub const CrtFileOptions = struct { function_sections: bool = true, data_sections: bool = true, omit_frame_pointer: ?bool = null, - unwind_tables: ?std.builtin.UnwindTables = null, + unwind_tables: ?std.lang.UnwindTables = null, pic: ?bool = null, no_builtin: ?bool = null, @@ -7443,7 +7443,7 @@ pub const CrtFileOptions = struct { pub fn build_crt_file( comp: *Compilation, root_name: []const u8, - output_mode: std.builtin.OutputMode, + output_mode: std.lang.OutputMode, misc_task_tag: MiscTask, prog_node: std.Progress.Node, /// These elements have to get mutated to add the owner module after it is @@ -7657,7 +7657,7 @@ pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void { /// This decides the optimization mode for all zig-provided libraries, including /// compiler-rt, libcxx, libc, libunwind, etc. -pub fn compilerRtOptMode(comp: Compilation) std.builtin.OptimizeMode { +pub fn compilerRtOptMode(comp: Compilation) std.lang.OptimizeMode { if (comp.debug_compiler_runtime_libs) |mode| { return mode; } diff --git a/src/Compilation/Config.zig b/src/Compilation/Config.zig @@ -4,8 +4,8 @@ //! order to resolve per-Module defaults. have_zcu: bool, -output_mode: std.builtin.OutputMode, -link_mode: std.builtin.LinkMode, +output_mode: std.lang.OutputMode, +link_mode: std.lang.LinkMode, link_libc: bool, link_libcpp: bool, link_libunwind: bool, @@ -53,13 +53,13 @@ lto: std.zig.LtoMode, incremental: bool, /// WASI-only. Type of WASI execution model ("command" or "reactor"). /// Always set to `command` for non-WASI targets. -wasi_exec_model: std.builtin.WasiExecModel, +wasi_exec_model: std.lang.WasiExecModel, import_memory: bool, export_memory: bool, shared_memory: bool, is_test: bool, debug_format: DebugFormat, -root_optimize_mode: std.builtin.OptimizeMode, +root_optimize_mode: std.lang.OptimizeMode, root_strip: bool, root_error_tracing: bool, dll_export_fns: bool, @@ -75,15 +75,15 @@ pub const DebugFormat = union(enum) { }; pub const Options = struct { - output_mode: std.builtin.OutputMode, + output_mode: std.lang.OutputMode, resolved_target: Module.ResolvedTarget, is_test: bool, have_zcu: bool, emit_bin: bool, - root_optimize_mode: ?std.builtin.OptimizeMode = null, + root_optimize_mode: ?std.lang.OptimizeMode = null, root_strip: ?bool = null, root_error_tracing: ?bool = null, - link_mode: ?std.builtin.LinkMode = null, + link_mode: ?std.lang.LinkMode = null, ensure_libc_on_non_freestanding: bool = false, ensure_libcpp_on_non_freestanding: bool = false, any_non_single_threaded: bool = false, @@ -109,7 +109,7 @@ pub const Options = struct { lto: ?std.zig.LtoMode = null, incremental: bool = false, /// WASI-only. Type of WASI execution model ("command" or "reactor"). - wasi_exec_model: ?std.builtin.WasiExecModel = null, + wasi_exec_model: ?std.lang.WasiExecModel = null, import_memory: ?bool = null, export_memory: ?bool = null, shared_memory: ?bool = null, diff --git a/src/InternPool.zig b/src/InternPool.zig @@ -486,12 +486,12 @@ pub const AnalUnit = packed struct(u64) { pub const MemoizedStateStage = enum(u32) { /// Everything other than panics and `VaList`. main, - /// Everything within `std.builtin.Panic`. + /// Everything within `std.lang.Panic`. /// Since the panic handler is user-provided, this must be able to reference the other memoized state. panic, - /// Specifically `std.builtin.VaList`. See `Zcu.BuiltinDecl.stage`. + /// Specifically `std.lang.VaList`. See `Zcu.StdLangDecl.stage`. va_list, - /// Everything within `std.builtin.assembly`. See `Zcu.BuiltinDecl.stage`. + /// Everything within `std.lang.assembly`. See `Zcu.StdLangDecl.stage`. assembly, }; @@ -566,7 +566,7 @@ pub const Nav = struct { type: InternPool.Index, @"align": Alignment, @"linksection": OptionalNullTerminatedString, - @"addrspace": std.builtin.AddressSpace, + @"addrspace": std.lang.AddressSpace, @"const": bool, @"threadlocal": bool, /// This field is whether this `Nav` is a literal `extern` definition. @@ -678,7 +678,7 @@ pub const Nav = struct { const Bits = packed struct(u16) { @"align": Alignment, - @"addrspace": std.builtin.AddressSpace, + @"addrspace": std.lang.AddressSpace, @"const": bool, @"threadlocal": bool, is_extern_decl: bool, @@ -1084,7 +1084,7 @@ const Local = struct { } } fn PtrElem(comptime opts: struct { - size: std.builtin.Type.Pointer.Size, + size: std.lang.Type.Pointer.Size, is_const: bool = false, }) type { const elem_info = @typeInfo(Elem).@"struct"; @@ -2029,7 +2029,7 @@ pub const Key = union(enum) { val: Index, }; - pub const IntType = std.builtin.Type.Int; + pub const IntType = std.lang.Type.Int; /// Extern for hashing via memory reinterpretation. pub const ErrorUnionType = extern struct { @@ -2090,8 +2090,8 @@ pub const Key = union(enum) { bit_offset: u16, }; - pub const Size = std.builtin.Type.Pointer.Size; - pub const AddressSpace = std.builtin.AddressSpace; + pub const Size = std.lang.Type.Pointer.Size; + pub const AddressSpace = std.lang.AddressSpace; }; /// Extern so that hashing can be done via memory reinterpreting. @@ -2160,7 +2160,7 @@ pub const Key = union(enum) { /// Tells whether a parameter is noalias. See `paramIsNoalias` helper /// method for accessing this. noalias_bits: u32, - cc: std.builtin.CallingConvention, + cc: std.lang.CallingConvention, is_var_args: bool, is_noinline: bool, @@ -2207,15 +2207,15 @@ pub const Key = union(enum) { /// For example `extern "c" fn write(...) usize` would have 'c' as library name. /// Index into the string table bytes. lib_name: OptionalNullTerminatedString, - linkage: std.builtin.GlobalLinkage, - visibility: std.builtin.SymbolVisibility, + linkage: std.lang.GlobalLinkage, + visibility: std.lang.SymbolVisibility, is_threadlocal: bool, is_dll_import: bool, - relocation: std.builtin.ExternOptions.Relocation, - decoration: ?std.builtin.ExternOptions.Decoration, + relocation: std.lang.ExternOptions.Relocation, + decoration: ?std.lang.ExternOptions.Decoration, is_const: bool, alignment: Alignment, - @"addrspace": std.builtin.AddressSpace, + @"addrspace": std.lang.AddressSpace, /// The ZIR instruction which created this extern; used only for source locations. /// This is a `declaration`. zir_index: TrackedInst.Index, @@ -2289,7 +2289,7 @@ pub const Key = union(enum) { return @atomicLoad(FuncAnalysis, func.analysisPtr(ip), .unordered); } - pub fn setBranchHint(func: Func, ip: *InternPool, io: Io, hint: std.builtin.BranchHint) void { + pub fn setBranchHint(func: Func, ip: *InternPool, io: Io, hint: std.lang.BranchHint) void { const extra_mutex = &ip.getLocal(func.tid).mutate.extra.mutex; extra_mutex.lockUncancelable(io); defer extra_mutex.unlock(io); @@ -3186,7 +3186,7 @@ pub const LoadedStructType = struct { name_nav: Nav.Index.Optional, namespace: NamespaceIndex, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, /// May be `undefined` if `layout != .@"packed"`. packed_backing_mode: BackingTypeMode, @@ -3369,7 +3369,7 @@ pub const LoadedUnionType = struct { name_nav: Nav.Index.Optional, namespace: NamespaceIndex, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, enum_tag_mode: BackingTypeMode, /// May be `undefined` if `layout != .@"packed"`. packed_backing_mode: BackingTypeMode, @@ -5368,10 +5368,10 @@ pub const Tag = enum(u8) { descriptor_binding: u32, pub const Flags = packed struct(u32) { - linkage: std.builtin.GlobalLinkage, - visibility: std.builtin.SymbolVisibility, + linkage: std.lang.GlobalLinkage, + visibility: std.lang.SymbolVisibility, is_dll_import: bool, - relocation: std.builtin.ExternOptions.Relocation, + relocation: std.lang.ExternOptions.Relocation, source: Source, decoration_type: DecorationType, _: u23 = 0, @@ -5380,13 +5380,13 @@ pub const Tag = enum(u8) { pub const DecorationType = enum(u2) { none, location, descriptor }; }; - pub fn decoration(self: Extern) ?std.builtin.ExternOptions.Decoration { + pub fn decoration(self: Extern) ?std.lang.ExternOptions.Decoration { return switch (self.flags.decoration_type) { .none => null, - .location => std.builtin.ExternOptions.Decoration{ + .location => std.lang.ExternOptions.Decoration{ .location = self.location_or_descriptor_set, }, - .descriptor => std.builtin.ExternOptions.Decoration{ .descriptor = .{ .set = self.location_or_descriptor_set, .binding = self.descriptor_binding } }, + .descriptor => std.lang.ExternOptions.Decoration{ .descriptor = .{ .set = self.location_or_descriptor_set, .binding = self.descriptor_binding } }, }; } }; @@ -5711,7 +5711,7 @@ pub const BackingTypeMode = enum(u1) { /// to be part of the type of the function. pub const FuncAnalysis = packed struct(u32) { want_runtime_analysis: bool, - branch_hint: std.builtin.BranchHint, + branch_hint: std.lang.BranchHint, is_noinline: bool, has_error_trace: bool, /// True if this function has an inferred error set. @@ -7980,7 +7980,7 @@ pub fn getDeclaredStructType( // InternPool, so that it is possible for their backing storage to be "reallocated" as needed // during type resolution. fields_len: u32, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, any_comptime_fields: bool, any_field_defaults: bool, any_field_aligns: bool, @@ -8124,7 +8124,7 @@ pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Pe zir_index: TrackedInst.Index, type_hash: u64, fields_len: u32, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, any_comptime_fields: bool, any_field_defaults: bool, any_field_aligns: bool, @@ -8300,7 +8300,7 @@ pub fn getDeclaredUnionType( // InternPool, so that it is possible for their backing storage to be "reallocated" as needed // during type resolution. fields_len: u32, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, any_field_aligns: bool, tag_usage: LoadedUnionType.TagUsage, enum_tag_mode: BackingTypeMode, @@ -8421,7 +8421,7 @@ pub fn getReifiedUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Per zir_index: TrackedInst.Index, type_hash: u64, fields_len: u32, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, any_field_aligns: bool, tag_usage: LoadedUnionType.TagUsage, /// Explicitly specified enum tag type. `.none` if `tag_usage != .tagged`. @@ -8969,7 +8969,7 @@ pub const GetFuncTypeKey = struct { comptime_bits: u32 = 0, noalias_bits: u32 = 0, /// `null` means generic. - cc: ?std.builtin.CallingConvention = .auto, + cc: ?std.lang.CallingConvention = .auto, is_var_args: bool = false, is_noinline: bool = false, }; @@ -9117,7 +9117,7 @@ pub const GetFuncDeclKey = struct { rbrace_line: u32, lbrace_column: u32, rbrace_column: u32, - cc: ?std.builtin.CallingConvention, + cc: ?std.lang.CallingConvention, is_noinline: bool, }; @@ -9193,7 +9193,7 @@ pub const GetFuncDeclIesKey = struct { comptime_bits: u32, bare_return_type: Index, /// null means generic. - cc: ?std.builtin.CallingConvention, + cc: ?std.lang.CallingConvention, is_var_args: bool, is_noinline: bool, zir_body_inst: TrackedInst.Index, @@ -11763,7 +11763,7 @@ pub fn getBackingAddrTag(ip: *const InternPool, val: Index) ?Key.Ptr.BaseAddr.Ta /// This is a particularly hot function, so we operate directly on encodings /// rather than the more straightforward implementation of calling `indexToKey`. /// Asserts `index` is not `.generic_poison_type`. -pub fn zigTypeTag(ip: *const InternPool, index: Index) std.builtin.TypeId { +pub fn zigTypeTag(ip: *const InternPool, index: Index) std.lang.TypeId { return switch (index) { .u0_type, .u1_type, @@ -12407,13 +12407,13 @@ pub fn getErrorValueIfExists(ip: *const InternPool, name: NullTerminatedString) } const PackedCallingConvention = packed struct(u18) { - tag: std.builtin.CallingConvention.Tag, + tag: std.lang.CallingConvention.Tag, /// May be ignored depending on `tag`. incoming_stack_alignment: Alignment, /// Interpretation depends on `tag`. extra: u4, - fn pack(cc: std.builtin.CallingConvention) PackedCallingConvention { + fn pack(cc: std.lang.CallingConvention) PackedCallingConvention { return switch (cc) { inline else => |pl, tag| switch (@TypeOf(pl)) { void => .{ @@ -12421,42 +12421,42 @@ const PackedCallingConvention = packed struct(u18) { .incoming_stack_alignment = .none, // unused .extra = 0, // unused }, - std.builtin.CallingConvention.CommonOptions => .{ + std.lang.CallingConvention.CommonOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), .extra = 0, // unused }, - std.builtin.CallingConvention.X86RegparmOptions => .{ + std.lang.CallingConvention.X86RegparmOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), .extra = pl.register_params, }, - std.builtin.CallingConvention.ArcInterruptOptions => .{ + std.lang.CallingConvention.ArcInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), .extra = @intFromEnum(pl.type), }, - std.builtin.CallingConvention.ArmInterruptOptions => .{ + std.lang.CallingConvention.ArmInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), .extra = @intFromEnum(pl.type), }, - std.builtin.CallingConvention.MicroblazeInterruptOptions => .{ + std.lang.CallingConvention.MicroblazeInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), .extra = @intFromEnum(pl.type), }, - std.builtin.CallingConvention.MipsInterruptOptions => .{ + std.lang.CallingConvention.MipsInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), .extra = @intFromEnum(pl.mode), }, - std.builtin.CallingConvention.RiscvInterruptOptions => .{ + std.lang.CallingConvention.RiscvInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), .extra = @intFromEnum(pl.mode), }, - std.builtin.CallingConvention.ShInterruptOptions => .{ + std.lang.CallingConvention.ShInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), .extra = @intFromEnum(pl.save), @@ -12466,41 +12466,41 @@ const PackedCallingConvention = packed struct(u18) { }; } - fn unpack(cc: PackedCallingConvention) std.builtin.CallingConvention { + fn unpack(cc: PackedCallingConvention) std.lang.CallingConvention { return switch (cc.tag) { inline else => |tag| @unionInit( - std.builtin.CallingConvention, + std.lang.CallingConvention, @tagName(tag), - switch (@FieldType(std.builtin.CallingConvention, @tagName(tag))) { + switch (@FieldType(std.lang.CallingConvention, @tagName(tag))) { void => {}, - std.builtin.CallingConvention.CommonOptions => .{ + std.lang.CallingConvention.CommonOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), }, - std.builtin.CallingConvention.X86RegparmOptions => .{ + std.lang.CallingConvention.X86RegparmOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), .register_params = @intCast(cc.extra), }, - std.builtin.CallingConvention.ArcInterruptOptions => .{ + std.lang.CallingConvention.ArcInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), .type = @enumFromInt(cc.extra), }, - std.builtin.CallingConvention.ArmInterruptOptions => .{ + std.lang.CallingConvention.ArmInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), .type = @enumFromInt(cc.extra), }, - std.builtin.CallingConvention.MicroblazeInterruptOptions => .{ + std.lang.CallingConvention.MicroblazeInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), .type = @enumFromInt(cc.extra), }, - std.builtin.CallingConvention.MipsInterruptOptions => .{ + std.lang.CallingConvention.MipsInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), .mode = @enumFromInt(cc.extra), }, - std.builtin.CallingConvention.RiscvInterruptOptions => .{ + std.lang.CallingConvention.RiscvInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), .mode = @enumFromInt(cc.extra), }, - std.builtin.CallingConvention.ShInterruptOptions => .{ + std.lang.CallingConvention.ShInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), .save = @enumFromInt(cc.extra), }, diff --git a/src/Package/Module.zig b/src/Package/Module.zig @@ -15,8 +15,8 @@ fully_qualified_name: []const u8, deps: Deps = .{}, resolved_target: ResolvedTarget, -optimize_mode: std.builtin.OptimizeMode, -code_model: std.builtin.CodeModel, +optimize_mode: std.lang.OptimizeMode, +code_model: std.lang.CodeModel, single_threaded: bool, error_tracing: bool, valgrind: bool, @@ -29,7 +29,7 @@ red_zone: bool, sanitize_c: std.zig.SanitizeC, sanitize_thread: bool, fuzz: bool, -unwind_tables: std.builtin.UnwindTables, +unwind_tables: std.lang.UnwindTables, cc_argv: []const []const u8, /// (SPIR-V) whether to generate a structured control flow graph or not structured_cfg: bool, @@ -61,8 +61,8 @@ pub const CreateOptions = struct { pub const Inherited = struct { /// If this is null then `parent` must be non-null. resolved_target: ?ResolvedTarget = null, - optimize_mode: ?std.builtin.OptimizeMode = null, - code_model: ?std.builtin.CodeModel = null, + optimize_mode: ?std.lang.OptimizeMode = null, + code_model: ?std.lang.CodeModel = null, single_threaded: ?bool = null, error_tracing: ?bool = null, valgrind: ?bool = null, @@ -75,7 +75,7 @@ pub const CreateOptions = struct { /// other number means stack protection with that buffer size. stack_protector: ?u32 = null, red_zone: ?bool = null, - unwind_tables: ?std.builtin.UnwindTables = null, + unwind_tables: ?std.lang.UnwindTables = null, sanitize_c: ?std.zig.SanitizeC = null, sanitize_thread: ?bool = null, fuzz: ?bool = null, @@ -238,7 +238,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module { break :b false; }; - const code_model: std.builtin.CodeModel = b: { + const code_model: std.lang.CodeModel = b: { if (options.inherited.code_model) |x| break :b x; if (options.parent) |p| break :b p.code_model; break :b .default; diff --git a/src/Sema.zig b/src/Sema.zig @@ -135,7 +135,7 @@ allow_memoize: bool = true, /// The `BranchHint` for the current branch of runtime control flow. /// This state is on `Sema` so that `cold` hints can be propagated up through blocks with less special handling. -branch_hint: ?std.builtin.BranchHint = null, +branch_hint: ?std.lang.BranchHint = null, const RuntimeIndex = enum(u32) { zero = 0, @@ -383,7 +383,7 @@ pub const Block = struct { want_safety: ?bool = null, /// What mode to generate float operations in, set by @setFloatMode - float_mode: std.builtin.FloatMode = .strict, + float_mode: std.lang.FloatMode = .strict, /// If not `null`, this boolean is set when a `dbg_var_ptr`, `dbg_var_val`, or `dbg_arg_inline`. /// instruction is emitted. It signals that the innermost lexically @@ -759,7 +759,7 @@ pub const Block = struct { }); } - fn addReduce(block: *Block, operand: Air.Inst.Ref, operation: std.builtin.ReduceOp) !Air.Inst.Ref { + fn addReduce(block: *Block, operand: Air.Inst.Ref, operation: std.lang.ReduceOp) !Air.Inst.Ref { const sema = block.sema; const zcu = sema.pt.zcu; const allow_optimized = switch (sema.typeOf(operand).childType(zcu).zigTypeTag(zcu)) { @@ -1023,7 +1023,7 @@ pub fn deinit(sema: *Sema) void { /// control flow happens here, Sema will convert it to runtime control flow by introducing post-hoc /// blocks where necessary. /// Returns the branch hint for this branch. -fn analyzeBodyRuntimeBreak(sema: *Sema, block: *Block, body: []const Zir.Inst.Index) !std.builtin.BranchHint { +fn analyzeBodyRuntimeBreak(sema: *Sema, block: *Block, body: []const Zir.Inst.Index) !std.lang.BranchHint { const parent_hint = sema.branch_hint; defer sema.branch_hint = parent_hint; sema.branch_hint = null; @@ -1473,7 +1473,7 @@ fn analyzeBodyInner( }, .value_placeholder => unreachable, // never appears in a body .field_parent_ptr => try sema.zirFieldParentPtr(block, extended), - .builtin_value => try sema.zirBuiltinValue(block, extended), + .std_lang_value => try sema.zirStdLangValue(block, extended), .inplace_arith_result_ty => try sema.zirInplaceArithResultTy(extended), .dbg_empty_stmt => { try sema.zirDbgEmptyStmt(block, inst); @@ -2225,7 +2225,7 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize) const addrs_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(addr_arr_ty)); // var st: StackTrace = undefined; - const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace); + const stack_trace_ty = try sema.getStdLangType(block.nodeOffset(.zero), .StackTrace); const st_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(stack_trace_ty)); // st.instruction_addresses = &addrs; @@ -2804,11 +2804,11 @@ fn analyzeValueAsCallconv( block: *Block, src: LazySrcLoc, val: Value, -) !std.builtin.CallingConvention { - return interpretBuiltinType(sema, block, src, val, std.builtin.CallingConvention); +) !std.lang.CallingConvention { + return interpretStdLangType(sema, block, src, val, std.lang.CallingConvention); } -fn interpretBuiltinType( +fn interpretStdLangType( sema: *Sema, block: *Block, src: LazySrcLoc, @@ -2818,7 +2818,7 @@ fn interpretBuiltinType( return val.interpret(T, sema.pt) catch |err| switch (err) { error.OutOfMemory => |e| return e, error.UndefinedValue => return sema.failWithUseOfUndef(block, src, null), - error.TypeMismatch => @panic("std.builtin is corrupt"), + error.TypeMismatch => @panic("std.lang is corrupt"), }; } @@ -5074,7 +5074,7 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void } try sema.ensureMemoizedStateResolved(src, .panic); - const panic_fn_index = zcu.builtin_decl_values.get(.@"panic.call"); + const panic_fn_index = zcu.std_lang_decl_values.get(.@"panic.call"); const opt_usize_ty = try pt.optionalType(.usize_type); const null_ret_addr = Air.internedToRef((try pt.intern(.{ .opt = .{ .ty = opt_usize_ty.toIntern(), @@ -5692,7 +5692,7 @@ fn zirDisableIntrinsics(sema: *Sema) CompileError!void { fn zirSetFloatMode(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!void { const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data; const src = block.builtinCallArgSrc(extra.node, 0); - block.float_mode = try sema.resolveBuiltinEnum(block, src, extra.operand, .FloatMode, .{ .simple = .operand_setFloatMode }); + block.float_mode = try sema.resolveStdLangEnum(block, src, extra.operand, .FloatMode, .{ .simple = .operand_setFloatMode }); } fn zirSetRuntimeSafety(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { @@ -6008,10 +6008,10 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref if (!block.ownerModule().error_tracing) return .none; - const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace); + const stack_trace_ty = try sema.getStdLangType(block.nodeOffset(.zero), .StackTrace); const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls); const field_index = sema.structFieldIndex(block, stack_trace_ty, field_name, LazySrcLoc.unneeded) catch |err| switch (err) { - error.AnalysisFail => @panic("std.builtin.StackTrace is corrupt"), + error.AnalysisFail => @panic("std.lang.StackTrace is corrupt"), error.ComptimeReturn, error.ComptimeBreak => unreachable, error.OutOfMemory, error.Canceled => |e| return e, }; @@ -6051,7 +6051,7 @@ fn popErrorReturnTrace( // AstGen determined this result does not go to an error-handling expr (try/catch/return etc.), or // the result is comptime-known to be a non-error. Either way, pop unconditionally. - const stack_trace_ty = try sema.getBuiltinType(src, .StackTrace); + const stack_trace_ty = try sema.getStdLangType(src, .StackTrace); const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty); const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty); const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls); @@ -6076,7 +6076,7 @@ fn popErrorReturnTrace( defer then_block.instructions.deinit(gpa); // If non-error, then pop the error return trace by restoring the index. - const stack_trace_ty = try sema.getBuiltinType(src, .StackTrace); + const stack_trace_ty = try sema.getStdLangType(src, .StackTrace); const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty); const err_return_trace = try then_block.addTy(.err_return_trace, ptr_stack_trace_ty); const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls); @@ -6147,7 +6147,7 @@ fn zirCall( const extra = sema.code.extraData(ExtraType, inst_data.payload_index); const args_len = extra.data.flags.args_len; - const modifier: std.builtin.CallModifier = @enumFromInt(extra.data.flags.packed_modifier); + const modifier: std.lang.CallModifier = @enumFromInt(extra.data.flags.packed_modifier); const ensure_result_used = extra.data.flags.ensure_result_used; const pop_error_return_trace = extra.data.flags.pop_error_return_trace; @@ -6215,7 +6215,7 @@ fn zirCall( // If any input is an error-type, we might need to pop any trace it generated. Otherwise, we only // need to clean-up our own trace if we were passed to a non-error-handling expression. if (input_is_error or (pop_error_return_trace and return_ty.isError(zcu))) { - const stack_trace_ty = try sema.getBuiltinType(call_src, .StackTrace); + const stack_trace_ty = try sema.getStdLangType(call_src, .StackTrace); const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls); const field_index = try sema.structFieldIndex(block, stack_trace_ty, field_name, call_src); @@ -6322,7 +6322,7 @@ fn callBuiltin( block: *Block, call_src: LazySrcLoc, builtin_fn: Air.Inst.Ref, - modifier: std.builtin.CallModifier, + modifier: std.lang.CallModifier, args: []const Air.Inst.Ref, operation: CallOperation, ) !void { @@ -6543,7 +6543,7 @@ fn analyzeCall( func_ty: Type, func_src: LazySrcLoc, call_src: LazySrcLoc, - modifier: std.builtin.CallModifier, + modifier: std.lang.CallModifier, ensure_result_used: bool, args_info: CallArgsInfo, call_dbg_node: ?Zir.Inst.Index, @@ -8367,7 +8367,7 @@ fn zirFunc( // If this instruction has a body, then it's a function declaration, and we decide // the callconv based on whether it is exported. Otherwise, the callconv defaults // to `.auto`. - const cc: std.builtin.CallingConvention = if (has_body) cc: { + const cc: std.lang.CallingConvention = if (has_body) cc: { const func_decl_nav = sema.owner.unwrap().nav_val; const fn_is_exported = exported: { const decl_inst = ip.getNav(func_decl_nav).analysis.?.zir_index.resolve(ip) orelse return error.AnalysisFail; @@ -8377,10 +8377,10 @@ fn zirFunc( if (fn_is_exported) { break :cc target.cCallingConvention() orelse { // This target has no default C calling convention. We sometimes trigger a similar - // error by trying to evaluate `std.builtin.CallingConvention.c`, so for consistency, + // error by trying to evaluate `std.lang.CallingConvention.c`, so for consistency, // let's eval that now and just get the transitive error. (It's guaranteed to error // because it does the exact `cCallingConvention` call we just did.) - const cc_type = try sema.getBuiltinType(src, .CallingConvention); + const cc_type = try sema.getStdLangType(src, .CallingConvention); _ = try sema.namespaceLookupVal( block, LazySrcLoc.unneeded, @@ -8388,7 +8388,7 @@ fn zirFunc( try ip.getOrPutString(gpa, io, pt.tid, "c", .no_embedded_nulls), ); // The above should have errored. - @panic("std.builtin is corrupt"); + @panic("std.lang is corrupt"); }; } else { break :cc .auto; @@ -8509,7 +8509,7 @@ pub fn handleExternLibName( /// These are calling conventions that are confirmed to work with variadic functions. /// Any calling conventions not included here are either not yet verified to work with variadic /// functions or there are no more other calling conventions that support variadic functions. -const calling_conventions_supporting_var_args = [_]std.builtin.CallingConvention.Tag{ +const calling_conventions_supporting_var_args = [_]std.lang.CallingConvention.Tag{ .x86_16_cdecl, .x86_64_sysv, .x86_64_x32, @@ -8570,12 +8570,12 @@ const calling_conventions_supporting_var_args = [_]std.builtin.CallingConvention .xtensa_call0, .xtensa_windowed, }; -fn callConvSupportsVarArgs(cc: std.builtin.CallingConvention.Tag) bool { +fn callConvSupportsVarArgs(cc: std.lang.CallingConvention.Tag) bool { return for (calling_conventions_supporting_var_args) |supported_cc| { if (cc == supported_cc) return true; } else false; } -fn checkCallConvSupportsVarArgs(sema: *Sema, block: *Block, src: LazySrcLoc, cc: std.builtin.CallingConvention.Tag) CompileError!void { +fn checkCallConvSupportsVarArgs(sema: *Sema, block: *Block, src: LazySrcLoc, cc: std.lang.CallingConvention.Tag) CompileError!void { const CallingConventionsSupportingVarArgsList = struct { arch: std.Target.Cpu.Arch, pub fn format(ctx: @This(), w: *std.Io.Writer) std.Io.Writer.Error!void { @@ -8612,7 +8612,7 @@ fn checkParamType( param_is_comptime: bool, param_is_noalias: bool, param_src: LazySrcLoc, - cc: std.builtin.CallingConvention, + cc: std.lang.CallingConvention, ) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; @@ -8668,7 +8668,7 @@ fn checkReturnTypeAndCallConv( block: *Block, bare_ret_ty: Type, ret_ty_src: LazySrcLoc, - @"callconv": std.builtin.CallingConvention, + @"callconv": std.lang.CallingConvention, callconv_src: LazySrcLoc, /// non-`null` only if the function is varargs. opt_varargs_src: ?LazySrcLoc, @@ -8772,7 +8772,7 @@ fn checkReturnTypeAndCallConv( fn validateResolvedFuncType( sema: *Sema, block: *Block, - @"callconv": std.builtin.CallingConvention, + @"callconv": std.lang.CallingConvention, param_types: []const InternPool.Index, ret_ty: Type, src: LazySrcLoc, @@ -8823,7 +8823,7 @@ fn validateResolvedFuncType( } } -fn callConvIsCallable(cc: std.builtin.CallingConvention.Tag) bool { +fn callConvIsCallable(cc: std.lang.CallingConvention.Tag) bool { return switch (cc) { .naked, @@ -8898,7 +8898,7 @@ fn funcCommon( block: *Block, src_node_offset: std.zig.Ast.Node.Offset, func_inst: Zir.Inst.Index, - cc: std.builtin.CallingConvention, + cc: std.lang.CallingConvention, /// this might be Type.generic_poison bare_return_type: Type, var_args: bool, @@ -9896,7 +9896,7 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp else try sema.analyzeIsNonErr(block, operand_src, eu_maybe_ptr); - const non_err_hint: std.builtin.BranchHint = hint: { + const non_err_hint: std.lang.BranchHint = hint: { // don't analyze the non-error body if it's unreachable if (non_err_cond == .bool_false) { break :hint undefined; @@ -10488,14 +10488,14 @@ fn finishSwitchBr( const bags_required = std.math.divCeil(u32, hints.count + additional_count, hints_per_bag) catch unreachable; return hints.bags.ensureUnusedCapacity(gpa_inner, bags_required); } - fn appendAssumeCapacity(hints: *@This(), hint: std.builtin.BranchHint) void { + fn appendAssumeCapacity(hints: *@This(), hint: std.lang.BranchHint) void { const idx_in_bag = hints.count % hints_per_bag; var bag: u32 = if (idx_in_bag > 0) hints.bags.pop().? else 0; - bag |= @as(u32, @intFromEnum(hint)) << @intCast(@bitSizeOf(std.builtin.BranchHint) * idx_in_bag); + bag |= @as(u32, @intFromEnum(hint)) << @intCast(@bitSizeOf(std.lang.BranchHint) * idx_in_bag); hints.count += 1; return hints.bags.appendAssumeCapacity(bag); } - fn append(hints: *@This(), gpa_inner: Allocator, hint: std.builtin.BranchHint) Allocator.Error!void { + fn append(hints: *@This(), gpa_inner: Allocator, hint: std.lang.BranchHint) Allocator.Error!void { try hints.ensureUnusedCapacity(gpa_inner, 1); return hints.appendAssumeCapacity(hint); } @@ -10574,7 +10574,7 @@ fn finishSwitchBr( } emit_bb = true; - const prong_hint: std.builtin.BranchHint = hint: { + const prong_hint: std.lang.BranchHint = hint: { if (analyze_body) break :hint try sema.analyzeSwitchProng( &case_block, operand, @@ -10717,7 +10717,7 @@ fn finishSwitchBr( case_block.instructions.clearRetainingCapacity(); case_block.error_return_trace_index = child_block.error_return_trace_index; - const prong_hint: std.builtin.BranchHint = hint: { + const prong_hint: std.lang.BranchHint = hint: { if (any_analyze_body) break :hint try sema.analyzeSwitchProng( &case_block, operand, @@ -10804,7 +10804,7 @@ fn finishSwitchBr( if (emit_bb) try sema.emitBackwardBranch(block, else_prong_src); emit_bb = true; - const prong_hint: std.builtin.BranchHint = hint: { + const prong_hint: std.lang.BranchHint = hint: { if (analyze_body) break :hint try sema.analyzeSwitchProng( &case_block, operand, @@ -10864,7 +10864,7 @@ fn finishSwitchBr( cases_len += 1; - const prong_hint: std.builtin.BranchHint = hint: { + const prong_hint: std.lang.BranchHint = hint: { if (!else_case.is_inline) break :hint try sema.analyzeSwitchProng( &case_block, operand, @@ -11937,7 +11937,7 @@ fn analyzeSwitchProng( else_err_ty: ?Type, switch_inst: Zir.Inst.Index, zir_switch: *const Zir.UnwrappedSwitchBlock, -) CompileError!std.builtin.BranchHint { +) CompileError!std.lang.BranchHint { const pt = sema.pt; const zcu = pt.zcu; @@ -12328,7 +12328,7 @@ fn analyzeSwitchPayloadCapture( { // All branch hints are `.none`, so just add zero elems. - comptime assert(@intFromEnum(std.builtin.BranchHint.none) == 0); + comptime assert(@intFromEnum(std.lang.BranchHint.none) == 0); const need_elems = std.math.divCeil(usize, prong_count + 1, 10) catch unreachable; try cases_extra.appendNTimes(0, need_elems); } @@ -12711,7 +12711,7 @@ fn maybeErrorUnwrap( const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; const msg_inst = sema.resolveInst(inst_data.operand); - const panic_fn = try getBuiltin(sema, operand_src, .@"panic.call"); + const panic_fn = try getStdLangValue(sema, operand_src, .@"panic.call"); const args: [2]Air.Inst.Ref = .{ msg_inst, .null_value }; try sema.callBuiltin(block, operand_src, Air.internedToRef(panic_fn), .auto, &args, .@"safety check"); return true; @@ -15319,7 +15319,7 @@ fn zirAsm( } const clobbers_src = block.src(.{ .asm_clobbers = src.offset.node_offset.x }); - const clobbers_ty = try sema.getBuiltinType(src, .@"assembly.Clobbers"); + const clobbers_ty = try sema.getStdLangType(src, .@"assembly.Clobbers"); const clobbers = if (extra.data.clobbers == .none) empty: { break :empty try sema.structInitEmpty(block, clobbers_ty, src, src); } else clobbers: { @@ -15930,7 +15930,7 @@ fn zirBuiltinSrc( } }); }; - const src_loc_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .SourceLocation); + const src_loc_ty = try sema.getStdLangType(block.nodeOffset(.zero), .SourceLocation); const fields = .{ // module: [:0]const u8, module_name_val, @@ -15957,7 +15957,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ty = try sema.resolveType(block, src, inst_data.operand); - const type_info_ty = try sema.getBuiltinType(src, .Type); + const type_info_ty = try sema.getStdLangType(src, .Type); const type_info_tag_ty = type_info_ty.unionTagType(zcu).?; try sema.ensureLayoutResolved(ty, src, .type_info); @@ -15979,15 +15979,15 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai => |type_info_tag| return .fromValue(try pt.unionValue( type_info_ty, Value.uninterpret(type_info_tag, type_info_tag_ty, pt) catch |err| switch (err) { - error.TypeMismatch => @panic("std.builtin is corrupt"), + error.TypeMismatch => @panic("std.lang is corrupt"), error.OutOfMemory => |e| return e, }, .void, )), .@"fn" => { - const fn_info_ty = try sema.getBuiltinType(src, .@"Type.Fn"); - const param_info_ty = try sema.getBuiltinType(src, .@"Type.Fn.Param"); + const fn_info_ty = try sema.getStdLangType(src, .@"Type.Fn"); + const param_info_ty = try sema.getStdLangType(src, .@"Type.Fn.Param"); const func_ty_info = zcu.typeToFunc(ty).?; const param_vals = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len); @@ -16068,9 +16068,9 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai .val = if (ret_ty_is_generic) .none else func_ty_info.return_type, } }); - const callconv_ty = try sema.getBuiltinType(src, .CallingConvention); + const callconv_ty = try sema.getStdLangType(src, .CallingConvention); const callconv_val = Value.uninterpret(func_ty_info.cc, callconv_ty, pt) catch |err| switch (err) { - error.TypeMismatch => @panic("std.builtin is corrupt"), + error.TypeMismatch => @panic("std.lang is corrupt"), error.OutOfMemory => |e| return e, }; @@ -16088,13 +16088,13 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"fn"))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"fn"))).toIntern(), .val = (try pt.aggregateValue(fn_info_ty, &field_values)).toIntern(), }))); }, .int => { - const int_info_ty = try sema.getBuiltinType(src, .@"Type.Int"); - const signedness_ty = try sema.getBuiltinType(src, .Signedness); + const int_info_ty = try sema.getStdLangType(src, .@"Type.Int"); + const signedness_ty = try sema.getStdLangType(src, .Signedness); const info = ty.intInfo(zcu); const field_values = .{ // signedness: Signedness, @@ -16104,12 +16104,12 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.int))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.int))).toIntern(), .val = (try pt.aggregateValue(int_info_ty, &field_values)).toIntern(), }))); }, .float => { - const float_info_ty = try sema.getBuiltinType(src, .@"Type.Float"); + const float_info_ty = try sema.getStdLangType(src, .@"Type.Float"); const field_vals = .{ // bits: u16, @@ -16117,7 +16117,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.float))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.float))).toIntern(), .val = (try pt.aggregateValue(float_info_ty, &field_vals)).toIntern(), }))); }, @@ -16135,9 +16135,9 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } })); }; - const addrspace_ty = try sema.getBuiltinType(src, .AddressSpace); - const pointer_ty = try sema.getBuiltinType(src, .@"Type.Pointer"); - const ptr_size_ty = try sema.getBuiltinType(src, .@"Type.Pointer.Size"); + const addrspace_ty = try sema.getStdLangType(src, .AddressSpace); + const pointer_ty = try sema.getStdLangType(src, .@"Type.Pointer"); + const ptr_size_ty = try sema.getStdLangType(src, .@"Type.Pointer.Size"); const field_values = .{ // size: Size, @@ -16162,12 +16162,12 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.pointer))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.pointer))).toIntern(), .val = (try pt.aggregateValue(pointer_ty, &field_values)).toIntern(), }))); }, .array => { - const array_field_ty = try sema.getBuiltinType(src, .@"Type.Array"); + const array_field_ty = try sema.getStdLangType(src, .@"Type.Array"); const info = ty.arrayInfo(zcu); const field_values = .{ @@ -16180,12 +16180,12 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.array))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.array))).toIntern(), .val = (try pt.aggregateValue(array_field_ty, &field_values)).toIntern(), }))); }, .vector => { - const vector_field_ty = try sema.getBuiltinType(src, .@"Type.Vector"); + const vector_field_ty = try sema.getStdLangType(src, .@"Type.Vector"); const info = ty.arrayInfo(zcu); const field_values = .{ @@ -16196,12 +16196,12 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.vector))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.vector))).toIntern(), .val = (try pt.aggregateValue(vector_field_ty, &field_values)).toIntern(), }))); }, .optional => { - const optional_field_ty = try sema.getBuiltinType(src, .@"Type.Optional"); + const optional_field_ty = try sema.getStdLangType(src, .@"Type.Optional"); const field_values = .{ // child: type, @@ -16209,13 +16209,13 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.optional))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.optional))).toIntern(), .val = (try pt.aggregateValue(optional_field_ty, &field_values)).toIntern(), }))); }, .error_set => { // Get the Error type - const error_field_ty = try sema.getBuiltinType(src, .@"Type.Error"); + const error_field_ty = try sema.getStdLangType(src, .@"Type.Error"); // Build our list of Error values // Optional value is only null if anyerror @@ -16300,12 +16300,12 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // Construct Type{ .error_set = errors_val } return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.error_set))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.error_set))).toIntern(), .val = errors_val, }))); }, .error_union => { - const error_union_field_ty = try sema.getBuiltinType(src, .@"Type.ErrorUnion"); + const error_union_field_ty = try sema.getStdLangType(src, .@"Type.ErrorUnion"); const field_values = .{ // error_set: type, @@ -16315,7 +16315,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.error_union))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.error_union))).toIntern(), .val = (try pt.aggregateValue(error_union_field_ty, &field_values)).toIntern(), }))); }, @@ -16323,7 +16323,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const enum_obj = ip.loadEnumType(ty.toIntern()); const is_exhaustive: Value = .makeBool(!enum_obj.nonexhaustive); - const enum_field_ty = try sema.getBuiltinType(src, .@"Type.EnumField"); + const enum_field_ty = try sema.getStdLangType(src, .@"Type.EnumField"); const enum_field_vals = try sema.arena.alloc(InternPool.Index, enum_obj.field_names.len); for (enum_field_vals, 0..) |*field_val, tag_index| { @@ -16404,7 +16404,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const decls_val = try sema.typeInfoDecls(src, ip.loadEnumType(ty.toIntern()).namespace.toOptional()); - const type_enum_ty = try sema.getBuiltinType(src, .@"Type.Enum"); + const type_enum_ty = try sema.getStdLangType(src, .@"Type.Enum"); const field_values = .{ // tag_type: type, @@ -16418,13 +16418,13 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"enum"))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"enum"))).toIntern(), .val = (try pt.aggregateValue(type_enum_ty, &field_values)).toIntern(), }))); }, .@"union" => { - const type_union_ty = try sema.getBuiltinType(src, .@"Type.Union"); - const union_field_ty = try sema.getBuiltinType(src, .@"Type.UnionField"); + const type_union_ty = try sema.getStdLangType(src, .@"Type.Union"); + const union_field_ty = try sema.getStdLangType(src, .@"Type.UnionField"); const union_obj = ip.loadUnionType(ty.toIntern()); const enum_obj = ip.loadEnumType(union_obj.enum_tag_type); @@ -16524,7 +16524,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai .val = if (ty.unionTagType(zcu)) |tag_ty| tag_ty.toIntern() else .none, } }); - const container_layout_ty = try sema.getBuiltinType(src, .@"Type.ContainerLayout"); + const container_layout_ty = try sema.getStdLangType(src, .@"Type.ContainerLayout"); const field_values = .{ // layout: ContainerLayout, @@ -16539,13 +16539,13 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"union"))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"union"))).toIntern(), .val = (try pt.aggregateValue(type_union_ty, &field_values)).toIntern(), }))); }, .@"struct" => { - const type_struct_ty = try sema.getBuiltinType(src, .@"Type.Struct"); - const struct_field_ty = try sema.getBuiltinType(src, .@"Type.StructField"); + const type_struct_ty = try sema.getStdLangType(src, .@"Type.Struct"); + const struct_field_ty = try sema.getStdLangType(src, .@"Type.StructField"); var struct_field_vals: []InternPool.Index = &.{}; defer gpa.free(struct_field_vals); @@ -16713,7 +16713,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } else .none, } }); - const container_layout_ty = try sema.getBuiltinType(src, .@"Type.ContainerLayout"); + const container_layout_ty = try sema.getStdLangType(src, .@"Type.ContainerLayout"); const layout = ty.containerLayout(zcu); @@ -16731,12 +16731,12 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"struct"))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"struct"))).toIntern(), .val = (try pt.aggregateValue(type_struct_ty, &field_values)).toIntern(), }))); }, .@"opaque" => { - const type_opaque_ty = try sema.getBuiltinType(src, .@"Type.Opaque"); + const type_opaque_ty = try sema.getStdLangType(src, .@"Type.Opaque"); const decls_val = try sema.typeInfoDecls(src, ty.getNamespace(zcu)); @@ -16746,7 +16746,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"opaque"))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"opaque"))).toIntern(), .val = (try pt.aggregateValue(type_opaque_ty, &field_values)).toIntern(), }))); }, @@ -16764,7 +16764,7 @@ fn typeInfoDecls( const zcu = pt.zcu; const gpa = sema.gpa; - const declaration_ty = try sema.getBuiltinType(src, .@"Type.Declaration"); + const declaration_ty = try sema.getStdLangType(src, .@"Type.Declaration"); var decl_vals = std.array_list.Managed(InternPool.Index).init(gpa); defer decl_vals.deinit(); @@ -17323,7 +17323,7 @@ fn zirCondbr( // Reset, this may have been updated by the then block analysis sub_block.error_return_trace_index = parent_block.error_return_trace_index; - const false_hint: std.builtin.BranchHint = if (err_cond != null and + const false_hint: std.lang.BranchHint = if (err_cond != null and try sema.maybeErrorUnwrap(&sub_block, else_body, err_cond.?, cond_src, false)) h: { // nothing to do here. weight against error branch @@ -17714,7 +17714,7 @@ fn maybePushErrorTrace( assert(pt.zcu.intern_pool.funcAnalysisUnordered(sema.owner.unwrap().func).has_error_trace); const gpa = sema.gpa; - const return_err_fn = Air.internedToRef(try sema.getBuiltin(src, .returnError)); + const return_err_fn = Air.internedToRef(try sema.getStdLangValue(src, .returnError)); if (!need_check) { try sema.callBuiltin(parent_block, src, return_err_fn, .never_tail, &.{}, .@"error return"); @@ -18040,7 +18040,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air break :blk try sema.validateAlign(block, align_src, align_bytes); } else .none; - const address_space: std.builtin.AddressSpace = if (inst_data.flags.has_addrspace) blk: { + const address_space: std.lang.AddressSpace = if (inst_data.flags.has_addrspace) blk: { const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]); extra_i += 1; break :blk try sema.resolveAddressSpace(block, addrspace_src, ref, .pointer); @@ -19179,7 +19179,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace); + const stack_trace_ty = try sema.getStdLangType(block.nodeOffset(.zero), .StackTrace); const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty); const opt_ptr_stack_trace_ty = try pt.optionalType(ptr_stack_trace_ty.toIntern()); @@ -19446,7 +19446,7 @@ fn zirReifyInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const signedness_src = block.builtinCallArgSrc(inst_data.src_node, 0); const bits_src = block.builtinCallArgSrc(inst_data.src_node, 1); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; - const signedness = try sema.resolveBuiltinEnum(block, signedness_src, extra.lhs, .Signedness, .{ .simple = .int_signedness }); + const signedness = try sema.resolveStdLangEnum(block, signedness_src, extra.lhs, .Signedness, .{ .simple = .int_signedness }); const bits: u16 = @intCast(try sema.resolveInt(block, bits_src, extra.rhs, .u16, .{ .simple = .int_bit_width })); if (bits == 0 and signedness == .signed) { return sema.fail(block, bits_src, "signed integer cannot have bit width 0", .{}); @@ -19469,11 +19469,11 @@ fn zirReifySliceArgTy( const comptime_reason: std.zig.SimpleComptimeReason, const in_scalar_ty: Type, const out_scalar_ty: Type = switch (info) { // zig fmt: off - .type_to_fn_param_attrs => .{ .fn_param_attrs, .type, try sema.getBuiltinType(src, .@"Type.Fn.Param.Attributes") }, + .type_to_fn_param_attrs => .{ .fn_param_attrs, .type, try sema.getStdLangType(src, .@"Type.Fn.Param.Attributes") }, .string_to_struct_field_type => .{ .struct_field_types, .slice_const_u8, .type }, .string_to_union_field_type => .{ .union_field_types, .slice_const_u8, .type }, - .string_to_struct_field_attrs => .{ .struct_field_attrs, .slice_const_u8, try sema.getBuiltinType(src, .@"Type.StructField.Attributes") }, - .string_to_union_field_attrs => .{ .union_field_attrs, .slice_const_u8, try sema.getBuiltinType(src, .@"Type.UnionField.Attributes") }, + .string_to_struct_field_attrs => .{ .struct_field_attrs, .slice_const_u8, try sema.getStdLangType(src, .@"Type.StructField.Attributes") }, + .string_to_union_field_attrs => .{ .union_field_attrs, .slice_const_u8, try sema.getStdLangType(src, .@"Type.UnionField.Attributes") }, // zig fmt: on }; @@ -19599,18 +19599,18 @@ fn zirReifyPointer( const elem_ty_src = block.builtinCallArgSrc(extra.node, 2); const sentinel_src = block.builtinCallArgSrc(extra.node, 3); - const size_ty = try sema.getBuiltinType(size_src, .@"Type.Pointer.Size"); - const attrs_ty = try sema.getBuiltinType(attrs_src, .@"Type.Pointer.Attributes"); + const size_ty = try sema.getStdLangType(size_src, .@"Type.Pointer.Size"); + const attrs_ty = try sema.getStdLangType(attrs_src, .@"Type.Pointer.Attributes"); const size_uncoerced = sema.resolveInst(extra.size); const size_coerced = try sema.coerce(block, size_ty, size_uncoerced, size_src); const size_val = try sema.resolveConstDefinedValue(block, size_src, size_coerced, .{ .simple = .pointer_size }); - const size = try sema.interpretBuiltinType(block, size_src, size_val, std.builtin.Type.Pointer.Size); + const size = try sema.interpretStdLangType(block, size_src, size_val, std.lang.Type.Pointer.Size); const attrs_uncoerced = sema.resolveInst(extra.attrs); const attrs_coerced = try sema.coerce(block, attrs_ty, attrs_uncoerced, attrs_src); const attrs_val = try sema.resolveConstDefinedValue(block, attrs_src, attrs_coerced, .{ .simple = .pointer_attrs }); - const attrs = try sema.interpretBuiltinType(block, attrs_src, attrs_val, std.builtin.Type.Pointer.Attributes); + const attrs = try sema.interpretStdLangType(block, attrs_src, attrs_val, std.lang.Type.Pointer.Attributes); const @"align": Alignment = if (attrs.@"align") |bytes| a: { break :a try sema.validateAlign(block, attrs_src, bytes); @@ -19687,8 +19687,8 @@ fn zirReifyFn( const ret_ty_src = block.builtinCallArgSrc(extra.node, 2); const fn_attrs_src = block.builtinCallArgSrc(extra.node, 3); - const single_param_attrs_ty = try sema.getBuiltinType(param_attrs_src, .@"Type.Fn.Param.Attributes"); - const fn_attrs_ty = try sema.getBuiltinType(fn_attrs_src, .@"Type.Fn.Attributes"); + const single_param_attrs_ty = try sema.getStdLangType(param_attrs_src, .@"Type.Fn.Param.Attributes"); + const fn_attrs_ty = try sema.getStdLangType(fn_attrs_src, .@"Type.Fn.Attributes"); const param_types_uncoerced = sema.resolveInst(extra.param_types); const param_types_coerced = try sema.coerce(block, .slice_const_type, param_types_uncoerced, param_types_src); @@ -19711,17 +19711,17 @@ fn zirReifyFn( const fn_attrs_uncoerced = sema.resolveInst(extra.fn_attrs); const fn_attrs_coerced = try sema.coerce(block, fn_attrs_ty, fn_attrs_uncoerced, fn_attrs_src); const fn_attrs_val = try sema.resolveConstDefinedValue(block, fn_attrs_src, fn_attrs_coerced, .{ .simple = .fn_attrs }); - const fn_attrs = try sema.interpretBuiltinType(block, fn_attrs_src, fn_attrs_val, std.builtin.Type.Fn.Attributes); + const fn_attrs = try sema.interpretStdLangType(block, fn_attrs_src, fn_attrs_val, std.lang.Type.Fn.Attributes); var noalias_bits: u32 = 0; const param_types_ip = try sema.arena.alloc(InternPool.Index, @intCast(params_len)); for (param_types_ip, 0..@intCast(params_len)) |*param_ty_ip, param_idx| { const param_ty: Type = (try param_types_arr.elemValue(pt, param_idx)).toType(); - const param_attrs = try sema.interpretBuiltinType( + const param_attrs = try sema.interpretStdLangType( block, param_attrs_src, try param_attrs_arr.elemValue(pt, param_idx), - std.builtin.Type.Fn.Param.Attributes, + std.lang.Type.Fn.Param.Attributes, ); try sema.checkParamType( block, @@ -19825,13 +19825,13 @@ fn zirReifyStruct( } }, }; - const container_layout_ty = try sema.getBuiltinType(layout_src, .@"Type.ContainerLayout"); - const single_field_attrs_ty = try sema.getBuiltinType(field_attrs_src, .@"Type.StructField.Attributes"); + const container_layout_ty = try sema.getStdLangType(layout_src, .@"Type.ContainerLayout"); + const single_field_attrs_ty = try sema.getStdLangType(field_attrs_src, .@"Type.StructField.Attributes"); const layout_uncoerced = sema.resolveInst(extra.layout); const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src); const layout_val = try sema.resolveConstDefinedValue(block, layout_src, layout_coerced, .{ .simple = .struct_layout }); - const layout = try sema.interpretBuiltinType(block, layout_src, layout_val, std.builtin.Type.ContainerLayout); + const layout = try sema.interpretStdLangType(block, layout_src, layout_val, std.lang.Type.ContainerLayout); const backing_int_ty_uncoerced = sema.resolveInst(extra.backing_ty); const backing_int_ty_coerced = try sema.coerce(block, .optional_type, backing_int_ty_uncoerced, backing_ty_src); @@ -19912,15 +19912,15 @@ fn zirReifyStruct( const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, .{ .simple = .struct_field_names }); const field_attr_comptime = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex( - std.builtin.Type.StructField.Attributes, + std.lang.Type.StructField.Attributes, "comptime", ).?); const field_attr_align = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex( - std.builtin.Type.StructField.Attributes, + std.lang.Type.StructField.Attributes, "align", ).?); const field_attr_default_value_ptr = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex( - std.builtin.Type.StructField.Attributes, + std.lang.Type.StructField.Attributes, "default_value_ptr", ).?); @@ -19997,15 +19997,15 @@ fn zirReifyStruct( wip.field_types.get(ip)[field_idx] = field_ty.toIntern(); const field_attr_comptime = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex( - std.builtin.Type.StructField.Attributes, + std.lang.Type.StructField.Attributes, "comptime", ).?); const field_attr_align = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex( - std.builtin.Type.StructField.Attributes, + std.lang.Type.StructField.Attributes, "align", ).?); const field_attr_default_value_ptr = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex( - std.builtin.Type.StructField.Attributes, + std.lang.Type.StructField.Attributes, "default_value_ptr", ).?); @@ -20105,13 +20105,13 @@ fn zirReifyUnion( } }, }; - const container_layout_ty = try sema.getBuiltinType(layout_src, .@"Type.ContainerLayout"); - const single_field_attrs_ty = try sema.getBuiltinType(field_attrs_src, .@"Type.UnionField.Attributes"); + const container_layout_ty = try sema.getStdLangType(layout_src, .@"Type.ContainerLayout"); + const single_field_attrs_ty = try sema.getStdLangType(field_attrs_src, .@"Type.UnionField.Attributes"); const layout_uncoerced = sema.resolveInst(extra.layout); const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src); const layout_val = try sema.resolveConstDefinedValue(block, layout_src, layout_coerced, .{ .simple = .union_layout }); - const layout = try sema.interpretBuiltinType(block, layout_src, layout_val, std.builtin.Type.ContainerLayout); + const layout = try sema.interpretStdLangType(block, layout_src, layout_val, std.lang.Type.ContainerLayout); const arg_ty_uncoerced = sema.resolveInst(extra.arg_ty); const arg_ty_coerced = try sema.coerce(block, .optional_type, arg_ty_uncoerced, arg_ty_src); @@ -20191,11 +20191,11 @@ fn zirReifyUnion( const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, .{ .simple = .union_field_names }); std.hash.autoHash(&hasher, field_name); - const field_attrs = try sema.interpretBuiltinType( + const field_attrs = try sema.interpretStdLangType( block, field_attrs_src, try field_attrs_arr.elemValue(pt, field_idx), - std.builtin.Type.UnionField.Attributes, + std.lang.Type.UnionField.Attributes, ); if (field_attrs.@"align") |bytes| { if (layout == .@"packed") { @@ -20240,11 +20240,11 @@ fn zirReifyUnion( wip.field_types.get(ip)[field_idx] = field_ty.toIntern(); // No source location; first loop checked this is valid. - const field_attrs = try sema.interpretBuiltinType( + const field_attrs = try sema.interpretStdLangType( block, .unneeded, try field_attrs_arr.elemValue(pt, field_idx), - std.builtin.Type.UnionField.Attributes, + std.lang.Type.UnionField.Attributes, ); if (field_attrs.@"align") |bytes| { // No source location; first loop checked this is valid. @@ -20319,7 +20319,7 @@ fn zirReifyEnum( } }, }; - const enum_mode_ty = try sema.getBuiltinType(mode_src, .@"Type.Enum.Mode"); + const enum_mode_ty = try sema.getStdLangType(mode_src, .@"Type.Enum.Mode"); const tag_ty_uncoerced = sema.resolveInst(extra.tag_ty); const tag_ty_coerced = try sema.coerce(block, .type, tag_ty_uncoerced, tag_ty_src); @@ -20329,7 +20329,7 @@ fn zirReifyEnum( const mode_uncoerced = sema.resolveInst(extra.mode); const mode_coerced = try sema.coerce(block, enum_mode_ty, mode_uncoerced, mode_src); const mode_val = try sema.resolveConstDefinedValue(block, mode_src, mode_coerced, .{ .simple = .type }); - const nonexhaustive = switch (try sema.interpretBuiltinType(block, mode_src, mode_val, std.builtin.Type.Enum.Mode)) { + const nonexhaustive = switch (try sema.interpretStdLangType(block, mode_src, mode_val, std.lang.Type.Enum.Mode)) { .exhaustive => false, .nonexhaustive => true, }; @@ -20423,7 +20423,7 @@ fn zirReifyEnum( fn resolveVaListRef(sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref) CompileError!Air.Inst.Ref { const pt = sema.pt; - const va_list_ty = try sema.getBuiltinType(src, .VaList); + const va_list_ty = try sema.getStdLangType(src, .VaList); const va_list_ptr = try pt.singleMutPtrType(va_list_ty); const inst = sema.resolveInst(zir_ref); @@ -20462,7 +20462,7 @@ fn zirCVaCopy(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) const va_list_src = block.builtinCallArgSrc(extra.node, 0); const va_list_ref = try sema.resolveVaListRef(block, va_list_src, extra.operand); - const va_list_ty = try sema.getBuiltinType(src, .VaList); + const va_list_ty = try sema.getStdLangType(src, .VaList); try sema.requireRuntimeBlock(block, src, null); return block.addTyOp(.c_va_copy, va_list_ty, va_list_ref); @@ -20484,7 +20484,7 @@ fn zirCVaStart(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) const src_node: std.zig.Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); const src = block.nodeOffset(src_node); - const va_list_ty = try sema.getBuiltinType(src, .VaList); + const va_list_ty = try sema.getStdLangType(src, .VaList); try sema.requireRuntimeBlock(block, src, null); return block.addInst(.{ .tag = .c_va_start, @@ -21962,9 +21962,9 @@ fn checkArithmeticOp( sema: *Sema, block: *Block, src: LazySrcLoc, - scalar_tag: std.builtin.TypeId, - lhs_zig_ty_tag: std.builtin.TypeId, - rhs_zig_ty_tag: std.builtin.TypeId, + scalar_tag: std.lang.TypeId, + lhs_zig_ty_tag: std.lang.TypeId, + rhs_zig_ty_tag: std.lang.TypeId, zir_tag: Zir.Inst.Tag, ) CompileError!void { const is_int = scalar_tag == .int or scalar_tag == .comptime_int; @@ -22373,7 +22373,7 @@ fn resolveExportOptions( const io = comp.io; const ip = &zcu.intern_pool; - const export_options_ty = try sema.getBuiltinType(src, .ExportOptions); + const export_options_ty = try sema.getStdLangType(src, .ExportOptions); const air_ref = sema.resolveInst(zir_ref); const options = try sema.coerce(block, export_options_ty, air_ref, src); @@ -22387,7 +22387,7 @@ fn resolveExportOptions( const linkage_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "linkage", .no_embedded_nulls), linkage_src); const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_operand, .{ .simple = .export_options }); - const linkage = try sema.interpretBuiltinType(block, linkage_src, linkage_val, std.builtin.GlobalLinkage); + const linkage = try sema.interpretStdLangType(block, linkage_src, linkage_val, std.lang.GlobalLinkage); const section_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "section", .no_embedded_nulls), section_src); const section_opt_val = try sema.resolveConstDefinedValue(block, section_src, section_operand, .{ .simple = .export_options }); @@ -22398,7 +22398,7 @@ fn resolveExportOptions( const visibility_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "visibility", .no_embedded_nulls), visibility_src); const visibility_val = try sema.resolveConstDefinedValue(block, visibility_src, visibility_operand, .{ .simple = .export_options }); - const visibility = try sema.interpretBuiltinType(block, visibility_src, visibility_val, std.builtin.SymbolVisibility); + const visibility = try sema.interpretStdLangType(block, visibility_src, visibility_val, std.lang.SymbolVisibility); if (name.len < 1) { return sema.fail(block, name_src, "exported symbol name cannot be empty", .{}); @@ -22418,19 +22418,19 @@ fn resolveExportOptions( }; } -fn resolveBuiltinEnum( +fn resolveStdLangEnum( sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref, - comptime name: Zcu.BuiltinDecl, + comptime name: Zcu.StdLangDecl, reason: ComptimeReason, -) CompileError!@field(std.builtin, @tagName(name)) { - const ty = try sema.getBuiltinType(src, name); +) CompileError!@field(std.lang, @tagName(name)) { + const ty = try sema.getStdLangType(src, name); const air_ref = sema.resolveInst(zir_ref); const coerced = try sema.coerce(block, ty, air_ref, src); const val = try sema.resolveConstDefinedValue(block, src, coerced, reason); - return sema.interpretBuiltinType(block, src, val, @field(std.builtin, @tagName(name))); + return sema.interpretStdLangType(block, src, val, @field(std.lang, @tagName(name))); } fn resolveAtomicOrder( @@ -22439,8 +22439,8 @@ fn resolveAtomicOrder( src: LazySrcLoc, zir_ref: Zir.Inst.Ref, reason: ComptimeReason, -) CompileError!std.builtin.AtomicOrder { - return sema.resolveBuiltinEnum(block, src, zir_ref, .AtomicOrder, reason); +) CompileError!std.lang.AtomicOrder { + return sema.resolveStdLangEnum(block, src, zir_ref, .AtomicOrder, reason); } fn resolveAtomicRmwOp( @@ -22448,8 +22448,8 @@ fn resolveAtomicRmwOp( block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref, -) CompileError!std.builtin.AtomicRmwOp { - return sema.resolveBuiltinEnum(block, src, zir_ref, .AtomicRmwOp, .{ .simple = .operand_atomicRmw_operation }); +) CompileError!std.lang.AtomicRmwOp { + return sema.resolveStdLangEnum(block, src, zir_ref, .AtomicRmwOp, .{ .simple = .operand_atomicRmw_operation }); } fn zirCmpxchg( @@ -22490,10 +22490,10 @@ fn zirCmpxchg( const success_order = try sema.resolveAtomicOrder(block, success_order_src, extra.success_order, .{ .simple = .atomic_order }); const failure_order = try sema.resolveAtomicOrder(block, failure_order_src, extra.failure_order, .{ .simple = .atomic_order }); - if (@intFromEnum(success_order) < @intFromEnum(std.builtin.AtomicOrder.monotonic)) { + if (@intFromEnum(success_order) < @intFromEnum(std.lang.AtomicOrder.monotonic)) { return sema.fail(block, success_order_src, "success atomic ordering must be monotonic or stricter", .{}); } - if (@intFromEnum(failure_order) < @intFromEnum(std.builtin.AtomicOrder.monotonic)) { + if (@intFromEnum(failure_order) < @intFromEnum(std.lang.AtomicOrder.monotonic)) { return sema.fail(block, failure_order_src, "failure atomic ordering must be monotonic or stricter", .{}); } if (@intFromEnum(failure_order) > @intFromEnum(success_order)) { @@ -22609,7 +22609,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const op_src = block.builtinCallArgSrc(inst_data.src_node, 0); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 1); - const operation = try sema.resolveBuiltinEnum(block, op_src, extra.lhs, .ReduceOp, .{ .simple = .operand_reduce_operation }); + const operation = try sema.resolveStdLangEnum(block, op_src, extra.lhs, .ReduceOp, .{ .simple = .operand_reduce_operation }); const operand = sema.resolveInst(extra.rhs); const operand_ty = sema.typeOf(operand); const pt = sema.pt; @@ -23196,11 +23196,11 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError const extra = sema.code.extraData(Zir.Inst.BuiltinCall, inst_data.payload_index).data; const func = sema.resolveInst(extra.callee); - const modifier_ty = try sema.getBuiltinType(call_src, .CallModifier); + const modifier_ty = try sema.getStdLangType(call_src, .CallModifier); const air_ref = sema.resolveInst(extra.modifier); const modifier_ref = try sema.coerce(block, modifier_ty, air_ref, modifier_src); const modifier_val = try sema.resolveConstDefinedValue(block, modifier_src, modifier_ref, .{ .simple = .call_modifier }); - var modifier = try sema.interpretBuiltinType(block, modifier_src, modifier_val, std.builtin.CallModifier); + var modifier = try sema.interpretStdLangType(block, modifier_src, modifier_val, std.lang.CallModifier); switch (modifier) { // These can be upgraded to comptime or nosuspend calls. .auto, .never_tail, .no_suspend => { @@ -24250,19 +24250,19 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A var extra_index: usize = extra.end; - const cc: std.builtin.CallingConvention = if (extra.data.bits.has_cc_body) blk: { + const cc: std.lang.CallingConvention = if (extra.data.bits.has_cc_body) blk: { const body_len = sema.code.extra[extra_index]; extra_index += 1; const body = sema.code.bodySlice(extra_index, body_len); extra_index += body.len; - const cc_ty = try sema.getBuiltinType(cc_src, .CallingConvention); + const cc_ty = try sema.getStdLangType(cc_src, .CallingConvention); const val = try sema.resolveGenericBody(block, cc_src, body, inst, cc_ty, .{ .simple = .@"callconv" }); break :blk try sema.analyzeValueAsCallconv(block, cc_src, val); } else if (extra.data.bits.has_cc_ref) blk: { const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); extra_index += 1; - const cc_ty = try sema.getBuiltinType(cc_src, .CallingConvention); + const cc_ty = try sema.getStdLangType(cc_src, .CallingConvention); const uncoerced_cc = sema.resolveInst(cc_ref); const coerced_cc = try sema.coerce(block, cc_ty, uncoerced_cc, cc_src); const cc_val = try sema.resolveConstDefinedValue(block, cc_src, coerced_cc, .{ .simple = .@"callconv" }); @@ -24275,10 +24275,10 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A if (zir_decl.linkage == .@"export") { break :cc target.cCallingConvention() orelse { // This target has no default C calling convention. We sometimes trigger a similar - // error by trying to evaluate `std.builtin.CallingConvention.c`, so for consistency, + // error by trying to evaluate `std.lang.CallingConvention.c`, so for consistency, // let's eval that now and just get the transitive error. (It's guaranteed to error // because it does the exact `cCallingConvention` call we just did.) - const cc_type = try sema.getBuiltinType(cc_src, .CallingConvention); + const cc_type = try sema.getStdLangType(cc_src, .CallingConvention); _ = try sema.namespaceLookupVal( block, LazySrcLoc.unneeded, @@ -24286,7 +24286,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A try ip.getOrPutString(gpa, io, pt.tid, "c", .no_embedded_nulls), ); // The above should have errored. - @panic("std.builtin is corrupt"); + @panic("std.lang is corrupt"); }; } } @@ -24398,7 +24398,7 @@ fn resolvePrefetchOptions( block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref, -) CompileError!std.builtin.PrefetchOptions { +) CompileError!std.lang.PrefetchOptions { const pt = sema.pt; const zcu = pt.zcu; const comp = zcu.comp; @@ -24406,7 +24406,7 @@ fn resolvePrefetchOptions( const io = comp.io; const ip = &zcu.intern_pool; - const options_ty = try sema.getBuiltinType(src, .PrefetchOptions); + const options_ty = try sema.getStdLangType(src, .PrefetchOptions); const options = try sema.coerce(block, options_ty, sema.resolveInst(zir_ref), src); const rw_src = block.src(.{ .init_field_rw = src.offset.node_offset_builtin_call_arg.builtin_call_node }); @@ -24422,10 +24422,10 @@ fn resolvePrefetchOptions( const cache = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "cache", .no_embedded_nulls), cache_src); const cache_val = try sema.resolveConstDefinedValue(block, cache_src, cache, .{ .simple = .prefetch_options }); - return std.builtin.PrefetchOptions{ - .rw = try sema.interpretBuiltinType(block, rw_src, rw_val, std.builtin.PrefetchOptions.Rw), + return std.lang.PrefetchOptions{ + .rw = try sema.interpretStdLangType(block, rw_src, rw_val, std.lang.PrefetchOptions.Rw), .locality = @intCast(locality_val.toUnsignedInt(zcu)), - .cache = try sema.interpretBuiltinType(block, cache_src, cache_val, std.builtin.PrefetchOptions.Cache), + .cache = try sema.interpretStdLangType(block, cache_src, cache_val, std.lang.PrefetchOptions.Cache), }; } @@ -24465,12 +24465,12 @@ fn resolveExternOptions( ) CompileError!struct { name: InternPool.NullTerminatedString, library_name: InternPool.OptionalNullTerminatedString, - linkage: std.builtin.GlobalLinkage, - visibility: std.builtin.SymbolVisibility, + linkage: std.lang.GlobalLinkage, + visibility: std.lang.SymbolVisibility, is_thread_local: bool, is_dll_import: bool, - relocation: std.builtin.ExternOptions.Relocation, - decoration: ?std.builtin.ExternOptions.Decoration, + relocation: std.lang.ExternOptions.Relocation, + decoration: ?std.lang.ExternOptions.Decoration, } { const pt = sema.pt; const zcu = pt.zcu; @@ -24480,7 +24480,7 @@ fn resolveExternOptions( const ip = &zcu.intern_pool; const options_inst = sema.resolveInst(zir_ref); - const extern_options_ty = try sema.getBuiltinType(src, .ExternOptions); + const extern_options_ty = try sema.getStdLangType(src, .ExternOptions); const options = try sema.coerce(block, extern_options_ty, options_inst, src); const name_src = block.src(.{ .init_field_name = src.offset.node_offset_builtin_call_arg.builtin_call_node }); @@ -24500,11 +24500,11 @@ fn resolveExternOptions( const linkage_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "linkage", .no_embedded_nulls), linkage_src); const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_ref, .{ .simple = .extern_options }); - const linkage = try sema.interpretBuiltinType(block, linkage_src, linkage_val, std.builtin.GlobalLinkage); + const linkage = try sema.interpretStdLangType(block, linkage_src, linkage_val, std.lang.GlobalLinkage); const visibility_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "visibility", .no_embedded_nulls), visibility_src); const visibility_val = try sema.resolveConstDefinedValue(block, visibility_src, visibility_ref, .{ .simple = .extern_options }); - const visibility = try sema.interpretBuiltinType(block, visibility_src, visibility_val, std.builtin.SymbolVisibility); + const visibility = try sema.interpretStdLangType(block, visibility_src, visibility_val, std.lang.SymbolVisibility); const is_thread_local = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "is_thread_local", .no_embedded_nulls), thread_local_src); const is_thread_local_val = try sema.resolveConstDefinedValue(block, thread_local_src, is_thread_local, .{ .simple = .extern_options }); @@ -24523,11 +24523,11 @@ fn resolveExternOptions( const relocation_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "relocation", .no_embedded_nulls), relocation_src); const relocation_val = try sema.resolveConstDefinedValue(block, relocation_src, relocation_ref, .{ .simple = .extern_options }); - const relocation = try sema.interpretBuiltinType(block, relocation_src, relocation_val, std.builtin.ExternOptions.Relocation); + const relocation = try sema.interpretStdLangType(block, relocation_src, relocation_val, std.lang.ExternOptions.Relocation); const decoration_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "decoration", .no_embedded_nulls), decoration_src); const decoration_val = try sema.resolveConstDefinedValue(block, decoration_src, decoration_ref, .{ .simple = .extern_options }); - const decoration = try sema.interpretBuiltinType(block, decoration_src, decoration_val, ?std.builtin.ExternOptions.Decoration); + const decoration = try sema.interpretStdLangType(block, decoration_src, decoration_val, ?std.lang.ExternOptions.Decoration); if (name.len == 0) { return sema.fail(block, name_src, "extern symbol name cannot be empty", .{}); @@ -24696,7 +24696,7 @@ fn zirInComptime( return if (block.isComptime()) .bool_true else .bool_false; } -fn zirBuiltinValue(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref { +fn zirStdLangValue(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; const comp = zcu.comp; @@ -24706,9 +24706,9 @@ fn zirBuiltinValue(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD const src_node: std.zig.Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); const src = block.nodeOffset(src_node); - const value: Zir.Inst.BuiltinValue = @enumFromInt(extended.small); + const value: Zir.Inst.StdLangValue = @enumFromInt(extended.small); - const builtin_type: Zcu.BuiltinDecl = switch (value) { + const std_lang_type: Zcu.StdLangDecl = switch (value) { // zig fmt: off .atomic_order => .AtomicOrder, .atomic_rmw_op => .AtomicRmwOp, @@ -24732,28 +24732,28 @@ fn zirBuiltinValue(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD // Values are handled here. .calling_convention_c => { - const callconv_ty = try sema.getBuiltinType(src, .CallingConvention); + const callconv_ty = try sema.getStdLangType(src, .CallingConvention); // Cannot use `Value.uninterpret` because `c` is a *declaration* whose value depends on the target. return try sema.namespaceLookupVal( block, src, callconv_ty.getNamespaceIndex(zcu), try ip.getOrPutString(gpa, io, pt.tid, "c", .no_embedded_nulls), - ) orelse @panic("std.builtin is corrupt"); + ) orelse @panic("std.lang is corrupt"); }, .calling_convention_inline => { - const callconv_ty = try sema.getBuiltinType(src, .CallingConvention); + const callconv_ty = try sema.getStdLangType(src, .CallingConvention); return .fromValue(Value.uninterpret( - @as(std.builtin.CallingConvention, .@"inline"), + @as(std.lang.CallingConvention, .@"inline"), callconv_ty, pt, ) catch |err| switch (err) { - error.TypeMismatch => @panic("std.builtin is corrupt"), + error.TypeMismatch => @panic("std.lang is corrupt"), error.OutOfMemory => |e| return e, }); }, }; - return .fromType(try sema.getBuiltinType(src, builtin_type)); + return .fromType(try sema.getStdLangType(src, std_lang_type)); } fn zirInplaceArithResultTy(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref { @@ -24788,14 +24788,14 @@ fn zirBranchHint(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat const uncoerced_hint = sema.resolveInst(extra.operand); const operand_src = block.builtinCallArgSrc(extra.node, 0); - const hint_ty = try sema.getBuiltinType(operand_src, .BranchHint); + const hint_ty = try sema.getStdLangType(operand_src, .BranchHint); const coerced_hint = try sema.coerce(block, hint_ty, uncoerced_hint, operand_src); const hint_val = try sema.resolveConstDefinedValue(block, operand_src, coerced_hint, .{ .simple = .operand_branchHint }); // We only apply the first hint in a branch. // This allows user-provided hints to override implicit cold hints. if (sema.branch_hint == null) { - sema.branch_hint = try sema.interpretBuiltinType(block, operand_src, hint_val, std.builtin.BranchHint); + sema.branch_hint = try sema.interpretStdLangType(block, operand_src, hint_val, std.lang.BranchHint); } } @@ -25148,7 +25148,7 @@ fn getPanicIdFunc(sema: *Sema, src: LazySrcLoc, panic_id: Zcu.SimplePanicId) !In const zcu = sema.pt.zcu; const io = zcu.comp.io; try sema.ensureMemoizedStateResolved(src, .panic); - const panic_fn_index = zcu.builtin_decl_values.get(panic_id.toBuiltin()); + const panic_fn_index = zcu.std_lang_decl_values.get(panic_id.toStdLangDecl()); switch (sema.owner.unwrap()) { .@"comptime", .nav_ty, @@ -25292,7 +25292,7 @@ fn safetyPanicUnwrapError(sema: *Sema, block: *Block, src: LazySrcLoc, err: Air. if (!zcu.backendSupportsFeature(.panic_fn)) { _ = try block.addNoOp(.trap); } else { - const panic_fn = try getBuiltin(sema, src, .@"panic.unwrapError"); + const panic_fn = try getStdLangValue(sema, src, .@"panic.unwrapError"); try sema.callBuiltin(block, src, Air.internedToRef(panic_fn), .auto, &.{err}, .@"safety check"); } } @@ -25382,7 +25382,7 @@ fn addSafetyCheckCall( parent_block: *Block, src: LazySrcLoc, ok: Air.Inst.Ref, - comptime func_decl: Zcu.BuiltinDecl, + comptime func_decl: Zcu.StdLangDecl, args: []const Air.Inst.Ref, ) !void { assert(!parent_block.isComptime()); @@ -25406,7 +25406,7 @@ fn addSafetyCheckCall( if (!zcu.backendSupportsFeature(.panic_fn)) { _ = try fail_block.addNoOp(.trap); } else { - const panic_fn = try getBuiltin(sema, src, func_decl); + const panic_fn = try getStdLangValue(sema, src, func_decl); try sema.callBuiltin(&fail_block, src, Air.internedToRef(panic_fn), .auto, args, .@"safety check"); } @@ -27911,8 +27911,8 @@ const InMemoryCoercionResult = union(enum) { }; const Int = struct { - actual_signedness: std.builtin.Signedness, - wanted_signedness: std.builtin.Signedness, + actual_signedness: std.lang.Signedness, + wanted_signedness: std.lang.Signedness, actual_bits: u16, wanted_bits: u16, }; @@ -27928,18 +27928,18 @@ const InMemoryCoercionResult = union(enum) { }; const Size = struct { - actual: std.builtin.Type.Pointer.Size, - wanted: std.builtin.Type.Pointer.Size, + actual: std.lang.Type.Pointer.Size, + wanted: std.lang.Type.Pointer.Size, }; const AddressSpace = struct { - actual: std.builtin.AddressSpace, - wanted: std.builtin.AddressSpace, + actual: std.lang.AddressSpace, + wanted: std.lang.AddressSpace, }; const CC = struct { - actual: std.builtin.CallingConvention, - wanted: std.builtin.CallingConvention, + actual: std.lang.CallingConvention, + wanted: std.lang.CallingConvention, }; const BitRange = struct { @@ -28209,7 +28209,7 @@ const InMemoryCoercionResult = union(enum) { } }; -fn pointerSizeString(size: std.builtin.Type.Pointer.Size) []const u8 { +fn pointerSizeString(size: std.lang.Type.Pointer.Size) []const u8 { return switch (size) { .one => "single pointer", .many => "many pointer", @@ -28635,10 +28635,10 @@ fn coerceInMemoryAllowedFns( fn callconvCoerceAllowed( target: *const std.Target, - src_cc: std.builtin.CallingConvention, - dest_cc: std.builtin.CallingConvention, + src_cc: std.lang.CallingConvention, + dest_cc: std.lang.CallingConvention, ) bool { - const Tag = std.builtin.CallingConvention.Tag; + const Tag = std.lang.CallingConvention.Tag; if (@as(Tag, src_cc) != @as(Tag, dest_cc)) return false; switch (src_cc) { @@ -28651,26 +28651,26 @@ fn callconvCoerceAllowed( if (dest_stack_align < src_stack_align) return false; } switch (@TypeOf(src_data)) { - void, std.builtin.CallingConvention.CommonOptions => {}, - std.builtin.CallingConvention.X86RegparmOptions => { + void, std.lang.CallingConvention.CommonOptions => {}, + std.lang.CallingConvention.X86RegparmOptions => { if (src_data.register_params != dest_data.register_params) return false; }, - std.builtin.CallingConvention.ArcInterruptOptions => { + std.lang.CallingConvention.ArcInterruptOptions => { if (src_data.type != dest_data.type) return false; }, - std.builtin.CallingConvention.ArmInterruptOptions => { + std.lang.CallingConvention.ArmInterruptOptions => { if (src_data.type != dest_data.type) return false; }, - std.builtin.CallingConvention.MicroblazeInterruptOptions => { + std.lang.CallingConvention.MicroblazeInterruptOptions => { if (src_data.type != dest_data.type) return false; }, - std.builtin.CallingConvention.MipsInterruptOptions => { + std.lang.CallingConvention.MipsInterruptOptions => { if (src_data.mode != dest_data.mode) return false; }, - std.builtin.CallingConvention.RiscvInterruptOptions => { + std.lang.CallingConvention.RiscvInterruptOptions => { if (src_data.mode != dest_data.mode) return false; }, - std.builtin.CallingConvention.ShInterruptOptions => { + std.lang.CallingConvention.ShInterruptOptions => { if (src_data.save != dest_data.save) return false; }, else => comptime unreachable, @@ -31115,7 +31115,7 @@ fn cmpNumeric( const dest_ty = if (dest_float_type) |ft| ft else blk: { const max_bits = @max(lhs_bits, rhs_bits); const casted_bits = std.math.cast(u16, max_bits) orelse return sema.fail(block, src, "{d} exceeds maximum integer bit count", .{max_bits}); - const signedness: std.builtin.Signedness = if (dest_int_is_signed) .signed else .unsigned; + const signedness: std.lang.Signedness = if (dest_int_is_signed) .signed else .unsigned; break :blk try pt.intType(signedness, casted_bits); }; const casted_lhs = try sema.coerce(block, dest_ty, lhs, lhs_src); @@ -33101,7 +33101,7 @@ fn resolveAddressSpace( src: LazySrcLoc, zir_ref: Zir.Inst.Ref, ctx: std.Target.AddressSpaceContext, -) !std.builtin.AddressSpace { +) !std.lang.AddressSpace { const air_ref = sema.resolveInst(zir_ref); return sema.analyzeAsAddressSpace(block, src, air_ref, ctx); } @@ -33112,12 +33112,12 @@ pub fn analyzeAsAddressSpace( src: LazySrcLoc, air_ref: Air.Inst.Ref, ctx: std.Target.AddressSpaceContext, -) !std.builtin.AddressSpace { +) !std.lang.AddressSpace { const pt = sema.pt; - const addrspace_ty = try sema.getBuiltinType(src, .AddressSpace); + const addrspace_ty = try sema.getStdLangType(src, .AddressSpace); const coerced = try sema.coerce(block, addrspace_ty, air_ref, src); const addrspace_val = try sema.resolveConstDefinedValue(block, src, coerced, .{ .simple = .@"addrspace" }); - const address_space = try sema.interpretBuiltinType(block, src, addrspace_val, std.builtin.AddressSpace); + const address_space = try sema.interpretStdLangType(block, src, addrspace_val, std.lang.AddressSpace); const target = pt.zcu.getTarget(); if (!target.supportsAddressSpace(address_space, ctx)) { @@ -33819,21 +33819,21 @@ pub const type_resolution = @import("Sema/type_resolution.zig"); pub const ensureLayoutResolved = type_resolution.ensureLayoutResolved; pub const ensureStructDefaultsResolved = type_resolution.ensureStructDefaultsResolved; -pub fn getBuiltinType(sema: *Sema, src: LazySrcLoc, decl: Zcu.BuiltinDecl) SemaError!Type { +pub fn getStdLangType(sema: *Sema, src: LazySrcLoc, decl: Zcu.StdLangDecl) SemaError!Type { assert(decl.kind() == .type); try sema.ensureMemoizedStateResolved(src, decl.stage()); - return .fromInterned(sema.pt.zcu.builtin_decl_values.get(decl)); + return .fromInterned(sema.pt.zcu.std_lang_decl_values.get(decl)); } -pub fn getBuiltin(sema: *Sema, src: LazySrcLoc, decl: Zcu.BuiltinDecl) SemaError!InternPool.Index { +pub fn getStdLangValue(sema: *Sema, src: LazySrcLoc, decl: Zcu.StdLangDecl) SemaError!InternPool.Index { assert(decl.kind() != .type); try sema.ensureMemoizedStateResolved(src, decl.stage()); - return sema.pt.zcu.builtin_decl_values.get(decl); + return sema.pt.zcu.std_lang_decl_values.get(decl); } pub const NavPtrModifiers = struct { @"align": Alignment, @"linksection": InternPool.OptionalNullTerminatedString, - @"addrspace": std.builtin.AddressSpace, + @"addrspace": std.lang.AddressSpace, }; pub fn resolveNavPtrModifiers( @@ -33872,7 +33872,7 @@ pub fn resolveNavPtrModifiers( break :ls try ip.getOrPutStringOpt(gpa, io, pt.tid, bytes, .no_embedded_nulls); }; - const @"addrspace": std.builtin.AddressSpace = as: { + const @"addrspace": std.lang.AddressSpace = as: { const addrspace_ctx: std.Target.AddressSpaceContext = switch (zir_decl.kind) { .@"var" => .variable, else => switch (nav_ty.zigTypeTag(zcu)) { @@ -33928,30 +33928,30 @@ pub fn analyzeMemoizedState(sema: *Sema, stage: InternPool.MemoizedStateStage) C }; defer block.instructions.deinit(gpa); - const std_builtin_ty: Type = ty: { + const std_lang_ty: Type = ty: { const std_src = block.nodeOffset(.zero); - const decl_name = try ip.getOrPutString(gpa, io, pt.tid, "builtin", .no_embedded_nulls); + const decl_name = try ip.getOrPutString(gpa, io, pt.tid, "lang", .no_embedded_nulls); const nav = try sema.namespaceLookup(&block, std_src, block.namespace, decl_name) orelse { - return sema.fail(&block, std_src, "'std' missing 'builtin'", .{}); + return sema.fail(&block, std_src, "'std' missing 'lang'", .{}); }; const uncoerced_val = try sema.analyzeNavVal(&block, std_src, nav); const decl_src: LazySrcLoc = .{ .base_node_inst = ip.getNav(nav).srcInst(ip), .offset = .nodeOffset(.zero), }; - break :ty try sema.analyzeAsType(&block, decl_src, .std_builtin_decl, uncoerced_val); + break :ty try sema.analyzeAsType(&block, decl_src, .std_lang_decl, uncoerced_val); }; var any_changed = false; - inline for (comptime std.enums.values(Zcu.BuiltinDecl)) |builtin_decl| { - if (stage == comptime builtin_decl.stage()) { - const parent_ns_ty: Type, const parent_name: []const u8, const name: []const u8 = switch (comptime builtin_decl.access()) { - .direct => |name| .{ std_builtin_ty, "std.builtin", name }, + inline for (comptime std.enums.values(Zcu.StdLangDecl)) |std_lang_decl| { + if (stage == comptime std_lang_decl.stage()) { + const parent_ns_ty: Type, const parent_name: []const u8, const name: []const u8 = switch (comptime std_lang_decl.access()) { + .direct => |name| .{ std_lang_ty, "std.lang", name }, .nested => |nested| access: { const parent_decl, const name = nested; - const parent_ty: Type = .fromInterned(zcu.builtin_decl_values.get(parent_decl)); - break :access .{ parent_ty, "std.builtin." ++ @tagName(parent_decl), name }; + const parent_ty: Type = .fromInterned(zcu.std_lang_decl_values.get(parent_decl)); + break :access .{ parent_ty, "std.lang." ++ @tagName(parent_decl), name }; }, }; @@ -33970,25 +33970,25 @@ pub fn analyzeMemoizedState(sema: *Sema, stage: InternPool.MemoizedStateStage) C .offset = .nodeOffset(.zero), }; - const val: Value = switch (builtin_decl.kind()) { + const val: Value = switch (std_lang_decl.kind()) { .type => val: { - const ty = try sema.analyzeAsType(&block, decl_src, .std_builtin_decl, uncoerced_val); - try sema.ensureLayoutResolved(ty, decl_src, .builtin_type); + const ty = try sema.analyzeAsType(&block, decl_src, .std_lang_decl, uncoerced_val); + try sema.ensureLayoutResolved(ty, decl_src, .std_lang_type); break :val ty.toValue(); }, .func => val: { - const func_ty = try sema.getExpectedBuiltinFnType(builtin_decl); + const func_ty = try sema.getExpectedBuiltinFnType(std_lang_decl); const coerced = try sema.coerce(&block, func_ty, uncoerced_val, decl_src); - break :val try sema.resolveConstDefinedValue(&block, decl_src, coerced, .{ .simple = .std_builtin_decl }); + break :val try sema.resolveConstDefinedValue(&block, decl_src, coerced, .{ .simple = .std_lang_decl }); }, .string => val: { const coerced = try sema.coerce(&block, .slice_const_u8, uncoerced_val, decl_src); - break :val try sema.resolveConstDefinedValue(&block, decl_src, coerced, .{ .simple = .std_builtin_decl }); + break :val try sema.resolveConstDefinedValue(&block, decl_src, coerced, .{ .simple = .std_lang_decl }); }, }; - if (zcu.builtin_decl_values.get(builtin_decl) != val.toIntern()) { - zcu.builtin_decl_values.set(builtin_decl, val.toIntern()); + if (zcu.std_lang_decl_values.get(std_lang_decl) != val.toIntern()) { + zcu.std_lang_decl_values.set(std_lang_decl, val.toIntern()); any_changed = true; } } @@ -33998,7 +33998,7 @@ pub fn analyzeMemoizedState(sema: *Sema, stage: InternPool.MemoizedStateStage) C } /// Given that `decl.kind() == .func`, get the type expected of the function. -fn getExpectedBuiltinFnType(sema: *Sema, decl: Zcu.BuiltinDecl) CompileError!Type { +fn getExpectedBuiltinFnType(sema: *Sema, decl: Zcu.StdLangDecl) CompileError!Type { const pt = sema.pt; return switch (decl) { // `noinline fn () void` diff --git a/src/Sema/arith.zig b/src/Sema/arith.zig @@ -1191,7 +1191,7 @@ pub fn truncate( val: Value, ty: Type, dest_ty: Type, - dest_signedness: std.builtin.Signedness, + dest_signedness: std.lang.Signedness, dest_bits: u16, ) CompileError!Value { const pt = sema.pt; @@ -1808,7 +1808,7 @@ fn intTruncate( sema: *Sema, val: Value, dest_ty: Type, - dest_signedness: std.builtin.Signedness, + dest_signedness: std.lang.Signedness, dest_bits: u16, ) !Value { const pt = sema.pt; diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig @@ -35,7 +35,7 @@ pub const LayoutResolveReason = enum { @"export", @"extern", asm_out_type, - builtin_type, + std_lang_type, /// Written after string: "while resolving type 'T' " /// e.g. "while resolving type 'MyStruct' for variable declared here" @@ -62,7 +62,7 @@ pub const LayoutResolveReason = enum { .@"export" => "for export here", .@"extern" => "for extern declaration here", .asm_out_type => "for inline assembly output type declared here", - .builtin_type => "from 'std.builtin'", + .std_lang_type => "from 'std.lang'", // zig fmt: on }; } diff --git a/src/Type.zig b/src/Type.zig @@ -19,7 +19,7 @@ const Type = @This(); ip_index: InternPool.Index, -pub fn zigTypeTag(ty: Type, zcu: *const Zcu) std.builtin.TypeId { +pub fn zigTypeTag(ty: Type, zcu: *const Zcu) std.lang.TypeId { return zcu.intern_pool.zigTypeTag(ty.toIntern()); } @@ -903,7 +903,7 @@ pub fn ptrAlignment(ptr_ty: Type, zcu: *Zcu) Alignment { return Type.fromInterned(ptr_key.child).abiAlignment(zcu); } -pub fn ptrAddressSpace(ty: Type, zcu: *const Zcu) std.builtin.AddressSpace { +pub fn ptrAddressSpace(ty: Type, zcu: *const Zcu) std.lang.AddressSpace { return switch (zcu.intern_pool.indexToKey(ty.toIntern())) { .ptr_type => |ptr_type| ptr_type.flags.address_space, .opt_type => |child| zcu.intern_pool.indexToKey(child).ptr_type.flags.address_space, @@ -1337,12 +1337,12 @@ pub fn isSinglePointer(ty: Type, zcu: *const Zcu) bool { } /// Asserts `ty` is a pointer. -pub fn ptrSize(ty: Type, zcu: *const Zcu) std.builtin.Type.Pointer.Size { +pub fn ptrSize(ty: Type, zcu: *const Zcu) std.lang.Type.Pointer.Size { return ty.ptrSizeOrNull(zcu).?; } /// Returns `null` if `ty` is not a pointer. -pub fn ptrSizeOrNull(ty: Type, zcu: *const Zcu) ?std.builtin.Type.Pointer.Size { +pub fn ptrSizeOrNull(ty: Type, zcu: *const Zcu) ?std.lang.Type.Pointer.Size { return switch (zcu.intern_pool.indexToKey(ty.toIntern())) { .ptr_type => |ptr_info| ptr_info.flags.size, else => null, @@ -1627,7 +1627,7 @@ pub fn unionGetLayout(ty: Type, zcu: *const Zcu) Zcu.UnionLayout { return Type.getUnionLayout(union_obj, zcu); } -pub fn containerLayout(ty: Type, zcu: *const Zcu) std.builtin.Type.ContainerLayout { +pub fn containerLayout(ty: Type, zcu: *const Zcu) std.lang.Type.ContainerLayout { const ip = &zcu.intern_pool; return switch (ip.indexToKey(ty.toIntern())) { .tuple_type => .auto, @@ -1949,7 +1949,7 @@ pub fn fnReturnType(ty: Type, zcu: *const Zcu) Type { } /// Asserts the type is a function. -pub fn fnCallingConvention(ty: Type, zcu: *const Zcu) std.builtin.CallingConvention { +pub fn fnCallingConvention(ty: Type, zcu: *const Zcu) std.lang.CallingConvention { return zcu.intern_pool.indexToKey(ty.toIntern()).func_type.cc; } @@ -2477,7 +2477,7 @@ pub fn explicitFieldAlignment(ty: Type, index: usize, zcu: *const Zcu) Alignment /// Asserts that the layout of `field_ty` is resolved. Asserts that `layout` is not `.@"packed"`. pub fn defaultStructFieldAlignment( field_ty: Type, - layout: std.builtin.Type.ContainerLayout, + layout: std.lang.Type.ContainerLayout, zcu: *const Zcu, ) Alignment { const overalign_big_int = switch (layout) { @@ -3227,7 +3227,7 @@ pub fn validateExtern(ty: Type, position: ExternPosition, zcu: *const Zcu) bool .optional => ty.isPtrLikeOptional(zcu), }; } -fn validateExternCallconv(cc: std.builtin.CallingConvention) bool { +fn validateExternCallconv(cc: std.lang.CallingConvention) bool { return switch (cc) { // For now we want to authorize PTX kernel to use zig objects, even if we end up exposing the ABI. // The goal is to experiment with more integrated CPU/GPU code. diff --git a/src/Value.zig b/src/Value.zig @@ -1845,7 +1845,7 @@ pub fn ptrElem(orig_parent_ptr: Value, field_idx: u64, pt: Zcu.PerThread) !Value } })); } -fn canonicalizeBasePtr(base_ptr: Value, want_size: std.builtin.Type.Pointer.Size, want_child: Type, pt: Zcu.PerThread) !Value { +fn canonicalizeBasePtr(base_ptr: Value, want_size: std.lang.Type.Pointer.Size, want_child: Type, pt: Zcu.PerThread) !Value { const ptr_ty = base_ptr.typeOf(pt.zcu); const ptr_info = ptr_ty.ptrInfo(pt.zcu); @@ -2199,19 +2199,19 @@ pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, op const InterpretMode = enum { /// In this mode, types are assumed to match what the compiler was built with in terms of field /// order, field types, etc. This improves compiler performance. However, it means that certain - /// modifications to `std.builtin` will result in compiler crashes. + /// modifications to `std.lang` will result in compiler crashes. direct, /// In this mode, various details of the type are allowed to differ from what the compiler was built /// with. Fields are matched by name rather than index; added struct fields are ignored, and removed /// struct fields use their default value if one exists. This is slower than `.direct`, but permits - /// making certain changes to `std.builtin` (in particular reordering/adding/removing fields), so it - /// is useful when applying breaking changes. + /// making certain changes to `std.lang` (in particular reordering/adding/removing fields), so it is + /// useful when applying breaking changes. by_name, }; const interpret_mode: InterpretMode = @field(InterpretMode, @tagName(build_options.value_interpret_mode)); /// Given a `Value` representing a comptime-known value of type `T`, unwrap it into an actual `T` known to the compiler. -/// This is useful for accessing `std.builtin` structures received from comptime logic. +/// This is useful for accessing `std.lang` structures received from comptime logic. pub fn interpret(val: Value, comptime T: type, pt: Zcu.PerThread) error{ OutOfMemory, UndefinedValue, TypeMismatch }!T { const zcu = pt.zcu; const io = zcu.comp.io; @@ -2313,7 +2313,7 @@ pub fn interpret(val: Value, comptime T: type, pt: Zcu.PerThread) error{ OutOfMe } /// Given any `val` and a `Type` corresponding `@TypeOf(val)`, construct a `Value` representing it which can be used -/// within the compilation. This is useful for passing `std.builtin` structures in the compiler back to the compilation. +/// within the compilation. This is useful for passing `std.lang` structures in the compiler back to the compilation. /// This is the inverse of `interpret`. pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory, TypeMismatch }!Value { const T = @TypeOf(val); diff --git a/src/Zcu.zig b/src/Zcu.zig @@ -333,7 +333,7 @@ all_type_references: std.ArrayList(TypeReference) = .empty, free_type_references: std.ArrayList(u32) = .empty, /// Populated by analysis of `AnalUnit.wrap(.{ .memoized_state = s })`, where `s` depends on the element. -builtin_decl_values: BuiltinDecl.Memoized = .initFill(.none), +std_lang_decl_values: StdLangDecl.Memoized = .initFill(.none), incremental_debug_state: if (build_options.enable_debug_extensions) IncrementalDebugState else void = if (build_options.enable_debug_extensions) .init else {}, @@ -425,11 +425,11 @@ pub const EmbedTableAdapter = struct { } }; -/// Names of declarations in `std.builtin` whose values are memoized in a `BuiltinDecl.Memoized`. +/// Names of declarations in `std.lang` whose values are memoized in a `StdLangDecl.Memoized`. /// The name must exactly match the declaration name, as comptime logic is used to compute the namespace accesses. /// Parent namespaces must be before their children in this enum. For instance, `.Type` must be before `.@"Type.Fn"`. -/// Additionally, parent namespaces must be resolved in the same stage as their children; see `BuiltinDecl.stage`. -pub const BuiltinDecl = enum { +/// Additionally, parent namespaces must be resolved in the same stage as their children; see `StdLangDecl.stage`. +pub const StdLangDecl = enum { Signedness, AddressSpace, CallingConvention, @@ -508,7 +508,7 @@ pub const BuiltinDecl = enum { @"assembly.Clobbers", /// Determines what kind of validation will be done to the decl's value. - pub fn kind(decl: BuiltinDecl) enum { type, func, string } { + pub fn kind(decl: StdLangDecl) enum { type, func, string } { return switch (decl) { .returnError => .func, @@ -593,7 +593,7 @@ pub const BuiltinDecl = enum { } /// Resolution of these values is done in three distinct stages: - /// * Resolution of `std.builtin.Panic` and everything under it + /// * Resolution of `std.lang.Panic` and everything under it /// * Resolution of `VaList` /// * Resolution of `assembly` /// * Everything else @@ -606,12 +606,12 @@ pub const BuiltinDecl = enum { /// by itself. /// /// `assembly` is separate because its value depends on the target. - pub fn stage(decl: BuiltinDecl) InternPool.MemoizedStateStage { + pub fn stage(decl: StdLangDecl) InternPool.MemoizedStateStage { return switch (decl) { .VaList => .va_list, .assembly, .@"assembly.Clobbers" => .assembly, else => { - if (@intFromEnum(decl) <= @intFromEnum(BuiltinDecl.@"Type.Declaration")) { + if (@intFromEnum(decl) <= @intFromEnum(StdLangDecl.@"Type.Declaration")) { return .main; } else { return .panic; @@ -621,24 +621,24 @@ pub const BuiltinDecl = enum { } /// Based on the tag name, determines how to access this decl; either as a direct child of the - /// `std.builtin` namespace, or as a child of some preceding `BuiltinDecl` value. - pub fn access(decl: BuiltinDecl) union(enum) { + /// `std.lang` namespace, or as a child of some preceding `StdLangDecl` value. + pub fn access(decl: StdLangDecl) union(enum) { direct: []const u8, - nested: struct { BuiltinDecl, []const u8 }, + nested: struct { StdLangDecl, []const u8 }, } { @setEvalBranchQuota(2000); return switch (decl) { inline else => |tag| { const name = @tagName(tag); const split = (comptime std.mem.lastIndexOfScalar(u8, name, '.')) orelse return .{ .direct = name }; - const parent = @field(BuiltinDecl, name[0..split]); + const parent = @field(StdLangDecl, name[0..split]); comptime assert(@intFromEnum(parent) < @intFromEnum(tag)); // dependencies ordered correctly return .{ .nested = .{ parent, name[split + 1 ..] } }; }, }; } - const Memoized = std.enums.EnumArray(BuiltinDecl, InternPool.Index); + const Memoized = std.enums.EnumArray(StdLangDecl, InternPool.Index); }; pub const SimplePanicId = enum { @@ -662,7 +662,7 @@ pub const SimplePanicId = enum { memcpy_alias, noreturn_returned, - pub fn toBuiltin(id: SimplePanicId) BuiltinDecl { + pub fn toStdLangDecl(id: SimplePanicId) StdLangDecl { return switch (id) { // zig fmt: off .reached_unreachable => .@"panic.reachedUnreachable", @@ -744,9 +744,9 @@ pub const Export = struct { pub const Options = struct { name: InternPool.NullTerminatedString, - linkage: std.builtin.GlobalLinkage = .strong, + linkage: std.lang.GlobalLinkage = .strong, section: InternPool.OptionalNullTerminatedString = .none, - visibility: std.builtin.SymbolVisibility = .default, + visibility: std.lang.SymbolVisibility = .default, }; /// Index into `all_exports`. @@ -3941,7 +3941,7 @@ pub fn addGlobalAssembly(zcu: *Zcu, unit: AnalUnit, source: []const u8) !void { pub const Feature = enum { /// When this feature is enabled, Sema will emit calls to - /// `std.builtin.panic` functions for things like safety checks and + /// `std.lang.panic` functions for things like safety checks and /// unreachables. Otherwise traps will be emitted. panic_fn, /// When this feature is enabled, Sema will insert tracer functions for gathering a stack @@ -4524,10 +4524,10 @@ fn formatDependee(data: FormatDependee, writer: *Io.Writer) Io.Writer.Error!void } } -pub fn callconvSupported(zcu: *Zcu, cc: std.builtin.CallingConvention) union(enum) { +pub fn callconvSupported(zcu: *Zcu, cc: std.lang.CallingConvention) union(enum) { ok, bad_arch: []const std.Target.Cpu.Arch, // value is allowed archs for cc - bad_backend: std.builtin.CompilerBackend, // value is current backend + bad_backend: std.lang.CompilerBackend, // value is current backend } { const target = zcu.getTarget(); const backend = target_util.zigBackend(target, zcu.comp.config.use_llvm); @@ -4995,7 +4995,7 @@ fn addDependencyLoopErrorLine( }), .memoized_state => |stage| switch (stage) { .panic => try eb.printString("{f} requires panic handler for call here", .{fmt_source}), - else => try eb.printString("{f} requires 'std.builtin' declarations here", .{fmt_source}), + else => try eb.printString("{f} requires 'std.lang' declarations here", .{fmt_source}), }, .func => |func| try eb.printString("{f} uses inferred error set of function '{f}' here", .{ fmt_source, ip.getNav(zcu.funcInfo(func).owner_nav).fqn.fmt(ip), @@ -5046,7 +5046,7 @@ fn formatDependencyLoopSourceUnit(data: FormatAnalUnit, w: *Io.Writer) Io.Writer .nav_ty => |nav| try w.print("type of declaration '{f}'", .{ip.getNav(nav).fqn.fmt(ip)}), .memoized_state => |stage| switch (stage) { .panic => try w.writeAll("panic handler"), - else => try w.writeAll("'std.builtin' declarations"), + else => try w.writeAll("'std.lang' declarations"), }, .type_layout => |ty| try w.print("type '{f}'", .{ Type.fromInterned(ty).containerTypeName(ip).fmt(ip), diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig @@ -1083,13 +1083,13 @@ pub fn ensureMemoizedStateUpToDate( } else { if (prev_failed) return error.AnalysisFail; // We use an arbitrary element to check if the state has been resolved yet. - const to_check: Zcu.BuiltinDecl = switch (stage) { + const to_check: Zcu.StdLangDecl = switch (stage) { .main => .Type, .panic => .panic, .va_list => .VaList, .assembly => .assembly, }; - if (zcu.builtin_decl_values.get(to_check) != .none) return; + if (zcu.std_lang_decl_values.get(to_check) != .none) return; } if (zcu.comp.debugIncremental()) { @@ -3751,7 +3751,7 @@ pub fn populateTestFunctions(pt: Zcu.PerThread) Allocator.Error!void { // Our job is to correctly set the value of the `test_functions` declaration if it has been // analyzed and sent to codegen, It usually will have been, because the test runner will - // reference it, and `std.builtin` shouldn't have type errors. However, if it hasn't been + // reference it, and `std.lang` shouldn't have type errors. However, if it hasn't been // analyzed, we will just terminate early, since clearly the test runner hasn't referenced // `test_functions` so there's no point populating it. More to the the point, we potentially // *can't* populate it without doing some type resolution, and... let's try to leave Sema in @@ -3965,7 +3965,7 @@ pub fn getCoerced(pt: Zcu.PerThread, val: Value, new_ty: Type) Allocator.Error!V return .fromInterned(try ip.getCoerced(gpa, io, pt.tid, val.toIntern(), new_ty.toIntern())); } -pub fn intType(pt: Zcu.PerThread, signedness: std.builtin.Signedness, bits: u16) Allocator.Error!Type { +pub fn intType(pt: Zcu.PerThread, signedness: std.lang.Signedness, bits: u16) Allocator.Error!Type { return Type.fromInterned(try pt.intern(.{ .int_type = .{ .signedness = signedness, .bits = bits, diff --git a/src/codegen.zig b/src/codegen.zig @@ -29,7 +29,7 @@ pub const CodeGenError = GenerateSymbolError || error{ CodegenFail, }; -fn devFeatureForBackend(backend: std.builtin.CompilerBackend) dev.Feature { +fn devFeatureForBackend(backend: std.lang.CompilerBackend) dev.Feature { return switch (backend) { .other, .stage1 => unreachable, .stage2_aarch64 => .aarch64_backend, @@ -47,7 +47,7 @@ fn devFeatureForBackend(backend: std.builtin.CompilerBackend) dev.Feature { }; } -fn importBackend(comptime backend: std.builtin.CompilerBackend) type { +fn importBackend(comptime backend: std.lang.CompilerBackend) type { return switch (backend) { .other, .stage1 => unreachable, .stage2_aarch64 => aarch64, @@ -105,7 +105,7 @@ pub const AnyMir = union { wasm: if (dev.env.supports(.wasm_backend)) @import("codegen/wasm/Mir.zig") else noreturn, c: if (dev.env.supports(.c_backend)) @import("codegen/c.zig").Mir else noreturn, - pub inline fn tag(comptime backend: std.builtin.CompilerBackend) []const u8 { + pub inline fn tag(comptime backend: std.lang.CompilerBackend) []const u8 { return switch (backend) { .stage2_aarch64 => "aarch64", .stage2_riscv64 => "riscv64", diff --git a/src/codegen/aarch64/Assemble.zig b/src/codegen/aarch64/Assemble.zig @@ -307,7 +307,7 @@ const SymbolSpec = union(enum) { }, systemreg, imm: struct { - type: std.builtin.Type.Int, + type: std.lang.Type.Int, multiple_of: ?comptime_int = null, min_valid: ?comptime_int = null, max_valid: ?comptime_int = null, diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig @@ -2887,7 +2887,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory, const bin_op = air.data(air.inst_index).bin_op; const ty = isel.air.typeOf(bin_op.lhs, ip); - const int_info: std.builtin.Type.Int = if (ty.toIntern() == .bool_type) + const int_info: std.lang.Type.Int = if (ty.toIntern() == .bool_type) .{ .signedness = .unsigned, .bits = 1 } else if (ty.isAbiInt(zcu)) ty.intInfo(zcu) @@ -3144,7 +3144,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory, const ty_op = air.data(air.inst_index).ty_op; const ty = ty_op.ty.toType(); - const int_info: std.builtin.Type.Int = int_info: { + const int_info: std.lang.Type.Int = int_info: { if (ty_op.ty == .bool_type) break :int_info .{ .signedness = .unsigned, .bits = 1 }; if (!ty.isAbiInt(zcu)) return isel.fail("bad {t} {f}", .{ air_tag, isel.fmtType(ty) }); break :int_info ty.intInfo(zcu); @@ -3199,7 +3199,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory, const src_tag = src_ty.zigTypeTag(zcu); if (dst_ty.isAbiInt(zcu) and (src_tag == .bool or src_ty.isAbiInt(zcu))) { const dst_int_info = dst_ty.intInfo(zcu); - const src_int_info: std.builtin.Type.Int = if (src_tag == .bool) .{ .signedness = undefined, .bits = 1 } else src_ty.intInfo(zcu); + const src_int_info: std.lang.Type.Int = if (src_tag == .bool) .{ .signedness = undefined, .bits = 1 } else src_ty.intInfo(zcu); assert(dst_int_info.bits == src_int_info.bits); if (dst_tag != .@"struct" and src_tag != .@"struct" and src_tag != .bool and dst_int_info.signedness == src_int_info.signedness) { try dst_vi.value.move(isel, ty_op.operand); @@ -4517,7 +4517,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory, .switch_br => { const switch_br = isel.air.unwrapSwitch(air.inst_index); const cond_ty = isel.air.typeOf(switch_br.operand, ip); - const cond_int_info: std.builtin.Type.Int = if (cond_ty.toIntern() == .bool_type) + const cond_int_info: std.lang.Type.Int = if (cond_ty.toIntern() == .bool_type) .{ .signedness = .unsigned, .bits = 1 } else if (cond_ty.isAbiInt(zcu)) cond_ty.intInfo(zcu) @@ -7981,7 +7981,7 @@ fn emit(isel: *Select, instruction: codegen.aarch64.encoding.Instruction) !void fn emitPanic(isel: *Select, panic_id: Zcu.SimplePanicId) !void { const zcu = isel.pt.zcu; try isel.nav_relocs.append(zcu.gpa, .{ - .nav = switch (zcu.intern_pool.indexToKey(zcu.builtin_decl_values.get(panic_id.toBuiltin()))) { + .nav = switch (zcu.intern_pool.indexToKey(zcu.std_lang_decl_values.get(panic_id.toStdLangDecl()))) { else => unreachable, inline .@"extern", .func => |func| func.owner_nav, }, @@ -8229,7 +8229,7 @@ fn elemPtr( fn clzLimb( isel: *Select, res_ra: Register.Alias, - src_int_info: std.builtin.Type.Int, + src_int_info: std.lang.Type.Int, src_ra: Register.Alias, ) !void { switch (src_int_info.bits) { @@ -8274,7 +8274,7 @@ fn clzLimb( fn ctzLimb( isel: *Select, res_ra: Register.Alias, - src_int_info: std.builtin.Type.Int, + src_int_info: std.lang.Type.Int, src_ra: Register.Alias, ) !void { switch (src_int_info.bits) { @@ -8319,7 +8319,7 @@ fn cmp( var lhs_vi = orig_lhs_vi; var rhs_vi = orig_rhs_vi; if (!ty.isRuntimeFloat()) { - const int_info: std.builtin.Type.Int = if (ty.toIntern() == .bool_type) + const int_info: std.lang.Type.Int = if (ty.toIntern() == .bool_type) .{ .signedness = .unsigned, .bits = 1 } else if (ty.isAbiInt(isel.pt.zcu)) ty.intInfo(isel.pt.zcu) @@ -8523,7 +8523,7 @@ fn loadReg( isel: *Select, ra: Register.Alias, size: u64, - signedness: std.builtin.Signedness, + signedness: std.lang.Signedness, base_ra: Register.Alias, offset: i65, ) !void { @@ -8908,7 +8908,7 @@ pub const Value = struct { }, small: struct { size: u5, - signedness: std.builtin.Signedness, + signedness: std.lang.Signedness, is_vector: bool, hint: Register.Alias, register: Register.Alias, @@ -9037,13 +9037,13 @@ pub const Value = struct { }; } - fn setSignedness(vi: Value.Index, isel: *Select, new_signedness: std.builtin.Signedness) void { + fn setSignedness(vi: Value.Index, isel: *Select, new_signedness: std.lang.Signedness) void { const value = vi.get(isel); assert(value.location_payload.small.size <= 2); value.location_payload.small.signedness = new_signedness; } - pub fn signedness(vi: Value.Index, isel: *Select) std.builtin.Signedness { + pub fn signedness(vi: Value.Index, isel: *Select) std.lang.Signedness { const value = vi.get(isel); return switch (value.flags.location_tag) { .large => .unsigned, @@ -9505,7 +9505,7 @@ pub const Value = struct { offset: u64 = 0, @"volatile": bool = false, split: bool = true, - wrap: ?std.builtin.Type.Int = null, + wrap: ?std.lang.Type.Int = null, expected_live_registers: *const LiveRegisters = &.initFill(.free), }; @@ -9717,7 +9717,7 @@ pub const Value = struct { root_ty: ZigType, opts: struct { root_vi: Value.Index = .free, - wrap: ?std.builtin.Type.Int = null, + wrap: ?std.lang.Type.Int = null, expected_live_registers: *const LiveRegisters = &.initFill(.free), }, ) !?void { @@ -10289,7 +10289,7 @@ pub const Value = struct { const payload_ty: ZigType = .fromInterned(error_union_type.payload_type); const error_set_offset = codegen.errUnionErrorOffset(payload_ty, zcu); const payload_offset = codegen.errUnionPayloadOffset(payload_ty, zcu); - const Part = struct { offset: u64, size: u64, signedness: ?std.builtin.Signedness, is_vector: bool }; + const Part = struct { offset: u64, size: u64, signedness: ?std.lang.Signedness, is_vector: bool }; var parts: [2]Part = undefined; var parts_len: Value.PartsLen = 0; var field_end: u64 = 0; @@ -10393,7 +10393,7 @@ pub const Value = struct { (std.math.divCeil(u64, size, @as(u64, 1) << min_part_log2_stride) catch unreachable) > Value.max_parts) return isel.fail("Value.FieldPartIterator.next({f})", .{isel.fmtType(ty)}); const alignment = vi.alignment(isel); - const Part = struct { offset: u64, size: u64, signedness: ?std.builtin.Signedness, is_vector: bool }; + const Part = struct { offset: u64, size: u64, signedness: ?std.lang.Signedness, is_vector: bool }; var parts: [Value.max_parts]Part = undefined; var parts_len: Value.PartsLen = 0; var field_end: u64 = 0; @@ -10512,7 +10512,7 @@ pub const Value = struct { const alignment = vi.alignment(isel); const tag_offset = union_layout.tagOffset(); const payload_offset = union_layout.payloadOffset(); - const Part = struct { offset: u64, size: u64, signedness: ?std.builtin.Signedness }; + const Part = struct { offset: u64, size: u64, signedness: ?std.lang.Signedness }; var parts: [2]Part = undefined; var parts_len: Value.PartsLen = 0; var field_end: u64 = 0; diff --git a/src/codegen/aarch64/encoding.zig b/src/codegen/aarch64/encoding.zig @@ -6755,7 +6755,7 @@ pub const Instruction = packed union { o0: AddSubtractOp = .add, Rm: Register.Encoded, op21: u2 = 0b01, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded24: u5 = 0b11011, op54: u2 = 0b00, sf: Register.GeneralSize = .doubleword, @@ -6769,7 +6769,7 @@ pub const Instruction = packed union { o0: AddSubtractOp = .sub, Rm: Register.Encoded, op21: u2 = 0b01, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded24: u5 = 0b11011, op54: u2 = 0b00, sf: Register.GeneralSize = .doubleword, @@ -6783,7 +6783,7 @@ pub const Instruction = packed union { o0: AddSubtractOp = .add, Rm: Register.Encoded, op21: u2 = 0b10, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded24: u5 = 0b11011, op54: u2 = 0b00, sf: Register.GeneralSize = .doubleword, @@ -6797,7 +6797,7 @@ pub const Instruction = packed union { o0: AddSubtractOp = .add, Rm: Register.Encoded, op21: u2 = 0b01, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded24: u5 = 0b11011, op54: u2 = 0b00, sf: Register.GeneralSize = .doubleword, @@ -6811,7 +6811,7 @@ pub const Instruction = packed union { o0: AddSubtractOp = .sub, Rm: Register.Encoded, op21: u2 = 0b01, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded24: u5 = 0b11011, op54: u2 = 0b00, sf: Register.GeneralSize = .doubleword, @@ -6825,7 +6825,7 @@ pub const Instruction = packed union { o0: AddSubtractOp = .add, Rm: Register.Encoded, op21: u2 = 0b10, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded24: u5 = 0b11011, op54: u2 = 0b00, sf: Register.GeneralSize = .doubleword, @@ -7052,7 +7052,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, a: u1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness, + U: std.lang.Signedness, decoded30: u2 = 0b01, }; @@ -7065,7 +7065,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7078,7 +7078,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7091,7 +7091,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7104,7 +7104,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7117,7 +7117,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7130,7 +7130,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7143,7 +7143,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7156,7 +7156,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7169,7 +7169,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7182,7 +7182,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7195,7 +7195,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7208,7 +7208,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7221,7 +7221,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7234,7 +7234,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7247,7 +7247,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7260,7 +7260,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7273,7 +7273,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7286,7 +7286,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7299,7 +7299,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7312,7 +7312,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7428,7 +7428,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness, + U: std.lang.Signedness, decoded30: u2 = 0b01, }; @@ -7441,7 +7441,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7454,7 +7454,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7467,7 +7467,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7480,7 +7480,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7493,7 +7493,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7506,7 +7506,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7519,7 +7519,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7533,7 +7533,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7547,7 +7547,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7561,7 +7561,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7575,7 +7575,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7589,7 +7589,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7603,7 +7603,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7617,7 +7617,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7631,7 +7631,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7645,7 +7645,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7659,7 +7659,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7673,7 +7673,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -7686,7 +7686,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7699,7 +7699,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7712,7 +7712,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7725,7 +7725,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7738,7 +7738,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7751,7 +7751,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7764,7 +7764,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7778,7 +7778,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7792,7 +7792,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7806,7 +7806,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7820,7 +7820,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7834,7 +7834,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7848,7 +7848,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7862,7 +7862,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7876,7 +7876,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7890,7 +7890,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -7904,7 +7904,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, decoded30: u2 = 0b01, }; @@ -8045,7 +8045,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b11000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness, + U: std.lang.Signedness, decoded30: u2 = 0b01, }; @@ -8058,7 +8058,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b11000, size: Size, decoded24: u5 = 0b11110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, decoded30: u2 = 0b01, }; @@ -8262,7 +8262,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, a: u1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness, + U: std.lang.Signedness, Q: Q, decoded31: u1 = 0b0, }; @@ -8276,7 +8276,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8290,7 +8290,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8304,7 +8304,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8318,7 +8318,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8332,7 +8332,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8346,7 +8346,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8360,7 +8360,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8374,7 +8374,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8388,7 +8388,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8402,7 +8402,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8416,7 +8416,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8430,7 +8430,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8444,7 +8444,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8458,7 +8458,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8472,7 +8472,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8486,7 +8486,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8500,7 +8500,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8514,7 +8514,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8528,7 +8528,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8542,7 +8542,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8556,7 +8556,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8570,7 +8570,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8584,7 +8584,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8598,7 +8598,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8612,7 +8612,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8626,7 +8626,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8640,7 +8640,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8654,7 +8654,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8668,7 +8668,7 @@ pub const Instruction = packed union { decoded17: u6 = 0b111100, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -8814,7 +8814,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness, + U: std.lang.Signedness, Q: Q, decoded31: u1 = 0b0, }; @@ -8828,7 +8828,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8842,7 +8842,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8856,7 +8856,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8870,7 +8870,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8884,7 +8884,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8898,7 +8898,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8912,7 +8912,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8926,7 +8926,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8941,7 +8941,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8956,7 +8956,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8971,7 +8971,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -8986,7 +8986,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9001,7 +9001,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9016,7 +9016,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9031,7 +9031,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9046,7 +9046,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9061,7 +9061,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9076,7 +9076,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9091,7 +9091,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9106,7 +9106,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9121,7 +9121,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9136,7 +9136,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9151,7 +9151,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9165,7 +9165,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9179,7 +9179,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9193,7 +9193,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9207,7 +9207,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9221,7 +9221,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9235,7 +9235,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9249,7 +9249,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9264,7 +9264,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9279,7 +9279,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9294,7 +9294,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9309,7 +9309,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9324,7 +9324,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9339,7 +9339,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9354,7 +9354,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b0, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9368,7 +9368,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b10000, size: Size = .byte, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9383,7 +9383,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9398,7 +9398,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9413,7 +9413,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9428,7 +9428,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9443,7 +9443,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9458,7 +9458,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9473,7 +9473,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9488,7 +9488,7 @@ pub const Instruction = packed union { sz: Sz, o2: u1 = 0b1, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9670,7 +9670,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b11000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness, + U: std.lang.Signedness, Q: Q, decoded31: u1 = 0b0, }; @@ -9684,7 +9684,7 @@ pub const Instruction = packed union { decoded17: u5 = 0b11000, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9726,7 +9726,7 @@ pub const Instruction = packed union { decoded21: u1 = 0b1, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness, + U: std.lang.Signedness, Q: Q, decoded31: u1 = 0b0, }; @@ -9741,7 +9741,7 @@ pub const Instruction = packed union { decoded21: u1 = 0b1, size: Size, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9756,7 +9756,7 @@ pub const Instruction = packed union { decoded21: u1 = 0b1, size: Size = .byte, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9771,7 +9771,7 @@ pub const Instruction = packed union { decoded21: u1 = 0b1, size: Size = .half, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9786,7 +9786,7 @@ pub const Instruction = packed union { decoded21: u1 = 0b1, size: Size = .single, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9801,7 +9801,7 @@ pub const Instruction = packed union { decoded21: u1 = 0b1, size: Size = .double, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .signed, + U: std.lang.Signedness = .signed, Q: Q, decoded31: u1 = 0b0, }; @@ -9816,7 +9816,7 @@ pub const Instruction = packed union { decoded21: u1 = 0b1, size: Size = .byte, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9831,7 +9831,7 @@ pub const Instruction = packed union { decoded21: u1 = 0b1, size: Size = .half, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9846,7 +9846,7 @@ pub const Instruction = packed union { decoded21: u1 = 0b1, size: Size = .single, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; @@ -9861,7 +9861,7 @@ pub const Instruction = packed union { decoded21: u1 = 0b1, size: Size = .double, decoded24: u5 = 0b01110, - U: std.builtin.Signedness = .unsigned, + U: std.lang.Signedness = .unsigned, Q: Q, decoded31: u1 = 0b0, }; diff --git a/src/codegen/c.zig b/src/codegen/c.zig @@ -1997,7 +1997,7 @@ pub const DeclGen = struct { .bits => {}, } - const int_info: std.builtin.Type.Int = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else .{ + const int_info: std.lang.Type.Int = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else .{ .signedness = .unsigned, .bits = @intCast(ty.bitSize(zcu)), }; @@ -3878,7 +3878,7 @@ fn airSlice(f: *Function, inst: Air.Inst.Index) !CValue { fn airCall( f: *Function, inst: Air.Inst.Index, - modifier: std.builtin.CallModifier, + modifier: std.lang.CallModifier, ) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; @@ -6911,7 +6911,7 @@ fn airCVaCopy(f: *Function, inst: Air.Inst.Index) !CValue { return local; } -fn toMemoryOrder(order: std.builtin.AtomicOrder) [:0]const u8 { +fn toMemoryOrder(order: std.lang.AtomicOrder) [:0]const u8 { return switch (order) { // Note: unordered is actually even less atomic than relaxed .unordered, .monotonic => "zig_memory_order_relaxed", @@ -6922,11 +6922,11 @@ fn toMemoryOrder(order: std.builtin.AtomicOrder) [:0]const u8 { }; } -fn writeMemoryOrder(w: *Writer, order: std.builtin.AtomicOrder) !void { +fn writeMemoryOrder(w: *Writer, order: std.lang.AtomicOrder) !void { return w.writeAll(toMemoryOrder(order)); } -fn toCallingConvention(cc: std.builtin.CallingConvention, zcu: *Zcu) ?[]const u8 { +fn toCallingConvention(cc: std.lang.CallingConvention, zcu: *Zcu) ?[]const u8 { if (zcu.getTarget().cCallingConvention()) |ccc| { if (cc.eql(ccc)) { return null; @@ -7021,7 +7021,7 @@ fn toCallingConvention(cc: std.builtin.CallingConvention, zcu: *Zcu) ?[]const u8 }; } -fn toAtomicRmwSuffix(order: std.builtin.AtomicRmwOp) []const u8 { +fn toAtomicRmwSuffix(order: std.lang.AtomicRmwOp) []const u8 { return switch (order) { .Xchg => "xchg", .Add => "add", @@ -7044,7 +7044,7 @@ fn toCIntBits(zig_bits: u32) ?u32 { return null; } -fn signAbbrev(signedness: std.builtin.Signedness) u8 { +fn signAbbrev(signedness: std.lang.Signedness) u8 { return switch (signedness) { .signed => 'i', .unsigned => 'u', diff --git a/src/codegen/c/type.zig b/src/codegen/c/type.zig @@ -512,7 +512,7 @@ pub const CType = union(enum) { }, } } - fn classifyBitInt(signedness: std.builtin.Signedness, bits: u16, zcu: *const Zcu) IntClass { + fn classifyBitInt(signedness: std.lang.Signedness, bits: u16, zcu: *const Zcu) IntClass { const is_ez80 = zcu.getTarget().cpu.arch == .ez80; return switch (bits) { 0 => .void, diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig @@ -500,7 +500,7 @@ const CodeModel = enum { large, }; -fn codeModel(model: std.builtin.CodeModel, target: *const std.Target) CodeModel { +fn codeModel(model: std.lang.CodeModel, target: *const std.Target) CodeModel { // Roughly match Clang's mapping of GCC code models to LLVM code models. return switch (model) { .default => .default, @@ -556,7 +556,7 @@ pub const Object = struct { /// Same as `nav_map` but for UAVs (which are always global constants). uav_map: std.AutoHashMapUnmanaged(struct { val: InternPool.Index, - @"addrspace": std.builtin.AddressSpace, + @"addrspace": std.lang.AddressSpace, }, Builder.Variable.Index), /// Maps enum types to their corresponding LLVM functions for implementing the `tag_name` instruction. enum_tag_name_map: std.AutoHashMapUnmanaged(InternPool.Index, Builder.Function.Index), @@ -1755,7 +1755,7 @@ pub const Object = struct { } // If the first export specifies a linksection, set the exported variable's section to that - // one. This is kind of a hack because `std.builtin.ExportOptions.section` doesn't actually + // one. This is kind of a hack because `std.lang.ExportOptions.section` doesn't actually // make much sense: the linksection should be associated with the declaration itself rather // than some particular symbol it is exported as! if (export_indices[0].ptr(zcu).opts.section.toSlice(ip)) |section_slice| { @@ -3378,7 +3378,7 @@ pub const Object = struct { } if (fn_info.cc == .auto and zcu.comp.config.any_error_tracing) { - // First parameter is a pointer to `std.builtin.StackTrace`. + // First parameter is a pointer to `std.lang.StackTrace`. const llvm_ptr_ty = try o.builder.ptrType(toLlvmAddressSpace(.generic, target)); try llvm_params.append(o.gpa, llvm_ptr_ty); } @@ -3986,7 +3986,7 @@ pub const Object = struct { o: *Object, /// Must not be `.none`. @"align": InternPool.Alignment, - @"addrspace": std.builtin.AddressSpace, + @"addrspace": std.lang.AddressSpace, ) Allocator.Error!Builder.Constant { const addr: u64 = @"align".toByteUnits().?; const llvm_usize = try o.lowerType(.usize); @@ -4000,7 +4000,7 @@ pub const Object = struct { uav_val: InternPool.Index, /// Must not be `.none`. @"align": InternPool.Alignment, - @"addrspace": std.builtin.AddressSpace, + @"addrspace": std.lang.AddressSpace, ) Allocator.Error!Builder.Constant { assert(@"align" != .none); @@ -4383,20 +4383,20 @@ const CallingConventionInfo = struct { inreg_param_count: u2 = 0, }; -pub fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: *const std.Target) ?CallingConventionInfo { +pub fn toLlvmCallConv(cc: std.lang.CallingConvention, target: *const std.Target) ?CallingConventionInfo { const llvm_cc = toLlvmCallConvTag(cc, target) orelse return null; const incoming_stack_alignment: ?u64, const register_params: u2 = switch (cc) { inline else => |pl| switch (@TypeOf(pl)) { void => .{ null, 0 }, - std.builtin.CallingConvention.ArcInterruptOptions, - std.builtin.CallingConvention.ArmInterruptOptions, - std.builtin.CallingConvention.RiscvInterruptOptions, - std.builtin.CallingConvention.ShInterruptOptions, - std.builtin.CallingConvention.MicroblazeInterruptOptions, - std.builtin.CallingConvention.MipsInterruptOptions, - std.builtin.CallingConvention.CommonOptions, + std.lang.CallingConvention.ArcInterruptOptions, + std.lang.CallingConvention.ArmInterruptOptions, + std.lang.CallingConvention.RiscvInterruptOptions, + std.lang.CallingConvention.ShInterruptOptions, + std.lang.CallingConvention.MicroblazeInterruptOptions, + std.lang.CallingConvention.MipsInterruptOptions, + std.lang.CallingConvention.CommonOptions, => .{ pl.incoming_stack_alignment, 0 }, - std.builtin.CallingConvention.X86RegparmOptions => .{ pl.incoming_stack_alignment, pl.register_params }, + std.lang.CallingConvention.X86RegparmOptions => .{ pl.incoming_stack_alignment, pl.register_params }, else => @compileError("TODO: toLlvmCallConv" ++ @tagName(pl)), }, }; @@ -4410,7 +4410,7 @@ pub fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: *const std.Targ .inreg_param_count = register_params, }; } -pub fn toLlvmCallConvTag(cc_tag: std.builtin.CallingConvention.Tag, target: *const std.Target) ?Builder.CallConv { +pub fn toLlvmCallConvTag(cc_tag: std.lang.CallingConvention.Tag, target: *const std.Target) ?Builder.CallConv { if (target.cCallingConvention()) |default_c| { if (cc_tag == default_c) { return .ccc; @@ -4543,13 +4543,13 @@ pub fn toLlvmCallConvTag(cc_tag: std.builtin.CallingConvention.Tag, target: *con } /// Convert a zig-address space to an llvm address space. -pub fn toLlvmAddressSpace(address_space: std.builtin.AddressSpace, target: *const std.Target) Builder.AddrSpace { +pub fn toLlvmAddressSpace(address_space: std.lang.AddressSpace, target: *const std.Target) Builder.AddrSpace { for (llvmAddrSpaceInfo(target)) |info| if (info.zig == address_space) return info.llvm; unreachable; } const AddrSpaceInfo = struct { - zig: ?std.builtin.AddressSpace, + zig: ?std.lang.AddressSpace, llvm: Builder.AddrSpace, non_integral: bool = false, size: ?u16 = null, @@ -4643,7 +4643,7 @@ fn llvmDefaultGlobalAddressSpace(target: *const std.Target) Builder.AddrSpace { /// Return the actual address space that a value should be stored in if its a global address space. /// When a value is placed in the resulting address space, it needs to be cast back into wanted_address_space. -fn toLlvmGlobalAddressSpace(wanted_address_space: std.builtin.AddressSpace, target: *const std.Target) Builder.AddrSpace { +fn toLlvmGlobalAddressSpace(wanted_address_space: std.lang.AddressSpace, target: *const std.Target) Builder.AddrSpace { return switch (wanted_address_space) { .generic => llvmDefaultGlobalAddressSpace(target), else => |as| toLlvmAddressSpace(as, target), diff --git a/src/codegen/llvm/FuncGen.zig b/src/codegen/llvm/FuncGen.zig @@ -567,7 +567,7 @@ const CallAttr = enum { AlwaysInline, }; -fn airCall(self: *FuncGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) Allocator.Error!Builder.Value { +fn airCall(self: *FuncGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier) Allocator.Error!Builder.Value { const air_call = self.air.unwrapCall(inst); const args = air_call.args; const o = self.object; @@ -891,7 +891,7 @@ fn buildSimplePanic(fg: *FuncGen, panic_id: Zcu.SimplePanicId) Allocator.Error!v const o = fg.object; const zcu = o.zcu; const target = zcu.getTarget(); - const panic_func = zcu.funcInfo(zcu.builtin_decl_values.get(panic_id.toBuiltin())); + const panic_func = zcu.funcInfo(zcu.std_lang_decl_values.get(panic_id.toStdLangDecl())); const fn_info = zcu.typeToFunc(.fromInterned(panic_func.ty)).?; const llvm_panic_fn_ty = try o.lowerType(.fromInterned(panic_func.ty)); @@ -6017,14 +6017,14 @@ fn airPrefetch(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Val const o = self.object; const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch; - comptime assert(@intFromEnum(std.builtin.PrefetchOptions.Rw.read) == 0); - comptime assert(@intFromEnum(std.builtin.PrefetchOptions.Rw.write) == 1); + comptime assert(@intFromEnum(std.lang.PrefetchOptions.Rw.read) == 0); + comptime assert(@intFromEnum(std.lang.PrefetchOptions.Rw.write) == 1); comptime assert(prefetch.locality >= 0); comptime assert(prefetch.locality <= 3); - comptime assert(@intFromEnum(std.builtin.PrefetchOptions.Cache.instruction) == 0); - comptime assert(@intFromEnum(std.builtin.PrefetchOptions.Cache.data) == 1); + comptime assert(@intFromEnum(std.lang.PrefetchOptions.Cache.instruction) == 0); + comptime assert(@intFromEnum(std.lang.PrefetchOptions.Cache.data) == 1); // LLVM fails during codegen of instruction cache prefetchs for these architectures. // This is an LLVM bug as the prefetch intrinsic should be a noop if not supported @@ -7106,7 +7106,7 @@ fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.E /// has different ABI than regular integer types, and there is no currently no /// way to determine whether a Zig integer type is meant to represent e.g. `int` /// or `_BitInt(32)`. -pub fn ccAbiPromoteInt(cc: std.builtin.CallingConvention, zcu: *Zcu, ty: Type) ?std.builtin.Signedness { +pub fn ccAbiPromoteInt(cc: std.lang.CallingConvention, zcu: *Zcu, ty: Type) ?std.lang.Signedness { switch (cc) { .auto, .@"inline", .async => return null, else => {}, @@ -7379,7 +7379,7 @@ fn intrinsicsAllowed(scalar_ty: Type, target: *const std.Target) bool { }; } -fn toLlvmAtomicOrdering(atomic_order: std.builtin.AtomicOrder) Builder.AtomicOrdering { +fn toLlvmAtomicOrdering(atomic_order: std.lang.AtomicOrder) Builder.AtomicOrdering { return switch (atomic_order) { .unordered => .unordered, .monotonic => .monotonic, @@ -7391,7 +7391,7 @@ fn toLlvmAtomicOrdering(atomic_order: std.builtin.AtomicOrder) Builder.AtomicOrd } fn toLlvmAtomicRmwBinOp( - op: std.builtin.AtomicRmwOp, + op: std.lang.AtomicRmwOp, is_signed: bool, is_float: bool, ) Builder.Function.Instruction.AtomicRmw.Operation { diff --git a/src/codegen/riscv64/CodeGen.zig b/src/codegen/riscv64/CodeGen.zig @@ -1901,7 +1901,7 @@ fn splitType(func: *Func, ty: Type) ![2]Type { fn truncateRegister(func: *Func, ty: Type, reg: Register) !void { const pt = func.pt; const zcu = pt.zcu; - const int_info = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else std.builtin.Type.Int{ + const int_info = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else std.lang.Type.Int{ .signedness = .unsigned, .bits = @intCast(ty.bitSize(zcu)), }; @@ -4788,7 +4788,7 @@ fn airFrameAddress(func: *Func, inst: Air.Inst.Index) !void { return func.finishAir(inst, dst_mcv, .{ .none, .none, .none }); } -fn airCall(func: *Func, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void { +fn airCall(func: *Func, inst: Air.Inst.Index, modifier: std.lang.CallModifier) !void { if (modifier == .always_tail) return func.fail("TODO implement tail calls for riscv64", .{}); const call = func.air.unwrapCall(inst); const arg_refs = call.args; @@ -7691,7 +7691,7 @@ fn airAtomicLoad(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; const atomic_load = func.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load; - const order: std.builtin.AtomicOrder = atomic_load.order; + const order: std.lang.AtomicOrder = atomic_load.order; const ptr_ty = func.typeOf(atomic_load.ptr); const elem_ty = ptr_ty.childType(zcu); @@ -7737,7 +7737,7 @@ fn airAtomicLoad(func: *Func, inst: Air.Inst.Index) !void { return func.finishAir(inst, result_mcv, .{ atomic_load.ptr, .none, .none }); } -fn airAtomicStore(func: *Func, inst: Air.Inst.Index, order: std.builtin.AtomicOrder) !void { +fn airAtomicStore(func: *Func, inst: Air.Inst.Index, order: std.lang.AtomicOrder) !void { const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; const ptr_ty = func.typeOf(bin_op.lhs); diff --git a/src/codegen/riscv64/Lower.zig b/src/codegen/riscv64/Lower.zig @@ -1,12 +1,12 @@ //! This file contains the functionality for lowering RISC-V MIR to Instructions pt: Zcu.PerThread, -output_mode: std.builtin.OutputMode, -link_mode: std.builtin.LinkMode, +output_mode: std.lang.OutputMode, +link_mode: std.lang.LinkMode, pic: bool, allocator: Allocator, mir: Mir, -cc: std.builtin.CallingConvention, +cc: std.lang.CallingConvention, err_msg: ?*ErrorMsg = null, src_loc: Zcu.LazySrcLoc, result_insts_len: u8 = undefined, diff --git a/src/codegen/sparc64/CodeGen.zig b/src/codegen/sparc64/CodeGen.zig @@ -20,7 +20,7 @@ const Mir = @import("Mir.zig"); const Emit = @import("Emit.zig"); const Type = @import("../../Type.zig"); const CodeGenError = codegen.CodeGenError; -const Endian = std.builtin.Endian; +const Endian = std.lang.Endian; const Alignment = InternPool.Alignment; const build_options = @import("build_options"); @@ -1255,7 +1255,7 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void { return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } -fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void { +fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.lang.CallModifier) !void { if (modifier == .always_tail) return self.fail("TODO implement tail calls for {}", .{self.target.cpu.arch}); const call = self.air.unwrapCall(inst); @@ -4702,7 +4702,7 @@ fn truncRegister( self: *Self, operand_reg: Register, dest_reg: Register, - int_signedness: std.builtin.Signedness, + int_signedness: std.lang.Signedness, int_bits: u16, ) !void { switch (int_bits) { diff --git a/src/codegen/sparc64/Emit.zig b/src/codegen/sparc64/Emit.zig @@ -2,7 +2,7 @@ //! machine code const std = @import("std"); -const Endian = std.builtin.Endian; +const Endian = std.lang.Endian; const assert = std.debug.assert; const link = @import("../../link.zig"); const Zcu = @import("../../Zcu.zig"); diff --git a/src/codegen/spirv/Assembler.zig b/src/codegen/spirv/Assembler.zig @@ -212,7 +212,7 @@ fn processTypeInstruction(ass: *Assembler) !AsmValue { .OpTypeVoid => try module.voidType(), .OpTypeBool => try module.boolType(), .OpTypeInt => blk: { - const signedness: std.builtin.Signedness = switch (operands[2].literal32) { + const signedness: std.lang.Signedness = switch (operands[2].literal32) { 0 => .unsigned, 1 => .signed, else => { @@ -766,7 +766,7 @@ fn parseContextDependentNumber(ass: *Assembler) !void { return ass.fail(tok.start, "cannot parse literal constant", .{}); } -fn parseContextDependentInt(ass: *Assembler, signedness: std.builtin.Signedness, width: u32) !void { +fn parseContextDependentInt(ass: *Assembler, signedness: std.lang.Signedness, width: u32) !void { const gpa = ass.cg.module.gpa; const tok = ass.currentToken(); diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig @@ -1,7 +1,7 @@ const std = @import("std"); const Allocator = std.mem.Allocator; const Target = std.Target; -const Signedness = std.builtin.Signedness; +const Signedness = std.lang.Signedness; const assert = std.debug.assert; const log = std.log.scoped(.codegen); @@ -569,7 +569,7 @@ const ArithmeticTypeInfo = struct { /// Null if this type is a scalar, or the length of the vector otherwise. vector_len: ?u32, /// Whether the inner type is signed. Only relevant for integers. - signedness: std.builtin.Signedness, + signedness: std.lang.Signedness, }; fn arithmeticTypeInfo(cg: *CodeGen, ty: Type) ArithmeticTypeInfo { @@ -2251,7 +2251,7 @@ fn buildBinary(cg: *CodeGen, opcode: Opcode, lhs: Temporary, rhs: Temporary) !Te /// or OpIMul and s_mul_hi or u_mul_hi on OpenCL. fn buildWideMul( cg: *CodeGen, - signedness: std.builtin.Signedness, + signedness: std.lang.Signedness, lhs: Temporary, rhs: Temporary, ) !struct { Temporary, Temporary } { @@ -2358,7 +2358,7 @@ fn buildWideMul( /// The SPIR-V backend is not yet advanced enough to support the std testing infrastructure. /// In order to be able to run tests, we "temporarily" lower test kernels into separate entry- /// points. The test executor will then be able to invoke these to run the tests. -/// Note that tests are lowered according to std.builtin.TestFn, which is `fn () anyerror!void`. +/// Note that tests are lowered according to std.lang.TestFn, which is `fn () anyerror!void`. /// (anyerror!void has the same layout as anyerror). /// Each test declaration generates a function like. /// %anyerror = OpTypeInt 0 16 @@ -5976,7 +5976,7 @@ fn airAssembly(cg: *CodeGen, inst: Air.Inst.Index) !?Id { return null; } -fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !?Id { +fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier) !?Id { _ = modifier; const gpa = cg.module.gpa; diff --git a/src/codegen/spirv/Module.zig b/src/codegen/spirv/Module.zig @@ -54,8 +54,8 @@ cache: struct { bool_type: ?Id = null, void_type: ?Id = null, opaque_types: std.StringHashMapUnmanaged(Id) = .empty, - int_types: std.AutoHashMapUnmanaged(std.builtin.Type.Int, Id) = .empty, - float_types: std.AutoHashMapUnmanaged(std.builtin.Type.Float, Id) = .empty, + int_types: std.AutoHashMapUnmanaged(std.lang.Type.Int, Id) = .empty, + float_types: std.AutoHashMapUnmanaged(std.lang.Type.Float, Id) = .empty, vector_types: std.AutoHashMapUnmanaged(struct { Id, u32 }, Id) = .empty, array_types: std.AutoHashMapUnmanaged(struct { Id, Id }, Id) = .empty, struct_types: std.ArrayHashMapUnmanaged(StructType, Id, StructType.HashContext, true) = .empty, @@ -582,7 +582,7 @@ pub fn backingIntBits(module: *Module, bits: u16) struct { u16, bool } { return .{ std.mem.alignForward(u16, bits, big_int_bits), true }; } -pub fn intType(module: *Module, signedness: std.builtin.Signedness, bits: u16) !Id { +pub fn intType(module: *Module, signedness: std.lang.Signedness, bits: u16) !Id { assert(bits > 0); const target = module.zcu.getTarget(); @@ -918,7 +918,7 @@ pub fn debugString(module: *Module, string: []const u8) !Id { return entry.value_ptr.*; } -pub fn storageClass(module: *Module, as: std.builtin.AddressSpace) spec.StorageClass { +pub fn storageClass(module: *Module, as: std.lang.AddressSpace) spec.StorageClass { const target = module.zcu.getTarget(); return switch (as) { .generic => .function, diff --git a/src/codegen/wasm/CodeGen.zig b/src/codegen/wasm/CodeGen.zig @@ -586,7 +586,7 @@ fn addExtraAssumeCapacity(cg: *CodeGen, extra: anytype) error{OutOfMemory}!u32 { return result; } -/// For `std.builtin.CallingConvention.auto`. +/// For `std.lang.CallingConvention.auto`. pub fn typeToValtype(ty: Type, zcu: *const Zcu, target: *const std.Target) std.wasm.Valtype { return switch (ty.zigTypeTag(zcu)) { .float => switch (ty.floatBits(target)) { @@ -951,7 +951,7 @@ fn resolveCallingConventionValues( } pub fn firstParamSRet( - cc: std.builtin.CallingConvention, + cc: std.lang.CallingConvention, return_type: Type, zcu: *const Zcu, target: *const std.Target, @@ -970,7 +970,7 @@ pub fn firstParamSRet( /// Lowers a Zig type and its value based on a given calling convention to ensure /// it matches the ABI. -fn lowerArg(cg: *CodeGen, cc: std.builtin.CallingConvention, ty: Type, value: WValue) !void { +fn lowerArg(cg: *CodeGen, cc: std.lang.CallingConvention, ty: Type, value: WValue) !void { if (cc != .wasm_mvp) { return cg.lowerToStack(value); } @@ -1989,7 +1989,7 @@ fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { return cg.finishAir(inst, .none, &.{un_op}); } -fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) InnerError!void { +fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier) InnerError!void { if (modifier == .always_tail) return cg.fail("TODO implement tail calls for wasm", .{}); const call = cg.air.unwrapCall(inst); const args = call.args; @@ -7268,7 +7268,7 @@ fn airAtomicRmw(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const ptr = try cg.resolveInst(pl_op.operand); const operand = try cg.resolveInst(extra.operand); const ty = cg.typeOfIndex(inst); - const op: std.builtin.AtomicRmwOp = extra.op(); + const op: std.lang.AtomicRmwOp = extra.op(); if (cg.useAtomicFeature()) { const int_ty: IntType = .fromType(cg, ty); diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig @@ -173952,7 +173952,7 @@ fn setFrameLoc( offset.* += self.frame_allocs.items(.abi_size)[frame_i]; } -fn computeFrameLayout(self: *CodeGen, cc: std.builtin.CallingConvention.Tag) !FrameLayout { +fn computeFrameLayout(self: *CodeGen, cc: std.lang.CallingConvention.Tag) !FrameLayout { const frame_allocs_len = self.frame_allocs.len; try self.frame_locs.resize(self.gpa, frame_allocs_len); const stack_frame_order = try self.gpa.alloc(FrameIndex, frame_allocs_len - FrameIndex.named_count); @@ -174294,7 +174294,7 @@ pub fn spillEflagsIfOccupied(self: *CodeGen) !void { } } -pub fn spillCallerPreservedRegs(self: *CodeGen, cc: std.builtin.CallingConvention.Tag, ignore_reg: Register) !void { +pub fn spillCallerPreservedRegs(self: *CodeGen, cc: std.lang.CallingConvention.Tag, ignore_reg: Register) !void { switch (cc) { inline .auto, .x86_64_sysv, .x86_64_win => |tag| inline for (comptime abi.getCallerPreservedRegs(tag)) |reg| if (reg != ignore_reg) try self.register_manager.getKnownReg(reg, null), @@ -175917,7 +175917,7 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue }; } -fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier, opts: CopyOptions) !void { +fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier, opts: CopyOptions) !void { if (modifier == .always_tail) return self.fail("TODO implement tail calls for x86_64", .{}); const call = self.air.unwrapCall(inst); @@ -179498,7 +179498,7 @@ fn airBitCast(self: *CodeGen, inst: Air.Inst.Index) !void { ); var offset = dst_limbs_len * 8; if (offset < abi_size) { - const dst_signedness: std.builtin.Signedness = if (dst_ty.isAbiInt(zcu)) + const dst_signedness: std.lang.Signedness = if (dst_ty.isAbiInt(zcu)) dst_ty.intInfo(zcu).signedness else .unsigned; @@ -179640,8 +179640,8 @@ fn atomicOp( ptr_ty: Type, val_ty: Type, unused: bool, - rmw_op: ?std.builtin.AtomicRmwOp, - order: std.builtin.AtomicOrder, + rmw_op: ?std.lang.AtomicRmwOp, + order: std.lang.AtomicOrder, ) InnerError!MCValue { const pt = self.pt; const zcu = pt.zcu; @@ -179714,7 +179714,7 @@ fn atomicOp( defer self.register_manager.unlockReg(dst_lock); try self.genSetReg(dst_reg, val_ty, val_mcv, .{}); - if (rmw_op == std.builtin.AtomicRmwOp.Sub and mir_tag[1] == .xadd) { + if (rmw_op == std.lang.AtomicRmwOp.Sub and mir_tag[1] == .xadd) { try self.genUnOpMir(.{ ._, .neg }, val_ty, dst_mcv); } try self.asmMemoryRegister(mir_tag, ptr_mem, registerAlias(dst_reg, val_abi_size)); @@ -179898,7 +179898,7 @@ fn atomicOp( }; const val_lo_mem = try val_mem_mcv.mem(self, .{ .size = .qword }); const val_hi_mem = try val_mem_mcv.address().offset(8).deref().mem(self, .{ .size = .qword }); - if (rmw_op != std.builtin.AtomicRmwOp.Xchg) { + if (rmw_op != std.lang.AtomicRmwOp.Xchg) { try self.asmRegisterRegister(.{ ._, .mov }, .rbx, .rax); try self.asmRegisterRegister(.{ ._, .mov }, .rcx, .rdx); } @@ -180033,7 +180033,7 @@ fn airAtomicLoad(self: *CodeGen, inst: Air.Inst.Index) !void { return self.finishAir(inst, result, .{ atomic_load.ptr, .none, .none }); } -fn airAtomicStore(self: *CodeGen, inst: Air.Inst.Index, order: std.builtin.AtomicOrder) !void { +fn airAtomicStore(self: *CodeGen, inst: Air.Inst.Index, order: std.lang.AtomicOrder) !void { const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; const ptr_ty = self.typeOf(bin_op.lhs); @@ -181813,7 +181813,7 @@ fn nonBoolScalarBitSize(cg: *CodeGen, ty: Type) u32 { }; } -fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int { +fn intInfo(cg: *CodeGen, ty: Type) ?std.lang.Type.Int { const zcu = cg.pt.zcu; const ip = &zcu.intern_pool; var ty_index = ty.ip_index; @@ -188528,7 +188528,7 @@ const Select = struct { const ConstSpec = struct { ref: Select.Operand.Ref = .none, - to_signedness: ?std.builtin.Signedness = null, + to_signedness: ?std.lang.Signedness = null, vectorize_to: ?Memory.Size = null, }; @@ -188537,7 +188537,7 @@ const Select = struct { after: u2, at: u2, - fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.builtin.CallingConvention.Tag { + fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.lang.CallingConvention.Tag { return switch (spec.cc) { .none => unreachable, .ccc => cg.target.cCallingConvention().?, @@ -188667,11 +188667,11 @@ const Select = struct { .smax_mem, .umin_mem => .bool_false, }) }, else => { - const scalar_info: std.builtin.Type.Int = cg.intInfo(scalar_ty) orelse .{ + const scalar_info: std.lang.Type.Int = cg.intInfo(scalar_ty) orelse .{ .signedness = .signed, .bits = cg.floatBits(scalar_ty).?, }; - const res_scalar_info: std.builtin.Type.Int = .{ + const res_scalar_info: std.lang.Type.Int = .{ .signedness = const_spec.to_signedness orelse scalar_info.signedness, .bits = switch (spec.kind) { else => scalar_info.bits, @@ -188739,7 +188739,7 @@ const Select = struct { .positive = undefined, }; defer allocator.free(big_int.limbs); - const signedness: std.builtin.Signedness = switch (spec.kind) { + const signedness: std.lang.Signedness = switch (spec.kind) { else => unreachable, .slimit_delta_mem => .signed, .umax_delta_mem => .unsigned, diff --git a/src/codegen/x86_64/Lower.zig b/src/codegen/x86_64/Lower.zig @@ -3,7 +3,7 @@ target: *const std.Target, allocator: std.mem.Allocator, mir: Mir, -cc: std.builtin.CallingConvention, +cc: std.lang.CallingConvention, err_msg: ?*Zcu.ErrorMsg = null, src_loc: Zcu.LazySrcLoc, result_insts_len: ResultInstIndex = undefined, diff --git a/src/codegen/x86_64/Mir.zig b/src/codegen/x86_64/Mir.zig @@ -1737,7 +1737,7 @@ pub const Inst = struct { @typeInfo(Tag).@"enum".fields.len != 251) { const cond_src = (struct { - fn src() std.builtin.SourceLocation { + fn src() std.lang.SourceLocation { return @src(); } }).src(); diff --git a/src/codegen/x86_64/abi.zig b/src/codegen/x86_64/abi.zig @@ -478,7 +478,7 @@ pub const Win64 = struct { pub const c_abi_sse_return_regs = sse_avx_regs[0..1]; }; -pub fn getCalleePreservedRegs(cc: std.builtin.CallingConvention.Tag) []const Register { +pub fn getCalleePreservedRegs(cc: std.lang.CallingConvention.Tag) []const Register { return switch (cc) { .auto => zigcc.callee_preserved_regs, .x86_64_sysv => &SysV.callee_preserved_regs, @@ -487,7 +487,7 @@ pub fn getCalleePreservedRegs(cc: std.builtin.CallingConvention.Tag) []const Reg }; } -pub fn getCallerPreservedRegs(cc: std.builtin.CallingConvention.Tag) []const Register { +pub fn getCallerPreservedRegs(cc: std.lang.CallingConvention.Tag) []const Register { return switch (cc) { .auto => zigcc.caller_preserved_regs, .x86_64_sysv => &SysV.caller_preserved_regs, @@ -496,7 +496,7 @@ pub fn getCallerPreservedRegs(cc: std.builtin.CallingConvention.Tag) []const Reg }; } -pub fn getCAbiIntParamRegs(cc: std.builtin.CallingConvention.Tag) []const Register { +pub fn getCAbiIntParamRegs(cc: std.lang.CallingConvention.Tag) []const Register { return switch (cc) { .auto => zigcc.int_param_regs, .x86_64_sysv => &SysV.c_abi_int_param_regs, @@ -505,7 +505,7 @@ pub fn getCAbiIntParamRegs(cc: std.builtin.CallingConvention.Tag) []const Regist }; } -pub fn getCAbiX87ParamRegs(cc: std.builtin.CallingConvention.Tag) []const Register { +pub fn getCAbiX87ParamRegs(cc: std.lang.CallingConvention.Tag) []const Register { return switch (cc) { .auto => zigcc.x87_param_regs, .x86_64_sysv => SysV.c_abi_x87_param_regs, @@ -514,7 +514,7 @@ pub fn getCAbiX87ParamRegs(cc: std.builtin.CallingConvention.Tag) []const Regist }; } -pub fn getCAbiSseParamRegs(cc: std.builtin.CallingConvention.Tag, target: *const std.Target) []const Register { +pub fn getCAbiSseParamRegs(cc: std.lang.CallingConvention.Tag, target: *const std.Target) []const Register { return switch (cc) { .auto => switch (target.cpu.arch) { else => unreachable, @@ -527,7 +527,7 @@ pub fn getCAbiSseParamRegs(cc: std.builtin.CallingConvention.Tag, target: *const }; } -pub fn getCAbiIntReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Register { +pub fn getCAbiIntReturnRegs(cc: std.lang.CallingConvention.Tag) []const Register { return switch (cc) { .auto => zigcc.int_return_regs, .x86_64_sysv => &SysV.c_abi_int_return_regs, @@ -536,7 +536,7 @@ pub fn getCAbiIntReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Regis }; } -pub fn getCAbiX87ReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Register { +pub fn getCAbiX87ReturnRegs(cc: std.lang.CallingConvention.Tag) []const Register { return switch (cc) { .auto => zigcc.x87_return_regs, .x86_64_sysv => SysV.c_abi_x87_return_regs, @@ -545,7 +545,7 @@ pub fn getCAbiX87ReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Regis }; } -pub fn getCAbiSseReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Register { +pub fn getCAbiSseReturnRegs(cc: std.lang.CallingConvention.Tag) []const Register { return switch (cc) { .auto => zigcc.sse_return_regs, .x86_64_sysv => SysV.c_abi_sse_return_regs, @@ -554,7 +554,7 @@ pub fn getCAbiSseReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Regis }; } -pub fn getCAbiLinkerScratchReg(cc: std.builtin.CallingConvention.Tag) Register { +pub fn getCAbiLinkerScratchReg(cc: std.lang.CallingConvention.Tag) Register { return switch (cc) { .auto => zigcc.int_return_regs[zigcc.int_return_regs.len - 1], .x86_64_sysv => SysV.c_abi_int_return_regs[0], diff --git a/src/codegen/x86_64/bits.zig b/src/codegen/x86_64/bits.zig @@ -106,7 +106,7 @@ pub const Condition = enum(u5) { } pub fn fromCompareOperator( - signedness: std.builtin.Signedness, + signedness: std.lang.Signedness, op: std.math.CompareOperator, ) Condition { return switch (signedness) { diff --git a/src/libs/freebsd.zig b/src/libs/freebsd.zig @@ -19,7 +19,7 @@ pub const CrtFile = enum { scrt1_o, }; -pub fn needsCrt0(output_mode: std.builtin.OutputMode) ?CrtFile { +pub fn needsCrt0(output_mode: std.lang.OutputMode) ?CrtFile { // For shared libraries and PIC executables, we should actually link in a variant of crt1 that // is built with `-DSHARED` so that it calls `__cxa_finalize` in an ELF destructor. However, we // currently make no effort to respect `__cxa_finalize` on any other targets, so for now, we're diff --git a/src/libs/glibc.zig b/src/libs/glibc.zig @@ -1277,7 +1277,7 @@ fn buildSharedLib( try comp.updateSubCompilation(sub_compilation, misc_task, prog_node); } -pub fn needsCrt0(output_mode: std.builtin.OutputMode) ?CrtFile { +pub fn needsCrt0(output_mode: std.lang.OutputMode) ?CrtFile { return switch (output_mode) { .Obj, .Lib => null, .Exe => .scrt1_o, diff --git a/src/libs/libcxx.zig b/src/libs/libcxx.zig @@ -324,7 +324,7 @@ pub fn buildLibCxxAbi(comp: *Compilation, prog_node: std.Progress.Node) BuildErr const strip = comp.compilerRtStrip(); // See the `-fno-exceptions` logic for WASI. // The old 32-bit x86 variant of SEH doesn't use tables. - const unwind_tables: std.builtin.UnwindTables = + const unwind_tables: std.lang.UnwindTables = if (target.os.tag == .wasi or (target.cpu.arch == .x86 and target.os.tag == .windows)) .none else .async; const config = Compilation.Config.resolve(.{ diff --git a/src/libs/libtsan.zig b/src/libs/libtsan.zig @@ -37,7 +37,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo .watchos => if (target.abi == .simulator) "clang_rt.tsan_watchossim_dynamic" else "clang_rt.tsan_watchos_dynamic", else => "tsan", }; - const link_mode: std.builtin.LinkMode = if (target.os.tag.isDarwin()) .dynamic else .static; + const link_mode: std.lang.LinkMode = if (target.os.tag.isDarwin()) .dynamic else .static; const output_mode = .Lib; const basename = try std.zig.binNameAlloc(arena, .{ .root_name = root_name, @@ -48,7 +48,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo const optimize_mode = comp.compilerRtOptMode(); const strip = comp.compilerRtStrip(); - const unwind_tables: std.builtin.UnwindTables = + const unwind_tables: std.lang.UnwindTables = if (target.cpu.arch == .x86 and target.os.tag == .windows) .none else .async; const link_libcpp = target.os.tag.isDarwin(); diff --git a/src/libs/libunwind.zig b/src/libs/libunwind.zig @@ -29,7 +29,7 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr const io = comp.io; const output_mode = .Lib; const target = &comp.root_mod.resolved_target.result; - const unwind_tables: std.builtin.UnwindTables = + const unwind_tables: std.lang.UnwindTables = if (target.cpu.arch == .x86 and target.os.tag == .windows) .none else .async; const config = Compilation.Config.resolve(.{ .output_mode = output_mode, diff --git a/src/libs/mingw.zig b/src/libs/mingw.zig @@ -37,7 +37,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre const target = comp.getTarget(); // The old 32-bit x86 variant of SEH doesn't use tables. - const unwind_tables: std.builtin.UnwindTables = if (target.cpu.arch != .x86) .async else .none; + const unwind_tables: std.lang.UnwindTables = if (target.cpu.arch != .x86) .async else .none; switch (crt_file) { .crt2_o => { diff --git a/src/libs/musl.zig b/src/libs/musl.zig @@ -173,7 +173,7 @@ pub fn buildCrtFile(comp: *Compilation, in_crt_file: CrtFile, prog_node: std.Pro .libc_so => { const optimize_mode = comp.compilerRtOptMode(); const strip = comp.compilerRtStrip(); - const output_mode: std.builtin.OutputMode = .Lib; + const output_mode: std.lang.OutputMode = .Lib; const config = try Compilation.Config.resolve(.{ .output_mode = output_mode, .link_mode = .dynamic, @@ -290,7 +290,7 @@ pub fn buildCrtFile(comp: *Compilation, in_crt_file: CrtFile, prog_node: std.Pro } } -pub fn needsCrt0(output_mode: std.builtin.OutputMode, link_mode: std.builtin.LinkMode, pie: bool) ?CrtFile { +pub fn needsCrt0(output_mode: std.lang.OutputMode, link_mode: std.lang.LinkMode, pie: bool) ?CrtFile { return switch (output_mode) { .Obj, .Lib => null, .Exe => switch (link_mode) { diff --git a/src/libs/netbsd.zig b/src/libs/netbsd.zig @@ -19,7 +19,7 @@ pub const CrtFile = enum { scrt0_o, }; -pub fn needsCrt0(output_mode: std.builtin.OutputMode) ?CrtFile { +pub fn needsCrt0(output_mode: std.lang.OutputMode) ?CrtFile { // For shared libraries and PIC executables, we should actually link in a variant of crt1 that // is built with `-DSHARED` so that it calls `__cxa_finalize` in an ELF destructor. However, we // currently make no effort to respect `__cxa_finalize` on any other targets, so for now, we're diff --git a/src/libs/openbsd.zig b/src/libs/openbsd.zig @@ -20,7 +20,7 @@ pub const CrtFile = enum { scrt0_o, }; -pub fn needsCrt0(output_mode: std.builtin.OutputMode) ?CrtFile { +pub fn needsCrt0(output_mode: std.lang.OutputMode) ?CrtFile { // https://github.com/ziglang/zig/issues/23574#issuecomment-2869089897 return switch (output_mode) { .Obj, .Lib => null, diff --git a/src/libs/wasi_libc.zig b/src/libs/wasi_libc.zig @@ -12,14 +12,14 @@ pub const CrtFile = enum { libc_a, }; -pub fn execModelCrtFile(wasi_exec_model: std.builtin.WasiExecModel) CrtFile { +pub fn execModelCrtFile(wasi_exec_model: std.lang.WasiExecModel) CrtFile { return switch (wasi_exec_model) { .reactor => CrtFile.crt1_reactor_o, .command => CrtFile.crt1_command_o, }; } -pub fn execModelCrtFileFullName(wasi_exec_model: std.builtin.WasiExecModel) []const u8 { +pub fn execModelCrtFileFullName(wasi_exec_model: std.lang.WasiExecModel) []const u8 { return switch (execModelCrtFile(wasi_exec_model)) { .crt1_reactor_o => "crt1-reactor.o", .crt1_command_o => "crt1-command.o", diff --git a/src/link.zig b/src/link.zig @@ -1300,8 +1300,8 @@ pub const File = struct { }; pub fn determinePermissions( - output_mode: std.builtin.OutputMode, - link_mode: std.builtin.LinkMode, + output_mode: std.lang.OutputMode, + link_mode: std.lang.LinkMode, ) Io.File.Permissions { // On common systems with a 0o022 umask, 0o777 will still result in a file created // with 0o755 permissions, but it works appropriately if the system is configured @@ -1714,10 +1714,10 @@ pub const UnresolvedInput = union(enum) { must_link: bool = false, hidden: bool = false, allow_so_scripts: bool = false, - preferred_mode: std.builtin.LinkMode, + preferred_mode: std.lang.LinkMode, search_strategy: SearchStrategy, - fn fallbackMode(q: Query) std.builtin.LinkMode { + fn fallbackMode(q: Query) std.lang.LinkMode { assert(q.search_strategy != .no_fallback); return switch (q.preferred_mode) { .dynamic => .static, @@ -1843,7 +1843,7 @@ pub fn resolveInputs( name: []const u8, strategy: UnresolvedInput.SearchStrategy, checked_paths: []const u8, - preferred_mode: std.builtin.LinkMode, + preferred_mode: std.lang.LinkMode, }) = .empty; // Convert external system libs into a stack so that items can be @@ -2077,7 +2077,7 @@ fn resolveLibInput( lib_directory: Directory, name_query: UnresolvedInput.NameQuery, target: *const std.Target, - link_mode: std.builtin.LinkMode, + link_mode: std.lang.LinkMode, color: std.zig.Color, ) Allocator.Error!ResolveLibInputResult { try resolved_inputs.ensureUnusedCapacity(gpa, 1); @@ -2161,7 +2161,7 @@ fn finishResolveLibInput( resolved_inputs: *std.ArrayList(Input), path: Path, file: Io.File, - link_mode: std.builtin.LinkMode, + link_mode: std.lang.LinkMode, query: UnresolvedInput.Query, ) ResolveLibInputResult { switch (link_mode) { @@ -2237,7 +2237,7 @@ fn resolvePathInputLib( ld_script_bytes: *std.ArrayList(u8), target: *const std.Target, pq: UnresolvedInput.PathQuery, - link_mode: std.builtin.LinkMode, + link_mode: std.lang.LinkMode, color: std.zig.Color, ) Allocator.Error!ResolveLibInputResult { try resolved_inputs.ensureUnusedCapacity(gpa, 1); diff --git a/src/link/Coff.zig b/src/link/Coff.zig @@ -1091,7 +1091,7 @@ fn computeNodeSectionOffset(coff: *Coff, ni: MappedFile.Node.Index) u32 { } } -pub inline fn targetEndian(_: *const Coff) std.builtin.Endian { +pub inline fn targetEndian(_: *const Coff) std.lang.Endian { return .little; } fn targetLoad(coff: *const Coff, ptr: anytype) @typeInfo(@TypeOf(ptr)).pointer.child { diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig @@ -22,7 +22,7 @@ const target_info = @import("../target.zig"); gpa: Allocator, bin_file: *link.File, format: DW.Format, -endian: std.builtin.Endian, +endian: std.lang.Endian, address_size: AddressSize, const_pool: link.ConstPool, @@ -1963,7 +1963,7 @@ pub const WipNav = struct { fn writer(counter: *ExprLocCounter) *Writer { return &counter.dw.writer; } - fn endian(_: ExprLocCounter) std.builtin.Endian { + fn endian(_: ExprLocCounter) std.lang.Endian { return @import("builtin").cpu.arch.endian(); } fn addrSym(counter: *ExprLocCounter, _: u32) Writer.Error!void { @@ -1984,7 +1984,7 @@ pub const WipNav = struct { fn writer(ctx: @This()) *Writer { return &ctx.wip_nav.debug_info.writer; } - fn endian(ctx: @This()) std.builtin.Endian { + fn endian(ctx: @This()) std.lang.Endian { return ctx.wip_nav.dwarf.endian; } fn addrSym(ctx: @This(), sym_index: u32) (UpdateError || Writer.Error)!void { @@ -2026,7 +2026,7 @@ pub const WipNav = struct { fn writer(ctx: @This()) *Writer { return &ctx.wip_nav.debug_frame.writer; } - fn endian(ctx: @This()) std.builtin.Endian { + fn endian(ctx: @This()) std.lang.Endian { return ctx.wip_nav.dwarf.endian; } fn addrSym(ctx: @This(), sym_index: u32) (UpdateError || Writer.Error)!void { @@ -4164,7 +4164,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)}); const cc: DW.CC = cc: { if (zcu.getTarget().cCallingConvention()) |cc| { - if (@as(std.builtin.CallingConvention.Tag, cc) == func_type.cc) { + if (@as(std.lang.CallingConvention.Tag, cc) == func_type.cc) { break :cc .normal; } } diff --git a/src/link/Elf2.zig b/src/link/Elf2.zig @@ -1697,7 +1697,7 @@ pub fn identData(elf: *const Elf) std.elf.DATA { return @enumFromInt(elf.mf.memory_map.memory[std.elf.EI.DATA]); } -pub fn targetEndian(elf: *const Elf) std.builtin.Endian { +pub fn targetEndian(elf: *const Elf) std.lang.Endian { return switch (elf.identData()) { .NONE, _ => unreachable, .@"2LSB" => .little, diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig @@ -3882,7 +3882,7 @@ pub fn flush( fn defaultEntrySymbolName( preloaded_strings: *const PreloadedStrings, - wasi_exec_model: std.builtin.WasiExecModel, + wasi_exec_model: std.lang.WasiExecModel, ) String { return switch (wasi_exec_model) { .reactor => preloaded_strings._initialize, @@ -3962,7 +3962,7 @@ pub fn getExistingFuncType2(wasm: *const Wasm, params: []const std.wasm.Valtype, pub fn internFunctionType( wasm: *Wasm, - cc: std.builtin.CallingConvention, + cc: std.lang.CallingConvention, params: []const InternPool.Index, return_type: Zcu.Type, target: *const std.Target, @@ -3976,7 +3976,7 @@ pub fn internFunctionType( pub fn getExistingFunctionType( wasm: *Wasm, - cc: std.builtin.CallingConvention, + cc: std.lang.CallingConvention, params: []const InternPool.Index, return_type: Zcu.Type, target: *const std.Target, @@ -4210,7 +4210,7 @@ pub fn errorNameTableAddr(wasm: *Wasm) u32 { fn convertZcuFnType( comp: *Compilation, - cc: std.builtin.CallingConvention, + cc: std.lang.CallingConvention, params: []const InternPool.Index, return_type: Zcu.Type, target: *const std.Target, diff --git a/src/main.zig b/src/main.zig @@ -766,7 +766,7 @@ const Emit = union(enum) { }; const ArgMode = union(enum) { - build: std.builtin.OutputMode, + build: std.lang.OutputMode, cc, cpp, translate_c, @@ -935,13 +935,13 @@ fn buildOutputType( var minor_subsystem_version: ?u16 = null; var mingw_unicode_entry_point: bool = false; var enable_link_snapshots: bool = false; - var debug_compiler_runtime_libs: ?std.builtin.OptimizeMode = null; + var debug_compiler_runtime_libs: ?std.lang.OptimizeMode = null; var install_name: ?[]const u8 = null; var hash_style: link.File.Lld.Elf.HashStyle = .both; var entitlements: ?[]const u8 = null; var pagezero_size: ?u64 = null; var lib_search_strategy: link.UnresolvedInput.SearchStrategy = .paths_first; - var lib_preferred_mode: std.builtin.LinkMode = .dynamic; + var lib_preferred_mode: std.lang.LinkMode = .dynamic; var headerpad_size: ?u32 = null; var headerpad_max_install_names: bool = false; var dead_strip_dylibs: bool = false; @@ -5752,7 +5752,7 @@ fn jitCmdInner( const self_exe_path = process.executablePathAlloc(io, arena) catch |err| fatal("unable to find self exe path: {t}", .{err}); - const optimize_mode: std.builtin.OptimizeMode = if (EnvVar.ZIG_DEBUG_CMD.isSet(environ_map)) + const optimize_mode: std.lang.OptimizeMode = if (EnvVar.ZIG_DEBUG_CMD.isSet(environ_map)) .Debug else .ReleaseFast; @@ -6263,8 +6263,8 @@ pub const ClangArgIterator = struct { } }; -fn parseCodeModel(arg: []const u8) std.builtin.CodeModel { - return std.meta.stringToEnum(std.builtin.CodeModel, arg) orelse +fn parseCodeModel(arg: []const u8) std.lang.CodeModel { + return std.meta.stringToEnum(std.lang.CodeModel, arg) orelse fatal("unsupported machine code model: '{s}'", .{arg}); } @@ -7667,13 +7667,13 @@ fn findTemplates(gpa: Allocator, arena: Allocator, io: Io) Templates { }; } -fn parseOptimizeMode(s: []const u8) std.builtin.OptimizeMode { - return std.meta.stringToEnum(std.builtin.OptimizeMode, s) orelse +fn parseOptimizeMode(s: []const u8) std.lang.OptimizeMode { + return std.meta.stringToEnum(std.lang.OptimizeMode, s) orelse fatal("unrecognized optimization mode: '{s}'", .{s}); } -fn parseWasiExecModel(s: []const u8) std.builtin.WasiExecModel { - return std.meta.stringToEnum(std.builtin.WasiExecModel, s) orelse +fn parseWasiExecModel(s: []const u8) std.lang.WasiExecModel { + return std.meta.stringToEnum(std.lang.WasiExecModel, s) orelse fatal("expected [command|reactor] for -mexec-mode=[value], found '{s}'", .{s}); } diff --git a/src/print_zir.zig b/src/print_zir.zig @@ -693,7 +693,7 @@ const Writer = struct { .restore_err_ret_index => try self.writeRestoreErrRetIndex(stream, extended), .closure_get => try self.writeClosureGet(stream, extended), .field_parent_ptr => try self.writeFieldParentPtr(stream, extended), - .builtin_value => try self.writeBuiltinValue(stream, extended), + .std_lang_value => try self.writeStdLangValue(stream, extended), .inplace_arith_result_ty => try self.writeInplaceArithResultTy(stream, extended), .dbg_empty_stmt => try stream.writeAll("))"), @@ -1340,7 +1340,7 @@ const Writer = struct { if (extra.data.flags.ensure_result_used) { try stream.writeAll("nodiscard "); } - try stream.print(".{s}, ", .{@tagName(@as(std.builtin.CallModifier, @enumFromInt(extra.data.flags.packed_modifier)))}); + try stream.print(".{s}, ", .{@tagName(@as(std.lang.CallModifier, @enumFromInt(extra.data.flags.packed_modifier)))}); switch (kind) { .direct => try self.writeInstRef(stream, extra.data.callee), .field => { @@ -2232,8 +2232,8 @@ const Writer = struct { try self.writeSrcNode(stream, src_node); } - fn writeBuiltinValue(self: *Writer, stream: *std.Io.Writer, extended: Zir.Inst.Extended.InstData) !void { - const val: Zir.Inst.BuiltinValue = @enumFromInt(extended.small); + fn writeStdLangValue(self: *Writer, stream: *std.Io.Writer, extended: Zir.Inst.Extended.InstData) !void { + const val: Zir.Inst.StdLangValue = @enumFromInt(extended.small); try stream.print("{s})) ", .{@tagName(val)}); const src_node: Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); try self.writeSrcNode(stream, src_node); diff --git a/src/target.zig b/src/target.zig @@ -3,7 +3,7 @@ const std = @import("std"); const assert = std.debug.assert; const Type = @import("Type.zig"); -const AddressSpace = std.builtin.AddressSpace; +const AddressSpace = std.lang.AddressSpace; const Alignment = @import("InternPool.zig").Alignment; const Compilation = @import("Compilation.zig"); const Feature = @import("Zcu.zig").Feature; @@ -31,7 +31,7 @@ pub fn canDynamicLink(target: *const std.Target) bool { }; } -pub fn libCNeedsLibUnwind(target: *const std.Target, link_mode: std.builtin.LinkMode) bool { +pub fn libCNeedsLibUnwind(target: *const std.Target, link_mode: std.lang.LinkMode) bool { return target.isGnuLibC() and link_mode == .static; } @@ -119,7 +119,7 @@ pub fn useEmulatedTls(target: *const std.Target) bool { }; } -pub fn hasValgrindSupport(target: *const std.Target, backend: std.builtin.CompilerBackend) bool { +pub fn hasValgrindSupport(target: *const std.Target, backend: std.lang.CompilerBackend) bool { // We can't currently output the necessary Valgrind client request assembly when using the C // backend and compiling with an MSVC-like compiler. const ofmt_c_msvc = (target.abi == .msvc or target.abi == .itanium) and target.ofmt == .c; @@ -265,7 +265,7 @@ pub fn hasLldSupport(ofmt: std.Target.ObjectFormat) bool { }; } -pub fn hasNewLinkerSupport(ofmt: std.Target.ObjectFormat, backend: std.builtin.CompilerBackend) bool { +pub fn hasNewLinkerSupport(ofmt: std.Target.ObjectFormat, backend: std.lang.CompilerBackend) bool { return switch (ofmt) { .elf, .coff => switch (backend) { .stage2_x86_64 => true, @@ -299,7 +299,7 @@ pub fn selfHostedBackendIsAsRobustAsLlvm(target: *const std.Target) bool { return false; } -pub fn supportsStackProbing(target: *const std.Target, backend: std.builtin.CompilerBackend) bool { +pub fn supportsStackProbing(target: *const std.Target, backend: std.lang.CompilerBackend) bool { return switch (backend) { .stage2_aarch64, .stage2_x86_64 => true, .stage2_llvm => target.os.tag != .windows and target.os.tag != .uefi and @@ -308,7 +308,7 @@ pub fn supportsStackProbing(target: *const std.Target, backend: std.builtin.Comp }; } -pub fn supportsStackProtector(target: *const std.Target, backend: std.builtin.CompilerBackend) bool { +pub fn supportsStackProtector(target: *const std.Target, backend: std.lang.CompilerBackend) bool { switch (target.os.tag) { .plan9 => return false, else => {}, @@ -336,7 +336,7 @@ pub fn libcProvidesStackProtector(target: *const std.Target) bool { /// Returns true if `@returnAddress()` is supported by the target and has a /// reasonably performant implementation for the requested optimization mode. -pub fn supportsReturnAddress(target: *const std.Target, optimize: std.builtin.OptimizeMode) bool { +pub fn supportsReturnAddress(target: *const std.Target, optimize: std.lang.OptimizeMode) bool { return switch (target.cpu.arch) { // Emscripten currently implements `emscripten_return_address()` by calling // out into JavaScript and parsing a stack trace, which introduces significant @@ -396,7 +396,7 @@ pub fn hasDebugInfo(target: *const std.Target) bool { }; } -pub fn defaultCompilerRtOptimizeMode(target: *const std.Target) std.builtin.OptimizeMode { +pub fn defaultCompilerRtOptimizeMode(target: *const std.Target) std.lang.OptimizeMode { if (target.cpu.arch.isWasm() and target.os.tag == .freestanding) { return .ReleaseSmall; } else { @@ -437,7 +437,7 @@ pub fn canBuildLibUbsanRt(target: *const std.Target) enum { no, yes, llvm_only, /// Whether libzigc can fill-in the gaps of an existing libc /// or *is* the libc of the target. -pub fn wantsZigC(target: *const std.Target, link_mode: std.builtin.LinkMode) bool { +pub fn wantsZigC(target: *const std.Target, link_mode: std.lang.LinkMode) bool { return (target.isMuslLibC() and link_mode == .static) or target.isWasiLibC() or target.isMinGW(); } @@ -547,7 +547,7 @@ pub fn clangSupportsNoImplicitFloatArg(target: *const std.Target) bool { }; } -pub fn defaultUnwindTables(target: *const std.Target, libunwind: bool, libtsan: bool) std.builtin.UnwindTables { +pub fn defaultUnwindTables(target: *const std.Target, libunwind: bool, libtsan: bool) std.lang.UnwindTables { if (target.os.tag == .windows) { // The old 32-bit x86 variant of SEH doesn't use tables. return if (target.cpu.arch != .x86) .async else .none; @@ -824,7 +824,7 @@ pub fn functionPointerMask(target: *const std.Target) ?u64 { null; } -pub fn supportsTailCall(target: *const std.Target, backend: std.builtin.CompilerBackend) bool { +pub fn supportsTailCall(target: *const std.Target, backend: std.lang.CompilerBackend) bool { switch (backend) { .stage2_llvm => return @import("codegen/llvm.zig").supportsTailCall(target), .stage2_c => return true, @@ -832,7 +832,7 @@ pub fn supportsTailCall(target: *const std.Target, backend: std.builtin.Compiler } } -pub fn supportsThreads(target: *const std.Target, backend: std.builtin.CompilerBackend) bool { +pub fn supportsThreads(target: *const std.Target, backend: std.lang.CompilerBackend) bool { _ = target; return switch (backend) { .stage2_aarch64 => false, @@ -880,7 +880,7 @@ pub fn compilerRtIntAbbrev(bits: u16) []const u8 { }; } -pub fn fnCallConvAllowsZigTypes(cc: std.builtin.CallingConvention) bool { +pub fn fnCallConvAllowsZigTypes(cc: std.lang.CallingConvention) bool { return switch (cc) { .auto, .async, .@"inline" => true, // For now we want to authorize PTX kernel to use zig objects, even if @@ -891,7 +891,7 @@ pub fn fnCallConvAllowsZigTypes(cc: std.builtin.CallingConvention) bool { }; } -pub fn zigBackend(target: *const std.Target, use_llvm: bool) std.builtin.CompilerBackend { +pub fn zigBackend(target: *const std.Target, use_llvm: bool) std.lang.CompilerBackend { if (use_llvm) return .stage2_llvm; if (target.ofmt == .c) return .stage2_c; return switch (target.cpu.arch) { @@ -908,7 +908,7 @@ pub fn zigBackend(target: *const std.Target, use_llvm: bool) std.builtin.Compile }; } -pub inline fn backendSupportsFeature(backend: std.builtin.CompilerBackend, comptime feature: Feature) bool { +pub inline fn backendSupportsFeature(backend: std.lang.CompilerBackend, comptime feature: Feature) bool { return switch (feature) { .panic_fn => switch (backend) { .stage2_aarch64, diff --git a/src/tracy.zig b/src/tracy.zig @@ -58,7 +58,7 @@ pub const Ctx = if (enable) ___tracy_c_zone_context else struct { } }; -pub inline fn trace(comptime src: std.builtin.SourceLocation) Ctx { +pub inline fn trace(comptime src: std.lang.SourceLocation) Ctx { if (!enable) return .{}; const global = struct { @@ -78,7 +78,7 @@ pub inline fn trace(comptime src: std.builtin.SourceLocation) Ctx { } } -pub inline fn traceNamed(comptime src: std.builtin.SourceLocation, comptime name: [:0]const u8) Ctx { +pub inline fn traceNamed(comptime src: std.lang.SourceLocation, comptime name: [:0]const u8) Ctx { if (!enable) return .{}; const global = struct { diff --git a/test/cases/compile_errors/invalid_member_of_builtin_enum.zig b/test/cases/compile_errors/invalid_member_of_builtin_enum.zig @@ -1,10 +1,10 @@ -const builtin = @import("std").builtin; +const lang = @import("std").lang; export fn entry() void { - const foo = builtin.OptimizeMode.x86; + const foo = lang.OptimizeMode.x86; _ = foo; } // error // -// :3:38: error: enum 'builtin.OptimizeMode' has no member named 'x86' +// :3:35: error: enum 'lang.OptimizeMode' has no member named 'x86' // : note: enum declared here diff --git a/test/cases/compile_errors/issue_15572_break_on_inline_while.zig b/test/cases/compile_errors/issue_15572_break_on_inline_while.zig @@ -16,4 +16,4 @@ pub fn main() void { // error // target=x86_64-linux // -// :9:28: error: incompatible types: 'builtin.Type.EnumField' and 'void' +// :9:28: error: incompatible types: 'lang.Type.EnumField' and 'void' diff --git a/test/cases/compile_errors/runtime_index_into_comptime_type_slice.zig b/test/cases/compile_errors/runtime_index_into_comptime_type_slice.zig @@ -12,6 +12,6 @@ export fn entry() void { // error // -// :9:54: error: values of type 'builtin.Type.StructField' must be comptime-known, but index value is runtime-known +// :9:54: error: values of type 'lang.Type.StructField' must be comptime-known, but index value is runtime-known // : note: struct requires comptime because of this field // : note: types are not available at runtime diff --git a/test/cases/compile_errors/wrong_type_for_reify_type.zig b/test/cases/compile_errors/wrong_type_for_reify_type.zig @@ -16,10 +16,10 @@ export fn entryU() void { // error // -// :2:14: error: expected type 'builtin.Signedness', found 'comptime_int' +// :2:14: error: expected type 'lang.Signedness', found 'comptime_int' // :?:?: note: enum declared here // :6:15: error: expected type 'type', found 'comptime_int' -// :10:17: error: expected type 'builtin.Type.ContainerLayout', found 'comptime_int' +// :10:17: error: expected type 'lang.Type.ContainerLayout', found 'comptime_int' // :?:?: enum declared here -// :14:16: error: expected type 'builtin.Type.ContainerLayout', found 'comptime_int' +// :14:16: error: expected type 'lang.Type.ContainerLayout', found 'comptime_int' // :?:?: enum declared here diff --git a/test/cases/compile_errors/wrong_types_given_to_atomic_order_args_in_cmpxchg.zig b/test/cases/compile_errors/wrong_types_given_to_atomic_order_args_in_cmpxchg.zig @@ -5,5 +5,5 @@ export fn entry() void { // error // -// :3:47: error: expected type 'builtin.AtomicOrder', found 'u32' +// :3:47: error: expected type 'lang.AtomicOrder', found 'u32' // :?:?: note: enum declared here diff --git a/test/cases/compile_errors/wrong_types_given_to_export.zig b/test/cases/compile_errors/wrong_types_given_to_export.zig @@ -5,5 +5,5 @@ comptime { // error // -// :3:42: error: expected type 'builtin.GlobalLinkage', found 'u32' +// :3:42: error: expected type 'lang.GlobalLinkage', found 'u32' // :?:?: note: enum declared here