mirror of
https://github.com/ziglang/zig.git
synced 2025-12-06 06:13:07 +00:00
ec95e00e28
stage2: change logic for detecting whether the main package is inside
the std package. Previously it relied on realpath() which is not portable.
This uses resolve() which is how imports already work.
* stage2: fix cleanup bug when creating Module
* flatten lib/std/special/* to lib/*
- this was motivated by making main_pkg_is_inside_std false for
compiler_rt & friends.
* rename "mini libc" to "universal libc"
172 lines
6.5 KiB
Zig
172 lines
6.5 KiB
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("mulXf3.zig").__multf3;
|
|
const __mulxf3 = @import("mulXf3.zig").__mulxf3;
|
|
const __muldf3 = @import("mulXf3.zig").__muldf3;
|
|
const __mulsf3 = @import("mulXf3.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
|
|
}
|