authorgravatar for david@vortan.devDavid Rubin <david@vortan.dev> 2024-05-02 03:33:56-07:00
committergravatar for david@vortan.devDavid Rubin <david@vortan.dev> 2024-06-13 02:20:47-07:00
log05de6c279bb4b36bd8751659984a9918624f7108
tree0a3c908736be592aa36e05d7327c73a8643fd62b
parent55b28c7e4438b3b8404a0fd703aad45db9dfe2ff
signaturelock-open Commit is signed but in an unrecognized format.

riscv: `std.fmt.format` running

- implements `airSlice`, `airBitAnd`, `airBitOr`, `airShr`. - got a basic design going for the `airErrorName` but for some reason it simply returns empty bytes. will investigate further. - only generating `.got.zig` entries when not compiling an object or shared library - reduced the total amount of ops a mnemonic can have to 3, simplifying the logic

44 files changed, 216 insertions(+), 177 deletions(-)

src/arch/riscv64/CodeGen.zig+193-14
......@@ -1609,10 +1609,7 @@ fn allocRegOrMem(self: *Self, inst: Air.Inst.Index, reg_ok: bool) !MCValue {
16091609 };
16101610
16111611 if (reg_ok) {
1612 // Make sure the type can fit in a register before we try to allocate one.
1613 const ptr_bits = self.target.ptrBitWidth();
1614 const ptr_bytes: u64 = @divExact(ptr_bits, 8);
1615 if (abi_size <= ptr_bytes) {
1612 if (abi_size <= 8) {
16161613 if (self.register_manager.tryAllocReg(inst, gp)) |reg| {
16171614 return .{ .register = reg };
16181615 }
......@@ -1625,7 +1622,7 @@ fn allocRegOrMem(self: *Self, inst: Air.Inst.Index, reg_ok: bool) !MCValue {
16251622
16261623/// Allocates a register from the general purpose set and returns the Register and the Lock.
16271624///
1628/// Up to the user to unlock the register later.
1625/// Up to the caller to unlock the register later.
16291626fn allocReg(self: *Self) !struct { Register, RegisterLock } {
16301627 const reg = try self.register_manager.allocReg(null, gp);
16311628 const lock = self.register_manager.lockRegAssumeUnused(reg);
......@@ -1923,9 +1920,25 @@ fn airMinMax(
19231920}
19241921
19251922fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
1923 const zcu = self.bin_file.comp.module.?;
19261924 const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
19271925 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
1928 const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement slice for {}", .{self.target.cpu.arch});
1926
1927 const slice_ty = self.typeOfIndex(inst);
1928 const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(slice_ty, zcu));
1929
1930 const ptr_ty = self.typeOf(bin_op.lhs);
1931 try self.genSetMem(.{ .frame = frame_index }, 0, ptr_ty, .{ .air_ref = bin_op.lhs });
1932
1933 const len_ty = self.typeOf(bin_op.rhs);
1934 try self.genSetMem(
1935 .{ .frame = frame_index },
1936 @intCast(ptr_ty.abiSize(zcu)),
1937 len_ty,
1938 .{ .air_ref = bin_op.rhs },
1939 );
1940
1941 const result = MCValue{ .load_frame = .{ .index = frame_index } };
19291942 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
19301943}
19311944
......@@ -2575,13 +2588,91 @@ fn airMod(self: *Self, inst: Air.Inst.Index) !void {
25752588
25762589fn airBitAnd(self: *Self, inst: Air.Inst.Index) !void {
25772590 const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
2578 const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement bitwise and for {}", .{self.target.cpu.arch});
2591 const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
2592 const lhs = try self.resolveInst(bin_op.lhs);
2593 const rhs = try self.resolveInst(bin_op.rhs);
2594
2595 const lhs_ty = self.typeOf(bin_op.lhs);
2596 const rhs_ty = self.typeOf(bin_op.rhs);
2597
2598 const lhs_reg, const lhs_lock = blk: {
2599 if (lhs == .register) break :blk .{ lhs.register, null };
2600
2601 const lhs_reg, const lhs_lock = try self.allocReg();
2602 try self.genSetReg(lhs_ty, lhs_reg, lhs);
2603 break :blk .{ lhs_reg, lhs_lock };
2604 };
2605 defer if (lhs_lock) |lock| self.register_manager.unlockReg(lock);
2606
2607 const rhs_reg, const rhs_lock = blk: {
2608 if (rhs == .register) break :blk .{ rhs.register, null };
2609
2610 const rhs_reg, const rhs_lock = try self.allocReg();
2611 try self.genSetReg(rhs_ty, rhs_reg, rhs);
2612 break :blk .{ rhs_reg, rhs_lock };
2613 };
2614 defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock);
2615
2616 const dest_reg, const dest_lock = try self.allocReg();
2617 defer self.register_manager.unlockReg(dest_lock);
2618
2619 _ = try self.addInst(.{
2620 .tag = .@"and",
2621 .ops = .rrr,
2622 .data = .{ .r_type = .{
2623 .rd = dest_reg,
2624 .rs1 = lhs_reg,
2625 .rs2 = rhs_reg,
2626 } },
2627 });
2628
2629 break :result .{ .register = dest_reg };
2630 };
25792631 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
25802632}
25812633
25822634fn airBitOr(self: *Self, inst: Air.Inst.Index) !void {
25832635 const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
2584 const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement bitwise or for {}", .{self.target.cpu.arch});
2636 const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
2637 const lhs = try self.resolveInst(bin_op.lhs);
2638 const rhs = try self.resolveInst(bin_op.rhs);
2639
2640 const lhs_ty = self.typeOf(bin_op.lhs);
2641 const rhs_ty = self.typeOf(bin_op.rhs);
2642
2643 const lhs_reg, const lhs_lock = blk: {
2644 if (lhs == .register) break :blk .{ lhs.register, null };
2645
2646 const lhs_reg, const lhs_lock = try self.allocReg();
2647 try self.genSetReg(lhs_ty, lhs_reg, lhs);
2648 break :blk .{ lhs_reg, lhs_lock };
2649 };
2650 defer if (lhs_lock) |lock| self.register_manager.unlockReg(lock);
2651
2652 const rhs_reg, const rhs_lock = blk: {
2653 if (rhs == .register) break :blk .{ rhs.register, null };
2654
2655 const rhs_reg, const rhs_lock = try self.allocReg();
2656 try self.genSetReg(rhs_ty, rhs_reg, rhs);
2657 break :blk .{ rhs_reg, rhs_lock };
2658 };
2659 defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock);
2660
2661 const dest_reg, const dest_lock = try self.allocReg();
2662 defer self.register_manager.unlockReg(dest_lock);
2663
2664 _ = try self.addInst(.{
2665 .tag = .@"or",
2666 .ops = .rrr,
2667 .data = .{ .r_type = .{
2668 .rd = dest_reg,
2669 .rs1 = lhs_reg,
2670 .rs2 = rhs_reg,
2671 } },
2672 });
2673
2674 break :result .{ .register = dest_reg };
2675 };
25852676 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
25862677}
25872678
......@@ -2612,7 +2703,14 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
26122703
26132704fn airShr(self: *Self, inst: Air.Inst.Index) !void {
26142705 const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
2615 const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement shr for {}", .{self.target.cpu.arch});
2706 const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
2707 const lhs = try self.resolveInst(bin_op.lhs);
2708 const rhs = try self.resolveInst(bin_op.rhs);
2709 const lhs_ty = self.typeOf(bin_op.lhs);
2710 const rhs_ty = self.typeOf(bin_op.rhs);
2711
2712 break :result try self.binOp(.shr, lhs, lhs_ty, rhs, rhs_ty);
2713 };
26162714 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
26172715}
26182716
......@@ -2671,6 +2769,10 @@ fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
26712769 }
26722770 break :result result;
26732771 },
2772 .load_frame => |frame_addr| break :result .{ .load_frame = .{
2773 .index = frame_addr.index,
2774 .off = frame_addr.off + @as(i32, @intCast(err_off)),
2775 } },
26742776 else => return self.fail("TODO implement unwrap_err_err for {}", .{operand}),
26752777 }
26762778 };
......@@ -3317,6 +3419,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
33173419 const zcu = self.bin_file.comp.module.?;
33183420 const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
33193421 const elem_ty = self.typeOfIndex(inst);
3422
33203423 const result: MCValue = result: {
33213424 if (!elem_ty.hasRuntimeBits(zcu))
33223425 break :result .none;
......@@ -3326,8 +3429,11 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
33263429 if (self.liveness.isUnused(inst) and !is_volatile)
33273430 break :result .unreach;
33283431
3432 const elem_size = elem_ty.abiSize(zcu);
3433
33293434 const dst_mcv: MCValue = blk: {
3330 if (self.reuseOperand(inst, ty_op.operand, 0, ptr)) {
3435 // Pointer is 8 bytes, and if the element is more than that, we cannot reuse it.
3436 if (elem_size <= 8 and self.reuseOperand(inst, ty_op.operand, 0, ptr)) {
33313437 // The MCValue that holds the pointer can be re-used as the value.
33323438 break :blk ptr;
33333439 } else {
......@@ -3794,6 +3900,7 @@ fn genCall(
37943900
37953901 for (call_info.args, arg_tys, args, frame_indices) |dst_arg, arg_ty, src_arg, frame_index| {
37963902 switch (dst_arg) {
3903 .none, .load_frame => {},
37973904 .register_pair => try self.genCopy(arg_ty, dst_arg, src_arg),
37983905 .register => |dst_reg| try self.genSetReg(
37993906 arg_ty,
......@@ -5573,6 +5680,7 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
55735680 const addr_reg, const addr_lock = try self.allocReg();
55745681 defer self.register_manager.unlockReg(addr_lock);
55755682
5683 // this is now the base address of the error name table
55765684 const lazy_sym = link.File.LazySymbol.initDecl(.const_data, null, zcu);
55775685 if (self.bin_file.cast(link.File.Elf)) |elf_file| {
55785686 const sym_index = elf_file.zigObjectPtr().?.getOrCreateMetadataForLazySymbol(elf_file, lazy_sym) catch |err|
......@@ -5589,10 +5697,77 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
55895697 const end_reg, const end_lock = try self.allocReg();
55905698 defer self.register_manager.unlockReg(end_lock);
55915699
5592 _ = start_reg;
5593 _ = end_reg;
5700 // const tmp_reg, const tmp_lock = try self.allocReg();
5701 // defer self.register_manager.unlockReg(tmp_lock);
5702
5703 // we move the base address forward by the following formula: base + (errno * 8)
5704
5705 // shifting left by 4 is the same as multiplying by 8
5706 _ = try self.addInst(.{
5707 .tag = .slli,
5708 .ops = .rri,
5709 .data = .{ .i_type = .{
5710 .imm12 = Immediate.s(4),
5711 .rd = err_reg,
5712 .rs1 = err_reg,
5713 } },
5714 });
5715
5716 _ = try self.addInst(.{
5717 .tag = .add,
5718 .ops = .rrr,
5719 .data = .{ .r_type = .{
5720 .rd = addr_reg,
5721 .rs1 = addr_reg,
5722 .rs2 = err_reg,
5723 } },
5724 });
5725
5726 _ = try self.addInst(.{
5727 .tag = .pseudo,
5728 .ops = .pseudo_load_rm,
5729 .data = .{
5730 .rm = .{
5731 .r = start_reg,
5732 .m = .{
5733 .base = .{ .reg = addr_reg },
5734 .mod = .{ .off = 0 },
5735 },
5736 },
5737 },
5738 });
5739
5740 _ = try self.addInst(.{
5741 .tag = .pseudo,
5742 .ops = .pseudo_load_rm,
5743 .data = .{
5744 .rm = .{
5745 .r = end_reg,
5746 .m = .{
5747 .base = .{ .reg = addr_reg },
5748 .mod = .{ .off = 8 },
5749 },
5750 },
5751 },
5752 });
5753
5754 const dst_mcv = try self.allocRegOrMem(inst, false);
5755 const frame = dst_mcv.load_frame;
5756 try self.genSetMem(
5757 .{ .frame = frame.index },
5758 frame.off,
5759 Type.usize,
5760 .{ .register = start_reg },
5761 );
55945762
5595 return self.fail("TODO: airErrorName", .{});
5763 try self.genSetMem(
5764 .{ .frame = frame.index },
5765 frame.off + 8,
5766 Type.usize,
5767 .{ .register = end_reg },
5768 );
5769
5770 return self.finishAir(inst, dst_mcv, .{ un_op, .none, .none });
55965771}
55975772
55985773fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
......@@ -5881,7 +6056,11 @@ fn resolveCallingConventionValues(
58816056 }
58826057
58836058 for (param_types, result.args) |ty, *arg| {
5884 assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
6059 if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
6060 assert(cc == .Unspecified);
6061 arg.* = .none;
6062 continue;
6063 }
58856064
58866065 var arg_mcv: [2]MCValue = undefined;
58876066 var arg_mcv_i: usize = 0;
src/arch/riscv64/Emit.zig+7-1
......@@ -42,6 +42,12 @@ pub fn emitMir(emit: *Emit) Error!void {
4242 .enc = std.meta.activeTag(lowered_inst.encoding.data),
4343 }),
4444 .load_symbol_reloc => |symbol| {
45 const is_obj_or_static_lib = switch (emit.lower.output_mode) {
46 .Exe => false,
47 .Obj => true,
48 .Lib => emit.lower.link_mode == .static,
49 };
50
4551 if (emit.lower.bin_file.cast(link.File.Elf)) |elf_file| {
4652 const atom_ptr = elf_file.symbol(symbol.atom_index).atom(elf_file).?;
4753 const sym_index = elf_file.zigObjectPtr().?.symbol(symbol.sym_index);
......@@ -50,7 +56,7 @@ pub fn emitMir(emit: *Emit) Error!void {
5056 var hi_r_type: u32 = @intFromEnum(std.elf.R_RISCV.HI20);
5157 var lo_r_type: u32 = @intFromEnum(std.elf.R_RISCV.LO12_I);
5258
53 if (sym.flags.needs_zig_got) {
59 if (sym.flags.needs_zig_got and !is_obj_or_static_lib) {
5460 _ = try sym.getOrCreateZigGotEntry(sym_index, elf_file);
5561
5662 hi_r_type = Elf.R_ZIG_GOT_HI20;
src/arch/riscv64/Encoding.zig+4
......@@ -16,6 +16,7 @@ pub const Mnemonic = enum {
1616 slli,
1717 srli,
1818 srai,
19 sllw,
1920
2021 addi,
2122 jalr,
......@@ -77,6 +78,8 @@ pub const Mnemonic = enum {
7778 .slli => .{ .opcode = 0b0010011, .funct3 = 0b001, .funct7 = null },
7879 .srli => .{ .opcode = 0b0010011, .funct3 = 0b101, .funct7 = null },
7980 .srai => .{ .opcode = 0b0010011, .funct3 = 0b101, .funct7 = null, .offset = 1 << 10 },
81
82 .sllw => .{ .opcode = 0b0111011, .funct3 = 0b001, .funct7 = 0b0000000 },
8083
8184 .lui => .{ .opcode = 0b0110111, .funct3 = null, .funct7 = null },
8285 .auipc => .{ .opcode = 0b0010111, .funct3 = null, .funct7 = null },
......@@ -152,6 +155,7 @@ pub const InstEnc = enum {
152155
153156 .slt,
154157 .sltu,
158 .sllw,
155159 .mul,
156160 .xor,
157161 .add,
src/arch/riscv64/Lower.zig+2-2
......@@ -71,7 +71,7 @@ pub fn lowerMir(lower: *Lower, index: Mir.Inst.Index) Error!struct {
7171
7272 switch (inst.ops) {
7373 .pseudo_load_rm => {
74 const tag: Encoding.Mnemonic = switch (rm.m.mod.rm.size) {
74 const tag: Encoding.Mnemonic = switch (rm.m.mod.size()) {
7575 .byte => .lb,
7676 .hword => .lh,
7777 .word => .lw,
......@@ -85,7 +85,7 @@ pub fn lowerMir(lower: *Lower, index: Mir.Inst.Index) Error!struct {
8585 });
8686 },
8787 .pseudo_store_rm => {
88 const tag: Encoding.Mnemonic = switch (rm.m.mod.rm.size) {
88 const tag: Encoding.Mnemonic = switch (rm.m.mod.size()) {
8989 .byte => .sb,
9090 .hword => .sh,
9191 .word => .sw,
src/arch/riscv64/bits.zig+7
......@@ -21,6 +21,13 @@ pub const Memory = struct {
2121 disp: i32 = 0,
2222 },
2323 off: i32,
24
25 pub fn size(mod: Mod) Size {
26 return switch (mod) {
27 .rm => |rm| rm.size,
28 .off => Size.dword, // assumed to be a register size
29 };
30 }
2431 };
2532
2633 pub const Size = enum(u4) {
src/arch/riscv64/encoder.zig+1-2
......@@ -11,12 +11,11 @@ pub const Instruction = struct {
1111
1212 pub fn new(mnemonic: Encoding.Mnemonic, ops: []const Operand) !Instruction {
1313 const encoding = (try Encoding.findByMnemonic(mnemonic, ops)) orelse {
14 std.log.err("no encoding found for: {s} {s} {s} {s} {s}", .{
14 std.log.err("no encoding found for: {s} [{s} {s} {s}]", .{
1515 @tagName(mnemonic),
1616 @tagName(if (ops.len > 0) ops[0] else .none),
1717 @tagName(if (ops.len > 1) ops[1] else .none),
1818 @tagName(if (ops.len > 2) ops[2] else .none),
19 @tagName(if (ops.len > 3) ops[3] else .none),
2019 });
2120 return error.InvalidInstruction;
2221 };
test/behavior/align.zig-3
......@@ -54,7 +54,6 @@ fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 {
5454}
5555
5656test "@alignCast pointers" {
57 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
5857 var x: u32 align(4) = 1;
5958 expectsOnly1(&x);
6059 try expect(x == 2);
......@@ -426,7 +425,6 @@ test "function callconv expression depends on generic parameter" {
426425}
427426
428427test "runtime-known array index has best alignment possible" {
429 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
430428 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
431429
432430 // take full advantage of over-alignment
......@@ -562,7 +560,6 @@ test "align(@alignOf(T)) T does not force resolution of T" {
562560}
563561
564562test "align(N) on functions" {
565 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
566563 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
567564 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
568565 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/array.zig-1
......@@ -1047,7 +1047,6 @@ test "union that needs padding bytes inside an array" {
10471047
10481048test "runtime index of array of zero-bit values" {
10491049 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1050 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10511050
10521051 var runtime: struct { array: [1]void, index: usize } = undefined;
10531052 runtime = .{ .array = .{{}}, .index = 0 };
test/behavior/basic.zig-6
......@@ -513,7 +513,6 @@ var global_foo: *i32 = undefined;
513513test "peer result location with typed parent, runtime condition, comptime prongs" {
514514 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
515515 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
516 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
517516
518517 const S = struct {
519518 fn doTheTest(arg: i32) i32 {
......@@ -593,7 +592,6 @@ test "equality compare fn ptrs" {
593592
594593test "self reference through fn ptr field" {
595594 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
596 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
597595
598596 const S = struct {
599597 const A = struct {
......@@ -838,7 +836,6 @@ test "labeled block implicitly ends in a break" {
838836test "catch in block has correct result location" {
839837 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
840838 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
841 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
842839
843840 const S = struct {
844841 fn open() error{A}!@This() {
......@@ -870,7 +867,6 @@ test "labeled block with runtime branch forwards its result location type to bre
870867
871868test "try in labeled block doesn't cast to wrong type" {
872869 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
873 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
874870
875871 const S = struct {
876872 a: u32,
......@@ -1246,8 +1242,6 @@ test "pointer to tuple field can be dereferenced at comptime" {
12461242}
12471243
12481244test "proper value is returned from labeled block" {
1249 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1250
12511245 const S = struct {
12521246 fn hash(v: *u32, key: anytype) void {
12531247 const Key = @TypeOf(key);
test/behavior/bitcast.zig-5
......@@ -250,7 +250,6 @@ test "bitcast packed struct to integer and back" {
250250test "implicit cast to error union by returning" {
251251 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
252252 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
253 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
254253
255254 const S = struct {
256255 fn entry() !void {
......@@ -280,8 +279,6 @@ test "comptime bitcast used in expression has the correct type" {
280279}
281280
282281test "bitcast passed as tuple element" {
283 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
284
285282 const S = struct {
286283 fn foo(args: anytype) !void {
287284 comptime assert(@TypeOf(args[0]) == f32);
......@@ -292,8 +289,6 @@ test "bitcast passed as tuple element" {
292289}
293290
294291test "triple level result location with bitcast sandwich passed as tuple element" {
295 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
296
297292 const S = struct {
298293 fn foo(args: anytype) !void {
299294 comptime assert(@TypeOf(args[0]) == f64);
test/behavior/call.zig-6
......@@ -60,7 +60,6 @@ test "tuple parameters" {
6060 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6161 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6262 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
63 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
6463
6564 const add = struct {
6665 fn add(a: i32, b: i32) i32 {
......@@ -94,7 +93,6 @@ test "result location of function call argument through runtime condition and st
9493 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9594 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9695 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
97 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
9896
9997 const E = enum { a, b };
10098 const S = struct {
......@@ -411,7 +409,6 @@ test "recursive inline call with comptime known argument" {
411409test "inline while with @call" {
412410 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
413411 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
414 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
415412
416413 const S = struct {
417414 fn inc(a: *u32) void {
......@@ -427,8 +424,6 @@ test "inline while with @call" {
427424}
428425
429426test "method call as parameter type" {
430 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
431
432427 const S = struct {
433428 fn foo(x: anytype, y: @TypeOf(x).Inner()) @TypeOf(y) {
434429 return y;
......@@ -477,7 +472,6 @@ test "argument to generic function has correct result type" {
477472 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
478473 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
479474 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
480 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
481475
482476 const S = struct {
483477 fn foo(_: anytype, e: enum { a, b }) bool {
test/behavior/cast.zig-7
......@@ -483,7 +483,6 @@ fn castToOptionalTypeError(z: i32) !void {
483483test "implicitly cast from [0]T to anyerror![]T" {
484484 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
485485 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
486 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
487486
488487 try testCastZeroArrayToErrSliceMut();
489488 try comptime testCastZeroArrayToErrSliceMut();
......@@ -558,7 +557,6 @@ fn testCastConstArrayRefToConstSlice() !void {
558557test "peer type resolution: error and [N]T" {
559558 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
560559 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
561 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
562560
563561 try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
564562 comptime assert(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
......@@ -1157,7 +1155,6 @@ fn foobar(func: PFN_void) !void {
11571155
11581156test "cast function with an opaque parameter" {
11591157 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1160 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11611158
11621159 if (builtin.zig_backend == .stage2_c) {
11631160 // https://github.com/ziglang/zig/issues/16845
......@@ -1309,7 +1306,6 @@ fn incrementVoidPtrValue(value: ?*anyopaque) void {
13091306test "implicit cast *[0]T to E![]const u8" {
13101307 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13111308 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1312 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13131309
13141310 var x = @as(anyerror![]const u8, &[0]u8{});
13151311 _ = &x;
......@@ -1496,7 +1492,6 @@ test "cast compatible optional types" {
14961492test "coerce undefined single-item pointer of array to error union of slice" {
14971493 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14981494 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1499 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
15001495
15011496 const a = @as([*]u8, undefined)[0..0];
15021497 var b: error{a}![]const u8 = a;
......@@ -2206,7 +2201,6 @@ test "peer type resolution: tuples with comptime fields" {
22062201 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22072202 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
22082203 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
2209 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
22102204
22112205 const a = .{ 1, 2 };
22122206 const b = .{ @as(u32, 3), @as(i16, 4) };
......@@ -2361,7 +2355,6 @@ test "cast builtins can wrap result in error union" {
23612355 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
23622356 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23632357 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2364 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
23652358
23662359 const S = struct {
23672360 const MyEnum = enum(u32) { _ };
test/behavior/comptime_memory.zig-4
......@@ -408,8 +408,6 @@ test "mutate entire slice at comptime" {
408408}
409409
410410test "dereference undefined pointer to zero-bit type" {
411 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
412
413411 const p0: *void = undefined;
414412 try testing.expectEqual({}, p0.*);
415413
......@@ -515,7 +513,5 @@ fn fieldPtrTest() u32 {
515513 return a.value;
516514}
517515test "pointer in aggregate field can mutate comptime state" {
518 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
519
520516 try comptime std.testing.expect(fieldPtrTest() == 2);
521517}
test/behavior/defer.zig-1
......@@ -162,7 +162,6 @@ test "reference to errdefer payload" {
162162test "simple else prong doesn't emit an error for unreachable else prong" {
163163 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
164164 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
165 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
166165
167166 const S = struct {
168167 fn foo() error{Foo}!void {
test/behavior/empty_union.zig-4
......@@ -48,8 +48,6 @@ test "empty extern union" {
4848}
4949
5050test "empty union passed as argument" {
51 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
52
5351 const U = union(enum) {
5452 fn f(u: @This()) void {
5553 switch (u) {}
......@@ -59,8 +57,6 @@ test "empty union passed as argument" {
5957}
6058
6159test "empty enum passed as argument" {
62 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
63
6460 const E = enum {
6561 fn f(e: @This()) void {
6662 switch (e) {}
test/behavior/enum.zig-2
......@@ -856,8 +856,6 @@ fn doALoopThing(id: EnumWithOneMember) void {
856856}
857857
858858test "comparison operator on enum with one member is comptime-known" {
859 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
860
861859 doALoopThing(EnumWithOneMember.Eof);
862860}
863861
test/behavior/error.zig-22
......@@ -31,7 +31,6 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
3131
3232test "error binary operator" {
3333 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
34 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3534
3635 const a = errBinaryOperatorG(true) catch 3;
3736 const b = errBinaryOperatorG(false) catch 3;
......@@ -63,14 +62,12 @@ pub fn baz() anyerror!i32 {
6362
6463test "error wrapping" {
6564 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
66 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
6765
6866 try expect((baz() catch unreachable) == 15);
6967}
7068
7169test "unwrap simple value from error" {
7270 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
73 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7471
7572 const i = unwrapSimpleValueFromErrorDo() catch unreachable;
7673 try expect(i == 13);
......@@ -81,7 +78,6 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize {
8178
8279test "error return in assignment" {
8380 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
84 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8581
8682 doErrReturnInAssignment() catch unreachable;
8783}
......@@ -104,7 +100,6 @@ test "syntax: optional operator in front of error union operator" {
104100test "widen cast integer payload of error union function call" {
105101 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
106102 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
107 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
108103
109104 const S = struct {
110105 fn errorable() !u64 {
......@@ -241,8 +236,6 @@ fn testExplicitErrorSetCast(set1: Set1) !void {
241236}
242237
243238test "@errorCast on error unions" {
244 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
245
246239 const S = struct {
247240 fn doTheTest() !void {
248241 {
......@@ -270,7 +263,6 @@ test "@errorCast on error unions" {
270263
271264test "comptime test error for empty error set" {
272265 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
273 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
274266
275267 try testComptimeTestErrorEmptySet(1234);
276268 try comptime testComptimeTestErrorEmptySet(1234);
......@@ -306,8 +298,6 @@ test "inferred empty error set comptime catch" {
306298}
307299
308300test "error inference with an empty set" {
309 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
310
311301 const S = struct {
312302 const Struct = struct {
313303 pub fn func() (error{})!usize {
......@@ -362,7 +352,6 @@ fn quux_1() !i32 {
362352
363353test "error: Zero sized error set returned with value payload crash" {
364354 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
365 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
366355
367356 _ = try foo3(0);
368357 _ = try comptime foo3(0);
......@@ -376,7 +365,6 @@ fn foo3(b: usize) Error!usize {
376365test "error: Infer error set from literals" {
377366 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
378367 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
379 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
380368
381369 _ = nullLiteral("n") catch |err| handleErrors(err);
382370 _ = floatLiteral("n") catch |err| handleErrors(err);
......@@ -498,7 +486,6 @@ test "optional error set is the same size as error set" {
498486test "nested catch" {
499487 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
500488 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
501 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
502489
503490 const S = struct {
504491 fn entry() !void {
......@@ -524,7 +511,6 @@ test "nested catch" {
524511test "function pointer with return type that is error union with payload which is pointer of parent struct" {
525512 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
526513 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
527 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
528514
529515 const S = struct {
530516 const Foo = struct {
......@@ -582,7 +568,6 @@ test "error payload type is correctly resolved" {
582568 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
583569 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
584570 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
585 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
586571
587572 const MyIntWrapper = struct {
588573 const Self = @This();
......@@ -1039,7 +1024,6 @@ test "function called at runtime is properly analyzed for inferred error set" {
10391024 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10401025 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10411026 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1042 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10431027
10441028 const S = struct {
10451029 fn foo() !void {
......@@ -1063,7 +1047,6 @@ test "generic type constructed from inferred error set of unresolved function" {
10631047 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10641048 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10651049 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1066 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10671050
10681051 const S = struct {
10691052 fn write(_: void, bytes: []const u8) !usize {
......@@ -1079,8 +1062,6 @@ test "generic type constructed from inferred error set of unresolved function" {
10791062}
10801063
10811064test "errorCast to adhoc inferred error set" {
1082 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1083
10841065 const S = struct {
10851066 inline fn baz() !i32 {
10861067 return @errorCast(err());
......@@ -1093,8 +1074,6 @@ test "errorCast to adhoc inferred error set" {
10931074}
10941075
10951076test "errorCast from error sets to error unions" {
1096 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1097
10981077 const err_union: Set1!void = @errorCast(error.A);
10991078 try expectError(error.A, err_union);
11001079}
......@@ -1103,7 +1082,6 @@ test "result location initialization of error union with OPV payload" {
11031082 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11041083 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11051084 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1106 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11071085 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11081086
11091087 const S = struct {
test/behavior/eval.zig-5
......@@ -505,7 +505,6 @@ test "comptime shlWithOverflow" {
505505test "const ptr to variable data changes at runtime" {
506506 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
507507 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
508 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
509508
510509 try expect(foo_ref.name[0] == 'a');
511510 foo_ref.name = "b";
......@@ -720,8 +719,6 @@ fn loopNTimes(comptime n: usize) void {
720719}
721720
722721test "variable inside inline loop that has different types on different iterations" {
723 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
724
725722 try testVarInsideInlineLoop(.{ true, @as(u32, 42) });
726723}
727724
......@@ -1643,8 +1640,6 @@ test "result of nested switch assigned to variable" {
16431640}
16441641
16451642test "inline for loop of functions returning error unions" {
1646 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1647
16481643 const T1 = struct {
16491644 fn v() error{}!usize {
16501645 return 1;
test/behavior/fn.zig-11
......@@ -71,7 +71,6 @@ fn outer(y: u32) *const fn (u32) u32 {
7171
7272test "return inner function which references comptime variable of outer function" {
7373 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
74 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7574
7675 const func = outer(10);
7776 try expect(func(3) == 7);
......@@ -81,7 +80,6 @@ test "discard the result of a function that returns a struct" {
8180 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8281 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8382 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
84 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8583
8684 const S = struct {
8785 fn entry() void {
......@@ -191,7 +189,6 @@ test "function with complex callconv and return type expressions" {
191189
192190test "pass by non-copying value" {
193191 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
194 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
195192
196193 try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
197194}
......@@ -207,7 +204,6 @@ fn addPointCoords(pt: Point) i32 {
207204
208205test "pass by non-copying value through var arg" {
209206 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
210 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
211207
212208 try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);
213209}
......@@ -219,7 +215,6 @@ fn addPointCoordsVar(pt: anytype) !i32 {
219215
220216test "pass by non-copying value as method" {
221217 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
222 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
223218
224219 var pt = Point2{ .x = 1, .y = 2 };
225220 try expect(pt.addPointCoords() == 3);
......@@ -236,7 +231,6 @@ const Point2 = struct {
236231
237232test "pass by non-copying value as method, which is generic" {
238233 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
239 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
240234
241235 var pt = Point3{ .x = 1, .y = 2 };
242236 try expect(pt.addPointCoords(i32) == 3);
......@@ -292,7 +286,6 @@ test "implicit cast fn call result to optional in field result" {
292286test "void parameters" {
293287 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
294288 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
295 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
296289
297290 try voidFun(1, void{}, 2, {});
298291}
......@@ -424,7 +417,6 @@ test "function with inferred error set but returning no error" {
424417
425418test "import passed byref to function in return type" {
426419 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
427 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
428420
429421 const S = struct {
430422 fn get() @import("std").ArrayListUnmanaged(i32) {
......@@ -541,7 +533,6 @@ test "function returns function returning type" {
541533
542534test "peer type resolution of inferred error set with non-void payload" {
543535 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
544 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
545536
546537 const S = struct {
547538 fn openDataFile(mode: enum { read, write }) !u32 {
......@@ -584,8 +575,6 @@ test "lazy values passed to anytype parameter" {
584575}
585576
586577test "pass and return comptime-only types" {
587 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
588
589578 const S = struct {
590579 fn returnNull(comptime x: @Type(.Null)) @Type(.Null) {
591580 return x;
test/behavior/fn_delegation.zig-1
......@@ -34,7 +34,6 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
3434test "fn delegation" {
3535 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
3636 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
37 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3837
3938 const foo = Foo{};
4039 try expect(foo.one() == 11);
test/behavior/for.zig-2
......@@ -438,7 +438,6 @@ test "inline for with counter as the comptime-known" {
438438 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
439439 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
440440 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
441 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
442441
443442 var runtime_slice = "hello";
444443 var runtime_i: usize = 3;
......@@ -471,7 +470,6 @@ test "inline for on tuple pointer" {
471470 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
472471 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
473472 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
474 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
475473
476474 const S = struct { u32, u32, u32 };
477475 var s: S = .{ 100, 200, 300 };
test/behavior/generics.zig-6
......@@ -286,7 +286,6 @@ test "generic function instantiation turns into comptime call" {
286286
287287test "generic function with void and comptime parameter" {
288288 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
289 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
290289
291290 const S = struct { x: i32 };
292291 const namespace = struct {
......@@ -303,7 +302,6 @@ test "generic function with void and comptime parameter" {
303302test "anonymous struct return type referencing comptime parameter" {
304303 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
305304 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
306 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
307305
308306 const S = struct {
309307 pub fn extraData(comptime T: type, index: usize) struct { data: T, end: usize } {
......@@ -394,7 +392,6 @@ test "extern function used as generic parameter" {
394392
395393test "generic struct as parameter type" {
396394 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
397 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
398395
399396 const S = struct {
400397 fn doTheTest(comptime Int: type, thing: struct { int: Int }) !void {
......@@ -435,7 +432,6 @@ test "null sentinel pointer passed as generic argument" {
435432
436433test "generic function passed as comptime argument" {
437434 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
438 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
439435
440436 const S = struct {
441437 fn doMath(comptime f: fn (type, i32, i32) error{Overflow}!i32, a: i32, b: i32) !void {
......@@ -461,7 +457,6 @@ test "return type of generic function is function pointer" {
461457
462458test "coerced function body has inequal value with its uncoerced body" {
463459 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
464 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
465460
466461 const S = struct {
467462 const A = B(i32, c);
......@@ -546,7 +541,6 @@ test "call generic function with from function called by the generic function" {
546541 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
547542 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
548543 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
549 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
550544 if (builtin.zig_backend == .stage2_llvm and
551545 builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;
552546
test/behavior/incomplete_struct_param_tld.zig-1
......@@ -23,7 +23,6 @@ fn foo(a: A) i32 {
2323
2424test "incomplete struct param top level declaration" {
2525 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
26 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2726
2827 const a = A{
2928 .b = B{
test/behavior/inline_switch.zig-1
......@@ -89,7 +89,6 @@ test "inline else bool" {
8989test "inline else error" {
9090 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9191 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
92 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
9392
9493 const Err = error{ a, b, c };
9594 var a = Err.a;
test/behavior/ir_block_deps.zig-1
......@@ -21,7 +21,6 @@ test "ir block deps" {
2121 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2222 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2323 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
24 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2524
2625 try expect((foo(1) catch unreachable) == 0);
2726 try expect((foo(2) catch unreachable) == 0);
test/behavior/math.zig-2
......@@ -1471,8 +1471,6 @@ fn testShrExact(x: u8) !void {
14711471}
14721472
14731473test "shift left/right on u0 operand" {
1474 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1475
14761474 const S = struct {
14771475 fn doTheTest() !void {
14781476 var x: u0 = 0;
test/behavior/maximum_minimum.zig+1
......@@ -300,6 +300,7 @@ test "@min/@max notices bounds from vector types when element of comptime-known
300300 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
301301 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
302302 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
303 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
303304 if (builtin.zig_backend == .stage2_x86_64 and
304305 !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx)) return error.SkipZigTest;
305306
test/behavior/member_func.zig-1
......@@ -31,7 +31,6 @@ test "standard field calls" {
3131 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3232 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3333 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
34 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3534
3635 try expect(HasFuncs.one(0) == 1);
3736 try expect(HasFuncs.two(0) == 2);
test/behavior/memset.zig-2
......@@ -7,7 +7,6 @@ test "@memset on array pointers" {
77 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
88 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
99 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1110
1211 try testMemsetArray();
1312 try comptime testMemsetArray();
......@@ -167,7 +166,6 @@ test "zero keys with @memset" {
167166 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
168167 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
169168 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
170 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
171169
172170 const Keys = struct {
173171 up: bool,
test/behavior/merge_error_sets.zig-1
......@@ -13,7 +13,6 @@ fn foo() C!void {
1313
1414test "merge error sets" {
1515 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1716
1817 if (foo()) {
1918 @panic("unexpected");
test/behavior/optional.zig-2
......@@ -615,8 +615,6 @@ test "cast slice to const slice nested in error union and optional" {
615615}
616616
617617test "variable of optional of noreturn" {
618 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
619
620618 var null_opv: ?noreturn = null;
621619 _ = &null_opv;
622620 try std.testing.expectEqual(@as(?noreturn, null), null_opv);
test/behavior/packed-struct.zig+1-2
......@@ -238,7 +238,6 @@ test "regular in irregular packed struct" {
238238 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
239239 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
240240 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
241 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
242241
243242 const Irregular = packed struct {
244243 bar: Regular = Regular{},
......@@ -435,6 +434,7 @@ test "nested packed struct field pointers" {
435434 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
436435 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
437436 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // ubsan unaligned pointer access
437 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
438438 if (native_endian != .little) return error.SkipZigTest; // Byte aligned packed struct field pointers have not been implemented yet
439439
440440 const S2 = packed struct {
......@@ -1190,7 +1190,6 @@ test "packed struct field pointer aligned properly" {
11901190 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11911191 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11921192 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
1193 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11941193
11951194 const Foo = packed struct {
11961195 a: i32,
test/behavior/ptrfromint.zig-3
......@@ -3,8 +3,6 @@ const builtin = @import("builtin");
33const expectEqual = std.testing.expectEqual;
44
55test "casting integer address to function pointer" {
6 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7
86 addressToFunction();
97 comptime addressToFunction();
108}
......@@ -19,7 +17,6 @@ test "mutate through ptr initialized with constant ptrFromInt value" {
1917 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2018 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2119 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
22 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2320
2421 forceCompilerAnalyzeBranchHardCodedPtrDereference(false);
2522}
test/behavior/sizeof_and_typeof.zig-2
......@@ -158,7 +158,6 @@ test "@TypeOf() has no runtime side effects" {
158158
159159test "branching logic inside @TypeOf" {
160160 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
162161
163162 const S = struct {
164163 var data: i32 = 0;
......@@ -412,7 +411,6 @@ test "Extern function calls, dereferences and field access in @TypeOf" {
412411 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
413412 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
414413 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
415 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
416414
417415 const Test = struct {
418416 fn test_fn_1(a: c_long) @TypeOf(c_fopen("test", "r").*) {
test/behavior/slice.zig-4
......@@ -124,7 +124,6 @@ test "slice of type" {
124124
125125test "generic malloc free" {
126126 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
127 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
128127
129128 const a = memAlloc(u8, 10) catch unreachable;
130129 memFree(u8, a);
......@@ -874,8 +873,6 @@ test "slice of void" {
874873}
875874
876875test "slice with dereferenced value" {
877 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
878
879876 var a: usize = 0;
880877 const idx: *usize = &a;
881878 _ = blk: {
......@@ -1004,7 +1001,6 @@ test "sentinel-terminated 0-length slices" {
10041001 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
10051002 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10061003 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1007 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10081004
10091005 const u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
10101006
test/behavior/struct.zig-25
......@@ -92,7 +92,6 @@ test "structs" {
9292 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9393 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9494 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
95 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
9695
9796 var foo: StructFoo = undefined;
9897 @memset(@as([*]u8, @ptrCast(&foo))[0..@sizeOf(StructFoo)], 0);
......@@ -175,7 +174,6 @@ const MemberFnTestFoo = struct {
175174
176175test "call member function directly" {
177176 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
178 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
179177
180178 const instance = MemberFnTestFoo{ .x = 1234 };
181179 const result = MemberFnTestFoo.member(instance);
......@@ -184,7 +182,6 @@ test "call member function directly" {
184182
185183test "store member function in variable" {
186184 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
187 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
188185
189186 const instance = MemberFnTestFoo{ .x = 1234 };
190187 const memberFn = MemberFnTestFoo.member;
......@@ -206,7 +203,6 @@ const MemberFnRand = struct {
206203test "return struct byval from function" {
207204 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
208205 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
209 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
210206
211207 const Bar = struct {
212208 x: i32,
......@@ -255,7 +251,6 @@ test "usingnamespace within struct scope" {
255251test "struct field init with catch" {
256252 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
257253 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
258 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
259254
260255 const S = struct {
261256 fn doTheTest() !void {
......@@ -631,7 +626,6 @@ fn getC(data: *const BitField1) u2 {
631626test "default struct initialization fields" {
632627 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
633628 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
634 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
635629
636630 const S = struct {
637631 a: i32 = 1234,
......@@ -807,7 +801,6 @@ test "fn with C calling convention returns struct by value" {
807801 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
808802 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
809803 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
810 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
811804
812805 const S = struct {
813806 fn entry() !void {
......@@ -907,8 +900,6 @@ test "anonymous struct literal syntax" {
907900}
908901
909902test "fully anonymous struct" {
910 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
911
912903 const S = struct {
913904 fn doTheTest() !void {
914905 try dump(.{
......@@ -931,8 +922,6 @@ test "fully anonymous struct" {
931922}
932923
933924test "fully anonymous list literal" {
934 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
935
936925 const S = struct {
937926 fn doTheTest() !void {
938927 try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
......@@ -980,7 +969,6 @@ test "tuple element initialized with fn call" {
980969 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
981970 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
982971 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
983 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
984972
985973 const S = struct {
986974 fn doTheTest() !void {
......@@ -1041,7 +1029,6 @@ test "type coercion of anon struct literal to struct" {
10411029 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10421030 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10431031 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1044 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10451032
10461033 const S = struct {
10471034 const S2 = struct {
......@@ -1081,7 +1068,6 @@ test "type coercion of pointer to anon struct literal to pointer to struct" {
10811068 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10821069 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10831070 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1084 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10851071
10861072 const S = struct {
10871073 const S2 = struct {
......@@ -1296,7 +1282,6 @@ test "initialize struct with empty literal" {
12961282
12971283test "loading a struct pointer perfoms a copy" {
12981284 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1299 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13001285
13011286 const S = struct {
13021287 a: i32,
......@@ -1558,7 +1543,6 @@ test "discarded struct initialization works as expected" {
15581543test "function pointer in struct returns the struct" {
15591544 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15601545 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1561 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
15621546
15631547 const A = struct {
15641548 const A = @This();
......@@ -1766,8 +1750,6 @@ test "extern struct field pointer has correct alignment" {
17661750}
17671751
17681752test "packed struct field in anonymous struct" {
1769 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1770
17711753 const T = packed struct {
17721754 f1: bool = false,
17731755 };
......@@ -1779,8 +1761,6 @@ fn countFields(v: anytype) usize {
17791761}
17801762
17811763test "struct init with no result pointer sets field result types" {
1782 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1783
17841764 const S = struct {
17851765 // A function parameter has a result type, but no result pointer.
17861766 fn f(s: struct { x: u32 }) u32 {
......@@ -1922,8 +1902,6 @@ test "circular dependency through pointer field of a struct" {
19221902}
19231903
19241904test "field calls do not force struct field init resolution" {
1925 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1926
19271905 const S = struct {
19281906 x: u32 = blk: {
19291907 _ = @TypeOf(make().dummyFn()); // runtime field call - S not fully resolved - dummyFn call should not force field init resolution
......@@ -2057,7 +2035,6 @@ test "runtime value in nested initializer passed as pointer to function" {
20572035 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
20582036 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
20592037 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2060 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
20612038
20622039 const Bar = struct {
20632040 b: u32,
......@@ -2132,7 +2109,6 @@ test "assignment of field with padding" {
21322109 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
21332110 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21342111 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2135 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
21362112
21372113 const Mesh = extern struct {
21382114 id: u32,
......@@ -2163,7 +2139,6 @@ test "initiate global variable with runtime value" {
21632139 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
21642140 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21652141 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2166 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
21672142
21682143 const S = struct {
21692144 field: i32,
test/behavior/switch.zig-2
......@@ -397,7 +397,6 @@ fn switchWithUnreachable(x: i32) i32 {
397397
398398test "capture value of switch with all unreachable prongs" {
399399 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
400 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
401400
402401 const x = return_a_number() catch |err| switch (err) {
403402 else => unreachable,
......@@ -503,7 +502,6 @@ test "switch prongs with error set cases make a new error set type for capture v
503502
504503test "return result loc and then switch with range implicit casted to error union" {
505504 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
506 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
507505
508506 const S = struct {
509507 fn doTheTest() !void {
test/behavior/try.zig-1
......@@ -4,7 +4,6 @@ const expect = std.testing.expect;
44
55test "try on error union" {
66 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
87
98 try tryOnErrorUnionImpl();
109 try comptime tryOnErrorUnionImpl();
test/behavior/tuple.zig-6
......@@ -10,7 +10,6 @@ test "tuple concatenation" {
1010 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1111 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1212 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1413
1514 const S = struct {
1615 fn doTheTest() !void {
......@@ -56,7 +55,6 @@ test "more tuple concatenation" {
5655 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
5756 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
5857 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
59 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
6058
6159 const T = struct {
6260 fn consume_tuple(tuple: anytype, len: usize) !void {
......@@ -326,8 +324,6 @@ test "tuple type with void field" {
326324}
327325
328326test "zero sized struct in tuple handled correctly" {
329 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
330
331327 const State = struct {
332328 const Self = @This();
333329 data: @Type(.{
......@@ -369,7 +365,6 @@ test "branching inside tuple literal" {
369365 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
370366 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
371367 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
372 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
373368
374369 const S = struct {
375370 fn foo(a: anytype) !void {
......@@ -474,7 +469,6 @@ test "coerce anon tuple to tuple" {
474469 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
475470 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
476471 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
477 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
478472
479473 var x: u8 = 1;
480474 var y: u16 = 2;
test/behavior/type.zig-1
......@@ -203,7 +203,6 @@ test "Type.Opaque" {
203203 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
204204 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
205205 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
206 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
207206
208207 const Opaque = @Type(.{
209208 .Opaque = .{
test/behavior/underscore.zig-1
......@@ -8,7 +8,6 @@ test "ignore lval with underscore" {
88
99test "ignore lval with underscore (while loop)" {
1010 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1211
1312 while (optionalReturnError()) |_| {
1413 while (optionalReturnError()) |_| {
test/behavior/union.zig-1
......@@ -418,7 +418,6 @@ test "tagged union initialization with runtime void" {
418418 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
419419 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
420420 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
421 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
422421
423422 try expect(testTaggedUnionInit({}));
424423}
test/behavior/var_args.zig-10
......@@ -14,8 +14,6 @@ fn add(args: anytype) i32 {
1414}
1515
1616test "add arbitrary args" {
17 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
18
1917 try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
2018 try expect(add(.{@as(i32, 1234)}) == 1234);
2119 try expect(add(.{}) == 0);
......@@ -26,15 +24,12 @@ fn readFirstVarArg(args: anytype) void {
2624}
2725
2826test "send void arg to var args" {
29 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
30
3127 readFirstVarArg(.{{}});
3228}
3329
3430test "pass args directly" {
3531 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
3632 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
37 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3833
3934 try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
4035 try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234);
......@@ -48,7 +43,6 @@ fn addSomeStuff(args: anytype) i32 {
4843test "runtime parameter before var args" {
4944 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
5045 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
5246
5347 try expect((try extraFn(10, .{})) == 0);
5448 try expect((try extraFn(10, .{false})) == 1);
......@@ -87,15 +81,11 @@ fn foo2(args: anytype) bool {
8781}
8882
8983test "array of var args functions" {
90 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
91
9284 try expect(foos[0](.{}));
9385 try expect(!foos[1](.{}));
9486}
9587
9688test "pass zero length array to var args param" {
97 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
98
9989 doNothingWithFirstArg(.{""});
10090}
10191
test/behavior/while.zig-3
......@@ -258,7 +258,6 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
258258
259259test "while on error union with else result follow else prong" {
260260 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
261 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
262261
263262 const result = while (returnError()) |value| {
264263 break value;
......@@ -268,7 +267,6 @@ test "while on error union with else result follow else prong" {
268267
269268test "while on error union with else result follow break prong" {
270269 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
271 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
272270
273271 const result = while (returnSuccess(10)) |value| {
274272 break value;
......@@ -315,7 +313,6 @@ test "while error 2 break statements and an else" {
315313 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
316314 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
317315 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
318 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
319316
320317 const S = struct {
321318 fn entry(opt_t: anyerror!bool, f: bool) !void {