authorgravatar for alichraghi@proton.meAli Chraghi <alichraghi@proton.me> 2025-03-09 06:41:56+03:30
committergravatar for alichraghi@proton.meAli Chraghi <alichraghi@proton.me> 2025-03-17 21:56:14+03:30
logc1977bf0fbe523afb4721bc8346ee6536e3c0aa2
tree0cff580546cdab5f638ae74991e0b496cb3f6904
parent2fc409a32f18b0c62e3918f0b832ed9e4c8d142d

Sema: error on illegal code when targeting spirv

6 files changed, 119 insertions(+), 29 deletions(-)

src/Sema.zig+53-24
...@@ -3648,7 +3648,7 @@ fn indexablePtrLen(...@@ -3648,7 +3648,7 @@ fn indexablePtrLen(
3648 const object_ty = sema.typeOf(object);3648 const object_ty = sema.typeOf(object);
3649 const is_pointer_to = object_ty.isSinglePointer(zcu);3649 const is_pointer_to = object_ty.isSinglePointer(zcu);
3650 const indexable_ty = if (is_pointer_to) object_ty.childType(zcu) else object_ty;3650 const indexable_ty = if (is_pointer_to) object_ty.childType(zcu) else object_ty;
3651 try checkIndexable(sema, block, src, indexable_ty);3651 try sema.checkIndexable(block, src, indexable_ty);
3652 const field_name = try zcu.intern_pool.getOrPutString(sema.gpa, pt.tid, "len", .no_embedded_nulls);3652 const field_name = try zcu.intern_pool.getOrPutString(sema.gpa, pt.tid, "len", .no_embedded_nulls);
3653 return sema.fieldVal(block, src, object, field_name, src);3653 return sema.fieldVal(block, src, object, field_name, src);
3654}3654}
...@@ -10103,6 +10103,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!...@@ -10103,6 +10103,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
10103 }10103 }
10104 try sema.requireRuntimeBlock(block, block.nodeOffset(inst_data.src_node), ptr_src);10104 try sema.requireRuntimeBlock(block, block.nodeOffset(inst_data.src_node), ptr_src);
10105 try sema.validateRuntimeValue(block, ptr_src, operand);10105 try sema.validateRuntimeValue(block, ptr_src, operand);
10106 try sema.checkLogicalPtrOperation(block, ptr_src, ptr_ty);
10106 if (!is_vector or zcu.backendSupportsFeature(.all_vector_instructions)) {10107 if (!is_vector or zcu.backendSupportsFeature(.all_vector_instructions)) {
10107 return block.addBitCast(dest_ty, operand);10108 return block.addBitCast(dest_ty, operand);
10108 }10109 }
...@@ -16389,6 +16390,8 @@ fn analyzeArithmetic(...@@ -16389,6 +16390,8 @@ fn analyzeArithmetic(
16389 };16390 };
1639016391
16391 try sema.requireRuntimeBlock(block, src, runtime_src);16392 try sema.requireRuntimeBlock(block, src, runtime_src);
16393 try sema.checkLogicalPtrOperation(block, src, lhs_ty);
16394 try sema.checkLogicalPtrOperation(block, src, rhs_ty);
16392 const lhs_int = try block.addBitCast(.usize, lhs);16395 const lhs_int = try block.addBitCast(.usize, lhs);
16393 const rhs_int = try block.addBitCast(.usize, rhs);16396 const rhs_int = try block.addBitCast(.usize, rhs);
16394 const address = try block.addBinOp(.sub_wrap, lhs_int, rhs_int);16397 const address = try block.addBinOp(.sub_wrap, lhs_int, rhs_int);
...@@ -16620,24 +16623,7 @@ fn analyzePtrArithmetic(...@@ -16620,24 +16623,7 @@ fn analyzePtrArithmetic(
16620 };16623 };
1662116624
16622 try sema.requireRuntimeBlock(block, op_src, runtime_src);16625 try sema.requireRuntimeBlock(block, op_src, runtime_src);
1662316626 try sema.checkLogicalPtrOperation(block, op_src, ptr_ty);
16624 const target = zcu.getTarget();
16625 if (target_util.arePointersLogical(target, ptr_info.flags.address_space)) {
16626 return sema.failWithOwnedErrorMsg(block, msg: {
16627 const msg = try sema.errMsg(op_src, "illegal pointer arithmetic on pointer of type '{}'", .{ptr_ty.fmt(pt)});
16628 errdefer msg.destroy(sema.gpa);
16629
16630 const backend = target_util.zigBackend(target, zcu.comp.config.use_llvm);
16631 try sema.errNote(op_src, msg, "arithmetic cannot be performed on pointers with address space '{s}' on target {s}-{s} by compiler backend {s}", .{
16632 @tagName(ptr_info.flags.address_space),
16633 target.cpu.arch.genericName(),
16634 @tagName(target.os.tag),
16635 @tagName(backend),
16636 });
16637
16638 break :msg msg;
16639 });
16640 }
1664116627
16642 return block.addInst(.{16628 return block.addInst(.{
16643 .tag = air_tag,16629 .tag = air_tag,
...@@ -22501,6 +22487,7 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!...@@ -22501,6 +22487,7 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
22501 });22487 });
22502 }22488 }
22503 try sema.requireRuntimeBlock(block, src, operand_src);22489 try sema.requireRuntimeBlock(block, src, operand_src);
22490 try sema.checkLogicalPtrOperation(block, src, ptr_ty);
22504 if (!is_vector or zcu.backendSupportsFeature(.all_vector_instructions)) {22491 if (!is_vector or zcu.backendSupportsFeature(.all_vector_instructions)) {
22505 if (block.wantSafety() and (try elem_ty.hasRuntimeBitsSema(pt) or elem_ty.zigTypeTag(zcu) == .@"fn")) {22492 if (block.wantSafety() and (try elem_ty.hasRuntimeBitsSema(pt) or elem_ty.zigTypeTag(zcu) == .@"fn")) {
22506 if (!ptr_ty.isAllowzeroPtr(zcu)) {22493 if (!ptr_ty.isAllowzeroPtr(zcu)) {
...@@ -23165,8 +23152,9 @@ fn ptrCastFull(...@@ -23165,8 +23152,9 @@ fn ptrCastFull(
2316523152
23166 try sema.validateRuntimeValue(block, operand_src, operand);23153 try sema.validateRuntimeValue(block, operand_src, operand);
2316723154
23168 const need_null_check = block.wantSafety() and operand_ty.ptrAllowsZero(zcu) and !dest_ty.ptrAllowsZero(zcu);23155 const can_cast_to_int = !target_util.arePointersLogical(zcu.getTarget(), operand_ty.ptrAddressSpace(zcu));
23169 const need_align_check = block.wantSafety() and dest_align.compare(.gt, src_align);23156 const need_null_check = can_cast_to_int and block.wantSafety() and operand_ty.ptrAllowsZero(zcu) and !dest_ty.ptrAllowsZero(zcu);
23157 const need_align_check = can_cast_to_int and block.wantSafety() and dest_align.compare(.gt, src_align);
2317023158
23171 // `operand` might be a slice. If `need_operand_ptr`, we'll populate `operand_ptr` with the raw pointer.23159 // `operand` might be a slice. If `need_operand_ptr`, we'll populate `operand_ptr` with the raw pointer.
23172 const need_operand_ptr = src_info.flags.size != .slice or // we already have it23160 const need_operand_ptr = src_info.flags.size != .slice or // we already have it
...@@ -23832,6 +23820,32 @@ fn checkPtrType(...@@ -23832,6 +23820,32 @@ fn checkPtrType(
23832 return sema.fail(block, ty_src, "expected pointer type, found '{}'", .{ty.fmt(pt)});23820 return sema.fail(block, ty_src, "expected pointer type, found '{}'", .{ty.fmt(pt)});
23833}23821}
2383423822
23823fn checkLogicalPtrOperation(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
23824 const pt = sema.pt;
23825 const zcu = pt.zcu;
23826 if (zcu.intern_pool.indexToKey(ty.toIntern()) == .ptr_type) {
23827 const target = zcu.getTarget();
23828 const as = ty.ptrAddressSpace(zcu);
23829 if (target_util.arePointersLogical(target, as)) {
23830 return sema.failWithOwnedErrorMsg(block, msg: {
23831 const msg = try sema.errMsg(src, "illegal operation on logical pointer of type '{}'", .{ty.fmt(pt)});
23832 errdefer msg.destroy(sema.gpa);
23833 try sema.errNote(
23834 src,
23835 msg,
23836 "cannot perform arithmetic on pointers with address space '{s}' on target {s}-{s}",
23837 .{
23838 @tagName(as),
23839 target.cpu.arch.genericName(),
23840 @tagName(target.os.tag),
23841 },
23842 );
23843 break :msg msg;
23844 });
23845 }
23846 }
23847}
23848
23835fn checkVectorElemType(23849fn checkVectorElemType(
23836 sema: *Sema,23850 sema: *Sema,
23837 block: *Block,23851 block: *Block,
...@@ -28326,7 +28340,7 @@ fn elemPtr(...@@ -28326,7 +28340,7 @@ fn elemPtr(
28326 .pointer => indexable_ptr_ty.childType(zcu),28340 .pointer => indexable_ptr_ty.childType(zcu),
28327 else => return sema.fail(block, indexable_ptr_src, "expected pointer, found '{}'", .{indexable_ptr_ty.fmt(pt)}),28341 else => return sema.fail(block, indexable_ptr_src, "expected pointer, found '{}'", .{indexable_ptr_ty.fmt(pt)}),
28328 };28342 };
28329 try checkIndexable(sema, block, src, indexable_ty);28343 try sema.checkIndexable(block, src, indexable_ty);
2833028344
28331 const elem_ptr = switch (indexable_ty.zigTypeTag(zcu)) {28345 const elem_ptr = switch (indexable_ty.zigTypeTag(zcu)) {
28332 .array, .vector => try sema.elemPtrArray(block, src, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init, oob_safety),28346 .array, .vector => try sema.elemPtrArray(block, src, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init, oob_safety),
...@@ -28362,7 +28376,7 @@ fn elemPtrOneLayerOnly(...@@ -28362,7 +28376,7 @@ fn elemPtrOneLayerOnly(
28362 const pt = sema.pt;28376 const pt = sema.pt;
28363 const zcu = pt.zcu;28377 const zcu = pt.zcu;
2836428378
28365 try checkIndexable(sema, block, src, indexable_ty);28379 try sema.checkIndexable(block, src, indexable_ty);
2836628380
28367 switch (indexable_ty.ptrSize(zcu)) {28381 switch (indexable_ty.ptrSize(zcu)) {
28368 .slice => return sema.elemPtrSlice(block, src, indexable_src, indexable, elem_index_src, elem_index, oob_safety),28382 .slice => return sema.elemPtrSlice(block, src, indexable_src, indexable, elem_index_src, elem_index, oob_safety),
...@@ -28376,6 +28390,8 @@ fn elemPtrOneLayerOnly(...@@ -28376,6 +28390,8 @@ fn elemPtrOneLayerOnly(
28376 const elem_ptr = try ptr_val.ptrElem(index, pt);28390 const elem_ptr = try ptr_val.ptrElem(index, pt);
28377 return Air.internedToRef(elem_ptr.toIntern());28391 return Air.internedToRef(elem_ptr.toIntern());
28378 }28392 }
28393
28394 try sema.checkLogicalPtrOperation(block, src, indexable_ty);
28379 const result_ty = try indexable_ty.elemPtrType(null, pt);28395 const result_ty = try indexable_ty.elemPtrType(null, pt);
2838028396
28381 return block.addPtrElemPtr(indexable, elem_index, result_ty);28397 return block.addPtrElemPtr(indexable, elem_index, result_ty);
...@@ -28412,7 +28428,7 @@ fn elemVal(...@@ -28412,7 +28428,7 @@ fn elemVal(
28412 const pt = sema.pt;28428 const pt = sema.pt;
28413 const zcu = pt.zcu;28429 const zcu = pt.zcu;
2841428430
28415 try checkIndexable(sema, block, src, indexable_ty);28431 try sema.checkIndexable(block, src, indexable_ty);
2841628432
28417 // TODO in case of a vector of pointers, we need to detect whether the element28433 // TODO in case of a vector of pointers, we need to detect whether the element
28418 // index is a scalar or vector instead of unconditionally casting to usize.28434 // index is a scalar or vector instead of unconditionally casting to usize.
...@@ -28438,6 +28454,7 @@ fn elemVal(...@@ -28438,6 +28454,7 @@ fn elemVal(
28438 return Air.internedToRef((try pt.getCoerced(elem_val, elem_ty)).toIntern());28454 return Air.internedToRef((try pt.getCoerced(elem_val, elem_ty)).toIntern());
28439 }28455 }
2844028456
28457 try sema.checkLogicalPtrOperation(block, src, indexable_ty);
28441 return block.addBinOp(.ptr_elem_val, indexable, elem_index);28458 return block.addBinOp(.ptr_elem_val, indexable, elem_index);
28442 },28459 },
28443 .one => {28460 .one => {
...@@ -28477,6 +28494,9 @@ fn validateRuntimeElemAccess(...@@ -28477,6 +28494,9 @@ fn validateRuntimeElemAccess(
28477 parent_ty: Type,28494 parent_ty: Type,
28478 parent_src: LazySrcLoc,28495 parent_src: LazySrcLoc,
28479) CompileError!void {28496) CompileError!void {
28497 const pt = sema.pt;
28498 const zcu = pt.zcu;
28499
28480 if (try elem_ty.comptimeOnlySema(sema.pt)) {28500 if (try elem_ty.comptimeOnlySema(sema.pt)) {
28481 const msg = msg: {28501 const msg = msg: {
28482 const msg = try sema.errMsg(28502 const msg = try sema.errMsg(
...@@ -28492,6 +28512,14 @@ fn validateRuntimeElemAccess(...@@ -28492,6 +28512,14 @@ fn validateRuntimeElemAccess(
28492 };28512 };
28493 return sema.failWithOwnedErrorMsg(block, msg);28513 return sema.failWithOwnedErrorMsg(block, msg);
28494 }28514 }
28515
28516 if (zcu.intern_pool.indexToKey(parent_ty.toIntern()) == .ptr_type) {
28517 const target = zcu.getTarget();
28518 const as = parent_ty.ptrAddressSpace(zcu);
28519 if (target_util.arePointersLogical(target, as)) {
28520 return sema.fail(block, elem_index_src, "cannot access element of logical pointer '{}'", .{parent_ty.fmt(pt)});
28521 }
28522 }
28495}28523}
2849628524
28497fn tupleFieldPtr(28525fn tupleFieldPtr(
...@@ -31158,6 +31186,7 @@ fn coerceCompatiblePtrs(...@@ -31158,6 +31186,7 @@ fn coerceCompatiblePtrs(
31158 if (block.wantSafety() and inst_allows_zero and !dest_ty.ptrAllowsZero(zcu) and31186 if (block.wantSafety() and inst_allows_zero and !dest_ty.ptrAllowsZero(zcu) and
31159 (try dest_ty.elemType2(zcu).hasRuntimeBitsSema(pt) or dest_ty.elemType2(zcu).zigTypeTag(zcu) == .@"fn"))31187 (try dest_ty.elemType2(zcu).hasRuntimeBitsSema(pt) or dest_ty.elemType2(zcu).zigTypeTag(zcu) == .@"fn"))
31160 {31188 {
31189 try sema.checkLogicalPtrOperation(block, inst_src, inst_ty);
31161 const actual_ptr = if (inst_ty.isSlice(zcu))31190 const actual_ptr = if (inst_ty.isSlice(zcu))
31162 try sema.analyzeSlicePtr(block, inst_src, inst, inst_ty)31191 try sema.analyzeSlicePtr(block, inst_src, inst, inst_ty)
31163 else31192 else
src/codegen/spirv.zig+6-5
...@@ -464,7 +464,7 @@ const NavGen = struct {...@@ -464,7 +464,7 @@ const NavGen = struct {
464464
465 const zcu = self.pt.zcu;465 const zcu = self.pt.zcu;
466 const ty = Type.fromInterned(zcu.intern_pool.typeOf(val));466 const ty = Type.fromInterned(zcu.intern_pool.typeOf(val));
467 const decl_ptr_ty_id = try self.ptrType(ty, .Generic, .indirect);467 const decl_ptr_ty_id = try self.ptrType(ty, self.spvStorageClass(.generic), .indirect);
468468
469 const spv_decl_index = blk: {469 const spv_decl_index = blk: {
470 const entry = try self.object.uav_link.getOrPut(self.object.gpa, .{ val, .Function });470 const entry = try self.object.uav_link.getOrPut(self.object.gpa, .{ val, .Function });
...@@ -4230,7 +4230,7 @@ const NavGen = struct {...@@ -4230,7 +4230,7 @@ const NavGen = struct {
4230 defer self.gpa.free(ids);4230 defer self.gpa.free(ids);
42314231
4232 const result_id = self.spv.allocId();4232 const result_id = self.spv.allocId();
4233 if (self.spv.hasFeature(.kernel)) {4233 if (self.spv.hasFeature(.addresses)) {
4234 try self.func.body.emit(self.spv.gpa, .OpInBoundsPtrAccessChain, .{4234 try self.func.body.emit(self.spv.gpa, .OpInBoundsPtrAccessChain, .{
4235 .id_result_type = result_ty_id,4235 .id_result_type = result_ty_id,
4236 .id_result = result_id,4236 .id_result = result_id,
...@@ -5293,7 +5293,7 @@ const NavGen = struct {...@@ -5293,7 +5293,7 @@ const NavGen = struct {
5293 /// The final storage class of the pointer. This may be either `.Generic` or `.Function`.5293 /// The final storage class of the pointer. This may be either `.Generic` or `.Function`.
5294 /// In either case, the local is allocated in the `.Function` storage class, and optionally5294 /// In either case, the local is allocated in the `.Function` storage class, and optionally
5295 /// cast back to `.Generic`.5295 /// cast back to `.Generic`.
5296 storage_class: StorageClass = .Generic,5296 storage_class: StorageClass,
5297 };5297 };
52985298
5299 // Allocate a function-local variable, with possible initializer.5299 // Allocate a function-local variable, with possible initializer.
...@@ -5333,9 +5333,10 @@ const NavGen = struct {...@@ -5333,9 +5333,10 @@ const NavGen = struct {
5333 fn airAlloc(self: *NavGen, inst: Air.Inst.Index) !?IdRef {5333 fn airAlloc(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
5334 const zcu = self.pt.zcu;5334 const zcu = self.pt.zcu;
5335 const ptr_ty = self.typeOfIndex(inst);5335 const ptr_ty = self.typeOfIndex(inst);
5336 assert(ptr_ty.ptrAddressSpace(zcu) == .generic);
5337 const child_ty = ptr_ty.childType(zcu);5336 const child_ty = ptr_ty.childType(zcu);
5338 return try self.alloc(child_ty, .{});5337 return try self.alloc(child_ty, .{
5338 .storage_class = self.spvStorageClass(ptr_ty.ptrAddressSpace(zcu)),
5339 });
5339 }5340 }
53405341
5341 fn airArg(self: *NavGen) IdRef {5342 fn airArg(self: *NavGen) IdRef {
test/behavior/globals.zig+4
...@@ -69,6 +69,8 @@ test "global loads can affect liveness" {...@@ -69,6 +69,8 @@ test "global loads can affect liveness" {
69}69}
7070
71test "global const can be self-referential" {71test "global const can be self-referential" {
72 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
73
72 const S = struct {74 const S = struct {
73 self: *const @This(),75 self: *const @This(),
74 x: u32,76 x: u32,
...@@ -113,6 +115,8 @@ test "global var can be self-referential" {...@@ -113,6 +115,8 @@ test "global var can be self-referential" {
113}115}
114116
115test "global const can be indirectly self-referential" {117test "global const can be indirectly self-referential" {
118 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
119
116 const S = struct {120 const S = struct {
117 other: *const @This(),121 other: *const @This(),
118 x: u32,122 x: u32,
test/behavior/ptrfromint.zig+2
...@@ -3,6 +3,8 @@ const builtin = @import("builtin");...@@ -3,6 +3,8 @@ const builtin = @import("builtin");
3const expectEqual = std.testing.expectEqual;3const expectEqual = std.testing.expectEqual;
44
5test "casting integer address to function pointer" {5test "casting integer address to function pointer" {
6 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
7
6 addressToFunction();8 addressToFunction();
7 comptime addressToFunction();9 comptime addressToFunction();
8}10}
test/behavior/sizeof_and_typeof.zig+2
...@@ -233,6 +233,8 @@ test "@sizeOf comparison against zero" {...@@ -233,6 +233,8 @@ test "@sizeOf comparison against zero" {
233}233}
234234
235test "hardcoded address in typeof expression" {235test "hardcoded address in typeof expression" {
236 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
237
236 const S = struct {238 const S = struct {
237 fn func() @TypeOf(@as(*[]u8, @ptrFromInt(0x10)).*[0]) {239 fn func() @TypeOf(@as(*[]u8, @ptrFromInt(0x10)).*[0]) {
238 return 0;240 return 0;
test/cases/compile_errors/illegal_operation_on_logical_ptr.zig created+52
...@@ -0,0 +1,52 @@
1export fn elemPtr() void {
2 var ptr: [*]u8 = undefined;
3 ptr[0] = 0;
4}
5
6export fn elemVal() void {
7 var ptr: [*]u8 = undefined;
8 var val = ptr[0];
9 _ = &ptr;
10 _ = &val;
11}
12
13export fn intFromPtr() void {
14 var value: u8 = 0;
15 _ = @intFromPtr(&value);
16}
17
18export fn ptrFromInt() void {
19 var v: u32 = 0x1234;
20 var ptr: *u8 = @ptrFromInt(v);
21 _ = &v;
22 _ = &ptr;
23}
24
25export fn ptrPtrArithmetic() void {
26 var value0: u8 = 0;
27 var value1: u8 = 0;
28 _ = &value0 - &value1;
29}
30
31export fn ptrIntArithmetic() void {
32 var ptr0: [*]u8 = undefined;
33 _ = &ptr0;
34 _ = ptr0 - 10;
35}
36
37// error
38// backend=stage2
39// target=spirv64-vulkan
40//
41// :3:8: error: illegal operation on logical pointer of type '[*]u8'
42// :3:8: note: cannot perform arithmetic on pointers with address space 'generic' on target spirv-vulkan
43// :8:18: error: illegal operation on logical pointer of type '[*]u8'
44// :8:18: note: cannot perform arithmetic on pointers with address space 'generic' on target spirv-vulkan
45// :15:21: error: illegal operation on logical pointer of type '*u8'
46// :15:21: note: cannot perform arithmetic on pointers with address space 'generic' on target spirv-vulkan
47// :20:20: error: illegal operation on logical pointer of type '*u8'
48// :20:20: note: cannot perform arithmetic on pointers with address space 'generic' on target spirv-vulkan
49// :28:17: error: illegal operation on logical pointer of type '*u8'
50// :28:17: note: cannot perform arithmetic on pointers with address space 'generic' on target spirv-vulkan
51// :34:14: error: illegal operation on logical pointer of type '[*]u8'
52// :34:14: note: cannot perform arithmetic on pointers with address space 'generic' on target spirv-vulkan