Commit e9f069f53627f1e647a200da7bb75e7663705c5f | zig

author	Jakub Konka <kubkon@jakubkonka.com> 2022-01-03 17:05:56+01:00
committer	Jakub Konka <kubkon@jakubkonka.com> 2022-01-04 01:21:24+01:00
log	e9f069f53627f1e647a200da7bb75e7663705c5f
tree	0e7ea14a58224101a863c1b9492df3c032c4f4b7
parent	818672312ffa068e0272483a03e7a5ca774bcca5

stage2: implement isErr/isNonErr and unwrap error

2 files changed, 89 insertions(+), 39 deletions(-)

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

src/arch/x86_64/CodeGen.zig+66-39

 @@ -415,9 +415,14 @@ fn gen(self: *Self) InnerError!void {
         try self.genBody(self.air.getMainBody());
-        if (self.exitlude_jump_relocs.items.len == 1) {
+        // TODO can single exitlude jump reloc be elided? What if it is not at the end of the code?
-            self.mir_instructions.len -= 1;
+        // Example:
-        } else for (self.exitlude_jump_relocs.items) |jmp_reloc| {
+        // pub fn main() void {
+        //     maybeErr() catch return;
+        //     unreachable;
+        // }
+        // Eliding the reloc will cause a miscompilation in this case.
+        for (self.exitlude_jump_relocs.items) |jmp_reloc| {
             self.mir_instructions.items(.data)[jmp_reloc].inst = @intCast(u32, self.mir_instructions.len);
         }
 @@ -1180,19 +1185,24 @@ 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))
+    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
-        .dead
+        const err_union_ty = self.air.typeOf(ty_op.operand);
-    else
+        const payload_ty = err_union_ty.errorUnionPayload();
-        return self.fail("TODO implement unwrap error union error for {}", .{self.target.cpu.arch});
+        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))
+    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
-        .dead
+        const err_union_ty = self.air.typeOf(ty_op.operand);
-    else
+        const payload_ty = err_union_ty.errorUnionPayload();
-        return self.fail("TODO implement unwrap error union payload for {}", .{self.target.cpu.arch});
+        if (!payload_ty.hasCodeGenBits()) break :result MCValue.none;
+        return self.fail("TODO implement unwrap error union payload for non-empty payloads", .{});
+    };
     return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
 }
 @@ -2396,19 +2406,35 @@ fn isNonNull(self: *Self, ty: Type, operand: MCValue) !MCValue {
 }
 fn isErr(self: *Self, ty: Type, operand: MCValue) !MCValue {
-    _ = ty;
+    const err_type = ty.errorUnionSet();
-    _ = operand;
+    const payload_type = ty.errorUnionPayload();
-    // Here you can specialize this instruction if it makes sense to, otherwise the default
+    if (!err_type.hasCodeGenBits()) {
-    // will call isNonErr and invert the result.
+        return MCValue{ .immediate = 0 }; // always false
-    return self.fail("TODO call isNonErr and invert the result", .{});
+    } else if (!payload_type.hasCodeGenBits()) {
+        if (err_type.abiSize(self.target.*) <= 8) {
+            try self.genBinMathOpMir(.cmp, err_type, operand, MCValue{ .immediate = 0 });
+            return MCValue{ .compare_flags_unsigned = .gt };
+        } else {
+            return self.fail("TODO isErr for errors with size larger than register size", .{});
+        }
+    } else {
+        return self.fail("TODO isErr for non-empty payloads", .{});
+    }
 }
 fn isNonErr(self: *Self, ty: Type, operand: MCValue) !MCValue {
-    _ = ty;
+    const is_err_res = try self.isErr(ty, operand);
-    _ = operand;
+    switch (is_err_res) {
-    // Here you can specialize this instruction if it makes sense to, otherwise the default
+        .compare_flags_unsigned => |op| {
-    // will call isErr and invert the result.
+            assert(op == .gt);
-    return self.fail("TODO call isErr and invert the result", .{});
+            return MCValue{ .compare_flags_unsigned = .lte };
+        },
+        .immediate => |imm| {
+            assert(imm == 0);
+            return MCValue{ .immediate = 1 };
+        },
+        else => unreachable,
+    }
 }
 fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
 @@ -3435,31 +3461,32 @@ fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
             }
         },
         .ErrorSet => {
-            switch (typed_value.val.tag()) {
+            const err_name = typed_value.val.castTag(.@"error").?.data.name;
-                .@"error" => {
+            const module = self.bin_file.options.module.?;
-                    const err_name = typed_value.val.castTag(.@"error").?.data.name;
+            const global_error_set = module.global_error_set;
-                    const module = self.bin_file.options.module.?;
+            const error_index = global_error_set.get(err_name).?;
-                    const global_error_set = module.global_error_set;
+            return MCValue{ .immediate = error_index };
-                    const error_index = global_error_set.get(err_name).?;
-                    return MCValue{ .immediate = error_index };
-                },
-                else => {
-                    // In this case we are rendering an error union which has a 0 bits payload.
-                    return MCValue{ .immediate = 0 };
-                },
-            }
         },
         .ErrorUnion => {
             const error_type = typed_value.ty.errorUnionSet();
             const payload_type = typed_value.ty.errorUnionPayload();
-            const sub_val = typed_value.val.castTag(.eu_payload).?.data;
-            if (!payload_type.hasCodeGenBits()) {
+            if (typed_value.val.castTag(.eu_payload)) |pl| {
-                // We use the error type directly as the type.
+                if (!payload_type.hasCodeGenBits()) {
-                return self.genTypedValue(.{ .ty = error_type, .val = sub_val });
+                    // We use the error type directly as the type.
+                    return MCValue{ .immediate = 0 };
+                }
+                _ = pl;
+                return self.fail("TODO implement error union const of type '{}' (non-error)", .{typed_value.ty});
+            } else {
+                if (!payload_type.hasCodeGenBits()) {
+                    // We use the error type directly as the type.
+                    return self.genTypedValue(.{ .ty = error_type, .val = typed_value.val });
+                }
             }
-            return self.fail("TODO implement error union const of type '{}'", .{typed_value.ty});
+            return self.fail("TODO implement error union const of type '{}' (error)", .{typed_value.ty});
         },
         else => return self.fail("TODO implement const of type '{}'", .{typed_value.ty}),
     }

test/stage2/x86_64.zig+23

...	@@ -1738,6 +1738,29 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -1738,6 +1738,29 @@ pub fn addCases(ctx: *TestContext) !void {
1738	\\}	1738	\\}
1739	, "");	1739	, "");
1740	}	1740	}
		1741
		1742	{
		1743	var case = ctx.exe("unwrap error union - simple errors", target);
		1744	case.addCompareOutput(
		1745	\\pub fn main() void {
		1746	\\ maybeErr() catch unreachable;
		1747	\\}
		1748	\\
		1749	\\fn maybeErr() !void {
		1750	\\ return;
		1751	\\}
		1752	, "");
		1753	case.addCompareOutput(
		1754	\\pub fn main() void {
		1755	\\ maybeErr() catch return;
		1756	\\ unreachable;
		1757	\\}
		1758	\\
		1759	\\fn maybeErr() !void {
		1760	\\ return error.NoWay;
		1761	\\}
		1762	, "");
		1763	}
1741	}	1764	}
1742	}	1765	}
1743		1766