@zigc/lib 0.16.0-test.1 → 0.16.0

package/compiler_rt/limb64.zig

@@ -0,0 +1,266 @@
+const std = @import("std");
+const testing = std.testing;
+const assert = std.debug.assert;
+const maxInt = std.math.maxInt;
+const minInt = std.math.minInt;
+const divCeil = std.math.divCeil;
+
+const builtin = @import("builtin");
+const compiler_rt = @import("../compiler_rt.zig");
+
+const endian = builtin.cpu.arch.endian();
+
+inline fn limbGet(limbs: []const u64, i: usize) u64 {
+    return switch (endian) {
+        .little => limbs[i],
+        .big => limbs[limbs.len - 1 - i],
+    };
+}
+
+inline fn limbSet(limbs: []u64, i: usize, value: u64) void {
+    switch (endian) {
+        .little => limbs[i] = value,
+        .big => limbs[limbs.len - 1 - i] = value,
+    }
+}
+
+fn limbCount(bits: u16) u16 {
+    return divCeil(u16, bits, 64) catch unreachable;
+}
+
+fn Limbs(T: type) type {
+    const int_info = @typeInfo(T).int;
+    const limb_cnt = comptime limbCount(int_info.bits);
+    return [limb_cnt]u64;
+}
+
+fn asLimbs(v: anytype) Limbs(@TypeOf(v)) {
+    const T = @TypeOf(v);
+    const int_info = @typeInfo(T).int;
+    const limb_cnt = comptime limbCount(int_info.bits);
+    const ET = @Int(int_info.signedness, limb_cnt * 64);
+    return @bitCast(@as(ET, v));
+}
+
+fn limbWrap(limb: u64, is_signed: bool, bits: u16) u64 {
+    assert(bits % 64 != 0);
+    const pad_bits: u6 = @intCast(64 - bits % 64);
+    if (!is_signed) {
+        const s = limb << pad_bits;
+        return s >> pad_bits;
+    } else {
+        const s = @as(i64, @bitCast(limb)) << pad_bits;
+        return @bitCast(s >> pad_bits);
+    }
+}
+
+comptime {
+    @export(&__addo_limb64, .{ .name = "__addo_limb64", .linkage = compiler_rt.linkage, .visibility = compiler_rt.visibility });
+}
+
+fn __addo_limb64(out_ptr: [*]u64, a_ptr: [*]const u64, b_ptr: [*]const u64, is_signed: bool, bits: u16) callconv(.c) bool {
+    const limb_cnt = limbCount(bits);
+    const out = out_ptr[0..limb_cnt];
+    const a = a_ptr[0..limb_cnt];
+    const b = b_ptr[0..limb_cnt];
+
+    var carry: u1 = 0;
+    var i: usize = 0;
+    while (i < limb_cnt - 1) : (i += 1) {
+        const s1 = @addWithOverflow(limbGet(a, i), limbGet(b, i));
+        const s2 = @addWithOverflow(s1[0], carry);
+        carry = s1[1] | s2[1];
+        limbSet(out, i, s2[0]);
+    }
+
+    const limb: u64 = b: {
+        if (!is_signed) {
+            const s1 = @addWithOverflow(limbGet(a, i), limbGet(b, i));
+            const s2 = @addWithOverflow(s1[0], carry);
+            carry = s1[1] | s2[1];
+            break :b s2[0];
+        } else {
+            const as: i64 = @bitCast(limbGet(a, i));
+            const bs: i64 = @bitCast(limbGet(b, i));
+            const s1 = @addWithOverflow(as, bs);
+            const s2 = @addWithOverflow(s1[0], carry);
+            carry = s1[1] | s2[1];
+            break :b @bitCast(s2[0]);
+        }
+    };
+
+    if (bits % 64 == 0) {
+        limbSet(out, i, limb);
+        return carry != 0;
+    } else {
+        assert(carry == 0);
+        const wrapped_limb = limbWrap(limb, is_signed, bits);
+        limbSet(out, i, wrapped_limb);
+        return wrapped_limb != limb;
+    }
+}
+
+fn test__addo_limb64(comptime T: type, a: T, b: T, expected: struct { T, bool }) !void {
+    const int_info = @typeInfo(T).int;
+    const is_signed = int_info.signedness == .signed;
+
+    var a_limbs = asLimbs(a);
+    var b_limbs = asLimbs(b);
+    var out: Limbs(T) = undefined;
+    const overflow = __addo_limb64(&out, &a_limbs, &b_limbs, is_signed, int_info.bits);
+
+    const expected_limbs = asLimbs(expected[0]);
+    try testing.expectEqual(expected_limbs, out);
+    try testing.expectEqual(expected[1], overflow);
+}
+
+test __addo_limb64 {
+    try test__addo_limb64(u64, 1, 2, .{ 3, false });
+    try test__addo_limb64(u64, maxInt(u64), 2, .{ 1, true });
+    try test__addo_limb64(u65, maxInt(u65), 2, .{ 1, true });
+    try test__addo_limb64(u255, 1, 2, .{ 3, false });
+
+    try test__addo_limb64(i64, 1, 2, .{ 3, false });
+    try test__addo_limb64(i64, maxInt(i64), 1, .{ minInt(i64), true });
+    try test__addo_limb64(i65, maxInt(i65), 1, .{ minInt(i65), true });
+    try test__addo_limb64(i255, -3, 2, .{ -1, false });
+}
+
+comptime {
+    @export(&__subo_limb64, .{ .name = "__subo_limb64", .linkage = compiler_rt.linkage, .visibility = compiler_rt.visibility });
+}
+
+fn __subo_limb64(out_ptr: [*]u64, a_ptr: [*]const u64, b_ptr: [*]const u64, is_signed: bool, bits: u16) callconv(.c) bool {
+    const limb_cnt = limbCount(bits);
+    const out = out_ptr[0..limb_cnt];
+    const a = a_ptr[0..limb_cnt];
+    const b = b_ptr[0..limb_cnt];
+
+    var borrow: u1 = 0;
+    var i: usize = 0;
+    while (i < limb_cnt - 1) : (i += 1) {
+        const s1 = @subWithOverflow(limbGet(a, i), limbGet(b, i));
+        const s2 = @subWithOverflow(s1[0], borrow);
+        borrow = s1[1] | s2[1];
+        limbSet(out, i, s2[0]);
+    }
+
+    const limb: u64 = b: {
+        if (!is_signed) {
+            const s1 = @subWithOverflow(limbGet(a, i), limbGet(b, i));
+            const s2 = @subWithOverflow(s1[0], borrow);
+            borrow = s1[1] | s2[1];
+            break :b s2[0];
+        } else {
+            const as: i64 = @bitCast(limbGet(a, i));
+            const bs: i64 = @bitCast(limbGet(b, i));
+            const s1 = @subWithOverflow(as, bs);
+            const s2 = @subWithOverflow(s1[0], borrow);
+            borrow = s1[1] | s2[1];
+            break :b @bitCast(s2[0]);
+        }
+    };
+
+    if (bits % 64 == 0) {
+        limbSet(out, i, limb);
+        return borrow != 0;
+    } else {
+        const wrapped_limb = limbWrap(limb, is_signed, bits);
+        limbSet(out, i, wrapped_limb);
+        return borrow != 0 or wrapped_limb != limb;
+    }
+}
+
+fn test__subo_limb64(comptime T: type, a: T, b: T, expected: struct { T, bool }) !void {
+    const int_info = @typeInfo(T).int;
+    const is_signed = int_info.signedness == .signed;
+
+    var a_limbs = asLimbs(a);
+    var b_limbs = asLimbs(b);
+    var out: Limbs(T) = undefined;
+    const overflow = __subo_limb64(&out, &a_limbs, &b_limbs, is_signed, int_info.bits);
+
+    const expected_limbs = asLimbs(expected[0]);
+    try testing.expectEqual(expected_limbs, out);
+    try testing.expectEqual(expected[1], overflow);
+}
+
+test __subo_limb64 {
+    try test__subo_limb64(u64, 3, 2, .{ 1, false });
+    try test__subo_limb64(u64, 0, 1, .{ maxInt(u64), true });
+    try test__subo_limb64(u65, 0, 1, .{ maxInt(u65), true });
+    try test__subo_limb64(u255, 3, 2, .{ 1, false });
+
+    try test__subo_limb64(i64, 1, 2, .{ -1, false });
+    try test__subo_limb64(i64, minInt(i64), 1, .{ maxInt(i64), true });
+    try test__subo_limb64(i65, minInt(i65), 1, .{ maxInt(i65), true });
+    try test__subo_limb64(i255, -1, 2, .{ -3, false });
+}
+
+comptime {
+    @export(&__cmp_limb64, .{ .name = "__cmp_limb64", .linkage = compiler_rt.linkage, .visibility = compiler_rt.visibility });
+}
+
+// a < b  -> -1
+// a == b ->  0
+// a > b  ->  1
+fn __cmp_limb64(a_ptr: [*]const u64, b_ptr: [*]const u64, is_signed: bool, bits: u16) callconv(.c) i8 {
+    const limb_cnt = limbCount(bits);
+    const a = a_ptr[0..limb_cnt];
+    const b = b_ptr[0..limb_cnt];
+
+    var i: usize = 0;
+    if (is_signed) {
+        const sa: i64 = @bitCast(limbGet(a, limb_cnt - 1));
+        const sb: i64 = @bitCast(limbGet(b, limb_cnt - 1));
+        if (sa < sb) return -1;
+        if (sa > sb) return 1;
+        i += 1;
+    }
+
+    while (i < limb_cnt) : (i += 1) {
+        const ai = limbGet(a, limb_cnt - 1 - i);
+        const bi = limbGet(b, limb_cnt - 1 - i);
+        if (ai < bi) return -1;
+        if (ai > bi) return 1;
+    }
+
+    return 0;
+}
+
+fn test__cmp_limb64(comptime T: type, a: T, b: T, expected: i8) !void {
+    const int_info = @typeInfo(T).int;
+    const is_signed = int_info.signedness == .signed;
+
+    var a_limbs = asLimbs(a);
+    var b_limbs = asLimbs(b);
+    const actual = __cmp_limb64(&a_limbs, &b_limbs, is_signed, int_info.bits);
+
+    try testing.expectEqual(expected, actual);
+}
+
+test __cmp_limb64 {
+    try test__cmp_limb64(u64, 1, 2, -1);
+    try test__cmp_limb64(u64, 2, 2, 0);
+    try test__cmp_limb64(u64, 3, 2, 1);
+
+    try test__cmp_limb64(u65, 1, 2, -1);
+    try test__cmp_limb64(u65, maxInt(u65), maxInt(u65), 0);
+    try test__cmp_limb64(u65, maxInt(u65), maxInt(u65) - 1, 1);
+
+    try test__cmp_limb64(u255, 1, 2, -1);
+    try test__cmp_limb64(u255, 7, 7, 0);
+    try test__cmp_limb64(u255, maxInt(u255), maxInt(u255) - 1, 1);
+
+    try test__cmp_limb64(i64, -1, 0, -1);
+    try test__cmp_limb64(i64, 0, 0, 0);
+    try test__cmp_limb64(i64, 1, 0, 1);
+
+    try test__cmp_limb64(i65, minInt(i65), maxInt(i65), -1);
+    try test__cmp_limb64(i65, -1, -1, 0);
+    try test__cmp_limb64(i65, maxInt(i65), minInt(i65), 1);
+
+    try test__cmp_limb64(i255, -3, 2, -1);
+    try test__cmp_limb64(i255, -5, -5, 0);
+    try test__cmp_limb64(i255, 2, -3, 1);
+}

package/compiler_rt/long_double.zig

@@ -0,0 +1,37 @@
+//! Utilities for dealing with the `long double` type (`f80` or `f128`)
+
+const std = @import("std");
+
+pub const U80 = std.meta.Int(.unsigned, 80);
+
+/// Returns the sign + exponent bits of a `long double`
+pub fn signExponent(x: anytype) u16 {
+    const T = @TypeOf(x);
+    switch (T) {
+        f80 => {
+            const bits: U80 = @bitCast(x);
+            return @intCast(bits >> 64);
+        },
+        f128 => {
+            const bits: u128 = @bitCast(x);
+            return @intCast(bits >> 112);
+        },
+        else => @compileError("`signExponent` supports only `f80` and `f128`, got: " ++ @typeName(T)),
+    }
+}
+
+/// Takes the top 16 bits of a `long double`'s mantissa
+pub fn mantissaTop(x: anytype) u16 {
+    const T = @TypeOf(x);
+    switch (T) {
+        f80 => {
+            const bits: U80 = @bitCast(x);
+            return @intCast((bits >> 48) & 0xFFFF);
+        },
+        f128 => {
+            const bits: u128 = @bitCast(x);
+            return @intCast((bits >> 96) & 0xFFFF);
+        },
+        else => @compileError("`mantissaTop` supports only `f80` and `f128`, got: " ++ @typeName(T)),
+    }
+}

package/compiler_rt/mulo.zig

@@ -19,7 +19,12 @@ comptime {
 inline fn muloXi4_genericSmall(comptime ST: type, a: ST, b: ST, overflow: *c_int) ST {
     overflow.* = 0;
     const min = math.minInt(ST);
-    const res: ST = a *% b;
+    const res: ST = if (ST == i128 and builtin.target.cpu.arch.isWasm()) res: {
+        // Despite compiler-rt being built with `-fno-builtin`, LLVM still converts this function to
+        // a call to `__muloti4` on WASM. This is an upstream bug: circumvent it by directly calling
+        // the "lower-level" compiler-rt routine for this wrapping multiplication.
+        break :res @import("mulXi3.zig").__multi3(a, b);
+    } else a *% b;
     // Hacker's Delight section Overflow subsection Multiplication
     // case a=-2^{31}, b=-1 problem, because
     // on some machines a*b = -2^{31} with overflow

package/compiler_rt/rem_pio2l.zig

@@ -0,0 +1,173 @@
+// Ported from musl, which is licensed under the MIT license:
+// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//
+// https://git.musl-libc.org/cgit/musl/tree/src/math/__rem_pio2l.c
+
+const std = @import("std");
+const math = std.math;
+
+const ld = @import("long_double.zig");
+const rem_pio2_large = @import("rem_pio2_large.zig").rem_pio2_large;
+
+pub fn rem_pio2l(comptime T: type, x: T, y: *[2]T) i32 {
+    const impl = switch (T) {
+        f80 => struct {
+            const round1: i8 = 22;
+            const round2: i8 = 61;
+            const nx: i8 = 3;
+            const ny: i8 = 2;
+
+            const pio4: T = 0x1.921fb54442d1846ap-1;
+            // 64 bits of 2/pi
+            const invpio2: T = 6.36619772367581343076e-01; // 0xa2f9836e4e44152a.0p-64
+            // first  39 bits of pi/2
+            const pio2_1: f64 = 1.57079632679597125389e+00; // 0x3FF921FB, 0x54444000
+            // pi/2 - pio2_1
+            const pio2_1t: T = -1.07463465549719416346e-12; // -0x973dcb3b399d747f.0p-103
+            // second 39 bits of pi/2
+            const pio2_2: f64 = -1.07463465549783099519e-12; // -0x12e7b967674000.0p-92
+            // pi/2 - (pio2_1+pio2_2)
+            const pio2_2t: T = 6.36831716351095013979e-25; // 0xc51701b839a25205.0p-144
+            // pi/2 - (pio2_1+pio2_2+pio2_3)
+            const pio2_3t: T = -2.75299651904407171810e-37; // -0xbb5bf6c7ddd660ce.0p-185
+            // third  39 bits of pi/2
+            const pio2_3: f64 = 6.36831716351370313614e-25; // 0x18a2e037074000.0p-133
+
+            fn small(x_val: T) bool {
+                const se = ld.signExponent(x_val);
+                const top = ld.mantissaTop(x_val);
+                const lhs = (@as(u32, se & 0x7fff) << 16) | top;
+                const rhs: u32 = ((0x3fff + 25) << 16) | 0x921f >> 1 | 0x8000;
+                return lhs < rhs;
+            }
+
+            fn quobits(v: T) i32 {
+                const q: i32 = @intFromFloat(v);
+                return @intCast(@as(u32, @bitCast(q)) & 0x7fffffff);
+            }
+        },
+        f128 => struct {
+            const round1: i8 = 51;
+            const round2: i8 = 119;
+            const nx: i8 = 5;
+            const ny: i8 = 3;
+
+            const pio4: T = 0x1.921fb54442d18469898cc51701b8p-1;
+            const invpio2: T = 6.3661977236758134307553505349005747e-01;
+            const pio2_1: T = 1.5707963267948966192292994253909555e+00;
+            const pio2_1t: T = 2.0222662487959507323996846200947577e-21;
+            const pio2_2: T = 2.0222662487959507323994779168837751e-21;
+            const pio2_2t: T = 2.0670321098263988236496903051604844e-43;
+            const pio2_3: T = 2.0670321098263988236499468110329591e-43;
+            const pio2_3t: T = -2.5650587247459238361625433492959285e-65;
+
+            fn small(x_val: T) bool {
+                const se = ld.signExponent(x_val);
+                const top = ld.mantissaTop(x_val);
+                const lhs = (@as(u32, se & 0x7fff) << 16) | top;
+                const rhs: u32 = ((0x3fff + 45) << 16) | 0x921f;
+                return lhs < rhs;
+            }
+
+            fn quobits(fn_val: T) i32 {
+                const q: i64 = @intFromFloat(fn_val);
+                return @intCast(@as(u64, @bitCast(q)) & 0x7fffffff);
+            }
+        },
+        else => @compileError("rem_pio2l supports only f80 and f128, got: " ++ @typeName(T)),
+    };
+
+    const x_se = ld.signExponent(x);
+    const ex: i32 = @intCast(x_se & 0x7fff);
+
+    if (impl.small(x)) {
+        // rint(x/(pi/2))
+        const toint: T = 1.5 / math.floatEps(T);
+        var fn_ = x * impl.invpio2 + toint - toint;
+        var n = impl.quobits(fn_);
+        var r = x - fn_ * @as(T, impl.pio2_1);
+        var w = fn_ * impl.pio2_1t; // 1st round good to 102/180 bits
+
+        // Matters with directed rounding.
+        if (r - w < -impl.pio4) {
+            @branchHint(.unlikely);
+            n -= 1;
+            fn_ -= 1;
+            r = x - fn_ * @as(T, impl.pio2_1);
+            w = fn_ * impl.pio2_1t;
+        } else if (r - w > impl.pio4) {
+            @branchHint(.unlikely);
+            n += 1;
+            fn_ += 1;
+            r = x - fn_ * @as(T, impl.pio2_1);
+            w = fn_ * impl.pio2_1t;
+        }
+
+        y[0] = r - w;
+
+        const ey: i32 = @intCast(ld.signExponent(y[0]) & 0x7fff);
+        if (ex - ey > impl.round1) {
+            var t = r;
+            w = fn_ * impl.pio2_2;
+            r = t - w;
+            w = fn_ * impl.pio2_2t - ((t - r) - w);
+            y[0] = r - w;
+            const ey2: i32 = @intCast(ld.signExponent(y[0]) & 0x7fff);
+            if (ex - ey2 > impl.round2) {
+                t = r;
+                w = fn_ * impl.pio2_3;
+                r = t - w;
+                w = fn_ * impl.pio2_3t - ((t - r) - w);
+                y[0] = r - w;
+            }
+        }
+        y[1] = (r - y[0]) - w;
+        return n;
+    }
+
+    // all other (large) arguments
+    if (ex == 0x7fff) { // x is inf or NaN
+        y[0] = x - x;
+        y[1] = y[0];
+        return 0;
+    }
+
+    var z: T = math.scalbn(@abs(x), -math.ilogb(x) + 23);
+    var tx: [impl.nx]f64 = undefined;
+    var ty: [impl.ny]f64 = undefined;
+    var i: usize = 0;
+
+    while (i < impl.nx - 1) : (i += 1) {
+        tx[i] = @floatFromInt(@as(i32, @intFromFloat(z)));
+        z = (z - @as(T, tx[i])) * 0x1p24;
+    }
+
+    tx[i] = @floatCast(z);
+    while (tx[i] == 0.0) {
+        i -= 1;
+    }
+
+    const n = rem_pio2_large(
+        tx[0..(i + 1)],
+        ty[0..impl.ny],
+        ex - 0x3fff - 23,
+        @intCast(i + 1),
+        impl.ny,
+    );
+    var w: f64 = ty[1];
+    if (impl.ny == 3) {
+        w += ty[2];
+    }
+    const r = ty[0] + w;
+    w -= r - ty[0];
+
+    if (x_se >> 15 != 0) {
+        y[0] = -@as(T, r);
+        y[1] = -@as(T, w);
+        return -n;
+    }
+
+    y[0] = @as(T, r);
+    y[1] = @as(T, w);
+    return n;
+}