Commit 86d8688c7f14d30c66b2cb4b55826ab15b39ad55 | zig

author	Jakub Konka <kubkon@jakubkonka.com> 2024-05-11 21:35:18+02:00
committer	GitHub <noreply@github.com> 2024-05-11 21:35:18+02:00
log	86d8688c7f14d30c66b2cb4b55826ab15b39ad55
tree	fb6e98b216a383cab98ceeb5931564401eb9dd60
parent	661a9be66bdee78530e5a6fbb6463297a405beee
parent	75372f12ef1301118eed33e429f7498e76836cb3
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #19431 from Rexicon226/revive-riscv

revive STAGE2 RISCV64 backend

135 files changed, 6570 insertions(+), 1660 deletions(-)

lib
- compiler
  - test_runner.zig
- std
src
- Sema.zig
- arch
  - riscv64
    CodeGen.zig
    Emit.zig
    Encoding.zig
    Lower.zig
    Mir.zig
    abi.zig
    bits.zig
    encoder.zig
- codegen
  - llvm.zig
- link
  - Elf.zig
  - Elf
    Atom.zig
  - riscv.zig
- register_manager.zig
- target.zig
test

lib/compiler/test_runner.zig+18

...	@@ -12,6 +12,8 @@ var cmdline_buffer: [4096]u8 = undefined;	...	@@ -12,6 +12,8 @@ var cmdline_buffer: [4096]u8 = undefined;
12	var fba = std.heap.FixedBufferAllocator.init(&cmdline_buffer);	12	var fba = std.heap.FixedBufferAllocator.init(&cmdline_buffer);
13		13
14	pub fn main() void {	14	pub fn main() void {
		15	if (builtin.zig_backend == .stage2_riscv64) return mainExtraSimple() catch @panic("test failure");
		16
15	if (builtin.zig_backend == .stage2_aarch64) {	17	if (builtin.zig_backend == .stage2_aarch64) {
16	return mainSimple() catch @panic("test failure");	18	return mainSimple() catch @panic("test failure");
17	}	19	}
...	@@ -247,3 +249,19 @@ pub fn mainSimple() anyerror!void {	...	@@ -247,3 +249,19 @@ pub fn mainSimple() anyerror!void {
247	if (failed != 0) std.process.exit(1);	249	if (failed != 0) std.process.exit(1);
248	}	250	}
249	}	251	}
		252
		253	pub fn mainExtraSimple() !void {
		254	var fail_count: u8 = 0;
		255
		256	for (builtin.test_functions) \|test_fn\| {
		257	test_fn.func() catch \|err\| {
		258	if (err != error.SkipZigTest) {
		259	fail_count += 1;
		260	continue;
		261	}
		262	continue;
		263	};
		264	}
		265
		266	if (fail_count != 0) std.process.exit(1);
		267	}

lib/std/builtin.zig+13-1

...	@@ -766,7 +766,6 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr	...	@@ -766,7 +766,6 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr
766	builtin.zig_backend == .stage2_aarch64 or	766	builtin.zig_backend == .stage2_aarch64 or
767	builtin.zig_backend == .stage2_x86 or	767	builtin.zig_backend == .stage2_x86 or
768	(builtin.zig_backend == .stage2_x86_64 and (builtin.target.ofmt != .elf and builtin.target.ofmt != .macho)) or	768	(builtin.zig_backend == .stage2_x86_64 and (builtin.target.ofmt != .elf and builtin.target.ofmt != .macho)) or
769	builtin.zig_backend == .stage2_riscv64 or
770	builtin.zig_backend == .stage2_sparc64 or	769	builtin.zig_backend == .stage2_sparc64 or
771	builtin.zig_backend == .stage2_spirv64)	770	builtin.zig_backend == .stage2_spirv64)
772	{	771	{
...	@@ -774,6 +773,19 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr	...	@@ -774,6 +773,19 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr
774	@breakpoint();	773	@breakpoint();
775	}	774	}
776	}	775	}
		776
		777	if (builtin.zig_backend == .stage2_riscv64) {
		778	asm volatile ("ecall"
		779	:
		780	: [number] "{a7}" (64),
		781	[arg1] "{a0}" (1),
		782	[arg2] "{a1}" (@intFromPtr(msg.ptr)),
		783	[arg3] "{a2}" (msg.len),
		784	: "memory"
		785	);
		786	std.posix.exit(127);
		787	}
		788
777	switch (builtin.os.tag) {	789	switch (builtin.os.tag) {
778	.freestanding => {	790	.freestanding => {
779	while (true) {	791	while (true) {

lib/std/dwarf.zig+1-9

...	@@ -1236,15 +1236,7 @@ pub const DwarfInfo = struct {	...	@@ -1236,15 +1236,7 @@ pub const DwarfInfo = struct {
1236		1236
1237	const opcode_base = try fbr.readByte();	1237	const opcode_base = try fbr.readByte();
1238		1238
1239	const standard_opcode_lengths = try allocator.alloc(u8, opcode_base - 1);	1239	const standard_opcode_lengths = try fbr.readBytes(opcode_base - 1);
1240	defer allocator.free(standard_opcode_lengths);
1241
1242	{
1243	var i: usize = 0;
1244	while (i < opcode_base - 1) : (i += 1) {
1245	standard_opcode_lengths[i] = try fbr.readByte();
1246	}
1247	}
1248		1240
1249	var include_directories = std.ArrayList(FileEntry).init(allocator);	1241	var include_directories = std.ArrayList(FileEntry).init(allocator);
1250	defer include_directories.deinit();	1242	defer include_directories.deinit();

lib/std/mem.zig+2

...	@@ -638,6 +638,8 @@ test lessThan {	...	@@ -638,6 +638,8 @@ test lessThan {
638	const backend_can_use_eql_bytes = switch (builtin.zig_backend) {	638	const backend_can_use_eql_bytes = switch (builtin.zig_backend) {
639	// The SPIR-V backend does not support the optimized path yet.	639	// The SPIR-V backend does not support the optimized path yet.
640	.stage2_spirv64 => false,	640	.stage2_spirv64 => false,
		641	// The RISC-V does not support vectors.
		642	.stage2_riscv64 => false,
641	else => true,	643	else => true,
642	};	644	};
643		645

lib/std/start.zig+23-10

 @@ -20,10 +20,10 @@ pub const simplified_logic =
     builtin.zig_backend == .stage2_x86 or
     builtin.zig_backend == .stage2_aarch64 or
     builtin.zig_backend == .stage2_arm or
-    builtin.zig_backend == .stage2_riscv64 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
 @@ -43,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" });
 @@ -151,14 +155,6 @@ fn exit2(code: usize) noreturn {
                     : "memory", "cc"
                 );
             },
-            .riscv64 => {
-                asm volatile ("ecall"
-                    :
-                    : [number] "{a7}" (94),
-                      [arg1] "{a0}" (0),
-                    : "rcx", "r11", "memory"
-                );
-            },
             .sparc64 => {
                 asm volatile ("ta 0x6d"
                     :
 @@ -212,6 +208,23 @@ fn wasi_start() callconv(.C) void {
     }
 }
+fn riscv_start() callconv(.C) noreturn {
+    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 {
     uefi.handle = handle;
     uefi.system_table = system_table;

lib/std/testing.zig+1-1

...	@@ -22,7 +22,7 @@ pub var base_allocator_instance = std.heap.FixedBufferAllocator.init("");	...	@@ -22,7 +22,7 @@ pub var base_allocator_instance = std.heap.FixedBufferAllocator.init("");
22	pub var log_level = std.log.Level.warn;	22	pub var log_level = std.log.Level.warn;
23		23
24	// Disable printing in tests for simple backends.	24	// Disable printing in tests for simple backends.
25	pub const backend_can_print = builtin.zig_backend != .stage2_spirv64;	25	pub const backend_can_print = !(builtin.zig_backend == .stage2_spirv64 or builtin.zig_backend == .stage2_riscv64);
26		26
27	fn print(comptime fmt: []const u8, args: anytype) void {	27	fn print(comptime fmt: []const u8, args: anytype) void {
28	if (@inComptime()) {	28	if (@inComptime()) {

src/Sema.zig+4-3

src/arch/riscv64/CodeGen.zig+3584-963

...	@@ -11,6 +11,7 @@ const Type = @import("../../type.zig").Type;	...	@@ -11,6 +11,7 @@ const Type = @import("../../type.zig").Type;
11	const Value = @import("../../Value.zig");	11	const Value = @import("../../Value.zig");
12	const link = @import("../../link.zig");	12	const link = @import("../../link.zig");
13	const Module = @import("../../Module.zig");	13	const Module = @import("../../Module.zig");
		14	const Package = @import("../../Package.zig");
14	const InternPool = @import("../../InternPool.zig");	15	const InternPool = @import("../../InternPool.zig");
15	const Compilation = @import("../../Compilation.zig");	16	const Compilation = @import("../../Compilation.zig");
16	const ErrorMsg = Module.ErrorMsg;	17	const ErrorMsg = Module.ErrorMsg;
...	@@ -19,7 +20,8 @@ const Allocator = mem.Allocator;	...	@@ -19,7 +20,8 @@ const Allocator = mem.Allocator;
19	const trace = @import("../../tracy.zig").trace;	20	const trace = @import("../../tracy.zig").trace;
20	const DW = std.dwarf;	21	const DW = std.dwarf;
21	const leb128 = std.leb;	22	const leb128 = std.leb;
22	const log = std.log.scoped(.codegen);	23	const log = std.log.scoped(.riscv_codegen);
		24	const tracking_log = std.log.scoped(.tracking);
23	const build_options = @import("build_options");	25	const build_options = @import("build_options");
24	const codegen = @import("../../codegen.zig");	26	const codegen = @import("../../codegen.zig");
25	const Alignment = InternPool.Alignment;	27	const Alignment = InternPool.Alignment;
...	@@ -31,16 +33,31 @@ const DebugInfoOutput = codegen.DebugInfoOutput;	...	@@ -31,16 +33,31 @@ const DebugInfoOutput = codegen.DebugInfoOutput;
31	const bits = @import("bits.zig");	33	const bits = @import("bits.zig");
32	const abi = @import("abi.zig");	34	const abi = @import("abi.zig");
33	const Register = bits.Register;	35	const Register = bits.Register;
		36	const Immediate = bits.Immediate;
		37	const Memory = bits.Memory;
		38	const FrameIndex = bits.FrameIndex;
34	const RegisterManager = abi.RegisterManager;	39	const RegisterManager = abi.RegisterManager;
35	const RegisterLock = RegisterManager.RegisterLock;	40	const RegisterLock = RegisterManager.RegisterLock;
36	const Instruction = abi.Instruction;
37	const callee_preserved_regs = abi.callee_preserved_regs;	41	const callee_preserved_regs = abi.callee_preserved_regs;
		42	/// General Purpose
38	const gp = abi.RegisterClass.gp;	43	const gp = abi.RegisterClass.gp;
		44	/// Function Args
		45	const fa = abi.RegisterClass.fa;
		46	/// Function Returns
		47	const fr = abi.RegisterClass.fr;
		48	/// Temporary Use
		49	const tp = abi.RegisterClass.tp;
39		50
40	const InnerError = CodeGenError \|\| error{OutOfRegisters};	51	const InnerError = CodeGenError \|\| error{OutOfRegisters};
41		52
		53	const RegisterView = enum(u1) {
		54	caller,
		55	callee,
		56	};
		57
42	gpa: Allocator,	58	gpa: Allocator,
43	air: Air,	59	air: Air,
		60	mod: *Package.Module,
44	liveness: Liveness,	61	liveness: Liveness,
45	bin_file: *link.File,	62	bin_file: *link.File,
46	target: *const std.Target,	63	target: *const std.Target,
...	@@ -49,11 +66,10 @@ code: *std.ArrayList(u8),	...	@@ -49,11 +66,10 @@ code: *std.ArrayList(u8),
49	debug_output: DebugInfoOutput,	66	debug_output: DebugInfoOutput,
50	err_msg: ?*ErrorMsg,	67	err_msg: ?*ErrorMsg,
51	args: []MCValue,	68	args: []MCValue,
52	ret_mcv: MCValue,	69	ret_mcv: InstTracking,
53	fn_type: Type,	70	fn_type: Type,
54	arg_index: usize,	71	arg_index: usize,
55	src_loc: Module.SrcLoc,	72	src_loc: Module.SrcLoc,
56	stack_align: Alignment,
57		73
58	/// MIR Instructions	74	/// MIR Instructions
59	mir_instructions: std.MultiArrayList(Mir.Inst) = .{},	75	mir_instructions: std.MultiArrayList(Mir.Inst) = .{},
...	@@ -64,6 +80,8 @@ mir_extra: std.ArrayListUnmanaged(u32) = .{},	...	@@ -64,6 +80,8 @@ mir_extra: std.ArrayListUnmanaged(u32) = .{},
64	end_di_line: u32,	80	end_di_line: u32,
65	end_di_column: u32,	81	end_di_column: u32,
66		82
		83	scope_generation: u32,
		84
67	/// The value is an offset into the `Function` `code` from the beginning.	85	/// The value is an offset into the `Function` `code` from the beginning.
68	/// To perform the reloc, write 32-bit signed little-endian integer	86	/// To perform the reloc, write 32-bit signed little-endian integer
69	/// which is a relative jump, based on the address following the reloc.	87	/// which is a relative jump, based on the address following the reloc.
...	@@ -80,22 +98,24 @@ branch_stack: *std.ArrayList(Branch),	...	@@ -80,22 +98,24 @@ branch_stack: *std.ArrayList(Branch),
80		98
81	// Key is the block instruction	99	// Key is the block instruction
82	blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, BlockData) = .{},	100	blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, BlockData) = .{},
83
84	register_manager: RegisterManager = .{},	101	register_manager: RegisterManager = .{},
85	/// Maps offset to what is stored there.
86	stack: std.AutoHashMapUnmanaged(u32, StackAllocation) = .{},
87		102
88	/// Offset from the stack base, representing the end of the stack frame.	103	const_tracking: ConstTrackingMap = .{},
89	max_end_stack: u32 = 0,	104	inst_tracking: InstTrackingMap = .{},
90	/// Represents the current end stack offset. If there is no existing slot	105
91	/// to place a new stack allocation, it goes here, and then bumps `max_end_stack`.	106	frame_allocs: std.MultiArrayList(FrameAlloc) = .{},
92	next_stack_offset: u32 = 0,	107	free_frame_indices: std.AutoArrayHashMapUnmanaged(FrameIndex, void) = .{},
		108	frame_locs: std.MultiArrayList(Mir.FrameLoc) = .{},
93		109
94	/// Debug field, used to find bugs in the compiler.	110	/// Debug field, used to find bugs in the compiler.
95	air_bookkeeping: @TypeOf(air_bookkeeping_init) = air_bookkeeping_init,	111	air_bookkeeping: @TypeOf(air_bookkeeping_init) = air_bookkeeping_init,
96		112
97	const air_bookkeeping_init = if (std.debug.runtime_safety) @as(usize, 0) else {};	113	const air_bookkeeping_init = if (std.debug.runtime_safety) @as(usize, 0) else {};
98		114
		115	const SymbolOffset = struct { sym: u32, off: i32 = 0 };
		116	const RegisterOffset = struct { reg: Register, off: i32 = 0 };
		117	pub const FrameAddr = struct { index: FrameIndex, off: i32 = 0 };
		118
99	const MCValue = union(enum) {	119	const MCValue = union(enum) {
100	/// No runtime bits. `void` types, empty structs, u0, enums with 1 tag, etc.	120	/// No runtime bits. `void` types, empty structs, u0, enums with 1 tag, etc.
101	/// TODO Look into deleting this tag and using `dead` instead, since every use	121	/// TODO Look into deleting this tag and using `dead` instead, since every use
...	@@ -104,26 +124,43 @@ const MCValue = union(enum) {	...	@@ -104,26 +124,43 @@ const MCValue = union(enum) {
104	/// Control flow will not allow this value to be observed.	124	/// Control flow will not allow this value to be observed.
105	unreach,	125	unreach,
106	/// No more references to this value remain.	126	/// No more references to this value remain.
107	dead,	127	/// The payload is the value of scope_generation at the point where the death occurred
		128	dead: u32,
108	/// The value is undefined.	129	/// The value is undefined.
109	undef,	130	undef,
110	/// A pointer-sized integer that fits in a register.	131	/// A pointer-sized integer that fits in a register.
111	/// If the type is a pointer, this is the pointer address in virtual address space.	132	/// If the type is a pointer, this is the pointer address in virtual address space.
112	immediate: u64,	133	immediate: u64,
		134	/// The value doesn't exist in memory yet.
		135	load_symbol: SymbolOffset,
		136	/// The address of the memory location not-yet-allocated by the linker.
		137	lea_symbol: SymbolOffset,
113	/// The value is in a target-specific register.	138	/// The value is in a target-specific register.
114	register: Register,	139	register: Register,
		140	/// The value is split across two registers
		141	register_pair: [2]Register,
115	/// The value is in memory at a hard-coded address.	142	/// The value is in memory at a hard-coded address.
116	/// If the type is a pointer, it means the pointer address is at this memory location.	143	/// If the type is a pointer, it means the pointer address is at this memory location.
117	memory: u64,	144	memory: u64,
118	/// The value is one of the stack variables.	145	/// The value stored at an offset from a frame index
119	/// If the type is a pointer, it means the pointer address is in the stack at this offset.	146	/// Payload is a frame address.
120	stack_offset: u32,	147	load_frame: FrameAddr,
121	/// The value is a pointer to one of the stack variables (payload is stack offset).	148	/// The address of an offset from a frame index
122	ptr_stack_offset: u32,	149	/// Payload is a frame address.
		150	lea_frame: FrameAddr,
		151	air_ref: Air.Inst.Ref,
		152	/// The value is in memory at a constant offset from the address in a register.
		153	indirect: RegisterOffset,
		154	/// The value is a constant offset from the value in a register.
		155	register_offset: RegisterOffset,
		156	/// This indicates that we have already allocated a frame index for this instruction,
		157	/// but it has not been spilled there yet in the current control flow.
		158	/// Payload is a frame index.
		159	reserved_frame: FrameIndex,
123		160
124	fn isMemory(mcv: MCValue) bool {	161	fn isMemory(mcv: MCValue) bool {
125	return switch (mcv) {	162	return switch (mcv) {
126	.memory, .stack_offset => true,	163	.memory, .indirect, .load_frame => true,
127	else => false,	164	else => false,
128	};	165	};
129	}	166	}
...	@@ -143,15 +180,116 @@ const MCValue = union(enum) {	...	@@ -143,15 +180,116 @@ const MCValue = union(enum) {
143		180
144	.immediate,	181	.immediate,
145	.memory,	182	.memory,
146	.ptr_stack_offset,	183	.lea_frame,
147	.undef,	184	.undef,
		185	.lea_symbol,
		186	.air_ref,
		187	.reserved_frame,
148	=> false,	188	=> false,
149		189
150	.register,	190	.register,
151	.stack_offset,	191	.register_pair,
		192	.register_offset,
		193	.load_frame,
		194	.load_symbol,
		195	.indirect,
152	=> true,	196	=> true,
153	};	197	};
154	}	198	}
		199
		200	fn address(mcv: MCValue) MCValue {
		201	return switch (mcv) {
		202	.none,
		203	.unreach,
		204	.dead,
		205	.immediate,
		206	.lea_frame,
		207	.register_offset,
		208	.register_pair,
		209	.register,
		210	.undef,
		211	.air_ref,
		212	.lea_symbol,
		213	.reserved_frame,
		214	=> unreachable, // not in memory
		215
		216	.load_symbol => \|sym_off\| .{ .lea_symbol = sym_off },
		217	.memory => \|addr\| .{ .immediate = addr },
		218	.load_frame => \|off\| .{ .lea_frame = off },
		219	.indirect => \|reg_off\| switch (reg_off.off) {
		220	0 => .{ .register = reg_off.reg },
		221	else => .{ .register_offset = reg_off },
		222	},
		223	};
		224	}
		225
		226	fn deref(mcv: MCValue) MCValue {
		227	return switch (mcv) {
		228	.none,
		229	.unreach,
		230	.dead,
		231	.memory,
		232	.indirect,
		233	.undef,
		234	.air_ref,
		235	.load_frame,
		236	.register_pair,
		237	.load_symbol,
		238	.reserved_frame,
		239	=> unreachable, // not a pointer
		240
		241	.immediate => \|addr\| .{ .memory = addr },
		242	.lea_frame => \|off\| .{ .load_frame = off },
		243	.register => \|reg\| .{ .indirect = .{ .reg = reg } },
		244	.register_offset => \|reg_off\| .{ .indirect = reg_off },
		245	.lea_symbol => \|sym_off\| .{ .load_symbol = sym_off },
		246	};
		247	}
		248
		249	fn offset(mcv: MCValue, off: i32) MCValue {
		250	return switch (mcv) {
		251	.none,
		252	.unreach,
		253	.dead,
		254	.undef,
		255	.air_ref,
		256	.reserved_frame,
		257	=> unreachable, // not valid
		258	.register_pair,
		259	.memory,
		260	.indirect,
		261	.load_frame,
		262	.load_symbol,
		263	.lea_symbol,
		264	=> switch (off) {
		265	0 => mcv,
		266	else => unreachable, // not offsettable
		267	},
		268	.immediate => \|imm\| .{ .immediate = @bitCast(@as(i64, @bitCast(imm)) +% off) },
		269	.register => \|reg\| .{ .register_offset = .{ .reg = reg, .off = off } },
		270	.register_offset => \|reg_off\| .{ .register_offset = .{ .reg = reg_off.reg, .off = reg_off.off + off } },
		271	.lea_frame => \|frame_addr\| .{
		272	.lea_frame = .{ .index = frame_addr.index, .off = frame_addr.off + off },
		273	},
		274	};
		275	}
		276
		277	fn getReg(mcv: MCValue) ?Register {
		278	return switch (mcv) {
		279	.register => \|reg\| reg,
		280	.register_offset, .indirect => \|ro\| ro.reg,
		281	else => null,
		282	};
		283	}
		284
		285	fn getRegs(mcv: *const MCValue) []const Register {
		286	return switch (mcv.*) {
		287	.register => \|reg\| @as(const [1]Register, reg),
		288	.register_pair => \|*regs\| regs,
		289	.register_offset, .indirect => \|ro\| @as(const [1]Register, &ro.reg),
		290	else => &.{},
		291	};
		292	}
155	};	293	};
156		294
157	const Branch = struct {	295	const Branch = struct {
...	@@ -163,60 +301,403 @@ const Branch = struct {	...	@@ -163,60 +301,403 @@ const Branch = struct {
163	}	301	}
164	};	302	};
165		303
		304	const InstTrackingMap = std.AutoArrayHashMapUnmanaged(Air.Inst.Index, InstTracking);
		305	const ConstTrackingMap = std.AutoArrayHashMapUnmanaged(InternPool.Index, InstTracking);
		306	const InstTracking = struct {
		307	long: MCValue,
		308	short: MCValue,
		309
		310	fn init(result: MCValue) InstTracking {
		311	return .{ .long = switch (result) {
		312	.none,
		313	.unreach,
		314	.undef,
		315	.immediate,
		316	.memory,
		317	.load_frame,
		318	.lea_frame,
		319	.load_symbol,
		320	.lea_symbol,
		321	=> result,
		322	.dead,
		323	.reserved_frame,
		324	.air_ref,
		325	=> unreachable,
		326	.register,
		327	.register_pair,
		328	.register_offset,
		329	.indirect,
		330	=> .none,
		331	}, .short = result };
		332	}
		333
		334	fn getReg(self: InstTracking) ?Register {
		335	return self.short.getReg();
		336	}
		337
		338	fn getRegs(self: *const InstTracking) []const Register {
		339	return self.short.getRegs();
		340	}
		341
		342	fn spill(self: InstTracking, function: Self, inst: Air.Inst.Index) !void {
		343	if (std.meta.eql(self.long, self.short)) return; // Already spilled
		344	// Allocate or reuse frame index
		345	switch (self.long) {
		346	.none => self.long = try function.allocRegOrMem(inst, false),
		347	.load_frame => {},
		348	.reserved_frame => \|index\| self.long = .{ .load_frame = .{ .index = index } },
		349	else => unreachable,
		350	}
		351	tracking_log.debug("spill %{d} from {} to {}", .{ inst, self.short, self.long });
		352	try function.genCopy(function.typeOfIndex(inst), self.long, self.short);
		353	}
		354
		355	fn reuseFrame(self: *InstTracking) void {
		356	switch (self.long) {
		357	.reserved_frame => \|index\| self.long = .{ .load_frame = .{ .index = index } },
		358	else => {},
		359	}
		360	self.short = switch (self.long) {
		361	.none,
		362	.unreach,
		363	.undef,
		364	.immediate,
		365	.memory,
		366	.load_frame,
		367	.lea_frame,
		368	.load_symbol,
		369	.lea_symbol,
		370	=> self.long,
		371	.dead,
		372	.register,
		373	.register_pair,
		374	.register_offset,
		375	.indirect,
		376	.reserved_frame,
		377	.air_ref,
		378	=> unreachable,
		379	};
		380	}
		381
		382	fn trackSpill(self: InstTracking, function: Self, inst: Air.Inst.Index) !void {
		383	try function.freeValue(self.short);
		384	self.reuseFrame();
		385	tracking_log.debug("%{d} => {} (spilled)", .{ inst, self.* });
		386	}
		387
		388	fn verifyMaterialize(self: InstTracking, target: InstTracking) void {
		389	switch (self.long) {
		390	.none,
		391	.unreach,
		392	.undef,
		393	.immediate,
		394	.memory,
		395	.lea_frame,
		396	.load_symbol,
		397	.lea_symbol,
		398	=> assert(std.meta.eql(self.long, target.long)),
		399	.load_frame,
		400	.reserved_frame,
		401	=> switch (target.long) {
		402	.none,
		403	.load_frame,
		404	.reserved_frame,
		405	=> {},
		406	else => unreachable,
		407	},
		408	.dead,
		409	.register,
		410	.register_pair,
		411	.register_offset,
		412	.indirect,
		413	.air_ref,
		414	=> unreachable,
		415	}
		416	}
		417
		418	fn materialize(
		419	self: *InstTracking,
		420	function: *Self,
		421	inst: Air.Inst.Index,
		422	target: InstTracking,
		423	) !void {
		424	self.verifyMaterialize(target);
		425	try self.materializeUnsafe(function, inst, target);
		426	}
		427
		428	fn materializeUnsafe(
		429	self: InstTracking,
		430	function: *Self,
		431	inst: Air.Inst.Index,
		432	target: InstTracking,
		433	) !void {
		434	const ty = function.typeOfIndex(inst);
		435	if ((self.long == .none or self.long == .reserved_frame) and target.long == .load_frame)
		436	try function.genCopy(ty, target.long, self.short);
		437	try function.genCopy(ty, target.short, self.short);
		438	}
		439
		440	fn trackMaterialize(self: *InstTracking, inst: Air.Inst.Index, target: InstTracking) void {
		441	self.verifyMaterialize(target);
		442	// Don't clobber reserved frame indices
		443	self.long = if (target.long == .none) switch (self.long) {
		444	.load_frame => \|addr\| .{ .reserved_frame = addr.index },
		445	.reserved_frame => self.long,
		446	else => target.long,
		447	} else target.long;
		448	self.short = target.short;
		449	tracking_log.debug("%{d} => {} (materialize)", .{ inst, self.* });
		450	}
		451
		452	fn resurrect(self: *InstTracking, inst: Air.Inst.Index, scope_generation: u32) void {
		453	switch (self.short) {
		454	.dead => \|die_generation\| if (die_generation >= scope_generation) {
		455	self.reuseFrame();
		456	tracking_log.debug("%{d} => {} (resurrect)", .{ inst, self.* });
		457	},
		458	else => {},
		459	}
		460	}
		461
		462	fn die(self: InstTracking, function: Self, inst: Air.Inst.Index) !void {
		463	if (self.short == .dead) return;
		464	try function.freeValue(self.short);
		465	self.short = .{ .dead = function.scope_generation };
		466	tracking_log.debug("%{d} => {} (death)", .{ inst, self.* });
		467	}
		468
		469	fn reuse(
		470	self: *InstTracking,
		471	function: *Self,
		472	new_inst: ?Air.Inst.Index,
		473	old_inst: Air.Inst.Index,
		474	) void {
		475	self.short = .{ .dead = function.scope_generation };
		476	if (new_inst) \|inst\|
		477	tracking_log.debug("%{d} => {} (reuse %{d})", .{ inst, self.*, old_inst })
		478	else
		479	tracking_log.debug("tmp => {} (reuse %{d})", .{ self.*, old_inst });
		480	}
		481
		482	fn liveOut(self: InstTracking, function: Self, inst: Air.Inst.Index) void {
		483	for (self.getRegs()) \|reg\| {
		484	if (function.register_manager.isRegFree(reg)) {
		485	tracking_log.debug("%{d} => {} (live-out)", .{ inst, self.* });
		486	continue;
		487	}
		488
		489	const index = RegisterManager.indexOfRegIntoTracked(reg).?;
		490	const tracked_inst = function.register_manager.registers[index];
		491	const tracking = function.getResolvedInstValue(tracked_inst);
		492
		493	// Disable death.
		494	var found_reg = false;
		495	var remaining_reg: Register = .zero;
		496	for (tracking.getRegs()) \|tracked_reg\| if (tracked_reg.id() == reg.id()) {
		497	assert(!found_reg);
		498	found_reg = true;
		499	} else {
		500	assert(remaining_reg == .zero);
		501	remaining_reg = tracked_reg;
		502	};
		503	assert(found_reg);
		504	tracking.short = switch (remaining_reg) {
		505	.zero => .{ .dead = function.scope_generation },
		506	else => .{ .register = remaining_reg },
		507	};
		508
		509	// Perform side-effects of freeValue manually.
		510	function.register_manager.freeReg(reg);
		511
		512	tracking_log.debug("%{d} => {} (live-out %{d})", .{ inst, self.*, tracked_inst });
		513	}
		514	}
		515
		516	pub fn format(
		517	self: InstTracking,
		518	comptime _: []const u8,
		519	_: std.fmt.FormatOptions,
		520	writer: anytype,
		521	) @TypeOf(writer).Error!void {
		522	if (!std.meta.eql(self.long, self.short)) try writer.print("\|{}\| ", .{self.long});
		523	try writer.print("{}", .{self.short});
		524	}
		525	};
		526
		527	const FrameAlloc = struct {
		528	abi_size: u31,
		529	spill_pad: u3,
		530	abi_align: Alignment,
		531	ref_count: u16,
		532
		533	fn init(alloc_abi: struct { size: u64, pad: u3 = 0, alignment: Alignment }) FrameAlloc {
		534	return .{
		535	.abi_size = @intCast(alloc_abi.size),
		536	.spill_pad = alloc_abi.pad,
		537	.abi_align = alloc_abi.alignment,
		538	.ref_count = 0,
		539	};
		540	}
		541	fn initType(ty: Type, zcu: *Module) FrameAlloc {
		542	return init(.{
		543	.size = ty.abiSize(zcu),
		544	.alignment = ty.abiAlignment(zcu),
		545	});
		546	}
		547	fn initSpill(ty: Type, zcu: *Module) FrameAlloc {
		548	const abi_size = ty.abiSize(zcu);
		549	const spill_size = if (abi_size < 8)
		550	math.ceilPowerOfTwoAssert(u64, abi_size)
		551	else
		552	std.mem.alignForward(u64, abi_size, 8);
		553	return init(.{
		554	.size = spill_size,
		555	.pad = @intCast(spill_size - abi_size),
		556	.alignment = ty.abiAlignment(zcu).maxStrict(
		557	Alignment.fromNonzeroByteUnits(@min(spill_size, 8)),
		558	),
		559	});
		560	}
		561	};
		562
166	const StackAllocation = struct {	563	const StackAllocation = struct {
167	inst: Air.Inst.Index,	564	inst: ?Air.Inst.Index,
168	/// TODO do we need size? should be determined by inst.ty.abiSize()	565	/// TODO: make the size inferred from the bits of the inst
169	size: u32,	566	size: u32,
170	};	567	};
171		568
172	const BlockData = struct {	569	const BlockData = struct {
173	relocs: std.ArrayListUnmanaged(Reloc),	570	relocs: std.ArrayListUnmanaged(Mir.Inst.Index) = .{},
174	/// The first break instruction encounters `null` here and chooses a	571	state: State,
175	/// machine code value for the block result, populating this field.	572
176	/// Following break instructions encounter that value and use it for	573	fn deinit(self: *BlockData, gpa: Allocator) void {
177	/// the location to store their block results.	574	self.relocs.deinit(gpa);
178	mcv: MCValue,	575	self.* = undefined;
		576	}
179	};	577	};
180		578
181	const Reloc = union(enum) {	579	const State = struct {
182	/// The value is an offset into the `Function` `code` from the beginning.	580	registers: RegisterManager.TrackedRegisters,
183	/// To perform the reloc, write 32-bit signed little-endian integer	581	reg_tracking: [RegisterManager.RegisterBitSet.bit_length]InstTracking,
184	/// which is a relative jump, based on the address following the reloc.	582	free_registers: RegisterManager.RegisterBitSet,
185	rel32: usize,	583	inst_tracking_len: u32,
186	/// A branch in the ARM instruction set	584	scope_generation: u32,
187	arm_branch: struct {
188	pos: usize,
189	cond: @import("../arm/bits.zig").Condition,
190	},
191	};	585	};
192		586
193	const BigTomb = struct {	587	fn initRetroactiveState(self: *Self) State {
194	function: *Self,	588	var state: State = undefined;
195	inst: Air.Inst.Index,	589	state.inst_tracking_len = @intCast(self.inst_tracking.count());
196	lbt: Liveness.BigTomb,	590	state.scope_generation = self.scope_generation;
		591	return state;
		592	}
197		593
198	fn feed(bt: *BigTomb, op_ref: Air.Inst.Ref) void {	594	fn saveRetroactiveState(self: Self, state: State) !void {
199	const dies = bt.lbt.feed();	595	const free_registers = self.register_manager.free_registers;
200	const op_index = op_ref.toIndex() orelse return;	596	var it = free_registers.iterator(.{ .kind = .unset });
201	if (!dies) return;	597	while (it.next()) \|index\| {
202	bt.function.processDeath(op_index);	598	const tracked_inst = self.register_manager.registers[index];
		599	state.registers[index] = tracked_inst;
		600	state.reg_tracking[index] = self.inst_tracking.get(tracked_inst).?;
		601	}
		602	state.free_registers = free_registers;
		603	}
		604
		605	fn saveState(self: *Self) !State {
		606	var state = self.initRetroactiveState();
		607	try self.saveRetroactiveState(&state);
		608	return state;
		609	}
		610
		611	fn restoreState(self: *Self, state: State, deaths: []const Air.Inst.Index, comptime opts: struct {
		612	emit_instructions: bool,
		613	update_tracking: bool,
		614	resurrect: bool,
		615	close_scope: bool,
		616	}) !void {
		617	if (opts.close_scope) {
		618	for (
		619	self.inst_tracking.keys()[state.inst_tracking_len..],
		620	self.inst_tracking.values()[state.inst_tracking_len..],
		621	) \|inst, *tracking\| try tracking.die(self, inst);
		622	self.inst_tracking.shrinkRetainingCapacity(state.inst_tracking_len);
203	}	623	}
204		624
205	fn finishAir(bt: *BigTomb, result: MCValue) void {	625	if (opts.resurrect) for (
206	const is_used = !bt.function.liveness.isUnused(bt.inst);	626	self.inst_tracking.keys()[0..state.inst_tracking_len],
207	if (is_used) {	627	self.inst_tracking.values()[0..state.inst_tracking_len],
208	log.debug("%{d} => {}", .{ bt.inst, result });	628	) \|inst, *tracking\| tracking.resurrect(inst, state.scope_generation);
209	const branch = &bt.function.branch_stack.items[bt.function.branch_stack.items.len - 1];	629	for (deaths) \|death\| try self.processDeath(death);
210	branch.inst_table.putAssumeCapacityNoClobber(bt.inst, result);	630
		631	const ExpectedContents = [@typeInfo(RegisterManager.TrackedRegisters).Array.len]RegisterLock;
		632	var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
		633	if (opts.update_tracking)
		634	{} else std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
		635
		636	var reg_locks = if (opts.update_tracking) {} else try std.ArrayList(RegisterLock).initCapacity(
		637	stack.get(),
		638	@typeInfo(ExpectedContents).Array.len,
		639	);
		640	defer if (!opts.update_tracking) {
		641	for (reg_locks.items) \|lock\| self.register_manager.unlockReg(lock);
		642	reg_locks.deinit();
		643	};
		644
		645	for (0..state.registers.len) \|index\| {
		646	const current_maybe_inst = if (self.register_manager.free_registers.isSet(index))
		647	null
		648	else
		649	self.register_manager.registers[index];
		650	const target_maybe_inst = if (state.free_registers.isSet(index))
		651	null
		652	else
		653	state.registers[index];
		654	if (std.debug.runtime_safety) if (target_maybe_inst) \|target_inst\|
		655	assert(self.inst_tracking.getIndex(target_inst).? < state.inst_tracking_len);
		656	if (opts.emit_instructions) {
		657	if (current_maybe_inst) \|current_inst\| {
		658	try self.inst_tracking.getPtr(current_inst).?.spill(self, current_inst);
		659	}
		660	if (target_maybe_inst) \|target_inst\| {
		661	const target_tracking = self.inst_tracking.getPtr(target_inst).?;
		662	try target_tracking.materialize(self, target_inst, state.reg_tracking[index]);
		663	}
211	}	664	}
212	bt.function.finishAirBookkeeping();	665	if (opts.update_tracking) {
		666	if (current_maybe_inst) \|current_inst\| {
		667	try self.inst_tracking.getPtr(current_inst).?.trackSpill(self, current_inst);
		668	}
		669	{
		670	const reg = RegisterManager.regAtTrackedIndex(@intCast(index));
		671	self.register_manager.freeReg(reg);
		672	self.register_manager.getRegAssumeFree(reg, target_maybe_inst);
		673	}
		674	if (target_maybe_inst) \|target_inst\| {
		675	self.inst_tracking.getPtr(target_inst).?.trackMaterialize(
		676	target_inst,
		677	state.reg_tracking[index],
		678	);
		679	}
		680	} else if (target_maybe_inst) \|_\|
		681	try reg_locks.append(self.register_manager.lockRegIndexAssumeUnused(@intCast(index)));
213	}	682	}
214	};	683
		684	if (opts.update_tracking and std.debug.runtime_safety) {
		685	assert(self.register_manager.free_registers.eql(state.free_registers));
		686	var used_reg_it = state.free_registers.iterator(.{ .kind = .unset });
		687	while (used_reg_it.next()) \|index\|
		688	assert(self.register_manager.registers[index] == state.registers[index]);
		689	}
		690	}
215		691
216	const Self = @This();	692	const Self = @This();
217		693
		694	const CallView = enum(u1) {
		695	callee,
		696	caller,
		697	};
		698
218	pub fn generate(	699	pub fn generate(
219	lf: *link.File,	700	bin_file: *link.File,
220	src_loc: Module.SrcLoc,	701	src_loc: Module.SrcLoc,
221	func_index: InternPool.Index,	702	func_index: InternPool.Index,
222	air: Air,	703	air: Air,
...	@@ -224,14 +705,17 @@ pub fn generate(	...	@@ -224,14 +705,17 @@ pub fn generate(
224	code: *std.ArrayList(u8),	705	code: *std.ArrayList(u8),
225	debug_output: DebugInfoOutput,	706	debug_output: DebugInfoOutput,
226	) CodeGenError!Result {	707	) CodeGenError!Result {
227	const gpa = lf.comp.gpa;	708	const comp = bin_file.comp;
228	const zcu = lf.comp.module.?;	709	const gpa = comp.gpa;
		710	const zcu = comp.module.?;
		711	const ip = &zcu.intern_pool;
229	const func = zcu.funcInfo(func_index);	712	const func = zcu.funcInfo(func_index);
230	const fn_owner_decl = zcu.declPtr(func.owner_decl);	713	const fn_owner_decl = zcu.declPtr(func.owner_decl);
231	assert(fn_owner_decl.has_tv);	714	assert(fn_owner_decl.has_tv);
232	const fn_type = fn_owner_decl.typeOf(zcu);	715	const fn_type = fn_owner_decl.typeOf(zcu);
233	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);	716	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);
234	const target = &namespace.file_scope.mod.resolved_target.result;	717	const target = &namespace.file_scope.mod.resolved_target.result;
		718	const mod = namespace.file_scope.mod;
235		719
236	var branch_stack = std.ArrayList(Branch).init(gpa);	720	var branch_stack = std.ArrayList(Branch).init(gpa);
237	defer {	721	defer {
...	@@ -244,9 +728,10 @@ pub fn generate(	...	@@ -244,9 +728,10 @@ pub fn generate(
244	var function = Self{	728	var function = Self{
245	.gpa = gpa,	729	.gpa = gpa,
246	.air = air,	730	.air = air,
		731	.mod = mod,
247	.liveness = liveness,	732	.liveness = liveness,
248	.target = target,	733	.target = target,
249	.bin_file = lf,	734	.bin_file = bin_file,
250	.func_index = func_index,	735	.func_index = func_index,
251	.code = code,	736	.code = code,
252	.debug_output = debug_output,	737	.debug_output = debug_output,
...	@@ -257,27 +742,69 @@ pub fn generate(	...	@@ -257,27 +742,69 @@ pub fn generate(
257	.arg_index = 0,	742	.arg_index = 0,
258	.branch_stack = &branch_stack,	743	.branch_stack = &branch_stack,
259	.src_loc = src_loc,	744	.src_loc = src_loc,
260	.stack_align = undefined,
261	.end_di_line = func.rbrace_line,	745	.end_di_line = func.rbrace_line,
262	.end_di_column = func.rbrace_column,	746	.end_di_column = func.rbrace_column,
		747	.scope_generation = 0,
263	};	748	};
264	defer function.stack.deinit(gpa);	749	defer {
265	defer function.blocks.deinit(gpa);	750	function.frame_allocs.deinit(gpa);
266	defer function.exitlude_jump_relocs.deinit(gpa);	751	function.free_frame_indices.deinit(gpa);
		752	function.frame_locs.deinit(gpa);
		753	var block_it = function.blocks.valueIterator();
		754	while (block_it.next()) \|block\| block.deinit(gpa);
		755	function.blocks.deinit(gpa);
		756	function.inst_tracking.deinit(gpa);
		757	function.const_tracking.deinit(gpa);
		758	function.exitlude_jump_relocs.deinit(gpa);
		759	function.mir_instructions.deinit(gpa);
		760	function.mir_extra.deinit(gpa);
		761	}
267		762
268	var call_info = function.resolveCallingConventionValues(fn_type) catch \|err\| switch (err) {	763	try function.frame_allocs.resize(gpa, FrameIndex.named_count);
		764	function.frame_allocs.set(
		765	@intFromEnum(FrameIndex.stack_frame),
		766	FrameAlloc.init(.{
		767	.size = 0,
		768	.alignment = func.analysis(ip).stack_alignment.max(.@"1"),
		769	}),
		770	);
		771	function.frame_allocs.set(
		772	@intFromEnum(FrameIndex.call_frame),
		773	FrameAlloc.init(.{ .size = 0, .alignment = .@"1" }),
		774	);
		775
		776	const fn_info = zcu.typeToFunc(fn_type).?;
		777	var call_info = function.resolveCallingConventionValues(fn_info) catch \|err\| switch (err) {
269	error.CodegenFail => return Result{ .fail = function.err_msg.? },	778	error.CodegenFail => return Result{ .fail = function.err_msg.? },
270	error.OutOfRegisters => return Result{	779	error.OutOfRegisters => return Result{
271	.fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),	780	.fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
272	},	781	},
273	else => \|e\| return e,	782	else => \|e\| return e,
274	};	783	};
		784
275	defer call_info.deinit(&function);	785	defer call_info.deinit(&function);
276		786
277	function.args = call_info.args;	787	function.args = call_info.args;
278	function.ret_mcv = call_info.return_value;	788	function.ret_mcv = call_info.return_value;
279	function.stack_align = call_info.stack_align;	789	function.frame_allocs.set(@intFromEnum(FrameIndex.ret_addr), FrameAlloc.init(.{
280	function.max_end_stack = call_info.stack_byte_count;	790	.size = Type.usize.abiSize(zcu),
		791	.alignment = Type.usize.abiAlignment(zcu).min(call_info.stack_align),
		792	}));
		793	function.frame_allocs.set(@intFromEnum(FrameIndex.base_ptr), FrameAlloc.init(.{
		794	.size = Type.usize.abiSize(zcu),
		795	.alignment = Alignment.min(
		796	call_info.stack_align,
		797	Alignment.fromNonzeroByteUnits(function.target.stackAlignment()),
		798	),
		799	}));
		800	function.frame_allocs.set(@intFromEnum(FrameIndex.args_frame), FrameAlloc.init(.{
		801	.size = call_info.stack_byte_count,
		802	.alignment = call_info.stack_align,
		803	}));
		804	function.frame_allocs.set(@intFromEnum(FrameIndex.spill_frame), FrameAlloc.init(.{
		805	.size = 0,
		806	.alignment = Type.usize.abiAlignment(zcu),
		807	}));
281		808
282	function.gen() catch \|err\| switch (err) {	809	function.gen() catch \|err\| switch (err) {
283	error.CodegenFail => return Result{ .fail = function.err_msg.? },	810	error.CodegenFail => return Result{ .fail = function.err_msg.? },
...	@@ -290,15 +817,22 @@ pub fn generate(	...	@@ -290,15 +817,22 @@ pub fn generate(
290	var mir = Mir{	817	var mir = Mir{
291	.instructions = function.mir_instructions.toOwnedSlice(),	818	.instructions = function.mir_instructions.toOwnedSlice(),
292	.extra = try function.mir_extra.toOwnedSlice(gpa),	819	.extra = try function.mir_extra.toOwnedSlice(gpa),
		820	.frame_locs = function.frame_locs.toOwnedSlice(),
293	};	821	};
294	defer mir.deinit(gpa);	822	defer mir.deinit(gpa);
295		823
296	var emit = Emit{	824	var emit = Emit{
297	.mir = mir,	825	.lower = .{
298	.bin_file = lf,	826	.bin_file = bin_file,
		827	.allocator = gpa,
		828	.mir = mir,
		829	.cc = fn_info.cc,
		830	.src_loc = src_loc,
		831	.output_mode = comp.config.output_mode,
		832	.link_mode = comp.config.link_mode,
		833	.pic = mod.pic,
		834	},
299	.debug_output = debug_output,	835	.debug_output = debug_output,
300	.target = target,
301	.src_loc = src_loc,
302	.code = code,	836	.code = code,
303	.prev_di_pc = 0,	837	.prev_di_pc = 0,
304	.prev_di_line = func.lbrace_line,	838	.prev_di_line = func.lbrace_line,
...	@@ -307,7 +841,20 @@ pub fn generate(	...	@@ -307,7 +841,20 @@ pub fn generate(
307	defer emit.deinit();	841	defer emit.deinit();
308		842
309	emit.emitMir() catch \|err\| switch (err) {	843	emit.emitMir() catch \|err\| switch (err) {
310	error.EmitFail => return Result{ .fail = emit.err_msg.? },	844	error.LowerFail, error.EmitFail => return Result{ .fail = emit.lower.err_msg.? },
		845	error.InvalidInstruction => \|e\| {
		846	const msg = switch (e) {
		847	error.InvalidInstruction => "CodeGen failed to find a viable instruction.",
		848	};
		849	return Result{
		850	.fail = try ErrorMsg.create(
		851	gpa,
		852	src_loc,
		853	"{s} This is a bug in the Zig compiler.",
		854	.{msg},
		855	),
		856	};
		857	},
311	else => \|e\| return e,	858	else => \|e\| return e,
312	};	859	};
313		860
...	@@ -328,6 +875,30 @@ fn addInst(self: *Self, inst: Mir.Inst) error{OutOfMemory}!Mir.Inst.Index {	...	@@ -328,6 +875,30 @@ fn addInst(self: *Self, inst: Mir.Inst) error{OutOfMemory}!Mir.Inst.Index {
328	return result_index;	875	return result_index;
329	}	876	}
330		877
		878	fn addNop(self: *Self) error{OutOfMemory}!Mir.Inst.Index {
		879	return self.addInst(.{
		880	.tag = .nop,
		881	.ops = .none,
		882	.data = undefined,
		883	});
		884	}
		885
		886	fn addPseudoNone(self: *Self, ops: Mir.Inst.Ops) !void {
		887	_ = try self.addInst(.{
		888	.tag = .pseudo,
		889	.ops = ops,
		890	.data = undefined,
		891	});
		892	}
		893
		894	fn addPseudo(self: *Self, ops: Mir.Inst.Ops) !Mir.Inst.Index {
		895	return self.addInst(.{
		896	.tag = .pseudo,
		897	.ops = ops,
		898	.data = undefined,
		899	});
		900	}
		901
331	pub fn addExtra(self: *Self, extra: anytype) Allocator.Error!u32 {	902	pub fn addExtra(self: *Self, extra: anytype) Allocator.Error!u32 {
332	const fields = std.meta.fields(@TypeOf(extra));	903	const fields = std.meta.fields(@TypeOf(extra));
333	try self.mir_extra.ensureUnusedCapacity(self.gpa, fields.len);	904	try self.mir_extra.ensureUnusedCapacity(self.gpa, fields.len);
...	@@ -349,122 +920,131 @@ pub fn addExtraAssumeCapacity(self: *Self, extra: anytype) u32 {	...	@@ -349,122 +920,131 @@ pub fn addExtraAssumeCapacity(self: *Self, extra: anytype) u32 {
349		920
350	fn gen(self: *Self) !void {	921	fn gen(self: *Self) !void {
351	const mod = self.bin_file.comp.module.?;	922	const mod = self.bin_file.comp.module.?;
352	const cc = self.fn_type.fnCallingConvention(mod);	923	const fn_info = mod.typeToFunc(self.fn_type).?;
353	if (cc != .Naked) {
354	// TODO Finish function prologue and epilogue for riscv64.
355		924
356	// TODO Backpatch stack offset	925	if (fn_info.cc != .Naked) {
357	// addi sp, sp, -16	926	try self.addPseudoNone(.pseudo_dbg_prologue_end);
358	_ = try self.addInst(.{	927
		928	const backpatch_stack_alloc = try self.addPseudo(.pseudo_dead);
		929	const backpatch_ra_spill = try self.addPseudo(.pseudo_dead);
		930	const backpatch_fp_spill = try self.addPseudo(.pseudo_dead);
		931	const backpatch_fp_add = try self.addPseudo(.pseudo_dead);
		932	const backpatch_spill_callee_preserved_regs = try self.addPseudo(.pseudo_dead);
		933
		934	try self.genBody(self.air.getMainBody());
		935
		936	for (self.exitlude_jump_relocs.items) \|jmp_reloc\| {
		937	self.mir_instructions.items(.data)[jmp_reloc].inst =
		938	@intCast(self.mir_instructions.len);
		939	}
		940
		941	try self.addPseudoNone(.pseudo_dbg_epilogue_begin);
		942
		943	const backpatch_restore_callee_preserved_regs = try self.addPseudo(.pseudo_dead);
		944	const backpatch_ra_restore = try self.addPseudo(.pseudo_dead);
		945	const backpatch_fp_restore = try self.addPseudo(.pseudo_dead);
		946	const backpatch_stack_alloc_restore = try self.addPseudo(.pseudo_dead);
		947	try self.addPseudoNone(.pseudo_ret);
		948
		949	const frame_layout = try self.computeFrameLayout();
		950	const need_save_reg = frame_layout.save_reg_list.count() > 0;
		951
		952	self.mir_instructions.set(backpatch_stack_alloc, .{
359	.tag = .addi,	953	.tag = .addi,
		954	.ops = .rri,
360	.data = .{ .i_type = .{	955	.data = .{ .i_type = .{
361	.rd = .sp,	956	.rd = .sp,
362	.rs1 = .sp,	957	.rs1 = .sp,
363	.imm12 = -16,	958	.imm12 = Immediate.s(-@as(i32, @intCast(frame_layout.stack_adjust))),
364	} },	959	} },
365	});	960	});
366		961	self.mir_instructions.set(backpatch_ra_spill, .{
367	// sd ra, 8(sp)	962	.tag = .pseudo,
368	_ = try self.addInst(.{	963	.ops = .pseudo_store_rm,
369	.tag = .sd,	964	.data = .{ .rm = .{
370	.data = .{ .i_type = .{	965	.r = .ra,
371	.rd = .ra,	966	.m = .{
372	.rs1 = .sp,	967	.base = .{ .frame = .ret_addr },
373	.imm12 = 8,	968	.mod = .{ .rm = .{ .size = .dword } },
		969	},
374	} },	970	} },
375	});	971	});
376		972	self.mir_instructions.set(backpatch_ra_restore, .{
377	// sd s0, 0(sp)	973	.tag = .pseudo,
378	_ = try self.addInst(.{	974	.ops = .pseudo_load_rm,
379	.tag = .sd,	975	.data = .{ .rm = .{
380	.data = .{ .i_type = .{	976	.r = .ra,
381	.rd = .s0,	977	.m = .{
382	.rs1 = .sp,	978	.base = .{ .frame = .ret_addr },
383	.imm12 = 0,	979	.mod = .{ .rm = .{ .size = .dword } },
		980	},
384	} },	981	} },
385	});	982	});
386		983	self.mir_instructions.set(backpatch_fp_spill, .{
387	_ = try self.addInst(.{	984	.tag = .pseudo,
388	.tag = .dbg_prologue_end,	985	.ops = .pseudo_store_rm,
389	.data = .{ .nop = {} },	986	.data = .{ .rm = .{
390	});	987	.r = .s0,
391		988	.m = .{
392	try self.genBody(self.air.getMainBody());	989	.base = .{ .frame = .base_ptr },
393		990	.mod = .{ .rm = .{ .size = .dword } },
394	_ = try self.addInst(.{	991	},
395	.tag = .dbg_epilogue_begin,	992	} },
396	.data = .{ .nop = {} },
397	});	993	});
398		994	self.mir_instructions.set(backpatch_fp_restore, .{
399	// exitlude jumps	995	.tag = .pseudo,
400	if (self.exitlude_jump_relocs.items.len > 0 and	996	.ops = .pseudo_load_rm,
401	self.exitlude_jump_relocs.items[self.exitlude_jump_relocs.items.len - 1] == self.mir_instructions.len - 2)	997	.data = .{ .rm = .{
402	{	998	.r = .s0,
403	// If the last Mir instruction (apart from the	999	.m = .{
404	// dbg_epilogue_begin) is the last exitlude jump	1000	.base = .{ .frame = .base_ptr },
405	// relocation (which would just jump one instruction	1001	.mod = .{ .rm = .{ .size = .dword } },
406	// further), it can be safely removed	1002	},
407	self.mir_instructions.orderedRemove(self.exitlude_jump_relocs.pop());
408	}
409
410	for (self.exitlude_jump_relocs.items) \|jmp_reloc\| {
411	_ = jmp_reloc;
412	return self.fail("TODO add branches in RISCV64", .{});
413	}
414
415	// ld ra, 8(sp)
416	_ = try self.addInst(.{
417	.tag = .ld,
418	.data = .{ .i_type = .{
419	.rd = .ra,
420	.rs1 = .sp,
421	.imm12 = 8,
422	} },	1003	} },
423	});	1004	});
424		1005	self.mir_instructions.set(backpatch_fp_add, .{
425	// ld s0, 0(sp)	1006	.tag = .addi,
426	_ = try self.addInst(.{	1007	.ops = .rri,
427	.tag = .ld,
428	.data = .{ .i_type = .{	1008	.data = .{ .i_type = .{
429	.rd = .s0,	1009	.rd = .s0,
430	.rs1 = .sp,	1010	.rs1 = .sp,
431	.imm12 = 0,	1011	.imm12 = Immediate.s(@intCast(frame_layout.stack_adjust)),
432	} },	1012	} },
433	});	1013	});
434		1014	self.mir_instructions.set(backpatch_stack_alloc_restore, .{
435	// addi sp, sp, 16
436	_ = try self.addInst(.{
437	.tag = .addi,	1015	.tag = .addi,
		1016	.ops = .rri,
438	.data = .{ .i_type = .{	1017	.data = .{ .i_type = .{
439	.rd = .sp,	1018	.rd = .sp,
440	.rs1 = .sp,	1019	.rs1 = .sp,
441	.imm12 = 16,	1020	.imm12 = Immediate.s(@intCast(frame_layout.stack_adjust)),
442	} },	1021	} },
443	});	1022	});
444		1023
445	// ret	1024	if (need_save_reg) {
446	_ = try self.addInst(.{	1025	self.mir_instructions.set(backpatch_spill_callee_preserved_regs, .{
447	.tag = .ret,	1026	.tag = .pseudo,
448	.data = .{ .nop = {} },	1027	.ops = .pseudo_spill_regs,
449	});	1028	.data = .{ .reg_list = frame_layout.save_reg_list },
450	} else {	1029	});
451	_ = try self.addInst(.{
452	.tag = .dbg_prologue_end,
453	.data = .{ .nop = {} },
454	});
455		1030
		1031	self.mir_instructions.set(backpatch_restore_callee_preserved_regs, .{
		1032	.tag = .pseudo,
		1033	.ops = .pseudo_restore_regs,
		1034	.data = .{ .reg_list = frame_layout.save_reg_list },
		1035	});
		1036	}
		1037	} else {
		1038	try self.addPseudoNone(.pseudo_dbg_prologue_end);
456	try self.genBody(self.air.getMainBody());	1039	try self.genBody(self.air.getMainBody());
457		1040	try self.addPseudoNone(.pseudo_dbg_epilogue_begin);
458	_ = try self.addInst(.{
459	.tag = .dbg_epilogue_begin,
460	.data = .{ .nop = {} },
461	});
462	}	1041	}
463		1042
464	// Drop them off at the rbrace.	1043	// Drop them off at the rbrace.
465	_ = try self.addInst(.{	1044	_ = try self.addInst(.{
466	.tag = .dbg_line,	1045	.tag = .pseudo,
467	.data = .{ .dbg_line_column = .{	1046	.ops = .pseudo_dbg_line_column,
		1047	.data = .{ .pseudo_dbg_line_column = .{
468	.line = self.end_di_line,	1048	.line = self.end_di_line,
469	.column = self.end_di_column,	1049	.column = self.end_di_column,
470	} },	1050	} },
...	@@ -472,18 +1052,15 @@ fn gen(self: *Self) !void {	...	@@ -472,18 +1052,15 @@ fn gen(self: *Self) !void {
472	}	1052	}
473		1053
474	fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	1054	fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
475	const mod = self.bin_file.comp.module.?;	1055	const zcu = self.bin_file.comp.module.?;
476	const ip = &mod.intern_pool;	1056	const ip = &zcu.intern_pool;
477	const air_tags = self.air.instructions.items(.tag);	1057	const air_tags = self.air.instructions.items(.tag);
478		1058
479	for (body) \|inst\| {	1059	for (body) \|inst\| {
480	// TODO: remove now-redundant isUnused calls from AIR handler functions	1060	if (self.liveness.isUnused(inst) and !self.air.mustLower(inst, ip)) continue;
481	if (self.liveness.isUnused(inst) and !self.air.mustLower(inst, ip))
482	continue;
483		1061
484	const old_air_bookkeeping = self.air_bookkeeping;	1062	const old_air_bookkeeping = self.air_bookkeeping;
485	try self.ensureProcessDeathCapacity(Liveness.bpi);	1063	try self.inst_tracking.ensureUnusedCapacity(self.gpa, 1);
486
487	switch (air_tags[@intFromEnum(inst)]) {	1064	switch (air_tags[@intFromEnum(inst)]) {
488	// zig fmt: off	1065	// zig fmt: off
489	.ptr_add => try self.airPtrArithmetic(inst, .ptr_add),	1066	.ptr_add => try self.airPtrArithmetic(inst, .ptr_add),
...	@@ -508,8 +1085,8 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	...	@@ -508,8 +1085,8 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
508	.mod => try self.airMod(inst),	1085	.mod => try self.airMod(inst),
509	.shl, .shl_exact => try self.airShl(inst),	1086	.shl, .shl_exact => try self.airShl(inst),
510	.shl_sat => try self.airShlSat(inst),	1087	.shl_sat => try self.airShlSat(inst),
511	.min => try self.airMin(inst),	1088	.min => try self.airMinMax(inst, .min),
512	.max => try self.airMax(inst),	1089	.max => try self.airMinMax(inst, .max),
513	.slice => try self.airSlice(inst),	1090	.slice => try self.airSlice(inst),
514		1091
515	.sqrt,	1092	.sqrt,
...	@@ -535,12 +1112,12 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	...	@@ -535,12 +1112,12 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
535		1112
536	.div_float, .div_trunc, .div_floor, .div_exact => try self.airDiv(inst),	1113	.div_float, .div_trunc, .div_floor, .div_exact => try self.airDiv(inst),
537		1114
538	.cmp_lt => try self.airCmp(inst, .lt),	1115	.cmp_lt => try self.airCmp(inst),
539	.cmp_lte => try self.airCmp(inst, .lte),	1116	.cmp_lte => try self.airCmp(inst),
540	.cmp_eq => try self.airCmp(inst, .eq),	1117	.cmp_eq => try self.airCmp(inst),
541	.cmp_gte => try self.airCmp(inst, .gte),	1118	.cmp_gte => try self.airCmp(inst),
542	.cmp_gt => try self.airCmp(inst, .gt),	1119	.cmp_gt => try self.airCmp(inst),
543	.cmp_neq => try self.airCmp(inst, .neq),	1120	.cmp_neq => try self.airCmp(inst),
544		1121
545	.cmp_vector => try self.airCmpVector(inst),	1122	.cmp_vector => try self.airCmpVector(inst),
546	.cmp_lt_errors_len => try self.airCmpLtErrorsLen(inst),	1123	.cmp_lt_errors_len => try self.airCmpLtErrorsLen(inst),
...	@@ -565,11 +1142,12 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	...	@@ -565,11 +1142,12 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
565	.frame_addr => try self.airFrameAddress(inst),	1142	.frame_addr => try self.airFrameAddress(inst),
566	.fence => try self.airFence(),	1143	.fence => try self.airFence(),
567	.cond_br => try self.airCondBr(inst),	1144	.cond_br => try self.airCondBr(inst),
		1145	.dbg_stmt => try self.airDbgStmt(inst),
568	.fptrunc => try self.airFptrunc(inst),	1146	.fptrunc => try self.airFptrunc(inst),
569	.fpext => try self.airFpext(inst),	1147	.fpext => try self.airFpext(inst),
570	.intcast => try self.airIntCast(inst),	1148	.intcast => try self.airIntCast(inst),
571	.trunc => try self.airTrunc(inst),	1149	.trunc => try self.airTrunc(inst),
572	.int_from_bool => try self.airIntFromBool(inst),	1150	.int_from_bool => try self.airIntFromBool(inst),
573	.is_non_null => try self.airIsNonNull(inst),	1151	.is_non_null => try self.airIsNonNull(inst),
574	.is_non_null_ptr => try self.airIsNonNullPtr(inst),	1152	.is_non_null_ptr => try self.airIsNonNullPtr(inst),
575	.is_null => try self.airIsNull(inst),	1153	.is_null => try self.airIsNull(inst),
...	@@ -581,17 +1159,17 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	...	@@ -581,17 +1159,17 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
581	.load => try self.airLoad(inst),	1159	.load => try self.airLoad(inst),
582	.loop => try self.airLoop(inst),	1160	.loop => try self.airLoop(inst),
583	.not => try self.airNot(inst),	1161	.not => try self.airNot(inst),
584	.int_from_ptr => try self.airIntFromPtr(inst),	1162	.int_from_ptr => try self.airIntFromPtr(inst),
585	.ret => try self.airRet(inst),	1163	.ret => try self.airRet(inst, false),
586	.ret_safe => try self.airRet(inst), // TODO	1164	.ret_safe => try self.airRet(inst, true),
587	.ret_load => try self.airRetLoad(inst),	1165	.ret_load => try self.airRetLoad(inst),
588	.store => try self.airStore(inst, false),	1166	.store => try self.airStore(inst, false),
589	.store_safe => try self.airStore(inst, true),	1167	.store_safe => try self.airStore(inst, true),
590	.struct_field_ptr=> try self.airStructFieldPtr(inst),	1168	.struct_field_ptr=> try self.airStructFieldPtr(inst),
591	.struct_field_val=> try self.airStructFieldVal(inst),	1169	.struct_field_val=> try self.airStructFieldVal(inst),
592	.array_to_slice => try self.airArrayToSlice(inst),	1170	.array_to_slice => try self.airArrayToSlice(inst),
593	.float_from_int => try self.airFloatFromInt(inst),	1171	.float_from_int => try self.airFloatFromInt(inst),
594	.int_from_float => try self.airIntFromFloat(inst),	1172	.int_from_float => try self.airIntFromFloat(inst),
595	.cmpxchg_strong => try self.airCmpxchg(inst),	1173	.cmpxchg_strong => try self.airCmpxchg(inst),
596	.cmpxchg_weak => try self.airCmpxchg(inst),	1174	.cmpxchg_weak => try self.airCmpxchg(inst),
597	.atomic_rmw => try self.airAtomicRmw(inst),	1175	.atomic_rmw => try self.airAtomicRmw(inst),
...	@@ -617,17 +1195,17 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	...	@@ -617,17 +1195,17 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
617	.union_init => try self.airUnionInit(inst),	1195	.union_init => try self.airUnionInit(inst),
618	.prefetch => try self.airPrefetch(inst),	1196	.prefetch => try self.airPrefetch(inst),
619	.mul_add => try self.airMulAdd(inst),	1197	.mul_add => try self.airMulAdd(inst),
620	.addrspace_cast => @panic("TODO"),	1198	.addrspace_cast => return self.fail("TODO: addrspace_cast", .{}),
621		1199
622	.@"try" => @panic("TODO"),	1200	.@"try" => try self.airTry(inst),
623	.try_ptr => @panic("TODO"),	1201	.try_ptr => return self.fail("TODO: try_ptr", .{}),
624		1202
625	.dbg_stmt => try self.airDbgStmt(inst),
626	.dbg_inline_block => try self.airDbgInlineBlock(inst),
627	.dbg_var_ptr,	1203	.dbg_var_ptr,
628	.dbg_var_val,	1204	.dbg_var_val,
629	=> try self.airDbgVar(inst),	1205	=> try self.airDbgVar(inst),
630		1206
		1207	.dbg_inline_block => try self.airDbgInlineBlock(inst),
		1208
631	.call => try self.airCall(inst, .auto),	1209	.call => try self.airCall(inst, .auto),
632	.call_always_tail => try self.airCall(inst, .always_tail),	1210	.call_always_tail => try self.airCall(inst, .always_tail),
633	.call_never_tail => try self.airCall(inst, .never_tail),	1211	.call_never_tail => try self.airCall(inst, .never_tail),
...	@@ -715,28 +1293,60 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	...	@@ -715,28 +1293,60 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
715	.work_group_id => unreachable,	1293	.work_group_id => unreachable,
716	// zig fmt: on	1294	// zig fmt: on
717	}	1295	}
		1296
		1297	assert(!self.register_manager.lockedRegsExist());
		1298
718	if (std.debug.runtime_safety) {	1299	if (std.debug.runtime_safety) {
719	if (self.air_bookkeeping < old_air_bookkeeping + 1) {	1300	if (self.air_bookkeeping < old_air_bookkeeping + 1) {
720	std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@intFromEnum(inst)] });	1301	std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@intFromEnum(inst)] });
721	}	1302	}
		1303
		1304	{ // check consistency of tracked registers
		1305	var it = self.register_manager.free_registers.iterator(.{ .kind = .unset });
		1306	while (it.next()) \|index\| {
		1307	const tracked_inst = self.register_manager.registers[index];
		1308	const tracking = self.getResolvedInstValue(tracked_inst);
		1309	for (tracking.getRegs()) \|reg\| {
		1310	if (RegisterManager.indexOfRegIntoTracked(reg).? == index) break;
		1311	} else return self.fail(
		1312	\\%{} takes up these regs: {any}, however those regs don't use it
		1313	, .{ index, tracking.getRegs() });
		1314	}
		1315	}
722	}	1316	}
723	}	1317	}
724	}	1318	}
725		1319
726	/// Asserts there is already capacity to insert into top branch inst_table.	1320	fn getValue(self: *Self, value: MCValue, inst: ?Air.Inst.Index) !void {
727	fn processDeath(self: *Self, inst: Air.Inst.Index) void {	1321	for (value.getRegs()) \|reg\| try self.register_manager.getReg(reg, inst);
728	// When editing this function, note that the logic must synchronize with `reuseOperand`.	1322	}
729	const prev_value = self.getResolvedInstValue(inst);	1323
730	const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];	1324	fn getValueIfFree(self: *Self, value: MCValue, inst: ?Air.Inst.Index) void {
731	branch.inst_table.putAssumeCapacity(inst, .dead);	1325	for (value.getRegs()) \|reg\| if (self.register_manager.isRegFree(reg))
732	switch (prev_value) {	1326	self.register_manager.getRegAssumeFree(reg, inst);
733	.register => \|reg\| {	1327	}
734	self.register_manager.freeReg(reg);	1328
735	},	1329	fn freeValue(self: *Self, value: MCValue) !void {
		1330	switch (value) {
		1331	.register => \|reg\| self.register_manager.freeReg(reg),
		1332	.register_pair => \|regs\| for (regs) \|reg\| self.register_manager.freeReg(reg),
		1333	.register_offset => \|reg_off\| self.register_manager.freeReg(reg_off.reg),
736	else => {}, // TODO process stack allocation death	1334	else => {}, // TODO process stack allocation death
737	}	1335	}
738	}	1336	}
739		1337
		1338	fn feed(self: Self, bt: Liveness.BigTomb, operand: Air.Inst.Ref) !void {
		1339	if (bt.feed()) if (operand.toIndex()) \|inst\| {
		1340	log.debug("feed inst: %{}", .{inst});
		1341	try self.processDeath(inst);
		1342	};
		1343	}
		1344
		1345	/// Asserts there is already capacity to insert into top branch inst_table.
		1346	fn processDeath(self: *Self, inst: Air.Inst.Index) !void {
		1347	try self.inst_tracking.getPtr(inst).?.die(self, inst);
		1348	}
		1349
740	/// Called when there are no operands, and the instruction is always unreferenced.	1350	/// Called when there are no operands, and the instruction is always unreferenced.
741	fn finishAirBookkeeping(self: *Self) void {	1351	fn finishAirBookkeeping(self: *Self) void {
742	if (std.debug.runtime_safety) {	1352	if (std.debug.runtime_safety) {
...	@@ -744,36 +1354,143 @@ fn finishAirBookkeeping(self: *Self) void {	...	@@ -744,36 +1354,143 @@ fn finishAirBookkeeping(self: *Self) void {
744	}	1354	}
745	}	1355	}
746		1356
747	fn finishAir(self: *Self, inst: Air.Inst.Index, result: MCValue, operands: [Liveness.bpi - 1]Air.Inst.Ref) void {	1357	fn finishAirResult(self: *Self, inst: Air.Inst.Index, result: MCValue) void {
		1358	if (self.liveness.isUnused(inst)) switch (result) {
		1359	.none, .dead, .unreach => {},
		1360	else => unreachable, // Why didn't the result die?
		1361	} else {
		1362	tracking_log.debug("%{d} => {} (birth)", .{ inst, result });
		1363	self.inst_tracking.putAssumeCapacityNoClobber(inst, InstTracking.init(result));
		1364	// In some cases, an operand may be reused as the result.
		1365	// If that operand died and was a register, it was freed by
		1366	// processDeath, so we have to "re-allocate" the register.
		1367	self.getValueIfFree(result, inst);
		1368	}
		1369	self.finishAirBookkeeping();
		1370	}
		1371
		1372	fn finishAir(
		1373	self: *Self,
		1374	inst: Air.Inst.Index,
		1375	result: MCValue,
		1376	operands: [Liveness.bpi - 1]Air.Inst.Ref,
		1377	) !void {
748	var tomb_bits = self.liveness.getTombBits(inst);	1378	var tomb_bits = self.liveness.getTombBits(inst);
749	for (operands) \|op\| {	1379	for (operands) \|op\| {
750	const dies = @as(u1, @truncate(tomb_bits)) != 0;	1380	const dies = @as(u1, @truncate(tomb_bits)) != 0;
751	tomb_bits >>= 1;	1381	tomb_bits >>= 1;
752	if (!dies) continue;	1382	if (!dies) continue;
753	const op_index = op.toIndex() orelse continue;	1383	try self.processDeath(op.toIndexAllowNone() orelse continue);
754	self.processDeath(op_index);
755	}	1384	}
756	const is_used = @as(u1, @truncate(tomb_bits)) == 0;	1385	self.finishAirResult(inst, result);
757	if (is_used) {	1386	}
758	log.debug("%{d} => {}", .{ inst, result });
759	const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
760	branch.inst_table.putAssumeCapacityNoClobber(inst, result);
761		1387
762	switch (result) {	1388	const FrameLayout = struct {
763	.register => \|reg\| {	1389	stack_adjust: u32,
764	// In some cases (such as bitcast), an operand	1390	save_reg_list: Mir.RegisterList,
765	// may be the same MCValue as the result. If	1391	};
766	// that operand died and was a register, it	1392
767	// was freed by processDeath. We have to	1393	fn setFrameLoc(
768	// "re-allocate" the register.	1394	self: *Self,
769	if (self.register_manager.isRegFree(reg)) {	1395	frame_index: FrameIndex,
770	self.register_manager.getRegAssumeFree(reg, inst);	1396	base: Register,
771	}	1397	offset: *i32,
772	},	1398	comptime aligned: bool,
773	else => {},	1399	) void {
		1400	const frame_i = @intFromEnum(frame_index);
		1401	if (aligned) {
		1402	const alignment: InternPool.Alignment = self.frame_allocs.items(.abi_align)[frame_i];
		1403	offset.* = if (math.sign(offset.*) < 0)
		1404	-1 * @as(i32, @intCast(alignment.backward(@intCast(@abs(offset.*)))))
		1405	else
		1406	@intCast(alignment.forward(@intCast(@abs(offset.*))));
		1407	}
		1408	self.frame_locs.set(frame_i, .{ .base = base, .disp = offset.* });
		1409	offset.* += self.frame_allocs.items(.abi_size)[frame_i];
		1410	}
		1411
		1412	fn computeFrameLayout(self: *Self) !FrameLayout {
		1413	const frame_allocs_len = self.frame_allocs.len;
		1414	try self.frame_locs.resize(self.gpa, frame_allocs_len);
		1415	const stack_frame_order = try self.gpa.alloc(FrameIndex, frame_allocs_len - FrameIndex.named_count);
		1416	defer self.gpa.free(stack_frame_order);
		1417
		1418	const frame_size = self.frame_allocs.items(.abi_size);
		1419	const frame_align = self.frame_allocs.items(.abi_align);
		1420
		1421	for (stack_frame_order, FrameIndex.named_count..) \|*frame_order, frame_index\|
		1422	frame_order.* = @enumFromInt(frame_index);
		1423
		1424	{
		1425	const SortContext = struct {
		1426	frame_align: @TypeOf(frame_align),
		1427	pub fn lessThan(context: @This(), lhs: FrameIndex, rhs: FrameIndex) bool {
		1428	return context.frame_align[@intFromEnum(lhs)].compare(.gt, context.frame_align[@intFromEnum(rhs)]);
		1429	}
		1430	};
		1431	const sort_context = SortContext{ .frame_align = frame_align };
		1432	mem.sort(FrameIndex, stack_frame_order, sort_context, SortContext.lessThan);
		1433	}
		1434
		1435	var save_reg_list = Mir.RegisterList{};
		1436	for (callee_preserved_regs) \|reg\| {
		1437	if (self.register_manager.isRegAllocated(reg)) {
		1438	save_reg_list.push(&callee_preserved_regs, reg);
774	}	1439	}
775	}	1440	}
776	self.finishAirBookkeeping();	1441
		1442	const total_alloc_size: i32 = blk: {
		1443	var i: i32 = 0;
		1444	for (stack_frame_order) \|frame_index\| {
		1445	i += frame_size[@intFromEnum(frame_index)];
		1446	}
		1447	break :blk i;
		1448	};
		1449	const saved_reg_size = save_reg_list.size();
		1450
		1451	frame_size[@intFromEnum(FrameIndex.spill_frame)] = @intCast(saved_reg_size);
		1452
		1453	// The total frame size is calculated by the amount of s registers you need to save * 8, as each
		1454	// register is 8 bytes, the total allocation sizes, and 16 more register for the spilled ra and s0
		1455	// register. Finally we align the frame size to the align of the base pointer.
		1456	const args_frame_size = frame_size[@intFromEnum(FrameIndex.args_frame)];
		1457	const spill_frame_size = frame_size[@intFromEnum(FrameIndex.spill_frame)];
		1458	const call_frame_size = frame_size[@intFromEnum(FrameIndex.call_frame)];
		1459
		1460	// TODO: this 64 should be a 16, but we were clobbering the top and bottom of the frame.
		1461	// maybe everything can go from the bottom?
		1462	const acc_frame_size: i32 = std.mem.alignForward(
		1463	i32,
		1464	total_alloc_size + 64 + args_frame_size + spill_frame_size + call_frame_size,
		1465	@intCast(frame_align[@intFromEnum(FrameIndex.base_ptr)].toByteUnits().?),
		1466	);
		1467	log.debug("frame size: {}", .{acc_frame_size});
		1468
		1469	// store the ra at total_size - 8, so it's the very first thing in the stack
		1470	// relative to the fp
		1471	self.frame_locs.set(
		1472	@intFromEnum(FrameIndex.ret_addr),
		1473	.{ .base = .sp, .disp = acc_frame_size - 8 },
		1474	);
		1475	self.frame_locs.set(
		1476	@intFromEnum(FrameIndex.base_ptr),
		1477	.{ .base = .sp, .disp = acc_frame_size - 16 },
		1478	);
		1479
		1480	// now we grow the stack frame from the bottom of total frame in order to
		1481	// not need to know the size of the first allocation. Stack offsets point at the "bottom"
		1482	// of variables.
		1483	var s0_offset: i32 = -acc_frame_size;
		1484	self.setFrameLoc(.stack_frame, .s0, &s0_offset, true);
		1485	for (stack_frame_order) \|frame_index\| self.setFrameLoc(frame_index, .s0, &s0_offset, true);
		1486	self.setFrameLoc(.args_frame, .s0, &s0_offset, true);
		1487	self.setFrameLoc(.call_frame, .s0, &s0_offset, true);
		1488	self.setFrameLoc(.spill_frame, .s0, &s0_offset, true);
		1489
		1490	return .{
		1491	.stack_adjust = @intCast(acc_frame_size),
		1492	.save_reg_list = save_reg_list,
		1493	};
777	}	1494	}
778		1495
779	fn ensureProcessDeathCapacity(self: *Self, additional_count: usize) !void {	1496	fn ensureProcessDeathCapacity(self: *Self, additional_count: usize) !void {
...	@@ -781,40 +1498,94 @@ fn ensureProcessDeathCapacity(self: *Self, additional_count: usize) !void {	...	@@ -781,40 +1498,94 @@ fn ensureProcessDeathCapacity(self: *Self, additional_count: usize) !void {
781	try table.ensureUnusedCapacity(self.gpa, additional_count);	1498	try table.ensureUnusedCapacity(self.gpa, additional_count);
782	}	1499	}
783		1500
784	fn allocMem(self: *Self, inst: Air.Inst.Index, abi_size: u32, abi_align: Alignment) !u32 {	1501	fn memSize(self: *Self, ty: Type) Memory.Size {
785	self.stack_align = self.stack_align.max(abi_align);	1502	const mod = self.bin_file.comp.module.?;
786	// TODO find a free slot instead of always appending	1503	return switch (ty.zigTypeTag(mod)) {
787	const offset: u32 = @intCast(abi_align.forward(self.next_stack_offset));	1504	.Float => Memory.Size.fromBitSize(ty.floatBits(self.target.*)),
788	self.next_stack_offset = offset + abi_size;	1505	else => Memory.Size.fromByteSize(ty.abiSize(mod)),
789	if (self.next_stack_offset > self.max_end_stack)	1506	};
790	self.max_end_stack = self.next_stack_offset;
791	try self.stack.putNoClobber(self.gpa, offset, .{
792	.inst = inst,
793	.size = abi_size,
794	});
795	return offset;
796	}	1507	}
797		1508
798	/// Use a pointer instruction as the basis for allocating stack memory.	1509	fn splitType(self: *Self, ty: Type) ![2]Type {
799	fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {	1510	const zcu = self.bin_file.comp.module.?;
800	const mod = self.bin_file.comp.module.?;	1511	const classes = mem.sliceTo(&abi.classifySystem(ty, zcu), .none);
801	const elem_ty = self.typeOfIndex(inst).childType(mod);	1512	var parts: [2]Type = undefined;
802	const abi_size = math.cast(u32, elem_ty.abiSize(mod)) orelse {	1513	if (classes.len == 2) for (&parts, classes, 0..) \|*part, class, part_i\| {
803	return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(mod)});	1514	part.* = switch (class) {
		1515	.integer => switch (part_i) {
		1516	0 => Type.u64,
		1517	1 => part: {
		1518	const elem_size = ty.abiAlignment(zcu).minStrict(.@"8").toByteUnits().?;
		1519	const elem_ty = try zcu.intType(.unsigned, @intCast(elem_size * 8));
		1520	break :part switch (@divExact(ty.abiSize(zcu) - 8, elem_size)) {
		1521	1 => elem_ty,
		1522	else => \|len\| try zcu.arrayType(.{ .len = len, .child = elem_ty.toIntern() }),
		1523	};
		1524	},
		1525	else => unreachable,
		1526	},
		1527	else => return self.fail("TODO: splitType class {}", .{class}),
		1528	};
		1529	} else if (parts[0].abiSize(zcu) + parts[1].abiSize(zcu) == ty.abiSize(zcu)) return parts;
		1530	return self.fail("TODO implement splitType for {}", .{ty.fmt(zcu)});
		1531	}
		1532
		1533	fn symbolIndex(self: *Self) !u32 {
		1534	const zcu = self.bin_file.comp.module.?;
		1535	const decl_index = zcu.funcOwnerDeclIndex(self.func_index);
		1536	return switch (self.bin_file.tag) {
		1537	.elf => blk: {
		1538	const elf_file = self.bin_file.cast(link.File.Elf).?;
		1539	const atom_index = try elf_file.zigObjectPtr().?.getOrCreateMetadataForDecl(elf_file, decl_index);
		1540	break :blk atom_index;
		1541	},
		1542	else => return self.fail("TODO genSetReg load_symbol for {s}", .{@tagName(self.bin_file.tag)}),
804	};	1543	};
805	// TODO swap this for inst.ty.ptrAlign	1544	}
806	const abi_align = elem_ty.abiAlignment(mod);	1545
807	return self.allocMem(inst, abi_size, abi_align);	1546	fn allocFrameIndex(self: *Self, alloc: FrameAlloc) !FrameIndex {
		1547	const frame_allocs_slice = self.frame_allocs.slice();
		1548	const frame_size = frame_allocs_slice.items(.abi_size);
		1549	const frame_align = frame_allocs_slice.items(.abi_align);
		1550
		1551	const stack_frame_align = &frame_align[@intFromEnum(FrameIndex.stack_frame)];
		1552	stack_frame_align.* = stack_frame_align.max(alloc.abi_align);
		1553
		1554	for (self.free_frame_indices.keys(), 0..) \|frame_index, free_i\| {
		1555	const abi_size = frame_size[@intFromEnum(frame_index)];
		1556	if (abi_size != alloc.abi_size) continue;
		1557	const abi_align = &frame_align[@intFromEnum(frame_index)];
		1558	abi_align.* = abi_align.max(alloc.abi_align);
		1559
		1560	_ = self.free_frame_indices.swapRemoveAt(free_i);
		1561	return frame_index;
		1562	}
		1563	const frame_index: FrameIndex = @enumFromInt(self.frame_allocs.len);
		1564	try self.frame_allocs.append(self.gpa, alloc);
		1565	log.debug("allocated frame {}", .{frame_index});
		1566	return frame_index;
		1567	}
		1568
		1569	/// Use a pointer instruction as the basis for allocating stack memory.
		1570	fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !FrameIndex {
		1571	const zcu = self.bin_file.comp.module.?;
		1572	const ptr_ty = self.typeOfIndex(inst);
		1573	const val_ty = ptr_ty.childType(zcu);
		1574	return self.allocFrameIndex(FrameAlloc.init(.{
		1575	.size = math.cast(u32, val_ty.abiSize(zcu)) orelse {
		1576	return self.fail("type '{}' too big to fit into stack frame", .{val_ty.fmt(zcu)});
		1577	},
		1578	.alignment = ptr_ty.ptrAlignment(zcu).max(.@"1"),
		1579	}));
808	}	1580	}
809		1581
810	fn allocRegOrMem(self: *Self, inst: Air.Inst.Index, reg_ok: bool) !MCValue {	1582	fn allocRegOrMem(self: *Self, inst: Air.Inst.Index, reg_ok: bool) !MCValue {
811	const mod = self.bin_file.comp.module.?;	1583	const zcu = self.bin_file.comp.module.?;
812	const elem_ty = self.typeOfIndex(inst);	1584	const elem_ty = self.typeOfIndex(inst);
813	const abi_size = math.cast(u32, elem_ty.abiSize(mod)) orelse {	1585
814	return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(mod)});	1586	const abi_size = math.cast(u32, elem_ty.abiSize(zcu)) orelse {
		1587	return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(zcu)});
815	};	1588	};
816	const abi_align = elem_ty.abiAlignment(mod);
817	self.stack_align = self.stack_align.max(abi_align);
818		1589
819	if (reg_ok) {	1590	if (reg_ok) {
820	// Make sure the type can fit in a register before we try to allocate one.	1591	// Make sure the type can fit in a register before we try to allocate one.
...	@@ -822,29 +1593,67 @@ fn allocRegOrMem(self: *Self, inst: Air.Inst.Index, reg_ok: bool) !MCValue {	...	@@ -822,29 +1593,67 @@ fn allocRegOrMem(self: *Self, inst: Air.Inst.Index, reg_ok: bool) !MCValue {
822	const ptr_bytes: u64 = @divExact(ptr_bits, 8);	1593	const ptr_bytes: u64 = @divExact(ptr_bits, 8);
823	if (abi_size <= ptr_bytes) {	1594	if (abi_size <= ptr_bytes) {
824	if (self.register_manager.tryAllocReg(inst, gp)) \|reg\| {	1595	if (self.register_manager.tryAllocReg(inst, gp)) \|reg\| {
825	return MCValue{ .register = reg };	1596	return .{ .register = reg };
826	}	1597	}
827	}	1598	}
828	}	1599	}
829	const stack_offset = try self.allocMem(inst, abi_size, abi_align);	1600
830	return MCValue{ .stack_offset = stack_offset };	1601	const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(elem_ty, zcu));
		1602	return .{ .load_frame = .{ .index = frame_index } };
		1603	}
		1604
		1605	/// Allocates a register from the general purpose set and returns the Register and the Lock.
		1606	///
		1607	/// Up to the user to unlock the register later.
		1608	fn allocReg(self: *Self) !struct { Register, RegisterLock } {
		1609	const reg = try self.register_manager.allocReg(null, gp);
		1610	const lock = self.register_manager.lockRegAssumeUnused(reg);
		1611	return .{ reg, lock };
		1612	}
		1613
		1614	fn elemOffset(self: *Self, index_ty: Type, index: MCValue, elem_size: u64) !Register {
		1615	const reg: Register = blk: {
		1616	switch (index) {
		1617	.immediate => \|imm\| {
		1618	// Optimisation: if index MCValue is an immediate, we can multiply in `comptime`
		1619	// and set the register directly to the scaled offset as an immediate.
		1620	const reg = try self.register_manager.allocReg(null, gp);
		1621	try self.genSetReg(index_ty, reg, .{ .immediate = imm * elem_size });
		1622	break :blk reg;
		1623	},
		1624	else => {
		1625	const reg = try self.copyToTmpRegister(index_ty, index);
		1626	const lock = self.register_manager.lockRegAssumeUnused(reg);
		1627	defer self.register_manager.unlockReg(lock);
		1628
		1629	const result = try self.binOp(
		1630	.mul,
		1631	.{ .register = reg },
		1632	index_ty,
		1633	.{ .immediate = elem_size },
		1634	index_ty,
		1635	);
		1636	break :blk result.register;
		1637	},
		1638	}
		1639	};
		1640	return reg;
831	}	1641	}
832		1642
833	pub fn spillInstruction(self: *Self, reg: Register, inst: Air.Inst.Index) !void {	1643	pub fn spillInstruction(self: *Self, reg: Register, inst: Air.Inst.Index) !void {
834	const stack_mcv = try self.allocRegOrMem(inst, false);	1644	const tracking = self.inst_tracking.getPtr(inst) orelse return;
835	log.debug("spilling {d} to stack mcv {any}", .{ inst, stack_mcv });	1645	for (tracking.getRegs()) \|tracked_reg\| {
836	const reg_mcv = self.getResolvedInstValue(inst);	1646	if (tracked_reg.id() == reg.id()) break;
837	assert(reg == reg_mcv.register);	1647	} else unreachable; // spilled reg not tracked with spilled instruciton
838	const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];	1648	try tracking.spill(self, inst);
839	try branch.inst_table.put(self.gpa, inst, stack_mcv);	1649	try tracking.trackSpill(self, inst);
840	try self.genSetStack(self.typeOfIndex(inst), stack_mcv.stack_offset, reg_mcv);
841	}	1650	}
842		1651
843	/// Copies a value to a register without tracking the register. The register is not considered	1652	/// Copies a value to a register without tracking the register. The register is not considered
844	/// allocated. A second call to `copyToTmpRegister` may return the same register.	1653	/// allocated. A second call to `copyToTmpRegister` may return the same register.
845	/// This can have a side effect of spilling instructions to the stack to free up a register.	1654	/// This can have a side effect of spilling instructions to the stack to free up a register.
846	fn copyToTmpRegister(self: *Self, ty: Type, mcv: MCValue) !Register {	1655	fn copyToTmpRegister(self: *Self, ty: Type, mcv: MCValue) !Register {
847	const reg = try self.register_manager.allocReg(null, gp);	1656	const reg = try self.register_manager.allocReg(null, tp);
848	try self.genSetReg(ty, reg, mcv);	1657	try self.genSetReg(ty, reg, mcv);
849	return reg;	1658	return reg;
850	}	1659	}
...	@@ -859,51 +1668,84 @@ fn copyToNewRegister(self: *Self, reg_owner: Air.Inst.Index, mcv: MCValue) !MCVa	...	@@ -859,51 +1668,84 @@ fn copyToNewRegister(self: *Self, reg_owner: Air.Inst.Index, mcv: MCValue) !MCVa
859	}	1668	}
860		1669
861	fn airAlloc(self: *Self, inst: Air.Inst.Index) !void {	1670	fn airAlloc(self: *Self, inst: Air.Inst.Index) !void {
862	const stack_offset = try self.allocMemPtr(inst);	1671	const result = MCValue{ .lea_frame = .{ .index = try self.allocMemPtr(inst) } };
863	return self.finishAir(inst, .{ .ptr_stack_offset = stack_offset }, .{ .none, .none, .none });	1672	return self.finishAir(inst, result, .{ .none, .none, .none });
864	}	1673	}
865		1674
866	fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {	1675	fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
867	const stack_offset = try self.allocMemPtr(inst);	1676	const result: MCValue = switch (self.ret_mcv.long) {
868	return self.finishAir(inst, .{ .ptr_stack_offset = stack_offset }, .{ .none, .none, .none });	1677	.none => .{ .lea_frame = .{ .index = try self.allocMemPtr(inst) } },
		1678	.load_frame => .{ .register_offset = .{
		1679	.reg = (try self.copyToNewRegister(
		1680	inst,
		1681	self.ret_mcv.long,
		1682	)).register,
		1683	.off = self.ret_mcv.short.indirect.off,
		1684	} },
		1685	else => \|t\| return self.fail("TODO: airRetPtr {s}", .{@tagName(t)}),
		1686	};
		1687	return self.finishAir(inst, result, .{ .none, .none, .none });
869	}	1688	}
870		1689
871	fn airFptrunc(self: *Self, inst: Air.Inst.Index) !void {	1690	fn airFptrunc(self: *Self, inst: Air.Inst.Index) !void {
872	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	1691	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
873	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFptrunc for {}", .{self.target.cpu.arch});	1692	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airFptrunc for {}", .{self.target.cpu.arch});
874	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	1693	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
875	}	1694	}
876		1695
877	fn airFpext(self: *Self, inst: Air.Inst.Index) !void {	1696	fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
878	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	1697	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
879	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFpext for {}", .{self.target.cpu.arch});	1698	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airFpext for {}", .{self.target.cpu.arch});
880	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	1699	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
881	}	1700	}
882		1701
883	fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {	1702	fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
		1703	const zcu = self.bin_file.comp.module.?;
884	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	1704	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
885	if (self.liveness.isUnused(inst))	1705	const src_ty = self.typeOf(ty_op.operand);
886	return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });	1706	const dst_ty = self.typeOfIndex(inst);
887		1707
888	const mod = self.bin_file.comp.module.?;	1708	const result: MCValue = result: {
889	const operand_ty = self.typeOf(ty_op.operand);	1709	const src_int_info = src_ty.intInfo(zcu);
890	const operand = try self.resolveInst(ty_op.operand);	1710	const dst_int_info = dst_ty.intInfo(zcu);
891	const info_a = operand_ty.intInfo(mod);
892	const info_b = self.typeOfIndex(inst).intInfo(mod);
893	if (info_a.signedness != info_b.signedness)
894	return self.fail("TODO gen intcast sign safety in semantic analysis", .{});
895		1711
896	if (info_a.bits == info_b.bits)	1712	const min_ty = if (dst_int_info.bits < src_int_info.bits) dst_ty else src_ty;
897	return self.finishAir(inst, operand, .{ ty_op.operand, .none, .none });
898		1713
899	return self.fail("TODO implement intCast for {}", .{self.target.cpu.arch});	1714	const src_mcv = try self.resolveInst(ty_op.operand);
900	// return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	1715
		1716	const src_storage_bits: u16 = switch (src_mcv) {
		1717	.register => 64,
		1718	.load_frame => src_int_info.bits,
		1719	else => return self.fail("airIntCast from {s}", .{@tagName(src_mcv)}),
		1720	};
		1721
		1722	const dst_mcv = if (dst_int_info.bits <= src_storage_bits and
		1723	math.divCeil(u16, dst_int_info.bits, 64) catch unreachable ==
		1724	math.divCeil(u32, src_storage_bits, 64) catch unreachable and
		1725	self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) src_mcv else dst: {
		1726	const dst_mcv = try self.allocRegOrMem(inst, true);
		1727	try self.genCopy(min_ty, dst_mcv, src_mcv);
		1728	break :dst dst_mcv;
		1729	};
		1730
		1731	if (dst_int_info.bits <= src_int_info.bits)
		1732	break :result dst_mcv;
		1733
		1734	if (dst_int_info.bits > 64 or src_int_info.bits > 64)
		1735	break :result null; // TODO
		1736
		1737	break :result dst_mcv;
		1738	} orelse return self.fail("TODO implement airIntCast from {} to {}", .{
		1739	src_ty.fmt(zcu), dst_ty.fmt(zcu),
		1740	});
		1741
		1742	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
901	}	1743	}
902		1744
903	fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {	1745	fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
904	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	1746	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
905	if (self.liveness.isUnused(inst))	1747	if (self.liveness.isUnused(inst))
906	return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });	1748	return self.finishAir(inst, .unreach, .{ ty_op.operand, .none, .none });
907		1749
908	const operand = try self.resolveInst(ty_op.operand);	1750	const operand = try self.resolveInst(ty_op.operand);
909	_ = operand;	1751	_ = operand;
...	@@ -914,130 +1756,169 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -914,130 +1756,169 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
914	fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {	1756	fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {
915	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	1757	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
916	const operand = try self.resolveInst(un_op);	1758	const operand = try self.resolveInst(un_op);
917	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else operand;	1759	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else operand;
918	return self.finishAir(inst, result, .{ un_op, .none, .none });	1760	return self.finishAir(inst, result, .{ un_op, .none, .none });
919	}	1761	}
920		1762
921	fn airNot(self: *Self, inst: Air.Inst.Index) !void {	1763	fn airNot(self: *Self, inst: Air.Inst.Index) !void {
922	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	1764	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
923	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement NOT for {}", .{self.target.cpu.arch});	1765	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
924	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	1766	const zcu = self.bin_file.comp.module.?;
925	}
926		1767
927	fn airMin(self: *Self, inst: Air.Inst.Index) !void {	1768	const operand = try self.resolveInst(ty_op.operand);
928	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	1769	const ty = self.typeOf(ty_op.operand);
929	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement min for {}", .{self.target.cpu.arch});
930	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
931	}
932		1770
933	fn airMax(self: *Self, inst: Air.Inst.Index) !void {	1771	switch (ty.zigTypeTag(zcu)) {
934	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	1772	.Bool => {
935	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement max for {}", .{self.target.cpu.arch});	1773	const operand_reg = blk: {
936	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	1774	if (operand == .register) break :blk operand.register;
937	}	1775	break :blk try self.copyToTmpRegister(ty, operand);
		1776	};
938		1777
939	fn airSlice(self: *Self, inst: Air.Inst.Index) !void {	1778	const dst_reg: Register =
940	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	1779	if (self.reuseOperand(inst, ty_op.operand, 0, operand) and operand == .register)
941	const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;	1780	operand.register
942	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice for {}", .{self.target.cpu.arch});	1781	else
943	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	1782	try self.register_manager.allocReg(inst, gp);
		1783
		1784	_ = try self.addInst(.{
		1785	.tag = .pseudo,
		1786	.ops = .pseudo_not,
		1787	.data = .{
		1788	.rr = .{
		1789	.rs = operand_reg,
		1790	.rd = dst_reg,
		1791	},
		1792	},
		1793	});
		1794
		1795	break :result .{ .register = dst_reg };
		1796	},
		1797	.Int => return self.fail("TODO: airNot ints", .{}),
		1798	else => unreachable,
		1799	}
		1800	};
		1801	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
944	}	1802	}
945		1803
946	/// Don't call this function directly. Use binOp instead.	1804	fn airMinMax(
947	///
948	/// Calling this function signals an intention to generate a Mir
949	/// instruction of the form
950	///
951	/// op dest, lhs, rhs
952	///
953	/// Asserts that generating an instruction of that form is possible.
954	fn binOpRegister(
955	self: *Self,	1805	self: *Self,
956	tag: Air.Inst.Tag,	1806	inst: Air.Inst.Index,
957	maybe_inst: ?Air.Inst.Index,	1807	comptime tag: enum {
958	lhs: MCValue,	1808	max,
959	rhs: MCValue,	1809	min,
960	lhs_ty: Type,	1810	},
961	rhs_ty: Type,	1811	) !void {
962	) !MCValue {	1812	const zcu = self.bin_file.comp.module.?;
963	const lhs_is_register = lhs == .register;	1813	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
964	const rhs_is_register = rhs == .register;
965		1814
966	const lhs_lock: ?RegisterLock = if (lhs_is_register)	1815	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
967	self.register_manager.lockReg(lhs.register)	1816	const lhs = try self.resolveInst(bin_op.lhs);
968	else	1817	const rhs = try self.resolveInst(bin_op.rhs);
969	null;	1818	const lhs_ty = self.typeOf(bin_op.lhs);
970	defer if (lhs_lock) \|reg\| self.register_manager.unlockReg(reg);	1819	const rhs_ty = self.typeOf(bin_op.rhs);
971		1820
972	const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];	1821	const int_info = lhs_ty.intInfo(zcu);
973		1822
974	const lhs_reg = if (lhs_is_register) lhs.register else blk: {	1823	if (int_info.bits > 64) return self.fail("TODO: > 64 bit @min", .{});
975	const track_inst: ?Air.Inst.Index = if (maybe_inst) \|inst\| inst: {
976	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
977	break :inst bin_op.lhs.toIndex().?;
978	} else null;
979		1824
980	const reg = try self.register_manager.allocReg(track_inst, gp);	1825	const lhs_reg, const lhs_lock = blk: {
		1826	if (lhs == .register) break :blk .{ lhs.register, null };
981		1827
982	if (track_inst) \|inst\| branch.inst_table.putAssumeCapacity(inst, .{ .register = reg });	1828	const lhs_reg, const lhs_lock = try self.allocReg();
		1829	try self.genSetReg(lhs_ty, lhs_reg, lhs);
		1830	break :blk .{ lhs_reg, lhs_lock };
		1831	};
		1832	defer if (lhs_lock) \|lock\| self.register_manager.unlockReg(lock);
983		1833
984	break :blk reg;	1834	const rhs_reg, const rhs_lock = blk: {
985	};	1835	if (rhs == .register) break :blk .{ rhs.register, null };
986	const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
987	defer if (new_lhs_lock) \|reg\| self.register_manager.unlockReg(reg);
988		1836
989	const rhs_reg = if (rhs_is_register) rhs.register else blk: {	1837	const rhs_reg, const rhs_lock = try self.allocReg();
990	const track_inst: ?Air.Inst.Index = if (maybe_inst) \|inst\| inst: {	1838	try self.genSetReg(rhs_ty, rhs_reg, rhs);
991	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	1839	break :blk .{ rhs_reg, rhs_lock };
992	break :inst bin_op.rhs.toIndex().?;	1840	};
993	} else null;	1841	defer if (rhs_lock) \|lock\| self.register_manager.unlockReg(lock);
994		1842
995	const reg = try self.register_manager.allocReg(track_inst, gp);	1843	const mask_reg, const mask_lock = try self.allocReg();
		1844	defer self.register_manager.unlockReg(mask_lock);
996		1845
997	if (track_inst) \|inst\| branch.inst_table.putAssumeCapacity(inst, .{ .register = reg });	1846	const result_reg, const result_lock = try self.allocReg();
		1847	defer self.register_manager.unlockReg(result_lock);
998		1848
999	break :blk reg;	1849	_ = try self.addInst(.{
1000	};	1850	.tag = if (int_info.signedness == .unsigned) .sltu else .slt,
1001	const new_rhs_lock = self.register_manager.lockReg(rhs_reg);	1851	.ops = .rrr,
1002	defer if (new_rhs_lock) \|reg\| self.register_manager.unlockReg(reg);	1852	.data = .{ .r_type = .{
		1853	.rd = mask_reg,
		1854	.rs1 = lhs_reg,
		1855	.rs2 = rhs_reg,
		1856	} },
		1857	});
1003		1858
1004	const dest_reg = if (maybe_inst) \|inst\| blk: {	1859	_ = try self.addInst(.{
1005	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	1860	.tag = .sub,
		1861	.ops = .rrr,
		1862	.data = .{ .r_type = .{
		1863	.rd = mask_reg,
		1864	.rs1 = .zero,
		1865	.rs2 = mask_reg,
		1866	} },
		1867	});
1006		1868
1007	if (lhs_is_register and self.reuseOperand(inst, bin_op.lhs, 0, lhs)) {	1869	_ = try self.addInst(.{
1008	break :blk lhs_reg;	1870	.tag = .xor,
1009	} else if (rhs_is_register and self.reuseOperand(inst, bin_op.rhs, 1, rhs)) {	1871	.ops = .rrr,
1010	break :blk rhs_reg;	1872	.data = .{ .r_type = .{
1011	} else {	1873	.rd = result_reg,
1012	break :blk try self.register_manager.allocReg(inst, gp);	1874	.rs1 = lhs_reg,
1013	}	1875	.rs2 = rhs_reg,
1014	} else try self.register_manager.allocReg(null, gp);	1876	} },
		1877	});
1015		1878
1016	if (!lhs_is_register) try self.genSetReg(lhs_ty, lhs_reg, lhs);	1879	_ = try self.addInst(.{
1017	if (!rhs_is_register) try self.genSetReg(rhs_ty, rhs_reg, rhs);	1880	.tag = .@"and",
		1881	.ops = .rrr,
		1882	.data = .{ .r_type = .{
		1883	.rd = mask_reg,
		1884	.rs1 = result_reg,
		1885	.rs2 = mask_reg,
		1886	} },
		1887	});
1018		1888
1019	const mir_tag: Mir.Inst.Tag = switch (tag) {	1889	_ = try self.addInst(.{
1020	.add => .add,	1890	.tag = .xor,
1021	.sub => .sub,	1891	.ops = .rrr,
1022	else => unreachable,	1892	.data = .{ .r_type = .{
1023	};	1893	.rd = result_reg,
1024	const mir_data: Mir.Inst.Data = switch (tag) {	1894	.rs1 = if (tag == .min) rhs_reg else lhs_reg,
1025	.add,	1895	.rs2 = mask_reg,
1026	.sub,	1896	} },
1027	=> .{ .r_type = .{	1897	});
1028	.rd = dest_reg,	1898
1029	.rs1 = lhs_reg,	1899	break :result .{ .register = result_reg };
1030	.rs2 = rhs_reg,
1031	} },
1032	else => unreachable,
1033	};	1900	};
		1901	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
		1902	}
1034		1903
1035	_ = try self.addInst(.{	1904	fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
1036	.tag = mir_tag,	1905	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
1037	.data = mir_data,	1906	const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
1038	});	1907	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement slice for {}", .{self.target.cpu.arch});
		1908	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
		1909	}
1039		1910
1040	return MCValue{ .register = dest_reg };	1911	fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
		1912	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
		1913	const lhs = try self.resolveInst(bin_op.lhs);
		1914	const rhs = try self.resolveInst(bin_op.rhs);
		1915	const lhs_ty = self.typeOf(bin_op.lhs);
		1916	const rhs_ty = self.typeOf(bin_op.rhs);
		1917
		1918	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		1919	break :result try self.binOp(tag, lhs, lhs_ty, rhs, rhs_ty);
		1920	};
		1921	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1041	}	1922	}
1042		1923
1043	/// For all your binary operation needs, this function will generate	1924	/// For all your binary operation needs, this function will generate
...	@@ -1052,48 +1933,57 @@ fn binOpRegister(	...	@@ -1052,48 +1933,57 @@ fn binOpRegister(
1052	/// looks at the lhs and rhs and determines which kind of lowering	1933	/// looks at the lhs and rhs and determines which kind of lowering
1053	/// would be best suitable and then delegates the lowering to other	1934	/// would be best suitable and then delegates the lowering to other
1054	/// functions.	1935	/// functions.
		1936	///
		1937	/// `maybe_inst` needs to be a bin_op, make sure of that.
1055	fn binOp(	1938	fn binOp(
1056	self: *Self,	1939	self: *Self,
1057	tag: Air.Inst.Tag,	1940	tag: Air.Inst.Tag,
1058	maybe_inst: ?Air.Inst.Index,
1059	lhs: MCValue,	1941	lhs: MCValue,
1060	rhs: MCValue,
1061	lhs_ty: Type,	1942	lhs_ty: Type,
		1943	rhs: MCValue,
1062	rhs_ty: Type,	1944	rhs_ty: Type,
1063	) InnerError!MCValue {	1945	) InnerError!MCValue {
1064	const mod = self.bin_file.comp.module.?;	1946	const zcu = self.bin_file.comp.module.?;
		1947
1065	switch (tag) {	1948	switch (tag) {
1066	// Arithmetic operations on integers and floats	1949	// Arithmetic operations on integers and floats
1067	.add,	1950	.add,
1068	.sub,	1951	.sub,
		1952	.mul,
		1953	.cmp_eq,
		1954	.cmp_neq,
		1955	.cmp_gt,
		1956	.cmp_gte,
		1957	.cmp_lt,
		1958	.cmp_lte,
1069	=> {	1959	=> {
1070	switch (lhs_ty.zigTypeTag(mod)) {	1960	switch (lhs_ty.zigTypeTag(zcu)) {
1071	.Float => return self.fail("TODO binary operations on floats", .{}),	1961	.Float => return self.fail("TODO binary operations on floats", .{}),
1072	.Vector => return self.fail("TODO binary operations on vectors", .{}),	1962	.Vector => return self.fail("TODO binary operations on vectors", .{}),
1073	.Int => {	1963	.Int => {
1074	assert(lhs_ty.eql(rhs_ty, mod));	1964	assert(lhs_ty.eql(rhs_ty, zcu));
1075	const int_info = lhs_ty.intInfo(mod);	1965	const int_info = lhs_ty.intInfo(zcu);
1076	if (int_info.bits <= 64) {	1966	if (int_info.bits <= 64) {
1077	// TODO immediate operands	1967	return self.binOpRegister(tag, lhs, lhs_ty, rhs, rhs_ty);
1078	return try self.binOpRegister(tag, maybe_inst, lhs, rhs, lhs_ty, rhs_ty);
1079	} else {	1968	} else {
1080	return self.fail("TODO binary operations on int with bits > 64", .{});	1969	return self.fail("TODO binary operations on int with bits > 64", .{});
1081	}	1970	}
1082	},	1971	},
1083	else => unreachable,	1972	else => \|x\| return self.fail("TOOD: binOp {s}", .{@tagName(x)}),
1084	}	1973	}
1085	},	1974	},
		1975
1086	.ptr_add,	1976	.ptr_add,
1087	.ptr_sub,	1977	.ptr_sub,
1088	=> {	1978	=> {
1089	switch (lhs_ty.zigTypeTag(mod)) {	1979	switch (lhs_ty.zigTypeTag(zcu)) {
1090	.Pointer => {	1980	.Pointer => {
1091	const ptr_ty = lhs_ty;	1981	const ptr_ty = lhs_ty;
1092	const elem_ty = switch (ptr_ty.ptrSize(mod)) {	1982	const elem_ty = switch (ptr_ty.ptrSize(zcu)) {
1093	.One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type	1983	.One => ptr_ty.childType(zcu).childType(zcu), // ptr to array, so get array element type
1094	else => ptr_ty.childType(mod),	1984	else => ptr_ty.childType(zcu),
1095	};	1985	};
1096	const elem_size = elem_ty.abiSize(mod);	1986	const elem_size = elem_ty.abiSize(zcu);
1097		1987
1098	if (elem_size == 1) {	1988	if (elem_size == 1) {
1099	const base_tag: Air.Inst.Tag = switch (tag) {	1989	const base_tag: Air.Inst.Tag = switch (tag) {
...	@@ -1102,27 +1992,167 @@ fn binOp(	...	@@ -1102,27 +1992,167 @@ fn binOp(
1102	else => unreachable,	1992	else => unreachable,
1103	};	1993	};
1104		1994
1105	return try self.binOpRegister(base_tag, maybe_inst, lhs, rhs, lhs_ty, rhs_ty);	1995	return try self.binOpRegister(base_tag, lhs, lhs_ty, rhs, rhs_ty);
1106	} else {	1996	} else {
1107	return self.fail("TODO ptr_add with elem_size > 1", .{});	1997	const offset = try self.binOp(
		1998	.mul,
		1999	rhs,
		2000	Type.usize,
		2001	.{ .immediate = elem_size },
		2002	Type.usize,
		2003	);
		2004
		2005	const addr = try self.binOp(
		2006	tag,
		2007	lhs,
		2008	Type.manyptr_u8,
		2009	offset,
		2010	Type.usize,
		2011	);
		2012	return addr;
1108	}	2013	}
1109	},	2014	},
1110	else => unreachable,	2015	else => unreachable,
1111	}	2016	}
1112	},	2017	},
1113	else => unreachable,	2018
		2019	// These instructions have unsymteric bit sizes on RHS and LHS.
		2020	.shr,
		2021	.shl,
		2022	=> {
		2023	switch (lhs_ty.zigTypeTag(zcu)) {
		2024	.Float => return self.fail("TODO binary operations on floats", .{}),
		2025	.Vector => return self.fail("TODO binary operations on vectors", .{}),
		2026	.Int => {
		2027	const int_info = lhs_ty.intInfo(zcu);
		2028	if (int_info.bits <= 64) {
		2029	return self.binOpRegister(tag, lhs, lhs_ty, rhs, rhs_ty);
		2030	} else {
		2031	return self.fail("TODO binary operations on int with bits > 64", .{});
		2032	}
		2033	},
		2034	else => unreachable,
		2035	}
		2036	},
		2037	else => return self.fail("TODO binOp {}", .{tag}),
1114	}	2038	}
1115	}	2039	}
		2040	/// Don't call this function directly. Use binOp instead.
		2041	///
		2042	/// Calling this function signals an intention to generate a Mir
		2043	/// instruction of the form
		2044	///
		2045	/// op dest, lhs, rhs
		2046	///
		2047	/// Asserts that generating an instruction of that form is possible.
		2048	fn binOpRegister(
		2049	self: *Self,
		2050	tag: Air.Inst.Tag,
		2051	lhs: MCValue,
		2052	lhs_ty: Type,
		2053	rhs: MCValue,
		2054	rhs_ty: Type,
		2055	) !MCValue {
		2056	const lhs_reg, const lhs_lock = blk: {
		2057	if (lhs == .register) break :blk .{ lhs.register, null };
1116		2058
1117	fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {	2059	const lhs_reg, const lhs_lock = try self.allocReg();
1118	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2060	try self.genSetReg(lhs_ty, lhs_reg, lhs);
1119	const lhs = try self.resolveInst(bin_op.lhs);	2061	break :blk .{ lhs_reg, lhs_lock };
1120	const rhs = try self.resolveInst(bin_op.rhs);	2062	};
1121	const lhs_ty = self.typeOf(bin_op.lhs);	2063	defer if (lhs_lock) \|lock\| self.register_manager.unlockReg(lock);
1122	const rhs_ty = self.typeOf(bin_op.rhs);
1123		2064
1124	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else try self.binOp(tag, inst, lhs, rhs, lhs_ty, rhs_ty);	2065	const rhs_reg, const rhs_lock = blk: {
1125	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2066	if (rhs == .register) break :blk .{ rhs.register, null };
		2067
		2068	const rhs_reg, const rhs_lock = try self.allocReg();
		2069	try self.genSetReg(rhs_ty, rhs_reg, rhs);
		2070	break :blk .{ rhs_reg, rhs_lock };
		2071	};
		2072	defer if (rhs_lock) \|lock\| self.register_manager.unlockReg(lock);
		2073
		2074	const dest_reg, const dest_lock = try self.allocReg();
		2075	defer self.register_manager.unlockReg(dest_lock);
		2076
		2077	const mir_tag: Mir.Inst.Tag = switch (tag) {
		2078	.add => .add,
		2079	.sub => .sub,
		2080	.mul => .mul,
		2081
		2082	.shl => .sllw,
		2083	.shr => .srlw,
		2084
		2085	.cmp_eq,
		2086	.cmp_neq,
		2087	.cmp_gt,
		2088	.cmp_gte,
		2089	.cmp_lt,
		2090	.cmp_lte,
		2091	=> .pseudo,
		2092
		2093	else => return self.fail("TODO: binOpRegister {s}", .{@tagName(tag)}),
		2094	};
		2095
		2096	switch (mir_tag) {
		2097	.add,
		2098	.sub,
		2099	.mul,
		2100	.sllw,
		2101	.srlw,
		2102	=> {
		2103	_ = try self.addInst(.{
		2104	.tag = mir_tag,
		2105	.ops = .rrr,
		2106	.data = .{
		2107	.r_type = .{
		2108	.rd = dest_reg,
		2109	.rs1 = lhs_reg,
		2110	.rs2 = rhs_reg,
		2111	},
		2112	},
		2113	});
		2114	},
		2115
		2116	.pseudo => {
		2117	const pseudo_op = switch (tag) {
		2118	.cmp_eq,
		2119	.cmp_neq,
		2120	.cmp_gt,
		2121	.cmp_gte,
		2122	.cmp_lt,
		2123	.cmp_lte,
		2124	=> .pseudo_compare,
		2125	else => unreachable,
		2126	};
		2127
		2128	_ = try self.addInst(.{
		2129	.tag = .pseudo,
		2130	.ops = pseudo_op,
		2131	.data = .{
		2132	.compare = .{
		2133	.rd = dest_reg,
		2134	.rs1 = lhs_reg,
		2135	.rs2 = rhs_reg,
		2136	.op = switch (tag) {
		2137	.cmp_eq => .eq,
		2138	.cmp_neq => .neq,
		2139	.cmp_gt => .gt,
		2140	.cmp_gte => .gte,
		2141	.cmp_lt => .lt,
		2142	.cmp_lte => .lte,
		2143	else => unreachable,
		2144	},
		2145	},
		2146	},
		2147	});
		2148	},
		2149
		2150	else => unreachable,
		2151	}
		2152
		2153	// generate the struct for OF checks
		2154
		2155	return MCValue{ .register = dest_reg };
1126	}	2156	}
1127		2157
1128	fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {	2158	fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
...	@@ -1133,55 +2163,150 @@ fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void	...	@@ -1133,55 +2163,150 @@ fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void
1133	const lhs_ty = self.typeOf(bin_op.lhs);	2163	const lhs_ty = self.typeOf(bin_op.lhs);
1134	const rhs_ty = self.typeOf(bin_op.rhs);	2164	const rhs_ty = self.typeOf(bin_op.rhs);
1135		2165
1136	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else try self.binOp(tag, inst, lhs, rhs, lhs_ty, rhs_ty);	2166	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		2167	break :result try self.binOp(tag, lhs, lhs_ty, rhs, rhs_ty);
		2168	};
1137	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2169	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1138	}	2170	}
1139		2171
1140	fn airAddWrap(self: *Self, inst: Air.Inst.Index) !void {	2172	fn airAddWrap(self: *Self, inst: Air.Inst.Index) !void {
1141	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2173	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1142	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement addwrap for {}", .{self.target.cpu.arch});	2174	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement addwrap for {}", .{self.target.cpu.arch});
1143	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2175	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1144	}	2176	}
1145		2177
1146	fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {	2178	fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
1147	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2179	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1148	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement add_sat for {}", .{self.target.cpu.arch});	2180	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement add_sat for {}", .{self.target.cpu.arch});
1149	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2181	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1150	}	2182	}
1151		2183
1152	fn airSubWrap(self: *Self, inst: Air.Inst.Index) !void {	2184	fn airSubWrap(self: *Self, inst: Air.Inst.Index) !void {
1153	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2185	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1154	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement subwrap for {}", .{self.target.cpu.arch});	2186	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		2187	// RISCV arthemtic instructions already wrap, so this is simply a sub binOp with
		2188	// no overflow checks.
		2189	const lhs = try self.resolveInst(bin_op.lhs);
		2190	const rhs = try self.resolveInst(bin_op.rhs);
		2191	const lhs_ty = self.typeOf(bin_op.lhs);
		2192	const rhs_ty = self.typeOf(bin_op.rhs);
		2193
		2194	break :result try self.binOp(.sub, lhs, lhs_ty, rhs, rhs_ty);
		2195	};
1155	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2196	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1156	}	2197	}
1157		2198
1158	fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {	2199	fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
1159	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2200	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1160	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement sub_sat for {}", .{self.target.cpu.arch});	2201	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement sub_sat for {}", .{self.target.cpu.arch});
1161	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2202	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1162	}	2203	}
1163		2204
1164	fn airMul(self: *Self, inst: Air.Inst.Index) !void {	2205	fn airMul(self: *Self, inst: Air.Inst.Index) !void {
1165	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2206	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1166	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mul for {}", .{self.target.cpu.arch});	2207	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement mul for {}", .{self.target.cpu.arch});
1167	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2208	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1168	}	2209	}
1169		2210
1170	fn airMulWrap(self: *Self, inst: Air.Inst.Index) !void {	2211	fn airMulWrap(self: *Self, inst: Air.Inst.Index) !void {
1171	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2212	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1172	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mulwrap for {}", .{self.target.cpu.arch});	2213	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement mulwrap for {}", .{self.target.cpu.arch});
1173	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2214	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1174	}	2215	}
1175		2216
1176	fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {	2217	fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
1177	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2218	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1178	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mul_sat for {}", .{self.target.cpu.arch});	2219	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement mul_sat for {}", .{self.target.cpu.arch});
1179	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2220	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1180	}	2221	}
1181		2222
1182	fn airAddWithOverflow(self: *Self, inst: Air.Inst.Index) !void {	2223	fn airAddWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1183	_ = inst;	2224	const zcu = self.bin_file.comp.module.?;
1184	return self.fail("TODO implement airAddWithOverflow for {}", .{self.target.cpu.arch});	2225	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
		2226	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
		2227
		2228	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		2229	const lhs = try self.resolveInst(extra.lhs);
		2230	const rhs = try self.resolveInst(extra.rhs);
		2231	const lhs_ty = self.typeOf(extra.lhs);
		2232	const rhs_ty = self.typeOf(extra.rhs);
		2233
		2234	const int_info = lhs_ty.intInfo(zcu);
		2235
		2236	const tuple_ty = self.typeOfIndex(inst);
		2237	const result_mcv = try self.allocRegOrMem(inst, false);
		2238	const offset = result_mcv.load_frame;
		2239
		2240	if (int_info.bits >= 8 and math.isPowerOfTwo(int_info.bits)) {
		2241	const add_result = try self.binOp(.add, lhs, lhs_ty, rhs, rhs_ty);
		2242	const add_result_reg = try self.copyToTmpRegister(lhs_ty, add_result);
		2243	const add_result_reg_lock = self.register_manager.lockRegAssumeUnused(add_result_reg);
		2244	defer self.register_manager.unlockReg(add_result_reg_lock);
		2245
		2246	const shift_amount: u6 = @intCast(Type.usize.bitSize(zcu) - int_info.bits);
		2247
		2248	const shift_reg, const shift_lock = try self.allocReg();
		2249	defer self.register_manager.unlockReg(shift_lock);
		2250
		2251	_ = try self.addInst(.{
		2252	.tag = .slli,
		2253	.ops = .rri,
		2254	.data = .{
		2255	.i_type = .{
		2256	.rd = shift_reg,
		2257	.rs1 = add_result_reg,
		2258	.imm12 = Immediate.s(shift_amount),
		2259	},
		2260	},
		2261	});
		2262
		2263	_ = try self.addInst(.{
		2264	.tag = if (int_info.signedness == .unsigned) .srli else .srai,
		2265	.ops = .rri,
		2266	.data = .{
		2267	.i_type = .{
		2268	.rd = shift_reg,
		2269	.rs1 = shift_reg,
		2270	.imm12 = Immediate.s(shift_amount),
		2271	},
		2272	},
		2273	});
		2274
		2275	const add_result_frame: FrameAddr = .{
		2276	.index = offset.index,
		2277	.off = offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(0, zcu))),
		2278	};
		2279	try self.genSetStack(
		2280	lhs_ty,
		2281	add_result_frame,
		2282	add_result,
		2283	);
		2284
		2285	const overflow_mcv = try self.binOp(
		2286	.cmp_neq,
		2287	.{ .register = shift_reg },
		2288	lhs_ty,
		2289	.{ .register = add_result_reg },
		2290	lhs_ty,
		2291	);
		2292
		2293	const overflow_frame: FrameAddr = .{
		2294	.index = offset.index,
		2295	.off = offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(1, zcu))),
		2296	};
		2297	try self.genSetStack(
		2298	Type.u1,
		2299	overflow_frame,
		2300	overflow_mcv,
		2301	);
		2302
		2303	break :result result_mcv;
		2304	} else {
		2305	return self.fail("TODO: less than 8 bit or non-pow 2 addition", .{});
		2306	}
		2307	};
		2308
		2309	return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
1185	}	2310	}
1186		2311
1187	fn airSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {	2312	fn airSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
...	@@ -1190,8 +2315,104 @@ fn airSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1190,8 +2315,104 @@ fn airSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1190	}	2315	}
1191		2316
1192	fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {	2317	fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1193	_ = inst;	2318	//const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
1194	return self.fail("TODO implement airMulWithOverflow for {}", .{self.target.cpu.arch});	2319	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
		2320	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
		2321	const zcu = self.bin_file.comp.module.?;
		2322	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		2323	const lhs = try self.resolveInst(extra.lhs);
		2324	const rhs = try self.resolveInst(extra.rhs);
		2325	const lhs_ty = self.typeOf(extra.lhs);
		2326	const rhs_ty = self.typeOf(extra.rhs);
		2327
		2328	switch (lhs_ty.zigTypeTag(zcu)) {
		2329	else => \|x\| return self.fail("TODO: airMulWithOverflow {s}", .{@tagName(x)}),
		2330	.Int => {
		2331	assert(lhs_ty.eql(rhs_ty, zcu));
		2332	const int_info = lhs_ty.intInfo(zcu);
		2333	switch (int_info.bits) {
		2334	1...32 => {
		2335	if (self.hasFeature(.m)) {
		2336	const dest = try self.binOp(.mul, lhs, lhs_ty, rhs, rhs_ty);
		2337
		2338	const add_result_lock = self.register_manager.lockRegAssumeUnused(dest.register);
		2339	defer self.register_manager.unlockReg(add_result_lock);
		2340
		2341	const tuple_ty = self.typeOfIndex(inst);
		2342
		2343	// TODO: optimization, set this to true. needs the other struct access stuff to support
		2344	// accessing registers.
		2345	const result_mcv = try self.allocRegOrMem(inst, false);
		2346
		2347	const result_off: i32 = @intCast(tuple_ty.structFieldOffset(0, zcu));
		2348	const overflow_off: i32 = @intCast(tuple_ty.structFieldOffset(1, zcu));
		2349
		2350	try self.genSetStack(lhs_ty, result_mcv.offset(result_off).load_frame, dest);
		2351
		2352	if (int_info.bits >= 8 and math.isPowerOfTwo(int_info.bits)) {
		2353	if (int_info.signedness == .unsigned) {
		2354	switch (int_info.bits) {
		2355	1...8 => {
		2356	const max_val = std.math.pow(u16, 2, int_info.bits) - 1;
		2357
		2358	const overflow_reg, const overflow_lock = try self.allocReg();
		2359	defer self.register_manager.unlockReg(overflow_lock);
		2360
		2361	const add_reg, const add_lock = blk: {
		2362	if (dest == .register) break :blk .{ dest.register, null };
		2363
		2364	const add_reg, const add_lock = try self.allocReg();
		2365	try self.genSetReg(lhs_ty, add_reg, dest);
		2366	break :blk .{ add_reg, add_lock };
		2367	};
		2368	defer if (add_lock) \|lock\| self.register_manager.unlockReg(lock);
		2369
		2370	_ = try self.addInst(.{
		2371	.tag = .andi,
		2372	.ops = .rri,
		2373	.data = .{ .i_type = .{
		2374	.rd = overflow_reg,
		2375	.rs1 = add_reg,
		2376	.imm12 = Immediate.s(max_val),
		2377	} },
		2378	});
		2379
		2380	const overflow_mcv = try self.binOp(
		2381	.cmp_neq,
		2382	.{ .register = overflow_reg },
		2383	lhs_ty,
		2384	.{ .register = add_reg },
		2385	lhs_ty,
		2386	);
		2387
		2388	try self.genSetStack(
		2389	lhs_ty,
		2390	result_mcv.offset(overflow_off).load_frame,
		2391	overflow_mcv,
		2392	);
		2393
		2394	break :result result_mcv;
		2395	},
		2396
		2397	else => return self.fail("TODO: airMulWithOverflow check for size {d}", .{int_info.bits}),
		2398	}
		2399	} else {
		2400	return self.fail("TODO: airMulWithOverflow calculate carry for signed addition", .{});
		2401	}
		2402	} else {
		2403	return self.fail("TODO: airMulWithOverflow with < 8 bits or non-pow of 2", .{});
		2404	}
		2405	} else {
		2406	return self.fail("TODO: emulate mul for targets without M feature", .{});
		2407	}
		2408	},
		2409	else => return self.fail("TODO: airMulWithOverflow larger than 32-bit mul", .{}),
		2410	}
		2411	},
		2412	}
		2413	};
		2414
		2415	return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
1195	}	2416	}
1196		2417
1197	fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {	2418	fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
...	@@ -1201,111 +2422,200 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1201,111 +2422,200 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1201		2422
1202	fn airDiv(self: *Self, inst: Air.Inst.Index) !void {	2423	fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
1203	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2424	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1204	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement div for {}", .{self.target.cpu.arch});	2425	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement div for {}", .{self.target.cpu.arch});
1205	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2426	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1206	}	2427	}
1207		2428
1208	fn airRem(self: *Self, inst: Air.Inst.Index) !void {	2429	fn airRem(self: *Self, inst: Air.Inst.Index) !void {
1209	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2430	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1210	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement rem for {}", .{self.target.cpu.arch});	2431	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement rem for {}", .{self.target.cpu.arch});
1211	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2432	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1212	}	2433	}
1213		2434
1214	fn airMod(self: *Self, inst: Air.Inst.Index) !void {	2435	fn airMod(self: *Self, inst: Air.Inst.Index) !void {
1215	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2436	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1216	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mod for {}", .{self.target.cpu.arch});	2437	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement zcu for {}", .{self.target.cpu.arch});
1217	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2438	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1218	}	2439	}
1219		2440
1220	fn airBitAnd(self: *Self, inst: Air.Inst.Index) !void {	2441	fn airBitAnd(self: *Self, inst: Air.Inst.Index) !void {
1221	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2442	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1222	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement bitwise and for {}", .{self.target.cpu.arch});	2443	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement bitwise and for {}", .{self.target.cpu.arch});
1223	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2444	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1224	}	2445	}
1225		2446
1226	fn airBitOr(self: *Self, inst: Air.Inst.Index) !void {	2447	fn airBitOr(self: *Self, inst: Air.Inst.Index) !void {
1227	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2448	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1228	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement bitwise or for {}", .{self.target.cpu.arch});	2449	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement bitwise or for {}", .{self.target.cpu.arch});
1229	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2450	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1230	}	2451	}
1231		2452
1232	fn airXor(self: *Self, inst: Air.Inst.Index) !void {	2453	fn airXor(self: *Self, inst: Air.Inst.Index) !void {
1233	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2454	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1234	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement xor for {}", .{self.target.cpu.arch});	2455	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement xor for {}", .{self.target.cpu.arch});
1235	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2456	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1236	}	2457	}
1237		2458
1238	fn airShl(self: *Self, inst: Air.Inst.Index) !void {	2459	fn airShl(self: *Self, inst: Air.Inst.Index) !void {
1239	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2460	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1240	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shl for {}", .{self.target.cpu.arch});	2461	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		2462	const lhs = try self.resolveInst(bin_op.lhs);
		2463	const rhs = try self.resolveInst(bin_op.rhs);
		2464	const lhs_ty = self.typeOf(bin_op.lhs);
		2465	const rhs_ty = self.typeOf(bin_op.rhs);
		2466
		2467	break :result try self.binOp(.shl, lhs, lhs_ty, rhs, rhs_ty);
		2468	};
1241	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2469	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1242	}	2470	}
1243		2471
1244	fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {	2472	fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
1245	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2473	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1246	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shl_sat for {}", .{self.target.cpu.arch});	2474	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement shl_sat for {}", .{self.target.cpu.arch});
1247	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2475	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1248	}	2476	}
1249		2477
1250	fn airShr(self: *Self, inst: Air.Inst.Index) !void {	2478	fn airShr(self: *Self, inst: Air.Inst.Index) !void {
1251	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2479	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1252	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shr for {}", .{self.target.cpu.arch});	2480	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement shr for {}", .{self.target.cpu.arch});
1253	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2481	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1254	}	2482	}
1255		2483
1256	fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {	2484	fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
1257	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2485	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1258	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload for {}", .{self.target.cpu.arch});	2486	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement .optional_payload for {}", .{self.target.cpu.arch});
1259	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2487	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1260	}	2488	}
1261		2489
1262	fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {	2490	fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
1263	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2491	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1264	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr for {}", .{self.target.cpu.arch});	2492	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement .optional_payload_ptr for {}", .{self.target.cpu.arch});
1265	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2493	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1266	}	2494	}
1267		2495
1268	fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {	2496	fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
1269	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2497	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1270	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr_set for {}", .{self.target.cpu.arch});	2498	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement .optional_payload_ptr_set for {}", .{self.target.cpu.arch});
1271	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2499	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1272	}	2500	}
1273		2501
1274	fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {	2502	fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
1275	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2503	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1276	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union error for {}", .{self.target.cpu.arch});	2504	const zcu = self.bin_file.comp.module.?;
		2505	const err_union_ty = self.typeOf(ty_op.operand);
		2506	const err_ty = err_union_ty.errorUnionSet(zcu);
		2507	const payload_ty = err_union_ty.errorUnionPayload(zcu);
		2508	const operand = try self.resolveInst(ty_op.operand);
		2509
		2510	const result: MCValue = result: {
		2511	if (err_ty.errorSetIsEmpty(zcu)) {
		2512	break :result .{ .immediate = 0 };
		2513	}
		2514
		2515	if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
		2516	break :result operand;
		2517	}
		2518
		2519	const err_off: u32 = @intCast(errUnionErrorOffset(payload_ty, zcu));
		2520
		2521	switch (operand) {
		2522	.register => \|reg\| {
		2523	const eu_lock = self.register_manager.lockReg(reg);
		2524	defer if (eu_lock) \|lock\| self.register_manager.unlockReg(lock);
		2525
		2526	var result = try self.copyToNewRegister(inst, operand);
		2527
		2528	if (err_off > 0) {
		2529	result = try self.binOp(
		2530	.shr,
		2531	result,
		2532	err_union_ty,
		2533	.{ .immediate = @as(u6, @intCast(err_off * 8)) },
		2534	Type.u8,
		2535	);
		2536	}
		2537	break :result result;
		2538	},
		2539	else => return self.fail("TODO implement unwrap_err_err for {}", .{operand}),
		2540	}
		2541	};
		2542
1277	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2543	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1278	}	2544	}
1279		2545
1280	fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {	2546	fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
1281	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2547	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1282	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union payload for {}", .{self.target.cpu.arch});	2548	const operand_ty = self.typeOf(ty_op.operand);
		2549	const operand = try self.resolveInst(ty_op.operand);
		2550	const result = try self.genUnwrapErrUnionPayloadMir(operand_ty, operand);
1283	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2551	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1284	}	2552	}
1285		2553
		2554	fn genUnwrapErrUnionPayloadMir(
		2555	self: *Self,
		2556	err_union_ty: Type,
		2557	err_union: MCValue,
		2558	) !MCValue {
		2559	const zcu = self.bin_file.comp.module.?;
		2560	const payload_ty = err_union_ty.errorUnionPayload(zcu);
		2561
		2562	const result: MCValue = result: {
		2563	if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
		2564
		2565	const payload_off: u31 = @intCast(errUnionPayloadOffset(payload_ty, zcu));
		2566	switch (err_union) {
		2567	.load_frame => \|frame_addr\| break :result .{ .load_frame = .{
		2568	.index = frame_addr.index,
		2569	.off = frame_addr.off + payload_off,
		2570	} },
		2571	.register => \|reg\| {
		2572	const eu_lock = self.register_manager.lockReg(reg);
		2573	defer if (eu_lock) \|lock\| self.register_manager.unlockReg(lock);
		2574
		2575	var result: MCValue = .{ .register = try self.copyToTmpRegister(err_union_ty, err_union) };
		2576
		2577	if (payload_off > 0) {
		2578	result = try self.binOp(
		2579	.shr,
		2580	result,
		2581	err_union_ty,
		2582	.{ .immediate = @as(u6, @intCast(payload_off * 8)) },
		2583	Type.u8,
		2584	);
		2585	}
		2586
		2587	break :result result;
		2588	},
		2589	else => return self.fail("TODO implement genUnwrapErrUnionPayloadMir for {}", .{err_union}),
		2590	}
		2591	};
		2592
		2593	return result;
		2594	}
		2595
1286	// *(E!T) -> E	2596	// *(E!T) -> E
1287	fn airUnwrapErrErrPtr(self: *Self, inst: Air.Inst.Index) !void {	2597	fn airUnwrapErrErrPtr(self: *Self, inst: Air.Inst.Index) !void {
1288	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2598	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1289	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union error ptr for {}", .{self.target.cpu.arch});	2599	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement unwrap error union error ptr for {}", .{self.target.cpu.arch});
1290	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2600	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1291	}	2601	}
1292		2602
1293	// (E!T) -> T	2603	// (E!T) -> T
1294	fn airUnwrapErrPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {	2604	fn airUnwrapErrPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
1295	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2605	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1296	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union payload ptr for {}", .{self.target.cpu.arch});	2606	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement unwrap error union payload ptr for {}", .{self.target.cpu.arch});
1297	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2607	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1298	}	2608	}
1299		2609
1300	fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {	2610	fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
1301	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2611	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1302	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .errunion_payload_ptr_set for {}", .{self.target.cpu.arch});	2612	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement .errunion_payload_ptr_set for {}", .{self.target.cpu.arch});
1303	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2613	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1304	}	2614	}
1305		2615
1306	fn airErrReturnTrace(self: *Self, inst: Air.Inst.Index) !void {	2616	fn airErrReturnTrace(self: *Self, inst: Air.Inst.Index) !void {
1307	const result: MCValue = if (self.liveness.isUnused(inst))	2617	const result: MCValue = if (self.liveness.isUnused(inst))
1308	.dead	2618	.unreach
1309	else	2619	else
1310	return self.fail("TODO implement airErrReturnTrace for {}", .{self.target.cpu.arch});	2620	return self.fail("TODO implement airErrReturnTrace for {}", .{self.target.cpu.arch});
1311	return self.finishAir(inst, result, .{ .none, .none, .none });	2621	return self.finishAir(inst, result, .{ .none, .none, .none });
...	@@ -1323,12 +2633,12 @@ fn airSaveErrReturnTraceIndex(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1323,12 +2633,12 @@ fn airSaveErrReturnTraceIndex(self: *Self, inst: Air.Inst.Index) !void {
1323		2633
1324	fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {	2634	fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
1325	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2635	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1326	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	2636	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
1327	const mod = self.bin_file.comp.module.?;	2637	const zcu = self.bin_file.comp.module.?;
1328	const optional_ty = self.typeOfIndex(inst);	2638	const optional_ty = self.typeOfIndex(inst);
1329		2639
1330	// Optional with a zero-bit payload type is just a boolean true	2640	// Optional with a zero-bit payload type is just a boolean true
1331	if (optional_ty.abiSize(mod) == 1)	2641	if (optional_ty.abiSize(zcu) == 1)
1332	break :result MCValue{ .immediate = 1 };	2642	break :result MCValue{ .immediate = 1 };
1333		2643
1334	return self.fail("TODO implement wrap optional for {}", .{self.target.cpu.arch});	2644	return self.fail("TODO implement wrap optional for {}", .{self.target.cpu.arch});
...	@@ -1339,72 +2649,251 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1339,72 +2649,251 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
1339	/// T to E!T	2649	/// T to E!T
1340	fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {	2650	fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
1341	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2651	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1342	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement wrap errunion payload for {}", .{self.target.cpu.arch});	2652	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement wrap errunion payload for {}", .{self.target.cpu.arch});
1343	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2653	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1344	}	2654	}
1345		2655
1346	/// E to E!T	2656	/// E to E!T
1347	fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {	2657	fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
		2658	const zcu = self.bin_file.comp.module.?;
1348	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2659	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1349	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement wrap errunion error for {}", .{self.target.cpu.arch});	2660
		2661	const eu_ty = ty_op.ty.toType();
		2662	const pl_ty = eu_ty.errorUnionPayload(zcu);
		2663	const err_ty = eu_ty.errorUnionSet(zcu);
		2664
		2665	const result: MCValue = result: {
		2666	if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result try self.resolveInst(ty_op.operand);
		2667
		2668	const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(eu_ty, zcu));
		2669	const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
		2670	const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, zcu));
		2671	try self.genSetStack(pl_ty, .{ .index = frame_index, .off = pl_off }, .undef);
		2672	const operand = try self.resolveInst(ty_op.operand);
		2673	try self.genSetStack(err_ty, .{ .index = frame_index, .off = err_off }, operand);
		2674	break :result .{ .load_frame = .{ .index = frame_index } };
		2675	};
1350	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2676	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1351	}	2677	}
1352		2678
		2679	fn airTry(self: *Self, inst: Air.Inst.Index) !void {
		2680	const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
		2681	const extra = self.air.extraData(Air.Try, pl_op.payload);
		2682	const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
		2683	const operand_ty = self.typeOf(pl_op.operand);
		2684	const result = try self.genTry(inst, pl_op.operand, body, operand_ty, false);
		2685	return self.finishAir(inst, result, .{ .none, .none, .none });
		2686	}
		2687
		2688	fn genTry(
		2689	self: *Self,
		2690	inst: Air.Inst.Index,
		2691	operand: Air.Inst.Ref,
		2692	body: []const Air.Inst.Index,
		2693	operand_ty: Type,
		2694	operand_is_ptr: bool,
		2695	) !MCValue {
		2696	_ = operand_is_ptr;
		2697
		2698	const liveness_cond_br = self.liveness.getCondBr(inst);
		2699
		2700	const operand_mcv = try self.resolveInst(operand);
		2701	const is_err_mcv = try self.isErr(null, operand_ty, operand_mcv);
		2702
		2703	// A branch to the false section. Uses beq. 1 is the default "true" state.
		2704	const reloc = try self.condBr(Type.anyerror, is_err_mcv);
		2705
		2706	if (self.liveness.operandDies(inst, 0)) {
		2707	if (operand.toIndex()) \|operand_inst\| try self.processDeath(operand_inst);
		2708	}
		2709
		2710	self.scope_generation += 1;
		2711	const state = try self.saveState();
		2712
		2713	for (liveness_cond_br.else_deaths) \|death\| try self.processDeath(death);
		2714	try self.genBody(body);
		2715	try self.restoreState(state, &.{}, .{
		2716	.emit_instructions = false,
		2717	.update_tracking = true,
		2718	.resurrect = true,
		2719	.close_scope = true,
		2720	});
		2721
		2722	self.performReloc(reloc);
		2723
		2724	for (liveness_cond_br.then_deaths) \|death\| try self.processDeath(death);
		2725
		2726	const result = if (self.liveness.isUnused(inst))
		2727	.unreach
		2728	else
		2729	try self.genUnwrapErrUnionPayloadMir(operand_ty, operand_mcv);
		2730
		2731	return result;
		2732	}
		2733
1353	fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {	2734	fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
1354	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2735	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1355	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice_ptr for {}", .{self.target.cpu.arch});	2736	const result = result: {
		2737	const src_mcv = try self.resolveInst(ty_op.operand);
		2738	if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv;
		2739
		2740	const dst_mcv = try self.allocRegOrMem(inst, true);
		2741	const dst_ty = self.typeOfIndex(inst);
		2742	try self.genCopy(dst_ty, dst_mcv, src_mcv);
		2743	break :result dst_mcv;
		2744	};
1356	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2745	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1357	}	2746	}
1358		2747
1359	fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {	2748	fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
1360	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2749	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1361	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice_len for {}", .{self.target.cpu.arch});	2750	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		2751	const src_mcv = try self.resolveInst(ty_op.operand);
		2752	switch (src_mcv) {
		2753	.load_frame => \|frame_addr\| {
		2754	const len_mcv: MCValue = .{ .load_frame = .{
		2755	.index = frame_addr.index,
		2756	.off = frame_addr.off + 8,
		2757	} };
		2758	if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result len_mcv;
		2759
		2760	const dst_mcv = try self.allocRegOrMem(inst, true);
		2761	try self.genCopy(Type.usize, dst_mcv, len_mcv);
		2762	break :result dst_mcv;
		2763	},
		2764	.register_pair => \|pair\| {
		2765	const len_mcv: MCValue = .{ .register = pair[1] };
		2766
		2767	if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result len_mcv;
		2768
		2769	const dst_mcv = try self.allocRegOrMem(inst, true);
		2770	try self.genCopy(Type.usize, dst_mcv, len_mcv);
		2771	break :result dst_mcv;
		2772	},
		2773	else => return self.fail("TODO airSliceLen for {}", .{src_mcv}),
		2774	}
		2775	};
1362	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2776	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1363	}	2777	}
1364		2778
1365	fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {	2779	fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
1366	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2780	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1367	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_slice_len_ptr for {}", .{self.target.cpu.arch});	2781	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement ptr_slice_len_ptr for {}", .{self.target.cpu.arch});
1368	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2782	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1369	}	2783	}
1370		2784
1371	fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {	2785	fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
1372	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2786	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1373	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_slice_ptr_ptr for {}", .{self.target.cpu.arch});	2787	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement ptr_slice_ptr_ptr for {}", .{self.target.cpu.arch});
1374	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2788	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1375	}	2789	}
1376		2790
1377	fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {	2791	fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
		2792	const zcu = self.bin_file.comp.module.?;
1378	const is_volatile = false; // TODO	2793	const is_volatile = false; // TODO
1379	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2794	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1380	const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice_elem_val for {}", .{self.target.cpu.arch});	2795
		2796	if (!is_volatile and self.liveness.isUnused(inst)) return self.finishAir(
		2797	inst,
		2798	.unreach,
		2799	.{ bin_op.lhs, bin_op.rhs, .none },
		2800	);
		2801	const result: MCValue = result: {
		2802	const slice_mcv = try self.resolveInst(bin_op.lhs);
		2803	const index_mcv = try self.resolveInst(bin_op.rhs);
		2804
		2805	const slice_ty = self.typeOf(bin_op.lhs);
		2806
		2807	const slice_ptr_field_type = slice_ty.slicePtrFieldType(zcu);
		2808
		2809	const index_lock: ?RegisterLock = if (index_mcv == .register)
		2810	self.register_manager.lockRegAssumeUnused(index_mcv.register)
		2811	else
		2812	null;
		2813	defer if (index_lock) \|reg\| self.register_manager.unlockReg(reg);
		2814
		2815	const base_mcv: MCValue = switch (slice_mcv) {
		2816	.load_frame,
		2817	.load_symbol,
		2818	=> .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, slice_mcv) },
		2819	else => return self.fail("TODO slice_elem_val when slice is {}", .{slice_mcv}),
		2820	};
		2821
		2822	const dest = try self.allocRegOrMem(inst, true);
		2823	const addr = try self.binOp(.ptr_add, base_mcv, slice_ptr_field_type, index_mcv, Type.usize);
		2824	try self.load(dest, addr, slice_ptr_field_type);
		2825
		2826	break :result dest;
		2827	};
1381	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2828	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1382	}	2829	}
1383		2830
1384	fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {	2831	fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {
1385	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	2832	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
1386	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;	2833	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
1387	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice_elem_ptr for {}", .{self.target.cpu.arch});	2834	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement slice_elem_ptr for {}", .{self.target.cpu.arch});
1388	return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });	2835	return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
1389	}	2836	}
1390		2837
1391	fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {	2838	fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
		2839	const zcu = self.bin_file.comp.module.?;
1392	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2840	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1393	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement array_elem_val for {}", .{self.target.cpu.arch});	2841	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		2842	const array_ty = self.typeOf(bin_op.lhs);
		2843	const array_mcv = try self.resolveInst(bin_op.lhs);
		2844
		2845	const index_mcv = try self.resolveInst(bin_op.rhs);
		2846	const index_ty = self.typeOf(bin_op.rhs);
		2847
		2848	const elem_ty = array_ty.childType(zcu);
		2849	const elem_abi_size = elem_ty.abiSize(zcu);
		2850
		2851	const addr_reg, const addr_reg_lock = try self.allocReg();
		2852	defer self.register_manager.unlockReg(addr_reg_lock);
		2853
		2854	switch (array_mcv) {
		2855	.register => {
		2856	const frame_index = try self.allocFrameIndex(FrameAlloc.initType(array_ty, zcu));
		2857	try self.genSetStack(array_ty, .{ .index = frame_index }, array_mcv);
		2858	try self.genSetReg(Type.usize, addr_reg, .{ .lea_frame = .{ .index = frame_index } });
		2859	},
		2860	.load_frame => \|frame_addr\| {
		2861	try self.genSetReg(Type.usize, addr_reg, .{ .lea_frame = frame_addr });
		2862	},
		2863	else => try self.genSetReg(Type.usize, addr_reg, array_mcv.address()),
		2864	}
		2865
		2866	const offset_reg = try self.elemOffset(index_ty, index_mcv, elem_abi_size);
		2867	const offset_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
		2868	defer self.register_manager.unlockReg(offset_lock);
		2869
		2870	const dst_mcv = try self.allocRegOrMem(inst, false);
		2871	_ = try self.addInst(.{
		2872	.tag = .add,
		2873	.ops = .rrr,
		2874	.data = .{ .r_type = .{
		2875	.rd = addr_reg,
		2876	.rs1 = offset_reg,
		2877	.rs2 = addr_reg,
		2878	} },
		2879	});
		2880	try self.genCopy(elem_ty, dst_mcv, .{ .indirect = .{ .reg = addr_reg } });
		2881	break :result dst_mcv;
		2882	};
1394	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2883	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1395	}	2884	}
1396		2885
1397	fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {	2886	fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
1398	const is_volatile = false; // TODO	2887	const is_volatile = false; // TODO
1399	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2888	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1400	const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_val for {}", .{self.target.cpu.arch});	2889	const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement ptr_elem_val for {}", .{self.target.cpu.arch});
1401	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });	2890	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1402	}	2891	}
1403		2892
1404	fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {	2893	fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
1405	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	2894	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
1406	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;	2895	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
1407	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_ptr for {}", .{self.target.cpu.arch});	2896	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement ptr_elem_ptr for {}", .{self.target.cpu.arch});
1408	return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });	2897	return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
1409	}	2898	}
1410		2899
...	@@ -1417,124 +2906,234 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1417,124 +2906,234 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
1417		2906
1418	fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {	2907	fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
1419	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2908	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1420	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airGetUnionTag for {}", .{self.target.cpu.arch});	2909	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airGetUnionTag for {}", .{self.target.cpu.arch});
1421	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2910	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1422	}	2911	}
1423		2912
1424	fn airClz(self: *Self, inst: Air.Inst.Index) !void {	2913	fn airClz(self: *Self, inst: Air.Inst.Index) !void {
1425	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2914	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1426	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airClz for {}", .{self.target.cpu.arch});	2915	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airClz for {}", .{self.target.cpu.arch});
1427	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2916	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1428	}	2917	}
1429		2918
1430	fn airCtz(self: *Self, inst: Air.Inst.Index) !void {	2919	fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
1431	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2920	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1432	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCtz for {}", .{self.target.cpu.arch});	2921	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		2922	const operand = try self.resolveInst(ty_op.operand);
		2923	const operand_ty = self.typeOf(ty_op.operand);
		2924
		2925	const dest_reg = try self.register_manager.allocReg(inst, gp);
		2926
		2927	const source_reg, const source_lock = blk: {
		2928	if (operand == .register) break :blk .{ operand.register, null };
		2929
		2930	const source_reg, const source_lock = try self.allocReg();
		2931	try self.genSetReg(operand_ty, source_reg, operand);
		2932	break :blk .{ source_reg, source_lock };
		2933	};
		2934	defer if (source_lock) \|lock\| self.register_manager.unlockReg(lock);
		2935
		2936	// TODO: the B extension for RISCV should have the ctz instruction, and we should use it.
		2937
		2938	try self.ctz(source_reg, dest_reg, operand_ty);
		2939
		2940	break :result .{ .register = dest_reg };
		2941	};
1433	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2942	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1434	}	2943	}
1435		2944
		2945	fn ctz(self: *Self, src: Register, dst: Register, ty: Type) !void {
		2946	const zcu = self.bin_file.comp.module.?;
		2947	const length = (ty.abiSize(zcu) * 8) - 1;
		2948
		2949	const count_reg, const count_lock = try self.allocReg();
		2950	defer self.register_manager.unlockReg(count_lock);
		2951
		2952	const len_reg, const len_lock = try self.allocReg();
		2953	defer self.register_manager.unlockReg(len_lock);
		2954
		2955	try self.genSetReg(Type.usize, count_reg, .{ .immediate = 0 });
		2956	try self.genSetReg(Type.usize, len_reg, .{ .immediate = length });
		2957
		2958	_ = src;
		2959	_ = dst;
		2960
		2961	return self.fail("TODO: finish ctz", .{});
		2962	}
		2963
1436	fn airPopcount(self: *Self, inst: Air.Inst.Index) !void {	2964	fn airPopcount(self: *Self, inst: Air.Inst.Index) !void {
1437	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2965	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1438	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airPopcount for {}", .{self.target.cpu.arch});	2966	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airPopcount for {}", .{self.target.cpu.arch});
1439	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	2967	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1440	}	2968	}
1441		2969
1442	fn airAbs(self: *Self, inst: Air.Inst.Index) !void {	2970	fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
		2971	const zcu = self.bin_file.comp.module.?;
1443	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2972	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1444	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airAbs for {}", .{self.target.cpu.arch});	2973	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		2974	const ty = self.typeOf(ty_op.operand);
		2975	const scalar_ty = ty.scalarType(zcu);
		2976	const operand = try self.resolveInst(ty_op.operand);
		2977
		2978	switch (scalar_ty.zigTypeTag(zcu)) {
		2979	.Int => if (ty.zigTypeTag(zcu) == .Vector) {
		2980	return self.fail("TODO implement airAbs for {}", .{ty.fmt(zcu)});
		2981	} else {
		2982	const int_bits = ty.intInfo(zcu).bits;
		2983
		2984	if (int_bits > 32) {
		2985	return self.fail("TODO: airAbs for larger than 32 bits", .{});
		2986	}
		2987
		2988	// promote the src into a register
		2989	const src_mcv = try self.copyToNewRegister(inst, operand);
		2990	// temp register for shift
		2991	const temp_reg = try self.register_manager.allocReg(inst, gp);
		2992
		2993	_ = try self.addInst(.{
		2994	.tag = .abs,
		2995	.ops = .rri,
		2996	.data = .{
		2997	.i_type = .{
		2998	.rs1 = src_mcv.register,
		2999	.rd = temp_reg,
		3000	.imm12 = Immediate.s(int_bits - 1),
		3001	},
		3002	},
		3003	});
		3004
		3005	break :result src_mcv;
		3006	},
		3007	else => return self.fail("TODO: implement airAbs {}", .{scalar_ty.fmt(zcu)}),
		3008	}
		3009	};
1445	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	3010	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1446	}	3011	}
1447		3012
1448	fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {	3013	fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
1449	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	3014	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1450	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airByteSwap for {}", .{self.target.cpu.arch});	3015	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		3016	const zcu = self.bin_file.comp.module.?;
		3017	const ty = self.typeOf(ty_op.operand);
		3018	const operand = try self.resolveInst(ty_op.operand);
		3019
		3020	const int_bits = ty.intInfo(zcu).bits;
		3021
		3022	// bytes are no-op
		3023	if (int_bits == 8 and self.reuseOperand(inst, ty_op.operand, 0, operand)) {
		3024	return self.finishAir(inst, operand, .{ ty_op.operand, .none, .none });
		3025	}
		3026
		3027	const dest_reg = try self.register_manager.allocReg(null, gp);
		3028	try self.genSetReg(ty, dest_reg, operand);
		3029
		3030	const dest_mcv: MCValue = .{ .register = dest_reg };
		3031
		3032	switch (int_bits) {
		3033	16 => {
		3034	const temp = try self.binOp(.shr, dest_mcv, ty, .{ .immediate = 8 }, Type.u8);
		3035	assert(temp == .register);
		3036	_ = try self.addInst(.{
		3037	.tag = .slli,
		3038	.ops = .rri,
		3039	.data = .{ .i_type = .{
		3040	.imm12 = Immediate.s(8),
		3041	.rd = dest_reg,
		3042	.rs1 = dest_reg,
		3043	} },
		3044	});
		3045	_ = try self.addInst(.{
		3046	.tag = .@"or",
		3047	.ops = .rri,
		3048	.data = .{ .r_type = .{
		3049	.rd = dest_reg,
		3050	.rs1 = dest_reg,
		3051	.rs2 = temp.register,
		3052	} },
		3053	});
		3054	},
		3055	else => return self.fail("TODO: {d} bits for airByteSwap", .{int_bits}),
		3056	}
		3057
		3058	break :result dest_mcv;
		3059	};
1451	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	3060	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1452	}	3061	}
1453		3062
1454	fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {	3063	fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
1455	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	3064	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1456	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airBitReverse for {}", .{self.target.cpu.arch});	3065	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airBitReverse for {}", .{self.target.cpu.arch});
1457	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	3066	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1458	}	3067	}
1459		3068
1460	fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void {	3069	fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void {
1461	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	3070	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1462	const result: MCValue = if (self.liveness.isUnused(inst))	3071	const result: MCValue = if (self.liveness.isUnused(inst))
1463	.dead	3072	.unreach
1464	else	3073	else
1465	return self.fail("TODO implement airUnaryMath for {}", .{self.target.cpu.arch});	3074	return self.fail("TODO implement airUnaryMath for {}", .{self.target.cpu.arch});
1466	return self.finishAir(inst, result, .{ un_op, .none, .none });	3075	return self.finishAir(inst, result, .{ un_op, .none, .none });
1467	}	3076	}
1468		3077
1469	fn reuseOperand(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, op_index: Liveness.OperandInt, mcv: MCValue) bool {	3078	fn reuseOperand(
		3079	self: *Self,
		3080	inst: Air.Inst.Index,
		3081	operand: Air.Inst.Ref,
		3082	op_index: Liveness.OperandInt,
		3083	mcv: MCValue,
		3084	) bool {
		3085	return self.reuseOperandAdvanced(inst, operand, op_index, mcv, inst);
		3086	}
		3087
		3088	fn reuseOperandAdvanced(
		3089	self: *Self,
		3090	inst: Air.Inst.Index,
		3091	operand: Air.Inst.Ref,
		3092	op_index: Liveness.OperandInt,
		3093	mcv: MCValue,
		3094	maybe_tracked_inst: ?Air.Inst.Index,
		3095	) bool {
1470	if (!self.liveness.operandDies(inst, op_index))	3096	if (!self.liveness.operandDies(inst, op_index))
1471	return false;	3097	return false;
1472		3098
1473	switch (mcv) {	3099	switch (mcv) {
1474	.register => \|reg\| {	3100	.register,
1475	// If it's in the registers table, need to associate the register with the	3101	.register_pair,
		3102	=> for (mcv.getRegs()) \|reg\| {
		3103	// If it's in the registers table, need to associate the register(s) with the
1476	// new instruction.	3104	// new instruction.
1477	if (RegisterManager.indexOfRegIntoTracked(reg)) \|index\| {	3105	if (maybe_tracked_inst) \|tracked_inst\| {
1478	if (!self.register_manager.isRegFree(reg)) {	3106	if (!self.register_manager.isRegFree(reg)) {
1479	self.register_manager.registers[index] = inst;	3107	if (RegisterManager.indexOfRegIntoTracked(reg)) \|index\| {
		3108	self.register_manager.registers[index] = tracked_inst;
		3109	}
1480	}	3110	}
1481	}	3111	} else self.register_manager.freeReg(reg);
1482	log.debug("%{d} => {} (reused)", .{ inst, reg });
1483	},
1484	.stack_offset => \|off\| {
1485	log.debug("%{d} => stack offset {d} (reused)", .{ inst, off });
1486	},	3112	},
		3113	.load_frame => \|frame_addr\| if (frame_addr.index.isNamed()) return false,
1487	else => return false,	3114	else => return false,
1488	}	3115	}
1489		3116
1490	// Prevent the operand deaths processing code from deallocating it.	3117	// Prevent the operand deaths processing code from deallocating it.
1491	self.liveness.clearOperandDeath(inst, op_index);	3118	self.liveness.clearOperandDeath(inst, op_index);
1492		3119	const op_inst = operand.toIndex().?;
1493	// That makes us responsible for doing the rest of the stuff that processDeath would have done.	3120	self.getResolvedInstValue(op_inst).reuse(self, maybe_tracked_inst, op_inst);
1494	const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
1495	branch.inst_table.putAssumeCapacity(operand.toIndex().?, .dead);
1496		3121
1497	return true;	3122	return true;
1498	}	3123	}
1499		3124
1500	fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {
1501	const mod = self.bin_file.comp.module.?;
1502	const elem_ty = ptr_ty.childType(mod);
1503	switch (ptr) {
1504	.none => unreachable,
1505	.undef => unreachable,
1506	.unreach => unreachable,
1507	.dead => unreachable,
1508	.immediate => \|imm\| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),
1509	.ptr_stack_offset => \|off\| try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off }),
1510	.register => {
1511	return self.fail("TODO implement loading from MCValue.register", .{});
1512	},
1513	.memory,
1514	.stack_offset,
1515	=> {
1516	const reg = try self.register_manager.allocReg(null, gp);
1517	const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
1518	defer self.register_manager.unlockReg(reg_lock);
1519
1520	try self.genSetReg(ptr_ty, reg, ptr);
1521	try self.load(dst_mcv, .{ .register = reg }, ptr_ty);
1522	},
1523	}
1524	}
1525
1526	fn airLoad(self: *Self, inst: Air.Inst.Index) !void {	3125	fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
1527	const mod = self.bin_file.comp.module.?;	3126	const zcu = self.bin_file.comp.module.?;
1528	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	3127	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1529	const elem_ty = self.typeOfIndex(inst);	3128	const elem_ty = self.typeOfIndex(inst);
1530	const result: MCValue = result: {	3129	const result: MCValue = result: {
1531	if (!elem_ty.hasRuntimeBits(mod))	3130	if (!elem_ty.hasRuntimeBits(zcu))
1532	break :result MCValue.none;	3131	break :result .none;
1533		3132
1534	const ptr = try self.resolveInst(ty_op.operand);	3133	const ptr = try self.resolveInst(ty_op.operand);
1535	const is_volatile = self.typeOf(ty_op.operand).isVolatilePtr(mod);	3134	const is_volatile = self.typeOf(ty_op.operand).isVolatilePtr(zcu);
1536	if (self.liveness.isUnused(inst) and !is_volatile)	3135	if (self.liveness.isUnused(inst) and !is_volatile)
1537	break :result MCValue.dead;	3136	break :result .unreach;
1538		3137
1539	const dst_mcv: MCValue = blk: {	3138	const dst_mcv: MCValue = blk: {
1540	if (self.reuseOperand(inst, ty_op.operand, 0, ptr)) {	3139	if (self.reuseOperand(inst, ty_op.operand, 0, ptr)) {
...	@@ -1544,35 +3143,47 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1544,35 +3143,47 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
1544	break :blk try self.allocRegOrMem(inst, true);	3143	break :blk try self.allocRegOrMem(inst, true);
1545	}	3144	}
1546	};	3145	};
		3146
1547	try self.load(dst_mcv, ptr, self.typeOf(ty_op.operand));	3147	try self.load(dst_mcv, ptr, self.typeOf(ty_op.operand));
1548	break :result dst_mcv;	3148	break :result dst_mcv;
1549	};	3149	};
1550	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	3150	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1551	}	3151	}
1552		3152
1553	fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type) !void {	3153	fn load(self: *Self, dst_mcv: MCValue, ptr_mcv: MCValue, ptr_ty: Type) InnerError!void {
1554	_ = ptr_ty;	3154	const zcu = self.bin_file.comp.module.?;
		3155	const dst_ty = ptr_ty.childType(zcu);
		3156
		3157	log.debug("loading {}:{} into {}", .{ ptr_mcv, ptr_ty.fmt(zcu), dst_mcv });
		3158
		3159	switch (ptr_mcv) {
		3160	.none,
		3161	.undef,
		3162	.unreach,
		3163	.dead,
		3164	.register_pair,
		3165	.reserved_frame,
		3166	=> unreachable, // not a valid pointer
		3167
		3168	.immediate,
		3169	.register,
		3170	.register_offset,
		3171	.lea_frame,
		3172	.lea_symbol,
		3173	=> try self.genCopy(dst_ty, dst_mcv, ptr_mcv.deref()),
1555		3174
1556	switch (ptr) {	3175	.memory,
1557	.none => unreachable,	3176	.indirect,
1558	.undef => unreachable,	3177	.load_symbol,
1559	.unreach => unreachable,	3178	.load_frame,
1560	.dead => unreachable,	3179	=> {
1561	.immediate => \|imm\| {	3180	const addr_reg = try self.copyToTmpRegister(ptr_ty, ptr_mcv);
1562	try self.setRegOrMem(value_ty, .{ .memory = imm }, value);	3181	const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
1563	},	3182	defer self.register_manager.unlockReg(addr_lock);
1564	.ptr_stack_offset => \|off\| {	3183
1565	try self.genSetStack(value_ty, off, value);	3184	try self.genCopy(dst_ty, dst_mcv, .{ .indirect = .{ .reg = addr_reg } });
1566	},
1567	.register => {
1568	return self.fail("TODO implement storing to MCValue.register", .{});
1569	},
1570	.memory => {
1571	return self.fail("TODO implement storing to MCValue.memory", .{});
1572	},
1573	.stack_offset => {
1574	return self.fail("TODO implement storing to MCValue.stack_offset", .{});
1575	},	3185	},
		3186	.air_ref => \|ptr_ref\| try self.load(dst_mcv, try self.resolveInst(ptr_ref), ptr_ty),
1576	}	3187	}
1577	}	3188	}
1578		3189
...	@@ -1590,33 +3201,186 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {	...	@@ -1590,33 +3201,186 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
1590		3201
1591	try self.store(ptr, value, ptr_ty, value_ty);	3202	try self.store(ptr, value, ptr_ty, value_ty);
1592		3203
1593	return self.finishAir(inst, .dead, .{ bin_op.lhs, bin_op.rhs, .none });	3204	return self.finishAir(inst, .none, .{ bin_op.lhs, bin_op.rhs, .none });
		3205	}
		3206
		3207	/// Loads `value` into the "payload" of `pointer`.
		3208	fn store(self: *Self, ptr_mcv: MCValue, src_mcv: MCValue, ptr_ty: Type, src_ty: Type) !void {
		3209	const zcu = self.bin_file.comp.module.?;
		3210
		3211	log.debug("storing {}:{} in {}:{}", .{ src_mcv, src_ty.fmt(zcu), ptr_mcv, ptr_ty.fmt(zcu) });
		3212
		3213	switch (ptr_mcv) {
		3214	.none => unreachable,
		3215	.undef => unreachable,
		3216	.unreach => unreachable,
		3217	.dead => unreachable,
		3218	.register_pair => unreachable,
		3219	.reserved_frame => unreachable,
		3220
		3221	.immediate,
		3222	.register,
		3223	.register_offset,
		3224	.lea_symbol,
		3225	.lea_frame,
		3226	=> try self.genCopy(src_ty, ptr_mcv.deref(), src_mcv),
		3227
		3228	.memory,
		3229	.indirect,
		3230	.load_symbol,
		3231	.load_frame,
		3232	=> {
		3233	const addr_reg = try self.copyToTmpRegister(ptr_ty, ptr_mcv);
		3234	const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
		3235	defer self.register_manager.unlockReg(addr_lock);
		3236
		3237	try self.genCopy(src_ty, .{ .indirect = .{ .reg = addr_reg } }, src_mcv);
		3238	},
		3239	.air_ref => \|ptr_ref\| try self.store(try self.resolveInst(ptr_ref), src_mcv, ptr_ty, src_ty),
		3240	}
1594	}	3241	}
1595		3242
1596	fn airStructFieldPtr(self: *Self, inst: Air.Inst.Index) !void {	3243	fn airStructFieldPtr(self: *Self, inst: Air.Inst.Index) !void {
1597	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	3244	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
1598	const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;	3245	const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
1599	return self.structFieldPtr(extra.struct_operand, ty_pl.ty, extra.field_index);	3246	const result = try self.structFieldPtr(inst, extra.struct_operand, extra.field_index);
		3247	return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none });
1600	}	3248	}
1601		3249
1602	fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {	3250	fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {
1603	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	3251	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1604	return self.structFieldPtr(ty_op.operand, ty_op.ty, index);	3252	const result = try self.structFieldPtr(inst, ty_op.operand, index);
		3253	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1605	}	3254	}
1606	fn structFieldPtr(self: *Self, operand: Air.Inst.Ref, ty: Air.Inst.Ref, index: u32) !void {	3255
1607	_ = operand;	3256	fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, index: u32) !MCValue {
1608	_ = ty;	3257	const zcu = self.bin_file.comp.module.?;
1609	_ = index;	3258	const ptr_field_ty = self.typeOfIndex(inst);
1610	return self.fail("TODO implement codegen struct_field_ptr", .{});	3259	const ptr_container_ty = self.typeOf(operand);
1611	//return self.finishAir(inst, result, .{ extra.struct_ptr, .none, .none });	3260	const ptr_container_ty_info = ptr_container_ty.ptrInfo(zcu);
		3261	const container_ty = ptr_container_ty.childType(zcu);
		3262
		3263	const field_offset: i32 = if (zcu.typeToPackedStruct(container_ty)) \|struct_obj\|
		3264	if (ptr_field_ty.ptrInfo(zcu).packed_offset.host_size == 0)
		3265	@divExact(zcu.structPackedFieldBitOffset(struct_obj, index) +
		3266	ptr_container_ty_info.packed_offset.bit_offset, 8)
		3267	else
		3268	0
		3269	else
		3270	@intCast(container_ty.structFieldOffset(index, zcu));
		3271
		3272	const src_mcv = try self.resolveInst(operand);
		3273	const dst_mcv = if (switch (src_mcv) {
		3274	.immediate, .lea_frame => true,
		3275	.register, .register_offset => self.reuseOperand(inst, operand, 0, src_mcv),
		3276	else => false,
		3277	}) src_mcv else try self.copyToNewRegister(inst, src_mcv);
		3278	return dst_mcv.offset(field_offset);
1612	}	3279	}
1613		3280
1614	fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {	3281	fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
		3282	const mod = self.bin_file.comp.module.?;
		3283
1615	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	3284	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
1616	const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;	3285	const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
1617	_ = extra;	3286	const operand = extra.struct_operand;
1618	return self.fail("TODO implement codegen struct_field_val", .{});	3287	const index = extra.field_index;
1619	//return self.finishAir(inst, result, .{ extra.struct_ptr, .none, .none });	3288
		3289	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
		3290	const zcu = self.bin_file.comp.module.?;
		3291	const src_mcv = try self.resolveInst(operand);
		3292	const struct_ty = self.typeOf(operand);
		3293	const field_ty = struct_ty.structFieldType(index, zcu);
		3294	if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
		3295
		3296	const field_off: u32 = switch (struct_ty.containerLayout(zcu)) {
		3297	.auto, .@"extern" => @intCast(struct_ty.structFieldOffset(index, zcu) * 8),
		3298	.@"packed" => if (zcu.typeToStruct(struct_ty)) \|struct_type\|
		3299	zcu.structPackedFieldBitOffset(struct_type, index)
		3300	else
		3301	0,
		3302	};
		3303
		3304	switch (src_mcv) {
		3305	.dead, .unreach => unreachable,
		3306	.register => \|src_reg\| {
		3307	const src_reg_lock = self.register_manager.lockRegAssumeUnused(src_reg);
		3308	defer self.register_manager.unlockReg(src_reg_lock);
		3309
		3310	const dst_reg = if (field_off == 0)
		3311	(try self.copyToNewRegister(inst, src_mcv)).register
		3312	else
		3313	try self.copyToTmpRegister(Type.usize, .{ .register = src_reg });
		3314
		3315	const dst_mcv: MCValue = .{ .register = dst_reg };
		3316	const dst_lock = self.register_manager.lockReg(dst_reg);
		3317	defer if (dst_lock) \|lock\| self.register_manager.unlockReg(lock);
		3318
		3319	if (field_off > 0) {
		3320	_ = try self.addInst(.{
		3321	.tag = .srli,
		3322	.ops = .rri,
		3323	.data = .{ .i_type = .{
		3324	.imm12 = Immediate.s(@intCast(field_off)),
		3325	.rd = dst_reg,
		3326	.rs1 = dst_reg,
		3327	} },
		3328	});
		3329
		3330	return self.fail("TODO: airStructFieldVal register with field_off > 0", .{});
		3331	}
		3332
		3333	break :result if (field_off == 0) dst_mcv else try self.copyToNewRegister(inst, dst_mcv);
		3334	},
		3335	.load_frame => {
		3336	const field_abi_size: u32 = @intCast(field_ty.abiSize(mod));
		3337	if (field_off % 8 == 0) {
		3338	const field_byte_off = @divExact(field_off, 8);
		3339	const off_mcv = src_mcv.address().offset(@intCast(field_byte_off)).deref();
		3340	const field_bit_size = field_ty.bitSize(mod);
		3341
		3342	if (field_abi_size <= 8) {
		3343	const int_ty = try mod.intType(
		3344	if (field_ty.isAbiInt(mod)) field_ty.intInfo(mod).signedness else .unsigned,
		3345	@intCast(field_bit_size),
		3346	);
		3347
		3348	const dst_reg, const dst_lock = try self.allocReg();
		3349	const dst_mcv = MCValue{ .register = dst_reg };
		3350	defer self.register_manager.unlockReg(dst_lock);
		3351
		3352	try self.genCopy(int_ty, dst_mcv, off_mcv);
		3353	break :result try self.copyToNewRegister(inst, dst_mcv);
		3354	}
		3355
		3356	const container_abi_size: u32 = @intCast(struct_ty.abiSize(mod));
		3357	const dst_mcv = if (field_byte_off + field_abi_size <= container_abi_size and
		3358	self.reuseOperand(inst, operand, 0, src_mcv))
		3359	off_mcv
		3360	else dst: {
		3361	const dst_mcv = try self.allocRegOrMem(inst, true);
		3362	try self.genCopy(field_ty, dst_mcv, off_mcv);
		3363	break :dst dst_mcv;
		3364	};
		3365	if (field_abi_size * 8 > field_bit_size and dst_mcv.isMemory()) {
		3366	const tmp_reg, const tmp_lock = try self.allocReg();
		3367	defer self.register_manager.unlockReg(tmp_lock);
		3368
		3369	const hi_mcv =
		3370	dst_mcv.address().offset(@intCast(field_bit_size / 64 * 8)).deref();
		3371	try self.genSetReg(Type.usize, tmp_reg, hi_mcv);
		3372	try self.genCopy(Type.usize, hi_mcv, .{ .register = tmp_reg });
		3373	}
		3374	break :result dst_mcv;
		3375	}
		3376
		3377	return self.fail("TODO: airStructFieldVal load_frame field_off non multiple of 8", .{});
		3378	},
		3379	else => return self.fail("TODO: airStructField {s}", .{@tagName(src_mcv)}),
		3380	}
		3381	};
		3382
		3383	return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none });
1620	}	3384	}
1621		3385
1622	fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {	3386	fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
...	@@ -1625,18 +3389,18 @@ fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1625,18 +3389,18 @@ fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
1625	}	3389	}
1626		3390
1627	fn genArgDbgInfo(self: Self, inst: Air.Inst.Index, mcv: MCValue) !void {	3391	fn genArgDbgInfo(self: Self, inst: Air.Inst.Index, mcv: MCValue) !void {
1628	const mod = self.bin_file.comp.module.?;	3392	const zcu = self.bin_file.comp.module.?;
1629	const arg = self.air.instructions.items(.data)[@intFromEnum(inst)].arg;	3393	const arg = self.air.instructions.items(.data)[@intFromEnum(inst)].arg;
1630	const ty = arg.ty.toType();	3394	const ty = arg.ty.toType();
1631	const owner_decl = mod.funcOwnerDeclIndex(self.func_index);	3395	const owner_decl = zcu.funcOwnerDeclIndex(self.func_index);
1632	const name = mod.getParamName(self.func_index, arg.src_index);	3396	const name = zcu.getParamName(self.func_index, arg.src_index);
1633		3397
1634	switch (self.debug_output) {	3398	switch (self.debug_output) {
1635	.dwarf => \|dw\| switch (mcv) {	3399	.dwarf => \|dw\| switch (mcv) {
1636	.register => \|reg\| try dw.genArgDbgInfo(name, ty, owner_decl, .{	3400	.register => \|reg\| try dw.genArgDbgInfo(name, ty, owner_decl, .{
1637	.register = reg.dwarfLocOp(),	3401	.register = reg.dwarfLocOp(),
1638	}),	3402	}),
1639	.stack_offset => {},	3403	.load_frame => {},
1640	else => {},	3404	else => {},
1641	},	3405	},
1642	.plan9 => {},	3406	.plan9 => {},
...	@@ -1645,35 +3409,53 @@ fn genArgDbgInfo(self: Self, inst: Air.Inst.Index, mcv: MCValue) !void {	...	@@ -1645,35 +3409,53 @@ fn genArgDbgInfo(self: Self, inst: Air.Inst.Index, mcv: MCValue) !void {
1645	}	3409	}
1646		3410
1647	fn airArg(self: *Self, inst: Air.Inst.Index) !void {	3411	fn airArg(self: *Self, inst: Air.Inst.Index) !void {
1648	const arg_index = self.arg_index;	3412	const zcu = self.bin_file.comp.module.?;
1649	self.arg_index += 1;	3413	var arg_index = self.arg_index;
1650		3414
1651	const ty = self.typeOfIndex(inst);	3415	// we skip over args that have no bits
1652	_ = ty;	3416	while (self.args[arg_index] == .none) arg_index += 1;
1653		3417	self.arg_index = arg_index + 1;
1654	const result = self.args[arg_index];	3418
1655	// TODO support stack-only arguments	3419	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
1656	// TODO Copy registers to the stack	3420	const src_mcv = self.args[arg_index];
1657	const mcv = result;	3421
1658	try self.genArgDbgInfo(inst, mcv);	3422	const arg_ty = self.typeOfIndex(inst);
1659		3423
1660	if (self.liveness.isUnused(inst))	3424	const dst_mcv = switch (src_mcv) {
1661	return self.finishAirBookkeeping();	3425	.register => dst: {
		3426	const frame = try self.allocFrameIndex(FrameAlloc.init(.{
		3427	.size = Type.usize.abiSize(zcu),
		3428	.alignment = Type.usize.abiAlignment(zcu),
		3429	}));
		3430	const dst_mcv: MCValue = .{ .load_frame = .{ .index = frame } };
		3431	try self.genCopy(Type.usize, dst_mcv, src_mcv);
		3432	break :dst dst_mcv;
		3433	},
		3434	.register_pair => dst: {
		3435	const frame = try self.allocFrameIndex(FrameAlloc.init(.{
		3436	.size = Type.usize.abiSize(zcu) * 2,
		3437	.alignment = Type.usize.abiAlignment(zcu),
		3438	}));
		3439	const dst_mcv: MCValue = .{ .load_frame = .{ .index = frame } };
		3440	try self.genCopy(arg_ty, dst_mcv, src_mcv);
		3441	break :dst dst_mcv;
		3442	},
		3443	.load_frame => src_mcv,
		3444	else => return self.fail("TODO: airArg {s}", .{@tagName(src_mcv)}),
		3445	};
1662		3446
1663	switch (mcv) {	3447	try self.genArgDbgInfo(inst, src_mcv);
1664	.register => \|reg\| {	3448	break :result dst_mcv;
1665	self.register_manager.getRegAssumeFree(reg, inst);	3449	};
1666	},
1667	else => {},
1668	}
1669		3450
1670	return self.finishAir(inst, mcv, .{ .none, .none, .none });	3451	return self.finishAir(inst, result, .{ .none, .none, .none });
1671	}	3452	}
1672		3453
1673	fn airTrap(self: *Self) !void {	3454	fn airTrap(self: *Self) !void {
1674	_ = try self.addInst(.{	3455	_ = try self.addInst(.{
1675	.tag = .unimp,	3456	.tag = .unimp,
1676	.data = .{ .nop = {} },	3457	.ops = .none,
		3458	.data = undefined,
1677	});	3459	});
1678	return self.finishAirBookkeeping();	3460	return self.finishAirBookkeeping();
1679	}	3461	}
...	@@ -1681,19 +3463,22 @@ fn airTrap(self: *Self) !void {	...	@@ -1681,19 +3463,22 @@ fn airTrap(self: *Self) !void {
1681	fn airBreakpoint(self: *Self) !void {	3463	fn airBreakpoint(self: *Self) !void {
1682	_ = try self.addInst(.{	3464	_ = try self.addInst(.{
1683	.tag = .ebreak,	3465	.tag = .ebreak,
1684	.data = .{ .nop = {} },	3466	.ops = .none,
		3467	.data = undefined,
1685	});	3468	});
1686	return self.finishAirBookkeeping();	3469	return self.finishAirBookkeeping();
1687	}	3470	}
1688		3471
1689	fn airRetAddr(self: *Self, inst: Air.Inst.Index) !void {	3472	fn airRetAddr(self: *Self, inst: Air.Inst.Index) !void {
1690	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airRetAddr for riscv64", .{});	3473	const dst_mcv = try self.allocRegOrMem(inst, true);
1691	return self.finishAir(inst, result, .{ .none, .none, .none });	3474	try self.genCopy(Type.usize, dst_mcv, .{ .load_frame = .{ .index = .ret_addr } });
		3475	return self.finishAir(inst, dst_mcv, .{ .none, .none, .none });
1692	}	3476	}
1693		3477
1694	fn airFrameAddress(self: *Self, inst: Air.Inst.Index) !void {	3478	fn airFrameAddress(self: *Self, inst: Air.Inst.Index) !void {
1695	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFrameAddress for riscv64", .{});	3479	const dst_mcv = try self.allocRegOrMem(inst, true);
1696	return self.finishAir(inst, result, .{ .none, .none, .none });	3480	try self.genCopy(Type.usize, dst_mcv, .{ .lea_frame = .{ .index = .base_ptr } });
		3481	return self.finishAir(inst, dst_mcv, .{ .none, .none, .none });
1697	}	3482	}
1698		3483
1699	fn airFence(self: *Self) !void {	3484	fn airFence(self: *Self) !void {
...	@@ -1702,152 +3487,257 @@ fn airFence(self: *Self) !void {	...	@@ -1702,152 +3487,257 @@ fn airFence(self: *Self) !void {
1702	}	3487	}
1703		3488
1704	fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {	3489	fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
1705	const mod = self.bin_file.comp.module.?;
1706	if (modifier == .always_tail) return self.fail("TODO implement tail calls for riscv64", .{});	3490	if (modifier == .always_tail) return self.fail("TODO implement tail calls for riscv64", .{});
1707	const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;	3491	const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
1708	const fn_ty = self.typeOf(pl_op.operand);
1709	const callee = pl_op.operand;	3492	const callee = pl_op.operand;
1710	const extra = self.air.extraData(Air.Call, pl_op.payload);	3493	const extra = self.air.extraData(Air.Call, pl_op.payload);
1711	const args: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);	3494	const arg_refs: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);
		3495
		3496	const expected_num_args = 8;
		3497	const ExpectedContents = extern struct {
		3498	vals: [expected_num_args][@sizeOf(MCValue)]u8 align(@alignOf(MCValue)),
		3499	};
		3500	var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
		3501	std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
		3502	const allocator = stack.get();
		3503
		3504	const arg_tys = try allocator.alloc(Type, arg_refs.len);
		3505	defer allocator.free(arg_tys);
		3506	for (arg_tys, arg_refs) \|arg_ty, arg_ref\| arg_ty. = self.typeOf(arg_ref);
		3507
		3508	const arg_vals = try allocator.alloc(MCValue, arg_refs.len);
		3509	defer allocator.free(arg_vals);
		3510	for (arg_vals, arg_refs) \|arg_val, arg_ref\| arg_val. = .{ .air_ref = arg_ref };
		3511
		3512	const call_ret = try self.genCall(.{ .air = callee }, arg_tys, arg_vals);
		3513
		3514	var bt = self.liveness.iterateBigTomb(inst);
		3515	try self.feed(&bt, pl_op.operand);
		3516	for (arg_refs) \|arg_ref\| try self.feed(&bt, arg_ref);
		3517
		3518	const result = if (self.liveness.isUnused(inst)) .unreach else call_ret;
		3519	return self.finishAirResult(inst, result);
		3520	}
		3521
		3522	fn genCall(
		3523	self: *Self,
		3524	info: union(enum) {
		3525	air: Air.Inst.Ref,
		3526	lib: struct {
		3527	return_type: InternPool.Index,
		3528	param_types: []const InternPool.Index,
		3529	lib: ?[]const u8 = null,
		3530	callee: []const u8,
		3531	},
		3532	},
		3533	arg_tys: []const Type,
		3534	args: []const MCValue,
		3535	) !MCValue {
		3536	const zcu = self.bin_file.comp.module.?;
		3537
		3538	const fn_ty = switch (info) {
		3539	.air => \|callee\| fn_info: {
		3540	const callee_ty = self.typeOf(callee);
		3541	break :fn_info switch (callee_ty.zigTypeTag(zcu)) {
		3542	.Fn => callee_ty,
		3543	.Pointer => callee_ty.childType(zcu),
		3544	else => unreachable,
		3545	};
		3546	},
		3547	.lib => \|lib\| try zcu.funcType(.{
		3548	.param_types = lib.param_types,
		3549	.return_type = lib.return_type,
		3550	.cc = .C,
		3551	}),
		3552	};
		3553
		3554	const fn_info = zcu.typeToFunc(fn_ty).?;
		3555	var call_info = try self.resolveCallingConventionValues(fn_info);
		3556	defer call_info.deinit(self);
		3557
		3558	// We need a properly aligned and sized call frame to be able to call this function.
		3559	{
		3560	const needed_call_frame = FrameAlloc.init(.{
		3561	.size = call_info.stack_byte_count,
		3562	.alignment = call_info.stack_align,
		3563	});
		3564	const frame_allocs_slice = self.frame_allocs.slice();
		3565	const stack_frame_size =
		3566	&frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)];
		3567	stack_frame_size.* = @max(stack_frame_size.*, needed_call_frame.abi_size);
		3568	const stack_frame_align =
		3569	&frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)];
		3570	stack_frame_align.* = stack_frame_align.max(needed_call_frame.abi_align);
		3571	}
1712		3572
1713	var info = try self.resolveCallingConventionValues(fn_ty);	3573	for (call_info.args, 0..) \|mc_arg, arg_i\| try self.genCopy(arg_tys[arg_i], mc_arg, args[arg_i]);
1714	defer info.deinit(self);
1715		3574
1716	// Due to incremental compilation, how function calls are generated depends	3575	// Due to incremental compilation, how function calls are generated depends
1717	// on linking.	3576	// on linking.
1718	if (self.bin_file.cast(link.File.Elf)) \|elf_file\| {	3577	switch (info) {
1719	for (info.args, 0..) \|mc_arg, arg_i\| {	3578	.air => \|callee\| {
1720	const arg = args[arg_i];	3579	if (try self.air.value(callee, zcu)) \|func_value\| {
1721	const arg_ty = self.typeOf(arg);	3580	const func_key = zcu.intern_pool.indexToKey(func_value.ip_index);
1722	const arg_mcv = try self.resolveInst(args[arg_i]);	3581	switch (switch (func_key) {
1723		3582	else => func_key,
1724	switch (mc_arg) {	3583	.ptr => \|ptr\| if (ptr.byte_offset == 0) switch (ptr.base_addr) {
1725	.none => continue,	3584	.decl => \|decl\| zcu.intern_pool.indexToKey(zcu.declPtr(decl).val.toIntern()),
1726	.undef => unreachable,	3585	else => func_key,
1727	.immediate => unreachable,	3586	} else func_key,
1728	.unreach => unreachable,	3587	}) {
1729	.dead => unreachable,	3588	.func => \|func\| {
1730	.memory => unreachable,	3589	if (self.bin_file.cast(link.File.Elf)) \|elf_file\| {
1731	.register => \|reg\| {	3590	const sym_index = try elf_file.zigObjectPtr().?.getOrCreateMetadataForDecl(elf_file, func.owner_decl);
1732	try self.register_manager.getReg(reg, null);	3591	const sym = elf_file.symbol(sym_index);
1733	try self.genSetReg(arg_ty, reg, arg_mcv);	3592
1734	},	3593	_ = try sym.getOrCreateZigGotEntry(sym_index, elf_file);
1735	.stack_offset => {	3594	const got_addr = sym.zigGotAddress(elf_file);
1736	return self.fail("TODO implement calling with parameters in memory", .{});	3595	try self.genSetReg(Type.usize, .ra, .{ .memory = @intCast(got_addr) });
1737	},	3596
1738	.ptr_stack_offset => {	3597	_ = try self.addInst(.{
1739	return self.fail("TODO implement calling with MCValue.ptr_stack_offset arg", .{});	3598	.tag = .jalr,
1740	},	3599	.ops = .rri,
		3600	.data = .{ .i_type = .{
		3601	.rd = .ra,
		3602	.rs1 = .ra,
		3603	.imm12 = Immediate.s(0),
		3604	} },
		3605	});
		3606	} else unreachable;
		3607	},
		3608	.extern_func => return self.fail("TODO: extern func calls", .{}),
		3609	else => return self.fail("TODO implement calling bitcasted functions", .{}),
		3610	}
		3611	} else {
		3612	assert(self.typeOf(callee).zigTypeTag(zcu) == .Pointer);
		3613	const addr_reg, const addr_lock = try self.allocReg();
		3614	defer self.register_manager.unlockReg(addr_lock);
		3615	try self.genSetReg(Type.usize, addr_reg, .{ .air_ref = callee });
		3616	_ = try self.addInst(.{
		3617	.tag = .jalr,
		3618	.ops = .rri,
		3619	.data = .{ .i_type = .{
		3620	.rd = .ra,
		3621	.rs1 = addr_reg,
		3622	.imm12 = Immediate.s(0),
		3623	} },
		3624	});
1741	}	3625	}
1742	}	3626	},
		3627	.lib => return self.fail("TODO: lib func calls", .{}),
		3628	}
1743		3629
1744	if (try self.air.value(callee, mod)) \|func_value\| {	3630	return call_info.return_value.short;
1745	switch (mod.intern_pool.indexToKey(func_value.ip_index)) {	3631	}
1746	.func => \|func\| {
1747	const sym_index = try elf_file.zigObjectPtr().?.getOrCreateMetadataForDecl(elf_file, func.owner_decl);
1748	const sym = elf_file.symbol(sym_index);
1749	_ = try sym.getOrCreateZigGotEntry(sym_index, elf_file);
1750	const got_addr: u32 = @intCast(sym.zigGotAddress(elf_file));
1751	try self.genSetReg(Type.usize, .ra, .{ .memory = got_addr });
1752	_ = try self.addInst(.{
1753	.tag = .jalr,
1754	.data = .{ .i_type = .{
1755	.rd = .ra,
1756	.rs1 = .ra,
1757	.imm12 = 0,
1758	} },
1759	});
1760	},
1761	.extern_func => {
1762	return self.fail("TODO implement calling extern functions", .{});
1763	},
1764	else => {
1765	return self.fail("TODO implement calling bitcasted functions", .{});
1766	},
1767	}
1768	} else {
1769	return self.fail("TODO implement calling runtime-known function pointer", .{});
1770	}
1771	} else if (self.bin_file.cast(link.File.Coff)) \|_\| {
1772	return self.fail("TODO implement calling in COFF for {}", .{self.target.cpu.arch});
1773	} else if (self.bin_file.cast(link.File.MachO)) \|_\| {
1774	unreachable; // unsupported architecture for MachO
1775	} else if (self.bin_file.cast(link.File.Plan9)) \|_\| {
1776	return self.fail("TODO implement call on plan9 for {}", .{self.target.cpu.arch});
1777	} else unreachable;
1778		3632
1779	const result: MCValue = result: {	3633	fn airRet(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
1780	switch (info.return_value) {	3634	const zcu = self.bin_file.comp.module.?;
1781	.register => \|reg\| {	3635	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1782	if (RegisterManager.indexOfReg(&callee_preserved_regs, reg) == null) {
1783	// Save function return value in a callee saved register
1784	break :result try self.copyToNewRegister(inst, info.return_value);
1785	}
1786	},
1787	else => {},
1788	}
1789	break :result info.return_value;
1790	};
1791		3636
1792	if (args.len <= Liveness.bpi - 2) {	3637	if (safety) {
1793	var buf = [1]Air.Inst.Ref{.none} ** (Liveness.bpi - 1);	3638	// safe
1794	buf[0] = callee;	3639	} else {
1795	@memcpy(buf[1..][0..args.len], args);	3640	// not safe
1796	return self.finishAir(inst, result, buf);
1797	}	3641	}
1798	var bt = try self.iterateBigTomb(inst, 1 + args.len);	3642
1799	bt.feed(callee);	3643	const ret_ty = self.fn_type.fnReturnType(zcu);
1800	for (args) \|arg\| {	3644	switch (self.ret_mcv.short) {
1801	bt.feed(arg);	3645	.none => {},
		3646	.register,
		3647	.register_pair,
		3648	=> try self.genCopy(ret_ty, self.ret_mcv.short, .{ .air_ref = un_op }),
		3649	.indirect => \|reg_off\| {
		3650	try self.register_manager.getReg(reg_off.reg, null);
		3651	const lock = self.register_manager.lockRegAssumeUnused(reg_off.reg);
		3652	defer self.register_manager.unlockReg(lock);
		3653
		3654	try self.genSetReg(Type.usize, reg_off.reg, self.ret_mcv.long);
		3655	try self.genCopy(
		3656	ret_ty,
		3657	.{ .register_offset = reg_off },
		3658	.{ .air_ref = un_op },
		3659	);
		3660	},
		3661	else => unreachable,
1802	}	3662	}
1803	return bt.finishAir(result);
1804	}
1805		3663
1806	fn ret(self: *Self, mcv: MCValue) !void {	3664	self.ret_mcv.liveOut(self, inst);
1807	const mod = self.bin_file.comp.module.?;	3665	try self.finishAir(inst, .unreach, .{ un_op, .none, .none });
1808	const ret_ty = self.fn_type.fnReturnType(mod);	3666
1809	try self.setRegOrMem(ret_ty, self.ret_mcv, mcv);	3667	// Just add space for an instruction, reloced this later
1810	// Just add space for an instruction, patch this later
1811	const index = try self.addInst(.{	3668	const index = try self.addInst(.{
1812	.tag = .nop,	3669	.tag = .pseudo,
1813	.data = .{ .nop = {} },	3670	.ops = .pseudo_j,
		3671	.data = .{ .inst = undefined },
1814	});	3672	});
1815	try self.exitlude_jump_relocs.append(self.gpa, index);
1816	}
1817		3673
1818	fn airRet(self: *Self, inst: Air.Inst.Index) !void {	3674	try self.exitlude_jump_relocs.append(self.gpa, index);
1819	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1820	const operand = try self.resolveInst(un_op);
1821	try self.ret(operand);
1822	return self.finishAir(inst, .dead, .{ un_op, .none, .none });
1823	}	3675	}
1824		3676
1825	fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {	3677	fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
1826	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	3678	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1827	const ptr = try self.resolveInst(un_op);	3679	const ptr = try self.resolveInst(un_op);
1828	_ = ptr;	3680
1829	return self.fail("TODO implement airRetLoad for {}", .{self.target.cpu.arch});	3681	const ptr_ty = self.typeOf(un_op);
1830	//return self.finishAir(inst, .dead, .{ un_op, .none, .none });	3682	switch (self.ret_mcv.short) {
		3683	.none => {},
		3684	.register, .register_pair => try self.load(self.ret_mcv.short, ptr, ptr_ty),
		3685	.indirect => \|reg_off\| try self.genSetReg(ptr_ty, reg_off.reg, ptr),
		3686	else => unreachable,
		3687	}
		3688	self.ret_mcv.liveOut(self, inst);
		3689	try self.finishAir(inst, .unreach, .{ un_op, .none, .none });
		3690
		3691	// Just add space for an instruction, reloced this later
		3692	const index = try self.addInst(.{
		3693	.tag = .pseudo,
		3694	.ops = .pseudo_j,
		3695	.data = .{ .inst = undefined },
		3696	});
		3697
		3698	try self.exitlude_jump_relocs.append(self.gpa, index);
1831	}	3699	}
1832		3700
1833	fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {	3701	fn airCmp(self: *Self, inst: Air.Inst.Index) !void {
		3702	const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
1834	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	3703	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
1835	if (self.liveness.isUnused(inst))	3704	const zcu = self.bin_file.comp.module.?;
1836	return self.finishAir(inst, .dead, .{ bin_op.lhs, bin_op.rhs, .none });	3705
1837	const ty = self.typeOf(bin_op.lhs);	3706	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
1838	const mod = self.bin_file.comp.module.?;	3707	const lhs = try self.resolveInst(bin_op.lhs);
1839	assert(ty.eql(self.typeOf(bin_op.rhs), mod));	3708	const rhs = try self.resolveInst(bin_op.rhs);
1840	if (ty.zigTypeTag(mod) == .ErrorSet)	3709	const lhs_ty = self.typeOf(bin_op.lhs);
1841	return self.fail("TODO implement cmp for errors", .{});	3710
		3711	const int_ty = switch (lhs_ty.zigTypeTag(zcu)) {
		3712	.Vector => unreachable, // Handled by cmp_vector.
		3713	.Enum => lhs_ty.intTagType(zcu),
		3714	.Int => lhs_ty,
		3715	.Bool => Type.u1,
		3716	.Pointer => Type.usize,
		3717	.ErrorSet => Type.u16,
		3718	.Optional => blk: {
		3719	const payload_ty = lhs_ty.optionalChild(zcu);
		3720	if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
		3721	break :blk Type.u1;
		3722	} else if (lhs_ty.isPtrLikeOptional(zcu)) {
		3723	break :blk Type.usize;
		3724	} else {
		3725	return self.fail("TODO riscv cmp non-pointer optionals", .{});
		3726	}
		3727	},
		3728	.Float => return self.fail("TODO riscv cmp floats", .{}),
		3729	else => unreachable,
		3730	};
1842		3731
1843	const lhs = try self.resolveInst(bin_op.lhs);	3732	const int_info = int_ty.intInfo(zcu);
1844	const rhs = try self.resolveInst(bin_op.rhs);	3733	if (int_info.bits <= 64) {
1845	_ = op;	3734	break :result try self.binOp(tag, lhs, int_ty, rhs, int_ty);
1846	_ = lhs;	3735	} else {
1847	_ = rhs;	3736	return self.fail("TODO riscv cmp for ints > 64 bits", .{});
		3737	}
		3738	};
1848		3739
1849	return self.fail("TODO implement cmp for {}", .{self.target.cpu.arch});	3740	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1850	// return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1851	}	3741	}
1852		3742
1853	fn airCmpVector(self: *Self, inst: Air.Inst.Index) !void {	3743	fn airCmpVector(self: *Self, inst: Air.Inst.Index) !void {
...	@@ -1859,7 +3749,7 @@ fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1859,7 +3749,7 @@ fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
1859	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	3749	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1860	const operand = try self.resolveInst(un_op);	3750	const operand = try self.resolveInst(un_op);
1861	_ = operand;	3751	_ = operand;
1862	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCmpLtErrorsLen for {}", .{self.target.cpu.arch});	3752	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airCmpLtErrorsLen for {}", .{self.target.cpu.arch});
1863	return self.finishAir(inst, result, .{ un_op, .none, .none });	3753	return self.finishAir(inst, result, .{ un_op, .none, .none });
1864	}	3754	}
1865		3755
...	@@ -1867,8 +3757,9 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1867,8 +3757,9 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
1867	const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;	3757	const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
1868		3758
1869	_ = try self.addInst(.{	3759	_ = try self.addInst(.{
1870	.tag = .dbg_line,	3760	.tag = .pseudo,
1871	.data = .{ .dbg_line_column = .{	3761	.ops = .pseudo_dbg_line_column,
		3762	.data = .{ .pseudo_dbg_line_column = .{
1872	.line = dbg_stmt.line,	3763	.line = dbg_stmt.line,
1873	.column = dbg_stmt.column,	3764	.column = dbg_stmt.column,
1874	} },	3765	} },
...	@@ -1878,62 +3769,126 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1878,62 +3769,126 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
1878	}	3769	}
1879		3770
1880	fn airDbgInlineBlock(self: *Self, inst: Air.Inst.Index) !void {	3771	fn airDbgInlineBlock(self: *Self, inst: Air.Inst.Index) !void {
1881	const mod = self.bin_file.comp.module.?;
1882	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	3772	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
1883	const extra = self.air.extraData(Air.DbgInlineBlock, ty_pl.payload);	3773	const extra = self.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
1884	const func = mod.funcInfo(extra.data.func);
1885	// TODO emit debug info for function change
1886	_ = func;
1887	try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]));	3774	try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]));
1888	}	3775	}
1889		3776
1890	fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void {	3777	fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void {
1891	const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;	3778	const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
1892	const name = self.air.nullTerminatedString(pl_op.payload);
1893	const operand = pl_op.operand;	3779	const operand = pl_op.operand;
1894	// TODO emit debug info for this variable	3780	const ty = self.typeOf(operand);
1895	_ = name;	3781	const mcv = try self.resolveInst(operand);
1896	return self.finishAir(inst, .dead, .{ operand, .none, .none });
1897	}
1898		3782
1899	fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {	3783	const name = self.air.nullTerminatedString(pl_op.payload);
1900	_ = inst;
1901		3784
1902	return self.fail("TODO implement condbr {}", .{self.target.cpu.arch});	3785	const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
1903	// return self.finishAir(inst, .unreach, .{ pl_op.operand, .none, .none });	3786	try self.genVarDbgInfo(tag, ty, mcv, name);
1904	}
1905		3787
1906	fn isNull(self: *Self, operand: MCValue) !MCValue {	3788	return self.finishAir(inst, .unreach, .{ operand, .none, .none });
1907	_ = operand;
1908	// Here you can specialize this instruction if it makes sense to, otherwise the default
1909	// will call isNonNull and invert the result.
1910	return self.fail("TODO call isNonNull and invert the result", .{});
1911	}	3789	}
1912		3790
1913	fn isNonNull(self: *Self, operand: MCValue) !MCValue {	3791	fn genVarDbgInfo(
1914	_ = operand;	3792	self: Self,
1915	// Here you can specialize this instruction if it makes sense to, otherwise the default	3793	tag: Air.Inst.Tag,
1916	// will call isNull and invert the result.	3794	ty: Type,
1917	return self.fail("TODO call isNull and invert the result", .{});	3795	mcv: MCValue,
		3796	name: [:0]const u8,
		3797	) !void {
		3798	const zcu = self.bin_file.comp.module.?;
		3799	const is_ptr = switch (tag) {
		3800	.dbg_var_ptr => true,
		3801	.dbg_var_val => false,
		3802	else => unreachable,
		3803	};
		3804
		3805	switch (self.debug_output) {
		3806	.dwarf => \|dw\| {
		3807	const loc: link.File.Dwarf.DeclState.DbgInfoLoc = switch (mcv) {
		3808	.register => \|reg\| .{ .register = reg.dwarfLocOp() },
		3809	.memory => \|address\| .{ .memory = address },
		3810	.load_symbol => \|sym_off\| loc: {
		3811	assert(sym_off.off == 0);
		3812	break :loc .{ .linker_load = .{ .type = .direct, .sym_index = sym_off.sym } };
		3813	},
		3814	.immediate => \|x\| .{ .immediate = x },
		3815	.undef => .undef,
		3816	.none => .none,
		3817	else => blk: {
		3818	// log.warn("TODO generate debug info for {}", .{mcv});
		3819	break :blk .nop;
		3820	},
		3821	};
		3822	try dw.genVarDbgInfo(name, ty, zcu.funcOwnerDeclIndex(self.func_index), is_ptr, loc);
		3823	},
		3824	.plan9 => {},
		3825	.none => {},
		3826	}
1918	}	3827	}
1919		3828
1920	fn isErr(self: *Self, operand: MCValue) !MCValue {	3829	fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
1921	_ = operand;	3830	const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
1922	// Here you can specialize this instruction if it makes sense to, otherwise the default	3831	const cond = try self.resolveInst(pl_op.operand);
1923	// will call isNonNull and invert the result.	3832	const cond_ty = self.typeOf(pl_op.operand);
1924	return self.fail("TODO call isNonErr and invert the result", .{});	3833	const extra = self.air.extraData(Air.CondBr, pl_op.payload);
		3834	const then_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.then_body_len]);
		3835	const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len]);
		3836	const liveness_cond_br = self.liveness.getCondBr(inst);
		3837
		3838	// If the condition dies here in this condbr instruction, process
		3839	// that death now instead of later as this has an effect on
		3840	// whether it needs to be spilled in the branches
		3841	if (self.liveness.operandDies(inst, 0)) {
		3842	if (pl_op.operand.toIndex()) \|op_inst\| try self.processDeath(op_inst);
		3843	}
		3844
		3845	self.scope_generation += 1;
		3846	const state = try self.saveState();
		3847	const reloc = try self.condBr(cond_ty, cond);
		3848
		3849	for (liveness_cond_br.then_deaths) \|death\| try self.processDeath(death);
		3850	try self.genBody(then_body);
		3851	try self.restoreState(state, &.{}, .{
		3852	.emit_instructions = false,
		3853	.update_tracking = true,
		3854	.resurrect = true,
		3855	.close_scope = true,
		3856	});
		3857
		3858	self.performReloc(reloc);
		3859
		3860	for (liveness_cond_br.else_deaths) \|death\| try self.processDeath(death);
		3861	try self.genBody(else_body);
		3862	try self.restoreState(state, &.{}, .{
		3863	.emit_instructions = false,
		3864	.update_tracking = true,
		3865	.resurrect = true,
		3866	.close_scope = true,
		3867	});
		3868
		3869	// We already took care of pl_op.operand earlier, so there's nothing left to do.
		3870	self.finishAirBookkeeping();
1925	}	3871	}
1926		3872
1927	fn isNonErr(self: *Self, operand: MCValue) !MCValue {	3873	fn condBr(self: *Self, cond_ty: Type, condition: MCValue) !Mir.Inst.Index {
1928	_ = operand;	3874	const cond_reg = try self.copyToTmpRegister(cond_ty, condition);
1929	// Here you can specialize this instruction if it makes sense to, otherwise the default	3875
1930	// will call isNull and invert the result.	3876	return try self.addInst(.{
1931	return self.fail("TODO call isErr and invert the result", .{});	3877	.tag = .beq,
		3878	.ops = .rr_inst,
		3879	.data = .{
		3880	.b_type = .{
		3881	.rs1 = cond_reg,
		3882	.rs2 = .zero,
		3883	.inst = undefined,
		3884	},
		3885	},
		3886	});
1932	}	3887	}
1933		3888
1934	fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {	3889	fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
1935	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	3890	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1936	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	3891	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
1937	const operand = try self.resolveInst(un_op);	3892	const operand = try self.resolveInst(un_op);
1938	break :result try self.isNull(operand);	3893	break :result try self.isNull(operand);
1939	};	3894	};
...	@@ -1942,7 +3897,7 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1942,7 +3897,7 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
1942		3897
1943	fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {	3898	fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
1944	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	3899	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1945	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	3900	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
1946	const operand_ptr = try self.resolveInst(un_op);	3901	const operand_ptr = try self.resolveInst(un_op);
1947	const operand: MCValue = blk: {	3902	const operand: MCValue = blk: {
1948	if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {	3903	if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
...	@@ -1958,18 +3913,32 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1958,18 +3913,32 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
1958	return self.finishAir(inst, result, .{ un_op, .none, .none });	3913	return self.finishAir(inst, result, .{ un_op, .none, .none });
1959	}	3914	}
1960		3915
		3916	fn isNull(self: *Self, operand: MCValue) !MCValue {
		3917	_ = operand;
		3918	// Here you can specialize this instruction if it makes sense to, otherwise the default
		3919	// will call isNonNull and invert the result.
		3920	return self.fail("TODO call isNonNull and invert the result", .{});
		3921	}
		3922
1961	fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {	3923	fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
1962	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	3924	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1963	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	3925	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
1964	const operand = try self.resolveInst(un_op);	3926	const operand = try self.resolveInst(un_op);
1965	break :result try self.isNonNull(operand);	3927	break :result try self.isNonNull(operand);
1966	};	3928	};
1967	return self.finishAir(inst, result, .{ un_op, .none, .none });	3929	return self.finishAir(inst, result, .{ un_op, .none, .none });
1968	}	3930	}
1969		3931
		3932	fn isNonNull(self: *Self, operand: MCValue) !MCValue {
		3933	_ = operand;
		3934	// Here you can specialize this instruction if it makes sense to, otherwise the default
		3935	// will call isNull and invert the result.
		3936	return self.fail("TODO call isNull and invert the result", .{});
		3937	}
		3938
1970	fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {	3939	fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
1971	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	3940	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1972	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	3941	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
1973	const operand_ptr = try self.resolveInst(un_op);	3942	const operand_ptr = try self.resolveInst(un_op);
1974	const operand: MCValue = blk: {	3943	const operand: MCValue = blk: {
1975	if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {	3944	if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
...	@@ -1987,16 +3956,18 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1987,16 +3956,18 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
1987		3956
1988	fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {	3957	fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
1989	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	3958	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1990	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	3959	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
1991	const operand = try self.resolveInst(un_op);	3960	const operand = try self.resolveInst(un_op);
1992	break :result try self.isErr(operand);	3961	const operand_ty = self.typeOf(un_op);
		3962	break :result try self.isErr(inst, operand_ty, operand);
1993	};	3963	};
1994	return self.finishAir(inst, result, .{ un_op, .none, .none });	3964	return self.finishAir(inst, result, .{ un_op, .none, .none });
1995	}	3965	}
1996		3966
1997	fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {	3967	fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
		3968	const zcu = self.bin_file.comp.module.?;
1998	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	3969	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
1999	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	3970	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
2000	const operand_ptr = try self.resolveInst(un_op);	3971	const operand_ptr = try self.resolveInst(un_op);
2001	const operand: MCValue = blk: {	3972	const operand: MCValue = blk: {
2002	if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {	3973	if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
...	@@ -2007,23 +3978,100 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2007,23 +3978,100 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
2007	}	3978	}
2008	};	3979	};
2009	try self.load(operand, operand_ptr, self.typeOf(un_op));	3980	try self.load(operand, operand_ptr, self.typeOf(un_op));
2010	break :result try self.isErr(operand);	3981	const operand_ptr_ty = self.typeOf(un_op);
		3982	const operand_ty = operand_ptr_ty.childType(zcu);
		3983
		3984	break :result try self.isErr(inst, operand_ty, operand);
2011	};	3985	};
2012	return self.finishAir(inst, result, .{ un_op, .none, .none });	3986	return self.finishAir(inst, result, .{ un_op, .none, .none });
2013	}	3987	}
2014		3988
		3989	/// Generates a compare instruction which will indicate if `eu_mcv` is an error.
		3990	///
		3991	/// Result is in the return register.
		3992	fn isErr(self: *Self, maybe_inst: ?Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) !MCValue {
		3993	const zcu = self.bin_file.comp.module.?;
		3994	const err_ty = eu_ty.errorUnionSet(zcu);
		3995	if (err_ty.errorSetIsEmpty(zcu)) return MCValue{ .immediate = 0 }; // always false
		3996
		3997	_ = maybe_inst;
		3998
		3999	const err_off = errUnionErrorOffset(eu_ty.errorUnionPayload(zcu), zcu);
		4000
		4001	switch (eu_mcv) {
		4002	.register => \|reg\| {
		4003	const eu_lock = self.register_manager.lockReg(reg);
		4004	defer if (eu_lock) \|lock\| self.register_manager.unlockReg(lock);
		4005
		4006	const return_reg = try self.copyToTmpRegister(eu_ty, eu_mcv);
		4007	const return_lock = self.register_manager.lockRegAssumeUnused(return_reg);
		4008	defer self.register_manager.unlockReg(return_lock);
		4009
		4010	var return_mcv: MCValue = .{ .register = return_reg };
		4011
		4012	if (err_off > 0) {
		4013	return_mcv = try self.binOp(
		4014	.shr,
		4015	return_mcv,
		4016	eu_ty,
		4017	.{ .immediate = @as(u6, @intCast(err_off * 8)) },
		4018	Type.u8,
		4019	);
		4020	}
		4021
		4022	return_mcv = try self.binOp(
		4023	.cmp_neq,
		4024	return_mcv,
		4025	Type.u16,
		4026	.{ .immediate = 0 },
		4027	Type.u16,
		4028	);
		4029
		4030	return return_mcv;
		4031	},
		4032	else => return self.fail("TODO implement isErr for {}", .{eu_mcv}),
		4033	}
		4034	}
		4035
2015	fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {	4036	fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
2016	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4037	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
2017	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	4038	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
2018	const operand = try self.resolveInst(un_op);	4039	const operand = try self.resolveInst(un_op);
2019	break :result try self.isNonErr(operand);	4040	const ty = self.typeOf(un_op);
		4041	break :result try self.isNonErr(inst, ty, operand);
2020	};	4042	};
2021	return self.finishAir(inst, result, .{ un_op, .none, .none });	4043	return self.finishAir(inst, result, .{ un_op, .none, .none });
2022	}	4044	}
2023		4045
		4046	fn isNonErr(self: *Self, inst: Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) !MCValue {
		4047	const is_err_res = try self.isErr(inst, eu_ty, eu_mcv);
		4048	switch (is_err_res) {
		4049	.register => \|reg\| {
		4050	_ = try self.addInst(.{
		4051	.tag = .pseudo,
		4052	.ops = .pseudo_not,
		4053	.data = .{
		4054	.rr = .{
		4055	.rd = reg,
		4056	.rs = reg,
		4057	},
		4058	},
		4059	});
		4060	return is_err_res;
		4061	},
		4062	// always false case
		4063	.immediate => \|imm\| {
		4064	assert(imm == 0);
		4065	return MCValue{ .immediate = @intFromBool(imm == 0) };
		4066	},
		4067	else => unreachable,
		4068	}
		4069	}
		4070
2024	fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {	4071	fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
		4072	const zcu = self.bin_file.comp.module.?;
2025	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4073	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
2026	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	4074	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else result: {
2027	const operand_ptr = try self.resolveInst(un_op);	4075	const operand_ptr = try self.resolveInst(un_op);
2028	const operand: MCValue = blk: {	4076	const operand: MCValue = blk: {
2029	if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {	4077	if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
...	@@ -2033,8 +4081,11 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2033,8 +4081,11 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
2033	break :blk try self.allocRegOrMem(inst, true);	4081	break :blk try self.allocRegOrMem(inst, true);
2034	}	4082	}
2035	};	4083	};
		4084	const operand_ptr_ty = self.typeOf(un_op);
		4085	const operand_ty = operand_ptr_ty.childType(zcu);
		4086
2036	try self.load(operand, operand_ptr, self.typeOf(un_op));	4087	try self.load(operand, operand_ptr, self.typeOf(un_op));
2037	break :result try self.isNonErr(operand);	4088	break :result try self.isNonErr(inst, operand_ty, operand);
2038	};	4089	};
2039	return self.finishAir(inst, result, .{ un_op, .none, .none });	4090	return self.finishAir(inst, result, .{ un_op, .none, .none });
2040	}	4091	}
...	@@ -2044,16 +4095,32 @@ fn airLoop(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2044,16 +4095,32 @@ fn airLoop(self: *Self, inst: Air.Inst.Index) !void {
2044	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	4095	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
2045	const loop = self.air.extraData(Air.Block, ty_pl.payload);	4096	const loop = self.air.extraData(Air.Block, ty_pl.payload);
2046	const body: []const Air.Inst.Index = @ptrCast(self.air.extra[loop.end..][0..loop.data.body_len]);	4097	const body: []const Air.Inst.Index = @ptrCast(self.air.extra[loop.end..][0..loop.data.body_len]);
2047	const start_index = self.code.items.len;	4098
		4099	self.scope_generation += 1;
		4100	const state = try self.saveState();
		4101
		4102	const jmp_target: Mir.Inst.Index = @intCast(self.mir_instructions.len);
2048	try self.genBody(body);	4103	try self.genBody(body);
2049	try self.jump(start_index);	4104	try self.restoreState(state, &.{}, .{
2050	return self.finishAirBookkeeping();	4105	.emit_instructions = true,
		4106	.update_tracking = false,
		4107	.resurrect = false,
		4108	.close_scope = true,
		4109	});
		4110	_ = try self.jump(jmp_target);
		4111
		4112	self.finishAirBookkeeping();
2051	}	4113	}
2052		4114
2053	/// Send control flow to the `index` of `self.code`.	4115	/// Send control flow to the `index` of `self.code`.
2054	fn jump(self: *Self, index: usize) !void {	4116	fn jump(self: *Self, index: Mir.Inst.Index) !Mir.Inst.Index {
2055	_ = index;	4117	return self.addInst(.{
2056	return self.fail("TODO implement jump for {}", .{self.target.cpu.arch});	4118	.tag = .pseudo,
		4119	.ops = .pseudo_j,
		4120	.data = .{
		4121	.inst = index,
		4122	},
		4123	});
2057	}	4124	}
2058		4125
2059	fn airBlock(self: *Self, inst: Air.Inst.Index) !void {	4126	fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
...	@@ -2063,24 +4130,34 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2063,24 +4130,34 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
2063	}	4130	}
2064		4131
2065	fn lowerBlock(self: *Self, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void {	4132	fn lowerBlock(self: *Self, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void {
2066	try self.blocks.putNoClobber(self.gpa, inst, .{	4133	// A block is a setup to be able to jump to the end.
2067	// A block is a setup to be able to jump to the end.	4134	const inst_tracking_i = self.inst_tracking.count();
2068	.relocs = .{},	4135	self.inst_tracking.putAssumeCapacityNoClobber(inst, InstTracking.init(.unreach));
2069	// It also acts as a receptacle for break operands.	4136
2070	// Here we use `MCValue.none` to represent a null value so that the first	4137	self.scope_generation += 1;
2071	// break instruction will choose a MCValue for the block result and overwrite	4138	try self.blocks.putNoClobber(self.gpa, inst, .{ .state = self.initRetroactiveState() });
2072	// this field. Following break instructions will use that MCValue to put their	4139	const liveness = self.liveness.getBlock(inst);
2073	// block results.	4140
2074	.mcv = MCValue{ .none = {} },
2075	});
2076	defer self.blocks.getPtr(inst).?.relocs.deinit(self.gpa);
2077	// TODO emit debug info lexical block	4141	// TODO emit debug info lexical block
2078	try self.genBody(body);	4142	try self.genBody(body);
2079		4143
2080	for (self.blocks.getPtr(inst).?.relocs.items) \|reloc\| try self.performReloc(reloc);	4144	var block_data = self.blocks.fetchRemove(inst).?;
		4145	defer block_data.value.deinit(self.gpa);
		4146	if (block_data.value.relocs.items.len > 0) {
		4147	try self.restoreState(block_data.value.state, liveness.deaths, .{
		4148	.emit_instructions = false,
		4149	.update_tracking = true,
		4150	.resurrect = true,
		4151	.close_scope = true,
		4152	});
		4153	for (block_data.value.relocs.items) \|reloc\| self.performReloc(reloc);
		4154	}
2081		4155
2082	const result = self.blocks.getPtr(inst).?.mcv;	4156	if (std.debug.runtime_safety) assert(self.inst_tracking.getIndex(inst).? == inst_tracking_i);
2083	return self.finishAir(inst, result, .{ .none, .none, .none });	4157	const tracking = &self.inst_tracking.values()[inst_tracking_i];
		4158	if (self.liveness.isUnused(inst)) try tracking.die(self, inst);
		4159	self.getValueIfFree(tracking.short, inst);
		4160	self.finishAirBookkeeping();
2084	}	4161	}
2085		4162
2086	fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {	4163	fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
...	@@ -2091,51 +4168,91 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2091,51 +4168,91 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
2091	// return self.finishAir(inst, .dead, .{ condition, .none, .none });	4168	// return self.finishAir(inst, .dead, .{ condition, .none, .none });
2092	}	4169	}
2093		4170
2094	fn performReloc(self: *Self, reloc: Reloc) !void {	4171	fn performReloc(self: *Self, inst: Mir.Inst.Index) void {
2095	_ = self;	4172	const tag = self.mir_instructions.items(.tag)[inst];
2096	switch (reloc) {	4173	const ops = self.mir_instructions.items(.ops)[inst];
2097	.rel32 => unreachable,	4174	const target: Mir.Inst.Index = @intCast(self.mir_instructions.len);
2098	.arm_branch => unreachable,	4175
		4176	switch (tag) {
		4177	.bne,
		4178	.beq,
		4179	=> self.mir_instructions.items(.data)[inst].b_type.inst = target,
		4180	.jal => self.mir_instructions.items(.data)[inst].j_type.inst = target,
		4181	.pseudo => switch (ops) {
		4182	.pseudo_j => self.mir_instructions.items(.data)[inst].inst = target,
		4183	else => std.debug.panic("TODO: performReloc {s}", .{@tagName(ops)}),
		4184	},
		4185	else => std.debug.panic("TODO: performReloc {s}", .{@tagName(tag)}),
2099	}	4186	}
2100	}	4187	}
2101		4188
2102	fn airBr(self: *Self, inst: Air.Inst.Index) !void {	4189	fn airBr(self: *Self, inst: Air.Inst.Index) !void {
2103	const branch = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
2104	try self.br(branch.block_inst, branch.operand);
2105	return self.finishAir(inst, .dead, .{ branch.operand, .none, .none });
2106	}
2107
2108	fn airBoolOp(self: *Self, inst: Air.Inst.Index) !void {
2109	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
2110	const air_tags = self.air.instructions.items(.tag);
2111	_ = air_tags;
2112	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement boolean operations for {}", .{self.target.cpu.arch});
2113	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
2114	}
2115
2116	fn br(self: *Self, block: Air.Inst.Index, operand: Air.Inst.Ref) !void {
2117	const block_data = self.blocks.getPtr(block).?;
2118
2119	const mod = self.bin_file.comp.module.?;	4190	const mod = self.bin_file.comp.module.?;
2120	if (self.typeOf(operand).hasRuntimeBits(mod)) {	4191	const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
2121	const operand_mcv = try self.resolveInst(operand);	4192
2122	const block_mcv = block_data.mcv;	4193	const block_ty = self.typeOfIndex(br.block_inst);
2123	if (block_mcv == .none) {	4194	const block_unused =
2124	block_data.mcv = operand_mcv;	4195	!block_ty.hasRuntimeBitsIgnoreComptime(mod) or self.liveness.isUnused(br.block_inst);
2125	} else {	4196	const block_tracking = self.inst_tracking.getPtr(br.block_inst).?;
2126	try self.setRegOrMem(self.typeOfIndex(block), block_mcv, operand_mcv);	4197	const block_data = self.blocks.getPtr(br.block_inst).?;
		4198	const first_br = block_data.relocs.items.len == 0;
		4199	const block_result = result: {
		4200	if (block_unused) break :result .none;
		4201
		4202	if (!first_br) try self.getValue(block_tracking.short, null);
		4203	const src_mcv = try self.resolveInst(br.operand);
		4204
		4205	if (self.reuseOperandAdvanced(inst, br.operand, 0, src_mcv, br.block_inst)) {
		4206	if (first_br) break :result src_mcv;
		4207
		4208	try self.getValue(block_tracking.short, br.block_inst);
		4209	// .long = .none to avoid merging operand and block result stack frames.
		4210	const current_tracking: InstTracking = .{ .long = .none, .short = src_mcv };
		4211	try current_tracking.materializeUnsafe(self, br.block_inst, block_tracking.*);
		4212	for (current_tracking.getRegs()) \|src_reg\| self.register_manager.freeReg(src_reg);
		4213	break :result block_tracking.short;
2127	}	4214	}
		4215
		4216	const dst_mcv = if (first_br) try self.allocRegOrMem(br.block_inst, true) else dst: {
		4217	try self.getValue(block_tracking.short, br.block_inst);
		4218	break :dst block_tracking.short;
		4219	};
		4220	try self.genCopy(block_ty, dst_mcv, try self.resolveInst(br.operand));
		4221	break :result dst_mcv;
		4222	};
		4223
		4224	// Process operand death so that it is properly accounted for in the State below.
		4225	if (self.liveness.operandDies(inst, 0)) {
		4226	if (br.operand.toIndex()) \|op_inst\| try self.processDeath(op_inst);
2128	}	4227	}
2129	return self.brVoid(block);
2130	}
2131		4228
2132	fn brVoid(self: *Self, block: Air.Inst.Index) !void {	4229	if (first_br) {
2133	const block_data = self.blocks.getPtr(block).?;	4230	block_tracking.* = InstTracking.init(block_result);
		4231	try self.saveRetroactiveState(&block_data.state);
		4232	} else try self.restoreState(block_data.state, &.{}, .{
		4233	.emit_instructions = true,
		4234	.update_tracking = false,
		4235	.resurrect = false,
		4236	.close_scope = false,
		4237	});
2134		4238
2135	// Emit a jump with a relocation. It will be patched up after the block ends.	4239	// Emit a jump with a relocation. It will be patched up after the block ends.
2136	try block_data.relocs.ensureUnusedCapacity(self.gpa, 1);	4240	// Leave the jump offset undefined
		4241	const jmp_reloc = try self.jump(undefined);
		4242	try block_data.relocs.append(self.gpa, jmp_reloc);
		4243
		4244	// Stop tracking block result without forgetting tracking info
		4245	try self.freeValue(block_tracking.short);
		4246
		4247	self.finishAirBookkeeping();
		4248	}
2137		4249
2138	return self.fail("TODO implement brvoid for {}", .{self.target.cpu.arch});	4250	fn airBoolOp(self: *Self, inst: Air.Inst.Index) !void {
		4251	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
		4252	const air_tags = self.air.instructions.items(.tag);
		4253	_ = air_tags;
		4254	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement boolean operations for {}", .{self.target.cpu.arch});
		4255	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
2139	}	4256	}
2140		4257
2141	fn airAsm(self: *Self, inst: Air.Inst.Index) !void {	4258	fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
...	@@ -2144,13 +4261,16 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2144,13 +4261,16 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
2144	const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;	4261	const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
2145	const clobbers_len: u31 = @truncate(extra.data.flags);	4262	const clobbers_len: u31 = @truncate(extra.data.flags);
2146	var extra_i: usize = extra.end;	4263	var extra_i: usize = extra.end;
2147	const outputs: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra_i..][0..extra.data.outputs_len]);	4264	const outputs: []const Air.Inst.Ref =
		4265	@ptrCast(self.air.extra[extra_i..][0..extra.data.outputs_len]);
2148	extra_i += outputs.len;	4266	extra_i += outputs.len;
2149	const inputs: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra_i..][0..extra.data.inputs_len]);	4267	const inputs: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra_i..][0..extra.data.inputs_len]);
2150	extra_i += inputs.len;	4268	extra_i += inputs.len;
2151		4269
		4270	log.debug("airAsm input: {any}", .{inputs});
		4271
2152	const dead = !is_volatile and self.liveness.isUnused(inst);	4272	const dead = !is_volatile and self.liveness.isUnused(inst);
2153	const result: MCValue = if (dead) .dead else result: {	4273	const result: MCValue = if (dead) .unreach else result: {
2154	if (outputs.len > 1) {	4274	if (outputs.len > 1) {
2155	return self.fail("TODO implement codegen for asm with more than 1 output", .{});	4275	return self.fail("TODO implement codegen for asm with more than 1 output", .{});
2156	}	4276	}
...	@@ -2197,19 +4317,25 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2197,19 +4317,25 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
2197	// for the string, we still use the next u32 for the null terminator.	4317	// for the string, we still use the next u32 for the null terminator.
2198	extra_i += clobber.len / 4 + 1;	4318	extra_i += clobber.len / 4 + 1;
2199		4319
2200	// TODO honor these	4320	if (std.mem.eql(u8, clobber, "") or std.mem.eql(u8, clobber, "memory")) {
		4321	// nothing really to do
		4322	} else {
		4323	try self.register_manager.getReg(parseRegName(clobber) orelse
		4324	return self.fail("invalid clobber: '{s}'", .{clobber}), null);
		4325	}
2201	}	4326	}
2202	}	4327	}
2203		4328
2204	const asm_source = std.mem.sliceAsBytes(self.air.extra[extra_i..])[0..extra.data.source_len];	4329	const asm_source = std.mem.sliceAsBytes(self.air.extra[extra_i..])[0..extra.data.source_len];
2205		4330
2206	if (mem.eql(u8, asm_source, "ecall")) {	4331	if (std.meta.stringToEnum(Mir.Inst.Tag, asm_source)) \|tag\| {
2207	_ = try self.addInst(.{	4332	_ = try self.addInst(.{
2208	.tag = .ecall,	4333	.tag = tag,
2209	.data = .{ .nop = {} },	4334	.ops = .none,
		4335	.data = undefined,
2210	});	4336	});
2211	} else {	4337	} else {
2212	return self.fail("TODO implement support for more riscv64 assembly instructions", .{});	4338	return self.fail("TODO: asm_source {s}", .{asm_source});
2213	}	4339	}
2214		4340
2215	if (output_constraint) \|output\| {	4341	if (output_constraint) \|output\| {
...	@@ -2219,11 +4345,12 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2219,11 +4345,12 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
2219	const reg_name = output[2 .. output.len - 1];	4345	const reg_name = output[2 .. output.len - 1];
2220	const reg = parseRegName(reg_name) orelse	4346	const reg = parseRegName(reg_name) orelse
2221	return self.fail("unrecognized register: '{s}'", .{reg_name});	4347	return self.fail("unrecognized register: '{s}'", .{reg_name});
2222	break :result MCValue{ .register = reg };	4348	break :result .{ .register = reg };
2223	} else {	4349	} else {
2224	break :result MCValue{ .none = {} };	4350	break :result .{ .none = {} };
2225	}	4351	}
2226	};	4352	};
		4353
2227	simple: {	4354	simple: {
2228	var buf = [1]Air.Inst.Ref{.none} ** (Liveness.bpi - 1);	4355	var buf = [1]Air.Inst.Ref{.none} ** (Liveness.bpi - 1);
2229	var buf_index: usize = 0;	4356	var buf_index: usize = 0;
...	@@ -2238,51 +4365,292 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2238,51 +4365,292 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
2238	@memcpy(buf[buf_index..][0..inputs.len], inputs);	4365	@memcpy(buf[buf_index..][0..inputs.len], inputs);
2239	return self.finishAir(inst, result, buf);	4366	return self.finishAir(inst, result, buf);
2240	}	4367	}
2241	var bt = try self.iterateBigTomb(inst, outputs.len + inputs.len);	4368	var bt = self.liveness.iterateBigTomb(inst);
2242	for (outputs) \|output\| {	4369	for (outputs) \|output\| if (output != .none) try self.feed(&bt, output);
2243	if (output == .none) continue;	4370	for (inputs) \|input\| try self.feed(&bt, input);
		4371	return self.finishAirResult(inst, result);
		4372	}
2244		4373
2245	bt.feed(output);	4374	/// Sets the value without any modifications to register allocation metadata or stack allocation metadata.
2246	}	4375	fn genCopy(self: *Self, ty: Type, dst_mcv: MCValue, src_mcv: MCValue) !void {
2247	for (inputs) \|input\| {	4376	const zcu = self.bin_file.comp.module.?;
2248	bt.feed(input);	4377
		4378	// There isn't anything to store
		4379	if (dst_mcv == .none) return;
		4380
		4381	if (!dst_mcv.isMutable()) {
		4382	// panic so we can see the trace
		4383	return self.fail("tried to genCopy immutable: {s}", .{@tagName(dst_mcv)});
2249	}	4384	}
2250	return bt.finishAir(result);
2251	}
2252		4385
2253	fn iterateBigTomb(self: *Self, inst: Air.Inst.Index, operand_count: usize) !BigTomb {	4386	switch (dst_mcv) {
2254	try self.ensureProcessDeathCapacity(operand_count + 1);	4387	.register => \|reg\| return self.genSetReg(ty, reg, src_mcv),
2255	return BigTomb{	4388	.register_offset => \|dst_reg_off\| try self.genSetReg(ty, dst_reg_off.reg, switch (src_mcv) {
2256	.function = self,	4389	.none,
2257	.inst = inst,	4390	.unreach,
2258	.lbt = self.liveness.iterateBigTomb(inst),	4391	.dead,
2259	};	4392	.undef,
		4393	=> unreachable,
		4394	.immediate,
		4395	.register,
		4396	.register_offset,
		4397	=> src_mcv.offset(-dst_reg_off.off),
		4398	else => .{ .register_offset = .{
		4399	.reg = try self.copyToTmpRegister(ty, src_mcv),
		4400	.off = -dst_reg_off.off,
		4401	} },
		4402	}),
		4403	.indirect => \|ro\| {
		4404	const src_reg = try self.copyToTmpRegister(ty, src_mcv);
		4405
		4406	_ = try self.addInst(.{
		4407	.tag = .pseudo,
		4408	.ops = .pseudo_store_rm,
		4409	.data = .{ .rm = .{
		4410	.r = src_reg,
		4411	.m = .{
		4412	.base = .{ .reg = ro.reg },
		4413	.mod = .{ .rm = .{ .disp = ro.off, .size = self.memSize(ty) } },
		4414	},
		4415	} },
		4416	});
		4417	},
		4418	.load_frame => \|frame\| return self.genSetStack(ty, frame, src_mcv),
		4419	.memory => return self.fail("TODO: genCopy memory", .{}),
		4420	.register_pair => \|dst_regs\| {
		4421	const src_info: ?struct { addr_reg: Register, addr_lock: RegisterLock } = switch (src_mcv) {
		4422	.register_pair, .memory, .indirect, .load_frame => null,
		4423	.load_symbol => src: {
		4424	const src_addr_reg, const src_addr_lock = try self.allocReg();
		4425	errdefer self.register_manager.unlockReg(src_addr_lock);
		4426
		4427	try self.genSetReg(Type.usize, src_addr_reg, src_mcv.address());
		4428	break :src .{ .addr_reg = src_addr_reg, .addr_lock = src_addr_lock };
		4429	},
		4430	.air_ref => \|src_ref\| return self.genCopy(
		4431	ty,
		4432	dst_mcv,
		4433	try self.resolveInst(src_ref),
		4434	),
		4435	else => unreachable,
		4436	};
		4437	defer if (src_info) \|info\| self.register_manager.unlockReg(info.addr_lock);
		4438
		4439	var part_disp: i32 = 0;
		4440	for (dst_regs, try self.splitType(ty), 0..) \|dst_reg, dst_ty, part_i\| {
		4441	try self.genSetReg(dst_ty, dst_reg, switch (src_mcv) {
		4442	.register_pair => \|src_regs\| .{ .register = src_regs[part_i] },
		4443	.memory, .indirect, .load_frame => src_mcv.address().offset(part_disp).deref(),
		4444	.load_symbol => .{ .indirect = .{
		4445	.reg = src_info.?.addr_reg,
		4446	.off = part_disp,
		4447	} },
		4448	else => unreachable,
		4449	});
		4450	part_disp += @intCast(dst_ty.abiSize(zcu));
		4451	}
		4452	},
		4453	else => return self.fail("TODO: genCopy to {s} from {s}", .{ @tagName(dst_mcv), @tagName(src_mcv) }),
		4454	}
2260	}	4455	}
2261		4456
2262	/// Sets the value without any modifications to register allocation metadata or stack allocation metadata.	4457	fn genSetStack(
2263	fn setRegOrMem(self: *Self, ty: Type, loc: MCValue, val: MCValue) !void {	4458	self: *Self,
2264	switch (loc) {	4459	ty: Type,
		4460	frame: FrameAddr,
		4461	src_mcv: MCValue,
		4462	) InnerError!void {
		4463	const zcu = self.bin_file.comp.module.?;
		4464	const abi_size: u32 = @intCast(ty.abiSize(zcu));
		4465
		4466	switch (src_mcv) {
2265	.none => return,	4467	.none => return,
2266	.register => \|reg\| return self.genSetReg(ty, reg, val),	4468	.dead => unreachable,
2267	.stack_offset => \|off\| return self.genSetStack(ty, off, val),	4469	.undef => {
2268	.memory => {	4470	if (!self.wantSafety()) return;
2269	return self.fail("TODO implement setRegOrMem for memory", .{});	4471	try self.genSetStack(ty, frame, .{ .immediate = 0xaaaaaaaaaaaaaaaa });
2270	},	4472	},
2271	else => unreachable,	4473	.immediate,
		4474	.lea_frame,
		4475	=> {
		4476	// TODO: remove this lock in favor of a copyToTmpRegister when we load 64 bit immediates with
		4477	// a register allocation.
		4478	const reg, const reg_lock = try self.allocReg();
		4479	defer self.register_manager.unlockReg(reg_lock);
		4480
		4481	try self.genSetReg(ty, reg, src_mcv);
		4482
		4483	return self.genSetStack(ty, frame, .{ .register = reg });
		4484	},
		4485	.register => \|reg\| {
		4486	switch (abi_size) {
		4487	1, 2, 4, 8 => {
		4488	_ = try self.addInst(.{
		4489	.tag = .pseudo,
		4490	.ops = .pseudo_store_rm,
		4491	.data = .{ .rm = .{
		4492	.r = reg,
		4493	.m = .{
		4494	.base = .{ .frame = frame.index },
		4495	.mod = .{
		4496	.rm = .{
		4497	.size = self.memSize(ty),
		4498	.disp = frame.off,
		4499	},
		4500	},
		4501	},
		4502	} },
		4503	});
		4504	},
		4505	else => unreachable, // register can hold a max of 8 bytes
		4506	}
		4507	},
		4508	.register_pair => \|pair\| {
		4509	var part_disp: i32 = frame.off;
		4510	for (try self.splitType(ty), pair) \|src_ty, src_reg\| {
		4511	try self.genSetStack(
		4512	src_ty,
		4513	.{ .index = frame.index, .off = part_disp },
		4514	.{ .register = src_reg },
		4515	);
		4516	part_disp += @intCast(src_ty.abiSize(zcu));
		4517	}
		4518	},
		4519	.load_frame,
		4520	.indirect,
		4521	.load_symbol,
		4522	=> {
		4523	if (abi_size <= 8) {
		4524	const reg = try self.copyToTmpRegister(ty, src_mcv);
		4525	return self.genSetStack(ty, frame, .{ .register = reg });
		4526	}
		4527
		4528	try self.genInlineMemcpy(
		4529	.{ .lea_frame = frame },
		4530	src_mcv.address(),
		4531	.{ .immediate = abi_size },
		4532	);
		4533	},
		4534	.air_ref => \|ref\| try self.genSetStack(ty, frame, try self.resolveInst(ref)),
		4535	else => return self.fail("TODO: genSetStack {s}", .{@tagName(src_mcv)}),
2272	}	4536	}
2273	}	4537	}
2274		4538
2275	fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {	4539	fn genInlineMemcpy(
2276	_ = ty;	4540	self: *Self,
2277	_ = stack_offset;	4541	dst_ptr: MCValue,
2278	_ = mcv;	4542	src_ptr: MCValue,
2279	return self.fail("TODO implement getSetStack for {}", .{self.target.cpu.arch});	4543	len: MCValue,
		4544	) !void {
		4545	const regs = try self.register_manager.allocRegs(4, .{null} ** 4, tp);
		4546	const locks = self.register_manager.lockRegsAssumeUnused(4, regs);
		4547	defer for (locks) \|lock\| self.register_manager.unlockReg(lock);
		4548
		4549	const count = regs[0];
		4550	const tmp = regs[1];
		4551	const src = regs[2];
		4552	const dst = regs[3];
		4553
		4554	try self.genSetReg(Type.usize, count, len);
		4555	try self.genSetReg(Type.usize, src, src_ptr);
		4556	try self.genSetReg(Type.usize, dst, dst_ptr);
		4557
		4558	// lb tmp, 0(src)
		4559	const first_inst = try self.addInst(.{
		4560	.tag = .lb,
		4561	.ops = .rri,
		4562	.data = .{
		4563	.i_type = .{
		4564	.rd = tmp,
		4565	.rs1 = src,
		4566	.imm12 = Immediate.s(0),
		4567	},
		4568	},
		4569	});
		4570
		4571	// sb tmp, 0(dst)
		4572	_ = try self.addInst(.{
		4573	.tag = .sb,
		4574	.ops = .rri,
		4575	.data = .{
		4576	.i_type = .{
		4577	.rd = dst,
		4578	.rs1 = tmp,
		4579	.imm12 = Immediate.s(0),
		4580	},
		4581	},
		4582	});
		4583
		4584	// dec count by 1
		4585	_ = try self.addInst(.{
		4586	.tag = .addi,
		4587	.ops = .rri,
		4588	.data = .{
		4589	.i_type = .{
		4590	.rd = count,
		4591	.rs1 = count,
		4592	.imm12 = Immediate.s(-1),
		4593	},
		4594	},
		4595	});
		4596
		4597	// branch if count is 0
		4598	_ = try self.addInst(.{
		4599	.tag = .beq,
		4600	.ops = .rr_inst,
		4601	.data = .{
		4602	.b_type = .{
		4603	.inst = @intCast(self.mir_instructions.len + 4), // points after the last inst
		4604	.rs1 = count,
		4605	.rs2 = .zero,
		4606	},
		4607	},
		4608	});
		4609
		4610	// increment the pointers
		4611	_ = try self.addInst(.{
		4612	.tag = .addi,
		4613	.ops = .rri,
		4614	.data = .{
		4615	.i_type = .{
		4616	.rd = src,
		4617	.rs1 = src,
		4618	.imm12 = Immediate.s(1),
		4619	},
		4620	},
		4621	});
		4622
		4623	_ = try self.addInst(.{
		4624	.tag = .addi,
		4625	.ops = .rri,
		4626	.data = .{
		4627	.i_type = .{
		4628	.rd = dst,
		4629	.rs1 = dst,
		4630	.imm12 = Immediate.s(1),
		4631	},
		4632	},
		4633	});
		4634
		4635	// jump back to start of loop
		4636	_ = try self.addInst(.{
		4637	.tag = .pseudo,
		4638	.ops = .pseudo_j,
		4639	.data = .{
		4640	.inst = first_inst,
		4641	},
		4642	});
2280	}	4643	}
2281		4644
2282	fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void {	4645	/// Sets the value of `src_mcv` into `reg`. Assumes you have a lock on it.
2283	switch (mcv) {	4646	fn genSetReg(self: *Self, ty: Type, reg: Register, src_mcv: MCValue) InnerError!void {
		4647	const zcu = self.bin_file.comp.module.?;
		4648	const abi_size: u32 = @intCast(ty.abiSize(zcu));
		4649
		4650	if (abi_size > 8) return self.fail("tried to set reg with size {}", .{abi_size});
		4651
		4652	switch (src_mcv) {
2284	.dead => unreachable,	4653	.dead => unreachable,
2285	.ptr_stack_offset => unreachable,
2286	.unreach, .none => return, // Nothing to do.	4654	.unreach, .none => return, // Nothing to do.
2287	.undef => {	4655	.undef => {
2288	if (!self.wantSafety())	4656	if (!self.wantSafety())
...	@@ -2295,10 +4663,11 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void	...	@@ -2295,10 +4663,11 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
2295	if (math.minInt(i12) <= x and x <= math.maxInt(i12)) {	4663	if (math.minInt(i12) <= x and x <= math.maxInt(i12)) {
2296	_ = try self.addInst(.{	4664	_ = try self.addInst(.{
2297	.tag = .addi,	4665	.tag = .addi,
		4666	.ops = .rri,
2298	.data = .{ .i_type = .{	4667	.data = .{ .i_type = .{
2299	.rd = reg,	4668	.rd = reg,
2300	.rs1 = .zero,	4669	.rs1 = .zero,
2301	.imm12 = @intCast(x),	4670	.imm12 = Immediate.s(@intCast(x)),
2302	} },	4671	} },
2303	});	4672	});
2304	} else if (math.minInt(i32) <= x and x <= math.maxInt(i32)) {	4673	} else if (math.minInt(i32) <= x and x <= math.maxInt(i32)) {
...	@@ -2306,26 +4675,56 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void	...	@@ -2306,26 +4675,56 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
2306	const carry: i32 = if (lo12 < 0) 1 else 0;	4675	const carry: i32 = if (lo12 < 0) 1 else 0;
2307	const hi20: i20 = @truncate((x >> 12) +% carry);	4676	const hi20: i20 = @truncate((x >> 12) +% carry);
2308		4677
2309	// TODO: add test case for 32-bit immediate
2310	_ = try self.addInst(.{	4678	_ = try self.addInst(.{
2311	.tag = .lui,	4679	.tag = .lui,
		4680	.ops = .ri,
2312	.data = .{ .u_type = .{	4681	.data = .{ .u_type = .{
2313	.rd = reg,	4682	.rd = reg,
2314	.imm20 = hi20,	4683	.imm20 = Immediate.s(hi20),
2315	} },	4684	} },
2316	});	4685	});
2317	_ = try self.addInst(.{	4686	_ = try self.addInst(.{
2318	.tag = .addi,	4687	.tag = .addi,
		4688	.ops = .rri,
2319	.data = .{ .i_type = .{	4689	.data = .{ .i_type = .{
2320	.rd = reg,	4690	.rd = reg,
2321	.rs1 = reg,	4691	.rs1 = reg,
2322	.imm12 = lo12,	4692	.imm12 = Immediate.s(lo12),
2323	} },	4693	} },
2324	});	4694	});
2325	} else {	4695	} else {
2326	// li rd, immediate	4696	// TODO: use a more advanced myriad seq to do this without a reg.
2327	// "Myriad sequences"	4697	// see: https://github.com/llvm/llvm-project/blob/081a66ffacfe85a37ff775addafcf3371e967328/llvm/lib/Target/RISCV/MCTargetDesc/RISCVMatInt.cpp#L224
2328	return self.fail("TODO genSetReg 33-64 bit immediates for riscv64", .{}); // glhf	4698
		4699	const temp, const temp_lock = try self.allocReg();
		4700	defer self.register_manager.unlockReg(temp_lock);
		4701
		4702	const lo32: i32 = @truncate(x);
		4703	const carry: i32 = if (lo32 < 0) 1 else 0;
		4704	const hi32: i32 = @truncate((x >> 32) +% carry);
		4705
		4706	try self.genSetReg(Type.i32, temp, .{ .immediate = @bitCast(@as(i64, lo32)) });
		4707	try self.genSetReg(Type.i32, reg, .{ .immediate = @bitCast(@as(i64, hi32)) });
		4708
		4709	_ = try self.addInst(.{
		4710	.tag = .slli,
		4711	.ops = .rri,
		4712	.data = .{ .i_type = .{
		4713	.rd = reg,
		4714	.rs1 = reg,
		4715	.imm12 = Immediate.s(32),
		4716	} },
		4717	});
		4718
		4719	_ = try self.addInst(.{
		4720	.tag = .add,
		4721	.ops = .rrr,
		4722	.data = .{ .r_type = .{
		4723	.rd = reg,
		4724	.rs1 = reg,
		4725	.rs2 = temp,
		4726	} },
		4727	});
2329	}	4728	}
2330	},	4729	},
2331	.register => \|src_reg\| {	4730	.register => \|src_reg\| {
...	@@ -2335,62 +4734,160 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void	...	@@ -2335,62 +4734,160 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
2335		4734
2336	// mov reg, src_reg	4735	// mov reg, src_reg
2337	_ = try self.addInst(.{	4736	_ = try self.addInst(.{
2338	.tag = .mv,	4737	.tag = .pseudo,
		4738	.ops = .pseudo_mv,
2339	.data = .{ .rr = .{	4739	.data = .{ .rr = .{
2340	.rd = reg,	4740	.rd = reg,
2341	.rs = src_reg,	4741	.rs = src_reg,
2342	} },	4742	} },
2343	});	4743	});
2344	},	4744	},
		4745	.register_pair => \|pair\| try self.genSetReg(ty, reg, .{ .register = pair[0] }),
2345	.memory => \|addr\| {	4746	.memory => \|addr\| {
2346	// The value is in memory at a hard-coded address.
2347	// If the type is a pointer, it means the pointer address is at this memory location.
2348	try self.genSetReg(ty, reg, .{ .immediate = addr });	4747	try self.genSetReg(ty, reg, .{ .immediate = addr });
2349		4748
2350	_ = try self.addInst(.{	4749	_ = try self.addInst(.{
2351	.tag = .ld,	4750	.tag = .ld,
		4751	.ops = .rri,
2352	.data = .{ .i_type = .{	4752	.data = .{ .i_type = .{
2353	.rd = reg,	4753	.rd = reg,
2354	.rs1 = reg,	4754	.rs1 = reg,
2355	.imm12 = 0,	4755	.imm12 = Immediate.s(0),
		4756	} },
		4757	});
		4758	},
		4759	.load_frame => \|frame\| {
		4760	_ = try self.addInst(.{
		4761	.tag = .pseudo,
		4762	.ops = .pseudo_load_rm,
		4763	.data = .{ .rm = .{
		4764	.r = reg,
		4765	.m = .{
		4766	.base = .{ .frame = frame.index },
		4767	.mod = .{
		4768	.rm = .{
		4769	.size = self.memSize(ty),
		4770	.disp = frame.off,
		4771	},
		4772	},
		4773	},
		4774	} },
		4775	});
		4776	},
		4777	.lea_frame => \|frame\| {
		4778	_ = try self.addInst(.{
		4779	.tag = .pseudo,
		4780	.ops = .pseudo_lea_rm,
		4781	.data = .{ .rm = .{
		4782	.r = reg,
		4783	.m = .{
		4784	.base = .{ .frame = frame.index },
		4785	.mod = .{
		4786	.rm = .{
		4787	.size = self.memSize(ty),
		4788	.disp = frame.off,
		4789	},
		4790	},
		4791	},
		4792	} },
		4793	});
		4794	},
		4795	.load_symbol => {
		4796	try self.genSetReg(ty, reg, src_mcv.address());
		4797	try self.genSetReg(ty, reg, .{ .indirect = .{ .reg = reg } });
		4798	},
		4799	.indirect => \|reg_off\| {
		4800	const load_tag: Mir.Inst.Tag = switch (abi_size) {
		4801	1 => .lb,
		4802	2 => .lh,
		4803	4 => .lw,
		4804	8 => .ld,
		4805	else => return self.fail("TODO: genSetReg for size {d}", .{abi_size}),
		4806	};
		4807
		4808	_ = try self.addInst(.{
		4809	.tag = load_tag,
		4810	.ops = .rri,
		4811	.data = .{ .i_type = .{
		4812	.rd = reg,
		4813	.rs1 = reg_off.reg,
		4814	.imm12 = Immediate.s(reg_off.off),
2356	} },	4815	} },
2357	});	4816	});
2358	// LOAD imm=[i12 offset = 0], rs1 =	4817	},
		4818	.lea_symbol => \|sym_off\| {
		4819	assert(sym_off.off == 0);
		4820
		4821	const atom_index = try self.symbolIndex();
2359		4822
2360	// return self.fail("TODO implement genSetReg memory for riscv64");	4823	_ = try self.addInst(.{
		4824	.tag = .pseudo,
		4825	.ops = .pseudo_load_symbol,
		4826	.data = .{ .payload = try self.addExtra(Mir.LoadSymbolPayload{
		4827	.register = reg.id(),
		4828	.atom_index = atom_index,
		4829	.sym_index = sym_off.sym,
		4830	}) },
		4831	});
2361	},	4832	},
2362	else => return self.fail("TODO implement getSetReg for riscv64 {}", .{mcv}),	4833	.air_ref => \|ref\| try self.genSetReg(ty, reg, try self.resolveInst(ref)),
		4834	else => return self.fail("TODO: genSetReg {s}", .{@tagName(src_mcv)}),
2363	}	4835	}
2364	}	4836	}
2365		4837
2366	fn airIntFromPtr(self: *Self, inst: Air.Inst.Index) !void {	4838	fn airIntFromPtr(self: *Self, inst: Air.Inst.Index) !void {
2367	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4839	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
2368	const result = try self.resolveInst(un_op);	4840	const result = result: {
		4841	const src_mcv = try self.resolveInst(un_op);
		4842	if (self.reuseOperand(inst, un_op, 0, src_mcv)) break :result src_mcv;
		4843
		4844	const dst_mcv = try self.allocRegOrMem(inst, true);
		4845	const dst_ty = self.typeOfIndex(inst);
		4846	try self.genCopy(dst_ty, dst_mcv, src_mcv);
		4847	break :result dst_mcv;
		4848	};
2369	return self.finishAir(inst, result, .{ un_op, .none, .none });	4849	return self.finishAir(inst, result, .{ un_op, .none, .none });
2370	}	4850	}
2371		4851
2372	fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {	4852	fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
2373	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	4853	const zcu = self.bin_file.comp.module.?;
2374	const result = if (self.liveness.isUnused(inst)) .dead else result: {
2375	const operand = try self.resolveInst(ty_op.operand);
2376	if (self.reuseOperand(inst, ty_op.operand, 0, operand)) break :result operand;
2377		4854
2378	const operand_lock = switch (operand) {	4855	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
2379	.register => \|reg\| self.register_manager.lockReg(reg),	4856	const result = if (self.liveness.isUnused(inst)) .unreach else result: {
2380	else => null,	4857	const src_mcv = try self.resolveInst(ty_op.operand);
		4858
		4859	const dst_ty = self.typeOfIndex(inst);
		4860	const src_ty = self.typeOf(ty_op.operand);
		4861
		4862	const src_lock = if (src_mcv.getReg()) \|reg\| self.register_manager.lockReg(reg) else null;
		4863	defer if (src_lock) \|lock\| self.register_manager.unlockReg(lock);
		4864
		4865	const dst_mcv = if (dst_ty.abiSize(zcu) <= src_ty.abiSize(zcu) and
		4866	self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) src_mcv else dst: {
		4867	const dst_mcv = try self.allocRegOrMem(inst, true);
		4868	try self.genCopy(switch (math.order(dst_ty.abiSize(zcu), src_ty.abiSize(zcu))) {
		4869	.lt => dst_ty,
		4870	.eq => if (!dst_mcv.isMemory() or src_mcv.isMemory()) dst_ty else src_ty,
		4871	.gt => src_ty,
		4872	}, dst_mcv, src_mcv);
		4873	break :dst dst_mcv;
2381	};	4874	};
2382	defer if (operand_lock) \|lock\| self.register_manager.unlockReg(lock);
2383		4875
2384	const dest = try self.allocRegOrMem(inst, true);	4876	if (dst_ty.isAbiInt(zcu) and src_ty.isAbiInt(zcu) and
2385	try self.setRegOrMem(self.typeOfIndex(inst), dest, operand);	4877	dst_ty.intInfo(zcu).signedness == src_ty.intInfo(zcu).signedness) break :result dst_mcv;
2386	break :result dest;	4878
		4879	const abi_size = dst_ty.abiSize(zcu);
		4880	const bit_size = dst_ty.bitSize(zcu);
		4881	if (abi_size * 8 <= bit_size) break :result dst_mcv;
		4882
		4883	return self.fail("TODO: airBitCast {} to {}", .{ src_ty.fmt(zcu), dst_ty.fmt(zcu) });
2387	};	4884	};
2388	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	4885	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2389	}	4886	}
2390		4887
2391	fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {	4888	fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
2392	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	4889	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
2393	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airArrayToSlice for {}", .{	4890	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airArrayToSlice for {}", .{
2394	self.target.cpu.arch,	4891	self.target.cpu.arch,
2395	});	4892	});
2396	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	4893	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
...	@@ -2398,7 +4895,7 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2398,7 +4895,7 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
2398		4895
2399	fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {	4896	fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
2400	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	4897	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
2401	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFloatFromInt for {}", .{	4898	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airFloatFromInt for {}", .{
2402	self.target.cpu.arch,	4899	self.target.cpu.arch,
2403	});	4900	});
2404	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	4901	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
...	@@ -2406,7 +4903,7 @@ fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2406,7 +4903,7 @@ fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
2406		4903
2407	fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {	4904	fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
2408	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	4905	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
2409	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airIntFromFloat for {}", .{	4906	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airIntFromFloat for {}", .{
2410	self.target.cpu.arch,	4907	self.target.cpu.arch,
2411	});	4908	});
2412	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	4909	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
...	@@ -2456,7 +4953,7 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2456,7 +4953,7 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
2456	fn airTagName(self: *Self, inst: Air.Inst.Index) !void {	4953	fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
2457	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4954	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
2458	const operand = try self.resolveInst(un_op);	4955	const operand = try self.resolveInst(un_op);
2459	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {	4956	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else {
2460	_ = operand;	4957	_ = operand;
2461	return self.fail("TODO implement airTagName for riscv64", .{});	4958	return self.fail("TODO implement airTagName for riscv64", .{});
2462	};	4959	};
...	@@ -2464,49 +4961,98 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2464,49 +4961,98 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
2464	}	4961	}
2465		4962
2466	fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {	4963	fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
		4964	const zcu = self.bin_file.comp.module.?;
2467	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4965	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
2468	const operand = try self.resolveInst(un_op);	4966
2469	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {	4967	const err_ty = self.typeOf(un_op);
2470	_ = operand;	4968	const err_mcv = try self.resolveInst(un_op);
2471	return self.fail("TODO implement airErrorName for riscv64", .{});	4969
2472	};	4970	const err_reg = try self.copyToTmpRegister(err_ty, err_mcv);
2473	return self.finishAir(inst, result, .{ un_op, .none, .none });	4971	const err_lock = self.register_manager.lockRegAssumeUnused(err_reg);
		4972	defer self.register_manager.unlockReg(err_lock);
		4973
		4974	const addr_reg, const addr_lock = try self.allocReg();
		4975	defer self.register_manager.unlockReg(addr_lock);
		4976
		4977	const lazy_sym = link.File.LazySymbol.initDecl(.const_data, null, zcu);
		4978	if (self.bin_file.cast(link.File.Elf)) \|elf_file\| {
		4979	const sym_index = elf_file.zigObjectPtr().?.getOrCreateMetadataForLazySymbol(elf_file, lazy_sym) catch \|err\|
		4980	return self.fail("{s} creating lazy symbol", .{@errorName(err)});
		4981	const sym = elf_file.symbol(sym_index);
		4982	try self.genSetReg(Type.usize, addr_reg, .{ .load_symbol = .{ .sym = sym.esym_index } });
		4983	} else {
		4984	return self.fail("TODO: riscv non-elf", .{});
		4985	}
		4986
		4987	const start_reg, const start_lock = try self.allocReg();
		4988	defer self.register_manager.unlockReg(start_lock);
		4989
		4990	const end_reg, const end_lock = try self.allocReg();
		4991	defer self.register_manager.unlockReg(end_lock);
		4992
		4993	_ = start_reg;
		4994	_ = end_reg;
		4995
		4996	return self.fail("TODO: airErrorName", .{});
2474	}	4997	}
2475		4998
2476	fn airSplat(self: *Self, inst: Air.Inst.Index) !void {	4999	fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
2477	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	5000	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
2478	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSplat for riscv64", .{});	5001	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airSplat for riscv64", .{});
2479	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	5002	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2480	}	5003	}
2481		5004
2482	fn airSelect(self: *Self, inst: Air.Inst.Index) !void {	5005	fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
2483	const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;	5006	const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
2484	const extra = self.air.extraData(Air.Bin, pl_op.payload).data;	5007	const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
2485	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSelect for riscv64", .{});	5008	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airSelect for riscv64", .{});
2486	return self.finishAir(inst, result, .{ pl_op.operand, extra.lhs, extra.rhs });	5009	return self.finishAir(inst, result, .{ pl_op.operand, extra.lhs, extra.rhs });
2487	}	5010	}
2488		5011
2489	fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {	5012	fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
2490	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	5013	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
2491	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airShuffle for riscv64", .{});	5014	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airShuffle for riscv64", .{});
2492	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });	5015	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2493	}	5016	}
2494		5017
2495	fn airReduce(self: *Self, inst: Air.Inst.Index) !void {	5018	fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
2496	const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;	5019	const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
2497	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airReduce for riscv64", .{});	5020	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else return self.fail("TODO implement airReduce for riscv64", .{});
2498	return self.finishAir(inst, result, .{ reduce.operand, .none, .none });	5021	return self.finishAir(inst, result, .{ reduce.operand, .none, .none });
2499	}	5022	}
2500		5023
2501	fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {	5024	fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
2502	const mod = self.bin_file.comp.module.?;	5025	const zcu = self.bin_file.comp.module.?;
2503	const vector_ty = self.typeOfIndex(inst);	5026	const result_ty = self.typeOfIndex(inst);
2504	const len = vector_ty.vectorLen(mod);	5027	const len: usize = @intCast(result_ty.arrayLen(zcu));
2505	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	5028	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
2506	const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);	5029	const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
2507	const result: MCValue = res: {	5030	const result: MCValue = result: {
2508	if (self.liveness.isUnused(inst)) break :res MCValue.dead;	5031	switch (result_ty.zigTypeTag(zcu)) {
2509	return self.fail("TODO implement airAggregateInit for riscv64", .{});	5032	.Struct => {
		5033	const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(result_ty, zcu));
		5034
		5035	if (result_ty.containerLayout(zcu) == .@"packed") {} else for (elements, 0..) \|elem, elem_i\| {
		5036	if ((try result_ty.structFieldValueComptime(zcu, elem_i)) != null) continue;
		5037
		5038	const elem_ty = result_ty.structFieldType(elem_i, zcu);
		5039	const elem_off: i32 = @intCast(result_ty.structFieldOffset(elem_i, zcu));
		5040	const elem_mcv = try self.resolveInst(elem);
		5041
		5042	const elem_frame: FrameAddr = .{
		5043	.index = frame_index,
		5044	.off = elem_off,
		5045	};
		5046	try self.genSetStack(
		5047	elem_ty,
		5048	elem_frame,
		5049	elem_mcv,
		5050	);
		5051	}
		5052	},
		5053	else => return self.fail("TODO: airAggregateInit {}", .{result_ty.fmt(zcu)}),
		5054	}
		5055	break :result .{ .register = .zero };
2510	};	5056	};
2511		5057
2512	if (elements.len <= Liveness.bpi - 1) {	5058	if (elements.len <= Liveness.bpi - 1) {
...	@@ -2514,11 +5060,9 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2514,11 +5060,9 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
2514	@memcpy(buf[0..elements.len], elements);	5060	@memcpy(buf[0..elements.len], elements);
2515	return self.finishAir(inst, result, buf);	5061	return self.finishAir(inst, result, buf);
2516	}	5062	}
2517	var bt = try self.iterateBigTomb(inst, elements.len);	5063	var bt = self.liveness.iterateBigTomb(inst);
2518	for (elements) \|elem\| {	5064	for (elements) \|elem\| try self.feed(&bt, elem);
2519	bt.feed(elem);	5065	return self.finishAirResult(inst, result);
2520	}
2521	return bt.finishAir(result);
2522	}	5066	}
2523		5067
2524	fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {	5068	fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
...	@@ -2531,57 +5075,68 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2531,57 +5075,68 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
2531		5075
2532	fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {	5076	fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
2533	const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;	5077	const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
2534	return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none });	5078	// TODO: RISC-V does have prefetch instruction variants.
		5079	// see here: https://raw.githubusercontent.com/riscv/riscv-CMOs/master/specifications/cmobase-v1.0.1.pdf
		5080	return self.finishAir(inst, .unreach, .{ prefetch.ptr, .none, .none });
2535	}	5081	}
2536		5082
2537	fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {	5083	fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
2538	const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;	5084	const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
2539	const extra = self.air.extraData(Air.Bin, pl_op.payload).data;	5085	const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
2540	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {	5086	const result: MCValue = if (self.liveness.isUnused(inst)) .unreach else {
2541	return self.fail("TODO implement airMulAdd for riscv64", .{});	5087	return self.fail("TODO implement airMulAdd for riscv64", .{});
2542	};	5088	};
2543	return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, pl_op.operand });	5089	return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, pl_op.operand });
2544	}	5090	}
2545		5091
2546	fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {	5092	fn resolveInst(self: *Self, ref: Air.Inst.Ref) InnerError!MCValue {
2547	const mod = self.bin_file.comp.module.?;	5093	const zcu = self.bin_file.comp.module.?;
2548		5094
2549	// If the type has no codegen bits, no need to store it.	5095	// If the type has no codegen bits, no need to store it.
2550	const inst_ty = self.typeOf(inst);	5096	const inst_ty = self.typeOf(ref);
2551	if (!inst_ty.hasRuntimeBits(mod))	5097	if (!inst_ty.hasRuntimeBits(zcu))
2552	return MCValue{ .none = {} };	5098	return .none;
2553		5099
2554	const inst_index = inst.toIndex() orelse return self.genTypedValue((try self.air.value(inst, mod)).?);	5100	const mcv = if (ref.toIndex()) \|inst\| mcv: {
		5101	break :mcv self.inst_tracking.getPtr(inst).?.short;
		5102	} else mcv: {
		5103	const ip_index = ref.toInterned().?;
		5104	const gop = try self.const_tracking.getOrPut(self.gpa, ip_index);
		5105	if (!gop.found_existing) gop.value_ptr.* = InstTracking.init(
		5106	try self.genTypedValue(Value.fromInterned(ip_index)),
		5107	);
		5108	break :mcv gop.value_ptr.short;
		5109	};
2555		5110
2556	return self.getResolvedInstValue(inst_index);	5111	return mcv;
2557	}	5112	}
2558		5113
2559	fn getResolvedInstValue(self: *Self, inst: Air.Inst.Index) MCValue {	5114	fn getResolvedInstValue(self: Self, inst: Air.Inst.Index) InstTracking {
2560	// Treat each stack item as a "layer" on top of the previous one.	5115	const tracking = self.inst_tracking.getPtr(inst).?;
2561	var i: usize = self.branch_stack.items.len;	5116	return switch (tracking.short) {
2562	while (true) {	5117	.none, .unreach, .dead => unreachable,
2563	i -= 1;	5118	else => tracking,
2564	if (self.branch_stack.items[i].inst_table.get(inst)) \|mcv\| {	5119	};
2565	assert(mcv != .dead);
2566	return mcv;
2567	}
2568	}
2569	}	5120	}
2570		5121
2571	fn genTypedValue(self: *Self, val: Value) InnerError!MCValue {	5122	fn genTypedValue(self: *Self, val: Value) InnerError!MCValue {
2572	const mod = self.bin_file.comp.module.?;	5123	const zcu = self.bin_file.comp.module.?;
2573	const mcv: MCValue = switch (try codegen.genTypedValue(	5124	const result = try codegen.genTypedValue(
2574	self.bin_file,	5125	self.bin_file,
2575	self.src_loc,	5126	self.src_loc,
2576	val,	5127	val,
2577	mod.funcOwnerDeclIndex(self.func_index),	5128	zcu.funcOwnerDeclIndex(self.func_index),
2578	)) {	5129	);
		5130	const mcv: MCValue = switch (result) {
2579	.mcv => \|mcv\| switch (mcv) {	5131	.mcv => \|mcv\| switch (mcv) {
2580	.none => .none,	5132	.none => .none,
2581	.undef => .undef,	5133	.undef => .undef,
2582	.load_got, .load_symbol, .load_direct, .load_tlv => unreachable, // TODO	5134	.load_symbol => \|sym_index\| .{ .load_symbol = .{ .sym = sym_index } },
2583	.immediate => \|imm\| .{ .immediate = imm },	5135	.immediate => \|imm\| .{ .immediate = imm },
2584	.memory => \|addr\| .{ .memory = addr },	5136	.memory => \|addr\| .{ .memory = addr },
		5137	.load_got, .load_direct, .load_tlv => {
		5138	return self.fail("TODO: genTypedValue {s}", .{@tagName(mcv)});
		5139	},
2585	},	5140	},
2586	.fail => \|msg\| {	5141	.fail => \|msg\| {
2587	self.err_msg = msg;	5142	self.err_msg = msg;
...	@@ -2593,8 +5148,8 @@ fn genTypedValue(self: *Self, val: Value) InnerError!MCValue {	...	@@ -2593,8 +5148,8 @@ fn genTypedValue(self: *Self, val: Value) InnerError!MCValue {
2593		5148
2594	const CallMCValues = struct {	5149	const CallMCValues = struct {
2595	args: []MCValue,	5150	args: []MCValue,
2596	return_value: MCValue,	5151	return_value: InstTracking,
2597	stack_byte_count: u32,	5152	stack_byte_count: u31,
2598	stack_align: Alignment,	5153	stack_align: Alignment,
2599		5154
2600	fn deinit(self: CallMCValues, func: Self) void {	5155	fn deinit(self: CallMCValues, func: Self) void {
...	@@ -2604,94 +5159,134 @@ const CallMCValues = struct {	...	@@ -2604,94 +5159,134 @@ const CallMCValues = struct {
2604	};	5159	};
2605		5160
2606	/// Caller must call `CallMCValues.deinit`.	5161	/// Caller must call `CallMCValues.deinit`.
2607	fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {	5162	fn resolveCallingConventionValues(
2608	const mod = self.bin_file.comp.module.?;	5163	self: *Self,
2609	const ip = &mod.intern_pool;	5164	fn_info: InternPool.Key.FuncType,
2610	const fn_info = mod.typeToFunc(fn_ty).?;	5165	) !CallMCValues {
		5166	const zcu = self.bin_file.comp.module.?;
		5167	const ip = &zcu.intern_pool;
		5168
		5169	const param_types = try self.gpa.alloc(Type, fn_info.param_types.len);
		5170	defer self.gpa.free(param_types);
		5171
		5172	for (param_types[0..fn_info.param_types.len], fn_info.param_types.get(ip)) \|*dest, src\| {
		5173	dest.* = Type.fromInterned(src);
		5174	}
		5175
2611	const cc = fn_info.cc;	5176	const cc = fn_info.cc;
2612	var result: CallMCValues = .{	5177	var result: CallMCValues = .{
2613	.args = try self.gpa.alloc(MCValue, fn_info.param_types.len),	5178	.args = try self.gpa.alloc(MCValue, param_types.len),
2614	// These undefined values must be populated before returning from this function.	5179	// These undefined values must be populated before returning from this function.
2615	.return_value = undefined,	5180	.return_value = undefined,
2616	.stack_byte_count = undefined,	5181	.stack_byte_count = 0,
2617	.stack_align = undefined,	5182	.stack_align = undefined,
2618	};	5183	};
2619	errdefer self.gpa.free(result.args);	5184	errdefer self.gpa.free(result.args);
2620		5185
2621	const ret_ty = fn_ty.fnReturnType(mod);	5186	const ret_ty = Type.fromInterned(fn_info.return_type);
2622		5187
2623	switch (cc) {	5188	switch (cc) {
2624	.Naked => {	5189	.Naked => {
2625	assert(result.args.len == 0);	5190	assert(result.args.len == 0);
2626	result.return_value = .{ .unreach = {} };	5191	result.return_value = InstTracking.init(.unreach);
2627	result.stack_byte_count = 0;	5192	result.stack_align = .@"8";
2628	result.stack_align = .@"1";
2629	return result;
2630	},	5193	},
2631	.Unspecified, .C => {	5194	.C, .Unspecified => {
2632	// LP64D ABI	5195	if (result.args.len > 8) {
2633	//	5196	return self.fail("RISC-V calling convention does not support more than 8 arguments", .{});
2634	// TODO make this generic with other ABIs, in particular
2635	// with different hardware floating-point calling
2636	// conventions
2637	var next_register: usize = 0;
2638	var next_stack_offset: u32 = 0;
2639	// TODO: this is never assigned, which is a bug, but I don't know how this code works
2640	// well enough to try and fix it. I think `next_register += next_stack_offset` is
2641	// supposed to be `next_stack_offset += param_size` in every case where it appears.
2642	_ = &next_stack_offset;
2643
2644	const argument_registers = [_]Register{ .a0, .a1, .a2, .a3, .a4, .a5, .a6, .a7 };
2645
2646	for (fn_info.param_types.get(ip), result.args) \|ty, *result_arg\| {
2647	const param_size: u32 = @intCast(Type.fromInterned(ty).abiSize(mod));
2648	if (param_size <= 8) {
2649	if (next_register < argument_registers.len) {
2650	result_arg.* = .{ .register = argument_registers[next_register] };
2651	next_register += 1;
2652	} else {
2653	result_arg.* = .{ .stack_offset = next_stack_offset };
2654	next_register += next_stack_offset;
2655	}
2656	} else if (param_size <= 16) {
2657	if (next_register < argument_registers.len - 1) {
2658	return self.fail("TODO MCValues with 2 registers", .{});
2659	} else if (next_register < argument_registers.len) {
2660	return self.fail("TODO MCValues split register + stack", .{});
2661	} else {
2662	result_arg.* = .{ .stack_offset = next_stack_offset };
2663	next_register += next_stack_offset;
2664	}
2665	} else {
2666	result_arg.* = .{ .stack_offset = next_stack_offset };
2667	next_register += next_stack_offset;
2668	}
2669	}	5197	}
2670		5198
2671	result.stack_byte_count = next_stack_offset;	5199	var ret_int_reg_i: u32 = 0;
		5200	var param_int_reg_i: u32 = 0;
		5201
2672	result.stack_align = .@"16";	5202	result.stack_align = .@"16";
2673	},
2674	else => return self.fail("TODO implement function parameters for {} on riscv64", .{cc}),
2675	}
2676		5203
2677	if (ret_ty.zigTypeTag(mod) == .NoReturn) {	5204	// Return values
2678	result.return_value = .{ .unreach = {} };	5205	if (ret_ty.zigTypeTag(zcu) == .NoReturn) {
2679	} else if (!ret_ty.hasRuntimeBits(mod)) {	5206	result.return_value = InstTracking.init(.unreach);
2680	result.return_value = .{ .none = {} };	5207	} else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
2681	} else switch (cc) {	5208	result.return_value = InstTracking.init(.none);
2682	.Naked => unreachable,
2683	.Unspecified, .C => {
2684	const ret_ty_size: u32 = @intCast(ret_ty.abiSize(mod));
2685	if (ret_ty_size <= 8) {
2686	result.return_value = .{ .register = .a0 };
2687	} else if (ret_ty_size <= 16) {
2688	return self.fail("TODO support MCValue 2 registers", .{});
2689	} else {	5209	} else {
2690	return self.fail("TODO support return by reference", .{});	5210	var ret_tracking: [2]InstTracking = undefined;
		5211	var ret_tracking_i: usize = 0;
		5212
		5213	const classes = mem.sliceTo(&abi.classifySystem(ret_ty, zcu), .none);
		5214
		5215	for (classes) \|class\| switch (class) {
		5216	.integer => {
		5217	const ret_int_reg = abi.function_ret_regs[ret_int_reg_i];
		5218	ret_int_reg_i += 1;
		5219
		5220	ret_tracking[ret_tracking_i] = InstTracking.init(.{ .register = ret_int_reg });
		5221	ret_tracking_i += 1;
		5222	},
		5223	.memory => {
		5224	const ret_int_reg = abi.function_ret_regs[ret_int_reg_i];
		5225	ret_int_reg_i += 1;
		5226	const ret_indirect_reg = abi.function_arg_regs[param_int_reg_i];
		5227	param_int_reg_i += 1;
		5228
		5229	ret_tracking[ret_tracking_i] = .{
		5230	.short = .{ .indirect = .{ .reg = ret_int_reg } },
		5231	.long = .{ .indirect = .{ .reg = ret_indirect_reg } },
		5232	};
		5233	ret_tracking_i += 1;
		5234	},
		5235	else => return self.fail("TODO: C calling convention return class {}", .{class}),
		5236	};
		5237
		5238	result.return_value = switch (ret_tracking_i) {
		5239	else => return self.fail("ty {} took {} tracking return indices", .{ ret_ty.fmt(zcu), ret_tracking_i }),
		5240	1 => ret_tracking[0],
		5241	2 => InstTracking.init(.{ .register_pair = .{
		5242	ret_tracking[0].short.register, ret_tracking[1].short.register,
		5243	} }),
		5244	};
		5245	}
		5246
		5247	for (param_types, result.args) \|ty, *arg\| {
		5248	assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
		5249
		5250	var arg_mcv: [2]MCValue = undefined;
		5251	var arg_mcv_i: usize = 0;
		5252
		5253	const classes = mem.sliceTo(&abi.classifySystem(ty, zcu), .none);
		5254
		5255	for (classes) \|class\| switch (class) {
		5256	.integer => {
		5257	const param_int_regs = abi.function_arg_regs;
		5258	if (param_int_reg_i >= param_int_regs.len) break;
		5259
		5260	const param_int_reg = param_int_regs[param_int_reg_i];
		5261	param_int_reg_i += 1;
		5262
		5263	arg_mcv[arg_mcv_i] = .{ .register = param_int_reg };
		5264	arg_mcv_i += 1;
		5265	},
		5266	.memory => {
		5267	const param_int_regs = abi.function_arg_regs;
		5268	const param_int_reg = param_int_regs[param_int_reg_i];
		5269
		5270	arg_mcv[arg_mcv_i] = .{ .indirect = .{ .reg = param_int_reg } };
		5271	arg_mcv_i += 1;
		5272	},
		5273	else => return self.fail("TODO: C calling convention arg class {}", .{class}),
		5274	} else {
		5275	arg.* = switch (arg_mcv_i) {
		5276	else => return self.fail("ty {} took {} tracking arg indices", .{ ty.fmt(zcu), arg_mcv_i }),
		5277	1 => arg_mcv[0],
		5278	2 => .{ .register_pair = .{ arg_mcv[0].register, arg_mcv[1].register } },
		5279	};
		5280	continue;
		5281	}
		5282
		5283	return self.fail("TODO: pass args by stack", .{});
2691	}	5284	}
2692	},	5285	},
2693	else => return self.fail("TODO implement function return values for {}", .{cc}),	5286	else => return self.fail("TODO implement function parameters for {} on riscv64", .{cc}),
2694	}	5287	}
		5288
		5289	result.stack_byte_count = @intCast(result.stack_align.forward(result.stack_byte_count));
2695	return result;	5290	return result;
2696	}	5291	}
2697		5292
...	@@ -2727,11 +5322,37 @@ fn parseRegName(name: []const u8) ?Register {	...	@@ -2727,11 +5322,37 @@ fn parseRegName(name: []const u8) ?Register {
2727	}	5322	}
2728		5323
2729	fn typeOf(self: *Self, inst: Air.Inst.Ref) Type {	5324	fn typeOf(self: *Self, inst: Air.Inst.Ref) Type {
2730	const mod = self.bin_file.comp.module.?;	5325	const zcu = self.bin_file.comp.module.?;
2731	return self.air.typeOf(inst, &mod.intern_pool);	5326	return self.air.typeOf(inst, &zcu.intern_pool);
2732	}	5327	}
2733		5328
2734	fn typeOfIndex(self: *Self, inst: Air.Inst.Index) Type {	5329	fn typeOfIndex(self: *Self, inst: Air.Inst.Index) Type {
2735	const mod = self.bin_file.comp.module.?;	5330	const zcu = self.bin_file.comp.module.?;
2736	return self.air.typeOfIndex(inst, &mod.intern_pool);	5331	return self.air.typeOfIndex(inst, &zcu.intern_pool);
		5332	}
		5333
		5334	fn hasFeature(self: *Self, feature: Target.riscv.Feature) bool {
		5335	return Target.riscv.featureSetHas(self.target.cpu.features, feature);
		5336	}
		5337
		5338	pub fn errUnionPayloadOffset(payload_ty: Type, zcu: *Module) u64 {
		5339	if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
		5340	const payload_align = payload_ty.abiAlignment(zcu);
		5341	const error_align = Type.anyerror.abiAlignment(zcu);
		5342	if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
		5343	return 0;
		5344	} else {
		5345	return payload_align.forward(Type.anyerror.abiSize(zcu));
		5346	}
		5347	}
		5348
		5349	pub fn errUnionErrorOffset(payload_ty: Type, zcu: *Module) u64 {
		5350	if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
		5351	const payload_align = payload_ty.abiAlignment(zcu);
		5352	const error_align = Type.anyerror.abiAlignment(zcu);
		5353	if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
		5354	return error_align.forward(payload_ty.abiSize(zcu));
		5355	} else {
		5356	return 0;
		5357	}
2737	}	5358	}

src/arch/riscv64/Emit.zig+156-184

...	@@ -1,25 +1,7 @@	...	@@ -1,25 +1,7 @@
1	//! This file contains the functionality for lowering RISCV64 MIR into	1	//! This file contains the functionality for emitting RISC-V MIR as machine code
2	//! machine code
3		2
4	const Emit = @This();	3	lower: Lower,
5	const std = @import("std");
6	const math = std.math;
7	const Mir = @import("Mir.zig");
8	const bits = @import("bits.zig");
9	const link = @import("../../link.zig");
10	const Module = @import("../../Module.zig");
11	const ErrorMsg = Module.ErrorMsg;
12	const assert = std.debug.assert;
13	const Instruction = bits.Instruction;
14	const Register = bits.Register;
15	const DebugInfoOutput = @import("../../codegen.zig").DebugInfoOutput;
16
17	mir: Mir,
18	bin_file: *link.File,
19	debug_output: DebugInfoOutput,	4	debug_output: DebugInfoOutput,
20	target: *const std.Target,
21	err_msg: ?*ErrorMsg = null,
22	src_loc: Module.SrcLoc,
23	code: *std.ArrayList(u8),	5	code: *std.ArrayList(u8),
24		6
25	prev_di_line: u32,	7	prev_di_line: u32,
...	@@ -27,195 +9,185 @@ prev_di_column: u32,	...	@@ -27,195 +9,185 @@ prev_di_column: u32,
27	/// Relative to the beginning of `code`.	9	/// Relative to the beginning of `code`.
28	prev_di_pc: usize,	10	prev_di_pc: usize,
29		11
30	const InnerError = error{	12	code_offset_mapping: std.AutoHashMapUnmanaged(Mir.Inst.Index, usize) = .{},
31	OutOfMemory,	13	relocs: std.ArrayListUnmanaged(Reloc) = .{},
		14
		15	pub const Error = Lower.Error \|\| error{
32	EmitFail,	16	EmitFail,
33	};	17	};
34		18
35	pub fn emitMir(	19	pub fn emitMir(emit: *Emit) Error!void {
36	emit: *Emit,	20	log.debug("mir instruction len: {}", .{emit.lower.mir.instructions.len});
37	) InnerError!void {	21	for (0..emit.lower.mir.instructions.len) \|mir_i\| {
38	const mir_tags = emit.mir.instructions.items(.tag);	22	const mir_index: Mir.Inst.Index = @intCast(mir_i);
39		23	try emit.code_offset_mapping.putNoClobber(
40	// Emit machine code	24	emit.lower.allocator,
41	for (mir_tags, 0..) \|tag, index\| {	25	mir_index,
42	const inst = @as(u32, @intCast(index));	26	@intCast(emit.code.items.len),
43	switch (tag) {	27	);
44	.add => try emit.mirRType(inst),	28	const lowered = try emit.lower.lowerMir(mir_index);
45	.sub => try emit.mirRType(inst),	29	var lowered_relocs = lowered.relocs;
46		30	for (lowered.insts, 0..) \|lowered_inst, lowered_index\| {
47	.addi => try emit.mirIType(inst),	31	const start_offset: u32 = @intCast(emit.code.items.len);
48	.jalr => try emit.mirIType(inst),	32	try lowered_inst.encode(emit.code.writer());
49	.ld => try emit.mirIType(inst),	33
50	.sd => try emit.mirIType(inst),	34	while (lowered_relocs.len > 0 and
51		35	lowered_relocs[0].lowered_inst_index == lowered_index) : ({
52	.ebreak => try emit.mirSystem(inst),	36	lowered_relocs = lowered_relocs[1..];
53	.ecall => try emit.mirSystem(inst),	37	}) switch (lowered_relocs[0].target) {
54	.unimp => try emit.mirSystem(inst),	38	.inst => \|target\| try emit.relocs.append(emit.lower.allocator, .{
55		39	.source = start_offset,
56	.dbg_line => try emit.mirDbgLine(inst),	40	.target = target,
57		41	.offset = 0,
58	.dbg_prologue_end => try emit.mirDebugPrologueEnd(),	42	.enc = std.meta.activeTag(lowered_inst.encoding.data),
59	.dbg_epilogue_begin => try emit.mirDebugEpilogueBegin(),	43	}),
60		44	.load_symbol_reloc => \|symbol\| {
61	.mv => try emit.mirRR(inst),	45	if (emit.lower.bin_file.cast(link.File.Elf)) \|elf_file\| {
62		46	const atom_ptr = elf_file.symbol(symbol.atom_index).atom(elf_file).?;
63	.nop => try emit.mirNop(inst),	47	const sym_index = elf_file.zigObjectPtr().?.symbol(symbol.sym_index);
64	.ret => try emit.mirNop(inst),	48	const sym = elf_file.symbol(sym_index);
65		49
66	.lui => try emit.mirUType(inst),	50	var hi_r_type: u32 = @intFromEnum(std.elf.R_RISCV.HI20);
		51	var lo_r_type: u32 = @intFromEnum(std.elf.R_RISCV.LO12_I);
		52
		53	if (sym.flags.needs_zig_got) {
		54	_ = try sym.getOrCreateZigGotEntry(sym_index, elf_file);
		55
		56	hi_r_type = Elf.R_ZIG_GOT_HI20;
		57	lo_r_type = Elf.R_ZIG_GOT_LO12;
		58	}
		59
		60	try atom_ptr.addReloc(elf_file, .{
		61	.r_offset = start_offset,
		62	.r_info = (@as(u64, @intCast(symbol.sym_index)) << 32) \| hi_r_type,
		63	.r_addend = 0,
		64	});
		65
		66	try atom_ptr.addReloc(elf_file, .{
		67	.r_offset = start_offset + 4,
		68	.r_info = (@as(u64, @intCast(symbol.sym_index)) << 32) \| lo_r_type,
		69	.r_addend = 0,
		70	});
		71	} else return emit.fail("TODO: load_symbol_reloc non-ELF", .{});
		72	},
		73	};
		74	}
		75	std.debug.assert(lowered_relocs.len == 0);
		76
		77	if (lowered.insts.len == 0) {
		78	const mir_inst = emit.lower.mir.instructions.get(mir_index);
		79	switch (mir_inst.tag) {
		80	else => unreachable,
		81	.pseudo => switch (mir_inst.ops) {
		82	else => unreachable,
		83	.pseudo_dbg_prologue_end => {
		84	switch (emit.debug_output) {
		85	.dwarf => \|dw\| {
		86	try dw.setPrologueEnd();
		87	log.debug("mirDbgPrologueEnd (line={d}, col={d})", .{
		88	emit.prev_di_line, emit.prev_di_column,
		89	});
		90	try emit.dbgAdvancePCAndLine(emit.prev_di_line, emit.prev_di_column);
		91	},
		92	.plan9 => {},
		93	.none => {},
		94	}
		95	},
		96	.pseudo_dbg_line_column => try emit.dbgAdvancePCAndLine(
		97	mir_inst.data.pseudo_dbg_line_column.line,
		98	mir_inst.data.pseudo_dbg_line_column.column,
		99	),
		100	.pseudo_dbg_epilogue_begin => {
		101	switch (emit.debug_output) {
		102	.dwarf => \|dw\| {
		103	try dw.setEpilogueBegin();
		104	log.debug("mirDbgEpilogueBegin (line={d}, col={d})", .{
		105	emit.prev_di_line, emit.prev_di_column,
		106	});
		107	try emit.dbgAdvancePCAndLine(emit.prev_di_line, emit.prev_di_column);
		108	},
		109	.plan9 => {},
		110	.none => {},
		111	}
		112	},
		113	.pseudo_dead => {},
		114	},
		115	}
67	}	116	}
68	}	117	}
		118	try emit.fixupRelocs();
69	}	119	}
70		120
71	pub fn deinit(emit: *Emit) void {	121	pub fn deinit(emit: *Emit) void {
		122	emit.relocs.deinit(emit.lower.allocator);
		123	emit.code_offset_mapping.deinit(emit.lower.allocator);
72	emit.* = undefined;	124	emit.* = undefined;
73	}	125	}
74		126
75	fn writeInstruction(emit: *Emit, instruction: Instruction) !void {	127	const Reloc = struct {
76	const endian = emit.target.cpu.arch.endian();	128	/// Offset of the instruction.
77	std.mem.writeInt(u32, try emit.code.addManyAsArray(4), instruction.toU32(), endian);	129	source: usize,
78	}	130	/// Target of the relocation.
79		131	target: Mir.Inst.Index,
80	fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {	132	/// Offset of the relocation within the instruction.
81	@setCold(true);	133	offset: u32,
82	assert(emit.err_msg == null);	134	/// Encoding of the instruction, used to determine how to modify it.
83	const comp = emit.bin_file.comp;	135	enc: Encoding.InstEnc,
84	const gpa = comp.gpa;	136	};
85	emit.err_msg = try ErrorMsg.create(gpa, emit.src_loc, format, args);
86	return error.EmitFail;
87	}
88
89	fn dbgAdvancePCAndLine(self: *Emit, line: u32, column: u32) !void {
90	const delta_line = @as(i32, @intCast(line)) - @as(i32, @intCast(self.prev_di_line));
91	const delta_pc: usize = self.code.items.len - self.prev_di_pc;
92	switch (self.debug_output) {
93	.dwarf => \|dw\| {
94	try dw.advancePCAndLine(delta_line, delta_pc);
95	self.prev_di_line = line;
96	self.prev_di_column = column;
97	self.prev_di_pc = self.code.items.len;
98	},
99	.plan9 => \|dbg_out\| {
100	if (delta_pc <= 0) return; // only do this when the pc changes
101
102	// increasing the line number
103	try link.File.Plan9.changeLine(&dbg_out.dbg_line, delta_line);
104	// increasing the pc
105	const d_pc_p9 = @as(i64, @intCast(delta_pc)) - dbg_out.pc_quanta;
106	if (d_pc_p9 > 0) {
107	// minus one because if its the last one, we want to leave space to change the line which is one pc quanta
108	try dbg_out.dbg_line.append(@as(u8, @intCast(@divExact(d_pc_p9, dbg_out.pc_quanta) + 128)) - dbg_out.pc_quanta);
109	if (dbg_out.pcop_change_index) \|pci\|
110	dbg_out.dbg_line.items[pci] += 1;
111	dbg_out.pcop_change_index = @as(u32, @intCast(dbg_out.dbg_line.items.len - 1));
112	} else if (d_pc_p9 == 0) {
113	// we don't need to do anything, because adding the pc quanta does it for us
114	} else unreachable;
115	if (dbg_out.start_line == null)
116	dbg_out.start_line = self.prev_di_line;
117	dbg_out.end_line = line;
118	// only do this if the pc changed
119	self.prev_di_line = line;
120	self.prev_di_column = column;
121	self.prev_di_pc = self.code.items.len;
122	},
123	.none => {},
124	}
125	}
126
127	fn mirRType(emit: *Emit, inst: Mir.Inst.Index) !void {
128	const tag = emit.mir.instructions.items(.tag)[inst];
129	const r_type = emit.mir.instructions.items(.data)[inst].r_type;
130
131	switch (tag) {
132	.add => try emit.writeInstruction(Instruction.add(r_type.rd, r_type.rs1, r_type.rs2)),
133	.sub => try emit.writeInstruction(Instruction.sub(r_type.rd, r_type.rs1, r_type.rs2)),
134	else => unreachable,
135	}
136	}
137
138	fn mirIType(emit: *Emit, inst: Mir.Inst.Index) !void {
139	const tag = emit.mir.instructions.items(.tag)[inst];
140	const i_type = emit.mir.instructions.items(.data)[inst].i_type;
141
142	switch (tag) {
143	.addi => try emit.writeInstruction(Instruction.addi(i_type.rd, i_type.rs1, i_type.imm12)),
144	.jalr => try emit.writeInstruction(Instruction.jalr(i_type.rd, i_type.imm12, i_type.rs1)),
145	.ld => try emit.writeInstruction(Instruction.ld(i_type.rd, i_type.imm12, i_type.rs1)),
146	.sd => try emit.writeInstruction(Instruction.sd(i_type.rd, i_type.imm12, i_type.rs1)),
147	else => unreachable,
148	}
149	}
150		137
151	fn mirSystem(emit: *Emit, inst: Mir.Inst.Index) !void {	138	fn fixupRelocs(emit: *Emit) Error!void {
152	const tag = emit.mir.instructions.items(.tag)[inst];	139	for (emit.relocs.items) \|reloc\| {
		140	log.debug("target inst: {}", .{emit.lower.mir.instructions.get(reloc.target)});
		141	const target = emit.code_offset_mapping.get(reloc.target) orelse
		142	return emit.fail("relocation target not found!", .{});
153		143
154	switch (tag) {	144	const disp = @as(i32, @intCast(target)) - @as(i32, @intCast(reloc.source));
155	.ebreak => try emit.writeInstruction(Instruction.ebreak),	145	const code: *[4]u8 = emit.code.items[reloc.source + reloc.offset ..][0..4];
156	.ecall => try emit.writeInstruction(Instruction.ecall),
157	.unimp => try emit.writeInstruction(Instruction.unimp),
158	else => unreachable,
159	}
160	}
161		146
162	fn mirDbgLine(emit: *Emit, inst: Mir.Inst.Index) !void {	147	log.debug("disp: {x}", .{disp});
163	const tag = emit.mir.instructions.items(.tag)[inst];
164	const dbg_line_column = emit.mir.instructions.items(.data)[inst].dbg_line_column;
165		148
166	switch (tag) {	149	switch (reloc.enc) {
167	.dbg_line => try emit.dbgAdvancePCAndLine(dbg_line_column.line, dbg_line_column.column),	150	.J => riscv_util.writeInstJ(code, @bitCast(disp)),
168	else => unreachable,	151	.B => riscv_util.writeInstB(code, @bitCast(disp)),
169	}	152	else => return emit.fail("tried to reloc encoding type {s}", .{@tagName(reloc.enc)}),
170	}	153	}
171
172	fn mirDebugPrologueEnd(self: *Emit) !void {
173	switch (self.debug_output) {
174	.dwarf => \|dw\| {
175	try dw.setPrologueEnd();
176	try self.dbgAdvancePCAndLine(self.prev_di_line, self.prev_di_column);
177	},
178	.plan9 => {},
179	.none => {},
180	}	154	}
181	}	155	}
182		156
183	fn mirDebugEpilogueBegin(self: *Emit) !void {	157	fn dbgAdvancePCAndLine(emit: *Emit, line: u32, column: u32) Error!void {
184	switch (self.debug_output) {	158	const delta_line = @as(i33, line) - @as(i33, emit.prev_di_line);
		159	const delta_pc: usize = emit.code.items.len - emit.prev_di_pc;
		160	log.debug(" (advance pc={d} and line={d})", .{ delta_pc, delta_line });
		161	switch (emit.debug_output) {
185	.dwarf => \|dw\| {	162	.dwarf => \|dw\| {
186	try dw.setEpilogueBegin();	163	if (column != emit.prev_di_column) try dw.setColumn(column);
187	try self.dbgAdvancePCAndLine(self.prev_di_line, self.prev_di_column);	164	if (delta_line == 0) return; // TODO: fix these edge cases.
		165	try dw.advancePCAndLine(delta_line, delta_pc);
		166	emit.prev_di_line = line;
		167	emit.prev_di_column = column;
		168	emit.prev_di_pc = emit.code.items.len;
188	},	169	},
189	.plan9 => {},	170	.plan9 => {},
190	.none => {},	171	.none => {},
191	}	172	}
192	}	173	}
193		174
194	fn mirRR(emit: *Emit, inst: Mir.Inst.Index) !void {	175	fn fail(emit: *Emit, comptime format: []const u8, args: anytype) Error {
195	const tag = emit.mir.instructions.items(.tag)[inst];	176	return switch (emit.lower.fail(format, args)) {
196	const rr = emit.mir.instructions.items(.data)[inst].rr;	177	error.LowerFail => error.EmitFail,
197		178	else => \|e\| e,
198	switch (tag) {	179	};
199	.mv => try emit.writeInstruction(Instruction.addi(rr.rd, rr.rs, 0)),
200	else => unreachable,
201	}
202	}
203	fn mirUType(emit: *Emit, inst: Mir.Inst.Index) !void {
204	const tag = emit.mir.instructions.items(.tag)[inst];
205	const u_type = emit.mir.instructions.items(.data)[inst].u_type;
206
207	switch (tag) {
208	.lui => try emit.writeInstruction(Instruction.lui(u_type.rd, u_type.imm20)),
209	else => unreachable,
210	}
211	}	180	}
212		181
213	fn mirNop(emit: *Emit, inst: Mir.Inst.Index) !void {	182	const link = @import("../../link.zig");
214	const tag = emit.mir.instructions.items(.tag)[inst];	183	const log = std.log.scoped(.emit);
		184	const mem = std.mem;
		185	const std = @import("std");
215		186
216	switch (tag) {	187	const DebugInfoOutput = @import("../../codegen.zig").DebugInfoOutput;
217	.nop => try emit.writeInstruction(Instruction.addi(.zero, .zero, 0)),	188	const Emit = @This();
218	.ret => try emit.writeInstruction(Instruction.jalr(.zero, 0, .ra)),	189	const Lower = @import("Lower.zig");
219	else => unreachable,	190	const Mir = @import("Mir.zig");
220	}	191	const riscv_util = @import("../../link/riscv.zig");
221	}	192	const Encoding = @import("Encoding.zig");
		193	const Elf = @import("../../link/Elf.zig");

src/arch/riscv64/Encoding.zig created+403

...	@@ -0,0 +1,403 @@
1	mnemonic: Mnemonic,
2	data: Data,
3
4	pub const Mnemonic = enum {
5	// I Type
6	ld,
7	lw,
8	lwu,
9	lh,
10	lhu,
11	lb,
12	lbu,
13	sltiu,
14	xori,
15	andi,
16	slli,
17	srli,
18	srai,
19
20	addi,
21	jalr,
22
23	// U Type
24	lui,
25
26	// S Type
27	sd,
28	sw,
29	sh,
30	sb,
31
32	// J Type
33	jal,
34
35	// B Type
36	beq,
37
38	// R Type
39	add,
40	@"and",
41	sub,
42	slt,
43	mul,
44	sltu,
45	xor,
46
47	// System
48	ecall,
49	ebreak,
50	unimp,
51
52	pub fn encoding(mnem: Mnemonic) Enc {
53	return switch (mnem) {
54	// zig fmt: off
55	.add => .{ .opcode = 0b0110011, .funct3 = 0b000, .funct7 = 0b0000000 },
56	.sltu => .{ .opcode = 0b0110011, .funct3 = 0b011, .funct7 = 0b0000000 },
57	.@"and" => .{ .opcode = 0b0110011, .funct3 = 0b111, .funct7 = 0b0000000 },
58	.sub => .{ .opcode = 0b0110011, .funct3 = 0b000, .funct7 = 0b0100000 },
59
60	.ld => .{ .opcode = 0b0000011, .funct3 = 0b011, .funct7 = null },
61	.lw => .{ .opcode = 0b0000011, .funct3 = 0b010, .funct7 = null },
62	.lwu => .{ .opcode = 0b0000011, .funct3 = 0b110, .funct7 = null },
63	.lh => .{ .opcode = 0b0000011, .funct3 = 0b001, .funct7 = null },
64	.lhu => .{ .opcode = 0b0000011, .funct3 = 0b101, .funct7 = null },
65	.lb => .{ .opcode = 0b0000011, .funct3 = 0b000, .funct7 = null },
66	.lbu => .{ .opcode = 0b0000011, .funct3 = 0b100, .funct7 = null },
67
68	.sltiu => .{ .opcode = 0b0010011, .funct3 = 0b011, .funct7 = null },
69
70	.addi => .{ .opcode = 0b0010011, .funct3 = 0b000, .funct7 = null },
71	.andi => .{ .opcode = 0b0010011, .funct3 = 0b111, .funct7 = null },
72	.xori => .{ .opcode = 0b0010011, .funct3 = 0b100, .funct7 = null },
73	.jalr => .{ .opcode = 0b1100111, .funct3 = 0b000, .funct7 = null },
74	.slli => .{ .opcode = 0b0010011, .funct3 = 0b001, .funct7 = null },
75	.srli => .{ .opcode = 0b0010011, .funct3 = 0b101, .funct7 = null },
76	.srai => .{ .opcode = 0b0010011, .funct3 = 0b101, .funct7 = null, .offset = 1 << 10 },
77
78	.lui => .{ .opcode = 0b0110111, .funct3 = null, .funct7 = null },
79
80	.sd => .{ .opcode = 0b0100011, .funct3 = 0b011, .funct7 = null },
81	.sw => .{ .opcode = 0b0100011, .funct3 = 0b010, .funct7 = null },
82	.sh => .{ .opcode = 0b0100011, .funct3 = 0b001, .funct7 = null },
83	.sb => .{ .opcode = 0b0100011, .funct3 = 0b000, .funct7 = null },
84
85	.jal => .{ .opcode = 0b1101111, .funct3 = null, .funct7 = null },
86
87	.beq => .{ .opcode = 0b1100011, .funct3 = 0b000, .funct7 = null },
88
89	.slt => .{ .opcode = 0b0110011, .funct3 = 0b010, .funct7 = 0b0000000 },
90
91	.xor => .{ .opcode = 0b0110011, .funct3 = 0b100, .funct7 = 0b0000000 },
92
93	.mul => .{ .opcode = 0b0110011, .funct3 = 0b000, .funct7 = 0b0000001 },
94
95	.ecall => .{ .opcode = 0b1110011, .funct3 = 0b000, .funct7 = null },
96	.ebreak => .{ .opcode = 0b1110011, .funct3 = 0b000, .funct7 = null },
97	.unimp => .{ .opcode = 0b0000000, .funct3 = 0b000, .funct7 = null },
98	// zig fmt: on
99	};
100	}
101	};
102
103	pub const InstEnc = enum {
104	R,
105	I,
106	S,
107	B,
108	U,
109	J,
110
111	/// extras that have unusual op counts
112	system,
113
114	pub fn fromMnemonic(mnem: Mnemonic) InstEnc {
115	return switch (mnem) {
116	.addi,
117	.ld,
118	.lw,
119	.lwu,
120	.lh,
121	.lhu,
122	.lb,
123	.lbu,
124	.jalr,
125	.sltiu,
126	.xori,
127	.andi,
128	.slli,
129	.srli,
130	.srai,
131	=> .I,
132
133	.lui,
134	=> .U,
135
136	.sd,
137	.sw,
138	.sh,
139	.sb,
140	=> .S,
141
142	.jal,
143	=> .J,
144
145	.beq,
146	=> .B,
147
148	.slt,
149	.sltu,
150	.mul,
151	.xor,
152	.add,
153	.sub,
154	.@"and",
155	=> .R,
156
157	.ecall,
158	.ebreak,
159	.unimp,
160	=> .system,
161	};
162	}
163
164	pub fn opsList(enc: InstEnc) [3]std.meta.FieldEnum(Operand) {
165	return switch (enc) {
166	// zig fmt: off
167	.R => .{ .reg, .reg, .reg, },
168	.I => .{ .reg, .reg, .imm, },
169	.S => .{ .reg, .reg, .imm, },
170	.B => .{ .reg, .reg, .imm, },
171	.U => .{ .reg, .imm, .none, },
172	.J => .{ .reg, .imm, .none, },
173	.system => .{ .none, .none, .none, },
174	// zig fmt: on
175	};
176	}
177	};
178
179	pub const Data = union(InstEnc) {
180	R: packed struct {
181	opcode: u7,
182	rd: u5,
183	funct3: u3,
184	rs1: u5,
185	rs2: u5,
186	funct7: u7,
187	},
188	I: packed struct {
189	opcode: u7,
190	rd: u5,
191	funct3: u3,
192	rs1: u5,
193	imm0_11: u12,
194	},
195	S: packed struct {
196	opcode: u7,
197	imm0_4: u5,
198	funct3: u3,
199	rs1: u5,
200	rs2: u5,
201	imm5_11: u7,
202	},
203	B: packed struct {
204	opcode: u7,
205	imm11: u1,
206	imm1_4: u4,
207	funct3: u3,
208	rs1: u5,
209	rs2: u5,
210	imm5_10: u6,
211	imm12: u1,
212	},
213	U: packed struct {
214	opcode: u7,
215	rd: u5,
216	imm12_31: u20,
217	},
218	J: packed struct {
219	opcode: u7,
220	rd: u5,
221	imm12_19: u8,
222	imm11: u1,
223	imm1_10: u10,
224	imm20: u1,
225	},
226	system: void,
227
228	pub fn toU32(self: Data) u32 {
229	return switch (self) {
230	.R => \|v\| @as(u32, @bitCast(v)),
231	.I => \|v\| @as(u32, @bitCast(v)),
232	.S => \|v\| @as(u32, @bitCast(v)),
233	.B => \|v\| @as(u32, @intCast(v.opcode)) + (@as(u32, @intCast(v.imm11)) << 7) + (@as(u32, @intCast(v.imm1_4)) << 8) + (@as(u32, @intCast(v.funct3)) << 12) + (@as(u32, @intCast(v.rs1)) << 15) + (@as(u32, @intCast(v.rs2)) << 20) + (@as(u32, @intCast(v.imm5_10)) << 25) + (@as(u32, @intCast(v.imm12)) << 31),
234	.U => \|v\| @as(u32, @bitCast(v)),
235	.J => \|v\| @as(u32, @bitCast(v)),
236	.system => unreachable,
237	};
238	}
239
240	pub fn construct(mnem: Mnemonic, ops: []const Operand) !Data {
241	const inst_enc = InstEnc.fromMnemonic(mnem);
242
243	const enc = mnem.encoding();
244
245	// special mnemonics
246	switch (mnem) {
247	.ecall,
248	.ebreak,
249	.unimp,
250	=> {
251	assert(ops.len == 0);
252	return .{
253	.I = .{
254	.rd = Register.zero.id(),
255	.rs1 = Register.zero.id(),
256	.imm0_11 = switch (mnem) {
257	.ecall => 0x000,
258	.ebreak => 0x001,
259	.unimp => 0,
260	else => unreachable,
261	},
262
263	.opcode = enc.opcode,
264	.funct3 = enc.funct3.?,
265	},
266	};
267	},
268	else => {},
269	}
270
271	switch (inst_enc) {
272	.R => {
273	assert(ops.len == 3);
274	return .{
275	.R = .{
276	.rd = ops[0].reg.id(),
277	.rs1 = ops[1].reg.id(),
278	.rs2 = ops[2].reg.id(),
279
280	.opcode = enc.opcode,
281	.funct3 = enc.funct3.?,
282	.funct7 = enc.funct7.?,
283	},
284	};
285	},
286	.S => {
287	assert(ops.len == 3);
288	const umm = ops[2].imm.asBits(u12);
289
290	return .{
291	.S = .{
292	.imm0_4 = @truncate(umm),
293	.rs1 = ops[0].reg.id(),
294	.rs2 = ops[1].reg.id(),
295	.imm5_11 = @truncate(umm >> 5),
296
297	.opcode = enc.opcode,
298	.funct3 = enc.funct3.?,
299	},
300	};
301	},
302	.I => {
303	assert(ops.len == 3);
304	return .{
305	.I = .{
306	.rd = ops[0].reg.id(),
307	.rs1 = ops[1].reg.id(),
308	.imm0_11 = ops[2].imm.asBits(u12) + enc.offset,
309
310	.opcode = enc.opcode,
311	.funct3 = enc.funct3.?,
312	},
313	};
314	},
315	.U => {
316	assert(ops.len == 2);
317	return .{
318	.U = .{
319	.rd = ops[0].reg.id(),
320	.imm12_31 = ops[1].imm.asBits(u20),
321
322	.opcode = enc.opcode,
323	},
324	};
325	},
326	.J => {
327	assert(ops.len == 2);
328
329	const umm = ops[1].imm.asBits(u21);
330	assert(umm % 4 == 0); // misaligned jump target
331
332	return .{
333	.J = .{
334	.rd = ops[0].reg.id(),
335	.imm1_10 = @truncate(umm >> 1),
336	.imm11 = @truncate(umm >> 11),
337	.imm12_19 = @truncate(umm >> 12),
338	.imm20 = @truncate(umm >> 20),
339
340	.opcode = enc.opcode,
341	},
342	};
343	},
344	.B => {
345	assert(ops.len == 3);
346
347	const umm = ops[2].imm.asBits(u13);
348	assert(umm % 4 == 0); // misaligned branch target
349
350	return .{
351	.B = .{
352	.rs1 = ops[0].reg.id(),
353	.rs2 = ops[1].reg.id(),
354	.imm1_4 = @truncate(umm >> 1),
355	.imm5_10 = @truncate(umm >> 5),
356	.imm11 = @truncate(umm >> 11),
357	.imm12 = @truncate(umm >> 12),
358
359	.opcode = enc.opcode,
360	.funct3 = enc.funct3.?,
361	},
362	};
363	},
364
365	else => std.debug.panic("TODO: construct {s}", .{@tagName(inst_enc)}),
366	}
367	}
368	};
369
370	pub fn findByMnemonic(mnem: Mnemonic, ops: []const Operand) !?Encoding {
371	if (!verifyOps(mnem, ops)) return null;
372
373	return .{
374	.mnemonic = mnem,
375	.data = try Data.construct(mnem, ops),
376	};
377	}
378
379	const Enc = struct {
380	opcode: u7,
381	funct3: ?u3,
382	funct7: ?u7,
383	offset: u12 = 0,
384	};
385
386	fn verifyOps(mnem: Mnemonic, ops: []const Operand) bool {
387	const inst_enc = InstEnc.fromMnemonic(mnem);
388	const list = std.mem.sliceTo(&inst_enc.opsList(), .none);
389	for (list, ops) \|l, o\| if (l != std.meta.activeTag(o)) return false;
390	return true;
391	}
392
393	const std = @import("std");
394	const assert = std.debug.assert;
395	const log = std.log.scoped(.encoding);
396
397	const Encoding = @This();
398	const bits = @import("bits.zig");
399	const Register = bits.Register;
400	const encoder = @import("encoder.zig");
401	const Instruction = encoder.Instruction;
402	const Operand = Instruction.Operand;
403	const OperandEnum = std.meta.FieldEnum(Operand);

src/arch/riscv64/Lower.zig created+360

...	@@ -0,0 +1,360 @@
1	//! This file contains the functionality for lowering RISC-V MIR to Instructions
2
3	bin_file: *link.File,
4	output_mode: std.builtin.OutputMode,
5	link_mode: std.builtin.LinkMode,
6	pic: bool,
7	allocator: Allocator,
8	mir: Mir,
9	cc: std.builtin.CallingConvention,
10	err_msg: ?*ErrorMsg = null,
11	src_loc: Module.SrcLoc,
12	result_insts_len: u8 = undefined,
13	result_relocs_len: u8 = undefined,
14	result_insts: [
15	@max(
16	1, // non-pseudo instruction
17	abi.callee_preserved_regs.len, // spill / restore regs,
18	)
19	]Instruction = undefined,
20	result_relocs: [1]Reloc = undefined,
21
22	pub const Error = error{
23	OutOfMemory,
24	LowerFail,
25	InvalidInstruction,
26	};
27
28	pub const Reloc = struct {
29	lowered_inst_index: u8,
30	target: Target,
31
32	const Target = union(enum) {
33	inst: Mir.Inst.Index,
34
35	/// Relocs the lowered_inst_index and the next one.
36	load_symbol_reloc: bits.Symbol,
37	};
38	};
39
40	/// The returned slice is overwritten by the next call to lowerMir.
41	pub fn lowerMir(lower: *Lower, index: Mir.Inst.Index) Error!struct {
42	insts: []const Instruction,
43	relocs: []const Reloc,
44	} {
45	lower.result_insts = undefined;
46	lower.result_relocs = undefined;
47	errdefer lower.result_insts = undefined;
48	errdefer lower.result_relocs = undefined;
49	lower.result_insts_len = 0;
50	lower.result_relocs_len = 0;
51	defer lower.result_insts_len = undefined;
52	defer lower.result_relocs_len = undefined;
53
54	const inst = lower.mir.instructions.get(index);
55	log.debug("lowerMir {}", .{inst});
56	switch (inst.tag) {
57	else => try lower.generic(inst),
58	.pseudo => switch (inst.ops) {
59	.pseudo_dbg_line_column,
60	.pseudo_dbg_epilogue_begin,
61	.pseudo_dbg_prologue_end,
62	.pseudo_dead,
63	=> {},
64
65	.pseudo_load_rm, .pseudo_store_rm => {
66	const rm = inst.data.rm;
67
68	const frame_loc = rm.m.toFrameLoc(lower.mir);
69
70	switch (inst.ops) {
71	.pseudo_load_rm => {
72	const tag: Encoding.Mnemonic = switch (rm.m.mod.rm.size) {
73	.byte => .lb,
74	.hword => .lh,
75	.word => .lw,
76	.dword => .ld,
77	};
78
79	try lower.emit(tag, &.{
80	.{ .reg = rm.r },
81	.{ .reg = frame_loc.base },
82	.{ .imm = Immediate.s(frame_loc.disp) },
83	});
84	},
85	.pseudo_store_rm => {
86	const tag: Encoding.Mnemonic = switch (rm.m.mod.rm.size) {
87	.byte => .sb,
88	.hword => .sh,
89	.word => .sw,
90	.dword => .sd,
91	};
92
93	try lower.emit(tag, &.{
94	.{ .reg = frame_loc.base },
95	.{ .reg = rm.r },
96	.{ .imm = Immediate.s(frame_loc.disp) },
97	});
98	},
99	else => unreachable,
100	}
101	},
102
103	.pseudo_mv => {
104	const rr = inst.data.rr;
105
106	try lower.emit(.addi, &.{
107	.{ .reg = rr.rd },
108	.{ .reg = rr.rs },
109	.{ .imm = Immediate.s(0) },
110	});
111	},
112
113	.pseudo_ret => {
114	try lower.emit(.jalr, &.{
115	.{ .reg = .zero },
116	.{ .reg = .ra },
117	.{ .imm = Immediate.s(0) },
118	});
119	},
120
121	.pseudo_j => {
122	try lower.emit(.jal, &.{
123	.{ .reg = .zero },
124	.{ .imm = lower.reloc(.{ .inst = inst.data.inst }) },
125	});
126	},
127
128	.pseudo_spill_regs => try lower.pushPopRegList(true, inst.data.reg_list),
129	.pseudo_restore_regs => try lower.pushPopRegList(false, inst.data.reg_list),
130
131	.pseudo_load_symbol => {
132	const payload = inst.data.payload;
133	const data = lower.mir.extraData(Mir.LoadSymbolPayload, payload).data;
134
135	try lower.emit(.lui, &.{
136	.{ .reg = @enumFromInt(data.register) },
137	.{ .imm = lower.reloc(.{ .load_symbol_reloc = .{
138	.atom_index = data.atom_index,
139	.sym_index = data.sym_index,
140	} }) },
141	});
142
143	// the above reloc implies this one
144	try lower.emit(.addi, &.{
145	.{ .reg = @enumFromInt(data.register) },
146	.{ .reg = @enumFromInt(data.register) },
147	.{ .imm = Immediate.s(0) },
148	});
149	},
150
151	.pseudo_lea_rm => {
152	const rm = inst.data.rm;
153	const frame = rm.m.toFrameLoc(lower.mir);
154
155	try lower.emit(.addi, &.{
156	.{ .reg = rm.r },
157	.{ .reg = frame.base },
158	.{ .imm = Immediate.s(frame.disp) },
159	});
160	},
161
162	.pseudo_compare => {
163	const compare = inst.data.compare;
164	const op = compare.op;
165
166	const rd = compare.rd;
167	const rs1 = compare.rs1;
168	const rs2 = compare.rs2;
169
170	switch (op) {
171	.eq => {
172	try lower.emit(.xor, &.{
173	.{ .reg = rd },
174	.{ .reg = rs1 },
175	.{ .reg = rs2 },
176	});
177
178	try lower.emit(.sltiu, &.{
179	.{ .reg = rd },
180	.{ .reg = rd },
181	.{ .imm = Immediate.s(1) },
182	});
183	},
184	.neq => {
185	try lower.emit(.xor, &.{
186	.{ .reg = rd },
187	.{ .reg = rs1 },
188	.{ .reg = rs2 },
189	});
190
191	try lower.emit(.sltu, &.{
192	.{ .reg = rd },
193	.{ .reg = .zero },
194	.{ .reg = rd },
195	});
196	},
197	.gt => {
198	try lower.emit(.sltu, &.{
199	.{ .reg = rd },
200	.{ .reg = rs1 },
201	.{ .reg = rs2 },
202	});
203	},
204	.gte => {
205	try lower.emit(.sltu, &.{
206	.{ .reg = rd },
207	.{ .reg = rs1 },
208	.{ .reg = rs2 },
209	});
210
211	try lower.emit(.xori, &.{
212	.{ .reg = rd },
213	.{ .reg = rd },
214	.{ .imm = Immediate.s(1) },
215	});
216	},
217	.lt => {
218	try lower.emit(.slt, &.{
219	.{ .reg = rd },
220	.{ .reg = rs1 },
221	.{ .reg = rs2 },
222	});
223	},
224	.lte => {
225	try lower.emit(.slt, &.{
226	.{ .reg = rd },
227	.{ .reg = rs2 },
228	.{ .reg = rs1 },
229	});
230
231	try lower.emit(.xori, &.{
232	.{ .reg = rd },
233	.{ .reg = rd },
234	.{ .imm = Immediate.s(1) },
235	});
236	},
237	}
238	},
239
240	.pseudo_not => {
241	const rr = inst.data.rr;
242
243	try lower.emit(.xori, &.{
244	.{ .reg = rr.rd },
245	.{ .reg = rr.rs },
246	.{ .imm = Immediate.s(1) },
247	});
248	},
249
250	else => return lower.fail("TODO lower: psuedo {s}", .{@tagName(inst.ops)}),
251	},
252	}
253
254	return .{
255	.insts = lower.result_insts[0..lower.result_insts_len],
256	.relocs = lower.result_relocs[0..lower.result_relocs_len],
257	};
258	}
259
260	fn generic(lower: *Lower, inst: Mir.Inst) Error!void {
261	const mnemonic = std.meta.stringToEnum(Encoding.Mnemonic, @tagName(inst.tag)) orelse {
262	return lower.fail("generic inst name '{s}' with op {s} doesn't match with a mnemonic", .{
263	@tagName(inst.tag),
264	@tagName(inst.ops),
265	});
266	};
267	try lower.emit(mnemonic, switch (inst.ops) {
268	.none => &.{},
269	.ri => &.{
270	.{ .reg = inst.data.u_type.rd },
271	.{ .imm = inst.data.u_type.imm20 },
272	},
273	.rr => &.{
274	.{ .reg = inst.data.rr.rd },
275	.{ .reg = inst.data.rr.rs },
276	},
277	.rri => &.{
278	.{ .reg = inst.data.i_type.rd },
279	.{ .reg = inst.data.i_type.rs1 },
280	.{ .imm = inst.data.i_type.imm12 },
281	},
282	.rr_inst => &.{
283	.{ .reg = inst.data.b_type.rs1 },
284	.{ .reg = inst.data.b_type.rs2 },
285	.{ .imm = lower.reloc(.{ .inst = inst.data.b_type.inst }) },
286	},
287	.rrr => &.{
288	.{ .reg = inst.data.r_type.rd },
289	.{ .reg = inst.data.r_type.rs1 },
290	.{ .reg = inst.data.r_type.rs2 },
291	},
292	else => return lower.fail("TODO: generic lower ops {s}", .{@tagName(inst.ops)}),
293	});
294	}
295
296	fn emit(lower: *Lower, mnemonic: Encoding.Mnemonic, ops: []const Instruction.Operand) !void {
297	lower.result_insts[lower.result_insts_len] =
298	try Instruction.new(mnemonic, ops);
299	lower.result_insts_len += 1;
300	}
301
302	fn reloc(lower: *Lower, target: Reloc.Target) Immediate {
303	lower.result_relocs[lower.result_relocs_len] = .{
304	.lowered_inst_index = lower.result_insts_len,
305	.target = target,
306	};
307	lower.result_relocs_len += 1;
308	return Immediate.s(0);
309	}
310
311	fn pushPopRegList(lower: *Lower, comptime spilling: bool, reg_list: Mir.RegisterList) !void {
312	var it = reg_list.iterator(.{ .direction = .forward });
313
314	var reg_i: u31 = 0;
315	while (it.next()) \|i\| {
316	const frame = lower.mir.frame_locs.get(@intFromEnum(bits.FrameIndex.spill_frame));
317
318	if (spilling) {
319	try lower.emit(.sd, &.{
320	.{ .reg = frame.base },
321	.{ .reg = abi.callee_preserved_regs[i] },
322	.{ .imm = Immediate.s(frame.disp + reg_i) },
323	});
324	} else {
325	try lower.emit(.ld, &.{
326	.{ .reg = abi.callee_preserved_regs[i] },
327	.{ .reg = frame.base },
328	.{ .imm = Immediate.s(frame.disp + reg_i) },
329	});
330	}
331
332	reg_i += 8;
333	}
334	}
335
336	pub fn fail(lower: *Lower, comptime format: []const u8, args: anytype) Error {
337	@setCold(true);
338	assert(lower.err_msg == null);
339	lower.err_msg = try ErrorMsg.create(lower.allocator, lower.src_loc, format, args);
340	return error.LowerFail;
341	}
342
343	const Lower = @This();
344
345	const abi = @import("abi.zig");
346	const assert = std.debug.assert;
347	const bits = @import("bits.zig");
348	const encoder = @import("encoder.zig");
349	const link = @import("../../link.zig");
350	const Encoding = @import("Encoding.zig");
351	const std = @import("std");
352	const log = std.log.scoped(.lower);
353
354	const Air = @import("../../Air.zig");
355	const Allocator = std.mem.Allocator;
356	const ErrorMsg = Module.ErrorMsg;
357	const Mir = @import("Mir.zig");
358	const Module = @import("../../Module.zig");
359	const Instruction = encoder.Instruction;
360	const Immediate = bits.Immediate;

src/arch/riscv64/Mir.zig+307-56

...	@@ -6,50 +6,111 @@	...	@@ -6,50 +6,111 @@
6	//! The main purpose of MIR is to postpone the assignment of offsets until Isel,	6	//! The main purpose of MIR is to postpone the assignment of offsets until Isel,
7	//! so that, for example, the smaller encodings of jump instructions can be used.	7	//! so that, for example, the smaller encodings of jump instructions can be used.
8		8
9	const Mir = @This();
10	const std = @import("std");
11	const builtin = @import("builtin");
12	const assert = std.debug.assert;
13
14	const bits = @import("bits.zig");
15	const Register = bits.Register;
16
17	instructions: std.MultiArrayList(Inst).Slice,	9	instructions: std.MultiArrayList(Inst).Slice,
18	/// The meaning of this data is determined by `Inst.Tag` value.	10	/// The meaning of this data is determined by `Inst.Tag` value.
19	extra: []const u32,	11	extra: []const u32,
		12	frame_locs: std.MultiArrayList(FrameLoc).Slice,
20		13
21	pub const Inst = struct {	14	pub const Inst = struct {
22	tag: Tag,	15	tag: Tag,
23	/// The meaning of this depends on `tag`.
24	data: Data,	16	data: Data,
		17	ops: Ops,
		18
		19	/// The position of an MIR instruction within the `Mir` instructions array.
		20	pub const Index = u32;
25		21
26	pub const Tag = enum(u16) {	22	pub const Tag = enum(u16) {
27	add,	23	/// Add immediate. Uses i_type payload.
28	addi,	24	addi,
29	/// Pseudo-instruction: End of prologue	25
30	dbg_prologue_end,	26	/// Add immediate and produce a sign-extended result.
31	/// Pseudo-instruction: Beginning of epilogue	27	///
32	dbg_epilogue_begin,	28	/// Uses i-type payload.
33	/// Pseudo-instruction: Update debug line	29	addiw,
34	dbg_line,	30
35	unimp,
36	ebreak,
37	ecall,
38	jalr,	31	jalr,
39	ld,
40	lui,	32	lui,
41	mv,	33	mv,
		34
		35	@"and",
		36	xor,
		37
		38	ebreak,
		39	ecall,
		40	unimp,
		41
		42	/// OR instruction. Uses r_type payload.
		43	@"or",
		44
		45	/// Addition
		46	add,
		47	/// Subtraction
		48	sub,
		49	/// Multiply, uses r_type. Needs the M extension.
		50	mul,
		51
		52	/// Absolute Value, uses i_type payload.
		53	abs,
		54
		55	sltu,
		56	slt,
		57
		58	/// Immediate Logical Right Shift, uses i_type payload
		59	srli,
		60	/// Immediate Logical Left Shift, uses i_type payload
		61	slli,
		62	/// Immediate Arithmetic Right Shift, uses i_type payload.
		63	srai,
		64	/// Register Logical Left Shift, uses r_type payload
		65	sllw,
		66	/// Register Logical Right Shit, uses r_type payload
		67	srlw,
		68
		69	/// Jumps, but stores the address of the instruction following the
		70	/// jump in `rd`.
		71	///
		72	/// Uses j_type payload.
		73	jal,
		74
		75	/// Immediate AND, uses i_type payload
		76	andi,
		77
		78	/// Branch if equal, Uses b_type
		79	beq,
		80	/// Branch if not equal, Uses b_type
		81	bne,
		82
		83	/// Boolean NOT, Uses rr payload
		84	not,
		85
		86	/// Generates a NO-OP, uses nop payload
42	nop,	87	nop,
43	ret,	88
		89	/// Load double (64 bits), uses i_type payload
		90	ld,
		91	/// Load word (32 bits), uses i_type payload
		92	lw,
		93	/// Load half (16 bits), uses i_type payload
		94	lh,
		95	/// Load byte (8 bits), uses i_type payload
		96	lb,
		97
		98	/// Store double (64 bits), uses s_type payload
44	sd,	99	sd,
45	sub,	100	/// Store word (32 bits), uses s_type payload
46	};	101	sw,
		102	/// Store half (16 bits), uses s_type payload
		103	sh,
		104	/// Store byte (8 bits), uses s_type payload
		105	sb,
47		106
48	/// The position of an MIR instruction within the `Mir` instructions array.	107	/// A pseudo-instruction. Used for anything that isn't 1:1 with an
49	pub const Index = u32;	108	/// assembly instruction.
		109	pseudo,
		110	};
50		111
51	/// All instructions have a 4-byte payload, which is contained within	112	/// All instructions have a 4-byte payload, which is contained within
52	/// this union. `Tag` determines which union field is active, as well as	113	/// this union. `Ops` determines which union field is active, as well as
53	/// how to interpret the data within.	114	/// how to interpret the data within.
54	pub const Data = union {	115	pub const Data = union {
55	/// No additional data	116	/// No additional data
...	@@ -60,72 +121,206 @@ pub const Inst = struct {	...	@@ -60,72 +121,206 @@ pub const Inst = struct {
60	///	121	///
61	/// Used by e.g. b	122	/// Used by e.g. b
62	inst: Index,	123	inst: Index,
63	/// A 16-bit immediate value.
64	///
65	/// Used by e.g. svc
66	imm16: u16,
67	/// Index into `extra`. Meaning of what can be found there is context-dependent.	124	/// Index into `extra`. Meaning of what can be found there is context-dependent.
68	///	125	///
69	/// Used by e.g. load_memory	126	/// Used by e.g. load_memory
70	payload: u32,	127	payload: u32,
71	/// A register	128
72	///	129	r_type: struct {
73	/// Used by e.g. blr
74	reg: Register,
75	/// Two registers
76	///
77	/// Used by e.g. mv
78	rr: struct {
79	rd: Register,	130	rd: Register,
80	rs: Register,	131	rs1: Register,
		132	rs2: Register,
81	},	133	},
82	/// I-Type	134
83	///
84	/// Used by e.g. jalr
85	i_type: struct {	135	i_type: struct {
86	rd: Register,	136	rd: Register,
87	rs1: Register,	137	rs1: Register,
88	imm12: i12,	138	imm12: Immediate,
89	},	139	},
90	/// R-Type	140
91	///	141	s_type: struct {
92	/// Used by e.g. add
93	r_type: struct {
94	rd: Register,
95	rs1: Register,	142	rs1: Register,
96	rs2: Register,	143	rs2: Register,
		144	imm5: Immediate,
		145	imm7: Immediate,
97	},	146	},
98	/// U-Type	147
99	///	148	b_type: struct {
100	/// Used by e.g. lui	149	rs1: Register,
		150	rs2: Register,
		151	inst: Inst.Index,
		152	},
		153
101	u_type: struct {	154	u_type: struct {
102	rd: Register,	155	rd: Register,
103	imm20: i20,	156	imm20: Immediate,
		157	},
		158
		159	j_type: struct {
		160	rd: Register,
		161	inst: Inst.Index,
104	},	162	},
		163
105	/// Debug info: line and column	164	/// Debug info: line and column
106	///	165	///
107	/// Used by e.g. dbg_line	166	/// Used by e.g. pseudo_dbg_line
108	dbg_line_column: struct {	167	pseudo_dbg_line_column: struct {
109	line: u32,	168	line: u32,
110	column: u32,	169	column: u32,
111	},	170	},
		171
		172	// Custom types to be lowered
		173
		174	/// Register + Memory
		175	rm: struct {
		176	r: Register,
		177	m: Memory,
		178	},
		179
		180	reg_list: Mir.RegisterList,
		181
		182	/// A register
		183	///
		184	/// Used by e.g. blr
		185	reg: Register,
		186
		187	/// Two registers
		188	///
		189	/// Used by e.g. mv
		190	rr: struct {
		191	rd: Register,
		192	rs: Register,
		193	},
		194
		195	compare: struct {
		196	rd: Register,
		197	rs1: Register,
		198	rs2: Register,
		199	op: enum {
		200	eq,
		201	neq,
		202	gt,
		203	gte,
		204	lt,
		205	lte,
		206	},
		207	},
		208	};
		209
		210	pub const Ops = enum {
		211	/// No data associated with this instruction (only mnemonic is used).
		212	none,
		213	/// Two registers
		214	rr,
		215	/// Three registers
		216	rrr,
		217
		218	/// Two registers + immediate, uses the i_type payload.
		219	rri,
		220	/// Two registers + Two Immediates
		221	rrii,
		222
		223	/// Two registers + another instruction.
		224	rr_inst,
		225
		226	/// Register + Memory
		227	rm,
		228
		229	/// Register + Immediate
		230	ri,
		231
		232	/// Another instruction.
		233	inst,
		234
		235	/// Pseudo-instruction that will generate a backpatched
		236	/// function prologue.
		237	pseudo_prologue,
		238	/// Pseudo-instruction that will generate a backpatched
		239	/// function epilogue
		240	pseudo_epilogue,
		241
		242	/// Pseudo-instruction: End of prologue
		243	pseudo_dbg_prologue_end,
		244	/// Pseudo-instruction: Beginning of epilogue
		245	pseudo_dbg_epilogue_begin,
		246	/// Pseudo-instruction: Update debug line
		247	pseudo_dbg_line_column,
		248
		249	/// Pseudo-instruction that loads from memory into a register.
		250	///
		251	/// Uses `rm` payload.
		252	pseudo_load_rm,
		253	/// Pseudo-instruction that stores from a register into memory
		254	///
		255	/// Uses `rm` payload.
		256	pseudo_store_rm,
		257
		258	/// Pseudo-instruction that loads the address of memory into a register.
		259	///
		260	/// Uses `rm` payload.
		261	pseudo_lea_rm,
		262
		263	/// Shorthand for returning, aka jumping to ra register.
		264	///
		265	/// Uses nop payload.
		266	pseudo_ret,
		267
		268	/// Jumps. Uses `inst` payload.
		269	pseudo_j,
		270
		271	/// Dead inst, ignored by the emitter.
		272	pseudo_dead,
		273
		274	/// Loads the address of a value that hasn't yet been allocated in memory.
		275	///
		276	/// uses the Mir.LoadSymbolPayload payload.
		277	pseudo_load_symbol,
		278
		279	/// Moves the value of rs1 to rd.
		280	///
		281	/// uses the `rr` payload.
		282	pseudo_mv,
		283
		284	pseudo_restore_regs,
		285	pseudo_spill_regs,
		286
		287	pseudo_compare,
		288	pseudo_not,
112	};	289	};
113		290
114	// Make sure we don't accidentally make instructions bigger than expected.	291	// Make sure we don't accidentally make instructions bigger than expected.
115	// Note that in safety builds, Zig is allowed to insert a secret field for safety checks.	292	// Note that in Debug builds, Zig is allowed to insert a secret field for safety checks.
116	// comptime {	293	// comptime {
117	// if (!std.debug.runtime_safety) {	294	// if (builtin.mode != .Debug) {
118	// assert(@sizeOf(Inst) == 8);	295	// assert(@sizeOf(Inst) == 8);
119	// }	296	// }
120	// }	297	// }
		298
		299	pub fn format(
		300	inst: Inst,
		301	comptime fmt: []const u8,
		302	options: std.fmt.FormatOptions,
		303	writer: anytype,
		304	) !void {
		305	assert(fmt.len == 0);
		306	_ = options;
		307
		308	try writer.print("Tag: {s}, Ops: {s}", .{ @tagName(inst.tag), @tagName(inst.ops) });
		309	}
121	};	310	};
122		311
123	pub fn deinit(mir: *Mir, gpa: std.mem.Allocator) void {	312	pub fn deinit(mir: *Mir, gpa: std.mem.Allocator) void {
124	mir.instructions.deinit(gpa);	313	mir.instructions.deinit(gpa);
		314	mir.frame_locs.deinit(gpa);
125	gpa.free(mir.extra);	315	gpa.free(mir.extra);
126	mir.* = undefined;	316	mir.* = undefined;
127	}	317	}
128		318
		319	pub const FrameLoc = struct {
		320	base: Register,
		321	disp: i32,
		322	};
		323
129	/// Returns the requested data, as well as the new index which is at the start of the	324	/// Returns the requested data, as well as the new index which is at the start of the
130	/// trailers for the object.	325	/// trailers for the object.
131	pub fn extraData(mir: Mir, comptime T: type, index: usize) struct { data: T, end: usize } {	326	pub fn extraData(mir: Mir, comptime T: type, index: usize) struct { data: T, end: usize } {
...	@@ -145,3 +340,59 @@ pub fn extraData(mir: Mir, comptime T: type, index: usize) struct { data: T, end	...	@@ -145,3 +340,59 @@ pub fn extraData(mir: Mir, comptime T: type, index: usize) struct { data: T, end
145	.end = i,	340	.end = i,
146	};	341	};
147	}	342	}
		343
		344	pub const LoadSymbolPayload = struct {
		345	register: u32,
		346	atom_index: u32,
		347	sym_index: u32,
		348	};
		349
		350	/// Used in conjunction with payload to transfer a list of used registers in a compact manner.
		351	pub const RegisterList = struct {
		352	bitset: BitSet = BitSet.initEmpty(),
		353
		354	const BitSet = IntegerBitSet(32);
		355	const Self = @This();
		356
		357	fn getIndexForReg(registers: []const Register, reg: Register) BitSet.MaskInt {
		358	for (registers, 0..) \|cpreg, i\| {
		359	if (reg.id() == cpreg.id()) return @intCast(i);
		360	}
		361	unreachable; // register not in input register list!
		362	}
		363
		364	pub fn push(self: *Self, registers: []const Register, reg: Register) void {
		365	const index = getIndexForReg(registers, reg);
		366	self.bitset.set(index);
		367	}
		368
		369	pub fn isSet(self: Self, registers: []const Register, reg: Register) bool {
		370	const index = getIndexForReg(registers, reg);
		371	return self.bitset.isSet(index);
		372	}
		373
		374	pub fn iterator(self: Self, comptime options: std.bit_set.IteratorOptions) BitSet.Iterator(options) {
		375	return self.bitset.iterator(options);
		376	}
		377
		378	pub fn count(self: Self) i32 {
		379	return @intCast(self.bitset.count());
		380	}
		381
		382	pub fn size(self: Self) i32 {
		383	return @intCast(self.bitset.count() * 8);
		384	}
		385	};
		386
		387	const Mir = @This();
		388	const std = @import("std");
		389	const builtin = @import("builtin");
		390	const assert = std.debug.assert;
		391
		392	const bits = @import("bits.zig");
		393	const Register = bits.Register;
		394	const Immediate = bits.Immediate;
		395	const Memory = bits.Memory;
		396	const FrameIndex = bits.FrameIndex;
		397	const FrameAddr = @import("CodeGen.zig").FrameAddr;
		398	const IntegerBitSet = std.bit_set.IntegerBitSet;

src/arch/riscv64/abi.zig+182-3

...	@@ -3,9 +3,11 @@ const bits = @import("bits.zig");	...	@@ -3,9 +3,11 @@ const bits = @import("bits.zig");
3	const Register = bits.Register;	3	const Register = bits.Register;
4	const RegisterManagerFn = @import("../../register_manager.zig").RegisterManager;	4	const RegisterManagerFn = @import("../../register_manager.zig").RegisterManager;
5	const Type = @import("../../type.zig").Type;	5	const Type = @import("../../type.zig").Type;
		6	const InternPool = @import("../../InternPool.zig");
6	const Module = @import("../../Module.zig");	7	const Module = @import("../../Module.zig");
		8	const assert = std.debug.assert;
7		9
8	pub const Class = enum { memory, byval, integer, double_integer, fields };	10	pub const Class = enum { memory, byval, integer, double_integer, fields, none };
9		11
10	pub fn classifyType(ty: Type, mod: *Module) Class {	12	pub fn classifyType(ty: Type, mod: *Module) Class {
11	const target = mod.getTarget();	13	const target = mod.getTarget();
...	@@ -91,11 +93,161 @@ pub fn classifyType(ty: Type, mod: *Module) Class {	...	@@ -91,11 +93,161 @@ pub fn classifyType(ty: Type, mod: *Module) Class {
91	}	93	}
92	}	94	}
93		95
		96	/// There are a maximum of 8 possible return slots. Returned values are in
		97	/// the beginning of the array; unused slots are filled with .none.
		98	pub fn classifySystem(ty: Type, zcu: *Module) [8]Class {
		99	var result = [1]Class{.none} ** 8;
		100	const memory_class = [_]Class{
		101	.memory, .none, .none, .none,
		102	.none, .none, .none, .none,
		103	};
		104	switch (ty.zigTypeTag(zcu)) {
		105	.Bool, .Void, .NoReturn => {
		106	result[0] = .integer;
		107	return result;
		108	},
		109	.Pointer => switch (ty.ptrSize(zcu)) {
		110	.Slice => {
		111	result[0] = .integer;
		112	result[1] = .integer;
		113	return result;
		114	},
		115	else => {
		116	result[0] = .integer;
		117	return result;
		118	},
		119	},
		120	.Optional => {
		121	if (ty.isPtrLikeOptional(zcu)) {
		122	result[0] = .integer;
		123	return result;
		124	}
		125	result[0] = .integer;
		126	result[1] = .integer;
		127	return result;
		128	},
		129	.Int, .Enum, .ErrorSet => {
		130	const int_bits = ty.intInfo(zcu).bits;
		131	if (int_bits <= 64) {
		132	result[0] = .integer;
		133	return result;
		134	}
		135	if (int_bits <= 128) {
		136	result[0] = .integer;
		137	result[1] = .integer;
		138	return result;
		139	}
		140	unreachable; // support > 128 bit int arguments
		141	},
		142	.ErrorUnion => {
		143	const payload_ty = ty.errorUnionPayload(zcu);
		144	const payload_bits = payload_ty.bitSize(zcu);
		145
		146	// the error union itself
		147	result[0] = .integer;
		148
		149	// anyerror!void can fit into one register
		150	if (payload_bits == 0) return result;
		151
		152	if (payload_bits <= 64) {
		153	result[1] = .integer;
		154	return result;
		155	}
		156
		157	std.debug.panic("TODO: classifySystem ErrorUnion > 64 bit payload", .{});
		158	},
		159	.Struct => {
		160	const layout = ty.containerLayout(zcu);
		161	const ty_size = ty.abiSize(zcu);
		162
		163	if (layout == .@"packed") {
		164	assert(ty_size <= 16);
		165	result[0] = .integer;
		166	if (ty_size > 8) result[1] = .integer;
		167	return result;
		168	}
		169
		170	return memory_class;
		171	},
		172	else => \|bad_ty\| std.debug.panic("classifySystem {s}", .{@tagName(bad_ty)}),
		173	}
		174	}
		175
		176	fn classifyStruct(
		177	result: *[8]Class,
		178	byte_offset: *u64,
		179	loaded_struct: InternPool.LoadedStructType,
		180	zcu: *Module,
		181	) void {
		182	const ip = &zcu.intern_pool;
		183	var field_it = loaded_struct.iterateRuntimeOrder(ip);
		184
		185	while (field_it.next()) \|field_index\| {
		186	const field_ty = Type.fromInterned(loaded_struct.field_types.get(ip)[field_index]);
		187	const field_align = loaded_struct.fieldAlign(ip, field_index);
		188	byte_offset.* = std.mem.alignForward(
		189	u64,
		190	byte_offset.*,
		191	field_align.toByteUnits() orelse field_ty.abiAlignment(zcu).toByteUnits().?,
		192	);
		193	if (zcu.typeToStruct(field_ty)) \|field_loaded_struct\| {
		194	if (field_loaded_struct.layout != .@"packed") {
		195	classifyStruct(result, byte_offset, field_loaded_struct, zcu);
		196	continue;
		197	}
		198	}
		199	const field_class = std.mem.sliceTo(&classifySystem(field_ty, zcu), .none);
		200	const field_size = field_ty.abiSize(zcu);
		201
		202	combine: {
		203	const result_class = &result[@intCast(byte_offset.* / 8)];
		204	if (result_class.* == field_class[0]) {
		205	break :combine;
		206	}
		207
		208	if (result_class.* == .none) {
		209	result_class.* = field_class[0];
		210	break :combine;
		211	}
		212	assert(field_class[0] != .none);
		213
		214	// "If one of the classes is MEMORY, the result is the MEMORY class."
		215	if (result_class.* == .memory or field_class[0] == .memory) {
		216	result_class.* = .memory;
		217	break :combine;
		218	}
		219
		220	// "If one of the classes is INTEGER, the result is the INTEGER."
		221	if (result_class.* == .integer or field_class[0] == .integer) {
		222	result_class.* = .integer;
		223	break :combine;
		224	}
		225
		226	result_class.* = .integer;
		227	}
		228	@memcpy(result[@intCast(byte_offset.* / 8 + 1)..][0 .. field_class.len - 1], field_class[1..]);
		229	byte_offset.* += field_size;
		230	}
		231	}
		232
94	pub const callee_preserved_regs = [_]Register{	233	pub const callee_preserved_regs = [_]Register{
95	.s0, .s1, .s2, .s3, .s4, .s5, .s6, .s7, .s8, .s9, .s10, .s11,	234	// .s0 is ommited to be used as a frame pointer
		235	.s1, .s2, .s3, .s4, .s5, .s6, .s7, .s8, .s9, .s10, .s11,
		236	};
		237
		238	pub const function_arg_regs = [_]Register{
		239	.a0, .a1, .a2, .a3, .a4, .a5, .a6, .a7,
		240	};
		241
		242	pub const function_ret_regs = [_]Register{
		243	.a0, .a1,
		244	};
		245
		246	pub const temporary_regs = [_]Register{
		247	.t0, .t1, .t2, .t3, .t4, .t5, .t6,
96	};	248	};
97		249
98	const allocatable_registers = callee_preserved_regs;	250	const allocatable_registers = callee_preserved_regs ++ function_arg_regs ++ temporary_regs;
99	pub const RegisterManager = RegisterManagerFn(@import("CodeGen.zig"), Register, &allocatable_registers);	251	pub const RegisterManager = RegisterManagerFn(@import("CodeGen.zig"), Register, &allocatable_registers);
100		252
101	// Register classes	253	// Register classes
...	@@ -109,4 +261,31 @@ pub const RegisterClass = struct {	...	@@ -109,4 +261,31 @@ pub const RegisterClass = struct {
109	}, true);	261	}, true);
110	break :blk set;	262	break :blk set;
111	};	263	};
		264
		265	pub const fa: RegisterBitSet = blk: {
		266	var set = RegisterBitSet.initEmpty();
		267	set.setRangeValue(.{
		268	.start = callee_preserved_regs.len,
		269	.end = callee_preserved_regs.len + function_arg_regs.len,
		270	}, true);
		271	break :blk set;
		272	};
		273
		274	pub const fr: RegisterBitSet = blk: {
		275	var set = RegisterBitSet.initEmpty();
		276	set.setRangeValue(.{
		277	.start = callee_preserved_regs.len,
		278	.end = callee_preserved_regs.len + function_ret_regs.len,
		279	}, true);
		280	break :blk set;
		281	};
		282
		283	pub const tp: RegisterBitSet = blk: {
		284	var set = RegisterBitSet.initEmpty();
		285	set.setRangeValue(.{
		286	.start = callee_preserved_regs.len + function_arg_regs.len,
		287	.end = callee_preserved_regs.len + function_arg_regs.len + temporary_regs.len,
		288	}, true);
		289	break :blk set;
		290	};
112	};	291	};

src/arch/riscv64/bits.zig+170-393

...	@@ -2,385 +2,149 @@ const std = @import("std");	...	@@ -2,385 +2,149 @@ const std = @import("std");
2	const DW = std.dwarf;	2	const DW = std.dwarf;
3	const assert = std.debug.assert;	3	const assert = std.debug.assert;
4	const testing = std.testing;	4	const testing = std.testing;
		5	const Encoding = @import("Encoding.zig");
		6	const Mir = @import("Mir.zig");
5		7
6	// TODO: this is only tagged to facilitate the monstrosity.	8	pub const Memory = struct {
7	// Once packed structs work make it packed.	9	base: Base,
8	pub const Instruction = union(enum) {	10	mod: Mod,
9	R: packed struct {
10	opcode: u7,
11	rd: u5,
12	funct3: u3,
13	rs1: u5,
14	rs2: u5,
15	funct7: u7,
16	},
17	I: packed struct {
18	opcode: u7,
19	rd: u5,
20	funct3: u3,
21	rs1: u5,
22	imm0_11: u12,
23	},
24	S: packed struct {
25	opcode: u7,
26	imm0_4: u5,
27	funct3: u3,
28	rs1: u5,
29	rs2: u5,
30	imm5_11: u7,
31	},
32	B: packed struct {
33	opcode: u7,
34	imm11: u1,
35	imm1_4: u4,
36	funct3: u3,
37	rs1: u5,
38	rs2: u5,
39	imm5_10: u6,
40	imm12: u1,
41	},
42	U: packed struct {
43	opcode: u7,
44	rd: u5,
45	imm12_31: u20,
46	},
47	J: packed struct {
48	opcode: u7,
49	rd: u5,
50	imm12_19: u8,
51	imm11: u1,
52	imm1_10: u10,
53	imm20: u1,
54	},
55		11
56	// TODO: once packed structs work we can remove this monstrosity.	12	pub const Base = union(enum) {
57	pub fn toU32(self: Instruction) u32 {	13	reg: Register,
58	return switch (self) {	14	frame: FrameIndex,
59	.R => \|v\| @as(u32, @bitCast(v)),	15	reloc: Symbol,
60	.I => \|v\| @as(u32, @bitCast(v)),	16	};
61	.S => \|v\| @as(u32, @bitCast(v)),
62	.B => \|v\| @as(u32, @intCast(v.opcode)) + (@as(u32, @intCast(v.imm11)) << 7) + (@as(u32, @intCast(v.imm1_4)) << 8) + (@as(u32, @intCast(v.funct3)) << 12) + (@as(u32, @intCast(v.rs1)) << 15) + (@as(u32, @intCast(v.rs2)) << 20) + (@as(u32, @intCast(v.imm5_10)) << 25) + (@as(u32, @intCast(v.imm12)) << 31),
63	.U => \|v\| @as(u32, @bitCast(v)),
64	.J => \|v\| @as(u32, @bitCast(v)),
65	};
66	}
67		17
68	fn rType(op: u7, fn3: u3, fn7: u7, rd: Register, r1: Register, r2: Register) Instruction {	18	pub const Mod = union(enum(u1)) {
69	return Instruction{	19	rm: struct {
70	.R = .{	20	size: Size,
71	.opcode = op,	21	disp: i32 = 0,
72	.funct3 = fn3,	22	},
73	.funct7 = fn7,	23	off: i32,
74	.rd = rd.id(),	24	};
75	.rs1 = r1.id(),
76	.rs2 = r2.id(),
77	},
78	};
79	}
80		25
81	// RISC-V is all signed all the time -- convert immediates to unsigned for processing	26	pub const Size = enum(u4) {
82	fn iType(op: u7, fn3: u3, rd: Register, r1: Register, imm: i12) Instruction {	27	/// Byte, 1 byte
83	const umm = @as(u12, @bitCast(imm));	28	byte,
		29	/// Half word, 2 bytes
		30	hword,
		31	/// Word, 4 bytes
		32	word,
		33	/// Double word, 8 Bytes
		34	dword,
		35
		36	pub fn fromByteSize(size: u64) Size {
		37	return switch (size) {
		38	1 => .byte,
		39	2 => .hword,
		40	4 => .word,
		41	8 => .dword,
		42	else => unreachable,
		43	};
		44	}
		45
		46	pub fn fromBitSize(bit_size: u64) Size {
		47	return switch (bit_size) {
		48	8 => .byte,
		49	16 => .hword,
		50	32 => .word,
		51	64 => .dword,
		52	else => unreachable,
		53	};
		54	}
		55
		56	pub fn bitSize(s: Size) u64 {
		57	return switch (s) {
		58	.byte => 8,
		59	.hword => 16,
		60	.word => 32,
		61	.dword => 64,
		62	};
		63	}
		64	};
84		65
85	return Instruction{	66	/// Asserts `mem` can be represented as a `FrameLoc`.
86	.I = .{	67	pub fn toFrameLoc(mem: Memory, mir: Mir) Mir.FrameLoc {
87	.opcode = op,	68	const offset: i32 = switch (mem.mod) {
88	.funct3 = fn3,	69	.off => \|off\| off,
89	.rd = rd.id(),	70	.rm => \|rm\| rm.disp,
90	.rs1 = r1.id(),
91	.imm0_11 = umm,
92	},
93	};	71	};
94	}
95
96	fn sType(op: u7, fn3: u3, r1: Register, r2: Register, imm: i12) Instruction {
97	const umm = @as(u12, @bitCast(imm));
98		72
99	return Instruction{	73	switch (mem.base) {
100	.S = .{	74	.reg => \|reg\| {
101	.opcode = op,	75	return .{
102	.funct3 = fn3,	76	.base = reg,
103	.rs1 = r1.id(),	77	.disp = offset,
104	.rs2 = r2.id(),	78	};
105	.imm0_4 = @as(u5, @truncate(umm)),
106	.imm5_11 = @as(u7, @truncate(umm >> 5)),
107	},	79	},
108	};	80	.frame => \|index\| {
		81	const base_loc = mir.frame_locs.get(@intFromEnum(index));
		82	return .{
		83	.base = base_loc.base,
		84	.disp = base_loc.disp + offset,
		85	};
		86	},
		87	.reloc => unreachable,
		88	}
109	}	89	}
		90	};
110		91
111	// Use significance value rather than bit value, same for J-type	92	pub const Immediate = union(enum) {
112	// -- less burden on callsite, bonus semantic checking	93	signed: i32,
113	fn bType(op: u7, fn3: u3, r1: Register, r2: Register, imm: i13) Instruction {	94	unsigned: u32,
114	const umm = @as(u13, @bitCast(imm));
115	assert(umm % 2 == 0); // misaligned branch target
116		95
117	return Instruction{	96	pub fn u(x: u64) Immediate {
118	.B = .{	97	return .{ .unsigned = x };
119	.opcode = op,
120	.funct3 = fn3,
121	.rs1 = r1.id(),
122	.rs2 = r2.id(),
123	.imm1_4 = @as(u4, @truncate(umm >> 1)),
124	.imm5_10 = @as(u6, @truncate(umm >> 5)),
125	.imm11 = @as(u1, @truncate(umm >> 11)),
126	.imm12 = @as(u1, @truncate(umm >> 12)),
127	},
128	};
129	}	98	}
130		99
131	// We have to extract the 20 bits anyway -- let's not make it more painful	100	pub fn s(x: i32) Immediate {
132	fn uType(op: u7, rd: Register, imm: i20) Instruction {	101	return .{ .signed = x };
133	const umm = @as(u20, @bitCast(imm));	102	}
134		103
135	return Instruction{	104	pub fn asSigned(imm: Immediate, bit_size: u64) i64 {
136	.U = .{	105	return switch (imm) {
137	.opcode = op,	106	.signed => \|x\| switch (bit_size) {
138	.rd = rd.id(),	107	1, 8 => @as(i8, @intCast(x)),
139	.imm12_31 = umm,	108	16 => @as(i16, @intCast(x)),
		109	32, 64 => x,
		110	else => unreachable,
		111	},
		112	.unsigned => \|x\| switch (bit_size) {
		113	1, 8 => @as(i8, @bitCast(@as(u8, @intCast(x)))),
		114	16 => @as(i16, @bitCast(@as(u16, @intCast(x)))),
		115	32 => @as(i32, @bitCast(@as(u32, @intCast(x)))),
		116	64 => @bitCast(x),
		117	else => unreachable,
140	},	118	},
141	};	119	};
142	}	120	}
143		121
144	fn jType(op: u7, rd: Register, imm: i21) Instruction {	122	pub fn asUnsigned(imm: Immediate, bit_size: u64) u64 {
145	const umm = @as(u21, @bitCast(imm));	123	return switch (imm) {
146	assert(umm % 2 == 0); // misaligned jump target	124	.signed => \|x\| switch (bit_size) {
147		125	1, 8 => @as(u8, @bitCast(@as(i8, @intCast(x)))),
148	return Instruction{	126	16 => @as(u16, @bitCast(@as(i16, @intCast(x)))),
149	.J = .{	127	32, 64 => @as(u32, @bitCast(x)),
150	.opcode = op,	128	else => unreachable,
151	.rd = rd.id(),	129	},
152	.imm1_10 = @as(u10, @truncate(umm >> 1)),	130	.unsigned => \|x\| switch (bit_size) {
153	.imm11 = @as(u1, @truncate(umm >> 11)),	131	1, 8 => @as(u8, @intCast(x)),
154	.imm12_19 = @as(u8, @truncate(umm >> 12)),	132	16 => @as(u16, @intCast(x)),
155	.imm20 = @as(u1, @truncate(umm >> 20)),	133	32 => @as(u32, @intCast(x)),
		134	64 => x,
		135	else => unreachable,
156	},	136	},
157	};	137	};
158	}	138	}
159		139
160	// The meat and potatoes. Arguments are in the order in which they would appear in assembly code.	140	pub fn asBits(imm: Immediate, comptime T: type) T {
161		141	const int_info = @typeInfo(T).Int;
162	// Arithmetic/Logical, Register-Register	142	if (int_info.signedness != .unsigned) @compileError("Immediate.asBits needs unsigned T");
163		143	return switch (imm) {
164	pub fn add(rd: Register, r1: Register, r2: Register) Instruction {	144	.signed => \|x\| @bitCast(@as(std.meta.Int(.signed, int_info.bits), @intCast(x))),
165	return rType(0b0110011, 0b000, 0b0000000, rd, r1, r2);	145	.unsigned => \|x\| @intCast(x),
166	}	146	};
167
168	pub fn sub(rd: Register, r1: Register, r2: Register) Instruction {
169	return rType(0b0110011, 0b000, 0b0100000, rd, r1, r2);
170	}
171
172	pub fn @"and"(rd: Register, r1: Register, r2: Register) Instruction {
173	return rType(0b0110011, 0b111, 0b0000000, rd, r1, r2);
174	}
175
176	pub fn @"or"(rd: Register, r1: Register, r2: Register) Instruction {
177	return rType(0b0110011, 0b110, 0b0000000, rd, r1, r2);
178	}
179
180	pub fn xor(rd: Register, r1: Register, r2: Register) Instruction {
181	return rType(0b0110011, 0b100, 0b0000000, rd, r1, r2);
182	}
183
184	pub fn sll(rd: Register, r1: Register, r2: Register) Instruction {
185	return rType(0b0110011, 0b001, 0b0000000, rd, r1, r2);
186	}
187
188	pub fn srl(rd: Register, r1: Register, r2: Register) Instruction {
189	return rType(0b0110011, 0b101, 0b0000000, rd, r1, r2);
190	}
191
192	pub fn sra(rd: Register, r1: Register, r2: Register) Instruction {
193	return rType(0b0110011, 0b101, 0b0100000, rd, r1, r2);
194	}
195
196	pub fn slt(rd: Register, r1: Register, r2: Register) Instruction {
197	return rType(0b0110011, 0b010, 0b0000000, rd, r1, r2);
198	}
199
200	pub fn sltu(rd: Register, r1: Register, r2: Register) Instruction {
201	return rType(0b0110011, 0b011, 0b0000000, rd, r1, r2);
202	}
203
204	// Arithmetic/Logical, Register-Register (32-bit)
205
206	pub fn addw(rd: Register, r1: Register, r2: Register) Instruction {
207	return rType(0b0111011, 0b000, rd, r1, r2);
208	}
209
210	pub fn subw(rd: Register, r1: Register, r2: Register) Instruction {
211	return rType(0b0111011, 0b000, 0b0100000, rd, r1, r2);
212	}
213
214	pub fn sllw(rd: Register, r1: Register, r2: Register) Instruction {
215	return rType(0b0111011, 0b001, 0b0000000, rd, r1, r2);
216	}
217
218	pub fn srlw(rd: Register, r1: Register, r2: Register) Instruction {
219	return rType(0b0111011, 0b101, 0b0000000, rd, r1, r2);
220	}
221
222	pub fn sraw(rd: Register, r1: Register, r2: Register) Instruction {
223	return rType(0b0111011, 0b101, 0b0100000, rd, r1, r2);
224	}
225
226	// Arithmetic/Logical, Register-Immediate
227
228	pub fn addi(rd: Register, r1: Register, imm: i12) Instruction {
229	return iType(0b0010011, 0b000, rd, r1, imm);
230	}
231
232	pub fn andi(rd: Register, r1: Register, imm: i12) Instruction {
233	return iType(0b0010011, 0b111, rd, r1, imm);
234	}
235
236	pub fn ori(rd: Register, r1: Register, imm: i12) Instruction {
237	return iType(0b0010011, 0b110, rd, r1, imm);
238	}
239
240	pub fn xori(rd: Register, r1: Register, imm: i12) Instruction {
241	return iType(0b0010011, 0b100, rd, r1, imm);
242	}
243
244	pub fn slli(rd: Register, r1: Register, shamt: u6) Instruction {
245	return iType(0b0010011, 0b001, rd, r1, shamt);
246	}
247
248	pub fn srli(rd: Register, r1: Register, shamt: u6) Instruction {
249	return iType(0b0010011, 0b101, rd, r1, shamt);
250	}
251
252	pub fn srai(rd: Register, r1: Register, shamt: u6) Instruction {
253	return iType(0b0010011, 0b101, rd, r1, (1 << 10) + shamt);
254	}
255
256	pub fn slti(rd: Register, r1: Register, imm: i12) Instruction {
257	return iType(0b0010011, 0b010, rd, r1, imm);
258	}
259
260	pub fn sltiu(rd: Register, r1: Register, imm: u12) Instruction {
261	return iType(0b0010011, 0b011, rd, r1, @as(i12, @bitCast(imm)));
262	}
263
264	// Arithmetic/Logical, Register-Immediate (32-bit)
265
266	pub fn addiw(rd: Register, r1: Register, imm: i12) Instruction {
267	return iType(0b0011011, 0b000, rd, r1, imm);
268	}
269
270	pub fn slliw(rd: Register, r1: Register, shamt: u5) Instruction {
271	return iType(0b0011011, 0b001, rd, r1, shamt);
272	}
273
274	pub fn srliw(rd: Register, r1: Register, shamt: u5) Instruction {
275	return iType(0b0011011, 0b101, rd, r1, shamt);
276	}
277
278	pub fn sraiw(rd: Register, r1: Register, shamt: u5) Instruction {
279	return iType(0b0011011, 0b101, rd, r1, (1 << 10) + shamt);
280	}
281
282	// Upper Immediate
283
284	pub fn lui(rd: Register, imm: i20) Instruction {
285	return uType(0b0110111, rd, imm);
286	}
287
288	pub fn auipc(rd: Register, imm: i20) Instruction {
289	return uType(0b0010111, rd, imm);
290	}
291
292	// Load
293
294	pub fn ld(rd: Register, offset: i12, base: Register) Instruction {
295	return iType(0b0000011, 0b011, rd, base, offset);
296	}
297
298	pub fn lw(rd: Register, offset: i12, base: Register) Instruction {
299	return iType(0b0000011, 0b010, rd, base, offset);
300	}
301
302	pub fn lwu(rd: Register, offset: i12, base: Register) Instruction {
303	return iType(0b0000011, 0b110, rd, base, offset);
304	}
305
306	pub fn lh(rd: Register, offset: i12, base: Register) Instruction {
307	return iType(0b0000011, 0b001, rd, base, offset);
308	}
309
310	pub fn lhu(rd: Register, offset: i12, base: Register) Instruction {
311	return iType(0b0000011, 0b101, rd, base, offset);
312	}
313
314	pub fn lb(rd: Register, offset: i12, base: Register) Instruction {
315	return iType(0b0000011, 0b000, rd, base, offset);
316	}
317
318	pub fn lbu(rd: Register, offset: i12, base: Register) Instruction {
319	return iType(0b0000011, 0b100, rd, base, offset);
320	}
321
322	// Store
323
324	pub fn sd(rs: Register, offset: i12, base: Register) Instruction {
325	return sType(0b0100011, 0b011, base, rs, offset);
326	}
327
328	pub fn sw(rs: Register, offset: i12, base: Register) Instruction {
329	return sType(0b0100011, 0b010, base, rs, offset);
330	}
331
332	pub fn sh(rs: Register, offset: i12, base: Register) Instruction {
333	return sType(0b0100011, 0b001, base, rs, offset);
334	}
335
336	pub fn sb(rs: Register, offset: i12, base: Register) Instruction {
337	return sType(0b0100011, 0b000, base, rs, offset);
338	}
339
340	// Fence
341	// TODO: implement fence
342
343	// Branch
344
345	pub fn beq(r1: Register, r2: Register, offset: i13) Instruction {
346	return bType(0b1100011, 0b000, r1, r2, offset);
347	}
348
349	pub fn bne(r1: Register, r2: Register, offset: i13) Instruction {
350	return bType(0b1100011, 0b001, r1, r2, offset);
351	}
352
353	pub fn blt(r1: Register, r2: Register, offset: i13) Instruction {
354	return bType(0b1100011, 0b100, r1, r2, offset);
355	}
356
357	pub fn bge(r1: Register, r2: Register, offset: i13) Instruction {
358	return bType(0b1100011, 0b101, r1, r2, offset);
359	}
360
361	pub fn bltu(r1: Register, r2: Register, offset: i13) Instruction {
362	return bType(0b1100011, 0b110, r1, r2, offset);
363	}
364
365	pub fn bgeu(r1: Register, r2: Register, offset: i13) Instruction {
366	return bType(0b1100011, 0b111, r1, r2, offset);
367	}
368
369	// Jump
370
371	pub fn jal(link: Register, offset: i21) Instruction {
372	return jType(0b1101111, link, offset);
373	}
374
375	pub fn jalr(link: Register, offset: i12, base: Register) Instruction {
376	return iType(0b1100111, 0b000, link, base, offset);
377	}	147	}
378
379	// System
380
381	pub const ecall = iType(0b1110011, 0b000, .zero, .zero, 0x000);
382	pub const ebreak = iType(0b1110011, 0b000, .zero, .zero, 0x001);
383	pub const unimp = iType(0, 0, .zero, .zero, 0);
384	};	148	};
385		149
386	pub const Register = enum(u6) {	150	pub const Register = enum(u6) {
...	@@ -404,50 +168,63 @@ pub const Register = enum(u6) {	...	@@ -404,50 +168,63 @@ pub const Register = enum(u6) {
404	t3, t4, t5, t6, // caller saved	168	t3, t4, t5, t6, // caller saved
405	// zig fmt: on	169	// zig fmt: on
406		170
407	/// Returns the unique 4-bit ID of this register which is used in	171	/// Returns the unique 5-bit ID of this register which is used in
408	/// the machine code	172	/// the machine code
409	pub fn id(self: Register) u5 {	173	pub fn id(self: Register) u5 {
410	return @as(u5, @truncate(@intFromEnum(self)));	174	return @as(u5, @truncate(@intFromEnum(self)));
411	}	175	}
412		176
413	pub fn dwarfLocOp(reg: Register) u8 {	177	pub fn dwarfLocOp(reg: Register) u8 {
414	return @as(u8, reg.id()) + DW.OP.reg0;	178	return @as(u8, reg.id());
415	}	179	}
416	};	180	};
417		181
418	// zig fmt: on	182	pub const FrameIndex = enum(u32) {
419		183	/// This index refers to the return address.
420	test "serialize instructions" {	184	ret_addr,
421	const Testcase = struct {	185	/// This index refers to the frame pointer.
422	inst: Instruction,	186	base_ptr,
423	expected: u32,	187	/// This index refers to the entire stack frame.
424	};	188	stack_frame,
425		189	/// This index referes to where in the stack frame the args are spilled to.
426	const testcases = [_]Testcase{	190	args_frame,
427	.{ // add t6, zero, zero	191	/// This index referes to a frame dedicated to setting up args for function called
428	.inst = Instruction.add(.t6, .zero, .zero),	192	/// in this function. Useful for aligning args separately.
429	.expected = 0b0000000_00000_00000_000_11111_0110011,	193	call_frame,
430	},	194	/// This index referes to the frame where callee saved registers are spilled and restore
431	.{ // sd s0, 0x7f(s0)	195	/// from.
432	.inst = Instruction.sd(.s0, 0x7f, .s0),	196	spill_frame,
433	.expected = 0b0000011_01000_01000_011_11111_0100011,	197	/// Other indices are used for local variable stack slots
434	},	198	_,
435	.{ // bne s0, s1, 0x42	199
436	.inst = Instruction.bne(.s0, .s1, 0x42),	200	pub const named_count = @typeInfo(FrameIndex).Enum.fields.len;
437	.expected = 0b0_000010_01001_01000_001_0001_0_1100011,	201
438	},	202	pub fn isNamed(fi: FrameIndex) bool {
439	.{ // j 0x1a	203	return @intFromEnum(fi) < named_count;
440	.inst = Instruction.jal(.zero, 0x1a),	204	}
441	.expected = 0b0_0000001101_0_00000000_00000_1101111,	205
442	},	206	pub fn format(
443	.{ // ebreak	207	fi: FrameIndex,
444	.inst = Instruction.ebreak,	208	comptime fmt: []const u8,
445	.expected = 0b000000000001_00000_000_00000_1110011,	209	options: std.fmt.FormatOptions,
446	},	210	writer: anytype,
447	};	211	) @TypeOf(writer).Error!void {
448		212	try writer.writeAll("FrameIndex");
449	for (testcases) \|case\| {	213	if (fi.isNamed()) {
450	const actual = case.inst.toU32();	214	try writer.writeByte('.');
451	try testing.expectEqual(case.expected, actual);	215	try writer.writeAll(@tagName(fi));
		216	} else {
		217	try writer.writeByte('(');
		218	try std.fmt.formatType(@intFromEnum(fi), fmt, options, writer, 0);
		219	try writer.writeByte(')');
		220	}
452	}	221	}
453	}	222	};
		223
		224	/// A linker symbol not yet allocated in VM.
		225	pub const Symbol = struct {
		226	/// Index of the containing atom.
		227	atom_index: u32,
		228	/// Index into the linker's symbol table.
		229	sym_index: u32,
		230	};

src/arch/riscv64/encoder.zig created+49

...	@@ -0,0 +1,49 @@
1	pub const Instruction = struct {
2	encoding: Encoding,
3	ops: [3]Operand = .{.none} ** 3,
4
5	pub const Operand = union(enum) {
6	none,
7	reg: Register,
8	mem: Memory,
9	imm: Immediate,
10	};
11
12	pub fn new(mnemonic: Encoding.Mnemonic, ops: []const Operand) !Instruction {
13	const encoding = (try Encoding.findByMnemonic(mnemonic, ops)) orelse {
14	std.log.err("no encoding found for: {s} {s} {s} {s} {s}", .{
15	@tagName(mnemonic),
16	@tagName(if (ops.len > 0) ops[0] else .none),
17	@tagName(if (ops.len > 1) ops[1] else .none),
18	@tagName(if (ops.len > 2) ops[2] else .none),
19	@tagName(if (ops.len > 3) ops[3] else .none),
20	});
21	return error.InvalidInstruction;
22	};
23
24	var result_ops: [3]Operand = .{.none} ** 3;
25	@memcpy(result_ops[0..ops.len], ops);
26
27	return .{
28	.encoding = encoding,
29	.ops = result_ops,
30	};
31	}
32
33	pub fn encode(inst: Instruction, writer: anytype) !void {
34	try writer.writeInt(u32, inst.encoding.data.toU32(), .little);
35	}
36	};
37
38	const std = @import("std");
39
40	const Lower = @import("Lower.zig");
41	const Mir = @import("Mir.zig");
42	const bits = @import("bits.zig");
43	const Encoding = @import("Encoding.zig");
44
45	const Register = bits.Register;
46	const Memory = bits.Memory;
47	const Immediate = bits.Immediate;
48
49	const log = std.log.scoped(.encode);

src/codegen/llvm.zig+2

...	@@ -11132,6 +11132,7 @@ fn lowerFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Bu	...	@@ -11132,6 +11132,7 @@ fn lowerFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Bu
11132	}	11132	}
11133	return o.builder.structType(.normal, types[0..types_len]);	11133	return o.builder.structType(.normal, types[0..types_len]);
11134	},	11134	},
		11135	.none => unreachable,
11135	}	11136	}
11136	},	11137	},
11137	// TODO investigate C ABI for other architectures	11138	// TODO investigate C ABI for other architectures
...	@@ -11389,6 +11390,7 @@ const ParamTypeIterator = struct {	...	@@ -11389,6 +11390,7 @@ const ParamTypeIterator = struct {
11389	it.llvm_index += it.types_len - 1;	11390	it.llvm_index += it.types_len - 1;
11390	return .multiple_llvm_types;	11391	return .multiple_llvm_types;
11391	},	11392	},
		11393	.none => unreachable,
11392	}	11394	}
11393	},	11395	},
11394	// TODO investigate C ABI for other architectures	11396	// TODO investigate C ABI for other architectures

src/link/Elf.zig+2

...	@@ -6409,6 +6409,8 @@ const RelaSectionTable = std.AutoArrayHashMapUnmanaged(u32, RelaSection);	...	@@ -6409,6 +6409,8 @@ const RelaSectionTable = std.AutoArrayHashMapUnmanaged(u32, RelaSection);
6409	// TODO: add comptime check we don't clobber any reloc for any ISA	6409	// TODO: add comptime check we don't clobber any reloc for any ISA
6410	pub const R_ZIG_GOT32: u32 = 0xff00;	6410	pub const R_ZIG_GOT32: u32 = 0xff00;
6411	pub const R_ZIG_GOTPCREL: u32 = 0xff01;	6411	pub const R_ZIG_GOTPCREL: u32 = 0xff01;
		6412	pub const R_ZIG_GOT_HI20: u32 = 0xff02;
		6413	pub const R_ZIG_GOT_LO12: u32 = 0xff03;
6412		6414
6413	fn defaultEntrySymbolName(cpu_arch: std.Target.Cpu.Arch) []const u8 {	6415	fn defaultEntrySymbolName(cpu_arch: std.Target.Cpu.Arch) []const u8 {
6414	return switch (cpu_arch) {	6416	return switch (cpu_arch) {

src/link/Elf/Atom.zig+25-3

...	@@ -2025,7 +2025,15 @@ const riscv = struct {	...	@@ -2025,7 +2025,15 @@ const riscv = struct {
2025	.SUB32,	2025	.SUB32,
2026	=> {},	2026	=> {},
2027		2027
2028	else => try atom.reportUnhandledRelocError(rel, elf_file),	2028	else => \|x\| switch (@intFromEnum(x)) {
		2029	Elf.R_ZIG_GOT_HI20,
		2030	Elf.R_ZIG_GOT_LO12,
		2031	=> {
		2032	assert(symbol.flags.has_zig_got);
		2033	},
		2034
		2035	else => try atom.reportUnhandledRelocError(rel, elf_file),
		2036	},
2029	}	2037	}
2030	}	2038	}
2031		2039
...	@@ -2046,7 +2054,6 @@ const riscv = struct {	...	@@ -2046,7 +2054,6 @@ const riscv = struct {
2046	const P, const A, const S, const GOT, const G, const TP, const DTP, const ZIG_GOT = args;	2054	const P, const A, const S, const GOT, const G, const TP, const DTP, const ZIG_GOT = args;
2047	_ = TP;	2055	_ = TP;
2048	_ = DTP;	2056	_ = DTP;
2049	_ = ZIG_GOT;
2050		2057
2051	switch (r_type) {	2058	switch (r_type) {
2052	.NONE => unreachable,	2059	.NONE => unreachable,
...	@@ -2136,7 +2143,22 @@ const riscv = struct {	...	@@ -2136,7 +2143,22 @@ const riscv = struct {
2136	}	2143	}
2137	},	2144	},
2138		2145
2139	else => try atom.reportUnhandledRelocError(rel, elf_file),	2146	else => \|x\| switch (@intFromEnum(x)) {
		2147	// Zig custom relocations
		2148	Elf.R_ZIG_GOT_HI20 => {
		2149	assert(target.flags.has_zig_got);
		2150	const disp: u32 = @bitCast(math.cast(i32, G + ZIG_GOT + A) orelse return error.Overflow);
		2151	riscv_util.writeInstU(code[r_offset..][0..4], disp);
		2152	},
		2153
		2154	Elf.R_ZIG_GOT_LO12 => {
		2155	assert(target.flags.has_zig_got);
		2156	const value: u32 = @bitCast(math.cast(i32, G + ZIG_GOT + A) orelse return error.Overflow);
		2157	riscv_util.writeInstI(code[r_offset..][0..4], value);
		2158	},
		2159
		2160	else => try atom.reportUnhandledRelocError(rel, elf_file),
		2161	},
2140	}	2162	}
2141	}	2163	}
2142		2164

src/link/riscv.zig+47-18

 @@ -25,38 +25,66 @@ pub fn writeAddend(
 }
 pub fn writeInstU(code: *[4]u8, value: u32) void {
-    var inst = Instruction{
+    var data = Encoding.Data{
         .U = mem.bytesToValue(std.meta.TagPayload(
-            Instruction,
+            Encoding.Data,
-            Instruction.U,
+            Encoding.Data.U,
         ), code),
     };
     const compensated: u32 = @bitCast(@as(i32, @bitCast(value)) + 0x800);
-    inst.U.imm12_31 = bitSlice(compensated, 31, 12);
+    data.U.imm12_31 = bitSlice(compensated, 31, 12);
-    mem.writeInt(u32, code, inst.toU32(), .little);
+    mem.writeInt(u32, code, data.toU32(), .little);
 }
 pub fn writeInstI(code: *[4]u8, value: u32) void {
-    var inst = Instruction{
+    var data = Encoding.Data{
         .I = mem.bytesToValue(std.meta.TagPayload(
-            Instruction,
+            Encoding.Data,
-            Instruction.I,
+            Encoding.Data.I,
         ), code),
     };
-    inst.I.imm0_11 = bitSlice(value, 11, 0);
+    data.I.imm0_11 = bitSlice(value, 11, 0);
-    mem.writeInt(u32, code, inst.toU32(), .little);
+    mem.writeInt(u32, code, data.toU32(), .little);
 }
 pub fn writeInstS(code: *[4]u8, value: u32) void {
-    var inst = Instruction{
+    var data = Encoding.Data{
         .S = mem.bytesToValue(std.meta.TagPayload(
-            Instruction,
+            Encoding.Data,
-            Instruction.S,
+            Encoding.Data.S,
         ), code),
     };
-    inst.S.imm0_4 = bitSlice(value, 4, 0);
+    data.S.imm0_4 = bitSlice(value, 4, 0);
-    inst.S.imm5_11 = bitSlice(value, 11, 5);
+    data.S.imm5_11 = bitSlice(value, 11, 5);
-    mem.writeInt(u32, code, inst.toU32(), .little);
+    mem.writeInt(u32, code, data.toU32(), .little);
+}
+pub fn writeInstJ(code: *[4]u8, value: u32) void {
+    var data = Encoding.Data{
+        .J = mem.bytesToValue(std.meta.TagPayload(
+            Encoding.Data,
+            Encoding.Data.J,
+        ), code),
+    };
+    data.J.imm1_10 = bitSlice(value, 10, 1);
+    data.J.imm11 = bitSlice(value, 11, 11);
+    data.J.imm12_19 = bitSlice(value, 19, 12);
+    data.J.imm20 = bitSlice(value, 20, 20);
+    mem.writeInt(u32, code, data.toU32(), .little);
+}
+pub fn writeInstB(code: *[4]u8, value: u32) void {
+    var data = Encoding.Data{
+        .B = mem.bytesToValue(std.meta.TagPayload(
+            Encoding.Data,
+            Encoding.Data.B,
+        ), code),
+    };
+    data.B.imm1_4 = bitSlice(value, 4, 1);
+    data.B.imm5_10 = bitSlice(value, 10, 5);
+    data.B.imm11 = bitSlice(value, 11, 11);
+    data.B.imm12 = bitSlice(value, 12, 12);
+    mem.writeInt(u32, code, data.toU32(), .little);
 }
 fn bitSlice(
 @@ -67,8 +95,9 @@ fn bitSlice(
     return @truncate((value >> low) & (1 << (high - low + 1)) - 1);
 }
-const bits = @import("../arch/riscv64/bits.zig");
+const encoder = @import("../arch/riscv64/encoder.zig");
+const Encoding = @import("../arch/riscv64/Encoding.zig");
 const mem = std.mem;
 const std = @import("std");
-pub const Instruction = bits.Instruction;
+pub const Instruction = encoder.Instruction;

src/register_manager.zig+2-1

...	@@ -102,7 +102,7 @@ pub fn RegisterManager(	...	@@ -102,7 +102,7 @@ pub fn RegisterManager(
102	}	102	}
103		103
104	const OptionalIndex = std.math.IntFittingRange(0, set.len);	104	const OptionalIndex = std.math.IntFittingRange(0, set.len);
105	comptime var map = [1]OptionalIndex{set.len} ** (max_id + 1 - min_id);	105	comptime var map = [1]OptionalIndex{set.len} ** (max_id - min_id + 1);
106	inline for (set, 0..) \|elem, elem_index\| map[comptime elem.id() - min_id] = elem_index;	106	inline for (set, 0..) \|elem, elem_index\| map[comptime elem.id() - min_id] = elem_index;
107		107
108	const id_index = reg.id() -% min_id;	108	const id_index = reg.id() -% min_id;
...	@@ -360,6 +360,7 @@ pub fn RegisterManager(	...	@@ -360,6 +360,7 @@ pub fn RegisterManager(
360	} else self.getRegIndexAssumeFree(tracked_index, inst);	360	} else self.getRegIndexAssumeFree(tracked_index, inst);
361	}	361	}
362	pub fn getReg(self: *Self, reg: Register, inst: ?Air.Inst.Index) AllocateRegistersError!void {	362	pub fn getReg(self: *Self, reg: Register, inst: ?Air.Inst.Index) AllocateRegistersError!void {
		363	log.debug("getting reg: {}", .{reg});
363	return self.getRegIndex(indexOfRegIntoTracked(reg) orelse return, inst);	364	return self.getRegIndex(indexOfRegIntoTracked(reg) orelse return, inst);
364	}	365	}
365	pub fn getKnownReg(	366	pub fn getKnownReg(

src/target.zig+2-2

test/behavior/abs.zig+5-6

 @@ -5,8 +5,8 @@ const expect = std.testing.expect;
 test "@abs integers" {
     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; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     try comptime testAbsIntegers();
     try testAbsIntegers();
 @@ -51,7 +51,6 @@ fn testAbsIntegers() !void {
 test "@abs unsigned integers" {
     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; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     try comptime testAbsUnsignedIntegers();
 @@ -92,9 +91,9 @@ fn testAbsUnsignedIntegers() !void {
 test "@abs floats" {
     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; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     try comptime testAbsFloats(f16);
     try testAbsFloats(f16);
 @@ -151,8 +150,8 @@ test "@abs int vectors" {
     if (builtin.zig_backend == .stage2_x86_64) 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; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     try comptime testAbsIntVectors(1);
     try testAbsIntVectors(1);
 @@ -218,8 +217,8 @@ test "@abs unsigned int vectors" {
     if (builtin.zig_backend == .stage2_x86_64) 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; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     try comptime testAbsUnsignedIntVectors(1);
     try testAbsUnsignedIntVectors(1);
 @@ -277,9 +276,9 @@ test "@abs float vectors" {
     if (builtin.zig_backend == .stage2_x86_64) 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; // 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;
     // https://github.com/ziglang/zig/issues/12827
     if (builtin.zig_backend == .stage2_llvm and

test/behavior/align.zig+16

test/behavior/alignof.zig+2

...	@@ -29,6 +29,8 @@ test "comparison of @alignOf(T) against zero" {	...	@@ -29,6 +29,8 @@ test "comparison of @alignOf(T) against zero" {
29	}	29	}
30		30
31	test "correct alignment for elements and slices of aligned array" {	31	test "correct alignment for elements and slices of aligned array" {
		32	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		33
32	var buf: [1024]u8 align(64) = undefined;	34	var buf: [1024]u8 align(64) = undefined;
33	var start: usize = 1;	35	var start: usize = 1;
34	var end: usize = undefined;	36	var end: usize = undefined;

test/behavior/array.zig+45

...	@@ -22,6 +22,7 @@ test "arrays" {	...	@@ -22,6 +22,7 @@ test "arrays" {
22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		25	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
25		26
26	var array: [5]u32 = undefined;	27	var array: [5]u32 = undefined;
27		28
...	@@ -49,6 +50,7 @@ fn getArrayLen(a: []const u32) usize {	...	@@ -49,6 +50,7 @@ fn getArrayLen(a: []const u32) usize {
49	test "array concat with undefined" {	50	test "array concat with undefined" {
50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
51	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		53	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
52		54
53	const S = struct {	55	const S = struct {
54	fn doTheTest() !void {	56	fn doTheTest() !void {
...	@@ -87,6 +89,7 @@ test "array concat with tuple" {	...	@@ -87,6 +89,7 @@ test "array concat with tuple" {
87		89
88	test "array init with concat" {	90	test "array init with concat" {
89	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	91	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		92	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
90		93
91	const a = 'a';	94	const a = 'a';
92	var i: [4]u8 = [2]u8{ a, 'b' } ++ [2]u8{ 'c', 'd' };	95	var i: [4]u8 = [2]u8{ a, 'b' } ++ [2]u8{ 'c', 'd' };
...	@@ -96,6 +99,7 @@ test "array init with concat" {	...	@@ -96,6 +99,7 @@ test "array init with concat" {
96	test "array init with mult" {	99	test "array init with mult" {
97	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	100	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
98	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	101	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		102	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
99		103
100	const a = 'a';	104	const a = 'a';
101	var i: [8]u8 = [2]u8{ a, 'b' } ** 4;	105	var i: [8]u8 = [2]u8{ a, 'b' } ** 4;
...	@@ -159,6 +163,7 @@ test "array len field" {	...	@@ -159,6 +163,7 @@ test "array len field" {
159	test "array with sentinels" {	163	test "array with sentinels" {
160	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	164	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
161	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	165	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		166	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
162		167
163	const S = struct {	168	const S = struct {
164	fn doTheTest(is_ct: bool) !void {	169	fn doTheTest(is_ct: bool) !void {
...	@@ -226,6 +231,7 @@ test "nested arrays of integers" {	...	@@ -226,6 +231,7 @@ test "nested arrays of integers" {
226	test "implicit comptime in array type size" {	231	test "implicit comptime in array type size" {
227	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	232	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
228	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	233	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		234	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
229		235
230	var arr: [plusOne(10)]bool = undefined;	236	var arr: [plusOne(10)]bool = undefined;
231	_ = &arr;	237	_ = &arr;
...	@@ -239,6 +245,7 @@ fn plusOne(x: u32) u32 {	...	@@ -239,6 +245,7 @@ fn plusOne(x: u32) u32 {
239	test "single-item pointer to array indexing and slicing" {	245	test "single-item pointer to array indexing and slicing" {
240	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	246	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
241	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	247	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		248	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
242		249
243	try testSingleItemPtrArrayIndexSlice();	250	try testSingleItemPtrArrayIndexSlice();
244	try comptime testSingleItemPtrArrayIndexSlice();	251	try comptime testSingleItemPtrArrayIndexSlice();
...	@@ -264,6 +271,7 @@ fn doSomeMangling(array: *[4]u8) void {	...	@@ -264,6 +271,7 @@ fn doSomeMangling(array: *[4]u8) void {
264		271
265	test "implicit cast zero sized array ptr to slice" {	272	test "implicit cast zero sized array ptr to slice" {
266	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	273	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		274	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
267		275
268	{	276	{
269	var b = "".*;	277	var b = "".*;
...	@@ -302,6 +310,7 @@ const Str = struct { a: []Sub };	...	@@ -302,6 +310,7 @@ const Str = struct { a: []Sub };
302	test "set global var array via slice embedded in struct" {	310	test "set global var array via slice embedded in struct" {
303	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	311	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
304	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	312	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		313	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
305		314
306	var s = Str{ .a = s_array[0..] };	315	var s = Str{ .a = s_array[0..] };
307		316
...	@@ -338,6 +347,7 @@ test "read/write through global variable array of struct fields initialized via	...	@@ -338,6 +347,7 @@ test "read/write through global variable array of struct fields initialized via
338	test "implicit cast single-item pointer" {	347	test "implicit cast single-item pointer" {
339	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	348	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
340	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		350	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
341		351
342	try testImplicitCastSingleItemPtr();	352	try testImplicitCastSingleItemPtr();
343	try comptime testImplicitCastSingleItemPtr();	353	try comptime testImplicitCastSingleItemPtr();
...	@@ -368,6 +378,7 @@ test "comptime evaluating function that takes array by value" {	...	@@ -368,6 +378,7 @@ test "comptime evaluating function that takes array by value" {
368	test "runtime initialize array elem and then implicit cast to slice" {	378	test "runtime initialize array elem and then implicit cast to slice" {
369	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	379	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
370	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	380	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		381	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
371		382
372	var two: i32 = 2;	383	var two: i32 = 2;
373	_ = &two;	384	_ = &two;
...	@@ -378,6 +389,7 @@ test "runtime initialize array elem and then implicit cast to slice" {	...	@@ -378,6 +389,7 @@ test "runtime initialize array elem and then implicit cast to slice" {
378	test "array literal as argument to function" {	389	test "array literal as argument to function" {
379	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	390	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
380	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	391	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		392	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
381		393
382	const S = struct {	394	const S = struct {
383	fn entry(two: i32) !void {	395	fn entry(two: i32) !void {
...	@@ -406,6 +418,7 @@ test "double nested array to const slice cast in array literal" {	...	@@ -406,6 +418,7 @@ test "double nested array to const slice cast in array literal" {
406	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	418	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
407	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	419	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
408	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	420	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		421	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
409		422
410	const S = struct {	423	const S = struct {
411	fn entry(two: i32) !void {	424	fn entry(two: i32) !void {
...	@@ -492,6 +505,7 @@ test "anonymous literal in array" {	...	@@ -492,6 +505,7 @@ test "anonymous literal in array" {
492	test "access the null element of a null terminated array" {	505	test "access the null element of a null terminated array" {
493	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	506	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
494	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	507	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		508	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
495		509
496	const S = struct {	510	const S = struct {
497	fn doTheTest() !void {	511	fn doTheTest() !void {
...	@@ -511,6 +525,7 @@ test "type deduction for array subscript expression" {	...	@@ -511,6 +525,7 @@ test "type deduction for array subscript expression" {
511	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	525	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
512	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	526	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
513	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	527	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		528	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
514		529
515	const S = struct {	530	const S = struct {
516	fn doTheTest() !void {	531	fn doTheTest() !void {
...	@@ -530,6 +545,7 @@ test "sentinel element count towards the ABI size calculation" {	...	@@ -530,6 +545,7 @@ test "sentinel element count towards the ABI size calculation" {
530	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	545	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
531	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	546	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
532	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	547	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		548	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
533		549
534	const S = struct {	550	const S = struct {
535	fn doTheTest() !void {	551	fn doTheTest() !void {
...	@@ -577,6 +593,7 @@ test "type coercion of anon struct literal to array" {	...	@@ -577,6 +593,7 @@ test "type coercion of anon struct literal to array" {
577	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	593	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
578	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	594	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
579	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	595	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		596	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
580		597
581	const S = struct {	598	const S = struct {
582	const U = union {	599	const U = union {
...	@@ -611,6 +628,7 @@ test "type coercion of pointer to anon struct literal to pointer to array" {	...	@@ -611,6 +628,7 @@ test "type coercion of pointer to anon struct literal to pointer to array" {
611	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	628	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
612	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	629	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
613	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	630	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		631	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
614		632
615	const S = struct {	633	const S = struct {
616	const U = union {	634	const U = union {
...	@@ -663,6 +681,7 @@ test "array init of container level array variable" {	...	@@ -663,6 +681,7 @@ test "array init of container level array variable" {
663	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	681	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
664	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	682	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
665	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	683	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		684	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
666		685
667	const S = struct {	686	const S = struct {
668	var pair: [2]usize = .{ 1, 2 };	687	var pair: [2]usize = .{ 1, 2 };
...	@@ -683,6 +702,8 @@ test "array init of container level array variable" {	...	@@ -683,6 +702,8 @@ test "array init of container level array variable" {
683	}	702	}
684		703
685	test "runtime initialized sentinel-terminated array literal" {	704	test "runtime initialized sentinel-terminated array literal" {
		705	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		706
686	var c: u16 = 300;	707	var c: u16 = 300;
687	_ = &c;	708	_ = &c;
688	const f = &[_:0x9999]u16{c};	709	const f = &[_:0x9999]u16{c};
...	@@ -695,6 +716,7 @@ test "array of array agregate init" {	...	@@ -695,6 +716,7 @@ test "array of array agregate init" {
695	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	716	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
696	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	717	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
697	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	718	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		719	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
698		720
699	var a = [1]u32{11} ** 10;	721	var a = [1]u32{11} ** 10;
700	var b = [1][10]u32{a} ** 2;	722	var b = [1][10]u32{a} ** 2;
...	@@ -745,6 +767,7 @@ test "slicing array of zero-sized values" {	...	@@ -745,6 +767,7 @@ test "slicing array of zero-sized values" {
745	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	767	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
746	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	768	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
747	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	769	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		770	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
748		771
749	var arr: [32]u0 = undefined;	772	var arr: [32]u0 = undefined;
750	for (arr[0..]) \|*zero\|	773	for (arr[0..]) \|*zero\|
...	@@ -754,6 +777,8 @@ test "slicing array of zero-sized values" {	...	@@ -754,6 +777,8 @@ test "slicing array of zero-sized values" {
754	}	777	}
755		778
756	test "array init with no result pointer sets field result types" {	779	test "array init with no result pointer sets field result types" {
		780	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		781
757	const S = struct {	782	const S = struct {
758	// A function parameter has a result type, but no result pointer.	783	// A function parameter has a result type, but no result pointer.
759	fn f(arr: [1]u32) u32 {	784	fn f(arr: [1]u32) u32 {
...	@@ -768,6 +793,8 @@ test "array init with no result pointer sets field result types" {	...	@@ -768,6 +793,8 @@ test "array init with no result pointer sets field result types" {
768	}	793	}
769		794
770	test "runtime side-effects in comptime-known array init" {	795	test "runtime side-effects in comptime-known array init" {
		796	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		797
771	var side_effects: u4 = 0;	798	var side_effects: u4 = 0;
772	const init = [4]u4{	799	const init = [4]u4{
773	blk: {	800	blk: {
...	@@ -792,6 +819,8 @@ test "runtime side-effects in comptime-known array init" {	...	@@ -792,6 +819,8 @@ test "runtime side-effects in comptime-known array init" {
792	}	819	}
793		820
794	test "slice initialized through reference to anonymous array init provides result types" {	821	test "slice initialized through reference to anonymous array init provides result types" {
		822	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		823
795	var my_u32: u32 = 123;	824	var my_u32: u32 = 123;
796	var my_u64: u64 = 456;	825	var my_u64: u64 = 456;
797	_ = .{ &my_u32, &my_u64 };	826	_ = .{ &my_u32, &my_u64 };
...	@@ -805,6 +834,8 @@ test "slice initialized through reference to anonymous array init provides resul	...	@@ -805,6 +834,8 @@ test "slice initialized through reference to anonymous array init provides resul
805	}	834	}
806		835
807	test "sentinel-terminated slice initialized through reference to anonymous array init provides result types" {	836	test "sentinel-terminated slice initialized through reference to anonymous array init provides result types" {
		837	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		838
808	var my_u32: u32 = 123;	839	var my_u32: u32 = 123;
809	var my_u64: u64 = 456;	840	var my_u64: u64 = 456;
810	_ = .{ &my_u32, &my_u64 };	841	_ = .{ &my_u32, &my_u64 };
...	@@ -818,6 +849,8 @@ test "sentinel-terminated slice initialized through reference to anonymous array	...	@@ -818,6 +849,8 @@ test "sentinel-terminated slice initialized through reference to anonymous array
818	}	849	}
819		850
820	test "many-item pointer initialized through reference to anonymous array init provides result types" {	851	test "many-item pointer initialized through reference to anonymous array init provides result types" {
		852	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		853
821	var my_u32: u32 = 123;	854	var my_u32: u32 = 123;
822	var my_u64: u64 = 456;	855	var my_u64: u64 = 456;
823	_ = .{ &my_u32, &my_u64 };	856	_ = .{ &my_u32, &my_u64 };
...	@@ -834,6 +867,8 @@ test "many-item pointer initialized through reference to anonymous array init pr	...	@@ -834,6 +867,8 @@ test "many-item pointer initialized through reference to anonymous array init pr
834	}	867	}
835		868
836	test "many-item sentinel-terminated pointer initialized through reference to anonymous array init provides result types" {	869	test "many-item sentinel-terminated pointer initialized through reference to anonymous array init provides result types" {
		870	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		871
837	var my_u32: u32 = 123;	872	var my_u32: u32 = 123;
838	var my_u64: u64 = 456;	873	var my_u64: u64 = 456;
839	_ = .{ &my_u32, &my_u64 };	874	_ = .{ &my_u32, &my_u64 };
...	@@ -851,6 +886,8 @@ test "many-item sentinel-terminated pointer initialized through reference to ano	...	@@ -851,6 +886,8 @@ test "many-item sentinel-terminated pointer initialized through reference to ano
851	}	886	}
852		887
853	test "pointer to array initialized through reference to anonymous array init provides result types" {	888	test "pointer to array initialized through reference to anonymous array init provides result types" {
		889	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		890
854	var my_u32: u32 = 123;	891	var my_u32: u32 = 123;
855	var my_u64: u64 = 456;	892	var my_u64: u64 = 456;
856	_ = .{ &my_u32, &my_u64 };	893	_ = .{ &my_u32, &my_u64 };
...	@@ -864,6 +901,8 @@ test "pointer to array initialized through reference to anonymous array init pro	...	@@ -864,6 +901,8 @@ test "pointer to array initialized through reference to anonymous array init pro
864	}	901	}
865		902
866	test "pointer to sentinel-terminated array initialized through reference to anonymous array init provides result types" {	903	test "pointer to sentinel-terminated array initialized through reference to anonymous array init provides result types" {
		904	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		905
867	var my_u32: u32 = 123;	906	var my_u32: u32 = 123;
868	var my_u64: u64 = 456;	907	var my_u64: u64 = 456;
869	_ = .{ &my_u32, &my_u64 };	908	_ = .{ &my_u32, &my_u64 };
...	@@ -890,6 +929,7 @@ test "copied array element doesn't alias source" {	...	@@ -890,6 +929,7 @@ test "copied array element doesn't alias source" {
890	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	929	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
891	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	930	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
892	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	931	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		932	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
893		933
894	var x: [10][10]u32 = undefined;	934	var x: [10][10]u32 = undefined;
895		935
...	@@ -902,6 +942,7 @@ test "copied array element doesn't alias source" {	...	@@ -902,6 +942,7 @@ test "copied array element doesn't alias source" {
902		942
903	test "array initialized with string literal" {	943	test "array initialized with string literal" {
904	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	944	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		945	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
905		946
906	const S = struct {	947	const S = struct {
907	a: u32,	948	a: u32,
...	@@ -922,6 +963,7 @@ test "array initialized with string literal" {	...	@@ -922,6 +963,7 @@ test "array initialized with string literal" {
922		963
923	test "array initialized with array with sentinel" {	964	test "array initialized with array with sentinel" {
924	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	965	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		966	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
925		967
926	const S = struct {	968	const S = struct {
927	a: u32,	969	a: u32,
...	@@ -969,6 +1011,7 @@ test "accessing multidimensional global array at comptime" {	...	@@ -969,6 +1011,7 @@ test "accessing multidimensional global array at comptime" {
969	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	1011	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
970	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1012	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
971	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1013	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		1014	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
972		1015
973	const S = struct {	1016	const S = struct {
974	const array = [_][]const []const u8{	1017	const array = [_][]const []const u8{
...	@@ -985,6 +1028,7 @@ test "union that needs padding bytes inside an array" {	...	@@ -985,6 +1028,7 @@ test "union that needs padding bytes inside an array" {
985	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1028	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
986	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	1029	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
987	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1030	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1031	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
988		1032
989	const B = union(enum) {	1033	const B = union(enum) {
990	D: u8,	1034	D: u8,
...	@@ -1006,6 +1050,7 @@ test "union that needs padding bytes inside an array" {	...	@@ -1006,6 +1050,7 @@ test "union that needs padding bytes inside an array" {
1006		1050
1007	test "runtime index of array of zero-bit values" {	1051	test "runtime index of array of zero-bit values" {
1008	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1052	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1053	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1009		1054
1010	var runtime: struct { array: [1]void, index: usize } = undefined;	1055	var runtime: struct { array: [1]void, index: usize } = undefined;
1011	runtime = .{ .array = .{{}}, .index = 0 };	1056	runtime = .{ .array = .{{}}, .index = 0 };

test/behavior/asm.zig+4

test/behavior/atomics.zig+13

test/behavior/basic.zig+37

test/behavior/bit_shifting.zig+2

...	@@ -65,6 +65,7 @@ test "sharded table" {	...	@@ -65,6 +65,7 @@ test "sharded table" {
65	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	65	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
66	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	66	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
67	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	67	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		68	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
68		69
69	// realistic 16-way sharding	70	// realistic 16-way sharding
70	try testShardedTable(u32, 4, 8);	71	try testShardedTable(u32, 4, 8);
...	@@ -116,6 +117,7 @@ test "Saturating Shift Left where lhs is of a computed type" {	...	@@ -116,6 +117,7 @@ test "Saturating Shift Left where lhs is of a computed type" {
116	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	117	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
117	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	118	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
118	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	119	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		120	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
119		121
120	const S = struct {	122	const S = struct {
121	fn getIntShiftType(comptime T: type) type {	123	fn getIntShiftType(comptime T: type) type {

test/behavior/bitcast.zig+17

test/behavior/bitreverse.zig+4

test/behavior/bool.zig+2

...	@@ -9,6 +9,8 @@ test "bool literals" {	...	@@ -9,6 +9,8 @@ test "bool literals" {
9	}	9	}
10		10
11	test "cast bool to int" {	11	test "cast bool to int" {
		12	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		13
12	const t = true;	14	const t = true;
13	const f = false;	15	const f = false;
14	try expectEqual(@as(u32, 1), @intFromBool(t));	16	try expectEqual(@as(u32, 1), @intFromBool(t));

test/behavior/builtin_functions_returning_void_or_noreturn.zig+1-1

 @@ -10,8 +10,8 @@ test {
     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; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     var val: u8 = undefined;
     try testing.expectEqual({}, @atomicStore(u8, &val, 0, .unordered));

test/behavior/byteswap.zig+4

test/behavior/byval_arg_var.zig+1

...	@@ -5,6 +5,7 @@ var result: []const u8 = "wrong";	...	@@ -5,6 +5,7 @@ var result: []const u8 = "wrong";
5		5
6	test "pass string literal byvalue to a generic var param" {	6	test "pass string literal byvalue to a generic var param" {
7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		8	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8		9
9	start();	10	start();
10	blowUpStack(10);	11	blowUpStack(10);

test/behavior/call.zig+13

test/behavior/call_tail.zig+2

...	@@ -31,6 +31,8 @@ noinline fn insertionSort(data: []u64) void {	...	@@ -31,6 +31,8 @@ noinline fn insertionSort(data: []u64) void {
31	}	31	}
32		32
33	test "arguments pointed to on stack into tailcall" {	33	test "arguments pointed to on stack into tailcall" {
		34	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		35
34	switch (builtin.cpu.arch) {	36	switch (builtin.cpu.arch) {
35	.wasm32,	37	.wasm32,
36	.mips,	38	.mips,

test/behavior/cast.zig+102

test/behavior/cast_int.zig+8

test/behavior/comptime_memory.zig+4

...	@@ -408,6 +408,8 @@ test "mutate entire slice at comptime" {	...	@@ -408,6 +408,8 @@ test "mutate entire slice at comptime" {
408	}	408	}
409		409
410	test "dereference undefined pointer to zero-bit type" {	410	test "dereference undefined pointer to zero-bit type" {
		411	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		412
411	const p0: *void = undefined;	413	const p0: *void = undefined;
412	try testing.expectEqual({}, p0.*);	414	try testing.expectEqual({}, p0.*);
413		415
...	@@ -513,5 +515,7 @@ fn fieldPtrTest() u32 {	...	@@ -513,5 +515,7 @@ fn fieldPtrTest() u32 {
513	return a.value;	515	return a.value;
514	}	516	}
515	test "pointer in aggregate field can mutate comptime state" {	517	test "pointer in aggregate field can mutate comptime state" {
		518	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		519
516	try comptime std.testing.expect(fieldPtrTest() == 2);	520	try comptime std.testing.expect(fieldPtrTest() == 2);
517	}	521	}

test/behavior/const_slice_child.zig+1

...	@@ -10,6 +10,7 @@ test "const slice child" {	...	@@ -10,6 +10,7 @@ test "const slice child" {
10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		13	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13		14
14	const strs = [_][*]const u8{ "one", "two", "three" };	15	const strs = [_][*]const u8{ "one", "two", "three" };
15	argv = &strs;	16	argv = &strs;

test/behavior/defer.zig+5

test/behavior/destructure.zig+2

...	@@ -23,6 +23,8 @@ test "simple destructure" {	...	@@ -23,6 +23,8 @@ test "simple destructure" {
23	}	23	}
24		24
25	test "destructure with comptime syntax" {	25	test "destructure with comptime syntax" {
		26	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		27
26	const S = struct {	28	const S = struct {
27	fn doTheTest() !void {	29	fn doTheTest() !void {
28	{	30	{

test/behavior/duplicated_test_names.zig+1

...	@@ -16,6 +16,7 @@ test "thingy" {}	...	@@ -16,6 +16,7 @@ test "thingy" {}
16		16
17	test thingy {	17	test thingy {
18	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	18	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		19	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
19		20
20	if (thingy(1, 2) != 3) unreachable;	21	if (thingy(1, 2) != 3) unreachable;
21	}	22	}

test/behavior/empty_tuple_fields.zig+2

...	@@ -5,6 +5,7 @@ test "empty file level struct" {	...	@@ -5,6 +5,7 @@ test "empty file level struct" {
5	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	5	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		8	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8		9
9	const T = @import("empty_file_level_struct.zig");	10	const T = @import("empty_file_level_struct.zig");
10	const info = @typeInfo(T);	11	const info = @typeInfo(T);
...	@@ -17,6 +18,7 @@ test "empty file level union" {	...	@@ -17,6 +18,7 @@ test "empty file level union" {
17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	20	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		21	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
20		22
21	const T = @import("empty_file_level_union.zig");	23	const T = @import("empty_file_level_union.zig");
22	const info = @typeInfo(T);	24	const info = @typeInfo(T);

test/behavior/empty_union.zig+4

...	@@ -48,6 +48,8 @@ test "empty extern union" {	...	@@ -48,6 +48,8 @@ test "empty extern union" {
48	}	48	}
49		49
50	test "empty union passed as argument" {	50	test "empty union passed as argument" {
		51	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		52
51	const U = union(enum) {	53	const U = union(enum) {
52	fn f(u: @This()) void {	54	fn f(u: @This()) void {
53	switch (u) {}	55	switch (u) {}
...	@@ -57,6 +59,8 @@ test "empty union passed as argument" {	...	@@ -57,6 +59,8 @@ test "empty union passed as argument" {
57	}	59	}
58		60
59	test "empty enum passed as argument" {	61	test "empty enum passed as argument" {
		62	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		63
60	const E = enum {	64	const E = enum {
61	fn f(e: @This()) void {	65	fn f(e: @This()) void {
62	switch (e) {}	66	switch (e) {}

test/behavior/enum.zig+20

test/behavior/error.zig+45

test/behavior/eval.zig+30

test/behavior/export_builtin.zig+2

test/behavior/export_keyword.zig+2

...	@@ -9,6 +9,8 @@ const builtin = @import("builtin");	...	@@ -9,6 +9,8 @@ const builtin = @import("builtin");
9	// and generates code	9	// and generates code
10	const vram = @as([*]volatile u8, @ptrFromInt(0x20000000))[0..0x8000];	10	const vram = @as([*]volatile u8, @ptrFromInt(0x20000000))[0..0x8000];
11	export fn writeToVRam() void {	11	export fn writeToVRam() void {
		12	if (builtin.zig_backend == .stage2_riscv64) return;
		13
12	vram[0] = 'X';	14	vram[0] = 'X';
13	}	15	}
14		16

test/behavior/extern.zig+3

test/behavior/field_parent_ptr.zig+21

...	@@ -2,6 +2,8 @@ const expect = @import("std").testing.expect;	...	@@ -2,6 +2,8 @@ const expect = @import("std").testing.expect;
2	const builtin = @import("builtin");	2	const builtin = @import("builtin");
3		3
4	test "@fieldParentPtr struct" {	4	test "@fieldParentPtr struct" {
		5	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		6
5	const C = struct {	7	const C = struct {
6	a: bool = true,	8	a: bool = true,
7	b: f32 = 3.14,	9	b: f32 = 3.14,
...	@@ -135,6 +137,8 @@ test "@fieldParentPtr struct" {	...	@@ -135,6 +137,8 @@ test "@fieldParentPtr struct" {
135	}	137	}
136		138
137	test "@fieldParentPtr extern struct" {	139	test "@fieldParentPtr extern struct" {
		140	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		141
138	const C = extern struct {	142	const C = extern struct {
139	a: bool = true,	143	a: bool = true,
140	b: f32 = 3.14,	144	b: f32 = 3.14,
...	@@ -269,6 +273,7 @@ test "@fieldParentPtr extern struct" {	...	@@ -269,6 +273,7 @@ test "@fieldParentPtr extern struct" {
269		273
270	test "@fieldParentPtr extern struct first zero-bit field" {	274	test "@fieldParentPtr extern struct first zero-bit field" {
271	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	275	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		276	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
272		277
273	const C = extern struct {	278	const C = extern struct {
274	a: u0 = 0,	279	a: u0 = 0,
...	@@ -372,6 +377,7 @@ test "@fieldParentPtr extern struct first zero-bit field" {	...	@@ -372,6 +377,7 @@ test "@fieldParentPtr extern struct first zero-bit field" {
372		377
373	test "@fieldParentPtr extern struct middle zero-bit field" {	378	test "@fieldParentPtr extern struct middle zero-bit field" {
374	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	379	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		380	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
375		381
376	const C = extern struct {	382	const C = extern struct {
377	a: f32 = 3.14,	383	a: f32 = 3.14,
...	@@ -475,6 +481,7 @@ test "@fieldParentPtr extern struct middle zero-bit field" {	...	@@ -475,6 +481,7 @@ test "@fieldParentPtr extern struct middle zero-bit field" {
475		481
476	test "@fieldParentPtr extern struct last zero-bit field" {	482	test "@fieldParentPtr extern struct last zero-bit field" {
477	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	483	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		484	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
478		485
479	const C = extern struct {	486	const C = extern struct {
480	a: f32 = 3.14,	487	a: f32 = 3.14,
...	@@ -581,6 +588,7 @@ test "@fieldParentPtr unaligned packed struct" {	...	@@ -581,6 +588,7 @@ test "@fieldParentPtr unaligned packed struct" {
581	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	588	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
582	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	589	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
583	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	590	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		591	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
584		592
585	const C = packed struct {	593	const C = packed struct {
586	a: bool = true,	594	a: bool = true,
...	@@ -719,6 +727,7 @@ test "@fieldParentPtr aligned packed struct" {	...	@@ -719,6 +727,7 @@ test "@fieldParentPtr aligned packed struct" {
719	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	727	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
720	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	728	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
721	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	729	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		730	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
722		731
723	const C = packed struct {	732	const C = packed struct {
724	a: f32 = 3.14,	733	a: f32 = 3.14,
...	@@ -856,6 +865,7 @@ test "@fieldParentPtr nested packed struct" {	...	@@ -856,6 +865,7 @@ test "@fieldParentPtr nested packed struct" {
856	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	865	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
857	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	866	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
858	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	867	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		868	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
859		869
860	{	870	{
861	const C = packed struct {	871	const C = packed struct {
...	@@ -1018,6 +1028,7 @@ test "@fieldParentPtr packed struct first zero-bit field" {	...	@@ -1018,6 +1028,7 @@ test "@fieldParentPtr packed struct first zero-bit field" {
1018	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	1028	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1019	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	1029	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1020	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1030	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1031	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1021		1032
1022	const C = packed struct {	1033	const C = packed struct {
1023	a: u0 = 0,	1034	a: u0 = 0,
...	@@ -1123,6 +1134,7 @@ test "@fieldParentPtr packed struct middle zero-bit field" {	...	@@ -1123,6 +1134,7 @@ test "@fieldParentPtr packed struct middle zero-bit field" {
1123	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	1134	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1124	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	1135	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1125	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1136	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1137	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1126		1138
1127	const C = packed struct {	1139	const C = packed struct {
1128	a: f32 = 3.14,	1140	a: f32 = 3.14,
...	@@ -1228,6 +1240,7 @@ test "@fieldParentPtr packed struct last zero-bit field" {	...	@@ -1228,6 +1240,7 @@ test "@fieldParentPtr packed struct last zero-bit field" {
1228	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	1240	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1229	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	1241	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1230	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1242	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1243	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1231		1244
1232	const C = packed struct {	1245	const C = packed struct {
1233	a: f32 = 3.14,	1246	a: f32 = 3.14,
...	@@ -1330,6 +1343,8 @@ test "@fieldParentPtr packed struct last zero-bit field" {	...	@@ -1330,6 +1343,8 @@ test "@fieldParentPtr packed struct last zero-bit field" {
1330	}	1343	}
1331		1344
1332	test "@fieldParentPtr tagged union" {	1345	test "@fieldParentPtr tagged union" {
		1346	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1347
1333	const C = union(enum) {	1348	const C = union(enum) {
1334	a: bool,	1349	a: bool,
1335	b: f32,	1350	b: f32,
...	@@ -1463,6 +1478,8 @@ test "@fieldParentPtr tagged union" {	...	@@ -1463,6 +1478,8 @@ test "@fieldParentPtr tagged union" {
1463	}	1478	}
1464		1479
1465	test "@fieldParentPtr untagged union" {	1480	test "@fieldParentPtr untagged union" {
		1481	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1482
1466	const C = union {	1483	const C = union {
1467	a: bool,	1484	a: bool,
1468	b: f32,	1485	b: f32,
...	@@ -1596,6 +1613,8 @@ test "@fieldParentPtr untagged union" {	...	@@ -1596,6 +1613,8 @@ test "@fieldParentPtr untagged union" {
1596	}	1613	}
1597		1614
1598	test "@fieldParentPtr extern union" {	1615	test "@fieldParentPtr extern union" {
		1616	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1617
1599	const C = extern union {	1618	const C = extern union {
1600	a: bool,	1619	a: bool,
1601	b: f32,	1620	b: f32,
...	@@ -1731,6 +1750,7 @@ test "@fieldParentPtr extern union" {	...	@@ -1731,6 +1750,7 @@ test "@fieldParentPtr extern union" {
1731	test "@fieldParentPtr packed union" {	1750	test "@fieldParentPtr packed union" {
1732	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	1751	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1733	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1752	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1753	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1734	if (builtin.target.cpu.arch.endian() == .big) return error.SkipZigTest; // TODO	1754	if (builtin.target.cpu.arch.endian() == .big) return error.SkipZigTest; // TODO
1735		1755
1736	const C = packed union {	1756	const C = packed union {
...	@@ -1868,6 +1888,7 @@ test "@fieldParentPtr packed union" {	...	@@ -1868,6 +1888,7 @@ test "@fieldParentPtr packed union" {
1868	test "@fieldParentPtr tagged union all zero-bit fields" {	1888	test "@fieldParentPtr tagged union all zero-bit fields" {
1869	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	1889	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1870	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	1890	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
		1891	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1871		1892
1872	const C = union(enum) {	1893	const C = union(enum) {
1873	a: u0,	1894	a: u0,

test/behavior/floatop.zig+78

test/behavior/fn.zig+22

test/behavior/fn_delegation.zig+1

...	@@ -34,6 +34,7 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {	...	@@ -34,6 +34,7 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
34	test "fn delegation" {	34	test "fn delegation" {
35	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	35	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		37	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
37		38
38	const foo = Foo{};	39	const foo = Foo{};
39	try expect(foo.one() == 11);	40	try expect(foo.one() == 11);

test/behavior/for.zig+18

test/behavior/generics.zig+19

test/behavior/globals.zig+3

test/behavior/hasdecl.zig+4

...	@@ -12,6 +12,8 @@ const Bar = struct {	...	@@ -12,6 +12,8 @@ const Bar = struct {
12	};	12	};
13		13
14	test "@hasDecl" {	14	test "@hasDecl" {
		15	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		16
15	try expect(@hasDecl(Foo, "public_thing"));	17	try expect(@hasDecl(Foo, "public_thing"));
16	try expect(!@hasDecl(Foo, "private_thing"));	18	try expect(!@hasDecl(Foo, "private_thing"));
17	try expect(!@hasDecl(Foo, "no_thing"));	19	try expect(!@hasDecl(Foo, "no_thing"));
...	@@ -22,6 +24,8 @@ test "@hasDecl" {	...	@@ -22,6 +24,8 @@ test "@hasDecl" {
22	}	24	}
23		25
24	test "@hasDecl using a sliced string literal" {	26	test "@hasDecl using a sliced string literal" {
		27	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		28
25	try expect(@hasDecl(@This(), "std") == true);	29	try expect(@hasDecl(@This(), "std") == true);
26	try expect(@hasDecl(@This(), "std"[0..0]) == false);	30	try expect(@hasDecl(@This(), "std"[0..0]) == false);
27	try expect(@hasDecl(@This(), "std"[0..1]) == false);	31	try expect(@hasDecl(@This(), "std"[0..1]) == false);

test/behavior/if.zig+8

...	@@ -45,6 +45,7 @@ var global_with_err: anyerror!u32 = error.SomeError;	...	@@ -45,6 +45,7 @@ var global_with_err: anyerror!u32 = error.SomeError;
45		45
46	test "unwrap mutable global var" {	46	test "unwrap mutable global var" {
47	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	47	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		48	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
48		49
49	if (global_with_val) \|v\| {	50	if (global_with_val) \|v\| {
50	try expect(v == 0);	51	try expect(v == 0);
...	@@ -82,6 +83,7 @@ test "const result loc, runtime if cond, else unreachable" {	...	@@ -82,6 +83,7 @@ test "const result loc, runtime if cond, else unreachable" {
82	test "if copies its payload" {	83	test "if copies its payload" {
83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	84	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	85	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		86	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
85		87
86	const S = struct {	88	const S = struct {
87	fn doTheTest() !void {	89	fn doTheTest() !void {
...	@@ -118,6 +120,7 @@ test "if peer expressions inferred optional type" {	...	@@ -118,6 +120,7 @@ test "if peer expressions inferred optional type" {
118	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	120	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
119	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	121	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
120	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		123	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
121		124
122	var self: []const u8 = "abcdef";	125	var self: []const u8 = "abcdef";
123	var index: usize = 0;	126	var index: usize = 0;
...	@@ -136,6 +139,7 @@ test "if-else expression with runtime condition result location is inferred opti	...	@@ -136,6 +139,7 @@ test "if-else expression with runtime condition result location is inferred opti
136	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	139	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
137	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	140	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
138	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	141	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		142	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
139		143
140	const A = struct { b: u64, c: u64 };	144	const A = struct { b: u64, c: u64 };
141	var d: bool = true;	145	var d: bool = true;
...	@@ -145,6 +149,8 @@ test "if-else expression with runtime condition result location is inferred opti	...	@@ -145,6 +149,8 @@ test "if-else expression with runtime condition result location is inferred opti
145	}	149	}
146		150
147	test "result location with inferred type ends up being pointer to comptime_int" {	151	test "result location with inferred type ends up being pointer to comptime_int" {
		152	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		153
148	var a: ?u32 = 1234;	154	var a: ?u32 = 1234;
149	var b: u32 = 2000;	155	var b: u32 = 2000;
150	_ = .{ &a, &b };	156	_ = .{ &a, &b };
...	@@ -190,6 +196,8 @@ test "if value shouldn't be load-elided if used later (structs)" {	...	@@ -190,6 +196,8 @@ test "if value shouldn't be load-elided if used later (structs)" {
190	}	196	}
191		197
192	test "if value shouldn't be load-elided if used later (optionals)" {	198	test "if value shouldn't be load-elided if used later (optionals)" {
		199	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		200
193	var a: ?i32 = 1;	201	var a: ?i32 = 1;
194	var b: ?i32 = 1;	202	var b: ?i32 = 1;
195		203

test/behavior/import.zig+4

 @@ -6,18 +6,21 @@ const a_namespace = @import("import/a_namespace.zig");
 test "call fn via namespace lookup" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     try expect(@as(i32, 1234) == a_namespace.foo());
 }
 test "importing the same thing gives the same import" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     try expect(@import("std") == @import("std"));
 }
 test "import in non-toplevel scope" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     const S = struct {
         usingnamespace @import("import/a_namespace.zig");
 @@ -27,6 +30,7 @@ test "import in non-toplevel scope" {
 test "import empty file" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     _ = @import("import/empty.zig");
 }

test/behavior/import_c_keywords.zig+1

...	@@ -33,6 +33,7 @@ test "import c keywords" {	...	@@ -33,6 +33,7 @@ test "import c keywords" {
33	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	33	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
34	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	34	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
35	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest;	35	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest;
		36	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
36		37
37	try std.testing.expect(int == .c_keyword_variable);	38	try std.testing.expect(int == .c_keyword_variable);
38	try std.testing.expect(long == .c_keyword_variable);	39	try std.testing.expect(long == .c_keyword_variable);

test/behavior/incomplete_struct_param_tld.zig+1

...	@@ -23,6 +23,7 @@ fn foo(a: A) i32 {	...	@@ -23,6 +23,7 @@ fn foo(a: A) i32 {
23		23
24	test "incomplete struct param top level declaration" {	24	test "incomplete struct param top level declaration" {
25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		26	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
26		27
27	const a = A{	28	const a = A{
28	.b = B{	29	.b = B{

test/behavior/inline_switch.zig+9

...	@@ -5,6 +5,7 @@ const builtin = @import("builtin");	...	@@ -5,6 +5,7 @@ const builtin = @import("builtin");
5	test "inline scalar prongs" {	5	test "inline scalar prongs" {
6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		8	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8		9
9	var x: usize = 0;	10	var x: usize = 0;
10	switch (x) {	11	switch (x) {
...	@@ -20,6 +21,7 @@ test "inline scalar prongs" {	...	@@ -20,6 +21,7 @@ test "inline scalar prongs" {
20	test "inline prong ranges" {	21	test "inline prong ranges" {
21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		24	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
23		25
24	var x: usize = 0;	26	var x: usize = 0;
25	_ = &x;	27	_ = &x;
...	@@ -35,6 +37,7 @@ const E = enum { a, b, c, d };	...	@@ -35,6 +37,7 @@ const E = enum { a, b, c, d };
35	test "inline switch enums" {	37	test "inline switch enums" {
36	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
37	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	39	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		40	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
38		41
39	var x: E = .a;	42	var x: E = .a;
40	_ = &x;	43	_ = &x;
...	@@ -49,6 +52,7 @@ test "inline switch unions" {	...	@@ -49,6 +52,7 @@ test "inline switch unions" {
49	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	52	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
50	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
51	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	54	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		55	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
52		56
53	var x: U = .a;	57	var x: U = .a;
54	_ = &x;	58	_ = &x;
...	@@ -75,6 +79,7 @@ test "inline switch unions" {	...	@@ -75,6 +79,7 @@ test "inline switch unions" {
75	test "inline else bool" {	79	test "inline else bool" {
76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	80	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
77	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	81	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		82	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
78		83
79	var a = true;	84	var a = true;
80	_ = &a;	85	_ = &a;
...	@@ -87,6 +92,7 @@ test "inline else bool" {	...	@@ -87,6 +92,7 @@ test "inline else bool" {
87	test "inline else error" {	92	test "inline else error" {
88	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	93	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
89	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	94	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		95	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
90		96
91	const Err = error{ a, b, c };	97	const Err = error{ a, b, c };
92	var a = Err.a;	98	var a = Err.a;
...	@@ -100,6 +106,7 @@ test "inline else error" {	...	@@ -100,6 +106,7 @@ test "inline else error" {
100	test "inline else enum" {	106	test "inline else enum" {
101	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	107	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
102	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	108	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		109	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
103		110
104	const E2 = enum(u8) { a = 2, b = 3, c = 4, d = 5 };	111	const E2 = enum(u8) { a = 2, b = 3, c = 4, d = 5 };
105	var a: E2 = .a;	112	var a: E2 = .a;
...	@@ -113,6 +120,7 @@ test "inline else enum" {	...	@@ -113,6 +120,7 @@ test "inline else enum" {
113	test "inline else int with gaps" {	120	test "inline else int with gaps" {
114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	121	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		123	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
116		124
117	var a: u8 = 0;	125	var a: u8 = 0;
118	_ = &a;	126	_ = &a;
...	@@ -131,6 +139,7 @@ test "inline else int with gaps" {	...	@@ -131,6 +139,7 @@ test "inline else int with gaps" {
131	test "inline else int all values" {	139	test "inline else int all values" {
132	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	140	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	141	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		142	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
134		143
135	var a: u2 = 0;	144	var a: u2 = 0;
136	_ = &a;	145	_ = &a;

test/behavior/int128.zig+5

test/behavior/int_comparison_elision.zig+2

...	@@ -4,6 +4,8 @@ const maxInt = std.math.maxInt;	...	@@ -4,6 +4,8 @@ const maxInt = std.math.maxInt;
4	const builtin = @import("builtin");	4	const builtin = @import("builtin");
5		5
6	test "int comparison elision" {	6	test "int comparison elision" {
		7	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		8
7	testIntEdges(u0);	9	testIntEdges(u0);
8	testIntEdges(i0);	10	testIntEdges(i0);
9	testIntEdges(u1);	11	testIntEdges(u1);

test/behavior/int_div.zig+2

...	@@ -6,6 +6,7 @@ test "integer division" {	...	@@ -6,6 +6,7 @@ test "integer division" {
6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
9		10
10	try testDivision();	11	try testDivision();
11	try comptime testDivision();	12	try comptime testDivision();
...	@@ -97,6 +98,7 @@ test "large integer division" {	...	@@ -97,6 +98,7 @@ test "large integer division" {
97	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	98	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
98	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	99	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
99	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	100	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		101	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
100		102
101	{	103	{
102	var numerator: u256 = 99999999999999999997315645440;	104	var numerator: u256 = 99999999999999999997315645440;

test/behavior/ir_block_deps.zig+1

...	@@ -21,6 +21,7 @@ test "ir block deps" {	...	@@ -21,6 +21,7 @@ test "ir block deps" {
21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		24	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
24		25
25	try expect((foo(1) catch unreachable) == 0);	26	try expect((foo(1) catch unreachable) == 0);
26	try expect((foo(2) catch unreachable) == 0);	27	try expect((foo(2) catch unreachable) == 0);

test/behavior/lower_strlit_to_vector.zig+1

...	@@ -6,6 +6,7 @@ test "strlit to vector" {	...	@@ -6,6 +6,7 @@ test "strlit to vector" {
6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	8	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
9		10
10	const strlit = "0123456789abcdef0123456789ABCDEF";	11	const strlit = "0123456789abcdef0123456789ABCDEF";
11	const vec_from_strlit: @Vector(32, u8) = strlit.*;	12	const vec_from_strlit: @Vector(32, u8) = strlit.*;

test/behavior/math.zig+61

test/behavior/maximum_minimum.zig+10

test/behavior/member_func.zig+2

...	@@ -31,6 +31,7 @@ test "standard field calls" {	...	@@ -31,6 +31,7 @@ test "standard field calls" {
31	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	31	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
33	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	33	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		34	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
34		35
35	try expect(HasFuncs.one(0) == 1);	36	try expect(HasFuncs.one(0) == 1);
36	try expect(HasFuncs.two(0) == 2);	37	try expect(HasFuncs.two(0) == 2);
...	@@ -75,6 +76,7 @@ test "@field field calls" {	...	@@ -75,6 +76,7 @@ test "@field field calls" {
75	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
76	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	77	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
77	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	78	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		79	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
78		80
79	try expect(@field(HasFuncs, "one")(0) == 1);	81	try expect(@field(HasFuncs, "one")(0) == 1);
80	try expect(@field(HasFuncs, "two")(0) == 2);	82	try expect(@field(HasFuncs, "two")(0) == 2);

test/behavior/memcpy.zig+4

test/behavior/memset.zig+9

test/behavior/merge_error_sets.zig+1

...	@@ -13,6 +13,7 @@ fn foo() C!void {	...	@@ -13,6 +13,7 @@ fn foo() C!void {
13		13
14	test "merge error sets" {	14	test "merge error sets" {
15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		16	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
16		17
17	if (foo()) {	18	if (foo()) {
18	@panic("unexpected");	19	@panic("unexpected");

test/behavior/muladd.zig+10

test/behavior/multiple_externs_with_conflicting_types.zig+1

...	@@ -16,6 +16,7 @@ test "call extern function defined with conflicting type" {	...	@@ -16,6 +16,7 @@ test "call extern function defined with conflicting type" {
16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
18	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	18	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		19	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
19		20
20	@import("conflicting_externs/a.zig").issue529(null);	21	@import("conflicting_externs/a.zig").issue529(null);
21	issue529(null);	22	issue529(null);

test/behavior/namespace_depends_on_compile_var.zig+1

...	@@ -4,6 +4,7 @@ const expect = std.testing.expect;	...	@@ -4,6 +4,7 @@ const expect = std.testing.expect;
4		4
5	test "namespace depends on compile var" {	5	test "namespace depends on compile var" {
6	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	6	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		7	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7		8
8	if (some_namespace.a_bool) {	9	if (some_namespace.a_bool) {
9	try expect(some_namespace.a_bool);	10	try expect(some_namespace.a_bool);

test/behavior/nan.zig+1

...	@@ -26,6 +26,7 @@ test "nan memory equality" {	...	@@ -26,6 +26,7 @@ test "nan memory equality" {
26	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	26	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
27	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;	27	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
28	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	28	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		29	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
29		30
30	// signaled	31	// signaled
31	try testing.expect(mem.eql(u8, mem.asBytes(&snan_u16), mem.asBytes(&snan_f16)));	32	try testing.expect(mem.eql(u8, mem.asBytes(&snan_u16), mem.asBytes(&snan_f16)));

test/behavior/null.zig+8

test/behavior/optional.zig+27

test/behavior/packed-struct.zig+30

test/behavior/packed-union.zig+5

test/behavior/pointers.zig+17

test/behavior/popcount.zig+3

test/behavior/prefetch.zig+1

...	@@ -3,6 +3,7 @@ const std = @import("std");	...	@@ -3,6 +3,7 @@ const std = @import("std");
3		3
4	test "@prefetch()" {	4	test "@prefetch()" {
5	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	5	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		6	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
6		7
7	var a: [2]u32 = .{ 42, 42 };	8	var a: [2]u32 = .{ 42, 42 };
8	var a_len = a.len;	9	var a_len = a.len;

test/behavior/ptrcast.zig+3

test/behavior/ptrfromint.zig+5

test/behavior/pub_enum.zig+2

...	@@ -4,6 +4,7 @@ const expect = @import("std").testing.expect;	...	@@ -4,6 +4,7 @@ const expect = @import("std").testing.expect;
4		4
5	test "pub enum" {	5	test "pub enum" {
6	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	6	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		7	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7		8
8	try pubEnumTest(other.APubEnum.Two);	9	try pubEnumTest(other.APubEnum.Two);
9	}	10	}
...	@@ -13,6 +14,7 @@ fn pubEnumTest(foo: other.APubEnum) !void {	...	@@ -13,6 +14,7 @@ fn pubEnumTest(foo: other.APubEnum) !void {
13		14
14	test "cast with imported symbol" {	15	test "cast with imported symbol" {
15	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	16	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		17	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
16		18
17	try expect(@as(other.size_t, 42) == 42);	19	try expect(@as(other.size_t, 42) == 42);
18	}	20	}

test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig+1

...	@@ -8,6 +8,7 @@ test "reference a variable in an if after an if in the 2nd switch prong" {	...	@@ -8,6 +8,7 @@ test "reference a variable in an if after an if in the 2nd switch prong" {
8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11		12
12	try foo(true, Num.Two, false, "aoeu");	13	try foo(true, Num.Two, false, "aoeu");
13	try expect(!ok);	14	try expect(!ok);

test/behavior/reflection.zig+1

...	@@ -28,6 +28,7 @@ fn dummy(a: bool, b: i32, c: f32) i32 {	...	@@ -28,6 +28,7 @@ fn dummy(a: bool, b: i32, c: f32) i32 {
28	test "reflection: @field" {	28	test "reflection: @field" {
29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		31	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
31		32
32	var f = Foo{	33	var f = Foo{
33	.one = 42,	34	.one = 42,

test/behavior/return_address.zig+1

...	@@ -10,6 +10,7 @@ test "return address" {	...	@@ -10,6 +10,7 @@ test "return address" {
10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		13	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13		14
14	_ = retAddr();	15	_ = retAddr();
15	// TODO: #14938	16	// TODO: #14938

test/behavior/saturating_arithmetic.zig+7

test/behavior/select.zig+2

...	@@ -9,6 +9,7 @@ test "@select vectors" {	...	@@ -9,6 +9,7 @@ test "@select vectors" {
9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		12	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12		13
13	try comptime selectVectors();	14	try comptime selectVectors();
14	try selectVectors();	15	try selectVectors();
...	@@ -39,6 +40,7 @@ test "@select arrays" {	...	@@ -39,6 +40,7 @@ test "@select arrays" {
39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	40	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
41	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	42	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		43	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
42	if (builtin.zig_backend == .stage2_x86_64 and	44	if (builtin.zig_backend == .stage2_x86_64 and
43	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx2)) return error.SkipZigTest;	45	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx2)) return error.SkipZigTest;
44		46

test/behavior/shuffle.zig+3

test/behavior/sizeof_and_typeof.zig+5

test/behavior/slice.zig+30

test/behavior/src.zig+3

...	@@ -17,6 +17,7 @@ test "@src" {	...	@@ -17,6 +17,7 @@ test "@src" {
17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		20	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
20		21
21	try doTheTest();	22	try doTheTest();
22	}	23	}
...	@@ -37,6 +38,8 @@ test "@src used as a comptime parameter" {	...	@@ -37,6 +38,8 @@ test "@src used as a comptime parameter" {
37	}	38	}
38		39
39	test "@src in tuple passed to anytype function" {	40	test "@src in tuple passed to anytype function" {
		41	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		42
40	const S = struct {	43	const S = struct {
41	fn Foo(a: anytype) u32 {	44	fn Foo(a: anytype) u32 {
42	return a[0].line;	45	return a[0].line;

test/behavior/string_literals.zig+3

test/behavior/struct.zig+75

...	@@ -68,6 +68,7 @@ const SmallStruct = struct {	...	@@ -68,6 +68,7 @@ const SmallStruct = struct {
68		68
69	test "lower unnamed constants" {	69	test "lower unnamed constants" {
70	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	70	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		71	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
71		72
72	var foo = SmallStruct{ .a = 1, .b = 255 };	73	var foo = SmallStruct{ .a = 1, .b = 255 };
73	try expect(foo.first() == 1);	74	try expect(foo.first() == 1);
...	@@ -91,6 +92,7 @@ test "structs" {	...	@@ -91,6 +92,7 @@ test "structs" {
91	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	92	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
92	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	93	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
93	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	94	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		95	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
94		96
95	var foo: StructFoo = undefined;	97	var foo: StructFoo = undefined;
96	@memset(@as([*]u8, @ptrCast(&foo))[0..@sizeOf(StructFoo)], 0);	98	@memset(@as([*]u8, @ptrCast(&foo))[0..@sizeOf(StructFoo)], 0);
...	@@ -109,6 +111,7 @@ fn testMutation(foo: *StructFoo) void {	...	@@ -109,6 +111,7 @@ fn testMutation(foo: *StructFoo) void {
109		111
110	test "struct byval assign" {	112	test "struct byval assign" {
111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	113	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		114	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
112		115
113	var foo1: StructFoo = undefined;	116	var foo1: StructFoo = undefined;
114	var foo2: StructFoo = undefined;	117	var foo2: StructFoo = undefined;
...	@@ -173,6 +176,7 @@ const MemberFnTestFoo = struct {	...	@@ -173,6 +176,7 @@ const MemberFnTestFoo = struct {
173		176
174	test "call member function directly" {	177	test "call member function directly" {
175	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	178	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		179	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
176		180
177	const instance = MemberFnTestFoo{ .x = 1234 };	181	const instance = MemberFnTestFoo{ .x = 1234 };
178	const result = MemberFnTestFoo.member(instance);	182	const result = MemberFnTestFoo.member(instance);
...	@@ -181,6 +185,7 @@ test "call member function directly" {	...	@@ -181,6 +185,7 @@ test "call member function directly" {
181		185
182	test "store member function in variable" {	186	test "store member function in variable" {
183	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	187	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		188	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
184		189
185	const instance = MemberFnTestFoo{ .x = 1234 };	190	const instance = MemberFnTestFoo{ .x = 1234 };
186	const memberFn = MemberFnTestFoo.member;	191	const memberFn = MemberFnTestFoo.member;
...	@@ -202,6 +207,7 @@ const MemberFnRand = struct {	...	@@ -202,6 +207,7 @@ const MemberFnRand = struct {
202	test "return struct byval from function" {	207	test "return struct byval from function" {
203	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	208	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
204	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	209	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		210	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
205		211
206	const Bar = struct {	212	const Bar = struct {
207	x: i32,	213	x: i32,
...	@@ -250,6 +256,7 @@ test "usingnamespace within struct scope" {	...	@@ -250,6 +256,7 @@ test "usingnamespace within struct scope" {
250	test "struct field init with catch" {	256	test "struct field init with catch" {
251	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	257	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
252	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	258	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		259	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
253		260
254	const S = struct {	261	const S = struct {
255	fn doTheTest() !void {	262	fn doTheTest() !void {
...	@@ -293,6 +300,7 @@ const Val = struct {	...	@@ -293,6 +300,7 @@ const Val = struct {
293	test "struct point to self" {	300	test "struct point to self" {
294	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	301	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
295	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	302	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		303	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
296		304
297	var root: Node = undefined;	305	var root: Node = undefined;
298	root.val.x = 1;	306	root.val.x = 1;
...	@@ -347,6 +355,7 @@ test "self-referencing struct via array member" {	...	@@ -347,6 +355,7 @@ test "self-referencing struct via array member" {
347	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	355	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
348	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	356	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	357	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		358	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
350		359
351	const T = struct {	360	const T = struct {
352	children: [1]*@This(),	361	children: [1]*@This(),
...	@@ -369,6 +378,7 @@ const EmptyStruct = struct {	...	@@ -369,6 +378,7 @@ const EmptyStruct = struct {
369		378
370	test "align 1 field before self referential align 8 field as slice return type" {	379	test "align 1 field before self referential align 8 field as slice return type" {
371	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	380	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		381	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
372		382
373	const result = alloc(Expr);	383	const result = alloc(Expr);
374	try expect(result.len == 0);	384	try expect(result.len == 0);
...	@@ -393,6 +403,7 @@ test "packed struct" {	...	@@ -393,6 +403,7 @@ test "packed struct" {
393	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	403	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
394	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	404	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
395	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	405	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		406	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
396		407
397	var foo = APackedStruct{	408	var foo = APackedStruct{
398	.x = 1,	409	.x = 1,
...	@@ -417,6 +428,7 @@ test "packed struct 24bits" {	...	@@ -417,6 +428,7 @@ test "packed struct 24bits" {
417	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	428	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
418	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	429	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
419	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	430	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		431	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
420	if (builtin.cpu.arch == .wasm32) return error.SkipZigTest; // TODO	432	if (builtin.cpu.arch == .wasm32) return error.SkipZigTest; // TODO
421	if (comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; // TODO	433	if (comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; // TODO
422	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	434	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -463,6 +475,7 @@ test "runtime struct initialization of bitfield" {	...	@@ -463,6 +475,7 @@ test "runtime struct initialization of bitfield" {
463	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	475	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
464	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	476	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
465	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	477	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		478	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
466		479
467	const s1 = Nibbles{	480	const s1 = Nibbles{
468	.x = x1,	481	.x = x1,
...	@@ -502,6 +515,7 @@ test "packed struct fields are ordered from LSB to MSB" {	...	@@ -502,6 +515,7 @@ test "packed struct fields are ordered from LSB to MSB" {
502	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	515	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
503	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	516	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
504	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	517	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		518	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
505		519
506	var all: u64 = 0x7765443322221111;	520	var all: u64 = 0x7765443322221111;
507	var bytes: [8]u8 align(@alignOf(Bitfields)) = undefined;	521	var bytes: [8]u8 align(@alignOf(Bitfields)) = undefined;
...	@@ -522,6 +536,7 @@ test "implicit cast packed struct field to const ptr" {	...	@@ -522,6 +536,7 @@ test "implicit cast packed struct field to const ptr" {
522	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	536	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
523	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	537	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
524	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	538	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		539	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
525		540
526	const LevelUpMove = packed struct {	541	const LevelUpMove = packed struct {
527	move_id: u9,	542	move_id: u9,
...	@@ -557,6 +572,7 @@ test "packed struct with non-ABI-aligned field" {	...	@@ -557,6 +572,7 @@ test "packed struct with non-ABI-aligned field" {
557	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	572	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
558	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	573	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
559	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	574	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		575	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
560		576
561	const S = packed struct {	577	const S = packed struct {
562	x: u9,	578	x: u9,
...	@@ -586,6 +602,7 @@ test "bit field access" {	...	@@ -586,6 +602,7 @@ test "bit field access" {
586	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	602	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
587	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	603	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
588	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	604	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		605	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
589		606
590	var data = bit_field_1;	607	var data = bit_field_1;
591	try expect(getA(&data) == 1);	608	try expect(getA(&data) == 1);
...	@@ -616,6 +633,7 @@ fn getC(data: *const BitField1) u2 {	...	@@ -616,6 +633,7 @@ fn getC(data: *const BitField1) u2 {
616	test "default struct initialization fields" {	633	test "default struct initialization fields" {
617	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	634	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
618	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	635	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		636	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
619		637
620	const S = struct {	638	const S = struct {
621	a: i32 = 1234,	639	a: i32 = 1234,
...	@@ -642,6 +660,7 @@ test "packed array 24bits" {	...	@@ -642,6 +660,7 @@ test "packed array 24bits" {
642	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	660	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
643	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	661	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
644	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	662	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		663	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
645		664
646	comptime {	665	comptime {
647	try expect(@sizeOf([9]Foo32Bits) == 9 * 4);	666	try expect(@sizeOf([9]Foo32Bits) == 9 * 4);
...	@@ -709,6 +728,7 @@ test "pointer to packed struct member in a stack variable" {	...	@@ -709,6 +728,7 @@ test "pointer to packed struct member in a stack variable" {
709	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	728	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
710	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	729	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
711	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	730	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		731	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
712		732
713	const S = packed struct {	733	const S = packed struct {
714	a: u2,	734	a: u2,
...	@@ -761,6 +781,7 @@ test "packed struct with fp fields" {	...	@@ -761,6 +781,7 @@ test "packed struct with fp fields" {
761	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	781	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
762	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	782	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
763	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	783	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		784	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
764		785
765	const S = packed struct {	786	const S = packed struct {
766	data0: f32,	787	data0: f32,
...	@@ -788,6 +809,7 @@ test "fn with C calling convention returns struct by value" {	...	@@ -788,6 +809,7 @@ test "fn with C calling convention returns struct by value" {
788	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	809	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
789	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	810	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
790	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	811	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		812	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
791		813
792	const S = struct {	814	const S = struct {
793	fn entry() !void {	815	fn entry() !void {
...	@@ -815,6 +837,7 @@ test "non-packed struct with u128 entry in union" {	...	@@ -815,6 +837,7 @@ test "non-packed struct with u128 entry in union" {
815	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	837	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
816	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	838	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
817	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	839	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
		840	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
818		841
819	const U = union(enum) {	842	const U = union(enum) {
820	Num: u128,	843	Num: u128,
...	@@ -863,6 +886,7 @@ test "packed struct field passed to generic function" {	...	@@ -863,6 +886,7 @@ test "packed struct field passed to generic function" {
863	test "anonymous struct literal syntax" {	886	test "anonymous struct literal syntax" {
864	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	887	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
865	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	888	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		889	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
866		890
867	const S = struct {	891	const S = struct {
868	const Point = struct {	892	const Point = struct {
...	@@ -885,6 +909,8 @@ test "anonymous struct literal syntax" {	...	@@ -885,6 +909,8 @@ test "anonymous struct literal syntax" {
885	}	909	}
886		910
887	test "fully anonymous struct" {	911	test "fully anonymous struct" {
		912	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		913
888	const S = struct {	914	const S = struct {
889	fn doTheTest() !void {	915	fn doTheTest() !void {
890	try dump(.{	916	try dump(.{
...	@@ -907,6 +933,8 @@ test "fully anonymous struct" {	...	@@ -907,6 +933,8 @@ test "fully anonymous struct" {
907	}	933	}
908		934
909	test "fully anonymous list literal" {	935	test "fully anonymous list literal" {
		936	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		937
910	const S = struct {	938	const S = struct {
911	fn doTheTest() !void {	939	fn doTheTest() !void {
912	try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });	940	try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
...	@@ -954,6 +982,7 @@ test "tuple element initialized with fn call" {	...	@@ -954,6 +982,7 @@ test "tuple element initialized with fn call" {
954	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	982	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
955	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	983	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
956	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	984	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		985	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
957		986
958	const S = struct {	987	const S = struct {
959	fn doTheTest() !void {	988	fn doTheTest() !void {
...	@@ -972,6 +1001,7 @@ test "struct with union field" {	...	@@ -972,6 +1001,7 @@ test "struct with union field" {
972	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1001	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
973	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1002	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
974	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1003	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1004	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
975		1005
976	const Value = struct {	1006	const Value = struct {
977	ref: u32 = 2,	1007	ref: u32 = 2,
...	@@ -993,6 +1023,7 @@ test "struct with 0-length union array field" {	...	@@ -993,6 +1023,7 @@ test "struct with 0-length union array field" {
993	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1023	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
994	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1024	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
995	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1025	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1026	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
996		1027
997	const U = union {	1028	const U = union {
998	a: u32,	1029	a: u32,
...	@@ -1013,6 +1044,7 @@ test "type coercion of anon struct literal to struct" {	...	@@ -1013,6 +1044,7 @@ test "type coercion of anon struct literal to struct" {
1013	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1044	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1014	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1045	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1015	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1046	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1047	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1016		1048
1017	const S = struct {	1049	const S = struct {
1018	const S2 = struct {	1050	const S2 = struct {
...	@@ -1052,6 +1084,7 @@ test "type coercion of pointer to anon struct literal to pointer to struct" {	...	@@ -1052,6 +1084,7 @@ test "type coercion of pointer to anon struct literal to pointer to struct" {
1052	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1084	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1053	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1085	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1054	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1086	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1087	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1055		1088
1056	const S = struct {	1089	const S = struct {
1057	const S2 = struct {	1090	const S2 = struct {
...	@@ -1091,6 +1124,7 @@ test "packed struct with undefined initializers" {	...	@@ -1091,6 +1124,7 @@ test "packed struct with undefined initializers" {
1091	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1124	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1092	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1125	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1093	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1126	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1127	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1094		1128
1095	const S = struct {	1129	const S = struct {
1096	const P = packed struct {	1130	const P = packed struct {
...	@@ -1120,6 +1154,7 @@ test "packed struct with undefined initializers" {	...	@@ -1120,6 +1154,7 @@ test "packed struct with undefined initializers" {
1120	test "for loop over pointers to struct, getting field from struct pointer" {	1154	test "for loop over pointers to struct, getting field from struct pointer" {
1121	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1155	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1156	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1157	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1123		1158
1124	const S = struct {	1159	const S = struct {
1125	const Foo = struct {	1160	const Foo = struct {
...	@@ -1160,6 +1195,7 @@ test "anon init through error unions and optionals" {	...	@@ -1160,6 +1195,7 @@ test "anon init through error unions and optionals" {
1160	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1195	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1161	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1196	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1162	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1197	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1198	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1163		1199
1164	const S = struct {	1200	const S = struct {
1165	a: u32,	1201	a: u32,
...	@@ -1187,6 +1223,7 @@ test "anon init through optional" {	...	@@ -1187,6 +1223,7 @@ test "anon init through optional" {
1187	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1223	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1188	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1224	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1189	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1225	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1226	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1190		1227
1191	const S = struct {	1228	const S = struct {
1192	a: u32,	1229	a: u32,
...	@@ -1207,6 +1244,7 @@ test "anon init through error union" {	...	@@ -1207,6 +1244,7 @@ test "anon init through error union" {
1207	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1244	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1208	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1245	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1209	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1246	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1247	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1210		1248
1211	const S = struct {	1249	const S = struct {
1212	a: u32,	1250	a: u32,
...	@@ -1226,6 +1264,7 @@ test "typed init through error unions and optionals" {	...	@@ -1226,6 +1264,7 @@ test "typed init through error unions and optionals" {
1226	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1264	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1227	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1265	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1228	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1266	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1267	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1229		1268
1230	const S = struct {	1269	const S = struct {
1231	a: u32,	1270	a: u32,
...	@@ -1260,6 +1299,7 @@ test "initialize struct with empty literal" {	...	@@ -1260,6 +1299,7 @@ test "initialize struct with empty literal" {
1260		1299
1261	test "loading a struct pointer perfoms a copy" {	1300	test "loading a struct pointer perfoms a copy" {
1262	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1301	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1302	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1263		1303
1264	const S = struct {	1304	const S = struct {
1265	a: i32,	1305	a: i32,
...	@@ -1288,6 +1328,7 @@ test "packed struct aggregate init" {	...	@@ -1288,6 +1328,7 @@ test "packed struct aggregate init" {
1288	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1328	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1289	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1329	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1290	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1330	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1331	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1291		1332
1292	const S = struct {	1333	const S = struct {
1293	fn foo(a: i2, b: i6) u8 {	1334	fn foo(a: i2, b: i6) u8 {
...	@@ -1347,6 +1388,7 @@ test "store to comptime field" {	...	@@ -1347,6 +1388,7 @@ test "store to comptime field" {
1347	test "struct field init value is size of the struct" {	1388	test "struct field init value is size of the struct" {
1348	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1389	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1390	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1391	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1350		1392
1351	const namespace = struct {	1393	const namespace = struct {
1352	const S = extern struct {	1394	const S = extern struct {
...	@@ -1364,6 +1406,7 @@ test "under-aligned struct field" {	...	@@ -1364,6 +1406,7 @@ test "under-aligned struct field" {
1364	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1406	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1365	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1407	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1366	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1408	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1409	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1367		1410
1368	const U = extern union {	1411	const U = extern union {
1369	fd: i32,	1412	fd: i32,
...	@@ -1386,6 +1429,7 @@ test "fieldParentPtr of a zero-bit field" {	...	@@ -1386,6 +1429,7 @@ test "fieldParentPtr of a zero-bit field" {
1386	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1429	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1387	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1430	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1388	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1431	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1432	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1389		1433
1390	const S = struct {	1434	const S = struct {
1391	fn testStruct(comptime A: type) !void {	1435	fn testStruct(comptime A: type) !void {
...	@@ -1444,6 +1488,8 @@ test "struct field has a pointer to an aligned version of itself" {	...	@@ -1444,6 +1488,8 @@ test "struct field has a pointer to an aligned version of itself" {
1444	}	1488	}
1445		1489
1446	test "struct has only one reference" {	1490	test "struct has only one reference" {
		1491	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1492
1447	const S = struct {	1493	const S = struct {
1448	fn optionalStructParam(_: ?struct { x: u8 }) void {}	1494	fn optionalStructParam(_: ?struct { x: u8 }) void {}
1449	fn errorUnionStructParam(_: error{}!struct { x: u8 }) void {}	1495	fn errorUnionStructParam(_: error{}!struct { x: u8 }) void {}
...	@@ -1493,6 +1539,7 @@ test "no dependency loop on pointer to optional struct" {	...	@@ -1493,6 +1539,7 @@ test "no dependency loop on pointer to optional struct" {
1493	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1539	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1494	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1540	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1495	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1541	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1542	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1496		1543
1497	const S = struct {	1544	const S = struct {
1498	const A = struct { b: B };	1545	const A = struct { b: B };
...	@@ -1514,6 +1561,7 @@ test "discarded struct initialization works as expected" {	...	@@ -1514,6 +1561,7 @@ test "discarded struct initialization works as expected" {
1514	test "function pointer in struct returns the struct" {	1561	test "function pointer in struct returns the struct" {
1515	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1562	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1516	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1563	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1564	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1517		1565
1518	const A = struct {	1566	const A = struct {
1519	const A = @This();	1567	const A = @This();
...	@@ -1549,6 +1597,7 @@ test "no dependency loop on optional field wrapped in generic function" {	...	@@ -1549,6 +1597,7 @@ test "no dependency loop on optional field wrapped in generic function" {
1549	test "optional field init with tuple" {	1597	test "optional field init with tuple" {
1550	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1598	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1551	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1599	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		1600	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1552		1601
1553	const S = struct {	1602	const S = struct {
1554	a: ?struct { b: u32 },	1603	a: ?struct { b: u32 },
...	@@ -1563,6 +1612,7 @@ test "optional field init with tuple" {	...	@@ -1563,6 +1612,7 @@ test "optional field init with tuple" {
1563		1612
1564	test "if inside struct init inside if" {	1613	test "if inside struct init inside if" {
1565	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1614	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		1615	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1566		1616
1567	const MyStruct = struct { x: u32 };	1617	const MyStruct = struct { x: u32 };
1568	const b: u32 = 5;	1618	const b: u32 = 5;
...	@@ -1682,6 +1732,7 @@ test "extern struct field pointer has correct alignment" {	...	@@ -1682,6 +1732,7 @@ test "extern struct field pointer has correct alignment" {
1682	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1732	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1683	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1733	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1684	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1734	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1735	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1685		1736
1686	const S = struct {	1737	const S = struct {
1687	fn doTheTest() !void {	1738	fn doTheTest() !void {
...	@@ -1719,6 +1770,8 @@ test "extern struct field pointer has correct alignment" {	...	@@ -1719,6 +1770,8 @@ test "extern struct field pointer has correct alignment" {
1719	}	1770	}
1720		1771
1721	test "packed struct field in anonymous struct" {	1772	test "packed struct field in anonymous struct" {
		1773	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1774
1722	const T = packed struct {	1775	const T = packed struct {
1723	f1: bool = false,	1776	f1: bool = false,
1724	};	1777	};
...	@@ -1730,6 +1783,8 @@ fn countFields(v: anytype) usize {	...	@@ -1730,6 +1783,8 @@ fn countFields(v: anytype) usize {
1730	}	1783	}
1731		1784
1732	test "struct init with no result pointer sets field result types" {	1785	test "struct init with no result pointer sets field result types" {
		1786	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1787
1733	const S = struct {	1788	const S = struct {
1734	// A function parameter has a result type, but no result pointer.	1789	// A function parameter has a result type, but no result pointer.
1735	fn f(s: struct { x: u32 }) u32 {	1790	fn f(s: struct { x: u32 }) u32 {
...	@@ -1744,6 +1799,8 @@ test "struct init with no result pointer sets field result types" {	...	@@ -1744,6 +1799,8 @@ test "struct init with no result pointer sets field result types" {
1744	}	1799	}
1745		1800
1746	test "runtime side-effects in comptime-known struct init" {	1801	test "runtime side-effects in comptime-known struct init" {
		1802	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1803
1747	var side_effects: u4 = 0;	1804	var side_effects: u4 = 0;
1748	const S = struct { a: u4, b: u4, c: u4, d: u4 };	1805	const S = struct { a: u4, b: u4, c: u4, d: u4 };
1749	const init = S{	1806	const init = S{
...	@@ -1769,6 +1826,8 @@ test "runtime side-effects in comptime-known struct init" {	...	@@ -1769,6 +1826,8 @@ test "runtime side-effects in comptime-known struct init" {
1769	}	1826	}
1770		1827
1771	test "pointer to struct initialized through reference to anonymous initializer provides result types" {	1828	test "pointer to struct initialized through reference to anonymous initializer provides result types" {
		1829	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1830
1772	const S = struct { a: u8, b: u16, c: *const anyopaque };	1831	const S = struct { a: u8, b: u16, c: *const anyopaque };
1773	var my_u16: u16 = 0xABCD;	1832	var my_u16: u16 = 0xABCD;
1774	_ = &my_u16;	1833	_ = &my_u16;
...	@@ -1804,6 +1863,8 @@ test "comptimeness of optional and error union payload is analyzed properly" {	...	@@ -1804,6 +1863,8 @@ test "comptimeness of optional and error union payload is analyzed properly" {
1804	}	1863	}
1805		1864
1806	test "initializer uses own alignment" {	1865	test "initializer uses own alignment" {
		1866	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1867
1807	const S = struct {	1868	const S = struct {
1808	x: u32 = @alignOf(@This()) + 1,	1869	x: u32 = @alignOf(@This()) + 1,
1809	};	1870	};
...	@@ -1815,6 +1876,8 @@ test "initializer uses own alignment" {	...	@@ -1815,6 +1876,8 @@ test "initializer uses own alignment" {
1815	}	1876	}
1816		1877
1817	test "initializer uses own size" {	1878	test "initializer uses own size" {
		1879	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1880
1818	const S = struct {	1881	const S = struct {
1819	x: u32 = @sizeOf(@This()) + 1,	1882	x: u32 = @sizeOf(@This()) + 1,
1820	};	1883	};
...	@@ -1826,6 +1889,8 @@ test "initializer uses own size" {	...	@@ -1826,6 +1889,8 @@ test "initializer uses own size" {
1826	}	1889	}
1827		1890
1828	test "initializer takes a pointer to a variable inside its struct" {	1891	test "initializer takes a pointer to a variable inside its struct" {
		1892	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1893
1829	const namespace = struct {	1894	const namespace = struct {
1830	const S = struct {	1895	const S = struct {
1831	s: *S = &S.instance,	1896	s: *S = &S.instance,
...	@@ -1844,6 +1909,8 @@ test "initializer takes a pointer to a variable inside its struct" {	...	@@ -1844,6 +1909,8 @@ test "initializer takes a pointer to a variable inside its struct" {
1844	}	1909	}
1845		1910
1846	test "circular dependency through pointer field of a struct" {	1911	test "circular dependency through pointer field of a struct" {
		1912	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1913
1847	const S = struct {	1914	const S = struct {
1848	const StructInner = extern struct {	1915	const StructInner = extern struct {
1849	outer: StructOuter = std.mem.zeroes(StructOuter),	1916	outer: StructOuter = std.mem.zeroes(StructOuter),
...	@@ -1865,6 +1932,8 @@ test "circular dependency through pointer field of a struct" {	...	@@ -1865,6 +1932,8 @@ test "circular dependency through pointer field of a struct" {
1865	}	1932	}
1866		1933
1867	test "field calls do not force struct field init resolution" {	1934	test "field calls do not force struct field init resolution" {
		1935	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1936
1868	const S = struct {	1937	const S = struct {
1869	x: u32 = blk: {	1938	x: u32 = blk: {
1870	_ = @TypeOf(make().dummyFn()); // runtime field call - S not fully resolved - dummyFn call should not force field init resolution	1939	_ = @TypeOf(make().dummyFn()); // runtime field call - S not fully resolved - dummyFn call should not force field init resolution
...	@@ -1914,6 +1983,7 @@ test "assign to slice.len of global variable" {	...	@@ -1914,6 +1983,7 @@ test "assign to slice.len of global variable" {
1914	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1983	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1915	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1984	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1916	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1985	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1986	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1917		1987
1918	const S = struct {	1988	const S = struct {
1919	const allocator = std.testing.allocator;	1989	const allocator = std.testing.allocator;
...	@@ -1964,6 +2034,7 @@ test "runtime call in nested initializer" {	...	@@ -1964,6 +2034,7 @@ test "runtime call in nested initializer" {
1964	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	2034	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1965	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	2035	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1966	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2036	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		2037	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1967		2038
1968	const Holder = struct {	2039	const Holder = struct {
1969	array: []const u8,	2040	array: []const u8,
...	@@ -1996,6 +2067,7 @@ test "runtime value in nested initializer passed as pointer to function" {	...	@@ -1996,6 +2067,7 @@ test "runtime value in nested initializer passed as pointer to function" {
1996	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	2067	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1997	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	2068	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1998	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2069	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		2070	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1999		2071
2000	const Bar = struct {	2072	const Bar = struct {
2001	b: u32,	2073	b: u32,
...	@@ -2070,6 +2142,7 @@ test "assignment of field with padding" {	...	@@ -2070,6 +2142,7 @@ test "assignment of field with padding" {
2070	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	2142	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2071	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2072	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2144	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		2145	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2073		2146
2074	const Mesh = extern struct {	2147	const Mesh = extern struct {
2075	id: u32,	2148	id: u32,
...	@@ -2100,6 +2173,7 @@ test "initiate global variable with runtime value" {	...	@@ -2100,6 +2173,7 @@ test "initiate global variable with runtime value" {
2100	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	2173	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2101	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2174	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2102	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2175	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		2176	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2103		2177
2104	const S = struct {	2178	const S = struct {
2105	field: i32,	2179	field: i32,
...	@@ -2118,6 +2192,7 @@ test "initiate global variable with runtime value" {	...	@@ -2118,6 +2192,7 @@ test "initiate global variable with runtime value" {
2118	test "struct containing optional pointer to array of @This()" {	2192	test "struct containing optional pointer to array of @This()" {
2119	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;	2193	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
2120	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	2194	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		2195	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2121		2196
2122	const S = struct {	2197	const S = struct {
2123	x: ?*const [1]@This(),	2198	x: ?*const [1]@This(),

test/behavior/struct_contains_null_ptr_itself.zig+1

...	@@ -5,6 +5,7 @@ const builtin = @import("builtin");	...	@@ -5,6 +5,7 @@ const builtin = @import("builtin");
5	test "struct contains null pointer which contains original struct" {	5	test "struct contains null pointer which contains original struct" {
6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		8	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8		9
9	var x: ?*NodeLineComment = null;	10	var x: ?*NodeLineComment = null;
10	_ = &x;	11	_ = &x;

test/behavior/struct_contains_slice_of_itself.zig+2

...	@@ -13,6 +13,7 @@ const NodeAligned = struct {	...	@@ -13,6 +13,7 @@ const NodeAligned = struct {
13		13
14	test "struct contains slice of itself" {	14	test "struct contains slice of itself" {
15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		16	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
16		17
17	var other_nodes = [_]Node{	18	var other_nodes = [_]Node{
18	Node{	19	Node{
...	@@ -53,6 +54,7 @@ test "struct contains slice of itself" {	...	@@ -53,6 +54,7 @@ test "struct contains slice of itself" {
53	test "struct contains aligned slice of itself" {	54	test "struct contains aligned slice of itself" {
54	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	55	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		57	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
56		58
57	var other_nodes = [_]NodeAligned{	59	var other_nodes = [_]NodeAligned{
58	NodeAligned{	60	NodeAligned{

test/behavior/switch.zig+43

...	@@ -7,6 +7,7 @@ const expectEqual = std.testing.expectEqual;	...	@@ -7,6 +7,7 @@ const expectEqual = std.testing.expectEqual;
7		7
8	test "switch with numbers" {	8	test "switch with numbers" {
9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10		11
11	try testSwitchWithNumbers(13);	12	try testSwitchWithNumbers(13);
12	}	13	}
...	@@ -22,6 +23,7 @@ fn testSwitchWithNumbers(x: u32) !void {	...	@@ -22,6 +23,7 @@ fn testSwitchWithNumbers(x: u32) !void {
22		23
23	test "switch with all ranges" {	24	test "switch with all ranges" {
24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		26	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
25		27
26	try expect(testSwitchWithAllRanges(50, 3) == 1);	28	try expect(testSwitchWithAllRanges(50, 3) == 1);
27	try expect(testSwitchWithAllRanges(101, 0) == 2);	29	try expect(testSwitchWithAllRanges(101, 0) == 2);
...	@@ -55,6 +57,7 @@ test "implicit comptime switch" {	...	@@ -55,6 +57,7 @@ test "implicit comptime switch" {
55		57
56	test "switch on enum" {	58	test "switch on enum" {
57	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	59	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		60	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
58		61
59	const fruit = Fruit.Orange;	62	const fruit = Fruit.Orange;
60	nonConstSwitchOnEnum(fruit);	63	nonConstSwitchOnEnum(fruit);
...	@@ -74,6 +77,7 @@ fn nonConstSwitchOnEnum(fruit: Fruit) void {	...	@@ -74,6 +77,7 @@ fn nonConstSwitchOnEnum(fruit: Fruit) void {
74		77
75	test "switch statement" {	78	test "switch statement" {
76	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		80	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
77		81
78	try nonConstSwitch(SwitchStatementFoo.C);	82	try nonConstSwitch(SwitchStatementFoo.C);
79	}	83	}
...	@@ -90,6 +94,7 @@ const SwitchStatementFoo = enum { A, B, C, D };	...	@@ -90,6 +94,7 @@ const SwitchStatementFoo = enum { A, B, C, D };
90		94
91	test "switch with multiple expressions" {	95	test "switch with multiple expressions" {
92	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	96	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		97	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
93		98
94	const x = switch (returnsFive()) {	99	const x = switch (returnsFive()) {
95	1, 2, 3 => 1,	100	1, 2, 3 => 1,
...	@@ -118,6 +123,7 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {	...	@@ -118,6 +123,7 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {
118		123
119	test "switching on booleans" {	124	test "switching on booleans" {
120	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	125	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		126	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
121		127
122	try testSwitchOnBools();	128	try testSwitchOnBools();
123	try comptime testSwitchOnBools();	129	try comptime testSwitchOnBools();
...	@@ -173,6 +179,7 @@ test "undefined.u0" {	...	@@ -173,6 +179,7 @@ test "undefined.u0" {
173		179
174	test "switch with disjoint range" {	180	test "switch with disjoint range" {
175	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	181	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		182	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
176		183
177	var q: u8 = 0;	184	var q: u8 = 0;
178	_ = &q;	185	_ = &q;
...	@@ -184,6 +191,8 @@ test "switch with disjoint range" {	...	@@ -184,6 +191,8 @@ test "switch with disjoint range" {
184	}	191	}
185		192
186	test "switch variable for range and multiple prongs" {	193	test "switch variable for range and multiple prongs" {
		194	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		195
187	const S = struct {	196	const S = struct {
188	fn doTheTest() !void {	197	fn doTheTest() !void {
189	try doTheSwitch(16);	198	try doTheSwitch(16);
...	@@ -215,6 +224,7 @@ fn poll() void {	...	@@ -215,6 +224,7 @@ fn poll() void {
215		224
216	test "switch on global mutable var isn't constant-folded" {	225	test "switch on global mutable var isn't constant-folded" {
217	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	226	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		227	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
218		228
219	while (state < 2) {	229	while (state < 2) {
220	poll();	230	poll();
...	@@ -231,6 +241,7 @@ test "switch prong with variable" {	...	@@ -231,6 +241,7 @@ test "switch prong with variable" {
231	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	241	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
232	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	242	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
233	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	243	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		244	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
234		245
235	try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 });	246	try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 });
236	try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 });	247	try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 });
...	@@ -255,6 +266,7 @@ test "switch on enum using pointer capture" {	...	@@ -255,6 +266,7 @@ test "switch on enum using pointer capture" {
255	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	266	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
256	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	267	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
257	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	268	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		269	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
258		270
259	try testSwitchEnumPtrCapture();	271	try testSwitchEnumPtrCapture();
260	try comptime testSwitchEnumPtrCapture();	272	try comptime testSwitchEnumPtrCapture();
...	@@ -274,6 +286,7 @@ fn testSwitchEnumPtrCapture() !void {	...	@@ -274,6 +286,7 @@ fn testSwitchEnumPtrCapture() !void {
274		286
275	test "switch handles all cases of number" {	287	test "switch handles all cases of number" {
276	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	288	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		289	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
277		290
278	try testSwitchHandleAllCases();	291	try testSwitchHandleAllCases();
279	try comptime testSwitchHandleAllCases();	292	try comptime testSwitchHandleAllCases();
...	@@ -315,6 +328,7 @@ test "switch on union with some prongs capturing" {	...	@@ -315,6 +328,7 @@ test "switch on union with some prongs capturing" {
315	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	328	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
316	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	329	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
317	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	330	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		331	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
318		332
319	const X = union(enum) {	333	const X = union(enum) {
320	a,	334	a,
...	@@ -368,6 +382,7 @@ test "anon enum literal used in switch on union enum" {	...	@@ -368,6 +382,7 @@ test "anon enum literal used in switch on union enum" {
368		382
369	test "switch all prongs unreachable" {	383	test "switch all prongs unreachable" {
370	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	384	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		385	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
371		386
372	try testAllProngsUnreachable();	387	try testAllProngsUnreachable();
373	try comptime testAllProngsUnreachable();	388	try comptime testAllProngsUnreachable();
...	@@ -391,6 +406,7 @@ fn switchWithUnreachable(x: i32) i32 {	...	@@ -391,6 +406,7 @@ fn switchWithUnreachable(x: i32) i32 {
391		406
392	test "capture value of switch with all unreachable prongs" {	407	test "capture value of switch with all unreachable prongs" {
393	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	408	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		409	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
394		410
395	const x = return_a_number() catch \|err\| switch (err) {	411	const x = return_a_number() catch \|err\| switch (err) {
396	else => unreachable,	412	else => unreachable,
...	@@ -404,6 +420,7 @@ fn return_a_number() anyerror!i32 {	...	@@ -404,6 +420,7 @@ fn return_a_number() anyerror!i32 {
404		420
405	test "switch on integer with else capturing expr" {	421	test "switch on integer with else capturing expr" {
406	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	422	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		423	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
407		424
408	const S = struct {	425	const S = struct {
409	fn doTheTest() !void {	426	fn doTheTest() !void {
...	@@ -425,6 +442,7 @@ test "else prong of switch on error set excludes other cases" {	...	@@ -425,6 +442,7 @@ test "else prong of switch on error set excludes other cases" {
425	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	442	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
426	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	443	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
427	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	444	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		445	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
428		446
429	const S = struct {	447	const S = struct {
430	fn doTheTest() !void {	448	fn doTheTest() !void {
...	@@ -460,6 +478,7 @@ test "switch prongs with error set cases make a new error set type for capture v	...	@@ -460,6 +478,7 @@ test "switch prongs with error set cases make a new error set type for capture v
460	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	478	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
461	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	479	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
462	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	480	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		481	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
463		482
464	const S = struct {	483	const S = struct {
465	fn doTheTest() !void {	484	fn doTheTest() !void {
...	@@ -494,6 +513,7 @@ test "switch prongs with error set cases make a new error set type for capture v	...	@@ -494,6 +513,7 @@ test "switch prongs with error set cases make a new error set type for capture v
494		513
495	test "return result loc and then switch with range implicit casted to error union" {	514	test "return result loc and then switch with range implicit casted to error union" {
496	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	515	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		516	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
497		517
498	const S = struct {	518	const S = struct {
499	fn doTheTest() !void {	519	fn doTheTest() !void {
...	@@ -514,6 +534,7 @@ test "switch with null and T peer types and inferred result location type" {	...	@@ -514,6 +534,7 @@ test "switch with null and T peer types and inferred result location type" {
514	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	534	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
515	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	535	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
516	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	536	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		537	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
517		538
518	const S = struct {	539	const S = struct {
519	fn doTheTest(c: u8) !void {	540	fn doTheTest(c: u8) !void {
...	@@ -534,6 +555,7 @@ test "switch prongs with cases with identical payload types" {	...	@@ -534,6 +555,7 @@ test "switch prongs with cases with identical payload types" {
534	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	555	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
535	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	556	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
536	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	557	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		558	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
537		559
538	const Union = union(enum) {	560	const Union = union(enum) {
539	A: usize,	561	A: usize,
...	@@ -640,6 +662,7 @@ test "switch prong pointer capture alignment" {	...	@@ -640,6 +662,7 @@ test "switch prong pointer capture alignment" {
640	test "switch on pointer type" {	662	test "switch on pointer type" {
641	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	663	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
642	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	664	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		665	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
643		666
644	const S = struct {	667	const S = struct {
645	const X = struct {	668	const X = struct {
...	@@ -688,6 +711,7 @@ test "switch capture copies its payload" {	...	@@ -688,6 +711,7 @@ test "switch capture copies its payload" {
688	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	711	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
689	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	712	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
690	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	713	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		714	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
691		715
692	const S = struct {	716	const S = struct {
693	fn doTheTest() !void {	717	fn doTheTest() !void {
...	@@ -711,6 +735,7 @@ test "switch capture copies its payload" {	...	@@ -711,6 +735,7 @@ test "switch capture copies its payload" {
711		735
712	test "capture of integer forwards the switch condition directly" {	736	test "capture of integer forwards the switch condition directly" {
713	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	737	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		738	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
714		739
715	const S = struct {	740	const S = struct {
716	fn foo(x: u8) !void {	741	fn foo(x: u8) !void {
...	@@ -732,6 +757,7 @@ test "capture of integer forwards the switch condition directly" {	...	@@ -732,6 +757,7 @@ test "capture of integer forwards the switch condition directly" {
732		757
733	test "enum value without tag name used as switch item" {	758	test "enum value without tag name used as switch item" {
734	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	759	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		760	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
735		761
736	const E = enum(u32) {	762	const E = enum(u32) {
737	a = 1,	763	a = 1,
...	@@ -749,6 +775,8 @@ test "enum value without tag name used as switch item" {	...	@@ -749,6 +775,8 @@ test "enum value without tag name used as switch item" {
749	}	775	}
750		776
751	test "switch item sizeof" {	777	test "switch item sizeof" {
		778	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		779
752	const S = struct {	780	const S = struct {
753	fn doTheTest() !void {	781	fn doTheTest() !void {
754	var a: usize = 0;	782	var a: usize = 0;
...	@@ -777,6 +805,8 @@ test "comptime inline switch" {	...	@@ -777,6 +805,8 @@ test "comptime inline switch" {
777	}	805	}
778		806
779	test "switch capture peer type resolution" {	807	test "switch capture peer type resolution" {
		808	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		809
780	const U = union(enum) {	810	const U = union(enum) {
781	a: u32,	811	a: u32,
782	b: u64,	812	b: u64,
...	@@ -792,6 +822,8 @@ test "switch capture peer type resolution" {	...	@@ -792,6 +822,8 @@ test "switch capture peer type resolution" {
792	}	822	}
793		823
794	test "switch capture peer type resolution for in-memory coercible payloads" {	824	test "switch capture peer type resolution for in-memory coercible payloads" {
		825	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		826
795	const T1 = c_int;	827	const T1 = c_int;
796	const T2 = @Type(@typeInfo(T1));	828	const T2 = @Type(@typeInfo(T1));
797		829
...	@@ -813,6 +845,7 @@ test "switch capture peer type resolution for in-memory coercible payloads" {	...	@@ -813,6 +845,7 @@ test "switch capture peer type resolution for in-memory coercible payloads" {
813		845
814	test "switch pointer capture peer type resolution" {	846	test "switch pointer capture peer type resolution" {
815	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	847	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		848	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
816		849
817	const T1 = c_int;	850	const T1 = c_int;
818	const T2 = @Type(@typeInfo(T1));	851	const T2 = @Type(@typeInfo(T1));
...	@@ -840,6 +873,8 @@ test "switch pointer capture peer type resolution" {	...	@@ -840,6 +873,8 @@ test "switch pointer capture peer type resolution" {
840	}	873	}
841		874
842	test "inline switch range that includes the maximum value of the switched type" {	875	test "inline switch range that includes the maximum value of the switched type" {
		876	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		877
843	const inputs: [3]u8 = .{ 0, 254, 255 };	878	const inputs: [3]u8 = .{ 0, 254, 255 };
844	for (inputs) \|input\| {	879	for (inputs) \|input\| {
845	switch (input) {	880	switch (input) {
...	@@ -850,6 +885,8 @@ test "inline switch range that includes the maximum value of the switched type"	...	@@ -850,6 +885,8 @@ test "inline switch range that includes the maximum value of the switched type"
850	}	885	}
851		886
852	test "nested break ignores switch conditions and breaks instead" {	887	test "nested break ignores switch conditions and breaks instead" {
		888	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		889
853	const S = struct {	890	const S = struct {
854	fn register_to_address(ident: []const u8) !u8 {	891	fn register_to_address(ident: []const u8) !u8 {
855	const reg: u8 = if (std.mem.eql(u8, ident, "zero")) 0x00 else blk: {	892	const reg: u8 = if (std.mem.eql(u8, ident, "zero")) 0x00 else blk: {
...	@@ -870,6 +907,7 @@ test "nested break ignores switch conditions and breaks instead" {	...	@@ -870,6 +907,7 @@ test "nested break ignores switch conditions and breaks instead" {
870		907
871	test "peer type resolution on switch captures ignores unused payload bits" {	908	test "peer type resolution on switch captures ignores unused payload bits" {
872	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	909	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		910	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
873		911
874	const Foo = union(enum) {	912	const Foo = union(enum) {
875	a: u32,	913	a: u32,
...	@@ -895,6 +933,7 @@ test "peer type resolution on switch captures ignores unused payload bits" {	...	@@ -895,6 +933,7 @@ test "peer type resolution on switch captures ignores unused payload bits" {
895	test "switch prong captures range" {	933	test "switch prong captures range" {
896	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	934	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
897	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	935	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		936	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
898		937
899	const S = struct {	938	const S = struct {
900	fn a(b: []u3, c: u3) void {	939	fn a(b: []u3, c: u3) void {
...	@@ -912,6 +951,8 @@ test "switch prong captures range" {	...	@@ -912,6 +951,8 @@ test "switch prong captures range" {
912	}	951	}
913		952
914	test "prong with inline call to unreachable" {	953	test "prong with inline call to unreachable" {
		954	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		955
915	const U = union(enum) {	956	const U = union(enum) {
916	void: void,	957	void: void,
917	bool: bool,	958	bool: bool,
...	@@ -929,6 +970,8 @@ test "prong with inline call to unreachable" {	...	@@ -929,6 +970,8 @@ test "prong with inline call to unreachable" {
929	}	970	}
930		971
931	test "block error return trace index is reset between prongs" {	972	test "block error return trace index is reset between prongs" {
		973	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		974
932	const S = struct {	975	const S = struct {
933	fn returnError() error{TestFailed} {	976	fn returnError() error{TestFailed} {
934	return error.TestFailed;	977	return error.TestFailed;

test/behavior/switch_on_captured_error.zig+2

...	@@ -8,6 +8,7 @@ const builtin = @import("builtin");	...	@@ -8,6 +8,7 @@ const builtin = @import("builtin");
8	test "switch on error union catch capture" {	8	test "switch on error union catch capture" {
9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	10	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
		11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11		12
12	const S = struct {	13	const S = struct {
13	const Error = error{ A, B, C };	14	const Error = error{ A, B, C };
...	@@ -302,6 +303,7 @@ test "switch on error union catch capture" {	...	@@ -302,6 +303,7 @@ test "switch on error union catch capture" {
302	test "switch on error union if else capture" {	303	test "switch on error union if else capture" {
303	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	304	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
304	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	305	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
		306	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
305		307
306	const S = struct {	308	const S = struct {
307	const Error = error{ A, B, C };	309	const Error = error{ A, B, C };

test/behavior/switch_prong_err_enum.zig+1

...	@@ -24,6 +24,7 @@ test "switch prong returns error enum" {	...	@@ -24,6 +24,7 @@ test "switch prong returns error enum" {
24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		27	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
27		28
28	switch (doThing(17) catch unreachable) {	29	switch (doThing(17) catch unreachable) {
29	FormValue.Address => \|payload\| {	30	FormValue.Address => \|payload\| {

test/behavior/switch_prong_implicit_cast.zig+1

...	@@ -18,6 +18,7 @@ test "switch prong implicit cast" {	...	@@ -18,6 +18,7 @@ test "switch prong implicit cast" {
18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		21	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
21		22
22	const result = switch (foo(2) catch unreachable) {	23	const result = switch (foo(2) catch unreachable) {
23	FormValue.One => false,	24	FormValue.One => false,

test/behavior/this.zig+2

...	@@ -27,6 +27,7 @@ test "this refer to module call private fn" {	...	@@ -27,6 +27,7 @@ test "this refer to module call private fn" {
27	test "this refer to container" {	27	test "this refer to container" {
28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		30	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
30		31
31	var pt: Point(i32) = undefined;	32	var pt: Point(i32) = undefined;
32	pt.x = 12;	33	pt.x = 12;
...	@@ -50,6 +51,7 @@ test "this used as optional function parameter" {	...	@@ -50,6 +51,7 @@ test "this used as optional function parameter" {
50	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
51	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
52	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	53	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		54	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
53		55
54	var global: State = undefined;	56	var global: State = undefined;
55	global.enter = prev;	57	global.enter = prev;

test/behavior/threadlocal.zig+3

test/behavior/truncate.zig+1

...	@@ -69,6 +69,7 @@ test "truncate on vectors" {	...	@@ -69,6 +69,7 @@ test "truncate on vectors" {
69	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	69	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
70	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	70	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		72	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
72		73
73	const S = struct {	74	const S = struct {
74	fn doTheTest() !void {	75	fn doTheTest() !void {

test/behavior/try.zig+2

...	@@ -4,6 +4,7 @@ const expect = std.testing.expect;	...	@@ -4,6 +4,7 @@ const expect = std.testing.expect;
4		4
5	test "try on error union" {	5	test "try on error union" {
6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		7	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7		8
8	try tryOnErrorUnionImpl();	9	try tryOnErrorUnionImpl();
9	try comptime tryOnErrorUnionImpl();	10	try comptime tryOnErrorUnionImpl();
...	@@ -51,6 +52,7 @@ test "`try`ing an if/else expression" {	...	@@ -51,6 +52,7 @@ test "`try`ing an if/else expression" {
51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	52	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
52	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
53	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	54	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		55	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
54		56
55	const S = struct {	57	const S = struct {
56	fn getError() !void {	58	fn getError() !void {

test/behavior/tuple.zig+19

test/behavior/tuple_declarations.zig+2

...	@@ -7,6 +7,7 @@ const expectEqualStrings = testing.expectEqualStrings;	...	@@ -7,6 +7,7 @@ const expectEqualStrings = testing.expectEqualStrings;
7	test "tuple declaration type info" {	7	test "tuple declaration type info" {
8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10		11
11	{	12	{
12	const T = struct { comptime u32 align(2) = 1, []const u8 };	13	const T = struct { comptime u32 align(2) = 1, []const u8 };
...	@@ -35,6 +36,7 @@ test "tuple declaration type info" {	...	@@ -35,6 +36,7 @@ test "tuple declaration type info" {
35	test "Tuple declaration usage" {	36	test "Tuple declaration usage" {
36	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	37	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
37	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	38	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		39	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
38		40
39	const T = struct { u32, []const u8 };	41	const T = struct { u32, []const u8 };
40	var t: T = .{ 1, "foo" };	42	var t: T = .{ 1, "foo" };

test/behavior/type.zig+3

test/behavior/type_info.zig+5

...	@@ -565,6 +565,8 @@ test "StructField.is_comptime" {	...	@@ -565,6 +565,8 @@ test "StructField.is_comptime" {
565	}	565	}
566		566
567	test "typeInfo resolves usingnamespace declarations" {	567	test "typeInfo resolves usingnamespace declarations" {
		568	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		569
568	const A = struct {	570	const A = struct {
569	pub const f1 = 42;	571	pub const f1 = 42;
570	};	572	};
...	@@ -590,6 +592,7 @@ test "value from struct @typeInfo default_value can be loaded at comptime" {	...	@@ -590,6 +592,7 @@ test "value from struct @typeInfo default_value can be loaded at comptime" {
590	test "@typeInfo decls and usingnamespace" {	592	test "@typeInfo decls and usingnamespace" {
591	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	593	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
592	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	594	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		595	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
593		596
594	const A = struct {	597	const A = struct {
595	pub const x = 5;	598	pub const x = 5;
...	@@ -630,6 +633,8 @@ test "type info of tuple of string literal default value" {	...	@@ -630,6 +633,8 @@ test "type info of tuple of string literal default value" {
630	}	633	}
631		634
632	test "@typeInfo only contains pub decls" {	635	test "@typeInfo only contains pub decls" {
		636	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		637
633	const other = struct {	638	const other = struct {
634	const std = @import("std");	639	const std = @import("std");
635		640

test/behavior/typename.zig+8

test/behavior/undefined.zig+2

...	@@ -91,6 +91,7 @@ test "reslice of undefined global var slice" {	...	@@ -91,6 +91,7 @@ test "reslice of undefined global var slice" {
91	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	91	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
92	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	92	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
93	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	93	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		94	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
94		95
95	var stack_buf: [100]u8 = [_]u8{0} ** 100;	96	var stack_buf: [100]u8 = [_]u8{0} ** 100;
96	buf = &stack_buf;	97	buf = &stack_buf;
...	@@ -103,6 +104,7 @@ test "returned undef is 0xaa bytes when runtime safety is enabled" {	...	@@ -103,6 +104,7 @@ test "returned undef is 0xaa bytes when runtime safety is enabled" {
103	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	104	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
104	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	105	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
105	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	106	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		107	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
106		108
107	const Rect = struct {	109	const Rect = struct {
108	x: f32,	110	x: f32,

test/behavior/underscore.zig+1

...	@@ -8,6 +8,7 @@ test "ignore lval with underscore" {	...	@@ -8,6 +8,7 @@ test "ignore lval with underscore" {
8		8
9	test "ignore lval with underscore (while loop)" {	9	test "ignore lval with underscore (while loop)" {
10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11		12
12	while (optionalReturnError()) \|_\| {	13	while (optionalReturnError()) \|_\| {
13	while (optionalReturnError()) \|_\| {	14	while (optionalReturnError()) \|_\| {

test/behavior/union.zig+66

test/behavior/union_with_members.zig+1

...	@@ -21,6 +21,7 @@ test "enum with members" {	...	@@ -21,6 +21,7 @@ test "enum with members" {
21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	23	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		24	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
24		25
25	const a = ET{ .SINT = -42 };	26	const a = ET{ .SINT = -42 };
26	const b = ET{ .UINT = 42 };	27	const b = ET{ .UINT = 42 };

test/behavior/usingnamespace.zig+13

test/behavior/usingnamespace/file_1.zig+3

 @@ -1,9 +1,12 @@
 const std = @import("std");
 const expect = std.testing.expect;
 const imports = @import("imports.zig");
+const builtin = @import("builtin");
 const A = 456;
 test {
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     try expect(imports.A == 123);
 }

test/behavior/usingnamespace/import_segregation.zig+1

...	@@ -6,6 +6,7 @@ usingnamespace @import("bar.zig");	...	@@ -6,6 +6,7 @@ usingnamespace @import("bar.zig");
6		6
7	test "no clobbering happened" {	7	test "no clobbering happened" {
8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
9		10
10	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {	11	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {
11	// https://github.com/ziglang/zig/issues/16846	12	// https://github.com/ziglang/zig/issues/16846

test/behavior/var_args.zig+15

test/behavior/vector.zig+45-1

test/behavior/void.zig+2

...	@@ -20,6 +20,7 @@ test "compare void with void compile time known" {	...	@@ -20,6 +20,7 @@ test "compare void with void compile time known" {
20		20
21	test "iterate over a void slice" {	21	test "iterate over a void slice" {
22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		23	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
23		24
24	var j: usize = 0;	25	var j: usize = 0;
25	for (times(10), 0..) \|_, i\| {	26	for (times(10), 0..) \|_, i\| {
...	@@ -36,6 +37,7 @@ test "void optional" {	...	@@ -36,6 +37,7 @@ test "void optional" {
36	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	37	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
37	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
38	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	39	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		40	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
39		41
40	var x: ?void = {};	42	var x: ?void = {};
41	_ = &x;	43	_ = &x;

test/behavior/wasm.zig+2

...	@@ -3,6 +3,8 @@ const expect = std.testing.expect;	...	@@ -3,6 +3,8 @@ const expect = std.testing.expect;
3	const builtin = @import("builtin");	3	const builtin = @import("builtin");
4		4
5	test "memory size and grow" {	5	test "memory size and grow" {
		6	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		7
6	var prev = @wasmMemorySize(0);	8	var prev = @wasmMemorySize(0);
7	_ = &prev;	9	_ = &prev;
8	try expect(prev == @wasmMemoryGrow(0, 1));	10	try expect(prev == @wasmMemoryGrow(0, 1));

test/behavior/while.zig+13

test/behavior/widening.zig+5

test/behavior/wrapping_arithmetic.zig+3

...	@@ -6,6 +6,7 @@ const expect = std.testing.expect;	...	@@ -6,6 +6,7 @@ const expect = std.testing.expect;
6		6
7	test "wrapping add" {	7	test "wrapping add" {
8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
9		10
10	const S = struct {	11	const S = struct {
11	fn doTheTest() !void {	12	fn doTheTest() !void {
...	@@ -43,6 +44,7 @@ test "wrapping add" {	...	@@ -43,6 +44,7 @@ test "wrapping add" {
43		44
44	test "wrapping subtraction" {	45	test "wrapping subtraction" {
45	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	46	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		47	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
46		48
47	const S = struct {	49	const S = struct {
48	fn doTheTest() !void {	50	fn doTheTest() !void {
...	@@ -78,6 +80,7 @@ test "wrapping subtraction" {	...	@@ -78,6 +80,7 @@ test "wrapping subtraction" {
78		80
79	test "wrapping multiplication" {	81	test "wrapping multiplication" {
80	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	82	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		83	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
81		84
82	// TODO: once #9660 has been solved, remove this line	85	// TODO: once #9660 has been solved, remove this line
83	if (builtin.cpu.arch == .wasm32) return error.SkipZigTest;	86	if (builtin.cpu.arch == .wasm32) return error.SkipZigTest;

test/cases/compile_errors/capture_by_ref_while.zig+1-1

...	@@ -7,4 +7,4 @@ test {	...	@@ -7,4 +7,4 @@ test {
7	// target=native	7	// target=native
8	//	8	//
9	// :2:25: error: unused capture	9	// :2:25: error: unused capture
10	// :2:39: error: unused capture
	\ No newline at end of file
		10	// :2:39: error: unused capture

test/cases/compile_errors/switch_expression-missing_error_prong.zig+1-1

...	@@ -1,4 +1,4 @@	...	@@ -1,4 +1,4 @@
1	const Error = error {	1	const Error = error{
2	One,	2	One,
3	Two,	3	Two,
4	Three,	4	Three,

test/cases/compile_errors/switch_expression-multiple_else_prongs.zig+2-2

...	@@ -5,14 +5,14 @@ fn f(x: u32) void {	...	@@ -5,14 +5,14 @@ fn f(x: u32) void {
5	else => true,	5	else => true,
6	};	6	};
7	}	7	}
8	fn g(x: error{Foo, Bar, Baz}!u32) void {	8	fn g(x: error{ Foo, Bar, Baz }!u32) void {
9	const value: bool = if (x) \|_\| true else \|e\| switch (e) {	9	const value: bool = if (x) \|_\| true else \|e\| switch (e) {
10	error.Foo => false,	10	error.Foo => false,
11	else => true,	11	else => true,
12	else => true,	12	else => true,
13	};	13	};
14	}	14	}
15	fn h(x: error{Foo, Bar, Baz}!u32) void {	15	fn h(x: error{ Foo, Bar, Baz }!u32) void {
16	const value: u32 = x catch \|e\| switch (e) {	16	const value: u32 = x catch \|e\| switch (e) {
17	error.Foo => 1,	17	error.Foo => 1,
18	else => 2,	18	else => 2,

test/cases/inherit_want_safety.zig+1-1

...	@@ -28,7 +28,7 @@ pub export fn entry() usize {	...	@@ -28,7 +28,7 @@ pub export fn entry() usize {
28	} else \|e\| switch (e) {	28	} else \|e\| switch (e) {
29	else => {	29	else => {
30	u += 1;	30	u += 1;
31	}	31	},
32	}	32	}
33	return u;	33	return u;
34	}	34	}

test/tests.zig+14

...	@@ -435,6 +435,16 @@ const test_targets = blk: {	...	@@ -435,6 +435,16 @@ const test_targets = blk: {
435	// .use_llvm = true,	435	// .use_llvm = true,
436	//},	436	//},
437		437
		438	.{
		439	.target = .{
		440	.cpu_arch = .riscv64,
		441	.os_tag = .linux,
		442	.abi = .musl,
		443	},
		444	.use_llvm = false,
		445	.use_lld = false,
		446	},
		447
438	// https://github.com/ziglang/zig/issues/3340	448	// https://github.com/ziglang/zig/issues/3340
439	//.{	449	//.{
440	// .target = .{	450	// .target = .{
...	@@ -1019,6 +1029,10 @@ pub fn addModuleTests(b: std.Build, options: ModuleTestOptions) Step {	...	@@ -1019,6 +1029,10 @@ pub fn addModuleTests(b: std.Build, options: ModuleTestOptions) Step {
1019	test_target.use_llvm == false and mem.eql(u8, options.name, "std"))	1029	test_target.use_llvm == false and mem.eql(u8, options.name, "std"))
1020	continue;	1030	continue;
1021		1031
		1032	if (target.cpu.arch != .x86_64 and
		1033	test_target.use_llvm == false and mem.eql(u8, options.name, "c-import"))
		1034	continue;
		1035
1022	if (target.cpu.arch == .x86_64 and target.os.tag == .windows and	1036	if (target.cpu.arch == .x86_64 and target.os.tag == .windows and
1023	test_target.target.cpu_arch == null and test_target.optimize_mode != .Debug and	1037	test_target.target.cpu_arch == null and test_target.optimize_mode != .Debug and
1024	mem.eql(u8, options.name, "std"))	1038	mem.eql(u8, options.name, "std"))

...	@@ -10499,9 +10499,10 @@ fn intCast(	...	@@ -10499,9 +10499,10 @@ fn intCast(
10499	const dest_max_val_scalar = try dest_scalar_ty.maxIntScalar(mod, operand_scalar_ty);	10499	const dest_max_val_scalar = try dest_scalar_ty.maxIntScalar(mod, operand_scalar_ty);
10500	const dest_max_val = try sema.splat(operand_ty, dest_max_val_scalar);	10500	const dest_max_val = try sema.splat(operand_ty, dest_max_val_scalar);
10501	const dest_max = Air.internedToRef(dest_max_val.toIntern());	10501	const dest_max = Air.internedToRef(dest_max_val.toIntern());
10502	const diff = try block.addBinOp(.sub_wrap, dest_max, operand);
10503		10502
10504	if (actual_info.signedness == .signed) {	10503	if (actual_info.signedness == .signed) {
		10504	const diff = try block.addBinOp(.sub_wrap, dest_max, operand);
		10505
10505	// Reinterpret the sign-bit as part of the value. This will make	10506	// Reinterpret the sign-bit as part of the value. This will make
10506	// negative differences (`operand` > `dest_max`) appear too big.	10507	// negative differences (`operand` > `dest_max`) appear too big.
10507	const unsigned_scalar_operand_ty = try mod.intType(.unsigned, actual_bits);	10508	const unsigned_scalar_operand_ty = try mod.intType(.unsigned, actual_bits);
...	@@ -10542,7 +10543,7 @@ fn intCast(	...	@@ -10542,7 +10543,7 @@ fn intCast(
10542	try sema.addSafetyCheck(block, src, ok, .cast_truncated_data);	10543	try sema.addSafetyCheck(block, src, ok, .cast_truncated_data);
10543	} else {	10544	} else {
10544	const ok = if (is_vector) ok: {	10545	const ok = if (is_vector) ok: {
10545	const is_in_range = try block.addCmpVector(diff, dest_max, .lte);	10546	const is_in_range = try block.addCmpVector(operand, dest_max, .lte);
10546	const all_in_range = try block.addInst(.{	10547	const all_in_range = try block.addInst(.{
10547	.tag = if (block.float_mode == .optimized) .reduce_optimized else .reduce,	10548	.tag = if (block.float_mode == .optimized) .reduce_optimized else .reduce,
10548	.data = .{ .reduce = .{	10549	.data = .{ .reduce = .{
...	@@ -10552,7 +10553,7 @@ fn intCast(	...	@@ -10552,7 +10553,7 @@ fn intCast(
10552	});	10553	});
10553	break :ok all_in_range;	10554	break :ok all_in_range;
10554	} else ok: {	10555	} else ok: {
10555	const is_in_range = try block.addBinOp(.cmp_lte, diff, dest_max);	10556	const is_in_range = try block.addBinOp(.cmp_lte, operand, dest_max);
10556	break :ok is_in_range;	10557	break :ok is_in_range;
10557	};	10558	};
10558	try sema.addSafetyCheck(block, src, ok, .cast_truncated_data);	10559	try sema.addSafetyCheck(block, src, ok, .cast_truncated_data);

...	@@ -507,7 +507,7 @@ pub fn zigBackend(target: std.Target, use_llvm: bool) std.builtin.CompilerBacken	...	@@ -507,7 +507,7 @@ pub fn zigBackend(target: std.Target, use_llvm: bool) std.builtin.CompilerBacken
507	if (use_llvm) return .stage2_llvm;	507	if (use_llvm) return .stage2_llvm;
508	if (target.ofmt == .c) return .stage2_c;	508	if (target.ofmt == .c) return .stage2_c;
509	return switch (target.cpu.arch) {	509	return switch (target.cpu.arch) {
510	.wasm32, .wasm64 => std.builtin.CompilerBackend.stage2_wasm,	510	.wasm32, .wasm64 => .stage2_wasm,
511	.arm, .armeb, .thumb, .thumbeb => .stage2_arm,	511	.arm, .armeb, .thumb, .thumbeb => .stage2_arm,
512	.x86_64 => .stage2_x86_64,	512	.x86_64 => .stage2_x86_64,
513	.x86 => .stage2_x86,	513	.x86 => .stage2_x86,
...	@@ -526,7 +526,7 @@ pub fn backendSupportsFeature(	...	@@ -526,7 +526,7 @@ pub fn backendSupportsFeature(
526	feature: Feature,	526	feature: Feature,
527	) bool {	527	) bool {
528	return switch (feature) {	528	return switch (feature) {
529	.panic_fn => ofmt == .c or use_llvm or cpu_arch == .x86_64,	529	.panic_fn => ofmt == .c or use_llvm or cpu_arch == .x86_64 or cpu_arch == .riscv64,
530	.panic_unwrap_error => ofmt == .c or use_llvm,	530	.panic_unwrap_error => ofmt == .c or use_llvm,
531	.safety_check_formatted => ofmt == .c or use_llvm,	531	.safety_check_formatted => ofmt == .c or use_llvm,
532	.error_return_trace => use_llvm,	532	.error_return_trace => use_llvm,

...	@@ -16,6 +16,7 @@ test "global variable alignment" {	...	@@ -16,6 +16,7 @@ test "global variable alignment" {
16	}	16	}
17		17
18	test "large alignment of local constant" {	18	test "large alignment of local constant" {
		19	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	20	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
20	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	21	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky	22	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
...	@@ -25,6 +26,7 @@ test "large alignment of local constant" {	...	@@ -25,6 +26,7 @@ test "large alignment of local constant" {
25	}	26	}
26		27
27	test "slicing array of length 1 can not assume runtime index is always zero" {	28	test "slicing array of length 1 can not assume runtime index is always zero" {
		29	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
30	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky	32	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
...	@@ -52,6 +54,7 @@ fn addUnaligned(a: align(1) const u32, b: align(1) const u32) u32 {	...	@@ -52,6 +54,7 @@ fn addUnaligned(a: align(1) const u32, b: align(1) const u32) u32 {
52	}	54	}
53		55
54	test "@alignCast pointers" {	56	test "@alignCast pointers" {
		57	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
55	var x: u32 align(4) = 1;	58	var x: u32 align(4) = 1;
56	expectsOnly1(&x);	59	expectsOnly1(&x);
57	try expect(x == 2);	60	try expect(x == 2);
...	@@ -235,6 +238,7 @@ fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {	...	@@ -235,6 +238,7 @@ fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
235	}	238	}
236		239
237	test "specifying alignment allows pointer cast" {	240	test "specifying alignment allows pointer cast" {
		241	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
238	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	242	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
239	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	243	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
240		244
...	@@ -247,6 +251,7 @@ fn testBytesAlign(b: u8) !void {	...	@@ -247,6 +251,7 @@ fn testBytesAlign(b: u8) !void {
247	}	251	}
248		252
249	test "@alignCast slices" {	253	test "@alignCast slices" {
		254	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
250	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	255	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
251	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	256	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
252	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	257	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -265,6 +270,7 @@ fn sliceExpects4(slice: []align(4) u32) void {	...	@@ -265,6 +270,7 @@ fn sliceExpects4(slice: []align(4) u32) void {
265	}	270	}
266		271
267	test "return error union with 128-bit integer" {	272	test "return error union with 128-bit integer" {
		273	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
268	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	274	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
269	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	275	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
270	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	276	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -277,6 +283,7 @@ fn give() anyerror!u128 {	...	@@ -277,6 +283,7 @@ fn give() anyerror!u128 {
277	}	283	}
278		284
279	test "page aligned array on stack" {	285	test "page aligned array on stack" {
		286	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
280	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	287	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	288	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	289	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -305,6 +312,7 @@ test "function alignment" {	...	@@ -305,6 +312,7 @@ test "function alignment" {
305	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	312	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
306	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	313	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
307	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	314	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		315	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
308		316
309	// function alignment is a compile error on wasm32/wasm64	317	// function alignment is a compile error on wasm32/wasm64
310	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;	318	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
...	@@ -418,6 +426,7 @@ test "function callconv expression depends on generic parameter" {	...	@@ -418,6 +426,7 @@ test "function callconv expression depends on generic parameter" {
418	}	426	}
419		427
420	test "runtime-known array index has best alignment possible" {	428	test "runtime-known array index has best alignment possible" {
		429	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
421	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	430	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
422		431
423	// take full advantage of over-alignment	432	// take full advantage of over-alignment
...	@@ -478,6 +487,7 @@ const DefaultAligned = struct {	...	@@ -478,6 +487,7 @@ const DefaultAligned = struct {
478	};	487	};
479		488
480	test "read 128-bit field from default aligned struct in stack memory" {	489	test "read 128-bit field from default aligned struct in stack memory" {
		490	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
481	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	491	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
482	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	492	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
483	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	493	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -497,6 +507,7 @@ var default_aligned_global = DefaultAligned{	...	@@ -497,6 +507,7 @@ var default_aligned_global = DefaultAligned{
497	};	507	};
498		508
499	test "read 128-bit field from default aligned struct in global memory" {	509	test "read 128-bit field from default aligned struct in global memory" {
		510	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
500	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	511	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
501	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	512	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
502	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	513	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -506,6 +517,7 @@ test "read 128-bit field from default aligned struct in global memory" {	...	@@ -506,6 +517,7 @@ test "read 128-bit field from default aligned struct in global memory" {
506	}	517	}
507		518
508	test "struct field explicit alignment" {	519	test "struct field explicit alignment" {
		520	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
509	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	521	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
510	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	522	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
511	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	523	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -550,6 +562,7 @@ test "align(@alignOf(T)) T does not force resolution of T" {	...	@@ -550,6 +562,7 @@ test "align(@alignOf(T)) T does not force resolution of T" {
550	}	562	}
551		563
552	test "align(N) on functions" {	564	test "align(N) on functions" {
		565	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
553	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	566	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
554	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	567	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
555	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	568	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -595,6 +608,7 @@ test "comptime alloc alignment" {	...	@@ -595,6 +608,7 @@ test "comptime alloc alignment" {
595	}	608	}
596		609
597	test "@alignCast null" {	610	test "@alignCast null" {
		611	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
598	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	612	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
599	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	613	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
600		614
...	@@ -610,6 +624,7 @@ test "alignment of slice element" {	...	@@ -610,6 +624,7 @@ test "alignment of slice element" {
610	}	624	}
611		625
612	test "sub-aligned pointer field access" {	626	test "sub-aligned pointer field access" {
		627	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
613	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	628	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
614	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	629	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
615	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	630	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
...	@@ -658,6 +673,7 @@ test "alignment of zero-bit types is respected" {	...	@@ -658,6 +673,7 @@ test "alignment of zero-bit types is respected" {
658	}	673	}
659		674
660	test "zero-bit fields in extern struct pad fields appropriately" {	675	test "zero-bit fields in extern struct pad fields appropriately" {
		676	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
661	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	677	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
662	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	678	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
663	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	679	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;

...	@@ -46,6 +46,7 @@ test "output constraint modifiers" {	...	@@ -46,6 +46,7 @@ test "output constraint modifiers" {
46	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	46	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
47	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	47	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
48	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	48	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		49	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
49		50
50	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly	51	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
51		52
...	@@ -69,6 +70,7 @@ test "alternative constraints" {	...	@@ -69,6 +70,7 @@ test "alternative constraints" {
69	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
70	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
71	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	72	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		73	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
72		74
73	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly	75	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
74		76
...	@@ -87,6 +89,7 @@ test "sized integer/float in asm input" {	...	@@ -87,6 +89,7 @@ test "sized integer/float in asm input" {
87	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	89	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
88	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	90	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
89	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	91	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		92	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
90		93
91	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly	94	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
92		95
...	@@ -137,6 +140,7 @@ test "struct/array/union types as input values" {	...	@@ -137,6 +140,7 @@ test "struct/array/union types as input values" {
137	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	140	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
138	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	141	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
139	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	142	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		143	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
140		144
141	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly	145	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
142		146

...	@@ -15,6 +15,7 @@ test "cmpxchg" {	...	@@ -15,6 +15,7 @@ test "cmpxchg" {
15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		18	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
18		19
19	try testCmpxchg();	20	try testCmpxchg();
20	try comptime testCmpxchg();	21	try comptime testCmpxchg();
...	@@ -41,6 +42,7 @@ test "fence" {	...	@@ -41,6 +42,7 @@ test "fence" {
41	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	42	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
42	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	43	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
43	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	44	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		45	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
44		46
45	var x: i32 = 1234;	47	var x: i32 = 1234;
46	@fence(.seq_cst);	48	@fence(.seq_cst);
...	@@ -52,6 +54,7 @@ test "atomicrmw and atomicload" {	...	@@ -52,6 +54,7 @@ test "atomicrmw and atomicload" {
52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	54	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	55	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
54	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	56	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		57	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
55		58
56	var data: u8 = 200;	59	var data: u8 = 200;
57	try testAtomicRmw(&data);	60	try testAtomicRmw(&data);
...	@@ -80,6 +83,7 @@ test "cmpxchg with ptr" {	...	@@ -80,6 +83,7 @@ test "cmpxchg with ptr" {
80	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	83	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
81	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	84	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
82	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	85	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		86	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
83		87
84	var data1: i32 = 1234;	88	var data1: i32 = 1234;
85	var data2: i32 = 5678;	89	var data2: i32 = 5678;
...	@@ -105,6 +109,7 @@ test "cmpxchg with ignored result" {	...	@@ -105,6 +109,7 @@ test "cmpxchg with ignored result" {
105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	109	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	110	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
107	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	111	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		112	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
108		113
109	var x: i32 = 1234;	114	var x: i32 = 1234;
110		115
...	@@ -149,6 +154,7 @@ test "cmpxchg on a global variable" {	...	@@ -149,6 +154,7 @@ test "cmpxchg on a global variable" {
149	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	154	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
150	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	155	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
151	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	156	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		157	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
152		158
153	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {	159	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
154	// https://github.com/ziglang/zig/issues/10627	160	// https://github.com/ziglang/zig/issues/10627
...	@@ -164,6 +170,7 @@ test "atomic load and rmw with enum" {	...	@@ -164,6 +170,7 @@ test "atomic load and rmw with enum" {
164	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	170	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
165	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	171	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
166	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	172	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		173	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
167		174
168	const Value = enum(u8) { a, b, c };	175	const Value = enum(u8) { a, b, c };
169	var x = Value.a;	176	var x = Value.a;
...	@@ -181,6 +188,7 @@ test "atomic store" {	...	@@ -181,6 +188,7 @@ test "atomic store" {
181	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	188	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
182	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	189	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
183	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	190	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		191	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
184		192
185	var x: u32 = 0;	193	var x: u32 = 0;
186	@atomicStore(u32, &x, 1, .seq_cst);	194	@atomicStore(u32, &x, 1, .seq_cst);
...	@@ -194,6 +202,7 @@ test "atomic store comptime" {	...	@@ -194,6 +202,7 @@ test "atomic store comptime" {
194	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	202	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
195	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	203	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
196	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	204	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		205	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
197		206
198	try comptime testAtomicStore();	207	try comptime testAtomicStore();
199	try testAtomicStore();	208	try testAtomicStore();
...	@@ -212,6 +221,7 @@ test "atomicrmw with floats" {	...	@@ -212,6 +221,7 @@ test "atomicrmw with floats" {
212	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
213	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	222	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
214	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	223	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		224	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
215		225
216	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {	226	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
217	// https://github.com/ziglang/zig/issues/10627	227	// https://github.com/ziglang/zig/issues/10627
...	@@ -241,6 +251,7 @@ test "atomicrmw with ints" {	...	@@ -241,6 +251,7 @@ test "atomicrmw with ints" {
241	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	251	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
242	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	252	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
243	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	253	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		254	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
244		255
245	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {	256	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {
246	// https://github.com/ziglang/zig/issues/16846	257	// https://github.com/ziglang/zig/issues/16846
...	@@ -390,6 +401,7 @@ test "atomics with different types" {	...	@@ -390,6 +401,7 @@ test "atomics with different types" {
390	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	401	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
391	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	402	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
392	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	403	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		404	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
393		405
394	try testAtomicsWithType(bool, true, false);	406	try testAtomicsWithType(bool, true, false);
395		407
...	@@ -419,6 +431,7 @@ test "return @atomicStore, using it as a void value" {	...	@@ -419,6 +431,7 @@ test "return @atomicStore, using it as a void value" {
419	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	431	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
420	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	432	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
421	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	433	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		434	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
422		435
423	const S = struct {	436	const S = struct {
424	const A = struct {	437	const A = struct {

...	@@ -10,6 +10,7 @@ const native_endian = builtin.target.cpu.arch.endian();	...	@@ -10,6 +10,7 @@ const native_endian = builtin.target.cpu.arch.endian();
10		10
11	test "@bitCast iX -> uX (32, 64)" {	11	test "@bitCast iX -> uX (32, 64)" {
12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		13	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13		14
14	const bit_values = [_]usize{ 32, 64 };	15	const bit_values = [_]usize{ 32, 64 };
15		16
...	@@ -24,6 +25,7 @@ test "@bitCast iX -> uX (8, 16, 128)" {	...	@@ -24,6 +25,7 @@ test "@bitCast iX -> uX (8, 16, 128)" {
24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	25	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
26	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		28	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
27		29
28	const bit_values = [_]usize{ 8, 16, 128 };	30	const bit_values = [_]usize{ 8, 16, 128 };
29		31
...	@@ -39,6 +41,7 @@ test "@bitCast iX -> uX exotic integers" {	...	@@ -39,6 +41,7 @@ test "@bitCast iX -> uX exotic integers" {
39	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	41	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	42	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
41	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	43	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		44	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
42		45
43	const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };	46	const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
44		47
...	@@ -83,6 +86,7 @@ test "bitcast uX to bytes" {	...	@@ -83,6 +86,7 @@ test "bitcast uX to bytes" {
83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	86	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	87	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
85	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	88	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		89	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
86		90
87	const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };	91	const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
88	inline for (bit_values) \|bits\| {	92	inline for (bit_values) \|bits\| {
...	@@ -161,6 +165,7 @@ test "@bitCast packed structs at runtime and comptime" {	...	@@ -161,6 +165,7 @@ test "@bitCast packed structs at runtime and comptime" {
161	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	165	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	166	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	167	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		168	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
164		169
165	const Full = packed struct {	170	const Full = packed struct {
166	number: u16,	171	number: u16,
...	@@ -187,6 +192,7 @@ test "@bitCast packed structs at runtime and comptime" {	...	@@ -187,6 +192,7 @@ test "@bitCast packed structs at runtime and comptime" {
187	test "@bitCast extern structs at runtime and comptime" {	192	test "@bitCast extern structs at runtime and comptime" {
188	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	193	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
189	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	194	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		195	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
190		196
191	const Full = extern struct {	197	const Full = extern struct {
192	number: u16,	198	number: u16,
...	@@ -221,6 +227,7 @@ test "bitcast packed struct to integer and back" {	...	@@ -221,6 +227,7 @@ test "bitcast packed struct to integer and back" {
221	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	227	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
222	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	228	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
223	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	229	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		230	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
224		231
225	const LevelUpMove = packed struct {	232	const LevelUpMove = packed struct {
226	move_id: u9,	233	move_id: u9,
...	@@ -243,6 +250,7 @@ test "bitcast packed struct to integer and back" {	...	@@ -243,6 +250,7 @@ test "bitcast packed struct to integer and back" {
243	test "implicit cast to error union by returning" {	250	test "implicit cast to error union by returning" {
244	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	251	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
245	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	252	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		253	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
246		254
247	const S = struct {	255	const S = struct {
248	fn entry() !void {	256	fn entry() !void {
...	@@ -272,6 +280,8 @@ test "comptime bitcast used in expression has the correct type" {	...	@@ -272,6 +280,8 @@ test "comptime bitcast used in expression has the correct type" {
272	}	280	}
273		281
274	test "bitcast passed as tuple element" {	282	test "bitcast passed as tuple element" {
		283	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		284
275	const S = struct {	285	const S = struct {
276	fn foo(args: anytype) !void {	286	fn foo(args: anytype) !void {
277	comptime assert(@TypeOf(args[0]) == f32);	287	comptime assert(@TypeOf(args[0]) == f32);
...	@@ -282,6 +292,8 @@ test "bitcast passed as tuple element" {	...	@@ -282,6 +292,8 @@ test "bitcast passed as tuple element" {
282	}	292	}
283		293
284	test "triple level result location with bitcast sandwich passed as tuple element" {	294	test "triple level result location with bitcast sandwich passed as tuple element" {
		295	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		296
285	const S = struct {	297	const S = struct {
286	fn foo(args: anytype) !void {	298	fn foo(args: anytype) !void {
287	comptime assert(@TypeOf(args[0]) == f64);	299	comptime assert(@TypeOf(args[0]) == f64);
...	@@ -299,6 +311,7 @@ test "@bitCast packed struct of floats" {	...	@@ -299,6 +311,7 @@ test "@bitCast packed struct of floats" {
299	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	311	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
300	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	312	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
301	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	313	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		314	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
302		315
303	const Foo = packed struct {	316	const Foo = packed struct {
304	a: f16 = 0,	317	a: f16 = 0,
...	@@ -337,6 +350,7 @@ test "comptime @bitCast packed struct to int and back" {	...	@@ -337,6 +350,7 @@ test "comptime @bitCast packed struct to int and back" {
337	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	350	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
338	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	351	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
339	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;	352	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
		353	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
340		354
341	if (builtin.zig_backend == .stage2_llvm and native_endian == .big) {	355	if (builtin.zig_backend == .stage2_llvm and native_endian == .big) {
342	// https://github.com/ziglang/zig/issues/13782	356	// https://github.com/ziglang/zig/issues/13782
...	@@ -401,6 +415,7 @@ test "bitcast vector to integer and back" {	...	@@ -401,6 +415,7 @@ test "bitcast vector to integer and back" {
401	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	415	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
402	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	416	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
403	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	417	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		418	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
404		419
405	const arr: [16]bool = [_]bool{ true, false } ++ [_]bool{true} ** 14;	420	const arr: [16]bool = [_]bool{ true, false } ++ [_]bool{true} ** 14;
406	var x: @Vector(16, bool) = @splat(true);	421	var x: @Vector(16, bool) = @splat(true);
...	@@ -426,6 +441,7 @@ test "bitcast nan float does not modify signaling bit" {	...	@@ -426,6 +441,7 @@ test "bitcast nan float does not modify signaling bit" {
426	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	441	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
427	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	442	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
428	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	443	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		444	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
429		445
430	// TODO: https://github.com/ziglang/zig/issues/14366	446	// TODO: https://github.com/ziglang/zig/issues/14366
431	if (builtin.zig_backend == .stage2_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	447	if (builtin.zig_backend == .stage2_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
...	@@ -482,6 +498,7 @@ test "@bitCast of packed struct of bools all true" {	...	@@ -482,6 +498,7 @@ test "@bitCast of packed struct of bools all true" {
482	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	498	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
483	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	499	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
484	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO	500	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
		501	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
485		502
486	const P = packed struct {	503	const P = packed struct {
487	b0: bool,	504	b0: bool,

...	@@ -16,6 +16,7 @@ test "@bitReverse" {	...	@@ -16,6 +16,7 @@ test "@bitReverse" {
16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
18	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	18	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		19	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
19		20
20	try comptime testBitReverse();	21	try comptime testBitReverse();
21	try testBitReverse();	22	try testBitReverse();
...	@@ -121,6 +122,7 @@ test "bitReverse vectors u8" {	...	@@ -121,6 +122,7 @@ test "bitReverse vectors u8" {
121	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	122	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	123	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
123	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	124	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		125	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
124		126
125	try comptime vector8();	127	try comptime vector8();
126	try vector8();	128	try vector8();
...	@@ -141,6 +143,7 @@ test "bitReverse vectors u16" {	...	@@ -141,6 +143,7 @@ test "bitReverse vectors u16" {
141	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
142	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	144	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
143	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	145	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		146	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
144		147
145	try comptime vector16();	148	try comptime vector16();
146	try vector16();	149	try vector16();
...	@@ -161,6 +164,7 @@ test "bitReverse vectors u24" {	...	@@ -161,6 +164,7 @@ test "bitReverse vectors u24" {
161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	164	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	165	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	166	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		167	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
164		168
165	try comptime vector24();	169	try comptime vector24();
166	try vector24();	170	try vector24();

...	@@ -3,6 +3,8 @@ const builtin = @import("builtin");	...	@@ -3,6 +3,8 @@ const builtin = @import("builtin");
3	const expect = std.testing.expect;	3	const expect = std.testing.expect;
4		4
5	test "@byteSwap integers" {	5	test "@byteSwap integers" {
		6	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		7
6	if (builtin.zig_backend == .stage2_wasm) {	8	if (builtin.zig_backend == .stage2_wasm) {
7	// TODO: Remove when self-hosted wasm supports more types for byteswap	9	// TODO: Remove when self-hosted wasm supports more types for byteswap
8	const ByteSwapIntTest = struct {	10	const ByteSwapIntTest = struct {
...	@@ -118,6 +120,7 @@ test "@byteSwap vectors u16" {	...	@@ -118,6 +120,7 @@ test "@byteSwap vectors u16" {
118	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	120	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
119	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	121	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
120	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	122	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		123	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
121		124
122	try comptime vector16();	125	try comptime vector16();
123	try vector16();	126	try vector16();
...	@@ -138,6 +141,7 @@ test "@byteSwap vectors u24" {	...	@@ -138,6 +141,7 @@ test "@byteSwap vectors u24" {
138	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	141	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
139	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	142	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
140	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	143	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		144	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
141		145
142	try comptime vector24();	146	try comptime vector24();
143	try vector24();	147	try vector24();

...	@@ -60,6 +60,7 @@ test "tuple parameters" {	...	@@ -60,6 +60,7 @@ test "tuple parameters" {
60	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	60	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
61	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	61	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
62	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	62	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		63	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
63		64
64	const add = struct {	65	const add = struct {
65	fn add(a: i32, b: i32) i32 {	66	fn add(a: i32, b: i32) i32 {
...	@@ -93,6 +94,7 @@ test "result location of function call argument through runtime condition and st	...	@@ -93,6 +94,7 @@ test "result location of function call argument through runtime condition and st
93	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	94	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
94	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	95	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
95	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	96	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		97	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
96		98
97	const E = enum { a, b };	99	const E = enum { a, b };
98	const S = struct {	100	const S = struct {
...	@@ -112,6 +114,7 @@ test "result location of function call argument through runtime condition and st	...	@@ -112,6 +114,7 @@ test "result location of function call argument through runtime condition and st
112		114
113	test "function call with 40 arguments" {	115	test "function call with 40 arguments" {
114	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	116	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		117	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
115		118
116	const S = struct {	119	const S = struct {
117	fn doTheTest(thirty_nine: i32) !void {	120	fn doTheTest(thirty_nine: i32) !void {
...	@@ -271,6 +274,7 @@ test "forced tail call" {	...	@@ -271,6 +274,7 @@ test "forced tail call" {
271	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	274	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
272	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	275	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
273	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	276	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		277	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
274		278
275	if (builtin.zig_backend == .stage2_llvm) {	279	if (builtin.zig_backend == .stage2_llvm) {
276	// Only attempt this test on targets we know have tail call support in LLVM.	280	// Only attempt this test on targets we know have tail call support in LLVM.
...	@@ -306,6 +310,7 @@ test "inline call preserves tail call" {	...	@@ -306,6 +310,7 @@ test "inline call preserves tail call" {
306	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	310	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
307	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	311	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
308	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	312	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		313	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
309		314
310	if (builtin.zig_backend == .stage2_llvm) {	315	if (builtin.zig_backend == .stage2_llvm) {
311	// Only attempt this test on targets we know have tail call support in LLVM.	316	// Only attempt this test on targets we know have tail call support in LLVM.
...	@@ -339,6 +344,7 @@ test "inline call preserves tail call" {	...	@@ -339,6 +344,7 @@ test "inline call preserves tail call" {
339	test "inline call doesn't re-evaluate non generic struct" {	344	test "inline call doesn't re-evaluate non generic struct" {
340	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	345	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
341	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	346	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		347	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
342		348
343	const S = struct {	349	const S = struct {
344	fn foo(f: struct { a: u8, b: u8 }) !void {	350	fn foo(f: struct { a: u8, b: u8 }) !void {
...	@@ -405,6 +411,7 @@ test "recursive inline call with comptime known argument" {	...	@@ -405,6 +411,7 @@ test "recursive inline call with comptime known argument" {
405	test "inline while with @call" {	411	test "inline while with @call" {
406	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	412	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
407	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	413	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		414	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
408		415
409	const S = struct {	416	const S = struct {
410	fn inc(a: *u32) void {	417	fn inc(a: *u32) void {
...	@@ -420,6 +427,8 @@ test "inline while with @call" {	...	@@ -420,6 +427,8 @@ test "inline while with @call" {
420	}	427	}
421		428
422	test "method call as parameter type" {	429	test "method call as parameter type" {
		430	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		431
423	const S = struct {	432	const S = struct {
424	fn foo(x: anytype, y: @TypeOf(x).Inner()) @TypeOf(y) {	433	fn foo(x: anytype, y: @TypeOf(x).Inner()) @TypeOf(y) {
425	return y;	434	return y;
...	@@ -437,6 +446,7 @@ test "non-anytype generic parameters provide result type" {	...	@@ -437,6 +446,7 @@ test "non-anytype generic parameters provide result type" {
437	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	446	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
438	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	447	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
439	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	448	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		449	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
440		450
441	const S = struct {	451	const S = struct {
442	fn f(comptime T: type, y: T) !void {	452	fn f(comptime T: type, y: T) !void {
...	@@ -467,6 +477,7 @@ test "argument to generic function has correct result type" {	...	@@ -467,6 +477,7 @@ test "argument to generic function has correct result type" {
467	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	477	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
468	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	478	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
469	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	479	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		480	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
470		481
471	const S = struct {	482	const S = struct {
472	fn foo(_: anytype, e: enum { a, b }) bool {	483	fn foo(_: anytype, e: enum { a, b }) bool {
...	@@ -502,6 +513,8 @@ test "call inline fn through pointer" {	...	@@ -502,6 +513,8 @@ test "call inline fn through pointer" {
502	}	513	}
503		514
504	test "call coerced function" {	515	test "call coerced function" {
		516	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		517
505	const T = struct {	518	const T = struct {
506	x: f64,	519	x: f64,
507	const T = @This();	520	const T = @This();

...	@@ -9,6 +9,7 @@ test "@intCast i32 to u7" {	...	@@ -9,6 +9,7 @@ test "@intCast i32 to u7" {
9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		12	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12		13
13	var x: u128 = maxInt(u128);	14	var x: u128 = maxInt(u128);
14	var y: i32 = 120;	15	var y: i32 = 120;
...	@@ -34,6 +35,8 @@ test "coerce i8 to i32 and @intCast back" {	...	@@ -34,6 +35,8 @@ test "coerce i8 to i32 and @intCast back" {
34	}	35	}
35		36
36	test "coerce non byte-sized integers accross 32bits boundary" {	37	test "coerce non byte-sized integers accross 32bits boundary" {
		38	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		39
37	{	40	{
38	var v: u21 = 6417;	41	var v: u21 = 6417;
39	_ = &v;	42	_ = &v;
...	@@ -163,6 +166,8 @@ const Piece = packed struct {	...	@@ -163,6 +166,8 @@ const Piece = packed struct {
163	};	166	};
164		167
165	test "load non byte-sized optional value" {	168	test "load non byte-sized optional value" {
		169	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		170
166	// Originally reported at https://github.com/ziglang/zig/issues/14200	171	// Originally reported at https://github.com/ziglang/zig/issues/14200
167	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	172	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
168		173
...	@@ -178,6 +183,8 @@ test "load non byte-sized optional value" {	...	@@ -178,6 +183,8 @@ test "load non byte-sized optional value" {
178	}	183	}
179		184
180	test "load non byte-sized value in struct" {	185	test "load non byte-sized value in struct" {
		186	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		187
181	if (builtin.cpu.arch.endian() != .little) return error.SkipZigTest; // packed struct TODO	188	if (builtin.cpu.arch.endian() != .little) return error.SkipZigTest; // packed struct TODO
182	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	189	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
183		190
...	@@ -215,6 +222,7 @@ test "load non byte-sized value in union" {	...	@@ -215,6 +222,7 @@ test "load non byte-sized value in union" {
215	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	222	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
216	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	223	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
217	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	224	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
		225	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
218		226
219	// note: this bug is triggered by the == operator, expectEqual will hide it	227	// note: this bug is triggered by the == operator, expectEqual will hide it
220	// using ptrCast not to depend on unitialised memory state	228	// using ptrCast not to depend on unitialised memory state

...	@@ -53,6 +53,7 @@ test "return variable while defer expression in scope to modify it" {	...	@@ -53,6 +53,7 @@ test "return variable while defer expression in scope to modify it" {
53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
54	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	54	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		56	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
56		57
57	const S = struct {	58	const S = struct {
58	fn doTheTest() !void {	59	fn doTheTest() !void {
...	@@ -94,6 +95,7 @@ test "mixing normal and error defers" {	...	@@ -94,6 +95,7 @@ test "mixing normal and error defers" {
94	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	95	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
95	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	96	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
96	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	97	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		98	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
97		99
98	try expect(runSomeErrorDefers(true) catch unreachable);	100	try expect(runSomeErrorDefers(true) catch unreachable);
99	try expect(result[0] == 'c');	101	try expect(result[0] == 'c');
...	@@ -114,6 +116,7 @@ test "errdefer with payload" {	...	@@ -114,6 +116,7 @@ test "errdefer with payload" {
114	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	116	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	117	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
116	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	118	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		119	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
117		120
118	const S = struct {	121	const S = struct {
119	fn foo() !i32 {	122	fn foo() !i32 {
...	@@ -136,6 +139,7 @@ test "reference to errdefer payload" {	...	@@ -136,6 +139,7 @@ test "reference to errdefer payload" {
136	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	139	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
137	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	140	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
138	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO	141	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
		142	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
139		143
140	const S = struct {	144	const S = struct {
141	fn foo() !i32 {	145	fn foo() !i32 {
...	@@ -158,6 +162,7 @@ test "reference to errdefer payload" {	...	@@ -158,6 +162,7 @@ test "reference to errdefer payload" {
158	test "simple else prong doesn't emit an error for unreachable else prong" {	162	test "simple else prong doesn't emit an error for unreachable else prong" {
159	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	163	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
160	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	164	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		165	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
161		166
162	const S = struct {	167	const S = struct {
163	fn foo() error{Foo}!void {	168	fn foo() error{Foo}!void {

...	@@ -610,6 +610,7 @@ fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void {	...	@@ -610,6 +610,7 @@ fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void {
610	test "enum with specified tag values" {	610	test "enum with specified tag values" {
611	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	611	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
612	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	612	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		613	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
613		614
614	try testEnumWithSpecifiedTagValues(MultipleChoice.C);	615	try testEnumWithSpecifiedTagValues(MultipleChoice.C);
615	try comptime testEnumWithSpecifiedTagValues(MultipleChoice.C);	616	try comptime testEnumWithSpecifiedTagValues(MultipleChoice.C);
...	@@ -618,6 +619,7 @@ test "enum with specified tag values" {	...	@@ -618,6 +619,7 @@ test "enum with specified tag values" {
618	test "non-exhaustive enum" {	619	test "non-exhaustive enum" {
619	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	620	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
620	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	621	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		622	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
621		623
622	const S = struct {	624	const S = struct {
623	const E = enum(u8) { a, b, _ };	625	const E = enum(u8) { a, b, _ };
...	@@ -682,6 +684,7 @@ test "empty non-exhaustive enum" {	...	@@ -682,6 +684,7 @@ test "empty non-exhaustive enum" {
682	test "single field non-exhaustive enum" {	684	test "single field non-exhaustive enum" {
683	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	685	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
684	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	686	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		687	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
685		688
686	const S = struct {	689	const S = struct {
687	const E = enum(u8) { a, _ };	690	const E = enum(u8) { a, _ };
...	@@ -746,6 +749,7 @@ test "cast integer literal to enum" {	...	@@ -746,6 +749,7 @@ test "cast integer literal to enum" {
746	test "enum with specified and unspecified tag values" {	749	test "enum with specified and unspecified tag values" {
747	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	750	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
748	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	751	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		752	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
749		753
750	try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);	754	try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);
751	try comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);	755	try comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);
...	@@ -854,6 +858,8 @@ fn doALoopThing(id: EnumWithOneMember) void {	...	@@ -854,6 +858,8 @@ fn doALoopThing(id: EnumWithOneMember) void {
854	}	858	}
855		859
856	test "comparison operator on enum with one member is comptime-known" {	860	test "comparison operator on enum with one member is comptime-known" {
		861	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		862
857	doALoopThing(EnumWithOneMember.Eof);	863	doALoopThing(EnumWithOneMember.Eof);
858	}	864	}
859		865
...	@@ -907,6 +913,7 @@ test "enum literal casting to tagged union" {	...	@@ -907,6 +913,7 @@ test "enum literal casting to tagged union" {
907	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	913	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
908	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	914	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
909	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	915	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		916	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
910		917
911	const Arch = union(enum) {	918	const Arch = union(enum) {
912	x86_64,	919	x86_64,
...	@@ -933,6 +940,7 @@ const Bar = enum { A, B, C, D };	...	@@ -933,6 +940,7 @@ const Bar = enum { A, B, C, D };
933	test "enum literal casting to error union with payload enum" {	940	test "enum literal casting to error union with payload enum" {
934	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	941	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
935	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	942	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		943	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
936		944
937	var bar: error{B}!Bar = undefined;	945	var bar: error{B}!Bar = undefined;
938	bar = .B; // should never cast to the error set	946	bar = .B; // should never cast to the error set
...	@@ -944,6 +952,7 @@ test "constant enum initialization with differing sizes" {	...	@@ -944,6 +952,7 @@ test "constant enum initialization with differing sizes" {
944	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	952	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
945	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	953	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
946	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	954	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		955	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
947		956
948	try test3_1(test3_foo);	957	try test3_1(test3_foo);
949	try test3_2(test3_bar);	958	try test3_2(test3_bar);
...	@@ -987,6 +996,7 @@ test "@tagName" {	...	@@ -987,6 +996,7 @@ test "@tagName" {
987	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	996	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
988	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	997	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
989	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	998	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		999	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
990		1000
991	try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));	1001	try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
992	comptime assert(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));	1002	comptime assert(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
...	@@ -1003,6 +1013,7 @@ test "@tagName non-exhaustive enum" {	...	@@ -1003,6 +1013,7 @@ test "@tagName non-exhaustive enum" {
1003	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1013	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1004	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1014	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1005	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1015	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1016	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1006		1017
1007	try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));	1018	try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
1008	comptime assert(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));	1019	comptime assert(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
...	@@ -1014,6 +1025,7 @@ test "@tagName is null-terminated" {	...	@@ -1014,6 +1025,7 @@ test "@tagName is null-terminated" {
1014	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1025	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1015	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1026	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1016	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1027	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1028	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1017		1029
1018	const S = struct {	1030	const S = struct {
1019	fn doTheTest(n: BareNumber) !void {	1031	fn doTheTest(n: BareNumber) !void {
...	@@ -1029,6 +1041,7 @@ test "tag name with assigned enum values" {	...	@@ -1029,6 +1041,7 @@ test "tag name with assigned enum values" {
1029	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1041	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1030	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1042	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1031	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1043	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1044	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1032		1045
1033	const LocalFoo = enum(u8) {	1046	const LocalFoo = enum(u8) {
1034	A = 1,	1047	A = 1,
...	@@ -1052,6 +1065,7 @@ test "tag name with signed enum values" {	...	@@ -1052,6 +1065,7 @@ test "tag name with signed enum values" {
1052	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1065	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1053	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1066	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1054	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1067	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1068	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1055		1069
1056	const LocalFoo = enum(isize) {	1070	const LocalFoo = enum(isize) {
1057	alfa = 62,	1071	alfa = 62,
...	@@ -1068,6 +1082,7 @@ test "enum literal casting to optional" {	...	@@ -1068,6 +1082,7 @@ test "enum literal casting to optional" {
1068	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	1082	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1069	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1083	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1070	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1084	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1085	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1071		1086
1072	var bar: ?Bar = undefined;	1087	var bar: ?Bar = undefined;
1073	bar = .B;	1088	bar = .B;
...	@@ -1096,6 +1111,7 @@ test "bit field access with enum fields" {	...	@@ -1096,6 +1111,7 @@ test "bit field access with enum fields" {
1096	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1111	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1097	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1112	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1098	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1113	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1114	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1099		1115
1100	var data = bit_field_1;	1116	var data = bit_field_1;
1101	try expect(getA(&data) == A.Two);	1117	try expect(getA(&data) == A.Two);
...	@@ -1136,6 +1152,7 @@ test "tag name functions are unique" {	...	@@ -1136,6 +1152,7 @@ test "tag name functions are unique" {
1136	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1152	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1137	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1153	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1138	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1154	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1155	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1139		1156
1140	{	1157	{
1141	const E = enum { a, b };	1158	const E = enum { a, b };
...	@@ -1212,6 +1229,8 @@ test "enum tag from a local variable" {	...	@@ -1212,6 +1229,8 @@ test "enum tag from a local variable" {
1212	}	1229	}
1213		1230
1214	test "auto-numbered enum with signed tag type" {	1231	test "auto-numbered enum with signed tag type" {
		1232	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1233
1215	const E = enum(i32) { a, b };	1234	const E = enum(i32) { a, b };
1216		1235
1217	try std.testing.expectEqual(@as(i32, 0), @intFromEnum(E.a));	1236	try std.testing.expectEqual(@as(i32, 0), @intFromEnum(E.a));
...	@@ -1266,6 +1285,7 @@ test "matching captures causes enum equivalence" {	...	@@ -1266,6 +1285,7 @@ test "matching captures causes enum equivalence" {
1266		1285
1267	test "large enum field values" {	1286	test "large enum field values" {
1268	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	1287	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
		1288	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1269		1289
1270	{	1290	{
1271	const E = enum(u64) { min = std.math.minInt(u64), max = std.math.maxInt(u64) };	1291	const E = enum(u64) { min = std.math.minInt(u64), max = std.math.maxInt(u64) };

...	@@ -73,6 +73,7 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {	...	@@ -73,6 +73,7 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {
73	test "constant expressions" {	73	test "constant expressions" {
74	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	74	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		76	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
76		77
77	var array: [array_size]u8 = undefined;	78	var array: [array_size]u8 = undefined;
78	_ = &array;	79	_ = &array;
...	@@ -142,6 +143,7 @@ test "pointer to type" {	...	@@ -142,6 +143,7 @@ test "pointer to type" {
142	test "a type constructed in a global expression" {	143	test "a type constructed in a global expression" {
143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	144	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
144	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	145	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		146	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
145		147
146	var l: List = undefined;	148	var l: List = undefined;
147	l.array[0] = 10;	149	l.array[0] = 10;
...	@@ -394,6 +396,7 @@ test "return 0 from function that has u0 return type" {	...	@@ -394,6 +396,7 @@ test "return 0 from function that has u0 return type" {
394	test "statically initialized struct" {	396	test "statically initialized struct" {
395	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	397	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
396	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	398	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		399	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
397		400
398	st_init_str_foo.x += 1;	401	st_init_str_foo.x += 1;
399	try expect(st_init_str_foo.x == 14);	402	try expect(st_init_str_foo.x == 14);
...	@@ -444,6 +447,7 @@ test "binary math operator in partially inlined function" {	...	@@ -444,6 +447,7 @@ test "binary math operator in partially inlined function" {
444	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	447	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
445	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	448	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
446	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	449	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		450	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
447		451
448	var s: [4]u32 = undefined;	452	var s: [4]u32 = undefined;
449	var b: [16]u8 = undefined;	453	var b: [16]u8 = undefined;
...	@@ -489,6 +493,7 @@ test "comptime bitwise operators" {	...	@@ -489,6 +493,7 @@ test "comptime bitwise operators" {
489		493
490	test "comptime shlWithOverflow" {	494	test "comptime shlWithOverflow" {
491	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	495	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		496	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
492		497
493	const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0];	498	const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0];
494	var a = ~@as(u64, 0);	499	var a = ~@as(u64, 0);
...	@@ -501,6 +506,7 @@ test "comptime shlWithOverflow" {	...	@@ -501,6 +506,7 @@ test "comptime shlWithOverflow" {
501	test "const ptr to variable data changes at runtime" {	506	test "const ptr to variable data changes at runtime" {
502	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	507	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
503	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	508	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		509	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
504		510
505	try expect(foo_ref.name[0] == 'a');	511	try expect(foo_ref.name[0] == 'a');
506	foo_ref.name = "b";	512	foo_ref.name = "b";
...	@@ -522,6 +528,7 @@ test "runtime 128 bit integer division" {	...	@@ -522,6 +528,7 @@ test "runtime 128 bit integer division" {
522	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	528	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
523	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	529	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
524	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	530	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		531	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
525		532
526	var a: u128 = 152313999999999991610955792383;	533	var a: u128 = 152313999999999991610955792383;
527	var b: u128 = 10000000000000000000;	534	var b: u128 = 10000000000000000000;
...	@@ -542,6 +549,7 @@ test "static eval list init" {	...	@@ -542,6 +549,7 @@ test "static eval list init" {
542	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	549	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
543	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	550	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
544	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	551	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		552	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
545		553
546	try expect(static_vec3.data[2] == 1.0);	554	try expect(static_vec3.data[2] == 1.0);
547	try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0);	555	try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0);
...	@@ -713,6 +721,8 @@ fn loopNTimes(comptime n: usize) void {	...	@@ -713,6 +721,8 @@ fn loopNTimes(comptime n: usize) void {
713	}	721	}
714		722
715	test "variable inside inline loop that has different types on different iterations" {	723	test "variable inside inline loop that has different types on different iterations" {
		724	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		725
716	try testVarInsideInlineLoop(.{ true, @as(u32, 42) });	726	try testVarInsideInlineLoop(.{ true, @as(u32, 42) });
717	}	727	}
718		728
...	@@ -736,6 +746,7 @@ test "array concatenation of function calls" {	...	@@ -736,6 +746,7 @@ test "array concatenation of function calls" {
736	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	746	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
737	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	747	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
738	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	748	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		749	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
739		750
740	var a = oneItem(3) ++ oneItem(4);	751	var a = oneItem(3) ++ oneItem(4);
741	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));	752	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
...	@@ -745,6 +756,7 @@ test "array multiplication of function calls" {	...	@@ -745,6 +756,7 @@ test "array multiplication of function calls" {
745	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	756	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
746	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	757	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
747	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	758	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		759	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
748		760
749	var a = oneItem(3) ** scalar(2);	761	var a = oneItem(3) ** scalar(2);
750	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));	762	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));
...	@@ -762,6 +774,7 @@ test "array concatenation peer resolves element types - value" {	...	@@ -762,6 +774,7 @@ test "array concatenation peer resolves element types - value" {
762	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	774	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
763	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	775	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
764	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	776	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		777	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
765		778
766	var a = [2]u3{ 1, 7 };	779	var a = [2]u3{ 1, 7 };
767	var b = [3]u8{ 200, 225, 255 };	780	var b = [3]u8{ 200, 225, 255 };
...	@@ -779,6 +792,7 @@ test "array concatenation peer resolves element types - pointer" {	...	@@ -779,6 +792,7 @@ test "array concatenation peer resolves element types - pointer" {
779	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	792	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
780	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	793	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
781	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	794	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		795	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
782		796
783	var a = [2]u3{ 1, 7 };	797	var a = [2]u3{ 1, 7 };
784	var b = [3]u8{ 200, 225, 255 };	798	var b = [3]u8{ 200, 225, 255 };
...	@@ -795,6 +809,7 @@ test "array concatenation sets the sentinel - value" {	...	@@ -795,6 +809,7 @@ test "array concatenation sets the sentinel - value" {
795	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	809	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
796	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	810	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
797	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	811	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		812	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
798		813
799	var a = [2]u3{ 1, 7 };	814	var a = [2]u3{ 1, 7 };
800	var b = [3:69]u8{ 200, 225, 255 };	815	var b = [3:69]u8{ 200, 225, 255 };
...	@@ -813,6 +828,7 @@ test "array concatenation sets the sentinel - value" {	...	@@ -813,6 +828,7 @@ test "array concatenation sets the sentinel - value" {
813	test "array concatenation sets the sentinel - pointer" {	828	test "array concatenation sets the sentinel - pointer" {
814	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	829	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
815	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	830	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		831	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
816		832
817	var a = [2]u3{ 1, 7 };	833	var a = [2]u3{ 1, 7 };
818	var b = [3:69]u8{ 200, 225, 255 };	834	var b = [3:69]u8{ 200, 225, 255 };
...	@@ -831,6 +847,7 @@ test "array multiplication sets the sentinel - value" {	...	@@ -831,6 +847,7 @@ test "array multiplication sets the sentinel - value" {
831	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	847	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
832	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	848	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
833	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	849	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		850	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
834		851
835	var a = [2:7]u3{ 1, 6 };	852	var a = [2:7]u3{ 1, 6 };
836	_ = &a;	853	_ = &a;
...	@@ -848,6 +865,7 @@ test "array multiplication sets the sentinel - pointer" {	...	@@ -848,6 +865,7 @@ test "array multiplication sets the sentinel - pointer" {
848	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	865	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
849	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	866	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
850	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	867	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		868	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
851		869
852	var a = [2:7]u3{ 1, 6 };	870	var a = [2:7]u3{ 1, 6 };
853	const b = &a ** 2;	871	const b = &a ** 2;
...	@@ -1070,6 +1088,7 @@ test "comptime break operand passing through runtime condition converted to runt	...	@@ -1070,6 +1088,7 @@ test "comptime break operand passing through runtime condition converted to runt
1070	test "comptime break operand passing through runtime switch converted to runtime break" {	1088	test "comptime break operand passing through runtime switch converted to runtime break" {
1071	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1089	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1072	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1090	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1091	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1073		1092
1074	const S = struct {	1093	const S = struct {
1075	fn doTheTest(runtime: u8) !void {	1094	fn doTheTest(runtime: u8) !void {
...	@@ -1090,6 +1109,7 @@ test "comptime break operand passing through runtime switch converted to runtime	...	@@ -1090,6 +1109,7 @@ test "comptime break operand passing through runtime switch converted to runtime
1090	test "no dependency loop for alignment of self struct" {	1109	test "no dependency loop for alignment of self struct" {
1091	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1110	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1092	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1112	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1093		1113
1094	const S = struct {	1114	const S = struct {
1095	fn doTheTest() !void {	1115	fn doTheTest() !void {
...	@@ -1127,6 +1147,7 @@ test "no dependency loop for alignment of self struct" {	...	@@ -1127,6 +1147,7 @@ test "no dependency loop for alignment of self struct" {
1127	test "no dependency loop for alignment of self bare union" {	1147	test "no dependency loop for alignment of self bare union" {
1128	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1148	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1129	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1149	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1150	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1130		1151
1131	const S = struct {	1152	const S = struct {
1132	fn doTheTest() !void {	1153	fn doTheTest() !void {
...	@@ -1164,6 +1185,7 @@ test "no dependency loop for alignment of self bare union" {	...	@@ -1164,6 +1185,7 @@ test "no dependency loop for alignment of self bare union" {
1164	test "no dependency loop for alignment of self tagged union" {	1185	test "no dependency loop for alignment of self tagged union" {
1165	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1186	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1166	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1187	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1188	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1167		1189
1168	const S = struct {	1190	const S = struct {
1169	fn doTheTest() !void {	1191	fn doTheTest() !void {
...	@@ -1354,6 +1376,7 @@ test "lazy value is resolved as slice operand" {	...	@@ -1354,6 +1376,7 @@ test "lazy value is resolved as slice operand" {
1354	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1376	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1355	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1377	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1356	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1378	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1379	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1357		1380
1358	const A = struct { a: u32 };	1381	const A = struct { a: u32 };
1359	var a: [512]u64 = undefined;	1382	var a: [512]u64 = undefined;
...	@@ -1533,6 +1556,7 @@ test "non-optional and optional array elements concatenated" {	...	@@ -1533,6 +1556,7 @@ test "non-optional and optional array elements concatenated" {
1533	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1556	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1534	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1557	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1535	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1558	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1559	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1536		1560
1537	const array = [1]u8{'A'} ++ [1]?u8{null};	1561	const array = [1]u8{'A'} ++ [1]?u8{null};
1538	var index: usize = 0;	1562	var index: usize = 0;
...	@@ -1607,6 +1631,8 @@ test "struct in comptime false branch is not evaluated" {	...	@@ -1607,6 +1631,8 @@ test "struct in comptime false branch is not evaluated" {
1607	}	1631	}
1608		1632
1609	test "result of nested switch assigned to variable" {	1633	test "result of nested switch assigned to variable" {
		1634	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1635
1610	var zds: u32 = 0;	1636	var zds: u32 = 0;
1611	zds = switch (zds) {	1637	zds = switch (zds) {
1612	0 => switch (zds) {	1638	0 => switch (zds) {
...	@@ -1621,6 +1647,8 @@ test "result of nested switch assigned to variable" {	...	@@ -1621,6 +1647,8 @@ test "result of nested switch assigned to variable" {
1621	}	1647	}
1622		1648
1623	test "inline for loop of functions returning error unions" {	1649	test "inline for loop of functions returning error unions" {
		1650	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1651
1624	const T1 = struct {	1652	const T1 = struct {
1625	fn v() error{}!usize {	1653	fn v() error{}!usize {
1626	return 1;	1654	return 1;
...	@@ -1639,6 +1667,8 @@ test "inline for loop of functions returning error unions" {	...	@@ -1639,6 +1667,8 @@ test "inline for loop of functions returning error unions" {
1639	}	1667	}
1640		1668
1641	test "if inside a switch" {	1669	test "if inside a switch" {
		1670	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1671
1642	var condition = true;	1672	var condition = true;
1643	var wave_type: u32 = 0;	1673	var wave_type: u32 = 0;
1644	_ = .{ &condition, &wave_type };	1674	_ = .{ &condition, &wave_type };

...	@@ -48,6 +48,7 @@ test "exporting using field access" {	...	@@ -48,6 +48,7 @@ test "exporting using field access" {
48	test "exporting comptime-known value" {	48	test "exporting comptime-known value" {
49	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	49	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
50	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	50	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		51	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
51	if (builtin.zig_backend == .stage2_x86_64 and	52	if (builtin.zig_backend == .stage2_x86_64 and
52	(builtin.target.ofmt != .elf and	53	(builtin.target.ofmt != .elf and
53	builtin.target.ofmt != .macho and	54	builtin.target.ofmt != .macho and
...	@@ -67,6 +68,7 @@ test "exporting comptime-known value" {	...	@@ -67,6 +68,7 @@ test "exporting comptime-known value" {
67	test "exporting comptime var" {	68	test "exporting comptime var" {
68	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	69	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	70	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		71	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
70	if (builtin.zig_backend == .stage2_x86_64 and	72	if (builtin.zig_backend == .stage2_x86_64 and
71	(builtin.target.ofmt != .elf and	73	(builtin.target.ofmt != .elf and
72	builtin.target.ofmt != .macho and	74	builtin.target.ofmt != .macho and

...	@@ -7,6 +7,7 @@ test "anyopaque extern symbol" {	...	@@ -7,6 +7,7 @@ test "anyopaque extern symbol" {
7	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	7	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
8	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	8	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10		11
11	const a = @extern(*anyopaque, .{ .name = "a_mystery_symbol" });	12	const a = @extern(*anyopaque, .{ .name = "a_mystery_symbol" });
12	const b: *i32 = @alignCast(@ptrCast(a));	13	const b: *i32 = @alignCast(@ptrCast(a));
...	@@ -19,6 +20,7 @@ test "function extern symbol" {	...	@@ -19,6 +20,7 @@ test "function extern symbol" {
19	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	20	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
20	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	21	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	22	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		23	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
22		24
23	const a = @extern(*const fn () callconv(.C) i32, .{ .name = "a_mystery_function" });	25	const a = @extern(*const fn () callconv(.C) i32, .{ .name = "a_mystery_function" });
24	try expect(a() == 4567);	26	try expect(a() == 4567);
...	@@ -32,6 +34,7 @@ test "function extern symbol matches extern decl" {	...	@@ -32,6 +34,7 @@ test "function extern symbol matches extern decl" {
32	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	34	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
33	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	35	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
34	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	36	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		37	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
35		38
36	const S = struct {	39	const S = struct {
37	extern fn another_mystery_function() u32;	40	extern fn another_mystery_function() u32;

...	@@ -71,6 +71,7 @@ fn outer(y: u32) *const fn (u32) u32 {	...	@@ -71,6 +71,7 @@ fn outer(y: u32) *const fn (u32) u32 {
71		71
72	test "return inner function which references comptime variable of outer function" {	72	test "return inner function which references comptime variable of outer function" {
73	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	73	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		74	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
74		75
75	const func = outer(10);	76	const func = outer(10);
76	try expect(func(3) == 7);	77	try expect(func(3) == 7);
...	@@ -80,6 +81,7 @@ test "discard the result of a function that returns a struct" {	...	@@ -80,6 +81,7 @@ test "discard the result of a function that returns a struct" {
80	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	81	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
81	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	82	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
82	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	83	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		84	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
83		85
84	const S = struct {	86	const S = struct {
85	fn entry() void {	87	fn entry() void {
...	@@ -104,6 +106,7 @@ test "inline function call that calls optional function pointer, return pointer	...	@@ -104,6 +106,7 @@ test "inline function call that calls optional function pointer, return pointer
104	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	106	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	108	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		109	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
107		110
108	const S = struct {	111	const S = struct {
109	field: u32,	112	field: u32,
...	@@ -181,12 +184,14 @@ test "function with complex callconv and return type expressions" {	...	@@ -181,12 +184,14 @@ test "function with complex callconv and return type expressions" {
181	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	184	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
182	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	185	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
183	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	186	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		187	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
184		188
185	try expect(fComplexCallconvRet(3).x == 9);	189	try expect(fComplexCallconvRet(3).x == 9);
186	}	190	}
187		191
188	test "pass by non-copying value" {	192	test "pass by non-copying value" {
189	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	193	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		194	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
190		195
191	try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);	196	try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
192	}	197	}
...	@@ -202,6 +207,7 @@ fn addPointCoords(pt: Point) i32 {	...	@@ -202,6 +207,7 @@ fn addPointCoords(pt: Point) i32 {
202		207
203	test "pass by non-copying value through var arg" {	208	test "pass by non-copying value through var arg" {
204	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	209	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		210	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
205		211
206	try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);	212	try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);
207	}	213	}
...	@@ -213,6 +219,7 @@ fn addPointCoordsVar(pt: anytype) !i32 {	...	@@ -213,6 +219,7 @@ fn addPointCoordsVar(pt: anytype) !i32 {
213		219
214	test "pass by non-copying value as method" {	220	test "pass by non-copying value as method" {
215	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		222	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
216		223
217	var pt = Point2{ .x = 1, .y = 2 };	224	var pt = Point2{ .x = 1, .y = 2 };
218	try expect(pt.addPointCoords() == 3);	225	try expect(pt.addPointCoords() == 3);
...	@@ -229,6 +236,7 @@ const Point2 = struct {	...	@@ -229,6 +236,7 @@ const Point2 = struct {
229		236
230	test "pass by non-copying value as method, which is generic" {	237	test "pass by non-copying value as method, which is generic" {
231	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	238	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		239	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
232		240
233	var pt = Point3{ .x = 1, .y = 2 };	241	var pt = Point3{ .x = 1, .y = 2 };
234	try expect(pt.addPointCoords(i32) == 3);	242	try expect(pt.addPointCoords(i32) == 3);
...	@@ -257,6 +265,7 @@ test "implicit cast fn call result to optional in field result" {	...	@@ -257,6 +265,7 @@ test "implicit cast fn call result to optional in field result" {
257	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	265	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
258	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	266	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	267	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		268	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
260		269
261	const S = struct {	270	const S = struct {
262	fn entry() !void {	271	fn entry() !void {
...	@@ -283,6 +292,7 @@ test "implicit cast fn call result to optional in field result" {	...	@@ -283,6 +292,7 @@ test "implicit cast fn call result to optional in field result" {
283	test "void parameters" {	292	test "void parameters" {
284	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	293	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
285	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	294	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		295	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
286		296
287	try voidFun(1, void{}, 2, {});	297	try voidFun(1, void{}, 2, {});
288	}	298	}
...	@@ -346,6 +356,7 @@ test "function call with anon list literal" {	...	@@ -346,6 +356,7 @@ test "function call with anon list literal" {
346	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	356	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
347	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	357	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
348	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	358	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		359	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
349		360
350	const S = struct {	361	const S = struct {
351	fn doTheTest() !void {	362	fn doTheTest() !void {
...	@@ -366,6 +377,7 @@ test "function call with anon list literal - 2D" {	...	@@ -366,6 +377,7 @@ test "function call with anon list literal - 2D" {
366	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	377	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
367	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	378	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
368	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	379	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		380	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
369		381
370	const S = struct {	382	const S = struct {
371	fn doTheTest() !void {	383	fn doTheTest() !void {
...	@@ -402,6 +414,8 @@ test "ability to give comptime types and non comptime types to same parameter" {	...	@@ -402,6 +414,8 @@ test "ability to give comptime types and non comptime types to same parameter" {
402	}	414	}
403		415
404	test "function with inferred error set but returning no error" {	416	test "function with inferred error set but returning no error" {
		417	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		418
405	const S = struct {	419	const S = struct {
406	fn foo() !void {}	420	fn foo() !void {}
407	};	421	};
...	@@ -412,6 +426,7 @@ test "function with inferred error set but returning no error" {	...	@@ -412,6 +426,7 @@ test "function with inferred error set but returning no error" {
412		426
413	test "import passed byref to function in return type" {	427	test "import passed byref to function in return type" {
414	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	428	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		429	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
415		430
416	const S = struct {	431	const S = struct {
417	fn get() @import("std").ArrayListUnmanaged(i32) {	432	fn get() @import("std").ArrayListUnmanaged(i32) {
...	@@ -429,6 +444,7 @@ test "implicit cast function to function ptr" {	...	@@ -429,6 +444,7 @@ test "implicit cast function to function ptr" {
429	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	444	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
430	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	445	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
431	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	446	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		447	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
432		448
433	const S1 = struct {	449	const S1 = struct {
434	export fn someFunctionThatReturnsAValue() c_int {	450	export fn someFunctionThatReturnsAValue() c_int {
...	@@ -449,6 +465,7 @@ test "implicit cast function to function ptr" {	...	@@ -449,6 +465,7 @@ test "implicit cast function to function ptr" {
449	test "method call with optional and error union first param" {	465	test "method call with optional and error union first param" {
450	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	466	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
451	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	467	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		468	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
452		469
453	const S = struct {	470	const S = struct {
454	x: i32 = 1234,	471	x: i32 = 1234,
...	@@ -468,6 +485,7 @@ test "method call with optional and error union first param" {	...	@@ -468,6 +485,7 @@ test "method call with optional and error union first param" {
468	test "method call with optional pointer first param" {	485	test "method call with optional pointer first param" {
469	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	486	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
470	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	487	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		488	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
471		489
472	const S = struct {	490	const S = struct {
473	x: i32 = 1234,	491	x: i32 = 1234,
...	@@ -487,6 +505,7 @@ test "using @ptrCast on function pointers" {	...	@@ -487,6 +505,7 @@ test "using @ptrCast on function pointers" {
487	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	505	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
488	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	506	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
489	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	507	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		508	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
490		509
491	const S = struct {	510	const S = struct {
492	const A = struct { data: [4]u8 };	511	const A = struct { data: [4]u8 };
...	@@ -524,6 +543,7 @@ test "function returns function returning type" {	...	@@ -524,6 +543,7 @@ test "function returns function returning type" {
524		543
525	test "peer type resolution of inferred error set with non-void payload" {	544	test "peer type resolution of inferred error set with non-void payload" {
526	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	545	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		546	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
527		547
528	const S = struct {	548	const S = struct {
529	fn openDataFile(mode: enum { read, write }) !u32 {	549	fn openDataFile(mode: enum { read, write }) !u32 {
...	@@ -566,6 +586,8 @@ test "lazy values passed to anytype parameter" {	...	@@ -566,6 +586,8 @@ test "lazy values passed to anytype parameter" {
566	}	586	}
567		587
568	test "pass and return comptime-only types" {	588	test "pass and return comptime-only types" {
		589	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		590
569	const S = struct {	591	const S = struct {
570	fn returnNull(comptime x: @Type(.Null)) @Type(.Null) {	592	fn returnNull(comptime x: @Type(.Null)) @Type(.Null) {
571	return x;	593	return x;

...	@@ -69,6 +69,7 @@ test "basic for loop" {	...	@@ -69,6 +69,7 @@ test "basic for loop" {
69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		72	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
72		73
73	const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3;	74	const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3;
74		75
...	@@ -112,6 +113,7 @@ test "for with null and T peer types and inferred result location type" {	...	@@ -112,6 +113,7 @@ test "for with null and T peer types and inferred result location type" {
112	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	113	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
113	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
114	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		116	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
115		117
116	const S = struct {	118	const S = struct {
117	fn doTheTest(slice: []const u8) !void {	119	fn doTheTest(slice: []const u8) !void {
...	@@ -132,6 +134,7 @@ test "for with null and T peer types and inferred result location type" {	...	@@ -132,6 +134,7 @@ test "for with null and T peer types and inferred result location type" {
132	test "2 break statements and an else" {	134	test "2 break statements and an else" {
133	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	135	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
134	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	136	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		137	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
135		138
136	const S = struct {	139	const S = struct {
137	fn entry(t: bool, f: bool) !void {	140	fn entry(t: bool, f: bool) !void {
...	@@ -153,6 +156,7 @@ test "for loop with pointer elem var" {	...	@@ -153,6 +156,7 @@ test "for loop with pointer elem var" {
153	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	156	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
154	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	157	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	158	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		159	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
156		160
157	const source = "abcdefg";	161	const source = "abcdefg";
158	var target: [source.len]u8 = undefined;	162	var target: [source.len]u8 = undefined;
...	@@ -179,6 +183,7 @@ fn mangleString(s: []u8) void {	...	@@ -179,6 +183,7 @@ fn mangleString(s: []u8) void {
179	test "for copies its payload" {	183	test "for copies its payload" {
180	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	184	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
181	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	185	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		186	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
182		187
183	const S = struct {	188	const S = struct {
184	fn doTheTest() !void {	189	fn doTheTest() !void {
...	@@ -198,6 +203,7 @@ test "for on slice with allowzero ptr" {	...	@@ -198,6 +203,7 @@ test "for on slice with allowzero ptr" {
198	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	203	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
199	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	204	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	205	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		206	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
201		207
202	const S = struct {	208	const S = struct {
203	fn doTheTest(slice: []const u8) !void {	209	fn doTheTest(slice: []const u8) !void {
...	@@ -213,6 +219,7 @@ test "for on slice with allowzero ptr" {	...	@@ -213,6 +219,7 @@ test "for on slice with allowzero ptr" {
213	test "else continue outer for" {	219	test "else continue outer for" {
214	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	220	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
215	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		222	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
216		223
217	var i: usize = 6;	224	var i: usize = 6;
218	var buf: [5]u8 = undefined;	225	var buf: [5]u8 = undefined;
...	@@ -226,6 +233,7 @@ test "else continue outer for" {	...	@@ -226,6 +233,7 @@ test "else continue outer for" {
226		233
227	test "for loop with else branch" {	234	test "for loop with else branch" {
228	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	235	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		236	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
229		237
230	{	238	{
231	var x = [_]u32{ 1, 2 };	239	var x = [_]u32{ 1, 2 };
...	@@ -275,6 +283,7 @@ test "two counters" {	...	@@ -275,6 +283,7 @@ test "two counters" {
275	test "1-based counter and ptr to array" {	283	test "1-based counter and ptr to array" {
276	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	284	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
277	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	285	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		286	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
278		287
279	var ok: usize = 0;	288	var ok: usize = 0;
280		289
...	@@ -308,6 +317,7 @@ test "slice and two counters, one is offset and one is runtime" {	...	@@ -308,6 +317,7 @@ test "slice and two counters, one is offset and one is runtime" {
308	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	317	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
309	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	318	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
310	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	319	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		320	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
311		321
312	const slice: []const u8 = "blah";	322	const slice: []const u8 = "blah";
313	var start: usize = 0;	323	var start: usize = 0;
...	@@ -337,6 +347,7 @@ test "two slices, one captured by-ref" {	...	@@ -337,6 +347,7 @@ test "two slices, one captured by-ref" {
337	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	347	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
338	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	348	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
339	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	349	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		350	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
340		351
341	var buf: [10]u8 = undefined;	352	var buf: [10]u8 = undefined;
342	const slice1: []const u8 = "blah";	353	const slice1: []const u8 = "blah";
...	@@ -356,6 +367,7 @@ test "raw pointer and slice" {	...	@@ -356,6 +367,7 @@ test "raw pointer and slice" {
356	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	367	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
357	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	368	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
358	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	369	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		370	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
359		371
360	var buf: [10]u8 = undefined;	372	var buf: [10]u8 = undefined;
361	const slice: []const u8 = "blah";	373	const slice: []const u8 = "blah";
...	@@ -375,6 +387,7 @@ test "raw pointer and counter" {	...	@@ -375,6 +387,7 @@ test "raw pointer and counter" {
375	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	387	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
376	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	388	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
377	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	389	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		390	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
378		391
379	var buf: [10]u8 = undefined;	392	var buf: [10]u8 = undefined;
380	const ptr: [*]u8 = &buf;	393	const ptr: [*]u8 = &buf;
...	@@ -393,6 +406,7 @@ test "inline for with slice as the comptime-known" {	...	@@ -393,6 +406,7 @@ test "inline for with slice as the comptime-known" {
393	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	406	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
394	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	407	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
395	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	408	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		409	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
396		410
397	const comptime_slice = "hello";	411	const comptime_slice = "hello";
398	var runtime_i: usize = 3;	412	var runtime_i: usize = 3;
...	@@ -424,6 +438,7 @@ test "inline for with counter as the comptime-known" {	...	@@ -424,6 +438,7 @@ test "inline for with counter as the comptime-known" {
424	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	438	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
425	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	439	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
426	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	440	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		441	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
427		442
428	var runtime_slice = "hello";	443	var runtime_slice = "hello";
429	var runtime_i: usize = 3;	444	var runtime_i: usize = 3;
...	@@ -456,6 +471,7 @@ test "inline for on tuple pointer" {	...	@@ -456,6 +471,7 @@ test "inline for on tuple pointer" {
456	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	471	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
457	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	472	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
458	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	473	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		474	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
459		475
460	const S = struct { u32, u32, u32 };	476	const S = struct { u32, u32, u32 };
461	var s: S = .{ 100, 200, 300 };	477	var s: S = .{ 100, 200, 300 };
...	@@ -471,6 +487,7 @@ test "ref counter that starts at zero" {	...	@@ -471,6 +487,7 @@ test "ref counter that starts at zero" {
471	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	487	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
472	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	488	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
473	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	489	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		490	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
474		491
475	for ([_]usize{ 0, 1, 2 }, 0..) \|i, j\| {	492	for ([_]usize{ 0, 1, 2 }, 0..) \|i, j\| {
476	try expectEqual(i, j);	493	try expectEqual(i, j);
...	@@ -486,6 +503,7 @@ test "inferred alloc ptr of for loop" {	...	@@ -486,6 +503,7 @@ test "inferred alloc ptr of for loop" {
486	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	503	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
487	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	504	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
488	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	505	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		506	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
489		507
490	{	508	{
491	var cond = false;	509	var cond = false;

...	@@ -19,6 +19,7 @@ fn checkSize(comptime T: type) usize {	...	@@ -19,6 +19,7 @@ fn checkSize(comptime T: type) usize {
19	test "simple generic fn" {	19	test "simple generic fn" {
20	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	20	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	21	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		22	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
22		23
23	try expect(max(i32, 3, -1) == 3);	24	try expect(max(i32, 3, -1) == 3);
24	try expect(max(u8, 1, 100) == 100);	25	try expect(max(u8, 1, 100) == 100);
...	@@ -55,6 +56,7 @@ test "fn with comptime args" {	...	@@ -55,6 +56,7 @@ test "fn with comptime args" {
55	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	56	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	57	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
57	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	58	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		59	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
58		60
59	try expect(gimmeTheBigOne(1234, 5678) == 5678);	61	try expect(gimmeTheBigOne(1234, 5678) == 5678);
60	try expect(shouldCallSameInstance(34, 12) == 34);	62	try expect(shouldCallSameInstance(34, 12) == 34);
...	@@ -65,6 +67,7 @@ test "anytype params" {	...	@@ -65,6 +67,7 @@ test "anytype params" {
65	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	67	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
66	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	68	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	69	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		70	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
68		71
69	try expect(max_i32(12, 34) == 34);	72	try expect(max_i32(12, 34) == 34);
70	try expect(max_f64(1.2, 3.4) == 3.4);	73	try expect(max_f64(1.2, 3.4) == 3.4);
...	@@ -89,6 +92,7 @@ fn max_f64(a: f64, b: f64) f64 {	...	@@ -89,6 +92,7 @@ fn max_f64(a: f64, b: f64) f64 {
89	test "type constructed by comptime function call" {	92	test "type constructed by comptime function call" {
90	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	93	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
91	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	94	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		95	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
92		96
93	var l: SimpleList(10) = undefined;	97	var l: SimpleList(10) = undefined;
94	l.array[0] = 10;	98	l.array[0] = 10;
...	@@ -113,6 +117,7 @@ test "function with return type type" {	...	@@ -113,6 +117,7 @@ test "function with return type type" {
113	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	117	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	118	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	119	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		120	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
116		121
117	var list: List(i32) = undefined;	122	var list: List(i32) = undefined;
118	var list2: List(i32) = undefined;	123	var list2: List(i32) = undefined;
...	@@ -154,6 +159,7 @@ test "generic fn with implicit cast" {	...	@@ -154,6 +159,7 @@ test "generic fn with implicit cast" {
154	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	159	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
155	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	160	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
156	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	161	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		162	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
157		163
158	try expect(getFirstByte(u8, &[_]u8{13}) == 13);	164	try expect(getFirstByte(u8, &[_]u8{13}) == 13);
159	try expect(getFirstByte(u16, &[_]u16{	165	try expect(getFirstByte(u16, &[_]u16{
...	@@ -172,6 +178,7 @@ test "generic fn keeps non-generic parameter types" {	...	@@ -172,6 +178,7 @@ test "generic fn keeps non-generic parameter types" {
172	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	178	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
173	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	179	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
174	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	180	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		181	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
175		182
176	const A = 128;	183	const A = 128;
177		184
...	@@ -280,6 +287,7 @@ test "generic function instantiation turns into comptime call" {	...	@@ -280,6 +287,7 @@ test "generic function instantiation turns into comptime call" {
280		287
281	test "generic function with void and comptime parameter" {	288	test "generic function with void and comptime parameter" {
282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	289	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		290	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
283		291
284	const S = struct { x: i32 };	292	const S = struct { x: i32 };
285	const namespace = struct {	293	const namespace = struct {
...	@@ -296,6 +304,7 @@ test "generic function with void and comptime parameter" {	...	@@ -296,6 +304,7 @@ test "generic function with void and comptime parameter" {
296	test "anonymous struct return type referencing comptime parameter" {	304	test "anonymous struct return type referencing comptime parameter" {
297	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	305	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
298	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	306	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		307	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
299		308
300	const S = struct {	309	const S = struct {
301	pub fn extraData(comptime T: type, index: usize) struct { data: T, end: usize } {	310	pub fn extraData(comptime T: type, index: usize) struct { data: T, end: usize } {
...	@@ -314,6 +323,7 @@ test "generic function instantiation non-duplicates" {	...	@@ -314,6 +323,7 @@ test "generic function instantiation non-duplicates" {
314	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	323	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
315	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	324	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
316	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	325	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		326	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
317	if (builtin.os.tag == .wasi) return error.SkipZigTest;	327	if (builtin.os.tag == .wasi) return error.SkipZigTest;
318		328
319	const S = struct {	329	const S = struct {
...	@@ -385,6 +395,7 @@ test "extern function used as generic parameter" {	...	@@ -385,6 +395,7 @@ test "extern function used as generic parameter" {
385		395
386	test "generic struct as parameter type" {	396	test "generic struct as parameter type" {
387	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	397	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		398	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
388		399
389	const S = struct {	400	const S = struct {
390	fn doTheTest(comptime Int: type, thing: struct { int: Int }) !void {	401	fn doTheTest(comptime Int: type, thing: struct { int: Int }) !void {
...	@@ -399,6 +410,8 @@ test "generic struct as parameter type" {	...	@@ -399,6 +410,8 @@ test "generic struct as parameter type" {
399	}	410	}
400		411
401	test "slice as parameter type" {	412	test "slice as parameter type" {
		413	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		414
402	const S = struct {	415	const S = struct {
403	fn internComptimeString(comptime str: []const u8) *const []const u8 {	416	fn internComptimeString(comptime str: []const u8) *const []const u8 {
404	return &struct {	417	return &struct {
...	@@ -423,6 +436,7 @@ test "null sentinel pointer passed as generic argument" {	...	@@ -423,6 +436,7 @@ test "null sentinel pointer passed as generic argument" {
423		436
424	test "generic function passed as comptime argument" {	437	test "generic function passed as comptime argument" {
425	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	438	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		439	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
426		440
427	const S = struct {	441	const S = struct {
428	fn doMath(comptime f: fn (type, i32, i32) error{Overflow}!i32, a: i32, b: i32) !void {	442	fn doMath(comptime f: fn (type, i32, i32) error{Overflow}!i32, a: i32, b: i32) !void {
...	@@ -435,6 +449,7 @@ test "generic function passed as comptime argument" {	...	@@ -435,6 +449,7 @@ test "generic function passed as comptime argument" {
435		449
436	test "return type of generic function is function pointer" {	450	test "return type of generic function is function pointer" {
437	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	451	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		452	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
438		453
439	const S = struct {	454	const S = struct {
440	fn b(comptime T: type) ?*const fn () error{}!T {	455	fn b(comptime T: type) ?*const fn () error{}!T {
...	@@ -447,6 +462,7 @@ test "return type of generic function is function pointer" {	...	@@ -447,6 +462,7 @@ test "return type of generic function is function pointer" {
447		462
448	test "coerced function body has inequal value with its uncoerced body" {	463	test "coerced function body has inequal value with its uncoerced body" {
449	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	464	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		465	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
450		466
451	const S = struct {	467	const S = struct {
452	const A = B(i32, c);	468	const A = B(i32, c);
...	@@ -496,6 +512,7 @@ test "union in struct captures argument" {	...	@@ -496,6 +512,7 @@ test "union in struct captures argument" {
496	test "function argument tuple used as struct field" {	512	test "function argument tuple used as struct field" {
497	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	513	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
498	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	514	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		515	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
499		516
500	const S = struct {	517	const S = struct {
501	fn DeleagateWithContext(comptime Function: type) type {	518	fn DeleagateWithContext(comptime Function: type) type {
...	@@ -530,6 +547,7 @@ test "call generic function with from function called by the generic function" {	...	@@ -530,6 +547,7 @@ test "call generic function with from function called by the generic function" {
530	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	547	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
531	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	548	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
532	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	549	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		550	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
533	if (builtin.zig_backend == .stage2_llvm and	551	if (builtin.zig_backend == .stage2_llvm and
534	builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;	552	builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;
535		553
...	@@ -572,6 +590,7 @@ fn StructCapture(comptime T: type) type {	...	@@ -572,6 +590,7 @@ fn StructCapture(comptime T: type) type {
572		590
573	test "call generic function that uses capture from function declaration's scope" {	591	test "call generic function that uses capture from function declaration's scope" {
574	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	592	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		593	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
575		594
576	const S = StructCapture(f64);	595	const S = StructCapture(f64);
577	const s = S.foo(123);	596	const s = S.foo(123);

...	@@ -7,6 +7,7 @@ test "store to global array" {	...	@@ -7,6 +7,7 @@ test "store to global array" {
7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10		11
11	try expect(pos[1] == 0.0);	12	try expect(pos[1] == 0.0);
12	pos = [2]f32{ 0.0, 1.0 };	13	pos = [2]f32{ 0.0, 1.0 };
...	@@ -18,6 +19,7 @@ test "store to global vector" {	...	@@ -18,6 +19,7 @@ test "store to global vector" {
18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	20	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
20	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		22	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
21		23
22	try expect(vpos[1] == 0.0);	24	try expect(vpos[1] == 0.0);
23	vpos = @Vector(2, f32){ 0.0, 1.0 };	25	vpos = @Vector(2, f32){ 0.0, 1.0 };
...	@@ -28,6 +30,7 @@ test "slices pointing at the same address as global array." {	...	@@ -28,6 +30,7 @@ test "slices pointing at the same address as global array." {
28	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	31	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		33	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
31		34
32	const S = struct {	35	const S = struct {
33	const a = [_]u8{ 1, 2, 3 };	36	const a = [_]u8{ 1, 2, 3 };

...	@@ -9,6 +9,7 @@ test "uint128" {	...	@@ -9,6 +9,7 @@ test "uint128" {
9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		12	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12		13
13	var buff: u128 = maxInt(u128);	14	var buff: u128 = maxInt(u128);
14	try expect(buff == maxInt(u128));	15	try expect(buff == maxInt(u128));
...	@@ -28,6 +29,7 @@ test "undefined 128 bit int" {	...	@@ -28,6 +29,7 @@ test "undefined 128 bit int" {
28	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	29	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
30	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	31	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		32	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
31		33
32	@setRuntimeSafety(true);	34	@setRuntimeSafety(true);
33		35
...	@@ -47,6 +49,7 @@ test "int128" {	...	@@ -47,6 +49,7 @@ test "int128" {
47	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	49	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
48	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
49	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	51	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		52	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
50		53
51	var buff: i128 = -1;	54	var buff: i128 = -1;
52	try expect(buff < 0 and (buff + 1) == 0);	55	try expect(buff < 0 and (buff + 1) == 0);
...	@@ -70,6 +73,7 @@ test "truncate int128" {	...	@@ -70,6 +73,7 @@ test "truncate int128" {
70	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	73	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	74	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
72	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	75	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		76	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
73		77
74	{	78	{
75	var buff: u128 = maxInt(u128);	79	var buff: u128 = maxInt(u128);
...	@@ -93,6 +97,7 @@ test "shift int128" {	...	@@ -93,6 +97,7 @@ test "shift int128" {
93	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	97	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
94	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	98	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
95	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	99	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		100	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
96		101
97	const types = .{ u128, i128 };	102	const types = .{ u128, i128 };
98	inline for (types) \|t\| {	103	inline for (types) \|t\| {

...	@@ -9,6 +9,7 @@ test "@max" {	...	@@ -9,6 +9,7 @@ test "@max" {
9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		12	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12		13
13	const S = struct {	14	const S = struct {
14	fn doTheTest() !void {	15	fn doTheTest() !void {
...	@@ -31,6 +32,7 @@ test "@max on vectors" {	...	@@ -31,6 +32,7 @@ test "@max on vectors" {
31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	32	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
33	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		35	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
34	if (builtin.zig_backend == .stage2_x86_64 and	36	if (builtin.zig_backend == .stage2_x86_64 and
35	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest;	37	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest;
36		38
...	@@ -63,6 +65,7 @@ test "@min" {	...	@@ -63,6 +65,7 @@ test "@min" {
63	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	65	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
64	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	66	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
65	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		68	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
66		69
67	const S = struct {	70	const S = struct {
68	fn doTheTest() !void {	71	fn doTheTest() !void {
...	@@ -85,6 +88,7 @@ test "@min for vectors" {	...	@@ -85,6 +88,7 @@ test "@min for vectors" {
85	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	88	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
86	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	89	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
87	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	90	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		91	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
88	if (builtin.zig_backend == .stage2_x86_64 and	92	if (builtin.zig_backend == .stage2_x86_64 and
89	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest;	93	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest;
90		94
...	@@ -120,6 +124,7 @@ test "@min/max for floats" {	...	@@ -120,6 +124,7 @@ test "@min/max for floats" {
120	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	124	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
121	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	125	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
122	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;	126	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
		127	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
123		128
124	const S = struct {	129	const S = struct {
125	fn doTheTest(comptime T: type) !void {	130	fn doTheTest(comptime T: type) !void {
...	@@ -167,6 +172,7 @@ test "@min/@max more than two vector arguments" {	...	@@ -167,6 +172,7 @@ test "@min/@max more than two vector arguments" {
167	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	172	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
168	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	173	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
169	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	174	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		175	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
170		176
171	const x: @Vector(2, u32) = .{ 3, 2 };	177	const x: @Vector(2, u32) = .{ 3, 2 };
172	const y: @Vector(2, u32) = .{ 4, 1 };	178	const y: @Vector(2, u32) = .{ 4, 1 };
...	@@ -198,6 +204,7 @@ test "@min/@max notices vector bounds" {	...	@@ -198,6 +204,7 @@ test "@min/@max notices vector bounds" {
198	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	204	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
199	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	205	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
200	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;	206	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
		207	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
201		208
202	var x: @Vector(2, u16) = .{ 140, 40 };	209	var x: @Vector(2, u16) = .{ 140, 40 };
203	const y: @Vector(2, u64) = .{ 5, 100 };	210	const y: @Vector(2, u64) = .{ 5, 100 };
...	@@ -251,6 +258,7 @@ test "@min/@max notices bounds from vector types" {	...	@@ -251,6 +258,7 @@ test "@min/@max notices bounds from vector types" {
251	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	258	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
252	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
253	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;	260	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
		261	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
254		262
255	var x: @Vector(2, u16) = .{ 30, 67 };	263	var x: @Vector(2, u16) = .{ 30, 67 };
256	var y: @Vector(2, u32) = .{ 20, 500 };	264	var y: @Vector(2, u32) = .{ 20, 500 };
...	@@ -271,6 +279,7 @@ test "@min/@max notices bounds from types when comptime-known value is undef" {	...	@@ -271,6 +279,7 @@ test "@min/@max notices bounds from types when comptime-known value is undef" {
271	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	279	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
272	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	280	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
273	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	281	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		282	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
274		283
275	var x: u32 = 1_000_000;	284	var x: u32 = 1_000_000;
276	_ = &x;	285	_ = &x;
...	@@ -291,6 +300,7 @@ test "@min/@max notices bounds from vector types when element of comptime-known	...	@@ -291,6 +300,7 @@ test "@min/@max notices bounds from vector types when element of comptime-known
291	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	300	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
292	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	301	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
293	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	302	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		303	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
294	if (builtin.zig_backend == .stage2_x86_64 and	304	if (builtin.zig_backend == .stage2_x86_64 and
295	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx)) return error.SkipZigTest;	305	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx)) return error.SkipZigTest;
296		306

...	@@ -7,6 +7,7 @@ test "memcpy and memset intrinsics" {	...	@@ -7,6 +7,7 @@ test "memcpy and memset intrinsics" {
7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10		11
11	try testMemcpyMemset();	12	try testMemcpyMemset();
12	try comptime testMemcpyMemset();	13	try comptime testMemcpyMemset();
...	@@ -28,6 +29,7 @@ test "@memcpy with both operands single-ptr-to-array, one is null-terminated" {	...	@@ -28,6 +29,7 @@ test "@memcpy with both operands single-ptr-to-array, one is null-terminated" {
28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
29	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		32	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
31		33
32	try testMemcpyBothSinglePtrArrayOneIsNullTerminated();	34	try testMemcpyBothSinglePtrArrayOneIsNullTerminated();
33	try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated();	35	try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated();
...	@@ -48,6 +50,7 @@ test "@memcpy dest many pointer" {	...	@@ -48,6 +50,7 @@ test "@memcpy dest many pointer" {
48	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
49	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		53	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
51		54
52	try testMemcpyDestManyPtr();	55	try testMemcpyDestManyPtr();
53	try comptime testMemcpyDestManyPtr();	56	try comptime testMemcpyDestManyPtr();
...	@@ -70,6 +73,7 @@ test "@memcpy slice" {	...	@@ -70,6 +73,7 @@ test "@memcpy slice" {
70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
71	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
72	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		76	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
73		77
74	try testMemcpySlice();	78	try testMemcpySlice();
75	try comptime testMemcpySlice();	79	try comptime testMemcpySlice();

...	@@ -7,6 +7,7 @@ test "@memset on array pointers" {	...	@@ -7,6 +7,7 @@ test "@memset on array pointers" {
7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10		11
11	try testMemsetArray();	12	try testMemsetArray();
12	try comptime testMemsetArray();	13	try comptime testMemsetArray();
...	@@ -36,6 +37,7 @@ test "@memset on slices" {	...	@@ -36,6 +37,7 @@ test "@memset on slices" {
36	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	37	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
37	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	38	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
38	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	39	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		40	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
39		41
40	try testMemsetSlice();	42	try testMemsetSlice();
41	try comptime testMemsetSlice();	43	try comptime testMemsetSlice();
...	@@ -71,6 +73,7 @@ test "memset with bool element" {	...	@@ -71,6 +73,7 @@ test "memset with bool element" {
71	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	73	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
72	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	74	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
73	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	75	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		76	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
74		77
75	var buf: [5]bool = undefined;	78	var buf: [5]bool = undefined;
76	@memset(&buf, true);	79	@memset(&buf, true);
...	@@ -83,6 +86,7 @@ test "memset with 1-byte struct element" {	...	@@ -83,6 +86,7 @@ test "memset with 1-byte struct element" {
83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	86	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	87	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
85	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	88	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		89	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
86		90
87	const S = struct { x: bool };	91	const S = struct { x: bool };
88	var buf: [5]S = undefined;	92	var buf: [5]S = undefined;
...	@@ -96,6 +100,7 @@ test "memset with 1-byte array element" {	...	@@ -96,6 +100,7 @@ test "memset with 1-byte array element" {
96	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	100	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
97	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	101	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
98	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	102	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		103	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
99		104
100	const A = [1]bool;	105	const A = [1]bool;
101	var buf: [5]A = undefined;	106	var buf: [5]A = undefined;
...	@@ -109,6 +114,7 @@ test "memset with large array element, runtime known" {	...	@@ -109,6 +114,7 @@ test "memset with large array element, runtime known" {
109	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	114	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
110	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
111	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	116	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		117	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
112		118
113	const A = [128]u64;	119	const A = [128]u64;
114	var buf: [5]A = undefined;	120	var buf: [5]A = undefined;
...	@@ -127,6 +133,7 @@ test "memset with large array element, comptime known" {	...	@@ -127,6 +133,7 @@ test "memset with large array element, comptime known" {
127	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	133	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
128	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	134	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
129	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	135	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		136	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
130		137
131	const A = [128]u64;	138	const A = [128]u64;
132	var buf: [5]A = undefined;	139	var buf: [5]A = undefined;
...	@@ -144,6 +151,7 @@ test "@memset provides result type" {	...	@@ -144,6 +151,7 @@ test "@memset provides result type" {
144	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	151	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
145	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
146	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	153	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		154	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
147		155
148	const S = struct { x: u32 };	156	const S = struct { x: u32 };
149		157
...	@@ -162,6 +170,7 @@ test "zero keys with @memset" {	...	@@ -162,6 +170,7 @@ test "zero keys with @memset" {
162	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	170	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
163	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	171	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
164	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	172	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		173	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
165		174
166	const Keys = struct {	175	const Keys = struct {
167	up: bool,	176	up: bool,

...	@@ -6,6 +6,8 @@ const no_x86_64_hardware_fma_support = builtin.zig_backend == .stage2_x86_64 and	...	@@ -6,6 +6,8 @@ const no_x86_64_hardware_fma_support = builtin.zig_backend == .stage2_x86_64 and
6	!std.Target.x86.featureSetHas(builtin.cpu.features, .fma);	6	!std.Target.x86.featureSetHas(builtin.cpu.features, .fma);
7		7
8	test "@mulAdd" {	8	test "@mulAdd" {
		9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		10
9	if (no_x86_64_hardware_fma_support) return error.SkipZigTest; // TODO	11	if (no_x86_64_hardware_fma_support) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	13	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
...	@@ -37,6 +39,7 @@ test "@mulAdd f16" {	...	@@ -37,6 +39,7 @@ test "@mulAdd f16" {
37	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
38	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
39	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	41	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		42	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
40		43
41	try comptime testMulAdd16();	44	try comptime testMulAdd16();
42	try testMulAdd16();	45	try testMulAdd16();
...	@@ -57,6 +60,7 @@ test "@mulAdd f80" {	...	@@ -57,6 +60,7 @@ test "@mulAdd f80" {
57	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	60	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
58	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	61	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
59	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	62	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		63	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
60		64
61	try comptime testMulAdd80();	65	try comptime testMulAdd80();
62	try testMulAdd80();	66	try testMulAdd80();
...	@@ -77,6 +81,7 @@ test "@mulAdd f128" {	...	@@ -77,6 +81,7 @@ test "@mulAdd f128" {
77	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	81	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
78	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	82	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
79	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	83	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		84	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
80		85
81	try comptime testMulAdd128();	86	try comptime testMulAdd128();
82	try testMulAdd128();	87	try testMulAdd128();
...	@@ -109,6 +114,7 @@ test "vector f16" {	...	@@ -109,6 +114,7 @@ test "vector f16" {
109	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	114	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
110	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	115	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	116	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		117	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
112		118
113	try comptime vector16();	119	try comptime vector16();
114	try vector16();	120	try vector16();
...	@@ -129,6 +135,7 @@ fn vector32() !void {	...	@@ -129,6 +135,7 @@ fn vector32() !void {
129		135
130	test "vector f32" {	136	test "vector f32" {
131	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	137	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		138	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
132	if (no_x86_64_hardware_fma_support) return error.SkipZigTest; // TODO	139	if (no_x86_64_hardware_fma_support) return error.SkipZigTest; // TODO
133	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	140	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
134	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	141	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
...	@@ -153,6 +160,7 @@ fn vector64() !void {	...	@@ -153,6 +160,7 @@ fn vector64() !void {
153		160
154	test "vector f64" {	161	test "vector f64" {
155	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	162	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		163	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
156	if (no_x86_64_hardware_fma_support) return error.SkipZigTest; // TODO	164	if (no_x86_64_hardware_fma_support) return error.SkipZigTest; // TODO
157	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	165	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
158	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	166	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
...	@@ -182,6 +190,7 @@ test "vector f80" {	...	@@ -182,6 +190,7 @@ test "vector f80" {
182	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	190	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
183	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	191	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
184	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	192	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
		193	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
185		194
186	try comptime vector80();	195	try comptime vector80();
187	try vector80();	196	try vector80();
...	@@ -208,6 +217,7 @@ test "vector f128" {	...	@@ -208,6 +217,7 @@ test "vector f128" {
208	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	217	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
209	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	218	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
210	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	219	if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
		220	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
211		221
212	try comptime vector128();	222	try comptime vector128();
213	try vector128();	223	try vector128();

...	@@ -32,6 +32,7 @@ test "test maybe object and get a pointer to the inner value" {	...	@@ -32,6 +32,7 @@ test "test maybe object and get a pointer to the inner value" {
32	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	32	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		35	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
35		36
36	var maybe_bool: ?bool = true;	37	var maybe_bool: ?bool = true;
37		38
...	@@ -52,6 +53,7 @@ test "maybe return" {	...	@@ -52,6 +53,7 @@ test "maybe return" {
52	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
53	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	54	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
54	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		56	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
55		57
56	try maybeReturnImpl();	58	try maybeReturnImpl();
57	try comptime maybeReturnImpl();	59	try comptime maybeReturnImpl();
...	@@ -71,6 +73,7 @@ fn foo(x: ?i32) ?bool {	...	@@ -71,6 +73,7 @@ fn foo(x: ?i32) ?bool {
71	test "test null runtime" {	73	test "test null runtime" {
72	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
73	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		76	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
74		77
75	try testTestNullRuntime(null);	78	try testTestNullRuntime(null);
76	}	79	}
...	@@ -82,6 +85,7 @@ fn testTestNullRuntime(x: ?i32) !void {	...	@@ -82,6 +85,7 @@ fn testTestNullRuntime(x: ?i32) !void {
82	test "optional void" {	85	test "optional void" {
83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	86	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	87	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		88	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
85		89
86	try optionalVoidImpl();	90	try optionalVoidImpl();
87	try comptime optionalVoidImpl();	91	try comptime optionalVoidImpl();
...	@@ -105,6 +109,7 @@ const Empty = struct {};	...	@@ -105,6 +109,7 @@ const Empty = struct {};
105	test "optional struct{}" {	109	test "optional struct{}" {
106	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	110	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		112	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
108		113
109	_ = try optionalEmptyStructImpl();	114	_ = try optionalEmptyStructImpl();
110	_ = try comptime optionalEmptyStructImpl();	115	_ = try comptime optionalEmptyStructImpl();
...	@@ -130,6 +135,7 @@ test "null with default unwrap" {	...	@@ -130,6 +135,7 @@ test "null with default unwrap" {
130		135
131	test "optional pointer to 0 bit type null value at runtime" {	136	test "optional pointer to 0 bit type null value at runtime" {
132	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	137	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		138	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
133		139
134	const EmptyStruct = struct {};	140	const EmptyStruct = struct {};
135	var x: ?*EmptyStruct = null;	141	var x: ?*EmptyStruct = null;
...	@@ -141,6 +147,7 @@ test "if var maybe pointer" {	...	@@ -141,6 +147,7 @@ test "if var maybe pointer" {
141	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	147	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
142	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	148	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
143	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	149	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		150	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
144		151
145	try expect(shouldBeAPlus1(Particle{	152	try expect(shouldBeAPlus1(Particle{
146	.a = 14,	153	.a = 14,
...	@@ -184,6 +191,7 @@ test "unwrap optional which is field of global var" {	...	@@ -184,6 +191,7 @@ test "unwrap optional which is field of global var" {
184	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	191	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
185	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	192	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
186	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	193	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		194	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
187		195
188	struct_with_optional.field = null;	196	struct_with_optional.field = null;
189	if (struct_with_optional.field) \|payload\| {	197	if (struct_with_optional.field) \|payload\| {

...	@@ -9,6 +9,7 @@ const expectEqualStrings = std.testing.expectEqualStrings;	...	@@ -9,6 +9,7 @@ const expectEqualStrings = std.testing.expectEqualStrings;
9	test "passing an optional integer as a parameter" {	9	test "passing an optional integer as a parameter" {
10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		12	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12		13
13	const S = struct {	14	const S = struct {
14	fn entry() bool {	15	fn entry() bool {
...	@@ -28,6 +29,7 @@ pub const EmptyStruct = struct {};	...	@@ -28,6 +29,7 @@ pub const EmptyStruct = struct {};
28		29
29	test "optional pointer to size zero struct" {	30	test "optional pointer to size zero struct" {
30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		32	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
31		33
32	var e = EmptyStruct{};	34	var e = EmptyStruct{};
33	const o: ?*EmptyStruct = &e;	35	const o: ?*EmptyStruct = &e;
...	@@ -58,6 +60,7 @@ fn testNullPtrsEql() !void {	...	@@ -58,6 +60,7 @@ fn testNullPtrsEql() !void {
58	test "optional with zero-bit type" {	60	test "optional with zero-bit type" {
59	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	61	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
60	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;	62	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
		63	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
61		64
62	const S = struct {	65	const S = struct {
63	fn doTheTest(comptime ZeroBit: type, comptime zero_bit: ZeroBit) !void {	66	fn doTheTest(comptime ZeroBit: type, comptime zero_bit: ZeroBit) !void {
...	@@ -110,6 +113,7 @@ test "address of unwrap optional" {	...	@@ -110,6 +113,7 @@ test "address of unwrap optional" {
110	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	113	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
111	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	114	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
112	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		116	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
113		117
114	const S = struct {	118	const S = struct {
115	const Foo = struct {	119	const Foo = struct {
...	@@ -131,6 +135,7 @@ test "nested optional field in struct" {	...	@@ -131,6 +135,7 @@ test "nested optional field in struct" {
131	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	135	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
132	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	136	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	137	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		138	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
134		139
135	const S2 = struct {	140	const S2 = struct {
136	y: u8,	141	y: u8,
...	@@ -149,6 +154,7 @@ test "equality compare optionals and non-optionals" {	...	@@ -149,6 +154,7 @@ test "equality compare optionals and non-optionals" {
149	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	154	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
150	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	155	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
151	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	156	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		157	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
152		158
153	const S = struct {	159	const S = struct {
154	fn doTheTest() !void {	160	fn doTheTest() !void {
...	@@ -206,6 +212,7 @@ test "equality compare optionals and non-optionals" {	...	@@ -206,6 +212,7 @@ test "equality compare optionals and non-optionals" {
206		212
207	test "compare optionals with modified payloads" {	213	test "compare optionals with modified payloads" {
208	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	214	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
		215	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
209		216
210	var lhs: ?bool = false;	217	var lhs: ?bool = false;
211	const lhs_payload = &lhs.?;	218	const lhs_payload = &lhs.?;
...	@@ -233,6 +240,7 @@ test "compare optionals with modified payloads" {	...	@@ -233,6 +240,7 @@ test "compare optionals with modified payloads" {
233	test "unwrap function call with optional pointer return value" {	240	test "unwrap function call with optional pointer return value" {
234	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	241	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
235	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	242	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		243	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
236		244
237	const S = struct {	245	const S = struct {
238	fn entry() !void {	246	fn entry() !void {
...	@@ -254,6 +262,7 @@ test "unwrap function call with optional pointer return value" {	...	@@ -254,6 +262,7 @@ test "unwrap function call with optional pointer return value" {
254	test "nested orelse" {	262	test "nested orelse" {
255	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	263	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
256	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	264	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		265	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
257		266
258	const S = struct {	267	const S = struct {
259	fn entry() !void {	268	fn entry() !void {
...	@@ -280,6 +289,7 @@ test "nested orelse" {	...	@@ -280,6 +289,7 @@ test "nested orelse" {
280	test "self-referential struct through a slice of optional" {	289	test "self-referential struct through a slice of optional" {
281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	290	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	291	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		292	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
283		293
284	const S = struct {	294	const S = struct {
285	const Node = struct {	295	const Node = struct {
...	@@ -316,6 +326,7 @@ test "coerce an anon struct literal to optional struct" {	...	@@ -316,6 +326,7 @@ test "coerce an anon struct literal to optional struct" {
316	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	326	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
317	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	327	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
318	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	328	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		329	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
319		330
320	const S = struct {	331	const S = struct {
321	const Struct = struct {	332	const Struct = struct {
...	@@ -335,6 +346,7 @@ test "0-bit child type coerced to optional return ptr result location" {	...	@@ -335,6 +346,7 @@ test "0-bit child type coerced to optional return ptr result location" {
335	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	346	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
336	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	347	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
337	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	348	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		349	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
338		350
339	const S = struct {	351	const S = struct {
340	fn doTheTest() !void {	352	fn doTheTest() !void {
...	@@ -360,6 +372,7 @@ test "0-bit child type coerced to optional return ptr result location" {	...	@@ -360,6 +372,7 @@ test "0-bit child type coerced to optional return ptr result location" {
360	test "0-bit child type coerced to optional" {	372	test "0-bit child type coerced to optional" {
361	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	373	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
362	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	374	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		375	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
363		376
364	const S = struct {	377	const S = struct {
365	fn doTheTest() !void {	378	fn doTheTest() !void {
...	@@ -387,6 +400,7 @@ test "array of optional unaligned types" {	...	@@ -387,6 +400,7 @@ test "array of optional unaligned types" {
387	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	400	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
388	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	401	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
389	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	402	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		403	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
390		404
391	const Enum = enum { one, two, three };	405	const Enum = enum { one, two, three };
392		406
...	@@ -423,6 +437,7 @@ test "optional pointer to zero bit optional payload" {	...	@@ -423,6 +437,7 @@ test "optional pointer to zero bit optional payload" {
423	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	437	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
424	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	438	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
425	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	439	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		440	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
426		441
427	const B = struct {	442	const B = struct {
428	fn foo(_: *@This()) void {}	443	fn foo(_: *@This()) void {}
...	@@ -442,6 +457,7 @@ test "optional pointer to zero bit error union payload" {	...	@@ -442,6 +457,7 @@ test "optional pointer to zero bit error union payload" {
442	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	457	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
443	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	458	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
444	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	459	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		460	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
445		461
446	const B = struct {	462	const B = struct {
447	fn foo(_: *@This()) void {}	463	fn foo(_: *@This()) void {}
...	@@ -475,6 +491,7 @@ const NoReturn = struct {	...	@@ -475,6 +491,7 @@ const NoReturn = struct {
475		491
476	test "optional of noreturn used with if" {	492	test "optional of noreturn used with if" {
477	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	493	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		494	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
478		495
479	NoReturn.a = 64;	496	NoReturn.a = 64;
480	if (NoReturn.loop()) \|_\| {	497	if (NoReturn.loop()) \|_\| {
...	@@ -486,6 +503,7 @@ test "optional of noreturn used with if" {	...	@@ -486,6 +503,7 @@ test "optional of noreturn used with if" {
486		503
487	test "optional of noreturn used with orelse" {	504	test "optional of noreturn used with orelse" {
488	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	505	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		506	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
489		507
490	NoReturn.a = 64;	508	NoReturn.a = 64;
491	const val = NoReturn.testOrelse();	509	const val = NoReturn.testOrelse();
...	@@ -505,6 +523,7 @@ test "alignment of wrapping an optional payload" {	...	@@ -505,6 +523,7 @@ test "alignment of wrapping an optional payload" {
505	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	523	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
506	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	524	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
507	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	525	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		526	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
508		527
509	const S = struct {	528	const S = struct {
510	const I = extern struct { x: i128 };	529	const I = extern struct { x: i128 };
...	@@ -522,6 +541,7 @@ test "Optional slice size is optimized" {	...	@@ -522,6 +541,7 @@ test "Optional slice size is optimized" {
522	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	541	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
523	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	542	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
524	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	543	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		544	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
525		545
526	try expect(@sizeOf(?[]u8) == @sizeOf([]u8));	546	try expect(@sizeOf(?[]u8) == @sizeOf([]u8));
527	var a: ?[]const u8 = null;	547	var a: ?[]const u8 = null;
...	@@ -535,6 +555,7 @@ test "Optional slice passed to function" {	...	@@ -535,6 +555,7 @@ test "Optional slice passed to function" {
535	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	555	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
536	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	556	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
537	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	557	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		558	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
538		559
539	const S = struct {	560	const S = struct {
540	fn foo(a: ?[]const u8) !void {	561	fn foo(a: ?[]const u8) !void {
...	@@ -551,6 +572,7 @@ test "Optional slice passed to function" {	...	@@ -551,6 +572,7 @@ test "Optional slice passed to function" {
551	test "peer type resolution in nested if expressions" {	572	test "peer type resolution in nested if expressions" {
552	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	573	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
553	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	574	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		575	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
554		576
555	const Thing = struct { n: i32 };	577	const Thing = struct { n: i32 };
556	var a = false;	578	var a = false;
...	@@ -578,6 +600,7 @@ test "cast slice to const slice nested in error union and optional" {	...	@@ -578,6 +600,7 @@ test "cast slice to const slice nested in error union and optional" {
578	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	600	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
579	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	601	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
580	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	602	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		603	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
581		604
582	const S = struct {	605	const S = struct {
583	fn inner() !?[]u8 {	606	fn inner() !?[]u8 {
...	@@ -591,6 +614,8 @@ test "cast slice to const slice nested in error union and optional" {	...	@@ -591,6 +614,8 @@ test "cast slice to const slice nested in error union and optional" {
591	}	614	}
592		615
593	test "variable of optional of noreturn" {	616	test "variable of optional of noreturn" {
		617	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		618
594	var null_opv: ?noreturn = null;	619	var null_opv: ?noreturn = null;
595	_ = &null_opv;	620	_ = &null_opv;
596	try std.testing.expectEqual(@as(?noreturn, null), null_opv);	621	try std.testing.expectEqual(@as(?noreturn, null), null_opv);
...	@@ -600,6 +625,7 @@ test "copied optional doesn't alias source" {	...	@@ -600,6 +625,7 @@ test "copied optional doesn't alias source" {
600	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	625	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
601	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	626	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
602	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	627	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		628	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
603		629
604	var opt_x: ?[3]f32 = [_]f32{0.0} ** 3;	630	var opt_x: ?[3]f32 = [_]f32{0.0} ** 3;
605		631
...	@@ -614,6 +640,7 @@ test "result location initialization of optional with OPV payload" {	...	@@ -614,6 +640,7 @@ test "result location initialization of optional with OPV payload" {
614	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	640	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
615	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	641	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
616	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	642	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		643	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
617		644
618	const S = struct {	645	const S = struct {
619	x: u0,	646	x: u0,

...	@@ -238,6 +238,7 @@ test "regular in irregular packed struct" {	...	@@ -238,6 +238,7 @@ test "regular in irregular packed struct" {
238	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	238	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
239	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	239	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
240	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	240	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		241	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
241		242
242	const Irregular = packed struct {	243	const Irregular = packed struct {
243	bar: Regular = Regular{},	244	bar: Regular = Regular{},
...	@@ -258,6 +259,7 @@ test "nested packed struct unaligned" {	...	@@ -258,6 +259,7 @@ test "nested packed struct unaligned" {
258	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	259	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	260	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
260	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	261	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		262	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
261	if (native_endian != .little) return error.SkipZigTest; // Byte aligned packed struct field pointers have not been implemented yet	263	if (native_endian != .little) return error.SkipZigTest; // Byte aligned packed struct field pointers have not been implemented yet
262		264
263	const S1 = packed struct {	265	const S1 = packed struct {
...	@@ -330,6 +332,7 @@ test "byte-aligned field pointer offsets" {	...	@@ -330,6 +332,7 @@ test "byte-aligned field pointer offsets" {
330	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	332	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
331	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	333	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
332	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	334	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		335	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
333		336
334	const S = struct {	337	const S = struct {
335	const A = packed struct {	338	const A = packed struct {
...	@@ -432,6 +435,7 @@ test "nested packed struct field pointers" {	...	@@ -432,6 +435,7 @@ test "nested packed struct field pointers" {
432	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	435	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
433	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	436	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
434	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // ubsan unaligned pointer access	437	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // ubsan unaligned pointer access
		438	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
435	if (native_endian != .little) return error.SkipZigTest; // Byte aligned packed struct field pointers have not been implemented yet	439	if (native_endian != .little) return error.SkipZigTest; // Byte aligned packed struct field pointers have not been implemented yet
436		440
437	const S2 = packed struct {	441	const S2 = packed struct {
...	@@ -469,6 +473,7 @@ test "load pointer from packed struct" {	...	@@ -469,6 +473,7 @@ test "load pointer from packed struct" {
469	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	473	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
470	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	474	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
471	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	475	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		476	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
472		477
473	const A = struct {	478	const A = struct {
474	index: u16,	479	index: u16,
...	@@ -489,6 +494,7 @@ test "@intFromPtr on a packed struct field" {	...	@@ -489,6 +494,7 @@ test "@intFromPtr on a packed struct field" {
489	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	494	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
490	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	495	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
491	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	496	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		497	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
492	if (native_endian != .little) return error.SkipZigTest;	498	if (native_endian != .little) return error.SkipZigTest;
493		499
494	const S = struct {	500	const S = struct {
...	@@ -512,6 +518,7 @@ test "@intFromPtr on a packed struct field unaligned and nested" {	...	@@ -512,6 +518,7 @@ test "@intFromPtr on a packed struct field unaligned and nested" {
512	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	518	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
513	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	519	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
514	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	520	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		521	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
515	if (native_endian != .little) return error.SkipZigTest; // Byte aligned packed struct field pointers have not been implemented yet	522	if (native_endian != .little) return error.SkipZigTest; // Byte aligned packed struct field pointers have not been implemented yet
516		523
517	const S1 = packed struct {	524	const S1 = packed struct {
...	@@ -618,6 +625,8 @@ test "@intFromPtr on a packed struct field unaligned and nested" {	...	@@ -618,6 +625,8 @@ test "@intFromPtr on a packed struct field unaligned and nested" {
618	}	625	}
619		626
620	test "packed struct fields modification" {	627	test "packed struct fields modification" {
		628	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		629
621	// Originally reported at https://github.com/ziglang/zig/issues/16615	630	// Originally reported at https://github.com/ziglang/zig/issues/16615
622	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	631	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
623		632
...	@@ -646,6 +655,7 @@ test "optional pointer in packed struct" {	...	@@ -646,6 +655,7 @@ test "optional pointer in packed struct" {
646	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	655	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
647	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	656	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
648	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	657	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		658	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
649		659
650	const T = packed struct { ptr: ?*const u8 };	660	const T = packed struct { ptr: ?*const u8 };
651	var n: u8 = 0;	661	var n: u8 = 0;
...	@@ -661,6 +671,7 @@ test "nested packed struct field access test" {	...	@@ -661,6 +671,7 @@ test "nested packed struct field access test" {
661	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	671	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
662	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	672	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
663	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	673	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		674	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
664		675
665	const Vec2 = packed struct {	676	const Vec2 = packed struct {
666	x: f32,	677	x: f32,
...	@@ -777,6 +788,7 @@ test "nested packed struct field access test" {	...	@@ -777,6 +788,7 @@ test "nested packed struct field access test" {
777	test "nested packed struct at non-zero offset" {	788	test "nested packed struct at non-zero offset" {
778	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	789	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
779	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	790	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		791	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
780		792
781	const Pair = packed struct(u24) {	793	const Pair = packed struct(u24) {
782	a: u16 = 0,	794	a: u16 = 0,
...	@@ -810,6 +822,7 @@ test "nested packed struct at non-zero offset 2" {	...	@@ -810,6 +822,7 @@ test "nested packed struct at non-zero offset 2" {
810	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	822	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
811	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO packed structs larger than 64 bits	823	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO packed structs larger than 64 bits
812	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;	824	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
		825	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
813		826
814	const S = struct {	827	const S = struct {
815	const Pair = packed struct(u40) {	828	const Pair = packed struct(u40) {
...	@@ -890,6 +903,7 @@ test "packed struct passed to callconv(.C) function" {	...	@@ -890,6 +903,7 @@ test "packed struct passed to callconv(.C) function" {
890	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	903	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
891	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	904	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
892	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	905	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		906	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
893		907
894	const S = struct {	908	const S = struct {
895	const Packed = packed struct {	909	const Packed = packed struct {
...	@@ -938,6 +952,7 @@ test "packed struct initialized in bitcast" {	...	@@ -938,6 +952,7 @@ test "packed struct initialized in bitcast" {
938	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	952	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
939	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	953	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
940	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	954	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		955	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
941		956
942	const T = packed struct { val: u8 };	957	const T = packed struct { val: u8 };
943	var val: u8 = 123;	958	var val: u8 = 123;
...	@@ -951,6 +966,7 @@ test "pointer to container level packed struct field" {	...	@@ -951,6 +966,7 @@ test "pointer to container level packed struct field" {
951	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	966	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
952	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	967	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
953	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	968	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		969	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
954		970
955	const S = packed struct(u32) {	971	const S = packed struct(u32) {
956	test_bit: bool,	972	test_bit: bool,
...	@@ -975,6 +991,7 @@ test "store undefined to packed result location" {	...	@@ -975,6 +991,7 @@ test "store undefined to packed result location" {
975	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	991	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
976	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	992	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
977	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	993	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		994	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
978		995
979	var x: u4 = 0;	996	var x: u4 = 0;
980	_ = &x;	997	_ = &x;
...	@@ -995,6 +1012,8 @@ test "bitcast back and forth" {	...	@@ -995,6 +1012,8 @@ test "bitcast back and forth" {
995	}	1012	}
996		1013
997	test "field access of packed struct smaller than its abi size inside struct initialized with rls" {	1014	test "field access of packed struct smaller than its abi size inside struct initialized with rls" {
		1015	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1016
998	// Originally reported at https://github.com/ziglang/zig/issues/14200	1017	// Originally reported at https://github.com/ziglang/zig/issues/14200
999	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1018	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1000		1019
...	@@ -1013,6 +1032,8 @@ test "field access of packed struct smaller than its abi size inside struct init	...	@@ -1013,6 +1032,8 @@ test "field access of packed struct smaller than its abi size inside struct init
1013	}	1032	}
1014		1033
1015	test "modify nested packed struct aligned field" {	1034	test "modify nested packed struct aligned field" {
		1035	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1036
1016	// Originally reported at https://github.com/ziglang/zig/issues/14632	1037	// Originally reported at https://github.com/ziglang/zig/issues/14632
1017	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1038	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1018	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	1039	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
...	@@ -1043,6 +1064,8 @@ test "modify nested packed struct aligned field" {	...	@@ -1043,6 +1064,8 @@ test "modify nested packed struct aligned field" {
1043	}	1064	}
1044		1065
1045	test "assigning packed struct inside another packed struct" {	1066	test "assigning packed struct inside another packed struct" {
		1067	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1068
1046	// Originally reported at https://github.com/ziglang/zig/issues/9674	1069	// Originally reported at https://github.com/ziglang/zig/issues/9674
1047	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1070	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1048		1071
...	@@ -1077,6 +1100,7 @@ test "packed struct used as part of anon decl name" {	...	@@ -1077,6 +1100,7 @@ test "packed struct used as part of anon decl name" {
1077	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1100	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1078	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1101	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1079	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1102	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1103	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1080		1104
1081	const S = packed struct { a: u0 = 0 };	1105	const S = packed struct { a: u0 = 0 };
1082	var a: u8 = 0;	1106	var a: u8 = 0;
...	@@ -1099,6 +1123,8 @@ test "packed struct acts as a namespace" {	...	@@ -1099,6 +1123,8 @@ test "packed struct acts as a namespace" {
1099	}	1123	}
1100		1124
1101	test "pointer loaded correctly from packed struct" {	1125	test "pointer loaded correctly from packed struct" {
		1126	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1127
1102	const RAM = struct {	1128	const RAM = struct {
1103	data: [0xFFFF + 1]u8,	1129	data: [0xFFFF + 1]u8,
1104	fn new() !@This() {	1130	fn new() !@This() {
...	@@ -1142,6 +1168,7 @@ test "assignment to non-byte-aligned field in packed struct" {	...	@@ -1142,6 +1168,7 @@ test "assignment to non-byte-aligned field in packed struct" {
1142	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1168	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1143	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1169	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1144	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1170	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1171	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1145		1172
1146	const Frame = packed struct {	1173	const Frame = packed struct {
1147	num: u20,	1174	num: u20,
...	@@ -1164,6 +1191,7 @@ test "packed struct field pointer aligned properly" {	...	@@ -1164,6 +1191,7 @@ test "packed struct field pointer aligned properly" {
1164	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1191	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1165	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1192	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1166	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO	1193	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
		1194	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1167		1195
1168	const Foo = packed struct {	1196	const Foo = packed struct {
1169	a: i32,	1197	a: i32,
...	@@ -1183,6 +1211,7 @@ test "load flag from packed struct in union" {	...	@@ -1183,6 +1211,7 @@ test "load flag from packed struct in union" {
1183	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1211	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1184	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1212	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1185	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1213	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1214	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1186		1215
1187	const A = packed struct {	1216	const A = packed struct {
1188	a: bool,	1217	a: bool,
...	@@ -1251,6 +1280,7 @@ test "2-byte packed struct argument in C calling convention" {	...	@@ -1251,6 +1280,7 @@ test "2-byte packed struct argument in C calling convention" {
1251	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	1280	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
1252	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	1281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1253	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1282	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1283	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1254		1284
1255	const S = packed struct(u16) {	1285	const S = packed struct(u16) {
1256	x: u15 = 0,	1286	x: u15 = 0,

...	@@ -8,6 +8,7 @@ test "flags in packed union" {	...	@@ -8,6 +8,7 @@ test "flags in packed union" {
8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11		12
12	try testFlagsInPackedUnion();	13	try testFlagsInPackedUnion();
13	try comptime testFlagsInPackedUnion();	14	try comptime testFlagsInPackedUnion();
...	@@ -50,6 +51,7 @@ test "flags in packed union at offset" {	...	@@ -50,6 +51,7 @@ test "flags in packed union at offset" {
50	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
51	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
52	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	53	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		54	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
53		55
54	try testFlagsInPackedUnionAtOffset();	56	try testFlagsInPackedUnionAtOffset();
55	try comptime testFlagsInPackedUnionAtOffset();	57	try comptime testFlagsInPackedUnionAtOffset();
...	@@ -98,6 +100,8 @@ fn testFlagsInPackedUnionAtOffset() !void {	...	@@ -98,6 +100,8 @@ fn testFlagsInPackedUnionAtOffset() !void {
98	}	100	}
99		101
100	test "packed union in packed struct" {	102	test "packed union in packed struct" {
		103	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		104
101	// Originally reported at https://github.com/ziglang/zig/issues/16581	105	// Originally reported at https://github.com/ziglang/zig/issues/16581
102	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	106	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
103		107
...	@@ -137,6 +141,7 @@ test "packed union initialized with a runtime value" {	...	@@ -137,6 +141,7 @@ test "packed union initialized with a runtime value" {
137	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	141	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
138	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	142	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
139	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;	143	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
		144	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
140		145
141	const Fields = packed struct {	146	const Fields = packed struct {
142	timestamp: u50,	147	timestamp: u50,

...	@@ -20,6 +20,7 @@ fn testDerefPtr() !void {	...	@@ -20,6 +20,7 @@ fn testDerefPtr() !void {
20	test "pointer arithmetic" {	20	test "pointer arithmetic" {
21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		23	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
23		24
24	var ptr: [*]const u8 = "abcd";	25	var ptr: [*]const u8 = "abcd";
25		26
...	@@ -68,6 +69,7 @@ test "initialize const optional C pointer to null" {	...	@@ -68,6 +69,7 @@ test "initialize const optional C pointer to null" {
68		69
69	test "assigning integer to C pointer" {	70	test "assigning integer to C pointer" {
70	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		72	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
71		73
72	var x: i32 = 0;	74	var x: i32 = 0;
73	var y: i32 = 1;	75	var y: i32 = 1;
...	@@ -85,6 +87,7 @@ test "assigning integer to C pointer" {	...	@@ -85,6 +87,7 @@ test "assigning integer to C pointer" {
85		87
86	test "C pointer comparison and arithmetic" {	88	test "C pointer comparison and arithmetic" {
87	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	89	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		90	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
88		91
89	const S = struct {	92	const S = struct {
90	fn doTheTest() !void {	93	fn doTheTest() !void {
...	@@ -154,6 +157,7 @@ test "implicit casting between C pointer and optional non-C pointer" {	...	@@ -154,6 +157,7 @@ test "implicit casting between C pointer and optional non-C pointer" {
154	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	157	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
155	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	158	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
156	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	159	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		160	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
157		161
158	var slice: []const u8 = "aoeu";	162	var slice: []const u8 = "aoeu";
159	_ = &slice;	163	_ = &slice;
...	@@ -170,6 +174,7 @@ test "implicit cast error unions with non-optional to optional pointer" {	...	@@ -170,6 +174,7 @@ test "implicit cast error unions with non-optional to optional pointer" {
170	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	174	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
171	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	175	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
172	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	176	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		177	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
173		178
174	const S = struct {	179	const S = struct {
175	fn doTheTest() !void {	180	fn doTheTest() !void {
...	@@ -197,6 +202,7 @@ test "allowzero pointer and slice" {	...	@@ -197,6 +202,7 @@ test "allowzero pointer and slice" {
197	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	202	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
198	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	203	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
199	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	204	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		205	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
200		206
201	var ptr: [*]allowzero i32 = @ptrFromInt(0);	207	var ptr: [*]allowzero i32 = @ptrFromInt(0);
202	const opt_ptr: ?[*]allowzero i32 = ptr;	208	const opt_ptr: ?[*]allowzero i32 = ptr;
...	@@ -216,6 +222,7 @@ test "assign null directly to C pointer and test null equality" {	...	@@ -216,6 +222,7 @@ test "assign null directly to C pointer and test null equality" {
216	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	222	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
217	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	223	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
218	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	224	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		225	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
219		226
220	var x: [*c]i32 = null;	227	var x: [*c]i32 = null;
221	_ = &x;	228	_ = &x;
...	@@ -283,6 +290,7 @@ test "array initialization types" {	...	@@ -283,6 +290,7 @@ test "array initialization types" {
283	test "null terminated pointer" {	290	test "null terminated pointer" {
284	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	291	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
285	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	292	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		293	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
286		294
287	const S = struct {	295	const S = struct {
288	fn doTheTest() !void {	296	fn doTheTest() !void {
...	@@ -300,6 +308,7 @@ test "null terminated pointer" {	...	@@ -300,6 +308,7 @@ test "null terminated pointer" {
300	test "allow any sentinel" {	308	test "allow any sentinel" {
301	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	309	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
302	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	310	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		311	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
303		312
304	const S = struct {	313	const S = struct {
305	fn doTheTest() !void {	314	fn doTheTest() !void {
...	@@ -315,6 +324,7 @@ test "allow any sentinel" {	...	@@ -315,6 +324,7 @@ test "allow any sentinel" {
315	test "pointer sentinel with enums" {	324	test "pointer sentinel with enums" {
316	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	325	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
317	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	326	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		327	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
318		328
319	const S = struct {	329	const S = struct {
320	const Number = enum {	330	const Number = enum {
...	@@ -337,6 +347,7 @@ test "pointer sentinel with optional element" {	...	@@ -337,6 +347,7 @@ test "pointer sentinel with optional element" {
337	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	347	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
338	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	348	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
339	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		350	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
340		351
341	const S = struct {	352	const S = struct {
342	fn doTheTest() !void {	353	fn doTheTest() !void {
...	@@ -353,6 +364,7 @@ test "pointer sentinel with +inf" {	...	@@ -353,6 +364,7 @@ test "pointer sentinel with +inf" {
353	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	364	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
354	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	365	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
355	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	366	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		367	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
356		368
357	const S = struct {	369	const S = struct {
358	fn doTheTest() !void {	370	fn doTheTest() !void {
...	@@ -430,6 +442,7 @@ test "indexing array with sentinel returns correct type" {	...	@@ -430,6 +442,7 @@ test "indexing array with sentinel returns correct type" {
430	test "element pointer to slice" {	442	test "element pointer to slice" {
431	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	443	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
432	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	444	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		445	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
433		446
434	const S = struct {	447	const S = struct {
435	fn doTheTest() !void {	448	fn doTheTest() !void {
...	@@ -452,6 +465,7 @@ test "element pointer to slice" {	...	@@ -452,6 +465,7 @@ test "element pointer to slice" {
452	test "element pointer arithmetic to slice" {	465	test "element pointer arithmetic to slice" {
453	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	466	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
454	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	467	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		468	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
455		469
456	const S = struct {	470	const S = struct {
457	fn doTheTest() !void {	471	fn doTheTest() !void {
...	@@ -476,6 +490,7 @@ test "element pointer arithmetic to slice" {	...	@@ -476,6 +490,7 @@ test "element pointer arithmetic to slice" {
476		490
477	test "array slicing to slice" {	491	test "array slicing to slice" {
478	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	492	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		493	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
479		494
480	const S = struct {	495	const S = struct {
481	fn doTheTest() !void {	496	fn doTheTest() !void {
...	@@ -506,6 +521,7 @@ test "ptrCast comptime known slice to C pointer" {	...	@@ -506,6 +521,7 @@ test "ptrCast comptime known slice to C pointer" {
506	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	521	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
507	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	522	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
508	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	523	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		524	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
509		525
510	const s: [:0]const u8 = "foo";	526	const s: [:0]const u8 = "foo";
511	var p: [*c]const u8 = @ptrCast(s);	527	var p: [*c]const u8 = @ptrCast(s);
...	@@ -525,6 +541,7 @@ test "pointer alignment and element type include call expression" {	...	@@ -525,6 +541,7 @@ test "pointer alignment and element type include call expression" {
525		541
526	test "pointer to array has explicit alignment" {	542	test "pointer to array has explicit alignment" {
527	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	543	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		544	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
528		545
529	const S = struct {	546	const S = struct {
530	const Base = extern struct { a: u8 };	547	const Base = extern struct { a: u8 };

...	@@ -8,6 +8,7 @@ test "@popCount integers" {	...	@@ -8,6 +8,7 @@ test "@popCount integers" {
8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11		12
12	try comptime testPopCountIntegers();	13	try comptime testPopCountIntegers();
13	try testPopCountIntegers();	14	try testPopCountIntegers();
...	@@ -18,6 +19,7 @@ test "@popCount 128bit integer" {	...	@@ -18,6 +19,7 @@ test "@popCount 128bit integer" {
18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
20	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		22	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
21		23
22	comptime {	24	comptime {
23	try expect(@popCount(@as(u128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);	25	try expect(@popCount(@as(u128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
...	@@ -81,6 +83,7 @@ test "@popCount vectors" {	...	@@ -81,6 +83,7 @@ test "@popCount vectors" {
81	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
82	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
83	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	85	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		86	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
84		87
85	try comptime testPopCountVectors();	88	try comptime testPopCountVectors();
86	try testPopCountVectors();	89	try testPopCountVectors();