[builtins] Add more test cases for __div[sdt]f3 LibCalls

[atrosinenko]

Summary

The existing tests for softfloat division for single and double precisions contain only two test cases each and only the quad precision test has somewhat more test cases.

This patch

• makes the three tests look more uniformly
• specifies types of integer and fp literals more stricter
• adds more test cases (basically, everything that was in some of test files is put everythere)
  • tests are added for obviously special cases of +/-Inf, +/-0 and some more implementation-specific cases such as divisor being almost 1.0
• makes NaN in the second test case of divtf3 to be sNaN instead of testing for qNaN again

This patch is sent in preparation for unifying the division implementations and implementing subnormal result handling.

[atrosinenko]

Ping.

[atrosinenko]

Ping

[sepavloff]

compiler-rt/test/builtins/Unit/divdf3_test.c

29–34

Expressions `any/nan' also could be checked.

49–54

Expression `Inf/0' also could be checked.

92

Is 0x1.00000001p+0 equal to 1.0 in UQ1.31?

compiler-rt/test/builtins/Unit/divsf3_test.c

27

Similar notes as for double precision checks.

compiler-rt/test/builtins/Unit/divtf3_test.c

34–36

Similar notes as double precision checks.

[atrosinenko]

Address the review comments.

[atrosinenko]

@sepavloff

Thank you for the test cases. Looks like it is worth completely rewriting the three tests as table-driven tests, so for example adding four cases for [+-]Inf / [+-]0.0 would be almost as easy as testing only one of them (something similar is already implemented for udivmod?i4_test.c). The differences between adjacent test cases would be more visually obvious, as well.

compiler-rt/test/builtins/Unit/divdf3_test.c

92

Divisor is 1.(31 zeroes)1 after restoring the implicit bit, so it is truncated to 1.0 as UQ1.31. Instead of counting bits carefully, it would probably be better to add several tests with the 1 bit shifted 1-2 places left/right as well as if the divisor is round up instead of truncating - just in case. :) So, with table-driven test it would probably be simpler to not make extra assumptions on the implementation.

[sepavloff]

In D84932#2223559, @atrosinenko wrote:

@sepavloff

Thank you for the test cases. Looks like it is worth completely rewriting the three tests as table-driven tests

Tests are not required to be compact. It is more important to have clear checks, which can be easily extracted. Table-driven tests are suitable if number of test cases is large, I think this is not the case.

compiler-rt/test/builtins/Unit/divdf3_test.c

92

Divisor is 1.(31 zeroes)1

So it is not 1.0 and the comment is misleading. Try rewording the comment to avoid confusion. Maybe divisor is truncated to 1.0 in UQ1.31 or something like that.

[atrosinenko]

Rebase the entire patch stack against the up-to-date master and re-upload.

[atrosinenko]

Fix the misleading comment.

compiler-rt/test/builtins/Unit/divdf3_test.c

92

Now got it, thank you.

[sepavloff]

LGTM.

[atrosinenko]

Uploaded, thank you!

compiler-rt/test/builtins/Unit/divdf3_test.c

if (ret){
                "expected %.20e\n", a, b, x,
                fromRep64(expected));
     }
     return ret;
 }
 
 int main()
 {
+    // Returned NaNs are assumed to be qNaN by default
+
+    // qNaN / any = qNaN
+    if (test__divdf3(makeQNaN64(), 3., UINT64_C(0x7ff8000000000000)))
+      return 1;
+    // NaN / any = NaN
+    if (test__divdf3(makeNaN64(UINT64_C(0x123)), 3., UINT64_C(0x7ff8000000000000)))
+      return 1;
+    // any / qNaN = qNaN
+    if (test__divdf3(3., makeQNaN64(), UINT64_C(0x7ff8000000000000)))
+      return 1;
+    // any / NaN = NaN
+    if (test__divdf3(3., makeNaN64(UINT64_C(0x123)), UINT64_C(0x7ff8000000000000)))
+      return 1;
+
+    // +Inf / positive = +Inf
+    if (test__divdf3(makeInf64(), 3., UINT64_C(0x7ff0000000000000)))
+      return 1;
+    // +Inf / negative = -Inf
+    if (test__divdf3(makeInf64(), -3., UINT64_C(0xfff0000000000000)))
+      return 1;
+    // -Inf / positive = -Inf
+    if (test__divdf3(makeNegativeInf64(), 3., UINT64_C(0xfff0000000000000)))
+      return 1;
+    // -Inf / negative = +Inf
+    if (test__divdf3(makeNegativeInf64(), -3., UINT64_C(0x7ff0000000000000)))
+      return 1;
+
+    // Inf / Inf = NaN
+    if (test__divdf3(makeInf64(), makeInf64(), UINT64_C(0x7ff8000000000000)))
+      return 1;
+    // 0.0 / 0.0 = NaN
+    if (test__divdf3(+0x0.0p+0, +0x0.0p+0, UINT64_C(0x7ff8000000000000)))
+      return 1;
+    // +0.0 / +Inf = +0.0
+    if (test__divdf3(+0x0.0p+0, makeInf64(), UINT64_C(0x0)))
+      return 1;
+    // +Inf / +0.0 = +Inf
+    if (test__divdf3(makeInf64(), +0x0.0p+0, UINT64_C(0x7ff0000000000000)))
+      return 1;
+
+    // positive / +0.0 = +Inf
+    if (test__divdf3(+1.0, +0x0.0p+0, UINT64_C(0x7ff0000000000000)))
+      return 1;
+    // positive / -0.0 = -Inf
+    if (test__divdf3(+1.0, -0x0.0p+0, UINT64_C(0xfff0000000000000)))
+      return 1;
+    // negative / +0.0 = -Inf
+    if (test__divdf3(-1.0, +0x0.0p+0, UINT64_C(0xfff0000000000000)))
+      return 1;
+    // negative / -0.0 = +Inf
+    if (test__divdf3(-1.0, -0x0.0p+0, UINT64_C(0x7ff0000000000000)))
+      return 1;
+
     // 1/3
-    if (test__divdf3(1., 3., 0x3fd5555555555555ULL))
+    if (test__divdf3(1., 3., UINT64_C(0x3fd5555555555555)))
       return 1;
     // smallest normal result
-    if (test__divdf3(4.450147717014403e-308, 2., 0x10000000000000ULL))
+    if (test__divdf3(0x1.0p-1021, 2., UINT64_C(0x10000000000000)))
+      return 1;
+
+    // divisor is exactly 1.0
+    if (test__divdf3(0x1.0p+0, 0x1.0p+0, UINT64_C(0x3ff0000000000000)))
+      return 1;
+    // divisor is truncated to exactly 1.0 in UQ1.31
+    if (test__divdf3(0x1.0p+0, 0x1.00000001p+0, UINT64_C(0x3fefffffffe00000)))
       return 1;
 
     return 0;
 }

compiler-rt/test/builtins/Unit/divsf3_test.c

if (ret){
                "expected %.20e\n", a, b, x,
                fromRep32(expected));
     }
     return ret;
 }
 
 int main()
 {
+    // Returned NaNs are assumed to be qNaN by default
+
+    // qNaN / any = qNaN
+    if (test__divsf3(makeQNaN32(), 3.F, UINT32_C(0x7fc00000)))
+      return 1;
+    // NaN / any = NaN
+    if (test__divsf3(makeNaN32(UINT32_C(0x123)), 3.F, UINT32_C(0x7fc00000)))
+      return 1;
+    // any / qNaN = qNaN
+    if (test__divsf3(3.F, makeQNaN32(), UINT32_C(0x7fc00000)))
+      return 1;
+    // any / NaN = NaN
+    if (test__divsf3(3.F, makeNaN32(UINT32_C(0x123)), UINT32_C(0x7fc00000)))
+      return 1;
+
+    // +Inf / positive = +Inf
+    if (test__divsf3(makeInf32(), 3.F, UINT32_C(0x7f800000)))
+      return 1;
+    // +Inf / negative = -Inf
+    if (test__divsf3(makeInf32(), -3.F, UINT32_C(0xff800000)))
+      return 1;
+    // -Inf / positive = -Inf
+    if (test__divsf3(makeNegativeInf32(), 3.F, UINT32_C(0xff800000)))
+      return 1;
+    // -Inf / negative = +Inf
+    if (test__divsf3(makeNegativeInf32(), -3.F, UINT32_C(0x7f800000)))
+      return 1;
+
+    // Inf / Inf = NaN
+    if (test__divsf3(makeInf32(), makeInf32(), UINT32_C(0x7fc00000)))
+      return 1;
+    // 0.0 / 0.0 = NaN
+    if (test__divsf3(+0x0.0p+0F, +0x0.0p+0F, UINT32_C(0x7fc00000)))
+      return 1;
+    // +0.0 / +Inf = +0.0
+    if (test__divsf3(+0x0.0p+0F, makeInf32(), UINT32_C(0x0)))
+      return 1;
+    // +Inf / +0.0 = +Inf
+    if (test__divsf3(makeInf32(), +0x0.0p+0F, UINT32_C(0x7f800000)))
+      return 1;
+
+    // positive / +0.0 = +Inf
+    if (test__divsf3(+1.F, +0x0.0p+0F, UINT32_C(0x7f800000)))
+      return 1;
+    // positive / -0.0 = -Inf
+    if (test__divsf3(+1.F, -0x0.0p+0F, UINT32_C(0xff800000)))
+      return 1;
+    // negative / +0.0 = -Inf
+    if (test__divsf3(-1.F, +0x0.0p+0F, UINT32_C(0xff800000)))
+      return 1;
+    // negative / -0.0 = +Inf
+    if (test__divsf3(-1.F, -0x0.0p+0F, UINT32_C(0x7f800000)))
+      return 1;
+
     // 1/3
-    if (test__divsf3(1.f, 3.f, 0x3EAAAAABU))
+    if (test__divsf3(1.F, 3.F, UINT32_C(0x3eaaaaab)))
       return 1;
     // smallest normal result
-    if (test__divsf3(2.3509887e-38, 2., 0x00800000U))
+    if (test__divsf3(0x1.0p-125F, 2.F, UINT32_C(0x00800000)))
+      return 1;
+
+    // divisor is exactly 1.0
+    if (test__divsf3(0x1.0p+0F, 0x1.0p+0F, UINT32_C(0x3f800000)))
+      return 1;
+    // divisor is truncated to exactly 1.0 in UQ1.15
+    if (test__divsf3(0x1.0p+0F, 0x1.0001p+0F, UINT32_C(0x3f7fff00)))
       return 1;
 
     return 0;
 }

compiler-rt/test/builtins/Unit/divtf3_test.c

 }
 
 char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
 
 #endif
 
 int main()
 {
 #if __LDBL_MANT_DIG__ == 113
+    // Returned NaNs are assumed to be qNaN by default
+
     // qNaN / any = qNaN
     if (test__divtf3(makeQNaN128(),
                      0x1.23456789abcdefp+5L,
                      UINT64_C(0x7fff800000000000),
                      UINT64_C(0x0)))
         return 1;
     // NaN / any = NaN
-    if (test__divtf3(makeNaN128(UINT64_C(0x800030000000)),
+    if (test__divtf3(makeNaN128(UINT64_C(0x30000000)),
                      0x1.23456789abcdefp+5L,
                      UINT64_C(0x7fff800000000000),
                      UINT64_C(0x0)))
         return 1;
-    // inf / any = inf
-    if (test__divtf3(makeInf128(),
-                     0x1.23456789abcdefp+5L,
+    // any / qNaN = qNaN
+    if (test__divtf3(0x1.23456789abcdefp+5L,
+                     makeQNaN128(),
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // any / NaN = NaN
+    if (test__divtf3(0x1.23456789abcdefp+5L,
+                     makeNaN128(UINT64_C(0x30000000)),
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+
+    // +Inf / positive = +Inf
+    if (test__divtf3(makeInf128(), 3.L,
                      UINT64_C(0x7fff000000000000),
                      UINT64_C(0x0)))
         return 1;
+    // +Inf / negative = -Inf
+    if (test__divtf3(makeInf128(), -3.L,
+                     UINT64_C(0xffff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // -Inf / positive = -Inf
+    if (test__divtf3(makeNegativeInf128(), 3.L,
+                     UINT64_C(0xffff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // -Inf / negative = +Inf
+    if (test__divtf3(makeNegativeInf128(), -3.L,
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+
+    // Inf / Inf = NaN
+    if (test__divtf3(makeInf128(), makeInf128(),
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // 0.0 / 0.0 = NaN
+    if (test__divtf3(+0x0.0p+0L, +0x0.0p+0L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // +0.0 / +Inf = +0.0
+    if (test__divtf3(+0x0.0p+0L, makeInf128(),
+                     UINT64_C(0x0),
+                     UINT64_C(0x0)))
+        return 1;
+    // +Inf / +0.0 = +Inf
+    if (test__divtf3(makeInf128(), +0x0.0p+0L,
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+
+    // positive / +0.0 = +Inf
+    if (test__divtf3(+1.0L, +0x0.0p+0L,
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // positive / -0.0 = -Inf
+    if (test__divtf3(+1.0L, -0x0.0p+0L,
+                     UINT64_C(0xffff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // negative / +0.0 = -Inf
+    if (test__divtf3(-1.0L, +0x0.0p+0L,
+                     UINT64_C(0xffff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // negative / -0.0 = +Inf
+    if (test__divtf3(-1.0L, -0x0.0p+0L,
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+
+    // 1/3
+    if (test__divtf3(1.L, 3.L,
+                     UINT64_C(0x3ffd555555555555),
+                     UINT64_C(0x5555555555555555)))
+        return 1;
+    // smallest normal result
+    if (test__divtf3(0x1.0p-16381L, 2.L,
+                     UINT64_C(0x0001000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+
+    // divisor is exactly 1.0
+    if (test__divtf3(0x1.0p+0L,
+                     0x1.0p+0L,
+                     UINT64_C(0x3fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // divisor is truncated to exactly 1.0 in UQ1.63
+    if (test__divtf3(0x1.0p+0L,
+                     0x1.0000000000000001p+0L,
+                     UINT64_C(0x3ffeffffffffffff),
+                     UINT64_C(0xfffe000000000000)))
+        return 1;
+
     // any / any
     if (test__divtf3(0x1.a23b45362464523375893ab4cdefp+5L,
                      0x1.eedcbaba3a94546558237654321fp-1L,
                      UINT64_C(0x4004b0b72924d407),
                      UINT64_C(0x0717e84356c6eba2)))
         return 1;
     if (test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50L,
                      0x1.ed2c3ba15935332532287654321fp-9L,

compiler-rt/test/builtins/Unit/fp_test.h

static inline uint16_t makeInf16(void)
     return fromRep16(0x7c00U);
 }
 
 static inline float makeInf32(void)
 {
     return fromRep32(0x7f800000U);
 }
 
+static inline float makeNegativeInf32(void)
+{
+    return fromRep32(0xff800000U);
+}
+
 static inline double makeInf64(void)
 {
     return fromRep64(0x7ff0000000000000UL);
 }
 
+static inline double makeNegativeInf64(void)
+{
+    return fromRep64(0xfff0000000000000UL);
+}
+
 #if __LDBL_MANT_DIG__ == 113
 static inline long double makeInf128(void)
 {
     return fromRep128(0x7fff000000000000UL, 0x0UL);
 }
+
+static inline long double makeNegativeInf128(void)
+{
+    return fromRep128(0xffff000000000000UL, 0x0UL);
+}
 #endif