Commit 7c1e17a840f8ff61372f04c5a9fc6282ad22e2c9 | zig

author	Jakub Konka <kubkon@jakubkonka.com> 2021-12-31 20:31:51+01:00
committer	GitHub <noreply@github.com> 2021-12-31 20:31:51+01:00
log	7c1e17a840f8ff61372f04c5a9fc6282ad22e2c9
tree	2ab32f42f282c04492c4c06611dbac7dada9d577
parent	e7ac05e882fa4290af4a41e9cae63105bcacb283
parent	c7f774803a3ecbc8d0641adde8ef0528f4a8bb8c
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #10470 from ziglang/stage2-x86_64-null-non-null

stage2: impl isNull/isNonNull, genSetReg for ptr_stack_offset, loading-storing via pointer (in register)

2 files changed, 188 insertions(+), 57 deletions(-)

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

src/arch/x86_64/CodeGen.zig+115-37

 @@ -1143,10 +1143,24 @@ fn airShr(self: *Self, inst: Air.Inst.Index) !void {
 fn airOptionalPayload(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 operand = try self.resolveInst(ty_op.operand);
-    else
+        if (self.wantSafety()) {
-        return self.fail("TODO implement .optional_payload for {}", .{self.target.cpu.arch});
+            // TODO check for null
+            return self.fail("TODO implement check for null in .optional_payload", .{});
+        }
+        const dst_mcv: MCValue = blk: {
+            if (self.reuseOperand(inst, ty_op.operand, 0, operand)) {
+                break :blk operand;
+            } else {
+                break :blk try self.allocRegOrMem(inst, true);
+            }
+        };
+        const ty = self.air.typeOf(ty_op.operand);
+        var buf: Type.Payload.ElemType = undefined;
+        try self.load(dst_mcv, operand, ty.optionalChild(&buf));
+        break :result dst_mcv;
+    };
     return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
 }
 @@ -1408,16 +1422,16 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
         .compare_flags_unsigned => unreachable,
         .compare_flags_signed => unreachable,
         .immediate => |imm| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),
-        .ptr_stack_offset => |off| try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off }),
+        .ptr_stack_offset => |off| {
+            try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off });
+        },
         .ptr_embedded_in_code => |off| {
             try self.setRegOrMem(elem_ty, dst_mcv, .{ .embedded_in_code = off });
         },
         .embedded_in_code => {
             return self.fail("TODO implement loading from MCValue.embedded_in_code", .{});
         },
-        .register => {
+        .register => |reg| try self.setRegOrMem(elem_ty, dst_mcv, .{ .register = reg }),
-            return self.fail("TODO implement loading from MCValue.register for {}", .{self.target.cpu.arch});
-        },
         .memory => |addr| {
             const reg = try self.register_manager.allocReg(null, &.{});
             try self.genSetReg(ptr_ty, reg, .{ .memory = addr });
 @@ -1479,8 +1493,8 @@ fn airStore(self: *Self, inst: Air.Inst.Index) !void {
         .embedded_in_code => {
             return self.fail("TODO implement storing to MCValue.embedded_in_code", .{});
         },
-        .register => {
+        .register => |reg| {
-            return self.fail("TODO implement storing to MCValue.register", .{});
+            try self.genSetPtrReg(elem_ty, reg, value);
         },
         .memory => {
             return self.fail("TODO implement storing to MCValue.memory", .{});
 @@ -2371,31 +2385,30 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, .unreach, .{ pl_op.operand, .none, .none });
 }
-fn isNull(self: *Self, operand: MCValue) !MCValue {
+fn isNull(self: *Self, ty: Type, operand: MCValue) !MCValue {
-    _ = operand;
+    try self.genBinMathOpMir(.cmp, ty, operand, MCValue{ .immediate = 0 });
-    // Here you can specialize this instruction if it makes sense to, otherwise the default
+    return MCValue{ .compare_flags_unsigned = .eq };
-    // will call isNonNull and invert the result.
-    return self.fail("TODO call isNonNull and invert the result", .{});
 }
-fn isNonNull(self: *Self, operand: MCValue) !MCValue {
+fn isNonNull(self: *Self, ty: Type, operand: MCValue) !MCValue {
-    _ = operand;
+    const is_null_res = try self.isNull(ty, operand);
-    // Here you can specialize this instruction if it makes sense to, otherwise the default
+    assert(is_null_res.compare_flags_unsigned == .eq);
-    // will call isNull and invert the result.
+    return MCValue{ .compare_flags_unsigned = .neq };
-    return self.fail("TODO call isNull and invert the result", .{});
 }
-fn isErr(self: *Self, operand: MCValue) !MCValue {
+fn isErr(self: *Self, ty: Type, operand: MCValue) !MCValue {
+    _ = ty;
     _ = operand;
     // Here you can specialize this instruction if it makes sense to, otherwise the default
-    // will call isNonNull and invert the result.
+    // will call isNonErr and invert the result.
     return self.fail("TODO call isNonErr and invert the result", .{});
 }
-fn isNonErr(self: *Self, operand: MCValue) !MCValue {
+fn isNonErr(self: *Self, ty: Type, operand: MCValue) !MCValue {
+    _ = ty;
     _ = operand;
     // Here you can specialize this instruction if it makes sense to, otherwise the default
-    // will call isNull and invert the result.
+    // will call isErr and invert the result.
     return self.fail("TODO call isErr and invert the result", .{});
 }
 @@ -2403,7 +2416,8 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
     const un_op = self.air.instructions.items(.data)[inst].un_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand = try self.resolveInst(un_op);
-        break :result try self.isNull(operand);
+        const ty = self.air.typeOf(un_op);
+        break :result try self.isNull(ty, operand);
     };
     return self.finishAir(inst, result, .{ un_op, .none, .none });
 }
 @@ -2420,8 +2434,9 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
                 break :blk try self.allocRegOrMem(inst, true);
             }
         };
-        try self.load(operand, operand_ptr, self.air.typeOf(un_op));
+        const ptr_ty = self.air.typeOf(un_op);
-        break :result try self.isNull(operand);
+        try self.load(operand, operand_ptr, ptr_ty);
+        break :result try self.isNull(ptr_ty.elemType(), operand);
     };
     return self.finishAir(inst, result, .{ un_op, .none, .none });
 }
 @@ -2430,7 +2445,8 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
     const un_op = self.air.instructions.items(.data)[inst].un_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand = try self.resolveInst(un_op);
-        break :result try self.isNonNull(operand);
+        const ty = self.air.typeOf(un_op);
+        break :result try self.isNonNull(ty, operand);
     };
     return self.finishAir(inst, result, .{ un_op, .none, .none });
 }
 @@ -2447,8 +2463,9 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
                 break :blk try self.allocRegOrMem(inst, true);
             }
         };
-        try self.load(operand, operand_ptr, self.air.typeOf(un_op));
+        const ptr_ty = self.air.typeOf(un_op);
-        break :result try self.isNonNull(operand);
+        try self.load(operand, operand_ptr, ptr_ty);
+        break :result try self.isNonNull(ptr_ty.elemType(), operand);
     };
     return self.finishAir(inst, result, .{ un_op, .none, .none });
 }
 @@ -2457,7 +2474,8 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
     const un_op = self.air.instructions.items(.data)[inst].un_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand = try self.resolveInst(un_op);
-        break :result try self.isErr(operand);
+        const ty = self.air.typeOf(un_op);
+        break :result try self.isErr(ty, operand);
     };
     return self.finishAir(inst, result, .{ un_op, .none, .none });
 }
 @@ -2474,8 +2492,9 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
                 break :blk try self.allocRegOrMem(inst, true);
             }
         };
-        try self.load(operand, operand_ptr, self.air.typeOf(un_op));
+        const ptr_ty = self.air.typeOf(un_op);
-        break :result try self.isErr(operand);
+        try self.load(operand, operand_ptr, ptr_ty);
+        break :result try self.isErr(ptr_ty.elemType(), operand);
     };
     return self.finishAir(inst, result, .{ un_op, .none, .none });
 }
 @@ -2484,7 +2503,8 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
     const un_op = self.air.instructions.items(.data)[inst].un_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand = try self.resolveInst(un_op);
-        break :result try self.isNonErr(operand);
+        const ty = self.air.typeOf(un_op);
+        break :result try self.isNonErr(ty, operand);
     };
     return self.finishAir(inst, result, .{ un_op, .none, .none });
 }
 @@ -2501,8 +2521,9 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
                 break :blk try self.allocRegOrMem(inst, true);
             }
         };
-        try self.load(operand, operand_ptr, self.air.typeOf(un_op));
+        const ptr_ty = self.air.typeOf(un_op);
-        break :result try self.isNonErr(operand);
+        try self.load(operand, operand_ptr, ptr_ty);
+        break :result try self.isNonErr(ptr_ty.elemType(), operand);
     };
     return self.finishAir(inst, result, .{ un_op, .none, .none });
 }
 @@ -2899,10 +2920,67 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
     }
 }
+/// Set pointee via pointer stored in a register.
+/// mov [reg], value
+fn genSetPtrReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void {
+    switch (mcv) {
+        .dead => unreachable,
+        .unreach, .none => return, // Nothing to do.
+        .immediate => |imm| {
+            const abi_size = ty.abiSize(self.target.*);
+            switch (abi_size) {
+                1, 2, 4 => {
+                    // TODO this is wasteful!
+                    // introduce new MIR tag specifically for mov [reg + 0], imm
+                    const payload = try self.addExtra(Mir.ImmPair{
+                        .dest_off = 0,
+                        .operand = @bitCast(i32, @intCast(u32, imm)),
+                    });
+                    _ = try self.addInst(.{
+                        .tag = .mov_mem_imm,
+                        .ops = (Mir.Ops{
+                            .reg1 = reg.to64(),
+                            .flags = switch (abi_size) {
+                                1 => 0b00,
+                                2 => 0b01,
+                                4 => 0b10,
+                                else => unreachable,
+                            },
+                        }).encode(),
+                        .data = .{ .payload = payload },
+                    });
+                },
+                else => {
+                    return self.fail("TODO implement set pointee with immediate of ABI size {d}", .{abi_size});
+                },
+            }
+        },
+        else => |other| {
+            return self.fail("TODO implement set pointee with {}", .{other});
+        },
+    }
+}
 fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void {
     switch (mcv) {
         .dead => unreachable,
-        .ptr_stack_offset => unreachable,
+        .ptr_stack_offset => |unadjusted_off| {
+            const ptr_abi_size = ty.abiSize(self.target.*);
+            const elem_ty = ty.childType();
+            const elem_abi_size = elem_ty.abiSize(self.target.*);
+            const off = unadjusted_off + elem_abi_size;
+            if (off < std.math.minInt(i32) or off > std.math.maxInt(i32)) {
+                return self.fail("stack offset too large", .{});
+            }
+            _ = try self.addInst(.{
+                .tag = .lea,
+                .ops = (Mir.Ops{
+                    .reg1 = registerAlias(reg, @intCast(u32, ptr_abi_size)),
+                    .reg2 = .rbp,
+                }).encode(),
+                .data = .{ .imm = -@intCast(i32, off) },
+            });
+        },
         .ptr_embedded_in_code => unreachable,
         .unreach, .none => return, // Nothing to do.
         .undef => {

test/stage2/x86_64.zig+73-20

...	@@ -1662,27 +1662,80 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -1662,27 +1662,80 @@ pub fn addCases(ctx: *TestContext) !void {
1662	"",	1662	"",
1663	);	1663	);
1664	}	1664	}
1665	}	1665	{
		1666	var case = ctx.exe("issue 7187: miscompilation with bool return type", target);
		1667	case.addCompareOutput(
		1668	\\pub fn main() void {
		1669	\\ var x: usize = 1;
		1670	\\ var y: bool = getFalse();
		1671	\\ _ = y;
		1672	\\
		1673	\\ assert(x == 1);
		1674	\\}
		1675	\\
		1676	\\fn getFalse() bool {
		1677	\\ return false;
		1678	\\}
		1679	\\
		1680	\\fn assert(ok: bool) void {
		1681	\\ if (!ok) unreachable;
		1682	\\}
		1683	, "");
		1684	}
1666		1685
1667	{	1686	{
1668	var case = ctx.exe("issue 7187: miscompilation with bool return type", linux_x64);	1687	var case = ctx.exe("load-store via pointer deref", target);
1669	case.addCompareOutput(	1688	case.addCompareOutput(
1670	\\pub fn main() void {	1689	\\pub fn main() void {
1671	\\ var x: usize = 1;	1690	\\ var x: u32 = undefined;
1672	\\ var y: bool = getFalse();	1691	\\ set(&x);
1673	\\ _ = y;	1692	\\ assert(x == 123);
1674	\\	1693	\\}
1675	\\ assert(x == 1);	1694	\\
1676	\\}	1695	\\fn set(x: *u32) void {
1677	\\	1696	\\ x.* = 123;
1678	\\fn getFalse() bool {	1697	\\}
1679	\\ return false;	1698	\\
1680	\\}	1699	\\fn assert(ok: bool) void {
1681	\\	1700	\\ if (!ok) unreachable;
1682	\\fn assert(ok: bool) void {	1701	\\}
1683	\\ if (!ok) unreachable;	1702	, "");
1684	\\}	1703	}
1685	, "");	1704
		1705	{
		1706	var case = ctx.exe("optional payload", target);
		1707	case.addCompareOutput(
		1708	\\pub fn main() void {
		1709	\\ var x: u32 = undefined;
		1710	\\ const maybe_x = byPtr(&x);
		1711	\\ assert(maybe_x != null);
		1712	\\}
		1713	\\
		1714	\\fn byPtr(x: u32) ?u32 {
		1715	\\ return x;
		1716	\\}
		1717	\\
		1718	\\fn assert(ok: bool) void {
		1719	\\ if (!ok) unreachable;
		1720	\\}
		1721	, "");
		1722	case.addCompareOutput(
		1723	\\pub fn main() void {
		1724	\\ var x: u32 = undefined;
		1725	\\ const maybe_x = byPtr(&x);
		1726	\\ assert(maybe_x == null);
		1727	\\}
		1728	\\
		1729	\\fn byPtr(x: u32) ?u32 {
		1730	\\ _ = x;
		1731	\\ return null;
		1732	\\}
		1733	\\
		1734	\\fn assert(ok: bool) void {
		1735	\\ if (!ok) unreachable;
		1736	\\}
		1737	, "");
		1738	}
1686	}	1739	}
1687	}	1740	}
1688		1741