Commit 68bf81432cd0bafc355821370268eedc91ed8eb7 | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-04-11 14:34:23-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-04-11 15:17:46-07:00
log	68bf81432cd0bafc355821370268eedc91ed8eb7
tree	c994fd653f8d282feacc5bd06ebb25ebfc6ec9bb
parent	bc08199ef1f9419b5b8ed4165458783314934266

update aro to latest

upstream commit 5f5a050569a95ecc40a426f0c3666ae7ef987ede

32 files changed, 3686 insertions(+), 2540 deletions(-)

lib
- compiler
  - aro
    aro
    Attribute.zig
    Attribute
    names.zig
    Builtins.zig
    Builtins
    common.zig
    eval.zig
    CodeGen.zig
    Compilation.zig
    Diagnostics.zig
    Driver.zig
    Driver
    Filesystem.zig
    GCCDetector.zig
    LangOpts.zig
    Parser.zig
    Parser
    Diagnostic.zig
    Preprocessor.zig
    Preprocessor
    Diagnostic.zig
    Target.zig
    Tokenizer.zig
    Toolchain.zig
    Tree.zig
    TypeStore.zig
    Value.zig
    features.zig
    pragmas
    once.zig
    record_layout.zig
    assembly_backend
    x86_64.zig
    backend
    Assembly.zig
    Interner.zig
    Ir.zig
    Ir
    x86
    Renderer.zig
    include
    ptrcheck.h
    main.zig

lib/compiler/aro/aro/Attribute.zig+202-116

...	@@ -7,7 +7,9 @@ const Diagnostics = @import("Diagnostics.zig");	...	@@ -7,7 +7,9 @@ const Diagnostics = @import("Diagnostics.zig");
7	const Parser = @import("Parser.zig");	7	const Parser = @import("Parser.zig");
8	const Tree = @import("Tree.zig");	8	const Tree = @import("Tree.zig");
9	const TokenIndex = Tree.TokenIndex;	9	const TokenIndex = Tree.TokenIndex;
10	const QualType = @import("TypeStore.zig").QualType;	10	const TypeStore = @import("TypeStore.zig");
		11	const Type = TypeStore.Type;
		12	const QualType = TypeStore.QualType;
11	const Value = @import("Value.zig");	13	const Value = @import("Value.zig");
12		14
13	const Attribute = @This();	15	const Attribute = @This();
...	@@ -341,7 +343,6 @@ fn diagnoseField(	...	@@ -341,7 +343,6 @@ fn diagnoseField(
341		343
342	pub fn diagnose(attr: Tag, arguments: Arguments, arg_idx: u32, res: Parser.Result, arg_start: TokenIndex, node: Tree.Node, p: Parser) !bool {	344	pub fn diagnose(attr: Tag, arguments: Arguments, arg_idx: u32, res: Parser.Result, arg_start: TokenIndex, node: Tree.Node, p: Parser) !bool {
343	switch (attr) {	345	switch (attr) {
344	.nonnull => return false,
345	inline else => \|tag\| {	346	inline else => \|tag\| {
346	const decl = @typeInfo(attributes).@"struct".decls[@intFromEnum(tag)];	347	const decl = @typeInfo(attributes).@"struct".decls[@intFromEnum(tag)];
347	const max_arg_count = comptime maxArgCount(tag);	348	const max_arg_count = comptime maxArgCount(tag);
...	@@ -529,7 +530,10 @@ const attributes = struct {	...	@@ -529,7 +530,10 @@ const attributes = struct {
529	pub const @"noinline" = struct {};	530	pub const @"noinline" = struct {};
530	pub const noipa = struct {};	531	pub const noipa = struct {};
531	// TODO: arbitrary number of arguments	532	// TODO: arbitrary number of arguments
532	pub const nonnull = struct {};	533	// const nonnull = struct {
		534	// // arg_index: []const u32,
		535	// };
		536	// };
533	pub const nonstring = struct {};	537	pub const nonstring = struct {};
534	pub const noplt = struct {};	538	pub const noplt = struct {};
535	pub const @"noreturn" = struct {};	539	pub const @"noreturn" = struct {};
...	@@ -577,6 +581,7 @@ const attributes = struct {	...	@@ -577,6 +581,7 @@ const attributes = struct {
577	};	581	};
578	} = null,	582	} = null,
579	};	583	};
		584	pub const single = struct {};
580	pub const spectre = struct {	585	pub const spectre = struct {
581	arg: enum {	586	arg: enum {
582	nomitigation,	587	nomitigation,
...	@@ -618,6 +623,7 @@ const attributes = struct {	...	@@ -618,6 +623,7 @@ const attributes = struct {
618	__name_tok: TokenIndex,	623	__name_tok: TokenIndex,
619	};	624	};
620	pub const uninitialized = struct {};	625	pub const uninitialized = struct {};
		626	pub const unsafe_indexable = struct {};
621	pub const unsequenced = struct {};	627	pub const unsequenced = struct {};
622	pub const unused = struct {};	628	pub const unused = struct {};
623	pub const used = struct {};	629	pub const used = struct {};
...	@@ -723,6 +729,7 @@ pub const Arguments = blk: {	...	@@ -723,6 +729,7 @@ pub const Arguments = blk: {
723	name.* = decl.name;	729	name.* = decl.name;
724	T.* = @field(attributes, decl.name);	730	T.* = @field(attributes, decl.name);
725	}	731	}
		732
726	break :blk @Union(.auto, null, &names, &types, &@splat(.{}));	733	break :blk @Union(.auto, null, &names, &types, &@splat(.{}));
727	};	734	};
728		735
...	@@ -784,15 +791,8 @@ fn ignoredAttrErr(p: *Parser, tok: TokenIndex, attr: Attribute.Tag, context: []c	...	@@ -784,15 +791,8 @@ fn ignoredAttrErr(p: *Parser, tok: TokenIndex, attr: Attribute.Tag, context: []c
784	try p.err(tok, .ignored_attribute, .{ @tagName(attr), context });	791	try p.err(tok, .ignored_attribute, .{ @tagName(attr), context });
785	}	792	}
786		793
787	pub fn applyParameterAttributes(p: *Parser, qt: QualType, attr_buf_start: usize, diagnostic: ?Parser.Diagnostic) !QualType {	794	pub const applyParameterAttributes = applyVariableAttributes;
788	return applyVariableOrParameterAttributes(p, qt, attr_buf_start, diagnostic, .parameter);
789	}
790
791	pub fn applyVariableAttributes(p: *Parser, qt: QualType, attr_buf_start: usize, diagnostic: ?Parser.Diagnostic) !QualType {	795	pub fn applyVariableAttributes(p: *Parser, qt: QualType, attr_buf_start: usize, diagnostic: ?Parser.Diagnostic) !QualType {
792	return applyVariableOrParameterAttributes(p, qt, attr_buf_start, diagnostic, .variable);
793	}
794
795	fn applyVariableOrParameterAttributes(p: *Parser, qt: QualType, attr_buf_start: usize, diagnostic: ?Parser.Diagnostic, context: enum { parameter, variable }) !QualType {
796	const gpa = p.comp.gpa;	796	const gpa = p.comp.gpa;
797	const attrs = p.attr_buf.items(.attr)[attr_buf_start..];	797	const attrs = p.attr_buf.items(.attr)[attr_buf_start..];
798	const toks = p.attr_buf.items(.tok)[attr_buf_start..];	798	const toks = p.attr_buf.items(.tok)[attr_buf_start..];
...	@@ -804,6 +804,7 @@ fn applyVariableOrParameterAttributes(p: *Parser, qt: QualType, attr_buf_start:	...	@@ -804,6 +804,7 @@ fn applyVariableOrParameterAttributes(p: *Parser, qt: QualType, attr_buf_start:
804	// zig fmt: off	804	// zig fmt: off
805	.alias, .may_alias, .deprecated, .unavailable, .unused, .warn_if_not_aligned, .weak, .used,	805	.alias, .may_alias, .deprecated, .unavailable, .unused, .warn_if_not_aligned, .weak, .used,
806	.noinit, .retain, .persistent, .section, .mode, .asm_label, .nullability, .unaligned, .selectany, .internal_linkage,	806	.noinit, .retain, .persistent, .section, .mode, .asm_label, .nullability, .unaligned, .selectany, .internal_linkage,
		807	.visibility,
807	=> try p.attr_application_buf.append(gpa, attr),	808	=> try p.attr_application_buf.append(gpa, attr),
808	// zig fmt: on	809	// zig fmt: on
809	.common => if (nocommon) {	810	.common => if (nocommon) {
...	@@ -820,12 +821,6 @@ fn applyVariableOrParameterAttributes(p: *Parser, qt: QualType, attr_buf_start:	...	@@ -820,12 +821,6 @@ fn applyVariableOrParameterAttributes(p: *Parser, qt: QualType, attr_buf_start:
820	},	821	},
821	.vector_size => try attr.applyVectorSize(p, tok, &base_qt),	822	.vector_size => try attr.applyVectorSize(p, tok, &base_qt),
822	.aligned => try attr.applyAligned(p, base_qt, diagnostic),	823	.aligned => try attr.applyAligned(p, base_qt, diagnostic),
823	.nonnull => {
824	switch (context) {
825	.parameter => try p.err(tok, .attribute_todo, .{ "nonnull", "parameters" }),
826	.variable => try p.err(tok, .nonnull_not_applicable, .{}),
827	}
828	},
829	.nonstring => {	824	.nonstring => {
830	if (base_qt.get(p.comp, .array)) \|array_ty\| {	825	if (base_qt.get(p.comp, .array)) \|array_ty\| {
831	if (array_ty.elem.get(p.comp, .int)) \|int_ty\| switch (int_ty) {	826	if (array_ty.elem.get(p.comp, .int)) \|int_ty\| switch (int_ty) {
...	@@ -848,11 +843,28 @@ fn applyVariableOrParameterAttributes(p: *Parser, qt: QualType, attr_buf_start:	...	@@ -848,11 +843,28 @@ fn applyVariableOrParameterAttributes(p: *Parser, qt: QualType, attr_buf_start:
848	} else {	843	} else {
849	try p.attr_application_buf.append(gpa, attr);	844	try p.attr_application_buf.append(gpa, attr);
850	},	845	},
851	.calling_convention => try applyCallingConvention(attr, p, tok, base_qt),	846	.single,
		847	.unsafe_indexable,
		848	=> try applyBoundsSafetyAttr(.fromTag(attr.tag), p, tok, &base_qt),
		849
		850	.calling_convention => try applyKeywordCallingConvention(attr, p, tok, base_qt),
		851
		852	.fastcall,
		853	.stdcall,
		854	.thiscall,
		855	.vectorcall,
		856	.cdecl,
		857	.pcs,
		858	.riscv_vector_cc,
		859	.aarch64_sve_pcs,
		860	.aarch64_vector_pcs,
		861	.sysv_abi,
		862	.ms_abi,
		863	=> try applyGnuAttrCallingConvention(attr, p, tok, base_qt),
		864
852	.alloc_size,	865	.alloc_size,
853	.copy,	866	.copy,
854	.tls_model,	867	.tls_model,
855	.visibility,
856	=> \|t\| try p.err(tok, .attribute_todo, .{ @tagName(t), "variables" }),	868	=> \|t\| try p.err(tok, .attribute_todo, .{ @tagName(t), "variables" }),
857	// There is already an error in Parser for _Noreturn keyword	869	// There is already an error in Parser for _Noreturn keyword
858	.noreturn => if (attr.syntax != .keyword) try ignoredAttrErr(p, tok, attr.tag, "variables"),	870	.noreturn => if (attr.syntax != .keyword) try ignoredAttrErr(p, tok, attr.tag, "variables"),
...	@@ -903,7 +915,25 @@ pub fn applyTypeAttributes(p: *Parser, qt: QualType, attr_buf_start: usize, diag	...	@@ -903,7 +915,25 @@ pub fn applyTypeAttributes(p: *Parser, qt: QualType, attr_buf_start: usize, diag
903	} else {	915	} else {
904	try p.err(tok, .designated_init_invalid, .{});	916	try p.err(tok, .designated_init_invalid, .{});
905	},	917	},
906	.calling_convention => try applyCallingConvention(attr, p, tok, base_qt),	918	.calling_convention => try applyKeywordCallingConvention(attr, p, tok, base_qt),
		919
		920	.fastcall,
		921	.stdcall,
		922	.thiscall,
		923	.vectorcall,
		924	.cdecl,
		925	.pcs,
		926	.riscv_vector_cc,
		927	.aarch64_sve_pcs,
		928	.aarch64_vector_pcs,
		929	.sysv_abi,
		930	.ms_abi,
		931	=> try applyGnuAttrCallingConvention(attr, p, tok, base_qt),
		932
		933	.single,
		934	.unsafe_indexable,
		935	=> try applyBoundsSafetyAttr(.fromTag(attr.tag), p, tok, &base_qt),
		936
907	.alloc_size,	937	.alloc_size,
908	.copy,	938	.copy,
909	.scalar_storage_order,	939	.scalar_storage_order,
...	@@ -931,6 +961,7 @@ pub fn applyFunctionAttributes(p: *Parser, qt: QualType, attr_buf_start: usize)	...	@@ -931,6 +961,7 @@ pub fn applyFunctionAttributes(p: *Parser, qt: QualType, attr_buf_start: usize)
931	.@"const", .warn_unused_result, .section, .returns_nonnull, .returns_twice, .@"error",	961	.@"const", .warn_unused_result, .section, .returns_nonnull, .returns_twice, .@"error",
932	.externally_visible, .retain, .flatten, .gnu_inline, .alias, .asm_label, .nodiscard,	962	.externally_visible, .retain, .flatten, .gnu_inline, .alias, .asm_label, .nodiscard,
933	.reproducible, .unsequenced, .nothrow, .nullability, .unaligned, .internal_linkage,	963	.reproducible, .unsequenced, .nothrow, .nullability, .unaligned, .internal_linkage,
		964	.visibility,
934	=> try p.attr_application_buf.append(gpa, attr),	965	=> try p.attr_application_buf.append(gpa, attr),
935	// zig fmt: on	966	// zig fmt: on
936	.hot => if (cold) {	967	.hot => if (cold) {
...	@@ -959,97 +990,21 @@ pub fn applyFunctionAttributes(p: *Parser, qt: QualType, attr_buf_start: usize)	...	@@ -959,97 +990,21 @@ pub fn applyFunctionAttributes(p: *Parser, qt: QualType, attr_buf_start: usize)
959	},	990	},
960	.aligned => try attr.applyAligned(p, base_qt, null),	991	.aligned => try attr.applyAligned(p, base_qt, null),
961	.format => try attr.applyFormat(p, base_qt),	992	.format => try attr.applyFormat(p, base_qt),
962	.calling_convention => try applyCallingConvention(attr, p, tok, base_qt),	993	.calling_convention => try applyKeywordCallingConvention(attr, p, tok, base_qt),
963	.fastcall => if (p.comp.target.cpu.arch == .x86) {	994
964	try p.attr_application_buf.append(gpa, .{	995	.fastcall,
965	.tag = .calling_convention,	996	.stdcall,
966	.args = .{ .calling_convention = .{ .cc = .fastcall } },	997	.thiscall,
967	.syntax = attr.syntax,	998	.vectorcall,
968	});	999	.cdecl,
969	} else {	1000	.pcs,
970	try p.err(tok, .callconv_not_supported, .{"fastcall"});	1001	.riscv_vector_cc,
971	},	1002	.aarch64_sve_pcs,
972	.stdcall => if (p.comp.target.cpu.arch == .x86) {	1003	.aarch64_vector_pcs,
973	try p.attr_application_buf.append(gpa, .{	1004	.sysv_abi,
974	.tag = .calling_convention,	1005	.ms_abi,
975	.args = .{ .calling_convention = .{ .cc = .stdcall } },	1006	=> try applyGnuAttrCallingConvention(attr, p, tok, base_qt),
976	.syntax = attr.syntax,	1007
977	});
978	} else {
979	try p.err(tok, .callconv_not_supported, .{"stdcall"});
980	},
981	.thiscall => if (p.comp.target.cpu.arch == .x86) {
982	try p.attr_application_buf.append(gpa, .{
983	.tag = .calling_convention,
984	.args = .{ .calling_convention = .{ .cc = .thiscall } },
985	.syntax = attr.syntax,
986	});
987	} else {
988	try p.err(tok, .callconv_not_supported, .{"thiscall"});
989	},
990	.vectorcall => if (p.comp.target.cpu.arch == .x86 or p.comp.target.cpu.arch.isAARCH64()) {
991	try p.attr_application_buf.append(gpa, .{
992	.tag = .calling_convention,
993	.args = .{ .calling_convention = .{ .cc = .vectorcall } },
994	.syntax = attr.syntax,
995	});
996	} else {
997	try p.err(tok, .callconv_not_supported, .{"vectorcall"});
998	},
999	.cdecl => {},
1000	.pcs => if (p.comp.target.cpu.arch.isArm()) {
1001	try p.attr_application_buf.append(gpa, .{
1002	.tag = .calling_convention,
1003	.args = .{ .calling_convention = .{ .cc = switch (attr.args.pcs.kind) {
1004	.aapcs => .arm_aapcs,
1005	.@"aapcs-vfp" => .arm_aapcs_vfp,
1006	} } },
1007	.syntax = attr.syntax,
1008	});
1009	} else {
1010	try p.err(tok, .callconv_not_supported, .{"pcs"});
1011	},
1012	.riscv_vector_cc => if (p.comp.target.cpu.arch.isRISCV()) {
1013	try p.attr_application_buf.append(gpa, .{
1014	.tag = .calling_convention,
1015	.args = .{ .calling_convention = .{ .cc = .riscv_vector } },
1016	.syntax = attr.syntax,
1017	});
1018	} else {
1019	try p.err(tok, .callconv_not_supported, .{"pcs"});
1020	},
1021	.aarch64_sve_pcs => if (p.comp.target.cpu.arch.isAARCH64()) {
1022	try p.attr_application_buf.append(gpa, .{
1023	.tag = .calling_convention,
1024	.args = .{ .calling_convention = .{ .cc = .aarch64_sve_pcs } },
1025	.syntax = attr.syntax,
1026	});
1027	} else {
1028	try p.err(tok, .callconv_not_supported, .{"pcs"});
1029	},
1030	.aarch64_vector_pcs => if (p.comp.target.cpu.arch.isAARCH64()) {
1031	try p.attr_application_buf.append(gpa, .{
1032	.tag = .calling_convention,
1033	.args = .{ .calling_convention = .{ .cc = .aarch64_vector_pcs } },
1034	.syntax = attr.syntax,
1035	});
1036	} else {
1037	try p.err(tok, .callconv_not_supported, .{"pcs"});
1038	},
1039	.sysv_abi => if (p.comp.target.cpu.arch == .x86_64 and p.comp.target.os.tag == .windows) {
1040	try p.attr_application_buf.append(gpa, .{
1041	.tag = .calling_convention,
1042	.args = .{ .calling_convention = .{ .cc = .x86_64_sysv } },
1043	.syntax = attr.syntax,
1044	});
1045	},
1046	.ms_abi => if (p.comp.target.cpu.arch == .x86_64 and p.comp.target.os.tag != .windows) {
1047	try p.attr_application_buf.append(gpa, .{
1048	.tag = .calling_convention,
1049	.args = .{ .calling_convention = .{ .cc = .x86_64_win } },
1050	.syntax = attr.syntax,
1051	});
1052	},
1053	.malloc => {	1008	.malloc => {
1054	if (base_qt.get(p.comp, .func).?.return_type.isPointer(p.comp)) {	1009	if (base_qt.get(p.comp, .func).?.return_type.isPointer(p.comp)) {
1055	try p.attr_application_buf.append(gpa, attr);	1010	try p.attr_application_buf.append(gpa, attr);
...	@@ -1102,7 +1057,7 @@ pub fn applyFunctionAttributes(p: *Parser, qt: QualType, attr_buf_start: usize)	...	@@ -1102,7 +1057,7 @@ pub fn applyFunctionAttributes(p: *Parser, qt: QualType, attr_buf_start: usize)
1102	.no_stack_protector,	1057	.no_stack_protector,
1103	.noclone,	1058	.noclone,
1104	.noipa,	1059	.noipa,
1105	.nonnull,	1060	// .nonnull,
1106	.noplt,	1061	.noplt,
1107	// .optimize,	1062	// .optimize,
1108	.patchable_function_entry,	1063	.patchable_function_entry,
...	@@ -1112,7 +1067,6 @@ pub fn applyFunctionAttributes(p: *Parser, qt: QualType, attr_buf_start: usize)	...	@@ -1112,7 +1067,6 @@ pub fn applyFunctionAttributes(p: *Parser, qt: QualType, attr_buf_start: usize)
1112	.symver,	1067	.symver,
1113	.target,	1068	.target,
1114	.target_clones,	1069	.target_clones,
1115	.visibility,
1116	.weakref,	1070	.weakref,
1117	.zero_call_used_regs,	1071	.zero_call_used_regs,
1118	=> \|t\| try p.err(tok, .attribute_todo, .{ @tagName(t), "functions" }),	1072	=> \|t\| try p.err(tok, .attribute_todo, .{ @tagName(t), "functions" }),
...	@@ -1262,9 +1216,129 @@ fn applyFormat(attr: Attribute, p: *Parser, qt: QualType) !void {	...	@@ -1262,9 +1216,129 @@ fn applyFormat(attr: Attribute, p: *Parser, qt: QualType) !void {
1262	try p.attr_application_buf.append(p.comp.gpa, attr);	1216	try p.attr_application_buf.append(p.comp.gpa, attr);
1263	}	1217	}
1264		1218
1265	fn applyCallingConvention(attr: Attribute, p: *Parser, tok: TokenIndex, qt: QualType) !void {	1219	/// These come from GNU attributes like __attribute__((sysv_abi))
1266	if (!qt.is(p.comp, .func)) {	1220	fn applyGnuAttrCallingConvention(attr: Attribute, p: *Parser, tok: TokenIndex, qt: QualType) !void {
1267	return p.err(tok, .callconv_non_func, .{ p.tok_ids[tok].symbol(), qt });	1221	if (!qt.isCallable(p.comp)) {
		1222	return p.err(tok, .callconv_non_func, .{ p.tokSlice(tok), qt });
		1223	}
		1224	const gpa = p.comp.gpa;
		1225	switch (attr.tag) {
		1226	.fastcall => if (p.comp.target.cpu.arch == .x86) {
		1227	try p.attr_application_buf.append(gpa, .{
		1228	.tag = .calling_convention,
		1229	.args = .{ .calling_convention = .{ .cc = .fastcall } },
		1230	.syntax = attr.syntax,
		1231	});
		1232	} else {
		1233	try p.err(tok, .callconv_not_supported, .{"fastcall"});
		1234	},
		1235	.stdcall => if (p.comp.target.cpu.arch == .x86) {
		1236	try p.attr_application_buf.append(gpa, .{
		1237	.tag = .calling_convention,
		1238	.args = .{ .calling_convention = .{ .cc = .stdcall } },
		1239	.syntax = attr.syntax,
		1240	});
		1241	} else {
		1242	try p.err(tok, .callconv_not_supported, .{"stdcall"});
		1243	},
		1244	.thiscall => if (p.comp.target.cpu.arch == .x86) {
		1245	try p.attr_application_buf.append(gpa, .{
		1246	.tag = .calling_convention,
		1247	.args = .{ .calling_convention = .{ .cc = .thiscall } },
		1248	.syntax = attr.syntax,
		1249	});
		1250	} else {
		1251	try p.err(tok, .callconv_not_supported, .{"thiscall"});
		1252	},
		1253	.vectorcall => if (p.comp.target.cpu.arch == .x86 or p.comp.target.cpu.arch.isAARCH64()) {
		1254	try p.attr_application_buf.append(gpa, .{
		1255	.tag = .calling_convention,
		1256	.args = .{ .calling_convention = .{ .cc = .vectorcall } },
		1257	.syntax = attr.syntax,
		1258	});
		1259	} else {
		1260	try p.err(tok, .callconv_not_supported, .{"vectorcall"});
		1261	},
		1262	.cdecl => {},
		1263	.pcs => if (p.comp.target.cpu.arch.isArm()) {
		1264	try p.attr_application_buf.append(gpa, .{
		1265	.tag = .calling_convention,
		1266	.args = .{ .calling_convention = .{ .cc = switch (attr.args.pcs.kind) {
		1267	.aapcs => .arm_aapcs,
		1268	.@"aapcs-vfp" => .arm_aapcs_vfp,
		1269	} } },
		1270	.syntax = attr.syntax,
		1271	});
		1272	} else {
		1273	try p.err(tok, .callconv_not_supported, .{"pcs"});
		1274	},
		1275	.riscv_vector_cc => if (p.comp.target.cpu.arch.isRISCV()) {
		1276	try p.attr_application_buf.append(gpa, .{
		1277	.tag = .calling_convention,
		1278	.args = .{ .calling_convention = .{ .cc = .riscv_vector } },
		1279	.syntax = attr.syntax,
		1280	});
		1281	} else {
		1282	try p.err(tok, .callconv_not_supported, .{"pcs"});
		1283	},
		1284	.aarch64_sve_pcs => if (p.comp.target.cpu.arch.isAARCH64()) {
		1285	try p.attr_application_buf.append(gpa, .{
		1286	.tag = .calling_convention,
		1287	.args = .{ .calling_convention = .{ .cc = .aarch64_sve_pcs } },
		1288	.syntax = attr.syntax,
		1289	});
		1290	} else {
		1291	try p.err(tok, .callconv_not_supported, .{"pcs"});
		1292	},
		1293	.aarch64_vector_pcs => if (p.comp.target.cpu.arch.isAARCH64()) {
		1294	try p.attr_application_buf.append(gpa, .{
		1295	.tag = .calling_convention,
		1296	.args = .{ .calling_convention = .{ .cc = .aarch64_vector_pcs } },
		1297	.syntax = attr.syntax,
		1298	});
		1299	} else {
		1300	try p.err(tok, .callconv_not_supported, .{"pcs"});
		1301	},
		1302	.sysv_abi => if (p.comp.target.cpu.arch == .x86_64 and p.comp.target.os.tag == .windows) {
		1303	try p.attr_application_buf.append(gpa, .{
		1304	.tag = .calling_convention,
		1305	.args = .{ .calling_convention = .{ .cc = .x86_64_sysv } },
		1306	.syntax = attr.syntax,
		1307	});
		1308	},
		1309	.ms_abi => if (p.comp.target.cpu.arch == .x86_64 and p.comp.target.os.tag != .windows) {
		1310	try p.attr_application_buf.append(gpa, .{
		1311	.tag = .calling_convention,
		1312	.args = .{ .calling_convention = .{ .cc = .x86_64_win } },
		1313	.syntax = attr.syntax,
		1314	});
		1315	},
		1316	else => unreachable,
		1317	}
		1318	}
		1319
		1320	fn applyBoundsSafetyAttr(bounds: Type.Pointer.Bounds, p: Parser, tok: TokenIndex, qt: QualType) !void {
		1321	if (qt.isInvalid()) return;
		1322	const pointer = qt.get(p.comp, .pointer) orelse {
		1323	return p.err(tok, .attribute_requires_pointer, .{@tagName(bounds)});
		1324	};
		1325	if (pointer.bounds == bounds) {
		1326	return p.err(tok, .redundant_bounds_annotation, .{@tagName(bounds)});
		1327	}
		1328	if (pointer.bounds != .c) {
		1329	return p.err(tok, .multiple_bounds_annotations, .{});
		1330	}
		1331	qt.* = try p.comp.type_store.put(p.comp.gpa, .{ .pointer = .{
		1332	.child = pointer.child,
		1333	.decayed = pointer.decayed,
		1334	.bounds = bounds,
		1335	} });
		1336	}
		1337
		1338	/// These come from explicit MSVC keywords like __stdcall, __fastcall, etc
		1339	fn applyKeywordCallingConvention(attr: Attribute, p: *Parser, tok: TokenIndex, qt: QualType) !void {
		1340	if (!qt.isCallable(p.comp)) {
		1341	return p.err(tok, .callconv_non_func, .{ p.tokSlice(tok), qt });
1268	}	1342	}
1269	switch (attr.args.calling_convention.cc) {	1343	switch (attr.args.calling_convention.cc) {
1270	.c => {},	1344	.c => {},
...	@@ -1295,3 +1369,15 @@ fn applySelected(qt: QualType, p: *Parser) !QualType {	...	@@ -1295,3 +1369,15 @@ fn applySelected(qt: QualType, p: *Parser) !QualType {
1295	.attributes = p.attr_application_buf.items,	1369	.attributes = p.attr_application_buf.items,
1296	} })).withQualifiers(qt);	1370	} })).withQualifiers(qt);
1297	}	1371	}
		1372
		1373	pub fn visibilityFromString(s: []const u8) ?std.builtin.SymbolVisibility {
		1374	if (mem.eql(u8, s, "internal")) {
		1375	return .hidden;
		1376	}
		1377	const visibility = std.meta.stringToEnum(std.builtin.SymbolVisibility, s) orelse return null;
		1378	// compiler will notify us if .internal is added as a visibility type
		1379	switch (visibility) {
		1380	.default, .hidden, .protected => {},
		1381	}
		1382	return visibility;
		1383	}

lib/compiler/aro/aro/Attribute/names.zig+604-589

lib/compiler/aro/aro/Builtins.zig-1

...	@@ -264,7 +264,6 @@ fn createType(desc: TypeDescription, it: TypeDescription.TypeIterator, comp: C	...	@@ -264,7 +264,6 @@ fn createType(desc: TypeDescription, it: TypeDescription.TypeIterator, comp: C
264	_ = address_space; // TODO: handle address space	264	_ = address_space; // TODO: handle address space
265	const pointer_qt = try comp.type_store.put(comp.gpa, .{ .pointer = .{	265	const pointer_qt = try comp.type_store.put(comp.gpa, .{ .pointer = .{
266	.child = builder.finish() catch unreachable,	266	.child = builder.finish() catch unreachable,
267	.decayed = null,
268	} });	267	} });
269		268
270	builder.@"const" = null;	269	builder.@"const" = null;

lib/compiler/aro/aro/Builtins/common.zig+874-863

lib/compiler/aro/aro/Builtins/eval.zig+15-7

 @@ -1,16 +1,19 @@
 const std = @import("std");
+const assert = std.debug.assert;
 const backend = @import("../../backend.zig");
 const Interner = backend.Interner;
 const Builtins = @import("../Builtins.zig");
 const Parser = @import("../Parser.zig");
 const Tree = @import("../Tree.zig");
 const TypeStore = @import("../TypeStore.zig");
-const Type = TypeStore.Type;
 const QualType = TypeStore.QualType;
+const Type = TypeStore.Type;
 const Value = @import("../Value.zig");
 fn makeNan(comptime T: type, str: []const u8) T {
-    const UnsignedSameSize = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const UnsignedSameSize = @Int(.unsigned, @bitSizeOf(T));
     const parsed = std.fmt.parseUnsigned(UnsignedSameSize, str[0 .. str.len - 1], 0) catch 0;
     const bits: switch (T) {
         f32 => u23,
 @@ -24,7 +27,6 @@ fn makeNan(comptime T: type, str: []const u8) T {
 pub fn eval(expanded: Builtins.Expanded, p: *Parser, args: []const Tree.Node.Index) !Value {
     if (!expanded.attributes.const_evaluable) return .{};
     switch (expanded.tag) {
         .common => |tag| switch (tag) {
             .__builtin_inff,
 @@ -47,12 +49,12 @@ pub fn eval(expanded: Builtins.Expanded, p: *Parser, args: []const Tree.Node.Ind
                 return Value.intern(p.comp, .{ .float = f });
             },
             .__builtin_isinf => blk: {
-                if (args.len == 0) break :blk;
+                assert(args.len == 1);
                 const val = p.tree.value_map.get(args[0]) orelse break :blk;
                 return Value.fromBool(val.isInf(p.comp));
             },
             .__builtin_isinf_sign => blk: {
-                if (args.len == 0) break :blk;
+                assert(args.len == 1);
                 const val = p.tree.value_map.get(args[0]) orelse break :blk;
                 switch (val.isInfSign(p.comp)) {
                     .unknown => {},
 @@ -62,12 +64,12 @@ pub fn eval(expanded: Builtins.Expanded, p: *Parser, args: []const Tree.Node.Ind
                 }
             },
             .__builtin_isnan => blk: {
-                if (args.len == 0) break :blk;
+                assert(args.len == 1);
                 const val = p.tree.value_map.get(args[0]) orelse break :blk;
                 return Value.fromBool(val.isNan(p.comp));
             },
             .__builtin_nan => blk: {
-                if (args.len == 0) break :blk;
+                assert(args.len == 1);
                 const val = p.getDecayedStringLiteral(args[0]) orelse break :blk;
                 const bytes = p.comp.interner.get(val.ref()).bytes;
 @@ -80,6 +82,12 @@ pub fn eval(expanded: Builtins.Expanded, p: *Parser, args: []const Tree.Node.Ind
                 };
                 return Value.intern(p.comp, .{ .float = f });
             },
+            .__builtin_constant_p => {
+                assert(args.len == 1);
+                const arg = args[0];
+                const val = p.tree.value_map.get(arg) orelse return Value.fromBool(p.isAddressOfStringLiteral(arg));
+                return Value.fromBool(!val.isPointer(p.comp));
+            },
             else => {},
         },
         else => {},

lib/compiler/aro/aro/CodeGen.zig+3-1

...	@@ -2,7 +2,7 @@ const std = @import("std");	...	@@ -2,7 +2,7 @@ const std = @import("std");
2	const Allocator = std.mem.Allocator;	2	const Allocator = std.mem.Allocator;
3	const assert = std.debug.assert;	3	const assert = std.debug.assert;
4		4
5	const backend = @import("backend");	5	const backend = @import("../backend.zig");
6	const Interner = backend.Interner;	6	const Interner = backend.Interner;
7	const Ir = backend.Ir;	7	const Ir = backend.Ir;
8	const Builder = Ir.Builder;	8	const Builder = Ir.Builder;
...	@@ -867,6 +867,8 @@ fn genExpr(c: *CodeGen, node_index: Node.Index) Error!Ir.Ref {	...	@@ -867,6 +867,8 @@ fn genExpr(c: *CodeGen, node_index: Node.Index) Error!Ir.Ref {
867	.imag_expr,	867	.imag_expr,
868	.real_expr,	868	.real_expr,
869	.sizeof_expr,	869	.sizeof_expr,
		870	.builtin_va_arg_pack,
		871	.builtin_va_arg_pack_len,
870	=> return c.fail("TODO CodeGen.genExpr {s}\n", .{@tagName(node)}),	872	=> return c.fail("TODO CodeGen.genExpr {s}\n", .{@tagName(node)}),
871	else => unreachable, // Not an expression.	873	else => unreachable, // Not an expression.
872	}	874	}

lib/compiler/aro/aro/Compilation.zig+120-97

...	@@ -71,34 +71,23 @@ pub const Environment = struct {	...	@@ -71,34 +71,23 @@ pub const Environment = struct {
71	/// used for __DATE__, __TIME__, and __TIMESTAMP__	71	/// used for __DATE__, __TIME__, and __TIMESTAMP__
72	provided: u64,	72	provided: u64,
73		73
74	pub const default: @This() = .{ .provided = 0 };	74	pub const default: SourceEpoch = .{ .provided = 0 };
75	};	75	};
76		76
77	pub fn loadAll(allocator: std.mem.Allocator, environ_map: *const std.process.Environ.Map) !Environment {	77	/// Load all of the environment variables from an environ map. Does not copy values.
		78	pub fn loadAll(environ_map: *const std.process.Environ.Map) Environment {
78	var env: Environment = .{};	79	var env: Environment = .{};
79	errdefer env.deinit(allocator);
80		80
81	inline for (@typeInfo(@TypeOf(env)).@"struct".fields) \|field\| {	81	inline for (@typeInfo(@TypeOf(env)).@"struct".fields) \|field\| {
82	std.debug.assert(@field(env, field.name) == null);	82	std.debug.assert(@field(env, field.name) == null);
83		83
84	var env_var_buf: [field.name.len]u8 = undefined;	84	var env_var_buf: [field.name.len]u8 = undefined;
85	const env_var_name = std.ascii.upperString(&env_var_buf, field.name);	85	const env_var_name = std.ascii.upperString(&env_var_buf, field.name);
86	const val: ?[]const u8 = if (environ_map.get(env_var_name)) \|v\| try allocator.dupe(u8, v) else null;	86	@field(env, field.name) = environ_map.get(env_var_name);
87	@field(env, field.name) = val;
88	}	87	}
89	return env;	88	return env;
90	}	89	}
91		90
92	/// Use this only if environment slices were allocated with `allocator` (such as via `loadAll`)
93	pub fn deinit(self: *Environment, allocator: std.mem.Allocator) void {
94	inline for (@typeInfo(@TypeOf(self.*)).@"struct".fields) \|field\| {
95	if (@field(self, field.name)) \|slice\| {
96	allocator.free(slice);
97	}
98	}
99	self.* = undefined;
100	}
101
102	pub fn sourceEpoch(self: *const Environment, io: Io) !SourceEpoch {	91	pub fn sourceEpoch(self: *const Environment, io: Io) !SourceEpoch {
103	const max_timestamp = 253402300799; // Dec 31 9999 23:59:59	92	const max_timestamp = 253402300799; // Dec 31 9999 23:59:59
104		93
...	@@ -148,7 +137,7 @@ gpa: Allocator,	...	@@ -148,7 +137,7 @@ gpa: Allocator,
148	/// Allocations in this arena live all the way until `Compilation.deinit`.	137	/// Allocations in this arena live all the way until `Compilation.deinit`.
149	arena: Allocator,	138	arena: Allocator,
150	io: Io,	139	io: Io,
151	cwd: Io.Dir,	140	cwd: std.Io.Dir,
152	diagnostics: *Diagnostics,	141	diagnostics: *Diagnostics,
153		142
154	sources: std.StringArrayHashMapUnmanaged(Source) = .empty,	143	sources: std.StringArrayHashMapUnmanaged(Source) = .empty,
...	@@ -175,37 +164,48 @@ pragma_handlers: std.StringArrayHashMapUnmanaged(*Pragma) = .empty,	...	@@ -175,37 +164,48 @@ pragma_handlers: std.StringArrayHashMapUnmanaged(*Pragma) = .empty,
175	/// Used by MS extensions which allow searching for includes relative to the directory of the main source file.	164	/// Used by MS extensions which allow searching for includes relative to the directory of the main source file.
176	ms_cwd_source_id: ?Source.Id = null,	165	ms_cwd_source_id: ?Source.Id = null,
177		166
178	pub fn init(gpa: Allocator, arena: Allocator, io: Io, diagnostics: *Diagnostics, cwd: Io.Dir) Compilation {	167	pub const InitOptions = struct {
179	return .{
180	.gpa = gpa,
181	.arena = arena,
182	.io = io,
183	.diagnostics = diagnostics,
184	.cwd = cwd,
185	};
186	}
187
188	/// Initialize Compilation with default environment,
189	/// pragma handlers and emulation mode set to target.
190	pub fn initDefault(
191	gpa: Allocator,	168	gpa: Allocator,
192	arena: Allocator,	169	arena: Allocator,
193	io: Io,	170	io: Io,
194	diagnostics: *Diagnostics,	171	diagnostics: *Diagnostics,
195	cwd: Io.Dir,	172
196	environ_map: *const std.process.Environ.Map,	173	/// Used to initiate `Compilation.Environment`, values are not copied.
197	) !Compilation {	174	environ_map: ?*const std.process.Environ.Map,
		175	/// Defaults to `std.Io.Dir.cwd()`
		176	cwd: ?std.Io.Dir = null,
		177
		178	add_default_pragma_handlers: bool = true,
		179
		180	pub const testing: InitOptions = .{
		181	.gpa = std.testing.allocator,
		182	.arena = undefined,
		183	.io = std.testing.io,
		184	.diagnostics = undefined,
		185	.environ_map = null,
		186	.add_default_pragma_handlers = false,
		187	};
		188	};
		189
		190	/// Initialize Compilation with default environment,
		191	/// pragma handlers and emulation mode set to target.
		192	pub fn init(options: InitOptions) !Compilation {
198	var comp: Compilation = .{	193	var comp: Compilation = .{
199	.gpa = gpa,	194	.gpa = options.gpa,
200	.arena = arena,	195	.arena = options.arena,
201	.io = io,	196	.io = options.io,
202	.diagnostics = diagnostics,	197	.diagnostics = options.diagnostics,
203	.environment = try Environment.loadAll(gpa, environ_map),	198	.cwd = options.cwd orelse .cwd(),
204	.cwd = cwd,
205	};	199	};
206	errdefer comp.deinit();	200	errdefer comp.deinit();
207	try comp.addDefaultPragmaHandlers();	201
208	comp.langopts.setEmulatedCompiler(comp.target.systemCompiler());	202	if (options.environ_map) \|map\| {
		203	comp.environment = .loadAll(map);
		204	}
		205
		206	if (options.add_default_pragma_handlers) {
		207	try comp.addDefaultPragmaHandlers();
		208	}
209	return comp;	209	return comp;
210	}	210	}
211		211
...	@@ -228,7 +228,6 @@ pub fn deinit(comp: *Compilation) void {	...	@@ -228,7 +228,6 @@ pub fn deinit(comp: *Compilation) void {
228	comp.builtins.deinit(gpa);	228	comp.builtins.deinit(gpa);
229	comp.string_interner.deinit(gpa);	229	comp.string_interner.deinit(gpa);
230	comp.interner.deinit(gpa);	230	comp.interner.deinit(gpa);
231	comp.environment.deinit(gpa);
232	comp.type_store.deinit(gpa);	231	comp.type_store.deinit(gpa);
233	comp.* = undefined;	232	comp.* = undefined;
234	}	233	}
...	@@ -275,17 +274,18 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -275,17 +274,18 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
275	}	274	}
276		275
277	try w.writeAll(	276	try w.writeAll(
		277	\\#define __ARO_EMULATE_NO__ 0
278	\\#define __ARO_EMULATE_CLANG__ 1	278	\\#define __ARO_EMULATE_CLANG__ 1
279	\\#define __ARO_EMULATE_GCC__ 2	279	\\#define __ARO_EMULATE_GCC__ 2
280	\\#define __ARO_EMULATE_MSVC__ 3	280	\\#define __ARO_EMULATE_MSVC__ 3
281	\\	281	\\
282	);	282	);
283	const emulated = switch (comp.langopts.emulate) {	283	try w.print("#define __ARO_EMULATE__ {s}\n", .{switch (comp.langopts.emulate) {
		284	.no => "__ARO_EMULATE_NO__",
284	.clang => "__ARO_EMULATE_CLANG__",	285	.clang => "__ARO_EMULATE_CLANG__",
285	.gcc => "__ARO_EMULATE_GCC__",	286	.gcc => "__ARO_EMULATE_GCC__",
286	.msvc => "__ARO_EMULATE_MSVC__",	287	.msvc => "__ARO_EMULATE_MSVC__",
287	};	288	}});
288	try w.print("#define __ARO_EMULATE__ {s}\n", .{emulated});
289		289
290	if (comp.langopts.emulate == .msvc) {	290	if (comp.langopts.emulate == .msvc) {
291	try w.writeAll("#define _MSC_VER 1933\n");	291	try w.writeAll("#define _MSC_VER 1933\n");
...	@@ -375,6 +375,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -375,6 +375,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
375	.watchos,	375	.watchos,
376	=> {	376	=> {
377	try define(w, "__APPLE__");	377	try define(w, "__APPLE__");
		378	try w.writeAll("#define __APPLE_CC__ 6000\n");
378		379
379	const version = target.os.version_range.semver.min;	380	const version = target.os.version_range.semver.min;
380	var version_buf: [8]u8 = undefined;	381	var version_buf: [8]u8 = undefined;
...	@@ -647,6 +648,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -647,6 +648,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
647	try define(w, "__ppc__");	648	try define(w, "__ppc__");
648	try define(w, "__PPC__");	649	try define(w, "__PPC__");
649	try define(w, "_ARCH_PPC");	650	try define(w, "_ARCH_PPC");
		651	try w.print("#define _CALL_ELF {d}\n", .{target.ppcElfVersion()});
650	},	652	},
651	.powerpc64,	653	.powerpc64,
652	.powerpc64le,	654	.powerpc64le,
...	@@ -661,7 +663,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -661,7 +663,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
661	try define(w, "__PPC64__");	663	try define(w, "__PPC64__");
662	try define(w, "_ARCH_PPC");	664	try define(w, "_ARCH_PPC");
663	try define(w, "_ARCH_PPC64");	665	try define(w, "_ARCH_PPC64");
664	try w.writeAll("#define _CALL_ELF 2\n");	666	try w.print("#define _CALL_ELF {d}\n", .{target.ppcElfVersion()});
665	},	667	},
666	.sparc64 => {	668	.sparc64 => {
667	try defineStd(w, "sparc", is_gnu);	669	try defineStd(w, "sparc", is_gnu);
...	@@ -686,8 +688,19 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -686,8 +688,19 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
686	try define(w, "__thumb__");	688	try define(w, "__thumb__");
687	}	689	}
688	},	690	},
689	.aarch64, .aarch64_be => {	691	.aarch64, .aarch64_be => \|arch\| {
690	try define(w, "__aarch64__");	692	try define(w, "__aarch64__");
		693	switch (arch) {
		694	.aarch64 => {
		695	try define(w, "__AARCH64EL__");
		696	},
		697	.aarch64_be => {
		698	try define(w, "__AARCH64EB__");
		699	try define(w, "__AARCH_BIG_ENDIAN");
		700	try define(w, "__ARM_BIG_ENDIAN");
		701	},
		702	else => unreachable,
		703	}
691	if (target.os.tag.isDarwin()) {	704	if (target.os.tag.isDarwin()) {
692	try define(w, "__AARCH64_SIMD__");	705	try define(w, "__AARCH64_SIMD__");
693	if (ptr_width == 32) {	706	if (ptr_width == 32) {
...	@@ -839,6 +852,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -839,6 +852,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
839	}	852	}
840	},	853	},
841	.riscv32, .riscv32be, .riscv64, .riscv64be => {	854	.riscv32, .riscv32be, .riscv64, .riscv64be => {
		855	try define(w, "__riscv");
842	try w.print("#define __riscv_xlen {d}\n", .{ptr_width});	856	try w.print("#define __riscv_xlen {d}\n", .{ptr_width});
843	},	857	},
844	else => {},	858	else => {},
...	@@ -910,6 +924,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -910,6 +924,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
910	\\#define __ATOMIC_CHAR16_T_LOCK_FREE 1	924	\\#define __ATOMIC_CHAR16_T_LOCK_FREE 1
911	\\#define __ATOMIC_CHAR32_T_LOCK_FREE 1	925	\\#define __ATOMIC_CHAR32_T_LOCK_FREE 1
912	\\#define __ATOMIC_WCHAR_T_LOCK_FREE 1	926	\\#define __ATOMIC_WCHAR_T_LOCK_FREE 1
		927	\\#define __ATOMIC_WINT_T_LOCK_FREE 1
913	\\#define __ATOMIC_SHORT_LOCK_FREE 1	928	\\#define __ATOMIC_SHORT_LOCK_FREE 1
914	\\#define __ATOMIC_INT_LOCK_FREE 1	929	\\#define __ATOMIC_INT_LOCK_FREE 1
915	\\#define __ATOMIC_LONG_LOCK_FREE 1	930	\\#define __ATOMIC_LONG_LOCK_FREE 1
...	@@ -922,7 +937,15 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -922,7 +937,15 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
922	}	937	}
923		938
924	// types	939	// types
925	if (comp.getCharSignedness() == .unsigned) try w.writeAll("#define __CHAR_UNSIGNED__ 1\n");	940	if (comp.getCharSignedness() == .unsigned) {
		941	try w.writeAll("#define __CHAR_UNSIGNED__ 1\n");
		942	}
		943	if (comp.type_store.wchar.signedness(comp) == .unsigned) {
		944	try w.writeAll("#define __WCHAR_UNSIGNED__ 1\n");
		945	}
		946	if (comp.type_store.wint.signedness(comp) == .unsigned) {
		947	try w.writeAll("#define __WINT_UNSIGNED__ 1\n");
		948	}
926	try w.writeAll("#define __CHAR_BIT__ 8\n");	949	try w.writeAll("#define __CHAR_BIT__ 8\n");
927		950
928	// int maxs	951	// int maxs
...	@@ -933,7 +956,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -933,7 +956,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
933	try comp.generateIntMaxAndWidth(w, "LONG", .long);	956	try comp.generateIntMaxAndWidth(w, "LONG", .long);
934	try comp.generateIntMaxAndWidth(w, "LONG_LONG", .long_long);	957	try comp.generateIntMaxAndWidth(w, "LONG_LONG", .long_long);
935	try comp.generateIntMaxAndWidth(w, "WCHAR", comp.type_store.wchar);	958	try comp.generateIntMaxAndWidth(w, "WCHAR", comp.type_store.wchar);
936	// try comp.generateIntMax(w, "WINT", comp.type_store.wchar);	959	try comp.generateIntMaxAndWidth(w, "WINT", comp.type_store.wint);
937	try comp.generateIntMaxAndWidth(w, "INTMAX", comp.type_store.intmax);	960	try comp.generateIntMaxAndWidth(w, "INTMAX", comp.type_store.intmax);
938	try comp.generateIntMaxAndWidth(w, "SIZE", comp.type_store.size);	961	try comp.generateIntMaxAndWidth(w, "SIZE", comp.type_store.size);
939	try comp.generateIntMaxAndWidth(w, "UINTMAX", try comp.type_store.intmax.makeIntUnsigned(comp));	962	try comp.generateIntMaxAndWidth(w, "UINTMAX", try comp.type_store.intmax.makeIntUnsigned(comp));
...	@@ -957,7 +980,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -957,7 +980,7 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
957	try comp.generateSizeofType(w, "__SIZEOF_PTRDIFF_T__", comp.type_store.ptrdiff);	980	try comp.generateSizeofType(w, "__SIZEOF_PTRDIFF_T__", comp.type_store.ptrdiff);
958	try comp.generateSizeofType(w, "__SIZEOF_SIZE_T__", comp.type_store.size);	981	try comp.generateSizeofType(w, "__SIZEOF_SIZE_T__", comp.type_store.size);
959	try comp.generateSizeofType(w, "__SIZEOF_WCHAR_T__", comp.type_store.wchar);	982	try comp.generateSizeofType(w, "__SIZEOF_WCHAR_T__", comp.type_store.wchar);
960	// try comp.generateSizeofType(w, "__SIZEOF_WINT_T__", .void_pointer);	983	try comp.generateSizeofType(w, "__SIZEOF_WINT_T__", comp.type_store.wint);
961		984
962	if (target.hasInt128()) {	985	if (target.hasInt128()) {
963	try comp.generateSizeofType(w, "__SIZEOF_INT128__", .int128);	986	try comp.generateSizeofType(w, "__SIZEOF_INT128__", .int128);
...	@@ -968,14 +991,15 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {	...	@@ -968,14 +991,15 @@ fn generateSystemDefines(comp: Compilation, w: Io.Writer) !void {
968	try comp.generateTypeMacro(w, "__UINTPTR_TYPE__", try comp.type_store.intptr.makeIntUnsigned(comp));	991	try comp.generateTypeMacro(w, "__UINTPTR_TYPE__", try comp.type_store.intptr.makeIntUnsigned(comp));
969		992
970	try comp.generateTypeMacro(w, "__INTMAX_TYPE__", comp.type_store.intmax);	993	try comp.generateTypeMacro(w, "__INTMAX_TYPE__", comp.type_store.intmax);
971	try comp.generateSuffixMacro("__INTMAX", w, comp.type_store.intptr);	994	try comp.generateIntLiteralMacros("__INTMAX", w, comp.type_store.intptr);
972		995
973	try comp.generateTypeMacro(w, "__UINTMAX_TYPE__", try comp.type_store.intmax.makeIntUnsigned(comp));	996	try comp.generateTypeMacro(w, "__UINTMAX_TYPE__", try comp.type_store.intmax.makeIntUnsigned(comp));
974	try comp.generateSuffixMacro("__UINTMAX", w, try comp.type_store.intptr.makeIntUnsigned(comp));	997	try comp.generateIntLiteralMacros("__UINTMAX", w, try comp.type_store.intptr.makeIntUnsigned(comp));
975		998
976	try comp.generateTypeMacro(w, "__PTRDIFF_TYPE__", comp.type_store.ptrdiff);	999	try comp.generateTypeMacro(w, "__PTRDIFF_TYPE__", comp.type_store.ptrdiff);
977	try comp.generateTypeMacro(w, "__SIZE_TYPE__", comp.type_store.size);	1000	try comp.generateTypeMacro(w, "__SIZE_TYPE__", comp.type_store.size);
978	try comp.generateTypeMacro(w, "__WCHAR_TYPE__", comp.type_store.wchar);	1001	try comp.generateTypeMacro(w, "__WCHAR_TYPE__", comp.type_store.wchar);
		1002	try comp.generateTypeMacro(w, "__WINT_TYPE__", comp.type_store.wint);
979	try comp.generateTypeMacro(w, "__CHAR16_TYPE__", comp.type_store.uint_least16_t);	1003	try comp.generateTypeMacro(w, "__CHAR16_TYPE__", comp.type_store.uint_least16_t);
980	try comp.generateTypeMacro(w, "__CHAR32_TYPE__", comp.type_store.uint_least32_t);	1004	try comp.generateTypeMacro(w, "__CHAR32_TYPE__", comp.type_store.uint_least32_t);
981		1005
...	@@ -1167,8 +1191,10 @@ fn generateTypeMacro(comp: const Compilation, w: Io.Writer, name: []const u8,	...	@@ -1167,8 +1191,10 @@ fn generateTypeMacro(comp: const Compilation, w: Io.Writer, name: []const u8,
1167	}	1191	}
1168		1192
1169	pub fn float80Type(comp: *const Compilation) ?QualType {	1193	pub fn float80Type(comp: *const Compilation) ?QualType {
1170	if (comp.langopts.emulate != .gcc) return null;	1194	return switch (comp.langopts.emulate) {
1171	return comp.target.float80Type();	1195	.no, .gcc => comp.target.float80Type(),
		1196	.msvc, .clang => null,
		1197	};
1172	}	1198	}
1173		1199
1174	/// Smallest integer type with at least N bits	1200	/// Smallest integer type with at least N bits
...	@@ -1292,8 +1318,14 @@ fn generateFmt(comp: const Compilation, prefix: []const u8, w: Io.Writer, qt:	...	@@ -1292,8 +1318,14 @@ fn generateFmt(comp: const Compilation, prefix: []const u8, w: Io.Writer, qt:
1292	}	1318	}
1293	}	1319	}
1294		1320
1295	fn generateSuffixMacro(comp: const Compilation, prefix: []const u8, w: Io.Writer, qt: QualType) !void {	1321	fn generateIntLiteralMacros(comp: const Compilation, prefix: []const u8, w: Io.Writer, qt: QualType) !void {
1296	return w.print("#define {s}_C_SUFFIX__ {s}\n", .{ prefix, qt.intValueSuffix(comp) });	1322	const suffix = qt.intValueSuffix(comp);
		1323	try w.print("#define {s}_C_SUFFIX__ {s}\n", .{ prefix, suffix });
		1324	if (suffix.len == 0) {
		1325	try w.print("#define {s}_C(c) c\n", .{prefix});
		1326	} else {
		1327	try w.print("#define {s}_C(c) c##{s}\n", .{ prefix, suffix });
		1328	}
1297	}	1329	}
1298		1330
1299	/// Generate the following for a type:	1331	/// Generate the following for a type:
...	@@ -1322,7 +1354,7 @@ fn generateExactWidthType(comp: Compilation, w: Io.Writer, original_qt: QualTy	...	@@ -1322,7 +1354,7 @@ fn generateExactWidthType(comp: Compilation, w: Io.Writer, original_qt: QualTy
1322	const prefix = full[0 .. full.len - suffix.len]; // remove "_TYPE__"	1354	const prefix = full[0 .. full.len - suffix.len]; // remove "_TYPE__"
1323		1355
1324	try comp.generateFmt(prefix, w, qt);	1356	try comp.generateFmt(prefix, w, qt);
1325	try comp.generateSuffixMacro(prefix, w, qt);	1357	try comp.generateIntLiteralMacros(prefix, w, qt);
1326	}	1358	}
1327		1359
1328	pub fn hasFloat128(comp: *const Compilation) bool {	1360	pub fn hasFloat128(comp: *const Compilation) bool {
...	@@ -1414,7 +1446,7 @@ pub fn maxArrayBytes(comp: *const Compilation) u64 {	...	@@ -1414,7 +1446,7 @@ pub fn maxArrayBytes(comp: *const Compilation) u64 {
1414	pub fn fixedEnumTagType(comp: *const Compilation) ?QualType {	1446	pub fn fixedEnumTagType(comp: *const Compilation) ?QualType {
1415	switch (comp.langopts.emulate) {	1447	switch (comp.langopts.emulate) {
1416	.msvc => return .int,	1448	.msvc => return .int,
1417	.clang => if (comp.target.os.tag == .windows and comp.target.abi == .msvc) return .int,	1449	.no, .clang => if (comp.target.os.tag == .windows and comp.target.abi == .msvc) return .int,
1418	.gcc => {},	1450	.gcc => {},
1419	}	1451	}
1420	return null;	1452	return null;
...	@@ -1424,6 +1456,10 @@ pub fn getCharSignedness(comp: *const Compilation) std.builtin.Signedness {	...	@@ -1424,6 +1456,10 @@ pub fn getCharSignedness(comp: *const Compilation) std.builtin.Signedness {
1424	return comp.langopts.char_signedness_override orelse comp.target.cCharSignedness();	1456	return comp.langopts.char_signedness_override orelse comp.target.cCharSignedness();
1425	}	1457	}
1426		1458
		1459	pub fn hasClangStyleBoundsSafety(comp: *const Compilation) bool {
		1460	return comp.langopts.bounds_safety == .clang;
		1461	}
		1462
1427	pub fn getSource(comp: *const Compilation, id: Source.Id) Source {	1463	pub fn getSource(comp: *const Compilation, id: Source.Id) Source {
1428	if (id.alias) {	1464	if (id.alias) {
1429	return comp.source_aliases.items[@intFromEnum(id.index)];	1465	return comp.source_aliases.items[@intFromEnum(id.index)];
...	@@ -1643,14 +1679,12 @@ fn addSourceFromPathExtra(comp: *Compilation, path: []const u8, kind: Source.Kin	...	@@ -1643,14 +1679,12 @@ fn addSourceFromPathExtra(comp: *Compilation, path: []const u8, kind: Source.Kin
1643	return error.FileNotFound;	1679	return error.FileNotFound;
1644	}	1680	}
1645		1681
1646	const io = comp.io;	1682	const file = try comp.cwd.openFile(comp.io, path, .{});
1647		1683	defer file.close(comp.io);
1648	const file = try comp.cwd.openFile(io, path, .{});
1649	defer file.close(io);
1650	return comp.addSourceFromFile(file, path, kind);	1684	return comp.addSourceFromFile(file, path, kind);
1651	}	1685	}
1652		1686
1653	pub fn addSourceFromFile(comp: *Compilation, file: Io.File, path: []const u8, kind: Source.Kind) !Source {	1687	pub fn addSourceFromFile(comp: *Compilation, file: std.Io.File, path: []const u8, kind: Source.Kind) !Source {
1654	const contents = try comp.getFileContents(file, .unlimited);	1688	const contents = try comp.getFileContents(file, .unlimited);
1655	errdefer comp.gpa.free(contents);	1689	errdefer comp.gpa.free(contents);
1656	return comp.addSourceFromOwnedBuffer(path, contents, kind);	1690	return comp.addSourceFromOwnedBuffer(path, contents, kind);
...	@@ -1718,8 +1752,7 @@ pub fn initSearchPath(comp: *Compilation, includes: []const Include, verbose: bo	...	@@ -1718,8 +1752,7 @@ pub fn initSearchPath(comp: *Compilation, includes: []const Include, verbose: bo
1718	}	1752	}
1719	}	1753	}
1720	fn addToSearchPath(comp: *Compilation, include: Include, verbose: bool) !void {	1754	fn addToSearchPath(comp: *Compilation, include: Include, verbose: bool) !void {
1721	const io = comp.io;	1755	comp.cwd.access(comp.io, include.path, .{}) catch {
1722	comp.cwd.access(io, include.path, .{}) catch {
1723	if (verbose) {	1756	if (verbose) {
1724	std.debug.print("ignoring nonexistent directory \"{s}\"\n", .{include.path});	1757	std.debug.print("ignoring nonexistent directory \"{s}\"\n", .{include.path});
1725	return;	1758	return;
...	@@ -1979,14 +2012,12 @@ fn getPathContents(comp: *Compilation, path: []const u8, limit: Io.Limit) ![]u8	...	@@ -1979,14 +2012,12 @@ fn getPathContents(comp: *Compilation, path: []const u8, limit: Io.Limit) ![]u8
1979	return error.FileNotFound;	2012	return error.FileNotFound;
1980	}	2013	}
1981		2014
1982	const io = comp.io;	2015	const file = try comp.cwd.openFile(comp.io, path, .{});
1983		2016	defer file.close(comp.io);
1984	const file = try comp.cwd.openFile(io, path, .{});
1985	defer file.close(io);
1986	return comp.getFileContents(file, limit);	2017	return comp.getFileContents(file, limit);
1987	}	2018	}
1988		2019
1989	fn getFileContents(comp: *Compilation, file: Io.File, limit: Io.Limit) ![]u8 {	2020	fn getFileContents(comp: *Compilation, file: std.Io.File, limit: Io.Limit) ![]u8 {
1990	var file_buf: [4096]u8 = undefined;	2021	var file_buf: [4096]u8 = undefined;
1991	var file_reader = file.reader(comp.io, &file_buf);	2022	var file_reader = file.reader(comp.io, &file_buf);
1992		2023
...	@@ -2168,9 +2199,8 @@ pub fn locSlice(comp: *const Compilation, loc: Source.Location) []const u8 {	...	@@ -2168,9 +2199,8 @@ pub fn locSlice(comp: *const Compilation, loc: Source.Location) []const u8 {
2168	}	2199	}
2169		2200
2170	pub fn getSourceMTimeUncached(comp: *const Compilation, source_id: Source.Id) ?u64 {	2201	pub fn getSourceMTimeUncached(comp: *const Compilation, source_id: Source.Id) ?u64 {
2171	const io = comp.io;
2172	const source = comp.getSource(source_id);	2202	const source = comp.getSource(source_id);
2173	if (comp.cwd.statFile(io, source.path, .{})) \|stat\| {	2203	if (comp.cwd.statFile(comp.io, source.path, .{})) \|stat\| {
2174	return std.math.cast(u64, stat.mtime.toSeconds());	2204	return std.math.cast(u64, stat.mtime.toSeconds());
2175	} else \|_\| {	2205	} else \|_\| {
2176	return null;	2206	return null;
...	@@ -2257,10 +2287,9 @@ pub const Diagnostic = struct {	...	@@ -2257,10 +2287,9 @@ pub const Diagnostic = struct {
2257	test "addSourceFromBuffer" {	2287	test "addSourceFromBuffer" {
2258	const Test = struct {	2288	const Test = struct {
2259	fn addSourceFromBuffer(str: []const u8, expected: []const u8, warning_count: u32, splices: []const u32) !void {	2289	fn addSourceFromBuffer(str: []const u8, expected: []const u8, warning_count: u32, splices: []const u32) !void {
2260	var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
2261	defer arena.deinit();
2262	var diagnostics: Diagnostics = .{ .output = .ignore };	2290	var diagnostics: Diagnostics = .{ .output = .ignore };
2263	var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());	2291	var comp = try Compilation.init(.testing);
		2292	comp.diagnostics = &diagnostics;
2264	defer comp.deinit();	2293	defer comp.deinit();
2265		2294
2266	const source = try comp.addSourceFromBuffer("path", str);	2295	const source = try comp.addSourceFromBuffer("path", str);
...	@@ -2271,10 +2300,8 @@ test "addSourceFromBuffer" {	...	@@ -2271,10 +2300,8 @@ test "addSourceFromBuffer" {
2271	}	2300	}
2272		2301
2273	fn withAllocationFailures(allocator: std.mem.Allocator) !void {	2302	fn withAllocationFailures(allocator: std.mem.Allocator) !void {
2274	var arena: std.heap.ArenaAllocator = .init(allocator);	2303	var comp = try Compilation.init(.testing);
2275	defer arena.deinit();	2304	comp.gpa = allocator;
2276	var diagnostics: Diagnostics = .{ .output = .ignore };
2277	var comp = Compilation.init(allocator, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());
2278	defer comp.deinit();	2305	defer comp.deinit();
2279		2306
2280	_ = try comp.addSourceFromBuffer("path", "spliced\\\nbuffer\n");	2307	_ = try comp.addSourceFromBuffer("path", "spliced\\\nbuffer\n");
...	@@ -2320,7 +2347,8 @@ test "addSourceFromBuffer - exhaustive check for carriage return elimination" {	...	@@ -2320,7 +2347,8 @@ test "addSourceFromBuffer - exhaustive check for carriage return elimination" {
2320	var buf: [alphabet.len]u8 = @splat(alphabet[0]);	2347	var buf: [alphabet.len]u8 = @splat(alphabet[0]);
2321		2348
2322	var diagnostics: Diagnostics = .{ .output = .ignore };	2349	var diagnostics: Diagnostics = .{ .output = .ignore };
2323	var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());	2350	var comp = try Compilation.init(.testing);
		2351	comp.diagnostics = &diagnostics;
2324	defer comp.deinit();	2352	defer comp.deinit();
2325		2353
2326	var source_count: u32 = 0;	2354	var source_count: u32 = 0;
...	@@ -2346,9 +2374,8 @@ test "addSourceFromBuffer - exhaustive check for carriage return elimination" {	...	@@ -2346,9 +2374,8 @@ test "addSourceFromBuffer - exhaustive check for carriage return elimination" {
2346	test "ignore BOM at beginning of file" {	2374	test "ignore BOM at beginning of file" {
2347	const BOM = "\xEF\xBB\xBF";	2375	const BOM = "\xEF\xBB\xBF";
2348	const Test = struct {	2376	const Test = struct {
2349	fn run(arena: Allocator, buf: []const u8) !void {	2377	fn run(buf: []const u8) !void {
2350	var diagnostics: Diagnostics = .{ .output = .ignore };	2378	var comp = try Compilation.init(.testing);
2351	var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, &diagnostics, Io.Dir.cwd());
2352	defer comp.deinit();	2379	defer comp.deinit();
2353		2380
2354	const source = try comp.addSourceFromBuffer("file.c", buf);	2381	const source = try comp.addSourceFromBuffer("file.c", buf);
...	@@ -2357,19 +2384,15 @@ test "ignore BOM at beginning of file" {	...	@@ -2357,19 +2384,15 @@ test "ignore BOM at beginning of file" {
2357	}	2384	}
2358	};	2385	};
2359		2386
2360	var arena_state: std.heap.ArenaAllocator = .init(std.testing.allocator);	2387	try Test.run(BOM);
2361	defer arena_state.deinit();	2388	try Test.run(BOM ++ "x");
2362	const arena = arena_state.allocator();	2389	try Test.run("x" ++ BOM);
2363		2390	try Test.run(BOM ++ " ");
2364	try Test.run(arena, BOM);	2391	try Test.run(BOM ++ "\n");
2365	try Test.run(arena, BOM ++ "x");	2392	try Test.run(BOM ++ "\\");
2366	try Test.run(arena, "x" ++ BOM);	2393
2367	try Test.run(arena, BOM ++ " ");	2394	try Test.run(BOM[0..1] ++ "x");
2368	try Test.run(arena, BOM ++ "\n");	2395	try Test.run(BOM[0..2] ++ "x");
2369	try Test.run(arena, BOM ++ "\\");	2396	try Test.run(BOM[1..] ++ "x");
2370		2397	try Test.run(BOM[2..] ++ "x");
2371	try Test.run(arena, BOM[0..1] ++ "x");
2372	try Test.run(arena, BOM[0..2] ++ "x");
2373	try Test.run(arena, BOM[1..] ++ "x");
2374	try Test.run(arena, BOM[2..] ++ "x");
2375	}	2398	}

lib/compiler/aro/aro/Diagnostics.zig+21-17

 @@ -24,21 +24,21 @@ pub const Message = struct {
         @"fatal error",
     };
-    pub fn write(msg: Message, t: std.Io.Terminal, details: bool) std.Io.Terminal.SetColorError!void {
+    pub fn write(msg: Message, term: std.Io.Terminal, details: bool) std.Io.Terminal.SetColorError!void {
-        const w = t.writer;
+        const w = term.writer;
-        try t.setColor(.bold);
+        try term.setColor(.bold);
         if (msg.location) |loc| {
             try w.print("{s}:{d}:{d}: ", .{ loc.path, loc.line_no, loc.col });
         }
         switch (msg.effective_kind) {
-            .@"fatal error", .@"error" => try t.setColor(.bright_red),
+            .@"fatal error", .@"error" => try term.setColor(.bright_red),
-            .note => try t.setColor(.bright_cyan),
+            .note => try term.setColor(.bright_cyan),
-            .warning => try t.setColor(.bright_magenta),
+            .warning => try term.setColor(.bright_magenta),
             .off => unreachable,
         }
         try w.print("{s}: ", .{@tagName(msg.effective_kind)});
-        try t.setColor(.white);
+        try term.setColor(.white);
         try w.writeAll(msg.text);
         if (msg.opt) |some| {
             if (msg.effective_kind == .@"error" and msg.kind != .@"error") {
 @@ -56,17 +56,17 @@ pub const Message = struct {
         if (!details or msg.location == null) {
             try w.writeAll("\n");
-            try t.setColor(.reset);
+            try term.setColor(.reset);
         } else {
             const loc = msg.location.?;
             const trailer = if (loc.end_with_splice) "\\ " else "";
-            try t.setColor(.reset);
+            try term.setColor(.reset);
             try w.print("\n{s}{s}\n", .{ loc.line, trailer });
             try w.splatByteAll(' ', loc.width);
-            try t.setColor(.bold);
+            try term.setColor(.bold);
-            try t.setColor(.bright_green);
+            try term.setColor(.bright_green);
             try w.writeAll("^\n");
-            try t.setColor(.reset);
+            try term.setColor(.reset);
         }
         try w.flush();
     }
 @@ -199,6 +199,10 @@ pub const Option = enum {
     @"pragma-once-outside-header",
     @"underlying-atomic-qualifier-ignored",
     @"underlying-cv-qualifier-ignored",
+    @"bounds-attributes-redundant",
+    @"file-name-extension",
+    @"base-file-extension",
+    @"include-level-extension",
     /// GNU extensions
     pub const gnu = [_]Option{
 @@ -541,11 +545,11 @@ fn addMessage(d: *Diagnostics, msg: Message) Compilation.Error!void {
     switch (d.output) {
         .ignore => {},
-        .to_writer => |t| {
+        .to_writer => |terminal| {
-            var new_mode = t.mode;
+            var mode = terminal.mode;
-            if (d.color == false) new_mode = .no_color;
+            if (d.color == false) mode = .no_color;
-            if (d.color == true and new_mode == .no_color) new_mode = .escape_codes;
+            if (d.color == true and mode == .no_color) mode = .escape_codes;
-            msg.write(.{ .writer = t.writer, .mode = new_mode }, d.details) catch {
+            msg.write(.{ .mode = mode, .writer = terminal.writer }, d.details) catch {
                 return error.FatalError;
             };
         },

lib/compiler/aro/aro/Driver.zig+124-50

...	@@ -1,5 +1,4 @@	...	@@ -1,5 +1,4 @@
1	const std = @import("std");	1	const std = @import("std");
2	const Io = std.Io;
3	const mem = std.mem;	2	const mem = std.mem;
4	const Allocator = mem.Allocator;	3	const Allocator = mem.Allocator;
5	const process = std.process;	4	const process = std.process;
...	@@ -9,6 +8,7 @@ const Assembly = backend.Assembly;	...	@@ -9,6 +8,7 @@ const Assembly = backend.Assembly;
9	const Ir = backend.Ir;	8	const Ir = backend.Ir;
10	const Object = backend.Object;	9	const Object = backend.Object;
11		10
		11	const Attribute = @import("Attribute.zig");
12	const Compilation = @import("Compilation.zig");	12	const Compilation = @import("Compilation.zig");
13	const Diagnostics = @import("Diagnostics.zig");	13	const Diagnostics = @import("Diagnostics.zig");
14	const DepFile = @import("DepFile.zig");	14	const DepFile = @import("DepFile.zig");
...	@@ -52,6 +52,7 @@ implicit_includes: std.ArrayList(Source) = .empty,	...	@@ -52,6 +52,7 @@ implicit_includes: std.ArrayList(Source) = .empty,
52	/// List of includes that will be used to construct the compilation's search path	52	/// List of includes that will be used to construct the compilation's search path
53	includes: std.ArrayList(Compilation.Include) = .empty,	53	includes: std.ArrayList(Compilation.Include) = .empty,
54	link_objects: std.ArrayList([]const u8) = .empty,	54	link_objects: std.ArrayList([]const u8) = .empty,
		55	macro_prefix_map: std.ArrayList(struct { []const u8, []const u8 }) = .empty,
55	output_name: ?[]const u8 = null,	56	output_name: ?[]const u8 = null,
56	sysroot: ?[]const u8 = null,	57	sysroot: ?[]const u8 = null,
57	resource_dir: ?[]const u8 = null,	58	resource_dir: ?[]const u8 = null,
...	@@ -134,9 +135,8 @@ strip: bool = false,	...	@@ -134,9 +135,8 @@ strip: bool = false,
134	unwindlib: ?[]const u8 = null,	135	unwindlib: ?[]const u8 = null,
135		136
136	pub fn deinit(d: *Driver) void {	137	pub fn deinit(d: *Driver) void {
137	const io = d.comp.io;
138	for (d.link_objects.items[d.link_objects.items.len - d.temp_file_count ..]) \|obj\| {	138	for (d.link_objects.items[d.link_objects.items.len - d.temp_file_count ..]) \|obj\| {
139	Io.Dir.deleteFileAbsolute(io, obj) catch {};	139	std.Io.Dir.deleteFileAbsolute(d.comp.io, obj) catch {};
140	d.comp.gpa.free(obj);	140	d.comp.gpa.free(obj);
141	}	141	}
142	d.inputs.deinit(d.comp.gpa);	142	d.inputs.deinit(d.comp.gpa);
...	@@ -144,6 +144,7 @@ pub fn deinit(d: *Driver) void {	...	@@ -144,6 +144,7 @@ pub fn deinit(d: *Driver) void {
144	d.implicit_includes.deinit(d.comp.gpa);	144	d.implicit_includes.deinit(d.comp.gpa);
145	d.includes.deinit(d.comp.gpa);	145	d.includes.deinit(d.comp.gpa);
146	d.link_objects.deinit(d.comp.gpa);	146	d.link_objects.deinit(d.comp.gpa);
		147	d.macro_prefix_map.deinit(d.comp.gpa);
147	d.* = undefined;	148	d.* = undefined;
148	}	149	}
149		150
...	@@ -177,6 +178,10 @@ pub const usage =	...	@@ -177,6 +178,10 @@ pub const usage =
177	\\ -darwin-target-variant-triple	178	\\ -darwin-target-variant-triple
178	\\ Specify the darwin target variant triple	179	\\ Specify the darwin target variant triple
179	\\ -fapple-kext Use Apple's kernel extensions ABI	180	\\ -fapple-kext Use Apple's kernel extensions ABI
		181	\\ -fexperimental-bounds-safety
		182	\\ Enable experimental clang-style bounds safety attributes (INCOMPLETE)
		183	\\ -fno-experimental-bounds-safety
		184	\\ Disable experimental clang-style bounds safety attributes
180	\\ -fchar8_t Enable char8_t (enabled by default in C23 and later)	185	\\ -fchar8_t Enable char8_t (enabled by default in C23 and later)
181	\\ -fno-char8_t Disable char8_t (disabled by default for pre-C23)	186	\\ -fno-char8_t Disable char8_t (disabled by default for pre-C23)
182	\\ -fcolor-diagnostics Enable colors in diagnostics	187	\\ -fcolor-diagnostics Enable colors in diagnostics
...	@@ -218,6 +223,8 @@ pub const usage =	...	@@ -218,6 +223,8 @@ pub const usage =
218	\\ -fuse-line-directives Use `#line <num>` linemarkers in preprocessed output	223	\\ -fuse-line-directives Use `#line <num>` linemarkers in preprocessed output
219	\\ -fno-use-line-directives	224	\\ -fno-use-line-directives
220	\\ Use `# <num>` linemarkers in preprocessed output	225	\\ Use `# <num>` linemarkers in preprocessed output
		226	\\ -fvisibility=[default\|hidden\|internal\|protected]
		227	\\ Set the default ELF image symbol visibility to the specified option—all symbols are marked with this unless overridden within the code
221	\\ -iquote <dir> Add directory to QUOTE include search path	228	\\ -iquote <dir> Add directory to QUOTE include search path
222	\\ -I <dir> Add directory to include search path	229	\\ -I <dir> Add directory to include search path
223	\\ -idirafter <dir> Add directory to AFTER include search path	230	\\ -idirafter <dir> Add directory to AFTER include search path
...	@@ -375,6 +382,17 @@ pub fn parseArgs(	...	@@ -375,6 +382,17 @@ pub fn parseArgs(
375	d.use_line_directives = false;	382	d.use_line_directives = false;
376	} else if (mem.eql(u8, arg, "-fapple-kext")) {	383	} else if (mem.eql(u8, arg, "-fapple-kext")) {
377	d.apple_kext = true;	384	d.apple_kext = true;
		385	} else if (option(arg, "-fvisibility=")) \|visibility\| {
		386	d.comp.langopts.default_symbol_visibility = Attribute.visibilityFromString(visibility) orelse
		387	return d.fatal("unsupported value '{s}'' in '{s}'", .{ visibility, arg });
		388	} else if (option(arg, "-frandom-seed=")) \|_\| {
		389	// Ignore
		390	} else if (option(arg, "-fmacro-prefix-map=")) \|kv\| {
		391	const pair = mem.cutScalar(u8, kv, '=') orelse {
		392	try d.err("invalid argument '{s}' to '-fmacro-prefix-map=", .{kv});
		393	continue;
		394	};
		395	try d.macro_prefix_map.append(gpa, pair);
378	} else if (option(arg, "-mcmodel=")) \|cmodel\| {	396	} else if (option(arg, "-mcmodel=")) \|cmodel\| {
379	d.comp.cmodel = std.meta.stringToEnum(std.builtin.CodeModel, cmodel) orelse	397	d.comp.cmodel = std.meta.stringToEnum(std.builtin.CodeModel, cmodel) orelse
380	return d.fatal("unsupported machine code model: '{s}'", .{arg});	398	return d.fatal("unsupported machine code model: '{s}'", .{arg});
...	@@ -415,6 +433,10 @@ pub fn parseArgs(	...	@@ -415,6 +433,10 @@ pub fn parseArgs(
415	d.dependencies.file = path;	433	d.dependencies.file = path;
416	} else if (mem.eql(u8, arg, "-MV")) {	434	} else if (mem.eql(u8, arg, "-MV")) {
417	d.dependencies.format = .nmake;	435	d.dependencies.format = .nmake;
		436	} else if (mem.eql(u8, arg, "-fexperimental-bounds-safety")) {
		437	d.comp.langopts.bounds_safety = .clang;
		438	} else if (mem.eql(u8, arg, "-fno-experimental-bounds-safety")) {
		439	d.comp.langopts.bounds_safety = .none;
418	} else if (mem.eql(u8, arg, "-fchar8_t")) {	440	} else if (mem.eql(u8, arg, "-fchar8_t")) {
419	d.comp.langopts.has_char8_t_override = true;	441	d.comp.langopts.has_char8_t_override = true;
420	} else if (mem.eql(u8, arg, "-fno-char8_t")) {	442	} else if (mem.eql(u8, arg, "-fno-char8_t")) {
...	@@ -635,6 +657,42 @@ pub fn parseArgs(	...	@@ -635,6 +657,42 @@ pub fn parseArgs(
635	d.output_name = file;	657	d.output_name = file;
636	} else if (option(arg, "--sysroot=")) \|sysroot\| {	658	} else if (option(arg, "--sysroot=")) \|sysroot\| {
637	d.sysroot = sysroot;	659	d.sysroot = sysroot;
		660	} else if (mem.eql(u8, arg, "--sysroot")) {
		661	i += 1;
		662	if (i >= args.len) {
		663	try d.err("expected argument after --sysroot", .{});
		664	continue;
		665	}
		666	d.sysroot = args[i];
		667	} else if (mem.startsWith(u8, arg, "-isysroot")) {
		668	var path = arg["-isysroot".len..];
		669	if (path.len == 0) {
		670	i += 1;
		671	if (i >= args.len) {
		672	try d.err("expected argument after -isysroot", .{});
		673	continue;
		674	}
		675	path = args[i];
		676	}
		677	d.sysroot = path;
		678	} else if (mem.eql(u8, arg, "-rpath")) {
		679	i += 1;
		680	if (i >= args.len) {
		681	try d.err("expected argument after -rpath", .{});
		682	continue;
		683	}
		684	// ignore for now
		685	} else if (mem.startsWith(u8, arg, "-L")) {
		686	var path = arg["-L".len..];
		687	if (path.len == 0) {
		688	i += 1;
		689	if (i >= args.len) {
		690	try d.err("expected argument after -L", .{});
		691	continue;
		692	}
		693	path = args[i];
		694	}
		695	// ignore for now
638	} else if (mem.eql(u8, arg, "-Wp,-v")) {	696	} else if (mem.eql(u8, arg, "-Wp,-v")) {
639	// TODO this is not how this argument should work	697	// TODO this is not how this argument should work
640	d.verbose_search_path = true;	698	d.verbose_search_path = true;
...	@@ -706,6 +764,10 @@ pub fn parseArgs(	...	@@ -706,6 +764,10 @@ pub fn parseArgs(
706	d.comp.langopts.preserve_comments = true;	764	d.comp.langopts.preserve_comments = true;
707	d.comp.langopts.preserve_comments_in_macros = true;	765	d.comp.langopts.preserve_comments_in_macros = true;
708	comment_arg = arg;	766	comment_arg = arg;
		767	} else if (option(arg, "-fuse-ld=")) \|linker_name\| {
		768	d.use_linker = linker_name;
		769	} else if (mem.eql(u8, arg, "-fuse-ld=")) {
		770	d.use_linker = null;
709	} else if (option(arg, "--ld-path=")) \|linker_path\| {	771	} else if (option(arg, "--ld-path=")) \|linker_path\| {
710	d.linker_path = linker_path;	772	d.linker_path = linker_path;
711	} else if (mem.eql(u8, arg, "-r")) {	773	} else if (mem.eql(u8, arg, "-r")) {
...	@@ -810,6 +872,7 @@ pub fn parseArgs(	...	@@ -810,6 +872,7 @@ pub fn parseArgs(
810	.clang => try d.diagnostics.set("clang", .off),	872	.clang => try d.diagnostics.set("clang", .off),
811	.gcc => try d.diagnostics.set("gnu", .off),	873	.gcc => try d.diagnostics.set("gnu", .off),
812	.msvc => try d.diagnostics.set("microsoft", .off),	874	.msvc => try d.diagnostics.set("microsoft", .off),
		875	.no => {},
813	}	876	}
814	}	877	}
815	if (d.comp.langopts.preserve_comments and !d.only_preprocess) {	878	if (d.comp.langopts.preserve_comments and !d.only_preprocess) {
...	@@ -1063,20 +1126,22 @@ pub fn printDiagnosticsStats(d: *Driver) void {	...	@@ -1063,20 +1126,22 @@ pub fn printDiagnosticsStats(d: *Driver) void {
1063	}	1126	}
1064	}	1127	}
1065		1128
1066	pub fn detectConfig(d: *Driver, file: Io.File) std.Io.tty.Config {	1129	pub fn detectMode(d: *Driver, file: std.Io.File) std.Io.Cancelable!std.Io.Terminal.Mode {
1067	if (d.diagnostics.color == false) return .no_color;	1130	if (d.diagnostics.color == false) return .no_color;
1068	const force_color = d.diagnostics.color == true;	1131	const force_color = d.diagnostics.color == true;
1069		1132
1070	if (file.supportsAnsiEscapeCodes()) return .escape_codes;	1133	const io = d.comp.io;
1071	if (@import("builtin").os.tag == .windows and file.isTty()) {	1134	if (try file.supportsAnsiEscapeCodes(io)) return .escape_codes;
1072	var info: std.os.windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;	1135	if (@import("builtin").os.tag == .windows and try file.isTty(io)) {
1073	if (std.os.windows.kernel32.GetConsoleScreenBufferInfo(file.handle, &info) == std.os.windows.FALSE) {	1136	var get_console_info = std.os.windows.CONSOLE.USER_IO.GET_SCREEN_BUFFER_INFO;
1074	return if (force_color) .escape_codes else .no_color;	1137	switch (try get_console_info.operate(io, file)) {
		1138	.SUCCESS => return .{ .windows_api = .{
		1139	.io = io,
		1140	.file = file,
		1141	.reset_attributes = get_console_info.Data.wAttributes,
		1142	} },
		1143	else => {},
1075	}	1144	}
1076	return .{ .windows_api = .{
1077	.handle = file.handle,
1078	.reset_attributes = info.wAttributes,
1079	} };
1080	}	1145	}
1081		1146
1082	return if (force_color) .escape_codes else .no_color;	1147	return if (force_color) .escape_codes else .no_color;
...	@@ -1105,13 +1170,13 @@ pub fn errorDescription(e: anyerror) []const u8 {	...	@@ -1105,13 +1170,13 @@ pub fn errorDescription(e: anyerror) []const u8 {
1105		1170
1106	/// The entry point of the Aro compiler.	1171	/// The entry point of the Aro compiler.
1107	/// MAY call `exit` if `fast_exit` is set.	1172	/// MAY call `exit` if `fast_exit` is set.
1108	pub fn main(d: Driver, tc: Toolchain, args: []const []const u8, comptime fast_exit: bool, asm_gen_fn: ?AsmCodeGenFn) Compilation.Error!void {	1173	pub fn main(d: Driver, tc: Toolchain, args: []const []const u8, comptime fast_exit: bool, asm_gen_fn: ?AsmCodeGenFn) (Compilation.Error \|\| std.Io.Cancelable)!void {
1109	const user_macros = macros: {	1174	const user_macros = macros: {
1110	var macro_buf: std.ArrayList(u8) = .empty;	1175	var macro_buf: std.ArrayList(u8) = .empty;
1111	defer macro_buf.deinit(d.comp.gpa);	1176	defer macro_buf.deinit(d.comp.gpa);
1112		1177
1113	var stdout_buf: [256]u8 = undefined;	1178	var stdout_buf: [256]u8 = undefined;
1114	var stdout = Io.File.stdout().writer(&stdout_buf);	1179	var stdout = std.Io.File.stdout().writer(d.comp.io, &stdout_buf);
1115	if (parseArgs(d, &stdout.interface, &macro_buf, args) catch \|er\| switch (er) {	1180	if (parseArgs(d, &stdout.interface, &macro_buf, args) catch \|er\| switch (er) {
1116	error.WriteFailed => return d.fatal("failed to write to stdout: {s}", .{errorDescription(er)}),	1181	error.WriteFailed => return d.fatal("failed to write to stdout: {s}", .{errorDescription(er)}),
1117	error.OutOfMemory => return error.OutOfMemory,	1182	error.OutOfMemory => return error.OutOfMemory,
...	@@ -1217,14 +1282,13 @@ pub fn getDepFileName(d: Driver, source: Source, buf: [std.fs.max_name_bytes]u	...	@@ -1217,14 +1282,13 @@ pub fn getDepFileName(d: Driver, source: Source, buf: [std.fs.max_name_bytes]u
1217	}	1282	}
1218		1283
1219	fn getRandomFilename(d: Driver, buf: [std.fs.max_name_bytes]u8, extension: []const u8) ![]const u8 {	1284	fn getRandomFilename(d: Driver, buf: [std.fs.max_name_bytes]u8, extension: []const u8) ![]const u8 {
1220	const io = d.comp.io;
1221	const random_bytes_count = 12;	1285	const random_bytes_count = 12;
1222	const sub_path_len = comptime std.base64.url_safe.Encoder.calcSize(random_bytes_count);	1286	const sub_path_len = comptime std.fs.base64_encoder.calcSize(random_bytes_count);
1223		1287
1224	var random_bytes: [random_bytes_count]u8 = undefined;	1288	var random_bytes: [random_bytes_count]u8 = undefined;
1225	io.random(&random_bytes);	1289	d.comp.io.random(&random_bytes);
1226	var random_name: [sub_path_len]u8 = undefined;	1290	var random_name: [sub_path_len]u8 = undefined;
1227	_ = std.base64.url_safe.Encoder.encode(&random_name, &random_bytes);	1291	_ = std.fs.base64_encoder.encode(&random_name, &random_bytes);
1228		1292
1229	const fmt_template = "/tmp/{s}{s}";	1293	const fmt_template = "/tmp/{s}{s}";
1230	const fmt_args = .{	1294	const fmt_args = .{
...	@@ -1251,12 +1315,11 @@ fn getOutFileName(d: Driver, source: Source, buf: [std.fs.max_name_bytes]u8) !	...	@@ -1251,12 +1315,11 @@ fn getOutFileName(d: Driver, source: Source, buf: [std.fs.max_name_bytes]u8) !
1251	}	1315	}
1252		1316
1253	fn invokeAssembler(d: Driver, tc: Toolchain, input_path: []const u8, output_path: []const u8) !void {	1317	fn invokeAssembler(d: Driver, tc: Toolchain, input_path: []const u8, output_path: []const u8) !void {
1254	const io = d.comp.io;
1255	var assembler_path_buf: [std.fs.max_path_bytes]u8 = undefined;	1318	var assembler_path_buf: [std.fs.max_path_bytes]u8 = undefined;
1256	const assembler_path = try tc.getAssemblerPath(&assembler_path_buf);	1319	const assembler_path = try tc.getAssemblerPath(&assembler_path_buf);
1257	const argv = [_][]const u8{ assembler_path, input_path, "-o", output_path };	1320	const argv = [_][]const u8{ assembler_path, input_path, "-o", output_path };
1258		1321
1259	var child = std.process.spawn(io, .{	1322	var child = std.process.spawn(d.comp.io, .{
1260	.argv = &argv,	1323	.argv = &argv,
1261	// TODO handle better	1324	// TODO handle better
1262	.stdin = .inherit,	1325	.stdin = .inherit,
...	@@ -1265,8 +1328,8 @@ fn invokeAssembler(d: Driver, tc: Toolchain, input_path: []const u8, output_pa	...	@@ -1265,8 +1328,8 @@ fn invokeAssembler(d: Driver, tc: Toolchain, input_path: []const u8, output_pa
1265	}) catch \|er\| {	1328	}) catch \|er\| {
1266	return d.fatal("unable to spawn linker: {s}", .{errorDescription(er)});	1329	return d.fatal("unable to spawn linker: {s}", .{errorDescription(er)});
1267	};	1330	};
1268	const term = child.wait(io) catch \|er\| {	1331	const term = child.wait(d.comp.io) catch \|er\| {
1269	return d.fatal("unable to wait linker: {s}", .{errorDescription(er)});	1332	return d.fatal("error waiting for linker: {s}", .{errorDescription(er)});
1270	};	1333	};
1271	switch (term) {	1334	switch (term) {
1272	.exited => \|code\| if (code != 0) {	1335	.exited => \|code\| if (code != 0) {
...	@@ -1289,13 +1352,16 @@ fn processSource(	...	@@ -1289,13 +1352,16 @@ fn processSource(
1289	comptime fast_exit: bool,	1352	comptime fast_exit: bool,
1290	asm_gen_fn: ?AsmCodeGenFn,	1353	asm_gen_fn: ?AsmCodeGenFn,
1291	) !void {	1354	) !void {
1292	const gpa = d.comp.gpa;	1355	const comp = d.comp;
1293	d.comp.generated_buf.items.len = 0;	1356	const io = comp.io;
		1357	const gpa = comp.gpa;
		1358	comp.generated_buf.items.len = 0;
1294	const prev_total = d.diagnostics.errors;	1359	const prev_total = d.diagnostics.errors;
1295		1360
1296	const io = d.comp.io;	1361	var pp = try Preprocessor.init(comp, .{
1297		1362	.base_file = source.id,
1298	var pp = try Preprocessor.initDefault(d.comp);	1363	.path_replacements = d.macro_prefix_map.items,
		1364	});
1299	defer pp.deinit();	1365	defer pp.deinit();
1300		1366
1301	var name_buf: [std.fs.max_name_bytes]u8 = undefined;	1367	var name_buf: [std.fs.max_name_bytes]u8 = undefined;
...	@@ -1304,8 +1370,8 @@ fn processSource(	...	@@ -1304,8 +1370,8 @@ fn processSource(
1304		1370
1305	if (opt_dep_file) \|*dep_file\| pp.dep_file = dep_file;	1371	if (opt_dep_file) \|*dep_file\| pp.dep_file = dep_file;
1306		1372
1307	if (d.comp.langopts.ms_extensions) {	1373	if (comp.langopts.ms_extensions) {
1308	d.comp.ms_cwd_source_id = source.id;	1374	comp.ms_cwd_source_id = source.id;
1309	}	1375	}
1310	const dump_mode = d.debug_dump_letters.getPreprocessorDumpMode();	1376	const dump_mode = d.debug_dump_letters.getPreprocessorDumpMode();
1311	if (d.verbose_pp) pp.verbose = true;	1377	if (d.verbose_pp) pp.verbose = true;
...	@@ -1333,10 +1399,10 @@ fn processSource(	...	@@ -1333,10 +1399,10 @@ fn processSource(
1333	const dep_file_name = try d.getDepFileName(source, writer_buf[0..std.fs.max_name_bytes]);	1399	const dep_file_name = try d.getDepFileName(source, writer_buf[0..std.fs.max_name_bytes]);
1334		1400
1335	const file = if (dep_file_name) \|path\|	1401	const file = if (dep_file_name) \|path\|
1336	d.comp.cwd.createFile(io, path, .{}) catch \|er\|	1402	comp.cwd.createFile(io, path, .{}) catch \|er\|
1337	return d.fatal("unable to create dependency file '{s}': {s}", .{ path, errorDescription(er) })	1403	return d.fatal("unable to create dependency file '{s}': {s}", .{ path, errorDescription(er) })
1338	else	1404	else
1339	Io.File.stdout();	1405	std.Io.File.stdout();
1340	defer if (dep_file_name != null) file.close(io);	1406	defer if (dep_file_name != null) file.close(io);
1341		1407
1342	var file_writer = file.writer(io, &writer_buf);	1408	var file_writer = file.writer(io, &writer_buf);
...	@@ -1358,10 +1424,10 @@ fn processSource(	...	@@ -1358,10 +1424,10 @@ fn processSource(
1358	}	1424	}
1359		1425
1360	const file = if (d.output_name) \|some\|	1426	const file = if (d.output_name) \|some\|
1361	d.comp.cwd.createFile(io, some, .{}) catch \|er\|	1427	comp.cwd.createFile(io, some, .{}) catch \|er\|
1362	return d.fatal("unable to create output file '{s}': {s}", .{ some, errorDescription(er) })	1428	return d.fatal("unable to create output file '{s}': {s}", .{ some, errorDescription(er) })
1363	else	1429	else
1364	Io.File.stdout();	1430	std.Io.File.stdout();
1365	defer if (d.output_name != null) file.close(io);	1431	defer if (d.output_name != null) file.close(io);
1366		1432
1367	var file_writer = file.writer(io, &writer_buf);	1433	var file_writer = file.writer(io, &writer_buf);
...	@@ -1376,8 +1442,11 @@ fn processSource(	...	@@ -1376,8 +1442,11 @@ fn processSource(
1376	defer tree.deinit();	1442	defer tree.deinit();
1377		1443
1378	if (d.verbose_ast) {	1444	if (d.verbose_ast) {
1379	var stdout = Io.File.stdout().writer(&writer_buf);	1445	var stdout = std.Io.File.stdout().writer(io, &writer_buf);
1380	tree.dump(d.detectConfig(stdout.file), &stdout.interface) catch {};	1446	tree.dump(.{
		1447	.mode = try d.detectMode(stdout.file),
		1448	.writer = &stdout.interface,
		1449	}) catch {};
1381	}	1450	}
1382		1451
1383	d.printDiagnosticsStats();	1452	d.printDiagnosticsStats();
...	@@ -1392,10 +1461,10 @@ fn processSource(	...	@@ -1392,10 +1461,10 @@ fn processSource(
1392	return;	1461	return;
1393	}	1462	}
1394		1463
1395	if (d.comp.target.ofmt != .elf or d.comp.target.cpu.arch != .x86_64) {	1464	if (comp.target.ofmt != .elf or comp.target.cpu.arch != .x86_64) {
1396	return d.fatal(	1465	return d.fatal(
1397	"unsupported target {s}-{s}-{s}, currently only x86-64 elf is supported",	1466	"unsupported target {s}-{s}-{s}, currently only x86-64 elf is supported",
1398	.{ @tagName(d.comp.target.cpu.arch), @tagName(d.comp.target.os.tag), @tagName(d.comp.target.abi) },	1467	.{ @tagName(comp.target.cpu.arch), @tagName(comp.target.os.tag), @tagName(comp.target.abi) },
1399	);	1468	);
1400	}	1469	}
1401		1470
...	@@ -1407,15 +1476,15 @@ fn processSource(	...	@@ -1407,15 +1476,15 @@ fn processSource(
1407	.{},	1476	.{},
1408	);	1477	);
1409		1478
1410	const assembly = try asm_fn(d.comp.target.toZigTarget(), &tree);	1479	const assembly = try asm_fn(comp.target.toZigTarget(), &tree);
1411	defer assembly.deinit(gpa);	1480	defer assembly.deinit(gpa);
1412		1481
1413	if (d.only_preprocess_and_compile) {	1482	if (d.only_preprocess_and_compile) {
1414	const out_file = d.comp.cwd.createFile(io, out_file_name, .{}) catch \|er\|	1483	const out_file = comp.cwd.createFile(io, out_file_name, .{}) catch \|er\|
1415	return d.fatal("unable to create output file '{s}': {s}", .{ out_file_name, errorDescription(er) });	1484	return d.fatal("unable to create output file '{s}': {s}", .{ out_file_name, errorDescription(er) });
1416	defer out_file.close(io);	1485	defer out_file.close(io);
1417		1486
1418	assembly.writeToFile(out_file) catch \|er\|	1487	assembly.writeToFile(io, out_file) catch \|er\|
1419	return d.fatal("unable to write to output file '{s}': {s}", .{ out_file_name, errorDescription(er) });	1488	return d.fatal("unable to write to output file '{s}': {s}", .{ out_file_name, errorDescription(er) });
1420	if (fast_exit) std.process.exit(0); // Not linking, no need for cleanup.	1489	if (fast_exit) std.process.exit(0); // Not linking, no need for cleanup.
1421	return;	1490	return;
...	@@ -1425,10 +1494,10 @@ fn processSource(	...	@@ -1425,10 +1494,10 @@ fn processSource(
1425	// then assemble to out_file_name	1494	// then assemble to out_file_name
1426	var assembly_name_buf: [std.fs.max_name_bytes]u8 = undefined;	1495	var assembly_name_buf: [std.fs.max_name_bytes]u8 = undefined;
1427	const assembly_out_file_name = try d.getRandomFilename(&assembly_name_buf, ".s");	1496	const assembly_out_file_name = try d.getRandomFilename(&assembly_name_buf, ".s");
1428	const out_file = d.comp.cwd.createFile(io, assembly_out_file_name, .{}) catch \|er\|	1497	const out_file = comp.cwd.createFile(io, assembly_out_file_name, .{}) catch \|er\|
1429	return d.fatal("unable to create output file '{s}': {s}", .{ assembly_out_file_name, errorDescription(er) });	1498	return d.fatal("unable to create output file '{s}': {s}", .{ assembly_out_file_name, errorDescription(er) });
1430	defer out_file.close(io);	1499	defer out_file.close(io);
1431	assembly.writeToFile(out_file) catch \|er\|	1500	assembly.writeToFile(io, out_file) catch \|er\|
1432	return d.fatal("unable to write to output file '{s}': {s}", .{ assembly_out_file_name, errorDescription(er) });	1501	return d.fatal("unable to write to output file '{s}': {s}", .{ assembly_out_file_name, errorDescription(er) });
1433	try d.invokeAssembler(tc, assembly_out_file_name, out_file_name);	1502	try d.invokeAssembler(tc, assembly_out_file_name, out_file_name);
1434	if (d.only_compile) {	1503	if (d.only_compile) {
...	@@ -1440,8 +1509,11 @@ fn processSource(	...	@@ -1440,8 +1509,11 @@ fn processSource(
1440	defer ir.deinit(gpa);	1509	defer ir.deinit(gpa);
1441		1510
1442	if (d.verbose_ir) {	1511	if (d.verbose_ir) {
1443	var stdout = Io.File.stdout().writer(&writer_buf);	1512	var stdout = std.Io.File.stdout().writer(io, &writer_buf);
1444	ir.dump(gpa, d.detectConfig(stdout.file), &stdout.interface) catch {};	1513	ir.dump(gpa, .{
		1514	.mode = try d.detectMode(stdout.file),
		1515	.writer = &stdout.interface,
		1516	}) catch {};
1445	}	1517	}
1446		1518
1447	var render_errors: Ir.Renderer.ErrorList = .{};	1519	var render_errors: Ir.Renderer.ErrorList = .{};
...	@@ -1494,8 +1566,9 @@ fn dumpLinkerArgs(w: *std.Io.Writer, items: []const []const u8) !void {	...	@@ -1494,8 +1566,9 @@ fn dumpLinkerArgs(w: *std.Io.Writer, items: []const []const u8) !void {
1494	/// The entry point of the Aro compiler.	1566	/// The entry point of the Aro compiler.
1495	/// MAY call `exit` if `fast_exit` is set.	1567	/// MAY call `exit` if `fast_exit` is set.
1496	pub fn invokeLinker(d: Driver, tc: Toolchain, comptime fast_exit: bool) Compilation.Error!void {	1568	pub fn invokeLinker(d: Driver, tc: Toolchain, comptime fast_exit: bool) Compilation.Error!void {
1497	const gpa = d.comp.gpa;	1569	const comp = d.comp;
1498	const io = d.comp.io;	1570	const io = comp.io;
		1571	const gpa = comp.gpa;
1499	var argv: std.ArrayList([]const u8) = .empty;	1572	var argv: std.ArrayList([]const u8) = .empty;
1500	defer argv.deinit(gpa);	1573	defer argv.deinit(gpa);
1501		1574
...	@@ -1507,7 +1580,7 @@ pub fn invokeLinker(d: Driver, tc: Toolchain, comptime fast_exit: bool) Compil	...	@@ -1507,7 +1580,7 @@ pub fn invokeLinker(d: Driver, tc: Toolchain, comptime fast_exit: bool) Compil
1507		1580
1508	if (d.verbose_linker_args) {	1581	if (d.verbose_linker_args) {
1509	var stdout_buf: [4096]u8 = undefined;	1582	var stdout_buf: [4096]u8 = undefined;
1510	var stdout = Io.File.stdout().writer(&stdout_buf);	1583	var stdout = std.Io.File.stdout().writer(io, &stdout_buf);
1511	dumpLinkerArgs(&stdout.interface, argv.items) catch {	1584	dumpLinkerArgs(&stdout.interface, argv.items) catch {
1512	return d.fatal("unable to dump linker args: {s}", .{errorDescription(stdout.err.?)});	1585	return d.fatal("unable to dump linker args: {s}", .{errorDescription(stdout.err.?)});
1513	};	1586	};
...	@@ -1521,8 +1594,9 @@ pub fn invokeLinker(d: Driver, tc: Toolchain, comptime fast_exit: bool) Compil	...	@@ -1521,8 +1594,9 @@ pub fn invokeLinker(d: Driver, tc: Toolchain, comptime fast_exit: bool) Compil
1521	}) catch \|er\| {	1594	}) catch \|er\| {
1522	return d.fatal("unable to spawn linker: {s}", .{errorDescription(er)});	1595	return d.fatal("unable to spawn linker: {s}", .{errorDescription(er)});
1523	};	1596	};
		1597
1524	const term = child.wait(io) catch \|er\| {	1598	const term = child.wait(io) catch \|er\| {
1525	return d.fatal("unable to wait linker: {s}", .{errorDescription(er)});	1599	return d.fatal("error waiting for linker: {s}", .{errorDescription(er)});
1526	};	1600	};
1527	switch (term) {	1601	switch (term) {
1528	.exited => \|code\| if (code != 0) {	1602	.exited => \|code\| if (code != 0) {
...	@@ -1541,7 +1615,7 @@ pub fn invokeLinker(d: Driver, tc: Toolchain, comptime fast_exit: bool) Compil	...	@@ -1541,7 +1615,7 @@ pub fn invokeLinker(d: Driver, tc: Toolchain, comptime fast_exit: bool) Compil
1541		1615
1542	fn exitWithCleanup(d: *Driver, code: u8) noreturn {	1616	fn exitWithCleanup(d: *Driver, code: u8) noreturn {
1543	for (d.link_objects.items[d.link_objects.items.len - d.temp_file_count ..]) \|obj\| {	1617	for (d.link_objects.items[d.link_objects.items.len - d.temp_file_count ..]) \|obj\| {
1544	std.fs.deleteFileAbsolute(obj) catch {};	1618	std.Io.Dir.deleteFileAbsolute(d.comp.io, obj) catch {};
1545	}	1619	}
1546	std.process.exit(code);	1620	std.process.exit(code);
1547	}	1621	}

lib/compiler/aro/aro/Driver/Filesystem.zig deleted-241

...	@@ -1,241 +0,0 @@
1	const builtin = @import("builtin");
2	const is_windows = builtin.os.tag == .windows;
3
4	const std = @import("std");
5	const Io = std.Io;
6	const mem = std.std.mem;
7
8	fn readFileFake(entries: []const Filesystem.Entry, path: []const u8, buf: []u8) ?[]const u8 {
9	@branchHint(.cold);
10	for (entries) \|entry\| {
11	if (mem.eql(u8, entry.path, path)) {
12	const len = @min(entry.contents.len, buf.len);
13	@memcpy(buf[0..len], entry.contents[0..len]);
14	return buf[0..len];
15	}
16	}
17	return null;
18	}
19
20	fn findProgramByNameFake(entries: []const Filesystem.Entry, name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
21	@branchHint(.cold);
22	if (mem.indexOfScalar(u8, name, '/') != null) {
23	@memcpy(buf[0..name.len], name);
24	return buf[0..name.len];
25	}
26	const path_env = path orelse return null;
27	var fib = std.heap.FixedBufferAllocator.init(buf);
28
29	var it = mem.tokenizeScalar(u8, path_env, std.fs.path.delimiter);
30	while (it.next()) \|path_dir\| {
31	defer fib.reset();
32	const full_path = std.fs.path.join(fib.allocator(), &.{ path_dir, name }) catch continue;
33	if (canExecuteFake(entries, full_path)) return full_path;
34	}
35
36	return null;
37	}
38
39	fn canExecuteFake(entries: []const Filesystem.Entry, path: []const u8) bool {
40	@branchHint(.cold);
41	for (entries) \|entry\| {
42	if (mem.eql(u8, entry.path, path)) {
43	return entry.executable;
44	}
45	}
46	return false;
47	}
48
49	fn existsFake(entries: []const Filesystem.Entry, path: []const u8) bool {
50	@branchHint(.cold);
51	var buf: [std.fs.max_path_bytes]u8 = undefined;
52	var fib = std.heap.FixedBufferAllocator.init(&buf);
53	const resolved = std.fs.path.resolvePosix(fib.allocator(), &.{path}) catch return false;
54	for (entries) \|entry\| {
55	if (mem.eql(u8, entry.path, resolved)) return true;
56	}
57	return false;
58	}
59
60	fn canExecutePosix(io: Io, path: []const u8) bool {
61	Io.Dir.accessAbsolute(io, path, .{ .execute = true }) catch return false;
62	// Todo: ensure path is not a directory
63	return true;
64	}
65
66	/// TODO
67	fn canExecuteWindows(path: []const u8) bool {
68	_ = path;
69	return true;
70	}
71
72	/// TODO
73	fn findProgramByNameWindows(allocator: std.mem.Allocator, name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
74	_ = path;
75	_ = buf;
76	_ = name;
77	_ = allocator;
78	return null;
79	}
80
81	/// TODO: does WASI need special handling?
82	fn findProgramByNamePosix(name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
83	if (mem.indexOfScalar(u8, name, '/') != null) {
84	@memcpy(buf[0..name.len], name);
85	return buf[0..name.len];
86	}
87	const path_env = path orelse return null;
88	var fib = std.heap.FixedBufferAllocator.init(buf);
89
90	var it = mem.tokenizeScalar(u8, path_env, std.fs.path.delimiter);
91	while (it.next()) \|path_dir\| {
92	defer fib.reset();
93	const full_path = std.fs.path.join(fib.allocator(), &.{ path_dir, name }) catch continue;
94	if (canExecutePosix(full_path)) return full_path;
95	}
96
97	return null;
98	}
99
100	pub const Filesystem = union(enum) {
101	real: std.Io.Dir,
102	fake: []const Entry,
103
104	const Entry = struct {
105	path: []const u8,
106	contents: []const u8 = "",
107	executable: bool = false,
108	};
109
110	const FakeDir = struct {
111	entries: []const Entry,
112	path: []const u8,
113
114	fn iterate(self: FakeDir) FakeDir.Iterator {
115	return .{
116	.entries = self.entries,
117	.base = self.path,
118	};
119	}
120
121	const Iterator = struct {
122	entries: []const Entry,
123	base: []const u8,
124	i: usize = 0,
125
126	fn next(self: *@This()) !?std.Io.Dir.Entry {
127	while (self.i < self.entries.len) {
128	const entry = self.entries[self.i];
129	self.i += 1;
130	if (entry.path.len == self.base.len) continue;
131	if (std.mem.startsWith(u8, entry.path, self.base)) {
132	const remaining = entry.path[self.base.len + 1 ..];
133	if (std.mem.indexOfScalar(u8, remaining, std.fs.path.sep) != null) continue;
134	const extension = std.fs.path.extension(remaining);
135	const kind: std.Io.Dir.Entry.Kind = if (extension.len == 0) .directory else .file;
136	return .{ .name = remaining, .kind = kind };
137	}
138	}
139	return null;
140	}
141	};
142	};
143
144	const Dir = union(enum) {
145	dir: std.Io.Dir,
146	fake: FakeDir,
147
148	pub fn iterate(self: Dir) Iterator {
149	return switch (self) {
150	.dir => \|dir\| .{ .iterator = dir.iterate() },
151	.fake => \|fake\| .{ .fake = fake.iterate() },
152	};
153	}
154
155	pub fn close(self: *Dir, io: Io) void {
156	switch (self.*) {
157	.dir => \|*d\| d.close(io),
158	.fake => {},
159	}
160	}
161	};
162
163	const Iterator = union(enum) {
164	iterator: std.Io.Dir.Iterator,
165	fake: FakeDir.Iterator,
166
167	pub fn next(self: *Iterator) std.Io.Dir.Iterator.Error!?std.Io.Dir.Entry {
168	return switch (self.*) {
169	.iterator => \|*it\| it.next(),
170	.fake => \|*it\| it.next(),
171	};
172	}
173	};
174
175	pub fn exists(fs: Filesystem, io: Io, path: []const u8) bool {
176	switch (fs) {
177	.real => \|cwd\| {
178	cwd.access(io, path, .{}) catch return false;
179	return true;
180	},
181	.fake => \|paths\| return existsFake(paths, path),
182	}
183	}
184
185	pub fn joinedExists(fs: Filesystem, parts: []const []const u8) bool {
186	var buf: [std.fs.max_path_bytes]u8 = undefined;
187	var fib = std.heap.FixedBufferAllocator.init(&buf);
188	const joined = std.fs.path.join(fib.allocator(), parts) catch return false;
189	return fs.exists(joined);
190	}
191
192	pub fn canExecute(fs: Filesystem, path: []const u8) bool {
193	return switch (fs) {
194	.real => if (is_windows) canExecuteWindows(path) else canExecutePosix(path),
195	.fake => \|entries\| canExecuteFake(entries, path),
196	};
197	}
198
199	/// Search for an executable named `name` using platform-specific logic
200	/// If it's found, write the full path to `buf` and return a slice of it
201	/// Otherwise retun null
202	pub fn findProgramByName(fs: Filesystem, allocator: std.mem.Allocator, name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
203	std.debug.assert(name.len > 0);
204	return switch (fs) {
205	.real => if (is_windows) findProgramByNameWindows(allocator, name, path, buf) else findProgramByNamePosix(name, path, buf),
206	.fake => \|entries\| findProgramByNameFake(entries, name, path, buf),
207	};
208	}
209
210	/// Read the file at `path` into `buf`.
211	/// Returns null if any errors are encountered
212	/// Otherwise returns a slice of `buf`. If the file is larger than `buf` partial contents are returned
213	pub fn readFile(fs: Filesystem, io: Io, path: []const u8, buf: []u8) ?[]const u8 {
214	return switch (fs) {
215	.real => \|cwd\| {
216	const file = cwd.openFile(io, path, .{}) catch return null;
217	defer file.close(io);
218
219	const bytes_read = file.readAll(buf) catch return null;
220	return buf[0..bytes_read];
221	},
222	.fake => \|entries\| readFileFake(entries, path, buf),
223	};
224	}
225
226	pub fn openDir(fs: Filesystem, io: Io, dir_name: []const u8) std.Io.Dir.OpenError!Dir {
227	return switch (fs) {
228	.real => \|cwd\| .{ .dir = try cwd.openDir(io, dir_name, .{ .access_sub_paths = false, .iterate = true }) },
229	.fake => \|entries\| .{ .fake = .{ .entries = entries, .path = dir_name } },
230	};
231	}
232	};
233
234	test "Fake filesystem" {
235	const fs: Filesystem = .{ .fake = &.{
236	.{ .path = "/usr/bin" },
237	} };
238	try std.testing.expect(fs.exists("/usr/bin"));
239	try std.testing.expect(fs.exists("/usr/bin/foo/.."));
240	try std.testing.expect(!fs.exists("/usr/bin/bar"));
241	}

lib/compiler/aro/aro/Driver/GCCDetector.zig created+635

...	@@ -0,0 +1,635 @@
1	const std = @import("std");
2
3	const system_defaults = @import("system_defaults");
4
5	const GCCVersion = @import("GCCVersion.zig");
6	const Multilib = @import("Multilib.zig");
7	const Target = @import("../Target.zig");
8	const Toolchain = @import("../Toolchain.zig");
9
10	const GCCDetector = @This();
11
12	is_valid: bool = false,
13	install_path: []const u8 = "",
14	parent_lib_path: []const u8 = "",
15	version: GCCVersion = .{},
16	gcc_triple: []const u8 = "",
17	selected: Multilib = .{},
18	biarch_sibling: ?Multilib = null,
19
20	pub fn deinit(self: *GCCDetector) void {
21	if (!self.is_valid) return;
22	}
23
24	pub fn appendToolPath(self: const GCCDetector, tc: Toolchain) !void {
25	if (!self.is_valid) return;
26	return tc.addPathFromComponents(&.{
27	self.parent_lib_path,
28	"..",
29	self.gcc_triple,
30	"bin",
31	}, .program);
32	}
33
34	fn addDefaultGCCPrefixes(prefixes: std.ArrayList([]const u8), tc: const Toolchain) !void {
35	const sysroot = tc.getSysroot();
36	const target = tc.getTarget();
37	if (sysroot.len == 0 and target.os.tag == .linux and tc.exists("/opt/rh")) {
38	prefixes.appendAssumeCapacity("/opt/rh/gcc-toolset-12/root/usr");
39	prefixes.appendAssumeCapacity("/opt/rh/gcc-toolset-11/root/usr");
40	prefixes.appendAssumeCapacity("/opt/rh/gcc-toolset-10/root/usr");
41	prefixes.appendAssumeCapacity("/opt/rh/devtoolset-12/root/usr");
42	prefixes.appendAssumeCapacity("/opt/rh/devtoolset-11/root/usr");
43	prefixes.appendAssumeCapacity("/opt/rh/devtoolset-10/root/usr");
44	prefixes.appendAssumeCapacity("/opt/rh/devtoolset-9/root/usr");
45	prefixes.appendAssumeCapacity("/opt/rh/devtoolset-8/root/usr");
46	prefixes.appendAssumeCapacity("/opt/rh/devtoolset-7/root/usr");
47	prefixes.appendAssumeCapacity("/opt/rh/devtoolset-6/root/usr");
48	prefixes.appendAssumeCapacity("/opt/rh/devtoolset-4/root/usr");
49	prefixes.appendAssumeCapacity("/opt/rh/devtoolset-3/root/usr");
50	prefixes.appendAssumeCapacity("/opt/rh/devtoolset-2/root/usr");
51	}
52	if (sysroot.len == 0) {
53	prefixes.appendAssumeCapacity("/usr");
54	} else {
55	var usr_path = try tc.driver.comp.arena.alloc(u8, 4 + sysroot.len);
56	@memcpy(usr_path[0..4], "/usr");
57	@memcpy(usr_path[4..], sysroot);
58	prefixes.appendAssumeCapacity(usr_path);
59	}
60	}
61
62	fn collectLibDirsAndTriples(
63	tc: *Toolchain,
64	lib_dirs: *std.ArrayList([]const u8),
65	triple_aliases: *std.ArrayList([]const u8),
66	biarch_libdirs: *std.ArrayList([]const u8),
67	biarch_triple_aliases: *std.ArrayList([]const u8),
68	) !void {
69	const AArch64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
70	const AArch64Triples: [4][]const u8 = .{ "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-redhat-linux", "aarch64-suse-linux" };
71	const AArch64beLibDirs: [1][]const u8 = .{"/lib"};
72	const AArch64beTriples: [2][]const u8 = .{ "aarch64_be-none-linux-gnu", "aarch64_be-linux-gnu" };
73
74	const ARMLibDirs: [1][]const u8 = .{"/lib"};
75	const ARMTriples: [1][]const u8 = .{"arm-linux-gnueabi"};
76	const ARMHFTriples: [4][]const u8 = .{ "arm-linux-gnueabihf", "armv7hl-redhat-linux-gnueabi", "armv6hl-suse-linux-gnueabi", "armv7hl-suse-linux-gnueabi" };
77
78	const ARMebLibDirs: [1][]const u8 = .{"/lib"};
79	const ARMebTriples: [1][]const u8 = .{"armeb-linux-gnueabi"};
80	const ARMebHFTriples: [2][]const u8 = .{ "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi" };
81
82	const AVRLibDirs: [1][]const u8 = .{"/lib"};
83	const AVRTriples: [1][]const u8 = .{"avr"};
84
85	const CSKYLibDirs: [1][]const u8 = .{"/lib"};
86	const CSKYTriples: [3][]const u8 = .{ "csky-linux-gnuabiv2", "csky-linux-uclibcabiv2", "csky-elf-noneabiv2" };
87
88	const X86_64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
89	const X86_64Triples: [11][]const u8 = .{
90	"x86_64-linux-gnu", "x86_64-unknown-linux-gnu",
91	"x86_64-pc-linux-gnu", "x86_64-redhat-linux6E",
92	"x86_64-redhat-linux", "x86_64-suse-linux",
93	"x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
94	"x86_64-slackware-linux", "x86_64-unknown-linux",
95	"x86_64-amazon-linux",
96	};
97	const X32Triples: [2][]const u8 = .{ "x86_64-linux-gnux32", "x86_64-pc-linux-gnux32" };
98	const X32LibDirs: [2][]const u8 = .{ "/libx32", "/lib" };
99	const X86LibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
100	const X86Triples: [9][]const u8 = .{
101	"i586-linux-gnu", "i686-linux-gnu", "i686-pc-linux-gnu",
102	"i386-redhat-linux6E", "i686-redhat-linux", "i386-redhat-linux",
103	"i586-suse-linux", "i686-montavista-linux", "i686-gnu",
104	};
105
106	const LoongArch64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
107	const LoongArch64Triples: [2][]const u8 = .{ "loongarch64-linux-gnu", "loongarch64-unknown-linux-gnu" };
108
109	const M68kLibDirs: [1][]const u8 = .{"/lib"};
110	const M68kTriples: [3][]const u8 = .{ "m68k-linux-gnu", "m68k-unknown-linux-gnu", "m68k-suse-linux" };
111
112	const MIPSLibDirs: [2][]const u8 = .{ "/libo32", "/lib" };
113	const MIPSTriples: [5][]const u8 = .{
114	"mips-linux-gnu", "mips-mti-linux",
115	"mips-mti-linux-gnu", "mips-img-linux-gnu",
116	"mipsisa32r6-linux-gnu",
117	};
118	const MIPSELLibDirs: [2][]const u8 = .{ "/libo32", "/lib" };
119	const MIPSELTriples: [3][]const u8 = .{ "mipsel-linux-gnu", "mips-img-linux-gnu", "mipsisa32r6el-linux-gnu" };
120
121	const MIPS64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
122	const MIPS64Triples: [6][]const u8 = .{
123	"mips64-linux-gnu", "mips-mti-linux-gnu",
124	"mips-img-linux-gnu", "mips64-linux-gnuabi64",
125	"mipsisa64r6-linux-gnu", "mipsisa64r6-linux-gnuabi64",
126	};
127	const MIPS64ELLibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
128	const MIPS64ELTriples: [6][]const u8 = .{
129	"mips64el-linux-gnu", "mips-mti-linux-gnu",
130	"mips-img-linux-gnu", "mips64el-linux-gnuabi64",
131	"mipsisa64r6el-linux-gnu", "mipsisa64r6el-linux-gnuabi64",
132	};
133
134	const MIPSN32LibDirs: [1][]const u8 = .{"/lib32"};
135	const MIPSN32Triples: [2][]const u8 = .{ "mips64-linux-gnuabin32", "mipsisa64r6-linux-gnuabin32" };
136	const MIPSN32ELLibDirs: [1][]const u8 = .{"/lib32"};
137	const MIPSN32ELTriples: [2][]const u8 = .{ "mips64el-linux-gnuabin32", "mipsisa64r6el-linux-gnuabin32" };
138
139	const MSP430LibDirs: [1][]const u8 = .{"/lib"};
140	const MSP430Triples: [1][]const u8 = .{"msp430-elf"};
141
142	const PPCLibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
143	const PPCTriples: [5][]const u8 = .{
144	"powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
145	// On 32-bit PowerPC systems running SUSE Linux, gcc is configured as a
146	// 64-bit compiler which defaults to "-m32", hence "powerpc64-suse-linux".
147	"powerpc64-suse-linux", "powerpc-montavista-linuxspe",
148	};
149	const PPCLELibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
150	const PPCLETriples: [3][]const u8 = .{ "powerpcle-linux-gnu", "powerpcle-unknown-linux-gnu", "powerpcle-linux-musl" };
151
152	const PPC64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
153	const PPC64Triples: [4][]const u8 = .{
154	"powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu",
155	"powerpc64-suse-linux", "ppc64-redhat-linux",
156	};
157	const PPC64LELibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
158	const PPC64LETriples: [5][]const u8 = .{
159	"powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu",
160	"powerpc64le-none-linux-gnu", "powerpc64le-suse-linux",
161	"ppc64le-redhat-linux",
162	};
163
164	const RISCV32LibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
165	const RISCV32Triples: [3][]const u8 = .{ "riscv32-unknown-linux-gnu", "riscv32-linux-gnu", "riscv32-unknown-elf" };
166	const RISCV64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
167	const RISCV64Triples: [3][]const u8 = .{
168	"riscv64-unknown-linux-gnu",
169	"riscv64-linux-gnu",
170	"riscv64-unknown-elf",
171	};
172
173	const SPARCv8LibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
174	const SPARCv8Triples: [2][]const u8 = .{ "sparc-linux-gnu", "sparcv8-linux-gnu" };
175	const SPARCv9LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
176	const SPARCv9Triples: [2][]const u8 = .{ "sparc64-linux-gnu", "sparcv9-linux-gnu" };
177
178	const SystemZLibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
179	const SystemZTriples: [5][]const u8 = .{
180	"s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
181	"s390x-suse-linux", "s390x-redhat-linux",
182	};
183	const target = tc.getTarget();
184	if (target.os.tag == .illumos) {
185	// TODO
186	return;
187	}
188	if (target.abi.isAndroid()) {
189	const AArch64AndroidTriples: [1][]const u8 = .{"aarch64-linux-android"};
190	const ARMAndroidTriples: [1][]const u8 = .{"arm-linux-androideabi"};
191	const MIPSELAndroidTriples: [1][]const u8 = .{"mipsel-linux-android"};
192	const MIPS64ELAndroidTriples: [1][]const u8 = .{"mips64el-linux-android"};
193	const X86AndroidTriples: [1][]const u8 = .{"i686-linux-android"};
194	const X86_64AndroidTriples: [1][]const u8 = .{"x86_64-linux-android"};
195
196	switch (target.cpu.arch) {
197	.aarch64 => {
198	lib_dirs.appendSliceAssumeCapacity(&AArch64LibDirs);
199	triple_aliases.appendSliceAssumeCapacity(&AArch64AndroidTriples);
200	},
201	.arm,
202	.thumb,
203	=> {
204	lib_dirs.appendSliceAssumeCapacity(&ARMLibDirs);
205	triple_aliases.appendSliceAssumeCapacity(&ARMAndroidTriples);
206	},
207	.mipsel => {
208	lib_dirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
209	triple_aliases.appendSliceAssumeCapacity(&MIPSELAndroidTriples);
210	biarch_libdirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
211	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPS64ELAndroidTriples);
212	},
213	.mips64el => {
214	lib_dirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
215	triple_aliases.appendSliceAssumeCapacity(&MIPS64ELAndroidTriples);
216	biarch_libdirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
217	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSELAndroidTriples);
218	},
219	.x86_64 => {
220	lib_dirs.appendSliceAssumeCapacity(&X86_64LibDirs);
221	triple_aliases.appendSliceAssumeCapacity(&X86_64AndroidTriples);
222	biarch_libdirs.appendSliceAssumeCapacity(&X86LibDirs);
223	biarch_triple_aliases.appendSliceAssumeCapacity(&X86AndroidTriples);
224	},
225	.x86 => {
226	lib_dirs.appendSliceAssumeCapacity(&X86LibDirs);
227	triple_aliases.appendSliceAssumeCapacity(&X86AndroidTriples);
228	biarch_libdirs.appendSliceAssumeCapacity(&X86_64LibDirs);
229	biarch_triple_aliases.appendSliceAssumeCapacity(&X86_64AndroidTriples);
230	},
231	else => {},
232	}
233	return;
234	}
235	switch (target.cpu.arch) {
236	.aarch64 => {
237	lib_dirs.appendSliceAssumeCapacity(&AArch64LibDirs);
238	triple_aliases.appendSliceAssumeCapacity(&AArch64Triples);
239	biarch_libdirs.appendSliceAssumeCapacity(&AArch64LibDirs);
240	biarch_triple_aliases.appendSliceAssumeCapacity(&AArch64Triples);
241	},
242	.aarch64_be => {
243	lib_dirs.appendSliceAssumeCapacity(&AArch64beLibDirs);
244	triple_aliases.appendSliceAssumeCapacity(&AArch64beTriples);
245	biarch_libdirs.appendSliceAssumeCapacity(&AArch64beLibDirs);
246	biarch_triple_aliases.appendSliceAssumeCapacity(&AArch64beTriples);
247	},
248	.arm, .thumb => {
249	lib_dirs.appendSliceAssumeCapacity(&ARMLibDirs);
250	if (target.abi == .gnueabihf) {
251	triple_aliases.appendSliceAssumeCapacity(&ARMHFTriples);
252	} else {
253	triple_aliases.appendSliceAssumeCapacity(&ARMTriples);
254	}
255	},
256	.armeb, .thumbeb => {
257	lib_dirs.appendSliceAssumeCapacity(&ARMebLibDirs);
258	if (target.abi == .gnueabihf) {
259	triple_aliases.appendSliceAssumeCapacity(&ARMebHFTriples);
260	} else {
261	triple_aliases.appendSliceAssumeCapacity(&ARMebTriples);
262	}
263	},
264	.avr => {
265	lib_dirs.appendSliceAssumeCapacity(&AVRLibDirs);
266	triple_aliases.appendSliceAssumeCapacity(&AVRTriples);
267	},
268	.csky => {
269	lib_dirs.appendSliceAssumeCapacity(&CSKYLibDirs);
270	triple_aliases.appendSliceAssumeCapacity(&CSKYTriples);
271	},
272	.x86_64 => {
273	if (target.abi == .gnux32 or target.abi == .muslx32) {
274	lib_dirs.appendSliceAssumeCapacity(&X32LibDirs);
275	triple_aliases.appendSliceAssumeCapacity(&X32Triples);
276	biarch_libdirs.appendSliceAssumeCapacity(&X86_64LibDirs);
277	biarch_triple_aliases.appendSliceAssumeCapacity(&X86_64Triples);
278	} else {
279	lib_dirs.appendSliceAssumeCapacity(&X86_64LibDirs);
280	triple_aliases.appendSliceAssumeCapacity(&X86_64Triples);
281	biarch_libdirs.appendSliceAssumeCapacity(&X32LibDirs);
282	biarch_triple_aliases.appendSliceAssumeCapacity(&X32Triples);
283	}
284	biarch_libdirs.appendSliceAssumeCapacity(&X86LibDirs);
285	biarch_triple_aliases.appendSliceAssumeCapacity(&X86Triples);
286	},
287	.x86 => {
288	lib_dirs.appendSliceAssumeCapacity(&X86LibDirs);
289	},
290	.loongarch64 => {
291	lib_dirs.appendSliceAssumeCapacity(&LoongArch64LibDirs);
292	triple_aliases.appendSliceAssumeCapacity(&LoongArch64Triples);
293	},
294	.m68k => {
295	lib_dirs.appendSliceAssumeCapacity(&M68kLibDirs);
296	triple_aliases.appendSliceAssumeCapacity(&M68kTriples);
297	},
298	.mips => {
299	lib_dirs.appendSliceAssumeCapacity(&MIPSLibDirs);
300	triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
301	biarch_libdirs.appendSliceAssumeCapacity(&MIPS64LibDirs);
302	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPS64Triples);
303	biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32LibDirs);
304	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32Triples);
305	},
306	.mipsel => {
307	lib_dirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
308	triple_aliases.appendSliceAssumeCapacity(&MIPSELTriples);
309	triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
310	biarch_libdirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
311	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPS64ELTriples);
312	biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32ELLibDirs);
313	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32ELTriples);
314	},
315	.mips64 => {
316	lib_dirs.appendSliceAssumeCapacity(&MIPS64LibDirs);
317	triple_aliases.appendSliceAssumeCapacity(&MIPS64Triples);
318	biarch_libdirs.appendSliceAssumeCapacity(&MIPSLibDirs);
319	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
320	biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32LibDirs);
321	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32Triples);
322	},
323	.mips64el => {
324	lib_dirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
325	triple_aliases.appendSliceAssumeCapacity(&MIPS64ELTriples);
326	biarch_libdirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
327	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSELTriples);
328	biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32ELLibDirs);
329	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32ELTriples);
330	biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
331	},
332	.msp430 => {
333	lib_dirs.appendSliceAssumeCapacity(&MSP430LibDirs);
334	triple_aliases.appendSliceAssumeCapacity(&MSP430Triples);
335	},
336	.powerpc => {
337	lib_dirs.appendSliceAssumeCapacity(&PPCLibDirs);
338	triple_aliases.appendSliceAssumeCapacity(&PPCTriples);
339	biarch_libdirs.appendSliceAssumeCapacity(&PPC64LibDirs);
340	biarch_triple_aliases.appendSliceAssumeCapacity(&PPC64Triples);
341	},
342	.powerpcle => {
343	lib_dirs.appendSliceAssumeCapacity(&PPCLELibDirs);
344	triple_aliases.appendSliceAssumeCapacity(&PPCLETriples);
345	biarch_libdirs.appendSliceAssumeCapacity(&PPC64LELibDirs);
346	biarch_triple_aliases.appendSliceAssumeCapacity(&PPC64LETriples);
347	},
348	.powerpc64 => {
349	lib_dirs.appendSliceAssumeCapacity(&PPC64LibDirs);
350	triple_aliases.appendSliceAssumeCapacity(&PPC64Triples);
351	biarch_libdirs.appendSliceAssumeCapacity(&PPCLibDirs);
352	biarch_triple_aliases.appendSliceAssumeCapacity(&PPCTriples);
353	},
354	.powerpc64le => {
355	lib_dirs.appendSliceAssumeCapacity(&PPC64LELibDirs);
356	triple_aliases.appendSliceAssumeCapacity(&PPC64LETriples);
357	biarch_libdirs.appendSliceAssumeCapacity(&PPCLELibDirs);
358	biarch_triple_aliases.appendSliceAssumeCapacity(&PPCLETriples);
359	},
360	.riscv32 => {
361	lib_dirs.appendSliceAssumeCapacity(&RISCV32LibDirs);
362	triple_aliases.appendSliceAssumeCapacity(&RISCV32Triples);
363	biarch_libdirs.appendSliceAssumeCapacity(&RISCV64LibDirs);
364	biarch_triple_aliases.appendSliceAssumeCapacity(&RISCV64Triples);
365	},
366	.riscv64 => {
367	lib_dirs.appendSliceAssumeCapacity(&RISCV64LibDirs);
368	triple_aliases.appendSliceAssumeCapacity(&RISCV64Triples);
369	biarch_libdirs.appendSliceAssumeCapacity(&RISCV32LibDirs);
370	biarch_triple_aliases.appendSliceAssumeCapacity(&RISCV32Triples);
371	},
372	.sparc => {
373	lib_dirs.appendSliceAssumeCapacity(&SPARCv8LibDirs);
374	triple_aliases.appendSliceAssumeCapacity(&SPARCv8Triples);
375	biarch_libdirs.appendSliceAssumeCapacity(&SPARCv9LibDirs);
376	biarch_triple_aliases.appendSliceAssumeCapacity(&SPARCv9Triples);
377	},
378	.sparc64 => {
379	lib_dirs.appendSliceAssumeCapacity(&SPARCv9LibDirs);
380	triple_aliases.appendSliceAssumeCapacity(&SPARCv9Triples);
381	biarch_libdirs.appendSliceAssumeCapacity(&SPARCv8LibDirs);
382	biarch_triple_aliases.appendSliceAssumeCapacity(&SPARCv8Triples);
383	},
384	.s390x => {
385	lib_dirs.appendSliceAssumeCapacity(&SystemZLibDirs);
386	triple_aliases.appendSliceAssumeCapacity(&SystemZTriples);
387	},
388	else => {},
389	}
390	}
391
392	pub fn discover(self: GCCDetector, tc: Toolchain) !void {
393	var path_buf: [std.fs.max_path_bytes]u8 = undefined;
394	var fib = std.heap.FixedBufferAllocator.init(&path_buf);
395
396	const target = tc.getTarget();
397	const biarch_variant_target = if (target.ptrBitWidth() == 32)
398	target.get64BitArchVariant()
399	else
400	target.get32BitArchVariant();
401
402	var candidate_lib_dirs_buffer: [16][]const u8 = undefined;
403	var candidate_lib_dirs = std.ArrayList([]const u8).initBuffer(&candidate_lib_dirs_buffer);
404
405	var candidate_triple_aliases_buffer: [16][]const u8 = undefined;
406	var candidate_triple_aliases = std.ArrayList([]const u8).initBuffer(&candidate_triple_aliases_buffer);
407
408	var candidate_biarch_lib_dirs_buffer: [16][]const u8 = undefined;
409	var candidate_biarch_lib_dirs = std.ArrayList([]const u8).initBuffer(&candidate_biarch_lib_dirs_buffer);
410
411	var candidate_biarch_triple_aliases_buffer: [20][]const u8 = undefined;
412	var candidate_biarch_triple_aliases = std.ArrayList([]const u8).initBuffer(&candidate_biarch_triple_aliases_buffer);
413
414	try collectLibDirsAndTriples(
415	tc,
416	&candidate_lib_dirs,
417	&candidate_triple_aliases,
418	&candidate_biarch_lib_dirs,
419	&candidate_biarch_triple_aliases,
420	);
421
422	var target_buf: [64]u8 = undefined;
423	const triple_str = target.toLLVMTriple(&target_buf);
424	candidate_triple_aliases.appendAssumeCapacity(triple_str);
425
426	// Also include the multiarch variant if it's different.
427	var biarch_buf: [64]u8 = undefined;
428	if (biarch_variant_target) \|*biarch_target\| {
429	const biarch_triple_str = biarch_target.toLLVMTriple(&biarch_buf);
430	if (!std.mem.eql(u8, biarch_triple_str, triple_str)) {
431	candidate_triple_aliases.appendAssumeCapacity(biarch_triple_str);
432	}
433	}
434
435	var prefixes_buf: [16][]const u8 = undefined;
436	var prefixes = std.ArrayList([]const u8).initBuffer(&prefixes_buf);
437	const gcc_toolchain_dir = gccToolchainDir(tc);
438	if (gcc_toolchain_dir.len != 0) {
439	const adjusted = if (gcc_toolchain_dir[gcc_toolchain_dir.len - 1] == '/')
440	gcc_toolchain_dir[0 .. gcc_toolchain_dir.len - 1]
441	else
442	gcc_toolchain_dir;
443	prefixes.appendAssumeCapacity(adjusted);
444	} else {
445	const sysroot = tc.getSysroot();
446	if (sysroot.len > 0) {
447	prefixes.appendAssumeCapacity(sysroot);
448	try addDefaultGCCPrefixes(&prefixes, tc);
449	}
450
451	if (sysroot.len == 0) {
452	try addDefaultGCCPrefixes(&prefixes, tc);
453	}
454	// TODO: Special-case handling for Gentoo
455	}
456
457	const v0 = GCCVersion.parse("0.0.0");
458	for (prefixes.items) \|prefix\| {
459	if (!tc.exists(prefix)) continue;
460
461	for (candidate_lib_dirs.items) \|suffix\| {
462	defer fib.reset();
463	const lib_dir = std.fs.path.join(fib.allocator(), &.{ prefix, suffix }) catch continue;
464	if (!tc.exists(lib_dir)) continue;
465
466	const gcc_dir_exists = tc.joinedExists(&.{ lib_dir, "/gcc" });
467	const gcc_cross_dir_exists = tc.joinedExists(&.{ lib_dir, "/gcc-cross" });
468
469	try self.scanLibDirForGCCTriple(tc, target, lib_dir, triple_str, false, gcc_dir_exists, gcc_cross_dir_exists);
470	for (candidate_triple_aliases.items) \|candidate\| {
471	try self.scanLibDirForGCCTriple(tc, target, lib_dir, candidate, false, gcc_dir_exists, gcc_cross_dir_exists);
472	}
473	}
474	for (candidate_biarch_lib_dirs.items) \|suffix\| {
475	const lib_dir = std.fs.path.join(fib.allocator(), &.{ prefix, suffix }) catch continue;
476	if (!tc.exists(lib_dir)) continue;
477
478	const gcc_dir_exists = tc.joinedExists(&.{ lib_dir, "/gcc" });
479	const gcc_cross_dir_exists = tc.joinedExists(&.{ lib_dir, "/gcc-cross" });
480	for (candidate_biarch_triple_aliases.items) \|candidate\| {
481	try self.scanLibDirForGCCTriple(tc, target, lib_dir, candidate, true, gcc_dir_exists, gcc_cross_dir_exists);
482	}
483	}
484	if (self.version.order(v0) == .gt) break;
485	}
486	}
487
488	fn findBiarchMultilibs(
489	tc: *const Toolchain,
490	result: *Multilib.Detected,
491	target: *const Target,
492	path: [2][]const u8,
493	needs_biarch_suffix: bool,
494	) !bool {
495	const suff64 = if (target.os.tag == .illumos) switch (target.cpu.arch) {
496	.x86, .x86_64 => "/amd64",
497	.sparc => "/sparcv9",
498	else => "/64",
499	} else "/64";
500
501	const alt_64 = Multilib.init(suff64, suff64, &.{ "-m32", "+m64", "-mx32" });
502	const alt_32 = Multilib.init("/32", "/32", &.{ "+m32", "-m64", "-mx32" });
503	const alt_x32 = Multilib.init("/x32", "/x32", &.{ "-m32", "-m64", "+mx32" });
504
505	const multilib_filter = Multilib.Filter{
506	.base = path,
507	.file = "crtbegin.o",
508	};
509
510	const Want = enum {
511	want32,
512	want64,
513	wantx32,
514	};
515	const is_x32 = target.abi == .gnux32 or target.abi == .muslx32;
516	const target_ptr_width = target.ptrBitWidth();
517	const want: Want = if (target_ptr_width == 32 and multilib_filter.exists(alt_32, tc))
518	.want64
519	else if (target_ptr_width == 64 and is_x32 and multilib_filter.exists(alt_x32, tc))
520	.want64
521	else if (target_ptr_width == 64 and !is_x32 and multilib_filter.exists(alt_64, tc))
522	.want32
523	else if (target_ptr_width == 32)
524	if (needs_biarch_suffix) .want64 else .want32
525	else if (is_x32)
526	if (needs_biarch_suffix) .want64 else .wantx32
527	else if (needs_biarch_suffix) .want32 else .want64;
528
529	const default = switch (want) {
530	.want32 => Multilib.init("", "", &.{ "+m32", "-m64", "-mx32" }),
531	.want64 => Multilib.init("", "", &.{ "-m32", "+m64", "-mx32" }),
532	.wantx32 => Multilib.init("", "", &.{ "-m32", "-m64", "+mx32" }),
533	};
534	result.multilib_buf[result.multilib_count..][0..4].* = .{
535	default,
536	alt_64,
537	alt_32,
538	alt_x32,
539	};
540	result.multilib_count += 4;
541
542	result.filter(multilib_filter, tc);
543	return result.select(&.{
544	if (target_ptr_width == 64 and !is_x32) "+m64" else "-m64",
545	if (target_ptr_width == 32) "+m32" else "-m32",
546	if (target_ptr_width == 64 and is_x32) "+mx32" else "-mx32",
547	});
548	}
549
550	fn scanGCCForMultilibs(
551	self: *GCCDetector,
552	tc: *const Toolchain,
553	target: *const Target,
554	path: [2][]const u8,
555	needs_biarch_suffix: bool,
556	) !bool {
557	var detected: Multilib.Detected = .{};
558	if (target.cpu.arch == .csky) {
559	// TODO
560	} else if (target.cpu.arch.isMIPS()) {
561	// TODO
562	} else if (target.cpu.arch.isRISCV()) {
563	// TODO
564	} else if (target.cpu.arch == .msp430) {
565	// TODO
566	} else if (target.cpu.arch == .avr) {
567	// No multilibs
568	} else if (!try findBiarchMultilibs(tc, &detected, target, path, needs_biarch_suffix)) {
569	return false;
570	}
571	self.selected = detected.selected;
572	self.biarch_sibling = detected.biarch_sibling;
573	return true;
574	}
575
576	fn scanLibDirForGCCTriple(
577	self: *GCCDetector,
578	tc: *const Toolchain,
579	target: *const Target,
580	lib_dir: []const u8,
581	candidate_triple: []const u8,
582	needs_biarch_suffix: bool,
583	gcc_dir_exists: bool,
584	gcc_cross_dir_exists: bool,
585	) !void {
586	var path_buf: [std.fs.max_path_bytes]u8 = undefined;
587	var fib = std.heap.FixedBufferAllocator.init(&path_buf);
588	const comp = tc.driver.comp;
589	const arena = comp.arena;
590	const io = comp.io;
591	for (0..2) \|i\| {
592	if (i == 0 and !gcc_dir_exists) continue;
593	if (i == 1 and !gcc_cross_dir_exists) continue;
594	defer fib.reset();
595
596	const base: []const u8 = if (i == 0) "gcc" else "gcc-cross";
597	var lib_suffix_buf: [64]u8 = undefined;
598	var suffix_buf_fib = std.heap.FixedBufferAllocator.init(&lib_suffix_buf);
599	const lib_suffix = std.fs.path.join(suffix_buf_fib.allocator(), &.{ base, candidate_triple }) catch continue;
600
601	const dir_name = std.fs.path.join(fib.allocator(), &.{ lib_dir, lib_suffix }) catch continue;
602	var parent_dir = comp.cwd.openDir(io, dir_name, .{ .access_sub_paths = false, .iterate = true }) catch continue;
603	defer parent_dir.close(io);
604
605	var it = parent_dir.iterate();
606	while (it.next(io) catch continue) \|entry\| {
607	if (entry.kind != .directory) continue;
608
609	const version_text = entry.name;
610	const candidate_version = GCCVersion.parse(version_text);
611	if (candidate_version.major != -1) {
612	// TODO: cache path so we're not repeatedly scanning
613	}
614	if (candidate_version.isLessThan(4, 1, 1, "")) continue;
615	switch (candidate_version.order(self.version)) {
616	.lt, .eq => continue,
617	.gt => {},
618	}
619
620	if (!try self.scanGCCForMultilibs(tc, target, .{ dir_name, version_text }, needs_biarch_suffix)) continue;
621
622	self.version = candidate_version;
623	self.gcc_triple = try arena.dupe(u8, candidate_triple);
624	self.install_path = try std.fs.path.join(arena, &.{ lib_dir, lib_suffix, version_text });
625	self.parent_lib_path = try std.fs.path.join(arena, &.{ self.install_path, "..", "..", ".." });
626	self.is_valid = true;
627	}
628	}
629	}
630
631	fn gccToolchainDir(tc: *const Toolchain) []const u8 {
632	const sysroot = tc.getSysroot();
633	if (sysroot.len != 0) return "";
634	return system_defaults.gcc_install_prefix;
635	}

lib/compiler/aro/aro/LangOpts.zig+12-2

 @@ -7,16 +7,22 @@ pub const Compiler = enum {
     clang,
     gcc,
     msvc,
+    no,
     pub fn defaultGccVersion(self: Compiler) u32 {
         return switch (self) {
             .clang => 4 * 10_000 + 2 * 100 + 1,
-            .gcc => 7 * 10_000 + 1 * 100 + 0,
+            .no, .gcc => 7 * 10_000 + 1 * 100 + 0,
             .msvc => 0,
         };
     }
 };
+pub const BoundsSafety = enum {
+    none,
+    clang,
+};
 /// The floating-point evaluation method for intermediate results within a single expression
 pub const FPEvalMethod = enum(i8) {
     /// The evaluation method cannot be determined or is inconsistent for this target.
 @@ -116,7 +122,7 @@ pub const Standard = enum {
 const LangOpts = @This();
-emulate: Compiler = .clang,
+emulate: Compiler = .no,
 standard: Standard = .default,
 /// -fshort-enums option, makes enums only take up as much space as they need to hold all the values.
 short_enums: bool = false,
 @@ -149,6 +155,10 @@ preserve_comments_in_macros: bool = false,
 /// e.g. 4.2.1 == 40201
 gnuc_version: ?u32 = null,
+bounds_safety: BoundsSafety = .none,
+default_symbol_visibility: std.builtin.SymbolVisibility = .default,
 pub fn setStandard(self: *LangOpts, name: []const u8) error{InvalidStandard}!void {
     self.standard = Standard.NameMap.get(name) orelse return error.InvalidStandard;
 }

lib/compiler/aro/aro/Parser.zig+336-142

 @@ -1,5 +1,4 @@
 const std = @import("std");
-const Io = std.Io;
 const mem = std.mem;
 const Allocator = mem.Allocator;
 const assert = std.debug.assert;
 @@ -204,6 +203,11 @@ string_ids: struct {
     sigjmp_buf: StringId,
     ucontext_t: StringId,
 },
+va_arg_pack_ctx: packed struct {
+    valid: bool = false,
+    variadic: bool = false,
+    typed: bool = false,
+} = .{},
 /// Checks codepoint for various pedantic warnings
 /// Returns true if diagnostic issued
 @@ -212,7 +216,7 @@ fn checkIdentifierCodepointWarnings(p: *Parser, codepoint: u21, loc: Source.Loca
     const prev_total = p.diagnostics.total;
     var sf = std.heap.stackFallback(1024, p.comp.gpa);
-    var allocating: Io.Writer.Allocating = .init(sf.get());
+    var allocating: std.Io.Writer.Allocating = .init(sf.get());
     defer allocating.deinit();
     if (!char_info.isC99IdChar(codepoint)) {
 @@ -426,7 +430,7 @@ pub fn err(p: *Parser, tok_i: TokenIndex, diagnostic: Diagnostic, args: anytype)
     if (p.diagnostics.effectiveKind(diagnostic) == .off) return;
     var sf = std.heap.stackFallback(1024, p.comp.gpa);
-    var allocating: Io.Writer.Allocating = .init(sf.get());
+    var allocating: std.Io.Writer.Allocating = .init(sf.get());
     defer allocating.deinit();
     p.formatArgs(&allocating.writer, diagnostic.fmt, args) catch return error.OutOfMemory;
 @@ -448,7 +452,7 @@ pub fn err(p: *Parser, tok_i: TokenIndex, diagnostic: Diagnostic, args: anytype)
     }, p.pp.expansionSlice(tok_i), true);
 }
-fn formatArgs(p: *Parser, w: *Io.Writer, fmt: []const u8, args: anytype) !void {
+fn formatArgs(p: *Parser, w: *std.Io.Writer, fmt: []const u8, args: anytype) !void {
     var i: usize = 0;
     inline for (std.meta.fields(@TypeOf(args))) |arg_info| {
         const arg = @field(args, arg_info.name);
 @@ -477,13 +481,13 @@ fn formatArgs(p: *Parser, w: *Io.Writer, fmt: []const u8, args: anytype) !void {
     try w.writeAll(fmt[i..]);
 }
-fn formatTokenId(w: *Io.Writer, fmt: []const u8, tok_id: Tree.Token.Id) !usize {
+fn formatTokenId(w: *std.Io.Writer, fmt: []const u8, tok_id: Tree.Token.Id) !usize {
     const i = Diagnostics.templateIndex(w, fmt, "{tok_id}");
     try w.writeAll(tok_id.symbol());
     return i;
 }
-fn formatQualType(p: *Parser, w: *Io.Writer, fmt: []const u8, qt: QualType) !usize {
+fn formatQualType(p: *Parser, w: *std.Io.Writer, fmt: []const u8, qt: QualType) !usize {
     const i = Diagnostics.templateIndex(w, fmt, "{qt}");
     try w.writeByte('\'');
     try qt.print(p.comp, w);
 @@ -502,7 +506,7 @@ fn formatQualType(p: *Parser, w: *Io.Writer, fmt: []const u8, qt: QualType) !usi
     return i;
 }
-fn formatResult(p: *Parser, w: *Io.Writer, fmt: []const u8, res: Result) !usize {
+fn formatResult(p: *Parser, w: *std.Io.Writer, fmt: []const u8, res: Result) !usize {
     const i = Diagnostics.templateIndex(w, fmt, "{value}");
     switch (res.val.opt_ref) {
         .none => try w.writeAll("(none)"),
 @@ -525,7 +529,7 @@ const Normalized = struct {
         return .{ .str = str };
     }
-    pub fn format(ctx: Normalized, w: *Io.Writer, fmt: []const u8) !usize {
+    pub fn format(ctx: Normalized, w: *std.Io.Writer, fmt: []const u8) !usize {
         const i = Diagnostics.templateIndex(w, fmt, "{normalized}");
         var it: std.unicode.Utf8Iterator = .{
             .bytes = ctx.str,
 @@ -559,7 +563,7 @@ const Codepoint = struct {
         return .{ .codepoint = codepoint };
     }
-    pub fn format(ctx: Codepoint, w: *Io.Writer, fmt: []const u8) !usize {
+    pub fn format(ctx: Codepoint, w: *std.Io.Writer, fmt: []const u8) !usize {
         const i = Diagnostics.templateIndex(w, fmt, "{codepoint}");
         try w.print("{X:0>4}", .{ctx.codepoint});
         return i;
 @@ -573,7 +577,7 @@ const Escaped = struct {
         return .{ .str = str };
     }
-    pub fn format(ctx: Escaped, w: *Io.Writer, fmt: []const u8) !usize {
+    pub fn format(ctx: Escaped, w: *std.Io.Writer, fmt: []const u8) !usize {
         const i = Diagnostics.templateIndex(w, fmt, "{s}");
         try std.zig.stringEscape(ctx.str, w);
         return i;
 @@ -740,6 +744,11 @@ fn getNode(p: *Parser, node: Node.Index, comptime tag: std.meta.Tag(Tree.Node))
     }
 }
+pub fn isAddressOfStringLiteral(p: *Parser, node: Node.Index) bool {
+    const addr_of = p.getNode(node, .addr_of_expr) orelse return false;
+    return p.nodeIs(addr_of.operand, .string_literal_expr);
+}
 fn pragma(p: *Parser) Compilation.Error!bool {
     var found_pragma = false;
     while (p.eatToken(.keyword_pragma)) |_| {
 @@ -1070,14 +1079,15 @@ fn decl(p: *Parser) Error!bool {
     try p.attributeSpecifier();
+    const decl_spec_start = p.tok_i;
     var decl_spec = (try p.declSpec()) orelse blk: {
         if (p.func.qt != null) {
             p.tok_i = first_tok;
             return false;
         }
-        switch (p.tok_ids[first_tok]) {
+        switch (p.tok_ids[decl_spec_start]) {
             .asterisk, .l_paren => {},
-            .identifier, .extended_identifier => switch (p.tok_ids[first_tok + 1]) {
+            .identifier, .extended_identifier => switch (p.tok_ids[decl_spec_start + 1]) {
                 .identifier, .extended_identifier => {
                     // The most likely reason for `identifier identifier` is
                     // an unknown type name.
 @@ -1087,7 +1097,7 @@ fn decl(p: *Parser) Error!bool {
                 },
                 else => {},
             },
-            else => if (p.tok_i != first_tok) {
+            else => if (p.tok_i != decl_spec_start) {
                 try p.err(p.tok_i, .expected_ident_or_l_paren, .{});
                 return error.ParsingFailed;
             } else return false,
 @@ -1167,6 +1177,7 @@ fn decl(p: *Parser) Error!bool {
         // Collect old style parameter declarations.
         if (init_d.d.old_style_func != null) {
+            try p.err(init_d.d.name, .def_no_proto_deprecated, .{});
             const param_buf_top = p.param_buf.items.len;
             defer p.param_buf.items.len = param_buf_top;
 @@ -1340,7 +1351,7 @@ fn decl(p: *Parser) Error!bool {
         if (init_d.d.old_style_func) |tok_i| try p.err(tok_i, .invalid_old_style_params, .{});
         if (decl_spec.storage_class == .typedef) {
-            try decl_spec.validateDecl(p);
+            try decl_spec.validateDecl(p, init_d.asm_label);
             try p.tree.setNode(.{ .typedef = .{
                 .name_tok = init_d.d.name,
                 .qt = init_d.d.qt,
 @@ -1357,7 +1368,7 @@ fn decl(p: *Parser) Error!bool {
                 .definition = null,
             } }, @intFromEnum(decl_node));
         } else {
-            try decl_spec.validateDecl(p);
+            try decl_spec.validateDecl(p, init_d.asm_label);
             var node_qt = init_d.d.qt;
             if (p.func.qt == null and decl_spec.storage_class != .@"extern") {
                 if (node_qt.get(p.comp, .array)) |array_ty| {
 @@ -1454,7 +1465,7 @@ fn decl(p: *Parser) Error!bool {
     return true;
 }
-fn staticAssertMessage(p: *Parser, cond_node: Node.Index, maybe_message: ?Result, allocating: *Io.Writer.Allocating) !?[]const u8 {
+fn staticAssertMessage(p: *Parser, cond_node: Node.Index, maybe_message: ?Result, allocating: *std.Io.Writer.Allocating) !?[]const u8 {
     const w = &allocating.writer;
     const cond = cond_node.get(&p.tree);
 @@ -1527,7 +1538,7 @@ fn staticAssert(p: *Parser) Error!bool {
     } else {
         if (!res.val.toBool(p.comp)) {
             var sf = std.heap.stackFallback(1024, gpa);
-            var allocating: Io.Writer.Allocating = .init(sf.get());
+            var allocating: std.Io.Writer.Allocating = .init(sf.get());
             defer allocating.deinit();
             if (p.staticAssertMessage(res_node, str, &allocating) catch return error.OutOfMemory) |message| {
 @@ -1597,13 +1608,16 @@ pub const DeclSpec = struct {
         if (d.constexpr) |tok_i| try p.err(tok_i, .illegal_storage_on_func, .{});
     }
-    fn validateDecl(d: DeclSpec, p: *Parser) Error!void {
+    fn validateDecl(d: DeclSpec, p: *Parser, asm_label: ?Node.Index) Error!void {
         if (d.@"inline") |tok_i| try p.err(tok_i, .func_spec_non_func, .{"inline"});
         // TODO move to attribute validation
         if (d.noreturn) |tok_i| try p.err(tok_i, .func_spec_non_func, .{"_Noreturn"});
         switch (d.storage_class) {
-            .auto => std.debug.assert(!p.comp.langopts.standard.atLeast(.c23)),
+            .auto => {
-            .register => if (p.func.qt == null) try p.err(p.tok_i, .illegal_storage_on_global, .{}),
+                std.debug.assert(!p.comp.langopts.standard.atLeast(.c23));
+                try p.err(p.tok_i, .auto_on_global, .{});
+            },
+            .register => if (p.func.qt == null and asm_label == null) try p.err(p.tok_i, .register_on_global, .{}),
             else => {},
         }
     }
 @@ -1787,7 +1801,11 @@ fn storageClassSpec(p: *Parser, d: *DeclSpec) Error!bool {
     return p.tok_i != start;
 }
-const InitDeclarator = struct { d: Declarator, initializer: ?Result = null };
+const InitDeclarator = struct {
+    d: Declarator,
+    initializer: ?Result = null,
+    asm_label: ?Node.Index = null,
+};
 /// attribute
 ///  : attrIdentifier
 @@ -1829,18 +1847,18 @@ fn attribute(p: *Parser, kind: Attribute.Kind, namespace: ?[]const u8) Error!?Te
                 if (try p.eatIdentifier()) |ident| {
                     if (try Attribute.diagnoseIdent(attr, &arguments, ident, p)) {
                         p.skipTo(.r_paren);
-                        return error.ParsingFailed;
+                        return null;
                     }
                 } else {
                     try p.err(name_tok, .attribute_requires_identifier, .{name});
-                    return error.ParsingFailed;
+                    return null;
                 }
             } else {
                 const arg_start = p.tok_i;
                 const first_expr = try p.expect(assignExpr);
                 if (try p.diagnose(attr, &arguments, arg_idx, first_expr, arg_start)) {
                     p.skipTo(.r_paren);
-                    return error.ParsingFailed;
+                    return null;
                 }
             }
             arg_idx += 1;
 @@ -1851,7 +1869,7 @@ fn attribute(p: *Parser, kind: Attribute.Kind, namespace: ?[]const u8) Error!?Te
                 const arg_expr = try p.expect(assignExpr);
                 if (try p.diagnose(attr, &arguments, arg_idx, arg_expr, arg_start)) {
                     p.skipTo(.r_paren);
-                    return error.ParsingFailed;
+                    return null;
                 }
             }
         },
 @@ -1861,9 +1879,9 @@ fn attribute(p: *Parser, kind: Attribute.Kind, namespace: ?[]const u8) Error!?Te
         try p.err(name_tok, .attribute_not_enough_args, .{
             @tagName(attr), required_count,
         });
-        return error.ParsingFailed;
+        return null;
     }
-    return TentativeAttribute{ .attr = .{ .tag = attr, .args = arguments, .syntax = kind.toSyntax() }, .tok = name_tok };
+    return .{ .attr = .{ .tag = attr, .args = arguments, .syntax = kind.toSyntax() }, .tok = name_tok };
 }
 fn diagnose(p: *Parser, attr: Attribute.Tag, arguments: *Attribute.Arguments, arg_idx: u32, res: Result, arg_start: TokenIndex) !bool {
 @@ -1995,12 +2013,12 @@ fn initDeclarator(p: *Parser, decl_spec: *DeclSpec, attr_buf_top: usize, decl_no
     defer p.attr_buf.len = this_attr_buf_top;
     const gpa = p.comp.gpa;
-    var init_d = InitDeclarator{
+    var init_d: InitDeclarator = .{
         .d = (try p.declarator(decl_spec.qt, .normal)) orelse return null,
     };
     try p.attributeSpecifierExtra(init_d.d.name);
-    _ = try p.assembly(.decl_label);
+    init_d.asm_label = try p.assembly(.decl_label);
     try p.attributeSpecifierExtra(init_d.d.name);
     switch (init_d.d.declarator_type) {
 @@ -2276,14 +2294,13 @@ fn typeSpec(p: *Parser, builder: *TypeStore.Builder) Error!bool {
                         }, .syntax = .keyword },
                         .tok = align_tok,
                     });
-                } else {
+                } else check: {
                     const arg_start = p.tok_i;
                     const res = try p.integerConstExpr(.no_const_decl_folding);
                     if (!res.val.isZero(p.comp)) {
                         var args = Attribute.initArguments(.aligned, align_tok);
                         if (try p.diagnose(.aligned, &args, 0, res, arg_start)) {
-                            p.skipTo(.r_paren);
+                            break :check;
-                            return error.ParsingFailed;
                         }
                         args.aligned.alignment.?.node = .pack(res.node);
                         try p.attr_buf.append(gpa, .{
 @@ -2562,7 +2579,7 @@ fn recordSpec(p: *Parser) Error!QualType {
     if (!any_incomplete) {
         const pragma_pack_value = switch (p.comp.langopts.emulate) {
-            .clang => starting_pragma_pack,
+            .clang, .no => starting_pragma_pack,
             .gcc => p.pragma_pack,
             // TODO: msvc considers `#pragma pack` on a per-field basis
             .msvc => p.pragma_pack,
 @@ -3542,7 +3559,6 @@ fn declarator(
         const pointer_qt = try p.comp.type_store.put(p.comp.gpa, .{ .pointer = .{
             .child = d.qt,
-            .decayed = null,
         } });
         d.qt = try builder.finishQuals(pointer_qt);
     }
 @@ -4141,7 +4157,10 @@ fn designation(p: *Parser, il: *InitList, init_qt: QualType, index_list: *IndexL
                 const field = record_ty.fields[field_index];
                 if (field.name_tok == 0) if (field.qt.getRecord(p.comp)) |field_record_ty| {
                     // Recurse into anonymous field if it has a field by the name.
-                    if (!field_record_ty.hasField(p.comp, target_name)) continue;
+                    if (!field_record_ty.hasField(p.comp, target_name)) {
+                        field_index += 1;
+                        continue;
+                    }
                     try index_list.append(gpa, field_index);
                     cur_il = try il.find(gpa, field_index);
                     record_ty = field_record_ty;
 @@ -4983,31 +5002,31 @@ fn assembly(p: *Parser, kind: enum { global, decl_label, stmt }) Error!?Node.Ind
     };
     const l_paren = try p.expectToken(.l_paren);
-    var result_node: ?Node.Index = null;
+    const res = switch (kind) {
-    switch (kind) {
+        .decl_label => blk: {
-        .decl_label => {
             const asm_str = try p.asmStr();
             const str = try p.removeNull(asm_str.val);
             const attr = Attribute{ .tag = .asm_label, .args = .{ .asm_label = .{ .name = str } }, .syntax = .keyword };
             try p.attr_buf.append(p.comp.gpa, .{ .attr = attr, .tok = asm_tok });
+            break :blk asm_str.node;
         },
-        .global => {
+        .global => blk: {
             const asm_str = try p.asmStr();
             try p.checkAsmStr(asm_str.val, l_paren);
-            result_node = try p.addNode(.{
+            break :blk try p.addNode(.{
                 .global_asm = .{
                     .asm_tok = asm_tok,
                     .asm_str = asm_str.node,
                 },
             });
         },
-        .stmt => result_node = try p.gnuAsmStmt(quals, asm_tok, l_paren),
+        .stmt => try p.gnuAsmStmt(quals, asm_tok, l_paren),
-    }
+    };
     try p.expectClosing(l_paren, .r_paren);
     if (kind != .decl_label) _ = try p.expectToken(.semicolon);
-    return result_node;
+    return res;
 }
 /// Same as stringLiteral but errors on unicode and wide string literals
 @@ -5253,7 +5272,6 @@ fn stmt(p: *Parser) Error!Node.Index {
             if (!goto_expr.qt.isInvalid() and !goto_expr.qt.isPointer(p.comp)) {
                 const result_qt = try p.comp.type_store.put(gpa, .{ .pointer = .{
                     .child = .{ .@"const" = true, ._index = .void },
-                    .decayed = null,
                 } });
                 if (!goto_expr.qt.isRealInt(p.comp)) {
                     try p.err(expr_tok, .incompatible_arg, .{ goto_expr.qt, result_qt });
 @@ -5905,6 +5923,7 @@ const CallExpr = union(enum) {
                     .__builtin_reduce_xor,
                     .__builtin_reduce_max,
                     .__builtin_reduce_min,
+                    .__builtin_constant_p,
                     => 1,
                     .__builtin_complex,
 @@ -5922,13 +5941,15 @@ const CallExpr = union(enum) {
                     .__c11_atomic_store,
                     .__atomic_store,
+                    .__atomic_store_n,
+                    .__atomic_load,
                     .__c11_atomic_exchange,
-                    .__atomic_exchange,
                     .__c11_atomic_fetch_add,
                     .__c11_atomic_fetch_sub,
                     .__c11_atomic_fetch_or,
                     .__c11_atomic_fetch_xor,
                     .__c11_atomic_fetch_and,
+                    .__c11_atomic_fetch_nand,
                     .__atomic_fetch_add,
                     .__atomic_fetch_sub,
                     .__atomic_fetch_and,
 @@ -5948,6 +5969,9 @@ const CallExpr = union(enum) {
                     .__atomic_exchange_n,
                     => 3,
+                    .__atomic_exchange,
+                    => 4,
                     .__c11_atomic_compare_exchange_strong,
                     .__c11_atomic_compare_exchange_weak,
                     => 5,
 @@ -5964,25 +5988,13 @@ const CallExpr = union(enum) {
     fn returnType(self: CallExpr, p: *Parser, args: []const Node.Index, func_qt: QualType) !QualType {
         if (self == .standard) {
+            if (func_qt.isInvalid()) return .invalid;
             return if (func_qt.get(p.comp, .func)) |func_ty| func_ty.return_type else .invalid;
         }
         const builtin = self.builtin;
         const func_ty = func_qt.get(p.comp, .func).?;
         return switch (builtin.expanded.tag) {
             .common => |tag| switch (tag) {
-                .__c11_atomic_exchange => {
-                    if (args.len != 4) return .invalid; // wrong number of arguments; already an error
-                    const second_param = args[2];
-                    return second_param.qt(&p.tree);
-                },
-                .__c11_atomic_load => {
-                    if (args.len != 3) return .invalid; // wrong number of arguments; already an error
-                    const first_param = args[1];
-                    const qt = first_param.qt(&p.tree);
-                    if (!qt.isPointer(p.comp)) return .invalid;
-                    return qt.childType(p.comp);
-                },
                 .__atomic_fetch_add,
                 .__atomic_add_fetch,
                 .__c11_atomic_fetch_add,
 @@ -6008,15 +6020,38 @@ const CallExpr = union(enum) {
                 .__c11_atomic_fetch_nand,
                 .__atomic_exchange_n,
+                .__c11_atomic_exchange,
+                => {
+                    const second_param = args[1].qt(&p.tree);
+                    return second_param;
+                },
+                .__sync_fetch_and_add,
+                .__sync_fetch_and_and,
+                .__sync_fetch_and_nand,
+                .__sync_fetch_and_or,
+                .__sync_fetch_and_sub,
+                .__sync_fetch_and_xor,
+                .__sync_add_and_fetch,
+                .__sync_and_and_fetch,
+                .__sync_nand_and_fetch,
+                .__sync_or_and_fetch,
+                .__sync_sub_and_fetch,
+                .__sync_xor_and_fetch,
+                .__sync_swap,
+                .__sync_lock_test_and_set,
+                .__sync_val_compare_and_swap,
                 => {
-                    if (args.len != 3) return .invalid; // wrong number of arguments; already an error
+                    if (args.len < 2) return .invalid;
-                    const second_param = args[2];
+                    const second_param = args[1].qt(&p.tree);
-                    return second_param.qt(&p.tree);
+                    return second_param;
                 },
                 .__builtin_complex => {
-                    if (args.len < 1) return .invalid; // not enough arguments; already an error
+                    const last_param = args[args.len - 1].qt(&p.tree);
-                    const last_param = args[args.len - 1];
+                    if (last_param.isInvalid()) return .invalid;
-                    return try last_param.qt(&p.tree).toComplex(p.comp);
+                    return try last_param.toComplex(p.comp);
                 },
                 .__atomic_compare_exchange,
                 .__atomic_compare_exchange_n,
 @@ -6027,9 +6062,8 @@ const CallExpr = union(enum) {
                 .__c11_atomic_compare_exchange_strong,
                 .__c11_atomic_compare_exchange_weak,
                 => {
-                    if (args.len != 6) return .invalid; // wrong number of arguments
+                    const third_param = args[2].qt(&p.tree);
-                    const third_param = args[3];
+                    return third_param;
-                    return third_param.qt(&p.tree);
                 },
                 .__builtin_elementwise_abs,
 @@ -6058,13 +6092,12 @@ const CallExpr = union(enum) {
                 .__builtin_elementwise_sub_sat,
                 .__builtin_elementwise_fma,
                 .__builtin_elementwise_popcount,
                 .__builtin_nondeterministic_value,
                 => {
-                    if (args.len < 1) return .invalid; // not enough arguments; already an error
+                    const first_param = args[0].qt(&p.tree);
-                    const last_param = args[args.len - 1];
+                    return first_param;
-                    return last_param.qt(&p.tree);
                 },
-                .__builtin_nontemporal_load,
                 .__builtin_reduce_add,
                 .__builtin_reduce_mul,
                 .__builtin_reduce_and,
 @@ -6073,30 +6106,19 @@ const CallExpr = union(enum) {
                 .__builtin_reduce_max,
                 .__builtin_reduce_min,
                 => {
-                    if (args.len < 1) return .invalid; // not enough arguments; already an error
+                    const first_param = args[0].qt(&p.tree);
-                    const last_param = args[args.len - 1];
+                    if (first_param.isInvalid()) return .invalid;
-                    return last_param.qt(&p.tree).childType(p.comp);
+                    const vector_ty = first_param.get(p.comp, .vector) orelse return .invalid;
+                    return vector_ty.elem;
                 },
-                .__sync_add_and_fetch,
-                .__sync_and_and_fetch,
-                .__sync_fetch_and_add,
-                .__sync_fetch_and_and,
-                .__sync_fetch_and_nand,
-                .__sync_fetch_and_or,
-                .__sync_fetch_and_sub,
-                .__sync_fetch_and_xor,
-                .__sync_lock_test_and_set,
-                .__sync_nand_and_fetch,
-                .__sync_or_and_fetch,
-                .__sync_sub_and_fetch,
-                .__sync_swap,
-                .__sync_xor_and_fetch,
-                .__sync_val_compare_and_swap,
                 .__atomic_load_n,
+                .__c11_atomic_load,
+                .__builtin_nontemporal_load,
                 => {
-                    if (args.len < 1) return .invalid; // not enough arguments; already an error
+                    const first_param = args[0].qt(&p.tree);
-                    const first_param = args[0];
+                    if (first_param.isInvalid()) return .invalid;
-                    return first_param.qt(&p.tree).childType(p.comp);
+                    if (!first_param.isPointer(p.comp)) return .invalid;
+                    return first_param.childType(p.comp);
                 },
                 else => func_ty.return_type,
             },
 @@ -6104,9 +6126,16 @@ const CallExpr = union(enum) {
         };
     }
-    fn finish(self: CallExpr, p: *Parser, func_qt: QualType, list_buf_top: usize, l_paren: TokenIndex) Error!Result {
+    fn finish(
+        self: CallExpr,
+        p: *Parser,
+        func_qt: QualType,
+        list_buf_top: usize,
+        l_paren: TokenIndex,
+        args_ok: bool,
+    ) Error!Result {
         const args = p.list_buf.items[list_buf_top..];
-        const return_qt = try self.returnType(p, args, func_qt);
+        const return_qt: QualType = if (args_ok) try self.returnType(p, args, func_qt) else .invalid;
         switch (self) {
             .standard => |func_node| return .{
                 .qt = return_qt,
 @@ -6118,7 +6147,7 @@ const CallExpr = union(enum) {
                 } }),
             },
             .builtin => |builtin| return .{
-                .val = try evalBuiltin(builtin.expanded, p, args),
+                .val = if (args_ok) try evalBuiltin(builtin.expanded, p, args) else .{},
                 .qt = return_qt,
                 .node = try p.addNode(.{ .builtin_call_expr = .{
                     .builtin_tok = builtin.builtin_tok,
 @@ -6283,14 +6312,12 @@ pub const Result = struct {
         if (!adjusted_elem_qt.eqlQualified(a_elem, p.comp)) {
             a.qt = try p.comp.type_store.put(gpa, .{ .pointer = .{
                 .child = adjusted_elem_qt,
-                .decayed = null,
             } });
             try a.implicitCast(p, .bitcast, tok);
         }
         if (!adjusted_elem_qt.eqlQualified(b_elem, p.comp)) {
             b.qt = try p.comp.type_store.put(gpa, .{ .pointer = .{
                 .child = adjusted_elem_qt,
-                .decayed = null,
             } });
             try b.implicitCast(p, .bitcast, tok);
         }
 @@ -6478,6 +6505,7 @@ pub const Result = struct {
             .add => {
                 // if both aren't arithmetic one should be pointer and the other an integer
                 if (a_sk.isPointer() == b_sk.isPointer() or a_sk.isInt() == b_sk.isInt()) return a.invalidBinTy(tok, b, p);
+                try p.boundsSafetyCheckPointerArithmetic(a.qt, b.qt, tok, a.node);
                 if (a_sk == .void_pointer or b_sk == .void_pointer)
                     try p.err(tok, .gnu_pointer_arith, .{});
 @@ -6496,6 +6524,7 @@ pub const Result = struct {
             .sub => {
                 // if both aren't arithmetic then either both should be pointers or just the left one.
                 if (!a_sk.isPointer() or !(b_sk.isPointer() or b_sk.isInt())) return a.invalidBinTy(tok, b, p);
+                try p.boundsSafetyCheckPointerArithmetic(a.qt, b.qt, tok, a.node);
                 if (a_sk == .void_pointer)
                     try p.err(tok, .gnu_pointer_arith, .{});
 @@ -7087,14 +7116,14 @@ pub const Result = struct {
             } else if (dest_sk.isPointer()) {
                 if (src_sk.isPointer()) {
                     cast_kind = .bitcast;
+                } else if (src_sk == .bool) {
+                    cast_kind = .bool_to_pointer;
                 } else if (src_sk.isInt()) {
                     if (!src_sk.isReal()) {
                         res.qt = res.qt.toReal(p.comp);
                         try res.implicitCast(p, .complex_int_to_real, l_paren);
                     }
                     cast_kind = .int_to_pointer;
-                } else if (src_sk == .bool) {
-                    cast_kind = .bool_to_pointer;
                 } else if (res.qt.is(p.comp, .array)) {
                     cast_kind = .array_to_pointer;
                 } else if (res.qt.is(p.comp, .func)) {
 @@ -7497,7 +7526,16 @@ fn issueDeclaredConstHereNote(p: *Parser, decl_ref: Tree.Node.DeclRef, var_name:
     try p.err(location, .declared_const_here, .{var_name});
 }
-fn issueConstAssignmetDiagnostics(p: *Parser, node_idx: Node.Index, tok: TokenIndex) Compilation.Error!void {
+fn issueBoundsDeclaredHereNote(p: *Parser, decl_ref: Tree.Node.DeclRef, var_name: []const u8, bounds: Type.Pointer.Bounds) Compilation.Error!void {
+    const location = switch (decl_ref.decl.get(&p.tree)) {
+        .variable => |variable| variable.name_tok,
+        .param => |param| param.name_tok,
+        else => return,
+    };
+    try p.err(location, .pointer_bounds_declared_here, .{ var_name, @tagName(bounds) });
+}
+fn issueConstAssignmentDiagnostics(p: *Parser, node_idx: Node.Index, tok: TokenIndex) Compilation.Error!void {
     if (p.unwrapNestedOperation(node_idx)) |unwrapped| {
         const name = p.tokSlice(unwrapped.name_tok);
         try p.err(tok, .const_var_assignment, .{ name, unwrapped.qt });
 @@ -7530,7 +7568,7 @@ fn assignExpr(p: *Parser) Error!?Result {
     var is_const: bool = undefined;
     if (!p.tree.isLvalExtra(lhs.node, &is_const) or is_const) {
-        try p.issueConstAssignmetDiagnostics(lhs.node, tok);
+        try p.issueConstAssignmentDiagnostics(lhs.node, tok);
         lhs.qt = .invalid;
     }
 @@ -8226,7 +8264,7 @@ fn builtinChooseExpr(p: *Parser) Error!Result {
     return cond;
 }
-/// vaStart : __builtin_va_arg '(' assignExpr ',' typeName ')'
+/// vaArg : __builtin_va_arg '(' assignExpr ',' typeName ')'
 fn builtinVaArg(p: *Parser, builtin_tok: TokenIndex) Error!Result {
     const l_paren = try p.expectToken(.l_paren);
     const va_list_tok = p.tok_i;
 @@ -8258,6 +8296,62 @@ fn builtinVaArg(p: *Parser, builtin_tok: TokenIndex) Error!Result {
     };
 }
+/// vaArgPack : __builtin_va_arg_pack '(' ')'
+fn builtinVaArgPack(p: *Parser, builtin_tok: TokenIndex) Error!Result {
+    const l_paren = try p.expectToken(.l_paren);
+    try p.expectClosing(l_paren, .r_paren);
+    var res_qt: QualType = .invalid;
+    if (!try p.checkVaPackFunc(builtin_tok, "__builtin_va_arg_pack")) {
+        // Only add one error.
+    } else if (!p.va_arg_pack_ctx.valid) {
+        try p.err(builtin_tok, .va_pack_non_call, .{});
+    } else if (!p.va_arg_pack_ctx.variadic) {
+        try p.err(builtin_tok, .va_pack_non_variadic_call, .{});
+    } else if (p.va_arg_pack_ctx.typed) {
+        try p.err(builtin_tok, .va_pack_non_variadic_arg, .{});
+    } else {
+        res_qt = .void;
+    }
+    return .{
+        .qt = res_qt,
+        .node = try p.addNode(.{
+            .builtin_va_arg_pack = .{ .builtin_tok = builtin_tok },
+        }),
+    };
+}
+/// vaArgPackLen : __builtin_va_arg_pack_len '(' ')'
+fn builtinVaArgPackLen(p: *Parser, builtin_tok: TokenIndex) Error!Result {
+    const l_paren = try p.expectToken(.l_paren);
+    try p.expectClosing(l_paren, .r_paren);
+    _ = try p.checkVaPackFunc(builtin_tok, "__builtin_va_arg_pack_len");
+    return .{
+        .qt = .int,
+        .node = try p.addNode(.{
+            .builtin_va_arg_pack_len = .{
+                .builtin_tok = builtin_tok,
+            },
+        }),
+    };
+}
+fn checkVaPackFunc(p: *Parser, builtin_tok: TokenIndex, va_func_name: []const u8) !bool {
+    const func_qt, _ = (try p.checkVaFunc(builtin_tok, va_func_name)) orelse return false;
+    var it = Attribute.Iterator.initType(func_qt, p.comp);
+    while (it.next()) |item| switch (item[0].tag) {
+        .always_inline, .gnu_inline => break,
+        else => {},
+    } else {
+        try p.err(builtin_tok, .va_func_not_always_inline, .{va_func_name});
+        return false;
+    }
+    return true;
+}
 const OffsetKind = enum { bits, bytes };
 /// offsetof
 @@ -8504,7 +8598,6 @@ fn unExpr(p: *Parser) Error!?Result {
                 operand.qt = try p.comp.type_store.put(gpa, .{ .pointer = .{
                     .child = operand.qt,
-                    .decayed = null,
                 } });
             }
             if (p.getNode(operand.node, .decl_ref_expr)) |decl_ref| {
 @@ -8596,6 +8689,9 @@ fn unExpr(p: *Parser) Error!?Result {
                 try p.err(tok, .not_assignable, .{});
                 return error.ParsingFailed;
             }
+            if (operand.qt.get(p.comp, .pointer)) |pointer| {
+                try p.checkPtrArithmeticAllowed(pointer, p.tok_i, operand.node);
+            }
             try operand.usualUnaryConversion(p, tok);
             if (operand.val.is(.int, p.comp) or operand.val.is(.int, p.comp)) {
 @@ -8624,6 +8720,9 @@ fn unExpr(p: *Parser) Error!?Result {
                 try p.err(tok, .not_assignable, .{});
                 return error.ParsingFailed;
             }
+            if (operand.qt.get(p.comp, .pointer)) |pointer| {
+                try p.checkPtrArithmeticAllowed(pointer, p.tok_i, operand.node);
+            }
             try operand.usualUnaryConversion(p, tok);
             if (operand.val.is(.int, p.comp) or operand.val.is(.int, p.comp)) {
 @@ -8826,7 +8925,7 @@ fn unExpr(p: *Parser) Error!?Result {
             } else switch (p.comp.langopts.emulate) {
                 .msvc => {}, // Doesn't support `_Complex` or `__imag` in the first place
                 .gcc => operand.val = .zero,
-                .clang => {
+                .clang, .no => {
                     if (operand.val.is(.int, p.comp) or operand.val.is(.float, p.comp)) {
                         operand.val = .zero;
                     } else {
 @@ -8886,7 +8985,7 @@ fn compoundLiteral(p: *Parser, qt_opt: ?QualType, opt_l_paren: ?TokenIndex) Erro
                 try p.err(tok, .invalid_compound_literal_storage_class, .{@tagName(d.storage_class)});
                 d.storage_class = .none;
             },
-            .register => if (p.func.qt == null) try p.err(p.tok_i, .illegal_storage_on_global, .{}),
+            .register => if (p.func.qt == null) try p.err(p.tok_i, .register_on_global_compound_literal, .{}),
             else => {},
         }
 @@ -8968,6 +9067,9 @@ fn suffixExpr(p: *Parser, lhs: Result) Error!?Result {
                 try p.err(p.tok_i, .not_assignable, .{});
                 return error.ParsingFailed;
             }
+            if (operand.qt.get(p.comp, .pointer)) |pointer| {
+                try p.checkPtrArithmeticAllowed(pointer, p.tok_i, operand.node);
+            }
             try operand.usualUnaryConversion(p, p.tok_i);
             try operand.un(p, .post_inc_expr, p.tok_i);
 @@ -8989,6 +9091,9 @@ fn suffixExpr(p: *Parser, lhs: Result) Error!?Result {
                 try p.err(p.tok_i, .not_assignable, .{});
                 return error.ParsingFailed;
             }
+            if (operand.qt.get(p.comp, .pointer)) |pointer| {
+                try p.checkPtrArithmeticAllowed(pointer, p.tok_i, operand.node);
+            }
             try operand.usualUnaryConversion(p, p.tok_i);
             try operand.un(p, .post_dec_expr, p.tok_i);
 @@ -9003,6 +9108,7 @@ fn suffixExpr(p: *Parser, lhs: Result) Error!?Result {
             const array_before_conversion = lhs;
             const index_before_conversion = index;
             var ptr = lhs;
             try ptr.lvalConversion(p, l_bracket);
             try index.lvalConversion(p, l_bracket);
             if (ptr.qt.get(p.comp, .pointer)) |pointer_ty| {
 @@ -9176,14 +9282,7 @@ fn checkVaStartArg(p: *Parser, builtin_tok: TokenIndex, first_after: TokenIndex,
         return error.ParsingFailed;
     }
-    const func_qt = p.func.qt orelse {
+    _, const func_ty = (try p.checkVaFunc(builtin_tok, "va_start")) orelse return;
-        try p.err(builtin_tok, .va_start_not_in_func, .{});
-        return;
-    };
-    const func_ty = func_qt.get(p.comp, .func) orelse return;
-    if (func_ty.kind != .variadic or func_ty.params.len == 0) {
-        return p.err(builtin_tok, .va_start_fixed_args, .{});
-    }
     const last_param_name = func_ty.params[func_ty.params.len - 1].name;
     const decl_ref = p.getNode(arg.node, .decl_ref_expr);
     if (decl_ref == null or last_param_name != try p.comp.internString(p.tokSlice(decl_ref.?.name_tok))) {
 @@ -9191,6 +9290,19 @@ fn checkVaStartArg(p: *Parser, builtin_tok: TokenIndex, first_after: TokenIndex,
     }
 }
+fn checkVaFunc(p: *Parser, builtin_tok: TokenIndex, va_func_name: []const u8) !?struct { QualType, Type.Func } {
+    const func_qt = p.func.qt orelse {
+        try p.err(builtin_tok, .va_func_not_in_func, .{va_func_name});
+        return null;
+    };
+    const func_ty = func_qt.get(p.comp, .func) orelse return null;
+    if (func_ty.kind != .variadic or func_ty.params.len == 0) {
+        try p.err(builtin_tok, .va_func_fixed_args, .{va_func_name});
+        return null;
+    }
+    return .{ func_qt, func_ty };
+}
 fn checkArithOverflowArg(p: *Parser, builtin_tok: TokenIndex, first_after: TokenIndex, param_tok: TokenIndex, arg: *Result, idx: u32) !void {
     _ = builtin_tok;
     _ = first_after;
 @@ -9320,7 +9432,7 @@ fn callExpr(p: *Parser, lhs: Result) Error!Result {
     // We cannot refer to the function type here because the pointer to
     // type_store.extra might get invalidated while parsing args.
-    const func_qt, const params_len, const func_kind = blk: {
+    const func_qt, const typed_params_len, const func_kind_base = blk: {
         var base_qt = lhs.qt;
         if (base_qt.get(p.comp, .pointer)) |pointer_ty| base_qt = pointer_ty.child;
         if (base_qt.isInvalid()) break :blk .{ base_qt, std.math.maxInt(usize), undefined };
 @@ -9343,9 +9455,44 @@ fn callExpr(p: *Parser, lhs: Result) Error!Result {
     const call_expr = CallExpr.init(p, lhs.node, func.node);
+    const param_len_override = call_expr.paramCountOverride();
+    const params_len = param_len_override orelse typed_params_len;
+    const func_kind = if (param_len_override != null) .normal else func_kind_base;
     while (p.eatToken(.r_paren) == null) {
         const param_tok = p.tok_i;
         if (arg_count == params_len) first_after = p.tok_i;
+        // Check for __builtin_va_arg_pack
+        {
+            var i = p.tok_i;
+            loop: switch (p.tok_ids[i]) {
+                .l_paren => {
+                    i += 1;
+                    continue :loop p.tok_ids[i];
+                },
+                .identifier => if (mem.eql(u8, p.tokSlice(i), "__builtin_va_arg_pack")) {
+                    @branchHint(.cold);
+                    p.va_arg_pack_ctx = .{
+                        .valid = true,
+                        .variadic = func_kind != .normal,
+                        .typed = arg_count < typed_params_len,
+                    };
+                    defer p.va_arg_pack_ctx = .{};
+                    const arg = try p.expect(assignExpr);
+                    try p.list_buf.append(gpa, arg.node);
+                    arg_count += 1;
+                    if (p.eatToken(.comma)) |_| {
+                        try p.err(i, .va_pack_non_final_arg, .{});
+                        continue;
+                    }
+                    try p.expectClosing(l_paren, .r_paren);
+                    break;
+                },
+                else => {},
+            }
+        }
         var arg = try p.expect(assignExpr);
         if (call_expr.shouldPerformLvalConversion(arg_count)) {
 @@ -9353,7 +9500,7 @@ fn callExpr(p: *Parser, lhs: Result) Error!Result {
         }
         if ((arg.qt.hasIncompleteSize(p.comp) and !arg.qt.is(p.comp, .void)) or arg.qt.isInvalid()) return error.ParsingFailed;
-        if (arg_count >= params_len) {
+        if (arg_count >= typed_params_len) {
             if (call_expr.shouldPromoteVarArg(arg_count)) switch (arg.qt.base(p.comp).type) {
                 .int => |int_ty| if (int_ty == .int) try arg.castToInt(p, arg.qt.promoteInt(p.comp), param_tok),
                 .float => |float_ty| if (float_ty == .double) try arg.castToFloat(p, .double, param_tok),
 @@ -9407,19 +9554,23 @@ fn callExpr(p: *Parser, lhs: Result) Error!Result {
     }
     if (func_qt.isInvalid()) {
         // Skip argument count checks.
-        return try call_expr.finish(p, func_qt, list_buf_top, l_paren);
+        return try call_expr.finish(p, func_qt, list_buf_top, l_paren, false);
     }
-    if (call_expr.paramCountOverride()) |expected| {
+    const r_paren = p.tok_i - 1;
-        if (expected != arg_count) {
+    var args_ok = true;
-            try p.err(first_after, .expected_arguments, .{ expected, arg_count });
+    switch (func_kind) {
-        }
-    } else switch (func_kind) {
         .normal => if (params_len != arg_count) {
-            try p.err(first_after, .expected_arguments, .{ params_len, arg_count });
+            try p.err(
+                if (arg_count < params_len) r_paren else first_after,
+                .expected_arguments,
+                .{ params_len, arg_count },
+            );
+            args_ok = false;
         },
         .variadic => if (arg_count < params_len) {
-            try p.err(first_after, .expected_at_least_arguments, .{ params_len, arg_count });
+            try p.err(r_paren, .expected_at_least_arguments, .{ params_len, arg_count });
+            args_ok = false;
         },
         .old_style => if (params_len != arg_count) {
             if (params_len == 0)
 @@ -9429,10 +9580,60 @@ fn callExpr(p: *Parser, lhs: Result) Error!Result {
         },
     }
-    return try call_expr.finish(p, func_qt, list_buf_top, l_paren);
+    return try call_expr.finish(p, func_qt, list_buf_top, l_paren, args_ok);
+}
+fn boundsSafetyCheckArrayAccess(p: *Parser, lhs: Result, rhs: Result, l_bracket: TokenIndex) !void {
+    if (!p.comp.hasClangStyleBoundsSafety()) return;
+    const ptr_res, const pointer, const index = if (lhs.qt.get(p.comp, .pointer)) |pointer| .{ lhs, pointer, rhs } else .{ rhs, rhs.qt.get(p.comp, .pointer).?, lhs };
+    switch (pointer.bounds) {
+        .c, .unsafe_indexable => {},
+        .single => {
+            if (!index.val.isZero(p.comp)) {
+                try p.err(l_bracket, .single_requires_zero_index, .{});
+                if (p.unwrapNestedOperation(ptr_res.node)) |unwrapped| {
+                    const name = p.tokSlice(unwrapped.name_tok);
+                    try p.issueBoundsDeclaredHereNote(unwrapped, name, pointer.bounds);
+                }
+            }
+        },
+    }
+}
+fn boundsSafetyCheckPointerArithmetic(p: *Parser, lhs: QualType, rhs: QualType, tok: TokenIndex, node: Tree.Node.Index) !void {
+    if (!p.comp.hasClangStyleBoundsSafety()) return;
+    const pointer = if (rhs.isInt(p.comp))
+        lhs.get(p.comp, .pointer) orelse return
+    else if (lhs.isInt(p.comp))
+        rhs.get(p.comp, .pointer) orelse return
+    else
+        return;
+    try p.checkPtrArithmeticAllowed(pointer, tok, node);
+}
+fn checkPtrArithmeticAllowed(p: *Parser, pointer: Type.Pointer, tok: TokenIndex, node: Tree.Node.Index) !void {
+    if (!p.comp.hasClangStyleBoundsSafety()) return;
+    switch (pointer.bounds) {
+        .c, .unsafe_indexable => {},
+        .single => {
+            // clang issues this diagnostic even with a constant `0` operand
+            try p.err(tok, .pointer_arith_single, .{});
+            if (p.unwrapNestedOperation(node)) |unwrapped| {
+                const name = p.tokSlice(unwrapped.name_tok);
+                try p.issueBoundsDeclaredHereNote(unwrapped, name, pointer.bounds);
+            }
+        },
+    }
 }
 fn checkArrayBounds(p: *Parser, index: Result, array: Result, tok: TokenIndex) !void {
+    try p.boundsSafetyCheckArrayAccess(array, index, tok);
     if (index.val.opt_ref == .none) return;
     const array_len = array.qt.arrayLen(p.comp) orelse return;
 @@ -9579,6 +9780,8 @@ fn primaryExpr(p: *Parser) Error!?Result {
                     .common => |tag| switch (tag) {
                         .__builtin_choose_expr => return try p.builtinChooseExpr(),
                         .__builtin_va_arg => return try p.builtinVaArg(name_tok),
+                        .__builtin_va_arg_pack => return try p.builtinVaArgPack(name_tok),
+                        .__builtin_va_arg_pack_len => return try p.builtinVaArgPackLen(name_tok),
                         .__builtin_offsetof => return try p.builtinOffsetof(name_tok, .bytes),
                         .__builtin_bitoffsetof => return try p.builtinOffsetof(name_tok, .bits),
                         .__builtin_types_compatible_p => return try p.typesCompatible(name_tok),
 @@ -9720,7 +9923,7 @@ fn primaryExpr(p: *Parser) Error!?Result {
                 qt = some.qt;
             } else if (p.func.qt) |func_qt| {
                 var sf = std.heap.stackFallback(1024, gpa);
-                var allocating: Io.Writer.Allocating = .init(sf.get());
+                var allocating: std.Io.Writer.Allocating = .init(sf.get());
                 defer allocating.deinit();
                 func_qt.printNamed(p.tokSlice(p.func.name), p.comp, &allocating.writer) catch return error.OutOfMemory;
 @@ -10277,16 +10480,13 @@ fn fixedSizeInt(p: *Parser, base: u8, buf: []const u8, suffix: NumberSuffix, tok
         if (res.qt.intRankOrder(suffix_qt, p.comp).compare(.lt)) continue;
         const max_int = try Value.maxInt(res.qt, p.comp);
         if (interned_val.compare(.lte, max_int, p.comp)) break;
-    } else {
+    } else switch (p.comp.langopts.emulate) {
-        if (p.comp.langopts.emulate == .gcc) {
+        .no, .gcc => if (p.comp.target.hasInt128()) {
-            if (p.comp.target.hasInt128()) {
+            res.qt = .int128;
-                res.qt = .int128;
-            } else {
-                res.qt = .long_long;
-            }
         } else {
-            res.qt = .ulong_long;
+            res.qt = .long_long;
-        }
+        },
+        .msvc, .clang => res.qt = .ulong_long,
     }
     res.node = try p.addNode(.{ .int_literal = .{ .qt = res.qt, .literal_tok = tok_i } });
 @@ -10604,12 +10804,7 @@ fn genericSelection(p: *Parser) Error!?Result {
 }
 test "Node locations" {
-    var arena_state: std.heap.ArenaAllocator = .init(std.testing.allocator);
+    var comp = try Compilation.init(.testing);
-    defer arena_state.deinit();
-    const arena = arena_state.allocator();
-    var diagnostics: Diagnostics = .{ .output = .ignore };
-    var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, &diagnostics, Io.Dir.cwd());
     defer comp.deinit();
     const file = try comp.addSourceFromBuffer("file.c",
 @@ -10621,7 +10816,7 @@ test "Node locations" {
     const builtin_macros = try comp.generateBuiltinMacros(.no_system_defines);
-    var pp = Preprocessor.init(&comp, .default);
+    var pp = try Preprocessor.init(&comp, .testing);
     defer pp.deinit();
     try pp.addBuiltinMacros();
 @@ -10633,7 +10828,6 @@ test "Node locations" {
     var tree = try Parser.parse(&pp);
     defer tree.deinit();
-    try std.testing.expectEqual(0, comp.diagnostics.total);
     for (tree.root_decls.items[tree.root_decls.items.len - 3 ..], 0..) |node, i| {
         const slice = tree.tokSlice(node.tok(&tree));
         const expected_slice = switch (i) {

lib/compiler/aro/aro/Parser/Diagnostic.zig+79-19

 @@ -79,9 +79,9 @@ pub const expected_integer_constant_expr: Diagnostic = .{
 };
 pub const missing_type_specifier: Diagnostic = .{
-    .fmt = "type specifier missing, defaults to 'int'",
+    .fmt = "type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int",
     .opt = .@"implicit-int",
-    .kind = .warning,
+    .kind = .@"error",
 };
 pub const missing_type_specifier_c23: Diagnostic = .{
 @@ -90,9 +90,9 @@ pub const missing_type_specifier_c23: Diagnostic = .{
 };
 pub const param_not_declared: Diagnostic = .{
-    .fmt = "parameter '{s}' was not declared, defaults to 'int'",
+    .fmt = "parameter '{s}' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int",
     .opt = .@"implicit-int",
-    .kind = .warning,
+    .kind = .@"error",
     .extension = true,
 };
 @@ -216,8 +216,13 @@ pub const illegal_storage_on_func: Diagnostic = .{
     .kind = .@"error",
 };
-pub const illegal_storage_on_global: Diagnostic = .{
+pub const auto_on_global: Diagnostic = .{
-    .fmt = "illegal storage class on global variable",
+    .fmt = "'auto' specified on global variable",
+    .kind = .@"error",
+};
+pub const register_on_global: Diagnostic = .{
+    .fmt = "register name not specified for global variable",
     .kind = .@"error",
 };
 @@ -1507,13 +1512,38 @@ pub const builtin_must_be_called: Diagnostic = .{
     .kind = .@"error",
 };
-pub const va_start_not_in_func: Diagnostic = .{
+pub const va_func_not_in_func: Diagnostic = .{
-    .fmt = "'va_start' cannot be used outside a function",
+    .fmt = "'{s}' cannot be used outside a function",
+    .kind = .@"error",
+};
+pub const va_func_fixed_args: Diagnostic = .{
+    .fmt = "'{s}' used in a function with fixed args",
+    .kind = .@"error",
+};
+pub const va_func_not_always_inline: Diagnostic = .{
+    .fmt = "'{s}' used in a function that is not always inlined",
+    .kind = .@"error",
+};
+pub const va_pack_non_call: Diagnostic = .{
+    .fmt = "'__va_arg_pack' used outside a call",
+    .kind = .@"error",
+};
+pub const va_pack_non_variadic_call: Diagnostic = .{
+    .fmt = "'__va_arg_pack' passed to non-variadic function",
+    .kind = .@"error",
+};
+pub const va_pack_non_variadic_arg: Diagnostic = .{
+    .fmt = "'__va_arg_pack' passed as non-variadic argument",
     .kind = .@"error",
 };
-pub const va_start_fixed_args: Diagnostic = .{
+pub const va_pack_non_final_arg: Diagnostic = .{
-    .fmt = "'va_start' used in a function with fixed args",
+    .fmt = "'__va_arg_pack' is not the final argument",
     .kind = .@"error",
 };
 @@ -2258,11 +2288,11 @@ pub const unterminated_char_literal_error: Diagnostic = .{
     .kind = .@"error",
 };
-// pub const def_no_proto_deprecated: Diagnostic = .{
+pub const def_no_proto_deprecated: Diagnostic = .{
-//     .fmt = "a function definition without a prototype is deprecated in all versions of C and is not supported in C23",
+    .fmt = "a function definition without a prototype is deprecated in all versions of C and is not supported in C23",
-//     .kind = .warning,
+    .kind = .warning,
-//     .opt = .@"deprecated-non-prototype",
+    .opt = .@"deprecated-non-prototype",
-// };
+};
 pub const passing_args_to_kr: Diagnostic = .{
     .fmt = "passing arguments to a function without a prototype is deprecated in all versions of C and is not supported in C23",
 @@ -2296,6 +2326,11 @@ pub const invalid_compound_literal_storage_class: Diagnostic = .{
     .kind = .@"error",
 };
+pub const register_on_global_compound_literal: Diagnostic = .{
+    .fmt = "file scope compound literal specifies 'register'",
+    .kind = .@"error",
+};
 pub const identifier_not_normalized: Diagnostic = .{
     .fmt = "'{normalized}' is not in NFC",
     .kind = .warning,
 @@ -2465,10 +2500,9 @@ pub const declared_const_here: Diagnostic = .{
     .kind = .note,
 };
-pub const nonnull_not_applicable: Diagnostic = .{
+pub const pointer_bounds_declared_here: Diagnostic = .{
-    .fmt = "'nonnull' attribute only applies to functions, methods, and parameters",
+    .fmt = "pointer '{s}' declared {s} here",
-    .kind = .warning,
+    .kind = .note,
-    .opt = .@"ignored-attributes",
 };
 pub const mixing_decimal_floats: Diagnostic = .{
 @@ -2480,3 +2514,29 @@ pub const invalid_attribute_location: Diagnostic = .{
     .fmt = "{s} cannot appear here",
     .kind = .@"error",
 };
+pub const attribute_requires_pointer: Diagnostic = .{
+    .fmt = "'{s}' attribute only applies to pointer arguments",
+    .kind = .@"error",
+};
+pub const single_requires_zero_index: Diagnostic = .{
+    .fmt = "array subscript on single pointer must use a constant index of 0 to be in bounds",
+    .kind = .@"error",
+};
+pub const pointer_arith_single: Diagnostic = .{
+    .fmt = "pointer arithmetic on single pointer is out of bounds; consider adding '__counted_by'",
+    .kind = .@"error",
+};
+pub const redundant_bounds_annotation: Diagnostic = .{
+    .fmt = "pointer annotated with {s} multiple times. Annotate only once to remove this warning",
+    .kind = .warning,
+    .opt = .@"bounds-attributes-redundant",
+};
+pub const multiple_bounds_annotations: Diagnostic = .{
+    .fmt = "pointer cannot have more than one bound attribute",
+    .kind = .@"error",
+};

lib/compiler/aro/aro/Preprocessor.zig+127-56

...	@@ -1,6 +1,6 @@	...	@@ -1,6 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2	const Io = std.Io;
3	const mem = std.mem;	2	const mem = std.mem;
		3	const path = std.Io.Dir.path;
4	const Allocator = mem.Allocator;	4	const Allocator = mem.Allocator;
5	const assert = std.debug.assert;	5	const assert = std.debug.assert;
6		6
...	@@ -79,12 +79,15 @@ pub const Macro = struct {	...	@@ -79,12 +79,15 @@ pub const Macro = struct {
79	});	79	});
80		80
81	const Object = enum {	81	const Object = enum {
		82	base_file,
82	file,	83	file,
		84	file_basename,
83	line,	85	line,
84	counter,	86	counter,
85	date,	87	date,
86	time,	88	time,
87	timestamp,	89	timestamp,
		90	include_level,
88	};	91	};
89		92
90	const Func = enum {	93	const Func = enum {
...	@@ -216,8 +219,6 @@ pub const Macro = struct {	...	@@ -216,8 +219,6 @@ pub const Macro = struct {
216	}	219	}
217	};	220	};
218		221
219	const Preprocessor = @This();
220
221	const ExpansionEntry = struct {	222	const ExpansionEntry = struct {
222	idx: Tree.TokenIndex,	223	idx: Tree.TokenIndex,
223	locs: [*]Source.Location,	224	locs: [*]Source.Location,
...	@@ -228,6 +229,8 @@ const TokenState = struct {	...	@@ -228,6 +229,8 @@ const TokenState = struct {
228	expansion_entries_len: usize,	229	expansion_entries_len: usize,
229	};	230	};
230		231
		232	const Preprocessor = @This();
		233
231	comp: *Compilation,	234	comp: *Compilation,
232	diagnostics: *Diagnostics,	235	diagnostics: *Diagnostics,
233		236
...	@@ -275,6 +278,12 @@ m_times: std.AutoHashMapUnmanaged(Source.Id, u64) = .empty,	...	@@ -275,6 +278,12 @@ m_times: std.AutoHashMapUnmanaged(Source.Id, u64) = .empty,
275	/// The dependency file tracking all includes and embeds.	278	/// The dependency file tracking all includes and embeds.
276	dep_file: ?*DepFile = null,	279	dep_file: ?*DepFile = null,
277		280
		281	/// Path prefixes to replace when expanding __FILE__
		282	path_replacements: []const struct { []const u8, []const u8 } = &.{},
		283
		284	/// File used for __BASE_FILE__ macro.
		285	base_file: Source.Id,
		286
278	pub const parse = Parser.parse;	287	pub const parse = Parser.parse;
279		288
280	pub const Linemarkers = enum {	289	pub const Linemarkers = enum {
...	@@ -286,21 +295,22 @@ pub const Linemarkers = enum {	...	@@ -286,21 +295,22 @@ pub const Linemarkers = enum {
286	numeric_directives,	295	numeric_directives,
287	};	296	};
288		297
289	pub fn init(comp: *Compilation, source_epoch: SourceEpoch) Preprocessor {	298	pub const InitOptions = struct {
290	const pp: Preprocessor = .{	299	base_file: Source.Id,
291	.comp = comp,	300
292	.diagnostics = comp.diagnostics,	301	source_epoch: ?SourceEpoch = null,
293	.arena = .init(comp.gpa),	302	add_builtin_macros: bool = true,
294	.hideset = .{ .comp = comp },	303	path_replacements: []const struct { []const u8, []const u8 } = &.{},
295	.source_epoch = source_epoch,	304
		305	pub const testing: InitOptions = .{
		306	.base_file = undefined,
		307	.source_epoch = .default,
		308	.add_builtin_macros = false,
296	};	309	};
297	comp.pragmaEvent(.before_preprocess);	310	};
298	return pp;
299	}
300		311
301	/// Initialize Preprocessor with builtin macros.	312	pub fn init(comp: *Compilation, options: InitOptions) !Preprocessor {
302	pub fn initDefault(comp: *Compilation) !Preprocessor {	313	const source_epoch: SourceEpoch = options.source_epoch orelse comp.environment.sourceEpoch(comp.io) catch \|er\| switch (er) {
303	const source_epoch: SourceEpoch = comp.environment.sourceEpoch(comp.io) catch \|er\| switch (er) {
304	error.InvalidEpoch => blk: {	314	error.InvalidEpoch => blk: {
305	const diagnostic: Diagnostic = .invalid_source_epoch;	315	const diagnostic: Diagnostic = .invalid_source_epoch;
306	try comp.diagnostics.add(.{ .text = diagnostic.fmt, .kind = diagnostic.kind, .opt = diagnostic.opt, .location = null });	316	try comp.diagnostics.add(.{ .text = diagnostic.fmt, .kind = diagnostic.kind, .opt = diagnostic.opt, .location = null });
...	@@ -308,9 +318,18 @@ pub fn initDefault(comp: *Compilation) !Preprocessor {	...	@@ -308,9 +318,18 @@ pub fn initDefault(comp: *Compilation) !Preprocessor {
308	},	318	},
309	};	319	};
310		320
311	var pp = init(comp, source_epoch);	321	var pp: Preprocessor = .{
		322	.comp = comp,
		323	.diagnostics = comp.diagnostics,
		324	.arena = .init(comp.gpa),
		325	.hideset = .{ .comp = comp },
		326	.source_epoch = source_epoch,
		327	.base_file = options.base_file,
		328	.path_replacements = options.path_replacements,
		329	};
312	errdefer pp.deinit();	330	errdefer pp.deinit();
313	try pp.addBuiltinMacros();	331	comp.pragmaEvent(.before_preprocess);
		332	if (options.add_builtin_macros) try pp.addBuiltinMacros();
314	return pp;	333	return pp;
315	}	334	}
316		335
...	@@ -339,7 +358,7 @@ pub fn addBuiltinMacros(pp: *Preprocessor) !void {	...	@@ -339,7 +358,7 @@ pub fn addBuiltinMacros(pp: *Preprocessor) !void {
339	try pp.addBuiltinMacro("__is_identifier", .{ .func = .is_identifier });	358	try pp.addBuiltinMacro("__is_identifier", .{ .func = .is_identifier });
340	try pp.addBuiltinMacro("_Pragma", .{ .func = .pragma_operator });	359	try pp.addBuiltinMacro("_Pragma", .{ .func = .pragma_operator });
341		360
342	if (pp.comp.langopts.emulate == .clang) {	361	if (pp.comp.langopts.emulate == .no or pp.comp.langopts.emulate == .clang) {
343	try pp.addBuiltinMacro("__is_target_arch", .{ .func = .is_target_arch });	362	try pp.addBuiltinMacro("__is_target_arch", .{ .func = .is_target_arch });
344	try pp.addBuiltinMacro("__is_target_vendor", .{ .func = .is_target_vendor });	363	try pp.addBuiltinMacro("__is_target_vendor", .{ .func = .is_target_vendor });
345	try pp.addBuiltinMacro("__is_target_os", .{ .func = .is_target_os });	364	try pp.addBuiltinMacro("__is_target_os", .{ .func = .is_target_os });
...	@@ -359,6 +378,12 @@ pub fn addBuiltinMacros(pp: *Preprocessor) !void {	...	@@ -359,6 +378,12 @@ pub fn addBuiltinMacros(pp: *Preprocessor) !void {
359	try pp.addBuiltinMacro("__DATE__", .{ .obj = .date });	378	try pp.addBuiltinMacro("__DATE__", .{ .obj = .date });
360	try pp.addBuiltinMacro("__TIME__", .{ .obj = .time });	379	try pp.addBuiltinMacro("__TIME__", .{ .obj = .time });
361	try pp.addBuiltinMacro("__TIMESTAMP__", .{ .obj = .timestamp });	380	try pp.addBuiltinMacro("__TIMESTAMP__", .{ .obj = .timestamp });
		381
		382	if (pp.comp.langopts.emulate == .no or pp.comp.langopts.emulate == .clang) {
		383	try pp.addBuiltinMacro("__BASE_FILE__", .{ .obj = .base_file });
		384	try pp.addBuiltinMacro("__FILE_NAME__", .{ .obj = .file_basename });
		385	try pp.addBuiltinMacro("__INCLUDE_LEVEL__", .{ .obj = .include_level });
		386	}
362	}	387	}
363		388
364	pub fn deinit(pp: *Preprocessor) void {	389	pub fn deinit(pp: *Preprocessor) void {
...	@@ -395,7 +420,7 @@ fn mTime(pp: *Preprocessor, source_id: Source.Id) !u64 {	...	@@ -395,7 +420,7 @@ fn mTime(pp: *Preprocessor, source_id: Source.Id) !u64 {
395	return gop.value_ptr.*;	420	return gop.value_ptr.*;
396	}	421	}
397		422
398	pub fn expansionSlice(pp: *Preprocessor, tok: Tree.TokenIndex) []Source.Location {	423	pub fn expansionSlice(pp: *const Preprocessor, tok: Tree.TokenIndex) []Source.Location {
399	const S = struct {	424	const S = struct {
400	fn orderTokenIndex(context: Tree.TokenIndex, item: Tree.TokenIndex) std.math.Order {	425	fn orderTokenIndex(context: Tree.TokenIndex, item: Tree.TokenIndex) std.math.Order {
401	return std.math.order(context, item);	426	return std.math.order(context, item);
...	@@ -1065,13 +1090,11 @@ fn fatalNotFound(pp: *Preprocessor, tok: TokenWithExpansionLocs, filename: []con	...	@@ -1065,13 +1090,11 @@ fn fatalNotFound(pp: *Preprocessor, tok: TokenWithExpansionLocs, filename: []con
1065		1090
1066	fn verboseLog(pp: *Preprocessor, raw: RawToken, comptime fmt: []const u8, args: anytype) void {	1091	fn verboseLog(pp: *Preprocessor, raw: RawToken, comptime fmt: []const u8, args: anytype) void {
1067	@branchHint(.cold);	1092	@branchHint(.cold);
1068	const comp = pp.comp;	1093	const source = pp.comp.getSource(raw.source);
1069	const io = comp.io;
1070	const source = comp.getSource(raw.source);
1071	const line_col = source.lineCol(.{ .id = raw.source, .line = raw.line, .byte_offset = raw.start });	1094	const line_col = source.lineCol(.{ .id = raw.source, .line = raw.line, .byte_offset = raw.start });
1072		1095
1073	var stderr_buf: [4096]u8 = undefined;	1096	var stderr_buf: [4096]u8 = undefined;
1074	var stderr = Io.File.stderr().writer(io, &stderr_buf);	1097	var stderr = std.Io.File.stderr().writer(pp.comp.io, &stderr_buf);
1075	const w = &stderr.interface;	1098	const w = &stderr.interface;
1076		1099
1077	w.print("{s}:{d}:{d}: ", .{ source.path, line_col.line_no, line_col.col }) catch return;	1100	w.print("{s}:{d}:{d}: ", .{ source.path, line_col.line_no, line_col.col }) catch return;
...	@@ -1435,7 +1458,37 @@ fn expandObjMacro(pp: Preprocessor, simple_macro: const Macro) Error!ExpandBuf	...	@@ -1435,7 +1458,37 @@ fn expandObjMacro(pp: Preprocessor, simple_macro: const Macro) Error!ExpandBuf
1435	.file => {	1458	.file => {
1436	const start = pp.comp.generated_buf.items.len;	1459	const start = pp.comp.generated_buf.items.len;
1437	const source = pp.comp.getSource(pp.expansion_source_loc.id);	1460	const source = pp.comp.getSource(pp.expansion_source_loc.id);
1438	try pp.comp.generated_buf.print(gpa, "\"{f}\"\n", .{fmtEscapes(source.path)});	1461	for (pp.path_replacements) \|replacement\| {
		1462	if (mem.cutPrefix(u8, source.path, replacement[0])) \|rest\| {
		1463	try pp.comp.generated_buf.print(gpa, "\"{f}{f}\"", .{ fmtEscapes(replacement[1]), fmtEscapes(rest) });
		1464	break;
		1465	}
		1466	} else {
		1467	try pp.comp.generated_buf.print(gpa, "\"{f}\"\n", .{fmtEscapes(source.path)});
		1468	}
		1469
		1470	buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));
		1471	},
		1472	.base_file => {
		1473	try pp.err(pp.expansion_source_loc, .base_file_is_clang_extension, .{});
		1474	const start = pp.comp.generated_buf.items.len;
		1475	const base_file = pp.comp.getSource(pp.base_file);
		1476	for (pp.path_replacements) \|replacement\| {
		1477	if (mem.cutPrefix(u8, base_file.path, replacement[0])) \|rest\| {
		1478	try pp.comp.generated_buf.print(gpa, "\"{f}{f}\"", .{ fmtEscapes(replacement[1]), fmtEscapes(rest) });
		1479	}
		1480	} else {
		1481	try pp.comp.generated_buf.print(gpa, "\"{f}\"", .{fmtEscapes(base_file.path)});
		1482	}
		1483
		1484	buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));
		1485	},
		1486	.file_basename => {
		1487	try pp.err(pp.expansion_source_loc, .file_name_is_clang_extension, .{});
		1488	const start = pp.comp.generated_buf.items.len;
		1489	const source = pp.comp.getSource(pp.expansion_source_loc.id);
		1490	const basename = path.basename(source.path);
		1491	try pp.comp.generated_buf.print(gpa, "\"{f}\"", .{fmtEscapes(basename)});
1439		1492
1440	buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));	1493	buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));
1441	},	1494	},
...	@@ -1472,6 +1525,13 @@ fn expandObjMacro(pp: Preprocessor, simple_macro: const Macro) Error!ExpandBuf	...	@@ -1472,6 +1525,13 @@ fn expandObjMacro(pp: Preprocessor, simple_macro: const Macro) Error!ExpandBuf
1472	try pp.writeDateTimeStamp(.fromBuiltin(builtin_kind), timestamp);	1525	try pp.writeDateTimeStamp(.fromBuiltin(builtin_kind), timestamp);
1473	buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));	1526	buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));
1474	},	1527	},
		1528	.include_level => {
		1529	try pp.err(pp.expansion_source_loc, .include_level_is_clang_extension, .{});
		1530	const start = pp.comp.generated_buf.items.len;
		1531	try pp.comp.generated_buf.print(gpa, "{d}\n", .{pp.include_depth});
		1532
		1533	buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .pp_num, tok));
		1534	},
1475	},	1535	},
1476	else => buf.appendAssumeCapacity(tok),	1536	else => buf.appendAssumeCapacity(tok),
1477	}	1537	}
...	@@ -1828,7 +1888,11 @@ fn handleBuiltinMacro(pp: *Preprocessor, builtin: Macro.Builtin.Func, param_toks	...	@@ -1828,7 +1888,11 @@ fn handleBuiltinMacro(pp: *Preprocessor, builtin: Macro.Builtin.Func, param_toks
1828	features.hasFeature(pp.comp, ident_str)	1888	features.hasFeature(pp.comp, ident_str)
1829	else	1889	else
1830	features.hasExtension(pp.comp, ident_str),	1890	features.hasExtension(pp.comp, ident_str),
1831	.has_builtin => Builtins.fromName(pp.comp, ident_str) != null or (pp.comp.langopts.emulate == .clang and Macro.Builtin.has_builtin_special_cases.has(ident_str)),	1891
		1892	.has_builtin => Builtins.fromName(pp.comp, ident_str) != null or
		1893	((pp.comp.langopts.emulate == .no or pp.comp.langopts.emulate == .clang) and
		1894	Macro.Builtin.has_builtin_special_cases.has(ident_str)),
		1895
1832	.is_target_arch => pp.comp.isTargetArch(ident_str),	1896	.is_target_arch => pp.comp.isTargetArch(ident_str),
1833	.is_target_os => pp.comp.isTargetOs(ident_str),	1897	.is_target_os => pp.comp.isTargetOs(ident_str),
1834	.is_target_vendor => pp.comp.isTargetVendor(ident_str),	1898	.is_target_vendor => pp.comp.isTargetVendor(ident_str),
...	@@ -1972,7 +2036,7 @@ fn expandFuncMacro(	...	@@ -1972,7 +2036,7 @@ fn expandFuncMacro(
1972	},	2036	},
1973	.macro_param_no_expand => {	2037	.macro_param_no_expand => {
1974	if (tok_i + 1 < func_macro.tokens.len and func_macro.tokens[tok_i + 1].id == .hash_hash) {	2038	if (tok_i + 1 < func_macro.tokens.len and func_macro.tokens[tok_i + 1].id == .hash_hash) {
1975	hideset = pp.hideset.get(tokFromRaw(func_macro.tokens[tok_i + 1]).loc);	2039	hideset = .none;
1976	}	2040	}
1977	const slice = getPasteArgs(args.items[raw.end]);	2041	const slice = getPasteArgs(args.items[raw.end]);
1978	const raw_loc = Source.Location{ .id = raw.source, .byte_offset = raw.start, .line = raw.line };	2042	const raw_loc = Source.Location{ .id = raw.source, .byte_offset = raw.start, .line = raw.line };
...	@@ -1980,7 +2044,7 @@ fn expandFuncMacro(	...	@@ -1980,7 +2044,7 @@ fn expandFuncMacro(
1980	},	2044	},
1981	.macro_param => {	2045	.macro_param => {
1982	if (tok_i + 1 < func_macro.tokens.len and func_macro.tokens[tok_i + 1].id == .hash_hash) {	2046	if (tok_i + 1 < func_macro.tokens.len and func_macro.tokens[tok_i + 1].id == .hash_hash) {
1983	hideset = pp.hideset.get(tokFromRaw(func_macro.tokens[tok_i + 1]).loc);	2047	hideset = .none;
1984	}	2048	}
1985	const arg = expanded_args.items[raw.end];	2049	const arg = expanded_args.items[raw.end];
1986	const raw_loc = Source.Location{ .id = raw.source, .byte_offset = raw.start, .line = raw.line };	2050	const raw_loc = Source.Location{ .id = raw.source, .byte_offset = raw.start, .line = raw.line };
...	@@ -2330,9 +2394,10 @@ fn expandFuncMacro(	...	@@ -2330,9 +2394,10 @@ fn expandFuncMacro(
2330	for (buf.items) \|*tok\| {	2394	for (buf.items) \|*tok\| {
2331	try tok.addExpansionLocation(gpa, &.{macro_tok.loc});	2395	try tok.addExpansionLocation(gpa, &.{macro_tok.loc});
2332	try tok.addExpansionLocation(gpa, macro_expansion_locs);	2396	try tok.addExpansionLocation(gpa, macro_expansion_locs);
2333	const tok_hidelist = pp.hideset.get(tok.loc);	2397	if (tok.id.shouldTrackHideset(.func)) {
2334	const new_hidelist = try pp.hideset.@"union"(tok_hidelist, hideset);	2398	const new_hideset = try pp.hideset.@"union"(pp.hideset.get(tok.loc), hideset);
2335	try pp.hideset.put(tok.loc, new_hidelist);	2399	try pp.hideset.put(tok.loc, new_hideset);
		2400	}
2336	}	2401	}
2337		2402
2338	return buf;	2403	return buf;
...	@@ -2698,9 +2763,10 @@ fn expandMacroExhaustive(	...	@@ -2698,9 +2763,10 @@ fn expandMacroExhaustive(
2698	try tok.addExpansionLocation(gpa, &.{macro_tok.loc});	2763	try tok.addExpansionLocation(gpa, &.{macro_tok.loc});
2699	try tok.addExpansionLocation(gpa, macro_expansion_locs);	2764	try tok.addExpansionLocation(gpa, macro_expansion_locs);
2700		2765
2701	const tok_hidelist = pp.hideset.get(tok.loc);	2766	if (tok.id.shouldTrackHideset(.obj)) {
2702	const new_hidelist = try pp.hideset.@"union"(tok_hidelist, hs);	2767	const new_hideset = try pp.hideset.@"union"(pp.hideset.get(tok.loc), hs);
2703	try pp.hideset.put(tok.loc, new_hidelist);	2768	try pp.hideset.put(tok.loc, new_hideset);
		2769	}
2704		2770
2705	if (tok.id == .keyword_defined and eval_ctx == .expr) {	2771	if (tok.id == .keyword_defined and eval_ctx == .expr) {
2706	if (macro.is_func) {	2772	if (macro.is_func) {
...	@@ -2914,7 +2980,10 @@ fn pasteTokens(pp: Preprocessor, lhs_toks: ExpandBuf, rhs_toks: []const TokenW	...	@@ -2914,7 +2980,10 @@ fn pasteTokens(pp: Preprocessor, lhs_toks: ExpandBuf, rhs_toks: []const TokenW
2914	.placemarker	2980	.placemarker
2915	else	2981	else
2916	pasted_token.id;	2982	pasted_token.id;
2917	try lhs_toks.append(gpa, try pp.makeGeneratedToken(start, pasted_id, lhs));	2983
		2984	const hideset = try pp.hideset.intersection(pp.hideset.get(lhs.loc), pp.hideset.get(rhs.loc));
		2985	const generated_token = try pp.makeGeneratedTokenExtra(start, pasted_id, lhs, hideset);
		2986	try lhs_toks.append(gpa, generated_token);
2918		2987
2919	if (next.id != .nl and next.id != .eof) {	2988	if (next.id != .nl and next.id != .eof) {
2920	try pp.err(lhs, .pasting_formed_invalid, .{pp.comp.generated_buf.items[start..end]});	2989	try pp.err(lhs, .pasting_formed_invalid, .{pp.comp.generated_buf.items[start..end]});
...	@@ -2924,7 +2993,7 @@ fn pasteTokens(pp: Preprocessor, lhs_toks: ExpandBuf, rhs_toks: []const TokenW	...	@@ -2924,7 +2993,7 @@ fn pasteTokens(pp: Preprocessor, lhs_toks: ExpandBuf, rhs_toks: []const TokenW
2924	try bufCopyTokens(gpa, lhs_toks, rhs_toks[rhs_rest..], &.{});	2993	try bufCopyTokens(gpa, lhs_toks, rhs_toks[rhs_rest..], &.{});
2925	}	2994	}
2926		2995
2927	fn makeGeneratedToken(pp: *Preprocessor, start: usize, id: Token.Id, source: TokenWithExpansionLocs) !TokenWithExpansionLocs {	2996	fn makeGeneratedTokenExtra(pp: *Preprocessor, start: usize, id: Token.Id, source: TokenWithExpansionLocs, hideset: Hideset.Index) !TokenWithExpansionLocs {
2928	const gpa = pp.comp.gpa;	2997	const gpa = pp.comp.gpa;
2929	var pasted_token = TokenWithExpansionLocs{ .id = id, .loc = .{	2998	var pasted_token = TokenWithExpansionLocs{ .id = id, .loc = .{
2930	.id = .generated,	2999	.id = .generated,
...	@@ -2934,9 +3003,15 @@ fn makeGeneratedToken(pp: *Preprocessor, start: usize, id: Token.Id, source: Tok	...	@@ -2934,9 +3003,15 @@ fn makeGeneratedToken(pp: *Preprocessor, start: usize, id: Token.Id, source: Tok
2934	pp.generated_line += 1;	3003	pp.generated_line += 1;
2935	try pasted_token.addExpansionLocation(gpa, &.{source.loc});	3004	try pasted_token.addExpansionLocation(gpa, &.{source.loc});
2936	try pasted_token.addExpansionLocation(gpa, source.expansionSlice());	3005	try pasted_token.addExpansionLocation(gpa, source.expansionSlice());
		3006	try pp.hideset.put(pasted_token.loc, hideset);
		3007
2937	return pasted_token;	3008	return pasted_token;
2938	}	3009	}
2939		3010
		3011	fn makeGeneratedToken(pp: *Preprocessor, start: usize, id: Token.Id, source: TokenWithExpansionLocs) !TokenWithExpansionLocs {
		3012	return pp.makeGeneratedTokenExtra(start, id, source, pp.hideset.get(source.loc));
		3013	}
		3014
2940	/// Defines a new macro and warns if it is a duplicate	3015	/// Defines a new macro and warns if it is a duplicate
2941	fn defineMacro(pp: *Preprocessor, define_tok: RawToken, name_tok: TokenWithExpansionLocs, macro: Macro) Error!void {	3016	fn defineMacro(pp: *Preprocessor, define_tok: RawToken, name_tok: TokenWithExpansionLocs, macro: Macro) Error!void {
2942	const name_str = pp.expandedSlice(name_tok);	3017	const name_str = pp.expandedSlice(name_tok);
...	@@ -3898,16 +3973,14 @@ test "Preserve pragma tokens sometimes" {	...	@@ -3898,16 +3973,14 @@ test "Preserve pragma tokens sometimes" {
3898	const gpa = std.testing.allocator;	3973	const gpa = std.testing.allocator;
3899	const Test = struct {	3974	const Test = struct {
3900	fn runPreprocessor(source_text: []const u8) ![]const u8 {	3975	fn runPreprocessor(source_text: []const u8) ![]const u8 {
3901	var arena: std.heap.ArenaAllocator = .init(gpa);
3902	defer arena.deinit();
3903
3904	var diagnostics: Diagnostics = .{ .output = .ignore };	3976	var diagnostics: Diagnostics = .{ .output = .ignore };
3905	var comp = Compilation.init(gpa, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());	3977	var comp = try Compilation.init(.testing);
		3978	comp.diagnostics = &diagnostics;
3906	defer comp.deinit();	3979	defer comp.deinit();
3907		3980
3908	try comp.addDefaultPragmaHandlers();	3981	try comp.addDefaultPragmaHandlers();
3909		3982
3910	var pp = Preprocessor.init(&comp, .default);	3983	var pp = try Preprocessor.init(&comp, .testing);
3911	defer pp.deinit();	3984	defer pp.deinit();
3912		3985
3913	pp.preserve_whitespace = true;	3986	pp.preserve_whitespace = true;
...	@@ -3966,12 +4039,10 @@ test "destringify" {	...	@@ -3966,12 +4039,10 @@ test "destringify" {
3966	try std.testing.expectEqualStrings(destringified, pp.char_buf.items);	4039	try std.testing.expectEqualStrings(destringified, pp.char_buf.items);
3967	}	4040	}
3968	};	4041	};
3969	var arena: std.heap.ArenaAllocator = .init(gpa);	4042	var comp = try Compilation.init(.testing);
3970	defer arena.deinit();
3971	var diagnostics: Diagnostics = .{ .output = .ignore };
3972	var comp = Compilation.init(gpa, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());
3973	defer comp.deinit();	4043	defer comp.deinit();
3974	var pp = Preprocessor.init(&comp, .default);	4044
		4045	var pp = try Preprocessor.init(&comp, .testing);
3975	defer pp.deinit();	4046	defer pp.deinit();
3976		4047
3977	try Test.testDestringify(&pp, "hello\tworld\n", "hello\tworld\n");	4048	try Test.testDestringify(&pp, "hello\tworld\n", "hello\tworld\n");
...	@@ -4026,20 +4097,20 @@ test "Include guards" {	...	@@ -4026,20 +4097,20 @@ test "Include guards" {
4026	};	4097	};
4027	}	4098	}
4028		4099
4029	fn testIncludeGuard(gpa: std.mem.Allocator, comptime template: []const u8, tok_id: RawToken.Id, expected_guards: u32) !void {	4100	fn testIncludeGuard(comptime template: []const u8, tok_id: RawToken.Id, expected_guards: u32) !void {
4030	var arena_state: std.heap.ArenaAllocator = .init(gpa);	4101	const gpa = std.testing.allocator;
4031	defer arena_state.deinit();
4032	const arena = arena_state.allocator();
4033		4102
4034	var diagnostics: Diagnostics = .{ .output = .ignore };	4103	var diagnostics: Diagnostics = .{ .output = .ignore };
4035	var comp = Compilation.init(gpa, arena, std.testing.io, &diagnostics, Io.Dir.cwd());	4104	var comp = try Compilation.init(.testing);
		4105	comp.diagnostics = &diagnostics;
4036	defer comp.deinit();	4106	defer comp.deinit();
4037	var pp = Preprocessor.init(&comp, .default);	4107	var pp = try Preprocessor.init(&comp, .testing);
4038	defer pp.deinit();	4108	defer pp.deinit();
4039		4109
4040	const path = try std.fs.path.join(arena, &.{ ".", "bar.h" });	4110	const file_path = try path.join(gpa, &.{ ".", "bar.h" });
		4111	defer gpa.free(file_path);
4041		4112
4042	_ = try comp.addSourceFromBuffer(path, "int bar = 5;\n");	4113	_ = try comp.addSourceFromBuffer(file_path, "int bar = 5;\n");
4043		4114
4044	var buf: std.ArrayList(u8) = .empty;	4115	var buf: std.ArrayList(u8) = .empty;
4045	defer buf.deinit(gpa);	4116	defer buf.deinit(gpa);
...	@@ -4074,14 +4145,14 @@ test "Include guards" {	...	@@ -4074,14 +4145,14 @@ test "Include guards" {
4074	\\#endif	4145	\\#endif
4075	;	4146	;
4076	const expected_guards: u32 = if (Test.pairsWithIfndef(tag)) 0 else 1;	4147	const expected_guards: u32 = if (Test.pairsWithIfndef(tag)) 0 else 1;
4077	try Test.testIncludeGuard(std.testing.allocator, inside_ifndef_template, tag, expected_guards);	4148	try Test.testIncludeGuard(inside_ifndef_template, tag, expected_guards);
4078		4149
4079	const outside_ifndef_template =	4150	const outside_ifndef_template =
4080	\\#ifndef FOO	4151	\\#ifndef FOO
4081	\\#endif	4152	\\#endif
4082	\\#{s}{s}	4153	\\#{s}{s}
4083	;	4154	;
4084	try Test.testIncludeGuard(std.testing.allocator, outside_ifndef_template, tag, 0);	4155	try Test.testIncludeGuard(outside_ifndef_template, tag, 0);
4085	}	4156	}
4086	}	4157	}
4087	}	4158	}

lib/compiler/aro/aro/Preprocessor/Diagnostic.zig+21

...	@@ -472,3 +472,24 @@ pub const pragma_once_in_main_file: Diagnostic = .{	...	@@ -472,3 +472,24 @@ pub const pragma_once_in_main_file: Diagnostic = .{
472	.kind = .warning,	472	.kind = .warning,
473	.opt = .@"pragma-once-outside-header",	473	.opt = .@"pragma-once-outside-header",
474	};	474	};
		475
		476	pub const file_name_is_clang_extension: Diagnostic = .{
		477	.fmt = "__FILE_NAME__ is a clang extension",
		478	.opt = .@"file-name-extension",
		479	.kind = .off,
		480	.extension = true,
		481	};
		482
		483	pub const base_file_is_clang_extension: Diagnostic = .{
		484	.fmt = "__BASE_FILE__ is a clang extension",
		485	.opt = .@"base-file-extension",
		486	.kind = .off,
		487	.extension = true,
		488	};
		489
		490	pub const include_level_is_clang_extension: Diagnostic = .{
		491	.fmt = "__INCLUDE_LEVEL__ is a clang extension",
		492	.opt = .@"include-level-extension",
		493	.kind = .off,
		494	.extension = true,
		495	};

lib/compiler/aro/aro/Target.zig+17-12

 @@ -229,7 +229,7 @@ pub fn intMaxType(target: *const Target) QualType {
         => return .long,
         .x86_64 => switch (target.os.tag) {
-            .windows, .openbsd => {},
+            .windows, .openbsd, .uefi => {},
             else => switch (target.abi) {
                 .gnux32, .muslx32 => {},
                 else => return .long,
 @@ -546,18 +546,10 @@ pub fn systemCompiler(target: *const Target) LangOpts.Compiler {
 }
 pub fn hasFloat128(target: *const Target) bool {
-    if (target.cpu.arch.isWasm()) return true;
     if (target.os.tag.isDarwin()) return false;
-    if (target.cpu.arch.isPowerPC()) return std.Target.powerpc.featureSetHas(target.cpu.features, .float128);
+    if (target.os.tag == .windows) return false;
-    return switch (target.os.tag) {
+    if (target.cpu.arch.isX86()) return true;
-        .dragonfly,
+    return target.cTypeBitSize(.longdouble) == 128;
-        .haiku,
-        .linux,
-        .openbsd,
-        .illumos,
-        => target.cpu.arch.isX86(),
-        else => false,
-    };
 }
 pub fn hasInt128(target: *const Target) bool {
 @@ -1238,6 +1230,7 @@ pub fn toLLVMTriple(target: *const Target, buf: []u8) []const u8 {
         .other,
         .plan9,
         .vita,
+        .psp,
         => "unknown",
     };
     writer.writeAll(llvm_os) catch unreachable;
 @@ -1356,6 +1349,18 @@ pub fn isPIEDefault(target: *const Target) DefaultPIStatus {
     };
 }
+pub fn ppcElfVersion(target: *const Target) u32 {
+    std.debug.assert(target.cpu.arch.isPowerPC());
+    return switch (target.cpu.arch) {
+        .powerpc64le => 2,
+        .powerpc64 => if ((target.os.isAtLeast(.freebsd, .{ .major = 13, .minor = 0, .patch = 0 }) orelse false) or target.os.tag == .openbsd or target.abi.isMusl())
+            2
+        else
+            1,
+        else => 1,
+    };
+}
 pub fn isPICdefault(target: *const Target) DefaultPIStatus {
     return switch (target.os.tag) {
         .haiku,

lib/compiler/aro/aro/Tokenizer.zig+31-14

 @@ -1,5 +1,4 @@
 const std = @import("std");
-const Io = std.Io;
 const assert = std.debug.assert;
 const Compilation = @import("Compilation.zig");
 @@ -891,6 +890,14 @@ pub const Token = struct {
                 else => false,
             };
         }
+        pub fn shouldTrackHideset(id: Id, context: enum { func, obj }) bool {
+            return switch (id) {
+                .identifier, .extended_identifier => true,
+                .r_paren => context == .func,
+                else => false,
+            };
+        }
     };
     /// double underscore and underscore + capital letter identifiers
 @@ -938,6 +945,18 @@ pub const Token = struct {
             .keyword_unaligned,
             .keyword_unaligned2,
             => if (langopts.ms_extensions) kw else .identifier,
+            .keyword_float32,
+            .keyword_float64,
+            .keyword_float128,
+            .keyword_float32x,
+            .keyword_float64x,
+            .keyword_float128x,
+            .keyword_dfloat32,
+            .keyword_dfloat64,
+            .keyword_dfloat128,
+            .keyword_dfloat64x,
+            => if (langopts.emulate == .clang) .identifier else kw,
             else => kw,
         };
     }
 @@ -2008,11 +2027,11 @@ test "operators" {
 test "keywords" {
     try expectTokens(
         \\auto __auto_type break case char const continue default do
         \\double else enum extern float for goto if int
         \\long register return short signed sizeof static
         \\struct switch typedef union unsigned void volatile
         \\while _Bool _Complex _Imaginary inline restrict _Alignas
         \\_Alignof _Atomic _Generic _Noreturn _Static_assert _Thread_local
         \\__attribute __attribute__
         \\
     , &.{
 @@ -2324,13 +2343,13 @@ test "Universal character names" {
 test "Tokenizer fuzz test" {
     const Context = struct {
-        fn testOne(_: @This(), input_bytes: []const u8) anyerror!void {
+        fn testOne(_: @This(), smith: *std.testing.Smith) anyerror!void {
-            var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+            var comp = try Compilation.init(.testing);
-            defer arena.deinit();
-            var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, undefined, Io.Dir.cwd());
             defer comp.deinit();
-            const source = try comp.addSourceFromBuffer("fuzz.c", input_bytes);
+            var buf: [256]u8 = undefined;
+            const contents_len = smith.slice(&buf);
+            const source = try comp.addSourceFromBuffer("fuzz.c", buf[0..contents_len]);
             var tokenizer: Tokenizer = .{
                 .buf = source.buf,
 @@ -2350,9 +2369,7 @@ test "Tokenizer fuzz test" {
 }
 fn expectTokensExtra(contents: []const u8, expected_tokens: []const Token.Id, langopts: ?LangOpts) !void {
-    var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+    var comp = try Compilation.init(.testing);
-    defer arena.deinit();
-    var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, undefined, Io.Dir.cwd());
     defer comp.deinit();
     if (langopts) |provided| {
         comp.langopts = provided;

lib/compiler/aro/aro/Toolchain.zig+4-7

 @@ -495,9 +495,9 @@ pub fn addSystemIncludeDir(tc: *const Toolchain, path: []const u8) !void {
 pub fn addBuiltinIncludeDir(tc: *const Toolchain) !void {
     const d = tc.driver;
     const comp = d.comp;
+    const io = comp.io;
     const gpa = comp.gpa;
     const arena = comp.arena;
-    const io = comp.io;
     try d.includes.ensureUnusedCapacity(gpa, 1);
     if (d.resource_dir) |resource_dir| {
         const path = try std.fs.path.join(arena, &.{ resource_dir, "include" });
 @@ -524,14 +524,12 @@ pub fn addBuiltinIncludeDir(tc: *const Toolchain) !void {
 /// Otherwise returns a slice of `buf`. If the file is larger than `buf` partial contents are returned
 pub fn readFile(tc: *const Toolchain, path: []const u8, buf: []u8) ?[]const u8 {
     const comp = tc.driver.comp;
-    const io = comp.io;
+    return comp.cwd.readFile(comp.io, path, buf) catch null;
-    return comp.cwd.readFile(io, path, buf) catch null;
 }
 pub fn exists(tc: *const Toolchain, path: []const u8) bool {
     const comp = tc.driver.comp;
-    const io = comp.io;
+    comp.cwd.access(comp.io, path, .{}) catch return false;
-    comp.cwd.access(io, path, .{}) catch return false;
     return true;
 }
 @@ -549,8 +547,7 @@ pub fn canExecute(tc: *const Toolchain, path: []const u8) bool {
     }
     const comp = tc.driver.comp;
-    const io = comp.io;
+    comp.cwd.access(comp.io, path, .{ .execute = true }) catch return false;
-    comp.cwd.access(io, path, .{ .execute = true }) catch return false;
     // Todo: ensure path is not a directory
     return true;
 }

lib/compiler/aro/aro/Tree.zig+178-148

 @@ -34,7 +34,7 @@ pub const TokenWithExpansionLocs = struct {
     expansion_locs: ?[*]Source.Location = null,
     pub fn expansionSlice(tok: TokenWithExpansionLocs) []const Source.Location {
-        const locs = tok.expansion_locs orelse return &[0]Source.Location{};
+        const locs = tok.expansion_locs orelse return &.{};
         var i: usize = 0;
         while (locs[i].id.index != .unused) : (i += 1) {}
         return locs[0..i];
 @@ -243,6 +243,8 @@ pub const Node = union(enum) {
     builtin_choose_expr: Conditional,
     builtin_convertvector: Convertvector,
     builtin_shufflevector: Shufflevector,
+    builtin_va_arg_pack: VaArgPack,
+    builtin_va_arg_pack_len: VaArgPack,
     /// C23 bool literal `true` / `false`
     bool_literal: Literal,
 @@ -633,6 +635,10 @@ pub const Node = union(enum) {
         indexes: []const Node.Index,
     };
+    pub const VaArgPack = struct {
+        builtin_tok: TokenIndex,
+    };
     pub const Literal = struct {
         literal_tok: TokenIndex,
         qt: QualType,
 @@ -1689,6 +1695,16 @@ pub const Node = union(enum) {
                         .indexes = @ptrCast(tree.extra.items[node_data[1] + 2 ..][0..node_data[2]]),
                     },
                 },
+                .builtin_va_arg_pack => .{
+                    .builtin_va_arg_pack = .{
+                        .builtin_tok = node_tok,
+                    },
+                },
+                .builtin_va_arg_pack_len => .{
+                    .builtin_va_arg_pack_len = .{
+                        .builtin_tok = node_tok,
+                    },
+                },
                 .array_init_expr_two => .{
                     .array_init_expr = .{
                         .l_brace_tok = node_tok,
 @@ -1797,7 +1813,9 @@ pub const Node = union(enum) {
                 .global_asm,
                 .generic_association_expr,
                 .generic_default_expr,
+                .builtin_va_arg_pack,
                 => null,
+                .builtin_va_arg_pack_len => .int,
                 .builtin_types_compatible_p => .int,
                 else => {
                     // If a node is typed the type is stored in data[0].
 @@ -1963,6 +1981,8 @@ pub const Node = union(enum) {
             builtin_types_compatible_p,
             builtin_convertvector,
             builtin_shufflevector,
+            builtin_va_arg_pack,
+            builtin_va_arg_pack_len,
             array_init_expr,
             array_init_expr_two,
             struct_init_expr,
 @@ -2789,6 +2809,14 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void {
             tree.extra.appendAssumeCapacity(@intFromEnum(builtin.rhs));
             tree.extra.appendSliceAssumeCapacity(@ptrCast(builtin.indexes));
         },
+        .builtin_va_arg_pack => |builtin| {
+            repr.tag = .builtin_va_arg_pack;
+            repr.tok = builtin.builtin_tok;
+        },
+        .builtin_va_arg_pack_len => |builtin| {
+            repr.tag = .builtin_va_arg_pack_len;
+            repr.tok = builtin.builtin_tok;
+        },
         .array_init_expr => |init| {
             repr.data[0] = @bitCast(init.container_qt);
             if (init.items.len > 2) {
 @@ -3000,12 +3028,12 @@ pub fn tokSlice(tree: *const Tree, tok_i: TokenIndex) []const u8 {
     return tree.comp.locSlice(loc);
 }
-pub fn dump(tree: *const Tree, config: std.Io.tty.Config, w: *std.Io.Writer) std.Io.tty.Config.SetColorError!void {
+pub fn dump(tree: *const Tree, term: std.Io.Terminal) std.Io.Terminal.SetColorError!void {
     for (tree.root_decls.items) |i| {
-        try tree.dumpNode(i, 0, config, w);
+        try tree.dumpNode(i, 0, term);
-        try w.writeByte('\n');
+        try term.writer.writeByte('\n');
     }
-    try w.flush();
+    try term.writer.flush();
 }
 fn dumpFieldAttributes(tree: *const Tree, attributes: []const Attribute, level: u32, w: *std.Io.Writer) !void {
 @@ -3052,25 +3080,26 @@ fn dumpNode(
     tree: *const Tree,
     node_index: Node.Index,
     level: u32,
-    config: std.Io.tty.Config,
+    term: std.Io.Terminal,
-    w: *std.Io.Writer,
 ) !void {
     const delta = 2;
     const half = delta / 2;
-    const TYPE = std.Io.tty.Color.bright_magenta;
+    const TYPE = std.Io.Terminal.Color.bright_magenta;
-    const TAG = std.Io.tty.Color.bright_cyan;
+    const TAG = std.Io.Terminal.Color.bright_cyan;
-    const IMPLICIT = std.Io.tty.Color.bright_blue;
+    const IMPLICIT = std.Io.Terminal.Color.bright_blue;
-    const NAME = std.Io.tty.Color.bright_red;
+    const NAME = std.Io.Terminal.Color.bright_red;
-    const LITERAL = std.Io.tty.Color.bright_green;
+    const LITERAL = std.Io.Terminal.Color.bright_green;
-    const ATTRIBUTE = std.Io.tty.Color.bright_yellow;
+    const ATTRIBUTE = std.Io.Terminal.Color.bright_yellow;
+    const w = term.writer;
     const node = node_index.get(tree);
     try w.splatByteAll(' ', level);
-    if (config == .no_color) {
+    if (term.mode == .no_color) {
         if (node.isImplicit()) try w.writeAll("implicit ");
     } else {
-        try config.setColor(w, if (node.isImplicit()) IMPLICIT else TAG);
+        try term.setColor(if (node.isImplicit()) IMPLICIT else TAG);
     }
     try w.print("{s}", .{@tagName(node)});
 @@ -3078,36 +3107,36 @@ fn dumpNode(
         try w.writeAll(": ");
         switch (node) {
             .cast => |cast| {
-                try config.setColor(w, .white);
+                try term.setColor(.white);
                 try w.print("({s}) ", .{@tagName(cast.kind)});
             },
             else => {},
         }
-        try config.setColor(w, TYPE);
+        try term.setColor(TYPE);
         try w.writeByte('\'');
         try qt.dump(tree.comp, w);
         try w.writeByte('\'');
     }
     if (tree.isLval(node_index)) {
-        try config.setColor(w, ATTRIBUTE);
+        try term.setColor(ATTRIBUTE);
         try w.writeAll(" lvalue");
     }
     if (tree.isBitfield(node_index)) {
-        try config.setColor(w, ATTRIBUTE);
+        try term.setColor(ATTRIBUTE);
         try w.writeAll(" bitfield");
     }
     if (node == .asm_stmt) {
         const quals = node.asm_stmt.quals;
-        try config.setColor(w, ATTRIBUTE);
+        try term.setColor(ATTRIBUTE);
         if (quals.@"inline") try w.writeAll(" inline");
         if (quals.@"volatile") try w.writeAll(" volatile");
         if (quals.goto) try w.writeAll(" goto");
     }
     if (tree.value_map.get(node_index)) |val| {
-        try config.setColor(w, LITERAL);
+        try term.setColor(LITERAL);
         try w.writeAll(" (value: ");
         if (try val.print(node_index.qt(tree), tree.comp, w)) |nested| switch (nested) {
             .pointer => |ptr| {
 @@ -3127,15 +3156,15 @@ fn dumpNode(
         try w.writeByte(')');
     }
     if (node == .return_stmt and node.return_stmt.operand == .implicit and node.return_stmt.operand.implicit) {
-        try config.setColor(w, IMPLICIT);
+        try term.setColor(IMPLICIT);
         try w.writeAll(" (value: 0)");
     }
     try w.writeAll("\n");
-    try config.setColor(w, .reset);
+    try term.setColor(.reset);
     if (node_index.qtOrNull(tree)) |qt| {
-        try config.setColor(w, ATTRIBUTE);
+        try term.setColor(ATTRIBUTE);
         var it = Attribute.Iterator.initType(qt, tree.comp);
         while (it.next()) |item| {
             const attr, _ = item;
 @@ -3143,56 +3172,56 @@ fn dumpNode(
             try w.print("attr: {s}", .{@tagName(attr.tag)});
             try tree.dumpAttribute(attr, w);
         }
-        try config.setColor(w, .reset);
+        try term.setColor(.reset);
     }
     switch (node) {
         .empty_decl => {},
         .global_asm => |@"asm"| {
-            try tree.dumpNode(@"asm".asm_str, level + delta, config, w);
+            try tree.dumpNode(@"asm".asm_str, level + delta, term);
         },
         .static_assert => |assert| {
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("condition:\n");
-            try tree.dumpNode(assert.cond, level + delta, config, w);
+            try tree.dumpNode(assert.cond, level + delta, term);
             if (assert.message) |some| {
                 try w.splatByteAll(' ', level + 1);
                 try w.writeAll("diagnostic:\n");
-                try tree.dumpNode(some, level + delta, config, w);
+                try tree.dumpNode(some, level + delta, term);
             }
         },
         .function => |function| {
             try w.splatByteAll(' ', level + half);
-            try config.setColor(w, ATTRIBUTE);
+            try term.setColor(ATTRIBUTE);
             if (function.static) try w.writeAll("static ");
             if (function.@"inline") try w.writeAll("inline ");
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
             try w.writeAll("name: ");
-            try config.setColor(w, NAME);
+            try term.setColor(NAME);
             try w.print("{s}\n", .{tree.tokSlice(function.name_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
             if (function.body) |body| {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("body:\n");
-                try tree.dumpNode(body, level + delta, config, w);
+                try tree.dumpNode(body, level + delta, term);
             }
             if (function.definition) |definition| {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("definition: ");
-                try config.setColor(w, NAME);
+                try term.setColor(NAME);
                 try w.print("0x{X}\n", .{@intFromEnum(definition)});
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
             }
         },
         .typedef => |typedef| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("name: ");
-            try config.setColor(w, NAME);
+            try term.setColor(NAME);
             try w.print("{s}\n", .{tree.tokSlice(typedef.name_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
         },
         .param => |param| {
             try w.splatByteAll(' ', level + half);
 @@ -3200,21 +3229,21 @@ fn dumpNode(
             switch (param.storage_class) {
                 .auto => {},
                 .register => {
-                    try config.setColor(w, ATTRIBUTE);
+                    try term.setColor(ATTRIBUTE);
                     try w.writeAll("register ");
-                    try config.setColor(w, .reset);
+                    try term.setColor(.reset);
                 },
             }
             try w.writeAll("name: ");
-            try config.setColor(w, NAME);
+            try term.setColor(NAME);
             try w.print("{s}\n", .{tree.tokSlice(param.name_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
         },
         .variable => |variable| {
             try w.splatByteAll(' ', level + half);
-            try config.setColor(w, ATTRIBUTE);
+            try term.setColor(ATTRIBUTE);
             switch (variable.storage_class) {
                 .auto => {},
                 .static => try w.writeAll("static "),
 @@ -3222,37 +3251,37 @@ fn dumpNode(
                 .register => try w.writeAll("register "),
             }
             if (variable.thread_local) try w.writeAll("thread_local ");
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
             try w.writeAll("name: ");
-            try config.setColor(w, NAME);
+            try term.setColor(NAME);
             try w.print("{s}\n", .{tree.tokSlice(variable.name_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
             if (variable.initializer) |some| {
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("init:\n");
-                try tree.dumpNode(some, level + delta, config, w);
+                try tree.dumpNode(some, level + delta, term);
             }
             if (variable.definition) |definition| {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("definition: ");
-                try config.setColor(w, NAME);
+                try term.setColor(NAME);
                 try w.print("0x{X}\n", .{@intFromEnum(definition)});
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
             }
         },
         .enum_field => |field| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("name: ");
-            try config.setColor(w, NAME);
+            try term.setColor(NAME);
             try w.print("{s}\n", .{tree.tokSlice(field.name_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
             if (field.init) |some| {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("init:\n");
-                try tree.dumpNode(some, level + delta, config, w);
+                try tree.dumpNode(some, level + delta, term);
             }
         },
         .record_field => |field| {
 @@ -3260,26 +3289,26 @@ fn dumpNode(
             if (name_tok_id == .identifier or name_tok_id == .extended_identifier) {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("name: ");
-                try config.setColor(w, NAME);
+                try term.setColor(NAME);
                 try w.print("{s}\n", .{tree.tokSlice(field.name_or_first_tok)});
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
             }
             if (field.bit_width) |some| {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("bits:\n");
-                try tree.dumpNode(some, level + delta, config, w);
+                try tree.dumpNode(some, level + delta, term);
             }
         },
         .compound_stmt => |compound| {
             for (compound.body, 0..) |stmt, i| {
                 if (i != 0) try w.writeByte('\n');
-                try tree.dumpNode(stmt, level + delta, config, w);
+                try tree.dumpNode(stmt, level + delta, term);
             }
         },
         .enum_decl => |decl| {
             for (decl.fields, 0..) |field, i| {
                 if (i != 0) try w.writeByte('\n');
-                try tree.dumpNode(field, level + delta, config, w);
+                try tree.dumpNode(field, level + delta, term);
             }
         },
         .struct_decl, .union_decl => |decl| {
 @@ -3291,7 +3320,7 @@ fn dumpNode(
             var field_i: u32 = 0;
             for (decl.fields, 0..) |field_node, i| {
                 if (i != 0) try w.writeByte('\n');
-                try tree.dumpNode(field_node, level + delta, config, w);
+                try tree.dumpNode(field_node, level + delta, term);
                 if (field_node.get(tree) != .record_field) continue;
                 if (fields.len == 0) continue;
 @@ -3301,32 +3330,32 @@ fn dumpNode(
                 if (field_attributes.len == 0) continue;
-                try config.setColor(w, ATTRIBUTE);
+                try term.setColor(ATTRIBUTE);
                 try tree.dumpFieldAttributes(field_attributes, level + delta + half, w);
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
             }
         },
         .array_init_expr, .struct_init_expr => |init| {
             for (init.items, 0..) |item, i| {
                 if (i != 0) try w.writeByte('\n');
-                try tree.dumpNode(item, level + delta, config, w);
+                try tree.dumpNode(item, level + delta, term);
             }
         },
         .union_init_expr => |init| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("field index: ");
-            try config.setColor(w, LITERAL);
+            try term.setColor(LITERAL);
             try w.print("{d}\n", .{init.field_index});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
             if (init.initializer) |some| {
-                try tree.dumpNode(some, level + delta, config, w);
+                try tree.dumpNode(some, level + delta, term);
             }
         },
         .compound_literal_expr => |literal| {
             if (literal.storage_class != .auto or literal.thread_local) {
                 try w.splatByteAll(' ', level + half - 1);
-                try config.setColor(w, ATTRIBUTE);
+                try term.setColor(ATTRIBUTE);
                 switch (literal.storage_class) {
                     .auto => {},
                     .static => try w.writeAll(" static"),
 @@ -3334,137 +3363,138 @@ fn dumpNode(
                 }
                 if (literal.thread_local) try w.writeAll(" thread_local");
                 try w.writeByte('\n');
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
             }
-            try tree.dumpNode(literal.initializer, level + half, config, w);
+            try tree.dumpNode(literal.initializer, level + half, term);
         },
         .labeled_stmt => |labeled| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("label: ");
-            try config.setColor(w, LITERAL);
+            try term.setColor(LITERAL);
             try w.print("{s}\n", .{tree.tokSlice(labeled.label_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
             try w.splatByteAll(' ', level + half);
             try w.writeAll("stmt:\n");
-            try tree.dumpNode(labeled.body, level + delta, config, w);
+            try tree.dumpNode(labeled.body, level + delta, term);
         },
         .case_stmt => |case| {
             try w.splatByteAll(' ', level + half);
             if (case.end) |some| {
                 try w.writeAll("range start:\n");
-                try tree.dumpNode(case.start, level + delta, config, w);
+                try tree.dumpNode(case.start, level + delta, term);
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("range end:\n");
-                try tree.dumpNode(some, level + delta, config, w);
+                try tree.dumpNode(some, level + delta, term);
             } else {
                 try w.writeAll("value:\n");
-                try tree.dumpNode(case.start, level + delta, config, w);
+                try tree.dumpNode(case.start, level + delta, term);
             }
             try w.splatByteAll(' ', level + half);
             try w.writeAll("stmt:\n");
-            try tree.dumpNode(case.body, level + delta, config, w);
+            try tree.dumpNode(case.body, level + delta, term);
         },
         .default_stmt => |default| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("stmt:\n");
-            try tree.dumpNode(default.body, level + delta, config, w);
+            try tree.dumpNode(default.body, level + delta, term);
         },
         .binary_cond_expr, .cond_expr, .builtin_choose_expr => |conditional| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("cond:\n");
-            try tree.dumpNode(conditional.cond, level + delta, config, w);
+            try tree.dumpNode(conditional.cond, level + delta, term);
             try w.splatByteAll(' ', level + half);
             try w.writeAll("then:\n");
-            try tree.dumpNode(conditional.then_expr, level + delta, config, w);
+            try tree.dumpNode(conditional.then_expr, level + delta, term);
             try w.splatByteAll(' ', level + half);
             try w.writeAll("else:\n");
-            try tree.dumpNode(conditional.else_expr, level + delta, config, w);
+            try tree.dumpNode(conditional.else_expr, level + delta, term);
         },
         .builtin_types_compatible_p => |call| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("lhs: ");
-            try config.setColor(w, TYPE);
+            try term.setColor(TYPE);
             try call.lhs.dump(tree.comp, w);
             try w.writeByte('\n');
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
             try w.splatByteAll(' ', level + half);
             try w.writeAll("rhs: ");
-            try config.setColor(w, TYPE);
+            try term.setColor(TYPE);
             try call.rhs.dump(tree.comp, w);
             try w.writeByte('\n');
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
         },
         .builtin_convertvector => |convert| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("operand:\n");
-            try tree.dumpNode(convert.operand, level + delta, config, w);
+            try tree.dumpNode(convert.operand, level + delta, term);
         },
         .builtin_shufflevector => |shuffle| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("lhs:\n");
-            try tree.dumpNode(shuffle.lhs, level + delta, config, w);
+            try tree.dumpNode(shuffle.lhs, level + delta, term);
             try w.splatByteAll(' ', level + half);
             try w.writeAll("rhs:\n");
-            try tree.dumpNode(shuffle.rhs, level + delta, config, w);
+            try tree.dumpNode(shuffle.rhs, level + delta, term);
             if (shuffle.indexes.len > 0) {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("indexes:\n");
                 for (shuffle.indexes) |index| {
-                    try tree.dumpNode(index, level + delta, config, w);
+                    try tree.dumpNode(index, level + delta, term);
                 }
             }
         },
+        .builtin_va_arg_pack, .builtin_va_arg_pack_len => {},
         .if_stmt => |@"if"| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("cond:\n");
-            try tree.dumpNode(@"if".cond, level + delta, config, w);
+            try tree.dumpNode(@"if".cond, level + delta, term);
             try w.splatByteAll(' ', level + half);
             try w.writeAll("then:\n");
-            try tree.dumpNode(@"if".then_body, level + delta, config, w);
+            try tree.dumpNode(@"if".then_body, level + delta, term);
             if (@"if".else_body) |some| {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("else:\n");
-                try tree.dumpNode(some, level + delta, config, w);
+                try tree.dumpNode(some, level + delta, term);
             }
         },
         .switch_stmt => |@"switch"| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("cond:\n");
-            try tree.dumpNode(@"switch".cond, level + delta, config, w);
+            try tree.dumpNode(@"switch".cond, level + delta, term);
             try w.splatByteAll(' ', level + half);
             try w.writeAll("body:\n");
-            try tree.dumpNode(@"switch".body, level + delta, config, w);
+            try tree.dumpNode(@"switch".body, level + delta, term);
         },
         .while_stmt => |@"while"| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("cond:\n");
-            try tree.dumpNode(@"while".cond, level + delta, config, w);
+            try tree.dumpNode(@"while".cond, level + delta, term);
             try w.splatByteAll(' ', level + half);
             try w.writeAll("body:\n");
-            try tree.dumpNode(@"while".body, level + delta, config, w);
+            try tree.dumpNode(@"while".body, level + delta, term);
         },
         .do_while_stmt => |do| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("cond:\n");
-            try tree.dumpNode(do.cond, level + delta, config, w);
+            try tree.dumpNode(do.cond, level + delta, term);
             try w.splatByteAll(' ', level + half);
             try w.writeAll("body:\n");
-            try tree.dumpNode(do.body, level + delta, config, w);
+            try tree.dumpNode(do.body, level + delta, term);
         },
         .for_stmt => |@"for"| {
             switch (@"for".init) {
 @@ -3472,48 +3502,48 @@ fn dumpNode(
                     try w.splatByteAll(' ', level + half);
                     try w.writeAll("decl:\n");
                     for (decls) |decl| {
-                        try tree.dumpNode(decl, level + delta, config, w);
+                        try tree.dumpNode(decl, level + delta, term);
                         try w.writeByte('\n');
                     }
                 },
                 .expr => |expr| if (expr) |some| {
                     try w.splatByteAll(' ', level + half);
                     try w.writeAll("init:\n");
-                    try tree.dumpNode(some, level + delta, config, w);
+                    try tree.dumpNode(some, level + delta, term);
                 },
             }
             if (@"for".cond) |some| {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("cond:\n");
-                try tree.dumpNode(some, level + delta, config, w);
+                try tree.dumpNode(some, level + delta, term);
             }
             if (@"for".incr) |some| {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("incr:\n");
-                try tree.dumpNode(some, level + delta, config, w);
+                try tree.dumpNode(some, level + delta, term);
             }
             try w.splatByteAll(' ', level + half);
             try w.writeAll("body:\n");
-            try tree.dumpNode(@"for".body, level + delta, config, w);
+            try tree.dumpNode(@"for".body, level + delta, term);
         },
         .addr_of_label => |addr| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("label: ");
-            try config.setColor(w, LITERAL);
+            try term.setColor(LITERAL);
             try w.print("{s}\n", .{tree.tokSlice(addr.label_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
         },
         .goto_stmt => |goto| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("label: ");
-            try config.setColor(w, LITERAL);
+            try term.setColor(LITERAL);
             try w.print("{s}\n", .{tree.tokSlice(goto.label_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
         },
         .computed_goto_stmt => |goto| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("expr:\n");
-            try tree.dumpNode(goto.expr, level + delta, config, w);
+            try tree.dumpNode(goto.expr, level + delta, term);
         },
         .continue_stmt, .break_stmt, .null_stmt => {},
         .return_stmt => |ret| {
 @@ -3521,43 +3551,43 @@ fn dumpNode(
                 .expr => |expr| {
                     try w.splatByteAll(' ', level + half);
                     try w.writeAll("expr:\n");
-                    try tree.dumpNode(expr, level + delta, config, w);
+                    try tree.dumpNode(expr, level + delta, term);
                 },
                 .implicit => {},
                 .none => {},
             }
         },
         .asm_stmt => |@"asm"| {
-            try tree.dumpNode(@"asm".asm_str, level + delta, config, w);
+            try tree.dumpNode(@"asm".asm_str, level + delta, term);
             const write_operand = struct {
                 fn write_operand(
-                    _w: *std.Io.Writer,
                     _level: u32,
-                    _config: std.Io.tty.Config,
+                    _term: std.Io.Terminal,
                     _tree: *const Tree,
                     operands: []const Node.AsmStmt.Operand,
-                ) std.Io.tty.Config.SetColorError!void {
+                ) std.Io.Terminal.SetColorError!void {
+                    const _w = _term.writer;
                     for (operands) |operand| {
                         if (operand.name != 0) {
                             try _w.splatByteAll(' ', _level + delta);
                             try _w.writeAll("asm name: ");
-                            try _config.setColor(_w, NAME);
+                            try _term.setColor(NAME);
                             try _w.writeAll(_tree.tokSlice(operand.name));
                             try _w.writeByte('\n');
-                            try _config.setColor(_w, .reset);
+                            try _term.setColor(.reset);
                         }
                         try _w.splatByteAll(' ', _level + delta);
                         try _w.writeAll("constraint: ");
                         const constraint_val = _tree.value_map.get(operand.constraint).?;
-                        try _config.setColor(_w, LITERAL);
+                        try _term.setColor(LITERAL);
                         _ = try constraint_val.print(operand.constraint.qt(_tree), _tree.comp, _w);
                         try _w.writeByte('\n');
-                        try _tree.dumpNode(operand.expr, _level + delta, _config, _w);
+                        try _tree.dumpNode(operand.expr, _level + delta, _term);
                     }
-                    try _config.setColor(_w, .reset);
+                    try _term.setColor(.reset);
                 }
             }.write_operand;
 @@ -3565,18 +3595,18 @@ fn dumpNode(
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("ouputs:\n");
-                try write_operand(w, level, config, tree, @"asm".outputs);
+                try write_operand(level, term, tree, @"asm".outputs);
             }
             if (@"asm".inputs.len > 0) {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("inputs:\n");
-                try write_operand(w, level, config, tree, @"asm".inputs);
+                try write_operand(level, term, tree, @"asm".inputs);
             }
             if (@"asm".clobbers.len > 0) {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("clobbers:\n");
-                try config.setColor(w, LITERAL);
+                try term.setColor(LITERAL);
                 for (@"asm".clobbers) |clobber| {
                     const clobber_val = tree.value_map.get(clobber).?;
 @@ -3584,41 +3614,41 @@ fn dumpNode(
                     _ = try clobber_val.print(clobber.qt(tree), tree.comp, w);
                     try w.writeByte('\n');
                 }
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
             }
             if (@"asm".labels.len > 0) {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("labels:\n");
                 for (@"asm".labels) |label| {
-                    try tree.dumpNode(label, level + delta, config, w);
+                    try tree.dumpNode(label, level + delta, term);
                 }
             }
         },
         .call_expr => |call| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("callee:\n");
-            try tree.dumpNode(call.callee, level + delta, config, w);
+            try tree.dumpNode(call.callee, level + delta, term);
             if (call.args.len > 0) {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("args:\n");
                 for (call.args) |arg| {
-                    try tree.dumpNode(arg, level + delta, config, w);
+                    try tree.dumpNode(arg, level + delta, term);
                 }
             }
         },
         .builtin_call_expr => |call| {
             try w.splatByteAll(' ', level + half);
             try w.writeAll("name: ");
-            try config.setColor(w, NAME);
+            try term.setColor(NAME);
             try w.print("{s}\n", .{tree.tokSlice(call.builtin_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
             if (call.args.len > 0) {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("args:\n");
                 for (call.args) |arg| {
-                    try tree.dumpNode(arg, level + delta, config, w);
+                    try tree.dumpNode(arg, level + delta, term);
                 }
             }
         },
 @@ -3655,13 +3685,13 @@ fn dumpNode(
         => |bin| {
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("lhs:\n");
-            try tree.dumpNode(bin.lhs, level + delta, config, w);
+            try tree.dumpNode(bin.lhs, level + delta, term);
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("rhs:\n");
-            try tree.dumpNode(bin.rhs, level + delta, config, w);
+            try tree.dumpNode(bin.rhs, level + delta, term);
         },
-        .cast => |cast| try tree.dumpNode(cast.operand, level + delta, config, w),
+        .cast => |cast| try tree.dumpNode(cast.operand, level + delta, term),
         .addr_of_expr,
         .deref_expr,
         .plus_expr,
 @@ -3680,21 +3710,21 @@ fn dumpNode(
         => |un| {
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("operand:\n");
-            try tree.dumpNode(un.operand, level + delta, config, w);
+            try tree.dumpNode(un.operand, level + delta, term);
         },
         .decl_ref_expr, .enumeration_ref => |dr| {
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("name: ");
-            try config.setColor(w, NAME);
+            try term.setColor(NAME);
             try w.print("{s}\n", .{tree.tokSlice(dr.name_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
         },
         .builtin_ref => |dr| {
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("name: ");
-            try config.setColor(w, NAME);
+            try term.setColor(NAME);
             try w.print("{s}\n", .{tree.tokSlice(dr.name_tok)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
         },
         .bool_literal,
         .nullptr_literal,
 @@ -3706,7 +3736,7 @@ fn dumpNode(
         .member_access_expr, .member_access_ptr_expr => |access| {
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("lhs:\n");
-            try tree.dumpNode(access.base, level + delta, config, w);
+            try tree.dumpNode(access.base, level + delta, term);
             var base_qt = access.base.qt(tree);
             if (base_qt.get(tree.comp, .pointer)) |some| base_qt = some.child;
 @@ -3714,61 +3744,61 @@ fn dumpNode(
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("name: ");
-            try config.setColor(w, NAME);
+            try term.setColor(NAME);
             try w.print("{s}\n", .{fields[access.member_index].name.lookup(tree.comp)});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
         },
         .array_access_expr => |access| {
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("base:\n");
-            try tree.dumpNode(access.base, level + delta, config, w);
+            try tree.dumpNode(access.base, level + delta, term);
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("index:\n");
-            try tree.dumpNode(access.index, level + delta, config, w);
+            try tree.dumpNode(access.index, level + delta, term);
         },
         .sizeof_expr, .alignof_expr => |type_info| {
             if (type_info.expr) |some| {
                 try w.splatByteAll(' ', level + 1);
                 try w.writeAll("expr:\n");
-                try tree.dumpNode(some, level + delta, config, w);
+                try tree.dumpNode(some, level + delta, term);
             } else {
                 try w.splatByteAll(' ', level + half);
                 try w.writeAll("operand type: ");
-                try config.setColor(w, TYPE);
+                try term.setColor(TYPE);
                 try type_info.operand_qt.dump(tree.comp, w);
                 try w.writeByte('\n');
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
             }
         },
         .generic_expr => |generic| {
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("controlling:\n");
-            try tree.dumpNode(generic.controlling, level + delta, config, w);
+            try tree.dumpNode(generic.controlling, level + delta, term);
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("chosen:\n");
-            try tree.dumpNode(generic.chosen, level + delta, config, w);
+            try tree.dumpNode(generic.chosen, level + delta, term);
             if (generic.rest.len > 0) {
                 try w.splatByteAll(' ', level + 1);
                 try w.writeAll("rest:\n");
                 for (generic.rest) |expr| {
-                    try tree.dumpNode(expr, level + delta, config, w);
+                    try tree.dumpNode(expr, level + delta, term);
                 }
             }
         },
         .generic_association_expr => |assoc| {
-            try tree.dumpNode(assoc.expr, level + delta, config, w);
+            try tree.dumpNode(assoc.expr, level + delta, term);
         },
         .generic_default_expr => |default| {
-            try tree.dumpNode(default.expr, level + delta, config, w);
+            try tree.dumpNode(default.expr, level + delta, term);
         },
         .array_filler_expr => |filler| {
             try w.splatByteAll(' ', level + 1);
             try w.writeAll("count: ");
-            try config.setColor(w, LITERAL);
+            try term.setColor(LITERAL);
             try w.print("{d}\n", .{filler.count});
-            try config.setColor(w, .reset);
+            try term.setColor(.reset);
         },
         .struct_forward_decl,
         .union_forward_decl,

lib/compiler/aro/aro/TypeStore.zig+82-24

 @@ -219,9 +219,9 @@ pub const QualType = packed struct(u32) {
             .float_dfloat64 => return .{ .float = .dfloat64 },
             .float_dfloat128 => return .{ .float = .dfloat128 },
             .float_dfloat64x => return .{ .float = .dfloat64x },
-            .void_pointer => return .{ .pointer = .{ .child = .void, .decayed = null } },
+            .void_pointer => return .{ .pointer = .{ .child = .void } },
-            .char_pointer => return .{ .pointer = .{ .child = .char, .decayed = null } },
+            .char_pointer => return .{ .pointer = .{ .child = .char } },
-            .int_pointer => return .{ .pointer = .{ .child = .int, .decayed = null } },
+            .int_pointer => return .{ .pointer = .{ .child = .int } },
             else => {},
         }
 @@ -280,7 +280,7 @@ pub const QualType = packed struct(u32) {
             },
             .pointer => .{ .pointer = .{
                 .child = @bitCast(repr.data[0]),
-                .decayed = null,
+                .bounds = @enumFromInt(repr.data[1]),
             } },
             .pointer_decayed => .{ .pointer = .{
                 .child = @bitCast(repr.data[0]),
 @@ -800,7 +800,6 @@ pub const QualType = packed struct(u32) {
                 return comp.type_store.put(comp.gpa, .{ .pointer = .{
                     .child = qt,
-                    .decayed = null,
                 } });
             },
             else => return qt,
 @@ -1013,6 +1012,15 @@ pub const QualType = packed struct(u32) {
         return qt.scalarKind(comp).isPointer();
     }
+    /// Function or function pointer
+    pub fn isCallable(qt: QualType, comp: *const Compilation) bool {
+        return switch (qt.base(comp).type) {
+            .func => true,
+            .pointer => |ptr| ptr.child.is(comp, .func),
+            else => false,
+        };
+    }
     pub fn eqlQualified(a_qt: QualType, b_qt: QualType, comp: *const Compilation) bool {
         if (a_qt.@"const" != b_qt.@"const") return false;
         if (a_qt.@"volatile" != b_qt.@"volatile") return false;
 @@ -1632,7 +1640,25 @@ pub const Type = union(enum) {
     pub const Pointer = struct {
         child: QualType,
-        decayed: ?QualType,
+        decayed: ?QualType = null,
+        bounds: Bounds = .c,
+        pub const Bounds = enum {
+            /// C pointer with no bounds attribute
+            c,
+            /// No pointer arithmetic or non-zero indexing
+            single,
+            /// Explicitly specified as a traditional C pointer
+            unsafe_indexable,
+            pub fn fromTag(tag: Attribute.Tag) Bounds {
+                return switch (tag) {
+                    .single => .single,
+                    .unsafe_indexable => .unsafe_indexable,
+                    else => unreachable,
+                };
+            }
+        };
     };
     pub const Array = struct {
 @@ -1784,6 +1810,7 @@ attributes: std.ArrayList(Attribute) = .empty,
 anon_name_arena: std.heap.ArenaAllocator.State = .{},
 wchar: QualType = .invalid,
+wint: QualType = .invalid,
 uint_least16_t: QualType = .invalid,
 uint_least32_t: QualType = .invalid,
 ptrdiff: QualType = .invalid,
 @@ -1918,10 +1945,12 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void
         .pointer => |pointer| {
             repr.data[0] = @bitCast(pointer.child);
             if (pointer.decayed) |array| {
+                std.debug.assert(pointer.bounds == .c);
                 repr.tag = .pointer_decayed;
                 repr.data[1] = @bitCast(array);
             } else {
                 repr.tag = .pointer;
+                repr.data[1] = @intFromEnum(pointer.bounds);
             }
         },
         .array => |array| {
 @@ -2070,17 +2099,44 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void
 pub fn initNamedTypes(ts: *TypeStore, comp: *Compilation) !void {
     const os = comp.target.os.tag;
-    ts.wchar = switch (comp.target.cpu.arch) {
+    const arch = comp.target.cpu.arch;
-        .xcore => .uchar,
+    ts.wchar = switch (os) {
-        .ve, .msp430 => .uint,
+        .openbsd, .netbsd => .int,
-        .arm, .armeb, .thumb, .thumbeb => if (os != .windows and os != .netbsd and os != .openbsd) .uint else .int,
+        .ps4, .ps5 => .ushort,
-        .aarch64, .aarch64_be => if (!os.isDarwin() and os != .netbsd) .uint else .int,
+        .uefi => .ushort,
-        .x86_64, .x86 => if (os == .windows) .ushort else .int,
+        .windows => .ushort,
-        else => .int,
+        .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => .int,
+        else => switch (arch) {
+            .aarch64, .aarch64_be => .uint,
+            .arm, .armeb, .thumb, .thumbeb => .uint,
+            .ve, .msp430 => .uint,
+            .x86_64, .x86 => .int,
+            .xcore => .uchar,
+            else => .int,
+        },
+    };
+    ts.wint = switch (os) {
+        .fuchsia => .uint,
+        .linux => .uint,
+        .openbsd => .int,
+        .uefi => .ushort,
+        .windows => .ushort,
+        else => switch (arch) {
+            .csky => .uint,
+            .loongarch32, .loongarch64 => .uint,
+            .riscv32, .riscv32be, .riscv64, .riscv64be => .uint,
+            .ve => .uint,
+            .xcore => .uint,
+            .xtensa, .xtensaeb => .uint,
+            else => .int,
+        },
     };
     const ptr_width = comp.target.ptrBitWidth();
-    ts.ptrdiff = if (os == .windows and ptr_width == 64)
+    ts.ptrdiff = if (arch == .wasm32)
+        .long
+    else if (os == .windows and ptr_width == 64)
         .long_long
     else switch (ptr_width) {
         16 => .int,
 @@ -2089,7 +2145,9 @@ pub fn initNamedTypes(ts: *TypeStore, comp: *Compilation) !void {
         else => unreachable,
     };
-    ts.size = if (os == .windows and ptr_width == 64)
+    ts.size = if (arch == .wasm32)
+        .ulong
+    else if (os == .windows and ptr_width == 64)
         .ulong_long
     else switch (ptr_width) {
         16 => .uint,
 @@ -2206,9 +2264,9 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType {
     };
     const struct_qt = switch (kind) {
-        .aarch64_va_list => blk: {
+        .aarch64_va_list => {
             var record: Type.Record = .{
-                .name = try comp.internString("__va_list_tag"),
+                .name = try comp.internString("__va_list"),
                 .decl_node = undefined, // TODO
                 .layout = null,
                 .fields = &.{},
 @@ -2226,11 +2284,11 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType {
             record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable;
             try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index));
-            break :blk qt;
+            return qt;
         },
-        .arm_va_list => blk: {
+        .arm_va_list => {
             var record: Type.Record = .{
-                .name = try comp.internString("__va_list_tag"),
+                .name = try comp.internString("__va_list"),
                 .decl_node = undefined, // TODO
                 .layout = null,
                 .fields = &.{},
 @@ -2244,7 +2302,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType {
             record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable;
             try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index));
-            break :blk qt;
+            return qt;
         },
         .hexagon_va_list => blk: {
             var record: Type.Record = .{
 @@ -2330,7 +2388,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType {
             break :blk qt;
         },
-        .xtensa_va_list => blk: {
+        .xtensa_va_list => {
             var record: Type.Record = .{
                 .name = try comp.internString("__va_list_tag"),
                 .decl_node = undefined, // TODO
 @@ -2348,7 +2406,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType {
             record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable;
             try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index));
-            break :blk qt;
+            return qt;
         },
     };
 @@ -2830,7 +2888,7 @@ pub const Builder = struct {
     }
     fn duplicateSpec(b: *Builder, source_tok: TokenIndex, spec: []const u8) !void {
-        if (b.parser.comp.langopts.emulate != .clang) return b.cannotCombine(source_tok);
+        if (b.parser.comp.langopts.emulate == .gcc) return b.cannotCombine(source_tok);
         try b.parser.err(b.parser.tok_i, .duplicate_decl_spec, .{spec});
     }

lib/compiler/aro/aro/Value.zig+13-17

...	@@ -1,5 +1,4 @@	...	@@ -1,5 +1,4 @@
1	const std = @import("std");	1	const std = @import("std");
2	const Io = std.Io;
3	const assert = std.debug.assert;	2	const assert = std.debug.assert;
4	const BigIntConst = std.math.big.int.Const;	3	const BigIntConst = std.math.big.int.Const;
5	const BigIntMutable = std.math.big.int.Mutable;	4	const BigIntMutable = std.math.big.int.Mutable;
...	@@ -9,8 +8,8 @@ const BigIntSpace = Interner.Tag.Int.BigIntSpace;	...	@@ -9,8 +8,8 @@ const BigIntSpace = Interner.Tag.Int.BigIntSpace;
9		8
10	const annex_g = @import("annex_g.zig");	9	const annex_g = @import("annex_g.zig");
11	const Compilation = @import("Compilation.zig");	10	const Compilation = @import("Compilation.zig");
12	const Target = @import("Target.zig");
13	const QualType = @import("TypeStore.zig").QualType;	11	const QualType = @import("TypeStore.zig").QualType;
		12	const Target = @import("Target.zig");
14		13
15	const Value = @This();	14	const Value = @This();
16		15
...	@@ -77,11 +76,7 @@ test "minUnsignedBits" {	...	@@ -77,11 +76,7 @@ test "minUnsignedBits" {
77	}	76	}
78	};	77	};
79		78
80	var arena_state: std.heap.ArenaAllocator = .init(std.testing.allocator);	79	var comp = try Compilation.init(.testing);
81	defer arena_state.deinit();
82	const arena = arena_state.allocator();
83
84	var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, undefined, Io.Dir.cwd());
85	defer comp.deinit();	80	defer comp.deinit();
86	const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });	81	const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });
87	comp.target = .fromZigTarget(try std.zig.system.resolveTargetQuery(std.testing.io, target_query));	82	comp.target = .fromZigTarget(try std.zig.system.resolveTargetQuery(std.testing.io, target_query));
...	@@ -116,11 +111,7 @@ test "minSignedBits" {	...	@@ -116,11 +111,7 @@ test "minSignedBits" {
116	}	111	}
117	};	112	};
118		113
119	var arena_state: std.heap.ArenaAllocator = .init(std.testing.allocator);	114	var comp = try Compilation.init(.testing);
120	defer arena_state.deinit();
121	const arena = arena_state.allocator();
122
123	var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, undefined, Io.Dir.cwd());
124	defer comp.deinit();	115	defer comp.deinit();
125	const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });	116	const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });
126	comp.target = .fromZigTarget(try std.zig.system.resolveTargetQuery(std.testing.io, target_query));	117	comp.target = .fromZigTarget(try std.zig.system.resolveTargetQuery(std.testing.io, target_query));
...	@@ -465,6 +456,11 @@ pub fn isNan(v: Value, comp: *const Compilation) bool {	...	@@ -465,6 +456,11 @@ pub fn isNan(v: Value, comp: *const Compilation) bool {
465	};	456	};
466	}	457	}
467		458
		459	pub fn isPointer(v: Value, comp: *const Compilation) bool {
		460	if (v.opt_ref == .none) return false;
		461	return comp.interner.get(v.ref()) == .pointer;
		462	}
		463
468	/// Converts value to zero or one;	464	/// Converts value to zero or one;
469	/// `.none` value remains unchanged.	465	/// `.none` value remains unchanged.
470	pub fn boolCast(v: Value, comp: const Compilation) void {	466	pub fn boolCast(v: Value, comp: const Compilation) void {
...	@@ -1044,9 +1040,9 @@ fn twosCompIntLimit(limit: std.math.big.int.TwosCompIntLimit, qt: QualType, comp	...	@@ -1044,9 +1040,9 @@ fn twosCompIntLimit(limit: std.math.big.int.TwosCompIntLimit, qt: QualType, comp
1044	const mag_bits: usize = @intCast(qt.bitSizeof(comp));	1040	const mag_bits: usize = @intCast(qt.bitSizeof(comp));
1045	switch (mag_bits) {	1041	switch (mag_bits) {
1046	inline 8, 16, 32, 64 => \|bits\| {	1042	inline 8, 16, 32, 64 => \|bits\| {
1047	if (limit == .min) return Value.int(@as(i64, std.math.minInt(std.meta.Int(.signed, bits))), comp);	1043	if (limit == .min) return Value.int(@as(i64, std.math.minInt(@Int(.signed, bits))), comp);
1048	return switch (signedness) {	1044	return switch (signedness) {
1049	inline else => \|sign\| Value.int(std.math.maxInt(std.meta.Int(sign, bits)), comp),	1045	inline else => \|sign\| Value.int(std.math.maxInt(@Int(sign, bits)), comp),
1050	};	1046	};
1051	},	1047	},
1052	else => {},	1048	else => {},
...	@@ -1081,7 +1077,7 @@ const NestedPrint = union(enum) {	...	@@ -1081,7 +1077,7 @@ const NestedPrint = union(enum) {
1081	},	1077	},
1082	};	1078	};
1083		1079
1084	pub fn printPointer(offset: Value, base: []const u8, comp: const Compilation, w: Io.Writer) Io.Writer.Error!void {	1080	pub fn printPointer(offset: Value, base: []const u8, comp: const Compilation, w: std.Io.Writer) std.Io.Writer.Error!void {
1085	try w.writeByte('&');	1081	try w.writeByte('&');
1086	try w.writeAll(base);	1082	try w.writeAll(base);
1087	if (!offset.isZero(comp)) {	1083	if (!offset.isZero(comp)) {
...	@@ -1090,7 +1086,7 @@ pub fn printPointer(offset: Value, base: []const u8, comp: *const Compilation, w	...	@@ -1090,7 +1086,7 @@ pub fn printPointer(offset: Value, base: []const u8, comp: *const Compilation, w
1090	}	1086	}
1091	}	1087	}
1092		1088
1093	pub fn print(v: Value, qt: QualType, comp: const Compilation, w: Io.Writer) Io.Writer.Error!?NestedPrint {	1089	pub fn print(v: Value, qt: QualType, comp: const Compilation, w: std.Io.Writer) std.Io.Writer.Error!?NestedPrint {
1094	if (qt.is(comp, .bool)) {	1090	if (qt.is(comp, .bool)) {
1095	try w.writeAll(if (v.isZero(comp)) "false" else "true");	1091	try w.writeAll(if (v.isZero(comp)) "false" else "true");
1096	return null;	1092	return null;
...	@@ -1117,7 +1113,7 @@ pub fn print(v: Value, qt: QualType, comp: const Compilation, w: Io.Writer) Io	...	@@ -1117,7 +1113,7 @@ pub fn print(v: Value, qt: QualType, comp: const Compilation, w: Io.Writer) Io
1117	return null;	1113	return null;
1118	}	1114	}
1119		1115
1120	pub fn printString(bytes: []const u8, qt: QualType, comp: const Compilation, w: Io.Writer) Io.Writer.Error!void {	1116	pub fn printString(bytes: []const u8, qt: QualType, comp: const Compilation, w: std.Io.Writer) std.Io.Writer.Error!void {
1121	const size: Compilation.CharUnitSize = @enumFromInt(qt.childType(comp).sizeof(comp));	1117	const size: Compilation.CharUnitSize = @enumFromInt(qt.childType(comp).sizeof(comp));
1122	const without_null = bytes[0 .. bytes.len - @intFromEnum(size)];	1118	const without_null = bytes[0 .. bytes.len - @intFromEnum(size)];
1123	try w.writeByte('"');	1119	try w.writeByte('"');

lib/compiler/aro/aro/features.zig+1

...	@@ -44,6 +44,7 @@ pub fn hasFeature(comp: *Compilation, ext: []const u8) bool {	...	@@ -44,6 +44,7 @@ pub fn hasFeature(comp: *Compilation, ext: []const u8) bool {
44	.c_generic_selections = comp.langopts.standard.atLeast(.c11),	44	.c_generic_selections = comp.langopts.standard.atLeast(.c11),
45	.c_static_assert = comp.langopts.standard.atLeast(.c11),	45	.c_static_assert = comp.langopts.standard.atLeast(.c11),
46	.c_thread_local = comp.langopts.standard.atLeast(.c11) and comp.target.isTlsSupported(),	46	.c_thread_local = comp.langopts.standard.atLeast(.c11) and comp.target.isTlsSupported(),
		47	.bounds_attributes = comp.langopts.bounds_safety == .clang,
47	};	48	};
48	inline for (@typeInfo(@TypeOf(list)).@"struct".fields) \|f\| {	49	inline for (@typeInfo(@TypeOf(list)).@"struct".fields) \|f\| {
49	if (std.mem.eql(u8, f.name, ext)) return @field(list, f.name);	50	if (std.mem.eql(u8, f.name, ext)) return @field(list, f.name);

lib/compiler/aro/aro/pragmas/once.zig-1

...	@@ -35,7 +35,6 @@ fn deinit(pragma: Pragma, comp: Compilation) void {	...	@@ -35,7 +35,6 @@ fn deinit(pragma: Pragma, comp: Compilation) void {
35	var self: *Once = @fieldParentPtr("pragma", pragma);	35	var self: *Once = @fieldParentPtr("pragma", pragma);
36	self.pragma_once.deinit(comp.gpa);	36	self.pragma_once.deinit(comp.gpa);
37	comp.gpa.destroy(self);	37	comp.gpa.destroy(self);
38	pragma.* = undefined;
39	}	38	}
40		39
41	fn preprocessorHandler(pragma: Pragma, pp: Preprocessor, start_idx: TokenIndex) Pragma.Error!void {	40	fn preprocessorHandler(pragma: Pragma, pp: Preprocessor, start_idx: TokenIndex) Pragma.Error!void {

lib/compiler/aro/aro/record_layout.zig+3-3

lib/compiler/aro/assembly_backend/x86_64.zig+3-4

 @@ -5,15 +5,14 @@ const assert = std.debug.assert;
 const aro = @import("aro");
 const Assembly = aro.Assembly;
 const Compilation = aro.Compilation;
-const Node = Tree.Node;
 const Source = aro.Source;
 const Tree = aro.Tree;
 const QualType = aro.QualType;
 const Value = aro.Value;
-const AsmCodeGen = @This();
 const Error = aro.Compilation.Error;
+const Node = Tree.Node;
+const AsmCodeGen = @This();
 tree: *const Tree,
 comp: *Compilation,
 text: *std.Io.Writer,
 @@ -58,7 +57,7 @@ fn serializeFloat(comptime T: type, value: T, w: *std.Io.Writer) !void {
         },
         else => {
             const size = @bitSizeOf(T);
-            const storage_unit = std.enums.fromInt(StorageUnit, size).?;
+            const storage_unit = std.enums.fromInt(StorageUnit, size) orelse unreachable;
             const IntTy = @Int(.unsigned, size);
             const int_val: IntTy = @bitCast(value);
             return serializeInt(int_val, storage_unit, w);

lib/compiler/aro/backend/Assembly.zig+1-2

...	@@ -1,5 +1,4 @@	...	@@ -1,5 +1,4 @@
1	const std = @import("std");	1	const std = @import("std");
2	const Io = std.Io;
3	const Allocator = std.mem.Allocator;	2	const Allocator = std.mem.Allocator;
4		3
5	data: []const u8,	4	data: []const u8,
...	@@ -12,7 +11,7 @@ pub fn deinit(self: *const Assembly, gpa: Allocator) void {	...	@@ -12,7 +11,7 @@ pub fn deinit(self: *const Assembly, gpa: Allocator) void {
12	gpa.free(self.text);	11	gpa.free(self.text);
13	}	12	}
14		13
15	pub fn writeToFile(self: Assembly, io: Io, file: Io.File) !void {	14	pub fn writeToFile(self: Assembly, io: std.Io, file: std.Io.File) !void {
16	var file_writer = file.writer(io, &.{});	15	var file_writer = file.writer(io, &.{});
17		16
18	var buffers = [_][]const u8{ self.data, self.text };	17	var buffers = [_][]const u8{ self.data, self.text };

lib/compiler/aro/backend/Interner.zig+2-2

...	@@ -102,13 +102,13 @@ pub const Key = union(enum) {	...	@@ -102,13 +102,13 @@ pub const Key = union(enum) {
102	.float => \|repr\| switch (repr) {	102	.float => \|repr\| switch (repr) {
103	inline else => \|data\| std.hash.autoHash(	103	inline else => \|data\| std.hash.autoHash(
104	&hasher,	104	&hasher,
105	@as(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),	105	@as(@Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),
106	),	106	),
107	},	107	},
108	.complex => \|repr\| switch (repr) {	108	.complex => \|repr\| switch (repr) {
109	inline else => \|data\| std.hash.autoHash(	109	inline else => \|data\| std.hash.autoHash(
110	&hasher,	110	&hasher,
111	@as(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),	111	@as(@Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),
112	),	112	),
113	},	113	},
114	.int => \|repr\| {	114	.int => \|repr\| {

lib/compiler/aro/backend/Ir.zig+100-92

 @@ -374,24 +374,27 @@ pub fn deinit(ir: *Ir, gpa: std.mem.Allocator) void {
     ir.* = undefined;
 }
-const TYPE = std.Io.tty.Color.bright_magenta;
+const TYPE = std.Io.Terminal.Color.bright_magenta;
-const INST = std.Io.tty.Color.bright_cyan;
+const INST = std.Io.Terminal.Color.bright_cyan;
-const REF = std.Io.tty.Color.bright_blue;
+const REF = std.Io.Terminal.Color.bright_blue;
-const LITERAL = std.Io.tty.Color.bright_green;
+const LITERAL = std.Io.Terminal.Color.bright_green;
-const ATTRIBUTE = std.Io.tty.Color.bright_yellow;
+const ATTRIBUTE = std.Io.Terminal.Color.bright_yellow;
 const RefMap = std.AutoArrayHashMapUnmanaged(Ref, void);
-pub fn dump(ir: *const Ir, gpa: Allocator, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+pub const DumpError = std.Io.Terminal.SetColorError || std.mem.Allocator.Error;
+pub fn dump(ir: *const Ir, gpa: Allocator, term: std.Io.Terminal) DumpError!void {
     for (ir.decls.keys(), ir.decls.values()) |name, *decl| {
-        try ir.dumpDecl(decl, gpa, name, config, w);
+        try ir.dumpDecl(decl, gpa, name, term);
     }
-    try w.flush();
+    try term.writer.flush();
 }
-fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8, term: std.Io.Terminal) !void {
     const tags = decl.instructions.items(.tag);
     const data = decl.instructions.items(.data);
+    const w = term.writer;
     var ref_map: RefMap = .empty;
     defer ref_map.deinit(gpa);
 @@ -402,10 +405,10 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
     const ret_inst = decl.body.items[decl.body.items.len - 1];
     const ret_operand = data[@intFromEnum(ret_inst)].un;
     const ret_ty = decl.instructions.items(.ty)[@intFromEnum(ret_operand)];
-    try ir.writeType(ret_ty, config, w);
+    try ir.writeType(ret_ty, term);
-    try config.setColor(w, REF);
+    try term.setColor(REF);
     try w.print(" @{s}", .{name});
-    try config.setColor(w, .reset);
+    try term.setColor(.reset);
     try w.writeAll("(");
     var arg_count: u32 = 0;
 @@ -414,8 +417,8 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
         if (tags[@intFromEnum(ref)] != .arg) break;
         if (arg_count != 0) try w.writeAll(", ");
         try ref_map.put(gpa, ref, {});
-        try ir.writeRef(decl, &ref_map, ref, config, w);
+        try ir.writeRef(decl, &ref_map, ref, term);
-        try config.setColor(w, .reset);
+        try term.setColor(.reset);
     }
     try w.writeAll(") {\n");
     for (decl.body.items[arg_count..]) |ref| {
 @@ -432,7 +435,7 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
             .arg, .constant, .symbol => unreachable,
             .label => {
                 const label_index = label_map.getIndex(ref).?;
-                try config.setColor(w, REF);
+                try term.setColor(REF);
                 try w.print("{s}.{d}:\n", .{ data[i].label, label_index });
             },
             // .label_val => {
 @@ -441,35 +444,35 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
             // },
             .jmp => {
                 const un = data[i].un;
-                try config.setColor(w, INST);
+                try term.setColor(INST);
                 try w.writeAll("    jmp ");
-                try writeLabel(decl, &label_map, un, config, w);
+                try writeLabel(decl, &label_map, un, term);
                 try w.writeByte('\n');
             },
             .branch => {
                 const br = data[i].branch;
-                try config.setColor(w, INST);
+                try term.setColor(INST);
                 try w.writeAll("    branch ");
-                try ir.writeRef(decl, &ref_map, br.cond, config, w);
+                try ir.writeRef(decl, &ref_map, br.cond, term);
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try writeLabel(decl, &label_map, br.then, config, w);
+                try writeLabel(decl, &label_map, br.then, term);
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try writeLabel(decl, &label_map, br.@"else", config, w);
+                try writeLabel(decl, &label_map, br.@"else", term);
                 try w.writeByte('\n');
             },
             .select => {
                 const br = data[i].branch;
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.writeAll("select ");
-                try ir.writeRef(decl, &ref_map, br.cond, config, w);
+                try ir.writeRef(decl, &ref_map, br.cond, term);
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try ir.writeRef(decl, &ref_map, br.then, config, w);
+                try ir.writeRef(decl, &ref_map, br.then, term);
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try ir.writeRef(decl, &ref_map, br.@"else", config, w);
+                try ir.writeRef(decl, &ref_map, br.@"else", term);
                 try w.writeByte('\n');
             },
             // .jmp_val => {
 @@ -478,91 +481,91 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
             // },
             .@"switch" => {
                 const @"switch" = data[i].@"switch";
-                try config.setColor(w, INST);
+                try term.setColor(INST);
                 try w.writeAll("    switch ");
-                try ir.writeRef(decl, &ref_map, @"switch".target, config, w);
+                try ir.writeRef(decl, &ref_map, @"switch".target, term);
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll(" {");
                 for (@"switch".case_vals[0..@"switch".cases_len], @"switch".case_labels) |val_ref, label_ref| {
                     try w.writeAll("\n        ");
-                    try ir.writeValue(val_ref, config, w);
+                    try ir.writeValue(val_ref, term);
-                    try config.setColor(w, .reset);
+                    try term.setColor(.reset);
                     try w.writeAll(" => ");
-                    try writeLabel(decl, &label_map, label_ref, config, w);
+                    try writeLabel(decl, &label_map, label_ref, term);
-                    try config.setColor(w, .reset);
+                    try term.setColor(.reset);
                 }
-                try config.setColor(w, LITERAL);
+                try term.setColor(LITERAL);
                 try w.writeAll("\n        default ");
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll("=> ");
-                try writeLabel(decl, &label_map, @"switch".default, config, w);
+                try writeLabel(decl, &label_map, @"switch".default, term);
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll("\n    }\n");
             },
             .call => {
                 const call = data[i].call;
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.writeAll("call ");
-                try ir.writeRef(decl, &ref_map, call.func, config, w);
+                try ir.writeRef(decl, &ref_map, call.func, term);
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll("(");
                 for (call.args(), 0..) |arg, arg_i| {
                     if (arg_i != 0) try w.writeAll(", ");
-                    try ir.writeRef(decl, &ref_map, arg, config, w);
+                    try ir.writeRef(decl, &ref_map, arg, term);
-                    try config.setColor(w, .reset);
+                    try term.setColor(.reset);
                 }
                 try w.writeAll(")\n");
             },
             .alloc => {
                 const alloc = data[i].alloc;
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.writeAll("alloc ");
-                try config.setColor(w, ATTRIBUTE);
+                try term.setColor(ATTRIBUTE);
                 try w.writeAll("size ");
-                try config.setColor(w, LITERAL);
+                try term.setColor(LITERAL);
                 try w.print("{d}", .{alloc.size});
-                try config.setColor(w, ATTRIBUTE);
+                try term.setColor(ATTRIBUTE);
                 try w.writeAll(" align ");
-                try config.setColor(w, LITERAL);
+                try term.setColor(LITERAL);
                 try w.print("{d}", .{alloc.@"align"});
                 try w.writeByte('\n');
             },
             .phi => {
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.writeAll("phi");
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll(" {");
                 for (data[i].phi.inputs()) |input| {
                     try w.writeAll("\n        ");
-                    try writeLabel(decl, &label_map, input.label, config, w);
+                    try writeLabel(decl, &label_map, input.label, term);
-                    try config.setColor(w, .reset);
+                    try term.setColor(.reset);
                     try w.writeAll(" => ");
-                    try ir.writeRef(decl, &ref_map, input.value, config, w);
+                    try ir.writeRef(decl, &ref_map, input.value, term);
-                    try config.setColor(w, .reset);
+                    try term.setColor(.reset);
                 }
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll("\n    }\n");
             },
             .store => {
                 const bin = data[i].bin;
-                try config.setColor(w, INST);
+                try term.setColor(INST);
                 try w.writeAll("    store ");
-                try ir.writeRef(decl, &ref_map, bin.lhs, config, w);
+                try ir.writeRef(decl, &ref_map, bin.lhs, term);
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try ir.writeRef(decl, &ref_map, bin.rhs, config, w);
+                try ir.writeRef(decl, &ref_map, bin.rhs, term);
                 try w.writeByte('\n');
             },
             .ret => {
-                try config.setColor(w, INST);
+                try term.setColor(INST);
                 try w.writeAll("    ret ");
-                if (data[i].un != .none) try ir.writeRef(decl, &ref_map, data[i].un, config, w);
+                if (data[i].un != .none) try ir.writeRef(decl, &ref_map, data[i].un, term);
                 try w.writeByte('\n');
             },
             .load => {
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.writeAll("load ");
-                try ir.writeRef(decl, &ref_map, data[i].un, config, w);
+                try ir.writeRef(decl, &ref_map, data[i].un, term);
                 try w.writeByte('\n');
             },
             .bit_or,
 @@ -583,12 +586,12 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
             .mod,
             => {
                 const bin = data[i].bin;
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.print("{s} ", .{@tagName(tag)});
-                try ir.writeRef(decl, &ref_map, bin.lhs, config, w);
+                try ir.writeRef(decl, &ref_map, bin.lhs, term);
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try ir.writeRef(decl, &ref_map, bin.rhs, config, w);
+                try ir.writeRef(decl, &ref_map, bin.rhs, term);
                 try w.writeByte('\n');
             },
             .bit_not,
 @@ -598,33 +601,34 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
             .sext,
             => {
                 const un = data[i].un;
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.print("{s} ", .{@tagName(tag)});
-                try ir.writeRef(decl, &ref_map, un, config, w);
+                try ir.writeRef(decl, &ref_map, un, term);
                 try w.writeByte('\n');
             },
             .label_addr, .jmp_val => {},
         }
     }
-    try config.setColor(w, .reset);
+    try term.setColor(.reset);
     try w.writeAll("}\n\n");
 }
-fn writeType(ir: Ir, ty_ref: Interner.Ref, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn writeType(ir: Ir, ty_ref: Interner.Ref, term: std.Io.Terminal) !void {
+    const w = term.writer;
     const ty = ir.interner.get(ty_ref);
-    try config.setColor(w, TYPE);
+    try term.setColor(TYPE);
     switch (ty) {
         .ptr_ty, .noreturn_ty, .void_ty, .func_ty => try w.writeAll(@tagName(ty)),
         .int_ty => |bits| try w.print("i{d}", .{bits}),
         .float_ty => |bits| try w.print("f{d}", .{bits}),
         .array_ty => |info| {
             try w.print("[{d} * ", .{info.len});
-            try ir.writeType(info.child, .no_color, w);
+            try ir.writeType(info.child, .{ .mode = .no_color, .writer = w });
             try w.writeByte(']');
         },
         .vector_ty => |info| {
             try w.print("<{d} * ", .{info.len});
-            try ir.writeType(info.child, .no_color, w);
+            try ir.writeType(info.child, .{ .mode = .no_color, .writer = w });
             try w.writeByte('>');
         },
         .record_ty => |elems| {
 @@ -632,7 +636,7 @@ fn writeType(ir: Ir, ty_ref: Interner.Ref, config: std.Io.tty.Config, w: *std.Io
             try w.writeAll("{ ");
             for (elems, 0..) |elem, i| {
                 if (i != 0) try w.writeAll(", ");
-                try ir.writeType(elem, config, w);
+                try ir.writeType(elem, .{ .mode = .no_color, .writer = w });
             }
             try w.writeAll(" }");
         },
 @@ -640,8 +644,9 @@ fn writeType(ir: Ir, ty_ref: Interner.Ref, config: std.Io.tty.Config, w: *std.Io
     }
 }
-fn writeValue(ir: Ir, val: Interner.Ref, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn writeValue(ir: Ir, val: Interner.Ref, term: std.Io.Terminal) !void {
-    try config.setColor(w, LITERAL);
+    const w = term.writer;
+    try term.setColor(LITERAL);
     const key = ir.interner.get(val);
     switch (key) {
         .null => return w.writeAll("nullptr_t"),
 @@ -656,43 +661,46 @@ fn writeValue(ir: Ir, val: Interner.Ref, config: std.Io.tty.Config, w: *std.Io.W
     }
 }
-fn writeRef(ir: Ir, decl: *const Decl, ref_map: *RefMap, ref: Ref, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn writeRef(ir: Ir, decl: *const Decl, ref_map: *RefMap, ref: Ref, term: std.Io.Terminal) !void {
+    const w = term.writer;
     assert(ref != .none);
     const index = @intFromEnum(ref);
     const ty_ref = decl.instructions.items(.ty)[index];
     if (decl.instructions.items(.tag)[index] == .constant) {
-        try ir.writeType(ty_ref, config, w);
+        try ir.writeType(ty_ref, term);
         const v_ref = decl.instructions.items(.data)[index].constant;
         try w.writeByte(' ');
-        try ir.writeValue(v_ref, config, w);
+        try ir.writeValue(v_ref, term);
         return;
     } else if (decl.instructions.items(.tag)[index] == .symbol) {
         const name = decl.instructions.items(.data)[index].label;
-        try ir.writeType(ty_ref, config, w);
+        try ir.writeType(ty_ref, term);
-        try config.setColor(w, REF);
+        try term.setColor(REF);
         try w.print(" @{s}", .{name});
         return;
     }
-    try ir.writeType(ty_ref, config, w);
+    try ir.writeType(ty_ref, term);
-    try config.setColor(w, REF);
+    try term.setColor(REF);
     const ref_index = ref_map.getIndex(ref).?;
     try w.print(" %{d}", .{ref_index});
 }
-fn writeNewRef(ir: Ir, gpa: Allocator, decl: *const Decl, ref_map: *RefMap, ref: Ref, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn writeNewRef(ir: Ir, gpa: Allocator, decl: *const Decl, ref_map: *RefMap, ref: Ref, term: std.Io.Terminal) !void {
+    const w = term.writer;
     try ref_map.put(gpa, ref, {});
     try w.writeAll("    ");
-    try ir.writeRef(decl, ref_map, ref, config, w);
+    try ir.writeRef(decl, ref_map, ref, term);
-    try config.setColor(w, .reset);
+    try term.setColor(.reset);
     try w.writeAll(" = ");
-    try config.setColor(w, INST);
+    try term.setColor(INST);
 }
-fn writeLabel(decl: *const Decl, label_map: *RefMap, ref: Ref, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn writeLabel(decl: *const Decl, label_map: *RefMap, ref: Ref, term: std.Io.Terminal) !void {
+    const w = term.writer;
     assert(ref != .none);
     const index = @intFromEnum(ref);
     const label = decl.instructions.items(.data)[index].label;
-    try config.setColor(w, REF);
+    try term.setColor(REF);
     const label_index = label_map.getIndex(ref).?;
     try w.print("{s}.{d}", .{ label, label_index });
 }

lib/compiler/aro/backend/Ir/x86/Renderer.zig+3-3

lib/compiler/aro/include/ptrcheck.h created+49

...	@@ -0,0 +1,49 @@
1	#pragma once
2
3	#if defined(__has_feature) && __has_feature(bounds_attributes)
4	#define __has_ptrcheck 1
5	#else
6	#define __has_ptrcheck 0
7	#endif
8
9	#if __has_ptrcheck
10
11	#define __single __attribute__((__single__))
12	#define __unsafe_indexable __attribute__((__unsafe_indexable__))
13
14	#else
15
16	#define __single
17	#define __unsafe_indexable
18	#define __counted_by(N)
19	#define __counted_by_or_null(N)
20	#define __sized_by(N)
21	#define __sized_by_or_null(N)
22	#define __ended_by(E)
23
24	#define __terminated_by(T)
25	#define __null_terminated
26
27	/* __ptrcheck_abi_assume_indexable and __ptrcheck_abi_assume_bidi_indexable intentionally not defined */
28	#define __ptrcheck_abi_assume_single()
29	#define __ptrcheck_abi_assume_unsafe_indexable()
30
31	#define __unsafe_forge_bidi_indexable(T, P, S) ((T)(P))
32	#define __unsafe_forge_single(T, P) ((T)(P))
33	#define __unsafe_forge_terminated_by(T, P, E) ((T)(P))
34	#define __unsafe_forge_null_terminated(T, P) ((T)(P))
35
36	#define __terminated_by_to_indexable(P) (P)
37	#define __unsafe_terminated_by_to_indexable(P) (P)
38	#define __null_terminated_to_indexable(P) (P)
39	#define __unsafe_null_terminated_to_indexable(P) (P)
40	#define __unsafe_terminated_by_from_indexable(T, P, ...) (P)
41	#define __unsafe_null_terminated_from_indexable(P, ...) (P)
42
43	#define __array_decay_dicards_count_in_parameters
44
45	#define __ptrcheck_unavailable
46	#define __ptrcheck_unavailable_r(REPLACEMENT)
47
48
49	#endif

lib/compiler/aro/main.zig+26-10

 @@ -1,8 +1,9 @@
 const std = @import("std");
-const Io = std.Io;
-const Allocator = mem.Allocator;
 const mem = std.mem;
 const process = std.process;
+const Allocator = mem.Allocator;
+const build_options = @import("build_options");
 const aro = @import("aro");
 const Compilation = aro.Compilation;
 const Diagnostics = aro.Diagnostics;
 @@ -11,14 +12,15 @@ const Toolchain = aro.Toolchain;
 const assembly_backend = @import("assembly_backend");
 var debug_allocator: std.heap.DebugAllocator(.{
-    .stack_trace_frames = 0,
+    .stack_trace_frames = if (build_options.debug_allocations and std.debug.sys_can_stack_trace) 10 else 0,
+    .resize_stack_traces = build_options.debug_allocations,
     // A unique value so that when a default-constructed
-    // DebugAllocator is incorrectly passed to testing allocator, or
+    // GeneralPurposeAllocator is incorrectly passed to testing allocator, or
     // vice versa, panic occurs.
     .canary = @truncate(0xc647026dc6875134),
 }) = .{};
-pub fn main(init: std.process.Init.Minimal) u8 {
+pub fn main(init: process.Init.Minimal) u8 {
     const gpa = if (@import("builtin").link_libc)
         std.heap.c_allocator
     else
 @@ -31,7 +33,10 @@ pub fn main(init: std.process.Init.Minimal) u8 {
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
-    var threaded: std.Io.Threaded = .init(gpa, .{});
+    var threaded: std.Io.Threaded = .init(gpa, .{
+        .argv0 = .init(init.args),
+        .environ = init.environ,
+    });
     defer threaded.deinit();
     const io = threaded.io();
 @@ -43,7 +48,11 @@ pub fn main(init: std.process.Init.Minimal) u8 {
         return 1;
     };
-    const aro_name = process.executablePathAlloc(io, gpa) catch {
+    var environ_map = std.process.Environ.createMap(init.environ, gpa) catch |err|
+        std.process.fatal("failed to parse environment variables: {t}", .{err});
+    defer environ_map.deinit();
+    const aro_name = std.process.executableDirPathAlloc(io, gpa) catch {
         std.debug.print("unable to find Aro executable path\n", .{});
         if (fast_exit) process.exit(1);
         return 1;
 @@ -51,15 +60,21 @@ pub fn main(init: std.process.Init.Minimal) u8 {
     defer gpa.free(aro_name);
     var stderr_buf: [1024]u8 = undefined;
-    var stderr = Io.File.stderr().writer(&stderr_buf);
+    var stderr = std.Io.File.stderr().writer(io, &stderr_buf);
     var diagnostics: Diagnostics = .{
         .output = .{ .to_writer = .{
-            .color = .detect(stderr.file),
+            .mode = std.Io.Terminal.Mode.detect(io, stderr.file, false, false) catch .no_color,
             .writer = &stderr.interface,
         } },
     };
-    var comp = Compilation.initDefault(gpa, arena, io, &diagnostics, Io.Dir.cwd()) catch |er| switch (er) {
+    var comp = Compilation.init(.{
+        .gpa = gpa,
+        .arena = arena,
+        .io = io,
+        .diagnostics = &diagnostics,
+        .environ_map = &environ_map,
+    }) catch |er| switch (er) {
         error.OutOfMemory => {
             std.debug.print("out of memory\n", .{});
             if (fast_exit) process.exit(1);
 @@ -85,6 +100,7 @@ pub fn main(init: std.process.Init.Minimal) u8 {
             if (fast_exit) process.exit(1);
             return 1;
         },
+        error.Canceled => unreachable,
     };
     if (fast_exit) process.exit(@intFromBool(comp.diagnostics.errors != 0));
     return @intFromBool(diagnostics.errors != 0);

...	@@ -332,7 +332,7 @@ const SysVContext = struct {	...	@@ -332,7 +332,7 @@ const SysVContext = struct {
332	}	332	}
333	}	333	}
334	} else {	334	} else {
335	std.debug.assert(self.comp.langopts.emulate == .clang);	335	std.debug.assert(self.comp.langopts.emulate == .no or self.comp.langopts.emulate == .clang);
336		336
337	// On Clang, the alignment requested by annotations is not respected if it is	337	// On Clang, the alignment requested by annotations is not respected if it is
338	// larger than the value of #pragma pack. See test case 0083.	338	// larger than the value of #pragma pack. See test case 0083.
...	@@ -569,7 +569,7 @@ const MsvcContext = struct {	...	@@ -569,7 +569,7 @@ const MsvcContext = struct {
569		569
570	pub fn compute(fields: []Type.Record.Field, qt: QualType, comp: *const Compilation, pragma_pack: ?u8) Error!Type.Record.Layout {	570	pub fn compute(fields: []Type.Record.Field, qt: QualType, comp: *const Compilation, pragma_pack: ?u8) Error!Type.Record.Layout {
571	switch (comp.langopts.emulate) {	571	switch (comp.langopts.emulate) {
572	.gcc, .clang => {	572	.no, .gcc, .clang => {
573	var context = SysVContext.init(qt, comp, pragma_pack);	573	var context = SysVContext.init(qt, comp, pragma_pack);
574		574
575	try context.layoutFields(fields);	575	try context.layoutFields(fields);
...	@@ -620,7 +620,7 @@ fn computeLayout(qt: QualType, comp: *const Compilation) RecordLayout {	...	@@ -620,7 +620,7 @@ fn computeLayout(qt: QualType, comp: *const Compilation) RecordLayout {
620	else => {	620	else => {
621	const type_align = qt.alignof(comp) * BITS_PER_BYTE;	621	const type_align = qt.alignof(comp) * BITS_PER_BYTE;
622	return .{	622	return .{
623	.size_bits = qt.bitSizeofOrNull(comp) orelse 0,	623	.size_bits = BITS_PER_BYTE * (qt.sizeofOrNull(comp) orelse 0),
624	.pointer_alignment_bits = type_align,	624	.pointer_alignment_bits = type_align,
625	.field_alignment_bits = type_align,	625	.field_alignment_bits = type_align,
626	.required_alignment_bits = BITS_PER_BYTE,	626	.required_alignment_bits = BITS_PER_BYTE,

...	@@ -21,17 +21,17 @@ const RegisterManager = zig.RegisterManager(Renderer, Register, Ir.Ref, abi.allo	...	@@ -21,17 +21,17 @@ const RegisterManager = zig.RegisterManager(Renderer, Register, Ir.Ref, abi.allo
21	const RegisterBitSet = RegisterManager.RegisterBitSet;	21	const RegisterBitSet = RegisterManager.RegisterBitSet;
22	const RegisterClass = struct {	22	const RegisterClass = struct {
23	const gp: RegisterBitSet = blk: {	23	const gp: RegisterBitSet = blk: {
24	var set = RegisterBitSet.empty;	24	var set = RegisterBitSet.initEmpty();
25	for (abi.allocatable_regs, 0..) \|reg, index\| if (reg.class() == .general_purpose) set.set(index);	25	for (abi.allocatable_regs, 0..) \|reg, index\| if (reg.class() == .general_purpose) set.set(index);
26	break :blk set;	26	break :blk set;
27	};	27	};
28	const x87: RegisterBitSet = blk: {	28	const x87: RegisterBitSet = blk: {
29	var set = RegisterBitSet.empty;	29	var set = RegisterBitSet.initEmpty();
30	for (abi.allocatable_regs, 0..) \|reg, index\| if (reg.class() == .x87) set.set(index);	30	for (abi.allocatable_regs, 0..) \|reg, index\| if (reg.class() == .x87) set.set(index);
31	break :blk set;	31	break :blk set;
32	};	32	};
33	const sse: RegisterBitSet = blk: {	33	const sse: RegisterBitSet = blk: {
34	var set = RegisterBitSet.empty;	34	var set = RegisterBitSet.initEmpty();
35	for (abi.allocatable_regs, 0..) \|reg, index\| if (reg.class() == .sse) set.set(index);	35	for (abi.allocatable_regs, 0..) \|reg, index\| if (reg.class() == .sse) set.set(index);
36	break :blk set;	36	break :blk set;
37	};	37	};

...	@@ -99,6 +99,7 @@ pub const Tag = enum(u16) { aarch64_sve_pcs,	...	@@ -99,6 +99,7 @@ pub const Tag = enum(u16) { aarch64_sve_pcs,
99	selectany,	99	selectany,
100	sentinel,	100	sentinel,
101	simd,	101	simd,
		102	single,
102	spectre,	103	spectre,
103	stack_protect,	104	stack_protect,
104	stdcall,	105	stdcall,
...	@@ -112,6 +113,7 @@ pub const Tag = enum(u16) { aarch64_sve_pcs,	...	@@ -112,6 +113,7 @@ pub const Tag = enum(u16) { aarch64_sve_pcs,
112	transparent_union,	113	transparent_union,
113	unavailable,	114	unavailable,
114	uninitialized,	115	uninitialized,
		116	unsafe_indexable,
115	unsequenced,	117	unsequenced,
116	unused,	118	unused,
117	used,	119	used,
...	@@ -181,7 +183,7 @@ pub const longest_name = 30;	...	@@ -181,7 +183,7 @@ pub const longest_name = 30;
181	/// If found, returns the index of the node within the `dafsa` array.	183	/// If found, returns the index of the node within the `dafsa` array.
182	/// Otherwise, returns `null`.	184	/// Otherwise, returns `null`.
183	pub fn findInList(first_child_index: u16, char: u8) ?u16 {	185	pub fn findInList(first_child_index: u16, char: u8) ?u16 {
184	@setEvalBranchQuota(234);	186	@setEvalBranchQuota(238);
185	var index = first_child_index;	187	var index = first_child_index;
186	while (true) {	188	while (true) {
187	if (dafsa[index].char == char) return index;	189	if (dafsa[index].char == char) return index;
...	@@ -290,9 +292,9 @@ const dafsa = [_]Node{	...	@@ -290,9 +292,9 @@ const dafsa = [_]Node{
290	.{ .char = 'n', .end_of_word = false, .end_of_list = false, .number = 25, .child_index = 47 },	292	.{ .char = 'n', .end_of_word = false, .end_of_list = false, .number = 25, .child_index = 47 },
291	.{ .char = 'p', .end_of_word = false, .end_of_list = false, .number = 6, .child_index = 49 },	293	.{ .char = 'p', .end_of_word = false, .end_of_list = false, .number = 6, .child_index = 49 },
292	.{ .char = 'r', .end_of_word = false, .end_of_list = false, .number = 6, .child_index = 54 },	294	.{ .char = 'r', .end_of_word = false, .end_of_list = false, .number = 6, .child_index = 54 },
293	.{ .char = 's', .end_of_word = false, .end_of_list = false, .number = 11, .child_index = 56 },	295	.{ .char = 's', .end_of_word = false, .end_of_list = false, .number = 12, .child_index = 56 },
294	.{ .char = 't', .end_of_word = false, .end_of_list = false, .number = 6, .child_index = 63 },	296	.{ .char = 't', .end_of_word = false, .end_of_list = false, .number = 6, .child_index = 63 },
295	.{ .char = 'u', .end_of_word = false, .end_of_list = false, .number = 6, .child_index = 67 },	297	.{ .char = 'u', .end_of_word = false, .end_of_list = false, .number = 7, .child_index = 67 },
296	.{ .char = 'v', .end_of_word = false, .end_of_list = false, .number = 3, .child_index = 70 },	298	.{ .char = 'v', .end_of_word = false, .end_of_list = false, .number = 3, .child_index = 70 },
297	.{ .char = 'w', .end_of_word = false, .end_of_list = false, .number = 5, .child_index = 72 },	299	.{ .char = 'w', .end_of_word = false, .end_of_list = false, .number = 5, .child_index = 72 },
298	.{ .char = 'z', .end_of_word = false, .end_of_list = true, .number = 1, .child_index = 74 },	300	.{ .char = 'z', .end_of_word = false, .end_of_list = true, .number = 1, .child_index = 74 },
...	@@ -334,642 +336,653 @@ const dafsa = [_]Node{	...	@@ -334,642 +336,653 @@ const dafsa = [_]Node{
334	.{ .char = 'a', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 130 },	336	.{ .char = 'a', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 130 },
335	.{ .char = 'c', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 131 },	337	.{ .char = 'c', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 131 },
336	.{ .char = 'e', .end_of_word = false, .end_of_list = false, .number = 3, .child_index = 132 },	338	.{ .char = 'e', .end_of_word = false, .end_of_list = false, .number = 3, .child_index = 132 },
337	.{ .char = 'i', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 135 },	339	.{ .char = 'i', .end_of_word = false, .end_of_list = false, .number = 2, .child_index = 135 },
338	.{ .char = 'p', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 136 },	340	.{ .char = 'p', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 137 },

...	@@ -751,6 +751,8 @@ pub const Tag = enum(u16) { _Block_object_assign,	...	@@ -751,6 +751,8 @@ pub const Tag = enum(u16) { _Block_object_assign,
751	__builtin_usubl_overflow,	751	__builtin_usubl_overflow,
752	__builtin_usubll_overflow,	752	__builtin_usubll_overflow,
753	__builtin_va_arg,	753	__builtin_va_arg,
		754	__builtin_va_arg_pack,
		755	__builtin_va_arg_pack_len,
754	__builtin_va_copy,	756	__builtin_va_copy,
755	__builtin_va_end,	757	__builtin_va_end,
756	__builtin_va_start,	758	__builtin_va_start,
...	@@ -1436,7 +1438,7 @@ pub const longest_name = 41;	...	@@ -1436,7 +1438,7 @@ pub const longest_name = 41;
1436	/// If found, returns the index of the node within the `dafsa` array.	1438	/// If found, returns the index of the node within the `dafsa` array.
1437	/// Otherwise, returns `null`.	1439	/// Otherwise, returns `null`.
1438	pub fn findInList(first_child_index: u16, char: u8) ?u16 {	1440	pub fn findInList(first_child_index: u16, char: u8) ?u16 {
1439	@setEvalBranchQuota(2744);	1441	@setEvalBranchQuota(2748);
1440	var index = first_child_index;	1442	var index = first_child_index;
1441	while (true) {	1443	while (true) {
1442	if (dafsa[index].char == char) return index;	1444	if (dafsa[index].char == char) return index;
...	@@ -1531,7 +1533,7 @@ const Node = packed struct {	...	@@ -1531,7 +1533,7 @@ const Node = packed struct {
1531		1533
1532	const dafsa = [_]Node{	1534	const dafsa = [_]Node{
1533	.{ .char = 0, .end_of_word = false, .end_of_list = true, .number = 0, .child_index = 1 },	1535	.{ .char = 0, .end_of_word = false, .end_of_list = true, .number = 0, .child_index = 1 },
1534	.{ .char = '_', .end_of_word = false, .end_of_list = false, .number = 1016, .child_index = 19 },	1536	.{ .char = '_', .end_of_word = false, .end_of_list = false, .number = 1018, .child_index = 19 },
1535	.{ .char = 'a', .end_of_word = false, .end_of_list = false, .number = 25, .child_index = 31 },	1537	.{ .char = 'a', .end_of_word = false, .end_of_list = false, .number = 25, .child_index = 31 },
1536	.{ .char = 'b', .end_of_word = false, .end_of_list = false, .number = 3, .child_index = 36 },	1538	.{ .char = 'b', .end_of_word = false, .end_of_list = false, .number = 3, .child_index = 36 },
1537	.{ .char = 'c', .end_of_word = false, .end_of_list = false, .number = 82, .child_index = 38 },	1539	.{ .char = 'c', .end_of_word = false, .end_of_list = false, .number = 82, .child_index = 38 },
...	@@ -1553,7 +1555,7 @@ const dafsa = [_]Node{	...	@@ -1553,7 +1555,7 @@ const dafsa = [_]Node{
1553	.{ .char = 'E', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 102 },	1555	.{ .char = 'E', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 102 },
1554	.{ .char = 'I', .end_of_word = false, .end_of_list = false, .number = 29, .child_index = 103 },	1556	.{ .char = 'I', .end_of_word = false, .end_of_list = false, .number = 29, .child_index = 103 },
1555	.{ .char = 'R', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 104 },	1557	.{ .char = 'R', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 104 },
1556	.{ .char = '_', .end_of_word = false, .end_of_list = false, .number = 938, .child_index = 105 },	1558	.{ .char = '_', .end_of_word = false, .end_of_list = false, .number = 940, .child_index = 105 },
1557	.{ .char = 'a', .end_of_word = false, .end_of_list = false, .number = 2, .child_index = 123 },	1559	.{ .char = 'a', .end_of_word = false, .end_of_list = false, .number = 2, .child_index = 123 },
1558	.{ .char = 'b', .end_of_word = false, .end_of_list = false, .number = 11, .child_index = 125 },	1560	.{ .char = 'b', .end_of_word = false, .end_of_list = false, .number = 11, .child_index = 125 },
1559	.{ .char = 'e', .end_of_word = false, .end_of_list = false, .number = 3, .child_index = 127 },	1561	.{ .char = 'e', .end_of_word = false, .end_of_list = false, .number = 3, .child_index = 127 },
...	@@ -1637,7 +1639,7 @@ const dafsa = [_]Node{	...	@@ -1637,7 +1639,7 @@ const dafsa = [_]Node{
1637	.{ .char = 'e', .end_of_word = false, .end_of_list = true, .number = 1, .child_index = 238 },	1639	.{ .char = 'e', .end_of_word = false, .end_of_list = true, .number = 1, .child_index = 238 },
1638	.{ .char = 'G', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 239 },	1640	.{ .char = 'G', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 239 },
1639	.{ .char = 'a', .end_of_word = false, .end_of_list = false, .number = 34, .child_index = 240 },	1641	.{ .char = 'a', .end_of_word = false, .end_of_list = false, .number = 34, .child_index = 240 },
1640	.{ .char = 'b', .end_of_word = false, .end_of_list = false, .number = 694, .child_index = 245 },	1642	.{ .char = 'b', .end_of_word = false, .end_of_list = false, .number = 696, .child_index = 245 },
1641	.{ .char = 'c', .end_of_word = false, .end_of_list = false, .number = 19, .child_index = 246 },	1643	.{ .char = 'c', .end_of_word = false, .end_of_list = false, .number = 19, .child_index = 246 },
1642	.{ .char = 'd', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 248 },	1644	.{ .char = 'd', .end_of_word = false, .end_of_list = false, .number = 1, .child_index = 248 },