authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2023-05-14 15:02:11+03:00
committergravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2023-05-15 10:31:24+03:00
log2703db3b405b45e897231e85ba884543d684f64f
treed3ba46b2b681de2d2f7e47dc8e11d1d9f19f2488
parentab5a72f6ca9446820f3f516873e1b5d1aeefb5a8

Sema: add more type checks to `@mem{cpy,set}`

Closes #15634 Co-authored-by: Dima Afanasyev <dimaafanasev@example.com>

2 files changed, 60 insertions(+), 22 deletions(-)

src/Sema.zig+39-18
......@@ -3416,19 +3416,12 @@ fn indexablePtrLenOrNone(
34163416 sema: *Sema,
34173417 block: *Block,
34183418 src: LazySrcLoc,
3419 object: Air.Inst.Ref,
3419 operand: Air.Inst.Ref,
34203420) CompileError!Air.Inst.Ref {
3421 const object_ty = sema.typeOf(object);
3422 const indexable_ty = t: {
3423 const ptr_size = object_ty.ptrSizeOrNull() orelse break :t object_ty;
3424 break :t switch (ptr_size) {
3425 .Many => return .none,
3426 .One => object_ty.childType(),
3427 else => object_ty,
3428 };
3429 };
3430 try checkIndexable(sema, block, src, indexable_ty);
3431 return sema.fieldVal(block, src, object, "len", src);
3421 const operand_ty = sema.typeOf(operand);
3422 try checkMemOperand(sema, block, src, operand_ty);
3423 if (operand_ty.ptrSize() == .Many) return .none;
3424 return sema.fieldVal(block, src, operand, "len", src);
34323425}
34333426
34343427fn zirAllocExtended(
......@@ -22080,19 +22073,25 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
2208022073 const src_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
2208122074 const dest_ptr = try sema.resolveInst(extra.lhs);
2208222075 const src_ptr = try sema.resolveInst(extra.rhs);
22076 const dest_ty = sema.typeOf(dest_ptr);
22077 const src_ty = sema.typeOf(src_ptr);
2208322078 const dest_len = try indexablePtrLenOrNone(sema, block, dest_src, dest_ptr);
2208422079 const src_len = try indexablePtrLenOrNone(sema, block, src_src, src_ptr);
2208522080 const target = sema.mod.getTarget();
2208622081
22082 if (dest_ty.isConstPtr()) {
22083 return sema.fail(block, dest_src, "cannot memcpy to constant pointer", .{});
22084 }
22085
2208722086 if (dest_len == .none and src_len == .none) {
2208822087 const msg = msg: {
2208922088 const msg = try sema.errMsg(block, src, "unknown @memcpy length", .{});
2209022089 errdefer msg.destroy(sema.gpa);
2209122090 try sema.errNote(block, dest_src, msg, "destination type '{}' provides no length", .{
22092 sema.typeOf(dest_ptr).fmt(sema.mod),
22091 dest_ty.fmt(sema.mod),
2209322092 });
2209422093 try sema.errNote(block, src_src, msg, "source type '{}' provides no length", .{
22095 sema.typeOf(src_ptr).fmt(sema.mod),
22094 src_ty.fmt(sema.mod),
2209622095 });
2209722096 break :msg msg;
2209822097 };
......@@ -22180,9 +22179,6 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
2218022179 } else break :rs src_src;
2218122180 } else dest_src;
2218222181
22183 const dest_ty = sema.typeOf(dest_ptr);
22184 const src_ty = sema.typeOf(src_ptr);
22185
2218622182 // If in-memory coercion is not allowed, explode this memcpy call into a
2218722183 // for loop that copies element-wise.
2218822184 // Likewise if this is an iterable rather than a pointer, do the same
......@@ -22274,7 +22270,11 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
2227422270 const dest_ptr = try sema.resolveInst(extra.lhs);
2227522271 const uncoerced_elem = try sema.resolveInst(extra.rhs);
2227622272 const dest_ptr_ty = sema.typeOf(dest_ptr);
22277 try checkIndexable(sema, block, dest_src, dest_ptr_ty);
22273 try checkMemOperand(sema, block, dest_src, dest_ptr_ty);
22274
22275 if (dest_ptr_ty.isConstPtr()) {
22276 return sema.fail(block, dest_src, "cannot memset constant pointer", .{});
22277 }
2227822278
2227922279 const dest_elem_ty = dest_ptr_ty.elemType2();
2228022280 const target = sema.mod.getTarget();
......@@ -31102,6 +31102,27 @@ fn checkIndexable(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
3110231102 }
3110331103}
3110431104
31105fn checkMemOperand(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
31106 if (ty.zigTypeTag() == .Pointer) {
31107 switch (ty.ptrSize()) {
31108 .Slice, .Many, .C => return,
31109 .One => {
31110 const elem_ty = ty.childType();
31111 if (elem_ty.zigTypeTag() == .Array) return;
31112 // TODO https://github.com/ziglang/zig/issues/15479
31113 // if (elem_ty.isTuple()) return;
31114 },
31115 }
31116 }
31117 const msg = msg: {
31118 const msg = try sema.errMsg(block, src, "type '{}' is not an indexable pointer", .{ty.fmt(sema.mod)});
31119 errdefer msg.destroy(sema.gpa);
31120 try sema.errNote(block, src, msg, "operand must be a slice, a many pointer or a pointer to an array", .{});
31121 break :msg msg;
31122 };
31123 return sema.failWithOwnedErrorMsg(msg);
31124}
31125
3110531126fn resolveUnionLayout(sema: *Sema, ty: Type) CompileError!void {
3110631127 const resolved_ty = try sema.resolveTypeFields(ty);
3110731128 const union_obj = resolved_ty.cast(Type.Payload.Union).?.data;
test/cases/compile_errors/incorrect_type_to_memset_memcpy.zig+21-4
......@@ -19,6 +19,19 @@ pub export fn non_matching_lengths() void {
1919 var buf2: [6]u8 = .{ 1, 2, 3, 4, 5, 6 };
2020 @memcpy(&buf2, &buf1);
2121}
22pub export fn memset_const_dest_ptr() void {
23 const buf: [5]u8 = .{ 1, 2, 3, 4, 5 };
24 @memset(&buf, 1);
25}
26pub export fn memcpy_const_dest_ptr() void {
27 const buf1: [5]u8 = .{ 1, 2, 3, 4, 5 };
28 var buf2: [5]u8 = .{ 1, 2, 3, 4, 5 };
29 @memcpy(&buf1, &buf2);
30}
31pub export fn memset_array() void {
32 var buf: [5]u8 = .{ 1, 2, 3, 4, 5 };
33 @memcpy(buf, 1);
34}
2235
2336// error
2437// backend=stage2
......@@ -27,10 +40,14 @@ pub export fn non_matching_lengths() void {
2740// :5:5: error: unknown @memcpy length
2841// :5:18: note: destination type '[*]u8' provides no length
2942// :5:24: note: source type '[*]align(4) const u8' provides no length
30// :10:13: error: type 'u8' does not support indexing
31// :10:13: note: operand must be an array, slice, tuple, or vector
32// :15:13: error: type '*u8' does not support indexing
33// :15:13: note: operand must be an array, slice, tuple, or vector
43// :10:13: error: type '*u8' is not an indexable pointer
44// :10:13: note: operand must be a slice, a many pointer or a pointer to an array
45// :15:13: error: type '*u8' is not an indexable pointer
46// :15:13: note: operand must be a slice, a many pointer or a pointer to an array
3447// :20:5: error: non-matching @memcpy lengths
3548// :20:13: note: length 6 here
3649// :20:20: note: length 5 here
50// :24:13: error: cannot memset constant pointer
51// :29:13: error: cannot memcpy to constant pointer
52// :33:13: error: type '[5]u8' is not an indexable pointer
53// :33:13: note: operand must be a slice, a many pointer or a pointer to an array