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 {...@@ -728,7 +728,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
728 // zig fmt: on728 // zig fmt: on
729 }729 }
730730
731 assert(!self.register_manager.frozenRegsExist());731 assert(!self.register_manager.lockedRegsExist());
732732
733 if (std.debug.runtime_safety) {733 if (std.debug.runtime_safety) {
734 if (self.air_bookkeeping < old_air_bookkeeping + 1) {734 if (self.air_bookkeeping < old_air_bookkeeping + 1) {
...@@ -1058,8 +1058,8 @@ fn trunc(...@@ -1058,8 +1058,8 @@ fn trunc(
1058 }1058 }
1059 },1059 },
1060 };1060 };
1061 const lock = self.register_manager.freezeReg(operand_reg);1061 const lock = self.register_manager.lockReg(operand_reg);
1062 defer if (lock) |reg| self.register_manager.unfreezeReg(reg);1062 defer if (lock) |reg| self.register_manager.unlockReg(reg);
10631063
1064 const dest_reg = if (maybe_inst) |inst| blk: {1064 const dest_reg = if (maybe_inst) |inst| blk: {
1065 const ty_op = self.air.instructions.items(.data)[inst].ty_op;1065 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
...@@ -1145,8 +1145,8 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {...@@ -1145,8 +1145,8 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
1145 .register => |r| r,1145 .register => |r| r,
1146 else => try self.copyToTmpRegister(operand_ty, operand),1146 else => try self.copyToTmpRegister(operand_ty, operand),
1147 };1147 };
1148 const reg_lock = self.register_manager.freezeRegAssumeUnused(op_reg);1148 const reg_lock = self.register_manager.lockRegAssumeUnused(op_reg);
1149 defer self.register_manager.unfreezeReg(reg_lock);1149 defer self.register_manager.unlockReg(reg_lock);
11501150
1151 const dest_reg = blk: {1151 const dest_reg = blk: {
1152 if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {1152 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 {...@@ -1178,8 +1178,8 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
1178 .register => |r| r,1178 .register => |r| r,
1179 else => try self.copyToTmpRegister(operand_ty, operand),1179 else => try self.copyToTmpRegister(operand_ty, operand),
1180 };1180 };
1181 const reg_lock = self.register_manager.freezeRegAssumeUnused(op_reg);1181 const reg_lock = self.register_manager.lockRegAssumeUnused(op_reg);
1182 defer self.register_manager.unfreezeReg(reg_lock);1182 defer self.register_manager.unlockReg(reg_lock);
11831183
1184 const dest_reg = blk: {1184 const dest_reg = blk: {
1185 if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {1185 if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {
...@@ -1268,16 +1268,16 @@ fn binOpRegister(...@@ -1268,16 +1268,16 @@ fn binOpRegister(
1268 const rhs_is_register = rhs == .register;1268 const rhs_is_register = rhs == .register;
12691269
1270 const lhs_lock: ?RegisterLock = if (lhs_is_register)1270 const lhs_lock: ?RegisterLock = if (lhs_is_register)
1271 self.register_manager.freezeReg(lhs.register)1271 self.register_manager.lockReg(lhs.register)
1272 else1272 else
1273 null;1273 null;
1274 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);1274 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
12751275
1276 const rhs_lock: ?RegisterLock = if (rhs_is_register)1276 const rhs_lock: ?RegisterLock = if (rhs_is_register)
1277 self.register_manager.freezeReg(rhs.register)1277 self.register_manager.lockReg(rhs.register)
1278 else1278 else
1279 null;1279 null;
1280 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);1280 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
12811281
1282 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];1282 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
12831283
...@@ -1294,8 +1294,8 @@ fn binOpRegister(...@@ -1294,8 +1294,8 @@ fn binOpRegister(
12941294
1295 break :blk reg;1295 break :blk reg;
1296 };1296 };
1297 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);1297 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
1298 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);1298 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
12991299
1300 const rhs_reg = if (rhs_is_register) rhs.register else blk: {1300 const rhs_reg = if (rhs_is_register) rhs.register else blk: {
1301 const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {1301 const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {
...@@ -1310,8 +1310,8 @@ fn binOpRegister(...@@ -1310,8 +1310,8 @@ fn binOpRegister(
13101310
1311 break :blk reg;1311 break :blk reg;
1312 };1312 };
1313 const new_rhs_lock = self.register_manager.freezeReg(rhs_reg);1313 const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
1314 defer if (new_rhs_lock) |reg| self.register_manager.unfreezeReg(reg);1314 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
13151315
1316 const dest_reg = switch (mir_tag) {1316 const dest_reg = switch (mir_tag) {
1317 .cmp_shifted_register => undefined, // cmp has no destination register1317 .cmp_shifted_register => undefined, // cmp has no destination register
...@@ -1414,10 +1414,10 @@ fn binOpImmediate(...@@ -1414,10 +1414,10 @@ fn binOpImmediate(
1414 const lhs_is_register = lhs == .register;1414 const lhs_is_register = lhs == .register;
14151415
1416 const lhs_lock: ?RegisterLock = if (lhs_is_register)1416 const lhs_lock: ?RegisterLock = if (lhs_is_register)
1417 self.register_manager.freezeReg(lhs.register)1417 self.register_manager.lockReg(lhs.register)
1418 else1418 else
1419 null;1419 null;
1420 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);1420 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
14211421
1422 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];1422 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
14231423
...@@ -1436,8 +1436,8 @@ fn binOpImmediate(...@@ -1436,8 +1436,8 @@ fn binOpImmediate(
14361436
1437 break :blk reg;1437 break :blk reg;
1438 };1438 };
1439 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);1439 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
1440 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);1440 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
14411441
1442 const dest_reg = switch (mir_tag) {1442 const dest_reg = switch (mir_tag) {
1443 .cmp_immediate => undefined, // cmp has no destination register1443 .cmp_immediate => undefined, // cmp has no destination register
...@@ -1841,13 +1841,13 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -1841,13 +1841,13 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
1841 };1841 };
1842 const dest = try self.binOp(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);1842 const dest = try self.binOp(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);
1843 const dest_reg = dest.register;1843 const dest_reg = dest.register;
1844 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);1844 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
1845 defer self.register_manager.unfreezeReg(dest_reg_lock);1845 defer self.register_manager.unlockReg(dest_reg_lock);
18461846
1847 const raw_truncated_reg = try self.register_manager.allocReg(null);1847 const raw_truncated_reg = try self.register_manager.allocReg(null);
1848 const truncated_reg = registerAlias(raw_truncated_reg, lhs_ty.abiSize(self.target.*));1848 const truncated_reg = registerAlias(raw_truncated_reg, lhs_ty.abiSize(self.target.*));
1849 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);1849 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1850 defer self.register_manager.unfreezeReg(truncated_reg_lock);1850 defer self.register_manager.unlockReg(truncated_reg_lock);
18511851
1852 // sbfx/ubfx truncated, dest, #0, #bits1852 // sbfx/ubfx truncated, dest, #0, #bits
1853 try self.truncRegister(dest_reg, truncated_reg, int_info.signedness, int_info.bits);1853 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 {...@@ -1948,12 +1948,12 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
19481948
1949 const dest = try self.binOpRegister(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);1949 const dest = try self.binOpRegister(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);
1950 const dest_reg = dest.register;1950 const dest_reg = dest.register;
1951 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);1951 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
1952 defer self.register_manager.unfreezeReg(dest_reg_lock);1952 defer self.register_manager.unlockReg(dest_reg_lock);
19531953
1954 const truncated_reg = try self.register_manager.allocReg(null);1954 const truncated_reg = try self.register_manager.allocReg(null);
1955 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);1955 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1956 defer self.register_manager.unfreezeReg(truncated_reg_lock);1956 defer self.register_manager.unlockReg(truncated_reg_lock);
19571957
1958 try self.truncRegister(1958 try self.truncRegister(
1959 dest_reg.to32(),1959 dest_reg.to32(),
...@@ -2004,32 +2004,32 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -2004,32 +2004,32 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
2004 const rhs_is_register = rhs == .register;2004 const rhs_is_register = rhs == .register;
20052005
2006 const lhs_lock: ?RegisterLock = if (lhs_is_register)2006 const lhs_lock: ?RegisterLock = if (lhs_is_register)
2007 self.register_manager.freezeRegAssumeUnused(lhs.register)2007 self.register_manager.lockRegAssumeUnused(lhs.register)
2008 else2008 else
2009 null;2009 null;
2010 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);2010 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
20112011
2012 const rhs_lock: ?RegisterLock = if (rhs_is_register)2012 const rhs_lock: ?RegisterLock = if (rhs_is_register)
2013 self.register_manager.freezeRegAssumeUnused(rhs.register)2013 self.register_manager.lockRegAssumeUnused(rhs.register)
2014 else2014 else
2015 null;2015 null;
2016 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);2016 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
20172017
2018 const lhs_reg = if (lhs_is_register) lhs.register else blk: {2018 const lhs_reg = if (lhs_is_register) lhs.register else blk: {
2019 const raw_reg = try self.register_manager.allocReg(null);2019 const raw_reg = try self.register_manager.allocReg(null);
2020 const reg = registerAlias(raw_reg, lhs_ty.abiSize(self.target.*));2020 const reg = registerAlias(raw_reg, lhs_ty.abiSize(self.target.*));
2021 break :blk reg;2021 break :blk reg;
2022 };2022 };
2023 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);2023 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
2024 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);2024 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
20252025
2026 const rhs_reg = if (rhs_is_register) rhs.register else blk: {2026 const rhs_reg = if (rhs_is_register) rhs.register else blk: {
2027 const raw_reg = try self.register_manager.allocReg(null);2027 const raw_reg = try self.register_manager.allocReg(null);
2028 const reg = registerAlias(raw_reg, rhs_ty.abiAlignment(self.target.*));2028 const reg = registerAlias(raw_reg, rhs_ty.abiAlignment(self.target.*));
2029 break :blk reg;2029 break :blk reg;
2030 };2030 };
2031 const new_rhs_lock = self.register_manager.freezeReg(rhs_reg);2031 const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
2032 defer if (new_rhs_lock) |reg| self.register_manager.unfreezeReg(reg);2032 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
20332033
2034 if (!lhs_is_register) try self.genSetReg(lhs_ty, lhs_reg, lhs);2034 if (!lhs_is_register) try self.genSetReg(lhs_ty, lhs_reg, lhs);
2035 if (!rhs_is_register) try self.genSetReg(rhs_ty, rhs_reg, rhs);2035 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 {...@@ -2039,8 +2039,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
2039 const reg = registerAlias(raw_reg, lhs_ty.abiSize(self.target.*));2039 const reg = registerAlias(raw_reg, lhs_ty.abiSize(self.target.*));
2040 break :blk reg;2040 break :blk reg;
2041 };2041 };
2042 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);2042 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
2043 defer self.register_manager.unfreezeReg(dest_reg_lock);2043 defer self.register_manager.unlockReg(dest_reg_lock);
20442044
2045 switch (int_info.signedness) {2045 switch (int_info.signedness) {
2046 .signed => {2046 .signed => {
...@@ -2055,8 +2055,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -2055,8 +2055,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
2055 });2055 });
20562056
2057 const dest_high_reg = try self.register_manager.allocReg(null);2057 const dest_high_reg = try self.register_manager.allocReg(null);
2058 const dest_high_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_high_reg);2058 const dest_high_reg_lock = self.register_manager.lockRegAssumeUnused(dest_high_reg);
2059 defer self.register_manager.unfreezeReg(dest_high_reg_lock);2059 defer self.register_manager.unlockReg(dest_high_reg_lock);
20602060
2061 // smulh dest_high, lhs, rhs2061 // smulh dest_high, lhs, rhs
2062 _ = try self.addInst(.{2062 _ = try self.addInst(.{
...@@ -2105,8 +2105,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -2105,8 +2105,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
2105 },2105 },
2106 .unsigned => {2106 .unsigned => {
2107 const dest_high_reg = try self.register_manager.allocReg(null);2107 const dest_high_reg = try self.register_manager.allocReg(null);
2108 const dest_high_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_high_reg);2108 const dest_high_reg_lock = self.register_manager.lockRegAssumeUnused(dest_high_reg);
2109 defer self.register_manager.unfreezeReg(dest_high_reg_lock);2109 defer self.register_manager.unlockReg(dest_high_reg_lock);
21102110
2111 // umulh dest_high, lhs, rhs2111 // umulh dest_high, lhs, rhs
2112 _ = try self.addInst(.{2112 _ = try self.addInst(.{
...@@ -2161,8 +2161,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -2161,8 +2161,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
2161 }2161 }
21622162
2163 const truncated_reg = try self.register_manager.allocReg(null);2163 const truncated_reg = try self.register_manager.allocReg(null);
2164 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);2164 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
2165 defer self.register_manager.unfreezeReg(truncated_reg_lock);2165 defer self.register_manager.unlockReg(truncated_reg_lock);
21662166
2167 try self.truncRegister(dest_reg, truncated_reg, int_info.signedness, int_info.bits);2167 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 {...@@ -2203,10 +2203,10 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
2203 const stack_offset = try self.allocMem(inst, tuple_size, tuple_align);2203 const stack_offset = try self.allocMem(inst, tuple_size, tuple_align);
22042204
2205 const lhs_lock: ?RegisterLock = if (lhs == .register)2205 const lhs_lock: ?RegisterLock = if (lhs == .register)
2206 self.register_manager.freezeRegAssumeUnused(lhs.register)2206 self.register_manager.lockRegAssumeUnused(lhs.register)
2207 else2207 else
2208 null;2208 null;
2209 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);2209 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
22102210
2211 try self.spillCompareFlagsIfOccupied();2211 try self.spillCompareFlagsIfOccupied();
2212 self.compare_flags_inst = null;2212 self.compare_flags_inst = null;
...@@ -2214,8 +2214,8 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -2214,8 +2214,8 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
2214 // lsl dest, lhs, rhs2214 // lsl dest, lhs, rhs
2215 const dest = try self.binOp(.shl, null, lhs, rhs, lhs_ty, rhs_ty);2215 const dest = try self.binOp(.shl, null, lhs, rhs, lhs_ty, rhs_ty);
2216 const dest_reg = dest.register;2216 const dest_reg = dest.register;
2217 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);2217 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
2218 defer self.register_manager.unfreezeReg(dest_reg_lock);2218 defer self.register_manager.unlockReg(dest_reg_lock);
22192219
2220 // asr/lsr reconstructed, dest, rhs2220 // asr/lsr reconstructed, dest, rhs
2221 const reconstructed = try self.binOp(.shr, null, dest, rhs, lhs_ty, rhs_ty);2221 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 {...@@ -2454,17 +2454,17 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
2454 const slice_ptr_field_type = slice_ty.slicePtrFieldType(&buf);2454 const slice_ptr_field_type = slice_ty.slicePtrFieldType(&buf);
24552455
2456 const index_lock: ?RegisterLock = if (index_is_register)2456 const index_lock: ?RegisterLock = if (index_is_register)
2457 self.register_manager.freezeRegAssumeUnused(index_mcv.register)2457 self.register_manager.lockRegAssumeUnused(index_mcv.register)
2458 else2458 else
2459 null;2459 null;
2460 defer if (index_lock) |reg| self.register_manager.unfreezeReg(reg);2460 defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
24612461
2462 const base_mcv: MCValue = switch (slice_mcv) {2462 const base_mcv: MCValue = switch (slice_mcv) {
2463 .stack_offset => |off| .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, .{ .stack_offset = off }) },2463 .stack_offset => |off| .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, .{ .stack_offset = off }) },
2464 else => return self.fail("TODO slice_elem_val when slice is {}", .{slice_mcv}),2464 else => return self.fail("TODO slice_elem_val when slice is {}", .{slice_mcv}),
2465 };2465 };
2466 const base_lock = self.register_manager.freezeRegAssumeUnused(base_mcv.register);2466 const base_lock = self.register_manager.lockRegAssumeUnused(base_mcv.register);
2467 defer self.register_manager.unfreezeReg(base_lock);2467 defer self.register_manager.unlockReg(base_lock);
24682468
2469 switch (elem_size) {2469 switch (elem_size) {
2470 else => {2470 else => {
...@@ -2605,8 +2605,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo...@@ -2605,8 +2605,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
2605 .immediate => |imm| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),2605 .immediate => |imm| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),
2606 .ptr_stack_offset => |off| try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off }),2606 .ptr_stack_offset => |off| try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off }),
2607 .register => |addr_reg| {2607 .register => |addr_reg| {
2608 const addr_reg_lock = self.register_manager.freezeReg(addr_reg);2608 const addr_reg_lock = self.register_manager.lockReg(addr_reg);
2609 defer if (addr_reg_lock) |reg| self.register_manager.unfreezeReg(reg);2609 defer if (addr_reg_lock) |reg| self.register_manager.unlockReg(reg);
26102610
2611 switch (dst_mcv) {2611 switch (dst_mcv) {
2612 .dead => unreachable,2612 .dead => unreachable,
...@@ -2619,8 +2619,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo...@@ -2619,8 +2619,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
2619 if (elem_size <= 8) {2619 if (elem_size <= 8) {
2620 const raw_tmp_reg = try self.register_manager.allocReg(null);2620 const raw_tmp_reg = try self.register_manager.allocReg(null);
2621 const tmp_reg = registerAlias(raw_tmp_reg, elem_size);2621 const tmp_reg = registerAlias(raw_tmp_reg, elem_size);
2622 const tmp_reg_lock = self.register_manager.freezeRegAssumeUnused(tmp_reg);2622 const tmp_reg_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
2623 defer self.register_manager.unfreezeReg(tmp_reg_lock);2623 defer self.register_manager.unlockReg(tmp_reg_lock);
26242624
2625 try self.load(.{ .register = tmp_reg }, ptr, ptr_ty);2625 try self.load(.{ .register = tmp_reg }, ptr, ptr_ty);
2626 try self.genSetStack(elem_ty, off, MCValue{ .register = tmp_reg });2626 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...@@ -2628,9 +2628,9 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
2628 // TODO optimize the register allocation2628 // TODO optimize the register allocation
2629 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });2629 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });
2630 var regs_locks: [4]RegisterLock = undefined;2630 var regs_locks: [4]RegisterLock = undefined;
2631 self.register_manager.freezeRegsAssumeUnused(4, regs, &regs_locks);2631 self.register_manager.lockRegsAssumeUnused(4, regs, &regs_locks);
2632 defer for (regs_locks) |reg| {2632 defer for (regs_locks) |reg| {
2633 self.register_manager.unfreezeReg(reg);2633 self.register_manager.unlockReg(reg);
2634 };2634 };
26352635
2636 const src_reg = addr_reg;2636 const src_reg = addr_reg;
...@@ -2833,8 +2833,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type...@@ -2833,8 +2833,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
2833 try self.genSetStack(value_ty, off, value);2833 try self.genSetStack(value_ty, off, value);
2834 },2834 },
2835 .register => |addr_reg| {2835 .register => |addr_reg| {
2836 const addr_reg_lock = self.register_manager.freezeReg(addr_reg);2836 const addr_reg_lock = self.register_manager.lockReg(addr_reg);
2837 defer if (addr_reg_lock) |reg| self.register_manager.unfreezeReg(reg);2837 defer if (addr_reg_lock) |reg| self.register_manager.unlockReg(reg);
28382838
2839 switch (value) {2839 switch (value) {
2840 .register => |value_reg| {2840 .register => |value_reg| {
...@@ -2844,8 +2844,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type...@@ -2844,8 +2844,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
2844 if (abi_size <= 8) {2844 if (abi_size <= 8) {
2845 const raw_tmp_reg = try self.register_manager.allocReg(null);2845 const raw_tmp_reg = try self.register_manager.allocReg(null);
2846 const tmp_reg = registerAlias(raw_tmp_reg, abi_size);2846 const tmp_reg = registerAlias(raw_tmp_reg, abi_size);
2847 const tmp_reg_lock = self.register_manager.freezeRegAssumeUnused(tmp_reg);2847 const tmp_reg_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
2848 defer self.register_manager.unfreezeReg(tmp_reg_lock);2848 defer self.register_manager.unlockReg(tmp_reg_lock);
28492849
2850 try self.genSetReg(value_ty, tmp_reg, value);2850 try self.genSetReg(value_ty, tmp_reg, value);
2851 try self.store(ptr, .{ .register = tmp_reg }, ptr_ty, value_ty);2851 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...@@ -2905,12 +2905,12 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
2905 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{2905 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{
2906 .immediate = struct_field_offset,2906 .immediate = struct_field_offset,
2907 });2907 });
2908 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);2908 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2909 defer self.register_manager.unfreezeReg(offset_reg_lock);2909 defer self.register_manager.unlockReg(offset_reg_lock);
29102910
2911 const addr_reg = try self.copyToTmpRegister(ptr_ty, mcv);2911 const addr_reg = try self.copyToTmpRegister(ptr_ty, mcv);
2912 const addr_reg_lock = self.register_manager.freezeRegAssumeUnused(addr_reg);2912 const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
2913 defer self.register_manager.unfreezeReg(addr_reg_lock);2913 defer self.register_manager.unlockReg(addr_reg_lock);
29142914
2915 const dest = try self.binOp(2915 const dest = try self.binOp(
2916 .add,2916 .add,
...@@ -4008,8 +4008,8 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro...@@ -4008,8 +4008,8 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
4008 .register_c_flag,4008 .register_c_flag,
4009 .register_v_flag,4009 .register_v_flag,
4010 => |reg| {4010 => |reg| {
4011 const reg_lock = self.register_manager.freezeReg(reg);4011 const reg_lock = self.register_manager.lockReg(reg);
4012 defer if (reg_lock) |locked_reg| self.register_manager.unfreezeReg(locked_reg);4012 defer if (reg_lock) |locked_reg| self.register_manager.unlockReg(locked_reg);
40134013
4014 const wrapped_ty = ty.structFieldType(0);4014 const wrapped_ty = ty.structFieldType(0);
4015 try self.genSetStack(wrapped_ty, stack_offset, .{ .register = reg });4015 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...@@ -4066,9 +4066,9 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
4066 // TODO call extern memcpy4066 // TODO call extern memcpy
4067 const regs = try self.register_manager.allocRegs(5, .{ null, null, null, null, null });4067 const regs = try self.register_manager.allocRegs(5, .{ null, null, null, null, null });
4068 var regs_locks: [5]RegisterLock = undefined;4068 var regs_locks: [5]RegisterLock = undefined;
4069 self.register_manager.freezeRegsAssumeUnused(5, regs, &regs_locks);4069 self.register_manager.lockRegsAssumeUnused(5, regs, &regs_locks);
4070 defer for (regs_locks) |reg| {4070 defer for (regs_locks) |reg| {
4071 self.register_manager.unfreezeReg(reg);4071 self.register_manager.unlockReg(reg);
4072 };4072 };
40734073
4074 const src_reg = regs[0];4074 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 {...@@ -735,7 +735,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
735 // zig fmt: on735 // zig fmt: on
736 }736 }
737737
738 assert(!self.register_manager.frozenRegsExist());738 assert(!self.register_manager.lockedRegsExist());
739739
740 if (std.debug.runtime_safety) {740 if (std.debug.runtime_safety) {
741 if (self.air_bookkeeping < old_air_bookkeeping + 1) {741 if (self.air_bookkeeping < old_air_bookkeeping + 1) {
...@@ -1039,8 +1039,8 @@ fn trunc(...@@ -1039,8 +1039,8 @@ fn trunc(
1039 }1039 }
1040 },1040 },
1041 };1041 };
1042 const operand_reg_lock = self.register_manager.freezeReg(operand_reg);1042 const operand_reg_lock = self.register_manager.lockReg(operand_reg);
1043 defer if (operand_reg_lock) |reg| self.register_manager.unfreezeReg(reg);1043 defer if (operand_reg_lock) |reg| self.register_manager.unlockReg(reg);
10441044
1045 const dest_reg = if (maybe_inst) |inst| blk: {1045 const dest_reg = if (maybe_inst) |inst| blk: {
1046 const ty_op = self.air.instructions.items(.data)[inst].ty_op;1046 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
...@@ -1128,8 +1128,8 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {...@@ -1128,8 +1128,8 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
1128 .register => |r| r,1128 .register => |r| r,
1129 else => try self.copyToTmpRegister(operand_ty, operand),1129 else => try self.copyToTmpRegister(operand_ty, operand),
1130 };1130 };
1131 const op_reg_lock = self.register_manager.freezeRegAssumeUnused(op_reg);1131 const op_reg_lock = self.register_manager.lockRegAssumeUnused(op_reg);
1132 defer self.register_manager.unfreezeReg(op_reg_lock);1132 defer self.register_manager.unlockReg(op_reg_lock);
11331133
1134 const dest_reg = blk: {1134 const dest_reg = blk: {
1135 if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {1135 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 {...@@ -1158,8 +1158,8 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
1158 .register => |r| r,1158 .register => |r| r,
1159 else => try self.copyToTmpRegister(operand_ty, operand),1159 else => try self.copyToTmpRegister(operand_ty, operand),
1160 };1160 };
1161 const op_reg_lock = self.register_manager.freezeRegAssumeUnused(op_reg);1161 const op_reg_lock = self.register_manager.lockRegAssumeUnused(op_reg);
1162 defer self.register_manager.unfreezeReg(op_reg_lock);1162 defer self.register_manager.unlockReg(op_reg_lock);
11631163
1164 const dest_reg = blk: {1164 const dest_reg = blk: {
1165 if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {1165 if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {
...@@ -1219,15 +1219,15 @@ fn minMax(...@@ -1219,15 +1219,15 @@ fn minMax(
1219 .register => |r| r,1219 .register => |r| r,
1220 else => try self.copyToTmpRegister(lhs_ty, lhs),1220 else => try self.copyToTmpRegister(lhs_ty, lhs),
1221 };1221 };
1222 const lhs_reg_lock = self.register_manager.freezeReg(lhs_reg);1222 const lhs_reg_lock = self.register_manager.lockReg(lhs_reg);
1223 defer if (lhs_reg_lock) |reg| self.register_manager.unfreezeReg(reg);1223 defer if (lhs_reg_lock) |reg| self.register_manager.unlockReg(reg);
12241224
1225 const rhs_reg = switch (rhs) {1225 const rhs_reg = switch (rhs) {
1226 .register => |r| r,1226 .register => |r| r,
1227 else => try self.copyToTmpRegister(rhs_ty, rhs),1227 else => try self.copyToTmpRegister(rhs_ty, rhs),
1228 };1228 };
1229 const rhs_reg_lock = self.register_manager.freezeReg(rhs_reg);1229 const rhs_reg_lock = self.register_manager.lockReg(rhs_reg);
1230 defer if (rhs_reg_lock) |reg| self.register_manager.unfreezeReg(reg);1230 defer if (rhs_reg_lock) |reg| self.register_manager.unlockReg(reg);
12311231
1232 const dest_reg = if (maybe_inst) |inst| blk: {1232 const dest_reg = if (maybe_inst) |inst| blk: {
1233 const bin_op = self.air.instructions.items(.data)[inst].bin_op;1233 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
...@@ -1393,12 +1393,12 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -1393,12 +1393,12 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
1393 };1393 };
1394 const dest = try self.binOp(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);1394 const dest = try self.binOp(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);
1395 const dest_reg = dest.register;1395 const dest_reg = dest.register;
1396 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);1396 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
1397 defer self.register_manager.unfreezeReg(dest_reg_lock);1397 defer self.register_manager.unlockReg(dest_reg_lock);
13981398
1399 const truncated_reg = try self.register_manager.allocReg(null);1399 const truncated_reg = try self.register_manager.allocReg(null);
1400 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);1400 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1401 defer self.register_manager.unfreezeReg(truncated_reg_lock);1401 defer self.register_manager.unlockReg(truncated_reg_lock);
14021402
1403 // sbfx/ubfx truncated, dest, #0, #bits1403 // sbfx/ubfx truncated, dest, #0, #bits
1404 try self.truncRegister(dest_reg, truncated_reg, int_info.signedness, int_info.bits);1404 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 {...@@ -1494,12 +1494,12 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
14941494
1495 const dest = try self.binOpRegister(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);1495 const dest = try self.binOpRegister(base_tag, null, lhs, rhs, lhs_ty, rhs_ty);
1496 const dest_reg = dest.register;1496 const dest_reg = dest.register;
1497 const dest_reg_lock = self.register_manager.freezeRegAssumeUnused(dest_reg);1497 const dest_reg_lock = self.register_manager.lockRegAssumeUnused(dest_reg);
1498 defer self.register_manager.unfreezeReg(dest_reg_lock);1498 defer self.register_manager.unlockReg(dest_reg_lock);
14991499
1500 const truncated_reg = try self.register_manager.allocReg(null);1500 const truncated_reg = try self.register_manager.allocReg(null);
1501 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);1501 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1502 defer self.register_manager.unfreezeReg(truncated_reg_lock);1502 defer self.register_manager.unlockReg(truncated_reg_lock);
15031503
1504 // sbfx/ubfx truncated, dest, #0, #bits1504 // sbfx/ubfx truncated, dest, #0, #bits
1505 try self.truncRegister(dest_reg, truncated_reg, int_info.signedness, int_info.bits);1505 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 {...@@ -1528,30 +1528,30 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1528 const rhs_is_register = rhs == .register;1528 const rhs_is_register = rhs == .register;
15291529
1530 const lhs_lock: ?RegisterLock = if (lhs_is_register)1530 const lhs_lock: ?RegisterLock = if (lhs_is_register)
1531 self.register_manager.freezeReg(lhs.register)1531 self.register_manager.lockReg(lhs.register)
1532 else1532 else
1533 null;1533 null;
1534 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);1534 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
15351535
1536 const lhs_reg = if (lhs_is_register)1536 const lhs_reg = if (lhs_is_register)
1537 lhs.register1537 lhs.register
1538 else1538 else
1539 try self.register_manager.allocReg(null);1539 try self.register_manager.allocReg(null);
1540 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);1540 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
1541 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);1541 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
15421542
1543 const rhs_reg = if (rhs_is_register)1543 const rhs_reg = if (rhs_is_register)
1544 rhs.register1544 rhs.register
1545 else1545 else
1546 try self.register_manager.allocReg(null);1546 try self.register_manager.allocReg(null);
1547 const new_rhs_lock = self.register_manager.freezeReg(rhs_reg);1547 const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
1548 defer if (new_rhs_lock) |reg| self.register_manager.unfreezeReg(reg);1548 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
15491549
1550 const dest_regs = try self.register_manager.allocRegs(2, .{ null, null });1550 const dest_regs = try self.register_manager.allocRegs(2, .{ null, null });
1551 var dest_regs_locks: [2]RegisterLock = undefined;1551 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);
1553 defer for (dest_regs_locks) |reg| {1553 defer for (dest_regs_locks) |reg| {
1554 self.register_manager.unfreezeReg(reg);1554 self.register_manager.unlockReg(reg);
1555 };1555 };
1556 const rdlo = dest_regs[0];1556 const rdlo = dest_regs[0];
1557 const rdhi = dest_regs[1];1557 const rdhi = dest_regs[1];
...@@ -1560,8 +1560,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -1560,8 +1560,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1560 if (!rhs_is_register) try self.genSetReg(rhs_ty, rhs_reg, rhs);1560 if (!rhs_is_register) try self.genSetReg(rhs_ty, rhs_reg, rhs);
15611561
1562 const truncated_reg = try self.register_manager.allocReg(null);1562 const truncated_reg = try self.register_manager.allocReg(null);
1563 const truncated_reg_lock = self.register_manager.freezeRegAssumeUnused(truncated_reg);1563 const truncated_reg_lock = self.register_manager.lockRegAssumeUnused(truncated_reg);
1564 defer self.register_manager.unfreezeReg(truncated_reg_lock);1564 defer self.register_manager.unlockReg(truncated_reg_lock);
15651565
1566 _ = try self.addInst(.{1566 _ = try self.addInst(.{
1567 .tag = base_tag,1567 .tag = base_tag,
...@@ -1654,10 +1654,10 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -1654,10 +1654,10 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1654 const stack_offset = try self.allocMem(inst, tuple_size, tuple_align);1654 const stack_offset = try self.allocMem(inst, tuple_size, tuple_align);
16551655
1656 const lhs_lock: ?RegisterLock = if (lhs == .register)1656 const lhs_lock: ?RegisterLock = if (lhs == .register)
1657 self.register_manager.freezeRegAssumeUnused(lhs.register)1657 self.register_manager.lockRegAssumeUnused(lhs.register)
1658 else1658 else
1659 null;1659 null;
1660 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);1660 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
16611661
1662 try self.spillCompareFlagsIfOccupied();1662 try self.spillCompareFlagsIfOccupied();
1663 self.compare_flags_inst = null;1663 self.compare_flags_inst = null;
...@@ -1948,10 +1948,10 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {...@@ -1948,10 +1948,10 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
1948 const slice_ptr_field_type = slice_ty.slicePtrFieldType(&buf);1948 const slice_ptr_field_type = slice_ty.slicePtrFieldType(&buf);
19491949
1950 const index_lock: ?RegisterLock = if (index_is_register)1950 const index_lock: ?RegisterLock = if (index_is_register)
1951 self.register_manager.freezeRegAssumeUnused(index_mcv.register)1951 self.register_manager.lockRegAssumeUnused(index_mcv.register)
1952 else1952 else
1953 null;1953 null;
1954 defer if (index_lock) |reg| self.register_manager.unfreezeReg(reg);1954 defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
19551955
1956 const base_mcv = slicePtr(slice_mcv);1956 const base_mcv = slicePtr(slice_mcv);
19571957
...@@ -1961,20 +1961,20 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {...@@ -1961,20 +1961,20 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
1961 .register => |r| r,1961 .register => |r| r,
1962 else => try self.copyToTmpRegister(slice_ptr_field_type, base_mcv),1962 else => try self.copyToTmpRegister(slice_ptr_field_type, base_mcv),
1963 };1963 };
1964 const base_reg_lock = self.register_manager.freezeRegAssumeUnused(base_reg);1964 const base_reg_lock = self.register_manager.lockRegAssumeUnused(base_reg);
1965 defer self.register_manager.unfreezeReg(base_reg_lock);1965 defer self.register_manager.unlockReg(base_reg_lock);
19661966
1967 const dst_reg = try self.register_manager.allocReg(inst);1967 const dst_reg = try self.register_manager.allocReg(inst);
1968 const dst_mcv = MCValue{ .register = dst_reg };1968 const dst_mcv = MCValue{ .register = dst_reg };
1969 const dst_reg_lock = self.register_manager.freezeRegAssumeUnused(dst_reg);1969 const dst_reg_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
1970 defer self.register_manager.unfreezeReg(dst_reg_lock);1970 defer self.register_manager.unlockReg(dst_reg_lock);
19711971
1972 const index_reg: Register = switch (index_mcv) {1972 const index_reg: Register = switch (index_mcv) {
1973 .register => |reg| reg,1973 .register => |reg| reg,
1974 else => try self.copyToTmpRegister(Type.usize, index_mcv),1974 else => try self.copyToTmpRegister(Type.usize, index_mcv),
1975 };1975 };
1976 const index_reg_lock = self.register_manager.freezeRegAssumeUnused(index_reg);1976 const index_reg_lock = self.register_manager.lockRegAssumeUnused(index_reg);
1977 defer self.register_manager.unfreezeReg(index_reg_lock);1977 defer self.register_manager.unlockReg(index_reg_lock);
19781978
1979 const tag: Mir.Inst.Tag = switch (elem_size) {1979 const tag: Mir.Inst.Tag = switch (elem_size) {
1980 1 => .ldrb,1980 1 => .ldrb,
...@@ -2160,8 +2160,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo...@@ -2160,8 +2160,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
2160 .immediate => |imm| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),2160 .immediate => |imm| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),
2161 .ptr_stack_offset => |off| try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off }),2161 .ptr_stack_offset => |off| try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off }),
2162 .register => |reg| {2162 .register => |reg| {
2163 const reg_lock = self.register_manager.freezeReg(reg);2163 const reg_lock = self.register_manager.lockReg(reg);
2164 defer if (reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);2164 defer if (reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
21652165
2166 switch (dst_mcv) {2166 switch (dst_mcv) {
2167 .dead => unreachable,2167 .dead => unreachable,
...@@ -2173,8 +2173,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo...@@ -2173,8 +2173,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
2173 .stack_offset => |off| {2173 .stack_offset => |off| {
2174 if (elem_size <= 4) {2174 if (elem_size <= 4) {
2175 const tmp_reg = try self.register_manager.allocReg(null);2175 const tmp_reg = try self.register_manager.allocReg(null);
2176 const tmp_reg_lock = self.register_manager.freezeRegAssumeUnused(tmp_reg);2176 const tmp_reg_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
2177 defer self.register_manager.unfreezeReg(tmp_reg_lock);2177 defer self.register_manager.unlockReg(tmp_reg_lock);
21782178
2179 try self.load(.{ .register = tmp_reg }, ptr, ptr_ty);2179 try self.load(.{ .register = tmp_reg }, ptr, ptr_ty);
2180 try self.genSetStack(elem_ty, off, MCValue{ .register = tmp_reg });2180 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...@@ -2182,9 +2182,9 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
2182 // TODO optimize the register allocation2182 // TODO optimize the register allocation
2183 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });2183 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });
2184 var regs_locks: [4]RegisterLock = undefined;2184 var regs_locks: [4]RegisterLock = undefined;
2185 self.register_manager.freezeRegsAssumeUnused(4, regs, &regs_locks);2185 self.register_manager.lockRegsAssumeUnused(4, regs, &regs_locks);
2186 defer for (regs_locks) |reg_locked| {2186 defer for (regs_locks) |reg_locked| {
2187 self.register_manager.unfreezeReg(reg_locked);2187 self.register_manager.unlockReg(reg_locked);
2188 };2188 };
21892189
2190 const src_reg = reg;2190 const src_reg = reg;
...@@ -2211,8 +2211,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo...@@ -2211,8 +2211,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
2211 .stack_argument_offset,2211 .stack_argument_offset,
2212 => {2212 => {
2213 const reg = try self.register_manager.allocReg(null);2213 const reg = try self.register_manager.allocReg(null);
2214 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);2214 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
2215 defer self.register_manager.unfreezeReg(reg_lock);2215 defer self.register_manager.unlockReg(reg_lock);
22162216
2217 try self.genSetReg(ptr_ty, reg, ptr);2217 try self.genSetReg(ptr_ty, reg, ptr);
2218 try self.load(dst_mcv, .{ .register = reg }, ptr_ty);2218 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...@@ -2266,8 +2266,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
2266 try self.genSetStack(value_ty, off, value);2266 try self.genSetStack(value_ty, off, value);
2267 },2267 },
2268 .register => |addr_reg| {2268 .register => |addr_reg| {
2269 const addr_reg_lock = self.register_manager.freezeReg(addr_reg);2269 const addr_reg_lock = self.register_manager.lockReg(addr_reg);
2270 defer if (addr_reg_lock) |reg| self.register_manager.unfreezeReg(reg);2270 defer if (addr_reg_lock) |reg| self.register_manager.unlockReg(reg);
22712271
2272 switch (value) {2272 switch (value) {
2273 .dead => unreachable,2273 .dead => unreachable,
...@@ -2278,17 +2278,17 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type...@@ -2278,17 +2278,17 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
2278 else => {2278 else => {
2279 if (elem_size <= 4) {2279 if (elem_size <= 4) {
2280 const tmp_reg = try self.register_manager.allocReg(null);2280 const tmp_reg = try self.register_manager.allocReg(null);
2281 const tmp_reg_lock = self.register_manager.freezeRegAssumeUnused(tmp_reg);2281 const tmp_reg_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
2282 defer self.register_manager.unfreezeReg(tmp_reg_lock);2282 defer self.register_manager.unlockReg(tmp_reg_lock);
22832283
2284 try self.genSetReg(value_ty, tmp_reg, value);2284 try self.genSetReg(value_ty, tmp_reg, value);
2285 try self.store(ptr, .{ .register = tmp_reg }, ptr_ty, value_ty);2285 try self.store(ptr, .{ .register = tmp_reg }, ptr_ty, value_ty);
2286 } else {2286 } else {
2287 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });2287 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });
2288 var regs_locks: [4]RegisterLock = undefined;2288 var regs_locks: [4]RegisterLock = undefined;
2289 self.register_manager.freezeRegsAssumeUnused(4, regs, &regs_locks);2289 self.register_manager.lockRegsAssumeUnused(4, regs, &regs_locks);
2290 defer for (regs_locks) |reg| {2290 defer for (regs_locks) |reg| {
2291 self.register_manager.unfreezeReg(reg);2291 self.register_manager.unlockReg(reg);
2292 };2292 };
22932293
2294 const src_reg = regs[0];2294 const src_reg = regs[0];
...@@ -2373,12 +2373,12 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde...@@ -2373,12 +2373,12 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
2373 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{2373 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{
2374 .immediate = struct_field_offset,2374 .immediate = struct_field_offset,
2375 });2375 });
2376 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);2376 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2377 defer self.register_manager.unfreezeReg(offset_reg_lock);2377 defer self.register_manager.unlockReg(offset_reg_lock);
23782378
2379 const addr_reg = try self.copyToTmpRegister(ptr_ty, mcv);2379 const addr_reg = try self.copyToTmpRegister(ptr_ty, mcv);
2380 const addr_reg_lock = self.register_manager.freezeRegAssumeUnused(addr_reg);2380 const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
2381 defer self.register_manager.unfreezeReg(addr_reg_lock);2381 defer self.register_manager.unlockReg(addr_reg_lock);
23822382
2383 const dest = try self.binOp(2383 const dest = try self.binOp(
2384 .add,2384 .add,
...@@ -2495,10 +2495,10 @@ fn binOpRegister(...@@ -2495,10 +2495,10 @@ fn binOpRegister(
2495 const rhs_is_register = rhs == .register;2495 const rhs_is_register = rhs == .register;
24962496
2497 const lhs_lock: ?RegisterLock = if (lhs_is_register)2497 const lhs_lock: ?RegisterLock = if (lhs_is_register)
2498 self.register_manager.freezeReg(lhs.register)2498 self.register_manager.lockReg(lhs.register)
2499 else2499 else
2500 null;2500 null;
2501 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);2501 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
25022502
2503 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];2503 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
25042504
...@@ -2514,8 +2514,8 @@ fn binOpRegister(...@@ -2514,8 +2514,8 @@ fn binOpRegister(
25142514
2515 break :blk reg;2515 break :blk reg;
2516 };2516 };
2517 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);2517 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
2518 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);2518 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
25192519
2520 const rhs_reg = if (rhs_is_register) rhs.register else blk: {2520 const rhs_reg = if (rhs_is_register) rhs.register else blk: {
2521 const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {2521 const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {
...@@ -2529,8 +2529,8 @@ fn binOpRegister(...@@ -2529,8 +2529,8 @@ fn binOpRegister(
25292529
2530 break :blk reg;2530 break :blk reg;
2531 };2531 };
2532 const new_rhs_lock = self.register_manager.freezeReg(rhs_reg);2532 const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
2533 defer if (new_rhs_lock) |reg| self.register_manager.unfreezeReg(reg);2533 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
25342534
2535 const dest_reg = switch (mir_tag) {2535 const dest_reg = switch (mir_tag) {
2536 .cmp => .r0, // cmp has no destination regardless2536 .cmp => .r0, // cmp has no destination regardless
...@@ -2614,10 +2614,10 @@ fn binOpImmediate(...@@ -2614,10 +2614,10 @@ fn binOpImmediate(
2614 const lhs_is_register = lhs == .register;2614 const lhs_is_register = lhs == .register;
26152615
2616 const lhs_lock: ?RegisterLock = if (lhs_is_register)2616 const lhs_lock: ?RegisterLock = if (lhs_is_register)
2617 self.register_manager.freezeReg(lhs.register)2617 self.register_manager.lockReg(lhs.register)
2618 else2618 else
2619 null;2619 null;
2620 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);2620 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
26212621
2622 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];2622 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
26232623
...@@ -2635,8 +2635,8 @@ fn binOpImmediate(...@@ -2635,8 +2635,8 @@ fn binOpImmediate(
26352635
2636 break :blk reg;2636 break :blk reg;
2637 };2637 };
2638 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);2638 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
2639 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);2639 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
26402640
2641 const dest_reg = switch (mir_tag) {2641 const dest_reg = switch (mir_tag) {
2642 .cmp => .r0, // cmp has no destination reg2642 .cmp => .r0, // cmp has no destination reg
src/arch/riscv64/CodeGen.zig+8-8
...@@ -939,10 +939,10 @@ fn binOpRegister(...@@ -939,10 +939,10 @@ fn binOpRegister(
939 const rhs_is_register = rhs == .register;939 const rhs_is_register = rhs == .register;
940940
941 const lhs_lock: ?RegisterLock = if (lhs_is_register)941 const lhs_lock: ?RegisterLock = if (lhs_is_register)
942 self.register_manager.freezeReg(lhs.register)942 self.register_manager.lockReg(lhs.register)
943 else943 else
944 null;944 null;
945 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);945 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
946946
947 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];947 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
948948
...@@ -958,8 +958,8 @@ fn binOpRegister(...@@ -958,8 +958,8 @@ fn binOpRegister(
958958
959 break :blk reg;959 break :blk reg;
960 };960 };
961 const new_lhs_lock = self.register_manager.freezeReg(lhs_reg);961 const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
962 defer if (new_lhs_lock) |reg| self.register_manager.unfreezeReg(reg);962 defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
963963
964 const rhs_reg = if (rhs_is_register) rhs.register else blk: {964 const rhs_reg = if (rhs_is_register) rhs.register else blk: {
965 const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {965 const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {
...@@ -973,8 +973,8 @@ fn binOpRegister(...@@ -973,8 +973,8 @@ fn binOpRegister(
973973
974 break :blk reg;974 break :blk reg;
975 };975 };
976 const new_rhs_lock = self.register_manager.freezeReg(rhs_reg);976 const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
977 defer if (new_rhs_lock) |reg| self.register_manager.unfreezeReg(reg);977 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
978978
979 const dest_reg = if (maybe_inst) |inst| blk: {979 const dest_reg = if (maybe_inst) |inst| blk: {
980 const bin_op = self.air.instructions.items(.data)[inst].bin_op;980 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...@@ -1452,8 +1452,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
1452 .stack_offset,1452 .stack_offset,
1453 => {1453 => {
1454 const reg = try self.register_manager.allocReg(null);1454 const reg = try self.register_manager.allocReg(null);
1455 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);1455 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
1456 defer self.register_manager.unfreezeReg(reg_lock);1456 defer self.register_manager.unlockReg(reg_lock);
14571457
1458 try self.genSetReg(ptr_ty, reg, ptr);1458 try self.genSetReg(ptr_ty, reg, ptr);
1459 try self.load(dst_mcv, .{ .register = reg }, ptr_ty);1459 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 {...@@ -795,7 +795,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
795 // zig fmt: on795 // zig fmt: on
796 }796 }
797797
798 assert(!self.register_manager.frozenRegsExist());798 assert(!self.register_manager.lockedRegsExist());
799799
800 if (std.debug.runtime_safety) {800 if (std.debug.runtime_safety) {
801 if (self.air_bookkeeping < old_air_bookkeeping + 1) {801 if (self.air_bookkeeping < old_air_bookkeeping + 1) {
...@@ -1028,10 +1028,10 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {...@@ -1028,10 +1028,10 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
1028 }1028 }
10291029
1030 const operand_lock: ?RegisterLock = switch (operand) {1030 const operand_lock: ?RegisterLock = switch (operand) {
1031 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1031 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1032 else => null,1032 else => null,
1033 };1033 };
1034 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);1034 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
10351035
1036 const reg = try self.register_manager.allocReg(inst);1036 const reg = try self.register_manager.allocReg(inst);
1037 try self.genSetReg(dest_ty, reg, .{ .immediate = 0 });1037 try self.genSetReg(dest_ty, reg, .{ .immediate = 0 });
...@@ -1059,10 +1059,10 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {...@@ -1059,10 +1059,10 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
1059 }1059 }
10601060
1061 const operand_lock: ?RegisterLock = switch (operand) {1061 const operand_lock: ?RegisterLock = switch (operand) {
1062 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1062 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1063 else => null,1063 else => null,
1064 };1064 };
1065 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);1065 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
10661066
1067 const reg: Register = blk: {1067 const reg: Register = blk: {
1068 if (operand.isRegister()) {1068 if (operand.isRegister()) {
...@@ -1147,21 +1147,21 @@ fn airMin(self: *Self, inst: Air.Inst.Index) !void {...@@ -1147,21 +1147,21 @@ fn airMin(self: *Self, inst: Air.Inst.Index) !void {
1147 // TODO audit register allocation1147 // TODO audit register allocation
1148 const lhs = try self.resolveInst(bin_op.lhs);1148 const lhs = try self.resolveInst(bin_op.lhs);
1149 const lhs_lock: ?RegisterLock = switch (lhs) {1149 const lhs_lock: ?RegisterLock = switch (lhs) {
1150 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1150 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1151 else => null,1151 else => null,
1152 };1152 };
1153 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);1153 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
11541154
1155 const lhs_reg = try self.copyToTmpRegister(ty, lhs);1155 const lhs_reg = try self.copyToTmpRegister(ty, lhs);
1156 const lhs_reg_lock = self.register_manager.freezeRegAssumeUnused(lhs_reg);1156 const lhs_reg_lock = self.register_manager.lockRegAssumeUnused(lhs_reg);
1157 defer self.register_manager.unfreezeReg(lhs_reg_lock);1157 defer self.register_manager.unlockReg(lhs_reg_lock);
11581158
1159 const rhs_mcv = try self.limitImmediateType(bin_op.rhs, i32);1159 const rhs_mcv = try self.limitImmediateType(bin_op.rhs, i32);
1160 const rhs_lock: ?RegisterLock = switch (rhs_mcv) {1160 const rhs_lock: ?RegisterLock = switch (rhs_mcv) {
1161 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1161 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1162 else => null,1162 else => null,
1163 };1163 };
1164 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);1164 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
11651165
1166 try self.genBinMathOpMir(.cmp, ty, .{ .register = lhs_reg }, rhs_mcv);1166 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...@@ -1197,10 +1197,10 @@ fn genPtrBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_r
1197 const offset_ty = self.air.typeOf(op_rhs);1197 const offset_ty = self.air.typeOf(op_rhs);
11981198
1199 const offset_lock: ?RegisterLock = switch (offset) {1199 const offset_lock: ?RegisterLock = switch (offset) {
1200 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1200 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1201 else => null,1201 else => null,
1202 };1202 };
1203 defer if (offset_lock) |reg| self.register_manager.unfreezeReg(reg);1203 defer if (offset_lock) |reg| self.register_manager.unlockReg(reg);
12041204
1205 const dst_mcv = blk: {1205 const dst_mcv = blk: {
1206 if (self.reuseOperand(inst, op_lhs, 0, ptr)) {1206 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...@@ -1210,10 +1210,10 @@ fn genPtrBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_r
1210 };1210 };
12111211
1212 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {1212 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {
1213 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1213 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1214 else => null,1214 else => null,
1215 };1215 };
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
1218 const offset_mcv = blk: {1218 const offset_mcv = blk: {
1219 if (self.reuseOperand(inst, op_rhs, 1, offset)) {1219 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...@@ -1223,10 +1223,10 @@ fn genPtrBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_r
1223 };1223 };
12241224
1225 const offset_mcv_lock: ?RegisterLock = switch (offset_mcv) {1225 const offset_mcv_lock: ?RegisterLock = switch (offset_mcv) {
1226 .register => |reg| self.register_manager.freezeReg(reg),1226 .register => |reg| self.register_manager.lockReg(reg),
1227 else => null,1227 else => null,
1228 };1228 };
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
1231 try self.genIntMulComplexOpMir(offset_ty, offset_mcv, .{ .immediate = elem_size });1231 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...@@ -1312,17 +1312,17 @@ fn genSubOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs: Air
13121312
1313 const lhs = try self.resolveInst(op_lhs);1313 const lhs = try self.resolveInst(op_lhs);
1314 const lhs_lock: ?RegisterLock = switch (lhs) {1314 const lhs_lock: ?RegisterLock = switch (lhs) {
1315 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1315 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1316 else => null,1316 else => null,
1317 };1317 };
1318 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);1318 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
13191319
1320 const rhs = try self.resolveInst(op_rhs);1320 const rhs = try self.resolveInst(op_rhs);
1321 const rhs_lock: ?RegisterLock = switch (rhs) {1321 const rhs_lock: ?RegisterLock = switch (rhs) {
1322 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1322 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1323 else => null,1323 else => null,
1324 };1324 };
1325 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);1325 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
13261326
1327 const dst_mcv = blk: {1327 const dst_mcv = blk: {
1328 if (self.reuseOperand(inst, op_lhs, 0, lhs) and lhs.isRegister()) {1328 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...@@ -1331,20 +1331,20 @@ fn genSubOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs: Air
1331 break :blk try self.copyToRegisterWithInstTracking(inst, dst_ty, lhs);1331 break :blk try self.copyToRegisterWithInstTracking(inst, dst_ty, lhs);
1332 };1332 };
1333 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {1333 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {
1334 .register => |reg| self.register_manager.freezeReg(reg),1334 .register => |reg| self.register_manager.lockReg(reg),
1335 else => null,1335 else => null,
1336 };1336 };
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
1339 const rhs_mcv = blk: {1339 const rhs_mcv = blk: {
1340 if (rhs.isMemory() or rhs.isRegister()) break :blk rhs;1340 if (rhs.isMemory() or rhs.isRegister()) break :blk rhs;
1341 break :blk MCValue{ .register = try self.copyToTmpRegister(dst_ty, rhs) };1341 break :blk MCValue{ .register = try self.copyToTmpRegister(dst_ty, rhs) };
1342 };1342 };
1343 const rhs_mcv_lock: ?RegisterLock = switch (rhs_mcv) {1343 const rhs_mcv_lock: ?RegisterLock = switch (rhs_mcv) {
1344 .register => |reg| self.register_manager.freezeReg(reg),1344 .register => |reg| self.register_manager.lockReg(reg),
1345 else => null,1345 else => null,
1346 };1346 };
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
1349 try self.genBinMathOpMir(.sub, dst_ty, dst_mcv, rhs_mcv);1349 try self.genBinMathOpMir(.sub, dst_ty, dst_mcv, rhs_mcv);
13501350
...@@ -1382,9 +1382,9 @@ fn airMul(self: *Self, inst: Air.Inst.Index) !void {...@@ -1382,9 +1382,9 @@ fn airMul(self: *Self, inst: Air.Inst.Index) !void {
1382 try self.register_manager.getReg(.rax, inst);1382 try self.register_manager.getReg(.rax, inst);
1383 try self.register_manager.getReg(.rdx, null);1383 try self.register_manager.getReg(.rdx, null);
1384 var reg_locks: [2]RegisterLock = undefined;1384 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);
1386 defer for (reg_locks) |reg| {1386 defer for (reg_locks) |reg| {
1387 self.register_manager.unfreezeReg(reg);1387 self.register_manager.unlockReg(reg);
1388 };1388 };
13891389
1390 const lhs = try self.resolveInst(bin_op.lhs);1390 const lhs = try self.resolveInst(bin_op.lhs);
...@@ -1496,9 +1496,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -1496,9 +1496,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1496 try self.register_manager.getReg(.rax, inst);1496 try self.register_manager.getReg(.rax, inst);
1497 try self.register_manager.getReg(.rdx, null);1497 try self.register_manager.getReg(.rdx, null);
1498 var reg_locks: [2]RegisterLock = undefined;1498 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);
1500 defer for (reg_locks) |reg| {1500 defer for (reg_locks) |reg| {
1501 self.register_manager.unfreezeReg(reg);1501 self.register_manager.unlockReg(reg);
1502 };1502 };
15031503
1504 const lhs = try self.resolveInst(bin_op.lhs);1504 const lhs = try self.resolveInst(bin_op.lhs);
...@@ -1526,27 +1526,27 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -1526,27 +1526,27 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1526 const rhs = try self.resolveInst(bin_op.rhs);1526 const rhs = try self.resolveInst(bin_op.rhs);
15271527
1528 const rhs_lock: ?RegisterLock = switch (rhs) {1528 const rhs_lock: ?RegisterLock = switch (rhs) {
1529 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1529 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1530 else => null,1530 else => null,
1531 };1531 };
1532 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);1532 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
15331533
1534 const dst_reg: Register = blk: {1534 const dst_reg: Register = blk: {
1535 if (lhs.isRegister()) break :blk lhs.register;1535 if (lhs.isRegister()) break :blk lhs.register;
1536 break :blk try self.copyToTmpRegister(ty, lhs);1536 break :blk try self.copyToTmpRegister(ty, lhs);
1537 };1537 };
1538 const dst_reg_lock = self.register_manager.freezeRegAssumeUnused(dst_reg);1538 const dst_reg_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
1539 defer self.register_manager.unfreezeReg(dst_reg_lock);1539 defer self.register_manager.unlockReg(dst_reg_lock);
15401540
1541 const rhs_mcv = blk: {1541 const rhs_mcv = blk: {
1542 if (rhs.isRegister() or rhs.isMemory()) break :blk rhs;1542 if (rhs.isRegister() or rhs.isMemory()) break :blk rhs;
1543 break :blk MCValue{ .register = try self.copyToTmpRegister(ty, rhs) };1543 break :blk MCValue{ .register = try self.copyToTmpRegister(ty, rhs) };
1544 };1544 };
1545 const rhs_mcv_lock: ?RegisterLock = switch (rhs_mcv) {1545 const rhs_mcv_lock: ?RegisterLock = switch (rhs_mcv) {
1546 .register => |reg| self.register_manager.freezeReg(reg),1546 .register => |reg| self.register_manager.lockReg(reg),
1547 else => null,1547 else => null,
1548 };1548 };
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
1551 try self.genIntMulComplexOpMir(Type.isize, .{ .register = dst_reg }, rhs_mcv);1551 try self.genIntMulComplexOpMir(Type.isize, .{ .register = dst_reg }, rhs_mcv);
15521552
...@@ -1557,9 +1557,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -1557,9 +1557,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1557 try self.register_manager.getReg(.rax, null);1557 try self.register_manager.getReg(.rax, null);
1558 try self.register_manager.getReg(.rdx, null);1558 try self.register_manager.getReg(.rdx, null);
1559 var reg_locks: [2]RegisterLock = undefined;1559 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);
1561 defer for (reg_locks) |reg| {1561 defer for (reg_locks) |reg| {
1562 self.register_manager.unfreezeReg(reg);1562 self.register_manager.unlockReg(reg);
1563 };1563 };
15641564
1565 const lhs = try self.resolveInst(bin_op.lhs);1565 const lhs = try self.resolveInst(bin_op.lhs);
...@@ -1571,8 +1571,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -1571,8 +1571,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1571 },1571 },
1572 }1572 }
1573 };1573 };
1574 const dst_reg_lock = self.register_manager.freezeRegAssumeUnused(dst_reg);1574 const dst_reg_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
1575 defer self.register_manager.unfreezeReg(dst_reg_lock);1575 defer self.register_manager.unlockReg(dst_reg_lock);
15761576
1577 const tuple_ty = self.air.typeOfIndex(inst);1577 const tuple_ty = self.air.typeOfIndex(inst);
1578 const tuple_size = @intCast(u32, tuple_ty.abiSize(self.target.*));1578 const tuple_size = @intCast(u32, tuple_ty.abiSize(self.target.*));
...@@ -1587,9 +1587,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {...@@ -1587,9 +1587,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
15871587
1588 const temp_regs = try self.register_manager.allocRegs(3, .{ null, null, null });1588 const temp_regs = try self.register_manager.allocRegs(3, .{ null, null, null });
1589 var temp_regs_locks: [3]RegisterLock = undefined;1589 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);
1591 defer for (temp_regs_locks) |reg| {1591 defer for (temp_regs_locks) |reg| {
1592 self.register_manager.unfreezeReg(reg);1592 self.register_manager.unlockReg(reg);
1593 };1593 };
15941594
1595 const overflow_reg = temp_regs[0];1595 const overflow_reg = temp_regs[0];
...@@ -1738,15 +1738,15 @@ fn genInlineIntDivFloor(self: *Self, ty: Type, lhs: MCValue, rhs: MCValue) !MCVa...@@ -1738,15 +1738,15 @@ fn genInlineIntDivFloor(self: *Self, ty: Type, lhs: MCValue, rhs: MCValue) !MCVa
1738 .register => |reg| reg,1738 .register => |reg| reg,
1739 else => try self.copyToTmpRegister(ty, lhs),1739 else => try self.copyToTmpRegister(ty, lhs),
1740 };1740 };
1741 const dividend_lock = self.register_manager.freezeReg(dividend);1741 const dividend_lock = self.register_manager.lockReg(dividend);
1742 defer if (dividend_lock) |reg| self.register_manager.unfreezeReg(reg);1742 defer if (dividend_lock) |reg| self.register_manager.unlockReg(reg);
17431743
1744 const divisor = switch (rhs) {1744 const divisor = switch (rhs) {
1745 .register => |reg| reg,1745 .register => |reg| reg,
1746 else => try self.copyToTmpRegister(ty, rhs),1746 else => try self.copyToTmpRegister(ty, rhs),
1747 };1747 };
1748 const divisor_lock = self.register_manager.freezeReg(divisor);1748 const divisor_lock = self.register_manager.lockReg(divisor);
1749 defer if (divisor_lock) |reg| self.register_manager.unfreezeReg(reg);1749 defer if (divisor_lock) |reg| self.register_manager.unlockReg(reg);
17501750
1751 try self.genIntMulDivOpMir(switch (signedness) {1751 try self.genIntMulDivOpMir(switch (signedness) {
1752 .signed => .idiv,1752 .signed => .idiv,
...@@ -1816,17 +1816,17 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {...@@ -1816,17 +1816,17 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
1816 try self.register_manager.getReg(.rax, track_rax);1816 try self.register_manager.getReg(.rax, track_rax);
1817 try self.register_manager.getReg(.rdx, null);1817 try self.register_manager.getReg(.rdx, null);
1818 var reg_locks: [2]RegisterLock = undefined;1818 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);
1820 defer for (reg_locks) |reg| {1820 defer for (reg_locks) |reg| {
1821 self.register_manager.unfreezeReg(reg);1821 self.register_manager.unlockReg(reg);
1822 };1822 };
18231823
1824 const lhs = try self.resolveInst(bin_op.lhs);1824 const lhs = try self.resolveInst(bin_op.lhs);
1825 const lhs_lock: ?RegisterLock = switch (lhs) {1825 const lhs_lock: ?RegisterLock = switch (lhs) {
1826 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1826 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1827 else => null,1827 else => null,
1828 };1828 };
1829 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);1829 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
18301830
1831 const rhs = blk: {1831 const rhs = blk: {
1832 const rhs = try self.resolveInst(bin_op.rhs);1832 const rhs = try self.resolveInst(bin_op.rhs);
...@@ -1834,10 +1834,10 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {...@@ -1834,10 +1834,10 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
1834 switch (tag) {1834 switch (tag) {
1835 .div_floor => {1835 .div_floor => {
1836 const rhs_lock: ?RegisterLock = switch (rhs) {1836 const rhs_lock: ?RegisterLock = switch (rhs) {
1837 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),1837 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
1838 else => null,1838 else => null,
1839 };1839 };
1840 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);1840 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
18411841
1842 break :blk try self.copyToRegisterWithInstTracking(inst, ty, rhs);1842 break :blk try self.copyToRegisterWithInstTracking(inst, ty, rhs);
1843 },1843 },
...@@ -1847,10 +1847,10 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {...@@ -1847,10 +1847,10 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
1847 break :blk rhs;1847 break :blk rhs;
1848 };1848 };
1849 const rhs_lock: ?RegisterLock = switch (rhs) {1849 const rhs_lock: ?RegisterLock = switch (rhs) {
1850 .register => |reg| self.register_manager.freezeReg(reg),1850 .register => |reg| self.register_manager.lockReg(reg),
1851 else => null,1851 else => null,
1852 };1852 };
1853 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);1853 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
18541854
1855 if (signedness == .unsigned) {1855 if (signedness == .unsigned) {
1856 try self.genIntMulDivOpMir(.div, ty, signedness, lhs, rhs);1856 try self.genIntMulDivOpMir(.div, ty, signedness, lhs, rhs);
...@@ -1885,9 +1885,9 @@ fn airRem(self: *Self, inst: Air.Inst.Index) !void {...@@ -1885,9 +1885,9 @@ fn airRem(self: *Self, inst: Air.Inst.Index) !void {
1885 try self.register_manager.getReg(.rax, null);1885 try self.register_manager.getReg(.rax, null);
1886 try self.register_manager.getReg(.rdx, inst);1886 try self.register_manager.getReg(.rdx, inst);
1887 var reg_locks: [2]RegisterLock = undefined;1887 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);
1889 defer for (reg_locks) |reg| {1889 defer for (reg_locks) |reg| {
1890 self.register_manager.unfreezeReg(reg);1890 self.register_manager.unlockReg(reg);
1891 };1891 };
18921892
1893 const lhs = try self.resolveInst(bin_op.lhs);1893 const lhs = try self.resolveInst(bin_op.lhs);
...@@ -1916,9 +1916,9 @@ fn airMod(self: *Self, inst: Air.Inst.Index) !void {...@@ -1916,9 +1916,9 @@ fn airMod(self: *Self, inst: Air.Inst.Index) !void {
1916 try self.register_manager.getReg(.rax, null);1916 try self.register_manager.getReg(.rax, null);
1917 try self.register_manager.getReg(.rdx, if (signedness == .unsigned) inst else null);1917 try self.register_manager.getReg(.rdx, if (signedness == .unsigned) inst else null);
1918 var reg_locks: [2]RegisterLock = undefined;1918 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);
1920 defer for (reg_locks) |reg| {1920 defer for (reg_locks) |reg| {
1921 self.register_manager.unfreezeReg(reg);1921 self.register_manager.unlockReg(reg);
1922 };1922 };
19231923
1924 const lhs = try self.resolveInst(bin_op.lhs);1924 const lhs = try self.resolveInst(bin_op.lhs);
...@@ -2009,15 +2009,15 @@ fn airShl(self: *Self, inst: Air.Inst.Index) !void {...@@ -2009,15 +2009,15 @@ fn airShl(self: *Self, inst: Air.Inst.Index) !void {
2009 try self.register_manager.getReg(.rcx, null);2009 try self.register_manager.getReg(.rcx, null);
2010 try self.genSetReg(shift_ty, .rcx, shift);2010 try self.genSetReg(shift_ty, .rcx, shift);
2011 }2011 }
2012 const rcx_lock = self.register_manager.freezeRegAssumeUnused(.rcx);2012 const rcx_lock = self.register_manager.lockRegAssumeUnused(.rcx);
2013 defer self.register_manager.unfreezeReg(rcx_lock);2013 defer self.register_manager.unlockReg(rcx_lock);
20142014
2015 const value = try self.resolveInst(bin_op.lhs);2015 const value = try self.resolveInst(bin_op.lhs);
2016 const value_lock: ?RegisterLock = switch (value) {2016 const value_lock: ?RegisterLock = switch (value) {
2017 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2017 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2018 else => null,2018 else => null,
2019 };2019 };
2020 defer if (value_lock) |reg| self.register_manager.unfreezeReg(reg);2020 defer if (value_lock) |reg| self.register_manager.unlockReg(reg);
20212021
2022 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ty, value);2022 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ty, value);
2023 _ = try self.addInst(.{2023 _ = try self.addInst(.{
...@@ -2114,10 +2114,10 @@ fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {...@@ -2114,10 +2114,10 @@ fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
2114 const payload_ty = err_union_ty.errorUnionPayload();2114 const payload_ty = err_union_ty.errorUnionPayload();
2115 const operand = try self.resolveInst(ty_op.operand);2115 const operand = try self.resolveInst(ty_op.operand);
2116 const operand_lock: ?RegisterLock = switch (operand) {2116 const operand_lock: ?RegisterLock = switch (operand) {
2117 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2117 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2118 else => null,2118 else => null,
2119 };2119 };
2120 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);2120 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
21212121
2122 const result: MCValue = result: {2122 const result: MCValue = result: {
2123 if (!payload_ty.hasRuntimeBits()) break :result operand;2123 if (!payload_ty.hasRuntimeBits()) break :result operand;
...@@ -2147,10 +2147,10 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {...@@ -2147,10 +2147,10 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
21472147
2148 const operand = try self.resolveInst(ty_op.operand);2148 const operand = try self.resolveInst(ty_op.operand);
2149 const operand_lock: ?RegisterLock = switch (operand) {2149 const operand_lock: ?RegisterLock = switch (operand) {
2150 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2150 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2151 else => null,2151 else => null,
2152 };2152 };
2153 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);2153 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
21542154
2155 const abi_align = err_union_ty.abiAlignment(self.target.*);2155 const abi_align = err_union_ty.abiAlignment(self.target.*);
2156 const err_ty = err_union_ty.errorUnionSet();2156 const err_ty = err_union_ty.errorUnionSet();
...@@ -2219,10 +2219,10 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {...@@ -2219,10 +2219,10 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
2219 const optional_ty = self.air.typeOfIndex(inst);2219 const optional_ty = self.air.typeOfIndex(inst);
2220 const operand = try self.resolveInst(ty_op.operand);2220 const operand = try self.resolveInst(ty_op.operand);
2221 const operand_lock: ?RegisterLock = switch (operand) {2221 const operand_lock: ?RegisterLock = switch (operand) {
2222 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2222 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2223 else => null,2223 else => null,
2224 };2224 };
2225 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);2225 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
22262226
2227 if (optional_ty.isPtrLikeOptional()) {2227 if (optional_ty.isPtrLikeOptional()) {
2228 // TODO should we check if we can reuse the operand?2228 // 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 {...@@ -2356,10 +2356,10 @@ fn genSliceElemPtr(self: *Self, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {
2356 const slice_ty = self.air.typeOf(lhs);2356 const slice_ty = self.air.typeOf(lhs);
2357 const slice_mcv = try self.resolveInst(lhs);2357 const slice_mcv = try self.resolveInst(lhs);
2358 const slice_mcv_lock: ?RegisterLock = switch (slice_mcv) {2358 const slice_mcv_lock: ?RegisterLock = switch (slice_mcv) {
2359 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2359 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2360 else => null,2360 else => null,
2361 };2361 };
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
2364 const elem_ty = slice_ty.childType();2364 const elem_ty = slice_ty.childType();
2365 const elem_size = elem_ty.abiSize(self.target.*);2365 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 {...@@ -2369,14 +2369,14 @@ fn genSliceElemPtr(self: *Self, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {
2369 const index_ty = self.air.typeOf(rhs);2369 const index_ty = self.air.typeOf(rhs);
2370 const index_mcv = try self.resolveInst(rhs);2370 const index_mcv = try self.resolveInst(rhs);
2371 const index_mcv_lock: ?RegisterLock = switch (index_mcv) {2371 const index_mcv_lock: ?RegisterLock = switch (index_mcv) {
2372 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2372 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2373 else => null,2373 else => null,
2374 };2374 };
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
2377 const offset_reg = try self.elemOffset(index_ty, index_mcv, elem_size);2377 const offset_reg = try self.elemOffset(index_ty, index_mcv, elem_size);
2378 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);2378 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2379 defer self.register_manager.unfreezeReg(offset_reg_lock);2379 defer self.register_manager.unlockReg(offset_reg_lock);
23802380
2381 const addr_reg = try self.register_manager.allocReg(null);2381 const addr_reg = try self.register_manager.allocReg(null);
2382 switch (slice_mcv) {2382 switch (slice_mcv) {
...@@ -2433,10 +2433,10 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {...@@ -2433,10 +2433,10 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
2433 const array_ty = self.air.typeOf(bin_op.lhs);2433 const array_ty = self.air.typeOf(bin_op.lhs);
2434 const array = try self.resolveInst(bin_op.lhs);2434 const array = try self.resolveInst(bin_op.lhs);
2435 const array_lock: ?RegisterLock = switch (array) {2435 const array_lock: ?RegisterLock = switch (array) {
2436 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2436 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2437 else => null,2437 else => null,
2438 };2438 };
2439 defer if (array_lock) |reg| self.register_manager.unfreezeReg(reg);2439 defer if (array_lock) |reg| self.register_manager.unlockReg(reg);
24402440
2441 const elem_ty = array_ty.childType();2441 const elem_ty = array_ty.childType();
2442 const elem_abi_size = elem_ty.abiSize(self.target.*);2442 const elem_abi_size = elem_ty.abiSize(self.target.*);
...@@ -2444,14 +2444,14 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {...@@ -2444,14 +2444,14 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
2444 const index_ty = self.air.typeOf(bin_op.rhs);2444 const index_ty = self.air.typeOf(bin_op.rhs);
2445 const index = try self.resolveInst(bin_op.rhs);2445 const index = try self.resolveInst(bin_op.rhs);
2446 const index_lock: ?RegisterLock = switch (index) {2446 const index_lock: ?RegisterLock = switch (index) {
2447 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2447 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2448 else => null,2448 else => null,
2449 };2449 };
2450 defer if (index_lock) |reg| self.register_manager.unfreezeReg(reg);2450 defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
24512451
2452 const offset_reg = try self.elemOffset(index_ty, index, elem_abi_size);2452 const offset_reg = try self.elemOffset(index_ty, index, elem_abi_size);
2453 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);2453 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2454 defer self.register_manager.unfreezeReg(offset_reg_lock);2454 defer self.register_manager.unlockReg(offset_reg_lock);
24552455
2456 const addr_reg = try self.register_manager.allocReg(null);2456 const addr_reg = try self.register_manager.allocReg(null);
2457 switch (array) {2457 switch (array) {
...@@ -2512,24 +2512,24 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {...@@ -2512,24 +2512,24 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
2512 const ptr_ty = self.air.typeOf(bin_op.lhs);2512 const ptr_ty = self.air.typeOf(bin_op.lhs);
2513 const ptr = try self.resolveInst(bin_op.lhs);2513 const ptr = try self.resolveInst(bin_op.lhs);
2514 const ptr_lock: ?RegisterLock = switch (ptr) {2514 const ptr_lock: ?RegisterLock = switch (ptr) {
2515 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2515 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2516 else => null,2516 else => null,
2517 };2517 };
2518 defer if (ptr_lock) |reg| self.register_manager.unfreezeReg(reg);2518 defer if (ptr_lock) |reg| self.register_manager.unlockReg(reg);
25192519
2520 const elem_ty = ptr_ty.elemType2();2520 const elem_ty = ptr_ty.elemType2();
2521 const elem_abi_size = elem_ty.abiSize(self.target.*);2521 const elem_abi_size = elem_ty.abiSize(self.target.*);
2522 const index_ty = self.air.typeOf(bin_op.rhs);2522 const index_ty = self.air.typeOf(bin_op.rhs);
2523 const index = try self.resolveInst(bin_op.rhs);2523 const index = try self.resolveInst(bin_op.rhs);
2524 const index_lock: ?RegisterLock = switch (index) {2524 const index_lock: ?RegisterLock = switch (index) {
2525 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2525 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2526 else => null,2526 else => null,
2527 };2527 };
2528 defer if (index_lock) |reg| self.register_manager.unfreezeReg(reg);2528 defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
25292529
2530 const offset_reg = try self.elemOffset(index_ty, index, elem_abi_size);2530 const offset_reg = try self.elemOffset(index_ty, index, elem_abi_size);
2531 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);2531 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2532 defer self.register_manager.unfreezeReg(offset_reg_lock);2532 defer self.register_manager.unlockReg(offset_reg_lock);
25332533
2534 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ptr_ty, ptr);2534 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ptr_ty, ptr);
2535 try self.genBinMathOpMir(.add, ptr_ty, dst_mcv, .{ .register = offset_reg });2535 try self.genBinMathOpMir(.add, ptr_ty, dst_mcv, .{ .register = offset_reg });
...@@ -2559,24 +2559,24 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {...@@ -2559,24 +2559,24 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
2559 const ptr_ty = self.air.typeOf(extra.lhs);2559 const ptr_ty = self.air.typeOf(extra.lhs);
2560 const ptr = try self.resolveInst(extra.lhs);2560 const ptr = try self.resolveInst(extra.lhs);
2561 const ptr_lock: ?RegisterLock = switch (ptr) {2561 const ptr_lock: ?RegisterLock = switch (ptr) {
2562 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2562 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2563 else => null,2563 else => null,
2564 };2564 };
2565 defer if (ptr_lock) |reg| self.register_manager.unfreezeReg(reg);2565 defer if (ptr_lock) |reg| self.register_manager.unlockReg(reg);
25662566
2567 const elem_ty = ptr_ty.elemType2();2567 const elem_ty = ptr_ty.elemType2();
2568 const elem_abi_size = elem_ty.abiSize(self.target.*);2568 const elem_abi_size = elem_ty.abiSize(self.target.*);
2569 const index_ty = self.air.typeOf(extra.rhs);2569 const index_ty = self.air.typeOf(extra.rhs);
2570 const index = try self.resolveInst(extra.rhs);2570 const index = try self.resolveInst(extra.rhs);
2571 const index_lock: ?RegisterLock = switch (index) {2571 const index_lock: ?RegisterLock = switch (index) {
2572 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2572 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2573 else => null,2573 else => null,
2574 };2574 };
2575 defer if (index_lock) |reg| self.register_manager.unfreezeReg(reg);2575 defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
25762576
2577 const offset_reg = try self.elemOffset(index_ty, index, elem_abi_size);2577 const offset_reg = try self.elemOffset(index_ty, index, elem_abi_size);
2578 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);2578 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
2579 defer self.register_manager.unfreezeReg(offset_reg_lock);2579 defer self.register_manager.unlockReg(offset_reg_lock);
25802580
2581 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ptr_ty, ptr);2581 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ptr_ty, ptr);
2582 try self.genBinMathOpMir(.add, ptr_ty, dst_mcv, .{ .register = offset_reg });2582 try self.genBinMathOpMir(.add, ptr_ty, dst_mcv, .{ .register = offset_reg });
...@@ -2598,17 +2598,17 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {...@@ -2598,17 +2598,17 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
25982598
2599 const ptr = try self.resolveInst(bin_op.lhs);2599 const ptr = try self.resolveInst(bin_op.lhs);
2600 const ptr_lock: ?RegisterLock = switch (ptr) {2600 const ptr_lock: ?RegisterLock = switch (ptr) {
2601 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2601 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2602 else => null,2602 else => null,
2603 };2603 };
2604 defer if (ptr_lock) |reg| self.register_manager.unfreezeReg(reg);2604 defer if (ptr_lock) |reg| self.register_manager.unlockReg(reg);
26052605
2606 const tag = try self.resolveInst(bin_op.rhs);2606 const tag = try self.resolveInst(bin_op.rhs);
2607 const tag_lock: ?RegisterLock = switch (tag) {2607 const tag_lock: ?RegisterLock = switch (tag) {
2608 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2608 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2609 else => null,2609 else => null,
2610 };2610 };
2611 defer if (tag_lock) |reg| self.register_manager.unfreezeReg(reg);2611 defer if (tag_lock) |reg| self.register_manager.unlockReg(reg);
26122612
2613 const adjusted_ptr: MCValue = if (layout.payload_size > 0 and layout.tag_align < layout.payload_align) blk: {2613 const adjusted_ptr: MCValue = if (layout.payload_size > 0 and layout.tag_align < layout.payload_align) blk: {
2614 // TODO reusing the operand2614 // TODO reusing the operand
...@@ -2639,10 +2639,10 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {...@@ -2639,10 +2639,10 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
2639 // TODO reusing the operand2639 // TODO reusing the operand
2640 const operand = try self.resolveInst(ty_op.operand);2640 const operand = try self.resolveInst(ty_op.operand);
2641 const operand_lock: ?RegisterLock = switch (operand) {2641 const operand_lock: ?RegisterLock = switch (operand) {
2642 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),2642 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
2643 else => null,2643 else => null,
2644 };2644 };
2645 defer if (operand_lock) |reg| self.register_manager.unfreezeReg(reg);2645 defer if (operand_lock) |reg| self.register_manager.unlockReg(reg);
26462646
2647 const tag_abi_size = tag_ty.abiSize(self.target.*);2647 const tag_abi_size = tag_ty.abiSize(self.target.*);
2648 const dst_mcv: MCValue = blk: {2648 const dst_mcv: MCValue = blk: {
...@@ -2789,8 +2789,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo...@@ -2789,8 +2789,8 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
2789 try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off });2789 try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off });
2790 },2790 },
2791 .register => |reg| {2791 .register => |reg| {
2792 const reg_lock = self.register_manager.freezeReg(reg);2792 const reg_lock = self.register_manager.lockReg(reg);
2793 defer if (reg_lock) |locked_reg| self.register_manager.unfreezeReg(locked_reg);2793 defer if (reg_lock) |locked_reg| self.register_manager.unlockReg(locked_reg);
27942794
2795 switch (dst_mcv) {2795 switch (dst_mcv) {
2796 .dead => unreachable,2796 .dead => unreachable,
...@@ -2915,8 +2915,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type...@@ -2915,8 +2915,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
2915 try self.genSetStack(value_ty, off, value, .{});2915 try self.genSetStack(value_ty, off, value, .{});
2916 },2916 },
2917 .register => |reg| {2917 .register => |reg| {
2918 const reg_lock = self.register_manager.freezeReg(reg);2918 const reg_lock = self.register_manager.lockReg(reg);
2919 defer if (reg_lock) |locked_reg| self.register_manager.unfreezeReg(locked_reg);2919 defer if (reg_lock) |locked_reg| self.register_manager.unlockReg(locked_reg);
29202920
2921 switch (value) {2921 switch (value) {
2922 .none => unreachable,2922 .none => unreachable,
...@@ -3007,14 +3007,14 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type...@@ -3007,14 +3007,14 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
3007 .memory,3007 .memory,
3008 => {3008 => {
3009 const value_lock: ?RegisterLock = switch (value) {3009 const value_lock: ?RegisterLock = switch (value) {
3010 .register => |reg| self.register_manager.freezeReg(reg),3010 .register => |reg| self.register_manager.lockReg(reg),
3011 else => null,3011 else => null,
3012 };3012 };
3013 defer if (value_lock) |reg| self.register_manager.unfreezeReg(reg);3013 defer if (value_lock) |reg| self.register_manager.unlockReg(reg);
30143014
3015 const addr_reg = try self.register_manager.allocReg(null);3015 const addr_reg = try self.register_manager.allocReg(null);
3016 const addr_reg_lock = self.register_manager.freezeRegAssumeUnused(addr_reg);3016 const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
3017 defer self.register_manager.unfreezeReg(addr_reg_lock);3017 defer self.register_manager.unlockReg(addr_reg_lock);
30183018
3019 try self.loadMemPtrIntoRegister(addr_reg, ptr_ty, ptr);3019 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...@@ -3085,8 +3085,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
3085 => {3085 => {
3086 if (abi_size <= 8) {3086 if (abi_size <= 8) {
3087 const tmp_reg = try self.register_manager.allocReg(null);3087 const tmp_reg = try self.register_manager.allocReg(null);
3088 const tmp_reg_lock = self.register_manager.freezeRegAssumeUnused(tmp_reg);3088 const tmp_reg_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
3089 defer self.register_manager.unfreezeReg(tmp_reg_lock);3089 defer self.register_manager.unlockReg(tmp_reg_lock);
30903090
3091 try self.loadMemPtrIntoRegister(tmp_reg, value_ty, value);3091 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...@@ -3176,8 +3176,8 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
3176 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{3176 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{
3177 .immediate = struct_field_offset,3177 .immediate = struct_field_offset,
3178 });3178 });
3179 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);3179 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
3180 defer self.register_manager.unfreezeReg(offset_reg_lock);3180 defer self.register_manager.unlockReg(offset_reg_lock);
31813181
3182 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ptr_ty, mcv);3182 const dst_mcv = try self.copyToRegisterWithInstTracking(inst, ptr_ty, mcv);
3183 try self.genBinMathOpMir(.add, ptr_ty, dst_mcv, .{ .register = offset_reg });3183 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...@@ -3188,14 +3188,14 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
3188 break :result MCValue{ .ptr_stack_offset = ptr_stack_offset };3188 break :result MCValue{ .ptr_stack_offset = ptr_stack_offset };
3189 },3189 },
3190 .register => |reg| {3190 .register => |reg| {
3191 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);3191 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
3192 defer self.register_manager.unfreezeReg(reg_lock);3192 defer self.register_manager.unlockReg(reg_lock);
31933193
3194 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{3194 const offset_reg = try self.copyToTmpRegister(ptr_ty, .{
3195 .immediate = struct_field_offset,3195 .immediate = struct_field_offset,
3196 });3196 });
3197 const offset_reg_lock = self.register_manager.freezeRegAssumeUnused(offset_reg);3197 const offset_reg_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
3198 defer self.register_manager.unfreezeReg(offset_reg_lock);3198 defer self.register_manager.unlockReg(offset_reg_lock);
31993199
3200 const can_reuse_operand = self.reuseOperand(inst, operand, 0, mcv);3200 const can_reuse_operand = self.reuseOperand(inst, operand, 0, mcv);
3201 const result_reg = blk: {3201 const result_reg = blk: {
...@@ -3207,8 +3207,8 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde...@@ -3207,8 +3207,8 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
3207 break :blk result_reg;3207 break :blk result_reg;
3208 }3208 }
3209 };3209 };
3210 const result_reg_lock = self.register_manager.freezeReg(result_reg);3210 const result_reg_lock = self.register_manager.lockReg(result_reg);
3211 defer if (result_reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);3211 defer if (result_reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
32123212
3213 try self.genBinMathOpMir(.add, ptr_ty, .{ .register = result_reg }, .{ .register = offset_reg });3213 try self.genBinMathOpMir(.add, ptr_ty, .{ .register = result_reg }, .{ .register = offset_reg });
3214 break :result MCValue{ .register = result_reg };3214 break :result MCValue{ .register = result_reg };
...@@ -3236,8 +3236,8 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {...@@ -3236,8 +3236,8 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
3236 break :result MCValue{ .stack_offset = stack_offset };3236 break :result MCValue{ .stack_offset = stack_offset };
3237 },3237 },
3238 .register => |reg| {3238 .register => |reg| {
3239 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);3239 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
3240 defer self.register_manager.unfreezeReg(reg_lock);3240 defer self.register_manager.unlockReg(reg_lock);
32413241
3242 const dst_mcv = blk: {3242 const dst_mcv = blk: {
3243 if (self.reuseOperand(inst, operand, 0, mcv)) {3243 if (self.reuseOperand(inst, operand, 0, mcv)) {
...@@ -3250,10 +3250,10 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {...@@ -3250,10 +3250,10 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
3250 }3250 }
3251 };3251 };
3252 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {3252 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {
3253 .register => |reg| self.register_manager.freezeReg(reg),3253 .register => |reg| self.register_manager.lockReg(reg),
3254 else => null,3254 else => null,
3255 };3255 };
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
3258 // Shift by struct_field_offset.3258 // Shift by struct_field_offset.
3259 const shift = @intCast(u8, struct_field_offset * @sizeOf(usize));3259 const shift = @intCast(u8, struct_field_offset * @sizeOf(usize));
...@@ -3295,8 +3295,8 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {...@@ -3295,8 +3295,8 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
3295 },3295 },
3296 1 => {3296 1 => {
3297 // Get overflow bit.3297 // Get overflow bit.
3298 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);3298 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
3299 defer self.register_manager.unfreezeReg(reg_lock);3299 defer self.register_manager.unlockReg(reg_lock);
33003300
3301 const dst_reg = try self.register_manager.allocReg(inst);3301 const dst_reg = try self.register_manager.allocReg(inst);
3302 const flags: u2 = switch (mcv) {3302 const flags: u2 = switch (mcv) {
...@@ -3339,17 +3339,17 @@ fn genBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs:...@@ -3339,17 +3339,17 @@ fn genBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs:
33393339
3340 const lhs = try self.resolveInst(op_lhs);3340 const lhs = try self.resolveInst(op_lhs);
3341 const lhs_lock: ?RegisterLock = switch (lhs) {3341 const lhs_lock: ?RegisterLock = switch (lhs) {
3342 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),3342 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
3343 else => null,3343 else => null,
3344 };3344 };
3345 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);3345 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
33463346
3347 const rhs = try self.resolveInst(op_rhs);3347 const rhs = try self.resolveInst(op_rhs);
3348 const rhs_lock: ?RegisterLock = switch (rhs) {3348 const rhs_lock: ?RegisterLock = switch (rhs) {
3349 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),3349 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
3350 else => null,3350 else => null,
3351 };3351 };
3352 defer if (rhs_lock) |reg| self.register_manager.unfreezeReg(reg);3352 defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
33533353
3354 var flipped: bool = false;3354 var flipped: bool = false;
3355 const dst_mcv = blk: {3355 const dst_mcv = blk: {
...@@ -3363,10 +3363,10 @@ fn genBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs:...@@ -3363,10 +3363,10 @@ fn genBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs:
3363 break :blk try self.copyToRegisterWithInstTracking(inst, dst_ty, lhs);3363 break :blk try self.copyToRegisterWithInstTracking(inst, dst_ty, lhs);
3364 };3364 };
3365 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {3365 const dst_mcv_lock: ?RegisterLock = switch (dst_mcv) {
3366 .register => |reg| self.register_manager.freezeReg(reg),3366 .register => |reg| self.register_manager.lockReg(reg),
3367 else => null,3367 else => null,
3368 };3368 };
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
3371 const src_mcv = blk: {3371 const src_mcv = blk: {
3372 const mcv = if (flipped) lhs else rhs;3372 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:...@@ -3374,10 +3374,10 @@ fn genBinMathOp(self: *Self, inst: Air.Inst.Index, op_lhs: Air.Inst.Ref, op_rhs:
3374 break :blk MCValue{ .register = try self.copyToTmpRegister(dst_ty, mcv) };3374 break :blk MCValue{ .register = try self.copyToTmpRegister(dst_ty, mcv) };
3375 };3375 };
3376 const src_mcv_lock: ?RegisterLock = switch (src_mcv) {3376 const src_mcv_lock: ?RegisterLock = switch (src_mcv) {
3377 .register => |reg| self.register_manager.freezeReg(reg),3377 .register => |reg| self.register_manager.lockReg(reg),
3378 else => null,3378 else => null,
3379 };3379 };
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
3382 const tag = self.air.instructions.items(.tag)[inst];3382 const tag = self.air.instructions.items(.tag)[inst];
3383 switch (tag) {3383 switch (tag) {
...@@ -3408,8 +3408,8 @@ fn genBinMathOpMir(self: *Self, mir_tag: Mir.Inst.Tag, dst_ty: Type, dst_mcv: MC...@@ -3408,8 +3408,8 @@ fn genBinMathOpMir(self: *Self, mir_tag: Mir.Inst.Tag, dst_ty: Type, dst_mcv: MC
3408 .register_overflow_unsigned => unreachable,3408 .register_overflow_unsigned => unreachable,
3409 .register_overflow_signed => unreachable,3409 .register_overflow_signed => unreachable,
3410 .ptr_stack_offset => {3410 .ptr_stack_offset => {
3411 const dst_reg_lock = self.register_manager.freezeReg(dst_reg);3411 const dst_reg_lock = self.register_manager.lockReg(dst_reg);
3412 defer if (dst_reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);3412 defer if (dst_reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
34133413
3414 const reg = try self.copyToTmpRegister(dst_ty, src_mcv);3414 const reg = try self.copyToTmpRegister(dst_ty, src_mcv);
3415 return self.genBinMathOpMir(mir_tag, dst_ty, dst_mcv, .{ .register = reg });3415 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...@@ -3440,8 +3440,8 @@ fn genBinMathOpMir(self: *Self, mir_tag: Mir.Inst.Tag, dst_ty: Type, dst_mcv: MC
3440 .compare_flags_unsigned,3440 .compare_flags_unsigned,
3441 => {3441 => {
3442 assert(abi_size <= 8);3442 assert(abi_size <= 8);
3443 const dst_reg_lock = self.register_manager.freezeReg(dst_reg);3443 const dst_reg_lock = self.register_manager.lockReg(dst_reg);
3444 defer if (dst_reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);3444 defer if (dst_reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
34453445
3446 const reg = try self.copyToTmpRegister(dst_ty, src_mcv);3446 const reg = try self.copyToTmpRegister(dst_ty, src_mcv);
3447 return self.genBinMathOpMir(mir_tag, dst_ty, dst_mcv, .{ .register = reg });3447 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....@@ -3791,13 +3791,13 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
37913791
3792 try self.register_manager.getReg(.rdi, null);3792 try self.register_manager.getReg(.rdi, null);
3793 try self.genSetReg(Type.usize, .rdi, .{ .ptr_stack_offset = stack_offset });3793 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
3796 info.return_value.stack_offset = stack_offset;3796 info.return_value.stack_offset = stack_offset;
37973797
3798 break :blk rdi_lock;3798 break :blk rdi_lock;
3799 } else null;3799 } 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
3802 for (args) |arg, arg_i| {3802 for (args) |arg, arg_i| {
3803 const mc_arg = info.args[arg_i];3803 const mc_arg = info.args[arg_i];
...@@ -4017,8 +4017,8 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {...@@ -4017,8 +4017,8 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {
4017 switch (self.ret_mcv) {4017 switch (self.ret_mcv) {
4018 .stack_offset => {4018 .stack_offset => {
4019 const reg = try self.copyToTmpRegister(Type.usize, self.ret_mcv);4019 const reg = try self.copyToTmpRegister(Type.usize, self.ret_mcv);
4020 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);4020 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
4021 defer self.register_manager.unfreezeReg(reg_lock);4021 defer self.register_manager.unlockReg(reg_lock);
40224022
4023 try self.genSetStack(ret_ty, 0, operand, .{4023 try self.genSetStack(ret_ty, 0, operand, .{
4024 .source_stack_base = .rbp,4024 .source_stack_base = .rbp,
...@@ -4051,8 +4051,8 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {...@@ -4051,8 +4051,8 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
4051 switch (self.ret_mcv) {4051 switch (self.ret_mcv) {
4052 .stack_offset => {4052 .stack_offset => {
4053 const reg = try self.copyToTmpRegister(Type.usize, self.ret_mcv);4053 const reg = try self.copyToTmpRegister(Type.usize, self.ret_mcv);
4054 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);4054 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
4055 defer self.register_manager.unfreezeReg(reg_lock);4055 defer self.register_manager.unlockReg(reg_lock);
40564056
4057 try self.genInlineMemcpy(.{ .stack_offset = 0 }, ptr, .{ .immediate = elem_ty.abiSize(self.target.*) }, .{4057 try self.genInlineMemcpy(.{ .stack_offset = 0 }, ptr, .{ .immediate = elem_ty.abiSize(self.target.*) }, .{
4058 .source_stack_base = .rbp,4058 .source_stack_base = .rbp,
...@@ -4104,14 +4104,14 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {...@@ -4104,14 +4104,14 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
4104 // TODO look into reusing the operand4104 // TODO look into reusing the operand
4105 const lhs = try self.resolveInst(bin_op.lhs);4105 const lhs = try self.resolveInst(bin_op.lhs);
4106 const lhs_lock: ?RegisterLock = switch (lhs) {4106 const lhs_lock: ?RegisterLock = switch (lhs) {
4107 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),4107 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
4108 else => null,4108 else => null,
4109 };4109 };
4110 defer if (lhs_lock) |reg| self.register_manager.unfreezeReg(reg);4110 defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
41114111
4112 const dst_reg = try self.copyToTmpRegister(ty, lhs);4112 const dst_reg = try self.copyToTmpRegister(ty, lhs);
4113 const dst_reg_lock = self.register_manager.freezeRegAssumeUnused(dst_reg);4113 const dst_reg_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
4114 defer self.register_manager.unfreezeReg(dst_reg_lock);4114 defer self.register_manager.unlockReg(dst_reg_lock);
41154115
4116 const dst_mcv = MCValue{ .register = dst_reg };4116 const dst_mcv = MCValue{ .register = dst_reg };
41174117
...@@ -4576,10 +4576,10 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {...@@ -4576,10 +4576,10 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
4576 const operand_ptr = try self.resolveInst(un_op);4576 const operand_ptr = try self.resolveInst(un_op);
45774577
4578 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {4578 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {
4579 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),4579 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
4580 else => null,4580 else => null,
4581 };4581 };
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
4584 const operand: MCValue = blk: {4584 const operand: MCValue = blk: {
4585 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {4585 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
...@@ -4612,10 +4612,10 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {...@@ -4612,10 +4612,10 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
4612 const operand_ptr = try self.resolveInst(un_op);4612 const operand_ptr = try self.resolveInst(un_op);
46134613
4614 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {4614 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {
4615 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),4615 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
4616 else => null,4616 else => null,
4617 };4617 };
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
4620 const operand: MCValue = blk: {4620 const operand: MCValue = blk: {
4621 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {4621 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
...@@ -4648,10 +4648,10 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {...@@ -4648,10 +4648,10 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
4648 const operand_ptr = try self.resolveInst(un_op);4648 const operand_ptr = try self.resolveInst(un_op);
46494649
4650 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {4650 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {
4651 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),4651 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
4652 else => null,4652 else => null,
4653 };4653 };
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
4656 const operand: MCValue = blk: {4656 const operand: MCValue = blk: {
4657 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {4657 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
...@@ -4684,10 +4684,10 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {...@@ -4684,10 +4684,10 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
4684 const operand_ptr = try self.resolveInst(un_op);4684 const operand_ptr = try self.resolveInst(un_op);
46854685
4686 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {4686 const operand_ptr_lock: ?RegisterLock = switch (operand_ptr) {
4687 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),4687 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
4688 else => null,4688 else => null,
4689 };4689 };
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
4692 const operand: MCValue = blk: {4692 const operand: MCValue = blk: {
4693 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {4693 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
...@@ -4756,8 +4756,8 @@ fn genCondSwitchMir(self: *Self, ty: Type, condition: MCValue, case: MCValue) !u...@@ -4756,8 +4756,8 @@ fn genCondSwitchMir(self: *Self, ty: Type, condition: MCValue, case: MCValue) !u
4756 .register => |cond_reg| {4756 .register => |cond_reg| {
4757 try self.spillCompareFlagsIfOccupied();4757 try self.spillCompareFlagsIfOccupied();
47584758
4759 const cond_reg_lock = self.register_manager.freezeReg(cond_reg);4759 const cond_reg_lock = self.register_manager.lockReg(cond_reg);
4760 defer if (cond_reg_lock) |reg| self.register_manager.unfreezeReg(reg);4760 defer if (cond_reg_lock) |reg| self.register_manager.unlockReg(reg);
47614761
4762 switch (case) {4762 switch (case) {
4763 .none => unreachable,4763 .none => unreachable,
...@@ -4816,8 +4816,8 @@ fn genCondSwitchMir(self: *Self, ty: Type, condition: MCValue, case: MCValue) !u...@@ -4816,8 +4816,8 @@ fn genCondSwitchMir(self: *Self, ty: Type, condition: MCValue, case: MCValue) !u
48164816
4817 if (abi_size <= 8) {4817 if (abi_size <= 8) {
4818 const reg = try self.copyToTmpRegister(ty, condition);4818 const reg = try self.copyToTmpRegister(ty, condition);
4819 const reg_lock = self.register_manager.freezeRegAssumeUnused(reg);4819 const reg_lock = self.register_manager.lockRegAssumeUnused(reg);
4820 defer self.register_manager.unfreezeReg(reg_lock);4820 defer self.register_manager.unlockReg(reg_lock);
4821 return self.genCondSwitchMir(ty, .{ .register = reg }, case);4821 return self.genCondSwitchMir(ty, .{ .register = reg }, case);
4822 }4822 }
48234823
...@@ -5304,8 +5304,8 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: i32, mcv: MCValue, opts: Inl...@@ -5304,8 +5304,8 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: i32, mcv: MCValue, opts: Inl
5304 .register_overflow_unsigned,5304 .register_overflow_unsigned,
5305 .register_overflow_signed,5305 .register_overflow_signed,
5306 => |reg| {5306 => |reg| {
5307 const reg_lock = self.register_manager.freezeReg(reg);5307 const reg_lock = self.register_manager.lockReg(reg);
5308 defer if (reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);5308 defer if (reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
53095309
5310 const wrapped_ty = ty.structFieldType(0);5310 const wrapped_ty = ty.structFieldType(0);
5311 try self.genSetStack(wrapped_ty, stack_offset, .{ .register = reg }, .{});5311 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...@@ -5406,8 +5406,8 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: i32, mcv: MCValue, opts: Inl
54065406
5407 const base_reg = opts.dest_stack_base orelse .rbp;5407 const base_reg = opts.dest_stack_base orelse .rbp;
5408 if (!math.isPowerOfTwo(abi_size)) {5408 if (!math.isPowerOfTwo(abi_size)) {
5409 const reg_lock = self.register_manager.freezeReg(reg);5409 const reg_lock = self.register_manager.lockReg(reg);
5410 defer if (reg_lock) |reg_locked| self.register_manager.unfreezeReg(reg_locked);5410 defer if (reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
54115411
5412 const tmp_reg = try self.copyToTmpRegister(ty, mcv);5412 const tmp_reg = try self.copyToTmpRegister(ty, mcv);
54135413
...@@ -5500,22 +5500,22 @@ fn genInlineMemcpy(...@@ -5500,22 +5500,22 @@ fn genInlineMemcpy(
5500 try self.register_manager.getReg(.rcx, null);5500 try self.register_manager.getReg(.rcx, null);
55015501
5502 var reg_locks: [2]RegisterLock = undefined;5502 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);
5504 defer for (reg_locks) |reg| {5504 defer for (reg_locks) |reg| {
5505 self.register_manager.unfreezeReg(reg);5505 self.register_manager.unlockReg(reg);
5506 };5506 };
55075507
5508 const ssbase_lock: ?RegisterLock = if (opts.source_stack_base) |reg|5508 const ssbase_lock: ?RegisterLock = if (opts.source_stack_base) |reg|
5509 self.register_manager.freezeReg(reg)5509 self.register_manager.lockReg(reg)
5510 else5510 else
5511 null;5511 null;
5512 defer if (ssbase_lock) |reg| self.register_manager.unfreezeReg(reg);5512 defer if (ssbase_lock) |reg| self.register_manager.unlockReg(reg);
55135513
5514 const dsbase_lock: ?RegisterLock = if (opts.dest_stack_base) |reg|5514 const dsbase_lock: ?RegisterLock = if (opts.dest_stack_base) |reg|
5515 self.register_manager.freezeReg(reg)5515 self.register_manager.lockReg(reg)
5516 else5516 else
5517 null;5517 null;
5518 defer if (dsbase_lock) |reg| self.register_manager.unfreezeReg(reg);5518 defer if (dsbase_lock) |reg| self.register_manager.unlockReg(reg);
55195519
5520 const dst_addr_reg = try self.register_manager.allocReg(null);5520 const dst_addr_reg = try self.register_manager.allocReg(null);
5521 switch (dst_ptr) {5521 switch (dst_ptr) {
...@@ -5549,8 +5549,8 @@ fn genInlineMemcpy(...@@ -5549,8 +5549,8 @@ fn genInlineMemcpy(
5549 return self.fail("TODO implement memcpy for setting stack when dest is {}", .{dst_ptr});5549 return self.fail("TODO implement memcpy for setting stack when dest is {}", .{dst_ptr});
5550 },5550 },
5551 }5551 }
5552 const dst_addr_reg_lock = self.register_manager.freezeRegAssumeUnused(dst_addr_reg);5552 const dst_addr_reg_lock = self.register_manager.lockRegAssumeUnused(dst_addr_reg);
5553 defer self.register_manager.unfreezeReg(dst_addr_reg_lock);5553 defer self.register_manager.unlockReg(dst_addr_reg_lock);
55545554
5555 const src_addr_reg = try self.register_manager.allocReg(null);5555 const src_addr_reg = try self.register_manager.allocReg(null);
5556 switch (src_ptr) {5556 switch (src_ptr) {
...@@ -5584,8 +5584,8 @@ fn genInlineMemcpy(...@@ -5584,8 +5584,8 @@ fn genInlineMemcpy(
5584 return self.fail("TODO implement memcpy for setting stack when src is {}", .{src_ptr});5584 return self.fail("TODO implement memcpy for setting stack when src is {}", .{src_ptr});
5585 },5585 },
5586 }5586 }
5587 const src_addr_reg_lock = self.register_manager.freezeRegAssumeUnused(src_addr_reg);5587 const src_addr_reg_lock = self.register_manager.lockRegAssumeUnused(src_addr_reg);
5588 defer self.register_manager.unfreezeReg(src_addr_reg_lock);5588 defer self.register_manager.unlockReg(src_addr_reg_lock);
55895589
5590 const regs = try self.register_manager.allocRegs(2, .{ null, null });5590 const regs = try self.register_manager.allocRegs(2, .{ null, null });
5591 const count_reg = regs[0].to64();5591 const count_reg = regs[0].to64();
...@@ -5695,8 +5695,8 @@ fn genInlineMemset(...@@ -5695,8 +5695,8 @@ fn genInlineMemset(
5695 opts: InlineMemcpyOpts,5695 opts: InlineMemcpyOpts,
5696) InnerError!void {5696) InnerError!void {
5697 try self.register_manager.getReg(.rax, null);5697 try self.register_manager.getReg(.rax, null);
5698 const rax_lock = self.register_manager.freezeRegAssumeUnused(.rax);5698 const rax_lock = self.register_manager.lockRegAssumeUnused(.rax);
5699 defer self.register_manager.unfreezeReg(rax_lock);5699 defer self.register_manager.unlockReg(rax_lock);
57005700
5701 const addr_reg = try self.register_manager.allocReg(null);5701 const addr_reg = try self.register_manager.allocReg(null);
5702 switch (dst_ptr) {5702 switch (dst_ptr) {
...@@ -5730,8 +5730,8 @@ fn genInlineMemset(...@@ -5730,8 +5730,8 @@ fn genInlineMemset(
5730 return self.fail("TODO implement memcpy for setting stack when dest is {}", .{dst_ptr});5730 return self.fail("TODO implement memcpy for setting stack when dest is {}", .{dst_ptr});
5731 },5731 },
5732 }5732 }
5733 const addr_reg_lock = self.register_manager.freezeRegAssumeUnused(addr_reg);5733 const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
5734 defer self.register_manager.unfreezeReg(addr_reg_lock);5734 defer self.register_manager.unlockReg(addr_reg_lock);
57355735
5736 try self.genSetReg(Type.usize, .rax, len);5736 try self.genSetReg(Type.usize, .rax, len);
5737 try self.genBinMathOpMir(.sub, Type.usize, .{ .register = .rax }, .{ .immediate = 1 });5737 try self.genBinMathOpMir(.sub, Type.usize, .{ .register = .rax }, .{ .immediate = 1 });
...@@ -6171,24 +6171,24 @@ fn airMemset(self: *Self, inst: Air.Inst.Index) !void {...@@ -6171,24 +6171,24 @@ fn airMemset(self: *Self, inst: Air.Inst.Index) !void {
61716171
6172 const dst_ptr = try self.resolveInst(pl_op.operand);6172 const dst_ptr = try self.resolveInst(pl_op.operand);
6173 const dst_ptr_lock: ?RegisterLock = switch (dst_ptr) {6173 const dst_ptr_lock: ?RegisterLock = switch (dst_ptr) {
6174 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),6174 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
6175 else => null,6175 else => null,
6176 };6176 };
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
6179 const src_val = try self.resolveInst(extra.lhs);6179 const src_val = try self.resolveInst(extra.lhs);
6180 const src_val_lock: ?RegisterLock = switch (src_val) {6180 const src_val_lock: ?RegisterLock = switch (src_val) {
6181 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),6181 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
6182 else => null,6182 else => null,
6183 };6183 };
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
6186 const len = try self.resolveInst(extra.rhs);6186 const len = try self.resolveInst(extra.rhs);
6187 const len_lock: ?RegisterLock = switch (len) {6187 const len_lock: ?RegisterLock = switch (len) {
6188 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),6188 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
6189 else => null,6189 else => null,
6190 };6190 };
6191 defer if (len_lock) |reg| self.register_manager.unfreezeReg(reg);6191 defer if (len_lock) |reg| self.register_manager.unlockReg(reg);
61926192
6193 try self.genInlineMemset(dst_ptr, src_val, len, .{});6193 try self.genInlineMemset(dst_ptr, src_val, len, .{});
61946194
...@@ -6201,25 +6201,25 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {...@@ -6201,25 +6201,25 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
62016201
6202 const dst_ptr = try self.resolveInst(pl_op.operand);6202 const dst_ptr = try self.resolveInst(pl_op.operand);
6203 const dst_ptr_lock: ?RegisterLock = switch (dst_ptr) {6203 const dst_ptr_lock: ?RegisterLock = switch (dst_ptr) {
6204 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),6204 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
6205 else => null,6205 else => null,
6206 };6206 };
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
6209 const src_ty = self.air.typeOf(extra.lhs);6209 const src_ty = self.air.typeOf(extra.lhs);
6210 const src_ptr = try self.resolveInst(extra.lhs);6210 const src_ptr = try self.resolveInst(extra.lhs);
6211 const src_ptr_lock: ?RegisterLock = switch (src_ptr) {6211 const src_ptr_lock: ?RegisterLock = switch (src_ptr) {
6212 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),6212 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
6213 else => null,6213 else => null,
6214 };6214 };
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
6217 const len = try self.resolveInst(extra.rhs);6217 const len = try self.resolveInst(extra.rhs);
6218 const len_lock: ?RegisterLock = switch (len) {6218 const len_lock: ?RegisterLock = switch (len) {
6219 .register => |reg| self.register_manager.freezeRegAssumeUnused(reg),6219 .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
6220 else => null,6220 else => null,
6221 };6221 };
6222 defer if (len_lock) |reg| self.register_manager.unfreezeReg(reg);6222 defer if (len_lock) |reg| self.register_manager.unlockReg(reg);
62236223
6224 // TODO Is this the only condition for pointer dereference for memcpy?6224 // TODO Is this the only condition for pointer dereference for memcpy?
6225 const src: MCValue = blk: {6225 const src: MCValue = blk: {
...@@ -6242,10 +6242,10 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {...@@ -6242,10 +6242,10 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
6242 }6242 }
6243 };6243 };
6244 const src_lock: ?RegisterLock = switch (src) {6244 const src_lock: ?RegisterLock = switch (src) {
6245 .register => |reg| self.register_manager.freezeReg(reg),6245 .register => |reg| self.register_manager.lockReg(reg),
6246 else => null,6246 else => null,
6247 };6247 };
6248 defer if (src_lock) |reg| self.register_manager.unfreezeReg(reg);6248 defer if (src_lock) |reg| self.register_manager.unlockReg(reg);
62496249
6250 try self.genInlineMemcpy(dst_ptr, src, len, .{});6250 try self.genInlineMemcpy(dst_ptr, src, len, .{});
62516251
src/register_manager.zig+53-54
...@@ -45,9 +45,8 @@ pub fn RegisterManager(...@@ -45,9 +45,8 @@ pub fn RegisterManager(
45 /// Tracks all registers allocated in the course of this45 /// Tracks all registers allocated in the course of this
46 /// function46 /// function
47 allocated_registers: FreeRegInt = 0,47 allocated_registers: FreeRegInt = 0,
48 /// Tracks registers which are temporarily blocked from being48 /// Tracks registers which are locked from being allocated
49 /// allocated49 locked_registers: FreeRegInt = 0,
50 frozen_registers: FreeRegInt = 0,
5150
52 const Self = @This();51 const Self = @This();
5352
...@@ -108,12 +107,12 @@ pub fn RegisterManager(...@@ -108,12 +107,12 @@ pub fn RegisterManager(
108 return self.allocated_registers & mask != 0;107 return self.allocated_registers & mask != 0;
109 }108 }
110109
111 /// Returns whether this register is frozen110 /// Returns whether this register is locked
112 ///111 ///
113 /// Returns false when this register is not tracked112 /// 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 {
115 const mask = getRegisterMask(reg) orelse return false;114 const mask = getRegisterMask(reg) orelse return false;
116 return self.frozen_registers & mask != 0;115 return self.locked_registers & mask != 0;
117 }116 }
118117
119 pub const RegisterLock = struct {118 pub const RegisterLock = struct {
...@@ -121,56 +120,56 @@ pub fn RegisterManager(...@@ -121,56 +120,56 @@ pub fn RegisterManager(
121 };120 };
122121
123 /// Prevents the register from being allocated until they are122 /// Prevents the register from being allocated until they are
124 /// unfrozen again.123 /// unlocked again.
125 /// Returns `RegisterLock` if the register was not already124 /// Returns `RegisterLock` if the register was not already
126 /// frozen, or `null` otherwise.125 /// locked, or `null` otherwise.
127 /// Only the owner of the `RegisterLock` can unfreeze the126 /// Only the owner of the `RegisterLock` can unlock the
128 /// register later.127 /// register later.
129 pub fn freezeReg(self: *Self, reg: Register) ?RegisterLock {128 pub fn lockReg(self: *Self, reg: Register) ?RegisterLock {
130 log.debug("freezing {}", .{reg});129 log.debug("locking {}", .{reg});
131 if (self.isRegFrozen(reg)) {130 if (self.isRegLocked(reg)) {
132 log.debug(" register already locked", .{});131 log.debug(" register already locked", .{});
133 return null;132 return null;
134 }133 }
135 const mask = getRegisterMask(reg) orelse return null;134 const mask = getRegisterMask(reg) orelse return null;
136 self.frozen_registers |= mask;135 self.locked_registers |= mask;
137 return RegisterLock{ .register = reg };136 return RegisterLock{ .register = reg };
138 }137 }
139138
140 /// Like `freezeReg` but asserts the register was unused always139 /// Like `lockReg` but asserts the register was unused always
141 /// returning a valid lock.140 /// returning a valid lock.
142 pub fn freezeRegAssumeUnused(self: *Self, reg: Register) RegisterLock {141 pub fn lockRegAssumeUnused(self: *Self, reg: Register) RegisterLock {
143 log.debug("freezing asserting free {}", .{reg});142 log.debug("locking asserting free {}", .{reg});
144 assert(!self.isRegFrozen(reg));143 assert(!self.isRegLocked(reg));
145 const mask = getRegisterMask(reg) orelse unreachable;144 const mask = getRegisterMask(reg) orelse unreachable;
146 self.frozen_registers |= mask;145 self.locked_registers |= mask;
147 return RegisterLock{ .register = reg };146 return RegisterLock{ .register = reg };
148 }147 }
149148
150 /// Like `freezeRegAssumeUnused` but locks multiple registers.149 /// Like `lockRegAssumeUnused` but locks multiple registers.
151 pub fn freezeRegsAssumeUnused(150 pub fn lockRegsAssumeUnused(
152 self: *Self,151 self: *Self,
153 comptime count: comptime_int,152 comptime count: comptime_int,
154 regs: [count]Register,153 regs: [count]Register,
155 buf: *[count]RegisterLock,154 buf: *[count]RegisterLock,
156 ) void {155 ) void {
157 for (&regs) |reg, i| {156 for (&regs) |reg, i| {
158 buf[i] = self.freezeRegAssumeUnused(reg);157 buf[i] = self.lockRegAssumeUnused(reg);
159 }158 }
160 }159 }
161160
162 /// Unfreezes the register allowing its re-allocation and re-use.161 /// Unlocks the register allowing its re-allocation and re-use.
163 /// Requires `RegisterLock` to unfreeze a register.162 /// Requires `RegisterLock` to unlock a register.
164 /// Call `freezeReg` to obtain the lock first.163 /// Call `lockReg` to obtain the lock first.
165 pub fn unfreezeReg(self: *Self, lock: RegisterLock) void {164 pub fn unlockReg(self: *Self, lock: RegisterLock) void {
166 log.debug("unfreezing {}", .{lock.register});165 log.debug("unlocking {}", .{lock.register});
167 const mask = getRegisterMask(lock.register) orelse return;166 const mask = getRegisterMask(lock.register) orelse return;
168 self.frozen_registers &= ~mask;167 self.locked_registers &= ~mask;
169 }168 }
170169
171 /// Returns true when at least one register is frozen170 /// Returns true when at least one register is locked
172 pub fn frozenRegsExist(self: Self) bool {171 pub fn lockedRegsExist(self: Self) bool {
173 return self.frozen_registers != 0;172 return self.locked_registers != 0;
174 }173 }
175174
176 /// Allocates a specified number of registers, optionally175 /// Allocates a specified number of registers, optionally
...@@ -183,15 +182,15 @@ pub fn RegisterManager(...@@ -183,15 +182,15 @@ pub fn RegisterManager(
183 ) ?[count]Register {182 ) ?[count]Register {
184 comptime assert(count > 0 and count <= tracked_registers.len);183 comptime assert(count > 0 and count <= tracked_registers.len);
185184
186 const free_and_not_frozen_registers = self.free_registers & ~self.frozen_registers;185 const free_and_not_locked_registers = self.free_registers & ~self.locked_registers;
187 const free_and_not_frozen_registers_count = @popCount(FreeRegInt, free_and_not_frozen_registers);186 const free_and_not_locked_registers_count = @popCount(FreeRegInt, free_and_not_locked_registers);
188 if (free_and_not_frozen_registers_count < count) return null;187 if (free_and_not_locked_registers_count < count) return null;
189188
190 var regs: [count]Register = undefined;189 var regs: [count]Register = undefined;
191 var i: usize = 0;190 var i: usize = 0;
192 for (tracked_registers) |reg| {191 for (tracked_registers) |reg| {
193 if (i >= count) break;192 if (i >= count) break;
194 if (self.isRegFrozen(reg)) continue;193 if (self.isRegLocked(reg)) continue;
195 if (!self.isRegFree(reg)) continue;194 if (!self.isRegFree(reg)) continue;
196195
197 regs[i] = reg;196 regs[i] = reg;
...@@ -229,8 +228,8 @@ pub fn RegisterManager(...@@ -229,8 +228,8 @@ pub fn RegisterManager(
229 insts: [count]?Air.Inst.Index,228 insts: [count]?Air.Inst.Index,
230 ) AllocateRegistersError![count]Register {229 ) AllocateRegistersError![count]Register {
231 comptime assert(count > 0 and count <= tracked_registers.len);230 comptime assert(count > 0 and count <= tracked_registers.len);
232 const frozen_registers_count = @popCount(FreeRegInt, self.frozen_registers);231 const locked_registers_count = @popCount(FreeRegInt, self.locked_registers);
233 if (count > tracked_registers.len - frozen_registers_count) return error.OutOfRegisters;232 if (count > tracked_registers.len - locked_registers_count) return error.OutOfRegisters;
234233
235 const result = self.tryAllocRegs(count, insts) orelse blk: {234 const result = self.tryAllocRegs(count, insts) orelse blk: {
236 // We'll take over the first count registers. Spill235 // We'll take over the first count registers. Spill
...@@ -240,7 +239,7 @@ pub fn RegisterManager(...@@ -240,7 +239,7 @@ pub fn RegisterManager(
240 var i: usize = 0;239 var i: usize = 0;
241 for (tracked_registers) |reg| {240 for (tracked_registers) |reg| {
242 if (i >= count) break;241 if (i >= count) break;
243 if (self.isRegFrozen(reg)) continue;242 if (self.isRegLocked(reg)) continue;
244243
245 regs[i] = reg;244 regs[i] = reg;
246 self.markRegAllocated(reg);245 self.markRegAllocated(reg);
...@@ -451,15 +450,15 @@ test "allocReg: spilling" {...@@ -451,15 +450,15 @@ test "allocReg: spilling" {
451 try expectEqual(@as(?MockRegister1, .r3), try function.register_manager.allocReg(mock_instruction));450 try expectEqual(@as(?MockRegister1, .r3), try function.register_manager.allocReg(mock_instruction));
452 try expectEqualSlices(MockRegister1, &[_]MockRegister1{.r2}, function.spilled.items);451 try expectEqualSlices(MockRegister1, &[_]MockRegister1{.r2}, function.spilled.items);
453452
454 // Frozen registers453 // Locked registers
455 function.register_manager.freeReg(.r3);454 function.register_manager.freeReg(.r3);
456 {455 {
457 const lock = function.register_manager.freezeReg(.r2);456 const lock = function.register_manager.lockReg(.r2);
458 defer if (lock) |reg| function.register_manager.unfreezeReg(reg);457 defer if (lock) |reg| function.register_manager.unlockReg(reg);
459458
460 try expectEqual(@as(?MockRegister1, .r3), try function.register_manager.allocReg(mock_instruction));459 try expectEqual(@as(?MockRegister1, .r3), try function.register_manager.allocReg(mock_instruction));
461 }460 }
462 try expect(!function.register_manager.frozenRegsExist());461 try expect(!function.register_manager.lockedRegsExist());
463}462}
464463
465test "tryAllocRegs" {464test "tryAllocRegs" {
...@@ -477,17 +476,17 @@ test "tryAllocRegs" {...@@ -477,17 +476,17 @@ test "tryAllocRegs" {
477 try expect(function.register_manager.isRegAllocated(.r2));476 try expect(function.register_manager.isRegAllocated(.r2));
478 try expect(!function.register_manager.isRegAllocated(.r3));477 try expect(!function.register_manager.isRegAllocated(.r3));
479478
480 // Frozen registers479 // Locked registers
481 function.register_manager.freeReg(.r0);480 function.register_manager.freeReg(.r0);
482 function.register_manager.freeReg(.r2);481 function.register_manager.freeReg(.r2);
483 function.register_manager.freeReg(.r3);482 function.register_manager.freeReg(.r3);
484 {483 {
485 const lock = function.register_manager.freezeReg(.r1);484 const lock = function.register_manager.lockReg(.r1);
486 defer if (lock) |reg| function.register_manager.unfreezeReg(reg);485 defer if (lock) |reg| function.register_manager.unlockReg(reg);
487486
488 try expectEqual([_]MockRegister2{ .r0, .r2, .r3 }, function.register_manager.tryAllocRegs(3, .{ null, null, null }).?);487 try expectEqual([_]MockRegister2{ .r0, .r2, .r3 }, function.register_manager.tryAllocRegs(3, .{ null, null, null }).?);
489 }488 }
490 try expect(!function.register_manager.frozenRegsExist());489 try expect(!function.register_manager.lockedRegsExist());
491490
492 try expect(function.register_manager.isRegAllocated(.r0));491 try expect(function.register_manager.isRegAllocated(.r0));
493 try expect(function.register_manager.isRegAllocated(.r1));492 try expect(function.register_manager.isRegAllocated(.r1));
...@@ -510,19 +509,19 @@ test "allocRegs: normal usage" {...@@ -510,19 +509,19 @@ test "allocRegs: normal usage" {
510509
511 // The result register is known and fixed at this point, we510 // The result register is known and fixed at this point, we
512 // don't want to accidentally allocate lhs or rhs to the511 // 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.
514 //513 //
515 // Using defer unfreeze right after freeze is a good idea in514 // Using defer unlock right after lock is a good idea in
516 // most cases as you probably are using the frozen registers515 // most cases as you probably are using the locked registers
517 // in the remainder of this scope and don't need to use it516 // in the remainder of this scope and don't need to use it
518 // after the end of this scope. However, in some situations,517 // after the end of this scope. However, in some situations,
519 // it may make sense to manually unfreeze registers before the518 // it may make sense to manually unlock registers before the
520 // end of the scope when you are certain that they don't519 // end of the scope when you are certain that they don't
521 // contain any valuable data anymore and can be reused. For an520 // contain any valuable data anymore and can be reused. For an
522 // example of that, see `selectively reducing register521 // example of that, see `selectively reducing register
523 // pressure`.522 // pressure`.
524 const lock = function.register_manager.freezeReg(result_reg);523 const lock = function.register_manager.lockReg(result_reg);
525 defer if (lock) |reg| function.register_manager.unfreezeReg(reg);524 defer if (lock) |reg| function.register_manager.unlockReg(reg);
526525
527 const regs = try function.register_manager.allocRegs(2, .{ null, null });526 const regs = try function.register_manager.allocRegs(2, .{ null, null });
528 try function.genAdd(result_reg, regs[0], regs[1]);527 try function.genAdd(result_reg, regs[0], regs[1]);
...@@ -542,14 +541,14 @@ test "allocRegs: selectively reducing register pressure" {...@@ -542,14 +541,14 @@ test "allocRegs: selectively reducing register pressure" {
542 {541 {
543 const result_reg: MockRegister2 = .r1;542 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 unfreeze546 // Here, we don't defer unlock because we manually unlock
548 // after genAdd547 // after genAdd
549 const regs = try function.register_manager.allocRegs(2, .{ null, null });548 const regs = try function.register_manager.allocRegs(2, .{ null, null });
550549
551 try function.genAdd(result_reg, regs[0], regs[1]);550 try function.genAdd(result_reg, regs[0], regs[1]);
552 function.register_manager.unfreezeReg(lock.?);551 function.register_manager.unlockReg(lock.?);
553552
554 const extra_summand_reg = try function.register_manager.allocReg(null);553 const extra_summand_reg = try function.register_manager.allocReg(null);
555 try function.genAdd(result_reg, result_reg, extra_summand_reg);554 try function.genAdd(result_reg, result_reg, extra_summand_reg);