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

package/std/heap.zig

@@ -11,14 +11,18 @@ const Alignment = std.mem.Alignment;
 
 pub const ArenaAllocator = @import("heap/ArenaAllocator.zig");
 pub const SmpAllocator = @import("heap/SmpAllocator.zig");
+pub const SafeAllocator = @import("heap/SafeAllocator.zig");
 pub const FixedBufferAllocator = @import("heap/FixedBufferAllocator.zig");
 pub const BufferFirstAllocator = @import("heap/BufferFirstAllocator.zig");
 pub const PageAllocator = @import("heap/PageAllocator.zig");
 pub const WasmAllocator = if (builtin.single_threaded) BrkAllocator else @compileError("unimplemented");
 pub const BrkAllocator = @import("heap/BrkAllocator.zig");
 
+/// Deprecated; use `SafeAllocator.Options`.
 pub const DebugAllocatorConfig = @import("heap/debug_allocator.zig").Config;
+/// Deprecated; use `SafeAllocator`.
 pub const DebugAllocator = @import("heap/debug_allocator.zig").DebugAllocator;
+/// Deprecated.
 pub const Check = enum { ok, leak };
 
 /// A memory pool that can allocate objects of a single type very quickly.
@@ -378,6 +382,17 @@ test smp_allocator {
     try testAllocatorAlignedShrink(smp_allocator);
 }
 
+test SafeAllocator {
+    var instance: SafeAllocator = .init(page_allocator, .{});
+    defer _ = instance.deinit();
+    const allocator = instance.allocator();
+
+    try testAllocator(allocator);
+    try testAllocatorAligned(allocator);
+    try testAllocatorLargeAlignment(allocator);
+    try testAllocatorAlignedShrink(allocator);
+}
+
 test PageAllocator {
     const allocator = page_allocator;
     try testAllocator(allocator);
@@ -880,6 +895,7 @@ test {
     _ = @import("heap/memory_pool.zig");
     _ = ArenaAllocator;
     _ = DebugAllocator(.{});
+    _ = SafeAllocator;
     _ = FixedBufferAllocator;
     _ = BufferFirstAllocator;
     if (builtin.single_threaded) {

package/std/mem/Allocator.zig

@@ -23,6 +23,8 @@ pub const VTable = struct {
     /// Return a pointer to `len` bytes with specified `alignment`, or return
     /// `null` indicating the allocation failed.
     ///
+    /// `new_len` must be greater than zero.
+    ///
     /// `ret_addr` is optionally provided as the first return address of the
     /// allocation call stack. If the value is `0` it means no return address
     /// has been provided.

package/std/mem.zig

@@ -201,9 +201,12 @@ test "Allocator.resize" {
         defer testing.allocator.free(values);
 
         for (values, 0..) |*v, i| v.* = @as(T, @intCast(i));
-        if (!testing.allocator.resize(values, values.len + 10)) return error.OutOfMemory;
-        values = values.ptr[0 .. values.len + 10];
-        try testing.expect(values.len == 110);
+        if (testing.allocator.resize(values, values.len + 10)) {
+            values = values.ptr[0 .. values.len + 10];
+            try testing.expect(values.len == 110);
+        } else {
+            // `resize` is not guaranteed to succeed even if there is sufficient memory.
+        }
     }
 
     const primitiveFloatTypes = .{
@@ -217,9 +220,12 @@ test "Allocator.resize" {
         defer testing.allocator.free(values);
 
         for (values, 0..) |*v, i| v.* = @as(T, @floatFromInt(i));
-        if (!testing.allocator.resize(values, values.len + 10)) return error.OutOfMemory;
-        values = values.ptr[0 .. values.len + 10];
-        try testing.expect(values.len == 110);
+        if (testing.allocator.resize(values, values.len + 10)) {
+            values = values.ptr[0 .. values.len + 10];
+            try testing.expect(values.len == 110);
+        } else {
+            // `resize` is not guaranteed to succeed even if there is sufficient memory.
+        }
     }
 }
 

package/std/os/linux/tls.zig

@@ -78,6 +78,8 @@ const current_variant: Variant = switch (native_arch) {
     .sheb,
     .thumb,
     .thumbeb,
+    .xtensa,
+    .xtensaeb,
     => .I_original,
     .loongarch32,
     .loongarch64,
@@ -152,6 +154,8 @@ const AbiTcb = switch (current_variant) {
         .sheb,
         .thumb,
         .thumbeb,
+        .xtensa,
+        .xtensaeb,
         => extern struct {
             /// This is offset by `current_dtv_offset`.
             dtv: usize,
@@ -364,6 +368,13 @@ pub fn setThreadPointer(addr: usize) void {
                 : [addr] "r" (addr),
             );
         },
+        .xtensa, .xtensaeb => {
+            asm volatile (
+                \\ wur %[addr], threadptr
+                :
+                : [addr] "a" (addr),
+            );
+        },
         else => @compileError("Unsupported architecture"),
     }
 }

package/std/os/linux/xtensa.zig

@@ -0,0 +1,171 @@
+const builtin = @import("builtin");
+const std = @import("../../std.zig");
+const SYS = std.os.linux.SYS;
+
+pub const syscall_arg_t = u32;
+
+pub fn syscall0(
+    number: SYS,
+) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={a2}" (-> u32),
+        : [number] "{a2}" (@intFromEnum(number)),
+        : .{ .memory = true });
+}
+
+pub fn syscall1(
+    number: SYS,
+    arg1: syscall_arg_t,
+) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={a2}" (-> u32),
+        : [number] "{a2}" (@intFromEnum(number)),
+          [arg1] "{a6}" (arg1),
+        : .{ .memory = true });
+}
+
+pub fn syscall2(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={a2}" (-> u32),
+        : [number] "{a2}" (@intFromEnum(number)),
+          [arg1] "{a6}" (arg1),
+          [arg2] "{a3}" (arg2),
+        : .{ .memory = true });
+}
+
+pub fn syscall3(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={a2}" (-> u32),
+        : [number] "{a2}" (@intFromEnum(number)),
+          [arg1] "{a6}" (arg1),
+          [arg2] "{a3}" (arg2),
+          [arg3] "{a4}" (arg3),
+        : .{ .memory = true });
+}
+
+pub fn syscall4(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={a2}" (-> u32),
+        : [number] "{a2}" (@intFromEnum(number)),
+          [arg1] "{a6}" (arg1),
+          [arg2] "{a3}" (arg2),
+          [arg3] "{a4}" (arg3),
+          [arg4] "{a5}" (arg4),
+        : .{ .memory = true });
+}
+
+pub fn syscall5(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={a2}" (-> u32),
+        : [number] "{a2}" (@intFromEnum(number)),
+          [arg1] "{a6}" (arg1),
+          [arg2] "{a3}" (arg2),
+          [arg3] "{a4}" (arg3),
+          [arg4] "{a5}" (arg4),
+          [arg5] "{a8}" (arg5),
+        : .{ .memory = true });
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+    arg6: syscall_arg_t,
+) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={a2}" (-> u32),
+        : [number] "{a2}" (@intFromEnum(number)),
+          [arg1] "{a6}" (arg1),
+          [arg2] "{a3}" (arg2),
+          [arg3] "{a4}" (arg3),
+          [arg4] "{a5}" (arg4),
+          [arg5] "{a8}" (arg5),
+          [arg6] "{a9}" (arg6),
+        : .{ .memory = true });
+}
+
+pub fn clone() callconv(.naked) u32 {
+    // __clone(func, stack, flags, arg, ptid, tls, ctid)
+    //         a2,   a3,    a4,    a5,  a6,   a7,  +16
+    //
+    // syscall(SYS_clone, flags, stack, ptid, tls, ctid)
+    //         a2         a6,    a3,    a4,   a5,  a8
+    asm volatile (
+        \\ entry sp, 16
+        \\
+        \\ movi a8, -16
+        \\ and a3, a3, a8
+        \\
+        \\ mov a9, a2
+        \\ mov a10, a5
+        \\
+        \\ mov a5, a7
+        \\ mov a8, a6
+        \\ mov a6, a4
+        \\ mov a4, a8
+        \\ l32i a8, sp, 16
+        \\ movi a2, 116 // SYS_clone
+        \\ syscall
+        \\
+        \\ beqz a2, 1f
+        \\ // parent
+        \\ retw
+        \\
+        \\ // child
+        \\1:
+        \\ movi a7, 0
+        \\ movi a0, 0
+        \\
+        \\ mov a2, a10
+        \\ callx0 a9
+        \\ movi a2, 118 // SYS_exit
+        \\ syscall
+    );
+}
+
+pub const restore = restore_rt;
+
+pub fn restore_rt() callconv(.naked) noreturn {
+    switch (builtin.zig_backend) {
+        .stage2_c => asm volatile (
+            \\ movi a2, %[number]
+            \\ syscall
+            :
+            : [number] "I" (@intFromEnum(SYS.rt_sigreturn)),
+        ),
+        else => asm volatile (
+            \\ syscall
+            :
+            : [number] "{a2}" (@intFromEnum(SYS.rt_sigreturn)),
+        ),
+    }
+}
+
+pub const VDSO = void;
+
+pub const time_t = i32;

package/std/os/linux.zig

@@ -56,6 +56,7 @@ const arch_bits = switch (native_arch) {
         .gnux32, .muslx32 => @import("linux/x32.zig"),
         else => @import("linux/x86_64.zig"),
     },
+    .xtensa, .xtensaeb => @import("linux/xtensa.zig"),
     else => struct {},
 };
 
@@ -338,6 +339,29 @@ pub const MAP = switch (native_arch) {
         _20: u1 = 0,
         _: u5 = 0,
     },
+    .xtensa, .xtensaeb => packed struct(u32) {
+        TYPE: MAP_TYPE,
+        FIXED: bool = false,
+        _RENAME: bool = false,
+        _AUTOGROW: bool = false,
+        _LOCAL: bool = false,
+        _AUTORSRV: bool = false,
+        _1: u1 = 0,
+        NORESERVE: bool = false,
+        ANONYMOUS: bool = false,
+        GROWSDOWN: bool = false,
+        DENYWRITE: bool = false,
+        EXECUTABLE: bool = false,
+        LOCKED: bool = false,
+        POPULATE: bool = false,
+        NONBLOCK: bool = false,
+        STACK: bool = false,
+        HUGETLB: bool = false,
+        FIXED_NOREPLACE: bool = false,
+        _2: u5 = 0,
+        UNINITIALIZED: bool = false,
+        _3: u5 = 0,
+    },
     else => @compileError("missing std.os.linux.MAP constants for this architecture"),
 };
 
@@ -497,6 +521,8 @@ pub const O = switch (native_arch) {
     .hexagon,
     .or1k,
     .s390x,
+    .xtensa,
+    .xtensaeb,
     => packed struct(u32) {
         ACCMODE: ACCMODE = .RDONLY,
         _2: u4 = 0,
@@ -6617,6 +6643,12 @@ pub const k_sigaction = switch (native_arch) {
         mask: sigset_t,
         flags: c_int,
     },
+    .xtensa, .xtensaeb => extern struct {
+        handler: k_sigaction_funcs.handler,
+        mask: sigset_t,
+        flags: c_ulong,
+        restorer: k_sigaction_funcs.restorer,
+    },
     else => extern struct {
         handler: k_sigaction_funcs.handler,
         flags: c_ulong,

package/std/os.zig

@@ -15,8 +15,6 @@ pub fn targetRequiresLibC(target: *const std.Target) bool {
     if (target.requiresLibC()) return true;
     return switch (target.os.tag) {
         .linux => switch (target.cpu.arch) {
-            // https://codeberg.org/ziglang/zig/issues/30940
-            .alpha,
             // https://codeberg.org/ziglang/zig/issues/30942
             .csky,
             // https://codeberg.org/ziglang/zig/issues/30943
@@ -30,9 +28,6 @@ pub fn targetRequiresLibC(target: *const std.Target) bool {
             .sheb,
             // https://codeberg.org/ziglang/zig/issues/30945
             .sparc,
-            // https://codeberg.org/ziglang/zig/issues/30947
-            .xtensa,
-            .xtensaeb,
             => true,
             else => false,
         },

package/std/pie.zig

@@ -22,6 +22,7 @@ const R_RISCV_RELATIVE = 3;
 const R_390_RELATIVE = 12;
 const R_SH_RELATIVE = 165;
 const R_SPARC_RELATIVE = 22;
+const R_XTENSA_RELATIVE = 5;
 
 const R_RELATIVE = switch (builtin.cpu.arch) {
     .x86 => R_386_RELATIVE,
@@ -43,6 +44,7 @@ const R_RELATIVE = switch (builtin.cpu.arch) {
     .s390x => R_390_RELATIVE,
     .sh, .sheb => R_SH_RELATIVE,
     .sparc, .sparc64 => R_SPARC_RELATIVE,
+    .xtensa, .xtensaeb => R_XTENSA_RELATIVE,
     else => @compileError("Missing R_RELATIVE definition for this target"),
 };
 
@@ -261,6 +263,25 @@ inline fn getDynamicSymbol() [*]const elf.Dyn {
                 : [ret] "=r" (-> [*]const elf.Dyn),
                 :
                 : .{ .l7 = true }),
+            .xtensa, .xtensaeb => asm volatile (
+                \\ .weak _DYNAMIC
+                \\ .hidden _DYNAMIC
+                // Set things up such that after the `call0`, `a0` will point 1 byte before the
+                // embedded constant. Note that `call0` is a 3-byte instruction, so we need both
+                // `.balign` directives to be safe.
+                \\ .balign 4
+                \\ .begin no-transform
+                \\ call0 1f
+                \\ .end no-transform
+                \\ .balign 4
+                \\ .word _DYNAMIC - .
+                \\1:
+                \\ add a0, a0, 1
+                \\ l32i a8, a0, 0
+                \\ add %[ret], a0, a8
+                : [ret] "=a" (-> [*]const elf.Dyn),
+                :
+                : .{ .a0 = true, .a8 = true }),
             else => {
                 @compileError("PIE startup is not yet supported for this target!");
             },

package/std/start.zig

@@ -183,6 +183,7 @@ fn _start() callconv(.naked) noreturn {
             .sparc, .sparc64 => ".cfi_undefined %%i7",
             .x86 => ".cfi_undefined %%eip",
             .x86_64 => ".cfi_undefined %%rip",
+            .xtensa, .xtensaeb => "", // No CFI support.
             else => @compileError("unsupported arch"),
         });
 
@@ -486,6 +487,15 @@ fn _start() callconv(.naked) noreturn {
             \\ sub %%sp, 2047, %%sp
             \\ ba,a %[posixCallMainAndExit]
             ,
+            .xtensa, .xtensaeb =>
+            // a0 = LR, a7 = FP, a1 = SP
+            \\ movi a0, 0
+            \\ movi a7, 0
+            \\ mov a2, sp
+            \\ movi a8, -16
+            \\ and sp, sp, a8
+            \\ callx0 %[posixCallMainAndExit]
+            ,
             else => @compileError("unsupported arch"),
         }
         :
@@ -710,12 +720,11 @@ fn mainWithoutEnv(c_argc: c_int, c_argv: [*][*:0]c_char) callconv(.c) c_int {
 /// General error message for a malformed return type
 const bad_main_ret = "expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'";
 
-const use_debug_allocator = !is_wasm and switch (builtin.mode) {
-    .Debug => true,
-    .ReleaseSafe => !builtin.link_libc, // Not ideal, but the best we have for now.
+const use_safe_allocator = !is_wasm and switch (builtin.mode) {
+    .Debug, .ReleaseSafe => true,
     .ReleaseFast, .ReleaseSmall => !builtin.link_libc and builtin.single_threaded, // Also not ideal.
 };
-var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
+var safe_allocator: std.heap.SafeAllocator = .init(std.heap.page_allocator, .{});
 
 inline fn callMain(args: std.process.Args.Vector, environ: std.process.Environ.Block) u8 {
     const fn_info = @typeInfo(@TypeOf(root.main)).@"fn";
@@ -725,8 +734,8 @@ inline fn callMain(args: std.process.Args.Vector, environ: std.process.Environ.B
         .environ = .{ .block = environ },
     }));
 
-    const gpa = if (use_debug_allocator)
-        debug_allocator.allocator()
+    const gpa = if (use_safe_allocator)
+        safe_allocator.allocator()
     else if (builtin.link_libc)
         std.heap.c_allocator
     else if (is_wasm)
@@ -736,8 +745,8 @@ inline fn callMain(args: std.process.Args.Vector, environ: std.process.Environ.B
     else
         comptime unreachable;
 
-    defer if (use_debug_allocator) {
-        _ = debug_allocator.deinit(); // Leaks do not affect return code.
+    defer if (use_safe_allocator) {
+        _ = safe_allocator.deinit(); // Leaks do not affect return code.
     };
 
     const arena_backing_allocator = if (is_wasm) gpa else std.heap.page_allocator;

package/std/testing.zig

@@ -17,19 +17,11 @@ var failing_allocator_instance = FailingAllocator.init(base_allocator_instance.a
 });
 var base_allocator_instance = std.heap.FixedBufferAllocator.init("");
 
-/// This should only be used in temporary test programs.
-pub const allocator = allocator_instance.allocator();
-pub var allocator_instance: std.heap.DebugAllocator(.{
-    .stack_trace_frames = if (std.debug.sys_can_stack_trace) 10 else 0,
-    .resize_stack_traces = true,
-    // A unique value so that when a default-constructed
-    // DebugAllocator is incorrectly passed to testing allocator, or
-    // vice versa, panic occurs.
-    .canary = @truncate(0x2731e675c3a701ba),
-}) = b: {
-    if (!builtin.is_test) @compileError("testing allocator used when not testing");
-    break :b .init;
-};
+pub var allocator_instance: std.heap.SafeAllocator = undefined;
+pub const allocator = if (builtin.is_test)
+    allocator_instance.allocator()
+else
+    @compileError("not testing");
 
 pub var io_instance: Io.Threaded = undefined;
 pub const io = if (builtin.is_test) io_instance.io() else @compileError("not testing");