@zigc/lib 0.16.0 → 0.17.0-dev.27

package/compiler_rt/mulXi3.zig

@@ -63,7 +63,7 @@ fn DoubleInt(comptime T: type) type {
     };
 }
 
-fn muldXi(comptime T: type, a: T, b: T) DoubleInt(T) {
+pub fn muldXi(comptime T: type, a: T, b: T) DoubleInt(T) {
     const DT = DoubleInt(T);
     const word_t = compiler_rt.HalveInt(DT, false);
     const bits_in_word_2 = @sizeOf(T) * 8 / 2;

package/compiler_rt/ssp.zig

@@ -24,7 +24,7 @@ extern fn memmove(dest: ?[*]u8, src: ?[*]const u8, n: usize) callconv(.c) ?[*]u8
 comptime {
     @export(&__stack_chk_fail, .{ .name = if (builtin.os.tag == .openbsd) "__stack_smash_handler" else "__stack_chk_fail", .linkage = compiler_rt.linkage, .visibility = compiler_rt.visibility });
     symbol(&__chk_fail, "__chk_fail");
-    symbol(&__stack_chk_guard, "__stack_chk_guard");
+    symbol(&__stack_chk_guard, if (builtin.os.tag == .openbsd) "__guard_local" else "__stack_chk_guard");
     symbol(&__strcpy_chk, "__strcpy_chk");
     symbol(&__strncpy_chk, "__strncpy_chk");
     symbol(&__strcat_chk, "__strcat_chk");

package/compiler_rt/udivmodei4.zig

@@ -13,6 +13,8 @@ const max_limbs = std.math.divCeil(usize, 65535, 32) catch unreachable; // max s
 comptime {
     symbol(&__udivei4, "__udivei4");
     symbol(&__umodei4, "__umodei4");
+    symbol(&__udivei5, "__udivei5");
+    symbol(&__umodei5, "__umodei5");
 }
 
 /// Get the value of a limb.
@@ -132,6 +134,32 @@ pub fn __umodei4(r_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, bits: usize) ca
     @call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
 }
 
+pub fn __udivei5(q_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, t_p: [*]u8, bits: usize) callconv(.c) void {
+    @setRuntimeSafety(compiler_rt.test_safety);
+    const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits));
+    const q: []u32 = @ptrCast(@alignCast(q_p[0..byte_size]));
+    const u: []const u32 = @ptrCast(@alignCast(u_p[0..byte_size]));
+    const v: []const u32 = @ptrCast(@alignCast(v_p[0..byte_size]));
+    const tu: []u32 = @ptrCast(@alignCast(t_p[0..byte_size]));
+    _ = tu;
+    const tv: []u32 = @ptrCast(@alignCast(t_p[byte_size..][0..byte_size]));
+    _ = tv;
+    @call(.always_inline, divmod, .{ q, null, u, v }) catch unreachable;
+}
+
+pub fn __umodei5(r_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, t_p: [*]u8, bits: usize) callconv(.c) void {
+    @setRuntimeSafety(compiler_rt.test_safety);
+    const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits));
+    const r: []u32 = @ptrCast(@alignCast(r_p[0..byte_size]));
+    const u: []const u32 = @ptrCast(@alignCast(u_p[0..byte_size]));
+    const v: []const u32 = @ptrCast(@alignCast(v_p[0..byte_size]));
+    const tu: []u32 = @ptrCast(@alignCast(t_p[0..byte_size]));
+    _ = tu;
+    const tv: []u32 = @ptrCast(@alignCast(t_p[byte_size..][0..byte_size]));
+    _ = tv;
+    @call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
+}
+
 test "__udivei4/__umodei4" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

package/package.json

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

package/std/Io/Writer.zig

@@ -551,64 +551,64 @@ pub fn writeAll(w: *Writer, bytes: []const u8) Error!void {
     while (index < bytes.len) index += try w.write(bytes[index..]);
 }
 
-/// Renders fmt string with args, calling `writer` with slices of bytes.
-/// If `writer` returns an error, the error is returned from `format` and
-/// `writer` is not called again.
+/// Renders `fmt` string with `args`, calling `w` with slices of bytes.
 ///
-/// The format string must be comptime-known and may contain placeholders following
-/// this format:
-/// `{[argument][specifier]:[fill][alignment][width].[precision]}`
+/// The format string must be comptime-known and may contain placeholders
+/// following this format:
+/// ```
+/// {[argument][specifier]:[fill][alignment][width].[precision]}
+/// ```
 ///
-/// Above, each word including its surrounding [ and ] is a parameter which you have to replace with something:
+/// Above, each word including its surrounding [ and ] is a parameter to be replaced with:
 ///
-/// - *argument* is either the numeric index or the field name of the argument that should be inserted
-///   - when using a field name, you are required to enclose the field name (an identifier) in square
-///     brackets, e.g. {[score]...} as opposed to the numeric index form which can be written e.g. {2...}
-/// - *specifier* is a type-dependent formatting option that determines how a type should formatted (see below)
-/// - *fill* is a single byte which is used to pad formatted numbers.
-/// - *alignment* is one of the three bytes '<', '^', or '>' to make numbers
+/// - **argument** is either the numeric index or the field name of the argument that should be inserted.
+///   - When using a field name, the field name (an identifier) must be enclosed in square
+///     brackets, e.g. `{[score]...}` as opposed to the numeric index form which can be written e.g. `{2...}`.
+/// - **specifier** is a type-dependent formatting option that determines how a type should formatted (see below).
+/// - **fill** is a single byte which is used to pad formatted numbers.
+/// - **alignment** is one of the three bytes '<', '^', or '>' to make numbers
 ///   left, center, or right-aligned, respectively.
 ///   - Not all specifiers support alignment.
-///   - Alignment is not Unicode-aware; appropriate only when used with raw bytes or ASCII.
-/// - *width* is the total width of the field in bytes. This only applies to number formatting.
-/// - *precision* specifies how many decimals a formatted number should have.
+///   - Alignment is not Unicode-aware; appropriate only when used with raw
+///     bytes or ASCII.
+/// - **width** is the total size of the field in bytes, only applicable to
+///   number formatting.
+/// - **precision** specifies how many decimals a formatted number should have.
 ///
-/// Note that most of the parameters are optional and may be omitted. Also you
-/// can leave out separators like `:` and `.` when all parameters after the
-/// separator are omitted.
+/// Most of the parameters are optional and may be omitted. The separators (':'
+/// and '.') may be omitted when all parameters afterwards are omitted.
 ///
-/// Only exception is the *fill* parameter. If a non-zero *fill* character is
-/// required at the same time as *width* is specified, one has to specify
-/// *alignment* as well, as otherwise the digit following `:` is interpreted as
-/// *width*, not *fill*.
+/// The **fill** parameter is an exception. If a non-zero **fill** character is
+/// required at the same time as **width** is specified, **alignment** is
+/// required, otherwise the digit following ':' is interpreted as **width**.
 ///
-/// The *specifier* has several options for types:
-/// - `x` and `X`: output numeric value in hexadecimal notation, or string in hexadecimal bytes
+/// **specifier** supports:
+/// - `x` and `X`: numeric value in hexadecimal notation, or string in hexadecimal bytes
 /// - `s`:
 ///   - for pointer-to-many and C pointers of u8, print as a C-string using zero-termination
 ///   - for slices of u8, print the entire slice as a string without zero-termination
 /// - `t`:
 ///   - for enums and tagged unions: prints the tag name
 ///   - for error sets: prints the error name
-/// - `b64`: output string as standard base64
-/// - `e`: output floating point value in scientific notation
-/// - `d`: output numeric value in decimal notation
-/// - `b`: output integer value in binary notation
-/// - `o`: output integer value in octal notation
-/// - `c`: output integer as an ASCII character. Integer type must have 8 bits at max.
-/// - `u`: output integer as an UTF-8 sequence. Integer type must have 21 bits at max.
-/// - `D`: output nanoseconds as duration
-/// - `B`: output bytes in SI units (decimal)
-/// - `Bi`: output bytes in IEC units (binary)
-/// - `?`: output optional value as either the unwrapped value, or `null`; may be followed by a format specifier for the underlying value.
-/// - `!`: output error union value as either the unwrapped value, or the formatted error value; may be followed by a format specifier for the underlying value.
-/// - `*`: output the address of the value instead of the value itself.
-/// - `any`: output a value of any type using its default format.
+/// - `b64`: string as standard base64
+/// - `e`: floating point value in scientific notation
+/// - `d`: numeric value in decimal notation
+/// - `b`: integer value in binary notation
+/// - `o`: integer value in octal notation
+/// - `c`: integer as an ASCII character. Integer type must have 8 bits at max.
+/// - `u`: integer as an UTF-8 sequence. Integer type must have 21 bits at max.
+/// - `B`: bytes in SI units (decimal)
+/// - `Bi`: bytes in IEC units (binary)
+/// - `?`: optional value as either the unwrapped value, or `null`; may be followed by a format specifier for the underlying value.
+/// - `!`: error union value as either the unwrapped value, or the formatted error value; may be followed by a format specifier for the underlying value.
+/// - `*`: the address of the value instead of the value itself.
+/// - `any`: a value of any type using its default format.
 /// - `f`: delegates to a method on the type named "format" with the signature `fn (*Writer, args: anytype) Writer.Error!void`.
 ///
-/// A user type may be a `struct`, `vector`, `union` or `enum` type.
+/// A user type may be a struct, vector, union or enum type.
 ///
-/// To print literal curly braces, escape them by writing them twice, e.g. `{{` or `}}`.
+/// Literal curly braces can be escaped in the format string via doubling, e.g.
+/// `{{` or `}}`.
 pub fn print(w: *Writer, comptime fmt: []const u8, args: anytype) Error!void {
     const ArgsType = @TypeOf(args);
     const args_type_info = @typeInfo(ArgsType);

package/std/os/emscripten.zig

@@ -211,7 +211,7 @@ pub const W = struct {
     pub fn TERMSIG(s: u32) SIG {
         return @enumFromInt(s & 0x7f);
     }
-    pub fn STOPSIG(s: u32) u32 {
+    pub fn STOPSIG(s: u32) SIG {
         return @enumFromInt(EXITSTATUS(s));
     }
     pub fn IFEXITED(s: u32) bool {

package/std/os/linux/arc.zig

@@ -0,0 +1,144 @@
+const builtin = @import("builtin");
+const std = @import("../../std.zig");
+const SYS = std.os.linux.SYS;
+
+pub fn syscall0(number: SYS) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+        : .{ .memory = true });
+}
+
+pub fn syscall1(number: SYS, arg1: u32) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+        : .{ .memory = true });
+}
+
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+        : .{ .memory = true });
+}
+
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+        : .{ .memory = true });
+}
+
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+        : .{ .memory = true });
+}
+
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+          [arg5] "{r4}" (arg5),
+        : .{ .memory = true });
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+          [arg5] "{r4}" (arg5),
+          [arg6] "{r5}" (arg6),
+        : .{ .memory = true });
+}
+
+pub fn clone() callconv(.naked) u32 {
+    // __clone(func, stack, flags, arg, ptid, tls, ctid)
+    //         r0,   r1,    r2,    r3,  r4,   r5,  r6
+    //
+    // syscall(SYS_clone, flags, stack, ptid, tls, ctid)
+    //         r8         r0,    r1,    r2,   r3,  r4
+    asm volatile (
+        \\    // Align stack pointer
+        \\    and r1, r1, -16
+        \\    mov r10, r0
+        \\    mov r11, r3
+        \\    // Setup the arguments
+        \\    mov r0, r2
+        \\    mov r2, r4
+        \\    mov r3, r5
+        \\    mov r4, r6
+        \\    mov r8, 220 // SYS_clone
+        \\    trap_s 0
+        \\    cmp r0, 0
+        \\    beq 1f
+        \\    j [blink]
+        \\    // Child
+        \\ 1: 
+    );
+    if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
+        \\ .cfi_undefined blink
+    );
+
+    asm volatile (
+        \\    mov fp, 0
+        \\    mov blink, 0
+        \\
+        \\    mov r0, r11
+        \\    jl [r10]
+        \\
+        \\    // Exit
+        \\    mov r8, 93 // SYS_exit
+        \\    trap_s 0
+    );
+}
+
+pub const restore = restore_rt;
+
+pub fn restore_rt() callconv(.naked) noreturn {
+    switch (builtin.zig_backend) {
+        .stage2_c => asm volatile (
+            \\ mov r8, %[number]
+            \\ trap_s 0
+            :
+            : [number] "I" (@intFromEnum(SYS.rt_sigreturn)),
+        ),
+        else => asm volatile (
+            \\ trap_s 0
+            :
+            : [number] "{r8}" (@intFromEnum(SYS.rt_sigreturn)),
+        ),
+    }
+}
+
+pub const time_t = i64;
+
+pub const VDSO = void;

package/std/os/linux.zig

@@ -31,6 +31,7 @@ test {
 
 const arch_bits = switch (native_arch) {
     .aarch64, .aarch64_be => @import("linux/aarch64.zig"),
+    .arc, .arceb => @import("linux/arc.zig"),
     .arm, .armeb, .thumb, .thumbeb => @import("linux/arm.zig"),
     .hexagon => @import("linux/hexagon.zig"),
     .loongarch32 => @import("linux/loongarch32.zig"),
@@ -274,7 +275,13 @@ pub const MAP = switch (native_arch) {
         UNINITIALIZED: bool = false,
         _: u5 = 0,
     },
-    .hexagon, .m68k, .or1k, .s390x => packed struct(u32) {
+    .arc,
+    .arceb,
+    .hexagon,
+    .m68k,
+    .or1k,
+    .s390x,
+    => packed struct(u32) {
         TYPE: MAP_TYPE,
         FIXED: bool = false,
         ANONYMOUS: bool = false,
@@ -451,7 +458,12 @@ pub const O = switch (native_arch) {
         TMPFILE: bool = false,
         _23: u9 = 0,
     },
-    .hexagon, .or1k, .s390x => packed struct(u32) {
+    .arc,
+    .arceb,
+    .hexagon,
+    .or1k,
+    .s390x,
+    => packed struct(u32) {
         ACCMODE: ACCMODE = .RDONLY,
         _2: u4 = 0,
         CREAT: bool = false,

package/libc/mingw/math/fdiml.c

@@ -1,24 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-#include <errno.h>
-#include <math.h>
-
-long double
-fdiml (long double x, long double y)
-{
-  int cx = fpclassify (x), cy = fpclassify (y);
-  long double r;
-
-  if (cx == FP_NAN || cy == FP_NAN
-      || (y < 0 && cx == FP_INFINITE && cy == FP_INFINITE))
-    return x - y;  /* Take care invalid flag is raised.  */
-  if (x <= y)
-    return 0.0;
-  r = x - y;
-  if (fpclassify (r) == FP_INFINITE)
-    errno = ERANGE;
-  return r;
-}

package/libc/musl/src/math/fdimf.c

@@ -1,10 +0,0 @@
-#include <math.h>
-
-float fdimf(float x, float y)
-{
-	if (isnan(x))
-		return x;
-	if (isnan(y))
-		return y;
-	return x > y ? x - y : 0;
-}

package/libc/musl/src/math/fdiml.c

@@ -1,18 +0,0 @@
-#include <math.h>
-#include <float.h>
-
-#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
-long double fdiml(long double x, long double y)
-{
-	return fdim(x, y);
-}
-#else
-long double fdiml(long double x, long double y)
-{
-	if (isnan(x))
-		return x;
-	if (isnan(y))
-		return y;
-	return x > y ? x - y : 0;
-}
-#endif