diff --git a/lib/std/start.zig b/lib/std/start.zig
index 5fad443956..ff97e3c8ae 100644
--- a/lib/std/start.zig
+++ b/lib/std/start.zig
@@ -22,7 +22,8 @@ pub const simplified_logic =
     builtin.zig_backend == .stage2_arm or
     builtin.zig_backend == .stage2_sparc64 or
     builtin.cpu.arch == .spirv32 or
-    builtin.cpu.arch == .spirv64;
+    builtin.cpu.arch == .spirv64 or
+    builtin.zig_backend == .stage2_riscv64;
 
 comptime {
     // No matter what, we import the root file, so that any export, test, comptime
@@ -42,6 +43,10 @@ comptime {
             } else if (builtin.os.tag == .opencl) {
                 if (@hasDecl(root, "main"))
                     @export(spirvMain2, .{ .name = "main" });
+            } else if (native_arch.isRISCV()) {
+                if (!@hasDecl(root, "_start")) {
+                    @export(riscv_start, .{ .name = "_start" });
+                }
             } else {
                 if (!@hasDecl(root, "_start")) {
                     @export(_start2, .{ .name = "_start" });
@@ -60,10 +65,6 @@ comptime {
                 } else if (@typeInfo(@TypeOf(root.main)).Fn.calling_convention != .C) {
                     @export(main, .{ .name = "main" });
                 }
-            } else if (native_arch.isRISCV()) {
-                if (!@hasDecl(root, "_start")) {
-                    @export(riscv_start, .{ .name = "_start" });
-                }
             } else if (native_os == .windows) {
                 if (!@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup") and
                     !@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup"))
@@ -208,7 +209,20 @@ fn wasi_start() callconv(.C) void {
 }
 
 fn riscv_start() callconv(.C) noreturn {
-    std.process.exit(@call(.always_inline, callMain, .{}));
+    std.process.exit(switch (@typeInfo(@typeInfo(@TypeOf(root.main)).Fn.return_type.?)) {
+        .NoReturn => root.main(),
+        .Void => ret: {
+            root.main();
+            break :ret 0;
+        },
+        .Int => |info| ret: {
+            if (info.bits != 8 or info.signedness == .signed) {
+                @compileError(bad_main_ret);
+            }
+            break :ret root.main();
+        },
+        else => @compileError("expected return type of main to be 'void', 'noreturn', 'u8'"),
+    });
 }
 
 fn EfiMain(handle: uefi.Handle, system_table: *uefi.tables.SystemTable) callconv(.C) usize {
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index 662351f153..4e895ef3a7 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -22,7 +22,7 @@ pub var base_allocator_instance = std.heap.FixedBufferAllocator.init("");
 pub var log_level = std.log.Level.warn;
 
 // Disable printing in tests for simple backends.
-pub const backend_can_print = builtin.zig_backend != .stage2_spirv64 and builtin.zig_backend != .stage2_riscv64;
+pub const backend_can_print = !(builtin.zig_backend == .stage2_spirv64 or builtin.zig_backend == .stage2_riscv64);
 
 fn print(comptime fmt: []const u8, args: anytype) void {
     if (@inComptime()) {
diff --git a/src/arch/riscv64/CodeGen.zig b/src/arch/riscv64/CodeGen.zig
index 38d77c9c5f..ed177ed1f1 100644
--- a/src/arch/riscv64/CodeGen.zig
+++ b/src/arch/riscv64/CodeGen.zig
@@ -43,6 +43,8 @@ const callee_preserved_regs = abi.callee_preserved_regs;
 const gp = abi.RegisterClass.gp;
 /// Function Args
 const fa = abi.RegisterClass.fa;
+/// Function Returns
+const fr = abi.RegisterClass.fr;
 /// Temporary Use
 const tp = abi.RegisterClass.tp;
 
@@ -1083,8 +1085,8 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .mod             => try self.airMod(inst),
             .shl, .shl_exact => try self.airShl(inst),
             .shl_sat         => try self.airShlSat(inst),
-            .min             => try self.airMin(inst),
-            .max             => try self.airMax(inst),
+            .min             => try self.airMinMax(inst, .min),
+            .max             => try self.airMinMax(inst, .max),
             .slice           => try self.airSlice(inst),
 
             .sqrt,
@@ -1672,7 +1674,6 @@ fn airAlloc(self: *Self, inst: Air.Inst.Index) !void {
 
 fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
     const result: MCValue = switch (self.ret_mcv.long) {
-        else => unreachable,
         .none => .{ .lea_frame = .{ .index = try self.allocMemPtr(inst) } },
         .load_frame => .{ .register_offset = .{
             .reg = (try self.copyToNewRegister(
@@ -1681,6 +1682,7 @@ fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
             )).register,
             .off = self.ret_mcv.short.indirect.off,
         } },
+        else => |t| return self.fail("TODO: airRetPtr {s}", .{@tagName(t)}),
     };
     return self.finishAir(inst, result, .{ .none, .none, .none });
 }
@@ -1799,7 +1801,14 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
 }
 
-fn airMin(self: *Self, inst: Air.Inst.Index) !void {
+fn airMinMax(
+    self: *Self,
+    inst: Air.Inst.Index,
+    comptime tag: enum {
+        max,
+        min,
+    },
+) !void {
     const zcu = self.bin_file.comp.module.?;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
 
@@ -1882,7 +1891,7 @@ fn airMin(self: *Self, inst: Air.Inst.Index) !void {
             .ops = .rrr,
             .data = .{ .r_type = .{
                 .rd = result_reg,
-                .rs1 = rhs_reg,
+                .rs1 = if (tag == .min) rhs_reg else lhs_reg,
                 .rs2 = mask_reg,
             } },
         });
@@ -1892,12 +1901,6 @@ fn airMin(self: *Self, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
 }
 
-fn airMax(self: *Self, inst: Air.Inst.Index) !void {
-    const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
-    const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement max for {}", .{self.target.cpu.arch});
-    return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
-}
-
 fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
@@ -3577,10 +3580,10 @@ fn genCall(
                 const func_key = zcu.intern_pool.indexToKey(func_value.ip_index);
                 switch (switch (func_key) {
                     else => func_key,
-                    .ptr => |ptr| switch (ptr.addr) {
+                    .ptr => |ptr| if (ptr.byte_offset == 0) switch (ptr.base_addr) {
                         .decl => |decl| zcu.intern_pool.indexToKey(zcu.declPtr(decl).val.toIntern()),
                         else => func_key,
-                    },
+                    } else func_key,
                 }) {
                     .func => |func| {
                         if (self.bin_file.cast(link.File.Elf)) |elf_file| {
@@ -4174,8 +4177,7 @@ fn performReloc(self: *Self, inst: Mir.Inst.Index) void {
         .bne,
         .beq,
         => self.mir_instructions.items(.data)[inst].b_type.inst = target,
-        .jal,
-        => self.mir_instructions.items(.data)[inst].j_type.inst = target,
+        .jal => self.mir_instructions.items(.data)[inst].j_type.inst = target,
         .pseudo => switch (ops) {
             .pseudo_j => self.mir_instructions.items(.data)[inst].inst = target,
             else => std.debug.panic("TODO: performReloc {s}", .{@tagName(ops)}),
@@ -5021,13 +5023,36 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
 
 fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
     const zcu = self.bin_file.comp.module.?;
-    const vector_ty = self.typeOfIndex(inst);
-    const len = vector_ty.vectorLen(zcu);
+    const result_ty = self.typeOfIndex(inst);
+    const len: usize = @intCast(result_ty.arrayLen(zcu));
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
-    const result: MCValue = res: {
-        if (self.liveness.isUnused(inst)) break :res .unreach;
-        return self.fail("TODO implement airAggregateInit for riscv64", .{});
+    const result: MCValue = result: {
+        switch (result_ty.zigTypeTag(zcu)) {
+            .Struct => {
+                const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(result_ty, zcu));
+
+                if (result_ty.containerLayout(zcu) == .@"packed") {} else for (elements, 0..) |elem, elem_i| {
+                    if ((try result_ty.structFieldValueComptime(zcu, elem_i)) != null) continue;
+
+                    const elem_ty = result_ty.structFieldType(elem_i, zcu);
+                    const elem_off: i32 = @intCast(result_ty.structFieldOffset(elem_i, zcu));
+                    const elem_mcv = try self.resolveInst(elem);
+
+                    const elem_frame: FrameAddr = .{
+                        .index = frame_index,
+                        .off = elem_off,
+                    };
+                    try self.genSetStack(
+                        elem_ty,
+                        elem_frame,
+                        elem_mcv,
+                    );
+                }
+            },
+            else => return self.fail("TODO: airAggregateInit {}", .{result_ty.fmt(zcu)}),
+        }
+        break :result .{ .register = .zero };
     };
 
     if (elements.len <= Liveness.bpi - 1) {
@@ -5189,12 +5214,24 @@ fn resolveCallingConventionValues(
 
                 for (classes) |class| switch (class) {
                     .integer => {
-                        const ret_int_reg = abi.function_arg_regs[ret_int_reg_i];
+                        const ret_int_reg = abi.function_ret_regs[ret_int_reg_i];
                         ret_int_reg_i += 1;
 
                         ret_tracking[ret_tracking_i] = InstTracking.init(.{ .register = ret_int_reg });
                         ret_tracking_i += 1;
                     },
+                    .memory => {
+                        const ret_int_reg = abi.function_ret_regs[ret_int_reg_i];
+                        ret_int_reg_i += 1;
+                        const ret_indirect_reg = abi.function_arg_regs[param_int_reg_i];
+                        param_int_reg_i += 1;
+
+                        ret_tracking[ret_tracking_i] = .{
+                            .short = .{ .indirect = .{ .reg = ret_int_reg } },
+                            .long = .{ .indirect = .{ .reg = ret_indirect_reg } },
+                        };
+                        ret_tracking_i += 1;
+                    },
                     else => return self.fail("TODO: C calling convention return class {}", .{class}),
                 };
 
@@ -5226,6 +5263,13 @@ fn resolveCallingConventionValues(
                         arg_mcv[arg_mcv_i] = .{ .register = param_int_reg };
                         arg_mcv_i += 1;
                     },
+                    .memory => {
+                        const param_int_regs = abi.function_arg_regs;
+                        const param_int_reg = param_int_regs[param_int_reg_i];
+
+                        arg_mcv[arg_mcv_i] = .{ .indirect = .{ .reg = param_int_reg } };
+                        arg_mcv_i += 1;
+                    },
                     else => return self.fail("TODO: C calling convention arg class {}", .{class}),
                 } else {
                     arg.* = switch (arg_mcv_i) {
diff --git a/src/arch/riscv64/abi.zig b/src/arch/riscv64/abi.zig
index 5c5b0b0acd..35f5659685 100644
--- a/src/arch/riscv64/abi.zig
+++ b/src/arch/riscv64/abi.zig
@@ -96,7 +96,6 @@ pub fn classifyType(ty: Type, mod: *Module) Class {
 /// There are a maximum of 8 possible return slots. Returned values are in
 /// the beginning of the array; unused slots are filled with .none.
 pub fn classifySystem(ty: Type, zcu: *Module) [8]Class {
-    const ip = zcu.intern_pool;
     var result = [1]Class{.none} ** 8;
     const memory_class = [_]Class{
         .memory, .none, .none, .none,
@@ -158,22 +157,17 @@ pub fn classifySystem(ty: Type, zcu: *Module) [8]Class {
             std.debug.panic("TODO: classifySystem ErrorUnion > 64 bit payload", .{});
         },
         .Struct => {
-            const loaded_struct = ip.loadStructType(ty.toIntern());
+            const layout = ty.containerLayout(zcu);
             const ty_size = ty.abiSize(zcu);
 
-            if (loaded_struct.layout == .@"packed") {
+            if (layout == .@"packed") {
                 assert(ty_size <= 16);
                 result[0] = .integer;
                 if (ty_size > 8) result[1] = .integer;
                 return result;
             }
-            if (ty_size > 64)
-                return memory_class;
 
-            var byte_offset: u64 = 0;
-            classifyStruct(&result, &byte_offset, loaded_struct, zcu);
-
-            return result;
+            return memory_class;
         },
         else => |bad_ty| std.debug.panic("classifySystem {s}", .{@tagName(bad_ty)}),
     }
@@ -245,6 +239,10 @@ pub const function_arg_regs = [_]Register{
     .a0, .a1, .a2, .a3, .a4, .a5, .a6, .a7,
 };
 
+pub const function_ret_regs = [_]Register{
+    .a0, .a1,
+};
+
 pub const temporary_regs = [_]Register{
     .t0, .t1, .t2, .t3, .t4, .t5, .t6,
 };
@@ -273,6 +271,15 @@ pub const RegisterClass = struct {
         break :blk set;
     };
 
+    pub const fr: RegisterBitSet = blk: {
+        var set = RegisterBitSet.initEmpty();
+        set.setRangeValue(.{
+            .start = callee_preserved_regs.len,
+            .end = callee_preserved_regs.len + function_ret_regs.len,
+        }, true);
+        break :blk set;
+    };
+
     pub const tp: RegisterBitSet = blk: {
         var set = RegisterBitSet.initEmpty();
         set.setRangeValue(.{
diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index ace8fe7866..659733962b 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -388,7 +388,6 @@ test "function align expression depends on generic parameter" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     // function alignment is a compile error on wasm32/wasm64
     if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index ad955a8648..eabac35787 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -593,6 +593,7 @@ test "equality compare fn ptrs" {
 
 test "self reference through fn ptr field" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
         const A = struct {
diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index 28c797cef3..b6f7862bd0 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -541,6 +541,7 @@ test "@bitCast of packed struct containing pointer" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
         const A = packed struct {
@@ -570,6 +571,7 @@ test "@bitCast of extern struct containing pointer" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
         const A = extern struct {
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index 1113fcfeaa..46cf272e57 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -2713,7 +2713,6 @@ test "bitcast vector" {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const u8x32 = @Vector(32, u8);
     const u32x8 = @Vector(8, u32);
diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig
index 73b9ea60f2..502c44dc35 100644
--- a/test/behavior/comptime_memory.zig
+++ b/test/behavior/comptime_memory.zig
@@ -32,6 +32,8 @@ test "type pun signed and unsigned as array pointer" {
 }
 
 test "type pun signed and unsigned as offset many pointer" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     comptime {
         var x: [11]u32 = undefined;
         var y: [*]i32 = @ptrCast(&x[10]);
@@ -42,6 +44,8 @@ test "type pun signed and unsigned as offset many pointer" {
 }
 
 test "type pun signed and unsigned as array pointer with pointer arithemtic" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     comptime {
         var x: [11]u32 = undefined;
         const y = @as([*]i32, @ptrCast(&x[10])) - 10;
@@ -289,6 +293,8 @@ test "dance on linker values" {
 }
 
 test "offset array ptr by element size" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     comptime {
         const VirtualStruct = struct { x: u32 };
         var arr: [4]VirtualStruct = .{
@@ -418,8 +424,6 @@ test "dereference undefined pointer to zero-bit type" {
 }
 
 test "type pun extern struct" {
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
     const S = extern struct { f: u8 };
     comptime var s = S{ .f = 123 };
     @as(*u8, @ptrCast(&s)).* = 72;
diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig
index 8b5890e231..dd2d83a289 100644
--- a/test/behavior/enum.zig
+++ b/test/behavior/enum.zig
@@ -1246,8 +1246,6 @@ test "auto-numbered enum with signed tag type" {
 }
 
 test "lazy initialized field" {
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
     try std.testing.expectEqual(@as(u8, @alignOf(struct {})), getLazyInitialized(.a));
 }
 
diff --git a/test/behavior/error.zig b/test/behavior/error.zig
index 08f842d93b..d5e8308309 100644
--- a/test/behavior/error.zig
+++ b/test/behavior/error.zig
@@ -1102,6 +1102,7 @@ test "result location initialization of error union with OPV payload" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
         x: u0,
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index 75933944fd..c62e116a5f 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -1705,8 +1705,6 @@ test "early exit in container level const" {
 }
 
 test "@inComptime" {
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
     const S = struct {
         fn inComptime() bool {
             return @inComptime();
diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig
index b242d29d83..b6eafeefc1 100644
--- a/test/behavior/fn.zig
+++ b/test/behavior/fn.zig
@@ -191,6 +191,7 @@ test "function with complex callconv and return type expressions" {
 
 test "pass by non-copying value" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
 }
@@ -218,6 +219,7 @@ fn addPointCoordsVar(pt: anytype) !i32 {
 
 test "pass by non-copying value as method" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var pt = Point2{ .x = 1, .y = 2 };
     try expect(pt.addPointCoords() == 3);
@@ -234,6 +236,7 @@ const Point2 = struct {
 
 test "pass by non-copying value as method, which is generic" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var pt = Point3{ .x = 1, .y = 2 };
     try expect(pt.addPointCoords(i32) == 3);
@@ -624,8 +627,6 @@ test "comptime parameters don't have to be marked comptime if only called at com
 }
 
 test "inline function with comptime-known comptime-only return type called at runtime" {
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
     const S = struct {
         inline fn foo(x: *i32, y: *const i32) type {
             x.* = y.*;
diff --git a/test/behavior/fn_delegation.zig b/test/behavior/fn_delegation.zig
index 95dbfeb4b2..6a3d46c15d 100644
--- a/test/behavior/fn_delegation.zig
+++ b/test/behavior/fn_delegation.zig
@@ -34,6 +34,7 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
 test "fn delegation" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const foo = Foo{};
     try expect(foo.one() == 11);
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index 2c3dfaba01..7ed75f0ead 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -395,6 +395,7 @@ test "extern function used as generic parameter" {
 
 test "generic struct as parameter type" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(comptime Int: type, thing: struct { int: Int }) !void {
diff --git a/test/behavior/if.zig b/test/behavior/if.zig
index 61a5fc8f1b..8cb923dd43 100644
--- a/test/behavior/if.zig
+++ b/test/behavior/if.zig
@@ -179,8 +179,6 @@ fn returnTrue() bool {
 }
 
 test "if value shouldn't be load-elided if used later (structs)" {
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
     const Foo = struct { x: i32 };
 
     var a = Foo{ .x = 1 };
diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig
index 54973a8b3f..d08bc82828 100644
--- a/test/behavior/maximum_minimum.zig
+++ b/test/behavior/maximum_minimum.zig
@@ -160,8 +160,6 @@ test "@min/@max on lazy values" {
 }
 
 test "@min/@max more than two arguments" {
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
     const x: u32 = 30;
     const y: u32 = 10;
     const z: u32 = 20;
@@ -187,7 +185,6 @@ test "@min/@max notices bounds" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var x: u16 = 20;
     const y = 30;
@@ -239,7 +236,6 @@ test "@min/@max notices bounds from types" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     var x: u16 = 123;
     var y: u32 = 456;
@@ -325,8 +321,6 @@ test "@min/@max notices bounds from vector types when element of comptime-known
 }
 
 test "@min/@max of signed and unsigned runtime integers" {
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
     var x: i32 = -1;
     var y: u31 = 1;
     _ = .{ &x, &y };
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index c5fb888bc9..02c329a7d5 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -640,6 +640,7 @@ test "result location initialization of optional with OPV payload" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
         x: u0,
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index c13919d0f8..4870cd5984 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -124,7 +124,6 @@ test "correct sizeOf and offsets in packed structs" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const PStruct = packed struct {
         bool_a: bool,
@@ -193,7 +192,6 @@ test "nested packed structs" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S1 = packed struct { a: u8, b: u8, c: u8 };
 
diff --git a/test/behavior/packed-union.zig b/test/behavior/packed-union.zig
index d76f28ae59..5dd1641c5f 100644
--- a/test/behavior/packed-union.zig
+++ b/test/behavior/packed-union.zig
@@ -177,6 +177,8 @@ test "assigning to non-active field at comptime" {
 }
 
 test "comptime packed union of pointers" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     const U = packed union {
         a: *const u32,
         b: *const [1]u32,
diff --git a/test/behavior/packed_struct_explicit_backing_int.zig b/test/behavior/packed_struct_explicit_backing_int.zig
index 35762a1b14..29b8c4aa9b 100644
--- a/test/behavior/packed_struct_explicit_backing_int.zig
+++ b/test/behavior/packed_struct_explicit_backing_int.zig
@@ -10,7 +10,6 @@ test "packed struct explicit backing integer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S1 = packed struct { a: u8, b: u8, c: u8 };
 
diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig
index ffeeca3986..35c32041ff 100644
--- a/test/behavior/pointers.zig
+++ b/test/behavior/pointers.zig
@@ -640,6 +640,8 @@ test "cast pointers with zero sized elements" {
 }
 
 test "comptime pointer equality through distinct fields with well-defined layout" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     const A = extern struct {
         x: u32,
         z: u16,
@@ -664,6 +666,8 @@ test "comptime pointer equality through distinct fields with well-defined layout
 }
 
 test "comptime pointer equality through distinct elements with well-defined layout" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     const buf: [2]u32 = .{ 123, 456 };
 
     const ptr: *const [2]u32 = &buf;
diff --git a/test/behavior/ptrcast.zig b/test/behavior/ptrcast.zig
index fc8a8b7482..ddf842f2d4 100644
--- a/test/behavior/ptrcast.zig
+++ b/test/behavior/ptrcast.zig
@@ -298,6 +298,8 @@ test "comptime @ptrCast with packed struct leaves value unmodified" {
 }
 
 test "@ptrCast restructures comptime-only array" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     {
         const a3a2: [3][2]comptime_int = .{
             .{ 1, 2 },
@@ -340,6 +342,8 @@ test "@ptrCast restructures comptime-only array" {
 }
 
 test "@ptrCast restructures sliced comptime-only array" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     const a3a2: [4][2]comptime_int = .{
         .{ 1, 2 },
         .{ 3, 4 },
diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig
index 1be9ab1c3a..506baa2666 100644
--- a/test/behavior/sizeof_and_typeof.zig
+++ b/test/behavior/sizeof_and_typeof.zig
@@ -412,6 +412,7 @@ test "Extern function calls, dereferences and field access in @TypeOf" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const Test = struct {
         fn test_fn_1(a: c_long) @TypeOf(c_fopen("test", "r").*) {
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index d0509e308e..602be7e95e 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -176,6 +176,7 @@ const MemberFnTestFoo = struct {
 
 test "call member function directly" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const instance = MemberFnTestFoo{ .x = 1234 };
     const result = MemberFnTestFoo.member(instance);
@@ -184,6 +185,7 @@ test "call member function directly" {
 
 test "store member function in variable" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const instance = MemberFnTestFoo{ .x = 1234 };
     const memberFn = MemberFnTestFoo.member;
@@ -1559,6 +1561,7 @@ test "discarded struct initialization works as expected" {
 test "function pointer in struct returns the struct" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const A = struct {
         const A = @This();
@@ -1699,7 +1702,6 @@ test "struct field pointer has correct alignment" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1781,6 +1783,8 @@ fn countFields(v: anytype) usize {
 }
 
 test "struct init with no result pointer sets field result types" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     const S = struct {
         // A function parameter has a result type, but no result pointer.
         fn f(s: struct { x: u32 }) u32 {
@@ -1928,6 +1932,8 @@ test "circular dependency through pointer field of a struct" {
 }
 
 test "field calls do not force struct field init resolution" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     const S = struct {
         x: u32 = blk: {
             _ = @TypeOf(make().dummyFn()); // runtime field call - S not fully resolved - dummyFn call should not force field init resolution
@@ -1958,7 +1964,6 @@ test "extern struct fields are aligned to 1" {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const Foo = extern struct {
         a: u8 align(1),
@@ -2090,7 +2095,6 @@ test "struct field default value is a call" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const Z = packed struct {
         a: u32,
diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig
index 82e9dd02eb..736bbad806 100644
--- a/test/behavior/tuple.zig
+++ b/test/behavior/tuple.zig
@@ -451,7 +451,6 @@ test "tuple pointer is indexable" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct { u32, bool };
 
diff --git a/test/behavior/type.zig b/test/behavior/type.zig
index d3b8beb1c0..364460ff98 100644
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -203,6 +203,7 @@ test "Type.Opaque" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const Opaque = @Type(.{
         .Opaque = .{
@@ -348,7 +349,6 @@ test "Type.Struct" {
 test "Type.Enum" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const Foo = @Type(.{
         .Enum = .{
@@ -763,6 +763,8 @@ test "matching captures causes opaque equivalence" {
 }
 
 test "reify enum where fields refers to part of array" {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+
     const fields: [3]std.builtin.Type.EnumField = .{
         .{ .name = "foo", .value = 0 },
         .{ .name = "bar", .value = 1 },
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 8c9eacf7ce..6ea092e13d 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1622,7 +1622,6 @@ test "defined-layout union field pointer has correct alignment" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(comptime U: type) !void {
@@ -1658,7 +1657,6 @@ test "undefined-layout union field pointer has correct alignment" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest(comptime U: type) !void {
@@ -1694,7 +1692,6 @@ test "packed union field pointer has correct alignment" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const U = packed union { x: u20 };
     const S = packed struct(u24) { a: u2, u: U, b: u2 };