Commit 6e3770e970dbf460271a0e0cb60c2bf40a7c861e | zig

author	Robin Voetter <robin@voetter.nl> 2023-05-18 02:45:21+02:00
committer	Robin Voetter <robin@voetter.nl> 2023-05-20 17:30:21+02:00
log	6e3770e970dbf460271a0e0cb60c2bf40a7c861e
tree	fa880846415c07b0d153688a1e1a7b8c35971671
parent	7077e90b3f8991c844deb08a16ad3f4e0569398f
signature	Commit is signed but in an unrecognized format.

spirv: implement pointer comparison in for air cmp

It turns out that the Khronos LLVM SPIRV translator does not support OpPtrEqual.
Therefore, this instruction is emitted using a series of conversions.

This commit breaks intToEnum, because enum was removed from the arithmetic type
info. The enum should be converted to an int before this function is called.

4 files changed, 127 insertions(+), 87 deletions(-)

src
- codegen
  - spirv.zig
test
- behavior

src/codegen/spirv.zig+114-61

 @@ -369,17 +369,6 @@ pub const DeclGen = struct {
                         .composite_integer,
                 };
             },
-            .Enum => blk: {
-                var buffer: Type.Payload.Bits = undefined;
-                const int_ty = ty.intTagType(&buffer);
-                const int_info = int_ty.intInfo(target);
-                break :blk ArithmeticTypeInfo{
-                    .bits = int_info.bits,
-                    .is_vector = false,
-                    .signedness = int_info.signedness,
-                    .class = .integer,
-                };
-            },
             // As of yet, there is no vector support in the self-hosted compiler.
             .Vector => self.todo("implement arithmeticTypeInfo for Vector", .{}),
             // TODO: For which types is this the case?
 @@ -1742,12 +1731,12 @@ pub const DeclGen = struct {
             .struct_field_ptr_index_2 => try self.airStructFieldPtrIndex(inst, 2),
             .struct_field_ptr_index_3 => try self.airStructFieldPtrIndex(inst, 3),
-            .cmp_eq  => try self.airCmp(inst, .OpFOrdEqual,            .OpLogicalEqual,      .OpIEqual),
+            .cmp_eq  => try self.airCmp(inst, .eq),
-            .cmp_neq => try self.airCmp(inst, .OpFOrdNotEqual,         .OpLogicalNotEqual,   .OpINotEqual),
+            .cmp_neq => try self.airCmp(inst, .neq),
-            .cmp_gt  => try self.airCmp(inst, .OpFOrdGreaterThan,      .OpSGreaterThan,      .OpUGreaterThan),
+            .cmp_gt  => try self.airCmp(inst, .gt),
-            .cmp_gte => try self.airCmp(inst, .OpFOrdGreaterThanEqual, .OpSGreaterThanEqual, .OpUGreaterThanEqual),
+            .cmp_gte => try self.airCmp(inst, .gte),
-            .cmp_lt  => try self.airCmp(inst, .OpFOrdLessThan,         .OpSLessThan,         .OpULessThan),
+            .cmp_lt  => try self.airCmp(inst, .lt),
-            .cmp_lte => try self.airCmp(inst, .OpFOrdLessThanEqual,    .OpSLessThanEqual,    .OpULessThanEqual),
+            .cmp_lte => try self.airCmp(inst, .lte),
             .arg     => self.airArg(),
             .alloc   => try self.airAlloc(inst),
 @@ -2039,58 +2028,122 @@ pub const DeclGen = struct {
         return result_id;
     }
-    fn airCmp(self: *DeclGen, inst: Air.Inst.Index, comptime fop: Opcode, comptime sop: Opcode, comptime uop: Opcode) !?IdRef {
+    fn cmp(
-        if (self.liveness.isUnused(inst)) return null;
+        self: *DeclGen,
-        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        comptime op: std.math.CompareOperator,
-        var lhs_id = try self.resolve(bin_op.lhs);
+        bool_ty_id: IdRef,
-        var rhs_id = try self.resolve(bin_op.rhs);
+        ty: Type,
-        const result_id = self.spv.allocId();
+        lhs_id: IdRef,
-        const result_type_id = try self.resolveTypeId(Type.bool);
+        rhs_id: IdRef,
-        const op_ty = self.air.typeOf(bin_op.lhs);
+    ) !IdRef {
-        assert(op_ty.eql(self.air.typeOf(bin_op.rhs), self.module));
+        var cmp_lhs_id = lhs_id;
+        var cmp_rhs_id = rhs_id;
+        const opcode: Opcode = opcode: {
+            var int_buffer: Type.Payload.Bits = undefined;
+            const op_ty = switch (ty.zigTypeTag()) {
+                .Int, .Bool, .Float => ty,
+                .Enum => ty.intTagType(&int_buffer),
+                .ErrorSet => Type.u16,
+                .Pointer => blk: {
+                    // Note that while SPIR-V offers OpPtrEqual and OpPtrNotEqual, they are
+                    // currently not implemented in the SPIR-V LLVM translator. Thus, we emit these using
+                    // OpConvertPtrToU...
+                    cmp_lhs_id = self.spv.allocId();
+                    cmp_rhs_id = self.spv.allocId();
+                    const usize_ty_id = self.typeId(try self.sizeType());
+                    try self.func.body.emit(self.spv.gpa, .OpConvertPtrToU, .{
+                        .id_result_type = usize_ty_id,
+                        .id_result = cmp_lhs_id,
+                        .pointer = lhs_id,
+                    });
-        // Comparisons are generally applicable to both scalar and vector operations in SPIR-V,
+                    try self.func.body.emit(self.spv.gpa, .OpConvertPtrToU, .{
-        // but int and float versions of operations require different opcodes.
+                        .id_result_type = usize_ty_id,
-        const info = try self.arithmeticTypeInfo(op_ty);
+                        .id_result = cmp_rhs_id,
+                        .pointer = rhs_id,
+                    });
-        const opcode_index: usize = switch (info.class) {
+                    break :blk Type.usize;
-            .composite_integer => {
+                },
-                return self.todo("binary operations for composite integers", .{});
+                .Optional => unreachable, // TODO
-            },
+                else => unreachable,
-            .float => 0,
+            };
-            .bool => 1,
-            .strange_integer => blk: {
-                const op_ty_ref = try self.resolveType(op_ty, .direct);
-                lhs_id = try self.maskStrangeInt(op_ty_ref, lhs_id, info.bits);
-                rhs_id = try self.maskStrangeInt(op_ty_ref, rhs_id, info.bits);
-                break :blk switch (info.signedness) {
-                    .signed => @as(usize, 1),
-                    .unsigned => @as(usize, 2),
-                };
-            },
-            .integer => switch (info.signedness) {
-                .signed => @as(usize, 1),
-                .unsigned => @as(usize, 2),
-            },
-        };
-        const operands = .{
+            const info = try self.arithmeticTypeInfo(op_ty);
-            .id_result_type = result_type_id,
+            const signedness = switch (info.class) {
-            .id_result = result_id,
+                .composite_integer => {
-            .operand_1 = lhs_id,
+                    return self.todo("binary operations for composite integers", .{});
-            .operand_2 = rhs_id,
+                },
-        };
+                .float => break :opcode switch (op) {
+                    .eq => .OpFOrdEqual,
+                    .neq => .OpFOrdNotEqual,
+                    .lt => .OpFOrdLessThan,
+                    .lte => .OpFOrdLessThanEqual,
+                    .gt => .OpFOrdGreaterThan,
+                    .gte => .OpFOrdGreaterThanEqual,
+                },
+                .bool => break :opcode switch (op) {
+                    .eq => .OpIEqual,
+                    .neq => .OpINotEqual,
+                    else => unreachable,
+                },
+                .strange_integer => sign: {
+                    const op_ty_ref = try self.resolveType(op_ty, .direct);
+                    // Mask operands before performing comparison.
+                    cmp_lhs_id = try self.maskStrangeInt(op_ty_ref, cmp_lhs_id, info.bits);
+                    cmp_rhs_id = try self.maskStrangeInt(op_ty_ref, cmp_rhs_id, info.bits);
+                    break :sign info.signedness;
+                },
+                .integer => info.signedness,
+            };
-        switch (opcode_index) {
+            break :opcode switch (signedness) {
-            0 => try self.func.body.emit(self.spv.gpa, fop, operands),
+                .unsigned => switch (op) {
-            1 => try self.func.body.emit(self.spv.gpa, sop, operands),
+                    .eq => .OpIEqual,
-            2 => try self.func.body.emit(self.spv.gpa, uop, operands),
+                    .neq => .OpINotEqual,
-            else => unreachable,
+                    .lt => .OpULessThan,
-        }
+                    .lte => .OpULessThanEqual,
+                    .gt => .OpUGreaterThan,
+                    .gte => .OpUGreaterThanEqual,
+                },
+                .signed => switch (op) {
+                    .eq => .OpIEqual,
+                    .neq => .OpINotEqual,
+                    .lt => .OpSLessThan,
+                    .lte => .OpSLessThanEqual,
+                    .gt => .OpSGreaterThan,
+                    .gte => .OpSGreaterThanEqual,
+                },
+            };
+        };
+        const result_id = self.spv.allocId();
+        try self.func.body.emitRaw(self.spv.gpa, opcode, 4);
+        self.func.body.writeOperand(spec.IdResultType, bool_ty_id);
+        self.func.body.writeOperand(spec.IdResult, result_id);
+        self.func.body.writeOperand(spec.IdResultType, cmp_lhs_id);
+        self.func.body.writeOperand(spec.IdResultType, cmp_rhs_id);
         return result_id;
     }
+    fn airCmp(
+        self: *DeclGen,
+        inst: Air.Inst.Index,
+        comptime op: std.math.CompareOperator,
+    ) !?IdRef {
+        if (self.liveness.isUnused(inst)) return null;
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const lhs_id = try self.resolve(bin_op.lhs);
+        const rhs_id = try self.resolve(bin_op.rhs);
+        const bool_ty_id = try self.resolveTypeId(Type.bool);
+        const ty = self.air.typeOf(bin_op.lhs);
+        assert(ty.eql(self.air.typeOf(bin_op.rhs), self.module));
+        return try self.cmp(op, bool_ty_id, ty, lhs_id, rhs_id);
+    }
     fn bitcast(self: *DeclGen, target_type_id: IdResultType, value_id: IdRef) !IdRef {
         const result_id = self.spv.allocId();
         try self.func.body.emit(self.spv.gpa, .OpBitcast, .{

test/behavior/basic.zig-17

 @@ -134,21 +134,18 @@ fn first4KeysOfHomeRow() []const u8 {
 test "return string from function" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
 }
 test "hex escape" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
 }
 test "multiline string" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const s1 =
         \\one
 @@ -161,7 +158,6 @@ test "multiline string" {
 test "multiline string comments at start" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const s1 =
         //\\one
 @@ -174,7 +170,6 @@ test "multiline string comments at start" {
 test "multiline string comments at end" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const s1 =
         \\one
 @@ -187,7 +182,6 @@ test "multiline string comments at end" {
 test "multiline string comments in middle" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const s1 =
         \\one
 @@ -200,7 +194,6 @@ test "multiline string comments in middle" {
 test "multiline string comments at multiple places" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const s1 =
         \\one
 @@ -214,14 +207,11 @@ test "multiline string comments at multiple places" {
 }
 test "string concatenation simple" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
 }
 test "array mult operator" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
 }
 @@ -387,7 +377,6 @@ test "take address of parameter" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     try testTakeAddressOfParameter(12.34);
 }
 @@ -690,8 +679,6 @@ test "explicit cast optional pointers" {
 }
 test "pointer comparison" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const a = @as([]const u8, "a");
     const b = &a;
     try expect(ptrEql(b, b));
 @@ -892,8 +879,6 @@ test "catch in block has correct result location" {
 }
 test "labeled block with runtime branch forwards its result location type to break statements" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const E = enum { a, b };
     var a = false;
     const e: E = blk: {
 @@ -1062,8 +1047,6 @@ test "switch inside @as gets correct type" {
 }
 test "inline call of function with a switch inside the return statement" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const S = struct {
         inline fn foo(x: anytype) @TypeOf(x) {
             return switch (x) {

test/behavior/enum.zig+2

...	@@ -20,6 +20,8 @@ test "enum to int" {	...	@@ -20,6 +20,8 @@ test "enum to int" {
20	}	20	}
21		21
22	fn testIntToEnumEval(x: i32) !void {	22	fn testIntToEnumEval(x: i32) !void {
		23	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		24
23	try expect(@intToEnum(IntToEnumNumber, x) == IntToEnumNumber.Three);	25	try expect(@intToEnum(IntToEnumNumber, x) == IntToEnumNumber.Three);
24	}	26	}
25	const IntToEnumNumber = enum { Zero, One, Two, Three, Four };	27	const IntToEnumNumber = enum { Zero, One, Two, Three, Four };

test/behavior/memcpy.zig+11-9

...	@@ -67,14 +67,16 @@ fn testMemcpyDestManyPtr() !void {	...	@@ -67,14 +67,16 @@ fn testMemcpyDestManyPtr() !void {
67	}	67	}
68		68
69	comptime {	69	comptime {
70	const S = struct {	70	if (builtin.zig_backend != .stage2_spirv64) {
71	buffer: [8]u8 = undefined,	71	const S = struct {
72	fn set(self: *@This(), items: []const u8) void {	72	buffer: [8]u8 = undefined,
73	@memcpy(self.buffer[0..items.len], items);	73	fn set(self: *@This(), items: []const u8) void {
74	}	74	@memcpy(self.buffer[0..items.len], items);
75	};	75	}
		76	};
76		77
77	var s = S{};	78	var s = S{};
78	s.set("hello");	79	s.set("hello");
79	if (!std.mem.eql(u8, s.buffer[0..5], "hello")) @compileError("bad");	80	if (!std.mem.eql(u8, s.buffer[0..5], "hello")) @compileError("bad");
		81	}
80	}	82	}