diff --git a/src/Air/Legalize.zig b/src/Air/Legalize.zig
index 870270f089f442c371c92139df1a97cea7be796f..221e98aebb6b3564fd6be678e2b99c18f76a57a9 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 93f87b506bdb3bdf602ac846d60ec266e1bdd436..a67d4dcc05e4661d41f8703bd326040ab645ec22 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 88fdeb98315fe33af897faea896a58b87ec10f21..e9e71599386c396471dcfcd10417e98c614ab0fd 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 a0183025664a975b053c087a63efb5f3fb77e5a0..8cc1d0a6073a0f785dc59b535d197325363d5396 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 a3a4615b4ab9ca6067ac9ee64b0d6b0f38468dff..0cfee67ebdbd63697cc47aa81f6332cd819fbc81 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 5732f4cd411c0fe3b5c832b63bc6662402320466..981b5a800fd903e30787554425172a699b69a938 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 ead7ef3e994e5ea4d0bb1aeacc810633f0512778..d473222288aa2ac588f47ad96accd2c7838fb8dd 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 a130f1508dccd4f975591b77a79a360544f5404d..ec448ca29be14e029c70eccb7d0000128a15614f 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 8d609682f150f55396f70a5fa5db0a989a79d950..1f794bbeeae0f22306cd940d2394477667b0efb0 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 2d3b236a8668040ac64c8642000c40c6f27c81ac..e76c8e069d14e4fff9c591fc876797664b20c2a6 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 6f411e7490073fd88dc815e003d23d584a029f98..77d8f3ff47c623a3ff93cad0e9443a643d8cec42 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 c51e38ac7ee34d3883ac4d414638348595035f54..7c969097510ee119700f199e59cd815692c85221 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 473cb4a8d075a6e2dfccf23480b7a862bd8585ac..019f18daeb447003ef6deac1f8d10921b12e8987 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,