authorgravatar for joachim.schmidt557@outlook.comJoachim Schmidt <joachim.schmidt557@outlook.com> 2021-12-18 14:41:01+01:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2021-12-18 15:23:25-08:00
log9892684d3555193f6b9d9e6d52761cd5ea829b85
treeb6ca77a9908fc32f149b29040db6bfbb3201cc79
parent5b29b4ffa6d21d574ed6cb8a00e2aba9dcb79ff8

stage2 ARM: spill insts currently in compare flags if necessary

2 files changed, 80 insertions(+), 4 deletions(-)

src/arch/arm/CodeGen.zig+59-4
......@@ -76,6 +76,8 @@ blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, BlockData) = .{},
7676register_manager: RegisterManager(Self, Register, &callee_preserved_regs) = .{},
7777/// Maps offset to what is stored there.
7878stack: std.AutoHashMapUnmanaged(u32, StackAllocation) = .{},
79/// Tracks the current instruction allocated to the compare flags
80compare_flags_inst: ?Air.Inst.Index = null,
7981
8082/// Offset from the stack base, representing the end of the stack frame.
8183max_end_stack: u32 = 0,
......@@ -647,6 +649,9 @@ fn processDeath(self: *Self, inst: Air.Inst.Index) void {
647649 .register => |reg| {
648650 self.register_manager.freeReg(reg);
649651 },
652 .compare_flags_signed, .compare_flags_unsigned => {
653 self.compare_flags_inst = null;
654 },
650655 else => {}, // TODO process stack allocation death
651656 }
652657}
......@@ -779,6 +784,28 @@ pub fn spillInstruction(self: *Self, reg: Register, inst: Air.Inst.Index) !void
779784 try self.genSetStack(self.air.typeOfIndex(inst), stack_mcv.stack_offset, reg_mcv);
780785}
781786
787/// Save the current instruction stored in the compare flags if
788/// occupied
789fn spillCompareFlagsIfOccupied(self: *Self) !void {
790 if (self.compare_flags_inst) |inst_to_save| {
791 const mcv = self.getResolvedInstValue(inst_to_save);
792 assert(mcv == .compare_flags_signed or mcv == .compare_flags_unsigned);
793
794 const new_mcv = try self.allocRegOrMem(inst_to_save, true);
795 switch (new_mcv) {
796 .register => |reg| try self.genSetReg(self.air.typeOfIndex(inst_to_save), reg, mcv),
797 .stack_offset => |offset| try self.genSetStack(self.air.typeOfIndex(inst_to_save), offset, mcv),
798 else => unreachable,
799 }
800 log.debug("spilling {d} to mcv {any}", .{ inst_to_save, new_mcv });
801
802 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
803 try branch.inst_table.put(self.gpa, inst_to_save, new_mcv);
804
805 self.compare_flags_inst = null;
806 }
807}
808
782809/// Copies a value to a register without tracking the register. The register is not considered
783810/// allocated. A second call to `copyToTmpRegister` may return the same register.
784811/// This can have a side effect of spilling instructions to the stack to free up a register.
......@@ -890,10 +917,10 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
890917 };
891918 break :result r;
892919 },
893 else => {},
920 else => {
921 break :result try self.genArmBinOp(inst, ty_op.operand, .bool_true, .not);
922 },
894923 }
895
896 break :result try self.genArmBinOp(inst, ty_op.operand, .bool_true, .not);
897924 };
898925 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
899926}
......@@ -1831,6 +1858,16 @@ fn airCall(self: *Self, inst: Air.Inst.Index) !void {
18311858 var info = try self.resolveCallingConventionValues(fn_ty);
18321859 defer info.deinit(self);
18331860
1861 // According to the Procedure Call Standard for the ARM
1862 // Architecture, compare flags are not preserved across
1863 // calls. Therefore, if some value is currently stored there, we
1864 // need to save it.
1865 //
1866 // TODO once caller-saved registers are implemented, save them
1867 // here too, but crucially *after* we save the compare flags as
1868 // saving compare flags may require a new caller-saved register
1869 try self.spillCompareFlagsIfOccupied();
1870
18341871 // Make space for the arguments passed via the stack
18351872 self.max_end_stack += info.stack_byte_count;
18361873
......@@ -1984,6 +2021,9 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
19842021 if (ty.zigTypeTag() == .ErrorSet)
19852022 return self.fail("TODO implement cmp for errors", .{});
19862023
2024 try self.spillCompareFlagsIfOccupied();
2025 self.compare_flags_inst = inst;
2026
19872027 const lhs = try self.resolveInst(bin_op.lhs);
19882028 const rhs = try self.resolveInst(bin_op.rhs);
19892029 const result: MCValue = result: {
......@@ -2094,12 +2134,24 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
20942134 });
20952135 };
20962136
2137 // If the condition dies here in this condbr instruction, process
2138 // that death now instead of later as this has an effect on
2139 // whether it needs to be spilled in the branches
2140 if (self.liveness.operandDies(inst, 0)) {
2141 const op_int = @enumToInt(pl_op.operand);
2142 if (op_int >= Air.Inst.Ref.typed_value_map.len) {
2143 const op_index = @intCast(Air.Inst.Index, op_int - Air.Inst.Ref.typed_value_map.len);
2144 self.processDeath(op_index);
2145 }
2146 }
2147
20972148 // Capture the state of register and stack allocation state so that we can revert to it.
20982149 const parent_next_stack_offset = self.next_stack_offset;
20992150 const parent_free_registers = self.register_manager.free_registers;
21002151 var parent_stack = try self.stack.clone(self.gpa);
21012152 defer parent_stack.deinit(self.gpa);
21022153 const parent_registers = self.register_manager.registers;
2154 const parent_compare_flags_inst = self.compare_flags_inst;
21032155
21042156 try self.branch_stack.append(.{});
21052157
......@@ -2115,6 +2167,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
21152167 defer saved_then_branch.deinit(self.gpa);
21162168
21172169 self.register_manager.registers = parent_registers;
2170 self.compare_flags_inst = parent_compare_flags_inst;
21182171
21192172 self.stack.deinit(self.gpa);
21202173 self.stack = parent_stack;
......@@ -2206,7 +2259,9 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
22062259
22072260 self.branch_stack.pop().deinit(self.gpa);
22082261
2209 return self.finishAir(inst, .unreach, .{ pl_op.operand, .none, .none });
2262 // We already took care of pl_op.operand earlier, so we're going
2263 // to pass .none here
2264 return self.finishAir(inst, .unreach, .{ .none, .none, .none });
22102265}
22112266
22122267fn isNull(self: *Self, operand: MCValue) !MCValue {
test/stage2/arm.zig+21
......@@ -547,4 +547,25 @@ pub fn addCases(ctx: *TestContext) !void {
547547 ,
548548 );
549549 }
550
551 {
552 var case = ctx.exe("save compare flags", linux_arm);
553 case.addCompareOutput(
554 \\pub fn main() void {
555 \\ foo(2, 1);
556 \\}
557 \\
558 \\fn foo(x: u32, y: u32) void {
559 \\ const b = x > y;
560 \\ assert(b);
561 \\ assert(b);
562 \\}
563 \\
564 \\pub fn assert(ok: bool) void {
565 \\ if (!ok) unreachable; // assertion failure
566 \\}
567 ,
568 "",
569 );
570 }
550571}