Commit e7a622fb3331987c2b2128fb2657a5dea1b8aa33 | zig

author	Veikka Tuominen <git@vexu.eu> 2025-07-28 14:37:57+03:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-09-24 20:01:18-07:00
log	e7a622fb3331987c2b2128fb2657a5dea1b8aa33
tree	2cf7543818aaaf64bf969fddac93416580d26808
parent	e8e8d7e5c8eee5fe29add5aac0c07bf08a2debad

update aro and translate-c sources

24 files changed, 1577 insertions(+), 141 deletions(-)

build.zig
lib
- compiler
  - aro
    aro
    Compilation.zig
    DepFile.zig
    Diagnostics.zig
    Driver.zig
    Parser.zig
    Parser
    Diagnostic.zig
    Preprocessor.zig
    backend
    CodeGenOptions.zig
    include
    float.h
    iso646.h
    limits.h
    stdalign.h
    stdarg.h
    stdatomic.h
    stdbool.h
    stdckdint.h
    stddef.h
    stdint.h
    stdnoreturn.h
    varargs.h
  - translate-c
    Translator.zig
    main.zig
src
- libs
  - mingw.zig

build.zig-1

...	...	@@ -1144,7 +1144,6 @@ fn toNativePathSep(b: *std.Build, s: []const u8) []u8 {
1144	1144	const zig_cpp_sources = [_][]const u8{
1145	1145	// These are planned to stay even when we are self-hosted.
1146	1146	"src/zig_llvm.cpp",
1147		"src/zig_clang.cpp",
1148	1147	"src/zig_llvm-ar.cpp",
1149	1148	"src/zig_clang_driver.cpp",
1150	1149	"src/zig_clang_cc1_main.cpp",

lib/compiler/aro/aro/Compilation.zig+329-28

...	...	@@ -10,6 +10,7 @@ const CodeGenOptions = @import("../backend.zig").CodeGenOptions;
10	10	const Builtins = @import("Builtins.zig");
11	11	const Builtin = Builtins.Builtin;
12	12	const Diagnostics = @import("Diagnostics.zig");
	13	const DepFile = @import("DepFile.zig");
13	14	const LangOpts = @import("LangOpts.zig");
14	15	const Pragma = @import("Pragma.zig");
15	16	const record_layout = @import("record_layout.zig");
...	...	@@ -140,6 +141,7 @@ system_framework_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
140	141	/// Allocated into `gpa`, but keys are externally managed.
141	142	embed_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
142	143	target: std.Target = @import("builtin").target,
	144	cmodel: std.builtin.CodeModel = .default,
143	145	pragma_handlers: std.StringArrayHashMapUnmanaged(*Pragma) = .{},
144	146	langopts: LangOpts = .{},
145	147	generated_buf: std.ArrayListUnmanaged(u8) = .{},
...	...	@@ -349,30 +351,206 @@ fn generateSystemDefines(comp: Compilation, w: std.Io.Writer) !void {
349	351
350	352	// architecture macros
351	353	switch (comp.target.cpu.arch) {
352		.x86_64 => {
353		try define(w, "__amd64__");
354		try define(w, "__amd64");
355		try define(w, "__x86_64__");
356		try define(w, "__x86_64");
	354	.x86, .x86_64 => {
	355	try w.print("#define __code_model_{s}__ 1\n", .{switch (comp.cmodel) {
	356	.default => "small",
	357	else => @tagName(comp.cmodel),
	358	}});
	359
	360	if (comp.target.cpu.arch == .x86_64) {
	361	try define(w, "__amd64__");
	362	try define(w, "__amd64");
	363	try define(w, "__x86_64__");
	364	try define(w, "__x86_64");
	365
	366	if (comp.target.os.tag == .windows and comp.target.abi == .msvc) {
	367	try w.writeAll(
	368	\\#define _M_X64 100
	369	\\#define _M_AMD64 100
	370	\\
	371	);
	372	}
	373	} else {
	374	try defineStd(w, "i386", is_gnu);
	375
	376	if (comp.target.os.tag == .windows and comp.target.abi == .msvc) {
	377	try w.print("#define _M_IX86 {d}\n", .{blk: {
	378	if (comp.target.cpu.model == &std.Target.x86.cpu.i386) break :blk 300;
	379	if (comp.target.cpu.model == &std.Target.x86.cpu.i486) break :blk 400;
	380	if (comp.target.cpu.model == &std.Target.x86.cpu.i586) break :blk 500;
	381	break :blk @as(u32, 600);
	382	}});
	383	}
	384	}
	385	try define(w, "__SEG_GS");
	386	try define(w, "__SEG_FS");
	387	try w.writeAll(
	388	\\#define __seg_gs __attribute__((address_space(256)))
	389	\\#define __seg_fs __attribute__((address_space(257)))
	390	\\
	391	);
357	392
358		if (comp.target.os.tag == .windows and comp.target.abi == .msvc) {
359		try w.writeAll(
360		\\#define _M_X64 100
361		\\#define _M_AMD64 100
362		\\
363		);
	393	if (comp.target.cpu.has(.x86, .sahf) or (comp.langopts.emulate == .clang and comp.target.cpu.arch == .x86)) {
	394	try define(w, "__LAHF_SAHF__");
364	395	}
365		},
366		.x86 => {
367		try defineStd(w, "i386", is_gnu);
368	396
369		if (comp.target.os.tag == .windows and comp.target.abi == .msvc) {
370		try w.print("#define _M_IX86 {d}\n", .{blk: {
371		if (comp.target.cpu.model == &std.Target.x86.cpu.i386) break :blk 300;
372		if (comp.target.cpu.model == &std.Target.x86.cpu.i486) break :blk 400;
373		if (comp.target.cpu.model == &std.Target.x86.cpu.i586) break :blk 500;
374		break :blk @as(u32, 600);
375		}});
	397	const features = comp.target.cpu.features;
	398	for ([_]struct { std.Target.x86.Feature, []const u8 }{
	399	.{ .aes, "__AES__" },
	400	.{ .vaes, "__VAES__" },
	401	.{ .pclmul, "__PCLMUL__" },
	402	.{ .vpclmulqdq, "__VPCLMULQDQ__" },
	403	.{ .lzcnt, "__LZCNT__" },
	404	.{ .rdrnd, "__RDRND__" },
	405	.{ .fsgsbase, "__FSGSBASE__" },
	406	.{ .bmi, "__BMI__" },
	407	.{ .bmi2, "__BMI2__" },
	408	.{ .popcnt, "__POPCNT__" },
	409	.{ .rtm, "__RTM__" },
	410	.{ .prfchw, "__PRFCHW__" },
	411	.{ .rdseed, "__RDSEED__" },
	412	.{ .adx, "__ADX__" },
	413	.{ .tbm, "__TBM__" },
	414	.{ .lwp, "__LWP__" },
	415	.{ .mwaitx, "__MWAITX__" },
	416	.{ .movbe, "__MOVBE__" },
	417
	418	.{ .xop, "__XOP__" },
	419	.{ .fma4, "__FMA4__" },
	420	.{ .sse4a, "__SSE4A__" },
	421
	422	.{ .fma, "__FMA__" },
	423	.{ .f16c, "__F16C__" },
	424	.{ .gfni, "__GFNI__" },
	425	.{ .evex512, "__EVEX512__" },
	426	.{ .avx10_1_256, "__AVX10_1__" },
	427	.{ .avx10_1_512, "__AVX10_1_512__" },
	428	.{ .avx10_2_256, "__AVX10_2__" },
	429	.{ .avx10_2_512, "__AVX10_2_512__" },
	430	.{ .avx512cd, "__AVX512CD__" },
	431	.{ .avx512vpopcntdq, "__AVX512VPOPCNTDQ__" },
	432	.{ .avx512vnni, "__AVX512VNNI__" },
	433	.{ .avx512bf16, "__AVX512BF16__" },
	434	.{ .avx512fp16, "__AVX512FP16__" },
	435	.{ .avx512dq, "__AVX512DQ__" },
	436	.{ .avx512bitalg, "__AVX512BITALG__" },
	437	.{ .avx512bw, "__AVX512BW__" },
	438
	439	.{ .avx512vl, "__AVX512VL__" },
	440	.{ .avx512vl, "__EVEX256__" },
	441
	442	.{ .avx512vbmi, "__AVX512VBMI__" },
	443	.{ .avx512vbmi2, "__AVX512VBMI2__" },
	444	.{ .avx512ifma, "__AVX512IFMA__" },
	445	.{ .avx512vp2intersect, "__AVX512VP2INTERSECT__" },
	446	.{ .sha, "__SHA__" },
	447	.{ .sha512, "__SHA512__" },
	448	.{ .fxsr, "__FXSR__" },
	449	.{ .xsave, "__XSAVE__" },
	450	.{ .xsaveopt, "__XSAVEOPT__" },
	451	.{ .xsavec, "__XSAVEC__" },
	452	.{ .xsaves, "__XSAVES__" },
	453	.{ .pku, "__PKU__" },
	454	.{ .clflushopt, "__CLFLUSHOPT__" },
	455	.{ .clwb, "__CLWB__" },
	456	.{ .wbnoinvd, "__WBNOINVD__" },
	457	.{ .shstk, "__SHSTK__" },
	458	.{ .sgx, "__SGX__" },
	459	.{ .sm3, "__SM3__" },
	460	.{ .sm4, "__SM4__" },
	461	.{ .prefetchi, "__PREFETCHI__" },
	462	.{ .clzero, "__CLZERO__" },
	463	.{ .kl, "__KL__" },
	464	.{ .widekl, "__WIDEKL__" },
	465	.{ .rdpid, "__RDPID__" },
	466	.{ .rdpru, "__RDPRU__" },
	467	.{ .cldemote, "__CLDEMOTE__" },
	468	.{ .waitpkg, "__WAITPKG__" },
	469	.{ .movdiri, "__MOVDIRI__" },
	470	.{ .movdir64b, "__MOVDIR64B__" },
	471	.{ .movrs, "__MOVRS__" },
	472	.{ .pconfig, "__PCONFIG__" },
	473	.{ .ptwrite, "__PTWRITE__" },
	474	.{ .invpcid, "__INVPCID__" },
	475	.{ .enqcmd, "__ENQCMD__" },
	476	.{ .hreset, "__HRESET__" },
	477	.{ .amx_tile, "__AMX_TILE__" },
	478	.{ .amx_int8, "__AMX_INT8__" },
	479	.{ .amx_bf16, "__AMX_BF16__" },
	480	.{ .amx_fp16, "__AMX_FP16__" },
	481	.{ .amx_complex, "__AMX_COMPLEX__" },
	482	.{ .amx_fp8, "__AMX_FP8__" },
	483	.{ .amx_movrs, "__AMX_MOVRS__" },
	484	.{ .amx_transpose, "__AMX_TRANSPOSE__" },
	485	.{ .amx_avx512, "__AMX_AVX512__" },
	486	.{ .amx_tf32, "__AMX_TF32__" },
	487	.{ .cmpccxadd, "__CMPCCXADD__" },
	488	.{ .raoint, "__RAOINT__" },
	489	.{ .avxifma, "__AVXIFMA__" },
	490	.{ .avxneconvert, "__AVXNECONVERT__" },
	491	.{ .avxvnni, "__AVXVNNI__" },
	492	.{ .avxvnniint16, "__AVXVNNIINT16__" },
	493	.{ .avxvnniint8, "__AVXVNNIINT8__" },
	494	.{ .serialize, "__SERIALIZE__" },
	495	.{ .tsxldtrk, "__TSXLDTRK__" },
	496	.{ .uintr, "__UINTR__" },
	497	.{ .usermsr, "__USERMSR__" },
	498	.{ .crc32, "__CRC32__" },
	499	.{ .egpr, "__EGPR__" },
	500	.{ .push2pop2, "__PUSH2POP2__" },
	501	.{ .ppx, "__PPX__" },
	502	.{ .ndd, "__NDD__" },
	503	.{ .ccmp, "__CCMP__" },
	504	.{ .nf, "__NF__" },
	505	.{ .cf, "__CF__" },
	506	.{ .zu, "__ZU__" },
	507
	508	.{ .avx512f, "__AVX512F__" },
	509	.{ .avx2, "__AVX2__" },
	510	.{ .avx, "__AVX__" },
	511	.{ .sse4_2, "__SSE4_2__" },
	512	.{ .sse4_1, "__SSE4_1__" },
	513	.{ .ssse3, "__SSSE3__" },
	514	.{ .sse3, "__SSE3__" },
	515	.{ .sse2, "__SSE2__" },
	516	.{ .sse, "__SSE__" },
	517	.{ .sse, "__SSE_MATH__" },
	518
	519	.{ .mmx, "__MMX__" },
	520	}) \|fs\| {
	521	if (features.isEnabled(@intFromEnum(fs[0]))) {
	522	try define(w, fs[1]);
	523	}
	524	}
	525
	526	if (comp.langopts.ms_extensions and comp.target.cpu.arch == .x86) {
	527	const level = if (comp.target.cpu.has(.x86, .sse2))
	528	"2"
	529	else if (comp.target.cpu.has(.x86, .sse))
	530	"1"
	531	else
	532	"0";
	533
	534	try w.print("#define _M_IX86_FP {s}\n", .{level});
	535	}
	536
	537	if (comp.target.cpu.hasAll(.x86, &.{ .egpr, .push2pop2, .ppx, .ndd, .ccmp, .nf, .cf, .zu })) {
	538	try define(w, "__APX_F__");
	539	}
	540
	541	if (comp.target.cpu.hasAll(.x86, &.{ .egpr, .inline_asm_use_gpr32 })) {
	542	try define(w, "__APX_INLINE_ASM_USE_GPR32__");
	543	}
	544
	545	if (comp.target.cpu.has(.x86, .cx8)) {
	546	try define(w, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
	547	}
	548	if (comp.target.cpu.has(.x86, .cx16) and comp.target.cpu.arch == .x86_64) {
	549	try define(w, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
	550	}
	551
	552	if (comp.hasFloat128()) {
	553	try w.writeAll("#define __SIZEOF_FLOAT128__ 16\n");
376	554	}
377	555	},
378	556	.mips,
...	...	@@ -443,13 +621,132 @@ fn generateSystemDefines(comp: Compilation, w: std.Io.Writer) !void {
443	621	try define(w, "__arm64__");
444	622	}
445	623	if (comp.target.os.tag == .windows and comp.target.abi == .msvc) {
446		try w.writeAll("#define _M_ARM64 100\n");
	624	try w.writeAll("#define _M_ARM64 1\n");
	625	}
	626
	627	{
	628	const cmodel = switch (comp.cmodel) {
	629	.default => "small",
	630	else => @tagName(comp.cmodel),
	631	};
	632	try w.writeAll("#define __AARCH64_CMODEL_");
	633	for (cmodel) \|c\| {
	634	try w.writeByte(std.ascii.toUpper(c));
	635	}
	636	try w.writeAll("__ 1\n");
	637	}
	638
	639	if (comp.target.cpu.has(.aarch64, .fp_armv8)) {
	640	try w.writeAll("#define __ARM_FP 0xE\n");
	641	}
	642	if (comp.target.cpu.has(.aarch64, .neon)) {
	643	try define(w, "__ARM_NEON");
	644	try w.writeAll("#define __ARM_NEON_FP 0xE\n");
	645	}
	646	if (comp.target.cpu.has(.aarch64, .bf16)) {
	647	try define(w, "__ARM_FEATURE_BF16");
	648	try define(w, "__ARM_FEATURE_BF16_VECTOR_ARITHMETIC");
	649	try define(w, "__ARM_BF16_FORMAT_ALTERNATIVE");
	650	try define(w, "__ARM_FEATURE_BF16_SCALAR_ARITHMETIC");
	651	if (comp.target.cpu.has(.aarch64, .sve)) {
	652	try define(w, "__ARM_FEATURE_SVE_BF16");
	653	}
	654	}
	655	if (comp.target.cpu.hasAll(.aarch64, &.{ .sve2, .sve_aes })) {
	656	try define(w, "__ARM_FEATURE_SVE2_AES");
	657	}
	658	if (comp.target.cpu.hasAll(.aarch64, &.{ .sve2, .sve_bitperm })) {
	659	try define(w, "__ARM_FEATURE_SVE2_BITPERM");
	660	}
	661	if (comp.target.cpu.has(.aarch64, .sme)) {
	662	try define(w, "__ARM_FEATURE_SME");
	663	try define(w, "__ARM_FEATURE_LOCALLY_STREAMING");
	664	}
	665	if (comp.target.cpu.has(.aarch64, .fmv)) {
	666	try define(w, "__HAVE_FUNCTION_MULTI_VERSIONING");
	667	}
	668	if (comp.target.cpu.has(.aarch64, .sha3)) {
	669	try define(w, "__ARM_FEATURE_SHA3");
	670	try define(w, "__ARM_FEATURE_SHA512");
	671	}
	672	if (comp.target.cpu.has(.aarch64, .sm4)) {
	673	try define(w, "__ARM_FEATURE_SM3");
	674	try define(w, "__ARM_FEATURE_SM4");
	675	}
	676	if (!comp.target.cpu.has(.aarch64, .strict_align)) {
	677	try define(w, "__ARM_FEATURE_UNALIGNED");
	678	}
	679	if (comp.target.cpu.hasAll(.aarch64, &.{ .neon, .fullfp16 })) {
	680	try define(w, "__ARM_FEATURE_FP16_VECTOR_ARITHMETIC");
	681	}
	682	if (comp.target.cpu.has(.aarch64, .rcpc3)) {
	683	try w.writeAll("#define __ARM_FEATURE_RCPC 3\n");
	684	} else if (comp.target.cpu.has(.aarch64, .rcpc)) {
	685	try define(w, "__ARM_FEATURE_RCPC");
	686	}
	687
	688	const features = comp.target.cpu.features;
	689	for ([_]struct { std.Target.aarch64.Feature, []const u8 }{
	690	.{ .sve, "SVE" },
	691	.{ .sve2, "SVE2" },
	692	.{ .sve2p1, "SVE2p1" },
	693	.{ .sve2_sha3, "SVE2_SHA3" },
	694	.{ .sve2_sm4, "SVE2_SM4" },
	695	.{ .sve_b16b16, "SVE_B16B16" },
	696	.{ .sme2, "SME2" },
	697	.{ .sme2p1, "SME2p1" },
	698	.{ .sme_f16f16, "SME_F16F16" },
	699	.{ .sme_b16b16, "SME_B16B16" },
	700	.{ .crc, "CRC32" },
	701	.{ .aes, "AES" },
	702	.{ .sha2, "SHA2" },
	703	.{ .pauth, "PAUTH" },
	704	.{ .pauth_lr, "PAUTH_LR" },
	705	.{ .bti, "BTI" },
	706	.{ .fullfp16, "FP16_SCALAR_ARITHMETIC" },
	707	.{ .dotprod, "DOTPROD" },
	708	.{ .mte, "MEMORY_TAGGING" },
	709	.{ .tme, "TME" },
	710	.{ .i8mm, "MATMUL_INT8" },
	711	.{ .lse, "ATOMICS" },
	712	.{ .f64mm, "SVE_MATMUL_FP64" },
	713	.{ .f32mm, "SVE_MATMUL_FP32" },
	714	.{ .i8mm, "SVE_MATMUL_INT8" },
	715	.{ .fp16fml, "FP16_FML" },
	716	.{ .ls64, "LS64" },
	717	.{ .rand, "RNG" },
	718	.{ .mops, "MOPS" },
	719	.{ .d128, "SYSREG128" },
	720	.{ .gcs, "GCS" },
	721	}) \|fs\| {
	722	if (features.isEnabled(@intFromEnum(fs[0]))) {
	723	try w.print("#define __ARM_FEATURE_{s} 1\n", .{fs[1]});
	724	}
447	725	}
448	726	},
449	727	.msp430 => {
450	728	try define(w, "MSP430");
451	729	try define(w, "__MSP430__");
452	730	},
	731	.arc => {
	732	try define(w, "__arc__");
	733	},
	734	.wasm32, .wasm64 => {
	735	try define(w, "__wasm");
	736	try define(w, "__wasm__");
	737	if (comp.target.cpu.arch == .wasm32) {
	738	try define(w, "__wasm32");
	739	try define(w, "__wasm32__");
	740	} else {
	741	try define(w, "__wasm64");
	742	try define(w, "__wasm64__");
	743	}
	744
	745	for (comp.target.cpu.arch.allFeaturesList()) \|feature\| {
	746	if (!comp.target.cpu.features.isEnabled(feature.index)) continue;
	747	try w.print("#define __wasm_{s}__ 1\n", .{feature.name});
	748	}
	749	},
453	750	else => {},
454	751	}
455	752
...	...	@@ -1477,7 +1774,7 @@ fn getFileContents(comp: *Compilation, path: []const u8, limit: std.Io.Limit) ![
1477	1774
1478	1775	var file_buf: [4096]u8 = undefined;
1479	1776	var file_reader = file.reader(&file_buf);
1480		if (limit.minInt(try file_reader.getSize()) > std.math.maxInt(u32)) return error.FileTooBig;
	1777	if (limit.minInt64(try file_reader.getSize()) > std.math.maxInt(u32)) return error.FileTooBig;
1481	1778
1482	1779	_ = allocating.writer.sendFileAll(&file_reader, limit) catch \|err\| switch (err) {
1483	1780	error.WriteFailed => return error.OutOfMemory,
...	...	@@ -1494,14 +1791,16 @@ pub fn findEmbed(
1494	1791	/// angle bracket vs quotes
1495	1792	include_type: IncludeType,
1496	1793	limit: std.Io.Limit,
	1794	opt_dep_file: ?*DepFile,
1497	1795	) !?[]const u8 {
1498	1796	if (std.fs.path.isAbsolute(filename)) {
1499		return if (comp.getFileContents(filename, limit)) \|some\|
1500		some
1501		else \|err\| switch (err) {
	1797	if (comp.getFileContents(filename, limit)) \|some\| {
	1798	if (opt_dep_file) \|dep_file\| try dep_file.addDependencyDupe(comp.gpa, comp.arena, filename);
	1799	return some;
	1800	} else \|err\| switch (err) {
1502	1801	error.OutOfMemory => \|e\| return e,
1503		else => null,
1504		};
	1802	else => return null,
	1803	}
1505	1804	}
1506	1805
1507	1806	var stack_fallback = std.heap.stackFallback(path_buf_stack_limit, comp.gpa);
...	...	@@ -1516,6 +1815,7 @@ pub fn findEmbed(
1516	1815	std.mem.replaceScalar(u8, path, '\\', '/');
1517	1816	}
1518	1817	if (comp.getFileContents(path, limit)) \|some\| {
	1818	if (opt_dep_file) \|dep_file\| try dep_file.addDependencyDupe(comp.gpa, comp.arena, filename);
1519	1819	return some;
1520	1820	} else \|err\| switch (err) {
1521	1821	error.OutOfMemory => return error.OutOfMemory,
...	...	@@ -1531,6 +1831,7 @@ pub fn findEmbed(
1531	1831	std.mem.replaceScalar(u8, path, '\\', '/');
1532	1832	}
1533	1833	if (comp.getFileContents(path, limit)) \|some\| {
	1834	if (opt_dep_file) \|dep_file\| try dep_file.addDependencyDupe(comp.gpa, comp.arena, filename);
1534	1835	return some;
1535	1836	} else \|err\| switch (err) {
1536	1837	error.OutOfMemory => return error.OutOfMemory,

lib/compiler/aro/aro/DepFile.zig created+78

...	...	@@ -0,0 +1,78 @@
	1	const std = @import("std");
	2	const Allocator = std.mem.Allocator;
	3
	4	pub const Format = enum { make, nmake };
	5
	6	const DepFile = @This();
	7
	8	target: []const u8,
	9	deps: std.StringArrayHashMapUnmanaged(void) = .empty,
	10	format: Format,
	11
	12	pub fn deinit(d: *DepFile, gpa: Allocator) void {
	13	d.deps.deinit(gpa);
	14	d.* = undefined;
	15	}
	16
	17	pub fn addDependency(d: *DepFile, gpa: Allocator, path: []const u8) !void {
	18	try d.deps.put(gpa, path, {});
	19	}
	20
	21	pub fn addDependencyDupe(d: *DepFile, gpa: Allocator, arena: Allocator, path: []const u8) !void {
	22	const gop = try d.deps.getOrPut(gpa, path);
	23	if (gop.found_existing) return;
	24	gop.key_ptr.* = try arena.dupe(u8, path);
	25	}
	26
	27	pub fn write(d: const DepFile, w: std.Io.Writer) std.Io.Writer.Error!void {
	28	const max_columns = 75;
	29	var columns: usize = 0;
	30
	31	try w.writeAll(d.target);
	32	columns += d.target.len;
	33	try w.writeByte(':');
	34	columns += 1;
	35
	36	for (d.deps.keys()) \|path\| {
	37	if (std.mem.eql(u8, path, "<stdin>")) continue;
	38
	39	if (columns + path.len + " \\\n".len > max_columns) {
	40	try w.writeAll(" \\\n ");
	41	columns = 1;
	42	}
	43	try w.writeByte(' ');
	44	try d.writePath(path, w);
	45	columns += path.len + 1;
	46	}
	47	try w.writeByte('\n');
	48	try w.flush();
	49	}
	50
	51	fn writePath(d: const DepFile, path: []const u8, w: std.Io.Writer) !void {
	52	switch (d.format) {
	53	.nmake => {
	54	if (std.mem.indexOfAny(u8, path, " #${}^!")) \|_\|
	55	try w.print("\"{s}\"", .{path})
	56	else
	57	try w.writeAll(path);
	58	},
	59	.make => {
	60	for (path, 0..) \|c, i\| {
	61	if (c == '#') {
	62	try w.writeByte('\\');
	63	} else if (c == '$') {
	64	try w.writeByte('$');
	65	} else if (c == ' ') {
	66	try w.writeByte('\\');
	67	var j = i;
	68	while (j != 0) {
	69	j -= 1;
	70	if (path[j] != '\\') break;
	71	try w.writeByte('\\');
	72	}
	73	}
	74	try w.writeByte(c);
	75	}
	76	},
	77	}
	78	}

lib/compiler/aro/aro/Diagnostics.zig+55-46

...	...	@@ -23,6 +23,52 @@ pub const Message = struct {
23	23	@"error",
24	24	@"fatal error",
25	25	};
	26
	27	pub fn write(msg: Message, w: *std.Io.Writer, config: std.Io.tty.Config, details: bool) std.Io.tty.Config.SetColorError!void {
	28	try config.setColor(w, .bold);
	29	if (msg.location) \|loc\| {
	30	try w.print("{s}:{d}:{d}: ", .{ loc.path, loc.line_no, loc.col });
	31	}
	32	switch (msg.effective_kind) {
	33	.@"fatal error", .@"error" => try config.setColor(w, .bright_red),
	34	.note => try config.setColor(w, .bright_cyan),
	35	.warning => try config.setColor(w, .bright_magenta),
	36	.off => unreachable,
	37	}
	38	try w.print("{s}: ", .{@tagName(msg.effective_kind)});
	39
	40	try config.setColor(w, .white);
	41	try w.writeAll(msg.text);
	42	if (msg.opt) \|some\| {
	43	if (msg.effective_kind == .@"error" and msg.kind != .@"error") {
	44	try w.print(" [-Werror,-W{s}]", .{@tagName(some)});
	45	} else if (msg.effective_kind != .note) {
	46	try w.print(" [-W{s}]", .{@tagName(some)});
	47	}
	48	} else if (msg.extension) {
	49	if (msg.effective_kind == .@"error") {
	50	try w.writeAll(" [-Werror,-Wpedantic]");
	51	} else if (msg.effective_kind != msg.kind) {
	52	try w.writeAll(" [-Wpedantic]");
	53	}
	54	}
	55
	56	if (!details or msg.location == null) {
	57	try w.writeAll("\n");
	58	try config.setColor(w, .reset);
	59	} else {
	60	const loc = msg.location.?;
	61	const trailer = if (loc.end_with_splice) "\\ " else "";
	62	try config.setColor(w, .reset);
	63	try w.print("\n{s}{s}\n", .{ loc.line, trailer });
	64	try w.splatByteAll(' ', loc.width);
	65	try config.setColor(w, .bold);
	66	try config.setColor(w, .bright_green);
	67	try w.writeAll("^\n");
	68	try config.setColor(w, .reset);
	69	}
	70	try w.flush();
	71	}
26	72	};
27	73
28	74	pub const Option = enum {
...	...	@@ -247,6 +293,11 @@ output: union(enum) {
247	293	},
248	294	ignore,
249	295	},
	296	/// Force usage of color in output.
	297	color: ?bool = null,
	298	/// Include line of code in output.
	299	details: bool = true,
	300
250	301	state: State = .{},
251	302	/// Amount of error or fatal error messages that have been sent to `output`.
252	303	errors: u32 = 0,
...	...	@@ -468,7 +519,10 @@ fn addMessage(d: *Diagnostics, msg: Message) Compilation.Error!void {
468	519	switch (d.output) {
469	520	.ignore => {},
470	521	.to_writer => \|writer\| {
471		writeToWriter(msg, writer.writer, writer.color) catch {
	522	var config = writer.color;
	523	if (d.color == false) config = .no_color;
	524	if (d.color == true and config == .no_color) config = .escape_codes;
	525	msg.write(writer.writer, config, d.details) catch {
472	526	return error.FatalError;
473	527	};
474	528	},
...	...	@@ -485,48 +539,3 @@ fn addMessage(d: *Diagnostics, msg: Message) Compilation.Error!void {
485	539	},
486	540	}
487	541	}
488
489		pub fn writeToWriter(msg: Message, w: *std.Io.Writer, config: std.Io.tty.Config) !void {
490		try config.setColor(w, .bold);
491		if (msg.location) \|loc\| {
492		try w.print("{s}:{d}:{d}: ", .{ loc.path, loc.line_no, loc.col });
493		}
494		switch (msg.effective_kind) {
495		.@"fatal error", .@"error" => try config.setColor(w, .bright_red),
496		.note => try config.setColor(w, .bright_cyan),
497		.warning => try config.setColor(w, .bright_magenta),
498		.off => unreachable,
499		}
500		try w.print("{s}: ", .{@tagName(msg.effective_kind)});
501
502		try config.setColor(w, .white);
503		try w.writeAll(msg.text);
504		if (msg.opt) \|some\| {
505		if (msg.effective_kind == .@"error" and msg.kind != .@"error") {
506		try w.print(" [-Werror,-W{s}]", .{@tagName(some)});
507		} else if (msg.effective_kind != .note) {
508		try w.print(" [-W{s}]", .{@tagName(some)});
509		}
510		} else if (msg.extension) {
511		if (msg.effective_kind == .@"error") {
512		try w.writeAll(" [-Werror,-Wpedantic]");
513		} else if (msg.effective_kind != msg.kind) {
514		try w.writeAll(" [-Wpedantic]");
515		}
516		}
517
518		if (msg.location) \|loc\| {
519		const trailer = if (loc.end_with_splice) "\\ " else "";
520		try config.setColor(w, .reset);
521		try w.print("\n{s}{s}\n", .{ loc.line, trailer });
522		try w.splatByteAll(' ', loc.width);
523		try config.setColor(w, .bold);
524		try config.setColor(w, .bright_green);
525		try w.writeAll("^\n");
526		try config.setColor(w, .reset);
527		} else {
528		try w.writeAll("\n");
529		try config.setColor(w, .reset);
530		}
531		try w.flush();
532		}

lib/compiler/aro/aro/Driver.zig+242-43

...	...	@@ -10,6 +10,7 @@ const Object = backend.Object;
10	10
11	11	const Compilation = @import("Compilation.zig");
12	12	const Diagnostics = @import("Diagnostics.zig");
	13	const DepFile = @import("DepFile.zig");
13	14	const GCCVersion = @import("Driver/GCCVersion.zig");
14	15	const LangOpts = @import("LangOpts.zig");
15	16	const Preprocessor = @import("Preprocessor.zig");
...	...	@@ -63,7 +64,6 @@ verbose_ast: bool = false,
63	64	verbose_pp: bool = false,
64	65	verbose_ir: bool = false,
65	66	verbose_linker_args: bool = false,
66		color: ?bool = null,
67	67	nobuiltininc: bool = false,
68	68	nostdinc: bool = false,
69	69	nostdlibinc: bool = false,
...	...	@@ -73,7 +73,6 @@ mabicalls: ?bool = null,
73	73	dynamic_nopic: ?bool = null,
74	74	ropi: bool = false,
75	75	rwpi: bool = false,
76		cmodel: std.builtin.CodeModel = .default,
77	76	debug_dump_letters: packed struct(u3) {
78	77	d: bool = false,
79	78	m: bool = false,
...	...	@@ -88,17 +87,27 @@ debug_dump_letters: packed struct(u3) {
88	87	return .result_only;
89	88	}
90	89	} = .{},
	90	dependencies: struct {
	91	m: bool = false,
	92	md: bool = false,
	93	format: DepFile.Format = .make,
	94	file: ?[]const u8 = null,
	95	} = .{},
91	96
92	97	/// Full path to the aro executable
93	98	aro_name: []const u8 = "",
94	99
95		/// Value of --triple= passed via CLI
	100	/// Value of -target passed via CLI
96	101	raw_target_triple: ?[]const u8 = null,
97	102
	103	/// Value of -mcpu passed via CLI
	104	raw_cpu: ?[]const u8 = null,
	105
98	106	/// Non-optimizing assembly backend is currently selected by passing `-O0`
99	107	use_assembly_backend: bool = false,
100	108
101	109	// linker options
	110	use_linker: ?[]const u8 = null,
102	111	linker_path: ?[]const u8 = null,
103	112	nodefaultlibs: bool = false,
104	113	nolibc: bool = false,
...	...	@@ -133,13 +142,26 @@ pub const usage =
133	142	\\ --help Print this message
134	143	\\ --version Print aro version
135	144	\\
136		\\Compile options:
137		\\ -c, --compile Only run preprocess, compile, and assemble steps
	145	\\Preprocessor options:
	146	\\ -C Do not discard comments
	147	\\ -CC Do not discard comments, including in macro expansions
138	148	\\ -dM Output #define directives for all the macros defined during the execution of the preprocessor
139	149	\\ -dD Like -dM except that it outputs both the #define directives and the result of preprocessing
140	150	\\ -dN Like -dD, but emit only the macro names, not their expansions.
141	151	\\ -D <macro>=<value> Define <macro> to <value> (defaults to 1)
142	152	\\ -E Only run the preprocessor
	153	\\ -fdollars-in-identifiers
	154	\\ Allow '$' in identifiers
	155	\\ -fno-dollars-in-identifiers
	156	\\ Disallow '$' in identifiers
	157	\\ -M Output dependency file instead of preprocessing result
	158	\\ -MD Like -M except -E is not implied
	159	\\ -MF <file> Write dependency file to <file>
	160	\\ -MV Use NMake/Jom format for dependency file
	161	\\ -P, --no-line-commands Disable linemarker output in -E mode
	162	\\
	163	\\Compile options:
	164	\\ -c, --compile Only run preprocess, compile, and assemble steps
143	165	\\ -fapple-kext Use Apple's kernel extensions ABI
144	166	\\ -fchar8_t Enable char8_t (enabled by default in C23 and later)
145	167	\\ -fno-char8_t Disable char8_t (disabled by default for pre-C23)
...	...	@@ -158,10 +180,6 @@ pub const usage =
158	180	\\ -fhosted Compilation in a hosted environment
159	181	\\ -fms-extensions Enable support for Microsoft extensions
160	182	\\ -fno-ms-extensions Disable support for Microsoft extensions
161		\\ -fdollars-in-identifiers
162		\\ Allow '$' in identifiers
163		\\ -fno-dollars-in-identifiers
164		\\ Disallow '$' in identifiers
165	183	\\ -g Generate debug information
166	184	\\ -fmacro-backtrace-limit=<limit>
167	185	\\ Set limit on how many macro expansion traces are shown in errors (default 6)
...	...	@@ -197,6 +215,7 @@ pub const usage =
197	215	\\ -mabicalls Enable SVR4-style position-independent code (Mips only)
198	216	\\ -mno-abicalls Disable SVR4-style position-independent code (Mips only)
199	217	\\ -mcmodel=<code-model> Generate code for the given code model
	218	\\ -mcpu [cpu] Specify target CPU and feature set
200	219	\\ -mkernel Enable kernel development mode
201	220	\\ -nobuiltininc Do not search the compiler's builtin directory for include files
202	221	\\ -resource-dir <dir> Override the path to the compiler's builtin resource directory
...	...	@@ -204,7 +223,6 @@ pub const usage =
204	223	\\ Do not search the standard system directories or compiler builtin directories for include files.
205	224	\\ -nostdlibinc Do not search the standard system directories for include files, but do search compiler builtin include directories
206	225	\\ -o <file> Write output to <file>
207		\\ -P, --no-line-commands Disable linemarker output in -E mode
208	226	\\ -pedantic Warn on language extensions
209	227	\\ -pedantic-errors Error on language extensions
210	228	\\ --rtlib=<arg> Compiler runtime library to use (libgcc or compiler-rt)
...	...	@@ -262,9 +280,12 @@ pub fn parseArgs(
262	280	var pic_arg: []const u8 = "";
263	281	var declspec_attrs: ?bool = null;
264	282	var ms_extensions: ?bool = null;
	283	var strip = true;
	284	var debug: ?backend.CodeGenOptions.DebugFormat = null;
	285	var emulate: ?LangOpts.Compiler = null;
265	286	while (i < args.len) : (i += 1) {
266	287	const arg = args[i];
267		if (mem.startsWith(u8, arg, "-") and arg.len > 1) {
	288	if (arg.len > 1 and arg[0] == '-') {
268	289	if (mem.eql(u8, arg, "--help")) {
269	290	try stdout.print(usage, .{args[0]});
270	291	try stdout.flush();
...	...	@@ -329,7 +350,7 @@ pub fn parseArgs(
329	350	} else if (mem.eql(u8, arg, "-fapple-kext")) {
330	351	d.apple_kext = true;
331	352	} else if (option(arg, "-mcmodel=")) \|cmodel\| {
332		d.cmodel = std.meta.stringToEnum(std.builtin.CodeModel, cmodel) orelse
	353	d.comp.cmodel = std.meta.stringToEnum(std.builtin.CodeModel, cmodel) orelse
333	354	return d.fatal("unsupported machine code model: '{s}'", .{arg});
334	355	} else if (mem.eql(u8, arg, "-mkernel")) {
335	356	d.mkernel = true;
...	...	@@ -339,14 +360,47 @@ pub fn parseArgs(
339	360	d.mabicalls = true;
340	361	} else if (mem.eql(u8, arg, "-mno-abicalls")) {
341	362	d.mabicalls = false;
	363	} else if (mem.eql(u8, arg, "-mcpu")) {
	364	i += 1;
	365	if (i >= args.len) {
	366	try d.err("expected argument after -mcpu", .{});
	367	continue;
	368	}
	369	d.raw_cpu = args[i];
	370	} else if (option(arg, "-mcpu=")) \|cpu\| {
	371	d.raw_cpu = cpu;
	372	} else if (mem.eql(u8, arg, "-M") or mem.eql(u8, arg, "--dependencies")) {
	373	d.dependencies.m = true;
	374	// -M implies -w and -E
	375	d.diagnostics.state.ignore_warnings = true;
	376	d.only_preprocess = true;
	377	} else if (mem.eql(u8, arg, "-MD") or mem.eql(u8, arg, "--write-dependencies")) {
	378	d.dependencies.md = true;
	379	} else if (mem.startsWith(u8, arg, "-MF")) {
	380	var path = arg["-MF".len..];
	381	if (path.len == 0) {
	382	i += 1;
	383	if (i >= args.len) {
	384	try d.err("expected argument after -MF", .{});
	385	continue;
	386	}
	387	path = args[i];
	388	}
	389	d.dependencies.file = path;
	390	} else if (mem.eql(u8, arg, "-MV")) {
	391	d.dependencies.format = .nmake;
342	392	} else if (mem.eql(u8, arg, "-fchar8_t")) {
343	393	d.comp.langopts.has_char8_t_override = true;
344	394	} else if (mem.eql(u8, arg, "-fno-char8_t")) {
345	395	d.comp.langopts.has_char8_t_override = false;
346	396	} else if (mem.eql(u8, arg, "-fcolor-diagnostics")) {
347		d.color = true;
	397	d.diagnostics.color = true;
348	398	} else if (mem.eql(u8, arg, "-fno-color-diagnostics")) {
349		d.color = false;
	399	d.diagnostics.color = false;
	400	} else if (mem.eql(u8, arg, "-fcaret-diagnostics")) {
	401	d.diagnostics.details = true;
	402	} else if (mem.eql(u8, arg, "-fno-caret-diagnostics")) {
	403	d.diagnostics.details = false;
350	404	} else if (mem.eql(u8, arg, "-fcommon")) {
351	405	d.comp.code_gen_options.common = true;
352	406	} else if (mem.eql(u8, arg, "-fno-common")) {
...	...	@@ -356,9 +410,31 @@ pub fn parseArgs(
356	410	} else if (mem.eql(u8, arg, "-fno-dollars-in-identifiers")) {
357	411	d.comp.langopts.dollars_in_identifiers = false;
358	412	} else if (mem.eql(u8, arg, "-g")) {
359		d.comp.code_gen_options.debug = true;
	413	strip = false;
360	414	} else if (mem.eql(u8, arg, "-g0")) {
361		d.comp.code_gen_options.debug = false;
	415	strip = true;
	416	} else if (mem.eql(u8, arg, "-gcodeview")) {
	417	debug = .code_view;
	418	} else if (mem.eql(u8, arg, "-gdwarf32")) {
	419	debug = .{ .dwarf = .@"32" };
	420	} else if (mem.eql(u8, arg, "-gdwarf64")) {
	421	debug = .{ .dwarf = .@"64" };
	422	} else if (mem.eql(u8, arg, "-gdwarf") or
	423	mem.eql(u8, arg, "-gdwarf-2") or
	424	mem.eql(u8, arg, "-gdwarf-3") or
	425	mem.eql(u8, arg, "-gdwarf-4") or
	426	mem.eql(u8, arg, "-gdwarf-5"))
	427	{
	428	d.comp.code_gen_options.dwarf_version = switch (arg[arg.len - 1]) {
	429	'2' => .@"2",
	430	'3' => .@"3",
	431	'4' => .@"4",
	432	'5' => .@"5",
	433	else => .@"0",
	434	};
	435	if (debug == null or debug.? != .dwarf) {
	436	debug = .{ .dwarf = .@"32" };
	437	}
362	438	} else if (mem.eql(u8, arg, "-fdigraphs")) {
363	439	d.comp.langopts.digraphs = true;
364	440	} else if (mem.eql(u8, arg, "-fno-digraphs")) {
...	...	@@ -413,9 +489,9 @@ pub fn parseArgs(
413	489	ms_extensions = true;
414	490	} else if (mem.eql(u8, arg, "-fno-ms-extensions")) {
415	491	ms_extensions = false;
416		} else if (mem.startsWith(u8, arg, "-fsyntax-only")) {
	492	} else if (mem.eql(u8, arg, "-fsyntax-only")) {
417	493	d.only_syntax = true;
418		} else if (mem.startsWith(u8, arg, "-fno-syntax-only")) {
	494	} else if (mem.eql(u8, arg, "-fno-syntax-only")) {
419	495	d.only_syntax = false;
420	496	} else if (mem.eql(u8, arg, "-fgnuc-version=")) {
421	497	gnuc_version = "0";
...	...	@@ -483,12 +559,7 @@ pub fn parseArgs(
483	559	try d.err("invalid compiler '{s}'", .{arg});
484	560	continue;
485	561	};
486		d.comp.langopts.setEmulatedCompiler(compiler);
487		switch (d.comp.langopts.emulate) {
488		.clang => try d.diagnostics.set("clang", .off),
489		.gcc => try d.diagnostics.set("gnu", .off),
490		.msvc => try d.diagnostics.set("microsoft", .off),
491		}
	562	emulate = compiler;
492	563	} else if (option(arg, "-ffp-eval-method=")) \|fp_method_str\| {
493	564	const fp_eval_method = std.meta.stringToEnum(LangOpts.FPEvalMethod, fp_method_str) orelse .indeterminate;
494	565	if (fp_eval_method == .indeterminate) {
...	...	@@ -554,8 +625,10 @@ pub fn parseArgs(
554	625	continue;
555	626	}
556	627	d.raw_target_triple = args[i];
	628	emulate = null;
557	629	} else if (option(arg, "--target=")) \|triple\| {
558	630	d.raw_target_triple = triple;
	631	emulate = null;
559	632	} else if (mem.eql(u8, arg, "--verbose-ast")) {
560	633	d.verbose_ast = true;
561	634	} else if (mem.eql(u8, arg, "--verbose-pp")) {
...	...	@@ -571,6 +644,10 @@ pub fn parseArgs(
571	644	d.comp.langopts.preserve_comments = true;
572	645	d.comp.langopts.preserve_comments_in_macros = true;
573	646	comment_arg = arg;
	647	} else if (option(arg, "-fuse-ld=")) \|linker_name\| {
	648	d.use_linker = linker_name;
	649	} else if (mem.eql(u8, arg, "-fuse-ld=")) {
	650	d.use_linker = null;
574	651	} else if (option(arg, "--ld-path=")) \|linker_path\| {
575	652	d.linker_path = linker_path;
576	653	} else if (mem.eql(u8, arg, "-r")) {
...	...	@@ -624,6 +701,33 @@ pub fn parseArgs(
624	701	} else {
625	702	try d.err("invalid unwind library name '{s}'", .{unwindlib});
626	703	}
	704	} else if (mem.startsWith(u8, arg, "-x")) {
	705	var lang = arg["-x".len..];
	706	if (lang.len == 0) {
	707	i += 1;
	708	if (i >= args.len) {
	709	try d.err("expected argument after -x", .{});
	710	continue;
	711	}
	712	lang = args[i];
	713	}
	714	if (!mem.eql(u8, lang, "none") and !mem.eql(u8, lang, "c")) {
	715	try d.err("language not recognized: '{s}'", .{lang});
	716	}
	717	} else if (mem.startsWith(u8, arg, "-flto")) {
	718	const rest = arg["-flto".len..];
	719	if (rest.len == 0 or
	720	mem.eql(u8, rest, "=auto") or
	721	mem.eql(u8, rest, "=full") or
	722	mem.eql(u8, rest, "=jobserver") or
	723	mem.eql(u8, rest, "=thin"))
	724	{
	725	try d.warn("lto not supported", .{});
	726	} else {
	727	return d.fatal("invalid lto mode: '{s}'", .{arg});
	728	}
	729	} else if (mem.eql(u8, arg, "-fno-lto")) {
	730	// nothing to do
627	731	} else {
628	732	try d.warn("unknown argument '{s}'", .{arg});
629	733	}
...	...	@@ -636,17 +740,33 @@ pub fn parseArgs(
636	740	try d.inputs.append(d.comp.gpa, source);
637	741	}
638	742	}
639		if (d.raw_target_triple) \|triple\| triple: {
640		const query = std.Target.Query.parse(.{ .arch_os_abi = triple }) catch {
641		try d.err("invalid target '{s}'", .{triple});
642		d.raw_target_triple = null;
643		break :triple;
	743	{
	744	var diags: std.Target.Query.ParseOptions.Diagnostics = .{};
	745	const opts: std.Target.Query.ParseOptions = .{
	746	.arch_os_abi = d.raw_target_triple orelse "native",
	747	.cpu_features = d.raw_cpu,
	748	.diagnostics = &diags,
	749	};
	750	const query = std.Target.Query.parse(opts) catch \|er\| switch (er) {
	751	error.UnknownCpuModel => {
	752	return d.fatal("unknown CPU: '{s}'", .{diags.cpu_name.?});
	753	},
	754	error.UnknownCpuFeature => {
	755	return d.fatal("unknown CPU feature: '{s}'", .{diags.unknown_feature_name.?});
	756	},
	757	error.UnknownArchitecture => {
	758	return d.fatal("unknown architecture: '{s}'", .{diags.unknown_architecture_name.?});
	759	},
	760	else => \|e\| return d.fatal("unable to parse target query '{s}': {s}", .{
	761	opts.arch_os_abi, @errorName(e),
	762	}),
644	763	};
645		const target = std.zig.system.resolveTargetQuery(query) catch \|e\| {
	764	d.comp.target = std.zig.system.resolveTargetQuery(query) catch \|e\| {
646	765	return d.fatal("unable to resolve target: {s}", .{errorDescription(e)});
647	766	};
648		d.comp.target = target;
649		d.comp.langopts.setEmulatedCompiler(target_util.systemCompiler(target));
	767	}
	768	if (emulate != null or d.raw_target_triple != null) {
	769	d.comp.langopts.setEmulatedCompiler(emulate orelse target_util.systemCompiler(d.comp.target));
650	770	switch (d.comp.langopts.emulate) {
651	771	.clang => try d.diagnostics.set("clang", .off),
652	772	.gcc => try d.diagnostics.set("gnu", .off),
...	...	@@ -673,6 +793,19 @@ pub fn parseArgs(
673	793	const pic_level, const is_pie = try d.getPICMode(pic_arg);
674	794	d.comp.code_gen_options.pic_level = pic_level;
675	795	d.comp.code_gen_options.is_pie = is_pie;
	796	d.comp.code_gen_options.debug = debug: {
	797	if (strip) break :debug .strip;
	798	if (debug) \|explicit\| break :debug explicit;
	799	break :debug switch (d.comp.target.ofmt) {
	800	.elf, .goff, .macho, .wasm, .xcoff => .{ .dwarf = .@"32" },
	801	.coff => .code_view,
	802	.c => switch (d.comp.target.os.tag) {
	803	.windows, .uefi => .code_view,
	804	else => .{ .dwarf = .@"32" },
	805	},
	806	.spirv, .hex, .raw, .plan9 => .strip,
	807	};
	808	};
676	809	if (declspec_attrs) \|some\| d.comp.langopts.declspec_attrs = some;
677	810	if (ms_extensions) \|some\| d.comp.langopts.setMSExtensions(some);
678	811	return false;
...	...	@@ -728,6 +861,7 @@ pub fn fatal(d: *Driver, comptime fmt: []const u8, args: anytype) error{ FatalEr
728	861	}
729	862
730	863	pub fn printDiagnosticsStats(d: *Driver) void {
	864	if (!d.diagnostics.details) return;
731	865	const warnings = d.diagnostics.warnings;
732	866	const errors = d.diagnostics.errors;
733	867
...	...	@@ -743,14 +877,14 @@ pub fn printDiagnosticsStats(d: *Driver) void {
743	877	}
744	878
745	879	pub fn detectConfig(d: *Driver, file: std.fs.File) std.Io.tty.Config {
746		if (d.color == true) return .escape_codes;
747		if (d.color == false) return .no_color;
	880	if (d.diagnostics.color == false) return .no_color;
	881	const force_color = d.diagnostics.color == true;
748	882
749	883	if (file.supportsAnsiEscapeCodes()) return .escape_codes;
750	884	if (@import("builtin").os.tag == .windows and file.isTty()) {
751	885	var info: std.os.windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
752		if (std.os.windows.kernel32.GetConsoleScreenBufferInfo(file.handle, &info) != std.os.windows.TRUE) {
753		return .no_color;
	886	if (std.os.windows.kernel32.GetConsoleScreenBufferInfo(file.handle, &info) == std.os.windows.FALSE) {
	887	return if (force_color) .escape_codes else .no_color;
754	888	}
755	889	return .{ .windows_api = .{
756	890	.handle = file.handle,
...	...	@@ -758,7 +892,7 @@ pub fn detectConfig(d: *Driver, file: std.fs.File) std.Io.tty.Config {
758	892	} };
759	893	}
760	894
761		return .no_color;
	895	return if (force_color) .escape_codes else .no_color;
762	896	}
763	897
764	898	pub fn errorDescription(e: anyerror) []const u8 {
...	...	@@ -851,6 +985,47 @@ pub fn main(d: Driver, tc: Toolchain, args: []const []const u8, comptime fast_
851	985	if (fast_exit) std.process.exit(0);
852	986	}
853	987
	988	/// Initializes a DepFile if requested by driver options.
	989	pub fn initDepFile(d: Driver, source: Source, buf: [std.fs.max_name_bytes]u8) Compilation.Error!?DepFile {
	990	if (!d.dependencies.m and !d.dependencies.md) return null;
	991	var dep_file: DepFile = .{
	992	.target = undefined,
	993	.format = d.dependencies.format,
	994	};
	995
	996	if (d.dependencies.md and d.output_name != null) {
	997	dep_file.target = d.output_name.?;
	998	} else {
	999	const args = .{
	1000	std.fs.path.stem(source.path),
	1001	d.comp.target.ofmt.fileExt(d.comp.target.cpu.arch),
	1002	};
	1003	dep_file.target = std.fmt.bufPrint(buf, "{s}{s}", args) catch
	1004	return d.fatal("dependency file name too long for filesystem '{s}{s}'", args);
	1005	}
	1006
	1007	try dep_file.addDependency(d.comp.gpa, source.path);
	1008	errdefer comptime unreachable;
	1009
	1010	return dep_file;
	1011	}
	1012
	1013	/// Returns name requested for the dependency file or null for stdout.
	1014	pub fn getDepFileName(d: Driver, source: Source, buf: [std.fs.max_name_bytes]u8) Compilation.Error!?[]const u8 {
	1015	if (d.dependencies.file) \|file\| {
	1016	if (std.mem.eql(u8, file, "-")) return null;
	1017	return file;
	1018	}
	1019	if (!d.dependencies.md) {
	1020	if (d.output_name) \|name\| return name;
	1021	return null;
	1022	}
	1023
	1024	const base_name = std.fs.path.stem(d.output_name orelse source.path);
	1025	return std.fmt.bufPrint(buf, "{s}.d", .{base_name}) catch
	1026	return d.fatal("dependency file name too long for filesystem: {s}.d", .{base_name});
	1027	}
	1028
854	1029	fn getRandomFilename(d: Driver, buf: [std.fs.max_name_bytes]u8, extension: []const u8) ![]const u8 {
855	1030	const random_bytes_count = 12;
856	1031	const sub_path_len = comptime std.fs.base64_encoder.calcSize(random_bytes_count);
...	...	@@ -925,6 +1100,12 @@ fn processSource(
925	1100	var pp = try Preprocessor.initDefault(d.comp);
926	1101	defer pp.deinit();
927	1102
	1103	var name_buf: [std.fs.max_name_bytes]u8 = undefined;
	1104	var opt_dep_file = try d.initDepFile(source, &name_buf);
	1105	defer if (opt_dep_file) \|*dep_file\| dep_file.deinit(pp.gpa);
	1106
	1107	if (opt_dep_file) \|*dep_file\| pp.dep_file = dep_file;
	1108
928	1109	if (d.comp.langopts.ms_extensions) {
929	1110	d.comp.ms_cwd_source_id = source.id;
930	1111	}
...	...	@@ -943,6 +1124,22 @@ fn processSource(
943	1124
944	1125	try pp.preprocessSources(&.{ source, builtin, user_macros });
945	1126
	1127	var writer_buf: [4096]u8 = undefined;
	1128	if (opt_dep_file) \|dep_file\| {
	1129	const dep_file_name = try d.getDepFileName(source, writer_buf[0..std.fs.max_name_bytes]);
	1130
	1131	const file = if (dep_file_name) \|path\|
	1132	d.comp.cwd.createFile(path, .{}) catch \|er\|
	1133	return d.fatal("unable to create dependency file '{s}': {s}", .{ path, errorDescription(er) })
	1134	else
	1135	std.fs.File.stdout();
	1136	defer if (dep_file_name != null) file.close();
	1137
	1138	var file_writer = file.writer(&writer_buf);
	1139	dep_file.write(&file_writer.interface) catch
	1140	return d.fatal("unable to write dependency file: {s}", .{errorDescription(file_writer.err.?)});
	1141	}
	1142
946	1143	if (d.only_preprocess) {
947	1144	d.printDiagnosticsStats();
948	1145
...	...	@@ -951,6 +1148,11 @@ fn processSource(
951	1148	return;
952	1149	}
953	1150
	1151	if (d.dependencies.m and !d.dependencies.md) {
	1152	if (fast_exit) std.process.exit(1); // Not linking, no need for cleanup.
	1153	return;
	1154	}
	1155
954	1156	const file = if (d.output_name) \|some\|
955	1157	d.comp.cwd.createFile(some, .{}) catch \|er\|
956	1158	return d.fatal("unable to create output file '{s}': {s}", .{ some, errorDescription(er) })
...	...	@@ -997,7 +1199,6 @@ fn processSource(
997	1199	);
998	1200	}
999	1201
1000		var name_buf: [std.fs.max_name_bytes]u8 = undefined;
1001	1202	const out_file_name = try d.getOutFileName(source, &name_buf);
1002	1203
1003	1204	if (d.use_assembly_backend) {
...	...	@@ -1039,8 +1240,7 @@ fn processSource(
1039	1240	defer ir.deinit(d.comp.gpa);
1040	1241
1041	1242	if (d.verbose_ir) {
1042		var stdout_buf: [4096]u8 = undefined;
1043		var stdout = std.fs.File.stdout().writer(&stdout_buf);
	1243	var stdout = std.fs.File.stdout().writer(&writer_buf);
1044	1244	ir.dump(d.comp.gpa, d.detectConfig(stdout.file), &stdout.interface) catch {};
1045	1245	}
1046	1246
...	...	@@ -1065,8 +1265,7 @@ fn processSource(
1065	1265	return d.fatal("unable to create output file '{s}': {s}", .{ out_file_name, errorDescription(er) });
1066	1266	defer out_file.close();
1067	1267
1068		var file_buf: [4096]u8 = undefined;
1069		var file_writer = out_file.writer(&file_buf);
	1268	var file_writer = out_file.writer(&writer_buf);
1070	1269	obj.finish(&file_writer.interface) catch
1071	1270	return d.fatal("could not output to object file '{s}': {s}", .{ out_file_name, errorDescription(file_writer.err.?) });
1072	1271	}
...	...	@@ -1236,7 +1435,7 @@ pub fn getPICMode(d: *Driver, lastpic: []const u8) Compilation.Error!struct { ba
1236	1435	} else {
1237	1436	pic, pie = .{ false, false };
1238	1437	if (target_util.isPS(target)) {
1239		if (d.cmodel != .kernel) {
	1438	if (d.comp.cmodel != .kernel) {
1240	1439	pic = true;
1241	1440	try d.warn(
1242	1441	"option '{s}' was ignored by the {s} toolchain, using '-fPIC'",

lib/compiler/aro/aro/Parser.zig+6-1

...	...	@@ -6904,6 +6904,9 @@ pub const Result = struct {
6904	6904	try p.err(l_paren, .invalid_union_cast, .{res.qt});
6905	6905	return error.ParsingFailed;
6906	6906	}
	6907	} else if (dest_qt.eql(res.qt, p.comp)) {
	6908	try p.err(l_paren, .cast_to_same_type, .{dest_qt});
	6909	cast_kind = .no_op;
6907	6910	} else {
6908	6911	try p.err(l_paren, .invalid_cast_type, .{dest_qt});
6909	6912	return error.ParsingFailed;
...	...	@@ -8720,7 +8723,9 @@ fn fieldAccess(
8720	8723	};
8721	8724
8722	8725	if (record_ty.layout == null) {
8723		std.debug.assert(is_ptr);
	8726	// Invalid use of incomplete type, error reported elsewhere.
	8727	if (!is_ptr) return error.ParsingFailed;
	8728
8724	8729	try p.err(field_name_tok - 2, .deref_incomplete_ty_ptr, .{expr_base_qt});
8725	8730	return error.ParsingFailed;
8726	8731	}

lib/compiler/aro/aro/Parser/Diagnostic.zig+9-2

...	...	@@ -694,6 +694,12 @@ pub const invalid_cast_type: Diagnostic = .{
694	694	.kind = .@"error",
695	695	};
696	696
	697	pub const cast_to_same_type: Diagnostic = .{
	698	.fmt = "C99 forbids casting nonscalar type {qt} to the same type",
	699	.kind = .off,
	700	.extension = true,
	701	};
	702
697	703	pub const invalid_cast_operand_type: Diagnostic = .{
698	704	.fmt = "operand of type {qt} where arithmetic or pointer type is required",
699	705	.kind = .@"error",
...	...	@@ -1484,9 +1490,10 @@ pub const duplicate_member: Diagnostic = .{
1484	1490	};
1485	1491
1486	1492	pub const binary_integer_literal: Diagnostic = .{
1487		.fmt = "binary integer literals are a GNU extension",
	1493	.fmt = "binary integer literals are a C23 extension",
	1494	.opt = .@"c23-extensions",
1488	1495	.kind = .off,
1489		.opt = .@"gnu-binary-literal",
	1496	.suppress_version = .c23,
1490	1497	.extension = true,
1491	1498	};
1492	1499

lib/compiler/aro/aro/Preprocessor.zig+20-10

...	...	@@ -7,6 +7,7 @@ const Attribute = @import("Attribute.zig");
7	7	const Compilation = @import("Compilation.zig");
8	8	const Error = Compilation.Error;
9	9	const Diagnostics = @import("Diagnostics.zig");
	10	const DepFile = @import("DepFile.zig");
10	11	const features = @import("features.zig");
11	12	const Hideset = @import("Hideset.zig");
12	13	const Parser = @import("Parser.zig");
...	...	@@ -157,6 +158,9 @@ hideset: Hideset,
157	158	source_epoch: SourceEpoch,
158	159	m_times: std.AutoHashMapUnmanaged(Source.Id, u64) = .{},
159	160
	161	/// The dependency file tracking all includes and embeds.
	162	dep_file: ?*DepFile = null,
	163
160	164	pub const parse = Parser.parse;
161	165
162	166	pub const Linemarkers = enum {
...	...	@@ -169,7 +173,7 @@ pub const Linemarkers = enum {
169	173	};
170	174
171	175	pub fn init(comp: *Compilation, source_epoch: SourceEpoch) Preprocessor {
172		const pp = Preprocessor{
	176	const pp: Preprocessor = .{
173	177	.comp = comp,
174	178	.diagnostics = comp.diagnostics,
175	179	.gpa = comp.gpa,
...	...	@@ -1614,13 +1618,18 @@ fn handleBuiltinMacro(pp: *Preprocessor, builtin: RawToken.Id, param_toks: []con
1614	1618	else => unreachable,
1615	1619	};
1616	1620	const filename = include_str[1 .. include_str.len - 1];
1617		if (builtin == .macro_param_has_include or pp.include_depth == 0) {
1618		if (builtin == .macro_param_has_include_next) {
1619		try pp.err(src_loc, .include_next_outside_header, .{});
	1621	const res = res: {
	1622	if (builtin == .macro_param_has_include or pp.include_depth == 0) {
	1623	if (builtin == .macro_param_has_include_next) {
	1624	try pp.err(src_loc, .include_next_outside_header, .{});
	1625	}
	1626	break :res try pp.comp.hasInclude(filename, src_loc.id, include_type, .first);
1620	1627	}
1621		return pp.comp.hasInclude(filename, src_loc.id, include_type, .first);
1622		}
1623		return pp.comp.hasInclude(filename, src_loc.id, include_type, .next);
	1628	break :res try pp.comp.hasInclude(filename, src_loc.id, include_type, .next);
	1629	};
	1630
	1631	if (res) if (pp.dep_file) \|dep_file\| try dep_file.addDependencyDupe(pp.gpa, pp.comp.arena, filename);
	1632	return res;
1624	1633	},
1625	1634	else => unreachable,
1626	1635	}
...	...	@@ -1929,7 +1938,7 @@ fn expandFuncMacro(
1929	1938	else => unreachable,
1930	1939	};
1931	1940	const filename = include_str[1 .. include_str.len - 1];
1932		const contents = (try pp.comp.findEmbed(filename, arg[0].loc.id, include_type, .limited(1))) orelse
	1941	const contents = (try pp.comp.findEmbed(filename, arg[0].loc.id, include_type, .limited(1), pp.dep_file)) orelse
1933	1942	break :res not_found;
1934	1943
1935	1944	defer pp.comp.gpa.free(contents);
...	...	@@ -2537,7 +2546,7 @@ fn expandedSliceExtra(pp: *const Preprocessor, tok: anytype, macro_ws_handling:
2537	2546	if (tok.id.lexeme()) \|some\| {
2538	2547	if (!tok.id.allowsDigraphs(pp.comp.langopts) and !(tok.id == .macro_ws and macro_ws_handling == .preserve_macro_ws)) return some;
2539	2548	}
2540		var tmp_tokenizer = Tokenizer{
	2549	var tmp_tokenizer: Tokenizer = .{
2541	2550	.buf = pp.comp.getSource(tok.loc.id).buf,
2542	2551	.langopts = pp.comp.langopts,
2543	2552	.index = tok.loc.byte_offset,
...	...	@@ -3087,7 +3096,7 @@ fn embed(pp: Preprocessor, tokenizer: Tokenizer) MacroError!void {
3087	3096	}
3088	3097	}
3089	3098
3090		const embed_bytes = (try pp.comp.findEmbed(filename, first.source, include_type, limit orelse .unlimited)) orelse
	3099	const embed_bytes = (try pp.comp.findEmbed(filename, first.source, include_type, limit orelse .unlimited, pp.dep_file)) orelse
3091	3100	return pp.fatalNotFound(filename_tok, filename);
3092	3101	defer pp.comp.gpa.free(embed_bytes);
3093	3102
...	...	@@ -3143,6 +3152,7 @@ fn include(pp: Preprocessor, tokenizer: Tokenizer, which: Compilation.WhichInc
3143	3152	if (pp.defines.contains(guard)) return;
3144	3153	}
3145	3154
	3155	if (pp.dep_file) \|dep\| try dep.addDependency(pp.gpa, new_source.path);
3146	3156	if (pp.verbose) {
3147	3157	pp.verboseLog(first, "include file {s}", .{new_source.path});
3148	3158	}

lib/compiler/aro/backend/CodeGenOptions.zig+18-2

...	...	@@ -11,7 +11,22 @@ pic_level: PicLevel,
11	11	is_pie: bool,
12	12	optimization_level: OptimizationLevel,
13	13	/// Generate debug information
14		debug: bool,
	14	debug: DebugFormat,
	15	dwarf_version: DwarfVersion,
	16
	17	pub const DebugFormat = union(enum) {
	18	strip,
	19	dwarf: std.dwarf.Format,
	20	code_view,
	21	};
	22
	23	pub const DwarfVersion = enum(u3) {
	24	@"0" = 0,
	25	@"2" = 2,
	26	@"3" = 3,
	27	@"4" = 4,
	28	@"5" = 5,
	29	};
15	30
16	31	pub const PicLevel = enum(u8) {
17	32	/// Do not generate position-independent code
...	...	@@ -60,5 +75,6 @@ pub const default: @This() = .{
60	75	.pic_level = .none,
61	76	.is_pie = false,
62	77	.optimization_level = .@"0",
63		.debug = false,
	78	.debug = .strip,
	79	.dwarf_version = .@"0",
64	80	};

lib/compiler/aro/include/float.h created+126

...	...	@@ -0,0 +1,126 @@
	1	/* <float.h> for the Aro C compiler */
	2
	3	#pragma once
	4
	5	#undef FLT_RADIX
	6	#define FLT_RADIX __FLT_RADIX__
	7
	8	#undef FLT_MANT_DIG
	9	#define FLT_MANT_DIG __FLT_MANT_DIG__
	10
	11	#undef DBL_MANT_DIG
	12	#define DBL_MANT_DIG __DBL_MANT_DIG__
	13
	14	#undef LDBL_MANT_DIG
	15	#define LDBL_MANT_DIG __LDBL_MANT_DIG__
	16
	17	#if __STDC_VERSION__ >= 199901L
	18	#undef FLT_EVAL_METHOD
	19	#define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
	20
	21	#undef DECIMAL_DIG
	22	#define DECIMAL_DIG __DECIMAL_DIG__
	23	#endif /* __STDC_VERSION__ >= 199901L */
	24
	25	#undef FLT_DIG
	26	#define FLT_DIG __FLT_DIG__
	27
	28	#undef DBL_DIG
	29	#define DBL_DIG __DBL_DIG__
	30
	31	#undef LDBL_DIG
	32	#define LDBL_DIG __LDBL_DIG__
	33
	34	#undef FLT_MIN_EXP
	35	#define FLT_MIN_EXP __FLT_MIN_EXP__
	36
	37	#undef DBL_MIN_EXP
	38	#define DBL_MIN_EXP __DBL_MIN_EXP__
	39
	40	#undef LDBL_MIN_EXP
	41	#define LDBL_MIN_EXP __LDBL_MIN_EXP__
	42
	43	#undef FLT_MIN_10_EXP
	44	#define FLT_MIN_10_EXP __FLT_MIN_10_EXP__
	45
	46	#undef DBL_MIN_10_EXP
	47	#define DBL_MIN_10_EXP __DBL_MIN_10_EXP__
	48
	49	#undef LDBL_MIN_10_EXP
	50	#define LDBL_MIN_10_EXP __LDBL_MIN_10_EXP__
	51
	52	#undef FLT_MAX_EXP
	53	#define FLT_MAX_EXP __FLT_MAX_EXP__
	54
	55	#undef DBL_MAX_EXP
	56	#define DBL_MAX_EXP __DBL_MAX_EXP__
	57
	58	#undef LDBL_MAX_EXP
	59	#define LDBL_MAX_EXP __LDBL_MAX_EXP__
	60
	61	#undef FLT_MAX_10_EXP
	62	#define FLT_MAX_10_EXP __FLT_MAX_10_EXP__
	63
	64	#undef DBL_MAX_10_EXP
	65	#define DBL_MAX_10_EXP __DBL_MAX_10_EXP__
	66
	67	#undef LDBL_MAX_10_EXP
	68	#define LDBL_MAX_10_EXP __LDBL_MAX_10_EXP__
	69
	70	#undef FLT_MAX
	71	#define FLT_MAX __FLT_MAX__
	72
	73	#undef DBL_MAX
	74	#define DBL_MAX __DBL_MAX__
	75
	76	#undef LDBL_MAX
	77	#define LDBL_MAX __LDBL_MAX__
	78
	79	#undef FLT_EPSILON
	80	#define FLT_EPSILON __FLT_EPSILON__
	81
	82	#undef DBL_EPSILON
	83	#define DBL_EPSILON __DBL_EPSILON__
	84
	85	#undef LDBL_EPSILON
	86	#define LDBL_EPSILON __LDBL_EPSILON__
	87
	88	#undef FLT_MIN
	89	#define FLT_MIN __FLT_MIN__
	90
	91	#undef DBL_MIN
	92	#define DBL_MIN __DBL_MIN__
	93
	94	#undef LDBL_MIN
	95	#define LDBL_MIN __LDBL_MIN__
	96
	97	#if __STDC_VERSION__ >= 201112L
	98
	99	#undef FLT_TRUE_MIN
	100	#define FLT_TRUE_MIN __FLT_DENORM_MIN__
	101
	102	#undef DBL_TRUE_MIN
	103	#define DBL_TRUE_MIN __DBL_DENORM_MIN__
	104
	105	#undef LDBL_TRUE_MIN
	106	#define LDBL_TRUE_MIN __LDBL_DENORM_MIN__
	107
	108	#undef FLT_DECIMAL_DIG
	109	#define FLT_DECIMAL_DIG __FLT_DECIMAL_DIG__
	110
	111	#undef DBL_DECIMAL_DIG
	112	#define DBL_DECIMAL_DIG __DBL_DECIMAL_DIG__
	113
	114	#undef LDBL_DECIMAL_DIG
	115	#define LDBL_DECIMAL_DIG __LDBL_DECIMAL_DIG__
	116
	117	#undef FLT_HAS_SUBNORM
	118	#define FLT_HAS_SUBNORM __FLT_HAS_DENORM__
	119
	120	#undef DBL_HAS_SUBNORM
	121	#define DBL_HAS_SUBNORM __DBL_HAS_DENORM__
	122
	123	#undef LDBL_HAS_SUBNORM
	124	#define LDBL_HAS_SUBNORM __LDBL_HAS_DENORM__
	125
	126	#endif /* __STDC_VERSION__ >= 201112L */

lib/compiler/aro/include/iso646.h created+15

...	...	@@ -0,0 +1,15 @@
	1	/* <iso646.h> for the Aro C compiler */
	2
	3	#pragma once
	4
	5	#define and &&
	6	#define and_eq &=
	7	#define bitand &
	8	#define bitor \|
	9	#define compl ~
	10	#define not !
	11	#define not_eq !=
	12	#define or \|\|
	13	#define or_eq \|=
	14	#define xor ^
	15	#define xor_eq ^=

lib/compiler/aro/include/limits.h created+124

...	...	@@ -0,0 +1,124 @@
	1	/* <limits.h> for the Aro C compiler */
	2
	3	#pragma once
	4
	5	/* GlibC will try to include_next GCC's limits.h which will fail.
	6	Define _GCC_LIMITS_H_ to prevent it. */
	7	#if defined __GNUC__ && !defined _GCC_LIMITS_H_
	8	#define _GCC_LIMITS_H_
	9	#endif
	10
	11	/* Include the system's limits.h */
	12	#if __STDC_HOSTED__ && __has_include_next(<limits.h>)
	13	#include_next <limits.h>
	14	#endif
	15
	16	#undef SCHAR_MAX
	17	#define SCHAR_MAX __SCHAR_MAX__
	18
	19	#undef SHRT_MAX
	20	#define SHRT_MAX __SHRT_MAX__
	21
	22	#undef INT_MAX
	23	#define INT_MAX __INT_MAX__
	24
	25	#undef LONG_MAX
	26	#define LONG_MAX __LONG_MAX__
	27
	28	#undef SCHAR_MIN
	29	#define SCHAR_MIN (-__SCHAR_MAX__-1)
	30
	31	#undef SHRT_MIN
	32	#define SHRT_MIN (-__SHRT_MAX__ -1)
	33
	34	#undef INT_MIN
	35	#define INT_MIN (-__INT_MAX__ -1)
	36
	37	#undef LONG_MIN
	38	#define LONG_MIN (-__LONG_MAX__ -1L)
	39
	40	#undef UCHAR_MAX
	41	#define UCHAR_MAX (__SCHAR_MAX__*2 +1)
	42
	43	#undef USHRT_MAX
	44	#define USHRT_MAX (__SHRT_MAX__ *2 +1)
	45
	46	#undef UINT_MAX
	47	#define UINT_MAX (__INT_MAX__ *2U +1U)
	48
	49	#undef ULONG_MAX
	50	#define ULONG_MAX (__LONG_MAX__ *2UL+1UL)
	51
	52	#ifndef MB_LEN_MAX
	53	#define MB_LEN_MAX 1
	54	#endif
	55
	56	#undef CHAR_BIT
	57	#define CHAR_BIT __CHAR_BIT__
	58
	59	#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
	60
	61	#undef BOOL_WIDTH
	62	#define BOOL_WIDTH __BOOL_WIDTH__
	63
	64	#undef CHAR_WIDTH
	65	#define CHAR_WIDTH CHAR_BIT
	66
	67	#undef SCHAR_WIDTH
	68	#define SCHAR_WIDTH CHAR_BIT
	69
	70	#undef UCHAR_WIDTH
	71	#define UCHAR_WIDTH CHAR_BIT
	72
	73	#undef USHRT_WIDTH
	74	#define USHRT_WIDTH __SHRT_WIDTH__
	75
	76	#undef SHRT_WIDTH
	77	#define SHRT_WIDTH __SHRT_WIDTH__
	78
	79	#undef UINT_WIDTH
	80	#define UINT_WIDTH __INT_WIDTH__
	81
	82	#undef INT_WIDTH
	83	#define INT_WIDTH __INT_WIDTH__
	84
	85	#undef ULONG_WIDTH
	86	#define ULONG_WIDTH __LONG_WIDTH__
	87
	88	#undef LONG_WIDTH
	89	#define LONG_WIDTH __LONG_WIDTH__
	90
	91	#undef ULLONG_WIDTH
	92	#define ULLONG_WIDTH __LLONG_WIDTH__
	93
	94	#undef LLONG_WIDTH
	95	#define LLONG_WIDTH __LLONG_WIDTH__
	96
	97	#undef BITINT_MAXWIDTH
	98	#define BITINT_MAXWIDTH __BITINT_MAXWIDTH__
	99
	100	#endif /* defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L */
	101
	102	#undef CHAR_MIN
	103	#undef CHAR_MAX
	104	#ifdef __CHAR_UNSIGNED__
	105	#define CHAR_MIN 0
	106	#define CHAR_MAX UCHAR_MAX
	107	#else
	108	#define CHAR_MIN SCHAR_MIN
	109	#define CHAR_MAX __SCHAR_MAX__
	110	#endif
	111
	112	#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
	113
	114	#undef LLONG_MIN
	115	#define LLONG_MIN (-__LONG_LONG_MAX__-1LL)
	116
	117	#undef LLONG_MAX
	118	#define LLONG_MAX __LONG_LONG_MAX__
	119
	120	#undef ULLONG_MAX
	121	#define ULLONG_MAX (__LONG_LONG_MAX__*2ULL+1ULL)
	122
	123	#endif
	124

lib/compiler/aro/include/stdalign.h created+11

...	...	@@ -0,0 +1,11 @@
	1	/* <stdalign.h> for the Aro C compiler */
	2
	3	#pragma once
	4	#if __STDC_VERSION__ < 202311L
	5
	6	#define alignas _Alignas
	7	#define alignof _Alignof
	8
	9	#define __alignas_is_defined 1
	10	#define __alignof_is_defined 1
	11	#endif

lib/compiler/aro/include/stdarg.h created+28

...	...	@@ -0,0 +1,28 @@
	1	/* <stdarg.h> for the Aro C compiler */
	2
	3	#pragma once
	4	/* Todo: Set to 202311L once header is compliant with C23 */
	5	#define __STDC_VERSION_STDARG_H__ 0
	6
	7	typedef __builtin_va_list va_list;
	8	#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
	9	/* C23 no longer requires the second parameter */
	10	#define va_start(ap, ...) __builtin_va_start(ap, __VA_ARGS__)
	11	#else
	12	#define va_start(ap, param) __builtin_va_start(ap, param)
	13	#endif
	14	#define va_end(ap) __builtin_va_end(ap)
	15	#define va_arg(ap, type) __builtin_va_arg(ap, type)
	16
	17	/* GCC and Clang always define __va_copy */
	18	#define __va_copy(d, s) __builtin_va_copy(d, s)
	19
	20	/* but va_copy only on c99+ or when strict ansi mode is turned off */
	21	#if __STDC_VERSION__ >= 199901L \|\| !defined(__STRICT_ANSI__)
	22	#define va_copy(d, s) __builtin_va_copy(d, s)
	23	#endif
	24
	25	#ifndef __GNUC_VA_LIST
	26	#define __GNUC_VA_LIST 1
	27	typedef __builtin_va_list __gnuc_va_list;
	28	#endif

lib/compiler/aro/include/stdatomic.h created+138

...	...	@@ -0,0 +1,138 @@
	1	/* <stdatomic.h> for the Aro C compiler */
	2
	3	#pragma once
	4
	5	#define __STDC_VERSION_STDATOMIC_H__ 202311L
	6
	7	#if __STDC_HOSTED__ && __has_include_next(<stdatomic.h>)
	8	#include_next <stdatomic.h>
	9	#else
	10
	11	#include <stddef.h>
	12	#include <stdint.h>
	13
	14	#define ATOMIC_BOOL_LOCK_FREE __ATOMIC_BOOL_LOCK_FREE
	15	#define ATOMIC_CHAR_LOCK_FREE __ATOMIC_CHAR_LOCK_FREE
	16	#define ATOMIC_CHAR16_T_LOCK_FREE __ATOMIC_CHAR16_T_LOCK_FREE
	17	#define ATOMIC_CHAR32_T_LOCK_FREE __ATOMIC_CHAR32_T_LOCK_FREE
	18	#define ATOMIC_WCHAR_T_LOCK_FREE __ATOMIC_WCHAR_T_LOCK_FREE
	19	#define ATOMIC_SHORT_LOCK_FREE __ATOMIC_SHORT_LOCK_FREE
	20	#define ATOMIC_INT_LOCK_FREE __ATOMIC_INT_LOCK_FREE
	21	#define ATOMIC_LONG_LOCK_FREE __ATOMIC_LONG_LOCK_FREE
	22	#define ATOMIC_LLONG_LOCK_FREE __ATOMIC_LLONG_LOCK_FREE
	23	#define ATOMIC_POINTER_LOCK_FREE __ATOMIC_POINTER_LOCK_FREE
	24	#if defined(__ATOMIC_CHAR8_T_LOCK_FREE)
	25	#define ATOMIC_CHAR8_T_LOCK_FREE __ATOMIC_CHAR8_T_LOCK_FREE
	26	#endif
	27
	28	#if __STDC_VERSION__ < 202311L
	29	/* ATOMIC_VAR_INIT was removed in C23 */
	30	#define ATOMIC_VAR_INIT(value) (value)
	31	#endif
	32
	33	#define atomic_init __c11_atomic_init
	34
	35	typedef enum memory_order {
	36	memory_order_relaxed = __ATOMIC_RELAXED,
	37	memory_order_consume = __ATOMIC_CONSUME,
	38	memory_order_acquire = __ATOMIC_ACQUIRE,
	39	memory_order_release = __ATOMIC_RELEASE,
	40	memory_order_acq_rel = __ATOMIC_ACQ_REL,
	41	memory_order_seq_cst = __ATOMIC_SEQ_CST
	42	} memory_order;
	43
	44	#define kill_dependency(y) (y)
	45
	46	void atomic_thread_fence(memory_order);
	47	void atomic_signal_fence(memory_order);
	48
	49	#define atomic_thread_fence(order) __c11_atomic_thread_fence(order)
	50	#define atomic_signal_fence(order) __c11_atomic_signal_fence(order)
	51
	52	#define atomic_is_lock_free(obj) __c11_atomic_is_lock_free(sizeof(*(obj)))
	53
	54	typedef _Atomic(_Bool) atomic_bool;
	55	typedef _Atomic(char) atomic_char;
	56	typedef _Atomic(signed char) atomic_schar;
	57	typedef _Atomic(unsigned char) atomic_uchar;
	58	typedef _Atomic(short) atomic_short;
	59	typedef _Atomic(unsigned short) atomic_ushort;
	60	typedef _Atomic(int) atomic_int;
	61	typedef _Atomic(unsigned int) atomic_uint;
	62	typedef _Atomic(long) atomic_long;
	63	typedef _Atomic(unsigned long) atomic_ulong;
	64	typedef _Atomic(long long) atomic_llong;
	65	typedef _Atomic(unsigned long long) atomic_ullong;
	66	typedef _Atomic(uint_least16_t) atomic_char16_t;
	67	typedef _Atomic(uint_least32_t) atomic_char32_t;
	68	typedef _Atomic(wchar_t) atomic_wchar_t;
	69	typedef _Atomic(int_least8_t) atomic_int_least8_t;
	70	typedef _Atomic(uint_least8_t) atomic_uint_least8_t;
	71	typedef _Atomic(int_least16_t) atomic_int_least16_t;
	72	typedef _Atomic(uint_least16_t) atomic_uint_least16_t;
	73	typedef _Atomic(int_least32_t) atomic_int_least32_t;
	74	typedef _Atomic(uint_least32_t) atomic_uint_least32_t;
	75	typedef _Atomic(int_least64_t) atomic_int_least64_t;
	76	typedef _Atomic(uint_least64_t) atomic_uint_least64_t;
	77	typedef _Atomic(int_fast8_t) atomic_int_fast8_t;
	78	typedef _Atomic(uint_fast8_t) atomic_uint_fast8_t;
	79	typedef _Atomic(int_fast16_t) atomic_int_fast16_t;
	80	typedef _Atomic(uint_fast16_t) atomic_uint_fast16_t;
	81	typedef _Atomic(int_fast32_t) atomic_int_fast32_t;
	82	typedef _Atomic(uint_fast32_t) atomic_uint_fast32_t;
	83	typedef _Atomic(int_fast64_t) atomic_int_fast64_t;
	84	typedef _Atomic(uint_fast64_t) atomic_uint_fast64_t;
	85	typedef _Atomic(intptr_t) atomic_intptr_t;
	86	typedef _Atomic(uintptr_t) atomic_uintptr_t;
	87	typedef _Atomic(size_t) atomic_size_t;
	88	typedef _Atomic(ptrdiff_t) atomic_ptrdiff_t;
	89	typedef _Atomic(intmax_t) atomic_intmax_t;
	90	typedef _Atomic(uintmax_t) atomic_uintmax_t;
	91
	92	#define atomic_store(object, desired) __c11_atomic_store(object, desired, __ATOMIC_SEQ_CST)
	93	#define atomic_store_explicit __c11_atomic_store
	94
	95	#define atomic_load(object) __c11_atomic_load(object, __ATOMIC_SEQ_CST)
	96	#define atomic_load_explicit __c11_atomic_load
	97
	98	#define atomic_exchange(object, desired) __c11_atomic_exchange(object, desired, __ATOMIC_SEQ_CST)
	99	#define atomic_exchange_explicit __c11_atomic_exchange
	100
	101	#define atomic_compare_exchange_strong(object, expected, desired) __c11_atomic_compare_exchange_strong(object, expected, desired, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
	102	#define atomic_compare_exchange_strong_explicit __c11_atomic_compare_exchange_strong
	103
	104	#define atomic_compare_exchange_weak(object, expected, desired) __c11_atomic_compare_exchange_weak(object, expected, desired, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
	105	#define atomic_compare_exchange_weak_explicit __c11_atomic_compare_exchange_weak
	106
	107	#define atomic_fetch_add(object, operand) __c11_atomic_fetch_add(object, operand, __ATOMIC_SEQ_CST)
	108	#define atomic_fetch_add_explicit __c11_atomic_fetch_add
	109
	110	#define atomic_fetch_sub(object, operand) __c11_atomic_fetch_sub(object, operand, __ATOMIC_SEQ_CST)
	111	#define atomic_fetch_sub_explicit __c11_atomic_fetch_sub
	112
	113	#define atomic_fetch_or(object, operand) __c11_atomic_fetch_or(object, operand, __ATOMIC_SEQ_CST)
	114	#define atomic_fetch_or_explicit __c11_atomic_fetch_or
	115
	116	#define atomic_fetch_xor(object, operand) __c11_atomic_fetch_xor(object, operand, __ATOMIC_SEQ_CST)
	117	#define atomic_fetch_xor_explicit __c11_atomic_fetch_xor
	118
	119	#define atomic_fetch_and(object, operand) __c11_atomic_fetch_and(object, operand, __ATOMIC_SEQ_CST)
	120	#define atomic_fetch_and_explicit __c11_atomic_fetch_and
	121
	122	typedef struct atomic_flag { atomic_bool _Value; } atomic_flag;
	123
	124	#define ATOMIC_FLAG_INIT { 0 }
	125
	126	_Bool atomic_flag_test_and_set(volatile atomic_flag *);
	127	_Bool atomic_flag_test_and_set_explicit(volatile atomic_flag *, memory_order);
	128	void atomic_flag_clear(volatile atomic_flag *);
	129	void atomic_flag_clear_explicit(volatile atomic_flag *, memory_order);
	130
	131	#define atomic_flag_test_and_set(object) __c11_atomic_exchange(&(object)->_Value, 1, __ATOMIC_SEQ_CST)
	132	#define atomic_flag_test_and_set_explicit(object, order) __c11_atomic_exchange(&(object)->_Value, 1, order)
	133
	134	#define atomic_flag_clear(object) __c11_atomic_store(&(object)->_Value, 0, __ATOMIC_SEQ_CST)
	135	#define atomic_flag_clear_explicit(object, order) __c11_atomic_store(&(object)->_Value, 0, order)
	136
	137
	138	#endif

lib/compiler/aro/include/stdbool.h created+13

...	...	@@ -0,0 +1,13 @@
	1	/* <stdbool.h> for the Aro C compiler */
	2
	3	#pragma once
	4
	5	#if __STDC_VERSION__ < 202311L
	6	#define bool _Bool
	7
	8	#define true 1
	9	#define false 0
	10
	11	#define __bool_true_false_are_defined 1
	12
	13	#endif

lib/compiler/aro/include/stdckdint.h created+9

...	...	@@ -0,0 +1,9 @@
	1	/* <stdckdint.h> for the Aro C compiler */
	2
	3	#pragma once
	4
	5	#define __STDC_VERSION_STDCKDINT_H__ 202311L
	6
	7	#define ckd_add(result, a, b) __builtin_add_overflow(a, b, result)
	8	#define ckd_sub(result, a, b) __builtin_sub_overflow(a, b, result)
	9	#define ckd_mul(result, a, b) __builtin_mul_overflow(a, b, result)

lib/compiler/aro/include/stddef.h created+31

...	...	@@ -0,0 +1,31 @@
	1	/* <stddef.h> for the Aro C compiler */
	2
	3	#pragma once
	4
	5	#define __STDC_VERSION_STDDEF_H__ 202311L
	6
	7	typedef __PTRDIFF_TYPE__ ptrdiff_t;
	8	typedef __SIZE_TYPE__ size_t;
	9	typedef __WCHAR_TYPE__ wchar_t;
	10
	11	/* define max_align_t to match GCC and Clang */
	12	typedef struct {
	13	long long __aro_max_align_ll;
	14	long double __aro_max_align_ld;
	15	} max_align_t;
	16
	17	#define NULL ((void*)0)
	18	#define offsetof(T, member) __builtin_offsetof(T, member)
	19
	20	#if __STDC_VERSION__ >= 202311L
	21	# pragma GCC diagnostic push
	22	# pragma GCC diagnostic ignored "-Wpre-c23-compat"
	23	typedef typeof(nullptr) nullptr_t;
	24	# pragma GCC diagnostic pop
	25
	26	# if defined unreachable
	27	# error unreachable() is a standard macro in C23
	28	# else
	29	# define unreachable() __builtin_unreachable()
	30	# endif
	31	#endif

lib/compiler/aro/include/stdint.h created+289

...	...	@@ -0,0 +1,289 @@
	1	/* <stdint.h> for the Aro C compiler */
	2
	3	#pragma once
	4
	5
	6	#if __STDC_HOSTED__ && __has_include_next(<stdint.h>)
	7
	8	# include_next <stdint.h>
	9
	10	#else
	11
	12	#define __stdint_int_c_cat(X, Y) X ## Y
	13	#define __stdint_int_c(V, SUFFIX) __stdint_int_c_cat(V, SUFFIX)
	14	#define __stdint_uint_c(V, SUFFIX) __stdint_int_c_cat(V##U, SUFFIX)
	15
	16	#define INTPTR_MIN (-__INTPTR_MAX__-1)
	17	#define INTPTR_MAX __INTPTR_MAX__
	18	#define UINTPTR_MAX __UINTPTR_MAX__
	19	#define PTRDIFF_MIN (-__PTRDIFF_MAX__-1)
	20	#define PTRDIFF_MAX __PTRDIFF_MAX__
	21	#define SIZE_MAX __SIZE_MAX__
	22	#define INTMAX_MIN (-__INTMAX_MAX__-1)
	23	#define INTMAX_MAX __INTMAX_MAX__
	24	#define UINTMAX_MAX __UINTMAX_MAX__
	25	#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
	26	# define INTPTR_WIDTH __INTPTR_WIDTH__
	27	# define UINTPTR_WIDTH __UINTPTR_WIDTH__
	28	# define INTMAX_WIDTH __INTMAX_WIDTH__
	29	# define UINTMAX_WIDTH __UINTMAX_WIDTH__
	30	# define PTRDIFF_WIDTH __PTRDIFF_WIDTH__
	31	# define SIZE_WIDTH __SIZE_WIDTH__
	32	# define WCHAR_WIDTH __WCHAR_WIDTH__
	33	#endif
	34
	35	typedef __INTMAX_TYPE__ intmax_t;
	36	typedef __UINTMAX_TYPE__ uintmax_t;
	37
	38	#ifndef _INTPTR_T
	39	# ifndef __intptr_t_defined
	40	typedef __INTPTR_TYPE__ intptr_t;
	41	# define __intptr_t_defined
	42	# define _INTPTR_T
	43	# endif
	44	#endif
	45
	46	#ifndef _UINTPTR_T
	47	typedef __UINTPTR_TYPE__ uintptr_t;
	48	# define _UINTPTR_T
	49	#endif
	50
	51
	52	#ifdef __INT64_TYPE__
	53	# ifndef __int8_t_defined /* glibc sys/types.h also defines int64_t*/
	54	typedef __INT64_TYPE__ int64_t;
	55	# endif /* __int8_t_defined */
	56	typedef __UINT64_TYPE__ uint64_t;
	57
	58	# undef __int64_c_suffix
	59	# undef __int32_c_suffix
	60	# undef __int16_c_suffix
	61	# undef __int8_c_suffix
	62	# ifdef __INT64_C_SUFFIX__
	63	# define __int64_c_suffix __INT64_C_SUFFIX__
	64	# define __int32_c_suffix __INT64_C_SUFFIX__
	65	# define __int16_c_suffix __INT64_C_SUFFIX__
	66	# define __int8_c_suffix __INT64_C_SUFFIX__
	67	# endif /* __INT64_C_SUFFIX__ */
	68
	69	# ifdef __int64_c_suffix
	70	# define INT64_C(v) (__stdint_int_c(v, __int64_c_suffix))
	71	# define UINT64_C(v) (__stdint_uint_c(v, __int64_c_suffix))
	72	# else
	73	# define INT64_C(v) (v)
	74	# define UINT64_C(v) (v ## U)
	75	# endif /* __int64_c_suffix */
	76
	77	# define INT64_MAX INT64_C( 9223372036854775807)
	78	# define INT64_MIN (-INT64_C( 9223372036854775807)-1)
	79	# define UINT64_MAX UINT64_C(18446744073709551615)
	80	# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
	81	# define UINT64_WIDTH 64
	82	# define INT64_WIDTH UINT64_WIDTH
	83	# endif /* __STDC_VERSION__ */
	84
	85	#endif /* __INT64_TYPE__ */
	86
	87	#ifdef __INT32_TYPE__
	88	# ifndef __int8_t_defined /* glibc sys/types.h also defines int32_t*/
	89	typedef __INT32_TYPE__ int32_t;
	90	# endif /* __int8_t_defined */
	91	typedef __UINT32_TYPE__ uint32_t;
	92
	93	# undef __int32_c_suffix
	94	# undef __int16_c_suffix
	95	# undef __int8_c_suffix
	96	# ifdef __INT32_C_SUFFIX__
	97	# define __int32_c_suffix __INT32_C_SUFFIX__
	98	# define __int16_c_suffix __INT32_C_SUFFIX__
	99	# define __int8_c_suffix __INT32_C_SUFFIX__
	100	# endif /* __INT32_C_SUFFIX__ */
	101
	102	# ifdef __int32_c_suffix
	103	# define INT32_C(v) (__stdint_int_c(v, __int32_c_suffix))
	104	# define UINT32_C(v) (__stdint_uint_c(v, __int32_c_suffix))
	105	# else
	106	# define INT32_C(v) (v)
	107	# define UINT32_C(v) (v ## U)
	108	# endif /* __int32_c_suffix */
	109
	110	# define INT32_MAX INT32_C( 2147483647)
	111	# define INT32_MIN (-INT32_C( 2147483647)-1)
	112	# define UINT32_MAX UINT32_C(4294967295)
	113	# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
	114	# define UINT32_WIDTH 32
	115	# define INT32_WIDTH UINT32_WIDTH
	116	# endif /* __STDC_VERSION__ */
	117
	118	#endif /* __INT32_TYPE__ */
	119
	120	#ifdef __INT16_TYPE__
	121	# ifndef __int8_t_defined /* glibc sys/types.h also defines int16_t*/
	122	typedef __INT16_TYPE__ int16_t;
	123	# endif /* __int8_t_defined */
	124	typedef __UINT16_TYPE__ uint16_t;
	125
	126	# undef __int16_c_suffix
	127	# undef __int8_c_suffix
	128	# ifdef __INT16_C_SUFFIX__
	129	# define __int16_c_suffix __INT16_C_SUFFIX__
	130	# define __int8_c_suffix __INT16_C_SUFFIX__
	131	# endif /* __INT16_C_SUFFIX__ */
	132
	133	# ifdef __int16_c_suffix
	134	# define INT16_C(v) (__stdint_int_c(v, __int16_c_suffix))
	135	# define UINT16_C(v) (__stdint_uint_c(v, __int16_c_suffix))
	136	# else
	137	# define INT16_C(v) (v)
	138	# define UINT16_C(v) (v ## U)
	139	# endif /* __int16_c_suffix */
	140
	141	# define INT16_MAX INT16_C( 32767)
	142	# define INT16_MIN (-INT16_C( 32767)-1)
	143	# define UINT16_MAX UINT16_C(65535)
	144	# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
	145	# define UINT16_WIDTH 16
	146	# define INT16_WIDTH UINT16_WIDTH
	147	# endif /* __STDC_VERSION__ */
	148
	149	#endif /* __INT16_TYPE__ */
	150
	151	#ifdef __INT8_TYPE__
	152	# ifndef __int8_t_defined /* glibc sys/types.h also defines int8_t*/
	153	typedef __INT8_TYPE__ int8_t;
	154	# endif /* __int8_t_defined */
	155	typedef __UINT8_TYPE__ uint8_t;
	156
	157	# undef __int8_c_suffix
	158	# ifdef __INT8_C_SUFFIX__
	159	# define __int8_c_suffix __INT8_C_SUFFIX__
	160	# endif /* __INT8_C_SUFFIX__ */
	161
	162	# ifdef __int8_c_suffix
	163	# define INT8_C(v) (__stdint_int_c(v, __int8_c_suffix))
	164	# define UINT8_C(v) (__stdint_uint_c(v, __int8_c_suffix))
	165	# else
	166	# define INT8_C(v) (v)
	167	# define UINT8_C(v) (v ## U)
	168	# endif /* __int8_c_suffix */
	169
	170	# define INT8_MAX INT8_C(127)
	171	# define INT8_MIN (-INT8_C(127)-1)
	172	# define UINT8_MAX UINT8_C(255)
	173	# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
	174	# define UINT8_WIDTH 8
	175	# define INT8_WIDTH UINT8_WIDTH
	176	# endif /* __STDC_VERSION__ */
	177
	178	#endif /* __INT8_TYPE__ */
	179
	180	typedef __INT_LEAST64_TYPE__ int_least64_t;
	181	typedef __INT_LEAST32_TYPE__ int_least32_t;
	182	typedef __INT_LEAST16_TYPE__ int_least16_t;
	183	typedef __INT_LEAST8_TYPE__ int_least8_t;
	184
	185	typedef __UINT_LEAST64_TYPE__ uint_least64_t;
	186	typedef __UINT_LEAST32_TYPE__ uint_least32_t;
	187	typedef __UINT_LEAST16_TYPE__ uint_least16_t;
	188	typedef __UINT_LEAST8_TYPE__ uint_least8_t;
	189
	190	#define INT_LEAST8_MAX __INT_LEAST8_MAX__
	191	#define INT_LEAST8_MIN (-__INT_LEAST8_MAX__-1)
	192	#define UINT_LEAST8_MAX __UINT_LEAST8_MAX__
	193
	194	#define INT_LEAST16_MAX __INT_LEAST16_MAX__
	195	#define INT_LEAST16_MIN (-__INT_LEAST16_MAX__-1)
	196	#define UINT_LEAST16_MAX __UINT_LEAST16_MAX__
	197
	198	#define INT_LEAST32_MAX __INT_LEAST32_MAX__
	199	#define INT_LEAST32_MIN (-__INT_LEAST32_MAX__-1)
	200	#define UINT_LEAST32_MAX __UINT_LEAST32_MAX__
	201
	202	#define INT_LEAST64_MAX __INT_LEAST64_MAX__
	203	#define INT_LEAST64_MIN (-__INT_LEAST64_MAX__-1)
	204	#define UINT_LEAST64_MAX __UINT_LEAST64_MAX__
	205
	206
	207	typedef __INT_FAST64_TYPE__ int_fast64_t;
	208	typedef __INT_FAST32_TYPE__ int_fast32_t;
	209	typedef __INT_FAST16_TYPE__ int_fast16_t;
	210	typedef __INT_FAST8_TYPE__ int_fast8_t;
	211
	212	typedef __UINT_FAST64_TYPE__ uint_fast64_t;
	213	typedef __UINT_FAST32_TYPE__ uint_fast32_t;
	214	typedef __UINT_FAST16_TYPE__ uint_fast16_t;
	215	typedef __UINT_FAST8_TYPE__ uint_fast8_t;
	216
	217	#define INT_FAST8_MAX __INT_FAST8_MAX__
	218	#define INT_FAST8_MIN (-__INT_FAST8_MAX__-1)
	219	#define UINT_FAST8_MAX __UINT_FAST8_MAX__
	220
	221	#define INT_FAST16_MAX __INT_FAST16_MAX__
	222	#define INT_FAST16_MIN (-__INT_FAST16_MAX__-1)
	223	#define UINT_FAST16_MAX __UINT_FAST16_MAX__
	224
	225	#define INT_FAST32_MAX __INT_FAST32_MAX__
	226	#define INT_FAST32_MIN (-__INT_FAST32_MAX__-1)
	227	#define UINT_FAST32_MAX __UINT_FAST32_MAX__
	228
	229	#define INT_FAST64_MAX __INT_FAST64_MAX__
	230	#define INT_FAST64_MIN (-__INT_FAST64_MAX__-1)
	231	#define UINT_FAST64_MAX __UINT_FAST64_MAX__
	232
	233
	234	#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
	235
	236	#define INT_FAST8_WIDTH __INT_FAST8_WIDTH__
	237	#define UINT_FAST8_WIDTH __INT_FAST8_WIDTH__
	238	#define INT_LEAST8_WIDTH __INT_LEAST8_WIDTH__
	239	#define UINT_LEAST8_WIDTH __INT_LEAST8_WIDTH__
	240
	241	#define INT_FAST16_WIDTH __INT_FAST16_WIDTH__
	242	#define UINT_FAST16_WIDTH __INT_FAST16_WIDTH__
	243	#define INT_LEAST16_WIDTH __INT_LEAST16_WIDTH__
	244	#define UINT_LEAST16_WIDTH __INT_LEAST16_WIDTH__
	245
	246	#define INT_FAST32_WIDTH __INT_FAST32_WIDTH__
	247	#define UINT_FAST32_WIDTH __INT_FAST32_WIDTH__
	248	#define INT_LEAST32_WIDTH __INT_LEAST32_WIDTH__
	249	#define UINT_LEAST32_WIDTH __INT_LEAST32_WIDTH__
	250
	251	#define INT_FAST64_WIDTH __INT_FAST64_WIDTH__
	252	#define UINT_FAST64_WIDTH __INT_FAST64_WIDTH__
	253	#define INT_LEAST64_WIDTH __INT_LEAST64_WIDTH__
	254	#define UINT_LEAST64_WIDTH __INT_LEAST64_WIDTH__
	255
	256	#endif
	257
	258	#ifdef __SIZEOF_INT128__
	259	typedef signed __int128 int128_t;
	260	typedef unsigned __int128 uint128_t;
	261	typedef signed __int128 int_fast128_t;
	262	typedef unsigned __int128 uint_fast128_t;
	263	typedef signed __int128 int_least128_t;
	264	typedef unsigned __int128 uint_least128_t;
	265	# define UINT128_MAX ((uint128_t)-1)
	266	# define INT128_MAX ((int128_t)+(UINT128_MAX/2))
	267	# define INT128_MIN (-INT128_MAX-1)
	268	# define UINT_LEAST128_MAX UINT128_MAX
	269	# define INT_LEAST128_MAX INT128_MAX
	270	# define INT_LEAST128_MIN INT128_MIN
	271	# define UINT_FAST128_MAX UINT128_MAX
	272	# define INT_FAST128_MAX INT128_MAX
	273	# define INT_FAST128_MIN INT128_MIN
	274	# define INT128_WIDTH 128
	275	# define UINT128_WIDTH 128
	276	# define INT_LEAST128_WIDTH 128
	277	# define UINT_LEAST128_WIDTH 128
	278	# define INT_FAST128_WIDTH 128
	279	# define UINT_FAST128_WIDTH 128
	280	# if UINT128_WIDTH > __LLONG_WIDTH__
	281	# define INT128_C(N) ((int_least128_t)+N ## WB)
	282	# define UINT128_C(N) ((uint_least128_t)+N ## WBU)
	283	# else
	284	# define INT128_C(N) ((int_least128_t)+N ## LL)
	285	# define UINT128_C(N) ((uint_least128_t)+N ## LLU)
	286	# endif
	287	#endif
	288
	289	#endif /* __STDC_HOSTED__ && __has_include_next(<stdint.h>) */

lib/compiler/aro/include/stdnoreturn.h created+6

...	...	@@ -0,0 +1,6 @@
	1	/* <stdnoreturn.h> for the Aro C compiler */
	2
	3	#pragma once
	4
	5	#define noreturn _Noreturn
	6	#define __noreturn_is_defined 1

lib/compiler/aro/include/varargs.h created+3

...	...	@@ -0,0 +1,3 @@
	1	/* <varargs.h> for the Aro C compiler */
	2	#pragma once
	3	#error please use <stdarg.h> instead of <varargs.h>

lib/compiler/translate-c/Translator.zig+4-4

...	...	@@ -171,7 +171,7 @@ pub const Options = struct {
171	171	tree: *const aro.Tree,
172	172	};
173	173
174		pub fn translate(options: Options) ![]u8 {
	174	pub fn translate(options: Options) mem.Allocator.Error![]u8 {
175	175	const gpa = options.gpa;
176	176	var arena_allocator = std.heap.ArenaAllocator.init(gpa);
177	177	defer arena_allocator.deinit();
...	...	@@ -219,19 +219,19 @@ pub fn translate(options: Options) ![]u8 {
219	219	var aw: std.Io.Writer.Allocating = .init(gpa);
220	220	defer aw.deinit();
221	221
222		try aw.writer.writeAll(
	222	aw.writer.writeAll(
223	223	\\pub const __builtin = @import("std").zig.c_translation.builtins;
224	224	\\pub const __helpers = @import("std").zig.c_translation.helpers;
225	225	\\
226	226	\\
227		);
	227	) catch return error.OutOfMemory;
228	228
229	229	var zig_ast = try ast.render(gpa, translator.global_scope.nodes.items);
230	230	defer {
231	231	gpa.free(zig_ast.source);
232	232	zig_ast.deinit(gpa);
233	233	}
234		try zig_ast.render(gpa, &aw.writer, .{});
	234	zig_ast.render(gpa, &aw.writer, .{}) catch return error.OutOfMemory;
235	235	return aw.toOwnedSlice();
236	236	}
237	237

lib/compiler/translate-c/main.zig+22-3

...	...	@@ -109,8 +109,6 @@ fn translate(d: aro.Driver, tc: aro.Toolchain, args: [][:0]u8) !void {
109	109	var macro_buf: std.ArrayListUnmanaged(u8) = .empty;
110	110	defer macro_buf.deinit(gpa);
111	111
112		try macro_buf.appendSlice(gpa, "#define __TRANSLATE_C__ 1\n");
113
114	112	var discard_buf: [256]u8 = undefined;
115	113	var discarding: std.io.Writer.Discarding = .init(&discard_buf);
116	114	assert(!try d.parseArgs(&discarding.writer, &macro_buf, aro_args));
...	...	@@ -146,6 +144,12 @@ fn translate(d: aro.Driver, tc: aro.Toolchain, args: [][:0]u8) !void {
146	144	var pp = try aro.Preprocessor.initDefault(d.comp);
147	145	defer pp.deinit();
148	146
	147	var name_buf: [std.fs.max_name_bytes]u8 = undefined;
	148	var opt_dep_file = try d.initDepFile(source, &name_buf);
	149	defer if (opt_dep_file) \|*dep_file\| dep_file.deinit(pp.gpa);
	150
	151	if (opt_dep_file) \|*dep_file\| pp.dep_file = dep_file;
	152
149	153	try pp.preprocessSources(&.{ source, builtin_macros, user_macros });
150	154
151	155	var c_tree = try pp.parse();
...	...	@@ -156,6 +160,22 @@ fn translate(d: aro.Driver, tc: aro.Toolchain, args: [][:0]u8) !void {
156	160	return error.FatalError;
157	161	}
158	162
	163	var out_buf: [4096]u8 = undefined;
	164	if (opt_dep_file) \|dep_file\| {
	165	const dep_file_name = try d.getDepFileName(source, out_buf[0..std.fs.max_name_bytes]);
	166
	167	const file = if (dep_file_name) \|path\|
	168	d.comp.cwd.createFile(path, .{}) catch \|er\|
	169	return d.fatal("unable to create dependency file '{s}': {s}", .{ path, aro.Driver.errorDescription(er) })
	170	else
	171	std.fs.File.stdout();
	172	defer if (dep_file_name != null) file.close();
	173
	174	var file_writer = file.writer(&out_buf);
	175	dep_file.write(&file_writer.interface) catch
	176	return d.fatal("unable to write dependency file: {s}", .{aro.Driver.errorDescription(file_writer.err.?)});
	177	}
	178
159	179	const rendered_zig = try Translator.translate(.{
160	180	.gpa = gpa,
161	181	.comp = d.comp,
...	...	@@ -182,7 +202,6 @@ fn translate(d: aro.Driver, tc: aro.Toolchain, args: [][:0]u8) !void {
182	202	out_file_path = path;
183	203	}
184	204
185		var out_buf: [4096]u8 = undefined;
186	205	var out_writer = out_file.writer(&out_buf);
187	206	out_writer.interface.writeAll(rendered_zig) catch
188	207	return d.fatal("failed to write result to '{s}': {s}", .{ out_file_path, aro.Driver.errorDescription(out_writer.err.?) });

src/libs/mingw.zig+1-1

...	...	@@ -333,7 +333,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
333	333	defer std.debug.unlockStderrWriter();
334	334	for (aro_comp.diagnostics.output.to_list.messages.items) \|msg\| {
335	335	if (msg.kind == .@"fatal error" or msg.kind == .@"error") {
336		aro.Diagnostics.writeToWriter(msg, w, std.io.tty.detectConfig(std.fs.File.stderr())) catch {};
	336	msg.write(w, .detect(std.fs.File.stderr()), true) catch {};
337	337	return error.AroPreprocessorFailed;
338	338	}
339	339	}