@zigc/lib 0.16.0-dev.3091 → 0.16.0-dev.3128

package/std/Build/abi.zig

@@ -162,15 +162,39 @@ pub const fuzz = struct {
     pub extern fn fuzzer_init(cache_dir_path: Slice) void;
     /// `fuzzer_init` must be called first.
     pub extern fn fuzzer_coverage() Coverage;
+    pub extern fn fuzzer_unslide_address(addr: usize) usize;
+
+    /// Performs all the fuzzing work and selects tests to run
+    ///
     /// `fuzzer_init` must be called first.
-    pub extern fn fuzzer_set_test(test_one: TestOne, unit_test_name: Slice) void;
-    /// `fuzzer_set_test` must be called first.
-    /// The callee owns the memory of bytes and must not free it until `fuzzer_main` returns
+    pub extern fn fuzzer_main(
+        n_tests: u32,
+        seed: u32,
+        limit_kind: LimitKind,
+        amount_or_instance: u64,
+    ) void;
+    pub extern fn runner_test_run(i: u32) void;
+    pub extern fn runner_test_name(i: u32) Slice;
+    // Since the runner owns the `std.zig.Server` instance, it also controls the
+    // concurrent Io instance so reads can be canceled. As such, the fuzzer has
+    // to call into the runner for any zig server / concurrent operation.
+    pub extern fn runner_start_input_poller() void;
+    pub extern fn runner_stop_input_poller() void;
+    /// Returns if cancelation has been indicated.
+    pub extern fn runner_futex_wait(*const u32, expected: u32) bool;
+    pub extern fn runner_futex_wake(*const u32, waiters: u32) void;
+    pub extern fn runner_broadcast_input(test_i: u32, bytes: Slice) void;
+    /// `fuzzer_main` must be called first.
+    ///
+    /// Called concurrently with `fuzzer_main`. Returns if cancelation has been indicated.
+    pub extern fn fuzzer_receive_input(test_i: u32, bytes: Slice) bool;
+
+    /// Must be called from inside a test function
+    pub extern fn fuzzer_set_test(test_one: TestOne) void;
+    /// Must be called from inside a test function where `fuzzer_set_test` has been called first.
     pub extern fn fuzzer_new_input(bytes: Slice) void;
-    /// `fuzzer_set_test` must be called first.
-    /// Resets the fuzzer's state to that of `fuzzer_init`.
-    pub extern fn fuzzer_main(limit_kind: LimitKind, amount: u64) void;
-    pub extern fn fuzzer_unslide_address(addr: usize) usize;
+    /// Must be called from inside a test function where `fuzzer_set_test` has been called first.
+    pub extern fn fuzzer_start_test() void;
 
     pub extern fn fuzzer_int(uid: Uid, weights: Weights) u64;
     pub extern fn fuzzer_eos(uid: Uid, weights: Weights) bool;
@@ -337,6 +361,14 @@ pub const fuzz = struct {
         }
     };
 
+    /// Fields are little-endian
+    pub const MmapInputHeader = extern struct {
+        pc_digest: u64 align(4), // aligned so header does not have padding
+        instance_id: u32,
+        test_i: u32,
+        len: u32,
+    };
+
     /// WebSocket server->client.
     ///
     /// Sent once, when fuzzing starts, to indicate the available coverage data.

package/std/Build.zig

@@ -128,6 +128,9 @@ pub const Graph = struct {
     random_seed: u32 = 0,
     dependency_cache: InitializedDepMap = .empty,
     allow_so_scripts: ?bool = null,
+    /// Steps should use `io` to limit the number of jobs, however in the case of
+    /// a single step spawning a fixed number of processes this can be used.
+    max_jobs: ?u32 = null,
     time_report: bool,
     /// Similar to the `Io.Terminal.Mode` returned by `Io.lockStderr`, but also
     /// respects the '--color' flag.

package/std/compress/flate/Compress.zig

@@ -1488,7 +1488,7 @@ const PackedContainer = packed struct(u2) {
 
 test Compress {
     const fbufs = try testingFreqBufs();
-    defer if (!builtin.fuzz) std.testing.allocator.destroy(fbufs);
+    defer std.testing.allocator.destroy(fbufs);
     try std.testing.fuzz(fbufs, testFuzzedCompressInput, .{});
 }
 
@@ -1818,7 +1818,7 @@ pub const Raw = struct {
 
 test Raw {
     const data_buf = try std.testing.allocator.create([4 * 65536]u8);
-    defer if (!builtin.fuzz) std.testing.allocator.destroy(data_buf);
+    defer std.testing.allocator.destroy(data_buf);
     var prng: std.Random.DefaultPrng = .init(std.testing.random_seed);
     prng.random().bytes(data_buf);
     try std.testing.fuzz(data_buf, testFuzzedRawInput, .{});
@@ -2491,7 +2491,7 @@ pub const Huffman = struct {
 
 test Huffman {
     const fbufs = try testingFreqBufs();
-    defer if (!builtin.fuzz) std.testing.allocator.destroy(fbufs);
+    defer std.testing.allocator.destroy(fbufs);
     try std.testing.fuzz(fbufs, testFuzzedHuffmanInput, .{});
 }
 

package/std/debug/Info.zig

@@ -99,6 +99,10 @@ pub fn resolveAddresses(
             // due to split debug information. For now, we'll just resolve the addreses one by one.
             for (sorted_pc_addrs, output) |pc_addr, *src_loc| {
                 const dwarf, const dwarf_pc_addr = mf.getDwarfForAddress(gpa, io, pc_addr) catch |err| switch (err) {
+                    error.MissingDebugInfo => {
+                        src_loc.* = .invalid;
+                        continue;
+                    },
                     error.InvalidMachO, error.InvalidDwarf => return error.InvalidDebugInfo,
                     else => |e| return e,
                 };

package/std/heap/ArenaAllocator.zig

@@ -358,14 +358,16 @@ fn alloc(ctx: *anyopaque, n: usize, alignment: Alignment, ret_addr: usize) ?[*]u
             const end_index = @atomicRmw(usize, &node.end_index, .Add, alignable, .acquire); // acquire any memory that may have been freed
             const aligned_index = alignedIndex(buf.ptr, end_index, alignment);
             assert(end_index + alignable >= aligned_index + n);
-            _ = @cmpxchgStrong(
-                usize,
-                &node.end_index,
-                end_index + alignable,
-                aligned_index + n,
-                .monotonic, // no need to release alignment padding; there's no one accessing it!
-                .monotonic,
-            );
+            if (end_index + alignable != aligned_index + n) {
+                _ = @cmpxchgStrong(
+                    usize,
+                    &node.end_index,
+                    end_index + alignable,
+                    aligned_index + n,
+                    .monotonic, // no need to release alignment padding; there's no one accessing it!
+                    .monotonic,
+                );
+            }
 
             if (aligned_index + n > buf.len) break :first_node .{ node, buf.len };
             return buf[aligned_index..][0..n].ptr;
@@ -682,45 +684,40 @@ test "reset while retaining a buffer" {
     try std.testing.expectEqual(2, arena_allocator.queryCapacity());
 }
 
-test "fuzz" {
+test "fuzz multi threaded" {
     @disableInstrumentation();
     if (@import("builtin").single_threaded) return error.SkipZigTest;
 
     const gpa = std.heap.smp_allocator;
 
+    var io_instance: std.Io.Threaded = .init(gpa, .{});
+    defer io_instance.deinit();
+
     var arena_state: ArenaAllocator.State = .init;
     // No need to deinit arena_state, all allocations are in `sample_buffer`!
 
-    const control_buffer = try gpa.alloc(u8, 64 << 10 << 10);
+    const buffer_size = FuzzContext.max_alloc_count * FuzzContext.max_alloc_size;
+
+    const control_buffer = try gpa.alloc(u8, buffer_size);
     defer gpa.free(control_buffer);
     var control_instance: std.heap.FixedBufferAllocator = .init(control_buffer);
 
-    const sample_buffer = try gpa.alloc(u8, 64 << 10 << 10);
+    const sample_buffer = try gpa.alloc(u8, buffer_size);
     defer gpa.free(sample_buffer);
     var sample_instance: FuzzAllocator = .init(sample_buffer);
 
-    var allocs: FuzzContext.Allocs = try .initCapacity(gpa, FuzzContext.max_alloc_count);
-    defer allocs.deinit(gpa);
-
     try std.testing.fuzz(FuzzContext.Init{
-        .gpa = gpa,
-        .allocs = &allocs,
+        .threaded_instance = &io_instance,
         .arena_state = &arena_state,
         .control_instance = &control_instance,
         .sample_instance = &sample_instance,
-    }, fuzzArenaAllocator, .{});
+    }, fuzzMultiThreaded, .{});
 }
 
-fn fuzzArenaAllocator(fuzz_init: FuzzContext.Init, smith: *std.testing.Smith) anyerror!void {
+fn fuzzMultiThreaded(fuzz_init: FuzzContext.Init, smith: *std.testing.Smith) anyerror!void {
     @disableInstrumentation();
     const testing = std.testing;
-
-    // We use a 'fresh' `Threaded` instance every time to reset threadlocals to
-    // their default values.
-
-    var io_instance: std.Io.Threaded = .init(fuzz_init.gpa, .{});
-    defer io_instance.deinit();
-    const io = io_instance.io();
+    const io = fuzz_init.threaded_instance.io();
 
     fuzz_init.sample_instance.prepareFailures(smith);
 
@@ -731,59 +728,57 @@ fn fuzzArenaAllocator(fuzz_init: FuzzContext.Init, smith: *std.testing.Smith) an
     defer fuzz_init.arena_state.* = arena_instance.state;
 
     var ctx: FuzzContext = .init(
-        io,
         control_allocator,
         arena_instance.allocator(),
-        fuzz_init.allocs,
     );
     defer ctx.deinit();
 
-    ctx.rwl.lockUncancelable(io);
-
     var group: std.Io.Group = .init;
     defer group.cancel(io);
 
+    var n_allocs: usize = 0;
     var n_actions: usize = 0;
     while (!smith.eosWeightedSimple(99, 1) and n_actions < FuzzContext.max_action_count) {
         errdefer comptime unreachable;
 
-        const ActionTag = @typeInfo(FuzzContext.Action).@"union".tag_type.?;
-        const weights: []const testing.Smith.Weight = weights: {
-            if (ctx.allocs.len == ctx.allocs.capacity)
-                break :weights &.{
-                    .value(ActionTag, .resize, 1),
-                    .value(ActionTag, .remap, 1),
-                    .value(ActionTag, .free, 1),
-                };
-            break :weights testing.Smith.baselineWeights(ActionTag) ++
-                .{testing.Smith.Weight.value(ActionTag, .alloc, 2)};
-        };
-        const action: FuzzContext.Action = switch (smith.valueWeighted(ActionTag, weights)) {
-            .alloc => action: {
-                const alloc_index = ctx.allocs.addOneBounded() catch continue;
-                ctx.allocs.items(.len)[alloc_index] = .free;
-                break :action .{ .alloc = .{
-                    .len = nextLen(smith),
-                    .alignment = smith.valueRangeAtMost(
+        const weights: []const testing.Smith.Weight = if (n_allocs == FuzzContext.max_alloc_count)
+            &.{
+                .value(FuzzContext.Action, .resize, 1),
+                .value(FuzzContext.Action, .remap, 1),
+                .value(FuzzContext.Action, .free, 1),
+            }
+        else
+            &.{
+                .value(FuzzContext.Action, .resize, 1),
+                .value(FuzzContext.Action, .remap, 1),
+                .value(FuzzContext.Action, .free, 1),
+                .value(FuzzContext.Action, .alloc, 3),
+            };
+        switch (smith.valueWeighted(FuzzContext.Action, weights)) {
+            .alloc => {
+                const alloc_index = n_allocs;
+                n_allocs += 1;
+                ctx.allocs[alloc_index].common.len = .free;
+                group.concurrent(io, FuzzContext.doOneAlloc, .{
+                    &ctx,
+                    nextLen(smith),
+                    smith.valueRangeAtMost(
                         Alignment,
                         .@"1",
                         .fromByteUnits(2 * std.heap.page_size_max),
                     ),
-                    .index = alloc_index,
-                } };
+                    @enumFromInt(alloc_index),
+                }) catch unreachable;
             },
-            .resize => .{ .resize = .{ .new_len = nextLen(smith) } },
-            .remap => .{ .remap = .{ .new_len = nextLen(smith) } },
-            .free => .free,
-        };
-        group.concurrent(io, FuzzContext.doOneAction, .{ &ctx, action }) catch break;
+            .resize => group.concurrent(io, FuzzContext.doOneResize, .{ &ctx, nextLen(smith) }) catch unreachable,
+            .remap => group.concurrent(io, FuzzContext.doOneRemap, .{ &ctx, nextLen(smith) }) catch unreachable,
+            .free => group.concurrent(io, FuzzContext.doOneFree, .{&ctx}) catch unreachable,
+        }
         n_actions += 1;
     }
 
-    ctx.rwl.unlock(io);
-
     try group.await(io);
-    try ctx.check();
+    try ctx.check(n_allocs);
 
     // This also covers the `deinit` logic since `free_all` uses it internally.
 
@@ -806,73 +801,71 @@ fn fuzzArenaAllocator(fuzz_init: FuzzContext.Init, smith: *std.testing.Smith) an
     }
 
     fuzz_init.control_instance.reset();
-    fuzz_init.allocs.clearRetainingCapacity();
-}
-fn nextLen(smith: *std.testing.Smith) usize {
-    @disableInstrumentation();
-    return usizeRange(smith, 1, 16 << 10 << 10);
 }
-fn usizeRange(smith: *std.testing.Smith, at_least: usize, at_most: usize) usize {
+fn nextLen(smith: *std.testing.Smith) @typeInfo(FuzzContext.Alloc.Len).@"enum".tag_type {
     @disableInstrumentation();
-    const Int = @Int(.unsigned, @min(64, @bitSizeOf(usize)));
-    return smith.valueRangeAtMost(Int, @intCast(at_least), @intCast(at_most));
+    const BackingInt = @typeInfo(FuzzContext.Alloc.Len).@"enum".tag_type;
+    return smith.valueRangeAtMost(BackingInt, 1, FuzzContext.max_alloc_size);
 }
 
 const FuzzContext = struct {
-    io: std.Io,
-    rwl: std.Io.RwLock,
-
     control_allocator: Allocator,
     sample_allocator: Allocator,
 
-    allocs: *Allocs,
+    last_alloc_index: Alloc.Index,
+    allocs: [max_alloc_count]Alloc,
 
-    const max_alloc_count = 4096;
+    const max_alloc_count = 64;
     const max_action_count = 2 * max_alloc_count;
 
-    const Allocs = std.MultiArrayList(struct {
+    const max_alloc_size = 16 << 10;
+
+    const Alloc = struct {
         control_ptr: [*]u8,
         sample_ptr: [*]u8,
-        len: Len,
-        alignment: Alignment,
-    });
+        common: packed struct(usize) {
+            len: Len,
+            alignment: Alignment,
+            _: @Int(.unsigned, padding_bits) = 0,
+        },
+
+        const Len = enum(@Int(.unsigned, len_bits)) {
+            free = (1 << len_bits) - 1,
+            _,
+        };
+        const len_bits = @min(64, @bitSizeOf(usize)) - @bitSizeOf(Alignment);
+        const padding_bits = @bitSizeOf(usize) - (len_bits + @bitSizeOf(Alignment));
 
-    const Len = enum(usize) {
-        free = std.math.maxInt(usize),
-        _,
+        const Index = enum(usize) {
+            none = std.math.maxInt(usize),
+            _,
+        };
     };
 
-    const Action = union(enum(u8)) {
-        alloc: struct { len: usize, alignment: Alignment, index: usize },
-        resize: struct { new_len: usize },
-        remap: struct { new_len: usize },
+    const Action = enum {
+        alloc,
+        resize,
+        remap,
         free,
     };
 
-    threadlocal var tls_next: u8 = 0;
-    threadlocal var tls_last_index: ?usize = null;
-
     const Init = struct {
-        gpa: Allocator,
-        allocs: *FuzzContext.Allocs,
+        threaded_instance: *std.Io.Threaded,
         arena_state: *ArenaAllocator.State,
         control_instance: *std.heap.FixedBufferAllocator,
         sample_instance: *FuzzAllocator,
     };
 
     fn init(
-        io: std.Io,
         control_allocator: Allocator,
         sample_allocator: Allocator,
-        allocs: *Allocs,
     ) FuzzContext {
         @disableInstrumentation();
         return .{
-            .io = io,
-            .rwl = .init,
             .control_allocator = control_allocator,
             .sample_allocator = sample_allocator,
-            .allocs = allocs,
+            .last_alloc_index = .none,
+            .allocs = undefined,
         };
     }
 
@@ -881,35 +874,22 @@ const FuzzContext = struct {
         ctx.* = undefined;
     }
 
-    fn check(ctx: *const FuzzContext) !void {
+    fn check(ctx: *const FuzzContext, n_allocs: usize) !void {
         @disableInstrumentation();
-        for (0..ctx.allocs.len) |index| {
-            const len: usize = switch (ctx.allocs.items(.len)[index]) {
+        for (ctx.allocs[0..n_allocs]) |allocation| {
+            const len: usize = switch (allocation.common.len) {
                 .free => continue,
                 _ => |len| @intFromEnum(len),
             };
-            const control = ctx.allocs.items(.control_ptr)[index][0..len];
-            const sample = ctx.allocs.items(.sample_ptr)[index][0..len];
+            const control = allocation.control_ptr[0..len];
+            const sample = allocation.sample_ptr[0..len];
             try std.testing.expectEqualSlices(u8, control, sample);
         }
     }
 
-    fn doOneAction(ctx: *FuzzContext, action: Action) std.Io.Cancelable!void {
+    fn doOneAlloc(ctx: *FuzzContext, len: usize, alignment: Alignment, index: Alloc.Index) void {
         @disableInstrumentation();
-        ctx.rwl.lockSharedUncancelable(ctx.io);
-        defer ctx.rwl.unlockShared(ctx.io);
-
-        switch (action) {
-            .alloc => |act| ctx.doOneAlloc(act.len, act.alignment, act.index),
-            .resize => |act| ctx.doOneResize(act.new_len),
-            .remap => |act| ctx.doOneRemap(act.new_len),
-            .free => ctx.doOneFree(),
-        }
-    }
-
-    fn doOneAlloc(ctx: *FuzzContext, len: usize, alignment: Alignment, index: usize) void {
-        @disableInstrumentation();
-        assert(ctx.allocs.items(.len)[index] == .free);
+        assert(ctx.allocs[@intFromEnum(index)].common.len == .free);
 
         const control_ptr = ctx.control_allocator.rawAlloc(len, alignment, @returnAddress()) orelse
             return;
@@ -918,38 +898,42 @@ const FuzzContext = struct {
             return;
         };
 
-        ctx.allocs.set(index, .{
+        ctx.allocs[@intFromEnum(index)] = .{
             .control_ptr = control_ptr,
             .sample_ptr = sample_ptr,
-            .len = @enumFromInt(len),
-            .alignment = alignment,
-        });
-
-        for (control_ptr[0..len], sample_ptr[0..len]) |*control, *sample| {
-            control.* = tls_next;
-            sample.* = tls_next;
-            tls_next +%= 1;
+            .common = .{
+                .len = @enumFromInt(len),
+                .alignment = alignment,
+            },
+        };
+
+        for (control_ptr[0..len], sample_ptr[0..len], 0..) |*control, *sample, i| {
+            control.* = @truncate(i);
+            sample.* = @truncate(i);
         }
 
-        tls_last_index = index;
+        @atomicStore(Alloc.Index, &ctx.last_alloc_index, index, .release);
     }
     fn doOneResize(ctx: *FuzzContext, new_len: usize) void {
         @disableInstrumentation();
-        const index = tls_last_index orelse return;
-        const len = ctx.allocs.items(.len)[index];
-        assert(len != .free);
-        const memory = ctx.allocs.items(.sample_ptr)[index][0..@intFromEnum(len)];
-        const alignment = ctx.allocs.items(.alignment)[index];
 
-        assert(alignment.check(@intFromPtr(ctx.allocs.items(.control_ptr)[index])));
-        assert(alignment.check(@intFromPtr(ctx.allocs.items(.sample_ptr)[index])));
+        const index = @atomicRmw(Alloc.Index, &ctx.last_alloc_index, .Xchg, .none, .acquire);
+        if (index == .none) return;
+
+        const allocation = &ctx.allocs[@intFromEnum(index)];
+        assert(allocation.common.len != .free);
+        const memory = allocation.sample_ptr[0..@intFromEnum(allocation.common.len)];
+        const alignment = allocation.common.alignment;
+
+        assert(alignment.check(@intFromPtr(allocation.control_ptr)));
+        assert(alignment.check(@intFromPtr(allocation.sample_ptr)));
 
         // Since `resize` is fallible, we have to ensure that `control_allocator`
         // is always successful by reserving the memory we need beforehand.
         const new_control_ptr = ctx.control_allocator.rawAlloc(new_len, alignment, @returnAddress()) orelse
             return;
         if (ctx.sample_allocator.rawResize(memory, alignment, new_len, @returnAddress())) {
-            const old_control = ctx.allocs.items(.control_ptr)[index][0..memory.len];
+            const old_control = allocation.control_ptr[0..memory.len];
             const overlap = @min(memory.len, new_len);
             @memcpy(new_control_ptr[0..overlap], old_control[0..overlap]);
             ctx.control_allocator.rawFree(old_control, alignment, @returnAddress());
@@ -958,23 +942,27 @@ const FuzzContext = struct {
             return;
         }
 
-        ctx.allocs.set(index, .{
+        ctx.allocs[@intFromEnum(index)] = .{
             .control_ptr = new_control_ptr,
             .sample_ptr = memory.ptr,
-            .len = @enumFromInt(new_len),
-            .alignment = alignment,
-        });
+            .common = .{
+                .len = @enumFromInt(new_len),
+                .alignment = alignment,
+            },
+        };
 
         if (new_len > memory.len) {
             for (
-                ctx.allocs.items(.control_ptr)[index][memory.len..new_len],
-                ctx.allocs.items(.sample_ptr)[index][memory.len..new_len],
-            ) |*control, *sample| {
-                control.* = tls_next;
-                sample.* = tls_next;
-                tls_next +%= 1;
+                allocation.control_ptr[memory.len..new_len],
+                allocation.sample_ptr[memory.len..new_len],
+                0..,
+            ) |*control, *sample, i| {
+                control.* = @truncate(i);
+                sample.* = @truncate(i);
             }
         }
+
+        @atomicStore(Alloc.Index, &ctx.last_alloc_index, index, .release);
     }
     fn doOneRemap(ctx: *FuzzContext, new_len: usize) void {
         @disableInstrumentation();
@@ -982,26 +970,29 @@ const FuzzContext = struct {
     }
     fn doOneFree(ctx: *FuzzContext) void {
         @disableInstrumentation();
-        const index = tls_last_index orelse return;
-        const len = ctx.allocs.items(.len)[index];
-        assert(len != .free);
-        const memory = ctx.allocs.items(.sample_ptr)[index][0..@intFromEnum(len)];
-        const alignment = ctx.allocs.items(.alignment)[index];
 
-        assert(alignment.check(@intFromPtr(ctx.allocs.items(.control_ptr)[index])));
-        assert(alignment.check(@intFromPtr(ctx.allocs.items(.sample_ptr)[index])));
+        const index = @atomicRmw(Alloc.Index, &ctx.last_alloc_index, .Xchg, .none, .acquire);
+        if (index == .none) return;
 
-        ctx.control_allocator.rawFree(ctx.allocs.items(.control_ptr)[index][0..memory.len], alignment, @returnAddress());
-        ctx.sample_allocator.rawFree(ctx.allocs.items(.sample_ptr)[index][0..memory.len], alignment, @returnAddress());
+        const allocation = &ctx.allocs[@intFromEnum(index)];
+        assert(allocation.common.len != .free);
+        const len: usize = @intFromEnum(allocation.common.len);
+        const alignment = allocation.common.alignment;
 
-        ctx.allocs.set(index, .{
+        assert(alignment.check(@intFromPtr(allocation.control_ptr)));
+        assert(alignment.check(@intFromPtr(allocation.sample_ptr)));
+
+        ctx.control_allocator.rawFree(allocation.control_ptr[0..len], alignment, @returnAddress());
+        ctx.sample_allocator.rawFree(allocation.sample_ptr[0..len], alignment, @returnAddress());
+
+        ctx.allocs[@intFromEnum(index)] = .{
             .control_ptr = undefined,
             .sample_ptr = undefined,
-            .len = .free,
-            .alignment = undefined,
-        });
-
-        tls_last_index = null;
+            .common = .{
+                .len = .free,
+                .alignment = .@"1",
+            },
+        };
     }
 };
 

package/std/mem/Allocator.zig

@@ -322,7 +322,7 @@ pub fn resize(self: Allocator, allocation: anytype, new_len: usize) bool {
     if (allocation.len == 0) {
         return false;
     }
-    const old_memory = mem.sliceAsBytes(allocation);
+    const old_memory: []u8 = @ptrCast(@constCast(mem.absorbSentinel(allocation)));
     // I would like to use saturating multiplication here, but LLVM cannot lower it
     // on WebAssembly: https://github.com/ziglang/zig/issues/9660
     //const new_len_bytes = new_len *| @sizeOf(T);
@@ -368,7 +368,7 @@ pub fn remap(self: Allocator, allocation: anytype, new_len: usize) ?@TypeOf(allo
         new_memory.len = new_len;
         return new_memory;
     }
-    const old_memory = mem.sliceAsBytes(allocation);
+    const old_memory: []u8 = @ptrCast(@constCast(mem.absorbSentinel(allocation)));
     // I would like to use saturating multiplication here, but LLVM cannot lower it
     // on WebAssembly: https://github.com/ziglang/zig/issues/9660
     //const new_len_bytes = new_len *| @sizeOf(T);
@@ -420,7 +420,7 @@ pub fn reallocAdvanced(
         return ptr;
     }
 
-    const old_byte_slice = mem.sliceAsBytes(old_mem);
+    const old_byte_slice: []u8 = @ptrCast(@constCast(mem.absorbSentinel(old_mem)));
     const byte_count = math.mul(usize, @sizeOf(T), new_n) catch return error.OutOfMemory;
     // Note: can't set shrunk memory to undefined as memory shouldn't be modified on realloc failure
     if (self.rawRemap(old_byte_slice, .fromByteUnits(slice_info.alignment orelse @alignOf(T)), byte_count, return_address)) |p| {
@@ -443,8 +443,7 @@ pub fn reallocAdvanced(
 pub fn free(self: Allocator, memory: anytype) void {
     const slice_info = @typeInfo(@TypeOf(memory)).pointer;
     comptime assert(slice_info.size == .slice);
-    const mem_with_sent = memory[0 .. memory.len + @intFromBool(slice_info.sentinel() != null)];
-    const bytes: []u8 = @ptrCast(@constCast(mem_with_sent));
+    const bytes: []u8 = @ptrCast(@constCast(mem.absorbSentinel(memory)));
     if (bytes.len == 0) return;
     @memset(bytes, undefined);
     self.rawFree(bytes, .fromByteUnits(slice_info.alignment orelse @alignOf(slice_info.child)), @returnAddress());