authorgravatar for joachim.schmidt557@outlook.comJoachim Schmidt <joachim.schmidt557@outlook.com> 2021-03-19 10:11:45+01:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2021-04-02 12:01:52-07:00
log4efbcad26d088a0b40cae308ca2990a71ea1f3f9
tree299e234e4354a6a7da0e27d90e7476aa8eb27e34
parentfc9c1b4e4ae86c36a7ff29859cc589a9816ab7d5

stage2 codegen: Extract register management code into separate file

2 files changed, 155 insertions(+), 104 deletions(-)

src/codegen.zig+28-104
......@@ -18,6 +18,7 @@ const leb128 = std.leb;
1818const log = std.log.scoped(.codegen);
1919const build_options = @import("build_options");
2020const LazySrcLoc = Module.LazySrcLoc;
21const RegisterManager = @import("register_manager.zig").RegisterManager;
2122
2223/// The codegen-related data that is stored in `ir.Inst.Block` instructions.
2324pub const BlockData = struct {
......@@ -286,11 +287,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
286287 /// across each runtime branch upon joining.
287288 branch_stack: *std.ArrayList(Branch),
288289
289 /// The key must be canonical register.
290 registers: std.AutoHashMapUnmanaged(Register, *ir.Inst) = .{},
291 free_registers: FreeRegInt = math.maxInt(FreeRegInt),
292 /// Tracks all registers allocated in the course of this function
293 allocated_registers: FreeRegInt = 0,
290 register_manager: RegisterManager(Self, Register, &callee_preserved_regs) = .{},
294291 /// Maps offset to what is stored there.
295292 stack: std.AutoHashMapUnmanaged(u32, StackAllocation) = .{},
296293
......@@ -382,49 +379,6 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
382379 }
383380 };
384381
385 fn markRegUsed(self: *Self, reg: Register) void {
386 if (FreeRegInt == u0) return;
387 const index = reg.allocIndex() orelse return;
388 const ShiftInt = math.Log2Int(FreeRegInt);
389 const shift = @intCast(ShiftInt, index);
390 const mask = @as(FreeRegInt, 1) << shift;
391 self.free_registers &= ~mask;
392 self.allocated_registers |= mask;
393 }
394
395 fn markRegFree(self: *Self, reg: Register) void {
396 if (FreeRegInt == u0) return;
397 const index = reg.allocIndex() orelse return;
398 const ShiftInt = math.Log2Int(FreeRegInt);
399 const shift = @intCast(ShiftInt, index);
400 self.free_registers |= @as(FreeRegInt, 1) << shift;
401 }
402
403 /// Before calling, must ensureCapacity + 1 on self.registers.
404 /// Returns `null` if all registers are allocated.
405 fn allocReg(self: *Self, inst: *ir.Inst) ?Register {
406 const free_index = @ctz(FreeRegInt, self.free_registers);
407 if (free_index >= callee_preserved_regs.len) {
408 return null;
409 }
410 const mask = @as(FreeRegInt, 1) << free_index;
411 self.free_registers &= ~mask;
412 self.allocated_registers |= mask;
413 const reg = callee_preserved_regs[free_index];
414 self.registers.putAssumeCapacityNoClobber(reg, inst);
415 log.debug("alloc {} => {*}", .{ reg, inst });
416 return reg;
417 }
418
419 /// Does not track the register.
420 fn findUnusedReg(self: *Self) ?Register {
421 const free_index = @ctz(FreeRegInt, self.free_registers);
422 if (free_index >= callee_preserved_regs.len) {
423 return null;
424 }
425 return callee_preserved_regs[free_index];
426 }
427
428382 const StackAllocation = struct {
429383 inst: *ir.Inst,
430384 /// TODO do we need size? should be determined by inst.ty.abiSize()
......@@ -495,7 +449,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
495449 .rbrace_src = src_data.rbrace_src,
496450 .source = src_data.source,
497451 };
498 defer function.registers.deinit(bin_file.allocator);
452 defer function.register_manager.deinit(bin_file.allocator);
499453 defer function.stack.deinit(bin_file.allocator);
500454 defer function.exitlude_jump_relocs.deinit(bin_file.allocator);
501455
......@@ -607,10 +561,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
607561 .r14 = true, // lr
608562 };
609563 inline for (callee_preserved_regs) |reg, i| {
610 const ShiftInt = math.Log2Int(FreeRegInt);
611 const shift = @intCast(ShiftInt, i);
612 const mask = @as(FreeRegInt, 1) << shift;
613 if (self.allocated_registers & mask != 0) {
564 if (self.register_manager.isRegAllocated(reg)) {
614565 @field(saved_regs, @tagName(reg)) = true;
615566 }
616567 }
......@@ -829,8 +780,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
829780 switch (prev_value) {
830781 .register => |reg| {
831782 const canon_reg = toCanonicalReg(reg);
832 _ = self.registers.remove(canon_reg);
833 self.markRegFree(canon_reg);
783 self.register_manager.freeReg(canon_reg);
834784 },
835785 else => {}, // TODO process stack allocation death
836786 }
......@@ -969,8 +919,8 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
969919 const ptr_bits = arch.ptrBitWidth();
970920 const ptr_bytes: u64 = @divExact(ptr_bits, 8);
971921 if (abi_size <= ptr_bytes) {
972 try self.registers.ensureCapacity(self.gpa, self.registers.count() + 1);
973 if (self.allocReg(inst)) |reg| {
922 try self.register_manager.registers.ensureCapacity(self.gpa, self.register_manager.registers.count() + 1);
923 if (self.register_manager.tryAllocReg(inst)) |reg| {
974924 return MCValue{ .register = registerAlias(reg, abi_size) };
975925 }
976926 }
......@@ -979,26 +929,20 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
979929 return MCValue{ .stack_offset = stack_offset };
980930 }
981931
932 pub fn spillInstruction(self: *Self, src: usize, reg: Register, inst: *ir.Inst) !void {
933 const stack_mcv = try self.allocRegOrMem(inst, false);
934 const reg_mcv = self.getResolvedInstValue(inst);
935 assert(reg == toCanonicalReg(reg_mcv.register));
936 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
937 try branch.inst_table.put(self.gpa, inst, stack_mcv);
938 try self.genSetStack(src, inst.ty, stack_mcv.stack_offset, reg_mcv);
939 }
940
982941 /// Copies a value to a register without tracking the register. The register is not considered
983942 /// allocated. A second call to `copyToTmpRegister` may return the same register.
984943 /// This can have a side effect of spilling instructions to the stack to free up a register.
985944 fn copyToTmpRegister(self: *Self, src: LazySrcLoc, ty: Type, mcv: MCValue) !Register {
986 const reg = self.findUnusedReg() orelse b: {
987 // We'll take over the first register. Move the instruction that was previously
988 // there to a stack allocation.
989 const reg = callee_preserved_regs[0];
990 const regs_entry = self.registers.remove(reg).?;
991 const spilled_inst = regs_entry.value;
992
993 const stack_mcv = try self.allocRegOrMem(spilled_inst, false);
994 const reg_mcv = self.getResolvedInstValue(spilled_inst);
995 assert(reg == toCanonicalReg(reg_mcv.register));
996 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
997 try branch.inst_table.put(self.gpa, spilled_inst, stack_mcv);
998 try self.genSetStack(src, spilled_inst.ty, stack_mcv.stack_offset, reg_mcv);
999
1000 break :b reg;
1001 };
945 const reg = try self.register_manager.allocRegWithoutTracking();
1002946 try self.genSetReg(src, ty, reg, mcv);
1003947 return reg;
1004948 }
......@@ -1007,25 +951,9 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1007951 /// `reg_owner` is the instruction that gets associated with the register in the register table.
1008952 /// This can have a side effect of spilling instructions to the stack to free up a register.
1009953 fn copyToNewRegister(self: *Self, reg_owner: *ir.Inst, mcv: MCValue) !MCValue {
1010 try self.registers.ensureCapacity(self.gpa, @intCast(u32, self.registers.count() + 1));
1011
1012 const reg = self.allocReg(reg_owner) orelse b: {
1013 // We'll take over the first register. Move the instruction that was previously
1014 // there to a stack allocation.
1015 const reg = callee_preserved_regs[0];
1016 const regs_entry = self.registers.getEntry(reg).?;
1017 const spilled_inst = regs_entry.value;
1018 regs_entry.value = reg_owner;
1019
1020 const stack_mcv = try self.allocRegOrMem(spilled_inst, false);
1021 const reg_mcv = self.getResolvedInstValue(spilled_inst);
1022 assert(reg == toCanonicalReg(reg_mcv.register));
1023 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
1024 try branch.inst_table.put(self.gpa, spilled_inst, stack_mcv);
1025 try self.genSetStack(reg_owner.src, spilled_inst.ty, stack_mcv.stack_offset, reg_mcv);
1026
1027 break :b reg;
1028 };
954 try self.register_manager.registers.ensureCapacity(self.gpa, @intCast(u32, self.register_manager.registers.count() + 1));
955
956 const reg = try self.register_manager.allocReg(reg_owner);
1029957 try self.genSetReg(reg_owner.src, reg_owner.ty, reg, mcv);
1030958 return MCValue{ .register = reg };
1031959 }
......@@ -1302,7 +1230,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
13021230 .register => |reg| {
13031231 // If it's in the registers table, need to associate the register with the
13041232 // new instruction.
1305 if (self.registers.getEntry(toCanonicalReg(reg))) |entry| {
1233 if (self.register_manager.registers.getEntry(toCanonicalReg(reg))) |entry| {
13061234 entry.value = inst;
13071235 }
13081236 log.debug("reusing {} => {*}", .{ reg, inst });
......@@ -1795,7 +1723,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
17951723 const arg_index = self.arg_index;
17961724 self.arg_index += 1;
17971725
1798 if (FreeRegInt == u0) {
1726 if (callee_preserved_regs.len == 0) {
17991727 return self.fail(inst.base.src, "TODO implement Register enum for {}", .{self.target.cpu.arch});
18001728 }
18011729
......@@ -1807,8 +1735,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
18071735
18081736 switch (result) {
18091737 .register => |reg| {
1810 try self.registers.putNoClobber(self.gpa, toCanonicalReg(reg), &inst.base);
1811 self.markRegUsed(reg);
1738 try self.register_manager.getRegAssumeFree(toCanonicalReg(reg), &inst.base);
18121739 },
18131740 else => {},
18141741 }
......@@ -2431,10 +2358,10 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
24312358
24322359 // Capture the state of register and stack allocation state so that we can revert to it.
24332360 const parent_next_stack_offset = self.next_stack_offset;
2434 const parent_free_registers = self.free_registers;
2361 const parent_free_registers = self.register_manager.free_registers;
24352362 var parent_stack = try self.stack.clone(self.gpa);
24362363 defer parent_stack.deinit(self.gpa);
2437 var parent_registers = try self.registers.clone(self.gpa);
2364 var parent_registers = try self.register_manager.registers.clone(self.gpa);
24382365 defer parent_registers.deinit(self.gpa);
24392366
24402367 try self.branch_stack.append(.{});
......@@ -2451,8 +2378,8 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
24512378 var saved_then_branch = self.branch_stack.pop();
24522379 defer saved_then_branch.deinit(self.gpa);
24532380
2454 self.registers.deinit(self.gpa);
2455 self.registers = parent_registers;
2381 self.register_manager.registers.deinit(self.gpa);
2382 self.register_manager.registers = parent_registers;
24562383 parent_registers = .{};
24572384
24582385 self.stack.deinit(self.gpa);
......@@ -2460,7 +2387,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
24602387 parent_stack = .{};
24612388
24622389 self.next_stack_offset = parent_next_stack_offset;
2463 self.free_registers = parent_free_registers;
2390 self.register_manager.free_registers = parent_free_registers;
24642391
24652392 try self.performReloc(inst.base.src, reloc);
24662393 const else_branch = self.branch_stack.addOneAssumeCapacity();
......@@ -4049,9 +3976,6 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
40493976 },
40503977 };
40513978
4052 /// An integer whose bits represent all the registers and whether they are free.
4053 const FreeRegInt = std.meta.Int(.unsigned, callee_preserved_regs.len);
4054
40553979 fn parseRegName(name: []const u8) ?Register {
40563980 if (@hasDecl(Register, "parseRegName")) {
40573981 return Register.parseRegName(name);
src/register_manager.zig created+127
......@@ -0,0 +1,127 @@
1const std = @import("std");
2const math = std.math;
3const assert = std.debug.assert;
4const Allocator = std.mem.Allocator;
5const ir = @import("ir.zig");
6const Type = @import("type.zig").Type;
7const log = std.log.scoped(.register_manager);
8
9pub fn RegisterManager(
10 comptime Function: type,
11 comptime Register: type,
12 comptime callee_preserved_regs: []const Register,
13) type {
14 return struct {
15 /// The key must be canonical register.
16 registers: std.AutoHashMapUnmanaged(Register, *ir.Inst) = .{},
17 free_registers: FreeRegInt = math.maxInt(FreeRegInt),
18 /// Tracks all registers allocated in the course of this function
19 allocated_registers: FreeRegInt = 0,
20
21 const Self = @This();
22
23 /// An integer whose bits represent all the registers and whether they are free.
24 const FreeRegInt = std.meta.Int(.unsigned, callee_preserved_regs.len);
25
26 fn getFunction(self: *Self) *Function {
27 return @fieldParentPtr(Function, "register_manager", self);
28 }
29
30 pub fn deinit(self: *Self, allocator: *Allocator) void {
31 self.registers.deinit(allocator);
32 }
33
34 fn markRegUsed(self: *Self, reg: Register) void {
35 if (FreeRegInt == u0) return;
36 const index = reg.allocIndex() orelse return;
37 const ShiftInt = math.Log2Int(FreeRegInt);
38 const shift = @intCast(ShiftInt, index);
39 const mask = @as(FreeRegInt, 1) << shift;
40 self.free_registers &= ~mask;
41 self.allocated_registers |= mask;
42 }
43
44 fn markRegFree(self: *Self, reg: Register) void {
45 if (FreeRegInt == u0) return;
46 const index = reg.allocIndex() orelse return;
47 const ShiftInt = math.Log2Int(FreeRegInt);
48 const shift = @intCast(ShiftInt, index);
49 self.free_registers |= @as(FreeRegInt, 1) << shift;
50 }
51
52 /// Returns whether this register was allocated in the course
53 /// of this function
54 pub fn isRegAllocated(self: Self, reg: Register) bool {
55 if (FreeRegInt == u0) return false;
56 const index = reg.allocIndex() orelse return false;
57 const ShiftInt = math.Log2Int(FreeRegInt);
58 const shift = @intCast(ShiftInt, index);
59 return self.free_registers & @as(FreeRegInt, 1) << shift != 0;
60 }
61
62 /// Before calling, must ensureCapacity + 1 on self.registers.
63 /// Returns `null` if all registers are allocated.
64 pub fn tryAllocReg(self: *Self, inst: *ir.Inst) ?Register {
65 const free_index = @ctz(FreeRegInt, self.free_registers);
66 if (free_index >= callee_preserved_regs.len) {
67 return null;
68 }
69 const mask = @as(FreeRegInt, 1) << free_index;
70 self.free_registers &= ~mask;
71 self.allocated_registers |= mask;
72 const reg = callee_preserved_regs[free_index];
73 self.registers.putAssumeCapacityNoClobber(reg, inst);
74 log.debug("alloc {} => {*}", .{ reg, inst });
75 return reg;
76 }
77
78 /// Before calling, must ensureCapacity + 1 on self.registers.
79 pub fn allocReg(self: *Self, inst: *ir.Inst) !Register {
80 return self.tryAllocReg(inst) orelse b: {
81 // We'll take over the first register. Move the instruction that was previously
82 // there to a stack allocation.
83 const reg = callee_preserved_regs[0];
84 const regs_entry = self.registers.getEntry(reg).?;
85 const spilled_inst = regs_entry.value;
86 regs_entry.value = inst;
87 try self.getFunction().spillInstruction(spilled_inst.src, reg, spilled_inst);
88
89 break :b reg;
90 };
91 }
92
93 /// Does not track the register.
94 /// Returns `null` if all registers are allocated.
95 pub fn findUnusedReg(self: *Self) ?Register {
96 const free_index = @ctz(FreeRegInt, self.free_registers);
97 if (free_index >= callee_preserved_regs.len) {
98 return null;
99 }
100 return callee_preserved_regs[free_index];
101 }
102
103 /// Does not track the register.
104 pub fn allocRegWithoutTracking(self: *Self) !Register {
105 return self.findUnusedReg() orelse b: {
106 // We'll take over the first register. Move the instruction that was previously
107 // there to a stack allocation.
108 const reg = callee_preserved_regs[0];
109 const regs_entry = self.registers.remove(reg).?;
110 const spilled_inst = regs_entry.value;
111 try self.getFunction().spillInstruction(spilled_inst.src, reg, spilled_inst);
112
113 break :b reg;
114 };
115 }
116
117 pub fn getRegAssumeFree(self: *Self, reg: Register, inst: *ir.Inst) !void {
118 try self.registers.putNoClobber(self.getFunction().gpa, reg, inst);
119 self.markRegUsed(reg);
120 }
121
122 pub fn freeReg(self: *Self, reg: Register) void {
123 _ = self.registers.remove(reg);
124 self.markRegFree(reg);
125 }
126 };
127}