zig/lib/compiler_rt/mulf3_test.zig

// Ported from:
//
// https://github.com/llvm/llvm-project/blob/2ffb1b0413efa9a24eb3c49e710e36f92e2cb50b/compiler-rt/test/builtins/Unit/multf3_test.c

const std = @import("std");
const math = std.math;
const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);

const __multf3 = @import("multf3.zig").__multf3;
const __mulxf3 = @import("mulxf3.zig").__mulxf3;
const __muldf3 = @import("muldf3.zig").__muldf3;
const __mulsf3 = @import("mulsf3.zig").__mulsf3;

// return true if equal
// use two 64-bit integers intead of one 128-bit integer
// because 128-bit integer constant can't be assigned directly
fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {
    const rep = @bitCast(u128, result);
    const hi = @intCast(u64, rep >> 64);
    const lo = @truncate(u64, rep);

    if (hi == expectedHi and lo == expectedLo) {
        return true;
    }
    // test other possible NaN representation(signal NaN)
    if (expectedHi == 0x7fff800000000000 and expectedLo == 0x0) {
        if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
            ((hi & 0xffffffffffff) > 0 or lo > 0))
        {
            return true;
        }
    }
    return false;
}

fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
    const x = __multf3(a, b);

    if (compareResultLD(x, expected_hi, expected_lo))
        return;

    @panic("__multf3 test failure");
}

fn makeNaN128(rand: u64) f128 {
    const int_result = @as(u128, 0x7fff000000000000 | (rand & 0xffffffffffff)) << 64;
    const float_result = @bitCast(f128, int_result);
    return float_result;
}
test "multf3" {
    // qNaN * any = qNaN
    try test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);

    // NaN * any = NaN
    const a = makeNaN128(0x800030000000);
    try test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
    // inf * any = inf
    try test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);

    // any * any
    try test__multf3(
        @bitCast(f128, @as(u128, 0x40042eab345678439abcdefea5678234)),
        @bitCast(f128, @as(u128, 0x3ffeedcb34a235253948765432134675)),
        0x400423e7f9e3c9fc,
        0xd906c2c2a85777c4,
    );

    try test__multf3(
        @bitCast(f128, @as(u128, 0x3fcd353e45674d89abacc3a2ebf3ff50)),
        @bitCast(f128, @as(u128, 0x3ff6ed8764648369535adf4be3214568)),
        0x3fc52a163c6223fc,
        0xc94c4bf0430768b4,
    );

    try test__multf3(
        0x1.234425696abcad34a35eeffefdcbap+456,
        0x451.ed98d76e5d46e5f24323dff21ffp+600,
        0x44293a91de5e0e94,
        0xe8ed17cc2cdf64ac,
    );

    try test__multf3(
        @bitCast(f128, @as(u128, 0x3f154356473c82a9fabf2d22ace345df)),
        @bitCast(f128, @as(u128, 0x3e38eda98765476743ab21da23d45679)),
        0x3d4f37c1a3137cae,
        0xfc6807048bc2836a,
    );

    try test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0);

    // Denormal operands.
    try test__multf3(
        0x0.0000000000000000000000000001p-16382,
        0x1p16383,
        0x3f90000000000000,
        0x0,
    );
    try test__multf3(
        0x1p16383,
        0x0.0000000000000000000000000001p-16382,
        0x3f90000000000000,
        0x0,
    );

    try test__multf3(0x1.0000_0000_0000_0000_0000_0000_0001p+0, 0x1.8p+5, 0x4004_8000_0000_0000, 0x0000_0000_0000_0002);
    try test__multf3(0x1.0000_0000_0000_0000_0000_0000_0002p+0, 0x1.8p+5, 0x4004_8000_0000_0000, 0x0000_0000_0000_0003);
    try test__multf3(2.0, math.floatTrueMin(f128), 0x0000_0000_0000_0000, 0x0000_0000_0000_0002);
}

const qnan80 = @bitCast(f80, @bitCast(u80, math.nan(f80)) | (1 << (math.floatFractionalBits(f80) - 1)));

fn test__mulxf3(a: f80, b: f80, expected: u80) !void {
    const x = __mulxf3(a, b);
    const rep = @bitCast(u80, x);

    if (rep == expected)
        return;

    if (math.isNan(@bitCast(f80, expected)) and math.isNan(x))
        return; // We don't currently test NaN payload propagation

    return error.TestFailed;
}

test "mulxf3" {
    // NaN * any = NaN
    try test__mulxf3(qnan80, 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
    try test__mulxf3(@bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));

    // any * NaN = NaN
    try test__mulxf3(0x1.23456789abcdefp+5, qnan80, @bitCast(u80, qnan80));
    try test__mulxf3(0x1.23456789abcdefp+5, @bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), @bitCast(u80, qnan80));

    // NaN * inf = NaN
    try test__mulxf3(qnan80, math.inf(f80), @bitCast(u80, qnan80));

    // inf * NaN = NaN
    try test__mulxf3(math.inf(f80), qnan80, @bitCast(u80, qnan80));

    // inf * inf = inf
    try test__mulxf3(math.inf(f80), math.inf(f80), @bitCast(u80, math.inf(f80)));

    // inf * -inf = -inf
    try test__mulxf3(math.inf(f80), -math.inf(f80), @bitCast(u80, -math.inf(f80)));

    // -inf + inf = -inf
    try test__mulxf3(-math.inf(f80), math.inf(f80), @bitCast(u80, -math.inf(f80)));

    // inf * any = inf
    try test__mulxf3(math.inf(f80), 0x1.2335653452436234723489432abcdefp+5, @bitCast(u80, math.inf(f80)));

    // any * inf = inf
    try test__mulxf3(0x1.2335653452436234723489432abcdefp+5, math.inf(f80), @bitCast(u80, math.inf(f80)));

    // any * any
    try test__mulxf3(0x1.0p+0, 0x1.dcba987654321p+5, 0x4004_ee5d_4c3b_2a19_0800);
    try test__mulxf3(0x1.0000_0000_0000_0004p+0, 0x1.8p+5, 0x4004_C000_0000_0000_0003); // exact

    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.0p+5, 0x4004_8000_0000_0000_0001); // exact
    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.7ffep+5, 0x4004_BFFF_0000_0000_0001); // round down
    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.8p+5, 0x4004_C000_0000_0000_0002); // round up to even
    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.8002p+5, 0x4004_C001_0000_0000_0002); // round up
    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.0p+6, 0x4005_8000_0000_0000_0001); // exact

    try test__mulxf3(0x1.0000_0001p+0, 0x1.0000_0001p+0, 0x3FFF_8000_0001_0000_0000); // round down to even
    try test__mulxf3(0x1.0000_0001p+0, 0x1.0000_0001_0002p+0, 0x3FFF_8000_0001_0001_0001); // round up
    try test__mulxf3(0x0.8000_0000_0000_0000p-16382, 2.0, 0x0001_8000_0000_0000_0000); // denormal -> normal
    try test__mulxf3(0x0.7fff_ffff_ffff_fffep-16382, 0x2.0000_0000_0000_0008p0, 0x0001_8000_0000_0000_0000); // denormal -> normal
    try test__mulxf3(0x0.7fff_ffff_ffff_fffep-16382, 0x1.0000_0000_0000_0000p0, 0x0000_3FFF_FFFF_FFFF_FFFF); // denormal -> denormal
}