authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-04-29 10:55:50-07:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2023-04-29 10:55:50-07:00
log7baf0de807afc8c2c56cc1278e624e9103c30cfb
tree8fd39ab072376b73f2e62147a7e1bd9d75293432
parent13aaa16ab2cac5c07a970a3b49f5dd0ffd4d3539
parentccc9b8caf632bf97f7765c1b1d7821118cf34008
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #15458 from koachan/sparc64-codegen

stage2: sparc64: Yet another patchset for the selfhosted backend

14 files changed, 331 insertions(+), 12 deletions(-)

src/arch/sparc64/CodeGen.zig+205-11
......@@ -22,6 +22,7 @@ const Type = @import("../../type.zig").Type;
2222const CodeGenError = codegen.CodeGenError;
2323const Result = @import("../../codegen.zig").Result;
2424const DebugInfoOutput = @import("../../codegen.zig").DebugInfoOutput;
25const Endian = std.builtin.Endian;
2526
2627const build_options = @import("build_options");
2728
......@@ -30,6 +31,7 @@ const abi = @import("abi.zig");
3031const errUnionPayloadOffset = codegen.errUnionPayloadOffset;
3132const errUnionErrorOffset = codegen.errUnionErrorOffset;
3233const Instruction = bits.Instruction;
34const ASI = Instruction.ASI;
3335const ShiftWidth = Instruction.ShiftWidth;
3436const RegisterManager = abi.RegisterManager;
3537const RegisterLock = RegisterManager.RegisterLock;
......@@ -141,6 +143,8 @@ const MCValue = union(enum) {
141143 /// The value is one of the stack variables.
142144 /// If the type is a pointer, it means the pointer address is in the stack at this offset.
143145 /// Note that this stores the plain value (i.e without the effects of the stack bias).
146 /// Always convert this value into machine offsets with realStackOffset() before
147 /// lowering into asm!
144148 stack_offset: u32,
145149 /// The value is a pointer to one of the stack variables (payload is stack offset).
146150 ptr_stack_offset: u32,
......@@ -595,7 +599,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
595599 .ret_load => try self.airRetLoad(inst),
596600 .store => try self.airStore(inst, false),
597601 .store_safe => try self.airStore(inst, true),
598 .struct_field_ptr=> @panic("TODO try self.airStructFieldPtr(inst)"),
602 .struct_field_ptr=> try self.airStructFieldPtr(inst),
599603 .struct_field_val=> try self.airStructFieldVal(inst),
600604 .array_to_slice => try self.airArrayToSlice(inst),
601605 .int_to_float => try self.airIntToFloat(inst),
......@@ -613,7 +617,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
613617 .clz => try self.airClz(inst),
614618 .ctz => try self.airCtz(inst),
615619 .popcount => try self.airPopcount(inst),
616 .byte_swap => @panic("TODO try self.airByteSwap(inst)"),
620 .byte_swap => try self.airByteSwap(inst),
617621 .bit_reverse => try self.airBitReverse(inst),
618622 .tag_name => try self.airTagName(inst),
619623 .error_name => try self.airErrorName(inst),
......@@ -663,8 +667,8 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
663667 .slice_ptr => try self.airSlicePtr(inst),
664668 .slice_len => try self.airSliceLen(inst),
665669
666 .ptr_slice_len_ptr => @panic("TODO try self.airPtrSliceLenPtr(inst)"),
667 .ptr_slice_ptr_ptr => @panic("TODO try self.airPtrSlicePtrPtr(inst)"),
670 .ptr_slice_len_ptr => try self.airPtrSliceLenPtr(inst),
671 .ptr_slice_ptr_ptr => try self.airPtrSlicePtrPtr(inst),
668672
669673 .array_elem_val => try self.airArrayElemVal(inst),
670674 .slice_elem_val => try self.airSliceElemVal(inst),
......@@ -720,10 +724,10 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
720724 .error_set_has_value => @panic("TODO implement error_set_has_value"),
721725 .vector_store_elem => @panic("TODO implement vector_store_elem"),
722726
723 .c_va_arg => @panic("TODO implement c_va_arg"),
724 .c_va_copy => @panic("TODO implement c_va_copy"),
725 .c_va_end => @panic("TODO implement c_va_end"),
726 .c_va_start => @panic("TODO implement c_va_start"),
727 .c_va_arg => return self.fail("TODO implement c_va_arg", .{}),
728 .c_va_copy => return self.fail("TODO implement c_va_copy", .{}),
729 .c_va_end => return self.fail("TODO implement c_va_end", .{}),
730 .c_va_start => return self.fail("TODO implement c_va_start", .{}),
727731
728732 .wasm_memory_size => unreachable,
729733 .wasm_memory_grow => unreachable,
......@@ -1198,6 +1202,90 @@ fn airBreakpoint(self: *Self) !void {
11981202 return self.finishAirBookkeeping();
11991203}
12001204
1205fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
1206 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1207
1208 // We have hardware byteswapper in SPARCv9, don't let mainstream compilers mislead you.
1209 // That being said, the strategy to lower this is:
1210 // - If src is an immediate, comptime-swap it.
1211 // - If src is in memory then issue an LD*A with #ASI_P_[oppposite-endian]
1212 // - If src is a register then issue an ST*A with #ASI_P_[oppposite-endian]
1213 // to a stack slot, then follow with a normal load from said stack slot.
1214 // This is because on some implementations, ASI-tagged memory operations are non-piplelinable
1215 // and loads tend to have longer latency than stores, so the sequence will minimize stall.
1216 // The result will always be either another immediate or stored in a register.
1217 // TODO: Fold byteswap+store into a single ST*A and load+byteswap into a single LD*A.
1218 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
1219 const operand = try self.resolveInst(ty_op.operand);
1220 const operand_ty = self.air.typeOf(ty_op.operand);
1221 switch (operand_ty.zigTypeTag()) {
1222 .Vector => return self.fail("TODO byteswap for vectors", .{}),
1223 .Int => {
1224 const int_info = operand_ty.intInfo(self.target.*);
1225 if (int_info.bits == 8) break :result operand;
1226
1227 const abi_size = int_info.bits >> 3;
1228 const abi_align = operand_ty.abiAlignment(self.target.*);
1229 const opposite_endian_asi = switch (self.target.cpu.arch.endian()) {
1230 Endian.Big => ASI.asi_primary_little,
1231 Endian.Little => ASI.asi_primary,
1232 };
1233
1234 switch (operand) {
1235 .immediate => |imm| {
1236 const swapped = switch (int_info.bits) {
1237 16 => @byteSwap(@intCast(u16, imm)),
1238 24 => @byteSwap(@intCast(u24, imm)),
1239 32 => @byteSwap(@intCast(u32, imm)),
1240 40 => @byteSwap(@intCast(u40, imm)),
1241 48 => @byteSwap(@intCast(u48, imm)),
1242 56 => @byteSwap(@intCast(u56, imm)),
1243 64 => @byteSwap(@intCast(u64, imm)),
1244 else => return self.fail("TODO synthesize SPARCv9 byteswap for other integer sizes", .{}),
1245 };
1246 break :result .{ .immediate = swapped };
1247 },
1248 .register => |reg| {
1249 if (int_info.bits > 64 or @popCount(int_info.bits) != 1)
1250 return self.fail("TODO synthesize SPARCv9 byteswap for other integer sizes", .{});
1251
1252 const off = try self.allocMem(inst, abi_size, abi_align);
1253 const off_reg = try self.copyToTmpRegister(operand_ty, .{ .immediate = realStackOffset(off) });
1254
1255 try self.genStoreASI(reg, .sp, off_reg, abi_size, opposite_endian_asi);
1256 try self.genLoad(reg, .sp, Register, off_reg, abi_size);
1257 break :result .{ .register = reg };
1258 },
1259 .memory => {
1260 if (int_info.bits > 64 or @popCount(int_info.bits) != 1)
1261 return self.fail("TODO synthesize SPARCv9 byteswap for other integer sizes", .{});
1262
1263 const addr_reg = try self.copyToTmpRegister(operand_ty, operand);
1264 const dst_reg = try self.register_manager.allocReg(null, gp);
1265
1266 try self.genLoadASI(dst_reg, addr_reg, .g0, abi_size, opposite_endian_asi);
1267 break :result .{ .register = dst_reg };
1268 },
1269 .stack_offset => |off| {
1270 if (int_info.bits > 64 or @popCount(int_info.bits) != 1)
1271 return self.fail("TODO synthesize SPARCv9 byteswap for other integer sizes", .{});
1272
1273 const off_reg = try self.copyToTmpRegister(operand_ty, .{ .immediate = realStackOffset(off) });
1274 const dst_reg = try self.register_manager.allocReg(null, gp);
1275
1276 try self.genLoadASI(dst_reg, .sp, off_reg, abi_size, opposite_endian_asi);
1277 break :result .{ .register = dst_reg };
1278 },
1279 else => unreachable,
1280 }
1281 },
1282 else => unreachable,
1283 }
1284 };
1285
1286 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1287}
1288
12011289fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
12021290 if (modifier == .always_tail) return self.fail("TODO implement tail calls for {}", .{self.target.cpu.arch});
12031291
......@@ -2150,6 +2238,38 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
21502238 return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
21512239}
21522240
2241fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
2242 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
2243 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
2244 const ptr_bits = self.target.cpu.arch.ptrBitWidth();
2245 const ptr_bytes = @divExact(ptr_bits, 8);
2246 const mcv = try self.resolveInst(ty_op.operand);
2247 switch (mcv) {
2248 .dead, .unreach, .none => unreachable,
2249 .ptr_stack_offset => |off| {
2250 break :result MCValue{ .ptr_stack_offset = off - ptr_bytes };
2251 },
2252 else => return self.fail("TODO implement ptr_slice_len_ptr for {}", .{mcv}),
2253 }
2254 };
2255 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2256}
2257
2258fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
2259 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
2260 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
2261 const mcv = try self.resolveInst(ty_op.operand);
2262 switch (mcv) {
2263 .dead, .unreach, .none => unreachable,
2264 .ptr_stack_offset => |off| {
2265 break :result MCValue{ .ptr_stack_offset = off };
2266 },
2267 else => return self.fail("TODO implement ptr_slice_len_ptr for {}", .{mcv}),
2268 }
2269 };
2270 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2271}
2272
21532273fn airPtrToInt(self: *Self, inst: Air.Inst.Index) !void {
21542274 const un_op = self.air.instructions.items(.data)[inst].un_op;
21552275 const result = try self.resolveInst(un_op);
......@@ -2425,6 +2545,13 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
24252545 return self.finishAir(inst, .dead, .{ bin_op.lhs, bin_op.rhs, .none });
24262546}
24272547
2548fn airStructFieldPtr(self: *Self, inst: Air.Inst.Index) !void {
2549 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
2550 const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
2551 const result = try self.structFieldPtr(inst, extra.struct_operand, extra.field_index);
2552 return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none });
2553}
2554
24282555fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {
24292556 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
24302557 const result = try self.structFieldPtr(inst, ty_op.operand, index);
......@@ -3574,6 +3701,34 @@ fn genLoad(self: *Self, value_reg: Register, addr_reg: Register, comptime off_ty
35743701 }
35753702}
35763703
3704fn genLoadASI(self: *Self, value_reg: Register, addr_reg: Register, off_reg: Register, abi_size: u64, asi: ASI) !void {
3705 switch (abi_size) {
3706 1, 2, 4, 8 => {
3707 const tag: Mir.Inst.Tag = switch (abi_size) {
3708 1 => .lduba,
3709 2 => .lduha,
3710 4 => .lduwa,
3711 8 => .ldxa,
3712 else => unreachable, // unexpected abi size
3713 };
3714
3715 _ = try self.addInst(.{
3716 .tag = tag,
3717 .data = .{
3718 .mem_asi = .{
3719 .rd = value_reg,
3720 .rs1 = addr_reg,
3721 .rs2 = off_reg,
3722 .asi = asi,
3723 },
3724 },
3725 });
3726 },
3727 3, 5, 6, 7 => return self.fail("TODO: genLoad for more abi_sizes", .{}),
3728 else => unreachable,
3729 }
3730}
3731
35773732fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void {
35783733 switch (mcv) {
35793734 .dead => unreachable,
......@@ -3644,7 +3799,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
36443799 return self.genSetReg(ty, reg, .{ .immediate = 0xaaaaaaaaaaaaaaaa });
36453800 },
36463801 .ptr_stack_offset => |off| {
3647 const real_offset = off + abi.stack_bias + abi.stack_reserved_area;
3802 const real_offset = realStackOffset(off);
36483803 const simm13 = math.cast(i13, real_offset) orelse
36493804 return self.fail("TODO larger stack offsets: {}", .{real_offset});
36503805
......@@ -3776,7 +3931,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
37763931 try self.genLoad(reg, reg, i13, 0, ty.abiSize(self.target.*));
37773932 },
37783933 .stack_offset => |off| {
3779 const real_offset = off + abi.stack_bias + abi.stack_reserved_area;
3934 const real_offset = realStackOffset(off);
37803935 const simm13 = math.cast(i13, real_offset) orelse
37813936 return self.fail("TODO larger stack offsets: {}", .{real_offset});
37823937 try self.genLoad(reg, .sp, i13, simm13, ty.abiSize(self.target.*));
......@@ -3810,7 +3965,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
38103965 return self.genSetStack(ty, stack_offset, MCValue{ .register = reg });
38113966 },
38123967 .register => |reg| {
3813 const real_offset = stack_offset + abi.stack_bias + abi.stack_reserved_area;
3968 const real_offset = realStackOffset(stack_offset);
38143969 const simm13 = math.cast(i13, real_offset) orelse
38153970 return self.fail("TODO larger stack offsets: {}", .{real_offset});
38163971 return self.genStore(reg, .sp, i13, simm13, abi_size);
......@@ -3933,6 +4088,34 @@ fn genStore(self: *Self, value_reg: Register, addr_reg: Register, comptime off_t
39334088 }
39344089}
39354090
4091fn genStoreASI(self: *Self, value_reg: Register, addr_reg: Register, off_reg: Register, abi_size: u64, asi: ASI) !void {
4092 switch (abi_size) {
4093 1, 2, 4, 8 => {
4094 const tag: Mir.Inst.Tag = switch (abi_size) {
4095 1 => .stba,
4096 2 => .stha,
4097 4 => .stwa,
4098 8 => .stxa,
4099 else => unreachable, // unexpected abi size
4100 };
4101
4102 _ = try self.addInst(.{
4103 .tag = tag,
4104 .data = .{
4105 .mem_asi = .{
4106 .rd = value_reg,
4107 .rs1 = addr_reg,
4108 .rs2 = off_reg,
4109 .asi = asi,
4110 },
4111 },
4112 });
4113 },
4114 3, 5, 6, 7 => return self.fail("TODO: genLoad for more abi_sizes", .{}),
4115 else => unreachable,
4116 }
4117}
4118
39364119fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
39374120 const mcv: MCValue = switch (try codegen.genTypedValue(
39384121 self.bin_file,
......@@ -4245,6 +4428,17 @@ fn processDeath(self: *Self, inst: Air.Inst.Index) void {
42454428 }
42464429}
42474430
4431/// Turns stack_offset MCV into a real SPARCv9 stack offset usable for asm.
4432fn realStackOffset(off: u32) u32 {
4433 return off
4434 // SPARCv9 %sp points away from the stack by some amount.
4435 + abi.stack_bias
4436 // The first couple bytes of each stack frame is reserved
4437 // for ABI and hardware purposes.
4438 + abi.stack_reserved_area;
4439 // Only after that we have the usable stack frame portion.
4440}
4441
42484442/// Caller must call `CallMCValues.deinit`.
42494443fn resolveCallingConventionValues(self: *Self, fn_ty: Type, role: RegisterView) !CallMCValues {
42504444 const cc = fn_ty.fnCallingConvention();
src/arch/sparc64/Emit.zig+33
......@@ -91,6 +91,11 @@ pub fn emitMir(
9191 .lduw => try emit.mirArithmetic3Op(inst),
9292 .ldx => try emit.mirArithmetic3Op(inst),
9393
94 .lduba => try emit.mirMemASI(inst),
95 .lduha => try emit.mirMemASI(inst),
96 .lduwa => try emit.mirMemASI(inst),
97 .ldxa => try emit.mirMemASI(inst),
98
9499 .@"and" => try emit.mirArithmetic3Op(inst),
95100 .@"or" => try emit.mirArithmetic3Op(inst),
96101 .xor => try emit.mirArithmetic3Op(inst),
......@@ -127,6 +132,11 @@ pub fn emitMir(
127132 .stw => try emit.mirArithmetic3Op(inst),
128133 .stx => try emit.mirArithmetic3Op(inst),
129134
135 .stba => try emit.mirMemASI(inst),
136 .stha => try emit.mirMemASI(inst),
137 .stwa => try emit.mirMemASI(inst),
138 .stxa => try emit.mirMemASI(inst),
139
130140 .sub => try emit.mirArithmetic3Op(inst),
131141 .subcc => try emit.mirArithmetic3Op(inst),
132142
......@@ -368,6 +378,29 @@ fn mirConditionalMove(emit: *Emit, inst: Mir.Inst.Index) !void {
368378 }
369379}
370380
381fn mirMemASI(emit: *Emit, inst: Mir.Inst.Index) !void {
382 const tag = emit.mir.instructions.items(.tag)[inst];
383 const data = emit.mir.instructions.items(.data)[inst].mem_asi;
384
385 const rd = data.rd;
386 const rs1 = data.rs1;
387 const rs2 = data.rs2;
388 const asi = data.asi;
389
390 switch (tag) {
391 .lduba => try emit.writeInstruction(Instruction.lduba(rs1, rs2, asi, rd)),
392 .lduha => try emit.writeInstruction(Instruction.lduha(rs1, rs2, asi, rd)),
393 .lduwa => try emit.writeInstruction(Instruction.lduwa(rs1, rs2, asi, rd)),
394 .ldxa => try emit.writeInstruction(Instruction.ldxa(rs1, rs2, asi, rd)),
395
396 .stba => try emit.writeInstruction(Instruction.stba(rs1, rs2, asi, rd)),
397 .stha => try emit.writeInstruction(Instruction.stha(rs1, rs2, asi, rd)),
398 .stwa => try emit.writeInstruction(Instruction.stwa(rs1, rs2, asi, rd)),
399 .stxa => try emit.writeInstruction(Instruction.stxa(rs1, rs2, asi, rd)),
400 else => unreachable,
401 }
402}
403
371404fn mirMembar(emit: *Emit, inst: Mir.Inst.Index) !void {
372405 const tag = emit.mir.instructions.items(.tag)[inst];
373406 const mask = emit.mir.instructions.items(.data)[inst].membar_mask;
src/arch/sparc64/Mir.zig+30
......@@ -15,6 +15,7 @@ const bits = @import("bits.zig");
1515const Air = @import("../../Air.zig");
1616
1717const Instruction = bits.Instruction;
18const ASI = bits.Instruction.ASI;
1819const Register = bits.Register;
1920
2021instructions: std.MultiArrayList(Inst).Slice,
......@@ -70,6 +71,16 @@ pub const Inst = struct {
7071 lduw,
7172 ldx,
7273
74 /// A.28 Load Integer from Alternate Space
75 /// This uses the mem_asi field.
76 /// Note that the ldda variant of this instruction is deprecated, so do not emit
77 /// it unless specifically requested (e.g. by inline assembly).
78 // TODO add other operations.
79 lduba,
80 lduha,
81 lduwa,
82 ldxa,
83
7384 /// A.31 Logical Operations
7485 /// This uses the arithmetic_3op field.
7586 // TODO add other operations.
......@@ -132,6 +143,16 @@ pub const Inst = struct {
132143 stw,
133144 stx,
134145
146 /// A.55 Store Integer into Alternate Space
147 /// This uses the mem_asi field.
148 /// Note that the stda variant of this instruction is deprecated, so do not emit
149 /// it unless specifically requested (e.g. by inline assembly).
150 // TODO add other operations.
151 stba,
152 stha,
153 stwa,
154 stxa,
155
135156 /// A.56 Subtract
136157 /// This uses the arithmetic_3op field.
137158 // TODO add other operations.
......@@ -241,6 +262,15 @@ pub const Inst = struct {
241262 inst: Index,
242263 },
243264
265 /// ASI-tagged memory operations.
266 /// Used by e.g. ldxa, stxa
267 mem_asi: struct {
268 rd: Register,
269 rs1: Register,
270 rs2: Register = .g0,
271 asi: ASI,
272 },
273
244274 /// Membar mask, controls the barrier behavior
245275 /// Used by e.g. membar
246276 membar_mask: struct {
src/arch/sparc64/bits.zig+32
......@@ -1229,6 +1229,22 @@ pub const Instruction = union(enum) {
12291229 };
12301230 }
12311231
1232 pub fn lduba(rs1: Register, rs2: Register, asi: ASI, rd: Register) Instruction {
1233 return format3i(0b11, 0b01_0001, rs1, rs2, rd, asi);
1234 }
1235
1236 pub fn lduha(rs1: Register, rs2: Register, asi: ASI, rd: Register) Instruction {
1237 return format3i(0b11, 0b01_0010, rs1, rs2, rd, asi);
1238 }
1239
1240 pub fn lduwa(rs1: Register, rs2: Register, asi: ASI, rd: Register) Instruction {
1241 return format3i(0b11, 0b01_0000, rs1, rs2, rd, asi);
1242 }
1243
1244 pub fn ldxa(rs1: Register, rs2: Register, asi: ASI, rd: Register) Instruction {
1245 return format3i(0b11, 0b01_1011, rs1, rs2, rd, asi);
1246 }
1247
12321248 pub fn @"and"(comptime s2: type, rs1: Register, rs2: s2, rd: Register) Instruction {
12331249 return switch (s2) {
12341250 Register => format3a(0b10, 0b00_0001, rs1, rs2, rd),
......@@ -1417,6 +1433,22 @@ pub const Instruction = union(enum) {
14171433 };
14181434 }
14191435
1436 pub fn stba(rs1: Register, rs2: Register, asi: ASI, rd: Register) Instruction {
1437 return format3i(0b11, 0b01_0101, rs1, rs2, rd, asi);
1438 }
1439
1440 pub fn stha(rs1: Register, rs2: Register, asi: ASI, rd: Register) Instruction {
1441 return format3i(0b11, 0b01_0110, rs1, rs2, rd, asi);
1442 }
1443
1444 pub fn stwa(rs1: Register, rs2: Register, asi: ASI, rd: Register) Instruction {
1445 return format3i(0b11, 0b01_0100, rs1, rs2, rd, asi);
1446 }
1447
1448 pub fn stxa(rs1: Register, rs2: Register, asi: ASI, rd: Register) Instruction {
1449 return format3i(0b11, 0b01_1110, rs1, rs2, rd, asi);
1450 }
1451
14201452 pub fn sub(comptime s2: type, rs1: Register, rs2: s2, rd: Register) Instruction {
14211453 return switch (s2) {
14221454 Register => format3a(0b10, 0b00_0100, rs1, rs2, rd),
test/behavior/array.zig+4
......@@ -47,6 +47,7 @@ fn getArrayLen(a: []const u32) usize {
4747
4848test "array concat with undefined" {
4949 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
50 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
5051
5152 const S = struct {
5253 fn doTheTest() !void {
......@@ -70,6 +71,7 @@ test "array concat with undefined" {
7071test "array concat with tuple" {
7172 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7273 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
74 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7375
7476 const array: [2]u8 = .{ 1, 2 };
7577 {
......@@ -103,6 +105,7 @@ test "array init with mult" {
103105
104106test "array literal with explicit type" {
105107 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
108 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106109
107110 const hex_mult: [4]u16 = .{ 4096, 256, 16, 1 };
108111
......@@ -203,6 +206,7 @@ test "nested arrays of strings" {
203206
204207test "nested arrays of integers" {
205208 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
209 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
206210
207211 const array_of_numbers = [_][2]u8{
208212 [2]u8{ 1, 2 },
test/behavior/bugs/12051.zig+1
......@@ -6,6 +6,7 @@ test {
66 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
77 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
88 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
910 const x = X{};
1011 try std.testing.expectEqual(@as(u16, 0), x.y.a);
1112 try std.testing.expectEqual(false, x.y.b);
test/behavior/bugs/12450.zig+1
......@@ -13,6 +13,7 @@ test {
1313 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1414 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1515 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1617 var f1: *align(16) Foo = @alignCast(16, @ptrCast(*align(1) Foo, &buffer[0]));
1718 try expect(@typeInfo(@TypeOf(f1)).Pointer.alignment == 16);
1819 try expect(@ptrToInt(f1) == @ptrToInt(&f1.a));
test/behavior/comptime_memory.zig+3
......@@ -76,6 +76,7 @@ fn bigToNativeEndian(comptime T: type, v: T) T {
7676}
7777test "type pun endianness" {
7878 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
79 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7980
8081 comptime {
8182 const StructOfBytes = extern struct { x: [4]u8 };
......@@ -376,6 +377,8 @@ test "offset field ptr by enclosing array element size" {
376377
377378test "accessing reinterpreted memory of parent object" {
378379 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
380 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
381
379382 const S = extern struct {
380383 a: f32,
381384 b: [4]u8,
test/behavior/packed-struct.zig+3-1
......@@ -563,7 +563,7 @@ test "packed struct passed to callconv(.C) function" {
563563test "overaligned pointer to packed struct" {
564564 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
565565 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
566
566 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
567567 const S = packed struct { a: u32, b: u32 };
568568 var foo: S align(4) = .{ .a = 123, .b = 456 };
569569 const ptr: *align(4) S = &foo;
......@@ -583,6 +583,7 @@ test "overaligned pointer to packed struct" {
583583test "packed struct initialized in bitcast" {
584584 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
585585 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
586 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
586587
587588 const T = packed struct { val: u8 };
588589 var val: u8 = 123;
......@@ -595,6 +596,7 @@ test "pointer to container level packed struct field" {
595596 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
596597 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
597598 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
599 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
598600
599601 const S = packed struct(u32) {
600602 test_bit: bool,
test/behavior/ptrcast.zig+10
......@@ -4,6 +4,8 @@ const expect = std.testing.expect;
44const native_endian = builtin.target.cpu.arch.endian();
55
66test "reinterpret bytes as integer with nonzero offset" {
7 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8
79 try testReinterpretBytesAsInteger();
810 comptime try testReinterpretBytesAsInteger();
911}
......@@ -74,6 +76,8 @@ fn testReinterpretBytesAsExternStruct() !void {
7476}
7577
7678test "reinterpret bytes of an extern struct (with under-aligned fields) into another" {
79 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
80
7781 try testReinterpretExternStructAsExternStruct();
7882 comptime try testReinterpretExternStructAsExternStruct();
7983}
......@@ -96,6 +100,8 @@ fn testReinterpretExternStructAsExternStruct() !void {
96100}
97101
98102test "reinterpret bytes of an extern struct into another" {
103 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
104
99105 try testReinterpretOverAlignedExternStructAsExternStruct();
100106 comptime try testReinterpretOverAlignedExternStructAsExternStruct();
101107}
......@@ -191,6 +197,8 @@ const Bytes = struct {
191197};
192198
193199test "comptime ptrcast keeps larger alignment" {
200 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
201
194202 comptime {
195203 const a: u32 = 1234;
196204 const p = @ptrCast([*]const u8, &a);
......@@ -199,6 +207,8 @@ test "comptime ptrcast keeps larger alignment" {
199207}
200208
201209test "ptrcast of const integer has the correct object size" {
210 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
211
202212 const is_value = ~@intCast(isize, std.math.minInt(isize));
203213 const is_bytes = @ptrCast([*]const u8, &is_value)[0..@sizeOf(isize)];
204214 if (@sizeOf(isize) == 8) {
test/behavior/tuple.zig+5
......@@ -296,6 +296,7 @@ test "coerce tuple to tuple" {
296296test "tuple type with void field" {
297297 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
298298 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
299 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
299300
300301 const T = std.meta.Tuple(&[_]type{void});
301302 const x = T{{}};
......@@ -341,6 +342,7 @@ test "tuple type with void field and a runtime field" {
341342test "branching inside tuple literal" {
342343 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
343344 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
345 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
344346
345347 const S = struct {
346348 fn foo(a: anytype) !void {
......@@ -355,6 +357,7 @@ test "tuple initialized with a runtime known value" {
355357 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
356358 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
357359 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
360 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
358361
359362 const E = union(enum) { e: []const u8 };
360363 const W = union(enum) { w: E };
......@@ -368,6 +371,7 @@ test "tuple of struct concatenation and coercion to array" {
368371 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
369372 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
370373 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
374 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
371375
372376 const StructWithDefault = struct { value: f32 = 42 };
373377 const SomeStruct = struct { array: [4]StructWithDefault };
......@@ -381,6 +385,7 @@ test "tuple of struct concatenation and coercion to array" {
381385test "nested runtime conditionals in tuple initializer" {
382386 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
383387 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
388 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
384389
385390 var data: u8 = 0;
386391 const x = .{
test/behavior/union.zig+1
......@@ -1495,6 +1495,7 @@ test "packed union with zero-bit field" {
14951495 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14961496 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
14971497 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1498 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14981499
14991500 const S = packed struct {
15001501 nested: packed union {
test/behavior/var_args.zig+2
......@@ -95,6 +95,7 @@ fn doNothingWithFirstArg(args: anytype) void {
9595
9696test "simple variadic function" {
9797 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
98 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9899 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
99100 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
100101 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
......@@ -143,6 +144,7 @@ test "simple variadic function" {
143144
144145test "variadic functions" {
145146 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
147 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
146148 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
147149 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
148150 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
test/behavior/vector.zig+1
......@@ -1282,6 +1282,7 @@ test "store to vector in slice" {
12821282 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12831283 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
12841284 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1285 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12851286
12861287 var v = [_]@Vector(3, f32){
12871288 .{ 1, 1, 1 },