Commit dec706c243ab7d0c2e87fd64c77cda9cd8847520 | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-08-24 16:09:52-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-08-26 20:54:49-07:00
log	dec706c243ab7d0c2e87fd64c77cda9cd8847520
tree	7abbba3ade3fc9fb83159fd80ff91758db9da589
parent	5a8c5e322b67c16be6cdcec7621c4a59ae86dd85

spork8: coding style conformance

1 files changed, 125 insertions(+), 68 deletions(-)

src
- codegen
  - spork8
    CodeGen.zig

src/codegen/spork8/CodeGen.zig+125-68

 @@ -187,7 +187,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
 fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const air_tags = cg.air.instructions.items(.tag);
-    return switch (air_tags[@intFromEnum(inst)]) {
+    return switch (air_tags[@backingInt(inst)]) {
         .inferred_alloc, .inferred_alloc_comptime => unreachable,
         .add,
 @@ -431,7 +431,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         .legalize_vec_store_elem,
         .legalize_vec_elem_val,
         .legalize_compiler_rt_call,
-        => |tag| return cg.fail("TODO: implement spork8 inst: {s}", .{@tagName(tag)}),
+        => |tag| return cg.fail("TODO: implement spork8 inst: {t}", .{tag}),
         .unreach => cg.airUnreachable(inst),
         .assembly => cg.airAssembly(inst),
 @@ -473,21 +473,21 @@ fn airAssembly(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         while (it.next()) |input| {
             const constraint = input.constraint;
             if (!mem.eql(u8, constraint, "I")) {
-                return cg.fail("Assembly constraint {q} not supported", .{constraint});
+                return cg.fail("assembly constraint {q} not supported", .{constraint});
             }
             const operand = input.operand.toInterned() orelse {
-                return cg.fail("Immediate argument to inline assembly must be compile-time value", .{});
+                return cg.fail("immediate argument to inline assembly must be compile-time value", .{});
             };
             const name = input.name;
             const value = switch (zcu.intern_pool.indexToKey(operand)) {
                 .int => |val| v: {
                     if (val.ty != .u8_type) {
-                        return cg.fail("Non-u8 type used in inline assembly value: {}", .{val.ty});
+                        return cg.fail("non-u8 type used in inline assembly value: {}", .{val.ty});
                     }
                     break :v val.storage.u64;
                 },
-                else => return cg.fail("Non-int operands not supported", .{}),
+                else => return cg.fail("non-int operands not supported", .{}),
             };
             try constValues.put(zcu.gpa, name, @intCast(value));
 @@ -500,18 +500,19 @@ fn airAssembly(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
             var tokens = mem.tokenizeScalar(u8, line, ' ');
             // If there's no tokens, then it must be a blank line, so just skip it.
             const op = tokens.next() orelse continue;
-            const instType = std.meta.stringToEnum(AsmInstType, op) orelse return cg.fail("Invalid asm instruction: {q}", .{op});
+            const instType = std.meta.stringToEnum(AsmInstType, op) orelse return cg.fail("invalid asm instruction: {q}", .{op});
             switch (instType) {
                 .LoadI => {
-                    const registerString = tokens.next() orelse return cg.fail("Missing register for LoadI instruction", .{});
+                    const registerString = tokens.next() orelse return cg.fail("missing register for LoadI instruction", .{});
-                    const register = std.meta.stringToEnum(Register, registerString) orelse return cg.fail("Invalid register: {q}", .{registerString});
+                    const register = std.meta.stringToEnum(Register, registerString) orelse return cg.fail("invalid register: {q}", .{registerString});
-                    const value = tokens.next() orelse return cg.fail("Missing immediate value for LoadI", .{});
+                    const value = tokens.next() orelse return cg.fail("missing immediate value for LoadI", .{});
                     const intValue = v: {
                         if (mem.startsWith(u8, value, "%[")) {
                             const name = value[2 .. value.len - 1];
-                            break :v constValues.get(name) orelse return cg.fail("Constraint name {q} not included in constraints for inline asm", .{name});
+                            break :v constValues.get(name) orelse return cg.fail("constraint name {q} not included in constraints for inline asm", .{name});
                         } else {
-                            break :v std.fmt.parseInt(u8, value, 0) catch return cg.fail("Couldn't parse u8 from LoadI immediate value", .{});
+                            break :v std.fmt.parseInt(u8, value, 0) catch |err|
+                                return cg.fail("invalid LoadI immediate value: {t}", .{err});
                         }
                     };
                     if (register != .OutA) {
 @@ -548,62 +549,118 @@ fn extraLen(cg: *const CodeGen) u32 {
 }
 const AsmInstType = enum(u8) {
-    SetPageReg, // Set the memory address high byte to a register value.
+    /// Set the memory address high byte to a register value.
-    SetPageI, // Set the memory address high byte to a constant value.
+    SetPageReg,
-    SetAddrReg, // Set the memory address low byte to a register value.
+    /// Set the memory address high byte to a constant value.
-    SetAddrI, // Set the memory address low byte to a constant value.
+    SetPageI,
-    Load, // Load a value from a constant address into a register.
+    /// Set the memory address low byte to a register value.
-    LoadI, // Load a constant value into a register.
+    SetAddrReg,
-    LoadP, // Load a value from a constant address (setting low byte only) into a register.
+    /// Set the memory address low byte to a constant value.
-    LoadInc, // Load a value from the currently set memory address into a register, and increment the address n times.
+    SetAddrI,
-    LoadStck, // Load a value from an offset on the current stack frame into a register.
+    /// Load a value from a constant address into a register.
-    Store, // Store a value to a constant address from a register.
+    Load,
-    StoreI, // Store a constant value into a constant address.
+    /// Load a constant value into a register.
-    StoreP, // Store a value to a constant address (low byte only) from a register.
+    LoadI,
-    StoreInc, // Store a value from the currently set memory address from a register, and increment the address n times.
+    /// Load a value from a constant address (setting low byte only) into a register.
-    StoreStck, // Store a value to an offset on the current stack frame, from a register.
+    LoadP,
-    StoreNStck, // Store a value to an offset on the next stack frame, from a register.
+    /// Load a value from the currently set memory address into a register, and increment the address n times.
-    StorePStck, // Store a value to an offset on the previous stack frame, from a register.
+    LoadInc,
-    StoreStckI, // Store a constant value to an offset on the current stack frame.
+    /// Load a value from an offset on the current stack frame into a register.
-    StoreNStckI, // Store a constant value to an offset on the next stack frame.
+    LoadStck,
-    StorePStckI, // Store a constant value to an offset on the previous stack frame.
+    /// Store a value to a constant address from a register.
-    Copy, // Copy a value from one register to another register.
+    Store,
-    Jump, // Jump to a constant location.
+    /// Store a constant value into a constant address.
-    JumpReg, // Jump to a register A (high byte) + register B (low byte).
+    StoreI,
-    JumpMem, // Jump to a location pointed to by memory at the current memory address (high byte first).
+    /// Store a value to a constant address (low byte only) from a register.
-    Call, // Call a function.
+    StoreP,
-    Return, // Return from a function.
+    /// Store a value from the currently set memory address from a register, and increment the address n times.
-    CmpI, // Compare A to a constant value (sets flags, but discards result).
+    StoreInc,
-    CmpAndI, // Compare A to a constant value with bitwise AND (sets flags, but discards result).
+    /// Store a value to an offset on the current stack frame, from a register.
-    Cmp, // Compare A to a value from memory (sets flags, but discards result).
+    StoreStck,
-    CmpAnd, // Compare A to a value in memory with bitwise AND (sets flags, but discards result).
+    /// Store a value to an offset on the next stack frame, from a register.
-    CmpReg, // Compare A to a value from a register (sets flags, but discards result).
+    StoreNStck,
-    CmpAndReg, // Compare A to a value from a register with bitwise AND (sets flags, but discards result).
+    /// Store a value to an offset on the previous stack frame, from a register.
-    ShiftL, // Shift B left by 1.
+    StorePStck,
-    ShiftR, // Shift B right by 1.
+    /// Store a constant value to an offset on the current stack frame.
-    RotateL, // Rotate B left by 1.
+    StoreStckI,
-    RotateR, // Rotate B right by 1.
+    /// Store a constant value to an offset on the next stack frame.
-    AddI, // Add a constant value to A.
+    StoreNStckI,
-    SubI, // Subtract a constant value from A.
+    /// Store a constant value to an offset on the previous stack frame.
-    AndI, // Bitwise-AND A with a constant value.
+    StorePStckI,
-    AddINF, // Add a constant value to A, without updating flags.
+    /// Copy a value from one register to another register.
-    SubINF, // Subtract a constant value from A, without updating flags.
+    Copy,
-    AndINF, // Bitwise-AND A with a constant value, without updating flags.
+    /// Jump to a constant location.
-    AccumulateAdd, // Add register B to A -> A.
+    Jump,
-    AccumulateSub, // Subtract register B from A -> A.
+    /// Jump to a register A (high byte) + register B (low byte).
-    AccumulateAnd, // A & B -> A.
+    JumpReg,
-    OrI, // Bitwise OR B with A -> A.
+    /// Jump to a location pointed to by memory at the current memory address (high byte first).
-    XorI, // Bitwise OR a constant value with A -> A.
+    JumpMem,
-    Not, // Invert register A.
+    /// Call a function.
-    Add, // Add a value from memory to A.
+    Call,
-    Sub, // Subtract a value from memory from A.
+    /// Return from a function.
-    And, // AND A with a value from memory.
+    Return,
-    Or, // OR A with a value from memory.
+    /// Compare A to a constant value (sets flags, but discards result).
-    Xor, // XOR A with a value from memory.
+    CmpI,
-    Nop, // No-op.
+    /// Compare A to a constant value with bitwise AND (sets flags, but discards result).
-    Nop1, // No-op with 1 extra clock cycle.
+    CmpAndI,
-    Nop2, // No-op with 2 extra clock cycles.
+    /// Compare A to a value from memory (sets flags, but discards result).
-    Halt, // Halt - stop the program forever (until reset).
+    Cmp,
+    /// Compare A to a value in memory with bitwise AND (sets flags, but discards result).
+    CmpAnd,
+    /// Compare A to a value from a register (sets flags, but discards result).
+    CmpReg,
+    /// Compare A to a value from a register with bitwise AND (sets flags, but discards result).
+    CmpAndReg,
+    /// Shift B left by 1.
+    ShiftL,
+    /// Shift B right by 1.
+    ShiftR,
+    /// Rotate B left by 1.
+    RotateL,
+    /// Rotate B right by 1.
+    RotateR,
+    /// Add a constant value to A.
+    AddI,
+    /// Subtract a constant value from A.
+    SubI,
+    /// Bitwise-AND A with a constant value.
+    AndI,
+    /// Add a constant value to A, without updating flags.
+    AddINF,
+    /// Subtract a constant value from A, without updating flags.
+    SubINF,
+    /// Bitwise-AND A with a constant value, without updating flags.
+    AndINF,
+    /// Add register B to A -> A.
+    AccumulateAdd,
+    /// Subtract register B from A -> A.
+    AccumulateSub,
+    /// A & B -> A.
+    AccumulateAnd,
+    /// Bitwise OR B with A -> A.
+    OrI,
+    /// Bitwise OR a constant value with A -> A.
+    XorI,
+    /// Invert register A.
+    Not,
+    /// Add a value from memory to A.
+    Add,
+    /// Subtract a value from memory from A.
+    Sub,
+    /// AND A with a value from memory.
+    And,
+    /// OR A with a value from memory.
+    Or,
+    /// XOR A with a value from memory.
+    Xor,
+    /// No-op.
+    Nop,
+    /// No-op with 1 extra clock cycle.
+    Nop1,
+    /// No-op with 2 extra clock cycles.
+    Nop2,
+    /// Halt - stop the program forever (until reset).
+    Halt,
 };
 const Register = enum(u8) {