Commit 4930094e622c043d9be459abbfc5a7b203a22aa2 | zig

author	Frank Denis <124872+jedisct1@users.noreply.github.com> 2023-10-02 19:37:17-06:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-10-03 02:51:01-07:00
log	4930094e622c043d9be459abbfc5a7b203a22aa2
tree	19e81fd0a9271a3f5d97ccb47740d8564ac898ff
parent	0bdbd3e235daee64caf1f99e5b9d7b62f4c5c484

valgrind.memcheck: fix makeMem*()

The `makeMem*()` functions crashed under valgrind in Debug and
ReleaseSafe modes.

The reason being that `doMemCheckClientRequestExpr()` returns `0`
when not running under Valgrind, and `maxInt(usize)` when running
under Valgrind.

Thus, `@as(i1, @intCast(maxInt(usize)))` always fails and these
functions crashed before returning.

That being said, what these functions used to return was quite
unexpected: `0` on error and `-1` on success (=running under valgrind).
That doesn't match any Zig nor C conventions.

But that return value doesn't seem to be very useful. Either we are
running under Valgrind or we are not. There's no point in checking this
for every single call. Applications are likely to always discard it.

So, just return a `void` instead.

Also avoid function comments that start with `Similarly, ...` because
that doesn't refer to anything in the context of autodoc or in IDEs.

1 files changed, 14 insertions(+), 20 deletions(-)

lib
- std
  - valgrind
    memcheck.zig

lib/std/valgrind/memcheck.zig+14-20

...	...	@@ -29,35 +29,29 @@ fn doMemCheckClientRequestStmt(request: MemCheckClientRequest, a1: usize, a2: us
29	29	}
30	30
31	31	/// Mark memory at qzz.ptr as unaddressable for qzz.len bytes.
32		/// This returns -1 when run on Valgrind and 0 otherwise.
33		pub fn makeMemNoAccess(qzz: []u8) i1 {
34		return @as(i1, @intCast(doMemCheckClientRequestExpr(0, // default return
35		.MakeMemNoAccess, @intFromPtr(qzz.ptr), qzz.len, 0, 0, 0)));
	32	pub fn makeMemNoAccess(qzz: []u8) void {
	33	_ = doMemCheckClientRequestExpr(0, // default return
	34	.MakeMemNoAccess, @intFromPtr(qzz.ptr), qzz.len, 0, 0, 0);
36	35	}
37	36
38		/// Similarly, mark memory at qzz.ptr as addressable but undefined
39		/// for qzz.len bytes.
40		/// This returns -1 when run on Valgrind and 0 otherwise.
41		pub fn makeMemUndefined(qzz: []u8) i1 {
42		return @as(i1, @intCast(doMemCheckClientRequestExpr(0, // default return
43		.MakeMemUndefined, @intFromPtr(qzz.ptr), qzz.len, 0, 0, 0)));
	37	/// Mark memory at qzz.ptr as addressable but undefined for qzz.len bytes.
	38	pub fn makeMemUndefined(qzz: []u8) void {
	39	_ = doMemCheckClientRequestExpr(0, // default return
	40	.MakeMemUndefined, @intFromPtr(qzz.ptr), qzz.len, 0, 0, 0);
44	41	}
45	42
46		/// Similarly, mark memory at qzz.ptr as addressable and defined
47		/// for qzz.len bytes.
48		pub fn makeMemDefined(qzz: []u8) i1 {
49		// This returns -1 when run on Valgrind and 0 otherwise.
50		return @as(i1, @intCast(doMemCheckClientRequestExpr(0, // default return
51		.MakeMemDefined, @intFromPtr(qzz.ptr), qzz.len, 0, 0, 0)));
	43	/// Mark memory at qzz.ptr as addressable and defined or qzz.len bytes.
	44	pub fn makeMemDefined(qzz: []u8) void {
	45	_ = doMemCheckClientRequestExpr(0, // default return
	46	.MakeMemDefined, @intFromPtr(qzz.ptr), qzz.len, 0, 0, 0);
52	47	}
53	48
54	49	/// Similar to makeMemDefined except that addressability is
55	50	/// not altered: bytes which are addressable are marked as defined,
56	51	/// but those which are not addressable are left unchanged.
57		/// This returns -1 when run on Valgrind and 0 otherwise.
58		pub fn makeMemDefinedIfAddressable(qzz: []u8) i1 {
59		return @as(i1, @intCast(doMemCheckClientRequestExpr(0, // default return
60		.MakeMemDefinedIfAddressable, @intFromPtr(qzz.ptr), qzz.len, 0, 0, 0)));
	52	pub fn makeMemDefinedIfAddressable(qzz: []u8) void {
	53	_ = doMemCheckClientRequestExpr(0, // default return
	54	.MakeMemDefinedIfAddressable, @intFromPtr(qzz.ptr), qzz.len, 0, 0, 0);
61	55	}
62	56
63	57	/// Create a block-description handle. The description is an ascii