authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-05-07 13:27:11+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-05-07 13:27:11+02:00
logf57b059e58253af3718c5b17fefc40c47b33e63c
tree33d7a59476490d8f5a02c0e77156f0cb9fc3dd00
parentbf11cdc9d880555aee087a9bc0ecd1424428b63b

regalloc: refactor locking multiple registers at once

4 files changed, 16 insertions(+), 28 deletions(-)

src/arch/aarch64/CodeGen.zig+2-4
......@@ -2627,8 +2627,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
26272627 } else {
26282628 // TODO optimize the register allocation
26292629 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });
2630 var regs_locks: [4]RegisterLock = undefined;
2631 self.register_manager.lockRegsAssumeUnused(4, regs, &regs_locks);
2630 const regs_locks = self.register_manager.lockRegsAssumeUnused(4, regs);
26322631 defer for (regs_locks) |reg| {
26332632 self.register_manager.unlockReg(reg);
26342633 };
......@@ -4065,8 +4064,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
40654064
40664065 // TODO call extern memcpy
40674066 const regs = try self.register_manager.allocRegs(5, .{ null, null, null, null, null });
4068 var regs_locks: [5]RegisterLock = undefined;
4069 self.register_manager.lockRegsAssumeUnused(5, regs, &regs_locks);
4067 const regs_locks = self.register_manager.lockRegsAssumeUnused(5, regs);
40704068 defer for (regs_locks) |reg| {
40714069 self.register_manager.unlockReg(reg);
40724070 };
src/arch/arm/CodeGen.zig+3-6
......@@ -1548,8 +1548,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
15481548 defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
15491549
15501550 const dest_regs = try self.register_manager.allocRegs(2, .{ null, null });
1551 var dest_regs_locks: [2]RegisterLock = undefined;
1552 self.register_manager.lockRegsAssumeUnused(2, dest_regs, &dest_regs_locks);
1551 const dest_regs_locks = self.register_manager.lockRegsAssumeUnused(2, dest_regs);
15531552 defer for (dest_regs_locks) |reg| {
15541553 self.register_manager.unlockReg(reg);
15551554 };
......@@ -2181,8 +2180,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
21812180 } else {
21822181 // TODO optimize the register allocation
21832182 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });
2184 var regs_locks: [4]RegisterLock = undefined;
2185 self.register_manager.lockRegsAssumeUnused(4, regs, &regs_locks);
2183 const regs_locks = self.register_manager.lockRegsAssumeUnused(4, regs);
21862184 defer for (regs_locks) |reg_locked| {
21872185 self.register_manager.unlockReg(reg_locked);
21882186 };
......@@ -2285,8 +2283,7 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
22852283 try self.store(ptr, .{ .register = tmp_reg }, ptr_ty, value_ty);
22862284 } else {
22872285 const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null });
2288 var regs_locks: [4]RegisterLock = undefined;
2289 self.register_manager.lockRegsAssumeUnused(4, regs, &regs_locks);
2286 const regs_locks = self.register_manager.lockRegsAssumeUnused(4, regs);
22902287 defer for (regs_locks) |reg| {
22912288 self.register_manager.unlockReg(reg);
22922289 };
src/arch/x86_64/CodeGen.zig+8-16
......@@ -1377,8 +1377,7 @@ fn airMul(self: *Self, inst: Air.Inst.Index) !void {
13771377 // Spill .rax and .rdx upfront to ensure we don't spill the operands too late.
13781378 try self.register_manager.getReg(.rax, inst);
13791379 try self.register_manager.getReg(.rdx, null);
1380 var reg_locks: [2]RegisterLock = undefined;
1381 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1380 const reg_locks = self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx });
13821381 defer for (reg_locks) |reg| {
13831382 self.register_manager.unlockReg(reg);
13841383 };
......@@ -1495,8 +1494,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
14951494 // Spill .rax and .rdx upfront to ensure we don't spill the operands too late.
14961495 try self.register_manager.getReg(.rax, inst);
14971496 try self.register_manager.getReg(.rdx, null);
1498 var reg_locks: [2]RegisterLock = undefined;
1499 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1497 const reg_locks = self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx });
15001498 defer for (reg_locks) |reg| {
15011499 self.register_manager.unlockReg(reg);
15021500 };
......@@ -1556,8 +1554,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
15561554 // Spill .rax and .rdx upfront to ensure we don't spill the operands too late.
15571555 try self.register_manager.getReg(.rax, null);
15581556 try self.register_manager.getReg(.rdx, null);
1559 var reg_locks: [2]RegisterLock = undefined;
1560 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1557 const reg_locks = self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx });
15611558 defer for (reg_locks) |reg| {
15621559 self.register_manager.unlockReg(reg);
15631560 };
......@@ -1586,8 +1583,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
15861583 };
15871584
15881585 const temp_regs = try self.register_manager.allocRegs(3, .{ null, null, null });
1589 var temp_regs_locks: [3]RegisterLock = undefined;
1590 self.register_manager.lockRegsAssumeUnused(3, temp_regs, &temp_regs_locks);
1586 const temp_regs_locks = self.register_manager.lockRegsAssumeUnused(3, temp_regs);
15911587 defer for (temp_regs_locks) |reg| {
15921588 self.register_manager.unlockReg(reg);
15931589 };
......@@ -1819,8 +1815,7 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
18191815 };
18201816 try self.register_manager.getReg(.rax, track_rax);
18211817 try self.register_manager.getReg(.rdx, null);
1822 var reg_locks: [2]RegisterLock = undefined;
1823 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1818 const reg_locks = self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx });
18241819 defer for (reg_locks) |reg| {
18251820 self.register_manager.unlockReg(reg);
18261821 };
......@@ -1893,8 +1888,7 @@ fn airRem(self: *Self, inst: Air.Inst.Index) !void {
18931888 // Spill .rax and .rdx upfront to ensure we don't spill the operands too late.
18941889 try self.register_manager.getReg(.rax, null);
18951890 try self.register_manager.getReg(.rdx, inst);
1896 var reg_locks: [2]RegisterLock = undefined;
1897 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1891 const reg_locks = self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx });
18981892 defer for (reg_locks) |reg| {
18991893 self.register_manager.unlockReg(reg);
19001894 };
......@@ -1929,8 +1923,7 @@ fn airMod(self: *Self, inst: Air.Inst.Index) !void {
19291923 // Spill .rax and .rdx upfront to ensure we don't spill the operands too late.
19301924 try self.register_manager.getReg(.rax, null);
19311925 try self.register_manager.getReg(.rdx, if (signedness == .unsigned) inst else null);
1932 var reg_locks: [2]RegisterLock = undefined;
1933 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx }, &reg_locks);
1926 const reg_locks = self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rdx });
19341927 defer for (reg_locks) |reg| {
19351928 self.register_manager.unlockReg(reg);
19361929 };
......@@ -5552,8 +5545,7 @@ fn genInlineMemcpy(
55525545 try self.register_manager.getReg(.rax, null);
55535546 try self.register_manager.getReg(.rcx, null);
55545547
5555 var reg_locks: [2]RegisterLock = undefined;
5556 self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rcx }, &reg_locks);
5548 const reg_locks = self.register_manager.lockRegsAssumeUnused(2, .{ .rax, .rcx });
55575549 defer for (reg_locks) |lock| {
55585550 self.register_manager.unlockReg(lock);
55595551 };
src/register_manager.zig+3-2
......@@ -151,11 +151,12 @@ pub fn RegisterManager(
151151 self: *Self,
152152 comptime count: comptime_int,
153153 regs: [count]Register,
154 buf: *[count]RegisterLock,
155 ) void {
154 ) [count]RegisterLock {
155 var buf: [count]RegisterLock = undefined;
156156 for (regs) |reg, i| {
157157 buf[i] = self.lockRegAssumeUnused(reg);
158158 }
159 return buf;
159160 }
160161
161162 /// Unlocks the register allowing its re-allocation and re-use.