authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-05-07 10:46:05+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-05-07 10:46:05+02:00
log197c2a465f51b61bd3d2e58c5e6fecadacb20894
treefb03f1b24821b0310157074d82daf60d0e154ea5
parent43a627927f989034ae64846abea73bc8bdb545be

regalloc: rename freeze/unfreeze to lock/unlock registers

5 files changed, 384 insertions(+), 385 deletions(-)

src/arch/aarch64/CodeGen.zig+69-69
......@@ -728,7 +728,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
728728 // zig fmt: on
729729 }
730730
731 assert(!self.register_manager.frozenRegsExist());
731 assert(!self.register_manager.lockedRegsExist());
732732
733733 if (std.debug.runtime_safety) {
734734 if (self.air_bookkeeping < old_air_bookkeeping + 1) {
......@@ -1058,8 +1058,8 @@ fn trunc(
10581058 }
10591059 },
10601060 };
1061 const lock = self.register_manager.freezeReg(operand_reg);
1062 defer if (lock) |reg| self.register_manager.unfreezeReg(reg);
1061 const lock = self.register_manager.lockReg(operand_reg);
1062 defer if (lock) |reg| self.register_manager.unlockReg(reg);
10631063
10641064 const dest_reg = if (maybe_inst) |inst| blk: {
10651065 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
......@@ -1145,8 +1145,8 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
11451145 .register => |r| r,
11461146 else => try self.copyToTmpRegister(operand_ty, operand),
11471147 };
1148 const reg_lock = self.register_manager.freezeRegAssumeUnused(op_reg);
1149 defer self.register_manager.unfreezeReg(reg_lock);
1148 const reg_lock = self.register_manager.lockRegAssumeUnused(op_reg);
1149 defer self.register_manager.unlockReg(reg_lock);
11501150
11511151 const dest_reg = blk: {
11521152 if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {
......@@ -1178,8 +1178,8 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
11781178 .register => |r| r,
11791179 else => try self.copyToTmpRegister(operand_ty, operand),
11801180 };
1181 const reg_lock = self.register_manager.freezeRegAssumeUnused(op_reg);
1182 defer self.register_manager.unfreezeReg(reg_lock);
1181 const reg_lock = self.register_manager.lockRegAssumeUnused(op_reg);
1182 defer self.register_manager.unlockReg(reg_lock);
11831183
11841184 const dest_reg = blk: {
11851185 if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {
......@@ -1268,16 +1268,16 @@ fn binOpRegister(
12681268 const rhs_is_register = rhs == .register;
12691269
12701270 const lhs_lock: ?RegisterLock = if (lhs_is_register)
1271 self.register_manager.freezeReg(lhs.register)
1271 self.register_manager.lockReg(lhs.register)
12721272 else
12731273 null;
1274 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1274 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
12751275
12761276 const rhs_lock: ?RegisterLock = if (rhs_is_register)
1277 self.register_manager.freezeReg(rhs.register)
1277 self.register_manager.lockReg(rhs.register)
12781278 else
12791279 null;
1280 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1280 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
12811281
12821282 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
12831283
......@@ -1294,8 +1294,8 @@ fn binOpRegister(
12941294
12951295 break :blk reg;
12961296 };
1297 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);
1298 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1297 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
1298 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
12991299
13001300 const rhs_reg = if (rhs_is_register) rhs.register else blk: {
13011301 const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {
......@@ -1310,8 +1310,8 @@ fn binOpRegister(
13101310
13111311 break :blk reg;
13121312 };
1313 const new_rhs_lock = self.register_manager.freezeReg(rhs_reg);
1314 defer if (new_rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1313 const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
1314 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
13151315
13161316 const dest_reg = switch (mir_tag) {
13171317 .cmp_shifted_register => undefined, // cmp has no destination register
......@@ -1414,10 +1414,10 @@ fn binOpImmediate(
14141414 const lhs_is_register = lhs == .register;
14151415
14161416 const lhs_lock: ?RegisterLock = if (lhs_is_register)
1417 self.register_manager.freezeReg(lhs.register)
1417 self.register_manager.lockReg(lhs.register)
14181418 else
14191419 null;
1420 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1420 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
14211421
14221422 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
14231423
......@@ -1436,8 +1436,8 @@ fn binOpImmediate(
14361436
14371437 break :blk reg;
14381438 };
1439 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);
1440 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1439 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
1440 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
14411441
14421442 const dest_reg = switch (mir_tag) {
14431443 .cmp_immediate => undefined, // cmp has no destination register
......@@ -1841,13 +1841,13 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
18411841 };
18421842 const dest = try self.binOp(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);
18431843 const dest_reg = dest.register;
1844 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);
1845 defer self.register_manager.unfreezeReg(dest_reg_lock);
1844 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
1845 defer self.register_manager.unlockReg(dest_reg_lock);
18461846
18471847 const raw_truncated_reg = try self.register_manager.allocReg(null);
18481848 const truncated_reg = registerAlias(raw_truncated_reg, lhs_ty.abiSize(self.target.*));
1849 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);
1850 defer self.register_manager.unfreezeReg(truncated_reg_lock);
1849 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1850 defer self.register_manager.unlockReg(truncated_reg_lock);
18511851
18521852 // sbfx/ubfx truncated, dest, #0, #bits
18531853 try self.truncRegister(dest_reg, truncated_reg, int_info.signedness, int_info.bits);
......@@ -1948,12 +1948,12 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
19481948
19491949 const dest = try self.binOpRegister(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);
19501950 const dest_reg = dest.register;
1951 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);
1952 defer self.register_manager.unfreezeReg(dest_reg_lock);
1951 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
1952 defer self.register_manager.unlockReg(dest_reg_lock);
19531953
19541954 const truncated_reg = try self.register_manager.allocReg(null);
1955 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);
1956 defer self.register_manager.unfreezeReg(truncated_reg_lock);
1955 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1956 defer self.register_manager.unlockReg(truncated_reg_lock);
19571957
19581958 try self.truncRegister(
19591959 dest_reg.to32(),
......@@ -2004,32 +2004,32 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
20042004 const rhs_is_register = rhs == .register;
20052005
20062006 const lhs_lock: ?RegisterLock = if (lhs_is_register)
2007 self.register_manager.freezeRegAssumeUnused(lhs.register)
2007 self.register_manager.lockRegAssumeUnused(lhs.register)
20082008 else
20092009 null;
2010 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
2010 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
20112011
20122012 const rhs_lock: ?RegisterLock = if (rhs_is_register)
2013 self.register_manager.freezeRegAssumeUnused(rhs.register)
2013 self.register_manager.lockRegAssumeUnused(rhs.register)
20142014 else
20152015 null;
2016 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
2016 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
20172017
20182018 const lhs_reg = if (lhs_is_register) lhs.register else blk: {
20192019 const raw_reg = try self.register_manager.allocReg(null);
20202020 const reg = registerAlias(raw_reg, lhs_ty.abiSize(self.target.*));
20212021 break :blk reg;
20222022 };
2023 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);
2024 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
2023 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
2024 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
20252025
20262026 const rhs_reg = if (rhs_is_register) rhs.register else blk: {
20272027 const raw_reg = try self.register_manager.allocReg(null);
20282028 const reg = registerAlias(raw_reg, rhs_ty.abiAlignment(self.target.*));
20292029 break :blk reg;
20302030 };
2031 const new_rhs_lock = self.register_manager.freezeReg(rhs_reg);
2032 defer if (new_rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
2031 const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
2032 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
20332033
20342034 if (!lhs_is_register) try self.genSetReg(lhs_ty, lhs_reg, lhs);
20352035 if (!rhs_is_register) try self.genSetReg(rhs_ty, rhs_reg, rhs);
......@@ -2039,8 +2039,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
20392039 const reg = registerAlias(raw_reg, lhs_ty.abiSize(self.target.*));
20402040 break :blk reg;
20412041 };
2042 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);
2043 defer self.register_manager.unfreezeReg(dest_reg_lock);
2042 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
2043 defer self.register_manager.unlockReg(dest_reg_lock);
20442044
20452045 switch (int_info.signedness) {
20462046 .signed => {
......@@ -2055,8 +2055,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
20552055 });
20562056
20572057 const dest_high_reg = try self.register_manager.allocReg(null);
2058 const dest_high_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_high_reg);
2059 defer self.register_manager.unfreezeReg(dest_high_reg_lock);
2058 const dest_high_reg_lock = self.register_manager.lockRegAssumeUnused(dest_high_reg);
2059 defer self.register_manager.unlockReg(dest_high_reg_lock);
20602060
20612061 // smulh dest_high, lhs, rhs
20622062 _ = try self.addInst(.{
......@@ -2105,8 +2105,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
21052105 },
21062106 .unsigned => {
21072107 const dest_high_reg = try self.register_manager.allocReg(null);
2108 const dest_high_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_high_reg);
2109 defer self.register_manager.unfreezeReg(dest_high_reg_lock);
2108 const dest_high_reg_lock = self.register_manager.lockRegAssumeUnused(dest_high_reg);
2109 defer self.register_manager.unlockReg(dest_high_reg_lock);
21102110
21112111 // umulh dest_high, lhs, rhs
21122112 _ = try self.addInst(.{
......@@ -2161,8 +2161,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
21612161 }
21622162
21632163 const truncated_reg = try self.register_manager.allocReg(null);
2164 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);
2165 defer self.register_manager.unfreezeReg(truncated_reg_lock);
2164 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
2165 defer self.register_manager.unlockReg(truncated_reg_lock);
21662166
21672167 try self.truncRegister(dest_reg, truncated_reg, int_info.signedness, int_info.bits);
21682168
......@@ -2203,10 +2203,10 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
22032203 const stack_offset = try self.allocMem(inst, tuple_size, tuple_align);
22042204
22052205 const lhs_lock: ?RegisterLock = if (lhs == .register)
2206 self.register_manager.freezeRegAssumeUnused(lhs.register)
2206 self.register_manager.lockRegAssumeUnused(lhs.register)
22072207 else
22082208 null;
2209 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
2209 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
22102210
22112211 try self.spillCompareFlagsIfOccupied();
22122212 self.compare_flags_inst = null;
......@@ -2214,8 +2214,8 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
22142214 // lsl dest, lhs, rhs
22152215 const dest = try self.binOp(.shl, null, lhs, rhs, lhs_ty, rhs_ty);
22162216 const dest_reg = dest.register;
2217 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);
2218 defer self.register_manager.unfreezeReg(dest_reg_lock);
2217 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
2218 defer self.register_manager.unlockReg(dest_reg_lock);
22192219
22202220 // asr/lsr reconstructed, dest, rhs
22212221 const reconstructed = try self.binOp(.shr, null, dest, rhs, lhs_ty, rhs_ty);
......@@ -2454,17 +2454,17 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
24542454 const slice_ptr_field_type = slice_ty.slicePtrFieldType(&buf);
24552455
24562456 const index_lock: ?RegisterLock = if (index_is_register)
2457 self.register_manager.freezeRegAssumeUnused(index_mcv.register)
2457 self.register_manager.lockRegAssumeUnused(index_mcv.register)
24582458 else
24592459 null;
2460 defer if (index_lock) |reg| self.register_manager.unfreezeReg(reg);
2460 defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
24612461
24622462 const base_mcv: MCValue = switch (slice_mcv) {
24632463 .stack_offset => |off| .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, .{ .stack_offset = off }) },
24642464 else => return self.fail("TODO slice_elem_val when slice is {}", .{slice_mcv}),
24652465 };
2466 const base_lock = self.register_manager.freezeRegAssumeUnused(base_mcv.register);
2467 defer self.register_manager.unfreezeReg(base_lock);
2466 const base_lock = self.register_manager.lockRegAssumeUnused(base_mcv.register);
2467 defer self.register_manager.unlockReg(base_lock);
24682468
24692469 switch (elem_size) {
24702470 else => {
......@@ -2605,8 +2605,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
26052605 .immediate => |imm| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),
26062606 .ptr_stack_offset => |off| try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off }),
26072607 .register => |addr_reg| {
2608 const addr_reg_lock = self.register_manager.freezeReg(addr_reg);
2609 defer if (addr_reg_lock) |reg| self.register_manager.unfreezeReg(reg);
2608 const addr_reg_lock = self.register_manager.lockReg(addr_reg);
2609 defer if (addr_reg_lock) |reg| self.register_manager.unlockReg(reg);
26102610
26112611 switch (dst_mcv) {
26122612 .dead => unreachable,
......@@ -2619,8 +2619,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
26192619 if (elem_size <= 8) {
26202620 const raw_tmp_reg = try self.register_manager.allocReg(null);
26212621 const tmp_reg = registerAlias(raw_tmp_reg, elem_size);
2622 const tmp_reg_lock = self.register_manager.freezeRegAssumeUnused(tmp_reg);
2623 defer self.register_manager.unfreezeReg(tmp_reg_lock);
2622 const tmp_reg_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
2623 defer self.register_manager.unlockReg(tmp_reg_lock);
26242624
26252625 try self.load(.{ .register = tmp_reg }, ptr, ptr_ty);
26262626 try self.genSetStack(elem_ty, off, MCValue{ .register = tmp_reg });
......@@ -2628,9 +2628,9 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
26282628 // TODO optimize the register allocation
26292629 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });
26302630 var regs_locks: [4]RegisterLock = undefined;
2631 self.register_manager.freezeRegsAssumeUnused(4, regs, &regs_locks);
2631 self.register_manager.lockRegsAssumeUnused(4, regs, &regs_locks);
26322632 defer for (regs_locks) |reg| {
2633 self.register_manager.unfreezeReg(reg);
2633 self.register_manager.unlockReg(reg);
26342634 };
26352635
26362636 const src_reg = addr_reg;
......@@ -2833,8 +2833,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
28332833 try self.genSetStack(value_ty, off, value);
28342834 },
28352835 .register => |addr_reg| {
2836 const addr_reg_lock = self.register_manager.freezeReg(addr_reg);
2837 defer if (addr_reg_lock) |reg| self.register_manager.unfreezeReg(reg);
2836 const addr_reg_lock = self.register_manager.lockReg(addr_reg);
2837 defer if (addr_reg_lock) |reg| self.register_manager.unlockReg(reg);
28382838
28392839 switch (value) {
28402840 .register => |value_reg| {
......@@ -2844,8 +2844,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
28442844 if (abi_size <= 8) {
28452845 const raw_tmp_reg = try self.register_manager.allocReg(null);
28462846 const tmp_reg = registerAlias(raw_tmp_reg, abi_size);
2847 const tmp_reg_lock = self.register_manager.freezeRegAssumeUnused(tmp_reg);
2848 defer self.register_manager.unfreezeReg(tmp_reg_lock);
2847 const tmp_reg_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
2848 defer self.register_manager.unlockReg(tmp_reg_lock);
28492849
28502850 try self.genSetReg(value_ty, tmp_reg, value);
28512851 try self.store(ptr, .{ .register = tmp_reg }, ptr_ty, value_ty);
......@@ -2905,12 +2905,12 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
29052905 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{
29062906 .immediate = struct_field_offset,
29072907 });
2908 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);
2909 defer self.register_manager.unfreezeReg(offset_reg_lock);
2908 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2909 defer self.register_manager.unlockReg(offset_reg_lock);
29102910
29112911 const addr_reg = try self.copyToTmpRegister(ptr_ty, mcv);
2912 const addr_reg_lock = self.register_manager.freezeRegAssumeUnused(addr_reg);
2913 defer self.register_manager.unfreezeReg(addr_reg_lock);
2912 const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
2913 defer self.register_manager.unlockReg(addr_reg_lock);
29142914
29152915 const dest = try self.binOp(
29162916 .add,
......@@ -4008,8 +4008,8 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
40084008 .register_c_flag,
40094009 .register_v_flag,
40104010 => |reg| {
4011 const reg_lock = self.register_manager.freezeReg(reg);
4012 defer if (reg_lock) |locked_reg| self.register_manager.unfreezeReg(locked_reg);
4011 const reg_lock = self.register_manager.lockReg(reg);
4012 defer if (reg_lock) |locked_reg| self.register_manager.unlockReg(locked_reg);
40134013
40144014 const wrapped_ty = ty.structFieldType(0);
40154015 try self.genSetStack(wrapped_ty, stack_offset, .{ .register = reg });
......@@ -4066,9 +4066,9 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
40664066 // TODO call extern memcpy
40674067 const regs = try self.register_manager.allocRegs(5, .{ null, null, null, null, null });
40684068 var regs_locks: [5]RegisterLock = undefined;
4069 self.register_manager.freezeRegsAssumeUnused(5, regs, &regs_locks);
4069 self.register_manager.lockRegsAssumeUnused(5, regs, &regs_locks);
40704070 defer for (regs_locks) |reg| {
4071 self.register_manager.unfreezeReg(reg);
4071 self.register_manager.unlockReg(reg);
40724072 };
40734073
40744074 const src_reg = regs[0];
src/arch/arm/CodeGen.zig+67-67
......@@ -735,7 +735,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
735735 // zig fmt: on
736736 }
737737
738 assert(!self.register_manager.frozenRegsExist());
738 assert(!self.register_manager.lockedRegsExist());
739739
740740 if (std.debug.runtime_safety) {
741741 if (self.air_bookkeeping < old_air_bookkeeping + 1) {
......@@ -1039,8 +1039,8 @@ fn trunc(
10391039 }
10401040 },
10411041 };
1042 const operand_reg_lock = self.register_manager.freezeReg(operand_reg);
1043 defer if (operand_reg_lock) |reg| self.register_manager.unfreezeReg(reg);
1042 const operand_reg_lock = self.register_manager.lockReg(operand_reg);
1043 defer if (operand_reg_lock) |reg| self.register_manager.unlockReg(reg);
10441044
10451045 const dest_reg = if (maybe_inst) |inst| blk: {
10461046 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
......@@ -1128,8 +1128,8 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
11281128 .register => |r| r,
11291129 else => try self.copyToTmpRegister(operand_ty, operand),
11301130 };
1131 const op_reg_lock = self.register_manager.freezeRegAssumeUnused(op_reg);
1132 defer self.register_manager.unfreezeReg(op_reg_lock);
1131 const op_reg_lock = self.register_manager.lockRegAssumeUnused(op_reg);
1132 defer self.register_manager.unlockReg(op_reg_lock);
11331133
11341134 const dest_reg = blk: {
11351135 if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {
......@@ -1158,8 +1158,8 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
11581158 .register => |r| r,
11591159 else => try self.copyToTmpRegister(operand_ty, operand),
11601160 };
1161 const op_reg_lock = self.register_manager.freezeRegAssumeUnused(op_reg);
1162 defer self.register_manager.unfreezeReg(op_reg_lock);
1161 const op_reg_lock = self.register_manager.lockRegAssumeUnused(op_reg);
1162 defer self.register_manager.unlockReg(op_reg_lock);
11631163
11641164 const dest_reg = blk: {
11651165 if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {
......@@ -1219,15 +1219,15 @@ fn minMax(
12191219 .register => |r| r,
12201220 else => try self.copyToTmpRegister(lhs_ty, lhs),
12211221 };
1222 const lhs_reg_lock = self.register_manager.freezeReg(lhs_reg);
1223 defer if (lhs_reg_lock) |reg| self.register_manager.unfreezeReg(reg);
1222 const lhs_reg_lock = self.register_manager.lockReg(lhs_reg);
1223 defer if (lhs_reg_lock) |reg| self.register_manager.unlockReg(reg);
12241224
12251225 const rhs_reg = switch (rhs) {
12261226 .register => |r| r,
12271227 else => try self.copyToTmpRegister(rhs_ty, rhs),
12281228 };
1229 const rhs_reg_lock = self.register_manager.freezeReg(rhs_reg);
1230 defer if (rhs_reg_lock) |reg| self.register_manager.unfreezeReg(reg);
1229 const rhs_reg_lock = self.register_manager.lockReg(rhs_reg);
1230 defer if (rhs_reg_lock) |reg| self.register_manager.unlockReg(reg);
12311231
12321232 const dest_reg = if (maybe_inst) |inst| blk: {
12331233 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
......@@ -1393,12 +1393,12 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
13931393 };
13941394 const dest = try self.binOp(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);
13951395 const dest_reg = dest.register;
1396 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);
1397 defer self.register_manager.unfreezeReg(dest_reg_lock);
1396 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
1397 defer self.register_manager.unlockReg(dest_reg_lock);
13981398
13991399 const truncated_reg = try self.register_manager.allocReg(null);
1400 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);
1401 defer self.register_manager.unfreezeReg(truncated_reg_lock);
1400 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1401 defer self.register_manager.unlockReg(truncated_reg_lock);
14021402
14031403 // sbfx/ubfx truncated, dest, #0, #bits
14041404 try self.truncRegister(dest_reg, truncated_reg, int_info.signedness, int_info.bits);
......@@ -1494,12 +1494,12 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
14941494
14951495 const dest = try self.binOpRegister(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);
14961496 const dest_reg = dest.register;
1497 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);
1498 defer self.register_manager.unfreezeReg(dest_reg_lock);
1497 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
1498 defer self.register_manager.unlockReg(dest_reg_lock);
14991499
15001500 const truncated_reg = try self.register_manager.allocReg(null);
1501 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);
1502 defer self.register_manager.unfreezeReg(truncated_reg_lock);
1501 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1502 defer self.register_manager.unlockReg(truncated_reg_lock);
15031503
15041504 // sbfx/ubfx truncated, dest, #0, #bits
15051505 try self.truncRegister(dest_reg, truncated_reg, int_info.signedness, int_info.bits);
......@@ -1528,30 +1528,30 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
15281528 const rhs_is_register = rhs == .register;
15291529
15301530 const lhs_lock: ?RegisterLock = if (lhs_is_register)
1531 self.register_manager.freezeReg(lhs.register)
1531 self.register_manager.lockReg(lhs.register)
15321532 else
15331533 null;
1534 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1534 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
15351535
15361536 const lhs_reg = if (lhs_is_register)
15371537 lhs.register
15381538 else
15391539 try self.register_manager.allocReg(null);
1540 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);
1541 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1540 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
1541 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
15421542
15431543 const rhs_reg = if (rhs_is_register)
15441544 rhs.register
15451545 else
15461546 try self.register_manager.allocReg(null);
1547 const new_rhs_lock = self.register_manager.freezeReg(rhs_reg);
1548 defer if (new_rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1547 const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
1548 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
15491549
15501550 const dest_regs = try self.register_manager.allocRegs(2, .{ null, null });
15511551 var dest_regs_locks: [2]RegisterLock = undefined;
1552 self.register_manager.freezeRegsAssumeUnused(2, dest_regs, &dest_regs_locks);
1552 self.register_manager.lockRegsAssumeUnused(2, dest_regs, &dest_regs_locks);
15531553 defer for (dest_regs_locks) |reg| {
1554 self.register_manager.unfreezeReg(reg);
1554 self.register_manager.unlockReg(reg);
15551555 };
15561556 const rdlo = dest_regs[0];
15571557 const rdhi = dest_regs[1];
......@@ -1560,8 +1560,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
15601560 if (!rhs_is_register) try self.genSetReg(rhs_ty, rhs_reg, rhs);
15611561
15621562 const truncated_reg = try self.register_manager.allocReg(null);
1563 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);
1564 defer self.register_manager.unfreezeReg(truncated_reg_lock);
1563 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1564 defer self.register_manager.unlockReg(truncated_reg_lock);
15651565
15661566 _ = try self.addInst(.{
15671567 .tag = base_tag,
......@@ -1654,10 +1654,10 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
16541654 const stack_offset = try self.allocMem(inst, tuple_size, tuple_align);
16551655
16561656 const lhs_lock: ?RegisterLock = if (lhs == .register)
1657 self.register_manager.freezeRegAssumeUnused(lhs.register)
1657 self.register_manager.lockRegAssumeUnused(lhs.register)
16581658 else
16591659 null;
1660 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1660 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
16611661
16621662 try self.spillCompareFlagsIfOccupied();
16631663 self.compare_flags_inst = null;
......@@ -1948,10 +1948,10 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
19481948 const slice_ptr_field_type = slice_ty.slicePtrFieldType(&buf);
19491949
19501950 const index_lock: ?RegisterLock = if (index_is_register)
1951 self.register_manager.freezeRegAssumeUnused(index_mcv.register)
1951 self.register_manager.lockRegAssumeUnused(index_mcv.register)
19521952 else
19531953 null;
1954 defer if (index_lock) |reg| self.register_manager.unfreezeReg(reg);
1954 defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
19551955
19561956 const base_mcv = slicePtr(slice_mcv);
19571957
......@@ -1961,20 +1961,20 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
19611961 .register => |r| r,
19621962 else => try self.copyToTmpRegister(slice_ptr_field_type, base_mcv),
19631963 };
1964 const base_reg_lock = self.register_manager.freezeRegAssumeUnused(base_reg);
1965 defer self.register_manager.unfreezeReg(base_reg_lock);
1964 const base_reg_lock = self.register_manager.lockRegAssumeUnused(base_reg);
1965 defer self.register_manager.unlockReg(base_reg_lock);
19661966
19671967 const dst_reg = try self.register_manager.allocReg(inst);
19681968 const dst_mcv = MCValue{ .register = dst_reg };
1969 const dst_reg_lock = self.register_manager.freezeRegAssumeUnused(dst_reg);
1970 defer self.register_manager.unfreezeReg(dst_reg_lock);
1969 const dst_reg_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
1970 defer self.register_manager.unlockReg(dst_reg_lock);
19711971
19721972 const index_reg: Register = switch (index_mcv) {
19731973 .register => |reg| reg,
19741974 else => try self.copyToTmpRegister(Type.usize, index_mcv),
19751975 };
1976 const index_reg_lock = self.register_manager.freezeRegAssumeUnused(index_reg);
1977 defer self.register_manager.unfreezeReg(index_reg_lock);
1976 const index_reg_lock = self.register_manager.lockRegAssumeUnused(index_reg);
1977 defer self.register_manager.unlockReg(index_reg_lock);
19781978
19791979 const tag: Mir.Inst.Tag = switch (elem_size) {
19801980 1 => .ldrb,
......@@ -2160,8 +2160,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
21602160 .immediate => |imm| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),
21612161 .ptr_stack_offset => |off| try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off }),
21622162 .register => |reg| {
2163 const reg_lock = self.register_manager.freezeReg(reg);
2164 defer if (reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);
2163 const reg_lock = self.register_manager.lockReg(reg);
2164 defer if (reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
21652165
21662166 switch (dst_mcv) {
21672167 .dead => unreachable,
......@@ -2173,8 +2173,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
21732173 .stack_offset => |off| {
21742174 if (elem_size <= 4) {
21752175 const tmp_reg = try self.register_manager.allocReg(null);
2176 const tmp_reg_lock = self.register_manager.freezeRegAssumeUnused(tmp_reg);
2177 defer self.register_manager.unfreezeReg(tmp_reg_lock);
2176 const tmp_reg_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
2177 defer self.register_manager.unlockReg(tmp_reg_lock);
21782178
21792179 try self.load(.{ .register = tmp_reg }, ptr, ptr_ty);
21802180 try self.genSetStack(elem_ty, off, MCValue{ .register = tmp_reg });
......@@ -2182,9 +2182,9 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
21822182 // TODO optimize the register allocation
21832183 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });
21842184 var regs_locks: [4]RegisterLock = undefined;
2185 self.register_manager.freezeRegsAssumeUnused(4, regs, &regs_locks);
2185 self.register_manager.lockRegsAssumeUnused(4, regs, &regs_locks);
21862186 defer for (regs_locks) |reg_locked| {
2187 self.register_manager.unfreezeReg(reg_locked);
2187 self.register_manager.unlockReg(reg_locked);
21882188 };
21892189
21902190 const src_reg = reg;
......@@ -2211,8 +2211,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
22112211 .stack_argument_offset,
22122212 => {
22132213 const reg = try self.register_manager.allocReg(null);
2214 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);
2215 defer self.register_manager.unfreezeReg(reg_lock);
2214 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
2215 defer self.register_manager.unlockReg(reg_lock);
22162216
22172217 try self.genSetReg(ptr_ty, reg, ptr);
22182218 try self.load(dst_mcv, .{ .register = reg }, ptr_ty);
......@@ -2266,8 +2266,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
22662266 try self.genSetStack(value_ty, off, value);
22672267 },
22682268 .register => |addr_reg| {
2269 const addr_reg_lock = self.register_manager.freezeReg(addr_reg);
2270 defer if (addr_reg_lock) |reg| self.register_manager.unfreezeReg(reg);
2269 const addr_reg_lock = self.register_manager.lockReg(addr_reg);
2270 defer if (addr_reg_lock) |reg| self.register_manager.unlockReg(reg);
22712271
22722272 switch (value) {
22732273 .dead => unreachable,
......@@ -2278,17 +2278,17 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
22782278 else => {
22792279 if (elem_size <= 4) {
22802280 const tmp_reg = try self.register_manager.allocReg(null);
2281 const tmp_reg_lock = self.register_manager.freezeRegAssumeUnused(tmp_reg);
2282 defer self.register_manager.unfreezeReg(tmp_reg_lock);
2281 const tmp_reg_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
2282 defer self.register_manager.unlockReg(tmp_reg_lock);
22832283
22842284 try self.genSetReg(value_ty, tmp_reg, value);
22852285 try self.store(ptr, .{ .register = tmp_reg }, ptr_ty, value_ty);
22862286 } else {
22872287 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });
22882288 var regs_locks: [4]RegisterLock = undefined;
2289 self.register_manager.freezeRegsAssumeUnused(4, regs, &regs_locks);
2289 self.register_manager.lockRegsAssumeUnused(4, regs, &regs_locks);
22902290 defer for (regs_locks) |reg| {
2291 self.register_manager.unfreezeReg(reg);
2291 self.register_manager.unlockReg(reg);
22922292 };
22932293
22942294 const src_reg = regs[0];
......@@ -2373,12 +2373,12 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
23732373 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{
23742374 .immediate = struct_field_offset,
23752375 });
2376 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);
2377 defer self.register_manager.unfreezeReg(offset_reg_lock);
2376 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2377 defer self.register_manager.unlockReg(offset_reg_lock);
23782378
23792379 const addr_reg = try self.copyToTmpRegister(ptr_ty, mcv);
2380 const addr_reg_lock = self.register_manager.freezeRegAssumeUnused(addr_reg);
2381 defer self.register_manager.unfreezeReg(addr_reg_lock);
2380 const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
2381 defer self.register_manager.unlockReg(addr_reg_lock);
23822382
23832383 const dest = try self.binOp(
23842384 .add,
......@@ -2495,10 +2495,10 @@ fn binOpRegister(
24952495 const rhs_is_register = rhs == .register;
24962496
24972497 const lhs_lock: ?RegisterLock = if (lhs_is_register)
2498 self.register_manager.freezeReg(lhs.register)
2498 self.register_manager.lockReg(lhs.register)
24992499 else
25002500 null;
2501 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
2501 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
25022502
25032503 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
25042504
......@@ -2514,8 +2514,8 @@ fn binOpRegister(
25142514
25152515 break :blk reg;
25162516 };
2517 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);
2518 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
2517 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
2518 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
25192519
25202520 const rhs_reg = if (rhs_is_register) rhs.register else blk: {
25212521 const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {
......@@ -2529,8 +2529,8 @@ fn binOpRegister(
25292529
25302530 break :blk reg;
25312531 };
2532 const new_rhs_lock = self.register_manager.freezeReg(rhs_reg);
2533 defer if (new_rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
2532 const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
2533 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
25342534
25352535 const dest_reg = switch (mir_tag) {
25362536 .cmp => .r0, // cmp has no destination regardless
......@@ -2614,10 +2614,10 @@ fn binOpImmediate(
26142614 const lhs_is_register = lhs == .register;
26152615
26162616 const lhs_lock: ?RegisterLock = if (lhs_is_register)
2617 self.register_manager.freezeReg(lhs.register)
2617 self.register_manager.lockReg(lhs.register)
26182618 else
26192619 null;
2620 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
2620 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
26212621
26222622 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
26232623
......@@ -2635,8 +2635,8 @@ fn binOpImmediate(
26352635
26362636 break :blk reg;
26372637 };
2638 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);
2639 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
2638 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
2639 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
26402640
26412641 const dest_reg = switch (mir_tag) {
26422642 .cmp => .r0, // cmp has no destination reg
src/arch/riscv64/CodeGen.zig+8-8
......@@ -939,10 +939,10 @@ fn binOpRegister(
939939 const rhs_is_register = rhs == .register;
940940
941941 const lhs_lock: ?RegisterLock = if (lhs_is_register)
942 self.register_manager.freezeReg(lhs.register)
942 self.register_manager.lockReg(lhs.register)
943943 else
944944 null;
945 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
945 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
946946
947947 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
948948
......@@ -958,8 +958,8 @@ fn binOpRegister(
958958
959959 break :blk reg;
960960 };
961 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);
962 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
961 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
962 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
963963
964964 const rhs_reg = if (rhs_is_register) rhs.register else blk: {
965965 const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {
......@@ -973,8 +973,8 @@ fn binOpRegister(
973973
974974 break :blk reg;
975975 };
976 const new_rhs_lock = self.register_manager.freezeReg(rhs_reg);
977 defer if (new_rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
976 const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
977 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
978978
979979 const dest_reg = if (maybe_inst) |inst| blk: {
980980 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
......@@ -1452,8 +1452,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
14521452 .stack_offset,
14531453 => {
14541454 const reg = try self.register_manager.allocReg(null);
1455 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);
1456 defer self.register_manager.unfreezeReg(reg_lock);
1455 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
1456 defer self.register_manager.unlockReg(reg_lock);
14571457
14581458 try self.genSetReg(ptr_ty, reg, ptr);
14591459 try self.load(dst_mcv, .{ .register = reg }, ptr_ty);
src/arch/x86_64/CodeGen.zig+187-187
......@@ -795,7 +795,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
795795 // zig fmt: on
796796 }
797797
798 assert(!self.register_manager.frozenRegsExist());
798 assert(!self.register_manager.lockedRegsExist());
799799
800800 if (std.debug.runtime_safety) {
801801 if (self.air_bookkeeping < old_air_bookkeeping + 1) {
......@@ -1028,10 +1028,10 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
10281028 }
10291029
10301030 const operand_lock: ?RegisterLock = switch (operand) {
1031 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1031 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
10321032 else => null,
10331033 };
1034 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);
1034 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
10351035
10361036 const reg = try self.register_manager.allocReg(inst);
10371037 try self.genSetReg(dest_ty, reg, .{ .immediate = 0 });
......@@ -1059,10 +1059,10 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
10591059 }
10601060
10611061 const operand_lock: ?RegisterLock = switch (operand) {
1062 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1062 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
10631063 else => null,
10641064 };
1065 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);
1065 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
10661066
10671067 const reg: Register = blk: {
10681068 if (operand.isRegister()) {
......@@ -1147,21 +1147,21 @@ fn airMin(self: *Self, inst: Air.Inst.Index) !void {
11471147 // TODO audit register allocation
11481148 const lhs = try self.resolveInst(bin_op.lhs);
11491149 const lhs_lock: ?RegisterLock = switch (lhs) {
1150 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1150 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
11511151 else => null,
11521152 };
1153 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1153 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
11541154
11551155 const lhs_reg = try self.copyToTmpRegister(ty, lhs);
1156 const lhs_reg_lock = self.register_manager.freezeRegAssumeUnused(lhs_reg);
1157 defer self.register_manager.unfreezeReg(lhs_reg_lock);
1156 const lhs_reg_lock = self.register_manager.lockRegAssumeUnused(lhs_reg);
1157 defer self.register_manager.unlockReg(lhs_reg_lock);
11581158
11591159 const rhs_mcv = try self.limitImmediateType(bin_op.rhs, i32);
11601160 const rhs_lock: ?RegisterLock = switch (rhs_mcv) {
1161 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1161 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
11621162 else => null,
11631163 };
1164 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1164 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
11651165
11661166 try self.genBinMathOpMir(.cmp, ty, .{ .register = lhs_reg }, rhs_mcv);
11671167
......@@ -1197,10 +1197,10 @@ fn genPtrBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_r
11971197 const offset_ty = self.air.typeOf(op_rhs);
11981198
11991199 const offset_lock: ?RegisterLock = switch (offset) {
1200 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1200 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
12011201 else => null,
12021202 };
1203 defer if (offset_lock) |reg| self.register_manager.unfreezeReg(reg);
1203 defer if (offset_lock) |reg| self.register_manager.unlockReg(reg);
12041204
12051205 const dst_mcv = blk: {
12061206 if (self.reuseOperand(inst, op_lhs, 0, ptr)) {
......@@ -1210,10 +1210,10 @@ fn genPtrBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_r
12101210 };
12111211
12121212 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {
1213 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1213 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
12141214 else => null,
12151215 };
1216 defer if (dst_mcv_lock) |reg| self.register_manager.unfreezeReg(reg);
1216 defer if (dst_mcv_lock) |reg| self.register_manager.unlockReg(reg);
12171217
12181218 const offset_mcv = blk: {
12191219 if (self.reuseOperand(inst, op_rhs, 1, offset)) {
......@@ -1223,10 +1223,10 @@ fn genPtrBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_r
12231223 };
12241224
12251225 const offset_mcv_lock: ?RegisterLock = switch (offset_mcv) {
1226 .register => |reg| self.register_manager.freezeReg(reg),
1226 .register => |reg| self.register_manager.lockReg(reg),
12271227 else => null,
12281228 };
1229 defer if (offset_mcv_lock) |reg| self.register_manager.unfreezeReg(reg);
1229 defer if (offset_mcv_lock) |reg| self.register_manager.unlockReg(reg);
12301230
12311231 try self.genIntMulComplexOpMir(offset_ty, offset_mcv, .{ .immediate = elem_size });
12321232
......@@ -1312,17 +1312,17 @@ fn genSubOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs: Air
13121312
13131313 const lhs = try self.resolveInst(op_lhs);
13141314 const lhs_lock: ?RegisterLock = switch (lhs) {
1315 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1315 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
13161316 else => null,
13171317 };
1318 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1318 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
13191319
13201320 const rhs = try self.resolveInst(op_rhs);
13211321 const rhs_lock: ?RegisterLock = switch (rhs) {
1322 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1322 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
13231323 else => null,
13241324 };
1325 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1325 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
13261326
13271327 const dst_mcv = blk: {
13281328 if (self.reuseOperand(inst, op_lhs, 0, lhs) and lhs.isRegister()) {
......@@ -1331,20 +1331,20 @@ fn genSubOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs: Air
13311331 break :blk try self.copyToRegisterWithInstTracking(inst, dst_ty, lhs);
13321332 };
13331333 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {
1334 .register => |reg| self.register_manager.freezeReg(reg),
1334 .register => |reg| self.register_manager.lockReg(reg),
13351335 else => null,
13361336 };
1337 defer if (dst_mcv_lock) |reg| self.register_manager.unfreezeReg(reg);
1337 defer if (dst_mcv_lock) |reg| self.register_manager.unlockReg(reg);
13381338
13391339 const rhs_mcv = blk: {
13401340 if (rhs.isMemory() or rhs.isRegister()) break :blk rhs;
13411341 break :blk MCValue{ .register = try self.copyToTmpRegister(dst_ty, rhs) };
13421342 };
13431343 const rhs_mcv_lock: ?RegisterLock = switch (rhs_mcv) {
1344 .register => |reg| self.register_manager.freezeReg(reg),
1344 .register => |reg| self.register_manager.lockReg(reg),
13451345 else => null,
13461346 };
1347 defer if (rhs_mcv_lock) |reg| self.register_manager.unfreezeReg(reg);
1347 defer if (rhs_mcv_lock) |reg| self.register_manager.unlockReg(reg);
13481348
13491349 try self.genBinMathOpMir(.sub, dst_ty, dst_mcv, rhs_mcv);
13501350
......@@ -1382,9 +1382,9 @@ fn airMul(self: *Self, inst: Air.Inst.Index) !void {
13821382 try self.register_manager.getReg(.rax, inst);
13831383 try self.register_manager.getReg(.rdx, null);
13841384 var reg_locks: [2]RegisterLock = undefined;
1385 self.register_manager.freezeRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1385 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
13861386 defer for (reg_locks) |reg| {
1387 self.register_manager.unfreezeReg(reg);
1387 self.register_manager.unlockReg(reg);
13881388 };
13891389
13901390 const lhs = try self.resolveInst(bin_op.lhs);
......@@ -1496,9 +1496,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
14961496 try self.register_manager.getReg(.rax, inst);
14971497 try self.register_manager.getReg(.rdx, null);
14981498 var reg_locks: [2]RegisterLock = undefined;
1499 self.register_manager.freezeRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1499 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
15001500 defer for (reg_locks) |reg| {
1501 self.register_manager.unfreezeReg(reg);
1501 self.register_manager.unlockReg(reg);
15021502 };
15031503
15041504 const lhs = try self.resolveInst(bin_op.lhs);
......@@ -1526,27 +1526,27 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
15261526 const rhs = try self.resolveInst(bin_op.rhs);
15271527
15281528 const rhs_lock: ?RegisterLock = switch (rhs) {
1529 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1529 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
15301530 else => null,
15311531 };
1532 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1532 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
15331533
15341534 const dst_reg: Register = blk: {
15351535 if (lhs.isRegister()) break :blk lhs.register;
15361536 break :blk try self.copyToTmpRegister(ty, lhs);
15371537 };
1538 const dst_reg_lock = self.register_manager.freezeRegAssumeUnused(dst_reg);
1539 defer self.register_manager.unfreezeReg(dst_reg_lock);
1538 const dst_reg_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
1539 defer self.register_manager.unlockReg(dst_reg_lock);
15401540
15411541 const rhs_mcv = blk: {
15421542 if (rhs.isRegister() or rhs.isMemory()) break :blk rhs;
15431543 break :blk MCValue{ .register = try self.copyToTmpRegister(ty, rhs) };
15441544 };
15451545 const rhs_mcv_lock: ?RegisterLock = switch (rhs_mcv) {
1546 .register => |reg| self.register_manager.freezeReg(reg),
1546 .register => |reg| self.register_manager.lockReg(reg),
15471547 else => null,
15481548 };
1549 defer if (rhs_mcv_lock) |reg| self.register_manager.unfreezeReg(reg);
1549 defer if (rhs_mcv_lock) |reg| self.register_manager.unlockReg(reg);
15501550
15511551 try self.genIntMulComplexOpMir(Type.isize, .{ .register = dst_reg }, rhs_mcv);
15521552
......@@ -1557,9 +1557,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
15571557 try self.register_manager.getReg(.rax, null);
15581558 try self.register_manager.getReg(.rdx, null);
15591559 var reg_locks: [2]RegisterLock = undefined;
1560 self.register_manager.freezeRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1560 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
15611561 defer for (reg_locks) |reg| {
1562 self.register_manager.unfreezeReg(reg);
1562 self.register_manager.unlockReg(reg);
15631563 };
15641564
15651565 const lhs = try self.resolveInst(bin_op.lhs);
......@@ -1571,8 +1571,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
15711571 },
15721572 }
15731573 };
1574 const dst_reg_lock = self.register_manager.freezeRegAssumeUnused(dst_reg);
1575 defer self.register_manager.unfreezeReg(dst_reg_lock);
1574 const dst_reg_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
1575 defer self.register_manager.unlockReg(dst_reg_lock);
15761576
15771577 const tuple_ty = self.air.typeOfIndex(inst);
15781578 const tuple_size = @intCast(u32, tuple_ty.abiSize(self.target.*));
......@@ -1587,9 +1587,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
15871587
15881588 const temp_regs = try self.register_manager.allocRegs(3, .{ null, null, null });
15891589 var temp_regs_locks: [3]RegisterLock = undefined;
1590 self.register_manager.freezeRegsAssumeUnused(3, temp_regs, &temp_regs_locks);
1590 self.register_manager.lockRegsAssumeUnused(3, temp_regs, &temp_regs_locks);
15911591 defer for (temp_regs_locks) |reg| {
1592 self.register_manager.unfreezeReg(reg);
1592 self.register_manager.unlockReg(reg);
15931593 };
15941594
15951595 const overflow_reg = temp_regs[0];
......@@ -1738,15 +1738,15 @@ fn genInlineIntDivFloor(self: *Self, ty: Type, lhs: MCValue, rhs: MCValue) !MCVa
17381738 .register => |reg| reg,
17391739 else => try self.copyToTmpRegister(ty, lhs),
17401740 };
1741 const dividend_lock = self.register_manager.freezeReg(dividend);
1742 defer if (dividend_lock) |reg| self.register_manager.unfreezeReg(reg);
1741 const dividend_lock = self.register_manager.lockReg(dividend);
1742 defer if (dividend_lock) |reg| self.register_manager.unlockReg(reg);
17431743
17441744 const divisor = switch (rhs) {
17451745 .register => |reg| reg,
17461746 else => try self.copyToTmpRegister(ty, rhs),
17471747 };
1748 const divisor_lock = self.register_manager.freezeReg(divisor);
1749 defer if (divisor_lock) |reg| self.register_manager.unfreezeReg(reg);
1748 const divisor_lock = self.register_manager.lockReg(divisor);
1749 defer if (divisor_lock) |reg| self.register_manager.unlockReg(reg);
17501750
17511751 try self.genIntMulDivOpMir(switch (signedness) {
17521752 .signed => .idiv,
......@@ -1816,17 +1816,17 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
18161816 try self.register_manager.getReg(.rax, track_rax);
18171817 try self.register_manager.getReg(.rdx, null);
18181818 var reg_locks: [2]RegisterLock = undefined;
1819 self.register_manager.freezeRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1819 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
18201820 defer for (reg_locks) |reg| {
1821 self.register_manager.unfreezeReg(reg);
1821 self.register_manager.unlockReg(reg);
18221822 };
18231823
18241824 const lhs = try self.resolveInst(bin_op.lhs);
18251825 const lhs_lock: ?RegisterLock = switch (lhs) {
1826 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1826 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
18271827 else => null,
18281828 };
1829 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1829 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
18301830
18311831 const rhs = blk: {
18321832 const rhs = try self.resolveInst(bin_op.rhs);
......@@ -1834,10 +1834,10 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
18341834 switch (tag) {
18351835 .div_floor => {
18361836 const rhs_lock: ?RegisterLock = switch (rhs) {
1837 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
1837 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
18381838 else => null,
18391839 };
1840 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1840 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
18411841
18421842 break :blk try self.copyToRegisterWithInstTracking(inst, ty, rhs);
18431843 },
......@@ -1847,10 +1847,10 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
18471847 break :blk rhs;
18481848 };
18491849 const rhs_lock: ?RegisterLock = switch (rhs) {
1850 .register => |reg| self.register_manager.freezeReg(reg),
1850 .register => |reg| self.register_manager.lockReg(reg),
18511851 else => null,
18521852 };
1853 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
1853 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
18541854
18551855 if (signedness == .unsigned) {
18561856 try self.genIntMulDivOpMir(.div, ty, signedness, lhs, rhs);
......@@ -1885,9 +1885,9 @@ fn airRem(self: *Self, inst: Air.Inst.Index) !void {
18851885 try self.register_manager.getReg(.rax, null);
18861886 try self.register_manager.getReg(.rdx, inst);
18871887 var reg_locks: [2]RegisterLock = undefined;
1888 self.register_manager.freezeRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1888 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
18891889 defer for (reg_locks) |reg| {
1890 self.register_manager.unfreezeReg(reg);
1890 self.register_manager.unlockReg(reg);
18911891 };
18921892
18931893 const lhs = try self.resolveInst(bin_op.lhs);
......@@ -1916,9 +1916,9 @@ fn airMod(self: *Self, inst: Air.Inst.Index) !void {
19161916 try self.register_manager.getReg(.rax, null);
19171917 try self.register_manager.getReg(.rdx, if (signedness == .unsigned) inst else null);
19181918 var reg_locks: [2]RegisterLock = undefined;
1919 self.register_manager.freezeRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1919 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
19201920 defer for (reg_locks) |reg| {
1921 self.register_manager.unfreezeReg(reg);
1921 self.register_manager.unlockReg(reg);
19221922 };
19231923
19241924 const lhs = try self.resolveInst(bin_op.lhs);
......@@ -2009,15 +2009,15 @@ fn airShl(self: *Self, inst: Air.Inst.Index) !void {
20092009 try self.register_manager.getReg(.rcx, null);
20102010 try self.genSetReg(shift_ty, .rcx, shift);
20112011 }
2012 const rcx_lock = self.register_manager.freezeRegAssumeUnused(.rcx);
2013 defer self.register_manager.unfreezeReg(rcx_lock);
2012 const rcx_lock = self.register_manager.lockRegAssumeUnused(.rcx);
2013 defer self.register_manager.unlockReg(rcx_lock);
20142014
20152015 const value = try self.resolveInst(bin_op.lhs);
20162016 const value_lock: ?RegisterLock = switch (value) {
2017 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2017 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
20182018 else => null,
20192019 };
2020 defer if (value_lock) |reg| self.register_manager.unfreezeReg(reg);
2020 defer if (value_lock) |reg| self.register_manager.unlockReg(reg);
20212021
20222022 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ty, value);
20232023 _ = try self.addInst(.{
......@@ -2114,10 +2114,10 @@ fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
21142114 const payload_ty = err_union_ty.errorUnionPayload();
21152115 const operand = try self.resolveInst(ty_op.operand);
21162116 const operand_lock: ?RegisterLock = switch (operand) {
2117 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2117 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
21182118 else => null,
21192119 };
2120 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);
2120 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
21212121
21222122 const result: MCValue = result: {
21232123 if (!payload_ty.hasRuntimeBits()) break :result operand;
......@@ -2147,10 +2147,10 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
21472147
21482148 const operand = try self.resolveInst(ty_op.operand);
21492149 const operand_lock: ?RegisterLock = switch (operand) {
2150 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2150 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
21512151 else => null,
21522152 };
2153 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);
2153 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
21542154
21552155 const abi_align = err_union_ty.abiAlignment(self.target.*);
21562156 const err_ty = err_union_ty.errorUnionSet();
......@@ -2219,10 +2219,10 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
22192219 const optional_ty = self.air.typeOfIndex(inst);
22202220 const operand = try self.resolveInst(ty_op.operand);
22212221 const operand_lock: ?RegisterLock = switch (operand) {
2222 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2222 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
22232223 else => null,
22242224 };
2225 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);
2225 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
22262226
22272227 if (optional_ty.isPtrLikeOptional()) {
22282228 // TODO should we check if we can reuse the operand?
......@@ -2356,10 +2356,10 @@ fn genSliceElemPtr(self: *Self, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {
23562356 const slice_ty = self.air.typeOf(lhs);
23572357 const slice_mcv = try self.resolveInst(lhs);
23582358 const slice_mcv_lock: ?RegisterLock = switch (slice_mcv) {
2359 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2359 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
23602360 else => null,
23612361 };
2362 defer if (slice_mcv_lock) |reg| self.register_manager.unfreezeReg(reg);
2362 defer if (slice_mcv_lock) |reg| self.register_manager.unlockReg(reg);
23632363
23642364 const elem_ty = slice_ty.childType();
23652365 const elem_size = elem_ty.abiSize(self.target.*);
......@@ -2369,14 +2369,14 @@ fn genSliceElemPtr(self: *Self, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {
23692369 const index_ty = self.air.typeOf(rhs);
23702370 const index_mcv = try self.resolveInst(rhs);
23712371 const index_mcv_lock: ?RegisterLock = switch (index_mcv) {
2372 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2372 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
23732373 else => null,
23742374 };
2375 defer if (index_mcv_lock) |reg| self.register_manager.unfreezeReg(reg);
2375 defer if (index_mcv_lock) |reg| self.register_manager.unlockReg(reg);
23762376
23772377 const offset_reg = try self.elemOffset(index_ty, index_mcv, elem_size);
2378 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);
2379 defer self.register_manager.unfreezeReg(offset_reg_lock);
2378 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2379 defer self.register_manager.unlockReg(offset_reg_lock);
23802380
23812381 const addr_reg = try self.register_manager.allocReg(null);
23822382 switch (slice_mcv) {
......@@ -2433,10 +2433,10 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
24332433 const array_ty = self.air.typeOf(bin_op.lhs);
24342434 const array = try self.resolveInst(bin_op.lhs);
24352435 const array_lock: ?RegisterLock = switch (array) {
2436 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2436 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
24372437 else => null,
24382438 };
2439 defer if (array_lock) |reg| self.register_manager.unfreezeReg(reg);
2439 defer if (array_lock) |reg| self.register_manager.unlockReg(reg);
24402440
24412441 const elem_ty = array_ty.childType();
24422442 const elem_abi_size = elem_ty.abiSize(self.target.*);
......@@ -2444,14 +2444,14 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
24442444 const index_ty = self.air.typeOf(bin_op.rhs);
24452445 const index = try self.resolveInst(bin_op.rhs);
24462446 const index_lock: ?RegisterLock = switch (index) {
2447 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2447 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
24482448 else => null,
24492449 };
2450 defer if (index_lock) |reg| self.register_manager.unfreezeReg(reg);
2450 defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
24512451
24522452 const offset_reg = try self.elemOffset(index_ty, index, elem_abi_size);
2453 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);
2454 defer self.register_manager.unfreezeReg(offset_reg_lock);
2453 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2454 defer self.register_manager.unlockReg(offset_reg_lock);
24552455
24562456 const addr_reg = try self.register_manager.allocReg(null);
24572457 switch (array) {
......@@ -2512,24 +2512,24 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
25122512 const ptr_ty = self.air.typeOf(bin_op.lhs);
25132513 const ptr = try self.resolveInst(bin_op.lhs);
25142514 const ptr_lock: ?RegisterLock = switch (ptr) {
2515 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2515 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
25162516 else => null,
25172517 };
2518 defer if (ptr_lock) |reg| self.register_manager.unfreezeReg(reg);
2518 defer if (ptr_lock) |reg| self.register_manager.unlockReg(reg);
25192519
25202520 const elem_ty = ptr_ty.elemType2();
25212521 const elem_abi_size = elem_ty.abiSize(self.target.*);
25222522 const index_ty = self.air.typeOf(bin_op.rhs);
25232523 const index = try self.resolveInst(bin_op.rhs);
25242524 const index_lock: ?RegisterLock = switch (index) {
2525 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2525 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
25262526 else => null,
25272527 };
2528 defer if (index_lock) |reg| self.register_manager.unfreezeReg(reg);
2528 defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
25292529
25302530 const offset_reg = try self.elemOffset(index_ty, index, elem_abi_size);
2531 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);
2532 defer self.register_manager.unfreezeReg(offset_reg_lock);
2531 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2532 defer self.register_manager.unlockReg(offset_reg_lock);
25332533
25342534 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ptr_ty, ptr);
25352535 try self.genBinMathOpMir(.add, ptr_ty, dst_mcv, .{ .register = offset_reg });
......@@ -2559,24 +2559,24 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
25592559 const ptr_ty = self.air.typeOf(extra.lhs);
25602560 const ptr = try self.resolveInst(extra.lhs);
25612561 const ptr_lock: ?RegisterLock = switch (ptr) {
2562 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2562 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
25632563 else => null,
25642564 };
2565 defer if (ptr_lock) |reg| self.register_manager.unfreezeReg(reg);
2565 defer if (ptr_lock) |reg| self.register_manager.unlockReg(reg);
25662566
25672567 const elem_ty = ptr_ty.elemType2();
25682568 const elem_abi_size = elem_ty.abiSize(self.target.*);
25692569 const index_ty = self.air.typeOf(extra.rhs);
25702570 const index = try self.resolveInst(extra.rhs);
25712571 const index_lock: ?RegisterLock = switch (index) {
2572 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2572 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
25732573 else => null,
25742574 };
2575 defer if (index_lock) |reg| self.register_manager.unfreezeReg(reg);
2575 defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
25762576
25772577 const offset_reg = try self.elemOffset(index_ty, index, elem_abi_size);
2578 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);
2579 defer self.register_manager.unfreezeReg(offset_reg_lock);
2578 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2579 defer self.register_manager.unlockReg(offset_reg_lock);
25802580
25812581 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ptr_ty, ptr);
25822582 try self.genBinMathOpMir(.add, ptr_ty, dst_mcv, .{ .register = offset_reg });
......@@ -2598,17 +2598,17 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
25982598
25992599 const ptr = try self.resolveInst(bin_op.lhs);
26002600 const ptr_lock: ?RegisterLock = switch (ptr) {
2601 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2601 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
26022602 else => null,
26032603 };
2604 defer if (ptr_lock) |reg| self.register_manager.unfreezeReg(reg);
2604 defer if (ptr_lock) |reg| self.register_manager.unlockReg(reg);
26052605
26062606 const tag = try self.resolveInst(bin_op.rhs);
26072607 const tag_lock: ?RegisterLock = switch (tag) {
2608 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2608 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
26092609 else => null,
26102610 };
2611 defer if (tag_lock) |reg| self.register_manager.unfreezeReg(reg);
2611 defer if (tag_lock) |reg| self.register_manager.unlockReg(reg);
26122612
26132613 const adjusted_ptr: MCValue = if (layout.payload_size > 0 and layout.tag_align < layout.payload_align) blk: {
26142614 // TODO reusing the operand
......@@ -2639,10 +2639,10 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
26392639 // TODO reusing the operand
26402640 const operand = try self.resolveInst(ty_op.operand);
26412641 const operand_lock: ?RegisterLock = switch (operand) {
2642 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
2642 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
26432643 else => null,
26442644 };
2645 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);
2645 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
26462646
26472647 const tag_abi_size = tag_ty.abiSize(self.target.*);
26482648 const dst_mcv: MCValue = blk: {
......@@ -2789,8 +2789,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
27892789 try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off });
27902790 },
27912791 .register => |reg| {
2792 const reg_lock = self.register_manager.freezeReg(reg);
2793 defer if (reg_lock) |locked_reg| self.register_manager.unfreezeReg(locked_reg);
2792 const reg_lock = self.register_manager.lockReg(reg);
2793 defer if (reg_lock) |locked_reg| self.register_manager.unlockReg(locked_reg);
27942794
27952795 switch (dst_mcv) {
27962796 .dead => unreachable,
......@@ -2915,8 +2915,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
29152915 try self.genSetStack(value_ty, off, value, .{});
29162916 },
29172917 .register => |reg| {
2918 const reg_lock = self.register_manager.freezeReg(reg);
2919 defer if (reg_lock) |locked_reg| self.register_manager.unfreezeReg(locked_reg);
2918 const reg_lock = self.register_manager.lockReg(reg);
2919 defer if (reg_lock) |locked_reg| self.register_manager.unlockReg(locked_reg);
29202920
29212921 switch (value) {
29222922 .none => unreachable,
......@@ -3007,14 +3007,14 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
30073007 .memory,
30083008 => {
30093009 const value_lock: ?RegisterLock = switch (value) {
3010 .register => |reg| self.register_manager.freezeReg(reg),
3010 .register => |reg| self.register_manager.lockReg(reg),
30113011 else => null,
30123012 };
3013 defer if (value_lock) |reg| self.register_manager.unfreezeReg(reg);
3013 defer if (value_lock) |reg| self.register_manager.unlockReg(reg);
30143014
30153015 const addr_reg = try self.register_manager.allocReg(null);
3016 const addr_reg_lock = self.register_manager.freezeRegAssumeUnused(addr_reg);
3017 defer self.register_manager.unfreezeReg(addr_reg_lock);
3016 const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
3017 defer self.register_manager.unlockReg(addr_reg_lock);
30183018
30193019 try self.loadMemPtrIntoRegister(addr_reg, ptr_ty, ptr);
30203020
......@@ -3085,8 +3085,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
30853085 => {
30863086 if (abi_size <= 8) {
30873087 const tmp_reg = try self.register_manager.allocReg(null);
3088 const tmp_reg_lock = self.register_manager.freezeRegAssumeUnused(tmp_reg);
3089 defer self.register_manager.unfreezeReg(tmp_reg_lock);
3088 const tmp_reg_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
3089 defer self.register_manager.unlockReg(tmp_reg_lock);
30903090
30913091 try self.loadMemPtrIntoRegister(tmp_reg, value_ty, value);
30923092
......@@ -3176,8 +3176,8 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
31763176 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{
31773177 .immediate = struct_field_offset,
31783178 });
3179 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);
3180 defer self.register_manager.unfreezeReg(offset_reg_lock);
3179 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
3180 defer self.register_manager.unlockReg(offset_reg_lock);
31813181
31823182 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ptr_ty, mcv);
31833183 try self.genBinMathOpMir(.add, ptr_ty, dst_mcv, .{ .register = offset_reg });
......@@ -3188,14 +3188,14 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
31883188 break :result MCValue{ .ptr_stack_offset = ptr_stack_offset };
31893189 },
31903190 .register => |reg| {
3191 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);
3192 defer self.register_manager.unfreezeReg(reg_lock);
3191 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
3192 defer self.register_manager.unlockReg(reg_lock);
31933193
31943194 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{
31953195 .immediate = struct_field_offset,
31963196 });
3197 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);
3198 defer self.register_manager.unfreezeReg(offset_reg_lock);
3197 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
3198 defer self.register_manager.unlockReg(offset_reg_lock);
31993199
32003200 const can_reuse_operand = self.reuseOperand(inst, operand, 0, mcv);
32013201 const result_reg = blk: {
......@@ -3207,8 +3207,8 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
32073207 break :blk result_reg;
32083208 }
32093209 };
3210 const result_reg_lock = self.register_manager.freezeReg(result_reg);
3211 defer if (result_reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);
3210 const result_reg_lock = self.register_manager.lockReg(result_reg);
3211 defer if (result_reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
32123212
32133213 try self.genBinMathOpMir(.add, ptr_ty, .{ .register = result_reg }, .{ .register = offset_reg });
32143214 break :result MCValue{ .register = result_reg };
......@@ -3236,8 +3236,8 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
32363236 break :result MCValue{ .stack_offset = stack_offset };
32373237 },
32383238 .register => |reg| {
3239 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);
3240 defer self.register_manager.unfreezeReg(reg_lock);
3239 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
3240 defer self.register_manager.unlockReg(reg_lock);
32413241
32423242 const dst_mcv = blk: {
32433243 if (self.reuseOperand(inst, operand, 0, mcv)) {
......@@ -3250,10 +3250,10 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
32503250 }
32513251 };
32523252 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {
3253 .register => |reg| self.register_manager.freezeReg(reg),
3253 .register => |reg| self.register_manager.lockReg(reg),
32543254 else => null,
32553255 };
3256 defer if (dst_mcv_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);
3256 defer if (dst_mcv_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
32573257
32583258 // Shift by struct_field_offset.
32593259 const shift = @intCast(u8, struct_field_offset * @sizeOf(usize));
......@@ -3295,8 +3295,8 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
32953295 },
32963296 1 => {
32973297 // Get overflow bit.
3298 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);
3299 defer self.register_manager.unfreezeReg(reg_lock);
3298 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
3299 defer self.register_manager.unlockReg(reg_lock);
33003300
33013301 const dst_reg = try self.register_manager.allocReg(inst);
33023302 const flags: u2 = switch (mcv) {
......@@ -3339,17 +3339,17 @@ fn genBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs:
33393339
33403340 const lhs = try self.resolveInst(op_lhs);
33413341 const lhs_lock: ?RegisterLock = switch (lhs) {
3342 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
3342 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
33433343 else => null,
33443344 };
3345 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
3345 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
33463346
33473347 const rhs = try self.resolveInst(op_rhs);
33483348 const rhs_lock: ?RegisterLock = switch (rhs) {
3349 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
3349 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
33503350 else => null,
33513351 };
3352 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);
3352 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
33533353
33543354 var flipped: bool = false;
33553355 const dst_mcv = blk: {
......@@ -3363,10 +3363,10 @@ fn genBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs:
33633363 break :blk try self.copyToRegisterWithInstTracking(inst, dst_ty, lhs);
33643364 };
33653365 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {
3366 .register => |reg| self.register_manager.freezeReg(reg),
3366 .register => |reg| self.register_manager.lockReg(reg),
33673367 else => null,
33683368 };
3369 defer if (dst_mcv_lock) |reg| self.register_manager.unfreezeReg(reg);
3369 defer if (dst_mcv_lock) |reg| self.register_manager.unlockReg(reg);
33703370
33713371 const src_mcv = blk: {
33723372 const mcv = if (flipped) lhs else rhs;
......@@ -3374,10 +3374,10 @@ fn genBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs:
33743374 break :blk MCValue{ .register = try self.copyToTmpRegister(dst_ty, mcv) };
33753375 };
33763376 const src_mcv_lock: ?RegisterLock = switch (src_mcv) {
3377 .register => |reg| self.register_manager.freezeReg(reg),
3377 .register => |reg| self.register_manager.lockReg(reg),
33783378 else => null,
33793379 };
3380 defer if (src_mcv_lock) |reg| self.register_manager.unfreezeReg(reg);
3380 defer if (src_mcv_lock) |reg| self.register_manager.unlockReg(reg);
33813381
33823382 const tag = self.air.instructions.items(.tag)[inst];
33833383 switch (tag) {
......@@ -3408,8 +3408,8 @@ fn genBinMathOpMir(self: *Self, mir_tag: Mir.Inst.Tag, dst_ty: Type, dst_mcv: MC
34083408 .register_overflow_unsigned => unreachable,
34093409 .register_overflow_signed => unreachable,
34103410 .ptr_stack_offset => {
3411 const dst_reg_lock = self.register_manager.freezeReg(dst_reg);
3412 defer if (dst_reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);
3411 const dst_reg_lock = self.register_manager.lockReg(dst_reg);
3412 defer if (dst_reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
34133413
34143414 const reg = try self.copyToTmpRegister(dst_ty, src_mcv);
34153415 return self.genBinMathOpMir(mir_tag, dst_ty, dst_mcv, .{ .register = reg });
......@@ -3440,8 +3440,8 @@ fn genBinMathOpMir(self: *Self, mir_tag: Mir.Inst.Tag, dst_ty: Type, dst_mcv: MC
34403440 .compare_flags_unsigned,
34413441 => {
34423442 assert(abi_size <= 8);
3443 const dst_reg_lock = self.register_manager.freezeReg(dst_reg);
3444 defer if (dst_reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);
3443 const dst_reg_lock = self.register_manager.lockReg(dst_reg);
3444 defer if (dst_reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
34453445
34463446 const reg = try self.copyToTmpRegister(dst_ty, src_mcv);
34473447 return self.genBinMathOpMir(mir_tag, dst_ty, dst_mcv, .{ .register = reg });
......@@ -3791,13 +3791,13 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
37913791
37923792 try self.register_manager.getReg(.rdi, null);
37933793 try self.genSetReg(Type.usize, .rdi, .{ .ptr_stack_offset = stack_offset });
3794 const rdi_lock = self.register_manager.freezeRegAssumeUnused(.rdi);
3794 const rdi_lock = self.register_manager.lockRegAssumeUnused(.rdi);
37953795
37963796 info.return_value.stack_offset = stack_offset;
37973797
37983798 break :blk rdi_lock;
37993799 } else null;
3800 defer if (rdi_lock) |reg| self.register_manager.unfreezeReg(reg);
3800 defer if (rdi_lock) |reg| self.register_manager.unlockReg(reg);
38013801
38023802 for (args) |arg, arg_i| {
38033803 const mc_arg = info.args[arg_i];
......@@ -4017,8 +4017,8 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {
40174017 switch (self.ret_mcv) {
40184018 .stack_offset => {
40194019 const reg = try self.copyToTmpRegister(Type.usize, self.ret_mcv);
4020 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);
4021 defer self.register_manager.unfreezeReg(reg_lock);
4020 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
4021 defer self.register_manager.unlockReg(reg_lock);
40224022
40234023 try self.genSetStack(ret_ty, 0, operand, .{
40244024 .source_stack_base = .rbp,
......@@ -4051,8 +4051,8 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
40514051 switch (self.ret_mcv) {
40524052 .stack_offset => {
40534053 const reg = try self.copyToTmpRegister(Type.usize, self.ret_mcv);
4054 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);
4055 defer self.register_manager.unfreezeReg(reg_lock);
4054 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
4055 defer self.register_manager.unlockReg(reg_lock);
40564056
40574057 try self.genInlineMemcpy(.{ .stack_offset = 0 }, ptr, .{ .immediate = elem_ty.abiSize(self.target.*) }, .{
40584058 .source_stack_base = .rbp,
......@@ -4104,14 +4104,14 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
41044104 // TODO look into reusing the operand
41054105 const lhs = try self.resolveInst(bin_op.lhs);
41064106 const lhs_lock: ?RegisterLock = switch (lhs) {
4107 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
4107 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
41084108 else => null,
41094109 };
4110 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);
4110 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
41114111
41124112 const dst_reg = try self.copyToTmpRegister(ty, lhs);
4113 const dst_reg_lock = self.register_manager.freezeRegAssumeUnused(dst_reg);
4114 defer self.register_manager.unfreezeReg(dst_reg_lock);
4113 const dst_reg_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
4114 defer self.register_manager.unlockReg(dst_reg_lock);
41154115
41164116 const dst_mcv = MCValue{ .register = dst_reg };
41174117
......@@ -4576,10 +4576,10 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
45764576 const operand_ptr = try self.resolveInst(un_op);
45774577
45784578 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {
4579 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
4579 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
45804580 else => null,
45814581 };
4582 defer if (operand_ptr_lock) |reg| self.register_manager.unfreezeReg(reg);
4582 defer if (operand_ptr_lock) |reg| self.register_manager.unlockReg(reg);
45834583
45844584 const operand: MCValue = blk: {
45854585 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
......@@ -4612,10 +4612,10 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
46124612 const operand_ptr = try self.resolveInst(un_op);
46134613
46144614 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {
4615 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
4615 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
46164616 else => null,
46174617 };
4618 defer if (operand_ptr_lock) |reg| self.register_manager.unfreezeReg(reg);
4618 defer if (operand_ptr_lock) |reg| self.register_manager.unlockReg(reg);
46194619
46204620 const operand: MCValue = blk: {
46214621 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
......@@ -4648,10 +4648,10 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
46484648 const operand_ptr = try self.resolveInst(un_op);
46494649
46504650 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {
4651 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
4651 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
46524652 else => null,
46534653 };
4654 defer if (operand_ptr_lock) |reg| self.register_manager.unfreezeReg(reg);
4654 defer if (operand_ptr_lock) |reg| self.register_manager.unlockReg(reg);
46554655
46564656 const operand: MCValue = blk: {
46574657 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
......@@ -4684,10 +4684,10 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
46844684 const operand_ptr = try self.resolveInst(un_op);
46854685
46864686 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {
4687 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
4687 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
46884688 else => null,
46894689 };
4690 defer if (operand_ptr_lock) |reg| self.register_manager.unfreezeReg(reg);
4690 defer if (operand_ptr_lock) |reg| self.register_manager.unlockReg(reg);
46914691
46924692 const operand: MCValue = blk: {
46934693 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
......@@ -4756,8 +4756,8 @@ fn genCondSwitchMir(self: *Self, ty: Type, condition: MCValue, case: MCValue) !u
47564756 .register => |cond_reg| {
47574757 try self.spillCompareFlagsIfOccupied();
47584758
4759 const cond_reg_lock = self.register_manager.freezeReg(cond_reg);
4760 defer if (cond_reg_lock) |reg| self.register_manager.unfreezeReg(reg);
4759 const cond_reg_lock = self.register_manager.lockReg(cond_reg);
4760 defer if (cond_reg_lock) |reg| self.register_manager.unlockReg(reg);
47614761
47624762 switch (case) {
47634763 .none => unreachable,
......@@ -4816,8 +4816,8 @@ fn genCondSwitchMir(self: *Self, ty: Type, condition: MCValue, case: MCValue) !u
48164816
48174817 if (abi_size <= 8) {
48184818 const reg = try self.copyToTmpRegister(ty, condition);
4819 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);
4820 defer self.register_manager.unfreezeReg(reg_lock);
4819 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
4820 defer self.register_manager.unlockReg(reg_lock);
48214821 return self.genCondSwitchMir(ty, .{ .register = reg }, case);
48224822 }
48234823
......@@ -5304,8 +5304,8 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: i32, mcv: MCValue, opts: Inl
53045304 .register_overflow_unsigned,
53055305 .register_overflow_signed,
53065306 => |reg| {
5307 const reg_lock = self.register_manager.freezeReg(reg);
5308 defer if (reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);
5307 const reg_lock = self.register_manager.lockReg(reg);
5308 defer if (reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
53095309
53105310 const wrapped_ty = ty.structFieldType(0);
53115311 try self.genSetStack(wrapped_ty, stack_offset, .{ .register = reg }, .{});
......@@ -5406,8 +5406,8 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: i32, mcv: MCValue, opts: Inl
54065406
54075407 const base_reg = opts.dest_stack_base orelse .rbp;
54085408 if (!math.isPowerOfTwo(abi_size)) {
5409 const reg_lock = self.register_manager.freezeReg(reg);
5410 defer if (reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);
5409 const reg_lock = self.register_manager.lockReg(reg);
5410 defer if (reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
54115411
54125412 const tmp_reg = try self.copyToTmpRegister(ty, mcv);
54135413
......@@ -5500,22 +5500,22 @@ fn genInlineMemcpy(
55005500 try self.register_manager.getReg(.rcx, null);
55015501
55025502 var reg_locks: [2]RegisterLock = undefined;
5503 self.register_manager.freezeRegsAssumeUnused(2, .{ .rax, .rcx }, &reg_locks);
5503 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rcx }, &reg_locks);
55045504 defer for (reg_locks) |reg| {
5505 self.register_manager.unfreezeReg(reg);
5505 self.register_manager.unlockReg(reg);
55065506 };
55075507
55085508 const ssbase_lock: ?RegisterLock = if (opts.source_stack_base) |reg|
5509 self.register_manager.freezeReg(reg)
5509 self.register_manager.lockReg(reg)
55105510 else
55115511 null;
5512 defer if (ssbase_lock) |reg| self.register_manager.unfreezeReg(reg);
5512 defer if (ssbase_lock) |reg| self.register_manager.unlockReg(reg);
55135513
55145514 const dsbase_lock: ?RegisterLock = if (opts.dest_stack_base) |reg|
5515 self.register_manager.freezeReg(reg)
5515 self.register_manager.lockReg(reg)
55165516 else
55175517 null;
5518 defer if (dsbase_lock) |reg| self.register_manager.unfreezeReg(reg);
5518 defer if (dsbase_lock) |reg| self.register_manager.unlockReg(reg);
55195519
55205520 const dst_addr_reg = try self.register_manager.allocReg(null);
55215521 switch (dst_ptr) {
......@@ -5549,8 +5549,8 @@ fn genInlineMemcpy(
55495549 return self.fail("TODO implement memcpy for setting stack when dest is {}", .{dst_ptr});
55505550 },
55515551 }
5552 const dst_addr_reg_lock = self.register_manager.freezeRegAssumeUnused(dst_addr_reg);
5553 defer self.register_manager.unfreezeReg(dst_addr_reg_lock);
5552 const dst_addr_reg_lock = self.register_manager.lockRegAssumeUnused(dst_addr_reg);
5553 defer self.register_manager.unlockReg(dst_addr_reg_lock);
55545554
55555555 const src_addr_reg = try self.register_manager.allocReg(null);
55565556 switch (src_ptr) {
......@@ -5584,8 +5584,8 @@ fn genInlineMemcpy(
55845584 return self.fail("TODO implement memcpy for setting stack when src is {}", .{src_ptr});
55855585 },
55865586 }
5587 const src_addr_reg_lock = self.register_manager.freezeRegAssumeUnused(src_addr_reg);
5588 defer self.register_manager.unfreezeReg(src_addr_reg_lock);
5587 const src_addr_reg_lock = self.register_manager.lockRegAssumeUnused(src_addr_reg);
5588 defer self.register_manager.unlockReg(src_addr_reg_lock);
55895589
55905590 const regs = try self.register_manager.allocRegs(2, .{ null, null });
55915591 const count_reg = regs[0].to64();
......@@ -5695,8 +5695,8 @@ fn genInlineMemset(
56955695 opts: InlineMemcpyOpts,
56965696) InnerError!void {
56975697 try self.register_manager.getReg(.rax, null);
5698 const rax_lock = self.register_manager.freezeRegAssumeUnused(.rax);
5699 defer self.register_manager.unfreezeReg(rax_lock);
5698 const rax_lock = self.register_manager.lockRegAssumeUnused(.rax);
5699 defer self.register_manager.unlockReg(rax_lock);
57005700
57015701 const addr_reg = try self.register_manager.allocReg(null);
57025702 switch (dst_ptr) {
......@@ -5730,8 +5730,8 @@ fn genInlineMemset(
57305730 return self.fail("TODO implement memcpy for setting stack when dest is {}", .{dst_ptr});
57315731 },
57325732 }
5733 const addr_reg_lock = self.register_manager.freezeRegAssumeUnused(addr_reg);
5734 defer self.register_manager.unfreezeReg(addr_reg_lock);
5733 const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
5734 defer self.register_manager.unlockReg(addr_reg_lock);
57355735
57365736 try self.genSetReg(Type.usize, .rax, len);
57375737 try self.genBinMathOpMir(.sub, Type.usize, .{ .register = .rax }, .{ .immediate = 1 });
......@@ -6171,24 +6171,24 @@ fn airMemset(self: *Self, inst: Air.Inst.Index) !void {
61716171
61726172 const dst_ptr = try self.resolveInst(pl_op.operand);
61736173 const dst_ptr_lock: ?RegisterLock = switch (dst_ptr) {
6174 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
6174 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
61756175 else => null,
61766176 };
6177 defer if (dst_ptr_lock) |reg| self.register_manager.unfreezeReg(reg);
6177 defer if (dst_ptr_lock) |reg| self.register_manager.unlockReg(reg);
61786178
61796179 const src_val = try self.resolveInst(extra.lhs);
61806180 const src_val_lock: ?RegisterLock = switch (src_val) {
6181 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
6181 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
61826182 else => null,
61836183 };
6184 defer if (src_val_lock) |reg| self.register_manager.unfreezeReg(reg);
6184 defer if (src_val_lock) |reg| self.register_manager.unlockReg(reg);
61856185
61866186 const len = try self.resolveInst(extra.rhs);
61876187 const len_lock: ?RegisterLock = switch (len) {
6188 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
6188 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
61896189 else => null,
61906190 };
6191 defer if (len_lock) |reg| self.register_manager.unfreezeReg(reg);
6191 defer if (len_lock) |reg| self.register_manager.unlockReg(reg);
61926192
61936193 try self.genInlineMemset(dst_ptr, src_val, len, .{});
61946194
......@@ -6201,25 +6201,25 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
62016201
62026202 const dst_ptr = try self.resolveInst(pl_op.operand);
62036203 const dst_ptr_lock: ?RegisterLock = switch (dst_ptr) {
6204 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
6204 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
62056205 else => null,
62066206 };
6207 defer if (dst_ptr_lock) |reg| self.register_manager.unfreezeReg(reg);
6207 defer if (dst_ptr_lock) |reg| self.register_manager.unlockReg(reg);
62086208
62096209 const src_ty = self.air.typeOf(extra.lhs);
62106210 const src_ptr = try self.resolveInst(extra.lhs);
62116211 const src_ptr_lock: ?RegisterLock = switch (src_ptr) {
6212 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
6212 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
62136213 else => null,
62146214 };
6215 defer if (src_ptr_lock) |reg| self.register_manager.unfreezeReg(reg);
6215 defer if (src_ptr_lock) |reg| self.register_manager.unlockReg(reg);
62166216
62176217 const len = try self.resolveInst(extra.rhs);
62186218 const len_lock: ?RegisterLock = switch (len) {
6219 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),
6219 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
62206220 else => null,
62216221 };
6222 defer if (len_lock) |reg| self.register_manager.unfreezeReg(reg);
6222 defer if (len_lock) |reg| self.register_manager.unlockReg(reg);
62236223
62246224 // TODO Is this the only condition for pointer dereference for memcpy?
62256225 const src: MCValue = blk: {
......@@ -6242,10 +6242,10 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
62426242 }
62436243 };
62446244 const src_lock: ?RegisterLock = switch (src) {
6245 .register => |reg| self.register_manager.freezeReg(reg),
6245 .register => |reg| self.register_manager.lockReg(reg),
62466246 else => null,
62476247 };
6248 defer if (src_lock) |reg| self.register_manager.unfreezeReg(reg);
6248 defer if (src_lock) |reg| self.register_manager.unlockReg(reg);
62496249
62506250 try self.genInlineMemcpy(dst_ptr, src, len, .{});
62516251
src/register_manager.zig+53-54
......@@ -45,9 +45,8 @@ pub fn RegisterManager(
4545 /// Tracks all registers allocated in the course of this
4646 /// function
4747 allocated_registers: FreeRegInt = 0,
48 /// Tracks registers which are temporarily blocked from being
49 /// allocated
50 frozen_registers: FreeRegInt = 0,
48 /// Tracks registers which are locked from being allocated
49 locked_registers: FreeRegInt = 0,
5150
5251 const Self = @This();
5352
......@@ -108,12 +107,12 @@ pub fn RegisterManager(
108107 return self.allocated_registers & mask != 0;
109108 }
110109
111 /// Returns whether this register is frozen
110 /// Returns whether this register is locked
112111 ///
113112 /// Returns false when this register is not tracked
114 pub fn isRegFrozen(self: Self, reg: Register) bool {
113 pub fn isRegLocked(self: Self, reg: Register) bool {
115114 const mask = getRegisterMask(reg) orelse return false;
116 return self.frozen_registers & mask != 0;
115 return self.locked_registers & mask != 0;
117116 }
118117
119118 pub const RegisterLock = struct {
......@@ -121,56 +120,56 @@ pub fn RegisterManager(
121120 };
122121
123122 /// Prevents the register from being allocated until they are
124 /// unfrozen again.
123 /// unlocked again.
125124 /// Returns `RegisterLock` if the register was not already
126 /// frozen, or `null` otherwise.
127 /// Only the owner of the `RegisterLock` can unfreeze the
125 /// locked, or `null` otherwise.
126 /// Only the owner of the `RegisterLock` can unlock the
128127 /// register later.
129 pub fn freezeReg(self: *Self, reg: Register) ?RegisterLock {
130 log.debug("freezing {}", .{reg});
131 if (self.isRegFrozen(reg)) {
128 pub fn lockReg(self: *Self, reg: Register) ?RegisterLock {
129 log.debug("locking {}", .{reg});
130 if (self.isRegLocked(reg)) {
132131 log.debug(" register already locked", .{});
133132 return null;
134133 }
135134 const mask = getRegisterMask(reg) orelse return null;
136 self.frozen_registers |= mask;
135 self.locked_registers |= mask;
137136 return RegisterLock{ .register = reg };
138137 }
139138
140 /// Like `freezeReg` but asserts the register was unused always
139 /// Like `lockReg` but asserts the register was unused always
141140 /// returning a valid lock.
142 pub fn freezeRegAssumeUnused(self: *Self, reg: Register) RegisterLock {
143 log.debug("freezing asserting free {}", .{reg});
144 assert(!self.isRegFrozen(reg));
141 pub fn lockRegAssumeUnused(self: *Self, reg: Register) RegisterLock {
142 log.debug("locking asserting free {}", .{reg});
143 assert(!self.isRegLocked(reg));
145144 const mask = getRegisterMask(reg) orelse unreachable;
146 self.frozen_registers |= mask;
145 self.locked_registers |= mask;
147146 return RegisterLock{ .register = reg };
148147 }
149148
150 /// Like `freezeRegAssumeUnused` but locks multiple registers.
151 pub fn freezeRegsAssumeUnused(
149 /// Like `lockRegAssumeUnused` but locks multiple registers.
150 pub fn lockRegsAssumeUnused(
152151 self: *Self,
153152 comptime count: comptime_int,
154153 regs: [count]Register,
155154 buf: *[count]RegisterLock,
156155 ) void {
157156 for (&regs) |reg, i| {
158 buf[i] = self.freezeRegAssumeUnused(reg);
157 buf[i] = self.lockRegAssumeUnused(reg);
159158 }
160159 }
161160
162 /// Unfreezes the register allowing its re-allocation and re-use.
163 /// Requires `RegisterLock` to unfreeze a register.
164 /// Call `freezeReg` to obtain the lock first.
165 pub fn unfreezeReg(self: *Self, lock: RegisterLock) void {
166 log.debug("unfreezing {}", .{lock.register});
161 /// Unlocks the register allowing its re-allocation and re-use.
162 /// Requires `RegisterLock` to unlock a register.
163 /// Call `lockReg` to obtain the lock first.
164 pub fn unlockReg(self: *Self, lock: RegisterLock) void {
165 log.debug("unlocking {}", .{lock.register});
167166 const mask = getRegisterMask(lock.register) orelse return;
168 self.frozen_registers &= ~mask;
167 self.locked_registers &= ~mask;
169168 }
170169
171 /// Returns true when at least one register is frozen
172 pub fn frozenRegsExist(self: Self) bool {
173 return self.frozen_registers != 0;
170 /// Returns true when at least one register is locked
171 pub fn lockedRegsExist(self: Self) bool {
172 return self.locked_registers != 0;
174173 }
175174
176175 /// Allocates a specified number of registers, optionally
......@@ -183,15 +182,15 @@ pub fn RegisterManager(
183182 ) ?[count]Register {
184183 comptime assert(count > 0 and count <= tracked_registers.len);
185184
186 const free_and_not_frozen_registers = self.free_registers & ~self.frozen_registers;
187 const free_and_not_frozen_registers_count = @popCount(FreeRegInt, free_and_not_frozen_registers);
188 if (free_and_not_frozen_registers_count < count) return null;
185 const free_and_not_locked_registers = self.free_registers & ~self.locked_registers;
186 const free_and_not_locked_registers_count = @popCount(FreeRegInt, free_and_not_locked_registers);
187 if (free_and_not_locked_registers_count < count) return null;
189188
190189 var regs: [count]Register = undefined;
191190 var i: usize = 0;
192191 for (tracked_registers) |reg| {
193192 if (i >= count) break;
194 if (self.isRegFrozen(reg)) continue;
193 if (self.isRegLocked(reg)) continue;
195194 if (!self.isRegFree(reg)) continue;
196195
197196 regs[i] = reg;
......@@ -229,8 +228,8 @@ pub fn RegisterManager(
229228 insts: [count]?Air.Inst.Index,
230229 ) AllocateRegistersError![count]Register {
231230 comptime assert(count > 0 and count <= tracked_registers.len);
232 const frozen_registers_count = @popCount(FreeRegInt, self.frozen_registers);
233 if (count > tracked_registers.len - frozen_registers_count) return error.OutOfRegisters;
231 const locked_registers_count = @popCount(FreeRegInt, self.locked_registers);
232 if (count > tracked_registers.len - locked_registers_count) return error.OutOfRegisters;
234233
235234 const result = self.tryAllocRegs(count, insts) orelse blk: {
236235 // We'll take over the first count registers. Spill
......@@ -240,7 +239,7 @@ pub fn RegisterManager(
240239 var i: usize = 0;
241240 for (tracked_registers) |reg| {
242241 if (i >= count) break;
243 if (self.isRegFrozen(reg)) continue;
242 if (self.isRegLocked(reg)) continue;
244243
245244 regs[i] = reg;
246245 self.markRegAllocated(reg);
......@@ -451,15 +450,15 @@ test "allocReg: spilling" {
451450 try expectEqual(@as(?MockRegister1, .r3), try function.register_manager.allocReg(mock_instruction));
452451 try expectEqualSlices(MockRegister1, &[_]MockRegister1{.r2}, function.spilled.items);
453452
454 // Frozen registers
453 // Locked registers
455454 function.register_manager.freeReg(.r3);
456455 {
457 const lock = function.register_manager.freezeReg(.r2);
458 defer if (lock) |reg| function.register_manager.unfreezeReg(reg);
456 const lock = function.register_manager.lockReg(.r2);
457 defer if (lock) |reg| function.register_manager.unlockReg(reg);
459458
460459 try expectEqual(@as(?MockRegister1, .r3), try function.register_manager.allocReg(mock_instruction));
461460 }
462 try expect(!function.register_manager.frozenRegsExist());
461 try expect(!function.register_manager.lockedRegsExist());
463462}
464463
465464test "tryAllocRegs" {
......@@ -477,17 +476,17 @@ test "tryAllocRegs" {
477476 try expect(function.register_manager.isRegAllocated(.r2));
478477 try expect(!function.register_manager.isRegAllocated(.r3));
479478
480 // Frozen registers
479 // Locked registers
481480 function.register_manager.freeReg(.r0);
482481 function.register_manager.freeReg(.r2);
483482 function.register_manager.freeReg(.r3);
484483 {
485 const lock = function.register_manager.freezeReg(.r1);
486 defer if (lock) |reg| function.register_manager.unfreezeReg(reg);
484 const lock = function.register_manager.lockReg(.r1);
485 defer if (lock) |reg| function.register_manager.unlockReg(reg);
487486
488487 try expectEqual([_]MockRegister2{ .r0, .r2, .r3 }, function.register_manager.tryAllocRegs(3, .{ null, null, null }).?);
489488 }
490 try expect(!function.register_manager.frozenRegsExist());
489 try expect(!function.register_manager.lockedRegsExist());
491490
492491 try expect(function.register_manager.isRegAllocated(.r0));
493492 try expect(function.register_manager.isRegAllocated(.r1));
......@@ -510,19 +509,19 @@ test "allocRegs: normal usage" {
510509
511510 // The result register is known and fixed at this point, we
512511 // don't want to accidentally allocate lhs or rhs to the
513 // result register, this is why we freeze it.
512 // result register, this is why we lock it.
514513 //
515 // Using defer unfreeze right after freeze is a good idea in
516 // most cases as you probably are using the frozen registers
514 // Using defer unlock right after lock is a good idea in
515 // most cases as you probably are using the locked registers
517516 // in the remainder of this scope and don't need to use it
518517 // after the end of this scope. However, in some situations,
519 // it may make sense to manually unfreeze registers before the
518 // it may make sense to manually unlock registers before the
520519 // end of the scope when you are certain that they don't
521520 // contain any valuable data anymore and can be reused. For an
522521 // example of that, see `selectively reducing register
523522 // pressure`.
524 const lock = function.register_manager.freezeReg(result_reg);
525 defer if (lock) |reg| function.register_manager.unfreezeReg(reg);
523 const lock = function.register_manager.lockReg(result_reg);
524 defer if (lock) |reg| function.register_manager.unlockReg(reg);
526525
527526 const regs = try function.register_manager.allocRegs(2, .{ null, null });
528527 try function.genAdd(result_reg, regs[0], regs[1]);
......@@ -542,14 +541,14 @@ test "allocRegs: selectively reducing register pressure" {
542541 {
543542 const result_reg: MockRegister2 = .r1;
544543
545 const lock = function.register_manager.freezeReg(result_reg);
544 const lock = function.register_manager.lockReg(result_reg);
546545
547 // Here, we don't defer unfreeze because we manually unfreeze
546 // Here, we don't defer unlock because we manually unlock
548547 // after genAdd
549548 const regs = try function.register_manager.allocRegs(2, .{ null, null });
550549
551550 try function.genAdd(result_reg, regs[0], regs[1]);
552 function.register_manager.unfreezeReg(lock.?);
551 function.register_manager.unlockReg(lock.?);
553552
554553 const extra_summand_reg = try function.register_manager.allocReg(null);
555554 try function.genAdd(result_reg, result_reg, extra_summand_reg);