[compiler-rt] [test] Use approximate comparison on float types

[mgorny]

Summary

Use approximate comparison between the result of __divsc3()
and the canonical value calculated, to allow the possible difference of
1 representable value resulting from optimization.

For example, the value of (0.000001+j0.000001) / (-0.500000-j2.000000))
computed the canonical way without specific machine flags is:

z = -0x1.3bce70p-21 + j0x1.7af7bcp-22

However, if -march=i386 -mfpmath=387 is used, it becomes:

z = -0x1.3bce72p-21 + j0x1.7af7bcp-22

While this difference is insignificant, it may cause the exact
comparison used in tests to fail. Allowing the difference of one
representable value seems to be a reasonable compromise.

[compnerd]

I think that the checks should be exact. Instead, we should check the compilation mode and change the exact value (i.e. if we are using i387 mode, we would use the adjusted value).

[mgorny]

Just to be clear, the values also differ per -O0 vs -O2. I'm not sure if we can even reliably figure that out.

I've tried to work around the issue by building everything in 387 mode. However, in that case muldc3_test has even larger mismatches and didn't really want to go figuring that out.

[scanon]

These tests should either be exact, or should have a tolerance that's mathematically sound. +/-1ulp is not sound; the allowed error should be proportional to the magnitude of the larger of the real and imaginary components of the result -- e.g. if one component is very small compared to the other, the smaller one may have *no* "correct" bits and still be acceptable.

[mgorny]

I've opened http://bugs.llvm.org/show_bug.cgi?id=31964 to track this further. I don't really have time to look into it in more detail at the moment.

test/builtins/Unit/divsc3_test.c

 //===-- divsc3_test.c - Test __divsc3 -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __divsc3 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
+#include <stdbool.h>
 #include <stdio.h>
 
 // Returns: the quotient of (a + ib) / (c + id)
 
 COMPILER_RT_ABI float _Complex
 __divsc3(float __a, float __b, float __c, float __d);
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
classify(float _Complex x)
     {
         if (crealf(x) == 0)
             return NaN;
         return non_zero_nan;
     }
     return non_zero;
 }
 
+// check for equality assuming that both real and imaginary parts
+// can differ by exactly 1 representable value, in order to handle
+// different levels of accuracy on 32-bit x86
+static bool approx_equal(float _Complex a, float _Complex b) {
+    if (a != b) {
+        float ra = __real__ a;
+        float ia = __imag__ a;
+        float rb = __real__ b;
+        float ib = __imag__ b;
+
+        if (ra != rb && nextafterf(ra, rb) != rb)
+            return false;
+        if (ia != ib && nextafterf(ia, ib) != ib)
+            return false;
+    }
+
+    return true;
+}
+
 int test__divsc3(float a, float b, float c, float d)
 {
     float _Complex r = __divsc3(a, b, c, d);
 //     printf("test__divsc3(%f, %f, %f, %f) = %f + I%f\n",
 //             a, b, c, d, crealf(r), cimagf(r));
   float _Complex dividend;
   float _Complex divisor;
   
case non_zero:
                 return 1;
             break;
         case non_zero:
             if (classify(r) != non_zero)
                 return 1;
             {
             float _Complex z = (a * c + b * d) / (c * c + d * d)
                              + (b * c - a * d) / (c * c + d * d) * _Complex_I;
-            if (r != z)
+            if (!approx_equal(r, z))
                 return 1;
             }
             break;
         case inf:
             if (classify(r) != zero)
                 return 1;
             break;
         case NaN: