memset/memcpy comptime error: out of bounds pointer access

[mikdusan]

export fn fail_memset() void {
    comptime {
        var num: u32 = undefined;
        @memset(@ptrCast([*]u8, &num), 0, @sizeOf(u32));
    }
}

export fn fail_memcpy() void {
    comptime {
        var src: u32 = 99;
        var dst: u32 = undefined;
        @memcpy(@ptrCast([*]u8, &dst), @ptrCast([*]const u8, &src), @sizeOf(u32));
    }
}

./bug1.zig:4:43: error: out of bounds pointer access
        @memset(@ptrCast([*]u8, &num), 0, @sizeOf(u32));
                                          ^
./bug1.zig:4:9: note: referenced here
        @memset(@ptrCast([*]u8, &num), 0, @sizeOf(u32));
        ^
./bug1.zig:12:9: error: out of bounds pointer access
        @memcpy(@ptrCast([*]u8, &dst), @ptrCast([*]const u8, &src), @sizeOf(u32));
        ^

This was found by trying:

const Foo = extern struct {
    num: u32,
};

var x: [*:comptime std.mem.zeroes(Foo)]Foo = undefined;
// or
_ = comptime std.mem.zeroes(Foo);

std.mem exposure with zeroes and secureZero (and probably more) can be worked around by replacing the builtins { @memset, @memcpy } with { std.mem.set, std.mem.copy } respectively but is not a solve for the primary issue.

[mikdusan]

a tiny code change gets us a step further but with a new error:

diff --git a/src/ir.cpp b/src/ir.cpp
index bb2dc75c6..8e6b44ede 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -25864,7 +25864,7 @@ static IrInstGen *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstSrcMemset
                 case ConstPtrSpecialRef:
                     dest_elements = dest_ptr_val->data.x_ptr.data.ref.pointee;
                     start = 0;
-                    bound_end = 1;
+                    bound_end = dest_elements->type->abi_size;
                     break;
                 case ConstPtrSpecialBaseArray:
                     {

this now compiles:

export fn fail_memset() void {
    comptime {
        var num: u32 = undefined;
        @memset(@ptrCast([*]u8, &num), 0, @sizeOf(u32));
    }
}

but this does not:

const std = @import("std");

export fn fail_memset() void {
    const Foo = extern struct {
        num: u32,
    };
    var z = comptime std.mem.zeroes(Foo);
}

./lib/std/mem.zig:319:17: error: expected type '*Foo', found 'u8'
                var item: T = undefined;
                ^
./bug1.zig:7:36: note: called from here
    var z = comptime std.mem.zeroes(Foo);
                                   ^
./bug1.zig:3:30: note: called from here
export fn fail_memset() void {
                             ^
./lib/std/mem.zig:321:24: note: referenced here
                return item;
                       ^
./bug1.zig:7:36: note: referenced here
    var z = comptime std.mem.zeroes(Foo);
                                   ^

[SpexGuy]

Ran into this trying to convert 4-character string literals to integers. Minimal repro:

comptime {
    var str = "test";
    var fourcc: u32 = undefined;
    @memcpy(@ptrCast([*]u8, &fourcc), str, 4);
}

.\src\foo.zig:4:5: error: out of bounds pointer access
    @memcpy(@ptrCast([*]u8, &fourcc), str, 4);
    ^

---

Interestingly, this variant works:

comptime {
    var str = "test";
    var array: *const [4]u8 = str[0..4];
    var fourcc: u32 = @bitCast(u32, array.*);
}

[mikdusan]

• no longer reproduces on 0.12.0-dev.288+9126852ba
• was probably fixed a long time ago

zig build-obj foo.zig

const std = @import("std");

export fn foo() void {
    const Foo = extern struct {
        num: u32,
    };

    var x: [*:std.mem.zeroes(Foo)]Foo = undefined;
    _ = x;
    _ = comptime std.mem.zeroes(Foo);
}

comptime {
    var str = "test";
    var fourcc: u32 = undefined;
    @memcpy(@as([*]u8, @ptrCast(&fourcc)), str);
}