authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-09-14 20:00:38-04:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2022-09-14 20:00:38-04:00
log78cd7b57ef7a3c8c645aab5c30b3fbf3834e6970
tree7523ab6cb09ccc1d171c5014eeb324809261bde2
parent17596c79a9239edec533a041f9a4da3a7af0d980
parent86dc982e74dd17633d2bdc0f5ba8e36c55f78053
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #12206 from koachan/sparc64-codegen

stage2: sparc64: Another batch of Air lowerings, bugfixes, etc.

7 files changed, 515 insertions(+), 153 deletions(-)

src/arch/sparc64/CodeGen.zig+452-140
......@@ -499,20 +499,29 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
499499 .ptr_sub => try self.airPtrArithmetic(inst, .ptr_sub),
500500
501501 .add => try self.airBinOp(inst, .add),
502 .addwrap => @panic("TODO try self.airAddWrap(inst)"),
503 .add_sat => @panic("TODO try self.airAddSat(inst)"),
504 .sub => @panic("TODO try self.airBinOp(inst)"),
505 .subwrap => @panic("TODO try self.airSubWrap(inst)"),
506 .sub_sat => @panic("TODO try self.airSubSat(inst)"),
507 .mul => @panic("TODO try self.airMul(inst)"),
508 .mulwrap => @panic("TODO try self.airMulWrap(inst)"),
509 .mul_sat => @panic("TODO try self.airMulSat(inst)"),
510 .rem => try self.airRem(inst),
511 .mod => try self.airMod(inst),
512 .shl, .shl_exact => @panic("TODO try self.airShl(inst)"),
513 .shl_sat => @panic("TODO try self.airShlSat(inst)"),
502 .addwrap => try self.airBinOp(inst, .addwrap),
503 .sub => try self.airBinOp(inst, .sub),
504 .subwrap => try self.airBinOp(inst, .subwrap),
505 .mul => try self.airBinOp(inst, .mul),
506 .mulwrap => try self.airBinOp(inst, .mulwrap),
507 .shl => try self.airBinOp(inst, .shl),
508 .shl_exact => try self.airBinOp(inst, .shl_exact),
509 .shr => try self.airBinOp(inst, .shr),
510 .shr_exact => try self.airBinOp(inst, .shr_exact),
511 .bool_and => try self.airBinOp(inst, .bool_and),
512 .bool_or => try self.airBinOp(inst, .bool_or),
513 .bit_and => try self.airBinOp(inst, .bit_and),
514 .bit_or => try self.airBinOp(inst, .bit_or),
515 .xor => try self.airBinOp(inst, .xor),
516
517 .add_sat => try self.airAddSat(inst),
518 .sub_sat => try self.airSubSat(inst),
519 .mul_sat => try self.airMulSat(inst),
520 .shl_sat => try self.airShlSat(inst),
514521 .min => @panic("TODO try self.airMin(inst)"),
515522 .max => @panic("TODO try self.airMax(inst)"),
523 .rem => try self.airRem(inst),
524 .mod => try self.airMod(inst),
516525 .slice => try self.airSlice(inst),
517526
518527 .sqrt,
......@@ -530,12 +539,12 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
530539 .round,
531540 .trunc_float,
532541 .neg,
533 => @panic("TODO try self.airUnaryMath(inst)"),
542 => try self.airUnaryMath(inst),
534543
535544 .add_with_overflow => try self.airAddSubWithOverflow(inst),
536545 .sub_with_overflow => try self.airAddSubWithOverflow(inst),
537 .mul_with_overflow => @panic("TODO try self.airMulWithOverflow(inst)"),
538 .shl_with_overflow => @panic("TODO try self.airShlWithOverflow(inst)"),
546 .mul_with_overflow => try self.airMulWithOverflow(inst),
547 .shl_with_overflow => try self.airShlWithOverflow(inst),
539548
540549 .div_float, .div_trunc, .div_floor, .div_exact => try self.airDiv(inst),
541550
......@@ -546,14 +555,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
546555 .cmp_gt => try self.airCmp(inst, .gt),
547556 .cmp_neq => try self.airCmp(inst, .neq),
548557 .cmp_vector => @panic("TODO try self.airCmpVector(inst)"),
549 .cmp_lt_errors_len => @panic("TODO try self.airCmpLtErrorsLen(inst)"),
550
551 .bool_and => @panic("TODO try self.airBoolOp(inst)"),
552 .bool_or => @panic("TODO try self.airBoolOp(inst)"),
553 .bit_and => try self.airBinOp(inst, .bit_and),
554 .bit_or => try self.airBinOp(inst, .bit_or),
555 .xor => try self.airBinOp(inst, .xor),
556 .shr, .shr_exact => @panic("TODO try self.airShr(inst)"),
558 .cmp_lt_errors_len => try self.airCmpLtErrorsLen(inst),
557559
558560 .alloc => try self.airAlloc(inst),
559561 .ret_ptr => try self.airRetPtr(inst),
......@@ -584,15 +586,15 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
584586 .load => try self.airLoad(inst),
585587 .loop => try self.airLoop(inst),
586588 .not => try self.airNot(inst),
587 .ptrtoint => @panic("TODO try self.airPtrToInt(inst)"),
589 .ptrtoint => try self.airPtrToInt(inst),
588590 .ret => try self.airRet(inst),
589591 .ret_load => try self.airRetLoad(inst),
590592 .store => try self.airStore(inst),
591593 .struct_field_ptr=> @panic("TODO try self.airStructFieldPtr(inst)"),
592594 .struct_field_val=> try self.airStructFieldVal(inst),
593595 .array_to_slice => try self.airArrayToSlice(inst),
594 .int_to_float => @panic("TODO try self.airIntToFloat(inst)"),
595 .float_to_int => @panic("TODO try self.airFloatToInt(inst)"),
596 .int_to_float => try self.airIntToFloat(inst),
597 .float_to_int => try self.airFloatToInt(inst),
596598 .cmpxchg_strong => @panic("TODO try self.airCmpxchg(inst)"),
597599 .cmpxchg_weak => @panic("TODO try self.airCmpxchg(inst)"),
598600 .atomic_rmw => @panic("TODO try self.airAtomicRmw(inst)"),
......@@ -601,12 +603,12 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
601603 .memset => try self.airMemset(inst),
602604 .set_union_tag => @panic("TODO try self.airSetUnionTag(inst)"),
603605 .get_union_tag => @panic("TODO try self.airGetUnionTag(inst)"),
604 .clz => @panic("TODO try self.airClz(inst)"),
605 .ctz => @panic("TODO try self.airCtz(inst)"),
606 .popcount => @panic("TODO try self.airPopcount(inst)"),
606 .clz => try self.airClz(inst),
607 .ctz => try self.airCtz(inst),
608 .popcount => try self.airPopcount(inst),
607609 .byte_swap => @panic("TODO try self.airByteSwap(inst)"),
608610 .bit_reverse => @panic("TODO try self.airBitReverse(inst)"),
609 .tag_name => @panic("TODO try self.airTagName(inst)"),
611 .tag_name => try self.airTagName(inst),
610612 .error_name => @panic("TODO try self.airErrorName(inst)"),
611613 .splat => @panic("TODO try self.airSplat(inst)"),
612614 .select => @panic("TODO try self.airSelect(inst)"),
......@@ -614,7 +616,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
614616 .reduce => @panic("TODO try self.airReduce(inst)"),
615617 .aggregate_init => try self.airAggregateInit(inst),
616618 .union_init => @panic("TODO try self.airUnionInit(inst)"),
617 .prefetch => @panic("TODO try self.airPrefetch(inst)"),
619 .prefetch => try self.airPrefetch(inst),
618620 .mul_add => @panic("TODO try self.airMulAdd(inst)"),
619621
620622 .@"try" => try self.airTry(inst),
......@@ -650,7 +652,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
650652 .field_parent_ptr => @panic("TODO try self.airFieldParentPtr(inst)"),
651653
652654 .switch_br => try self.airSwitch(inst),
653 .slice_ptr => @panic("TODO try self.airSlicePtr(inst)"),
655 .slice_ptr => try self.airSlicePtr(inst),
654656 .slice_len => try self.airSliceLen(inst),
655657
656658 .ptr_slice_len_ptr => @panic("TODO try self.airPtrSliceLenPtr(inst)"),
......@@ -659,16 +661,16 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
659661 .array_elem_val => try self.airArrayElemVal(inst),
660662 .slice_elem_val => try self.airSliceElemVal(inst),
661663 .slice_elem_ptr => @panic("TODO try self.airSliceElemPtr(inst)"),
662 .ptr_elem_val => @panic("TODO try self.airPtrElemVal(inst)"),
664 .ptr_elem_val => try self.airPtrElemVal(inst),
663665 .ptr_elem_ptr => try self.airPtrElemPtr(inst),
664666
665667 .constant => unreachable, // excluded from function bodies
666668 .const_ty => unreachable, // excluded from function bodies
667669 .unreach => self.finishAirBookkeeping(),
668670
669 .optional_payload => @panic("TODO try self.airOptionalPayload(inst)"),
670 .optional_payload_ptr => @panic("TODO try self.airOptionalPayloadPtr(inst)"),
671 .optional_payload_ptr_set => @panic("TODO try self.airOptionalPayloadPtrSet(inst)"),
671 .optional_payload => try self.airOptionalPayload(inst),
672 .optional_payload_ptr => try self.airOptionalPayloadPtr(inst),
673 .optional_payload_ptr_set => try self.airOptionalPayloadPtrSet(inst),
672674 .unwrap_errunion_err => try self.airUnwrapErrErr(inst),
673675 .unwrap_errunion_payload => try self.airUnwrapErrPayload(inst),
674676 .unwrap_errunion_err_ptr => @panic("TODO try self.airUnwrapErrErrPtr(inst)"),
......@@ -677,7 +679,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
677679 .err_return_trace => @panic("TODO try self.airErrReturnTrace(inst)"),
678680 .set_err_return_trace => @panic("TODO try self.airSetErrReturnTrace(inst)"),
679681
680 .wrap_optional => @panic("TODO try self.airWrapOptional(inst)"),
682 .wrap_optional => try self.airWrapOptional(inst),
681683 .wrap_errunion_payload => @panic("TODO try self.airWrapErrUnionPayload(inst)"),
682684 .wrap_errunion_err => try self.airWrapErrUnionErr(inst),
683685
......@@ -723,6 +725,12 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
723725 }
724726}
725727
728fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
729 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
730 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement add_sat for {}", .{self.target.cpu.arch});
731 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
732}
733
726734fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
727735 const tag = self.air.instructions.items(.tag)[inst];
728736 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
......@@ -763,7 +771,6 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
763771 };
764772
765773 try self.spillConditionFlagsIfOccupied();
766 self.condition_flags_inst = inst;
767774
768775 const dest = blk: {
769776 if (rhs_immediate_ok) {
......@@ -1241,6 +1248,12 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
12411248 return bt.finishAir(result);
12421249}
12431250
1251fn airClz(self: *Self, inst: Air.Inst.Index) !void {
1252 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1253 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airClz for {}", .{self.target.cpu.arch});
1254 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1255}
1256
12441257fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
12451258 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
12461259 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
......@@ -1299,6 +1312,14 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
12991312 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
13001313}
13011314
1315fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
1316 const un_op = self.air.instructions.items(.data)[inst].un_op;
1317 const operand = try self.resolveInst(un_op);
1318 _ = operand;
1319 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCmpLtErrorsLen for {}", .{self.target.cpu.arch});
1320 return self.finishAir(inst, result, .{ un_op, .none, .none });
1321}
1322
13021323fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
13031324 const pl_op = self.air.instructions.items(.data)[inst].pl_op;
13041325 const condition = try self.resolveInst(pl_op.operand);
......@@ -1446,6 +1467,12 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
14461467 return self.finishAir(inst, .unreach, .{ .none, .none, .none });
14471468}
14481469
1470fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
1471 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1472 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCtz for {}", .{self.target.cpu.arch});
1473 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1474}
1475
14491476fn airDbgBlock(self: *Self, inst: Air.Inst.Index) !void {
14501477 // TODO emit debug info lexical block
14511478 return self.finishAir(inst, .dead, .{ .none, .none, .none });
......@@ -1519,6 +1546,14 @@ fn airFence(self: *Self, inst: Air.Inst.Index) !void {
15191546 return self.finishAir(inst, .dead, .{ .none, .none, .none });
15201547}
15211548
1549fn airFloatToInt(self: *Self, inst: Air.Inst.Index) !void {
1550 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1551 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFloatToInt for {}", .{
1552 self.target.cpu.arch,
1553 });
1554 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1555}
1556
15221557fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
15231558 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
15241559 if (self.liveness.isUnused(inst))
......@@ -1537,6 +1572,14 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
15371572 return self.fail("TODO implement intCast for {}", .{self.target.cpu.arch});
15381573}
15391574
1575fn airIntToFloat(self: *Self, inst: Air.Inst.Index) !void {
1576 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1577 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airIntToFloat for {}", .{
1578 self.target.cpu.arch,
1579 });
1580 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1581}
1582
15401583fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
15411584 const un_op = self.air.instructions.items(.data)[inst].un_op;
15421585 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
......@@ -1768,6 +1811,78 @@ fn airMod(self: *Self, inst: Air.Inst.Index) !void {
17681811 return self.finishAir(inst, .{ .register = mod_reg }, .{ bin_op.lhs, bin_op.rhs, .none });
17691812}
17701813
1814fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
1815 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
1816 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mul_sat for {}", .{self.target.cpu.arch});
1817 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1818}
1819
1820fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1821 //const tag = self.air.instructions.items(.tag)[inst];
1822 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
1823 const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
1824 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
1825 const lhs = try self.resolveInst(extra.lhs);
1826 const rhs = try self.resolveInst(extra.rhs);
1827 const lhs_ty = self.air.typeOf(extra.lhs);
1828 const rhs_ty = self.air.typeOf(extra.rhs);
1829
1830 switch (lhs_ty.zigTypeTag()) {
1831 .Vector => return self.fail("TODO implement mul_with_overflow for vectors", .{}),
1832 .Int => {
1833 const mod = self.bin_file.options.module.?;
1834 assert(lhs_ty.eql(rhs_ty, mod));
1835 const int_info = lhs_ty.intInfo(self.target.*);
1836 switch (int_info.bits) {
1837 1...32 => {
1838 try self.spillConditionFlagsIfOccupied();
1839
1840 const dest = try self.binOp(.mul, lhs, rhs, lhs_ty, rhs_ty, null);
1841
1842 const dest_reg = dest.register;
1843 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
1844 defer self.register_manager.unlockReg(dest_reg_lock);
1845
1846 const truncated_reg = try self.register_manager.allocReg(null, gp);
1847 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1848 defer self.register_manager.unlockReg(truncated_reg_lock);
1849
1850 try self.truncRegister(
1851 dest_reg,
1852 truncated_reg,
1853 int_info.signedness,
1854 int_info.bits,
1855 );
1856
1857 _ = try self.addInst(.{
1858 .tag = .cmp,
1859 .data = .{ .arithmetic_2op = .{
1860 .is_imm = false,
1861 .rs1 = dest_reg,
1862 .rs2_or_imm = .{ .rs2 = truncated_reg },
1863 } },
1864 });
1865
1866 const cond = Instruction.ICondition.ne;
1867 const ccr = Instruction.CCR.xcc;
1868
1869 break :result MCValue{ .register_with_overflow = .{
1870 .reg = truncated_reg,
1871 .flag = .{ .cond = cond, .ccr = ccr },
1872 } };
1873 },
1874 // XXX DO NOT call __multi3 directly as it'll result in us doing six multiplications,
1875 // which is far more than strictly necessary
1876 33...64 => return self.fail("TODO copy compiler-rt's mulddi3 for a 64x64->128 multiply", .{}),
1877 else => return self.fail("TODO overflow operations on other integer sizes", .{}),
1878 }
1879 },
1880 else => unreachable,
1881 }
1882 };
1883 return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
1884}
1885
17711886fn airNot(self: *Self, inst: Air.Inst.Index) !void {
17721887 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
17731888 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
......@@ -1863,6 +1978,43 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
18631978 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
18641979}
18651980
1981fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
1982 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1983 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload for {}", .{self.target.cpu.arch});
1984 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1985}
1986
1987fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
1988 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1989 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr for {}", .{self.target.cpu.arch});
1990 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1991}
1992
1993fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
1994 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1995 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr_set for {}", .{self.target.cpu.arch});
1996 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1997}
1998
1999fn airPopcount(self: *Self, inst: Air.Inst.Index) !void {
2000 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
2001 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airPopcount for {}", .{self.target.cpu.arch});
2002 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2003}
2004
2005fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
2006 const prefetch = self.air.instructions.items(.data)[inst].prefetch;
2007 // TODO Emit a PREFETCH/IPREFETCH as necessary, see A.7 and A.42
2008 return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none });
2009}
2010
2011fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
2012 const is_volatile = false; // TODO
2013 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2014 const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_val for {}", .{self.target.cpu.arch});
2015 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
2016}
2017
18662018fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
18672019 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
18682020 const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
......@@ -1870,6 +2022,12 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
18702022 return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
18712023}
18722024
2025fn airPtrToInt(self: *Self, inst: Air.Inst.Index) !void {
2026 const un_op = self.air.instructions.items(.data)[inst].un_op;
2027 const result = try self.resolveInst(un_op);
2028 return self.finishAir(inst, result, .{ un_op, .none, .none });
2029}
2030
18732031fn airRem(self: *Self, inst: Air.Inst.Index) !void {
18742032 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
18752033 const lhs = try self.resolveInst(bin_op.lhs);
......@@ -1911,6 +2069,101 @@ fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
19112069 return self.finishAir(inst, .{ .ptr_stack_offset = stack_offset }, .{ .none, .none, .none });
19122070}
19132071
2072fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
2073 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2074 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shl_sat for {}", .{self.target.cpu.arch});
2075 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
2076}
2077
2078fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
2079 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
2080 const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
2081 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
2082 const lhs = try self.resolveInst(extra.lhs);
2083 const rhs = try self.resolveInst(extra.rhs);
2084 const lhs_ty = self.air.typeOf(extra.lhs);
2085 const rhs_ty = self.air.typeOf(extra.rhs);
2086
2087 switch (lhs_ty.zigTypeTag()) {
2088 .Vector => return self.fail("TODO implement mul_with_overflow for vectors", .{}),
2089 .Int => {
2090 const int_info = lhs_ty.intInfo(self.target.*);
2091 if (int_info.bits <= 64) {
2092 try self.spillConditionFlagsIfOccupied();
2093
2094 const lhs_lock: ?RegisterLock = if (lhs == .register)
2095 self.register_manager.lockRegAssumeUnused(lhs.register)
2096 else
2097 null;
2098 // TODO this currently crashes stage1
2099 // defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
2100
2101 // Increase shift amount (i.e, rhs) by shamt_bits - int_info.bits
2102 // e.g if shifting a i48 then use sr*x (shamt_bits == 64) but increase rhs by 16
2103 // and if shifting a i24 then use sr* (shamt_bits == 32) but increase rhs by 8
2104 const new_rhs = switch (int_info.bits) {
2105 1...31 => if (rhs == .immediate) MCValue{
2106 .immediate = rhs.immediate + 32 - int_info.bits,
2107 } else try self.binOp(.add, rhs, .{ .immediate = 32 - int_info.bits }, rhs_ty, rhs_ty, null),
2108 33...63 => if (rhs == .immediate) MCValue{
2109 .immediate = rhs.immediate + 64 - int_info.bits,
2110 } else try self.binOp(.add, rhs, .{ .immediate = 64 - int_info.bits }, rhs_ty, rhs_ty, null),
2111 32, 64 => rhs,
2112 else => unreachable,
2113 };
2114
2115 const new_rhs_lock: ?RegisterLock = if (new_rhs == .register)
2116 self.register_manager.lockRegAssumeUnused(new_rhs.register)
2117 else
2118 null;
2119 // TODO this currently crashes stage1
2120 // defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
2121
2122 const dest = try self.binOp(.shl, lhs, new_rhs, lhs_ty, rhs_ty, null);
2123 const dest_reg = dest.register;
2124 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
2125 defer self.register_manager.unlockReg(dest_reg_lock);
2126
2127 const shr = try self.binOp(.shr, dest, new_rhs, lhs_ty, rhs_ty, null);
2128
2129 _ = try self.addInst(.{
2130 .tag = .cmp,
2131 .data = .{ .arithmetic_2op = .{
2132 .is_imm = false,
2133 .rs1 = dest_reg,
2134 .rs2_or_imm = .{ .rs2 = shr.register },
2135 } },
2136 });
2137
2138 const cond = Instruction.ICondition.ne;
2139 const ccr = switch (int_info.bits) {
2140 1...32 => Instruction.CCR.icc,
2141 33...64 => Instruction.CCR.xcc,
2142 else => unreachable,
2143 };
2144
2145 // TODO Those should really be written as defers, however stage1 currently
2146 // panics when those are turned into defer statements so those are
2147 // written here at the end as ordinary statements.
2148 // Because of that, on failure, the lock on those registers wouldn't be
2149 // released.
2150 if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
2151 if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
2152
2153 break :result MCValue{ .register_with_overflow = .{
2154 .reg = dest_reg,
2155 .flag = .{ .cond = cond, .ccr = ccr },
2156 } };
2157 } else {
2158 return self.fail("TODO overflow operations on other integer sizes", .{});
2159 }
2160 },
2161 else => unreachable,
2162 }
2163 };
2164 return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
2165}
2166
19142167fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
19152168 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
19162169 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
......@@ -1996,6 +2249,25 @@ fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
19962249 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
19972250}
19982251
2252fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
2253 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
2254 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
2255 const mcv = try self.resolveInst(ty_op.operand);
2256 switch (mcv) {
2257 .dead, .unreach, .none => unreachable,
2258 .register => unreachable, // a slice doesn't fit in one register
2259 .stack_offset => |off| {
2260 break :result MCValue{ .stack_offset = off };
2261 },
2262 .memory => |addr| {
2263 break :result MCValue{ .memory = addr };
2264 },
2265 else => return self.fail("TODO implement slice_len for {}", .{mcv}),
2266 }
2267 };
2268 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2269}
2270
19992271fn airStore(self: *Self, inst: Air.Inst.Index) !void {
20002272 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
20012273 const ptr = try self.resolveInst(bin_op.lhs);
......@@ -2083,11 +2355,27 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
20832355 return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none });
20842356}
20852357
2358fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
2359 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2360 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement sub_sat for {}", .{self.target.cpu.arch});
2361 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
2362}
2363
20862364fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
20872365 _ = inst;
20882366 return self.fail("TODO implement switch for {}", .{self.target.cpu.arch});
20892367}
20902368
2369fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
2370 const un_op = self.air.instructions.items(.data)[inst].un_op;
2371 const operand = try self.resolveInst(un_op);
2372 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
2373 _ = operand;
2374 return self.fail("TODO implement airTagName for {}", .{self.target.cpu.arch});
2375 };
2376 return self.finishAir(inst, result, .{ un_op, .none, .none });
2377}
2378
20912379fn airTry(self: *Self, inst: Air.Inst.Index) !void {
20922380 const pl_op = self.air.instructions.items(.data)[inst].pl_op;
20932381 const extra = self.air.extraData(Air.Try, pl_op.payload);
......@@ -2106,6 +2394,15 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void {
21062394 return self.finishAir(inst, result, .{ pl_op.operand, .none, .none });
21072395}
21082396
2397fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void {
2398 const un_op = self.air.instructions.items(.data)[inst].un_op;
2399 const result: MCValue = if (self.liveness.isUnused(inst))
2400 .dead
2401 else
2402 return self.fail("TODO implement airUnaryMath for {}", .{self.target.cpu.arch});
2403 return self.finishAir(inst, result, .{ un_op, .none, .none });
2404}
2405
21092406fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
21102407 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
21112408 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
......@@ -2145,6 +2442,20 @@ fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
21452442 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
21462443}
21472444
2445fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
2446 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
2447 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
2448 const optional_ty = self.air.typeOfIndex(inst);
2449
2450 // Optional with a zero-bit payload type is just a boolean true
2451 if (optional_ty.abiSize(self.target.*) == 1)
2452 break :result MCValue{ .immediate = 1 };
2453
2454 return self.fail("TODO implement wrap optional for {}", .{self.target.cpu.arch});
2455 };
2456 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2457}
2458
21482459// Common helper functions
21492460
21502461/// Adds a Type to the .debug_info at the current position. The bytes will be populated later,
......@@ -2264,6 +2575,10 @@ fn binOp(
22642575 switch (tag) {
22652576 .add,
22662577 .sub,
2578 .mul,
2579 .bit_and,
2580 .bit_or,
2581 .xor,
22672582 .cmp_eq,
22682583 => {
22692584 switch (lhs_ty.zigTypeTag()) {
......@@ -2278,12 +2593,20 @@ fn binOp(
22782593 // operands
22792594 const lhs_immediate_ok = switch (tag) {
22802595 .add => lhs == .immediate and lhs.immediate <= std.math.maxInt(u12),
2596 .mul => lhs == .immediate and lhs.immediate <= std.math.maxInt(u12),
2597 .bit_and => lhs == .immediate and lhs.immediate <= std.math.maxInt(u12),
2598 .bit_or => lhs == .immediate and lhs.immediate <= std.math.maxInt(u12),
2599 .xor => lhs == .immediate and lhs.immediate <= std.math.maxInt(u12),
22812600 .sub, .cmp_eq => false,
22822601 else => unreachable,
22832602 };
22842603 const rhs_immediate_ok = switch (tag) {
22852604 .add,
22862605 .sub,
2606 .mul,
2607 .bit_and,
2608 .bit_or,
2609 .xor,
22872610 .cmp_eq,
22882611 => rhs == .immediate and rhs.immediate <= std.math.maxInt(u12),
22892612 else => unreachable,
......@@ -2292,6 +2615,10 @@ fn binOp(
22922615 const mir_tag: Mir.Inst.Tag = switch (tag) {
22932616 .add => .add,
22942617 .sub => .sub,
2618 .mul => .mulx,
2619 .bit_and => .@"and",
2620 .bit_or => .@"or",
2621 .xor => .xor,
22952622 .cmp_eq => .cmp,
22962623 else => unreachable,
22972624 };
......@@ -2313,72 +2640,60 @@ fn binOp(
23132640 }
23142641 },
23152642
2316 .div_trunc => {
2643 .addwrap,
2644 .subwrap,
2645 .mulwrap,
2646 => {
2647 const base_tag: Air.Inst.Tag = switch (tag) {
2648 .addwrap => .add,
2649 .subwrap => .sub,
2650 .mulwrap => .mul,
2651 else => unreachable,
2652 };
2653
2654 // Generate the base operation
2655 const result = try self.binOp(base_tag, lhs, rhs, lhs_ty, rhs_ty, metadata);
2656
2657 // Truncate if necessary
23172658 switch (lhs_ty.zigTypeTag()) {
23182659 .Vector => return self.fail("TODO binary operations on vectors", .{}),
23192660 .Int => {
2320 assert(lhs_ty.eql(rhs_ty, mod));
23212661 const int_info = lhs_ty.intInfo(self.target.*);
23222662 if (int_info.bits <= 64) {
2323 const rhs_immediate_ok = switch (tag) {
2324 .div_trunc => rhs == .immediate and rhs.immediate <= std.math.maxInt(u12),
2325 else => unreachable,
2326 };
2327
2328 const mir_tag: Mir.Inst.Tag = switch (tag) {
2329 .div_trunc => switch (int_info.signedness) {
2330 .signed => Mir.Inst.Tag.sdivx,
2331 .unsigned => Mir.Inst.Tag.udivx,
2332 },
2333 else => unreachable,
2334 };
2335
2336 if (rhs_immediate_ok) {
2337 return try self.binOpImmediate(mir_tag, lhs, rhs, lhs_ty, true, metadata);
2338 } else {
2339 return try self.binOpRegister(mir_tag, lhs, rhs, lhs_ty, rhs_ty, metadata);
2340 }
2663 const result_reg = result.register;
2664 try self.truncRegister(result_reg, result_reg, int_info.signedness, int_info.bits);
2665 return result;
23412666 } else {
2342 return self.fail("TODO binary operations on int with bits > 64", .{});
2667 return self.fail("TODO binary operations on integers > u64/i64", .{});
23432668 }
23442669 },
23452670 else => unreachable,
23462671 }
23472672 },
23482673
2349 .mul => {
2674 .div_trunc => {
23502675 switch (lhs_ty.zigTypeTag()) {
23512676 .Vector => return self.fail("TODO binary operations on vectors", .{}),
23522677 .Int => {
23532678 assert(lhs_ty.eql(rhs_ty, mod));
23542679 const int_info = lhs_ty.intInfo(self.target.*);
23552680 if (int_info.bits <= 64) {
2356 // Only say yes if the operation is
2357 // commutative, i.e. we can swap both of the
2358 // operands
2359 const lhs_immediate_ok = switch (tag) {
2360 .mul => lhs == .immediate and lhs.immediate <= std.math.maxInt(u12),
2361 else => unreachable,
2362 };
23632681 const rhs_immediate_ok = switch (tag) {
2364 .mul => rhs == .immediate and rhs.immediate <= std.math.maxInt(u12),
2682 .div_trunc => rhs == .immediate and rhs.immediate <= std.math.maxInt(u12),
23652683 else => unreachable,
23662684 };
23672685
23682686 const mir_tag: Mir.Inst.Tag = switch (tag) {
2369 .mul => .mulx,
2687 .div_trunc => switch (int_info.signedness) {
2688 .signed => Mir.Inst.Tag.sdivx,
2689 .unsigned => Mir.Inst.Tag.udivx,
2690 },
23702691 else => unreachable,
23712692 };
23722693
23732694 if (rhs_immediate_ok) {
2374 // At this point, rhs is an immediate
2375 return try self.binOpImmediate(mir_tag, lhs, rhs, lhs_ty, false, metadata);
2376 } else if (lhs_immediate_ok) {
2377 // swap lhs and rhs
2378 // At this point, lhs is an immediate
2379 return try self.binOpImmediate(mir_tag, rhs, lhs, rhs_ty, true, metadata);
2695 return try self.binOpImmediate(mir_tag, lhs, rhs, lhs_ty, true, metadata);
23802696 } else {
2381 // TODO convert large immediates to register before adding
23822697 return try self.binOpRegister(mir_tag, lhs, rhs, lhs_ty, rhs_ty, metadata);
23832698 }
23842699 } else {
......@@ -2419,88 +2734,61 @@ fn binOp(
24192734 }
24202735 },
24212736
2422 .bit_and,
2423 .bit_or,
2424 .xor,
2737 .bool_and,
2738 .bool_or,
24252739 => {
24262740 switch (lhs_ty.zigTypeTag()) {
2427 .Vector => return self.fail("TODO binary operations on vectors", .{}),
2428 .Int => {
2429 assert(lhs_ty.eql(rhs_ty, mod));
2430 const int_info = lhs_ty.intInfo(self.target.*);
2431 if (int_info.bits <= 64) {
2432 // Only say yes if the operation is
2433 // commutative, i.e. we can swap both of the
2434 // operands
2435 const lhs_immediate_ok = switch (tag) {
2436 .bit_and,
2437 .bit_or,
2438 .xor,
2439 => lhs == .immediate and lhs.immediate <= std.math.maxInt(u13),
2440 else => unreachable,
2441 };
2442 const rhs_immediate_ok = switch (tag) {
2443 .bit_and,
2444 .bit_or,
2445 .xor,
2446 => rhs == .immediate and rhs.immediate <= std.math.maxInt(u13),
2447 else => unreachable,
2448 };
2449
2450 const mir_tag: Mir.Inst.Tag = switch (tag) {
2451 .bit_and => .@"and",
2452 .bit_or => .@"or",
2453 .xor => .xor,
2454 else => unreachable,
2455 };
2741 .Bool => {
2742 assert(lhs != .immediate); // should have been handled by Sema
2743 assert(rhs != .immediate); // should have been handled by Sema
2744
2745 const mir_tag: Mir.Inst.Tag = switch (tag) {
2746 .bool_and => .@"and",
2747 .bool_or => .@"or",
2748 else => unreachable,
2749 };
24562750
2457 if (rhs_immediate_ok) {
2458 return try self.binOpImmediate(mir_tag, lhs, rhs, lhs_ty, false, metadata);
2459 } else if (lhs_immediate_ok) {
2460 // swap lhs and rhs
2461 return try self.binOpImmediate(mir_tag, rhs, lhs, rhs_ty, true, metadata);
2462 } else {
2463 // TODO convert large immediates to register before adding
2464 return try self.binOpRegister(mir_tag, lhs, rhs, lhs_ty, rhs_ty, metadata);
2465 }
2466 } else {
2467 return self.fail("TODO binary operations on int with bits > 64", .{});
2468 }
2751 return try self.binOpRegister(mir_tag, lhs, rhs, lhs_ty, rhs_ty, metadata);
24692752 },
24702753 else => unreachable,
24712754 }
24722755 },
24732756
2474 .shl => {
2757 .shl,
2758 .shr,
2759 => {
24752760 const base_tag: Air.Inst.Tag = switch (tag) {
24762761 .shl => .shl_exact,
2762 .shr => .shr_exact,
24772763 else => unreachable,
24782764 };
24792765
2480 // Generate a shl_exact/shr_exact
2766 // Generate the base operation
24812767 const result = try self.binOp(base_tag, lhs, rhs, lhs_ty, rhs_ty, metadata);
24822768
24832769 // Truncate if necessary
2484 switch (tag) {
2485 .shl => switch (lhs_ty.zigTypeTag()) {
2486 .Vector => return self.fail("TODO binary operations on vectors", .{}),
2487 .Int => {
2488 const int_info = lhs_ty.intInfo(self.target.*);
2489 if (int_info.bits <= 64) {
2490 const result_reg = result.register;
2491 try self.truncRegister(result_reg, result_reg, int_info.signedness, int_info.bits);
2492 return result;
2493 } else {
2494 return self.fail("TODO binary operations on integers > u64/i64", .{});
2495 }
2496 },
2497 else => unreachable,
2770 switch (lhs_ty.zigTypeTag()) {
2771 .Vector => return self.fail("TODO binary operations on vectors", .{}),
2772 .Int => {
2773 const int_info = lhs_ty.intInfo(self.target.*);
2774 if (int_info.bits <= 64) {
2775 // 32 and 64 bit operands doesn't need truncating
2776 if (int_info.bits == 32 or int_info.bits == 64) return result;
2777
2778 const result_reg = result.register;
2779 try self.truncRegister(result_reg, result_reg, int_info.signedness, int_info.bits);
2780 return result;
2781 } else {
2782 return self.fail("TODO binary operations on integers > u64/i64", .{});
2783 }
24982784 },
24992785 else => unreachable,
25002786 }
25012787 },
25022788
2503 .shl_exact => {
2789 .shl_exact,
2790 .shr_exact,
2791 => {
25042792 switch (lhs_ty.zigTypeTag()) {
25052793 .Vector => return self.fail("TODO binary operations on vectors", .{}),
25062794 .Int => {
......@@ -2509,7 +2797,11 @@ fn binOp(
25092797 const rhs_immediate_ok = rhs == .immediate;
25102798
25112799 const mir_tag: Mir.Inst.Tag = switch (tag) {
2512 .shl_exact => .sllx,
2800 .shl_exact => if (int_info.bits <= 32) Mir.Inst.Tag.sll else Mir.Inst.Tag.sllx,
2801 .shr_exact => switch (int_info.signedness) {
2802 .signed => if (int_info.bits <= 32) Mir.Inst.Tag.sra else Mir.Inst.Tag.srax,
2803 .unsigned => if (int_info.bits <= 32) Mir.Inst.Tag.srl else Mir.Inst.Tag.srlx,
2804 },
25132805 else => unreachable,
25142806 };
25152807
......@@ -2616,7 +2908,21 @@ fn binOpImmediate(
26162908 .rs2_or_imm = .{ .imm = @intCast(u12, rhs.immediate) },
26172909 },
26182910 },
2619 .sllx => .{
2911 .sll,
2912 .srl,
2913 .sra,
2914 => .{
2915 .shift = .{
2916 .is_imm = true,
2917 .rd = dest_reg,
2918 .rs1 = lhs_reg,
2919 .rs2_or_imm = .{ .imm = @intCast(u5, rhs.immediate) },
2920 },
2921 },
2922 .sllx,
2923 .srlx,
2924 .srax,
2925 => .{
26202926 .shift = .{
26212927 .is_imm = true,
26222928 .rd = dest_reg,
......@@ -2740,7 +3046,13 @@ fn binOpRegister(
27403046 .rs2_or_imm = .{ .rs2 = rhs_reg },
27413047 },
27423048 },
2743 .sllx => .{
3049 .sll,
3050 .srl,
3051 .sra,
3052 .sllx,
3053 .srlx,
3054 .srax,
3055 => .{
27443056 .shift = .{
27453057 .is_imm = false,
27463058 .rd = dest_reg,
src/arch/sparc64/Mir.zig+1-1
......@@ -218,7 +218,7 @@ pub const Inst = struct {
218218 /// Used by e.g. call
219219 branch_link: struct {
220220 inst: Index,
221 link: Register = .o7,
221 // link is always %o7
222222 },
223223
224224 /// Branch with prediction, checking the integer status code
src/arch/sparc64/bits.zig+12-12
......@@ -1339,48 +1339,48 @@ pub const Instruction = union(enum) {
13391339
13401340 pub fn sll(comptime s2: type, rs1: Register, rs2: s2, rd: Register) Instruction {
13411341 return switch (s2) {
1342 Register => format3k(0b11, 0b10_0101, .shift32, rs1, rs2, rd),
1343 u5 => format3l(0b11, 0b10_0101, rs1, rs2, rd),
1342 Register => format3k(0b10, 0b10_0101, .shift32, rs1, rs2, rd),
1343 u5 => format3l(0b10, 0b10_0101, rs1, rs2, rd),
13441344 else => unreachable,
13451345 };
13461346 }
13471347
13481348 pub fn srl(comptime s2: type, rs1: Register, rs2: s2, rd: Register) Instruction {
13491349 return switch (s2) {
1350 Register => format3k(0b11, 0b10_0110, .shift32, rs1, rs2, rd),
1351 u5 => format3l(0b11, 0b10_0110, rs1, rs2, rd),
1350 Register => format3k(0b10, 0b10_0110, .shift32, rs1, rs2, rd),
1351 u5 => format3l(0b10, 0b10_0110, rs1, rs2, rd),
13521352 else => unreachable,
13531353 };
13541354 }
13551355
13561356 pub fn sra(comptime s2: type, rs1: Register, rs2: s2, rd: Register) Instruction {
13571357 return switch (s2) {
1358 Register => format3k(0b11, 0b10_0111, .shift32, rs1, rs2, rd),
1359 u5 => format3l(0b11, 0b10_0111, rs1, rs2, rd),
1358 Register => format3k(0b10, 0b10_0111, .shift32, rs1, rs2, rd),
1359 u5 => format3l(0b10, 0b10_0111, rs1, rs2, rd),
13601360 else => unreachable,
13611361 };
13621362 }
13631363
13641364 pub fn sllx(comptime s2: type, rs1: Register, rs2: s2, rd: Register) Instruction {
13651365 return switch (s2) {
1366 Register => format3k(0b11, 0b10_0101, .shift64, rs1, rs2, rd),
1367 u6 => format3m(0b11, 0b10_0101, rs1, rs2, rd),
1366 Register => format3k(0b10, 0b10_0101, .shift64, rs1, rs2, rd),
1367 u6 => format3m(0b10, 0b10_0101, rs1, rs2, rd),
13681368 else => unreachable,
13691369 };
13701370 }
13711371
13721372 pub fn srlx(comptime s2: type, rs1: Register, rs2: s2, rd: Register) Instruction {
13731373 return switch (s2) {
1374 Register => format3k(0b11, 0b10_0110, .shift64, rs1, rs2, rd),
1375 u6 => format3m(0b11, 0b10_0110, rs1, rs2, rd),
1374 Register => format3k(0b10, 0b10_0110, .shift64, rs1, rs2, rd),
1375 u6 => format3m(0b10, 0b10_0110, rs1, rs2, rd),
13761376 else => unreachable,
13771377 };
13781378 }
13791379
13801380 pub fn srax(comptime s2: type, rs1: Register, rs2: s2, rd: Register) Instruction {
13811381 return switch (s2) {
1382 Register => format3k(0b11, 0b10_0111, .shift64, rs1, rs2, rd),
1383 u6 => format3m(0b11, 0b10_0111, rs1, rs2, rd),
1382 Register => format3k(0b10, 0b10_0111, .shift64, rs1, rs2, rd),
1383 u6 => format3m(0b10, 0b10_0111, rs1, rs2, rd),
13841384 else => unreachable,
13851385 };
13861386 }
test/behavior/error.zig+1
......@@ -223,6 +223,7 @@ fn testErrorSetType() !void {
223223test "explicit error set cast" {
224224 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
225225 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
226 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
226227
227228 try testExplicitErrorSetCast(Set1.A);
228229 comptime try testExplicitErrorSetCast(Set1.A);
test/behavior/math.zig+2
......@@ -1166,6 +1166,7 @@ test "remainder division" {
11661166 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
11671167 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11681168 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1169 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11691170 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11701171 if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
11711172
......@@ -1198,6 +1199,7 @@ test "float remainder division using @rem" {
11981199 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
11991200 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12001201 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1202 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12011203 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12021204 if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
12031205
test/behavior/packed-struct.zig+4
......@@ -155,6 +155,7 @@ test "correct sizeOf and offsets in packed structs" {
155155 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
156156 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
157157 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
158 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
158159
159160 const PStruct = packed struct {
160161 bool_a: bool,
......@@ -225,6 +226,7 @@ test "nested packed structs" {
225226 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
226227 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
227228 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
229 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
228230
229231 const S1 = packed struct { a: u8, b: u8, c: u8 };
230232
......@@ -272,6 +274,7 @@ test "regular in irregular packed struct" {
272274 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
273275 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
274276 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
277 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
275278
276279 const Irregular = packed struct {
277280 bar: Regular = Regular{},
......@@ -294,6 +297,7 @@ test "byte-aligned field pointer offsets" {
294297 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
295298 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
296299 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
300 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
297301
298302 const S = struct {
299303 const A = packed struct {
test/behavior/struct.zig+43
......@@ -10,6 +10,7 @@ top_level_field: i32,
1010
1111test "top level fields" {
1212 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1314
1415 var instance = @This(){
1516 .top_level_field = 1234,
......@@ -85,6 +86,7 @@ const StructFoo = struct {
8586test "structs" {
8687 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8788 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
89 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8890
8991 var foo: StructFoo = undefined;
9092 @memset(@ptrCast([*]u8, &foo), 0, @sizeOf(StructFoo));
......@@ -103,6 +105,7 @@ fn testMutation(foo: *StructFoo) void {
103105
104106test "struct byval assign" {
105107 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
108 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106109
107110 var foo1: StructFoo = undefined;
108111 var foo2: StructFoo = undefined;
......@@ -136,6 +139,7 @@ fn returnEmptyStructInstance() StructWithNoFields {
136139
137140test "fn call of struct field" {
138141 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
142 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
139143
140144 const Foo = struct {
141145 ptr: fn () i32,
......@@ -191,6 +195,7 @@ const MemberFnRand = struct {
191195
192196test "return struct byval from function" {
193197 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
198 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
194199
195200 const bar = makeBar2(1234, 5678);
196201 try expect(bar.y == 5678);
......@@ -238,6 +243,7 @@ test "usingnamespace within struct scope" {
238243
239244test "struct field init with catch" {
240245 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
246 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
241247
242248 const S = struct {
243249 fn doTheTest() !void {
......@@ -263,6 +269,7 @@ const blah: packed struct {
263269} = undefined;
264270
265271test "bit field alignment" {
272 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
266273 try expect(@TypeOf(&blah.b) == *align(1:3:1) const u3);
267274}
268275
......@@ -278,6 +285,7 @@ const Val = struct {
278285test "struct point to self" {
279286 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
280287 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
288 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
281289
282290 var root: Node = undefined;
283291 root.val.x = 1;
......@@ -293,6 +301,7 @@ test "struct point to self" {
293301
294302test "void struct fields" {
295303 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
304 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
296305
297306 const foo = VoidStructFieldsFoo{
298307 .a = void{},
......@@ -311,6 +320,7 @@ const VoidStructFieldsFoo = struct {
311320test "return empty struct from fn" {
312321 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
313322 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
323 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
314324
315325 _ = testReturnEmptyStructFromFn();
316326}
......@@ -322,6 +332,7 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {
322332test "pass slice of empty struct to fn" {
323333 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
324334 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
335 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
325336
326337 try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
327338}
......@@ -334,6 +345,7 @@ test "self-referencing struct via array member" {
334345 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
335346 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
336347 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
348 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
337349
338350 const T = struct {
339351 children: [1]*@This(),
......@@ -359,6 +371,7 @@ const EmptyStruct = struct {
359371test "align 1 field before self referential align 8 field as slice return type" {
360372 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
361373 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
374 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
362375
363376 const result = alloc(Expr);
364377 try expect(result.len == 0);
......@@ -384,6 +397,7 @@ test "packed struct" {
384397 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
385398 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
386399 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
400 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
387401
388402 var foo = APackedStruct{
389403 .x = 1,
......@@ -412,6 +426,7 @@ test "packed struct 24bits" {
412426 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
413427 if (builtin.cpu.arch == .wasm32) return error.SkipZigTest; // TODO
414428 if (builtin.cpu.arch == .arm) return error.SkipZigTest; // TODO
429 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
415430
416431 comptime {
417432 // stage1 gets the wrong answer for sizeof
......@@ -458,6 +473,7 @@ test "runtime struct initialization of bitfield" {
458473 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
459474 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
460475 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
476 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
461477
462478 const s1 = Nibbles{
463479 .x = x1,
......@@ -502,6 +518,7 @@ test "packed struct fields are ordered from LSB to MSB" {
502518 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
503519 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
504520 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
521 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
505522
506523 var all: u64 = 0x7765443322221111;
507524 var bytes: [8]u8 = undefined;
......@@ -523,6 +540,7 @@ test "implicit cast packed struct field to const ptr" {
523540 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
524541 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
525542 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
543 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
526544
527545 const LevelUpMove = packed struct {
528546 move_id: u9,
......@@ -543,6 +561,7 @@ test "zero-bit field in packed struct" {
543561 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
544562 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
545563 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
564 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
546565
547566 const S = packed struct {
548567 x: u10,
......@@ -554,6 +573,7 @@ test "zero-bit field in packed struct" {
554573
555574test "packed struct with non-ABI-aligned field" {
556575 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
576 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
557577 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
558578 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
559579 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
......@@ -588,6 +608,7 @@ test "bit field access" {
588608 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
589609 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
590610 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
611 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
591612
592613 var data = bit_field_1;
593614 try expect(getA(&data) == 1);
......@@ -618,6 +639,7 @@ fn getC(data: *const BitField1) u2 {
618639test "default struct initialization fields" {
619640 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
620641 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
642 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
621643
622644 const S = struct {
623645 a: i32 = 1234,
......@@ -645,6 +667,7 @@ test "packed array 24bits" {
645667 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
646668 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
647669 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
670 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
648671
649672 comptime {
650673 try expect(@sizeOf([9]Foo32Bits) == 9 * 4);
......@@ -701,6 +724,7 @@ const FooArray24Bits = packed struct {
701724test "aligned array of packed struct" {
702725 // Stage2 has different packed struct semantics.
703726 if (builtin.zig_backend != .stage1) return error.SkipZigTest;
727 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
704728
705729 comptime {
706730 try expect(@sizeOf(FooStructAligned) == 2);
......@@ -730,6 +754,7 @@ test "pointer to packed struct member in a stack variable" {
730754 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
731755 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
732756 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
757 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
733758
734759 const S = packed struct {
735760 a: u2,
......@@ -747,6 +772,7 @@ test "packed struct with u0 field access" {
747772 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
748773 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
749774 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
775 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
750776
751777 const S = packed struct {
752778 f0: u0,
......@@ -758,6 +784,7 @@ test "packed struct with u0 field access" {
758784test "access to global struct fields" {
759785 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
760786 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
787 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
761788
762789 g_foo.bar.value = 42;
763790 try expect(g_foo.bar.value == 42);
......@@ -782,6 +809,7 @@ test "packed struct with fp fields" {
782809 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
783810 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
784811 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
812 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
785813 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
786814
787815 const S = packed struct {
......@@ -859,6 +887,7 @@ test "packed struct field passed to generic function" {
859887 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
860888 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
861889 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
890 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
862891
863892 const S = struct {
864893 const P = packed struct {
......@@ -975,6 +1004,7 @@ test "tuple element initialized with fn call" {
9751004 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9761005 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9771006 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1007 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9781008
9791009 const S = struct {
9801010 fn doTheTest() !void {
......@@ -1012,6 +1042,7 @@ test "type coercion of anon struct literal to struct" {
10121042 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
10131043 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10141044 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1045 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10151046
10161047 const S = struct {
10171048 const S2 = struct {
......@@ -1050,6 +1081,7 @@ test "type coercion of pointer to anon struct literal to pointer to struct" {
10501081 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
10511082 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10521083 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1084 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10531085
10541086 const S = struct {
10551087 const S2 = struct {
......@@ -1089,6 +1121,7 @@ test "packed struct with undefined initializers" {
10891121 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
10901122 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10911123 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1124 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10921125
10931126 const S = struct {
10941127 const P = packed struct {
......@@ -1119,6 +1152,7 @@ test "for loop over pointers to struct, getting field from struct pointer" {
11191152 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11201153 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11211154 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1155 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11221156
11231157 const S = struct {
11241158 const Foo = struct {
......@@ -1160,6 +1194,7 @@ test "anon init through error unions and optionals" {
11601194 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11611195 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11621196 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1197 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11631198
11641199 const S = struct {
11651200 a: u32,
......@@ -1188,6 +1223,7 @@ test "anon init through optional" {
11881223 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11891224 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11901225 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1226 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11911227
11921228 const S = struct {
11931229 a: u32,
......@@ -1209,6 +1245,7 @@ test "anon init through error union" {
12091245 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12101246 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
12111247 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1248 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12121249
12131250 const S = struct {
12141251 a: u32,
......@@ -1230,6 +1267,7 @@ test "typed init through error unions and optionals" {
12301267 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12311268 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
12321269 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1270 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12331271
12341272 const S = struct {
12351273 a: u32,
......@@ -1254,6 +1292,7 @@ test "typed init through error unions and optionals" {
12541292
12551293test "initialize struct with empty literal" {
12561294 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1295 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12571296
12581297 const S = struct { x: i32 = 1234 };
12591298 var s: S = .{};
......@@ -1262,6 +1301,7 @@ test "initialize struct with empty literal" {
12621301
12631302test "loading a struct pointer perfoms a copy" {
12641303 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1304 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12651305
12661306 const S = struct {
12671307 a: i32,
......@@ -1295,6 +1335,7 @@ test "packed struct aggregate init" {
12951335 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
12961336 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
12971337 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1338 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12981339
12991340 const S = struct {
13001341 fn foo(a: i2, b: i6) u8 {
......@@ -1315,6 +1356,7 @@ test "packed struct field access via pointer" {
13151356 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
13161357 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13171358 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1359 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13181360
13191361 const S = struct {
13201362 fn doTheTest() !void {
......@@ -1355,6 +1397,7 @@ test "store to comptime field" {
13551397
13561398test "struct field init value is size of the struct" {
13571399 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1400 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13581401
13591402 const namespace = struct {
13601403 const S = extern struct {