Commit b019a19b5546d51865175359ec1ae8e5aa3f4128 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-01-11 16:09:17-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-01-13 22:13:44-07:00
log	b019a19b5546d51865175359ec1ae8e5aa3f4128
tree	72bc02abdac799f9aa3eeee9714cc8c13fe4bc49
parent	75b6637d6013b735d36da0ab6e5655002a1b59e9

Sema: comptime loads and stores for `elem_ptr`

The index is checked against actual array lengths, and now handles
coerced or casted pointers to single items.

3 files changed, 142 insertions(+), 92 deletions(-)

src
- Sema.zig
test
- behavior
  - array_llvm.zig
  - array_stage1.zig

src/Sema.zig+130-80

 @@ -14085,88 +14085,112 @@ fn beginComptimePtrMutation(
         .elem_ptr => {
             const elem_ptr = ptr_val.castTag(.elem_ptr).?.data;
             var parent = try beginComptimePtrMutation(sema, block, src, elem_ptr.array_ptr);
-            const elem_ty = parent.ty.childType();
+            switch (parent.ty.zigTypeTag()) {
-            switch (parent.val.tag()) {
+                .Array, .Vector => {
-                .undef => {
+                    const check_len = parent.ty.arrayLenIncludingSentinel();
-                    // An array has been initialized to undefined at comptime and now we
+                    if (elem_ptr.index >= check_len) {
-                    // are for the first time setting an element. We must change the representation
+                        // TODO have the parent include the decl so we can say "declared here"
-                    // of the array from `undef` to `array`.
+                        return sema.fail(block, src, "comptime store of index {d} out of bounds of array length {d}", .{
-                    const arena = parent.beginArena(sema.gpa);
+                            elem_ptr.index, check_len,
-                    defer parent.finishArena();
+                        });
+                    }
+                    const elem_ty = parent.ty.childType();
+                    switch (parent.val.tag()) {
+                        .undef => {
+                            // An array has been initialized to undefined at comptime and now we
+                            // are for the first time setting an element. We must change the representation
+                            // of the array from `undef` to `array`.
+                            const arena = parent.beginArena(sema.gpa);
+                            defer parent.finishArena();
+                            const array_len_including_sentinel =
+                                try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel());
+                            const elems = try arena.alloc(Value, array_len_including_sentinel);
+                            mem.set(Value, elems, Value.undef);
+                            parent.val.* = try Value.Tag.array.create(arena, elems);
-                    const array_len_including_sentinel =
+                            return ComptimePtrMutationKit{
-                        try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel());
+                                .decl_ref_mut = parent.decl_ref_mut,
-                    const elems = try arena.alloc(Value, array_len_including_sentinel);
+                                .val = &elems[elem_ptr.index],
-                    mem.set(Value, elems, Value.undef);
+                                .ty = elem_ty,
+                            };
+                        },
+                        .bytes => {
+                            // An array is memory-optimized to store a slice of bytes, but we are about
+                            // to modify an individual field and the representation has to change.
+                            // If we wanted to avoid this, there would need to be special detection
+                            // elsewhere to identify when writing a value to an array element that is stored
+                            // using the `bytes` tag, and handle it without making a call to this function.
+                            const arena = parent.beginArena(sema.gpa);
+                            defer parent.finishArena();
+                            const bytes = parent.val.castTag(.bytes).?.data;
+                            const dest_len = parent.ty.arrayLenIncludingSentinel();
+                            // bytes.len may be one greater than dest_len because of the case when
+                            // assigning `[N:S]T` to `[N]T`. This is allowed; the sentinel is omitted.
+                            assert(bytes.len >= dest_len);
+                            const elems = try arena.alloc(Value, @intCast(usize, dest_len));
+                            for (elems) |*elem, i| {
+                                elem.* = try Value.Tag.int_u64.create(arena, bytes[i]);
+                            }
-                    parent.val.* = try Value.Tag.array.create(arena, elems);
+                            parent.val.* = try Value.Tag.array.create(arena, elems);
-                    return ComptimePtrMutationKit{
+                            return ComptimePtrMutationKit{
-                        .decl_ref_mut = parent.decl_ref_mut,
+                                .decl_ref_mut = parent.decl_ref_mut,
-                        .val = &elems[elem_ptr.index],
+                                .val = &elems[elem_ptr.index],
-                        .ty = elem_ty,
+                                .ty = elem_ty,
-                    };
+                            };
-                },
+                        },
-                .bytes => {
+                        .repeated => {
-                    // An array is memory-optimized to store a slice of bytes, but we are about
+                            // An array is memory-optimized to store only a single element value, and
-                    // to modify an individual field and the representation has to change.
+                            // that value is understood to be the same for the entire length of the array.
-                    // If we wanted to avoid this, there would need to be special detection
+                            // However, now we want to modify an individual field and so the
-                    // elsewhere to identify when writing a value to an array element that is stored
+                            // representation has to change.  If we wanted to avoid this, there would
-                    // using the `bytes` tag, and handle it without making a call to this function.
+                            // need to be special detection elsewhere to identify when writing a value to an
-                    const arena = parent.beginArena(sema.gpa);
+                            // array element that is stored using the `repeated` tag, and handle it
-                    defer parent.finishArena();
+                            // without making a call to this function.
+                            const arena = parent.beginArena(sema.gpa);
+                            defer parent.finishArena();
+                            const repeated_val = try parent.val.castTag(.repeated).?.data.copy(arena);
+                            const array_len_including_sentinel =
+                                try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel());
+                            const elems = try arena.alloc(Value, array_len_including_sentinel);
+                            mem.set(Value, elems, repeated_val);
+                            parent.val.* = try Value.Tag.array.create(arena, elems);
-                    const bytes = parent.val.castTag(.bytes).?.data;
+                            return ComptimePtrMutationKit{
-                    const dest_len = parent.ty.arrayLenIncludingSentinel();
+                                .decl_ref_mut = parent.decl_ref_mut,
-                    // bytes.len may be one greater than dest_len because of the case when
+                                .val = &elems[elem_ptr.index],
-                    // assigning `[N:S]T` to `[N]T`. This is allowed; the sentinel is omitted.
+                                .ty = elem_ty,
-                    assert(bytes.len >= dest_len);
+                            };
-                    const elems = try arena.alloc(Value, @intCast(usize, dest_len));
+                        },
-                    for (elems) |*elem, i| {
-                        elem.* = try Value.Tag.int_u64.create(arena, bytes[i]);
-                    }
-                    parent.val.* = try Value.Tag.array.create(arena, elems);
+                        .array => return ComptimePtrMutationKit{
+                            .decl_ref_mut = parent.decl_ref_mut,
+                            .val = &parent.val.castTag(.array).?.data[elem_ptr.index],
+                            .ty = elem_ty,
+                        },
-                    return ComptimePtrMutationKit{
+                        else => unreachable,
-                        .decl_ref_mut = parent.decl_ref_mut,
+                    }
-                        .val = &elems[elem_ptr.index],
-                        .ty = elem_ty,
-                    };
                 },
-                .repeated => {
+                else => {
-                    // An array is memory-optimized to store only a single element value, and
+                    if (elem_ptr.index != 0) {
-                    // that value is understood to be the same for the entire length of the array.
+                        // TODO include a "declared here" note for the decl
-                    // However, now we want to modify an individual field and so the
+                        return sema.fail(block, src, "out of bounds comptime store of index {d}", .{
-                    // representation has to change.  If we wanted to avoid this, there would
+                            elem_ptr.index,
-                    // need to be special detection elsewhere to identify when writing a value to an
+                        });
-                    // array element that is stored using the `repeated` tag, and handle it
+                    }
-                    // without making a call to this function.
-                    const arena = parent.beginArena(sema.gpa);
-                    defer parent.finishArena();
-                    const repeated_val = try parent.val.castTag(.repeated).?.data.copy(arena);
-                    const array_len_including_sentinel =
-                        try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel());
-                    const elems = try arena.alloc(Value, array_len_including_sentinel);
-                    mem.set(Value, elems, repeated_val);
-                    parent.val.* = try Value.Tag.array.create(arena, elems);
                     return ComptimePtrMutationKit{
                         .decl_ref_mut = parent.decl_ref_mut,
-                        .val = &elems[elem_ptr.index],
+                        .val = parent.val,
-                        .ty = elem_ty,
+                        .ty = parent.ty,
                     };
                 },
-                .array => return ComptimePtrMutationKit{
-                    .decl_ref_mut = parent.decl_ref_mut,
-                    .val = &parent.val.castTag(.array).?.data[elem_ptr.index],
-                    .ty = elem_ty,
-                },
-                else => unreachable,
             }
         },
         .field_ptr => {
 @@ -14296,15 +14320,41 @@ fn beginComptimePtrLoad(
         .elem_ptr => {
             const elem_ptr = ptr_val.castTag(.elem_ptr).?.data;
             const parent = try beginComptimePtrLoad(sema, block, src, elem_ptr.array_ptr);
-            const elem_ty = parent.ty.childType();
+            switch (parent.ty.zigTypeTag()) {
-            const elem_size = elem_ty.abiSize(target);
+                .Array, .Vector => {
-            return ComptimePtrLoadKit{
+                    const check_len = parent.ty.arrayLenIncludingSentinel();
-                .root_val = parent.root_val,
+                    if (elem_ptr.index >= check_len) {
-                .val = try parent.val.elemValue(sema.arena, elem_ptr.index),
+                        // TODO have the parent include the decl so we can say "declared here"
-                .ty = elem_ty,
+                        return sema.fail(block, src, "comptime load of index {d} out of bounds of array length {d}", .{
-                .byte_offset = try sema.usizeCast(block, src, parent.byte_offset + elem_size * elem_ptr.index),
+                            elem_ptr.index, check_len,
-                .is_mutable = parent.is_mutable,
+                        });
-            };
+                    }
+                    const elem_ty = parent.ty.childType();
+                    const elem_size = elem_ty.abiSize(target);
+                    return ComptimePtrLoadKit{
+                        .root_val = parent.root_val,
+                        .val = try parent.val.elemValue(sema.arena, elem_ptr.index),
+                        .ty = elem_ty,
+                        .byte_offset = try sema.usizeCast(block, src, parent.byte_offset + elem_size * elem_ptr.index),
+                        .is_mutable = parent.is_mutable,
+                    };
+                },
+                else => {
+                    if (elem_ptr.index != 0) {
+                        // TODO have the parent include the decl so we can say "declared here"
+                        return sema.fail(block, src, "out of bounds comptime load of index {d}", .{
+                            elem_ptr.index,
+                        });
+                    }
+                    return ComptimePtrLoadKit{
+                        .root_val = parent.root_val,
+                        .val = parent.val,
+                        .ty = parent.ty,
+                        .byte_offset = parent.byte_offset,
+                        .is_mutable = parent.is_mutable,
+                    };
+                },
+            }
         },
         .field_ptr => {
             const field_ptr = ptr_val.castTag(.field_ptr).?.data;

test/behavior/array_llvm.zig+12

...	@@ -33,3 +33,15 @@ test "read/write through global variable array of struct fields initialized via	...	@@ -33,3 +33,15 @@ test "read/write through global variable array of struct fields initialized via
33	};	33	};
34	try S.doTheTest();	34	try S.doTheTest();
35	}	35	}
		36
		37	test "implicit cast single-item pointer" {
		38	try testImplicitCastSingleItemPtr();
		39	comptime try testImplicitCastSingleItemPtr();
		40	}
		41
		42	fn testImplicitCastSingleItemPtr() !void {
		43	var byte: u8 = 100;
		44	const slice = @as(*[1]u8, &byte)[0..];
		45	slice[0] += 1;
		46	try expect(byte == 101);
		47	}

test/behavior/array_stage1.zig-12

...	@@ -4,18 +4,6 @@ const mem = std.mem;	...	@@ -4,18 +4,6 @@ const mem = std.mem;
4	const expect = testing.expect;	4	const expect = testing.expect;
5	const expectEqual = testing.expectEqual;	5	const expectEqual = testing.expectEqual;
6		6
7	test "implicit cast single-item pointer" {
8	try testImplicitCastSingleItemPtr();
9	comptime try testImplicitCastSingleItemPtr();
10	}
11
12	fn testImplicitCastSingleItemPtr() !void {
13	var byte: u8 = 100;
14	const slice = @as(*[1]u8, &byte)[0..];
15	slice[0] += 1;
16	try expect(byte == 101);
17	}
18
19	fn testArrayByValAtComptime(b: [2]u8) u8 {	7	fn testArrayByValAtComptime(b: [2]u8) u8 {
20	return b[0];	8	return b[0];
21	}	9	}