std.builtin.CompilerBackend: useless renaming

lib/compiler_rt/aulldiv.zig

@@ -7,7 +7,7 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    if (arch == .x86 and abi == .msvc and builtin.zig_backend != .stage2_c) {
+    if (arch == .x86 and abi == .msvc and builtin.zig_backend != .zsf_c) {
         // Don't let LLVM apply the stdcall name mangling on those MSVC builtins
         @export(_alldiv, .{ .name = "\x01__alldiv", .linkage = common.linkage, .visibility = common.visibility });
         @export(_aulldiv, .{ .name = "\x01__aulldiv", .linkage = common.linkage, .visibility = common.visibility });

lib/compiler_rt/aullrem.zig

@@ -7,7 +7,7 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    if (arch == .x86 and abi == .msvc and builtin.zig_backend != .stage2_c) {
+    if (arch == .x86 and abi == .msvc and builtin.zig_backend != .zsf_c) {
         // Don't let LLVM apply the stdcall name mangling on those MSVC builtins
         @export(_allrem, .{ .name = "\x01__allrem", .linkage = common.linkage, .visibility = common.visibility });
         @export(_aullrem, .{ .name = "\x01__aullrem", .linkage = common.linkage, .visibility = common.visibility });

lib/compiler_rt/common.zig

@@ -84,8 +84,7 @@ pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, _: ?
 /// here in compiler-rt.
 pub fn F16T(comptime other_type: type) type {
     return switch (builtin.cpu.arch) {
-        .aarch64, .aarch64_be, .aarch64_32 => f16,
-        .riscv64 => if (builtin.zig_backend == .stage1) u16 else f16,
+        .aarch64, .aarch64_be, .aarch64_32, .riscv64 => f16,
         .x86, .x86_64 => if (builtin.target.isDarwin()) switch (other_type) {
             // Starting with LLVM 16, Darwin uses different abi for f16
             // depending on the type of the other return/argument..???

lib/compiler_rt/divdc3.zig

@@ -3,7 +3,7 @@ const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
-    if (@import("builtin").zig_backend != .stage2_c) {
+    if (@import("builtin").zig_backend != .zsf_c) {
         @export(__divdc3, .{ .name = "__divdc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }

lib/compiler_rt/divhc3.zig

@@ -3,7 +3,7 @@ const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
-    if (@import("builtin").zig_backend != .stage2_c) {
+    if (@import("builtin").zig_backend != .zsf_c) {
         @export(__divhc3, .{ .name = "__divhc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }

lib/compiler_rt/divsc3.zig

@@ -3,7 +3,7 @@ const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
-    if (@import("builtin").zig_backend != .stage2_c) {
+    if (@import("builtin").zig_backend != .zsf_c) {
         @export(__divsc3, .{ .name = "__divsc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }

lib/compiler_rt/divtc3.zig

@@ -3,7 +3,7 @@ const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
-    if (@import("builtin").zig_backend != .stage2_c) {
+    if (@import("builtin").zig_backend != .zsf_c) {
         if (common.want_ppc_abi)
             @export(__divtc3, .{ .name = "__divkc3", .linkage = common.linkage, .visibility = common.visibility });
         @export(__divtc3, .{ .name = "__divtc3", .linkage = common.linkage, .visibility = common.visibility });

lib/compiler_rt/divxc3.zig

@@ -3,7 +3,7 @@ const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
-    if (@import("builtin").zig_backend != .stage2_c) {
+    if (@import("builtin").zig_backend != .zsf_c) {
         @export(__divxc3, .{ .name = "__divxc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }

lib/compiler_rt/muldc3.zig

@@ -4,7 +4,7 @@ const mulc3 = @import("./mulc3.zig");
 pub const panic = common.panic;
 
 comptime {
-    if (@import("builtin").zig_backend != .stage2_c) {
+    if (@import("builtin").zig_backend != .zsf_c) {
         @export(__muldc3, .{ .name = "__muldc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }

lib/compiler_rt/mulhc3.zig

@@ -4,7 +4,7 @@ const mulc3 = @import("./mulc3.zig");
 pub const panic = common.panic;
 
 comptime {
-    if (@import("builtin").zig_backend != .stage2_c) {
+    if (@import("builtin").zig_backend != .zsf_c) {
         @export(__mulhc3, .{ .name = "__mulhc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }

lib/compiler_rt/mulsc3.zig

@@ -4,7 +4,7 @@ const mulc3 = @import("./mulc3.zig");
 pub const panic = common.panic;
 
 comptime {
-    if (@import("builtin").zig_backend != .stage2_c) {
+    if (@import("builtin").zig_backend != .zsf_c) {
         @export(__mulsc3, .{ .name = "__mulsc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }

lib/compiler_rt/multc3.zig

@@ -4,7 +4,7 @@ const mulc3 = @import("./mulc3.zig");
 pub const panic = common.panic;
 
 comptime {
-    if (@import("builtin").zig_backend != .stage2_c) {
+    if (@import("builtin").zig_backend != .zsf_c) {
         if (common.want_ppc_abi)
             @export(__multc3, .{ .name = "__mulkc3", .linkage = common.linkage, .visibility = common.visibility });
         @export(__multc3, .{ .name = "__multc3", .linkage = common.linkage, .visibility = common.visibility });

lib/compiler_rt/mulxc3.zig

@@ -4,7 +4,7 @@ const mulc3 = @import("./mulc3.zig");
 pub const panic = common.panic;
 
 comptime {
-    if (@import("builtin").zig_backend != .stage2_c) {
+    if (@import("builtin").zig_backend != .zsf_c) {
         @export(__mulxc3, .{ .name = "__mulxc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }

lib/compiler_rt/udivmodei4.zig

@@ -129,7 +129,7 @@ pub fn __umodei4(r_p: [*]u32, u_p: [*]const u32, v_p: [*]const u32, bits: usize)
 }
 
 test "__udivei4/__umodei4" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO
 
     const RndGen = std.rand.DefaultPrng;
     var rnd = RndGen.init(42);

lib/std/bit_set.zig

@@ -1636,7 +1636,7 @@ fn testStaticBitSet(comptime Set: type) !void {
 }
 
 test "IntegerBitSet" {
-    if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
+    if (@import("builtin").zig_backend == .zsf_c) return error.SkipZigTest;
 
     try testStaticBitSet(IntegerBitSet(0));
     try testStaticBitSet(IntegerBitSet(1));

lib/std/builtin.zig

@@ -667,42 +667,38 @@ pub const CompilerBackend = enum(u64) {
     /// in which case this value is appropriate. Be cool and make sure your
     /// code supports `other` Zig compilers!
     other = 0,
-    /// The original Zig compiler created in 2015 by Andrew Kelley. Implemented
-    /// in C++. Used LLVM. Deleted from the ZSF ziglang/zig codebase on
-    /// December 6th, 2022.
-    stage1 = 1,
-    /// The reference implementation self-hosted compiler of Zig, using the
+    /// The reference implementation by Zig Software Foundation, using the
     /// LLVM backend.
-    stage2_llvm = 2,
-    /// The reference implementation self-hosted compiler of Zig, using the
+    zsf_llvm = 1,
+    /// The reference implementation by Zig Software Foundation, using the
     /// backend that generates C source code.
     /// Note that one can observe whether the compilation will output C code
     /// directly with `object_format` value rather than the `compiler_backend` value.
-    stage2_c = 3,
-    /// The reference implementation self-hosted compiler of Zig, using the
+    zsf_c = 2,
+    /// The reference implementation by Zig Software Foundation, using the
     /// WebAssembly backend.
-    stage2_wasm = 4,
-    /// The reference implementation self-hosted compiler of Zig, using the
+    zsf_wasm = 3,
+    /// The reference implementation by Zig Software Foundation, using the
     /// arm backend.
-    stage2_arm = 5,
-    /// The reference implementation self-hosted compiler of Zig, using the
+    zsf_arm = 4,
+    /// The reference implementation by Zig Software Foundation, using the
     /// x86_64 backend.
-    stage2_x86_64 = 6,
-    /// The reference implementation self-hosted compiler of Zig, using the
+    zsf_x86_64 = 5,
+    /// The reference implementation by Zig Software Foundation, using the
     /// aarch64 backend.
-    stage2_aarch64 = 7,
-    /// The reference implementation self-hosted compiler of Zig, using the
+    zsf_aarch64 = 6,
+    /// The reference implementation by Zig Software Foundation, using the
     /// x86 backend.
-    stage2_x86 = 8,
-    /// The reference implementation self-hosted compiler of Zig, using the
+    zsf_x86 = 7,
+    /// The reference implementation by Zig Software Foundation, using the
     /// riscv64 backend.
-    stage2_riscv64 = 9,
-    /// The reference implementation self-hosted compiler of Zig, using the
+    zsf_riscv64 = 8,
+    /// The reference implementation by Zig Software Foundation, using the
     /// sparc64 backend.
-    stage2_sparc64 = 10,
-    /// The reference implementation self-hosted compiler of Zig, using the
+    zsf_sparc64 = 9,
+    /// The reference implementation by Zig Software Foundation, using the
     /// spirv backend.
-    stage2_spirv64 = 11,
+    zsf_spirv64 = 10,
 
     _,
 };
@@ -735,14 +731,14 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr
 
     // For backends that cannot handle the language features depended on by the
     // default panic handler, we have a simpler panic handler:
-    if (builtin.zig_backend == .stage2_wasm or
-        builtin.zig_backend == .stage2_arm or
-        builtin.zig_backend == .stage2_aarch64 or
-        builtin.zig_backend == .stage2_x86_64 or
-        builtin.zig_backend == .stage2_x86 or
-        builtin.zig_backend == .stage2_riscv64 or
-        builtin.zig_backend == .stage2_sparc64 or
-        builtin.zig_backend == .stage2_spirv64)
+    if (builtin.zig_backend == .zsf_wasm or
+        builtin.zig_backend == .zsf_arm or
+        builtin.zig_backend == .zsf_aarch64 or
+        builtin.zig_backend == .zsf_x86_64 or
+        builtin.zig_backend == .zsf_x86 or
+        builtin.zig_backend == .zsf_riscv64 or
+        builtin.zig_backend == .zsf_sparc64 or
+        builtin.zig_backend == .zsf_spirv64)
     {
         while (true) {
             @breakpoint();

lib/std/crypto/aes.zig

@@ -6,9 +6,9 @@ const has_aesni = std.Target.x86.featureSetHas(builtin.cpu.features, .aes);
 const has_avx = std.Target.x86.featureSetHas(builtin.cpu.features, .avx);
 const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes);
 // C backend doesn't currently support passing vectors to inline asm.
-const impl = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .stage2_c and has_aesni and has_avx) impl: {
+const impl = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .zsf_c and has_aesni and has_avx) impl: {
     break :impl @import("aes/aesni.zig");
-} else if (builtin.cpu.arch == .aarch64 and builtin.zig_backend != .stage2_c and has_armaes)
+} else if (builtin.cpu.arch == .aarch64 and builtin.zig_backend != .zsf_c and has_armaes)
 impl: {
     break :impl @import("aes/armcrypto.zig");
 } else impl: {

lib/std/crypto/aes_ocb.zig

@@ -257,7 +257,7 @@ inline fn xorWith(x: *Block, y: Block) void {
 const hexToBytes = std.fmt.hexToBytes;
 
 test "AesOcb test vector 1" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest;
 
     var k: [Aes128Ocb.key_length]u8 = undefined;
     var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
@@ -276,7 +276,7 @@ test "AesOcb test vector 1" {
 }
 
 test "AesOcb test vector 2" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest;
 
     var k: [Aes128Ocb.key_length]u8 = undefined;
     var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
@@ -297,7 +297,7 @@ test "AesOcb test vector 2" {
 }
 
 test "AesOcb test vector 3" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest;
 
     var k: [Aes128Ocb.key_length]u8 = undefined;
     var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
@@ -321,7 +321,7 @@ test "AesOcb test vector 3" {
 }
 
 test "AesOcb test vector 4" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest;
 
     var k: [Aes128Ocb.key_length]u8 = undefined;
     var nonce: [Aes128Ocb.nonce_length]u8 = undefined;

lib/std/crypto/ecdsa.zig

@@ -372,7 +372,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
 }
 
 test "ECDSA - Basic operations over EcdsaP384Sha384" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest;
 
     const Scheme = EcdsaP384Sha384;
     const kp = try Scheme.KeyPair.create(null);
@@ -388,7 +388,7 @@ test "ECDSA - Basic operations over EcdsaP384Sha384" {
 }
 
 test "ECDSA - Basic operations over Secp256k1" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest;
 
     const Scheme = EcdsaSecp256k1Sha256oSha256;
     const kp = try Scheme.KeyPair.create(null);
@@ -404,7 +404,7 @@ test "ECDSA - Basic operations over Secp256k1" {
 }
 
 test "ECDSA - Basic operations over EcdsaP384Sha256" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest;
 
     const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256);
     const kp = try Scheme.KeyPair.create(null);
@@ -420,7 +420,7 @@ test "ECDSA - Basic operations over EcdsaP384Sha256" {
 }
 
 test "ECDSA - Verifying a existing signature with EcdsaP384Sha256" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest;
 
     const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256);
     // zig fmt: off
@@ -464,7 +464,7 @@ const TestVector = struct {
 };
 
 test "ECDSA - Test vectors from Project Wycheproof" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest;
 
     const vectors = [_]TestVector{
         .{ .key = "042927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e", .msg = "313233343030", .sig = "304402202ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e1802204cd60b855d442f5b3c7b11eb6c4e0ae7525fe710fab9aa7c77a67f79e6fadd76", .result = .valid },
@@ -878,7 +878,7 @@ fn tvTry(vector: TestVector) !void {
 }
 
 test "ECDSA - Sec1 encoding/decoding" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .zsf_c) return error.SkipZigTest;
 
     const Scheme = EcdsaP384Sha384;
     const kp = try Scheme.KeyPair.create(null);

lib/std/crypto/ff.zig

@@ -854,7 +854,7 @@ const ct_unprotected = struct {
 };
 
 test {
-    if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
+    if (@import("builtin").zig_backend == .zsf_c) return error.SkipZigTest;
 
     const M = Modulus(256);
     const m = try M.fromPrimitive(u256, 3429938563481314093726330772853735541133072814650493833233);

lib/std/crypto/ghash_polyval.zig

@@ -293,9 +293,9 @@ fn Hash(comptime endian: std.builtin.Endian, comptime shift_key: bool) type {
         const has_avx = std.Target.x86.featureSetHas(builtin.cpu.features, .avx);
         const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes);
         // C backend doesn't currently support passing vectors to inline asm.
-        const clmul = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .stage2_c and has_pclmul and has_avx) impl: {
+        const clmul = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .zsf_c and has_pclmul and has_avx) impl: {
             break :impl clmulPclmul;
-        } else if (builtin.cpu.arch == .aarch64 and builtin.zig_backend != .stage2_c and has_armaes) impl: {
+        } else if (builtin.cpu.arch == .aarch64 and builtin.zig_backend != .zsf_c and has_armaes) impl: {
             break :impl clmulPmull;
         } else impl: {
             break :impl clmulSoft;

lib/std/crypto/pcurves/p384.zig

@@ -478,7 +478,7 @@ pub const AffineCoordinates = struct {
 };
 
 test {
-    if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
+    if (@import("builtin").zig_backend == .zsf_c) return error.SkipZigTest;
 
     _ = @import("tests/p384.zig");
 }

lib/std/crypto/pcurves/secp256k1.zig

@@ -556,7 +556,7 @@ pub const AffineCoordinates = struct {
 };
 
 test {
-    if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
+    if (@import("builtin").zig_backend == .zsf_c) return error.SkipZigTest;
 
     _ = @import("tests/secp256k1.zig");
 }

lib/std/crypto/sha2.zig

@@ -200,7 +200,7 @@ fn Sha2x32(comptime params: Sha2Params32) type {
 
             if (!@inComptime()) {
                 switch (builtin.cpu.arch) {
-                    .aarch64 => if (builtin.zig_backend != .stage2_c and comptime std.Target.aarch64.featureSetHas(builtin.cpu.features, .sha2)) {
+                    .aarch64 => if (builtin.zig_backend != .zsf_c and comptime std.Target.aarch64.featureSetHas(builtin.cpu.features, .sha2)) {
                         var x: v4u32 = d.s[0..4].*;
                         var y: v4u32 = d.s[4..8].*;
                         const s_v = @as(*[16]v4u32, @ptrCast(&s));
@@ -238,7 +238,7 @@ fn Sha2x32(comptime params: Sha2Params32) type {
                         return;
                     },
                     // C backend doesn't currently support passing vectors to inline asm.
-                    .x86_64 => if (builtin.zig_backend != .stage2_c and comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sha, .avx2 })) {
+                    .x86_64 => if (builtin.zig_backend != .zsf_c and comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sha, .avx2 })) {
                         var x: v4u32 = [_]u32{ d.s[5], d.s[4], d.s[1], d.s[0] };
                         var y: v4u32 = [_]u32{ d.s[7], d.s[6], d.s[3], d.s[2] };
                         const s_v = @as(*[16]v4u32, @ptrCast(&s));

lib/std/http/Client.zig

@@ -1042,7 +1042,7 @@ pub fn request(client: *Client, method: http.Method, uri: Uri, headers: http.Hea
 test {
     const builtin = @import("builtin");
     const native_endian = comptime builtin.cpu.arch.endian();
-    if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) {
+    if (builtin.zig_backend == .zsf_llvm and native_endian == .Big) {
         // https://github.com/ziglang/zig/issues/13782
         return error.SkipZigTest;
     }

lib/std/http/Server.zig

@@ -715,7 +715,7 @@ test "HTTP server handles a chunked transfer coding request" {
     }
 
     const native_endian = comptime builtin.cpu.arch.endian();
-    if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) {
+    if (builtin.zig_backend == .zsf_llvm and native_endian == .Big) {
         // https://github.com/ziglang/zig/issues/13782
         return error.SkipZigTest;
     }