zig

fork of https://codeberg.org/ziglang/zig
Log | Files | Refs | README | LICENSE

addf3_test.zig (6998B) - Raw

      1 // Ported from:
      2 //
      3 // https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/test/builtins/Unit/addtf3_test.c
      4 // https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/test/builtins/Unit/subtf3_test.c
      5 
      6 const std = @import("std");
      7 const builtin = @import("builtin");
      8 const math = std.math;
      9 const qnan128: f128 = @bitCast(@as(u128, 0x7fff800000000000) << 64);
     10 
     11 const __addtf3 = @import("addtf3.zig").__addtf3;
     12 const __addxf3 = @import("addxf3.zig").__addxf3;
     13 const __subtf3 = @import("subtf3.zig").__subtf3;
     14 
     15 fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
     16     const x = __addtf3(a, b);
     17 
     18     const rep: u128 = @bitCast(x);
     19     const hi: u64 = @intCast(rep >> 64);
     20     const lo: u64 = @truncate(rep);
     21 
     22     if (hi == expected_hi and lo == expected_lo) {
     23         return;
     24     }
     25     // test other possible NaN representation (signal NaN)
     26     else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
     27         if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
     28             ((hi & 0xffffffffffff) > 0 or lo > 0))
     29         {
     30             return;
     31         }
     32     }
     33 
     34     return error.TestFailed;
     35 }
     36 
     37 test "addtf3" {
     38     try test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
     39 
     40     // NaN + any = NaN
     41     try test__addtf3(@as(f128, @bitCast((@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000))), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
     42 
     43     // inf + inf = inf
     44     try test__addtf3(math.inf(f128), math.inf(f128), 0x7fff000000000000, 0x0);
     45 
     46     // inf + any = inf
     47     try test__addtf3(math.inf(f128), 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0);
     48 
     49     // any + any
     50     try test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
     51     try test__addtf3(0x1.edcba52449872455634654321fp-1, 0x1.23456734245345543849abcdefp+5, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
     52 }
     53 
     54 fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
     55     const x = __subtf3(a, b);
     56 
     57     const rep: u128 = @bitCast(x);
     58     const hi: u64 = @intCast(rep >> 64);
     59     const lo: u64 = @truncate(rep);
     60 
     61     if (hi == expected_hi and lo == expected_lo) {
     62         return;
     63     }
     64     // test other possible NaN representation (signal NaN)
     65     else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
     66         if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
     67             ((hi & 0xffffffffffff) > 0 or lo > 0))
     68         {
     69             return;
     70         }
     71     }
     72 
     73     return error.TestFailed;
     74 }
     75 
     76 test "subtf3" {
     77     // qNaN - any = qNaN
     78     try test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
     79 
     80     // NaN + any = NaN
     81     try test__subtf3(@as(f128, @bitCast((@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000))), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
     82 
     83     // inf - any = inf
     84     try test__subtf3(math.inf(f128), 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
     85 
     86     // any + any
     87     try test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c);
     88     try test__subtf3(0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x1.234567829a3bcdef5678ade36734p+5, 0xc0041b8af1915166, 0xa44a7bca780a166c);
     89 }
     90 
     91 const qnan80: f80 = @bitCast(@as(u80, @bitCast(math.nan(f80))) | (1 << (math.floatFractionalBits(f80) - 1)));
     92 
     93 fn test__addxf3(a: f80, b: f80, expected: u80) !void {
     94     const x = __addxf3(a, b);
     95     const rep: u80 = @bitCast(x);
     96 
     97     if (rep == expected)
     98         return;
     99 
    100     if (math.isNan(@as(f80, @bitCast(expected))) and math.isNan(x))
    101         return; // We don't currently test NaN payload propagation
    102 
    103     return error.TestFailed;
    104 }
    105 
    106 test "addxf3" {
    107     // NaN + any = NaN
    108     try test__addxf3(qnan80, 0x1.23456789abcdefp+5, @as(u80, @bitCast(qnan80)));
    109     try test__addxf3(@as(f80, @bitCast(@as(u80, 0x7fff_8000_8000_3000_0000))), 0x1.23456789abcdefp+5, @as(u80, @bitCast(qnan80)));
    110 
    111     // any + NaN = NaN
    112     try test__addxf3(0x1.23456789abcdefp+5, qnan80, @as(u80, @bitCast(qnan80)));
    113     try test__addxf3(0x1.23456789abcdefp+5, @as(f80, @bitCast(@as(u80, 0x7fff_8000_8000_3000_0000))), @as(u80, @bitCast(qnan80)));
    114 
    115     // NaN + inf = NaN
    116     try test__addxf3(qnan80, math.inf(f80), @as(u80, @bitCast(qnan80)));
    117 
    118     // inf + NaN = NaN
    119     try test__addxf3(math.inf(f80), qnan80, @as(u80, @bitCast(qnan80)));
    120 
    121     // inf + inf = inf
    122     try test__addxf3(math.inf(f80), math.inf(f80), @as(u80, @bitCast(math.inf(f80))));
    123 
    124     // inf + -inf = NaN
    125     try test__addxf3(math.inf(f80), -math.inf(f80), @as(u80, @bitCast(qnan80)));
    126 
    127     // -inf + inf = NaN
    128     try test__addxf3(-math.inf(f80), math.inf(f80), @as(u80, @bitCast(qnan80)));
    129 
    130     // inf + any = inf
    131     try test__addxf3(math.inf(f80), 0x1.2335653452436234723489432abcdefp+5, @as(u80, @bitCast(math.inf(f80))));
    132 
    133     // any + inf = inf
    134     try test__addxf3(0x1.2335653452436234723489432abcdefp+5, math.inf(f80), @as(u80, @bitCast(math.inf(f80))));
    135 
    136     // any + any
    137     try test__addxf3(0x1.23456789abcdp+5, 0x1.dcba987654321p+5, 0x4005_BFFFFFFFFFFFC400);
    138     try test__addxf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x4004_957E_4AE4_5ABC_B0F3);
    139     try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.0p-63, 0x3FFF_FFFFFFFFFFFFFFFF); // exact
    140     try test__addxf3(0x1.ffff_ffff_ffff_fffep+0, 0x0.0p0, 0x3FFF_FFFFFFFFFFFFFFFF); // exact
    141     try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.4p-63, 0x3FFF_FFFFFFFFFFFFFFFF); // round down
    142     try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.8p-63, 0x4000_8000000000000000); // round up to even
    143     try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.cp-63, 0x4000_8000000000000000); // round up
    144     try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x2.0p-63, 0x4000_8000000000000000); // exact
    145     try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x2.1p-63, 0x4000_8000000000000000); // round down
    146     try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x3.0p-63, 0x4000_8000000000000000); // round down to even
    147     try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x3.1p-63, 0x4000_8000000000000001); // round up
    148     try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x4.0p-63, 0x4000_8000000000000001); // exact
    149 
    150     try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.0p-63, 0x3FFF_8800000000000000); // exact
    151     try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.7p-63, 0x3FFF_8800000000000000); // round down
    152     try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.8p-63, 0x3FFF_8800000000000000); // round down to even
    153     try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.9p-63, 0x3FFF_8800000000000001); // round up
    154     try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x2.0p-63, 0x3FFF_8800000000000001); // exact
    155     try test__addxf3(0x0.ffff_ffff_ffff_fffcp-16382, 0x0.0000_0000_0000_0002p-16382, 0x0000_7FFFFFFFFFFFFFFF); // exact
    156     try test__addxf3(0x0.1fff_ffff_ffff_fffcp-16382, 0x0.0000_0000_0000_0002p-16382, 0x0000_0FFFFFFFFFFFFFFF); // exact
    157 }