Commit 4c330e053ba45f383a7642da53482dfbce1b50cf | zig

build.zig+9-10

...	...	@@ -1,5 +1,4 @@
1	1	const std = @import("std");
2		const builtin = std.builtin;
3	2	const BufMap = std.BufMap;
4	3	const mem = std.mem;
5	4	const fs = std.fs;
...	...	@@ -398,22 +397,22 @@ pub fn build(b: *std.Build) !void {
398	397	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{};
399	398	const test_extra_targets = b.option(bool, "test-extra-targets", "Enable running module tests for additional targets") orelse false;
400	399
401		var chosen_opt_modes_buf: [4]builtin.OptimizeMode = undefined;
	400	var chosen_opt_modes_buf: [4]std.lang.OptimizeMode = undefined;
402	401	var chosen_mode_index: usize = 0;
403	402	if (!skip_debug) {
404		chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.Debug;
	403	chosen_opt_modes_buf[chosen_mode_index] = .Debug;
405	404	chosen_mode_index += 1;
406	405	}
407	406	if (!skip_release_safe) {
408		chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseSafe;
	407	chosen_opt_modes_buf[chosen_mode_index] = .ReleaseSafe;
409	408	chosen_mode_index += 1;
410	409	}
411	410	if (!skip_release_fast) {
412		chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseFast;
	411	chosen_opt_modes_buf[chosen_mode_index] = .ReleaseFast;
413	412	chosen_mode_index += 1;
414	413	}
415	414	if (!skip_release_small) {
416		chosen_opt_modes_buf[chosen_mode_index] = builtin.OptimizeMode.ReleaseSmall;
	415	chosen_opt_modes_buf[chosen_mode_index] = .ReleaseSmall;
417	416	chosen_mode_index += 1;
418	417	}
419	418	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 {
706	705	//
707	706	// * We lose a small amount of performance. This is essentially irrelevant for zig1.
708	707	//
709		// * We lose the ability to perform trivial renames on certain `std.builtin` types without
	708	// * We lose the ability to perform trivial renames on certain `std.lang` types without
710	709	// zig1.wasm updates. For instance, we cannot rename an enum from PascalCase fields to
711	710	// snake_case fields without an update.
712	711	//
713		// * We gain the ability to add and remove fields to and from `std.builtin` types without
	712	// * We gain the ability to add and remove fields to and from `std.lang` types without
714	713	// zig1.wasm updates. For instance, we can add a new tag to `CallingConvention` without
715	714	// an update.
716	715	//
...	...	@@ -740,7 +739,7 @@ fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
740	739	}
741	740
742	741	const AddCompilerModOptions = struct {
743		optimize: std.builtin.OptimizeMode,
	742	optimize: std.lang.OptimizeMode,
744	743	target: std.Build.ResolvedTarget,
745	744	strip: ?bool = null,
746	745	valgrind: ?bool = null,
...	...	@@ -1029,7 +1028,7 @@ fn addCMakeLibraryList(mod: *std.Build.Module, list: []const u8) void {
1029	1028	}
1030	1029
1031	1030	const CMakeConfig = struct {
1032		llvm_linkage: std.builtin.LinkMode,
	1031	llvm_linkage: std.lang.LinkMode,
1033	1032	cmake_binary_dir: []const u8,
1034	1033	cmake_prefix_path: []const u8,
1035	1034	cmake_static_library_prefix: []const u8,

lib/std/zig/Ast.zig+2-2

...	...	@@ -2103,7 +2103,7 @@ fn fullFnProtoComponents(tree: Ast, info: full.FnProto.Components) full.FnProto
2103	2103	}
2104	2104
2105	2105	fn fullPtrTypeComponents(tree: Ast, info: full.PtrType.Components) full.PtrType {
2106		const size: std.builtin.Type.Pointer.Size = switch (tree.tokenTag(info.main_token)) {
	2106	const size: std.lang.Type.Pointer.Size = switch (tree.tokenTag(info.main_token)) {
2107	2107	.asterisk => .one,
2108	2108	.l_bracket => switch (tree.tokenTag(info.main_token + 1)) {
2109	2109	.asterisk => if (tree.tokenTag(info.main_token + 2) == .identifier) .c else .many,
...	...	@@ -2726,7 +2726,7 @@ pub const full = struct {
2726	2726	};
2727	2727
2728	2728	pub const PtrType = struct {
2729		size: std.builtin.Type.Pointer.Size,
	2729	size: std.lang.Type.Pointer.Size,
2730	2730	allowzero_token: ?TokenIndex,
2731	2731	const_token: ?TokenIndex,
2732	2732	volatile_token: ?TokenIndex,

lib/std/zig/AstGen.zig+8-8

...	...	@@ -4815,7 +4815,7 @@ fn structDeclInner(
4815	4815	scope: *Scope,
4816	4816	node: Ast.Node.Index,
4817	4817	container_decl: Ast.full.ContainerDecl,
4818		layout: std.builtin.Type.ContainerLayout,
	4818	layout: std.lang.Type.ContainerLayout,
4819	4819	maybe_backing_int_node: Ast.Node.OptionalIndex,
4820	4820	name_strat: Zir.Inst.NameStrategy,
4821	4821	) InnerError!Zir.Inst.Ref {
...	...	@@ -5020,7 +5020,7 @@ fn tupleDecl(
5020	5020	scope: *Scope,
5021	5021	node: Ast.Node.Index,
5022	5022	container_decl: Ast.full.ContainerDecl,
5023		layout: std.builtin.Type.ContainerLayout,
	5023	layout: std.lang.Type.ContainerLayout,
5024	5024	backing_int_node: Ast.Node.OptionalIndex,
5025	5025	) InnerError!Zir.Inst.Ref {
5026	5026	const astgen = gz.astgen;
...	...	@@ -5117,7 +5117,7 @@ fn unionDeclInner(
5117	5117	scope: *Scope,
5118	5118	node: Ast.Node.Index,
5119	5119	members: []const Ast.Node.Index,
5120		layout: std.builtin.Type.ContainerLayout,
	5120	layout: std.lang.Type.ContainerLayout,
5121	5121	opt_arg_node: Ast.Node.OptionalIndex,
5122	5122	auto_enum_tok: ?Ast.TokenIndex,
5123	5123	name_strat: Zir.Inst.NameStrategy,
...	...	@@ -5324,7 +5324,7 @@ fn containerDecl(
5324	5324
5325	5325	switch (tree.tokenTag(container_decl.ast.main_token)) {
5326	5326	.keyword_struct => {
5327		const layout: std.builtin.Type.ContainerLayout = if (container_decl.layout_token) \|t\| switch (tree.tokenTag(t)) {
	5327	const layout: std.lang.Type.ContainerLayout = if (container_decl.layout_token) \|t\| switch (tree.tokenTag(t)) {
5328	5328	.keyword_packed => .@"packed",
5329	5329	.keyword_extern => .@"extern",
5330	5330	else => unreachable,
...	...	@@ -5334,7 +5334,7 @@ fn containerDecl(
5334	5334	return rvalue(gz, ri, result, node);
5335	5335	},
5336	5336	.keyword_union => {
5337		const layout: std.builtin.Type.ContainerLayout = if (container_decl.layout_token) \|t\| switch (tree.tokenTag(t)) {
	5337	const layout: std.lang.Type.ContainerLayout = if (container_decl.layout_token) \|t\| switch (tree.tokenTag(t)) {
5338	5338	.keyword_packed => .@"packed",
5339	5339	.keyword_extern => .@"extern",
5340	5340	else => unreachable,
...	...	@@ -8060,7 +8060,7 @@ fn identifier(
8060	8060
8061	8061	int_type: {
8062	8062	if (ident_name_raw.len < 2) break :int_type;
8063		const signedness: std.builtin.Signedness = switch (ident_name_raw[0]) {
	8063	const signedness: std.lang.Signedness = switch (ident_name_raw[0]) {
8064	8064	'u' => .unsigned,
8065	8065	'i' => .signed,
8066	8066	else => break :int_type,
...	...	@@ -9925,7 +9925,7 @@ fn callExpr(
9925	9925	const astgen = gz.astgen;
9926	9926
9927	9927	const callee = try calleeExpr(gz, scope, ri.rl, override_decl_literal_type, call.ast.fn_expr);
9928		const modifier: std.builtin.CallModifier = blk: {
	9928	const modifier: std.lang.CallModifier = blk: {
9929	9929	if (gz.nosuspend_node != .none) {
9930	9930	break :blk .no_suspend;
9931	9931	}
...	...	@@ -12350,7 +12350,7 @@ const GenZir = struct {
12350	12350	fn setStruct(gz: *GenZir, inst: Zir.Inst.Index, args: struct {
12351	12351	src_node: Ast.Node.Index,
12352	12352	name_strat: Zir.Inst.NameStrategy,
12353		layout: std.builtin.Type.ContainerLayout,
	12353	layout: std.lang.Type.ContainerLayout,
12354	12354	backing_int_type_body_len: ?u32,
12355	12355	decls_len: u32,
12356	12356	fields_len: u32,

lib/std/zig/LibCInstallation.zig+2-2

...	...	@@ -703,8 +703,8 @@ pub const CrtBasenames = struct {
703	703	pub const GetArgs = struct {
704	704	target: *const std.Target,
705	705	link_libc: bool,
706		output_mode: std.builtin.OutputMode,
707		link_mode: std.builtin.LinkMode,
	706	output_mode: std.lang.OutputMode,
	707	link_mode: std.lang.LinkMode,
708	708	pie: bool,
709	709	};
710	710

lib/std/zig/Zir.zig+10-10

...	...	@@ -2418,7 +2418,7 @@ pub const Inst = struct {
2418	2418	has_bit_range: bool,
2419	2419	_: u1 = 0,
2420	2420	},
2421		size: std.builtin.Type.Pointer.Size,
	2421	size: std.lang.Type.Pointer.Size,
2422	2422	/// Index into extra. See `PtrType`.
2423	2423	payload_index: u32,
2424	2424	},
...	...	@@ -2426,7 +2426,7 @@ pub const Inst = struct {
2426	2426	/// Offset from Decl AST node index.
2427	2427	/// `Tag` determines which kind of AST node this points to.
2428	2428	src_node: Ast.Node.Offset,
2429		signedness: std.builtin.Signedness,
	2429	signedness: std.lang.Signedness,
2430	2430	bit_count: u16,
2431	2431	},
2432	2432	@"unreachable": struct {
...	...	@@ -3051,7 +3051,7 @@ pub const Inst = struct {
3051	3051	callee: Ref,
3052	3052
3053	3053	pub const Flags = packed struct {
3054		/// std.builtin.CallModifier in packed form
	3054	/// std.lang.CallModifier in packed form
3055	3055	pub const PackedModifier = u3;
3056	3056	pub const PackedArgsLen = u27;
3057	3057
...	...	@@ -3063,7 +3063,7 @@ pub const Inst = struct {
3063	3063	comptime {
3064	3064	if (@sizeOf(Flags) != 4 or @bitSizeOf(Flags) != 32)
3065	3065	@compileError("Layout of Call.Flags needs to be updated!");
3066		if (@bitSizeOf(std.builtin.CallModifier) != @bitSizeOf(PackedModifier))
	3066	if (@bitSizeOf(std.lang.CallModifier) != @bitSizeOf(PackedModifier))
3067	3067	@compileError("Call.Flags.PackedModifier needs to be updated!");
3068	3068	}
3069	3069	};
...	...	@@ -3186,7 +3186,7 @@ pub const Inst = struct {
3186	3186
3187	3187	pub const ReifySliceArgInfo = enum(u16) {
3188	3188	/// Input element type is `type`.
3189		/// Output element type is `std.builtin.Type.Fn.Param.Attributes`.
	3189	/// Output element type is `std.lang.Type.Fn.Param.Attributes`.
3190	3190	type_to_fn_param_attrs,
3191	3191	/// Input element type is `[]const u8`.
3192	3192	/// Output element type is `type`.
...	...	@@ -3194,10 +3194,10 @@ pub const Inst = struct {
3194	3194	/// Identical to `string_to_struct_field_type` aside from emitting slightly different error messages.
3195	3195	string_to_union_field_type,
3196	3196	/// Input element type is `[]const u8`.
3197		/// Output element type is `std.builtin.Type.StructField.Attributes`.
	3197	/// Output element type is `std.lang.Type.StructField.Attributes`.
3198	3198	string_to_struct_field_attrs,
3199	3199	/// Input element type is `[]const u8`.
3200		/// Output element type is `std.builtin.Type.UnionField.Attributes`.
	3200	/// Output element type is `std.lang.Type.UnionField.Attributes`.
3201	3201	string_to_union_field_attrs,
3202	3202	};
3203	3203
...	...	@@ -3468,7 +3468,7 @@ pub const Inst = struct {
3468	3468	has_decls_len: bool,
3469	3469	has_fields_len: bool,
3470	3470	name_strategy: NameStrategy,
3471		layout: std.builtin.Type.ContainerLayout,
	3471	layout: std.lang.Type.ContainerLayout,
3472	3472	/// Always `false` if `layout != .@"packed"`.
3473	3473	has_backing_int_type: bool,
3474	3474	any_field_aligns: bool,
...	...	@@ -3688,7 +3688,7 @@ pub const Inst = struct {
3688	3688	};
3689	3689	}
3690	3690
3691		pub fn layout(k: Kind) std.builtin.Type.ContainerLayout {
	3691	pub fn layout(k: Kind) std.lang.Type.ContainerLayout {
3692	3692	return switch (k) {
3693	3693	.auto, .tagged_explicit, .tagged_enum, .tagged_enum_explicit => .auto,
3694	3694	.@"extern" => .@"extern",
...	...	@@ -5286,7 +5286,7 @@ pub const UnwrappedStructDecl = struct {
5286	5286
5287	5287	decls: []const Inst.Index,
5288	5288
5289		layout: std.builtin.Type.ContainerLayout,
	5289	layout: std.lang.Type.ContainerLayout,
5290	5290	backing_int_type_body: ?[]const Inst.Index,
5291	5291
5292	5292	field_names: []const NullTerminatedString,

lib/std/zig/llvm/Builder.zig+1-1

...	...	@@ -1830,7 +1830,7 @@ pub const Visibility = enum(u2) {
1830	1830	hidden = 1,
1831	1831	protected = 2,
1832	1832
1833		pub fn fromSymbolVisibility(sv: std.builtin.SymbolVisibility) Visibility {
	1833	pub fn fromSymbolVisibility(sv: std.lang.SymbolVisibility) Visibility {
1834	1834	return switch (sv) {
1835	1835	.default => .default,
1836	1836	.hidden => .hidden,

src/Air.zig+14-14

...	...	@@ -1260,17 +1260,17 @@ pub const Inst = struct {
1260	1260	},
1261	1261	atomic_load: struct {
1262	1262	ptr: Ref,
1263		order: std.builtin.AtomicOrder,
	1263	order: std.lang.AtomicOrder,
1264	1264	},
1265	1265	prefetch: struct {
1266	1266	ptr: Ref,
1267		rw: std.builtin.PrefetchOptions.Rw,
	1267	rw: std.lang.PrefetchOptions.Rw,
1268	1268	locality: u2,
1269		cache: std.builtin.PrefetchOptions.Cache,
	1269	cache: std.lang.PrefetchOptions.Cache,
1270	1270	},
1271	1271	reduce: struct {
1272	1272	operand: Ref,
1273		operation: std.builtin.ReduceOp,
	1273	operation: std.lang.ReduceOp,
1274	1274	},
1275	1275	ty_nav: struct {
1276	1276	ty: InternPool.Index,
...	...	@@ -1332,8 +1332,8 @@ pub const CondBr = struct {
1332	1332	else_body_len: u32,
1333	1333	branch_hints: BranchHints,
1334	1334	pub const BranchHints = packed struct(u32) {
1335		true: std.builtin.BranchHint = .none,
1336		false: std.builtin.BranchHint = .none,
	1335	true: std.lang.BranchHint = .none,
	1336	false: std.lang.BranchHint = .none,
1337	1337	then_cov: CoveragePoint = .none,
1338	1338	else_cov: CoveragePoint = .none,
1339	1339	_: u24 = 0,
...	...	@@ -1499,11 +1499,11 @@ pub const Cmpxchg = struct {
1499	1499	/// 0b00000000000000000000000000XXX000 - failure_order
1500	1500	flags: u32,
1501	1501
1502		pub fn successOrder(self: Cmpxchg) std.builtin.AtomicOrder {
	1502	pub fn successOrder(self: Cmpxchg) std.lang.AtomicOrder {
1503	1503	return @enumFromInt(@as(u3, @truncate(self.flags)));
1504	1504	}
1505	1505
1506		pub fn failureOrder(self: Cmpxchg) std.builtin.AtomicOrder {
	1506	pub fn failureOrder(self: Cmpxchg) std.lang.AtomicOrder {
1507	1507	return @enumFromInt(@as(u3, @intCast(self.flags >> 3)));
1508	1508	}
1509	1509	};
...	...	@@ -1514,11 +1514,11 @@ pub const AtomicRmw = struct {
1514	1514	/// 0b0000000000000000000000000XXXX000 - op
1515	1515	flags: u32,
1516	1516
1517		pub fn ordering(self: AtomicRmw) std.builtin.AtomicOrder {
	1517	pub fn ordering(self: AtomicRmw) std.lang.AtomicOrder {
1518	1518	return @enumFromInt(@as(u3, @truncate(self.flags)));
1519	1519	}
1520	1520
1521		pub fn op(self: AtomicRmw) std.builtin.AtomicRmwOp {
	1521	pub fn op(self: AtomicRmw) std.lang.AtomicRmwOp {
1522	1522	return @enumFromInt(@as(u4, @intCast(self.flags >> 3)));
1523	1523	}
1524	1524	};
...	...	@@ -2077,14 +2077,14 @@ pub const UnwrappedSwitch = struct {
2077	2077	cases_start: u32,
2078	2078
2079	2079	/// Asserts that `case_idx < us.cases_len`.
2080		pub fn getHint(us: UnwrappedSwitch, case_idx: u32) std.builtin.BranchHint {
	2080	pub fn getHint(us: UnwrappedSwitch, case_idx: u32) std.lang.BranchHint {
2081	2081	assert(case_idx < us.cases_len);
2082	2082	return us.getHintInner(case_idx);
2083	2083	}
2084		pub fn getElseHint(us: UnwrappedSwitch) std.builtin.BranchHint {
	2084	pub fn getElseHint(us: UnwrappedSwitch) std.lang.BranchHint {
2085	2085	return us.getHintInner(us.cases_len);
2086	2086	}
2087		fn getHintInner(us: UnwrappedSwitch, idx: u32) std.builtin.BranchHint {
	2087	fn getHintInner(us: UnwrappedSwitch, idx: u32) std.lang.BranchHint {
2088	2088	const bag = us.air.extra.items[us.branch_hints_start..][idx / 10];
2089	2089	const bits: u3 = @truncate(bag >> @intCast(3 * (idx % 10)));
2090	2090	return @enumFromInt(bits);
...	...	@@ -2630,7 +2630,7 @@ pub const CompilerRtFunc = enum(u32) {
2630	2630	};
2631	2631	}
2632	2632
2633		pub fn @"callconv"(f: CompilerRtFunc, target: *const std.Target) std.builtin.CallingConvention {
	2633	pub fn @"callconv"(f: CompilerRtFunc, target: *const std.Target) std.lang.CallingConvention {
2634	2634	const use_gnu_f16_abi = switch (target.cpu.arch) {
2635	2635	.wasm32,
2636	2636	.wasm64,

src/Air/print.zig+1-1

...	...	@@ -625,7 +625,7 @@ const Writer = struct {
625	625	w: *Writer,
626	626	s: *std.Io.Writer,
627	627	inst: Air.Inst.Index,
628		order: std.builtin.AtomicOrder,
	628	order: std.lang.AtomicOrder,
629	629	) Error!void {
630	630	const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
631	631	try w.writeOperand(s, inst, 0, bin_op.lhs);

src/Builtin.zig+7-7

...	...	@@ -1,13 +1,13 @@
1	1	target: std.Target,
2		zig_backend: std.builtin.CompilerBackend,
3		output_mode: std.builtin.OutputMode,
4		link_mode: std.builtin.LinkMode,
5		unwind_tables: std.builtin.UnwindTables,
	2	zig_backend: std.lang.CompilerBackend,
	3	output_mode: std.lang.OutputMode,
	4	link_mode: std.lang.LinkMode,
	5	unwind_tables: std.lang.UnwindTables,
6	6	is_test: bool,
7	7	single_threaded: bool,
8	8	link_libc: bool,
9	9	link_libcpp: bool,
10		optimize_mode: std.builtin.OptimizeMode,
	10	optimize_mode: std.lang.OptimizeMode,
11	11	error_tracing: bool,
12	12	valgrind: bool,
13	13	sanitize_thread: bool,
...	...	@@ -15,9 +15,9 @@ fuzz: bool,
15	15	pic: bool,
16	16	pie: bool,
17	17	strip: bool,
18		code_model: std.builtin.CodeModel,
	18	code_model: std.lang.CodeModel,
19	19	omit_frame_pointer: bool,
20		wasi_exec_model: std.builtin.WasiExecModel,
	20	wasi_exec_model: std.lang.WasiExecModel,
21	21
22	22	/// Compute an abstract hash representing this `Builtin`. This is not a hash
23	23	/// of the resulting file contents.

src/Compilation.zig+12-12

...	...	@@ -177,7 +177,7 @@ verbose_link: bool,
177	177	link_depfile: ?[]const u8,
178	178	disable_c_depfile: bool,
179	179	stack_report: bool,
180		debug_compiler_runtime_libs: ?std.builtin.OptimizeMode,
	180	debug_compiler_runtime_libs: ?std.lang.OptimizeMode,
181	181	debug_compile_errors: bool,
182	182	/// Do not check this field directly. Instead, use the `debugIncremental` wrapper function.
183	183	debug_incremental: bool,
...	...	@@ -1676,7 +1676,7 @@ pub const CreateOptions = struct {
1676	1676	verbose_llvm_bc: ?[]const u8 = null,
1677	1677	link_depfile: ?[]const u8 = null,
1678	1678	verbose_llvm_cpu_features: bool = false,
1679		debug_compiler_runtime_libs: ?std.builtin.OptimizeMode = null,
	1679	debug_compiler_runtime_libs: ?std.lang.OptimizeMode = null,
1680	1680	debug_compile_errors: bool = false,
1681	1681	debug_incremental: bool = false,
1682	1682	/// Normally when you create a `Compilation`, Zig will automatically build
...	...	@@ -4928,8 +4928,8 @@ fn workerDocsWasmFallible(comp: *Compilation, prog_node: std.Progress.Node) SubU
4928	4928	defer arena_allocator.deinit();
4929	4929	const arena = arena_allocator.allocator();
4930	4930
4931		const optimize_mode = std.builtin.OptimizeMode.ReleaseSmall;
4932		const output_mode = std.builtin.OutputMode.Exe;
	4931	const optimize_mode = std.lang.OptimizeMode.ReleaseSmall;
	4932	const output_mode = std.lang.OutputMode.Exe;
4933	4933	const resolved_target: Package.Module.ResolvedTarget = .{
4934	4934	.result = std.zig.system.resolveTargetQuery(io, .{
4935	4935	.cpu_arch = .wasm32,
...	...	@@ -5285,8 +5285,8 @@ fn buildRt(
5285	5285	comp: *Compilation,
5286	5286	root_source_name: []const u8,
5287	5287	root_name: []const u8,
5288		output_mode: std.builtin.OutputMode,
5289		link_mode: std.builtin.LinkMode,
	5288	output_mode: std.lang.OutputMode,
	5289	link_mode: std.lang.LinkMode,
5290	5290	misc_task: MiscTask,
5291	5291	prog_node: std.Progress.Node,
5292	5292	options: RtOptions,
...	...	@@ -7260,7 +7260,7 @@ fn dumpArgvWriter(w: *Io.Writer, argv: []const []const u8) Io.Writer.Error!void
7260	7260	try w.writeByte('\n');
7261	7261	}
7262	7262
7263		pub fn getZigBackend(comp: Compilation) std.builtin.CompilerBackend {
	7263	pub fn getZigBackend(comp: Compilation) std.lang.CompilerBackend {
7264	7264	const target = &comp.root_mod.resolved_target.result;
7265	7265	return target_util.zigBackend(target, comp.config.use_llvm);
7266	7266	}
...	...	@@ -7302,8 +7302,8 @@ fn buildOutputFromZig(
7302	7302	comp: *Compilation,
7303	7303	src_basename: []const u8,
7304	7304	root_name: []const u8,
7305		output_mode: std.builtin.OutputMode,
7306		link_mode: std.builtin.LinkMode,
	7305	output_mode: std.lang.OutputMode,
	7306	link_mode: std.lang.LinkMode,
7307	7307	misc_task_tag: MiscTask,
7308	7308	prog_node: std.Progress.Node,
7309	7309	options: RtOptions,
...	...	@@ -7433,7 +7433,7 @@ pub const CrtFileOptions = struct {
7433	7433	function_sections: bool = true,
7434	7434	data_sections: bool = true,
7435	7435	omit_frame_pointer: ?bool = null,
7436		unwind_tables: ?std.builtin.UnwindTables = null,
	7436	unwind_tables: ?std.lang.UnwindTables = null,
7437	7437	pic: ?bool = null,
7438	7438	no_builtin: ?bool = null,
7439	7439
...	...	@@ -7443,7 +7443,7 @@ pub const CrtFileOptions = struct {
7443	7443	pub fn build_crt_file(
7444	7444	comp: *Compilation,
7445	7445	root_name: []const u8,
7446		output_mode: std.builtin.OutputMode,
	7446	output_mode: std.lang.OutputMode,
7447	7447	misc_task_tag: MiscTask,
7448	7448	prog_node: std.Progress.Node,
7449	7449	/// 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 {
7657	7657
7658	7658	/// This decides the optimization mode for all zig-provided libraries, including
7659	7659	/// compiler-rt, libcxx, libc, libunwind, etc.
7660		pub fn compilerRtOptMode(comp: Compilation) std.builtin.OptimizeMode {
	7660	pub fn compilerRtOptMode(comp: Compilation) std.lang.OptimizeMode {
7661	7661	if (comp.debug_compiler_runtime_libs) \|mode\| {
7662	7662	return mode;
7663	7663	}

src/Compilation/Config.zig+8-8

...	...	@@ -4,8 +4,8 @@
4	4	//! order to resolve per-Module defaults.
5	5
6	6	have_zcu: bool,
7		output_mode: std.builtin.OutputMode,
8		link_mode: std.builtin.LinkMode,
	7	output_mode: std.lang.OutputMode,
	8	link_mode: std.lang.LinkMode,
9	9	link_libc: bool,
10	10	link_libcpp: bool,
11	11	link_libunwind: bool,
...	...	@@ -53,13 +53,13 @@ lto: std.zig.LtoMode,
53	53	incremental: bool,
54	54	/// WASI-only. Type of WASI execution model ("command" or "reactor").
55	55	/// Always set to `command` for non-WASI targets.
56		wasi_exec_model: std.builtin.WasiExecModel,
	56	wasi_exec_model: std.lang.WasiExecModel,
57	57	import_memory: bool,
58	58	export_memory: bool,
59	59	shared_memory: bool,
60	60	is_test: bool,
61	61	debug_format: DebugFormat,
62		root_optimize_mode: std.builtin.OptimizeMode,
	62	root_optimize_mode: std.lang.OptimizeMode,
63	63	root_strip: bool,
64	64	root_error_tracing: bool,
65	65	dll_export_fns: bool,
...	...	@@ -75,15 +75,15 @@ pub const DebugFormat = union(enum) {
75	75	};
76	76
77	77	pub const Options = struct {
78		output_mode: std.builtin.OutputMode,
	78	output_mode: std.lang.OutputMode,
79	79	resolved_target: Module.ResolvedTarget,
80	80	is_test: bool,
81	81	have_zcu: bool,
82	82	emit_bin: bool,
83		root_optimize_mode: ?std.builtin.OptimizeMode = null,
	83	root_optimize_mode: ?std.lang.OptimizeMode = null,
84	84	root_strip: ?bool = null,
85	85	root_error_tracing: ?bool = null,
86		link_mode: ?std.builtin.LinkMode = null,
	86	link_mode: ?std.lang.LinkMode = null,
87	87	ensure_libc_on_non_freestanding: bool = false,
88	88	ensure_libcpp_on_non_freestanding: bool = false,
89	89	any_non_single_threaded: bool = false,
...	...	@@ -109,7 +109,7 @@ pub const Options = struct {
109	109	lto: ?std.zig.LtoMode = null,
110	110	incremental: bool = false,
111	111	/// WASI-only. Type of WASI execution model ("command" or "reactor").
112		wasi_exec_model: ?std.builtin.WasiExecModel = null,
	112	wasi_exec_model: ?std.lang.WasiExecModel = null,
113	113	import_memory: ?bool = null,
114	114	export_memory: ?bool = null,
115	115	shared_memory: ?bool = null,

src/InternPool.zig+51-51

...	...	@@ -566,7 +566,7 @@ pub const Nav = struct {
566	566	type: InternPool.Index,
567	567	@"align": Alignment,
568	568	@"linksection": OptionalNullTerminatedString,
569		@"addrspace": std.builtin.AddressSpace,
	569	@"addrspace": std.lang.AddressSpace,
570	570	@"const": bool,
571	571	@"threadlocal": bool,
572	572	/// This field is whether this `Nav` is a literal `extern` definition.
...	...	@@ -678,7 +678,7 @@ pub const Nav = struct {
678	678
679	679	const Bits = packed struct(u16) {
680	680	@"align": Alignment,
681		@"addrspace": std.builtin.AddressSpace,
	681	@"addrspace": std.lang.AddressSpace,
682	682	@"const": bool,
683	683	@"threadlocal": bool,
684	684	is_extern_decl: bool,
...	...	@@ -1084,7 +1084,7 @@ const Local = struct {
1084	1084	}
1085	1085	}
1086	1086	fn PtrElem(comptime opts: struct {
1087		size: std.builtin.Type.Pointer.Size,
	1087	size: std.lang.Type.Pointer.Size,
1088	1088	is_const: bool = false,
1089	1089	}) type {
1090	1090	const elem_info = @typeInfo(Elem).@"struct";
...	...	@@ -2029,7 +2029,7 @@ pub const Key = union(enum) {
2029	2029	val: Index,
2030	2030	};
2031	2031
2032		pub const IntType = std.builtin.Type.Int;
	2032	pub const IntType = std.lang.Type.Int;
2033	2033
2034	2034	/// Extern for hashing via memory reinterpretation.
2035	2035	pub const ErrorUnionType = extern struct {
...	...	@@ -2090,8 +2090,8 @@ pub const Key = union(enum) {
2090	2090	bit_offset: u16,
2091	2091	};
2092	2092
2093		pub const Size = std.builtin.Type.Pointer.Size;
2094		pub const AddressSpace = std.builtin.AddressSpace;
	2093	pub const Size = std.lang.Type.Pointer.Size;
	2094	pub const AddressSpace = std.lang.AddressSpace;
2095	2095	};
2096	2096
2097	2097	/// Extern so that hashing can be done via memory reinterpreting.
...	...	@@ -2160,7 +2160,7 @@ pub const Key = union(enum) {
2160	2160	/// Tells whether a parameter is noalias. See `paramIsNoalias` helper
2161	2161	/// method for accessing this.
2162	2162	noalias_bits: u32,
2163		cc: std.builtin.CallingConvention,
	2163	cc: std.lang.CallingConvention,
2164	2164	is_var_args: bool,
2165	2165	is_noinline: bool,
2166	2166
...	...	@@ -2207,15 +2207,15 @@ pub const Key = union(enum) {
2207	2207	/// For example `extern "c" fn write(...) usize` would have 'c' as library name.
2208	2208	/// Index into the string table bytes.
2209	2209	lib_name: OptionalNullTerminatedString,
2210		linkage: std.builtin.GlobalLinkage,
2211		visibility: std.builtin.SymbolVisibility,
	2210	linkage: std.lang.GlobalLinkage,
	2211	visibility: std.lang.SymbolVisibility,
2212	2212	is_threadlocal: bool,
2213	2213	is_dll_import: bool,
2214		relocation: std.builtin.ExternOptions.Relocation,
2215		decoration: ?std.builtin.ExternOptions.Decoration,
	2214	relocation: std.lang.ExternOptions.Relocation,
	2215	decoration: ?std.lang.ExternOptions.Decoration,
2216	2216	is_const: bool,
2217	2217	alignment: Alignment,
2218		@"addrspace": std.builtin.AddressSpace,
	2218	@"addrspace": std.lang.AddressSpace,
2219	2219	/// The ZIR instruction which created this extern; used only for source locations.
2220	2220	/// This is a `declaration`.
2221	2221	zir_index: TrackedInst.Index,
...	...	@@ -2289,7 +2289,7 @@ pub const Key = union(enum) {
2289	2289	return @atomicLoad(FuncAnalysis, func.analysisPtr(ip), .unordered);
2290	2290	}
2291	2291
2292		pub fn setBranchHint(func: Func, ip: *InternPool, io: Io, hint: std.builtin.BranchHint) void {
	2292	pub fn setBranchHint(func: Func, ip: *InternPool, io: Io, hint: std.lang.BranchHint) void {
2293	2293	const extra_mutex = &ip.getLocal(func.tid).mutate.extra.mutex;
2294	2294	extra_mutex.lockUncancelable(io);
2295	2295	defer extra_mutex.unlock(io);
...	...	@@ -3186,7 +3186,7 @@ pub const LoadedStructType = struct {
3186	3186	name_nav: Nav.Index.Optional,
3187	3187	namespace: NamespaceIndex,
3188	3188
3189		layout: std.builtin.Type.ContainerLayout,
	3189	layout: std.lang.Type.ContainerLayout,
3190	3190	/// May be `undefined` if `layout != .@"packed"`.
3191	3191	packed_backing_mode: BackingTypeMode,
3192	3192
...	...	@@ -3369,7 +3369,7 @@ pub const LoadedUnionType = struct {
3369	3369	name_nav: Nav.Index.Optional,
3370	3370	namespace: NamespaceIndex,
3371	3371
3372		layout: std.builtin.Type.ContainerLayout,
	3372	layout: std.lang.Type.ContainerLayout,
3373	3373	enum_tag_mode: BackingTypeMode,
3374	3374	/// May be `undefined` if `layout != .@"packed"`.
3375	3375	packed_backing_mode: BackingTypeMode,
...	...	@@ -5368,10 +5368,10 @@ pub const Tag = enum(u8) {
5368	5368	descriptor_binding: u32,
5369	5369
5370	5370	pub const Flags = packed struct(u32) {
5371		linkage: std.builtin.GlobalLinkage,
5372		visibility: std.builtin.SymbolVisibility,
	5371	linkage: std.lang.GlobalLinkage,
	5372	visibility: std.lang.SymbolVisibility,
5373	5373	is_dll_import: bool,
5374		relocation: std.builtin.ExternOptions.Relocation,
	5374	relocation: std.lang.ExternOptions.Relocation,
5375	5375	source: Source,
5376	5376	decoration_type: DecorationType,
5377	5377	_: u23 = 0,
...	...	@@ -5380,13 +5380,13 @@ pub const Tag = enum(u8) {
5380	5380	pub const DecorationType = enum(u2) { none, location, descriptor };
5381	5381	};
5382	5382
5383		pub fn decoration(self: Extern) ?std.builtin.ExternOptions.Decoration {
	5383	pub fn decoration(self: Extern) ?std.lang.ExternOptions.Decoration {
5384	5384	return switch (self.flags.decoration_type) {
5385	5385	.none => null,
5386		.location => std.builtin.ExternOptions.Decoration{
	5386	.location => std.lang.ExternOptions.Decoration{
5387	5387	.location = self.location_or_descriptor_set,
5388	5388	},
5389		.descriptor => std.builtin.ExternOptions.Decoration{ .descriptor = .{ .set = self.location_or_descriptor_set, .binding = self.descriptor_binding } },
	5389	.descriptor => std.lang.ExternOptions.Decoration{ .descriptor = .{ .set = self.location_or_descriptor_set, .binding = self.descriptor_binding } },
5390	5390	};
5391	5391	}
5392	5392	};
...	...	@@ -5711,7 +5711,7 @@ pub const BackingTypeMode = enum(u1) {
5711	5711	/// to be part of the type of the function.
5712	5712	pub const FuncAnalysis = packed struct(u32) {
5713	5713	want_runtime_analysis: bool,
5714		branch_hint: std.builtin.BranchHint,
	5714	branch_hint: std.lang.BranchHint,
5715	5715	is_noinline: bool,
5716	5716	has_error_trace: bool,
5717	5717	/// True if this function has an inferred error set.
...	...	@@ -7980,7 +7980,7 @@ pub fn getDeclaredStructType(
7980	7980	// InternPool, so that it is possible for their backing storage to be "reallocated" as needed
7981	7981	// during type resolution.
7982	7982	fields_len: u32,
7983		layout: std.builtin.Type.ContainerLayout,
	7983	layout: std.lang.Type.ContainerLayout,
7984	7984	any_comptime_fields: bool,
7985	7985	any_field_defaults: bool,
7986	7986	any_field_aligns: bool,
...	...	@@ -8124,7 +8124,7 @@ pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Pe
8124	8124	zir_index: TrackedInst.Index,
8125	8125	type_hash: u64,
8126	8126	fields_len: u32,
8127		layout: std.builtin.Type.ContainerLayout,
	8127	layout: std.lang.Type.ContainerLayout,
8128	8128	any_comptime_fields: bool,
8129	8129	any_field_defaults: bool,
8130	8130	any_field_aligns: bool,
...	...	@@ -8300,7 +8300,7 @@ pub fn getDeclaredUnionType(
8300	8300	// InternPool, so that it is possible for their backing storage to be "reallocated" as needed
8301	8301	// during type resolution.
8302	8302	fields_len: u32,
8303		layout: std.builtin.Type.ContainerLayout,
	8303	layout: std.lang.Type.ContainerLayout,
8304	8304	any_field_aligns: bool,
8305	8305	tag_usage: LoadedUnionType.TagUsage,
8306	8306	enum_tag_mode: BackingTypeMode,
...	...	@@ -8421,7 +8421,7 @@ pub fn getReifiedUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Per
8421	8421	zir_index: TrackedInst.Index,
8422	8422	type_hash: u64,
8423	8423	fields_len: u32,
8424		layout: std.builtin.Type.ContainerLayout,
	8424	layout: std.lang.Type.ContainerLayout,
8425	8425	any_field_aligns: bool,
8426	8426	tag_usage: LoadedUnionType.TagUsage,
8427	8427	/// Explicitly specified enum tag type. `.none` if `tag_usage != .tagged`.
...	...	@@ -8969,7 +8969,7 @@ pub const GetFuncTypeKey = struct {
8969	8969	comptime_bits: u32 = 0,
8970	8970	noalias_bits: u32 = 0,
8971	8971	/// `null` means generic.
8972		cc: ?std.builtin.CallingConvention = .auto,
	8972	cc: ?std.lang.CallingConvention = .auto,
8973	8973	is_var_args: bool = false,
8974	8974	is_noinline: bool = false,
8975	8975	};
...	...	@@ -9117,7 +9117,7 @@ pub const GetFuncDeclKey = struct {
9117	9117	rbrace_line: u32,
9118	9118	lbrace_column: u32,
9119	9119	rbrace_column: u32,
9120		cc: ?std.builtin.CallingConvention,
	9120	cc: ?std.lang.CallingConvention,
9121	9121	is_noinline: bool,
9122	9122	};
9123	9123
...	...	@@ -9193,7 +9193,7 @@ pub const GetFuncDeclIesKey = struct {
9193	9193	comptime_bits: u32,
9194	9194	bare_return_type: Index,
9195	9195	/// null means generic.
9196		cc: ?std.builtin.CallingConvention,
	9196	cc: ?std.lang.CallingConvention,
9197	9197	is_var_args: bool,
9198	9198	is_noinline: bool,
9199	9199	zir_body_inst: TrackedInst.Index,
...	...	@@ -11763,7 +11763,7 @@ pub fn getBackingAddrTag(ip: *const InternPool, val: Index) ?Key.Ptr.BaseAddr.Ta
11763	11763	/// This is a particularly hot function, so we operate directly on encodings
11764	11764	/// rather than the more straightforward implementation of calling `indexToKey`.
11765	11765	/// Asserts `index` is not `.generic_poison_type`.
11766		pub fn zigTypeTag(ip: *const InternPool, index: Index) std.builtin.TypeId {
	11766	pub fn zigTypeTag(ip: *const InternPool, index: Index) std.lang.TypeId {
11767	11767	return switch (index) {
11768	11768	.u0_type,
11769	11769	.u1_type,
...	...	@@ -12407,13 +12407,13 @@ pub fn getErrorValueIfExists(ip: *const InternPool, name: NullTerminatedString)
12407	12407	}
12408	12408
12409	12409	const PackedCallingConvention = packed struct(u18) {
12410		tag: std.builtin.CallingConvention.Tag,
	12410	tag: std.lang.CallingConvention.Tag,
12411	12411	/// May be ignored depending on `tag`.
12412	12412	incoming_stack_alignment: Alignment,
12413	12413	/// Interpretation depends on `tag`.
12414	12414	extra: u4,
12415	12415
12416		fn pack(cc: std.builtin.CallingConvention) PackedCallingConvention {
	12416	fn pack(cc: std.lang.CallingConvention) PackedCallingConvention {
12417	12417	return switch (cc) {
12418	12418	inline else => \|pl, tag\| switch (@TypeOf(pl)) {
12419	12419	void => .{
...	...	@@ -12421,42 +12421,42 @@ const PackedCallingConvention = packed struct(u18) {
12421	12421	.incoming_stack_alignment = .none, // unused
12422	12422	.extra = 0, // unused
12423	12423	},
12424		std.builtin.CallingConvention.CommonOptions => .{
	12424	std.lang.CallingConvention.CommonOptions => .{
12425	12425	.tag = tag,
12426	12426	.incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
12427	12427	.extra = 0, // unused
12428	12428	},
12429		std.builtin.CallingConvention.X86RegparmOptions => .{
	12429	std.lang.CallingConvention.X86RegparmOptions => .{
12430	12430	.tag = tag,
12431	12431	.incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
12432	12432	.extra = pl.register_params,
12433	12433	},
12434		std.builtin.CallingConvention.ArcInterruptOptions => .{
	12434	std.lang.CallingConvention.ArcInterruptOptions => .{
12435	12435	.tag = tag,
12436	12436	.incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
12437	12437	.extra = @intFromEnum(pl.type),
12438	12438	},
12439		std.builtin.CallingConvention.ArmInterruptOptions => .{
	12439	std.lang.CallingConvention.ArmInterruptOptions => .{
12440	12440	.tag = tag,
12441	12441	.incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
12442	12442	.extra = @intFromEnum(pl.type),
12443	12443	},
12444		std.builtin.CallingConvention.MicroblazeInterruptOptions => .{
	12444	std.lang.CallingConvention.MicroblazeInterruptOptions => .{
12445	12445	.tag = tag,
12446	12446	.incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
12447	12447	.extra = @intFromEnum(pl.type),
12448	12448	},
12449		std.builtin.CallingConvention.MipsInterruptOptions => .{
	12449	std.lang.CallingConvention.MipsInterruptOptions => .{
12450	12450	.tag = tag,
12451	12451	.incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
12452	12452	.extra = @intFromEnum(pl.mode),
12453	12453	},
12454		std.builtin.CallingConvention.RiscvInterruptOptions => .{
	12454	std.lang.CallingConvention.RiscvInterruptOptions => .{
12455	12455	.tag = tag,
12456	12456	.incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
12457	12457	.extra = @intFromEnum(pl.mode),
12458	12458	},
12459		std.builtin.CallingConvention.ShInterruptOptions => .{
	12459	std.lang.CallingConvention.ShInterruptOptions => .{
12460	12460	.tag = tag,
12461	12461	.incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
12462	12462	.extra = @intFromEnum(pl.save),
...	...	@@ -12466,41 +12466,41 @@ const PackedCallingConvention = packed struct(u18) {
12466	12466	};
12467	12467	}
12468	12468
12469		fn unpack(cc: PackedCallingConvention) std.builtin.CallingConvention {
	12469	fn unpack(cc: PackedCallingConvention) std.lang.CallingConvention {
12470	12470	return switch (cc.tag) {
12471	12471	inline else => \|tag\| @unionInit(
12472		std.builtin.CallingConvention,
	12472	std.lang.CallingConvention,
12473	12473	@tagName(tag),
12474		switch (@FieldType(std.builtin.CallingConvention, @tagName(tag))) {
	12474	switch (@FieldType(std.lang.CallingConvention, @tagName(tag))) {
12475	12475	void => {},
12476		std.builtin.CallingConvention.CommonOptions => .{
	12476	std.lang.CallingConvention.CommonOptions => .{
12477	12477	.incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
12478	12478	},
12479		std.builtin.CallingConvention.X86RegparmOptions => .{
	12479	std.lang.CallingConvention.X86RegparmOptions => .{
12480	12480	.incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
12481	12481	.register_params = @intCast(cc.extra),
12482	12482	},
12483		std.builtin.CallingConvention.ArcInterruptOptions => .{
	12483	std.lang.CallingConvention.ArcInterruptOptions => .{
12484	12484	.incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
12485	12485	.type = @enumFromInt(cc.extra),
12486	12486	},
12487		std.builtin.CallingConvention.ArmInterruptOptions => .{
	12487	std.lang.CallingConvention.ArmInterruptOptions => .{
12488	12488	.incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
12489	12489	.type = @enumFromInt(cc.extra),
12490	12490	},
12491		std.builtin.CallingConvention.MicroblazeInterruptOptions => .{
	12491	std.lang.CallingConvention.MicroblazeInterruptOptions => .{
12492	12492	.incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
12493	12493	.type = @enumFromInt(cc.extra),
12494	12494	},
12495		std.builtin.CallingConvention.MipsInterruptOptions => .{
	12495	std.lang.CallingConvention.MipsInterruptOptions => .{
12496	12496	.incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
12497	12497	.mode = @enumFromInt(cc.extra),
12498	12498	},
12499		std.builtin.CallingConvention.RiscvInterruptOptions => .{
	12499	std.lang.CallingConvention.RiscvInterruptOptions => .{
12500	12500	.incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
12501	12501	.mode = @enumFromInt(cc.extra),
12502	12502	},
12503		std.builtin.CallingConvention.ShInterruptOptions => .{
	12503	std.lang.CallingConvention.ShInterruptOptions => .{
12504	12504	.incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
12505	12505	.save = @enumFromInt(cc.extra),
12506	12506	},

src/Package/Module.zig+7-7

...	...	@@ -15,8 +15,8 @@ fully_qualified_name: []const u8,
15	15	deps: Deps = .{},
16	16
17	17	resolved_target: ResolvedTarget,
18		optimize_mode: std.builtin.OptimizeMode,
19		code_model: std.builtin.CodeModel,
	18	optimize_mode: std.lang.OptimizeMode,
	19	code_model: std.lang.CodeModel,
20	20	single_threaded: bool,
21	21	error_tracing: bool,
22	22	valgrind: bool,
...	...	@@ -29,7 +29,7 @@ red_zone: bool,
29	29	sanitize_c: std.zig.SanitizeC,
30	30	sanitize_thread: bool,
31	31	fuzz: bool,
32		unwind_tables: std.builtin.UnwindTables,
	32	unwind_tables: std.lang.UnwindTables,
33	33	cc_argv: []const []const u8,
34	34	/// (SPIR-V) whether to generate a structured control flow graph or not
35	35	structured_cfg: bool,
...	...	@@ -61,8 +61,8 @@ pub const CreateOptions = struct {
61	61	pub const Inherited = struct {
62	62	/// If this is null then `parent` must be non-null.
63	63	resolved_target: ?ResolvedTarget = null,
64		optimize_mode: ?std.builtin.OptimizeMode = null,
65		code_model: ?std.builtin.CodeModel = null,
	64	optimize_mode: ?std.lang.OptimizeMode = null,
	65	code_model: ?std.lang.CodeModel = null,
66	66	single_threaded: ?bool = null,
67	67	error_tracing: ?bool = null,
68	68	valgrind: ?bool = null,
...	...	@@ -75,7 +75,7 @@ pub const CreateOptions = struct {
75	75	/// other number means stack protection with that buffer size.
76	76	stack_protector: ?u32 = null,
77	77	red_zone: ?bool = null,
78		unwind_tables: ?std.builtin.UnwindTables = null,
	78	unwind_tables: ?std.lang.UnwindTables = null,
79	79	sanitize_c: ?std.zig.SanitizeC = null,
80	80	sanitize_thread: ?bool = null,
81	81	fuzz: ?bool = null,
...	...	@@ -238,7 +238,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
238	238	break :b false;
239	239	};
240	240
241		const code_model: std.builtin.CodeModel = b: {
	241	const code_model: std.lang.CodeModel = b: {
242	242	if (options.inherited.code_model) \|x\| break :b x;
243	243	if (options.parent) \|p\| break :b p.code_model;
244	244	break :b .default;

src/Sema.zig+111-111

...	...	@@ -135,7 +135,7 @@ allow_memoize: bool = true,
135	135
136	136	/// The `BranchHint` for the current branch of runtime control flow.
137	137	/// This state is on `Sema` so that `cold` hints can be propagated up through blocks with less special handling.
138		branch_hint: ?std.builtin.BranchHint = null,
	138	branch_hint: ?std.lang.BranchHint = null,
139	139
140	140	const RuntimeIndex = enum(u32) {
141	141	zero = 0,
...	...	@@ -383,7 +383,7 @@ pub const Block = struct {
383	383	want_safety: ?bool = null,
384	384
385	385	/// What mode to generate float operations in, set by @setFloatMode
386		float_mode: std.builtin.FloatMode = .strict,
	386	float_mode: std.lang.FloatMode = .strict,
387	387
388	388	/// If not `null`, this boolean is set when a `dbg_var_ptr`, `dbg_var_val`, or `dbg_arg_inline`.
389	389	/// instruction is emitted. It signals that the innermost lexically
...	...	@@ -759,7 +759,7 @@ pub const Block = struct {
759	759	});
760	760	}
761	761
762		fn addReduce(block: *Block, operand: Air.Inst.Ref, operation: std.builtin.ReduceOp) !Air.Inst.Ref {
	762	fn addReduce(block: *Block, operand: Air.Inst.Ref, operation: std.lang.ReduceOp) !Air.Inst.Ref {
763	763	const sema = block.sema;
764	764	const zcu = sema.pt.zcu;
765	765	const allow_optimized = switch (sema.typeOf(operand).childType(zcu).zigTypeTag(zcu)) {
...	...	@@ -1023,7 +1023,7 @@ pub fn deinit(sema: *Sema) void {
1023	1023	/// control flow happens here, Sema will convert it to runtime control flow by introducing post-hoc
1024	1024	/// blocks where necessary.
1025	1025	/// Returns the branch hint for this branch.
1026		fn analyzeBodyRuntimeBreak(sema: Sema, block: Block, body: []const Zir.Inst.Index) !std.builtin.BranchHint {
	1026	fn analyzeBodyRuntimeBreak(sema: Sema, block: Block, body: []const Zir.Inst.Index) !std.lang.BranchHint {
1027	1027	const parent_hint = sema.branch_hint;
1028	1028	defer sema.branch_hint = parent_hint;
1029	1029	sema.branch_hint = null;
...	...	@@ -2804,8 +2804,8 @@ fn analyzeValueAsCallconv(
2804	2804	block: *Block,
2805	2805	src: LazySrcLoc,
2806	2806	val: Value,
2807		) !std.builtin.CallingConvention {
2808		return interpretStdLangType(sema, block, src, val, std.builtin.CallingConvention);
	2807	) !std.lang.CallingConvention {
	2808	return interpretStdLangType(sema, block, src, val, std.lang.CallingConvention);
2809	2809	}
2810	2810
2811	2811	fn interpretStdLangType(
...	...	@@ -6147,7 +6147,7 @@ fn zirCall(
6147	6147	const extra = sema.code.extraData(ExtraType, inst_data.payload_index);
6148	6148	const args_len = extra.data.flags.args_len;
6149	6149
6150		const modifier: std.builtin.CallModifier = @enumFromInt(extra.data.flags.packed_modifier);
	6150	const modifier: std.lang.CallModifier = @enumFromInt(extra.data.flags.packed_modifier);
6151	6151	const ensure_result_used = extra.data.flags.ensure_result_used;
6152	6152	const pop_error_return_trace = extra.data.flags.pop_error_return_trace;
6153	6153
...	...	@@ -6322,7 +6322,7 @@ fn callBuiltin(
6322	6322	block: *Block,
6323	6323	call_src: LazySrcLoc,
6324	6324	builtin_fn: Air.Inst.Ref,
6325		modifier: std.builtin.CallModifier,
	6325	modifier: std.lang.CallModifier,
6326	6326	args: []const Air.Inst.Ref,
6327	6327	operation: CallOperation,
6328	6328	) !void {
...	...	@@ -6543,7 +6543,7 @@ fn analyzeCall(
6543	6543	func_ty: Type,
6544	6544	func_src: LazySrcLoc,
6545	6545	call_src: LazySrcLoc,
6546		modifier: std.builtin.CallModifier,
	6546	modifier: std.lang.CallModifier,
6547	6547	ensure_result_used: bool,
6548	6548	args_info: CallArgsInfo,
6549	6549	call_dbg_node: ?Zir.Inst.Index,
...	...	@@ -8367,7 +8367,7 @@ fn zirFunc(
8367	8367	// If this instruction has a body, then it's a function declaration, and we decide
8368	8368	// the callconv based on whether it is exported. Otherwise, the callconv defaults
8369	8369	// to `.auto`.
8370		const cc: std.builtin.CallingConvention = if (has_body) cc: {
	8370	const cc: std.lang.CallingConvention = if (has_body) cc: {
8371	8371	const func_decl_nav = sema.owner.unwrap().nav_val;
8372	8372	const fn_is_exported = exported: {
8373	8373	const decl_inst = ip.getNav(func_decl_nav).analysis.?.zir_index.resolve(ip) orelse return error.AnalysisFail;
...	...	@@ -8509,7 +8509,7 @@ pub fn handleExternLibName(
8509	8509	/// These are calling conventions that are confirmed to work with variadic functions.
8510	8510	/// Any calling conventions not included here are either not yet verified to work with variadic
8511	8511	/// functions or there are no more other calling conventions that support variadic functions.
8512		const calling_conventions_supporting_var_args = [_]std.builtin.CallingConvention.Tag{
	8512	const calling_conventions_supporting_var_args = [_]std.lang.CallingConvention.Tag{
8513	8513	.x86_16_cdecl,
8514	8514	.x86_64_sysv,
8515	8515	.x86_64_x32,
...	...	@@ -8570,12 +8570,12 @@ const calling_conventions_supporting_var_args = [_]std.builtin.CallingConvention
8570	8570	.xtensa_call0,
8571	8571	.xtensa_windowed,
8572	8572	};
8573		fn callConvSupportsVarArgs(cc: std.builtin.CallingConvention.Tag) bool {
	8573	fn callConvSupportsVarArgs(cc: std.lang.CallingConvention.Tag) bool {
8574	8574	return for (calling_conventions_supporting_var_args) \|supported_cc\| {
8575	8575	if (cc == supported_cc) return true;
8576	8576	} else false;
8577	8577	}
8578		fn checkCallConvSupportsVarArgs(sema: Sema, block: Block, src: LazySrcLoc, cc: std.builtin.CallingConvention.Tag) CompileError!void {
	8578	fn checkCallConvSupportsVarArgs(sema: Sema, block: Block, src: LazySrcLoc, cc: std.lang.CallingConvention.Tag) CompileError!void {
8579	8579	const CallingConventionsSupportingVarArgsList = struct {
8580	8580	arch: std.Target.Cpu.Arch,
8581	8581	pub fn format(ctx: @This(), w: *std.Io.Writer) std.Io.Writer.Error!void {
...	...	@@ -8612,7 +8612,7 @@ fn checkParamType(
8612	8612	param_is_comptime: bool,
8613	8613	param_is_noalias: bool,
8614	8614	param_src: LazySrcLoc,
8615		cc: std.builtin.CallingConvention,
	8615	cc: std.lang.CallingConvention,
8616	8616	) CompileError!void {
8617	8617	const pt = sema.pt;
8618	8618	const zcu = pt.zcu;
...	...	@@ -8668,7 +8668,7 @@ fn checkReturnTypeAndCallConv(
8668	8668	block: *Block,
8669	8669	bare_ret_ty: Type,
8670	8670	ret_ty_src: LazySrcLoc,
8671		@"callconv": std.builtin.CallingConvention,
	8671	@"callconv": std.lang.CallingConvention,
8672	8672	callconv_src: LazySrcLoc,
8673	8673	/// non-`null` only if the function is varargs.
8674	8674	opt_varargs_src: ?LazySrcLoc,
...	...	@@ -8772,7 +8772,7 @@ fn checkReturnTypeAndCallConv(
8772	8772	fn validateResolvedFuncType(
8773	8773	sema: *Sema,
8774	8774	block: *Block,
8775		@"callconv": std.builtin.CallingConvention,
	8775	@"callconv": std.lang.CallingConvention,
8776	8776	param_types: []const InternPool.Index,
8777	8777	ret_ty: Type,
8778	8778	src: LazySrcLoc,
...	...	@@ -8823,7 +8823,7 @@ fn validateResolvedFuncType(
8823	8823	}
8824	8824	}
8825	8825
8826		fn callConvIsCallable(cc: std.builtin.CallingConvention.Tag) bool {
	8826	fn callConvIsCallable(cc: std.lang.CallingConvention.Tag) bool {
8827	8827	return switch (cc) {
8828	8828	.naked,
8829	8829
...	...	@@ -8898,7 +8898,7 @@ fn funcCommon(
8898	8898	block: *Block,
8899	8899	src_node_offset: std.zig.Ast.Node.Offset,
8900	8900	func_inst: Zir.Inst.Index,
8901		cc: std.builtin.CallingConvention,
	8901	cc: std.lang.CallingConvention,
8902	8902	/// this might be Type.generic_poison
8903	8903	bare_return_type: Type,
8904	8904	var_args: bool,
...	...	@@ -9896,7 +9896,7 @@ fn zirSwitchBlockErrUnion(sema: Sema, block: Block, inst: Zir.Inst.Index) Comp
9896	9896	else
9897	9897	try sema.analyzeIsNonErr(block, operand_src, eu_maybe_ptr);
9898	9898
9899		const non_err_hint: std.builtin.BranchHint = hint: {
	9899	const non_err_hint: std.lang.BranchHint = hint: {
9900	9900	// don't analyze the non-error body if it's unreachable
9901	9901	if (non_err_cond == .bool_false) {
9902	9902	break :hint undefined;
...	...	@@ -10488,14 +10488,14 @@ fn finishSwitchBr(
10488	10488	const bags_required = std.math.divCeil(u32, hints.count + additional_count, hints_per_bag) catch unreachable;
10489	10489	return hints.bags.ensureUnusedCapacity(gpa_inner, bags_required);
10490	10490	}
10491		fn appendAssumeCapacity(hints: *@This(), hint: std.builtin.BranchHint) void {
	10491	fn appendAssumeCapacity(hints: *@This(), hint: std.lang.BranchHint) void {
10492	10492	const idx_in_bag = hints.count % hints_per_bag;
10493	10493	var bag: u32 = if (idx_in_bag > 0) hints.bags.pop().? else 0;
10494		bag \|= @as(u32, @intFromEnum(hint)) << @intCast(@bitSizeOf(std.builtin.BranchHint) * idx_in_bag);
	10494	bag \|= @as(u32, @intFromEnum(hint)) << @intCast(@bitSizeOf(std.lang.BranchHint) * idx_in_bag);
10495	10495	hints.count += 1;
10496	10496	return hints.bags.appendAssumeCapacity(bag);
10497	10497	}
10498		fn append(hints: *@This(), gpa_inner: Allocator, hint: std.builtin.BranchHint) Allocator.Error!void {
	10498	fn append(hints: *@This(), gpa_inner: Allocator, hint: std.lang.BranchHint) Allocator.Error!void {
10499	10499	try hints.ensureUnusedCapacity(gpa_inner, 1);
10500	10500	return hints.appendAssumeCapacity(hint);
10501	10501	}
...	...	@@ -10574,7 +10574,7 @@ fn finishSwitchBr(
10574	10574	}
10575	10575	emit_bb = true;
10576	10576
10577		const prong_hint: std.builtin.BranchHint = hint: {
	10577	const prong_hint: std.lang.BranchHint = hint: {
10578	10578	if (analyze_body) break :hint try sema.analyzeSwitchProng(
10579	10579	&case_block,
10580	10580	operand,
...	...	@@ -10717,7 +10717,7 @@ fn finishSwitchBr(
10717	10717	case_block.instructions.clearRetainingCapacity();
10718	10718	case_block.error_return_trace_index = child_block.error_return_trace_index;
10719	10719
10720		const prong_hint: std.builtin.BranchHint = hint: {
	10720	const prong_hint: std.lang.BranchHint = hint: {
10721	10721	if (any_analyze_body) break :hint try sema.analyzeSwitchProng(
10722	10722	&case_block,
10723	10723	operand,
...	...	@@ -10804,7 +10804,7 @@ fn finishSwitchBr(
10804	10804	if (emit_bb) try sema.emitBackwardBranch(block, else_prong_src);
10805	10805	emit_bb = true;
10806	10806
10807		const prong_hint: std.builtin.BranchHint = hint: {
	10807	const prong_hint: std.lang.BranchHint = hint: {
10808	10808	if (analyze_body) break :hint try sema.analyzeSwitchProng(
10809	10809	&case_block,
10810	10810	operand,
...	...	@@ -10864,7 +10864,7 @@ fn finishSwitchBr(
10864	10864
10865	10865	cases_len += 1;
10866	10866
10867		const prong_hint: std.builtin.BranchHint = hint: {
	10867	const prong_hint: std.lang.BranchHint = hint: {
10868	10868	if (!else_case.is_inline) break :hint try sema.analyzeSwitchProng(
10869	10869	&case_block,
10870	10870	operand,
...	...	@@ -11937,7 +11937,7 @@ fn analyzeSwitchProng(
11937	11937	else_err_ty: ?Type,
11938	11938	switch_inst: Zir.Inst.Index,
11939	11939	zir_switch: *const Zir.UnwrappedSwitchBlock,
11940		) CompileError!std.builtin.BranchHint {
	11940	) CompileError!std.lang.BranchHint {
11941	11941	const pt = sema.pt;
11942	11942	const zcu = pt.zcu;
11943	11943
...	...	@@ -12328,7 +12328,7 @@ fn analyzeSwitchPayloadCapture(
12328	12328
12329	12329	{
12330	12330	// All branch hints are `.none`, so just add zero elems.
12331		comptime assert(@intFromEnum(std.builtin.BranchHint.none) == 0);
	12331	comptime assert(@intFromEnum(std.lang.BranchHint.none) == 0);
12332	12332	const need_elems = std.math.divCeil(usize, prong_count + 1, 10) catch unreachable;
12333	12333	try cases_extra.appendNTimes(0, need_elems);
12334	12334	}
...	...	@@ -16088,7 +16088,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16088	16088	};
16089	16089	return Air.internedToRef((try pt.internUnion(.{
16090	16090	.ty = type_info_ty.toIntern(),
16091		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"fn"))).toIntern(),
	16091	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"fn"))).toIntern(),
16092	16092	.val = (try pt.aggregateValue(fn_info_ty, &field_values)).toIntern(),
16093	16093	})));
16094	16094	},
...	...	@@ -16104,7 +16104,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16104	16104	};
16105	16105	return Air.internedToRef((try pt.internUnion(.{
16106	16106	.ty = type_info_ty.toIntern(),
16107		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.int))).toIntern(),
	16107	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.int))).toIntern(),
16108	16108	.val = (try pt.aggregateValue(int_info_ty, &field_values)).toIntern(),
16109	16109	})));
16110	16110	},
...	...	@@ -16117,7 +16117,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16117	16117	};
16118	16118	return Air.internedToRef((try pt.internUnion(.{
16119	16119	.ty = type_info_ty.toIntern(),
16120		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.float))).toIntern(),
	16120	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.float))).toIntern(),
16121	16121	.val = (try pt.aggregateValue(float_info_ty, &field_vals)).toIntern(),
16122	16122	})));
16123	16123	},
...	...	@@ -16162,7 +16162,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16162	16162	};
16163	16163	return Air.internedToRef((try pt.internUnion(.{
16164	16164	.ty = type_info_ty.toIntern(),
16165		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.pointer))).toIntern(),
	16165	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.pointer))).toIntern(),
16166	16166	.val = (try pt.aggregateValue(pointer_ty, &field_values)).toIntern(),
16167	16167	})));
16168	16168	},
...	...	@@ -16180,7 +16180,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16180	16180	};
16181	16181	return Air.internedToRef((try pt.internUnion(.{
16182	16182	.ty = type_info_ty.toIntern(),
16183		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.array))).toIntern(),
	16183	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.array))).toIntern(),
16184	16184	.val = (try pt.aggregateValue(array_field_ty, &field_values)).toIntern(),
16185	16185	})));
16186	16186	},
...	...	@@ -16196,7 +16196,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16196	16196	};
16197	16197	return Air.internedToRef((try pt.internUnion(.{
16198	16198	.ty = type_info_ty.toIntern(),
16199		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.vector))).toIntern(),
	16199	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.vector))).toIntern(),
16200	16200	.val = (try pt.aggregateValue(vector_field_ty, &field_values)).toIntern(),
16201	16201	})));
16202	16202	},
...	...	@@ -16209,7 +16209,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16209	16209	};
16210	16210	return Air.internedToRef((try pt.internUnion(.{
16211	16211	.ty = type_info_ty.toIntern(),
16212		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.optional))).toIntern(),
	16212	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.optional))).toIntern(),
16213	16213	.val = (try pt.aggregateValue(optional_field_ty, &field_values)).toIntern(),
16214	16214	})));
16215	16215	},
...	...	@@ -16300,7 +16300,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16300	16300	// Construct Type{ .error_set = errors_val }
16301	16301	return Air.internedToRef((try pt.internUnion(.{
16302	16302	.ty = type_info_ty.toIntern(),
16303		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.error_set))).toIntern(),
	16303	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.error_set))).toIntern(),
16304	16304	.val = errors_val,
16305	16305	})));
16306	16306	},
...	...	@@ -16315,7 +16315,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16315	16315	};
16316	16316	return Air.internedToRef((try pt.internUnion(.{
16317	16317	.ty = type_info_ty.toIntern(),
16318		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.error_union))).toIntern(),
	16318	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.error_union))).toIntern(),
16319	16319	.val = (try pt.aggregateValue(error_union_field_ty, &field_values)).toIntern(),
16320	16320	})));
16321	16321	},
...	...	@@ -16418,7 +16418,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16418	16418	};
16419	16419	return Air.internedToRef((try pt.internUnion(.{
16420	16420	.ty = type_info_ty.toIntern(),
16421		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"enum"))).toIntern(),
	16421	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"enum"))).toIntern(),
16422	16422	.val = (try pt.aggregateValue(type_enum_ty, &field_values)).toIntern(),
16423	16423	})));
16424	16424	},
...	...	@@ -16539,7 +16539,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16539	16539	};
16540	16540	return Air.internedToRef((try pt.internUnion(.{
16541	16541	.ty = type_info_ty.toIntern(),
16542		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"union"))).toIntern(),
	16542	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"union"))).toIntern(),
16543	16543	.val = (try pt.aggregateValue(type_union_ty, &field_values)).toIntern(),
16544	16544	})));
16545	16545	},
...	...	@@ -16731,7 +16731,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16731	16731	};
16732	16732	return Air.internedToRef((try pt.internUnion(.{
16733	16733	.ty = type_info_ty.toIntern(),
16734		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"struct"))).toIntern(),
	16734	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"struct"))).toIntern(),
16735	16735	.val = (try pt.aggregateValue(type_struct_ty, &field_values)).toIntern(),
16736	16736	})));
16737	16737	},
...	...	@@ -16746,7 +16746,7 @@ fn zirTypeInfo(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
16746	16746	};
16747	16747	return Air.internedToRef((try pt.internUnion(.{
16748	16748	.ty = type_info_ty.toIntern(),
16749		.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.@"opaque"))).toIntern(),
	16749	.tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"opaque"))).toIntern(),
16750	16750	.val = (try pt.aggregateValue(type_opaque_ty, &field_values)).toIntern(),
16751	16751	})));
16752	16752	},
...	...	@@ -17323,7 +17323,7 @@ fn zirCondbr(
17323	17323	// Reset, this may have been updated by the then block analysis
17324	17324	sub_block.error_return_trace_index = parent_block.error_return_trace_index;
17325	17325
17326		const false_hint: std.builtin.BranchHint = if (err_cond != null and
	17326	const false_hint: std.lang.BranchHint = if (err_cond != null and
17327	17327	try sema.maybeErrorUnwrap(&sub_block, else_body, err_cond.?, cond_src, false))
17328	17328	h: {
17329	17329	// nothing to do here. weight against error branch
...	...	@@ -18040,7 +18040,7 @@ fn zirPtrType(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air
18040	18040	break :blk try sema.validateAlign(block, align_src, align_bytes);
18041	18041	} else .none;
18042	18042
18043		const address_space: std.builtin.AddressSpace = if (inst_data.flags.has_addrspace) blk: {
	18043	const address_space: std.lang.AddressSpace = if (inst_data.flags.has_addrspace) blk: {
18044	18044	const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]);
18045	18045	extra_i += 1;
18046	18046	break :blk try sema.resolveAddressSpace(block, addrspace_src, ref, .pointer);
...	...	@@ -19605,12 +19605,12 @@ fn zirReifyPointer(
19605	19605	const size_uncoerced = sema.resolveInst(extra.size);
19606	19606	const size_coerced = try sema.coerce(block, size_ty, size_uncoerced, size_src);
19607	19607	const size_val = try sema.resolveConstDefinedValue(block, size_src, size_coerced, .{ .simple = .pointer_size });
19608		const size = try sema.interpretStdLangType(block, size_src, size_val, std.builtin.Type.Pointer.Size);
	19608	const size = try sema.interpretStdLangType(block, size_src, size_val, std.lang.Type.Pointer.Size);
19609	19609
19610	19610	const attrs_uncoerced = sema.resolveInst(extra.attrs);
19611	19611	const attrs_coerced = try sema.coerce(block, attrs_ty, attrs_uncoerced, attrs_src);
19612	19612	const attrs_val = try sema.resolveConstDefinedValue(block, attrs_src, attrs_coerced, .{ .simple = .pointer_attrs });
19613		const attrs = try sema.interpretStdLangType(block, attrs_src, attrs_val, std.builtin.Type.Pointer.Attributes);
	19613	const attrs = try sema.interpretStdLangType(block, attrs_src, attrs_val, std.lang.Type.Pointer.Attributes);
19614	19614
19615	19615	const @"align": Alignment = if (attrs.@"align") \|bytes\| a: {
19616	19616	break :a try sema.validateAlign(block, attrs_src, bytes);
...	...	@@ -19711,7 +19711,7 @@ fn zirReifyFn(
19711	19711	const fn_attrs_uncoerced = sema.resolveInst(extra.fn_attrs);
19712	19712	const fn_attrs_coerced = try sema.coerce(block, fn_attrs_ty, fn_attrs_uncoerced, fn_attrs_src);
19713	19713	const fn_attrs_val = try sema.resolveConstDefinedValue(block, fn_attrs_src, fn_attrs_coerced, .{ .simple = .fn_attrs });
19714		const fn_attrs = try sema.interpretStdLangType(block, fn_attrs_src, fn_attrs_val, std.builtin.Type.Fn.Attributes);
	19714	const fn_attrs = try sema.interpretStdLangType(block, fn_attrs_src, fn_attrs_val, std.lang.Type.Fn.Attributes);
19715	19715
19716	19716	var noalias_bits: u32 = 0;
19717	19717	const param_types_ip = try sema.arena.alloc(InternPool.Index, @intCast(params_len));
...	...	@@ -19721,7 +19721,7 @@ fn zirReifyFn(
19721	19721	block,
19722	19722	param_attrs_src,
19723	19723	try param_attrs_arr.elemValue(pt, param_idx),
19724		std.builtin.Type.Fn.Param.Attributes,
	19724	std.lang.Type.Fn.Param.Attributes,
19725	19725	);
19726	19726	try sema.checkParamType(
19727	19727	block,
...	...	@@ -19831,7 +19831,7 @@ fn zirReifyStruct(
19831	19831	const layout_uncoerced = sema.resolveInst(extra.layout);
19832	19832	const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src);
19833	19833	const layout_val = try sema.resolveConstDefinedValue(block, layout_src, layout_coerced, .{ .simple = .struct_layout });
19834		const layout = try sema.interpretStdLangType(block, layout_src, layout_val, std.builtin.Type.ContainerLayout);
	19834	const layout = try sema.interpretStdLangType(block, layout_src, layout_val, std.lang.Type.ContainerLayout);
19835	19835
19836	19836	const backing_int_ty_uncoerced = sema.resolveInst(extra.backing_ty);
19837	19837	const backing_int_ty_coerced = try sema.coerce(block, .optional_type, backing_int_ty_uncoerced, backing_ty_src);
...	...	@@ -19912,15 +19912,15 @@ fn zirReifyStruct(
19912	19912	const field_name = try sema.sliceToIpString(block, field_names_src, field_name_val, .{ .simple = .struct_field_names });
19913	19913
19914	19914	const field_attr_comptime = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
19915		std.builtin.Type.StructField.Attributes,
	19915	std.lang.Type.StructField.Attributes,
19916	19916	"comptime",
19917	19917	).?);
19918	19918	const field_attr_align = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
19919		std.builtin.Type.StructField.Attributes,
	19919	std.lang.Type.StructField.Attributes,
19920	19920	"align",
19921	19921	).?);
19922	19922	const field_attr_default_value_ptr = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
19923		std.builtin.Type.StructField.Attributes,
	19923	std.lang.Type.StructField.Attributes,
19924	19924	"default_value_ptr",
19925	19925	).?);
19926	19926
...	...	@@ -19997,15 +19997,15 @@ fn zirReifyStruct(
19997	19997	wip.field_types.get(ip)[field_idx] = field_ty.toIntern();
19998	19998
19999	19999	const field_attr_comptime = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
20000		std.builtin.Type.StructField.Attributes,
	20000	std.lang.Type.StructField.Attributes,
20001	20001	"comptime",
20002	20002	).?);
20003	20003	const field_attr_align = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
20004		std.builtin.Type.StructField.Attributes,
	20004	std.lang.Type.StructField.Attributes,
20005	20005	"align",
20006	20006	).?);
20007	20007	const field_attr_default_value_ptr = try field_attrs_val.fieldValue(pt, std.meta.fieldIndex(
20008		std.builtin.Type.StructField.Attributes,
	20008	std.lang.Type.StructField.Attributes,
20009	20009	"default_value_ptr",
20010	20010	).?);
20011	20011
...	...	@@ -20111,7 +20111,7 @@ fn zirReifyUnion(
20111	20111	const layout_uncoerced = sema.resolveInst(extra.layout);
20112	20112	const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src);
20113	20113	const layout_val = try sema.resolveConstDefinedValue(block, layout_src, layout_coerced, .{ .simple = .union_layout });
20114		const layout = try sema.interpretStdLangType(block, layout_src, layout_val, std.builtin.Type.ContainerLayout);
	20114	const layout = try sema.interpretStdLangType(block, layout_src, layout_val, std.lang.Type.ContainerLayout);
20115	20115
20116	20116	const arg_ty_uncoerced = sema.resolveInst(extra.arg_ty);
20117	20117	const arg_ty_coerced = try sema.coerce(block, .optional_type, arg_ty_uncoerced, arg_ty_src);
...	...	@@ -20195,7 +20195,7 @@ fn zirReifyUnion(
20195	20195	block,
20196	20196	field_attrs_src,
20197	20197	try field_attrs_arr.elemValue(pt, field_idx),
20198		std.builtin.Type.UnionField.Attributes,
	20198	std.lang.Type.UnionField.Attributes,
20199	20199	);
20200	20200	if (field_attrs.@"align") \|bytes\| {
20201	20201	if (layout == .@"packed") {
...	...	@@ -20244,7 +20244,7 @@ fn zirReifyUnion(
20244	20244	block,
20245	20245	.unneeded,
20246	20246	try field_attrs_arr.elemValue(pt, field_idx),
20247		std.builtin.Type.UnionField.Attributes,
	20247	std.lang.Type.UnionField.Attributes,
20248	20248	);
20249	20249	if (field_attrs.@"align") \|bytes\| {
20250	20250	// No source location; first loop checked this is valid.
...	...	@@ -20329,7 +20329,7 @@ fn zirReifyEnum(
20329	20329	const mode_uncoerced = sema.resolveInst(extra.mode);
20330	20330	const mode_coerced = try sema.coerce(block, enum_mode_ty, mode_uncoerced, mode_src);
20331	20331	const mode_val = try sema.resolveConstDefinedValue(block, mode_src, mode_coerced, .{ .simple = .type });
20332		const nonexhaustive = switch (try sema.interpretStdLangType(block, mode_src, mode_val, std.builtin.Type.Enum.Mode)) {
	20332	const nonexhaustive = switch (try sema.interpretStdLangType(block, mode_src, mode_val, std.lang.Type.Enum.Mode)) {
20333	20333	.exhaustive => false,
20334	20334	.nonexhaustive => true,
20335	20335	};
...	...	@@ -21962,9 +21962,9 @@ fn checkArithmeticOp(
21962	21962	sema: *Sema,
21963	21963	block: *Block,
21964	21964	src: LazySrcLoc,
21965		scalar_tag: std.builtin.TypeId,
21966		lhs_zig_ty_tag: std.builtin.TypeId,
21967		rhs_zig_ty_tag: std.builtin.TypeId,
	21965	scalar_tag: std.lang.TypeId,
	21966	lhs_zig_ty_tag: std.lang.TypeId,
	21967	rhs_zig_ty_tag: std.lang.TypeId,
21968	21968	zir_tag: Zir.Inst.Tag,
21969	21969	) CompileError!void {
21970	21970	const is_int = scalar_tag == .int or scalar_tag == .comptime_int;
...	...	@@ -22387,7 +22387,7 @@ fn resolveExportOptions(
22387	22387
22388	22388	const linkage_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "linkage", .no_embedded_nulls), linkage_src);
22389	22389	const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_operand, .{ .simple = .export_options });
22390		const linkage = try sema.interpretStdLangType(block, linkage_src, linkage_val, std.builtin.GlobalLinkage);
	22390	const linkage = try sema.interpretStdLangType(block, linkage_src, linkage_val, std.lang.GlobalLinkage);
22391	22391
22392	22392	const section_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "section", .no_embedded_nulls), section_src);
22393	22393	const section_opt_val = try sema.resolveConstDefinedValue(block, section_src, section_operand, .{ .simple = .export_options });
...	...	@@ -22398,7 +22398,7 @@ fn resolveExportOptions(
22398	22398
22399	22399	const visibility_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "visibility", .no_embedded_nulls), visibility_src);
22400	22400	const visibility_val = try sema.resolveConstDefinedValue(block, visibility_src, visibility_operand, .{ .simple = .export_options });
22401		const visibility = try sema.interpretStdLangType(block, visibility_src, visibility_val, std.builtin.SymbolVisibility);
	22401	const visibility = try sema.interpretStdLangType(block, visibility_src, visibility_val, std.lang.SymbolVisibility);
22402	22402
22403	22403	if (name.len < 1) {
22404	22404	return sema.fail(block, name_src, "exported symbol name cannot be empty", .{});
...	...	@@ -22425,12 +22425,12 @@ fn resolveStdLangEnum(
22425	22425	zir_ref: Zir.Inst.Ref,
22426	22426	comptime name: Zcu.StdLangDecl,
22427	22427	reason: ComptimeReason,
22428		) CompileError!@field(std.builtin, @tagName(name)) {
	22428	) CompileError!@field(std.lang, @tagName(name)) {
22429	22429	const ty = try sema.getStdLangType(src, name);
22430	22430	const air_ref = sema.resolveInst(zir_ref);
22431	22431	const coerced = try sema.coerce(block, ty, air_ref, src);
22432	22432	const val = try sema.resolveConstDefinedValue(block, src, coerced, reason);
22433		return sema.interpretStdLangType(block, src, val, @field(std.builtin, @tagName(name)));
	22433	return sema.interpretStdLangType(block, src, val, @field(std.lang, @tagName(name)));
22434	22434	}
22435	22435
22436	22436	fn resolveAtomicOrder(
...	...	@@ -22439,7 +22439,7 @@ fn resolveAtomicOrder(
22439	22439	src: LazySrcLoc,
22440	22440	zir_ref: Zir.Inst.Ref,
22441	22441	reason: ComptimeReason,
22442		) CompileError!std.builtin.AtomicOrder {
	22442	) CompileError!std.lang.AtomicOrder {
22443	22443	return sema.resolveStdLangEnum(block, src, zir_ref, .AtomicOrder, reason);
22444	22444	}
22445	22445
...	...	@@ -22448,7 +22448,7 @@ fn resolveAtomicRmwOp(
22448	22448	block: *Block,
22449	22449	src: LazySrcLoc,
22450	22450	zir_ref: Zir.Inst.Ref,
22451		) CompileError!std.builtin.AtomicRmwOp {
	22451	) CompileError!std.lang.AtomicRmwOp {
22452	22452	return sema.resolveStdLangEnum(block, src, zir_ref, .AtomicRmwOp, .{ .simple = .operand_atomicRmw_operation });
22453	22453	}
22454	22454
...	...	@@ -22490,10 +22490,10 @@ fn zirCmpxchg(
22490	22490	const success_order = try sema.resolveAtomicOrder(block, success_order_src, extra.success_order, .{ .simple = .atomic_order });
22491	22491	const failure_order = try sema.resolveAtomicOrder(block, failure_order_src, extra.failure_order, .{ .simple = .atomic_order });
22492	22492
22493		if (@intFromEnum(success_order) < @intFromEnum(std.builtin.AtomicOrder.monotonic)) {
	22493	if (@intFromEnum(success_order) < @intFromEnum(std.lang.AtomicOrder.monotonic)) {
22494	22494	return sema.fail(block, success_order_src, "success atomic ordering must be monotonic or stricter", .{});
22495	22495	}
22496		if (@intFromEnum(failure_order) < @intFromEnum(std.builtin.AtomicOrder.monotonic)) {
	22496	if (@intFromEnum(failure_order) < @intFromEnum(std.lang.AtomicOrder.monotonic)) {
22497	22497	return sema.fail(block, failure_order_src, "failure atomic ordering must be monotonic or stricter", .{});
22498	22498	}
22499	22499	if (@intFromEnum(failure_order) > @intFromEnum(success_order)) {
...	...	@@ -23200,7 +23200,7 @@ fn zirBuiltinCall(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError
23200	23200	const air_ref = sema.resolveInst(extra.modifier);
23201	23201	const modifier_ref = try sema.coerce(block, modifier_ty, air_ref, modifier_src);
23202	23202	const modifier_val = try sema.resolveConstDefinedValue(block, modifier_src, modifier_ref, .{ .simple = .call_modifier });
23203		var modifier = try sema.interpretStdLangType(block, modifier_src, modifier_val, std.builtin.CallModifier);
	23203	var modifier = try sema.interpretStdLangType(block, modifier_src, modifier_val, std.lang.CallModifier);
23204	23204	switch (modifier) {
23205	23205	// These can be upgraded to comptime or nosuspend calls.
23206	23206	.auto, .never_tail, .no_suspend => {
...	...	@@ -24250,7 +24250,7 @@ fn zirFuncFancy(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!A
24250	24250
24251	24251	var extra_index: usize = extra.end;
24252	24252
24253		const cc: std.builtin.CallingConvention = if (extra.data.bits.has_cc_body) blk: {
	24253	const cc: std.lang.CallingConvention = if (extra.data.bits.has_cc_body) blk: {
24254	24254	const body_len = sema.code.extra[extra_index];
24255	24255	extra_index += 1;
24256	24256	const body = sema.code.bodySlice(extra_index, body_len);
...	...	@@ -24398,7 +24398,7 @@ fn resolvePrefetchOptions(
24398	24398	block: *Block,
24399	24399	src: LazySrcLoc,
24400	24400	zir_ref: Zir.Inst.Ref,
24401		) CompileError!std.builtin.PrefetchOptions {
	24401	) CompileError!std.lang.PrefetchOptions {
24402	24402	const pt = sema.pt;
24403	24403	const zcu = pt.zcu;
24404	24404	const comp = zcu.comp;
...	...	@@ -24422,10 +24422,10 @@ fn resolvePrefetchOptions(
24422	24422	const cache = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "cache", .no_embedded_nulls), cache_src);
24423	24423	const cache_val = try sema.resolveConstDefinedValue(block, cache_src, cache, .{ .simple = .prefetch_options });
24424	24424
24425		return std.builtin.PrefetchOptions{
24426		.rw = try sema.interpretStdLangType(block, rw_src, rw_val, std.builtin.PrefetchOptions.Rw),
	24425	return std.lang.PrefetchOptions{
	24426	.rw = try sema.interpretStdLangType(block, rw_src, rw_val, std.lang.PrefetchOptions.Rw),
24427	24427	.locality = @intCast(locality_val.toUnsignedInt(zcu)),
24428		.cache = try sema.interpretStdLangType(block, cache_src, cache_val, std.builtin.PrefetchOptions.Cache),
	24428	.cache = try sema.interpretStdLangType(block, cache_src, cache_val, std.lang.PrefetchOptions.Cache),
24429	24429	};
24430	24430	}
24431	24431
...	...	@@ -24465,12 +24465,12 @@ fn resolveExternOptions(
24465	24465	) CompileError!struct {
24466	24466	name: InternPool.NullTerminatedString,
24467	24467	library_name: InternPool.OptionalNullTerminatedString,
24468		linkage: std.builtin.GlobalLinkage,
24469		visibility: std.builtin.SymbolVisibility,
	24468	linkage: std.lang.GlobalLinkage,
	24469	visibility: std.lang.SymbolVisibility,
24470	24470	is_thread_local: bool,
24471	24471	is_dll_import: bool,
24472		relocation: std.builtin.ExternOptions.Relocation,
24473		decoration: ?std.builtin.ExternOptions.Decoration,
	24472	relocation: std.lang.ExternOptions.Relocation,
	24473	decoration: ?std.lang.ExternOptions.Decoration,
24474	24474	} {
24475	24475	const pt = sema.pt;
24476	24476	const zcu = pt.zcu;
...	...	@@ -24500,11 +24500,11 @@ fn resolveExternOptions(
24500	24500
24501	24501	const linkage_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "linkage", .no_embedded_nulls), linkage_src);
24502	24502	const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_ref, .{ .simple = .extern_options });
24503		const linkage = try sema.interpretStdLangType(block, linkage_src, linkage_val, std.builtin.GlobalLinkage);
	24503	const linkage = try sema.interpretStdLangType(block, linkage_src, linkage_val, std.lang.GlobalLinkage);
24504	24504
24505	24505	const visibility_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "visibility", .no_embedded_nulls), visibility_src);
24506	24506	const visibility_val = try sema.resolveConstDefinedValue(block, visibility_src, visibility_ref, .{ .simple = .extern_options });
24507		const visibility = try sema.interpretStdLangType(block, visibility_src, visibility_val, std.builtin.SymbolVisibility);
	24507	const visibility = try sema.interpretStdLangType(block, visibility_src, visibility_val, std.lang.SymbolVisibility);
24508	24508
24509	24509	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);
24510	24510	const is_thread_local_val = try sema.resolveConstDefinedValue(block, thread_local_src, is_thread_local, .{ .simple = .extern_options });
...	...	@@ -24523,11 +24523,11 @@ fn resolveExternOptions(
24523	24523
24524	24524	const relocation_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "relocation", .no_embedded_nulls), relocation_src);
24525	24525	const relocation_val = try sema.resolveConstDefinedValue(block, relocation_src, relocation_ref, .{ .simple = .extern_options });
24526		const relocation = try sema.interpretStdLangType(block, relocation_src, relocation_val, std.builtin.ExternOptions.Relocation);
	24526	const relocation = try sema.interpretStdLangType(block, relocation_src, relocation_val, std.lang.ExternOptions.Relocation);
24527	24527
24528	24528	const decoration_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, io, pt.tid, "decoration", .no_embedded_nulls), decoration_src);
24529	24529	const decoration_val = try sema.resolveConstDefinedValue(block, decoration_src, decoration_ref, .{ .simple = .extern_options });
24530		const decoration = try sema.interpretStdLangType(block, decoration_src, decoration_val, ?std.builtin.ExternOptions.Decoration);
	24530	const decoration = try sema.interpretStdLangType(block, decoration_src, decoration_val, ?std.lang.ExternOptions.Decoration);
24531	24531
24532	24532	if (name.len == 0) {
24533	24533	return sema.fail(block, name_src, "extern symbol name cannot be empty", .{});
...	...	@@ -24744,7 +24744,7 @@ fn zirStdLangValue(sema: Sema, block: Block, extended: Zir.Inst.Extended.InstD
24744	24744	.calling_convention_inline => {
24745	24745	const callconv_ty = try sema.getStdLangType(src, .CallingConvention);
24746	24746	return .fromValue(Value.uninterpret(
24747		@as(std.builtin.CallingConvention, .@"inline"),
	24747	@as(std.lang.CallingConvention, .@"inline"),
24748	24748	callconv_ty,
24749	24749	pt,
24750	24750	) catch \|err\| switch (err) {
...	...	@@ -24795,7 +24795,7 @@ fn zirBranchHint(sema: Sema, block: Block, extended: Zir.Inst.Extended.InstDat
24795	24795	// We only apply the first hint in a branch.
24796	24796	// This allows user-provided hints to override implicit cold hints.
24797	24797	if (sema.branch_hint == null) {
24798		sema.branch_hint = try sema.interpretStdLangType(block, operand_src, hint_val, std.builtin.BranchHint);
	24798	sema.branch_hint = try sema.interpretStdLangType(block, operand_src, hint_val, std.lang.BranchHint);
24799	24799	}
24800	24800	}
24801	24801
...	...	@@ -27911,8 +27911,8 @@ const InMemoryCoercionResult = union(enum) {
27911	27911	};
27912	27912
27913	27913	const Int = struct {
27914		actual_signedness: std.builtin.Signedness,
27915		wanted_signedness: std.builtin.Signedness,
	27914	actual_signedness: std.lang.Signedness,
	27915	wanted_signedness: std.lang.Signedness,
27916	27916	actual_bits: u16,
27917	27917	wanted_bits: u16,
27918	27918	};
...	...	@@ -27928,18 +27928,18 @@ const InMemoryCoercionResult = union(enum) {
27928	27928	};
27929	27929
27930	27930	const Size = struct {
27931		actual: std.builtin.Type.Pointer.Size,
27932		wanted: std.builtin.Type.Pointer.Size,
	27931	actual: std.lang.Type.Pointer.Size,
	27932	wanted: std.lang.Type.Pointer.Size,
27933	27933	};
27934	27934
27935	27935	const AddressSpace = struct {
27936		actual: std.builtin.AddressSpace,
27937		wanted: std.builtin.AddressSpace,
	27936	actual: std.lang.AddressSpace,
	27937	wanted: std.lang.AddressSpace,
27938	27938	};
27939	27939
27940	27940	const CC = struct {
27941		actual: std.builtin.CallingConvention,
27942		wanted: std.builtin.CallingConvention,
	27941	actual: std.lang.CallingConvention,
	27942	wanted: std.lang.CallingConvention,
27943	27943	};
27944	27944
27945	27945	const BitRange = struct {
...	...	@@ -28209,7 +28209,7 @@ const InMemoryCoercionResult = union(enum) {
28209	28209	}
28210	28210	};
28211	28211
28212		fn pointerSizeString(size: std.builtin.Type.Pointer.Size) []const u8 {
	28212	fn pointerSizeString(size: std.lang.Type.Pointer.Size) []const u8 {
28213	28213	return switch (size) {
28214	28214	.one => "single pointer",
28215	28215	.many => "many pointer",
...	...	@@ -28635,10 +28635,10 @@ fn coerceInMemoryAllowedFns(
28635	28635
28636	28636	fn callconvCoerceAllowed(
28637	28637	target: *const std.Target,
28638		src_cc: std.builtin.CallingConvention,
28639		dest_cc: std.builtin.CallingConvention,
	28638	src_cc: std.lang.CallingConvention,
	28639	dest_cc: std.lang.CallingConvention,
28640	28640	) bool {
28641		const Tag = std.builtin.CallingConvention.Tag;
	28641	const Tag = std.lang.CallingConvention.Tag;
28642	28642	if (@as(Tag, src_cc) != @as(Tag, dest_cc)) return false;
28643	28643
28644	28644	switch (src_cc) {
...	...	@@ -28651,26 +28651,26 @@ fn callconvCoerceAllowed(
28651	28651	if (dest_stack_align < src_stack_align) return false;
28652	28652	}
28653	28653	switch (@TypeOf(src_data)) {
28654		void, std.builtin.CallingConvention.CommonOptions => {},
28655		std.builtin.CallingConvention.X86RegparmOptions => {
	28654	void, std.lang.CallingConvention.CommonOptions => {},
	28655	std.lang.CallingConvention.X86RegparmOptions => {
28656	28656	if (src_data.register_params != dest_data.register_params) return false;
28657	28657	},
28658		std.builtin.CallingConvention.ArcInterruptOptions => {
	28658	std.lang.CallingConvention.ArcInterruptOptions => {
28659	28659	if (src_data.type != dest_data.type) return false;
28660	28660	},
28661		std.builtin.CallingConvention.ArmInterruptOptions => {
	28661	std.lang.CallingConvention.ArmInterruptOptions => {
28662	28662	if (src_data.type != dest_data.type) return false;
28663	28663	},
28664		std.builtin.CallingConvention.MicroblazeInterruptOptions => {
	28664	std.lang.CallingConvention.MicroblazeInterruptOptions => {
28665	28665	if (src_data.type != dest_data.type) return false;
28666	28666	},
28667		std.builtin.CallingConvention.MipsInterruptOptions => {
	28667	std.lang.CallingConvention.MipsInterruptOptions => {
28668	28668	if (src_data.mode != dest_data.mode) return false;
28669	28669	},
28670		std.builtin.CallingConvention.RiscvInterruptOptions => {
	28670	std.lang.CallingConvention.RiscvInterruptOptions => {
28671	28671	if (src_data.mode != dest_data.mode) return false;
28672	28672	},
28673		std.builtin.CallingConvention.ShInterruptOptions => {
	28673	std.lang.CallingConvention.ShInterruptOptions => {
28674	28674	if (src_data.save != dest_data.save) return false;
28675	28675	},
28676	28676	else => comptime unreachable,
...	...	@@ -31115,7 +31115,7 @@ fn cmpNumeric(
31115	31115	const dest_ty = if (dest_float_type) \|ft\| ft else blk: {
31116	31116	const max_bits = @max(lhs_bits, rhs_bits);
31117	31117	const casted_bits = std.math.cast(u16, max_bits) orelse return sema.fail(block, src, "{d} exceeds maximum integer bit count", .{max_bits});
31118		const signedness: std.builtin.Signedness = if (dest_int_is_signed) .signed else .unsigned;
	31118	const signedness: std.lang.Signedness = if (dest_int_is_signed) .signed else .unsigned;
31119	31119	break :blk try pt.intType(signedness, casted_bits);
31120	31120	};
31121	31121	const casted_lhs = try sema.coerce(block, dest_ty, lhs, lhs_src);
...	...	@@ -33101,7 +33101,7 @@ fn resolveAddressSpace(
33101	33101	src: LazySrcLoc,
33102	33102	zir_ref: Zir.Inst.Ref,
33103	33103	ctx: std.Target.AddressSpaceContext,
33104		) !std.builtin.AddressSpace {
	33104	) !std.lang.AddressSpace {
33105	33105	const air_ref = sema.resolveInst(zir_ref);
33106	33106	return sema.analyzeAsAddressSpace(block, src, air_ref, ctx);
33107	33107	}
...	...	@@ -33112,12 +33112,12 @@ pub fn analyzeAsAddressSpace(
33112	33112	src: LazySrcLoc,
33113	33113	air_ref: Air.Inst.Ref,
33114	33114	ctx: std.Target.AddressSpaceContext,
33115		) !std.builtin.AddressSpace {
	33115	) !std.lang.AddressSpace {
33116	33116	const pt = sema.pt;
33117	33117	const addrspace_ty = try sema.getStdLangType(src, .AddressSpace);
33118	33118	const coerced = try sema.coerce(block, addrspace_ty, air_ref, src);
33119	33119	const addrspace_val = try sema.resolveConstDefinedValue(block, src, coerced, .{ .simple = .@"addrspace" });
33120		const address_space = try sema.interpretStdLangType(block, src, addrspace_val, std.builtin.AddressSpace);
	33120	const address_space = try sema.interpretStdLangType(block, src, addrspace_val, std.lang.AddressSpace);
33121	33121	const target = pt.zcu.getTarget();
33122	33122
33123	33123	if (!target.supportsAddressSpace(address_space, ctx)) {
...	...	@@ -33833,7 +33833,7 @@ pub fn getStdLangValue(sema: *Sema, src: LazySrcLoc, decl: Zcu.StdLangDecl) Sema
33833	33833	pub const NavPtrModifiers = struct {
33834	33834	@"align": Alignment,
33835	33835	@"linksection": InternPool.OptionalNullTerminatedString,
33836		@"addrspace": std.builtin.AddressSpace,
	33836	@"addrspace": std.lang.AddressSpace,
33837	33837	};
33838	33838
33839	33839	pub fn resolveNavPtrModifiers(
...	...	@@ -33872,7 +33872,7 @@ pub fn resolveNavPtrModifiers(
33872	33872	break :ls try ip.getOrPutStringOpt(gpa, io, pt.tid, bytes, .no_embedded_nulls);
33873	33873	};
33874	33874
33875		const @"addrspace": std.builtin.AddressSpace = as: {
	33875	const @"addrspace": std.lang.AddressSpace = as: {
33876	33876	const addrspace_ctx: std.Target.AddressSpaceContext = switch (zir_decl.kind) {
33877	33877	.@"var" => .variable,
33878	33878	else => switch (nav_ty.zigTypeTag(zcu)) {

src/Sema/arith.zig+2-2

...	...	@@ -1191,7 +1191,7 @@ pub fn truncate(
1191	1191	val: Value,
1192	1192	ty: Type,
1193	1193	dest_ty: Type,
1194		dest_signedness: std.builtin.Signedness,
	1194	dest_signedness: std.lang.Signedness,
1195	1195	dest_bits: u16,
1196	1196	) CompileError!Value {
1197	1197	const pt = sema.pt;
...	...	@@ -1808,7 +1808,7 @@ fn intTruncate(
1808	1808	sema: *Sema,
1809	1809	val: Value,
1810	1810	dest_ty: Type,
1811		dest_signedness: std.builtin.Signedness,
	1811	dest_signedness: std.lang.Signedness,
1812	1812	dest_bits: u16,
1813	1813	) !Value {
1814	1814	const pt = sema.pt;

src/Type.zig+8-8

...	...	@@ -19,7 +19,7 @@ const Type = @This();
19	19
20	20	ip_index: InternPool.Index,
21	21
22		pub fn zigTypeTag(ty: Type, zcu: *const Zcu) std.builtin.TypeId {
	22	pub fn zigTypeTag(ty: Type, zcu: *const Zcu) std.lang.TypeId {
23	23	return zcu.intern_pool.zigTypeTag(ty.toIntern());
24	24	}
25	25
...	...	@@ -903,7 +903,7 @@ pub fn ptrAlignment(ptr_ty: Type, zcu: *Zcu) Alignment {
903	903	return Type.fromInterned(ptr_key.child).abiAlignment(zcu);
904	904	}
905	905
906		pub fn ptrAddressSpace(ty: Type, zcu: *const Zcu) std.builtin.AddressSpace {
	906	pub fn ptrAddressSpace(ty: Type, zcu: *const Zcu) std.lang.AddressSpace {
907	907	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
908	908	.ptr_type => \|ptr_type\| ptr_type.flags.address_space,
909	909	.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 {
1337	1337	}
1338	1338
1339	1339	/// Asserts `ty` is a pointer.
1340		pub fn ptrSize(ty: Type, zcu: *const Zcu) std.builtin.Type.Pointer.Size {
	1340	pub fn ptrSize(ty: Type, zcu: *const Zcu) std.lang.Type.Pointer.Size {
1341	1341	return ty.ptrSizeOrNull(zcu).?;
1342	1342	}
1343	1343
1344	1344	/// Returns `null` if `ty` is not a pointer.
1345		pub fn ptrSizeOrNull(ty: Type, zcu: *const Zcu) ?std.builtin.Type.Pointer.Size {
	1345	pub fn ptrSizeOrNull(ty: Type, zcu: *const Zcu) ?std.lang.Type.Pointer.Size {
1346	1346	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1347	1347	.ptr_type => \|ptr_info\| ptr_info.flags.size,
1348	1348	else => null,
...	...	@@ -1627,7 +1627,7 @@ pub fn unionGetLayout(ty: Type, zcu: *const Zcu) Zcu.UnionLayout {
1627	1627	return Type.getUnionLayout(union_obj, zcu);
1628	1628	}
1629	1629
1630		pub fn containerLayout(ty: Type, zcu: *const Zcu) std.builtin.Type.ContainerLayout {
	1630	pub fn containerLayout(ty: Type, zcu: *const Zcu) std.lang.Type.ContainerLayout {
1631	1631	const ip = &zcu.intern_pool;
1632	1632	return switch (ip.indexToKey(ty.toIntern())) {
1633	1633	.tuple_type => .auto,
...	...	@@ -1949,7 +1949,7 @@ pub fn fnReturnType(ty: Type, zcu: *const Zcu) Type {
1949	1949	}
1950	1950
1951	1951	/// Asserts the type is a function.
1952		pub fn fnCallingConvention(ty: Type, zcu: *const Zcu) std.builtin.CallingConvention {
	1952	pub fn fnCallingConvention(ty: Type, zcu: *const Zcu) std.lang.CallingConvention {
1953	1953	return zcu.intern_pool.indexToKey(ty.toIntern()).func_type.cc;
1954	1954	}
1955	1955
...	...	@@ -2477,7 +2477,7 @@ pub fn explicitFieldAlignment(ty: Type, index: usize, zcu: *const Zcu) Alignment
2477	2477	/// Asserts that the layout of `field_ty` is resolved. Asserts that `layout` is not `.@"packed"`.
2478	2478	pub fn defaultStructFieldAlignment(
2479	2479	field_ty: Type,
2480		layout: std.builtin.Type.ContainerLayout,
	2480	layout: std.lang.Type.ContainerLayout,
2481	2481	zcu: *const Zcu,
2482	2482	) Alignment {
2483	2483	const overalign_big_int = switch (layout) {
...	...	@@ -3227,7 +3227,7 @@ pub fn validateExtern(ty: Type, position: ExternPosition, zcu: *const Zcu) bool
3227	3227	.optional => ty.isPtrLikeOptional(zcu),
3228	3228	};
3229	3229	}
3230		fn validateExternCallconv(cc: std.builtin.CallingConvention) bool {
	3230	fn validateExternCallconv(cc: std.lang.CallingConvention) bool {
3231	3231	return switch (cc) {
3232	3232	// For now we want to authorize PTX kernel to use zig objects, even if we end up exposing the ABI.
3233	3233	// The goal is to experiment with more integrated CPU/GPU code.

src/Value.zig+1-1

...	...	@@ -1845,7 +1845,7 @@ pub fn ptrElem(orig_parent_ptr: Value, field_idx: u64, pt: Zcu.PerThread) !Value
1845	1845	} }));
1846	1846	}
1847	1847
1848		fn canonicalizeBasePtr(base_ptr: Value, want_size: std.builtin.Type.Pointer.Size, want_child: Type, pt: Zcu.PerThread) !Value {
	1848	fn canonicalizeBasePtr(base_ptr: Value, want_size: std.lang.Type.Pointer.Size, want_child: Type, pt: Zcu.PerThread) !Value {
1849	1849	const ptr_ty = base_ptr.typeOf(pt.zcu);
1850	1850	const ptr_info = ptr_ty.ptrInfo(pt.zcu);
1851	1851

src/Zcu.zig+4-4

...	...	@@ -744,9 +744,9 @@ pub const Export = struct {
744	744
745	745	pub const Options = struct {
746	746	name: InternPool.NullTerminatedString,
747		linkage: std.builtin.GlobalLinkage = .strong,
	747	linkage: std.lang.GlobalLinkage = .strong,
748	748	section: InternPool.OptionalNullTerminatedString = .none,
749		visibility: std.builtin.SymbolVisibility = .default,
	749	visibility: std.lang.SymbolVisibility = .default,
750	750	};
751	751
752	752	/// Index into `all_exports`.
...	...	@@ -4524,10 +4524,10 @@ fn formatDependee(data: FormatDependee, writer: *Io.Writer) Io.Writer.Error!void
4524	4524	}
4525	4525	}
4526	4526
4527		pub fn callconvSupported(zcu: *Zcu, cc: std.builtin.CallingConvention) union(enum) {
	4527	pub fn callconvSupported(zcu: *Zcu, cc: std.lang.CallingConvention) union(enum) {
4528	4528	ok,
4529	4529	bad_arch: []const std.Target.Cpu.Arch, // value is allowed archs for cc
4530		bad_backend: std.builtin.CompilerBackend, // value is current backend
	4530	bad_backend: std.lang.CompilerBackend, // value is current backend
4531	4531	} {
4532	4532	const target = zcu.getTarget();
4533	4533	const backend = target_util.zigBackend(target, zcu.comp.config.use_llvm);

src/Zcu/PerThread.zig+1-1

...	...	@@ -3965,7 +3965,7 @@ pub fn getCoerced(pt: Zcu.PerThread, val: Value, new_ty: Type) Allocator.Error!V
3965	3965	return .fromInterned(try ip.getCoerced(gpa, io, pt.tid, val.toIntern(), new_ty.toIntern()));
3966	3966	}
3967	3967
3968		pub fn intType(pt: Zcu.PerThread, signedness: std.builtin.Signedness, bits: u16) Allocator.Error!Type {
	3968	pub fn intType(pt: Zcu.PerThread, signedness: std.lang.Signedness, bits: u16) Allocator.Error!Type {
3969	3969	return Type.fromInterned(try pt.intern(.{ .int_type = .{
3970	3970	.signedness = signedness,
3971	3971	.bits = bits,

src/codegen.zig+3-3

...	...	@@ -29,7 +29,7 @@ pub const CodeGenError = GenerateSymbolError \|\| error{
29	29	CodegenFail,
30	30	};
31	31
32		fn devFeatureForBackend(backend: std.builtin.CompilerBackend) dev.Feature {
	32	fn devFeatureForBackend(backend: std.lang.CompilerBackend) dev.Feature {
33	33	return switch (backend) {
34	34	.other, .stage1 => unreachable,
35	35	.stage2_aarch64 => .aarch64_backend,
...	...	@@ -47,7 +47,7 @@ fn devFeatureForBackend(backend: std.builtin.CompilerBackend) dev.Feature {
47	47	};
48	48	}
49	49
50		fn importBackend(comptime backend: std.builtin.CompilerBackend) type {
	50	fn importBackend(comptime backend: std.lang.CompilerBackend) type {
51	51	return switch (backend) {
52	52	.other, .stage1 => unreachable,
53	53	.stage2_aarch64 => aarch64,
...	...	@@ -105,7 +105,7 @@ pub const AnyMir = union {
105	105	wasm: if (dev.env.supports(.wasm_backend)) @import("codegen/wasm/Mir.zig") else noreturn,
106	106	c: if (dev.env.supports(.c_backend)) @import("codegen/c.zig").Mir else noreturn,
107	107
108		pub inline fn tag(comptime backend: std.builtin.CompilerBackend) []const u8 {
	108	pub inline fn tag(comptime backend: std.lang.CompilerBackend) []const u8 {
109	109	return switch (backend) {
110	110	.stage2_aarch64 => "aarch64",
111	111	.stage2_riscv64 => "riscv64",

src/codegen/aarch64/Assemble.zig+1-1

...	...	@@ -307,7 +307,7 @@ const SymbolSpec = union(enum) {
307	307	},
308	308	systemreg,
309	309	imm: struct {
310		type: std.builtin.Type.Int,
	310	type: std.lang.Type.Int,
311	311	multiple_of: ?comptime_int = null,
312	312	min_valid: ?comptime_int = null,
313	313	max_valid: ?comptime_int = null,

src/codegen/aarch64/Select.zig+16-16

...	...	@@ -2887,7 +2887,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
2887	2887
2888	2888	const bin_op = air.data(air.inst_index).bin_op;
2889	2889	const ty = isel.air.typeOf(bin_op.lhs, ip);
2890		const int_info: std.builtin.Type.Int = if (ty.toIntern() == .bool_type)
	2890	const int_info: std.lang.Type.Int = if (ty.toIntern() == .bool_type)
2891	2891	.{ .signedness = .unsigned, .bits = 1 }
2892	2892	else if (ty.isAbiInt(zcu))
2893	2893	ty.intInfo(zcu)
...	...	@@ -3144,7 +3144,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
3144	3144
3145	3145	const ty_op = air.data(air.inst_index).ty_op;
3146	3146	const ty = ty_op.ty.toType();
3147		const int_info: std.builtin.Type.Int = int_info: {
	3147	const int_info: std.lang.Type.Int = int_info: {
3148	3148	if (ty_op.ty == .bool_type) break :int_info .{ .signedness = .unsigned, .bits = 1 };
3149	3149	if (!ty.isAbiInt(zcu)) return isel.fail("bad {t} {f}", .{ air_tag, isel.fmtType(ty) });
3150	3150	break :int_info ty.intInfo(zcu);
...	...	@@ -3199,7 +3199,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
3199	3199	const src_tag = src_ty.zigTypeTag(zcu);
3200	3200	if (dst_ty.isAbiInt(zcu) and (src_tag == .bool or src_ty.isAbiInt(zcu))) {
3201	3201	const dst_int_info = dst_ty.intInfo(zcu);
3202		const src_int_info: std.builtin.Type.Int = if (src_tag == .bool) .{ .signedness = undefined, .bits = 1 } else src_ty.intInfo(zcu);
	3202	const src_int_info: std.lang.Type.Int = if (src_tag == .bool) .{ .signedness = undefined, .bits = 1 } else src_ty.intInfo(zcu);
3203	3203	assert(dst_int_info.bits == src_int_info.bits);
3204	3204	if (dst_tag != .@"struct" and src_tag != .@"struct" and src_tag != .bool and dst_int_info.signedness == src_int_info.signedness) {
3205	3205	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,
4517	4517	.switch_br => {
4518	4518	const switch_br = isel.air.unwrapSwitch(air.inst_index);
4519	4519	const cond_ty = isel.air.typeOf(switch_br.operand, ip);
4520		const cond_int_info: std.builtin.Type.Int = if (cond_ty.toIntern() == .bool_type)
	4520	const cond_int_info: std.lang.Type.Int = if (cond_ty.toIntern() == .bool_type)
4521	4521	.{ .signedness = .unsigned, .bits = 1 }
4522	4522	else if (cond_ty.isAbiInt(zcu))
4523	4523	cond_ty.intInfo(zcu)
...	...	@@ -8229,7 +8229,7 @@ fn elemPtr(
8229	8229	fn clzLimb(
8230	8230	isel: *Select,
8231	8231	res_ra: Register.Alias,
8232		src_int_info: std.builtin.Type.Int,
	8232	src_int_info: std.lang.Type.Int,
8233	8233	src_ra: Register.Alias,
8234	8234	) !void {
8235	8235	switch (src_int_info.bits) {
...	...	@@ -8274,7 +8274,7 @@ fn clzLimb(
8274	8274	fn ctzLimb(
8275	8275	isel: *Select,
8276	8276	res_ra: Register.Alias,
8277		src_int_info: std.builtin.Type.Int,
	8277	src_int_info: std.lang.Type.Int,
8278	8278	src_ra: Register.Alias,
8279	8279	) !void {
8280	8280	switch (src_int_info.bits) {
...	...	@@ -8319,7 +8319,7 @@ fn cmp(
8319	8319	var lhs_vi = orig_lhs_vi;
8320	8320	var rhs_vi = orig_rhs_vi;
8321	8321	if (!ty.isRuntimeFloat()) {
8322		const int_info: std.builtin.Type.Int = if (ty.toIntern() == .bool_type)
	8322	const int_info: std.lang.Type.Int = if (ty.toIntern() == .bool_type)
8323	8323	.{ .signedness = .unsigned, .bits = 1 }
8324	8324	else if (ty.isAbiInt(isel.pt.zcu))
8325	8325	ty.intInfo(isel.pt.zcu)
...	...	@@ -8523,7 +8523,7 @@ fn loadReg(
8523	8523	isel: *Select,
8524	8524	ra: Register.Alias,
8525	8525	size: u64,
8526		signedness: std.builtin.Signedness,
	8526	signedness: std.lang.Signedness,
8527	8527	base_ra: Register.Alias,
8528	8528	offset: i65,
8529	8529	) !void {
...	...	@@ -8908,7 +8908,7 @@ pub const Value = struct {
8908	8908	},
8909	8909	small: struct {
8910	8910	size: u5,
8911		signedness: std.builtin.Signedness,
	8911	signedness: std.lang.Signedness,
8912	8912	is_vector: bool,
8913	8913	hint: Register.Alias,
8914	8914	register: Register.Alias,
...	...	@@ -9037,13 +9037,13 @@ pub const Value = struct {
9037	9037	};
9038	9038	}
9039	9039
9040		fn setSignedness(vi: Value.Index, isel: *Select, new_signedness: std.builtin.Signedness) void {
	9040	fn setSignedness(vi: Value.Index, isel: *Select, new_signedness: std.lang.Signedness) void {
9041	9041	const value = vi.get(isel);
9042	9042	assert(value.location_payload.small.size <= 2);
9043	9043	value.location_payload.small.signedness = new_signedness;
9044	9044	}
9045	9045
9046		pub fn signedness(vi: Value.Index, isel: *Select) std.builtin.Signedness {
	9046	pub fn signedness(vi: Value.Index, isel: *Select) std.lang.Signedness {
9047	9047	const value = vi.get(isel);
9048	9048	return switch (value.flags.location_tag) {
9049	9049	.large => .unsigned,
...	...	@@ -9505,7 +9505,7 @@ pub const Value = struct {
9505	9505	offset: u64 = 0,
9506	9506	@"volatile": bool = false,
9507	9507	split: bool = true,
9508		wrap: ?std.builtin.Type.Int = null,
	9508	wrap: ?std.lang.Type.Int = null,
9509	9509	expected_live_registers: *const LiveRegisters = &.initFill(.free),
9510	9510	};
9511	9511
...	...	@@ -9717,7 +9717,7 @@ pub const Value = struct {
9717	9717	root_ty: ZigType,
9718	9718	opts: struct {
9719	9719	root_vi: Value.Index = .free,
9720		wrap: ?std.builtin.Type.Int = null,
	9720	wrap: ?std.lang.Type.Int = null,
9721	9721	expected_live_registers: *const LiveRegisters = &.initFill(.free),
9722	9722	},
9723	9723	) !?void {
...	...	@@ -10289,7 +10289,7 @@ pub const Value = struct {
10289	10289	const payload_ty: ZigType = .fromInterned(error_union_type.payload_type);
10290	10290	const error_set_offset = codegen.errUnionErrorOffset(payload_ty, zcu);
10291	10291	const payload_offset = codegen.errUnionPayloadOffset(payload_ty, zcu);
10292		const Part = struct { offset: u64, size: u64, signedness: ?std.builtin.Signedness, is_vector: bool };
	10292	const Part = struct { offset: u64, size: u64, signedness: ?std.lang.Signedness, is_vector: bool };
10293	10293	var parts: [2]Part = undefined;
10294	10294	var parts_len: Value.PartsLen = 0;
10295	10295	var field_end: u64 = 0;
...	...	@@ -10393,7 +10393,7 @@ pub const Value = struct {
10393	10393	(std.math.divCeil(u64, size, @as(u64, 1) << min_part_log2_stride) catch unreachable) > Value.max_parts)
10394	10394	return isel.fail("Value.FieldPartIterator.next({f})", .{isel.fmtType(ty)});
10395	10395	const alignment = vi.alignment(isel);
10396		const Part = struct { offset: u64, size: u64, signedness: ?std.builtin.Signedness, is_vector: bool };
	10396	const Part = struct { offset: u64, size: u64, signedness: ?std.lang.Signedness, is_vector: bool };
10397	10397	var parts: [Value.max_parts]Part = undefined;
10398	10398	var parts_len: Value.PartsLen = 0;
10399	10399	var field_end: u64 = 0;
...	...	@@ -10512,7 +10512,7 @@ pub const Value = struct {
10512	10512	const alignment = vi.alignment(isel);
10513	10513	const tag_offset = union_layout.tagOffset();
10514	10514	const payload_offset = union_layout.payloadOffset();
10515		const Part = struct { offset: u64, size: u64, signedness: ?std.builtin.Signedness };
	10515	const Part = struct { offset: u64, size: u64, signedness: ?std.lang.Signedness };
10516	10516	var parts: [2]Part = undefined;
10517	10517	var parts_len: Value.PartsLen = 0;
10518	10518	var field_end: u64 = 0;

src/codegen/aarch64/encoding.zig+154-154

...	...	@@ -6755,7 +6755,7 @@ pub const Instruction = packed union {
6755	6755	o0: AddSubtractOp = .add,
6756	6756	Rm: Register.Encoded,
6757	6757	op21: u2 = 0b01,
6758		U: std.builtin.Signedness = .signed,
	6758	U: std.lang.Signedness = .signed,
6759	6759	decoded24: u5 = 0b11011,
6760	6760	op54: u2 = 0b00,
6761	6761	sf: Register.GeneralSize = .doubleword,
...	...	@@ -6769,7 +6769,7 @@ pub const Instruction = packed union {
6769	6769	o0: AddSubtractOp = .sub,
6770	6770	Rm: Register.Encoded,
6771	6771	op21: u2 = 0b01,
6772		U: std.builtin.Signedness = .signed,
	6772	U: std.lang.Signedness = .signed,
6773	6773	decoded24: u5 = 0b11011,
6774	6774	op54: u2 = 0b00,
6775	6775	sf: Register.GeneralSize = .doubleword,
...	...	@@ -6783,7 +6783,7 @@ pub const Instruction = packed union {
6783	6783	o0: AddSubtractOp = .add,
6784	6784	Rm: Register.Encoded,
6785	6785	op21: u2 = 0b10,
6786		U: std.builtin.Signedness = .signed,
	6786	U: std.lang.Signedness = .signed,
6787	6787	decoded24: u5 = 0b11011,
6788	6788	op54: u2 = 0b00,
6789	6789	sf: Register.GeneralSize = .doubleword,
...	...	@@ -6797,7 +6797,7 @@ pub const Instruction = packed union {
6797	6797	o0: AddSubtractOp = .add,
6798	6798	Rm: Register.Encoded,
6799	6799	op21: u2 = 0b01,
6800		U: std.builtin.Signedness = .unsigned,
	6800	U: std.lang.Signedness = .unsigned,
6801	6801	decoded24: u5 = 0b11011,
6802	6802	op54: u2 = 0b00,
6803	6803	sf: Register.GeneralSize = .doubleword,
...	...	@@ -6811,7 +6811,7 @@ pub const Instruction = packed union {
6811	6811	o0: AddSubtractOp = .sub,
6812	6812	Rm: Register.Encoded,
6813	6813	op21: u2 = 0b01,
6814		U: std.builtin.Signedness = .unsigned,
	6814	U: std.lang.Signedness = .unsigned,
6815	6815	decoded24: u5 = 0b11011,
6816	6816	op54: u2 = 0b00,
6817	6817	sf: Register.GeneralSize = .doubleword,
...	...	@@ -6825,7 +6825,7 @@ pub const Instruction = packed union {
6825	6825	o0: AddSubtractOp = .add,
6826	6826	Rm: Register.Encoded,
6827	6827	op21: u2 = 0b10,
6828		U: std.builtin.Signedness = .unsigned,
	6828	U: std.lang.Signedness = .unsigned,
6829	6829	decoded24: u5 = 0b11011,
6830	6830	op54: u2 = 0b00,
6831	6831	sf: Register.GeneralSize = .doubleword,
...	...	@@ -7052,7 +7052,7 @@ pub const Instruction = packed union {
7052	7052	decoded17: u6 = 0b111100,
7053	7053	a: u1,
7054	7054	decoded24: u5 = 0b11110,
7055		U: std.builtin.Signedness,
	7055	U: std.lang.Signedness,
7056	7056	decoded30: u2 = 0b01,
7057	7057	};
7058	7058
...	...	@@ -7065,7 +7065,7 @@ pub const Instruction = packed union {
7065	7065	decoded17: u6 = 0b111100,
7066	7066	o2: u1 = 0b0,
7067	7067	decoded24: u5 = 0b11110,
7068		U: std.builtin.Signedness = .signed,
	7068	U: std.lang.Signedness = .signed,
7069	7069	decoded30: u2 = 0b01,
7070	7070	};
7071	7071
...	...	@@ -7078,7 +7078,7 @@ pub const Instruction = packed union {
7078	7078	decoded17: u6 = 0b111100,
7079	7079	o2: u1 = 0b0,
7080	7080	decoded24: u5 = 0b11110,
7081		U: std.builtin.Signedness = .signed,
	7081	U: std.lang.Signedness = .signed,
7082	7082	decoded30: u2 = 0b01,
7083	7083	};
7084	7084
...	...	@@ -7091,7 +7091,7 @@ pub const Instruction = packed union {
7091	7091	decoded17: u6 = 0b111100,
7092	7092	o2: u1 = 0b0,
7093	7093	decoded24: u5 = 0b11110,
7094		U: std.builtin.Signedness = .signed,
	7094	U: std.lang.Signedness = .signed,
7095	7095	decoded30: u2 = 0b01,
7096	7096	};
7097	7097
...	...	@@ -7104,7 +7104,7 @@ pub const Instruction = packed union {
7104	7104	decoded17: u6 = 0b111100,
7105	7105	o2: u1 = 0b0,
7106	7106	decoded24: u5 = 0b11110,
7107		U: std.builtin.Signedness = .signed,
	7107	U: std.lang.Signedness = .signed,
7108	7108	decoded30: u2 = 0b01,
7109	7109	};
7110	7110
...	...	@@ -7117,7 +7117,7 @@ pub const Instruction = packed union {
7117	7117	decoded17: u6 = 0b111100,
7118	7118	o2: u1 = 0b1,
7119	7119	decoded24: u5 = 0b11110,
7120		U: std.builtin.Signedness = .signed,
	7120	U: std.lang.Signedness = .signed,
7121	7121	decoded30: u2 = 0b01,
7122	7122	};
7123	7123
...	...	@@ -7130,7 +7130,7 @@ pub const Instruction = packed union {
7130	7130	decoded17: u6 = 0b111100,
7131	7131	o2: u1 = 0b1,
7132	7132	decoded24: u5 = 0b11110,
7133		U: std.builtin.Signedness = .signed,
	7133	U: std.lang.Signedness = .signed,
7134	7134	decoded30: u2 = 0b01,
7135	7135	};
7136	7136
...	...	@@ -7143,7 +7143,7 @@ pub const Instruction = packed union {
7143	7143	decoded17: u6 = 0b111100,
7144	7144	o2: u1 = 0b1,
7145	7145	decoded24: u5 = 0b11110,
7146		U: std.builtin.Signedness = .signed,
	7146	U: std.lang.Signedness = .signed,
7147	7147	decoded30: u2 = 0b01,
7148	7148	};
7149	7149
...	...	@@ -7156,7 +7156,7 @@ pub const Instruction = packed union {
7156	7156	decoded17: u6 = 0b111100,
7157	7157	o2: u1 = 0b1,
7158	7158	decoded24: u5 = 0b11110,
7159		U: std.builtin.Signedness = .signed,
	7159	U: std.lang.Signedness = .signed,
7160	7160	decoded30: u2 = 0b01,
7161	7161	};
7162	7162
...	...	@@ -7169,7 +7169,7 @@ pub const Instruction = packed union {
7169	7169	decoded17: u6 = 0b111100,
7170	7170	o2: u1 = 0b1,
7171	7171	decoded24: u5 = 0b11110,
7172		U: std.builtin.Signedness = .signed,
	7172	U: std.lang.Signedness = .signed,
7173	7173	decoded30: u2 = 0b01,
7174	7174	};
7175	7175
...	...	@@ -7182,7 +7182,7 @@ pub const Instruction = packed union {
7182	7182	decoded17: u6 = 0b111100,
7183	7183	o2: u1 = 0b1,
7184	7184	decoded24: u5 = 0b11110,
7185		U: std.builtin.Signedness = .signed,
	7185	U: std.lang.Signedness = .signed,
7186	7186	decoded30: u2 = 0b01,
7187	7187	};
7188	7188
...	...	@@ -7195,7 +7195,7 @@ pub const Instruction = packed union {
7195	7195	decoded17: u6 = 0b111100,
7196	7196	o2: u1 = 0b1,
7197	7197	decoded24: u5 = 0b11110,
7198		U: std.builtin.Signedness = .signed,
	7198	U: std.lang.Signedness = .signed,
7199	7199	decoded30: u2 = 0b01,
7200	7200	};
7201	7201
...	...	@@ -7208,7 +7208,7 @@ pub const Instruction = packed union {
7208	7208	decoded17: u6 = 0b111100,
7209	7209	o2: u1 = 0b0,
7210	7210	decoded24: u5 = 0b11110,
7211		U: std.builtin.Signedness = .unsigned,
	7211	U: std.lang.Signedness = .unsigned,
7212	7212	decoded30: u2 = 0b01,
7213	7213	};
7214	7214
...	...	@@ -7221,7 +7221,7 @@ pub const Instruction = packed union {
7221	7221	decoded17: u6 = 0b111100,
7222	7222	o2: u1 = 0b0,
7223	7223	decoded24: u5 = 0b11110,
7224		U: std.builtin.Signedness = .unsigned,
	7224	U: std.lang.Signedness = .unsigned,
7225	7225	decoded30: u2 = 0b01,
7226	7226	};
7227	7227
...	...	@@ -7234,7 +7234,7 @@ pub const Instruction = packed union {
7234	7234	decoded17: u6 = 0b111100,
7235	7235	o2: u1 = 0b0,
7236	7236	decoded24: u5 = 0b11110,
7237		U: std.builtin.Signedness = .unsigned,
	7237	U: std.lang.Signedness = .unsigned,
7238	7238	decoded30: u2 = 0b01,
7239	7239	};
7240	7240
...	...	@@ -7247,7 +7247,7 @@ pub const Instruction = packed union {
7247	7247	decoded17: u6 = 0b111100,
7248	7248	o2: u1 = 0b0,
7249	7249	decoded24: u5 = 0b11110,
7250		U: std.builtin.Signedness = .unsigned,
	7250	U: std.lang.Signedness = .unsigned,
7251	7251	decoded30: u2 = 0b01,
7252	7252	};
7253	7253
...	...	@@ -7260,7 +7260,7 @@ pub const Instruction = packed union {
7260	7260	decoded17: u6 = 0b111100,
7261	7261	o2: u1 = 0b1,
7262	7262	decoded24: u5 = 0b11110,
7263		U: std.builtin.Signedness = .unsigned,
	7263	U: std.lang.Signedness = .unsigned,
7264	7264	decoded30: u2 = 0b01,
7265	7265	};
7266	7266
...	...	@@ -7273,7 +7273,7 @@ pub const Instruction = packed union {
7273	7273	decoded17: u6 = 0b111100,
7274	7274	o2: u1 = 0b1,
7275	7275	decoded24: u5 = 0b11110,
7276		U: std.builtin.Signedness = .unsigned,
	7276	U: std.lang.Signedness = .unsigned,
7277	7277	decoded30: u2 = 0b01,
7278	7278	};
7279	7279
...	...	@@ -7286,7 +7286,7 @@ pub const Instruction = packed union {
7286	7286	decoded17: u6 = 0b111100,
7287	7287	o2: u1 = 0b1,
7288	7288	decoded24: u5 = 0b11110,
7289		U: std.builtin.Signedness = .unsigned,
	7289	U: std.lang.Signedness = .unsigned,
7290	7290	decoded30: u2 = 0b01,
7291	7291	};
7292	7292
...	...	@@ -7299,7 +7299,7 @@ pub const Instruction = packed union {
7299	7299	decoded17: u6 = 0b111100,
7300	7300	o2: u1 = 0b1,
7301	7301	decoded24: u5 = 0b11110,
7302		U: std.builtin.Signedness = .unsigned,
	7302	U: std.lang.Signedness = .unsigned,
7303	7303	decoded30: u2 = 0b01,
7304	7304	};
7305	7305
...	...	@@ -7312,7 +7312,7 @@ pub const Instruction = packed union {
7312	7312	decoded17: u6 = 0b111100,
7313	7313	o2: u1 = 0b1,
7314	7314	decoded24: u5 = 0b11110,
7315		U: std.builtin.Signedness = .unsigned,
	7315	U: std.lang.Signedness = .unsigned,
7316	7316	decoded30: u2 = 0b01,
7317	7317	};
7318	7318
...	...	@@ -7428,7 +7428,7 @@ pub const Instruction = packed union {
7428	7428	decoded17: u5 = 0b10000,
7429	7429	size: Size,
7430	7430	decoded24: u5 = 0b11110,
7431		U: std.builtin.Signedness,
	7431	U: std.lang.Signedness,
7432	7432	decoded30: u2 = 0b01,
7433	7433	};
7434	7434
...	...	@@ -7441,7 +7441,7 @@ pub const Instruction = packed union {
7441	7441	decoded17: u5 = 0b10000,
7442	7442	size: Size,
7443	7443	decoded24: u5 = 0b11110,
7444		U: std.builtin.Signedness = .signed,
	7444	U: std.lang.Signedness = .signed,
7445	7445	decoded30: u2 = 0b01,
7446	7446	};
7447	7447
...	...	@@ -7454,7 +7454,7 @@ pub const Instruction = packed union {
7454	7454	decoded17: u5 = 0b10000,
7455	7455	size: Size,
7456	7456	decoded24: u5 = 0b11110,
7457		U: std.builtin.Signedness = .signed,
	7457	U: std.lang.Signedness = .signed,
7458	7458	decoded30: u2 = 0b01,
7459	7459	};
7460	7460
...	...	@@ -7467,7 +7467,7 @@ pub const Instruction = packed union {
7467	7467	decoded17: u5 = 0b10000,
7468	7468	size: Size,
7469	7469	decoded24: u5 = 0b11110,
7470		U: std.builtin.Signedness = .signed,
	7470	U: std.lang.Signedness = .signed,
7471	7471	decoded30: u2 = 0b01,
7472	7472	};
7473	7473
...	...	@@ -7480,7 +7480,7 @@ pub const Instruction = packed union {
7480	7480	decoded17: u5 = 0b10000,
7481	7481	size: Size,
7482	7482	decoded24: u5 = 0b11110,
7483		U: std.builtin.Signedness = .signed,
	7483	U: std.lang.Signedness = .signed,
7484	7484	decoded30: u2 = 0b01,
7485	7485	};
7486	7486
...	...	@@ -7493,7 +7493,7 @@ pub const Instruction = packed union {
7493	7493	decoded17: u5 = 0b10000,
7494	7494	size: Size,
7495	7495	decoded24: u5 = 0b11110,
7496		U: std.builtin.Signedness = .signed,
	7496	U: std.lang.Signedness = .signed,
7497	7497	decoded30: u2 = 0b01,
7498	7498	};
7499	7499
...	...	@@ -7506,7 +7506,7 @@ pub const Instruction = packed union {
7506	7506	decoded17: u5 = 0b10000,
7507	7507	size: Size,
7508	7508	decoded24: u5 = 0b11110,
7509		U: std.builtin.Signedness = .signed,
	7509	U: std.lang.Signedness = .signed,
7510	7510	decoded30: u2 = 0b01,
7511	7511	};
7512	7512
...	...	@@ -7519,7 +7519,7 @@ pub const Instruction = packed union {
7519	7519	decoded17: u5 = 0b10000,
7520	7520	size: Size,
7521	7521	decoded24: u5 = 0b11110,
7522		U: std.builtin.Signedness = .signed,
	7522	U: std.lang.Signedness = .signed,
7523	7523	decoded30: u2 = 0b01,
7524	7524	};
7525	7525
...	...	@@ -7533,7 +7533,7 @@ pub const Instruction = packed union {
7533	7533	sz: Sz,
7534	7534	o2: u1 = 0b0,
7535	7535	decoded24: u5 = 0b11110,
7536		U: std.builtin.Signedness = .signed,
	7536	U: std.lang.Signedness = .signed,
7537	7537	decoded30: u2 = 0b01,
7538	7538	};
7539	7539
...	...	@@ -7547,7 +7547,7 @@ pub const Instruction = packed union {
7547	7547	sz: Sz,
7548	7548	o2: u1 = 0b0,
7549	7549	decoded24: u5 = 0b11110,
7550		U: std.builtin.Signedness = .signed,
	7550	U: std.lang.Signedness = .signed,
7551	7551	decoded30: u2 = 0b01,
7552	7552	};
7553	7553
...	...	@@ -7561,7 +7561,7 @@ pub const Instruction = packed union {
7561	7561	sz: Sz,
7562	7562	o2: u1 = 0b0,
7563	7563	decoded24: u5 = 0b11110,
7564		U: std.builtin.Signedness = .signed,
	7564	U: std.lang.Signedness = .signed,
7565	7565	decoded30: u2 = 0b01,
7566	7566	};
7567	7567
...	...	@@ -7575,7 +7575,7 @@ pub const Instruction = packed union {
7575	7575	sz: Sz,
7576	7576	o2: u1 = 0b0,
7577	7577	decoded24: u5 = 0b11110,
7578		U: std.builtin.Signedness = .signed,
	7578	U: std.lang.Signedness = .signed,
7579	7579	decoded30: u2 = 0b01,
7580	7580	};
7581	7581
...	...	@@ -7589,7 +7589,7 @@ pub const Instruction = packed union {
7589	7589	sz: Sz,
7590	7590	o2: u1 = 0b1,
7591	7591	decoded24: u5 = 0b11110,
7592		U: std.builtin.Signedness = .signed,
	7592	U: std.lang.Signedness = .signed,
7593	7593	decoded30: u2 = 0b01,
7594	7594	};
7595	7595
...	...	@@ -7603,7 +7603,7 @@ pub const Instruction = packed union {
7603	7603	sz: Sz,
7604	7604	o2: u1 = 0b1,
7605	7605	decoded24: u5 = 0b11110,
7606		U: std.builtin.Signedness = .signed,
	7606	U: std.lang.Signedness = .signed,
7607	7607	decoded30: u2 = 0b01,
7608	7608	};
7609	7609
...	...	@@ -7617,7 +7617,7 @@ pub const Instruction = packed union {
7617	7617	sz: Sz,
7618	7618	o2: u1 = 0b1,
7619	7619	decoded24: u5 = 0b11110,
7620		U: std.builtin.Signedness = .signed,
	7620	U: std.lang.Signedness = .signed,
7621	7621	decoded30: u2 = 0b01,
7622	7622	};
7623	7623
...	...	@@ -7631,7 +7631,7 @@ pub const Instruction = packed union {
7631	7631	sz: Sz,
7632	7632	o2: u1 = 0b1,
7633	7633	decoded24: u5 = 0b11110,
7634		U: std.builtin.Signedness = .signed,
	7634	U: std.lang.Signedness = .signed,
7635	7635	decoded30: u2 = 0b01,
7636	7636	};
7637	7637
...	...	@@ -7645,7 +7645,7 @@ pub const Instruction = packed union {
7645	7645	sz: Sz,
7646	7646	o2: u1 = 0b1,
7647	7647	decoded24: u5 = 0b11110,
7648		U: std.builtin.Signedness = .signed,
	7648	U: std.lang.Signedness = .signed,
7649	7649	decoded30: u2 = 0b01,
7650	7650	};
7651	7651
...	...	@@ -7659,7 +7659,7 @@ pub const Instruction = packed union {
7659	7659	sz: Sz,
7660	7660	o2: u1 = 0b1,
7661	7661	decoded24: u5 = 0b11110,
7662		U: std.builtin.Signedness = .signed,
	7662	U: std.lang.Signedness = .signed,
7663	7663	decoded30: u2 = 0b01,
7664	7664	};
7665	7665
...	...	@@ -7673,7 +7673,7 @@ pub const Instruction = packed union {
7673	7673	sz: Sz,
7674	7674	o2: u1 = 0b1,
7675	7675	decoded24: u5 = 0b11110,
7676		U: std.builtin.Signedness = .signed,
	7676	U: std.lang.Signedness = .signed,
7677	7677	decoded30: u2 = 0b01,
7678	7678	};
7679	7679
...	...	@@ -7686,7 +7686,7 @@ pub const Instruction = packed union {
7686	7686	decoded17: u5 = 0b10000,
7687	7687	size: Size,
7688	7688	decoded24: u5 = 0b11110,
7689		U: std.builtin.Signedness = .unsigned,
	7689	U: std.lang.Signedness = .unsigned,
7690	7690	decoded30: u2 = 0b01,
7691	7691	};
7692	7692
...	...	@@ -7699,7 +7699,7 @@ pub const Instruction = packed union {
7699	7699	decoded17: u5 = 0b10000,
7700	7700	size: Size,
7701	7701	decoded24: u5 = 0b11110,
7702		U: std.builtin.Signedness = .unsigned,
	7702	U: std.lang.Signedness = .unsigned,
7703	7703	decoded30: u2 = 0b01,
7704	7704	};
7705	7705
...	...	@@ -7712,7 +7712,7 @@ pub const Instruction = packed union {
7712	7712	decoded17: u5 = 0b10000,
7713	7713	size: Size,
7714	7714	decoded24: u5 = 0b11110,
7715		U: std.builtin.Signedness = .unsigned,
	7715	U: std.lang.Signedness = .unsigned,
7716	7716	decoded30: u2 = 0b01,
7717	7717	};
7718	7718
...	...	@@ -7725,7 +7725,7 @@ pub const Instruction = packed union {
7725	7725	decoded17: u5 = 0b10000,
7726	7726	size: Size,
7727	7727	decoded24: u5 = 0b11110,
7728		U: std.builtin.Signedness = .unsigned,
	7728	U: std.lang.Signedness = .unsigned,
7729	7729	decoded30: u2 = 0b01,
7730	7730	};
7731	7731
...	...	@@ -7738,7 +7738,7 @@ pub const Instruction = packed union {
7738	7738	decoded17: u5 = 0b10000,
7739	7739	size: Size,
7740	7740	decoded24: u5 = 0b11110,
7741		U: std.builtin.Signedness = .unsigned,
	7741	U: std.lang.Signedness = .unsigned,
7742	7742	decoded30: u2 = 0b01,
7743	7743	};
7744	7744
...	...	@@ -7751,7 +7751,7 @@ pub const Instruction = packed union {
7751	7751	decoded17: u5 = 0b10000,
7752	7752	size: Size,
7753	7753	decoded24: u5 = 0b11110,
7754		U: std.builtin.Signedness = .unsigned,
	7754	U: std.lang.Signedness = .unsigned,
7755	7755	decoded30: u2 = 0b01,
7756	7756	};
7757	7757
...	...	@@ -7764,7 +7764,7 @@ pub const Instruction = packed union {
7764	7764	decoded17: u5 = 0b10000,
7765	7765	size: Size,
7766	7766	decoded24: u5 = 0b11110,
7767		U: std.builtin.Signedness = .unsigned,
	7767	U: std.lang.Signedness = .unsigned,
7768	7768	decoded30: u2 = 0b01,
7769	7769	};
7770	7770
...	...	@@ -7778,7 +7778,7 @@ pub const Instruction = packed union {
7778	7778	sz: Sz,
7779	7779	o2: u1 = 0b0,
7780	7780	decoded24: u5 = 0b11110,
7781		U: std.builtin.Signedness = .unsigned,
	7781	U: std.lang.Signedness = .unsigned,
7782	7782	decoded30: u2 = 0b01,
7783	7783	};
7784	7784
...	...	@@ -7792,7 +7792,7 @@ pub const Instruction = packed union {
7792	7792	sz: Sz,
7793	7793	o2: u1 = 0b0,
7794	7794	decoded24: u5 = 0b11110,
7795		U: std.builtin.Signedness = .unsigned,
	7795	U: std.lang.Signedness = .unsigned,
7796	7796	decoded30: u2 = 0b01,
7797	7797	};
7798	7798
...	...	@@ -7806,7 +7806,7 @@ pub const Instruction = packed union {
7806	7806	sz: Sz,
7807	7807	o2: u1 = 0b0,
7808	7808	decoded24: u5 = 0b11110,
7809		U: std.builtin.Signedness = .unsigned,
	7809	U: std.lang.Signedness = .unsigned,
7810	7810	decoded30: u2 = 0b01,
7811	7811	};
7812	7812
...	...	@@ -7820,7 +7820,7 @@ pub const Instruction = packed union {
7820	7820	sz: Sz,
7821	7821	o2: u1 = 0b0,
7822	7822	decoded24: u5 = 0b11110,
7823		U: std.builtin.Signedness = .unsigned,
	7823	U: std.lang.Signedness = .unsigned,
7824	7824	decoded30: u2 = 0b01,
7825	7825	};
7826	7826
...	...	@@ -7834,7 +7834,7 @@ pub const Instruction = packed union {
7834	7834	sz: Sz,
7835	7835	o2: u1 = 0b0,
7836	7836	decoded24: u5 = 0b11110,
7837		U: std.builtin.Signedness = .unsigned,
	7837	U: std.lang.Signedness = .unsigned,
7838	7838	decoded30: u2 = 0b01,
7839	7839	};
7840	7840
...	...	@@ -7848,7 +7848,7 @@ pub const Instruction = packed union {
7848	7848	sz: Sz,
7849	7849	o2: u1 = 0b1,
7850	7850	decoded24: u5 = 0b11110,
7851		U: std.builtin.Signedness = .unsigned,
	7851	U: std.lang.Signedness = .unsigned,
7852	7852	decoded30: u2 = 0b01,
7853	7853	};
7854	7854
...	...	@@ -7862,7 +7862,7 @@ pub const Instruction = packed union {
7862	7862	sz: Sz,
7863	7863	o2: u1 = 0b1,
7864	7864	decoded24: u5 = 0b11110,
7865		U: std.builtin.Signedness = .unsigned,
	7865	U: std.lang.Signedness = .unsigned,
7866	7866	decoded30: u2 = 0b01,
7867	7867	};
7868	7868
...	...	@@ -7876,7 +7876,7 @@ pub const Instruction = packed union {
7876	7876	sz: Sz,
7877	7877	o2: u1 = 0b1,
7878	7878	decoded24: u5 = 0b11110,
7879		U: std.builtin.Signedness = .unsigned,
	7879	U: std.lang.Signedness = .unsigned,
7880	7880	decoded30: u2 = 0b01,
7881	7881	};
7882	7882
...	...	@@ -7890,7 +7890,7 @@ pub const Instruction = packed union {
7890	7890	sz: Sz,
7891	7891	o2: u1 = 0b1,
7892	7892	decoded24: u5 = 0b11110,
7893		U: std.builtin.Signedness = .unsigned,
	7893	U: std.lang.Signedness = .unsigned,
7894	7894	decoded30: u2 = 0b01,
7895	7895	};
7896	7896
...	...	@@ -7904,7 +7904,7 @@ pub const Instruction = packed union {
7904	7904	sz: Sz,
7905	7905	o2: u1 = 0b1,
7906	7906	decoded24: u5 = 0b11110,
7907		U: std.builtin.Signedness = .unsigned,
	7907	U: std.lang.Signedness = .unsigned,
7908	7908	decoded30: u2 = 0b01,
7909	7909	};
7910	7910
...	...	@@ -8045,7 +8045,7 @@ pub const Instruction = packed union {
8045	8045	decoded17: u5 = 0b11000,
8046	8046	size: Size,
8047	8047	decoded24: u5 = 0b11110,
8048		U: std.builtin.Signedness,
	8048	U: std.lang.Signedness,
8049	8049	decoded30: u2 = 0b01,
8050	8050	};
8051	8051
...	...	@@ -8058,7 +8058,7 @@ pub const Instruction = packed union {
8058	8058	decoded17: u5 = 0b11000,
8059	8059	size: Size,
8060	8060	decoded24: u5 = 0b11110,
8061		U: std.builtin.Signedness = .signed,
	8061	U: std.lang.Signedness = .signed,
8062	8062	decoded30: u2 = 0b01,
8063	8063	};
8064	8064
...	...	@@ -8262,7 +8262,7 @@ pub const Instruction = packed union {
8262	8262	decoded17: u6 = 0b111100,
8263	8263	a: u1,
8264	8264	decoded24: u5 = 0b01110,
8265		U: std.builtin.Signedness,
	8265	U: std.lang.Signedness,
8266	8266	Q: Q,
8267	8267	decoded31: u1 = 0b0,
8268	8268	};
...	...	@@ -8276,7 +8276,7 @@ pub const Instruction = packed union {
8276	8276	decoded17: u6 = 0b111100,
8277	8277	o2: u1 = 0b0,
8278	8278	decoded24: u5 = 0b01110,
8279		U: std.builtin.Signedness = .signed,
	8279	U: std.lang.Signedness = .signed,
8280	8280	Q: Q,
8281	8281	decoded31: u1 = 0b0,
8282	8282	};
...	...	@@ -8290,7 +8290,7 @@ pub const Instruction = packed union {
8290	8290	decoded17: u6 = 0b111100,
8291	8291	o2: u1 = 0b0,
8292	8292	decoded24: u5 = 0b01110,
8293		U: std.builtin.Signedness = .signed,
	8293	U: std.lang.Signedness = .signed,
8294	8294	Q: Q,
8295	8295	decoded31: u1 = 0b0,
8296	8296	};
...	...	@@ -8304,7 +8304,7 @@ pub const Instruction = packed union {
8304	8304	decoded17: u6 = 0b111100,
8305	8305	o2: u1 = 0b0,
8306	8306	decoded24: u5 = 0b01110,
8307		U: std.builtin.Signedness = .signed,
	8307	U: std.lang.Signedness = .signed,
8308	8308	Q: Q,
8309	8309	decoded31: u1 = 0b0,
8310	8310	};
...	...	@@ -8318,7 +8318,7 @@ pub const Instruction = packed union {
8318	8318	decoded17: u6 = 0b111100,
8319	8319	o2: u1 = 0b0,
8320	8320	decoded24: u5 = 0b01110,
8321		U: std.builtin.Signedness = .signed,
	8321	U: std.lang.Signedness = .signed,
8322	8322	Q: Q,
8323	8323	decoded31: u1 = 0b0,
8324	8324	};
...	...	@@ -8332,7 +8332,7 @@ pub const Instruction = packed union {
8332	8332	decoded17: u6 = 0b111100,
8333	8333	o2: u1 = 0b0,
8334	8334	decoded24: u5 = 0b01110,
8335		U: std.builtin.Signedness = .signed,
	8335	U: std.lang.Signedness = .signed,
8336	8336	Q: Q,
8337	8337	decoded31: u1 = 0b0,
8338	8338	};
...	...	@@ -8346,7 +8346,7 @@ pub const Instruction = packed union {
8346	8346	decoded17: u6 = 0b111100,
8347	8347	o2: u1 = 0b0,
8348	8348	decoded24: u5 = 0b01110,
8349		U: std.builtin.Signedness = .signed,
	8349	U: std.lang.Signedness = .signed,
8350	8350	Q: Q,
8351	8351	decoded31: u1 = 0b0,
8352	8352	};
...	...	@@ -8360,7 +8360,7 @@ pub const Instruction = packed union {
8360	8360	decoded17: u6 = 0b111100,
8361	8361	o2: u1 = 0b1,
8362	8362	decoded24: u5 = 0b01110,
8363		U: std.builtin.Signedness = .signed,
	8363	U: std.lang.Signedness = .signed,
8364	8364	Q: Q,
8365	8365	decoded31: u1 = 0b0,
8366	8366	};
...	...	@@ -8374,7 +8374,7 @@ pub const Instruction = packed union {
8374	8374	decoded17: u6 = 0b111100,
8375	8375	o2: u1 = 0b1,
8376	8376	decoded24: u5 = 0b01110,
8377		U: std.builtin.Signedness = .signed,
	8377	U: std.lang.Signedness = .signed,
8378	8378	Q: Q,
8379	8379	decoded31: u1 = 0b0,
8380	8380	};
...	...	@@ -8388,7 +8388,7 @@ pub const Instruction = packed union {
8388	8388	decoded17: u6 = 0b111100,
8389	8389	o2: u1 = 0b1,
8390	8390	decoded24: u5 = 0b01110,
8391		U: std.builtin.Signedness = .signed,
	8391	U: std.lang.Signedness = .signed,
8392	8392	Q: Q,
8393	8393	decoded31: u1 = 0b0,
8394	8394	};
...	...	@@ -8402,7 +8402,7 @@ pub const Instruction = packed union {
8402	8402	decoded17: u6 = 0b111100,
8403	8403	o2: u1 = 0b1,
8404	8404	decoded24: u5 = 0b01110,
8405		U: std.builtin.Signedness = .signed,
	8405	U: std.lang.Signedness = .signed,
8406	8406	Q: Q,
8407	8407	decoded31: u1 = 0b0,
8408	8408	};
...	...	@@ -8416,7 +8416,7 @@ pub const Instruction = packed union {
8416	8416	decoded17: u6 = 0b111100,
8417	8417	o2: u1 = 0b1,
8418	8418	decoded24: u5 = 0b01110,
8419		U: std.builtin.Signedness = .signed,
	8419	U: std.lang.Signedness = .signed,
8420	8420	Q: Q,
8421	8421	decoded31: u1 = 0b0,
8422	8422	};
...	...	@@ -8430,7 +8430,7 @@ pub const Instruction = packed union {
8430	8430	decoded17: u6 = 0b111100,
8431	8431	o2: u1 = 0b1,
8432	8432	decoded24: u5 = 0b01110,
8433		U: std.builtin.Signedness = .signed,
	8433	U: std.lang.Signedness = .signed,
8434	8434	Q: Q,
8435	8435	decoded31: u1 = 0b0,
8436	8436	};
...	...	@@ -8444,7 +8444,7 @@ pub const Instruction = packed union {
8444	8444	decoded17: u6 = 0b111100,
8445	8445	o2: u1 = 0b1,
8446	8446	decoded24: u5 = 0b01110,
8447		U: std.builtin.Signedness = .signed,
	8447	U: std.lang.Signedness = .signed,
8448	8448	Q: Q,
8449	8449	decoded31: u1 = 0b0,
8450	8450	};
...	...	@@ -8458,7 +8458,7 @@ pub const Instruction = packed union {
8458	8458	decoded17: u6 = 0b111100,
8459	8459	o2: u1 = 0b1,
8460	8460	decoded24: u5 = 0b01110,
8461		U: std.builtin.Signedness = .signed,
	8461	U: std.lang.Signedness = .signed,
8462	8462	Q: Q,
8463	8463	decoded31: u1 = 0b0,
8464	8464	};
...	...	@@ -8472,7 +8472,7 @@ pub const Instruction = packed union {
8472	8472	decoded17: u6 = 0b111100,
8473	8473	o2: u1 = 0b1,
8474	8474	decoded24: u5 = 0b01110,
8475		U: std.builtin.Signedness = .signed,
	8475	U: std.lang.Signedness = .signed,
8476	8476	Q: Q,
8477	8477	decoded31: u1 = 0b0,
8478	8478	};
...	...	@@ -8486,7 +8486,7 @@ pub const Instruction = packed union {
8486	8486	decoded17: u6 = 0b111100,
8487	8487	o2: u1 = 0b0,
8488	8488	decoded24: u5 = 0b01110,
8489		U: std.builtin.Signedness = .unsigned,
	8489	U: std.lang.Signedness = .unsigned,
8490	8490	Q: Q,
8491	8491	decoded31: u1 = 0b0,
8492	8492	};
...	...	@@ -8500,7 +8500,7 @@ pub const Instruction = packed union {
8500	8500	decoded17: u6 = 0b111100,
8501	8501	o2: u1 = 0b0,
8502	8502	decoded24: u5 = 0b01110,
8503		U: std.builtin.Signedness = .unsigned,
	8503	U: std.lang.Signedness = .unsigned,
8504	8504	Q: Q,
8505	8505	decoded31: u1 = 0b0,
8506	8506	};
...	...	@@ -8514,7 +8514,7 @@ pub const Instruction = packed union {
8514	8514	decoded17: u6 = 0b111100,
8515	8515	o2: u1 = 0b0,
8516	8516	decoded24: u5 = 0b01110,
8517		U: std.builtin.Signedness = .unsigned,
	8517	U: std.lang.Signedness = .unsigned,
8518	8518	Q: Q,
8519	8519	decoded31: u1 = 0b0,
8520	8520	};
...	...	@@ -8528,7 +8528,7 @@ pub const Instruction = packed union {
8528	8528	decoded17: u6 = 0b111100,
8529	8529	o2: u1 = 0b0,
8530	8530	decoded24: u5 = 0b01110,
8531		U: std.builtin.Signedness = .unsigned,
	8531	U: std.lang.Signedness = .unsigned,
8532	8532	Q: Q,
8533	8533	decoded31: u1 = 0b0,
8534	8534	};
...	...	@@ -8542,7 +8542,7 @@ pub const Instruction = packed union {
8542	8542	decoded17: u6 = 0b111100,
8543	8543	o2: u1 = 0b0,
8544	8544	decoded24: u5 = 0b01110,
8545		U: std.builtin.Signedness = .unsigned,
	8545	U: std.lang.Signedness = .unsigned,
8546	8546	Q: Q,
8547	8547	decoded31: u1 = 0b0,
8548	8548	};
...	...	@@ -8556,7 +8556,7 @@ pub const Instruction = packed union {
8556	8556	decoded17: u6 = 0b111100,
8557	8557	o2: u1 = 0b0,
8558	8558	decoded24: u5 = 0b01110,
8559		U: std.builtin.Signedness = .unsigned,
	8559	U: std.lang.Signedness = .unsigned,
8560	8560	Q: Q,
8561	8561	decoded31: u1 = 0b0,
8562	8562	};
...	...	@@ -8570,7 +8570,7 @@ pub const Instruction = packed union {
8570	8570	decoded17: u6 = 0b111100,
8571	8571	o2: u1 = 0b1,
8572	8572	decoded24: u5 = 0b01110,
8573		U: std.builtin.Signedness = .unsigned,
	8573	U: std.lang.Signedness = .unsigned,
8574	8574	Q: Q,
8575	8575	decoded31: u1 = 0b0,
8576	8576	};
...	...	@@ -8584,7 +8584,7 @@ pub const Instruction = packed union {
8584	8584	decoded17: u6 = 0b111100,
8585	8585	o2: u1 = 0b1,
8586	8586	decoded24: u5 = 0b01110,
8587		U: std.builtin.Signedness = .unsigned,
	8587	U: std.lang.Signedness = .unsigned,
8588	8588	Q: Q,
8589	8589	decoded31: u1 = 0b0,
8590	8590	};
...	...	@@ -8598,7 +8598,7 @@ pub const Instruction = packed union {
8598	8598	decoded17: u6 = 0b111100,
8599	8599	o2: u1 = 0b1,
8600	8600	decoded24: u5 = 0b01110,
8601		U: std.builtin.Signedness = .unsigned,
	8601	U: std.lang.Signedness = .unsigned,
8602	8602	Q: Q,
8603	8603	decoded31: u1 = 0b0,
8604	8604	};
...	...	@@ -8612,7 +8612,7 @@ pub const Instruction = packed union {
8612	8612	decoded17: u6 = 0b111100,
8613	8613	o2: u1 = 0b1,
8614	8614	decoded24: u5 = 0b01110,
8615		U: std.builtin.Signedness = .unsigned,
	8615	U: std.lang.Signedness = .unsigned,
8616	8616	Q: Q,
8617	8617	decoded31: u1 = 0b0,
8618	8618	};
...	...	@@ -8626,7 +8626,7 @@ pub const Instruction = packed union {
8626	8626	decoded17: u6 = 0b111100,
8627	8627	o2: u1 = 0b1,
8628	8628	decoded24: u5 = 0b01110,
8629		U: std.builtin.Signedness = .unsigned,
	8629	U: std.lang.Signedness = .unsigned,
8630	8630	Q: Q,
8631	8631	decoded31: u1 = 0b0,
8632	8632	};
...	...	@@ -8640,7 +8640,7 @@ pub const Instruction = packed union {
8640	8640	decoded17: u6 = 0b111100,
8641	8641	o2: u1 = 0b1,
8642	8642	decoded24: u5 = 0b01110,
8643		U: std.builtin.Signedness = .unsigned,
	8643	U: std.lang.Signedness = .unsigned,
8644	8644	Q: Q,
8645	8645	decoded31: u1 = 0b0,
8646	8646	};
...	...	@@ -8654,7 +8654,7 @@ pub const Instruction = packed union {
8654	8654	decoded17: u6 = 0b111100,
8655	8655	o2: u1 = 0b1,
8656	8656	decoded24: u5 = 0b01110,
8657		U: std.builtin.Signedness = .unsigned,
	8657	U: std.lang.Signedness = .unsigned,
8658	8658	Q: Q,
8659	8659	decoded31: u1 = 0b0,
8660	8660	};
...	...	@@ -8668,7 +8668,7 @@ pub const Instruction = packed union {
8668	8668	decoded17: u6 = 0b111100,
8669	8669	o2: u1 = 0b1,
8670	8670	decoded24: u5 = 0b01110,
8671		U: std.builtin.Signedness = .unsigned,
	8671	U: std.lang.Signedness = .unsigned,
8672	8672	Q: Q,
8673	8673	decoded31: u1 = 0b0,
8674	8674	};
...	...	@@ -8814,7 +8814,7 @@ pub const Instruction = packed union {
8814	8814	decoded17: u5 = 0b10000,
8815	8815	size: Size,
8816	8816	decoded24: u5 = 0b01110,
8817		U: std.builtin.Signedness,
	8817	U: std.lang.Signedness,
8818	8818	Q: Q,
8819	8819	decoded31: u1 = 0b0,
8820	8820	};
...	...	@@ -8828,7 +8828,7 @@ pub const Instruction = packed union {
8828	8828	decoded17: u5 = 0b10000,
8829	8829	size: Size,
8830	8830	decoded24: u5 = 0b01110,
8831		U: std.builtin.Signedness = .signed,
	8831	U: std.lang.Signedness = .signed,
8832	8832	Q: Q,
8833	8833	decoded31: u1 = 0b0,
8834	8834	};
...	...	@@ -8842,7 +8842,7 @@ pub const Instruction = packed union {
8842	8842	decoded17: u5 = 0b10000,
8843	8843	size: Size,
8844	8844	decoded24: u5 = 0b01110,
8845		U: std.builtin.Signedness = .signed,
	8845	U: std.lang.Signedness = .signed,
8846	8846	Q: Q,
8847	8847	decoded31: u1 = 0b0,
8848	8848	};
...	...	@@ -8856,7 +8856,7 @@ pub const Instruction = packed union {
8856	8856	decoded17: u5 = 0b10000,
8857	8857	size: Size,
8858	8858	decoded24: u5 = 0b01110,
8859		U: std.builtin.Signedness = .signed,
	8859	U: std.lang.Signedness = .signed,
8860	8860	Q: Q,
8861	8861	decoded31: u1 = 0b0,
8862	8862	};
...	...	@@ -8870,7 +8870,7 @@ pub const Instruction = packed union {
8870	8870	decoded17: u5 = 0b10000,
8871	8871	size: Size,
8872	8872	decoded24: u5 = 0b01110,
8873		U: std.builtin.Signedness = .signed,
	8873	U: std.lang.Signedness = .signed,
8874	8874	Q: Q,
8875	8875	decoded31: u1 = 0b0,
8876	8876	};
...	...	@@ -8884,7 +8884,7 @@ pub const Instruction = packed union {
8884	8884	decoded17: u5 = 0b10000,
8885	8885	size: Size,
8886	8886	decoded24: u5 = 0b01110,
8887		U: std.builtin.Signedness = .signed,
	8887	U: std.lang.Signedness = .signed,
8888	8888	Q: Q,
8889	8889	decoded31: u1 = 0b0,
8890	8890	};
...	...	@@ -8898,7 +8898,7 @@ pub const Instruction = packed union {
8898	8898	decoded17: u5 = 0b10000,
8899	8899	size: Size,
8900	8900	decoded24: u5 = 0b01110,
8901		U: std.builtin.Signedness = .signed,
	8901	U: std.lang.Signedness = .signed,
8902	8902	Q: Q,
8903	8903	decoded31: u1 = 0b0,
8904	8904	};
...	...	@@ -8912,7 +8912,7 @@ pub const Instruction = packed union {
8912	8912	decoded17: u5 = 0b10000,
8913	8913	size: Size,
8914	8914	decoded24: u5 = 0b01110,
8915		U: std.builtin.Signedness = .signed,
	8915	U: std.lang.Signedness = .signed,
8916	8916	Q: Q,
8917	8917	decoded31: u1 = 0b0,
8918	8918	};
...	...	@@ -8926,7 +8926,7 @@ pub const Instruction = packed union {
8926	8926	decoded17: u5 = 0b10000,
8927	8927	size: Size,
8928	8928	decoded24: u5 = 0b01110,
8929		U: std.builtin.Signedness = .signed,
	8929	U: std.lang.Signedness = .signed,
8930	8930	Q: Q,
8931	8931	decoded31: u1 = 0b0,
8932	8932	};
...	...	@@ -8941,7 +8941,7 @@ pub const Instruction = packed union {
8941	8941	sz: Sz,
8942	8942	o2: u1 = 0b0,
8943	8943	decoded24: u5 = 0b01110,
8944		U: std.builtin.Signedness = .signed,
	8944	U: std.lang.Signedness = .signed,
8945	8945	Q: Q,
8946	8946	decoded31: u1 = 0b0,
8947	8947	};
...	...	@@ -8956,7 +8956,7 @@ pub const Instruction = packed union {
8956	8956	sz: Sz,
8957	8957	o2: u1 = 0b0,
8958	8958	decoded24: u5 = 0b01110,
8959		U: std.builtin.Signedness = .signed,
	8959	U: std.lang.Signedness = .signed,
8960	8960	Q: Q,
8961	8961	decoded31: u1 = 0b0,
8962	8962	};
...	...	@@ -8971,7 +8971,7 @@ pub const Instruction = packed union {
8971	8971	sz: Sz,
8972	8972	o2: u1 = 0b0,
8973	8973	decoded24: u5 = 0b01110,
8974		U: std.builtin.Signedness = .signed,
	8974	U: std.lang.Signedness = .signed,
8975	8975	Q: Q,
8976	8976	decoded31: u1 = 0b0,
8977	8977	};
...	...	@@ -8986,7 +8986,7 @@ pub const Instruction = packed union {
8986	8986	sz: Sz,
8987	8987	o2: u1 = 0b0,
8988	8988	decoded24: u5 = 0b01110,
8989		U: std.builtin.Signedness = .signed,
	8989	U: std.lang.Signedness = .signed,
8990	8990	Q: Q,
8991	8991	decoded31: u1 = 0b0,
8992	8992	};
...	...	@@ -9001,7 +9001,7 @@ pub const Instruction = packed union {
9001	9001	sz: Sz,
9002	9002	o2: u1 = 0b0,
9003	9003	decoded24: u5 = 0b01110,
9004		U: std.builtin.Signedness = .signed,
	9004	U: std.lang.Signedness = .signed,
9005	9005	Q: Q,
9006	9006	decoded31: u1 = 0b0,
9007	9007	};
...	...	@@ -9016,7 +9016,7 @@ pub const Instruction = packed union {
9016	9016	sz: Sz,
9017	9017	o2: u1 = 0b0,
9018	9018	decoded24: u5 = 0b01110,
9019		U: std.builtin.Signedness = .signed,
	9019	U: std.lang.Signedness = .signed,
9020	9020	Q: Q,
9021	9021	decoded31: u1 = 0b0,
9022	9022	};
...	...	@@ -9031,7 +9031,7 @@ pub const Instruction = packed union {
9031	9031	sz: Sz,
9032	9032	o2: u1 = 0b1,
9033	9033	decoded24: u5 = 0b01110,
9034		U: std.builtin.Signedness = .signed,
	9034	U: std.lang.Signedness = .signed,
9035	9035	Q: Q,
9036	9036	decoded31: u1 = 0b0,
9037	9037	};
...	...	@@ -9046,7 +9046,7 @@ pub const Instruction = packed union {
9046	9046	sz: Sz,
9047	9047	o2: u1 = 0b1,
9048	9048	decoded24: u5 = 0b01110,
9049		U: std.builtin.Signedness = .signed,
	9049	U: std.lang.Signedness = .signed,
9050	9050	Q: Q,
9051	9051	decoded31: u1 = 0b0,
9052	9052	};
...	...	@@ -9061,7 +9061,7 @@ pub const Instruction = packed union {
9061	9061	sz: Sz,
9062	9062	o2: u1 = 0b1,
9063	9063	decoded24: u5 = 0b01110,
9064		U: std.builtin.Signedness = .signed,
	9064	U: std.lang.Signedness = .signed,
9065	9065	Q: Q,
9066	9066	decoded31: u1 = 0b0,
9067	9067	};
...	...	@@ -9076,7 +9076,7 @@ pub const Instruction = packed union {
9076	9076	sz: Sz,
9077	9077	o2: u1 = 0b1,
9078	9078	decoded24: u5 = 0b01110,
9079		U: std.builtin.Signedness = .signed,
	9079	U: std.lang.Signedness = .signed,
9080	9080	Q: Q,
9081	9081	decoded31: u1 = 0b0,
9082	9082	};
...	...	@@ -9091,7 +9091,7 @@ pub const Instruction = packed union {
9091	9091	sz: Sz,
9092	9092	o2: u1 = 0b1,
9093	9093	decoded24: u5 = 0b01110,
9094		U: std.builtin.Signedness = .signed,
	9094	U: std.lang.Signedness = .signed,
9095	9095	Q: Q,
9096	9096	decoded31: u1 = 0b0,
9097	9097	};
...	...	@@ -9106,7 +9106,7 @@ pub const Instruction = packed union {
9106	9106	sz: Sz,
9107	9107	o2: u1 = 0b1,
9108	9108	decoded24: u5 = 0b01110,
9109		U: std.builtin.Signedness = .signed,
	9109	U: std.lang.Signedness = .signed,
9110	9110	Q: Q,
9111	9111	decoded31: u1 = 0b0,
9112	9112	};
...	...	@@ -9121,7 +9121,7 @@ pub const Instruction = packed union {
9121	9121	sz: Sz,
9122	9122	o2: u1 = 0b1,
9123	9123	decoded24: u5 = 0b01110,
9124		U: std.builtin.Signedness = .signed,
	9124	U: std.lang.Signedness = .signed,
9125	9125	Q: Q,
9126	9126	decoded31: u1 = 0b0,
9127	9127	};
...	...	@@ -9136,7 +9136,7 @@ pub const Instruction = packed union {
9136	9136	sz: Sz,
9137	9137	o2: u1 = 0b1,
9138	9138	decoded24: u5 = 0b01110,
9139		U: std.builtin.Signedness = .signed,
	9139	U: std.lang.Signedness = .signed,
9140	9140	Q: Q,
9141	9141	decoded31: u1 = 0b0,
9142	9142	};
...	...	@@ -9151,7 +9151,7 @@ pub const Instruction = packed union {
9151	9151	sz: Sz,
9152	9152	o2: u1 = 0b1,
9153	9153	decoded24: u5 = 0b01110,
9154		U: std.builtin.Signedness = .signed,
	9154	U: std.lang.Signedness = .signed,
9155	9155	Q: Q,
9156	9156	decoded31: u1 = 0b0,
9157	9157	};
...	...	@@ -9165,7 +9165,7 @@ pub const Instruction = packed union {
9165	9165	decoded17: u5 = 0b10000,
9166	9166	size: Size,
9167	9167	decoded24: u5 = 0b01110,
9168		U: std.builtin.Signedness = .unsigned,
	9168	U: std.lang.Signedness = .unsigned,
9169	9169	Q: Q,
9170	9170	decoded31: u1 = 0b0,
9171	9171	};
...	...	@@ -9179,7 +9179,7 @@ pub const Instruction = packed union {
9179	9179	decoded17: u5 = 0b10000,
9180	9180	size: Size,
9181	9181	decoded24: u5 = 0b01110,
9182		U: std.builtin.Signedness = .unsigned,
	9182	U: std.lang.Signedness = .unsigned,
9183	9183	Q: Q,
9184	9184	decoded31: u1 = 0b0,
9185	9185	};
...	...	@@ -9193,7 +9193,7 @@ pub const Instruction = packed union {
9193	9193	decoded17: u5 = 0b10000,
9194	9194	size: Size,
9195	9195	decoded24: u5 = 0b01110,
9196		U: std.builtin.Signedness = .unsigned,
	9196	U: std.lang.Signedness = .unsigned,
9197	9197	Q: Q,
9198	9198	decoded31: u1 = 0b0,
9199	9199	};
...	...	@@ -9207,7 +9207,7 @@ pub const Instruction = packed union {
9207	9207	decoded17: u5 = 0b10000,
9208	9208	size: Size,
9209	9209	decoded24: u5 = 0b01110,
9210		U: std.builtin.Signedness = .unsigned,
	9210	U: std.lang.Signedness = .unsigned,
9211	9211	Q: Q,
9212	9212	decoded31: u1 = 0b0,
9213	9213	};
...	...	@@ -9221,7 +9221,7 @@ pub const Instruction = packed union {
9221	9221	decoded17: u5 = 0b10000,
9222	9222	size: Size,
9223	9223	decoded24: u5 = 0b01110,
9224		U: std.builtin.Signedness = .unsigned,
	9224	U: std.lang.Signedness = .unsigned,
9225	9225	Q: Q,
9226	9226	decoded31: u1 = 0b0,
9227	9227	};
...	...	@@ -9235,7 +9235,7 @@ pub const Instruction = packed union {
9235	9235	decoded17: u5 = 0b10000,
9236	9236	size: Size,
9237	9237	decoded24: u5 = 0b01110,
9238		U: std.builtin.Signedness = .unsigned,
	9238	U: std.lang.Signedness = .unsigned,
9239	9239	Q: Q,
9240	9240	decoded31: u1 = 0b0,
9241	9241	};
...	...	@@ -9249,7 +9249,7 @@ pub const Instruction = packed union {
9249	9249	decoded17: u5 = 0b10000,
9250	9250	size: Size,
9251	9251	decoded24: u5 = 0b01110,
9252		U: std.builtin.Signedness = .unsigned,
	9252	U: std.lang.Signedness = .unsigned,
9253	9253	Q: Q,
9254	9254	decoded31: u1 = 0b0,
9255	9255	};
...	...	@@ -9264,7 +9264,7 @@ pub const Instruction = packed union {
9264	9264	sz: Sz,
9265	9265	o2: u1 = 0b0,
9266	9266	decoded24: u5 = 0b01110,
9267		U: std.builtin.Signedness = .unsigned,
	9267	U: std.lang.Signedness = .unsigned,
9268	9268	Q: Q,
9269	9269	decoded31: u1 = 0b0,
9270	9270	};
...	...	@@ -9279,7 +9279,7 @@ pub const Instruction = packed union {
9279	9279	sz: Sz,
9280	9280	o2: u1 = 0b0,
9281	9281	decoded24: u5 = 0b01110,
9282		U: std.builtin.Signedness = .unsigned,
	9282	U: std.lang.Signedness = .unsigned,
9283	9283	Q: Q,
9284	9284	decoded31: u1 = 0b0,
9285	9285	};
...	...	@@ -9294,7 +9294,7 @@ pub const Instruction = packed union {
9294	9294	sz: Sz,
9295	9295	o2: u1 = 0b0,
9296	9296	decoded24: u5 = 0b01110,
9297		U: std.builtin.Signedness = .unsigned,
	9297	U: std.lang.Signedness = .unsigned,
9298	9298	Q: Q,
9299	9299	decoded31: u1 = 0b0,
9300	9300	};
...	...	@@ -9309,7 +9309,7 @@ pub const Instruction = packed union {
9309	9309	sz: Sz,
9310	9310	o2: u1 = 0b0,
9311	9311	decoded24: u5 = 0b01110,
9312		U: std.builtin.Signedness = .unsigned,
	9312	U: std.lang.Signedness = .unsigned,
9313	9313	Q: Q,
9314	9314	decoded31: u1 = 0b0,
9315	9315	};
...	...	@@ -9324,7 +9324,7 @@ pub const Instruction = packed union {
9324	9324	sz: Sz,
9325	9325	o2: u1 = 0b0,
9326	9326	decoded24: u5 = 0b01110,
9327		U: std.builtin.Signedness = .unsigned,
	9327	U: std.lang.Signedness = .unsigned,
9328	9328	Q: Q,
9329	9329	decoded31: u1 = 0b0,
9330	9330	};
...	...	@@ -9339,7 +9339,7 @@ pub const Instruction = packed union {
9339	9339	sz: Sz,
9340	9340	o2: u1 = 0b0,
9341	9341	decoded24: u5 = 0b01110,
9342		U: std.builtin.Signedness = .unsigned,
	9342	U: std.lang.Signedness = .unsigned,
9343	9343	Q: Q,
9344	9344	decoded31: u1 = 0b0,
9345	9345	};
...	...	@@ -9354,7 +9354,7 @@ pub const Instruction = packed union {
9354	9354	sz: Sz,
9355	9355	o2: u1 = 0b0,
9356	9356	decoded24: u5 = 0b01110,
9357		U: std.builtin.Signedness = .unsigned,
	9357	U: std.lang.Signedness = .unsigned,
9358	9358	Q: Q,
9359	9359	decoded31: u1 = 0b0,
9360	9360	};
...	...	@@ -9368,7 +9368,7 @@ pub const Instruction = packed union {
9368	9368	decoded17: u5 = 0b10000,
9369	9369	size: Size = .byte,
9370	9370	decoded24: u5 = 0b01110,
9371		U: std.builtin.Signedness = .unsigned,
	9371	U: std.lang.Signedness = .unsigned,
9372	9372	Q: Q,
9373	9373	decoded31: u1 = 0b0,
9374	9374	};
...	...	@@ -9383,7 +9383,7 @@ pub const Instruction = packed union {
9383	9383	sz: Sz,
9384	9384	o2: u1 = 0b1,
9385	9385	decoded24: u5 = 0b01110,
9386		U: std.builtin.Signedness = .unsigned,
	9386	U: std.lang.Signedness = .unsigned,
9387	9387	Q: Q,
9388	9388	decoded31: u1 = 0b0,
9389	9389	};
...	...	@@ -9398,7 +9398,7 @@ pub const Instruction = packed union {
9398	9398	sz: Sz,
9399	9399	o2: u1 = 0b1,
9400	9400	decoded24: u5 = 0b01110,
9401		U: std.builtin.Signedness = .unsigned,
	9401	U: std.lang.Signedness = .unsigned,
9402	9402	Q: Q,
9403	9403	decoded31: u1 = 0b0,
9404	9404	};
...	...	@@ -9413,7 +9413,7 @@ pub const Instruction = packed union {
9413	9413	sz: Sz,
9414	9414	o2: u1 = 0b1,
9415	9415	decoded24: u5 = 0b01110,
9416		U: std.builtin.Signedness = .unsigned,
	9416	U: std.lang.Signedness = .unsigned,
9417	9417	Q: Q,
9418	9418	decoded31: u1 = 0b0,
9419	9419	};
...	...	@@ -9428,7 +9428,7 @@ pub const Instruction = packed union {
9428	9428	sz: Sz,
9429	9429	o2: u1 = 0b1,
9430	9430	decoded24: u5 = 0b01110,
9431		U: std.builtin.Signedness = .unsigned,
	9431	U: std.lang.Signedness = .unsigned,
9432	9432	Q: Q,
9433	9433	decoded31: u1 = 0b0,
9434	9434	};
...	...	@@ -9443,7 +9443,7 @@ pub const Instruction = packed union {
9443	9443	sz: Sz,
9444	9444	o2: u1 = 0b1,
9445	9445	decoded24: u5 = 0b01110,
9446		U: std.builtin.Signedness = .unsigned,
	9446	U: std.lang.Signedness = .unsigned,
9447	9447	Q: Q,
9448	9448	decoded31: u1 = 0b0,
9449	9449	};
...	...	@@ -9458,7 +9458,7 @@ pub const Instruction = packed union {
9458	9458	sz: Sz,
9459	9459	o2: u1 = 0b1,
9460	9460	decoded24: u5 = 0b01110,
9461		U: std.builtin.Signedness = .unsigned,
	9461	U: std.lang.Signedness = .unsigned,
9462	9462	Q: Q,
9463	9463	decoded31: u1 = 0b0,
9464	9464	};
...	...	@@ -9473,7 +9473,7 @@ pub const Instruction = packed union {
9473	9473	sz: Sz,
9474	9474	o2: u1 = 0b1,
9475	9475	decoded24: u5 = 0b01110,
9476		U: std.builtin.Signedness = .unsigned,
	9476	U: std.lang.Signedness = .unsigned,
9477	9477	Q: Q,
9478	9478	decoded31: u1 = 0b0,
9479	9479	};
...	...	@@ -9488,7 +9488,7 @@ pub const Instruction = packed union {
9488	9488	sz: Sz,
9489	9489	o2: u1 = 0b1,
9490	9490	decoded24: u5 = 0b01110,
9491		U: std.builtin.Signedness = .unsigned,
	9491	U: std.lang.Signedness = .unsigned,
9492	9492	Q: Q,
9493	9493	decoded31: u1 = 0b0,
9494	9494	};
...	...	@@ -9670,7 +9670,7 @@ pub const Instruction = packed union {
9670	9670	decoded17: u5 = 0b11000,
9671	9671	size: Size,
9672	9672	decoded24: u5 = 0b01110,
9673		U: std.builtin.Signedness,
	9673	U: std.lang.Signedness,
9674	9674	Q: Q,
9675	9675	decoded31: u1 = 0b0,
9676	9676	};
...	...	@@ -9684,7 +9684,7 @@ pub const Instruction = packed union {
9684	9684	decoded17: u5 = 0b11000,
9685	9685	size: Size,
9686	9686	decoded24: u5 = 0b01110,
9687		U: std.builtin.Signedness = .signed,
	9687	U: std.lang.Signedness = .signed,
9688	9688	Q: Q,
9689	9689	decoded31: u1 = 0b0,
9690	9690	};
...	...	@@ -9726,7 +9726,7 @@ pub const Instruction = packed union {
9726	9726	decoded21: u1 = 0b1,
9727	9727	size: Size,
9728	9728	decoded24: u5 = 0b01110,
9729		U: std.builtin.Signedness,
	9729	U: std.lang.Signedness,
9730	9730	Q: Q,
9731	9731	decoded31: u1 = 0b0,
9732	9732	};
...	...	@@ -9741,7 +9741,7 @@ pub const Instruction = packed union {
9741	9741	decoded21: u1 = 0b1,
9742	9742	size: Size,
9743	9743	decoded24: u5 = 0b01110,
9744		U: std.builtin.Signedness = .signed,
	9744	U: std.lang.Signedness = .signed,
9745	9745	Q: Q,
9746	9746	decoded31: u1 = 0b0,
9747	9747	};
...	...	@@ -9756,7 +9756,7 @@ pub const Instruction = packed union {
9756	9756	decoded21: u1 = 0b1,
9757	9757	size: Size = .byte,
9758	9758	decoded24: u5 = 0b01110,
9759		U: std.builtin.Signedness = .signed,
	9759	U: std.lang.Signedness = .signed,
9760	9760	Q: Q,
9761	9761	decoded31: u1 = 0b0,
9762	9762	};
...	...	@@ -9771,7 +9771,7 @@ pub const Instruction = packed union {
9771	9771	decoded21: u1 = 0b1,
9772	9772	size: Size = .half,
9773	9773	decoded24: u5 = 0b01110,
9774		U: std.builtin.Signedness = .signed,
	9774	U: std.lang.Signedness = .signed,
9775	9775	Q: Q,
9776	9776	decoded31: u1 = 0b0,
9777	9777	};
...	...	@@ -9786,7 +9786,7 @@ pub const Instruction = packed union {
9786	9786	decoded21: u1 = 0b1,
9787	9787	size: Size = .single,
9788	9788	decoded24: u5 = 0b01110,
9789		U: std.builtin.Signedness = .signed,
	9789	U: std.lang.Signedness = .signed,
9790	9790	Q: Q,
9791	9791	decoded31: u1 = 0b0,
9792	9792	};
...	...	@@ -9801,7 +9801,7 @@ pub const Instruction = packed union {
9801	9801	decoded21: u1 = 0b1,
9802	9802	size: Size = .double,
9803	9803	decoded24: u5 = 0b01110,
9804		U: std.builtin.Signedness = .signed,
	9804	U: std.lang.Signedness = .signed,
9805	9805	Q: Q,
9806	9806	decoded31: u1 = 0b0,
9807	9807	};
...	...	@@ -9816,7 +9816,7 @@ pub const Instruction = packed union {
9816	9816	decoded21: u1 = 0b1,
9817	9817	size: Size = .byte,
9818	9818	decoded24: u5 = 0b01110,
9819		U: std.builtin.Signedness = .unsigned,
	9819	U: std.lang.Signedness = .unsigned,
9820	9820	Q: Q,
9821	9821	decoded31: u1 = 0b0,
9822	9822	};
...	...	@@ -9831,7 +9831,7 @@ pub const Instruction = packed union {
9831	9831	decoded21: u1 = 0b1,
9832	9832	size: Size = .half,
9833	9833	decoded24: u5 = 0b01110,
9834		U: std.builtin.Signedness = .unsigned,
	9834	U: std.lang.Signedness = .unsigned,
9835	9835	Q: Q,
9836	9836	decoded31: u1 = 0b0,
9837	9837	};
...	...	@@ -9846,7 +9846,7 @@ pub const Instruction = packed union {
9846	9846	decoded21: u1 = 0b1,
9847	9847	size: Size = .single,
9848	9848	decoded24: u5 = 0b01110,
9849		U: std.builtin.Signedness = .unsigned,
	9849	U: std.lang.Signedness = .unsigned,
9850	9850	Q: Q,
9851	9851	decoded31: u1 = 0b0,
9852	9852	};
...	...	@@ -9861,7 +9861,7 @@ pub const Instruction = packed union {
9861	9861	decoded21: u1 = 0b1,
9862	9862	size: Size = .double,
9863	9863	decoded24: u5 = 0b01110,
9864		U: std.builtin.Signedness = .unsigned,
	9864	U: std.lang.Signedness = .unsigned,
9865	9865	Q: Q,
9866	9866	decoded31: u1 = 0b0,
9867	9867	};

src/codegen/c.zig+7-7

...	...	@@ -1997,7 +1997,7 @@ pub const DeclGen = struct {
1997	1997	.bits => {},
1998	1998	}
1999	1999
2000		const int_info: std.builtin.Type.Int = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else .{
	2000	const int_info: std.lang.Type.Int = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else .{
2001	2001	.signedness = .unsigned,
2002	2002	.bits = @intCast(ty.bitSize(zcu)),
2003	2003	};
...	...	@@ -3878,7 +3878,7 @@ fn airSlice(f: *Function, inst: Air.Inst.Index) !CValue {
3878	3878	fn airCall(
3879	3879	f: *Function,
3880	3880	inst: Air.Inst.Index,
3881		modifier: std.builtin.CallModifier,
	3881	modifier: std.lang.CallModifier,
3882	3882	) !CValue {
3883	3883	const pt = f.dg.pt;
3884	3884	const zcu = pt.zcu;
...	...	@@ -6911,7 +6911,7 @@ fn airCVaCopy(f: *Function, inst: Air.Inst.Index) !CValue {
6911	6911	return local;
6912	6912	}
6913	6913
6914		fn toMemoryOrder(order: std.builtin.AtomicOrder) [:0]const u8 {
	6914	fn toMemoryOrder(order: std.lang.AtomicOrder) [:0]const u8 {
6915	6915	return switch (order) {
6916	6916	// Note: unordered is actually even less atomic than relaxed
6917	6917	.unordered, .monotonic => "zig_memory_order_relaxed",
...	...	@@ -6922,11 +6922,11 @@ fn toMemoryOrder(order: std.builtin.AtomicOrder) [:0]const u8 {
6922	6922	};
6923	6923	}
6924	6924
6925		fn writeMemoryOrder(w: *Writer, order: std.builtin.AtomicOrder) !void {
	6925	fn writeMemoryOrder(w: *Writer, order: std.lang.AtomicOrder) !void {
6926	6926	return w.writeAll(toMemoryOrder(order));
6927	6927	}
6928	6928
6929		fn toCallingConvention(cc: std.builtin.CallingConvention, zcu: *Zcu) ?[]const u8 {
	6929	fn toCallingConvention(cc: std.lang.CallingConvention, zcu: *Zcu) ?[]const u8 {
6930	6930	if (zcu.getTarget().cCallingConvention()) \|ccc\| {
6931	6931	if (cc.eql(ccc)) {
6932	6932	return null;
...	...	@@ -7021,7 +7021,7 @@ fn toCallingConvention(cc: std.builtin.CallingConvention, zcu: *Zcu) ?[]const u8
7021	7021	};
7022	7022	}
7023	7023
7024		fn toAtomicRmwSuffix(order: std.builtin.AtomicRmwOp) []const u8 {
	7024	fn toAtomicRmwSuffix(order: std.lang.AtomicRmwOp) []const u8 {
7025	7025	return switch (order) {
7026	7026	.Xchg => "xchg",
7027	7027	.Add => "add",
...	...	@@ -7044,7 +7044,7 @@ fn toCIntBits(zig_bits: u32) ?u32 {
7044	7044	return null;
7045	7045	}
7046	7046
7047		fn signAbbrev(signedness: std.builtin.Signedness) u8 {
	7047	fn signAbbrev(signedness: std.lang.Signedness) u8 {
7048	7048	return switch (signedness) {
7049	7049	.signed => 'i',
7050	7050	.unsigned => 'u',

src/codegen/c/type.zig+1-1

...	...	@@ -512,7 +512,7 @@ pub const CType = union(enum) {
512	512	},
513	513	}
514	514	}
515		fn classifyBitInt(signedness: std.builtin.Signedness, bits: u16, zcu: *const Zcu) IntClass {
	515	fn classifyBitInt(signedness: std.lang.Signedness, bits: u16, zcu: *const Zcu) IntClass {
516	516	const is_ez80 = zcu.getTarget().cpu.arch == .ez80;
517	517	return switch (bits) {
518	518	0 => .void,

src/codegen/llvm.zig+17-17

...	...	@@ -500,7 +500,7 @@ const CodeModel = enum {
500	500	large,
501	501	};
502	502
503		fn codeModel(model: std.builtin.CodeModel, target: *const std.Target) CodeModel {
	503	fn codeModel(model: std.lang.CodeModel, target: *const std.Target) CodeModel {
504	504	// Roughly match Clang's mapping of GCC code models to LLVM code models.
505	505	return switch (model) {
506	506	.default => .default,
...	...	@@ -556,7 +556,7 @@ pub const Object = struct {
556	556	/// Same as `nav_map` but for UAVs (which are always global constants).
557	557	uav_map: std.AutoHashMapUnmanaged(struct {
558	558	val: InternPool.Index,
559		@"addrspace": std.builtin.AddressSpace,
	559	@"addrspace": std.lang.AddressSpace,
560	560	}, Builder.Variable.Index),
561	561	/// Maps enum types to their corresponding LLVM functions for implementing the `tag_name` instruction.
562	562	enum_tag_name_map: std.AutoHashMapUnmanaged(InternPool.Index, Builder.Function.Index),
...	...	@@ -3986,7 +3986,7 @@ pub const Object = struct {
3986	3986	o: *Object,
3987	3987	/// Must not be `.none`.
3988	3988	@"align": InternPool.Alignment,
3989		@"addrspace": std.builtin.AddressSpace,
	3989	@"addrspace": std.lang.AddressSpace,
3990	3990	) Allocator.Error!Builder.Constant {
3991	3991	const addr: u64 = @"align".toByteUnits().?;
3992	3992	const llvm_usize = try o.lowerType(.usize);
...	...	@@ -4000,7 +4000,7 @@ pub const Object = struct {
4000	4000	uav_val: InternPool.Index,
4001	4001	/// Must not be `.none`.
4002	4002	@"align": InternPool.Alignment,
4003		@"addrspace": std.builtin.AddressSpace,
	4003	@"addrspace": std.lang.AddressSpace,
4004	4004	) Allocator.Error!Builder.Constant {
4005	4005	assert(@"align" != .none);
4006	4006
...	...	@@ -4383,20 +4383,20 @@ const CallingConventionInfo = struct {
4383	4383	inreg_param_count: u2 = 0,
4384	4384	};
4385	4385
4386		pub fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: *const std.Target) ?CallingConventionInfo {
	4386	pub fn toLlvmCallConv(cc: std.lang.CallingConvention, target: *const std.Target) ?CallingConventionInfo {
4387	4387	const llvm_cc = toLlvmCallConvTag(cc, target) orelse return null;
4388	4388	const incoming_stack_alignment: ?u64, const register_params: u2 = switch (cc) {
4389	4389	inline else => \|pl\| switch (@TypeOf(pl)) {
4390	4390	void => .{ null, 0 },
4391		std.builtin.CallingConvention.ArcInterruptOptions,
4392		std.builtin.CallingConvention.ArmInterruptOptions,
4393		std.builtin.CallingConvention.RiscvInterruptOptions,
4394		std.builtin.CallingConvention.ShInterruptOptions,
4395		std.builtin.CallingConvention.MicroblazeInterruptOptions,
4396		std.builtin.CallingConvention.MipsInterruptOptions,
4397		std.builtin.CallingConvention.CommonOptions,
	4391	std.lang.CallingConvention.ArcInterruptOptions,
	4392	std.lang.CallingConvention.ArmInterruptOptions,
	4393	std.lang.CallingConvention.RiscvInterruptOptions,
	4394	std.lang.CallingConvention.ShInterruptOptions,
	4395	std.lang.CallingConvention.MicroblazeInterruptOptions,
	4396	std.lang.CallingConvention.MipsInterruptOptions,
	4397	std.lang.CallingConvention.CommonOptions,
4398	4398	=> .{ pl.incoming_stack_alignment, 0 },
4399		std.builtin.CallingConvention.X86RegparmOptions => .{ pl.incoming_stack_alignment, pl.register_params },
	4399	std.lang.CallingConvention.X86RegparmOptions => .{ pl.incoming_stack_alignment, pl.register_params },
4400	4400	else => @compileError("TODO: toLlvmCallConv" ++ @tagName(pl)),
4401	4401	},
4402	4402	};
...	...	@@ -4410,7 +4410,7 @@ pub fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: *const std.Targ
4410	4410	.inreg_param_count = register_params,
4411	4411	};
4412	4412	}
4413		pub fn toLlvmCallConvTag(cc_tag: std.builtin.CallingConvention.Tag, target: *const std.Target) ?Builder.CallConv {
	4413	pub fn toLlvmCallConvTag(cc_tag: std.lang.CallingConvention.Tag, target: *const std.Target) ?Builder.CallConv {
4414	4414	if (target.cCallingConvention()) \|default_c\| {
4415	4415	if (cc_tag == default_c) {
4416	4416	return .ccc;
...	...	@@ -4543,13 +4543,13 @@ pub fn toLlvmCallConvTag(cc_tag: std.builtin.CallingConvention.Tag, target: *con
4543	4543	}
4544	4544
4545	4545	/// Convert a zig-address space to an llvm address space.
4546		pub fn toLlvmAddressSpace(address_space: std.builtin.AddressSpace, target: *const std.Target) Builder.AddrSpace {
	4546	pub fn toLlvmAddressSpace(address_space: std.lang.AddressSpace, target: *const std.Target) Builder.AddrSpace {
4547	4547	for (llvmAddrSpaceInfo(target)) \|info\| if (info.zig == address_space) return info.llvm;
4548	4548	unreachable;
4549	4549	}
4550	4550
4551	4551	const AddrSpaceInfo = struct {
4552		zig: ?std.builtin.AddressSpace,
	4552	zig: ?std.lang.AddressSpace,
4553	4553	llvm: Builder.AddrSpace,
4554	4554	non_integral: bool = false,
4555	4555	size: ?u16 = null,
...	...	@@ -4643,7 +4643,7 @@ fn llvmDefaultGlobalAddressSpace(target: *const std.Target) Builder.AddrSpace {
4643	4643
4644	4644	/// Return the actual address space that a value should be stored in if its a global address space.
4645	4645	/// When a value is placed in the resulting address space, it needs to be cast back into wanted_address_space.
4646		fn toLlvmGlobalAddressSpace(wanted_address_space: std.builtin.AddressSpace, target: *const std.Target) Builder.AddrSpace {
	4646	fn toLlvmGlobalAddressSpace(wanted_address_space: std.lang.AddressSpace, target: *const std.Target) Builder.AddrSpace {
4647	4647	return switch (wanted_address_space) {
4648	4648	.generic => llvmDefaultGlobalAddressSpace(target),
4649	4649	else => \|as\| toLlvmAddressSpace(as, target),

src/codegen/llvm/FuncGen.zig+8-8

...	...	@@ -567,7 +567,7 @@ const CallAttr = enum {
567	567	AlwaysInline,
568	568	};
569	569
570		fn airCall(self: *FuncGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) Allocator.Error!Builder.Value {
	570	fn airCall(self: *FuncGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier) Allocator.Error!Builder.Value {
571	571	const air_call = self.air.unwrapCall(inst);
572	572	const args = air_call.args;
573	573	const o = self.object;
...	...	@@ -6017,14 +6017,14 @@ fn airPrefetch(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Val
6017	6017	const o = self.object;
6018	6018	const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
6019	6019
6020		comptime assert(@intFromEnum(std.builtin.PrefetchOptions.Rw.read) == 0);
6021		comptime assert(@intFromEnum(std.builtin.PrefetchOptions.Rw.write) == 1);
	6020	comptime assert(@intFromEnum(std.lang.PrefetchOptions.Rw.read) == 0);
	6021	comptime assert(@intFromEnum(std.lang.PrefetchOptions.Rw.write) == 1);
6022	6022
6023	6023	comptime assert(prefetch.locality >= 0);
6024	6024	comptime assert(prefetch.locality <= 3);
6025	6025
6026		comptime assert(@intFromEnum(std.builtin.PrefetchOptions.Cache.instruction) == 0);
6027		comptime assert(@intFromEnum(std.builtin.PrefetchOptions.Cache.data) == 1);
	6026	comptime assert(@intFromEnum(std.lang.PrefetchOptions.Cache.instruction) == 0);
	6027	comptime assert(@intFromEnum(std.lang.PrefetchOptions.Cache.data) == 1);
6028	6028
6029	6029	// LLVM fails during codegen of instruction cache prefetchs for these architectures.
6030	6030	// 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
7106	7106	/// has different ABI than regular integer types, and there is no currently no
7107	7107	/// way to determine whether a Zig integer type is meant to represent e.g. `int`
7108	7108	/// or `_BitInt(32)`.
7109		pub fn ccAbiPromoteInt(cc: std.builtin.CallingConvention, zcu: *Zcu, ty: Type) ?std.builtin.Signedness {
	7109	pub fn ccAbiPromoteInt(cc: std.lang.CallingConvention, zcu: *Zcu, ty: Type) ?std.lang.Signedness {
7110	7110	switch (cc) {
7111	7111	.auto, .@"inline", .async => return null,
7112	7112	else => {},
...	...	@@ -7379,7 +7379,7 @@ fn intrinsicsAllowed(scalar_ty: Type, target: *const std.Target) bool {
7379	7379	};
7380	7380	}
7381	7381
7382		fn toLlvmAtomicOrdering(atomic_order: std.builtin.AtomicOrder) Builder.AtomicOrdering {
	7382	fn toLlvmAtomicOrdering(atomic_order: std.lang.AtomicOrder) Builder.AtomicOrdering {
7383	7383	return switch (atomic_order) {
7384	7384	.unordered => .unordered,
7385	7385	.monotonic => .monotonic,
...	...	@@ -7391,7 +7391,7 @@ fn toLlvmAtomicOrdering(atomic_order: std.builtin.AtomicOrder) Builder.AtomicOrd
7391	7391	}
7392	7392
7393	7393	fn toLlvmAtomicRmwBinOp(
7394		op: std.builtin.AtomicRmwOp,
	7394	op: std.lang.AtomicRmwOp,
7395	7395	is_signed: bool,
7396	7396	is_float: bool,
7397	7397	) Builder.Function.Instruction.AtomicRmw.Operation {

src/codegen/riscv64/CodeGen.zig+4-4

...	...	@@ -1901,7 +1901,7 @@ fn splitType(func: *Func, ty: Type) ![2]Type {
1901	1901	fn truncateRegister(func: *Func, ty: Type, reg: Register) !void {
1902	1902	const pt = func.pt;
1903	1903	const zcu = pt.zcu;
1904		const int_info = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else std.builtin.Type.Int{
	1904	const int_info = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else std.lang.Type.Int{
1905	1905	.signedness = .unsigned,
1906	1906	.bits = @intCast(ty.bitSize(zcu)),
1907	1907	};
...	...	@@ -4788,7 +4788,7 @@ fn airFrameAddress(func: *Func, inst: Air.Inst.Index) !void {
4788	4788	return func.finishAir(inst, dst_mcv, .{ .none, .none, .none });
4789	4789	}
4790	4790
4791		fn airCall(func: *Func, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
	4791	fn airCall(func: *Func, inst: Air.Inst.Index, modifier: std.lang.CallModifier) !void {
4792	4792	if (modifier == .always_tail) return func.fail("TODO implement tail calls for riscv64", .{});
4793	4793	const call = func.air.unwrapCall(inst);
4794	4794	const arg_refs = call.args;
...	...	@@ -7691,7 +7691,7 @@ fn airAtomicLoad(func: *Func, inst: Air.Inst.Index) !void {
7691	7691	const pt = func.pt;
7692	7692	const zcu = pt.zcu;
7693	7693	const atomic_load = func.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
7694		const order: std.builtin.AtomicOrder = atomic_load.order;
	7694	const order: std.lang.AtomicOrder = atomic_load.order;
7695	7695
7696	7696	const ptr_ty = func.typeOf(atomic_load.ptr);
7697	7697	const elem_ty = ptr_ty.childType(zcu);
...	...	@@ -7737,7 +7737,7 @@ fn airAtomicLoad(func: *Func, inst: Air.Inst.Index) !void {
7737	7737	return func.finishAir(inst, result_mcv, .{ atomic_load.ptr, .none, .none });
7738	7738	}
7739	7739
7740		fn airAtomicStore(func: *Func, inst: Air.Inst.Index, order: std.builtin.AtomicOrder) !void {
	7740	fn airAtomicStore(func: *Func, inst: Air.Inst.Index, order: std.lang.AtomicOrder) !void {
7741	7741	const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
7742	7742
7743	7743	const ptr_ty = func.typeOf(bin_op.lhs);

src/codegen/riscv64/Lower.zig+3-3

...	...	@@ -1,12 +1,12 @@
1	1	//! This file contains the functionality for lowering RISC-V MIR to Instructions
2	2
3	3	pt: Zcu.PerThread,
4		output_mode: std.builtin.OutputMode,
5		link_mode: std.builtin.LinkMode,
	4	output_mode: std.lang.OutputMode,
	5	link_mode: std.lang.LinkMode,
6	6	pic: bool,
7	7	allocator: Allocator,
8	8	mir: Mir,
9		cc: std.builtin.CallingConvention,
	9	cc: std.lang.CallingConvention,
10	10	err_msg: ?*ErrorMsg = null,
11	11	src_loc: Zcu.LazySrcLoc,
12	12	result_insts_len: u8 = undefined,

src/codegen/sparc64/CodeGen.zig+3-3

...	...	@@ -20,7 +20,7 @@ const Mir = @import("Mir.zig");
20	20	const Emit = @import("Emit.zig");
21	21	const Type = @import("../../Type.zig");
22	22	const CodeGenError = codegen.CodeGenError;
23		const Endian = std.builtin.Endian;
	23	const Endian = std.lang.Endian;
24	24	const Alignment = InternPool.Alignment;
25	25
26	26	const build_options = @import("build_options");
...	...	@@ -1255,7 +1255,7 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
1255	1255	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1256	1256	}
1257	1257
1258		fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
	1258	fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.lang.CallModifier) !void {
1259	1259	if (modifier == .always_tail) return self.fail("TODO implement tail calls for {}", .{self.target.cpu.arch});
1260	1260
1261	1261	const call = self.air.unwrapCall(inst);
...	...	@@ -4702,7 +4702,7 @@ fn truncRegister(
4702	4702	self: *Self,
4703	4703	operand_reg: Register,
4704	4704	dest_reg: Register,
4705		int_signedness: std.builtin.Signedness,
	4705	int_signedness: std.lang.Signedness,
4706	4706	int_bits: u16,
4707	4707	) !void {
4708	4708	switch (int_bits) {

src/codegen/sparc64/Emit.zig+1-1

...	...	@@ -2,7 +2,7 @@
2	2	//! machine code
3	3
4	4	const std = @import("std");
5		const Endian = std.builtin.Endian;
	5	const Endian = std.lang.Endian;
6	6	const assert = std.debug.assert;
7	7	const link = @import("../../link.zig");
8	8	const Zcu = @import("../../Zcu.zig");

src/codegen/spirv/Assembler.zig+2-2

...	...	@@ -212,7 +212,7 @@ fn processTypeInstruction(ass: *Assembler) !AsmValue {
212	212	.OpTypeVoid => try module.voidType(),
213	213	.OpTypeBool => try module.boolType(),
214	214	.OpTypeInt => blk: {
215		const signedness: std.builtin.Signedness = switch (operands[2].literal32) {
	215	const signedness: std.lang.Signedness = switch (operands[2].literal32) {
216	216	0 => .unsigned,
217	217	1 => .signed,
218	218	else => {
...	...	@@ -766,7 +766,7 @@ fn parseContextDependentNumber(ass: *Assembler) !void {
766	766	return ass.fail(tok.start, "cannot parse literal constant", .{});
767	767	}
768	768
769		fn parseContextDependentInt(ass: *Assembler, signedness: std.builtin.Signedness, width: u32) !void {
	769	fn parseContextDependentInt(ass: *Assembler, signedness: std.lang.Signedness, width: u32) !void {
770	770	const gpa = ass.cg.module.gpa;
771	771
772	772	const tok = ass.currentToken();

src/codegen/spirv/CodeGen.zig+4-4

...	...	@@ -1,7 +1,7 @@
1	1	const std = @import("std");
2	2	const Allocator = std.mem.Allocator;
3	3	const Target = std.Target;
4		const Signedness = std.builtin.Signedness;
	4	const Signedness = std.lang.Signedness;
5	5	const assert = std.debug.assert;
6	6	const log = std.log.scoped(.codegen);
7	7
...	...	@@ -569,7 +569,7 @@ const ArithmeticTypeInfo = struct {
569	569	/// Null if this type is a scalar, or the length of the vector otherwise.
570	570	vector_len: ?u32,
571	571	/// Whether the inner type is signed. Only relevant for integers.
572		signedness: std.builtin.Signedness,
	572	signedness: std.lang.Signedness,
573	573	};
574	574
575	575	fn arithmeticTypeInfo(cg: *CodeGen, ty: Type) ArithmeticTypeInfo {
...	...	@@ -2251,7 +2251,7 @@ fn buildBinary(cg: *CodeGen, opcode: Opcode, lhs: Temporary, rhs: Temporary) !Te
2251	2251	/// or OpIMul and s_mul_hi or u_mul_hi on OpenCL.
2252	2252	fn buildWideMul(
2253	2253	cg: *CodeGen,
2254		signedness: std.builtin.Signedness,
	2254	signedness: std.lang.Signedness,
2255	2255	lhs: Temporary,
2256	2256	rhs: Temporary,
2257	2257	) !struct { Temporary, Temporary } {
...	...	@@ -5976,7 +5976,7 @@ fn airAssembly(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
5976	5976	return null;
5977	5977	}
5978	5978
5979		fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !?Id {
	5979	fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier) !?Id {
5980	5980	_ = modifier;
5981	5981
5982	5982	const gpa = cg.module.gpa;

src/codegen/spirv/Module.zig+4-4

...	...	@@ -54,8 +54,8 @@ cache: struct {
54	54	bool_type: ?Id = null,
55	55	void_type: ?Id = null,
56	56	opaque_types: std.StringHashMapUnmanaged(Id) = .empty,
57		int_types: std.AutoHashMapUnmanaged(std.builtin.Type.Int, Id) = .empty,
58		float_types: std.AutoHashMapUnmanaged(std.builtin.Type.Float, Id) = .empty,
	57	int_types: std.AutoHashMapUnmanaged(std.lang.Type.Int, Id) = .empty,
	58	float_types: std.AutoHashMapUnmanaged(std.lang.Type.Float, Id) = .empty,
59	59	vector_types: std.AutoHashMapUnmanaged(struct { Id, u32 }, Id) = .empty,
60	60	array_types: std.AutoHashMapUnmanaged(struct { Id, Id }, Id) = .empty,
61	61	struct_types: std.ArrayHashMapUnmanaged(StructType, Id, StructType.HashContext, true) = .empty,
...	...	@@ -582,7 +582,7 @@ pub fn backingIntBits(module: *Module, bits: u16) struct { u16, bool } {
582	582	return .{ std.mem.alignForward(u16, bits, big_int_bits), true };
583	583	}
584	584
585		pub fn intType(module: *Module, signedness: std.builtin.Signedness, bits: u16) !Id {
	585	pub fn intType(module: *Module, signedness: std.lang.Signedness, bits: u16) !Id {
586	586	assert(bits > 0);
587	587
588	588	const target = module.zcu.getTarget();
...	...	@@ -918,7 +918,7 @@ pub fn debugString(module: *Module, string: []const u8) !Id {
918	918	return entry.value_ptr.*;
919	919	}
920	920
921		pub fn storageClass(module: *Module, as: std.builtin.AddressSpace) spec.StorageClass {
	921	pub fn storageClass(module: *Module, as: std.lang.AddressSpace) spec.StorageClass {
922	922	const target = module.zcu.getTarget();
923	923	return switch (as) {
924	924	.generic => .function,

src/codegen/wasm/CodeGen.zig+4-4

...	...	@@ -951,7 +951,7 @@ fn resolveCallingConventionValues(
951	951	}
952	952
953	953	pub fn firstParamSRet(
954		cc: std.builtin.CallingConvention,
	954	cc: std.lang.CallingConvention,
955	955	return_type: Type,
956	956	zcu: *const Zcu,
957	957	target: *const std.Target,
...	...	@@ -970,7 +970,7 @@ pub fn firstParamSRet(
970	970
971	971	/// Lowers a Zig type and its value based on a given calling convention to ensure
972	972	/// it matches the ABI.
973		fn lowerArg(cg: *CodeGen, cc: std.builtin.CallingConvention, ty: Type, value: WValue) !void {
	973	fn lowerArg(cg: *CodeGen, cc: std.lang.CallingConvention, ty: Type, value: WValue) !void {
974	974	if (cc != .wasm_mvp) {
975	975	return cg.lowerToStack(value);
976	976	}
...	...	@@ -1989,7 +1989,7 @@ fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
1989	1989	return cg.finishAir(inst, .none, &.{un_op});
1990	1990	}
1991	1991
1992		fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) InnerError!void {
	1992	fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier) InnerError!void {
1993	1993	if (modifier == .always_tail) return cg.fail("TODO implement tail calls for wasm", .{});
1994	1994	const call = cg.air.unwrapCall(inst);
1995	1995	const args = call.args;
...	...	@@ -7268,7 +7268,7 @@ fn airAtomicRmw(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
7268	7268	const ptr = try cg.resolveInst(pl_op.operand);
7269	7269	const operand = try cg.resolveInst(extra.operand);
7270	7270	const ty = cg.typeOfIndex(inst);
7271		const op: std.builtin.AtomicRmwOp = extra.op();
	7271	const op: std.lang.AtomicRmwOp = extra.op();
7272	7272
7273	7273	if (cg.useAtomicFeature()) {
7274	7274	const int_ty: IntType = .fromType(cg, ty);

src/codegen/x86_64/CodeGen.zig+15-15

...	...	@@ -173952,7 +173952,7 @@ fn setFrameLoc(
173952	173952	offset.* += self.frame_allocs.items(.abi_size)[frame_i];
173953	173953	}
173954	173954
173955		fn computeFrameLayout(self: *CodeGen, cc: std.builtin.CallingConvention.Tag) !FrameLayout {
	173955	fn computeFrameLayout(self: *CodeGen, cc: std.lang.CallingConvention.Tag) !FrameLayout {
173956	173956	const frame_allocs_len = self.frame_allocs.len;
173957	173957	try self.frame_locs.resize(self.gpa, frame_allocs_len);
173958	173958	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 {
174294	174294	}
174295	174295	}
174296	174296
174297		pub fn spillCallerPreservedRegs(self: *CodeGen, cc: std.builtin.CallingConvention.Tag, ignore_reg: Register) !void {
	174297	pub fn spillCallerPreservedRegs(self: *CodeGen, cc: std.lang.CallingConvention.Tag, ignore_reg: Register) !void {
174298	174298	switch (cc) {
174299	174299	inline .auto, .x86_64_sysv, .x86_64_win => \|tag\| inline for (comptime abi.getCallerPreservedRegs(tag)) \|reg\|
174300	174300	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
175917	175917	};
175918	175918	}
175919	175919
175920		fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier, opts: CopyOptions) !void {
	175920	fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier, opts: CopyOptions) !void {
175921	175921	if (modifier == .always_tail) return self.fail("TODO implement tail calls for x86_64", .{});
175922	175922
175923	175923	const call = self.air.unwrapCall(inst);
...	...	@@ -179498,7 +179498,7 @@ fn airBitCast(self: *CodeGen, inst: Air.Inst.Index) !void {
179498	179498	);
179499	179499	var offset = dst_limbs_len * 8;
179500	179500	if (offset < abi_size) {
179501		const dst_signedness: std.builtin.Signedness = if (dst_ty.isAbiInt(zcu))
	179501	const dst_signedness: std.lang.Signedness = if (dst_ty.isAbiInt(zcu))
179502	179502	dst_ty.intInfo(zcu).signedness
179503	179503	else
179504	179504	.unsigned;
...	...	@@ -179640,8 +179640,8 @@ fn atomicOp(
179640	179640	ptr_ty: Type,
179641	179641	val_ty: Type,
179642	179642	unused: bool,
179643		rmw_op: ?std.builtin.AtomicRmwOp,
179644		order: std.builtin.AtomicOrder,
	179643	rmw_op: ?std.lang.AtomicRmwOp,
	179644	order: std.lang.AtomicOrder,
179645	179645	) InnerError!MCValue {
179646	179646	const pt = self.pt;
179647	179647	const zcu = pt.zcu;
...	...	@@ -179714,7 +179714,7 @@ fn atomicOp(
179714	179714	defer self.register_manager.unlockReg(dst_lock);
179715	179715
179716	179716	try self.genSetReg(dst_reg, val_ty, val_mcv, .{});
179717		if (rmw_op == std.builtin.AtomicRmwOp.Sub and mir_tag[1] == .xadd) {
	179717	if (rmw_op == std.lang.AtomicRmwOp.Sub and mir_tag[1] == .xadd) {
179718	179718	try self.genUnOpMir(.{ ._, .neg }, val_ty, dst_mcv);
179719	179719	}
179720	179720	try self.asmMemoryRegister(mir_tag, ptr_mem, registerAlias(dst_reg, val_abi_size));
...	...	@@ -179898,7 +179898,7 @@ fn atomicOp(
179898	179898	};
179899	179899	const val_lo_mem = try val_mem_mcv.mem(self, .{ .size = .qword });
179900	179900	const val_hi_mem = try val_mem_mcv.address().offset(8).deref().mem(self, .{ .size = .qword });
179901		if (rmw_op != std.builtin.AtomicRmwOp.Xchg) {
	179901	if (rmw_op != std.lang.AtomicRmwOp.Xchg) {
179902	179902	try self.asmRegisterRegister(.{ ._, .mov }, .rbx, .rax);
179903	179903	try self.asmRegisterRegister(.{ ._, .mov }, .rcx, .rdx);
179904	179904	}
...	...	@@ -180033,7 +180033,7 @@ fn airAtomicLoad(self: *CodeGen, inst: Air.Inst.Index) !void {
180033	180033	return self.finishAir(inst, result, .{ atomic_load.ptr, .none, .none });
180034	180034	}
180035	180035
180036		fn airAtomicStore(self: *CodeGen, inst: Air.Inst.Index, order: std.builtin.AtomicOrder) !void {
	180036	fn airAtomicStore(self: *CodeGen, inst: Air.Inst.Index, order: std.lang.AtomicOrder) !void {
180037	180037	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
180038	180038
180039	180039	const ptr_ty = self.typeOf(bin_op.lhs);
...	...	@@ -181813,7 +181813,7 @@ fn nonBoolScalarBitSize(cg: *CodeGen, ty: Type) u32 {
181813	181813	};
181814	181814	}
181815	181815
181816		fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int {
	181816	fn intInfo(cg: *CodeGen, ty: Type) ?std.lang.Type.Int {
181817	181817	const zcu = cg.pt.zcu;
181818	181818	const ip = &zcu.intern_pool;
181819	181819	var ty_index = ty.ip_index;
...	...	@@ -188528,7 +188528,7 @@ const Select = struct {
188528	188528
188529	188529	const ConstSpec = struct {
188530	188530	ref: Select.Operand.Ref = .none,
188531		to_signedness: ?std.builtin.Signedness = null,
	188531	to_signedness: ?std.lang.Signedness = null,
188532	188532	vectorize_to: ?Memory.Size = null,
188533	188533	};
188534	188534
...	...	@@ -188537,7 +188537,7 @@ const Select = struct {
188537	188537	after: u2,
188538	188538	at: u2,
188539	188539
188540		fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.builtin.CallingConvention.Tag {
	188540	fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.lang.CallingConvention.Tag {
188541	188541	return switch (spec.cc) {
188542	188542	.none => unreachable,
188543	188543	.ccc => cg.target.cCallingConvention().?,
...	...	@@ -188667,11 +188667,11 @@ const Select = struct {
188667	188667	.smax_mem, .umin_mem => .bool_false,
188668	188668	}) },
188669	188669	else => {
188670		const scalar_info: std.builtin.Type.Int = cg.intInfo(scalar_ty) orelse .{
	188670	const scalar_info: std.lang.Type.Int = cg.intInfo(scalar_ty) orelse .{
188671	188671	.signedness = .signed,
188672	188672	.bits = cg.floatBits(scalar_ty).?,
188673	188673	};
188674		const res_scalar_info: std.builtin.Type.Int = .{
	188674	const res_scalar_info: std.lang.Type.Int = .{
188675	188675	.signedness = const_spec.to_signedness orelse scalar_info.signedness,
188676	188676	.bits = switch (spec.kind) {
188677	188677	else => scalar_info.bits,
...	...	@@ -188739,7 +188739,7 @@ const Select = struct {
188739	188739	.positive = undefined,
188740	188740	};
188741	188741	defer allocator.free(big_int.limbs);
188742		const signedness: std.builtin.Signedness = switch (spec.kind) {
	188742	const signedness: std.lang.Signedness = switch (spec.kind) {
188743	188743	else => unreachable,
188744	188744	.slimit_delta_mem => .signed,
188745	188745	.umax_delta_mem => .unsigned,

src/codegen/x86_64/Lower.zig+1-1

...	...	@@ -3,7 +3,7 @@
3	3	target: *const std.Target,
4	4	allocator: std.mem.Allocator,
5	5	mir: Mir,
6		cc: std.builtin.CallingConvention,
	6	cc: std.lang.CallingConvention,
7	7	err_msg: ?*Zcu.ErrorMsg = null,
8	8	src_loc: Zcu.LazySrcLoc,
9	9	result_insts_len: ResultInstIndex = undefined,

src/codegen/x86_64/Mir.zig+1-1

...	...	@@ -1737,7 +1737,7 @@ pub const Inst = struct {
1737	1737	@typeInfo(Tag).@"enum".fields.len != 251)
1738	1738	{
1739	1739	const cond_src = (struct {
1740		fn src() std.builtin.SourceLocation {
	1740	fn src() std.lang.SourceLocation {
1741	1741	return @src();
1742	1742	}
1743	1743	}).src();

src/codegen/x86_64/abi.zig+9-9

...	...	@@ -478,7 +478,7 @@ pub const Win64 = struct {
478	478	pub const c_abi_sse_return_regs = sse_avx_regs[0..1];
479	479	};
480	480
481		pub fn getCalleePreservedRegs(cc: std.builtin.CallingConvention.Tag) []const Register {
	481	pub fn getCalleePreservedRegs(cc: std.lang.CallingConvention.Tag) []const Register {
482	482	return switch (cc) {
483	483	.auto => zigcc.callee_preserved_regs,
484	484	.x86_64_sysv => &SysV.callee_preserved_regs,
...	...	@@ -487,7 +487,7 @@ pub fn getCalleePreservedRegs(cc: std.builtin.CallingConvention.Tag) []const Reg
487	487	};
488	488	}
489	489
490		pub fn getCallerPreservedRegs(cc: std.builtin.CallingConvention.Tag) []const Register {
	490	pub fn getCallerPreservedRegs(cc: std.lang.CallingConvention.Tag) []const Register {
491	491	return switch (cc) {
492	492	.auto => zigcc.caller_preserved_regs,
493	493	.x86_64_sysv => &SysV.caller_preserved_regs,
...	...	@@ -496,7 +496,7 @@ pub fn getCallerPreservedRegs(cc: std.builtin.CallingConvention.Tag) []const Reg
496	496	};
497	497	}
498	498
499		pub fn getCAbiIntParamRegs(cc: std.builtin.CallingConvention.Tag) []const Register {
	499	pub fn getCAbiIntParamRegs(cc: std.lang.CallingConvention.Tag) []const Register {
500	500	return switch (cc) {
501	501	.auto => zigcc.int_param_regs,
502	502	.x86_64_sysv => &SysV.c_abi_int_param_regs,
...	...	@@ -505,7 +505,7 @@ pub fn getCAbiIntParamRegs(cc: std.builtin.CallingConvention.Tag) []const Regist
505	505	};
506	506	}
507	507
508		pub fn getCAbiX87ParamRegs(cc: std.builtin.CallingConvention.Tag) []const Register {
	508	pub fn getCAbiX87ParamRegs(cc: std.lang.CallingConvention.Tag) []const Register {
509	509	return switch (cc) {
510	510	.auto => zigcc.x87_param_regs,
511	511	.x86_64_sysv => SysV.c_abi_x87_param_regs,
...	...	@@ -514,7 +514,7 @@ pub fn getCAbiX87ParamRegs(cc: std.builtin.CallingConvention.Tag) []const Regist
514	514	};
515	515	}
516	516
517		pub fn getCAbiSseParamRegs(cc: std.builtin.CallingConvention.Tag, target: *const std.Target) []const Register {
	517	pub fn getCAbiSseParamRegs(cc: std.lang.CallingConvention.Tag, target: *const std.Target) []const Register {
518	518	return switch (cc) {
519	519	.auto => switch (target.cpu.arch) {
520	520	else => unreachable,
...	...	@@ -527,7 +527,7 @@ pub fn getCAbiSseParamRegs(cc: std.builtin.CallingConvention.Tag, target: *const
527	527	};
528	528	}
529	529
530		pub fn getCAbiIntReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Register {
	530	pub fn getCAbiIntReturnRegs(cc: std.lang.CallingConvention.Tag) []const Register {
531	531	return switch (cc) {
532	532	.auto => zigcc.int_return_regs,
533	533	.x86_64_sysv => &SysV.c_abi_int_return_regs,
...	...	@@ -536,7 +536,7 @@ pub fn getCAbiIntReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Regis
536	536	};
537	537	}
538	538
539		pub fn getCAbiX87ReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Register {
	539	pub fn getCAbiX87ReturnRegs(cc: std.lang.CallingConvention.Tag) []const Register {
540	540	return switch (cc) {
541	541	.auto => zigcc.x87_return_regs,
542	542	.x86_64_sysv => SysV.c_abi_x87_return_regs,
...	...	@@ -545,7 +545,7 @@ pub fn getCAbiX87ReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Regis
545	545	};
546	546	}
547	547
548		pub fn getCAbiSseReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Register {
	548	pub fn getCAbiSseReturnRegs(cc: std.lang.CallingConvention.Tag) []const Register {
549	549	return switch (cc) {
550	550	.auto => zigcc.sse_return_regs,
551	551	.x86_64_sysv => SysV.c_abi_sse_return_regs,
...	...	@@ -554,7 +554,7 @@ pub fn getCAbiSseReturnRegs(cc: std.builtin.CallingConvention.Tag) []const Regis
554	554	};
555	555	}
556	556
557		pub fn getCAbiLinkerScratchReg(cc: std.builtin.CallingConvention.Tag) Register {
	557	pub fn getCAbiLinkerScratchReg(cc: std.lang.CallingConvention.Tag) Register {
558	558	return switch (cc) {
559	559	.auto => zigcc.int_return_regs[zigcc.int_return_regs.len - 1],
560	560	.x86_64_sysv => SysV.c_abi_int_return_regs[0],

src/codegen/x86_64/bits.zig+1-1

...	...	@@ -106,7 +106,7 @@ pub const Condition = enum(u5) {
106	106	}
107	107
108	108	pub fn fromCompareOperator(
109		signedness: std.builtin.Signedness,
	109	signedness: std.lang.Signedness,
110	110	op: std.math.CompareOperator,
111	111	) Condition {
112	112	return switch (signedness) {

src/libs/freebsd.zig+1-1

...	...	@@ -19,7 +19,7 @@ pub const CrtFile = enum {
19	19	scrt1_o,
20	20	};
21	21
22		pub fn needsCrt0(output_mode: std.builtin.OutputMode) ?CrtFile {
	22	pub fn needsCrt0(output_mode: std.lang.OutputMode) ?CrtFile {
23	23	// For shared libraries and PIC executables, we should actually link in a variant of crt1 that
24	24	// is built with `-DSHARED` so that it calls `__cxa_finalize` in an ELF destructor. However, we
25	25	// currently make no effort to respect `__cxa_finalize` on any other targets, so for now, we're

src/libs/glibc.zig+1-1

...	...	@@ -1277,7 +1277,7 @@ fn buildSharedLib(
1277	1277	try comp.updateSubCompilation(sub_compilation, misc_task, prog_node);
1278	1278	}
1279	1279
1280		pub fn needsCrt0(output_mode: std.builtin.OutputMode) ?CrtFile {
	1280	pub fn needsCrt0(output_mode: std.lang.OutputMode) ?CrtFile {
1281	1281	return switch (output_mode) {
1282	1282	.Obj, .Lib => null,
1283	1283	.Exe => .scrt1_o,

src/libs/libcxx.zig+1-1

...	...	@@ -324,7 +324,7 @@ pub fn buildLibCxxAbi(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
324	324	const strip = comp.compilerRtStrip();
325	325	// See the `-fno-exceptions` logic for WASI.
326	326	// The old 32-bit x86 variant of SEH doesn't use tables.
327		const unwind_tables: std.builtin.UnwindTables =
	327	const unwind_tables: std.lang.UnwindTables =
328	328	if (target.os.tag == .wasi or (target.cpu.arch == .x86 and target.os.tag == .windows)) .none else .async;
329	329
330	330	const config = Compilation.Config.resolve(.{

src/libs/libtsan.zig+2-2

...	...	@@ -37,7 +37,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
37	37	.watchos => if (target.abi == .simulator) "clang_rt.tsan_watchossim_dynamic" else "clang_rt.tsan_watchos_dynamic",
38	38	else => "tsan",
39	39	};
40		const link_mode: std.builtin.LinkMode = if (target.os.tag.isDarwin()) .dynamic else .static;
	40	const link_mode: std.lang.LinkMode = if (target.os.tag.isDarwin()) .dynamic else .static;
41	41	const output_mode = .Lib;
42	42	const basename = try std.zig.binNameAlloc(arena, .{
43	43	.root_name = root_name,
...	...	@@ -48,7 +48,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
48	48
49	49	const optimize_mode = comp.compilerRtOptMode();
50	50	const strip = comp.compilerRtStrip();
51		const unwind_tables: std.builtin.UnwindTables =
	51	const unwind_tables: std.lang.UnwindTables =
52	52	if (target.cpu.arch == .x86 and target.os.tag == .windows) .none else .async;
53	53	const link_libcpp = target.os.tag.isDarwin();
54	54

src/libs/libunwind.zig+1-1

...	...	@@ -29,7 +29,7 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
29	29	const io = comp.io;
30	30	const output_mode = .Lib;
31	31	const target = &comp.root_mod.resolved_target.result;
32		const unwind_tables: std.builtin.UnwindTables =
	32	const unwind_tables: std.lang.UnwindTables =
33	33	if (target.cpu.arch == .x86 and target.os.tag == .windows) .none else .async;
34	34	const config = Compilation.Config.resolve(.{
35	35	.output_mode = output_mode,

src/libs/mingw.zig+1-1

...	...	@@ -37,7 +37,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
37	37	const target = comp.getTarget();
38	38
39	39	// The old 32-bit x86 variant of SEH doesn't use tables.
40		const unwind_tables: std.builtin.UnwindTables = if (target.cpu.arch != .x86) .async else .none;
	40	const unwind_tables: std.lang.UnwindTables = if (target.cpu.arch != .x86) .async else .none;
41	41
42	42	switch (crt_file) {
43	43	.crt2_o => {

src/libs/musl.zig+2-2

...	...	@@ -173,7 +173,7 @@ pub fn buildCrtFile(comp: *Compilation, in_crt_file: CrtFile, prog_node: std.Pro
173	173	.libc_so => {
174	174	const optimize_mode = comp.compilerRtOptMode();
175	175	const strip = comp.compilerRtStrip();
176		const output_mode: std.builtin.OutputMode = .Lib;
	176	const output_mode: std.lang.OutputMode = .Lib;
177	177	const config = try Compilation.Config.resolve(.{
178	178	.output_mode = output_mode,
179	179	.link_mode = .dynamic,
...	...	@@ -290,7 +290,7 @@ pub fn buildCrtFile(comp: *Compilation, in_crt_file: CrtFile, prog_node: std.Pro
290	290	}
291	291	}
292	292
293		pub fn needsCrt0(output_mode: std.builtin.OutputMode, link_mode: std.builtin.LinkMode, pie: bool) ?CrtFile {
	293	pub fn needsCrt0(output_mode: std.lang.OutputMode, link_mode: std.lang.LinkMode, pie: bool) ?CrtFile {
294	294	return switch (output_mode) {
295	295	.Obj, .Lib => null,
296	296	.Exe => switch (link_mode) {

src/libs/netbsd.zig+1-1

...	...	@@ -19,7 +19,7 @@ pub const CrtFile = enum {
19	19	scrt0_o,
20	20	};
21	21
22		pub fn needsCrt0(output_mode: std.builtin.OutputMode) ?CrtFile {
	22	pub fn needsCrt0(output_mode: std.lang.OutputMode) ?CrtFile {
23	23	// For shared libraries and PIC executables, we should actually link in a variant of crt1 that
24	24	// is built with `-DSHARED` so that it calls `__cxa_finalize` in an ELF destructor. However, we
25	25	// currently make no effort to respect `__cxa_finalize` on any other targets, so for now, we're

src/libs/openbsd.zig+1-1

...	...	@@ -20,7 +20,7 @@ pub const CrtFile = enum {
20	20	scrt0_o,
21	21	};
22	22
23		pub fn needsCrt0(output_mode: std.builtin.OutputMode) ?CrtFile {
	23	pub fn needsCrt0(output_mode: std.lang.OutputMode) ?CrtFile {
24	24	// https://github.com/ziglang/zig/issues/23574#issuecomment-2869089897
25	25	return switch (output_mode) {
26	26	.Obj, .Lib => null,

src/libs/wasi_libc.zig+2-2

...	...	@@ -12,14 +12,14 @@ pub const CrtFile = enum {
12	12	libc_a,
13	13	};
14	14
15		pub fn execModelCrtFile(wasi_exec_model: std.builtin.WasiExecModel) CrtFile {
	15	pub fn execModelCrtFile(wasi_exec_model: std.lang.WasiExecModel) CrtFile {
16	16	return switch (wasi_exec_model) {
17	17	.reactor => CrtFile.crt1_reactor_o,
18	18	.command => CrtFile.crt1_command_o,
19	19	};
20	20	}
21	21
22		pub fn execModelCrtFileFullName(wasi_exec_model: std.builtin.WasiExecModel) []const u8 {
	22	pub fn execModelCrtFileFullName(wasi_exec_model: std.lang.WasiExecModel) []const u8 {
23	23	return switch (execModelCrtFile(wasi_exec_model)) {
24	24	.crt1_reactor_o => "crt1-reactor.o",
25	25	.crt1_command_o => "crt1-command.o",

src/link.zig+8-8

...	...	@@ -1300,8 +1300,8 @@ pub const File = struct {
1300	1300	};
1301	1301
1302	1302	pub fn determinePermissions(
1303		output_mode: std.builtin.OutputMode,
1304		link_mode: std.builtin.LinkMode,
	1303	output_mode: std.lang.OutputMode,
	1304	link_mode: std.lang.LinkMode,
1305	1305	) Io.File.Permissions {
1306	1306	// On common systems with a 0o022 umask, 0o777 will still result in a file created
1307	1307	// with 0o755 permissions, but it works appropriately if the system is configured
...	...	@@ -1714,10 +1714,10 @@ pub const UnresolvedInput = union(enum) {
1714	1714	must_link: bool = false,
1715	1715	hidden: bool = false,
1716	1716	allow_so_scripts: bool = false,
1717		preferred_mode: std.builtin.LinkMode,
	1717	preferred_mode: std.lang.LinkMode,
1718	1718	search_strategy: SearchStrategy,
1719	1719
1720		fn fallbackMode(q: Query) std.builtin.LinkMode {
	1720	fn fallbackMode(q: Query) std.lang.LinkMode {
1721	1721	assert(q.search_strategy != .no_fallback);
1722	1722	return switch (q.preferred_mode) {
1723	1723	.dynamic => .static,
...	...	@@ -1843,7 +1843,7 @@ pub fn resolveInputs(
1843	1843	name: []const u8,
1844	1844	strategy: UnresolvedInput.SearchStrategy,
1845	1845	checked_paths: []const u8,
1846		preferred_mode: std.builtin.LinkMode,
	1846	preferred_mode: std.lang.LinkMode,
1847	1847	}) = .empty;
1848	1848
1849	1849	// Convert external system libs into a stack so that items can be
...	...	@@ -2077,7 +2077,7 @@ fn resolveLibInput(
2077	2077	lib_directory: Directory,
2078	2078	name_query: UnresolvedInput.NameQuery,
2079	2079	target: *const std.Target,
2080		link_mode: std.builtin.LinkMode,
	2080	link_mode: std.lang.LinkMode,
2081	2081	color: std.zig.Color,
2082	2082	) Allocator.Error!ResolveLibInputResult {
2083	2083	try resolved_inputs.ensureUnusedCapacity(gpa, 1);
...	...	@@ -2161,7 +2161,7 @@ fn finishResolveLibInput(
2161	2161	resolved_inputs: *std.ArrayList(Input),
2162	2162	path: Path,
2163	2163	file: Io.File,
2164		link_mode: std.builtin.LinkMode,
	2164	link_mode: std.lang.LinkMode,
2165	2165	query: UnresolvedInput.Query,
2166	2166	) ResolveLibInputResult {
2167	2167	switch (link_mode) {
...	...	@@ -2237,7 +2237,7 @@ fn resolvePathInputLib(
2237	2237	ld_script_bytes: *std.ArrayList(u8),
2238	2238	target: *const std.Target,
2239	2239	pq: UnresolvedInput.PathQuery,
2240		link_mode: std.builtin.LinkMode,
	2240	link_mode: std.lang.LinkMode,
2241	2241	color: std.zig.Color,
2242	2242	) Allocator.Error!ResolveLibInputResult {
2243	2243	try resolved_inputs.ensureUnusedCapacity(gpa, 1);

src/link/Coff.zig+1-1

...	...	@@ -1091,7 +1091,7 @@ fn computeNodeSectionOffset(coff: *Coff, ni: MappedFile.Node.Index) u32 {
1091	1091	}
1092	1092	}
1093	1093
1094		pub inline fn targetEndian(_: *const Coff) std.builtin.Endian {
	1094	pub inline fn targetEndian(_: *const Coff) std.lang.Endian {
1095	1095	return .little;
1096	1096	}
1097	1097	fn targetLoad(coff: *const Coff, ptr: anytype) @typeInfo(@TypeOf(ptr)).pointer.child {

src/link/Dwarf.zig+5-5

...	...	@@ -22,7 +22,7 @@ const target_info = @import("../target.zig");
22	22	gpa: Allocator,
23	23	bin_file: *link.File,
24	24	format: DW.Format,
25		endian: std.builtin.Endian,
	25	endian: std.lang.Endian,
26	26	address_size: AddressSize,
27	27
28	28	const_pool: link.ConstPool,
...	...	@@ -1963,7 +1963,7 @@ pub const WipNav = struct {
1963	1963	fn writer(counter: ExprLocCounter) Writer {
1964	1964	return &counter.dw.writer;
1965	1965	}
1966		fn endian(_: ExprLocCounter) std.builtin.Endian {
	1966	fn endian(_: ExprLocCounter) std.lang.Endian {
1967	1967	return @import("builtin").cpu.arch.endian();
1968	1968	}
1969	1969	fn addrSym(counter: *ExprLocCounter, _: u32) Writer.Error!void {
...	...	@@ -1984,7 +1984,7 @@ pub const WipNav = struct {
1984	1984	fn writer(ctx: @This()) *Writer {
1985	1985	return &ctx.wip_nav.debug_info.writer;
1986	1986	}
1987		fn endian(ctx: @This()) std.builtin.Endian {
	1987	fn endian(ctx: @This()) std.lang.Endian {
1988	1988	return ctx.wip_nav.dwarf.endian;
1989	1989	}
1990	1990	fn addrSym(ctx: @This(), sym_index: u32) (UpdateError \|\| Writer.Error)!void {
...	...	@@ -2026,7 +2026,7 @@ pub const WipNav = struct {
2026	2026	fn writer(ctx: @This()) *Writer {
2027	2027	return &ctx.wip_nav.debug_frame.writer;
2028	2028	}
2029		fn endian(ctx: @This()) std.builtin.Endian {
	2029	fn endian(ctx: @This()) std.lang.Endian {
2030	2030	return ctx.wip_nav.dwarf.endian;
2031	2031	}
2032	2032	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
4164	4164	try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)});
4165	4165	const cc: DW.CC = cc: {
4166	4166	if (zcu.getTarget().cCallingConvention()) \|cc\| {
4167		if (@as(std.builtin.CallingConvention.Tag, cc) == func_type.cc) {
	4167	if (@as(std.lang.CallingConvention.Tag, cc) == func_type.cc) {
4168	4168	break :cc .normal;
4169	4169	}
4170	4170	}

src/link/Elf2.zig+1-1

...	...	@@ -1697,7 +1697,7 @@ pub fn identData(elf: *const Elf) std.elf.DATA {
1697	1697	return @enumFromInt(elf.mf.memory_map.memory[std.elf.EI.DATA]);
1698	1698	}
1699	1699
1700		pub fn targetEndian(elf: *const Elf) std.builtin.Endian {
	1700	pub fn targetEndian(elf: *const Elf) std.lang.Endian {
1701	1701	return switch (elf.identData()) {
1702	1702	.NONE, _ => unreachable,
1703	1703	.@"2LSB" => .little,

src/link/Wasm.zig+4-4

...	...	@@ -3882,7 +3882,7 @@ pub fn flush(
3882	3882
3883	3883	fn defaultEntrySymbolName(
3884	3884	preloaded_strings: *const PreloadedStrings,
3885		wasi_exec_model: std.builtin.WasiExecModel,
	3885	wasi_exec_model: std.lang.WasiExecModel,
3886	3886	) String {
3887	3887	return switch (wasi_exec_model) {
3888	3888	.reactor => preloaded_strings._initialize,
...	...	@@ -3962,7 +3962,7 @@ pub fn getExistingFuncType2(wasm: *const Wasm, params: []const std.wasm.Valtype,
3962	3962
3963	3963	pub fn internFunctionType(
3964	3964	wasm: *Wasm,
3965		cc: std.builtin.CallingConvention,
	3965	cc: std.lang.CallingConvention,
3966	3966	params: []const InternPool.Index,
3967	3967	return_type: Zcu.Type,
3968	3968	target: *const std.Target,
...	...	@@ -3976,7 +3976,7 @@ pub fn internFunctionType(
3976	3976
3977	3977	pub fn getExistingFunctionType(
3978	3978	wasm: *Wasm,
3979		cc: std.builtin.CallingConvention,
	3979	cc: std.lang.CallingConvention,
3980	3980	params: []const InternPool.Index,
3981	3981	return_type: Zcu.Type,
3982	3982	target: *const std.Target,
...	...	@@ -4210,7 +4210,7 @@ pub fn errorNameTableAddr(wasm: *Wasm) u32 {
4210	4210
4211	4211	fn convertZcuFnType(
4212	4212	comp: *Compilation,
4213		cc: std.builtin.CallingConvention,
	4213	cc: std.lang.CallingConvention,
4214	4214	params: []const InternPool.Index,
4215	4215	return_type: Zcu.Type,
4216	4216	target: *const std.Target,

src/main.zig+10-10

...	...	@@ -766,7 +766,7 @@ const Emit = union(enum) {
766	766	};
767	767
768	768	const ArgMode = union(enum) {
769		build: std.builtin.OutputMode,
	769	build: std.lang.OutputMode,
770	770	cc,
771	771	cpp,
772	772	translate_c,
...	...	@@ -935,13 +935,13 @@ fn buildOutputType(
935	935	var minor_subsystem_version: ?u16 = null;
936	936	var mingw_unicode_entry_point: bool = false;
937	937	var enable_link_snapshots: bool = false;
938		var debug_compiler_runtime_libs: ?std.builtin.OptimizeMode = null;
	938	var debug_compiler_runtime_libs: ?std.lang.OptimizeMode = null;
939	939	var install_name: ?[]const u8 = null;
940	940	var hash_style: link.File.Lld.Elf.HashStyle = .both;
941	941	var entitlements: ?[]const u8 = null;
942	942	var pagezero_size: ?u64 = null;
943	943	var lib_search_strategy: link.UnresolvedInput.SearchStrategy = .paths_first;
944		var lib_preferred_mode: std.builtin.LinkMode = .dynamic;
	944	var lib_preferred_mode: std.lang.LinkMode = .dynamic;
945	945	var headerpad_size: ?u32 = null;
946	946	var headerpad_max_install_names: bool = false;
947	947	var dead_strip_dylibs: bool = false;
...	...	@@ -5754,7 +5754,7 @@ fn jitCmdInner(
5754	5754	const self_exe_path = process.executablePathAlloc(io, arena) catch \|err\|
5755	5755	fatal("unable to find self exe path: {t}", .{err});
5756	5756
5757		const optimize_mode: std.builtin.OptimizeMode = if (EnvVar.ZIG_DEBUG_CMD.isSet(environ_map))
	5757	const optimize_mode: std.lang.OptimizeMode = if (EnvVar.ZIG_DEBUG_CMD.isSet(environ_map))
5758	5758	.Debug
5759	5759	else
5760	5760	.ReleaseFast;
...	...	@@ -6265,8 +6265,8 @@ pub const ClangArgIterator = struct {
6265	6265	}
6266	6266	};
6267	6267
6268		fn parseCodeModel(arg: []const u8) std.builtin.CodeModel {
6269		return std.meta.stringToEnum(std.builtin.CodeModel, arg) orelse
	6268	fn parseCodeModel(arg: []const u8) std.lang.CodeModel {
	6269	return std.meta.stringToEnum(std.lang.CodeModel, arg) orelse
6270	6270	fatal("unsupported machine code model: '{s}'", .{arg});
6271	6271	}
6272	6272
...	...	@@ -7669,13 +7669,13 @@ fn findTemplates(gpa: Allocator, arena: Allocator, io: Io) Templates {
7669	7669	};
7670	7670	}
7671	7671
7672		fn parseOptimizeMode(s: []const u8) std.builtin.OptimizeMode {
7673		return std.meta.stringToEnum(std.builtin.OptimizeMode, s) orelse
	7672	fn parseOptimizeMode(s: []const u8) std.lang.OptimizeMode {
	7673	return std.meta.stringToEnum(std.lang.OptimizeMode, s) orelse
7674	7674	fatal("unrecognized optimization mode: '{s}'", .{s});
7675	7675	}
7676	7676
7677		fn parseWasiExecModel(s: []const u8) std.builtin.WasiExecModel {
7678		return std.meta.stringToEnum(std.builtin.WasiExecModel, s) orelse
	7677	fn parseWasiExecModel(s: []const u8) std.lang.WasiExecModel {
	7678	return std.meta.stringToEnum(std.lang.WasiExecModel, s) orelse
7679	7679	fatal("expected [command\|reactor] for -mexec-mode=[value], found '{s}'", .{s});
7680	7680	}
7681	7681

src/print_zir.zig+1-1

...	...	@@ -1340,7 +1340,7 @@ const Writer = struct {
1340	1340	if (extra.data.flags.ensure_result_used) {
1341	1341	try stream.writeAll("nodiscard ");
1342	1342	}
1343		try stream.print(".{s}, ", .{@tagName(@as(std.builtin.CallModifier, @enumFromInt(extra.data.flags.packed_modifier)))});
	1343	try stream.print(".{s}, ", .{@tagName(@as(std.lang.CallModifier, @enumFromInt(extra.data.flags.packed_modifier)))});
1344	1344	switch (kind) {
1345	1345	.direct => try self.writeInstRef(stream, extra.data.callee),
1346	1346	.field => {

src/target.zig+15-15

...	...	@@ -3,7 +3,7 @@ const std = @import("std");
3	3	const assert = std.debug.assert;
4	4
5	5	const Type = @import("Type.zig");
6		const AddressSpace = std.builtin.AddressSpace;
	6	const AddressSpace = std.lang.AddressSpace;
7	7	const Alignment = @import("InternPool.zig").Alignment;
8	8	const Compilation = @import("Compilation.zig");
9	9	const Feature = @import("Zcu.zig").Feature;
...	...	@@ -31,7 +31,7 @@ pub fn canDynamicLink(target: *const std.Target) bool {
31	31	};
32	32	}
33	33
34		pub fn libCNeedsLibUnwind(target: *const std.Target, link_mode: std.builtin.LinkMode) bool {
	34	pub fn libCNeedsLibUnwind(target: *const std.Target, link_mode: std.lang.LinkMode) bool {
35	35	return target.isGnuLibC() and link_mode == .static;
36	36	}
37	37
...	...	@@ -119,7 +119,7 @@ pub fn useEmulatedTls(target: *const std.Target) bool {
119	119	};
120	120	}
121	121
122		pub fn hasValgrindSupport(target: *const std.Target, backend: std.builtin.CompilerBackend) bool {
	122	pub fn hasValgrindSupport(target: *const std.Target, backend: std.lang.CompilerBackend) bool {
123	123	// We can't currently output the necessary Valgrind client request assembly when using the C
124	124	// backend and compiling with an MSVC-like compiler.
125	125	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 {
265	265	};
266	266	}
267	267
268		pub fn hasNewLinkerSupport(ofmt: std.Target.ObjectFormat, backend: std.builtin.CompilerBackend) bool {
	268	pub fn hasNewLinkerSupport(ofmt: std.Target.ObjectFormat, backend: std.lang.CompilerBackend) bool {
269	269	return switch (ofmt) {
270	270	.elf, .coff => switch (backend) {
271	271	.stage2_x86_64 => true,
...	...	@@ -299,7 +299,7 @@ pub fn selfHostedBackendIsAsRobustAsLlvm(target: *const std.Target) bool {
299	299	return false;
300	300	}
301	301
302		pub fn supportsStackProbing(target: *const std.Target, backend: std.builtin.CompilerBackend) bool {
	302	pub fn supportsStackProbing(target: *const std.Target, backend: std.lang.CompilerBackend) bool {
303	303	return switch (backend) {
304	304	.stage2_aarch64, .stage2_x86_64 => true,
305	305	.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
308	308	};
309	309	}
310	310
311		pub fn supportsStackProtector(target: *const std.Target, backend: std.builtin.CompilerBackend) bool {
	311	pub fn supportsStackProtector(target: *const std.Target, backend: std.lang.CompilerBackend) bool {
312	312	switch (target.os.tag) {
313	313	.plan9 => return false,
314	314	else => {},
...	...	@@ -336,7 +336,7 @@ pub fn libcProvidesStackProtector(target: *const std.Target) bool {
336	336
337	337	/// Returns true if `@returnAddress()` is supported by the target and has a
338	338	/// reasonably performant implementation for the requested optimization mode.
339		pub fn supportsReturnAddress(target: *const std.Target, optimize: std.builtin.OptimizeMode) bool {
	339	pub fn supportsReturnAddress(target: *const std.Target, optimize: std.lang.OptimizeMode) bool {
340	340	return switch (target.cpu.arch) {
341	341	// Emscripten currently implements `emscripten_return_address()` by calling
342	342	// out into JavaScript and parsing a stack trace, which introduces significant
...	...	@@ -396,7 +396,7 @@ pub fn hasDebugInfo(target: *const std.Target) bool {
396	396	};
397	397	}
398	398
399		pub fn defaultCompilerRtOptimizeMode(target: *const std.Target) std.builtin.OptimizeMode {
	399	pub fn defaultCompilerRtOptimizeMode(target: *const std.Target) std.lang.OptimizeMode {
400	400	if (target.cpu.arch.isWasm() and target.os.tag == .freestanding) {
401	401	return .ReleaseSmall;
402	402	} else {
...	...	@@ -437,7 +437,7 @@ pub fn canBuildLibUbsanRt(target: *const std.Target) enum { no, yes, llvm_only,
437	437
438	438	/// Whether libzigc can fill-in the gaps of an existing libc
439	439	/// or is the libc of the target.
440		pub fn wantsZigC(target: *const std.Target, link_mode: std.builtin.LinkMode) bool {
	440	pub fn wantsZigC(target: *const std.Target, link_mode: std.lang.LinkMode) bool {
441	441	return (target.isMuslLibC() and link_mode == .static) or target.isWasiLibC() or target.isMinGW();
442	442	}
443	443
...	...	@@ -547,7 +547,7 @@ pub fn clangSupportsNoImplicitFloatArg(target: *const std.Target) bool {
547	547	};
548	548	}
549	549
550		pub fn defaultUnwindTables(target: *const std.Target, libunwind: bool, libtsan: bool) std.builtin.UnwindTables {
	550	pub fn defaultUnwindTables(target: *const std.Target, libunwind: bool, libtsan: bool) std.lang.UnwindTables {
551	551	if (target.os.tag == .windows) {
552	552	// The old 32-bit x86 variant of SEH doesn't use tables.
553	553	return if (target.cpu.arch != .x86) .async else .none;
...	...	@@ -824,7 +824,7 @@ pub fn functionPointerMask(target: *const std.Target) ?u64 {
824	824	null;
825	825	}
826	826
827		pub fn supportsTailCall(target: *const std.Target, backend: std.builtin.CompilerBackend) bool {
	827	pub fn supportsTailCall(target: *const std.Target, backend: std.lang.CompilerBackend) bool {
828	828	switch (backend) {
829	829	.stage2_llvm => return @import("codegen/llvm.zig").supportsTailCall(target),
830	830	.stage2_c => return true,
...	...	@@ -832,7 +832,7 @@ pub fn supportsTailCall(target: *const std.Target, backend: std.builtin.Compiler
832	832	}
833	833	}
834	834
835		pub fn supportsThreads(target: *const std.Target, backend: std.builtin.CompilerBackend) bool {
	835	pub fn supportsThreads(target: *const std.Target, backend: std.lang.CompilerBackend) bool {
836	836	_ = target;
837	837	return switch (backend) {
838	838	.stage2_aarch64 => false,
...	...	@@ -880,7 +880,7 @@ pub fn compilerRtIntAbbrev(bits: u16) []const u8 {
880	880	};
881	881	}
882	882
883		pub fn fnCallConvAllowsZigTypes(cc: std.builtin.CallingConvention) bool {
	883	pub fn fnCallConvAllowsZigTypes(cc: std.lang.CallingConvention) bool {
884	884	return switch (cc) {
885	885	.auto, .async, .@"inline" => true,
886	886	// 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 {
891	891	};
892	892	}
893	893
894		pub fn zigBackend(target: *const std.Target, use_llvm: bool) std.builtin.CompilerBackend {
	894	pub fn zigBackend(target: *const std.Target, use_llvm: bool) std.lang.CompilerBackend {
895	895	if (use_llvm) return .stage2_llvm;
896	896	if (target.ofmt == .c) return .stage2_c;
897	897	return switch (target.cpu.arch) {
...	...	@@ -908,7 +908,7 @@ pub fn zigBackend(target: *const std.Target, use_llvm: bool) std.builtin.Compile
908	908	};
909	909	}
910	910
911		pub inline fn backendSupportsFeature(backend: std.builtin.CompilerBackend, comptime feature: Feature) bool {
	911	pub inline fn backendSupportsFeature(backend: std.lang.CompilerBackend, comptime feature: Feature) bool {
912	912	return switch (feature) {
913	913	.panic_fn => switch (backend) {
914	914	.stage2_aarch64,

src/tracy.zig+2-2

...	...	@@ -58,7 +58,7 @@ pub const Ctx = if (enable) ___tracy_c_zone_context else struct {
58	58	}
59	59	};
60	60
61		pub inline fn trace(comptime src: std.builtin.SourceLocation) Ctx {
	61	pub inline fn trace(comptime src: std.lang.SourceLocation) Ctx {
62	62	if (!enable) return .{};
63	63
64	64	const global = struct {
...	...	@@ -78,7 +78,7 @@ pub inline fn trace(comptime src: std.builtin.SourceLocation) Ctx {
78	78	}
79	79	}
80	80
81		pub inline fn traceNamed(comptime src: std.builtin.SourceLocation, comptime name: [:0]const u8) Ctx {
	81	pub inline fn traceNamed(comptime src: std.lang.SourceLocation, comptime name: [:0]const u8) Ctx {
82	82	if (!enable) return .{};
83	83
84	84	const global = struct {

author	Matthew Lugg <mlugg@mlugg.co.uk> 2026-05-02 10:59:45+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2026-05-03 12:23:30+01:00
log	4c330e053ba45f383a7642da53482dfbce1b50cf
tree	99aebc55fbb53f86feb4ecaa2f8a1946ddcfe9c1
parent	e133f793ee42cae28d68eaab442bf243489993d6
signature	Commit is signed but in an unrecognized format.

compiler: use 'std.lang' instead of 'std.builtin'