From 77e6513030a6258a893c2f11ad9708c9612b7715 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Fri, 30 May 2025 12:56:52 -0400 Subject: [PATCH] cbe: implement `stdbool.h` reserved identifiers Also remove the legalize pass from zig1. --- src/Air/Legalize.zig | 4 +++- src/Zcu/PerThread.zig | 4 +++- src/arch/aarch64/CodeGen.zig | 4 ++-- src/arch/arm/CodeGen.zig | 4 ++-- src/arch/powerpc/CodeGen.zig | 4 ++-- src/arch/riscv64/CodeGen.zig | 4 ++-- src/arch/sparc64/CodeGen.zig | 4 ++-- src/arch/wasm/CodeGen.zig | 4 ++-- src/codegen.zig | 30 +++++++++++++++++++++++------- src/codegen/c.zig | 10 +++++++--- src/codegen/llvm.zig | 4 ++-- src/codegen/spirv.zig | 4 ++-- src/dev.zig | 3 +++ 13 files changed, 55 insertions(+), 28 deletions(-) diff --git a/src/Air/Legalize.zig b/src/Air/Legalize.zig index 870270f089..221e98aebb 100644 --- a/src/Air/Legalize.zig +++ b/src/Air/Legalize.zig @@ -164,13 +164,14 @@ pub const Features = std.enums.EnumSet(Feature); pub const Error = std.mem.Allocator.Error; pub fn legalize(air: *Air, pt: Zcu.PerThread, features: *const Features) Error!void { + dev.check(.legalize); + assert(!features.bits.eql(.initEmpty())); // backend asked to run legalize, but no features were enabled var l: Legalize = .{ .pt = pt, .air_instructions = air.instructions.toMultiArrayList(), .air_extra = air.extra, .features = features, }; - if (l.features.bits.eql(.initEmpty())) return; defer air.* = l.getTmpAir(); const main_extra = l.extraData(Air.Block, l.air_extra.items[@intFromEnum(Air.ExtraIndex.main_block)]); try l.legalizeBody(main_extra.end, main_extra.data.body_len); @@ -845,6 +846,7 @@ inline fn replaceInst(l: *Legalize, inst: Air.Inst.Index, tag: Air.Inst.Tag, dat const Air = @import("../Air.zig"); const assert = std.debug.assert; +const dev = @import("../dev.zig"); const Legalize = @This(); const std = @import("std"); const Type = @import("../Type.zig"); diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index 93f87b506b..a67d4dcc05 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -1741,7 +1741,9 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: *A return; } - try air.legalize(pt, @import("../codegen.zig").legalizeFeatures(pt, nav_index)); + legalize: { + try air.legalize(pt, @import("../codegen.zig").legalizeFeatures(pt, nav_index) orelse break :legalize); + } var liveness = try Air.Liveness.analyze(gpa, air.*, ip); defer liveness.deinit(gpa); diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig index 88fdeb9831..e9e7159938 100644 --- a/src/arch/aarch64/CodeGen.zig +++ b/src/arch/aarch64/CodeGen.zig @@ -40,8 +40,8 @@ const gp = abi.RegisterClass.gp; const InnerError = CodeGenError || error{OutOfRegisters}; -pub inline fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { - return comptime &.initEmpty(); +pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features { + return null; } gpa: Allocator, diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig index a018302566..8cc1d0a607 100644 --- a/src/arch/arm/CodeGen.zig +++ b/src/arch/arm/CodeGen.zig @@ -41,8 +41,8 @@ const gp = abi.RegisterClass.gp; const InnerError = CodeGenError || error{OutOfRegisters}; -pub inline fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { - return comptime &.initEmpty(); +pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features { + return null; } gpa: Allocator, diff --git a/src/arch/powerpc/CodeGen.zig b/src/arch/powerpc/CodeGen.zig index a3a4615b4a..0cfee67ebd 100644 --- a/src/arch/powerpc/CodeGen.zig +++ b/src/arch/powerpc/CodeGen.zig @@ -10,8 +10,8 @@ const Zcu = @import("../../Zcu.zig"); const assert = std.debug.assert; const log = std.log.scoped(.codegen); -pub inline fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { - return comptime &.initEmpty(); +pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features { + return null; } pub fn generate( diff --git a/src/arch/riscv64/CodeGen.zig b/src/arch/riscv64/CodeGen.zig index 5732f4cd41..981b5a800f 100644 --- a/src/arch/riscv64/CodeGen.zig +++ b/src/arch/riscv64/CodeGen.zig @@ -51,8 +51,8 @@ const Instruction = encoding.Instruction; const InnerError = CodeGenError || error{OutOfRegisters}; -pub inline fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { - return comptime &.initEmpty(); +pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features { + return null; } pt: Zcu.PerThread, diff --git a/src/arch/sparc64/CodeGen.zig b/src/arch/sparc64/CodeGen.zig index ead7ef3e99..d473222288 100644 --- a/src/arch/sparc64/CodeGen.zig +++ b/src/arch/sparc64/CodeGen.zig @@ -41,8 +41,8 @@ const Self = @This(); const InnerError = CodeGenError || error{OutOfRegisters}; -pub inline fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { - return comptime &.initEmpty(); +pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features { + return null; } const RegisterView = enum(u1) { diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig index a130f1508d..ec448ca29b 100644 --- a/src/arch/wasm/CodeGen.zig +++ b/src/arch/wasm/CodeGen.zig @@ -31,8 +31,8 @@ const libcFloatSuffix = target_util.libcFloatSuffix; const compilerRtFloatAbbrev = target_util.compilerRtFloatAbbrev; const compilerRtIntAbbrev = target_util.compilerRtIntAbbrev; -pub inline fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { - return comptime &.initEmpty(); +pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features { + return null; } /// Reference to the function declaration the code diff --git a/src/codegen.zig b/src/codegen.zig index 8d609682f1..1f794bbeea 100644 --- a/src/codegen.zig +++ b/src/codegen.zig @@ -27,9 +27,22 @@ pub const CodeGenError = GenerateSymbolError || error{ CodegenFail, }; -fn devFeatureForBackend(comptime backend: std.builtin.CompilerBackend) dev.Feature { - comptime assert(mem.startsWith(u8, @tagName(backend), "stage2_")); - return @field(dev.Feature, @tagName(backend)["stage2_".len..] ++ "_backend"); +fn devFeatureForBackend(backend: std.builtin.CompilerBackend) dev.Feature { + return switch (backend) { + .other, .stage1 => unreachable, + .stage2_aarch64 => .aarch64_backend, + .stage2_arm => .arm_backend, + .stage2_c => .c_backend, + .stage2_llvm => .llvm_backend, + .stage2_powerpc => .powerpc_backend, + .stage2_riscv64 => .riscv64_backend, + .stage2_sparc64 => .sparc64_backend, + .stage2_spirv64 => .spirv64_backend, + .stage2_wasm => .wasm_backend, + .stage2_x86 => .x86_backend, + .stage2_x86_64 => .x86_64_backend, + _ => unreachable, + }; } fn importBackend(comptime backend: std.builtin.CompilerBackend) type { @@ -49,10 +62,10 @@ fn importBackend(comptime backend: std.builtin.CompilerBackend) type { }; } -pub fn legalizeFeatures(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) *const Air.Legalize.Features { +pub fn legalizeFeatures(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) ?*const Air.Legalize.Features { const zcu = pt.zcu; const target = &zcu.navFileScope(nav_index).mod.?.resolved_target.result; - return switch (target_util.zigBackend(target.*, zcu.comp.config.use_llvm)) { + switch (target_util.zigBackend(target.*, zcu.comp.config.use_llvm)) { else => unreachable, inline .stage2_llvm, .stage2_c, @@ -65,8 +78,11 @@ pub fn legalizeFeatures(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) *con .stage2_sparc64, .stage2_spirv64, .stage2_powerpc, - => |backend| importBackend(backend).legalizeFeatures(target), - }; + => |backend| { + dev.check(devFeatureForBackend(backend)); + return importBackend(backend).legalizeFeatures(target); + }, + } } pub fn generateFunction( diff --git a/src/codegen/c.zig b/src/codegen/c.zig index 2d3b236a86..e76c8e069d 100644 --- a/src/codegen/c.zig +++ b/src/codegen/c.zig @@ -20,8 +20,8 @@ const Alignment = InternPool.Alignment; const BigIntLimb = std.math.big.Limb; const BigInt = std.math.big.int; -pub inline fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { - return comptime &.initEmpty(); +pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features { + return null; } pub const CType = @import("c/Type.zig"); @@ -210,7 +210,6 @@ const reserved_idents = std.StaticStringMap(void).initComptime(.{ .{ "atomic_ushort", {} }, .{ "atomic_wchar_t", {} }, .{ "auto", {} }, - .{ "bool", {} }, .{ "break", {} }, .{ "case", {} }, .{ "char", {} }, @@ -270,6 +269,11 @@ const reserved_idents = std.StaticStringMap(void).initComptime(.{ .{ "va_end", {} }, .{ "va_copy", {} }, + // stdbool.h + .{ "bool", {} }, + .{ "false", {} }, + .{ "true", {} }, + // stddef.h .{ "offsetof", {} }, diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 6f411e7490..77d8f3ff47 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -36,8 +36,8 @@ const compilerRtIntAbbrev = target_util.compilerRtIntAbbrev; const Error = error{ OutOfMemory, CodegenFail }; -pub inline fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { - return comptime &.initEmpty(); +pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features { + return null; } fn subArchName(features: std.Target.Cpu.Feature.Set, arch: anytype, mappings: anytype) ?[]const u8 { diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig index c51e38ac7e..7c96909751 100644 --- a/src/codegen/spirv.zig +++ b/src/codegen/spirv.zig @@ -28,8 +28,8 @@ const SpvAssembler = @import("spirv/Assembler.zig"); const InstMap = std.AutoHashMapUnmanaged(Air.Inst.Index, IdRef); -pub inline fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { - return comptime &.initEmpty(); +pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features { + return null; } pub const zig_call_abi_ver = 3; diff --git a/src/dev.zig b/src/dev.zig index 473cb4a8d0..019f18daeb 100644 --- a/src/dev.zig +++ b/src/dev.zig @@ -67,6 +67,7 @@ pub const Env = enum { .incremental, .ast_gen, .sema, + .legalize, .llvm_backend, .c_backend, .wasm_backend, @@ -144,6 +145,7 @@ pub const Env = enum { .build_command, .stdio_listen, .incremental, + .legalize, .x86_64_backend, .elf_linker, => true, @@ -222,6 +224,7 @@ pub const Feature = enum { incremental, ast_gen, sema, + legalize, llvm_backend, c_backend,