Commit 845531dde10d215dc23956e2dc8a9a78125712a8 | zig

author	Joachim Schmidt <joachim.schmidt557@outlook.com> 2021-12-31 17:33:08+01:00
committer	Joachim Schmidt <joachim.schmidt557@outlook.com> 2022-01-01 11:16:38+01:00
log	845531dde10d215dc23956e2dc8a9a78125712a8
tree	8c82bfcc788fa5dbc25a2931b1c65c7fcc0b81bd
parent	f8163f7eaf45fa2b53a1f5ceac35088ad7d73e45
signature	Commit is signed but in an unrecognized format.

stage2 ARM: implement airUnwrapErrErr + airCmp for error sets

2 files changed, 62 insertions(+), 19 deletions(-)

src
- arch
  - arm
    CodeGen.zig
test
- stage2
  - arm.zig

src/arch/arm/CodeGen.zig+33-19

 @@ -1099,15 +1099,22 @@ fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
 fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
     const ty_op = self.air.instructions.items(.data)[inst].ty_op;
-    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union error for {}", .{self.target.cpu.arch});
+    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
+        const error_union_ty = self.air.typeOf(ty_op.operand);
+        const payload_ty = error_union_ty.errorUnionPayload();
+        const mcv = try self.resolveInst(ty_op.operand);
+        if (!payload_ty.hasCodeGenBits()) break :result mcv;
+        return self.fail("TODO implement unwrap error union error for non-empty payloads", .{});
+    };
     return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
 }
 fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
     const ty_op = self.air.instructions.items(.data)[inst].ty_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
-        const err_ty = self.air.typeOf(ty_op.operand);
+        const error_union_ty = self.air.typeOf(ty_op.operand);
-        const payload_ty = err_ty.errorUnionPayload();
+        const payload_ty = error_union_ty.errorUnionPayload();
         if (!payload_ty.hasCodeGenBits()) break :result MCValue.none;
         return self.fail("TODO implement unwrap error union payload for non-empty payloads", .{});
 @@ -2411,19 +2418,26 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
 fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
     const bin_op = self.air.instructions.items(.data)[inst].bin_op;
-    if (self.liveness.isUnused(inst))
+    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
-        return self.finishAir(inst, .dead, .{ bin_op.lhs, bin_op.rhs, .none });
+        const lhs = try self.resolveInst(bin_op.lhs);
-    const ty = self.air.typeOf(bin_op.lhs);
+        const rhs = try self.resolveInst(bin_op.rhs);
-    assert(ty.eql(self.air.typeOf(bin_op.rhs)));
+        const lhs_ty = self.air.typeOf(bin_op.lhs);
-    if (ty.zigTypeTag() == .ErrorSet)
-        return self.fail("TODO implement cmp for errors", .{});
-    try self.spillCompareFlagsIfOccupied();
+        if (lhs_ty.abiSize(self.target.*) > 4) {
-    self.compare_flags_inst = inst;
+            return self.fail("TODO cmp for types with size > 4", .{});
+        }
+        const signedness: std.builtin.Signedness = blk: {
+            // by default we tell the operand type is unsigned (i.e. bools and enum values)
+            if (lhs_ty.zigTypeTag() != .Int) break :blk .unsigned;
+            // incase of an actual integer, we emit the correct signedness
+            break :blk lhs_ty.intInfo(self.target.*).signedness;
+        };
+        try self.spillCompareFlagsIfOccupied();
+        self.compare_flags_inst = inst;
-    const lhs = try self.resolveInst(bin_op.lhs);
-    const rhs = try self.resolveInst(bin_op.rhs);
-    const result: MCValue = result: {
         const lhs_is_register = lhs == .register;
         const rhs_is_register = rhs == .register;
         // lhs should always be a register
 @@ -2457,11 +2471,11 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
         // Move the operands to the newly allocated registers
         const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
         if (lhs_mcv == .register and !lhs_is_register) {
-            try self.genSetReg(ty, lhs_mcv.register, lhs);
+            try self.genSetReg(lhs_ty, lhs_mcv.register, lhs);
             branch.inst_table.putAssumeCapacity(Air.refToIndex(bin_op.lhs).?, lhs);
         }
         if (rhs_mcv == .register and !rhs_is_register) {
-            try self.genSetReg(ty, rhs_mcv.register, rhs);
+            try self.genSetReg(lhs_ty, rhs_mcv.register, rhs);
             branch.inst_table.putAssumeCapacity(Air.refToIndex(bin_op.rhs).?, rhs);
         }
 @@ -2469,9 +2483,9 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
         // The signedness of the integer does not matter for the cmp instruction
         try self.genArmBinOpCode(undefined, lhs_mcv, rhs_mcv, false, .cmp_eq, undefined);
-        break :result switch (ty.isSignedInt()) {
+        break :result switch (signedness) {
-            true => MCValue{ .compare_flags_signed = op },
+            .signed => MCValue{ .compare_flags_signed = op },
-            false => MCValue{ .compare_flags_unsigned = op },
+            .unsigned => MCValue{ .compare_flags_unsigned = op },
         };
     };
     return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });

test/stage2/arm.zig+29

...	@@ -636,6 +636,35 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -636,6 +636,35 @@ pub fn addCases(ctx: *TestContext) !void {
636	,	636	,
637	"Hello, World!\n",	637	"Hello, World!\n",
638	);	638	);
		639
		640	case.addCompareOutput(
		641	\\pub fn main() void {
		642	\\ foo() catch \|err\| {
		643	\\ assert(err == error.Foo);
		644	\\ assert(err != error.Bar);
		645	\\ assert(err != error.Baz);
		646	\\ };
		647	\\ bar() catch \|err\| {
		648	\\ assert(err != error.Foo);
		649	\\ assert(err == error.Bar);
		650	\\ assert(err != error.Baz);
		651	\\ };
		652	\\}
		653	\\
		654	\\fn assert(ok: bool) void {
		655	\\ if (!ok) unreachable;
		656	\\}
		657	\\
		658	\\fn foo() anyerror!void {
		659	\\ return error.Foo;
		660	\\}
		661	\\
		662	\\fn bar() anyerror!void {
		663	\\ return error.Bar;
		664	\\}
		665	,
		666	"",
		667	);
639	}	668	}
640		669
641	{	670	{