@zigc/lib 0.17.0-dev.389 → 0.17.0-dev.420

package/compiler/build_runner.zig

@@ -26,9 +26,9 @@ pub const std_options: std.Options = .{
 pub fn main(init: process.Init.Minimal) !void {
     // The build runner is often short-lived, but thanks to `--watch` and `--webui`, that's not
     // always the case. So, we do need a true gpa for some things.
-    var debug_gpa_state: std.heap.DebugAllocator(.{}) = .init;
-    defer _ = debug_gpa_state.deinit();
-    const gpa = debug_gpa_state.allocator();
+    var safe_gpa_state: std.heap.SafeAllocator = .init(std.heap.page_allocator, .{});
+    defer _ = safe_gpa_state.deinit();
+    const gpa = safe_gpa_state.allocator();
 
     var threaded: std.Io.Threaded = .init(gpa, .{
         .environ = init.environ,

package/compiler/test_runner.zig

@@ -91,8 +91,8 @@ fn mainServer(init: std.process.Init.Minimal) !void {
                 return std.process.exit(0);
             },
             .query_test_metadata => {
-                testing.allocator_instance = .{};
-                defer if (testing.allocator_instance.deinit() == .leak) {
+                testing.allocator_instance = .init(std.heap.page_allocator, .{});
+                defer if (testing.allocator_instance.deinit() != 0) {
                     @panic("internal test runner memory leak");
                 };
 
@@ -123,7 +123,10 @@ fn mainServer(init: std.process.Init.Minimal) !void {
 
             .run_test => {
                 testing.environ = init.environ;
-                testing.allocator_instance = .{};
+                testing.allocator_instance = .init(std.heap.page_allocator, .{
+                    .canary = 0xc3a701ba,
+                    .check_write_after_free = true,
+                });
                 testing.io_instance = .init(testing.allocator, .{
                     .argv0 = .init(init.args),
                     .environ = init.environ,
@@ -150,8 +153,7 @@ fn mainServer(init: std.process.Init.Minimal) !void {
                     },
                 };
                 testing.io_instance.deinit();
-                const leak_count = testing.allocator_instance.detectLeaks();
-                testing.allocator_instance.deinitWithoutLeakChecks();
+                const leak_count = testing.allocator_instance.deinit();
                 try server.serveTestResults(.{
                     .index = index,
                     .flags = .{
@@ -173,8 +175,8 @@ fn mainServer(init: std.process.Init.Minimal) !void {
                 // since they are not present.
                 if (!builtin.fuzz) unreachable;
 
-                var gpa_instance: std.heap.DebugAllocator(.{}) = .init;
-                defer if (gpa_instance.deinit() == .leak) {
+                var gpa_instance: std.heap.SafeAllocator = .init(std.heap.page_allocator, .{});
+                defer if (gpa_instance.deinit() != 0) {
                     @panic("internal test runner memory leak");
                 };
                 const gpa = gpa_instance.allocator();
@@ -271,14 +273,17 @@ fn mainTerminal(init: std.process.Init.Minimal) void {
 
     var leaks: usize = 0;
     for (test_fn_list, 0..) |test_fn, i| {
-        testing.allocator_instance = .{};
+        testing.allocator_instance = .init(std.heap.page_allocator, .{
+            .canary = 0xc3a701ba,
+            .check_write_after_free = true,
+        });
         testing.io_instance = .init(testing.allocator, .{
             .argv0 = .init(init.args),
             .environ = init.environ,
         });
         defer {
             testing.io_instance.deinit();
-            if (testing.allocator_instance.deinit() == .leak) leaks += 1;
+            if (testing.allocator_instance.deinit() != 0) leaks += 1;
         }
         testing.log_level = .warn;
         testing.environ = init.environ;
@@ -430,8 +435,11 @@ var fuzz_runner: if (builtin.fuzz) struct {
             error.WriteFailed => panic("failed to write to stdout: {t}", .{stdout_writer.err.?}),
         };
 
-        testing.allocator_instance = .{};
-        defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
+        testing.allocator_instance = .init(std.heap.page_allocator, .{
+            .canary = 0xc3a701ba,
+            .check_write_after_free = true,
+        });
+        defer if (testing.allocator_instance.deinit() != 0) std.process.exit(1);
         is_fuzz_test = false;
 
         builtin.test_functions[fuzz_runner.indexes[i]].func() catch |err| switch (err) {
@@ -554,8 +562,11 @@ pub fn fuzz(
 
         fn test_one() callconv(.c) bool {
             @disableInstrumentation();
-            testing.allocator_instance = .{};
-            defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
+            testing.allocator_instance = .init(std.heap.page_allocator, .{
+                .canary = 0xcacce5e0,
+                .check_write_after_free = true,
+            });
+            defer if (testing.allocator_instance.deinit() != 0) std.process.exit(1);
             log_err_count = 0;
             testOne(ctx, @constCast(&testing.Smith{ .in = null })) catch |err| switch (err) {
                 error.SkipZigTest => return true,
@@ -582,7 +593,6 @@ pub fn fuzz(
     if (builtin.fuzz) {
         // Preserve the calling test's allocator state
         const prev_allocator_state = testing.allocator_instance;
-        testing.allocator_instance = .{};
         defer testing.allocator_instance = prev_allocator_state;
 
         global.ctx = context;

package/fuzzer.zig

@@ -39,10 +39,10 @@ fn logOverride(
     fw.interface.flush() catch panic("failed to write to fuzzer log: {t}", .{fw.err.?});
 }
 
-var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
+var safe_allocator: std.heap.SafeAllocator = .init(std.heap.page_allocator, .{});
 const gpa = switch (builtin.mode) {
-    .Debug => debug_allocator.allocator(),
-    .ReleaseFast, .ReleaseSmall, .ReleaseSafe => std.heap.smp_allocator,
+    .Debug, .ReleaseSafe => safe_allocator.allocator(),
+    .ReleaseFast, .ReleaseSmall => std.heap.smp_allocator,
 };
 
 // Seperate from `exec` to allow initialization before `exec` is.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.389",
+  "version": "0.17.0-dev.420",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Target/Query.zig

@@ -533,9 +533,8 @@ pub fn serializeCpuAlloc(q: Query, ally: Allocator) Allocator.Error![]u8 {
     return buffer.toOwnedSlice();
 }
 
+/// Deprecated; use `zigTriple` instead. Will be removed in 0.18.0.
 pub fn allocDescription(self: Query, allocator: Allocator) ![]u8 {
-    // TODO is there anything else worthy of the description that is not
-    // already captured in the triple?
     return self.zigTriple(allocator);
 }
 

package/std/Target.zig

@@ -2640,7 +2640,6 @@ pub const DynamicLinker = struct {
                 }
             else if (abi.isGnu())
                 switch (cpu.arch) {
-                    // TODO: `700` ABI support.
                     .arc,
                     .arceb,
                     => |arch| if (abi == .gnu) initFmt("/lib/ld-linux-{t}.so.2", .{arch}) else none,

package/std/Thread.zig

@@ -1411,6 +1411,16 @@ const LinuxThreadImpl = struct {
                     : [ptr] "{r4}" (@intFromPtr(self.mapped.ptr)),
                       [len] "{r5}" (self.mapped.len),
                     : .{ .memory = true }),
+                .xtensa, .xtensaeb => asm volatile (
+                    \\ movi a2, 81 // SYS_munmap
+                    \\ syscall
+                    \\ movi a6, 0
+                    \\ movi a2, 118 // SYS_exit
+                    \\ syscall
+                    :
+                    : [ptr] "{a6}" (@intFromPtr(self.mapped.ptr)),
+                      [len] "{a3}" (self.mapped.len),
+                    : .{ .memory = true }),
                 else => |cpu_arch| @compileError("Unsupported linux arch: " ++ @tagName(cpu_arch)),
             }
             unreachable;

package/std/debug.zig

@@ -994,6 +994,8 @@ const StackIterator = union(enum) {
         .sh,
         .sheb,
         .xcore,
+        .xtensa,
+        .xtensaeb,
         => .useless,
         .hexagon,
         // The PowerPC ABIs don't actually strictly require a backchain pointer; they allow omitting

package/std/elf.zig

@@ -224,6 +224,9 @@ pub const DT_PPC64_NUM = 4;
 pub const DT_IA_64_PLT_RESERVE = (DT_LOPROC + 0);
 pub const DT_IA_64_NUM = 1;
 
+pub const DT_XTENSA_GOT_LOC_OFF = 0x70000000;
+pub const DT_XTENSA_GOT_LOC_SZ = 0x70000001;
+
 pub const DT_NIOS2_GP = 0x70000002;
 
 pub const DF_ORIGIN = 0x00000001;

package/std/fmt/float.zig

@@ -1646,6 +1646,8 @@ test "format f64" {
 }
 
 test "format f80" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+
     try check(f80, 0.0, "0e0");
     try check(f80, -0.0, "-0e0");
     try check(f80, 1.0, "1e0");

package/std/heap/ArenaAllocator.zig

@@ -671,12 +671,10 @@ test "reset while retaining a buffer" {
 
     // Create two internal buffers
     _ = try a.alloc(u8, 1);
-    _ = try a.alloc(u8, 1000);
-
     try std.testing.expect(arena_allocator.state.used_list != null);
-
-    // Check that we have at least two buffers
-    try std.testing.expect(arena_allocator.state.used_list.?.next != null);
+    while (arena_allocator.state.used_list.?.next == null) {
+        _ = try a.alloc(u8, 1000);
+    }
 
     // This retains the first allocated buffer
     try std.testing.expect(arena_allocator.reset(.{ .retain_with_limit = 2 }));