This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.
Index Nav:	[Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav:	[Date Prev] [Date Next]	[Thread Prev] [Thread Next]
Other format:	[Raw text]
[PATCH TESTSUITE]: Fix gcc.dg/torture/builtin-math-6.c

From: "Kaveh R. GHAZI" <ghazi at caip dot rutgers dot edu>
To: janis187 at us dot ibm dot com
Cc: gcc-patches at gcc dot gnu dot org
Date: Tue, 9 Jun 2009 11:16:50 -0400 (EDT)
Subject: [PATCH TESTSUITE]: Fix gcc.dg/torture/builtin-math-6.c
One of the clog testcases in gcc.dg/torture/builtin-math-6.c had an error.
It was exposed by the MPC revision in the MPC svn repository that I'm
testing against for the next release of their library.  Fixed with the
patch below.

While touching this file, I took the opportunity to robustify some of the
support code and make some new generic macros.  This will become important
when I add support for cpow/mpc_pow and its associated testing
infrastructure.

Tested via "make check" with the SVN MPC and without MPC.  (Note mpc-0.6
will error on this now because it has a complex log bug, I verified that
the newer MPC correlates with GLIBC on this.)

Okay for mainline?

		Thanks,
		--Kaveh


2009-06-08  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>

	* gcc.dg/torture/builtin-math-6.c: Robustify and fix clog case.

diff -rup orig/egcc-SVN20090609/gcc/testsuite/gcc.dg/torture/builtin-math-6.c egcc-SVN20090609/gcc/testsuite/gcc.dg/torture/builtin-math-6.c
--- orig/egcc-SVN20090609/gcc/testsuite/gcc.dg/torture/builtin-math-6.c	2009-05-16 02:01:01.000000000 +0200
+++ egcc-SVN20090609/gcc/testsuite/gcc.dg/torture/builtin-math-6.c	2009-06-09 08:02:25.000000000 +0200
@@ -11,57 +11,73 @@
 /* All references to link_error should go away at compile-time.  */
 extern void link_error(int);

-/* Return TRUE if the sign of X != sign of Y.  This is important when
-   comparing signed zeros.  */
+/* Return TRUE if the signs of floating point values X and Y are not
+   equal.  This is important when comparing signed zeros.  */
 #define CKSGN_F(X,Y) \
-  (__builtin_copysignf(1.0F,(X)) != __builtin_copysignf(1.0F,(Y)))
+  (__builtin_copysignf(1,(X)) != __builtin_copysignf(1,(Y)))
 #define CKSGN(X,Y) \
-  (__builtin_copysign(1.0,(X)) != __builtin_copysign(1.0,(Y)))
+  (__builtin_copysign(1,(X)) != __builtin_copysign(1,(Y)))
 #define CKSGN_L(X,Y) \
-  (__builtin_copysignl(1.0L,(X)) != __builtin_copysignl(1.0L,(Y)))
+  (__builtin_copysignl(1,(X)) != __builtin_copysignl(1,(Y)))
+
+/* Return TRUE if signs of the real parts, and the signs of the
+   imaginary parts, of X and Y are not equal.  */
+#define COMPLEX_CKSGN_F(X,Y) \
+  (CKSGN_F(__real__ (X), __real__ (Y)) || CKSGN_F (__imag__ (X), __imag__ (Y)))
+#define COMPLEX_CKSGN(X,Y) \
+  (CKSGN(__real__ (X), __real__ (Y)) || CKSGN (__imag__ (X), __imag__ (Y)))
+#define COMPLEX_CKSGN_L(X,Y) \
+  (CKSGN_L(__real__ (X), __real__ (Y)) || CKSGN_L (__imag__ (X), __imag__ (Y)))

 /* For complex numbers, test that FUNC(ARG) == (RES).  */
 #define TESTIT_COMPLEX(FUNC, ARG, RES) do { \
   if (__builtin_##FUNC##f(ARG) != (RES) \
-    || CKSGN_F(__real__ __builtin_##FUNC##f(ARG), __real__ (RES)) \
-    || CKSGN_F(__imag__ __builtin_##FUNC##f(ARG), __imag__ (RES))) \
+    || COMPLEX_CKSGN_F(__builtin_##FUNC##f(ARG), (RES))) \
       link_error(__LINE__); \
   if (__builtin_##FUNC(ARG) != (RES) \
-    || CKSGN(__real__ __builtin_##FUNC(ARG), __real__ (RES)) \
-    || CKSGN(__imag__ __builtin_##FUNC(ARG), __imag__ (RES))) \
+    || COMPLEX_CKSGN(__builtin_##FUNC(ARG), (RES))) \
       link_error(__LINE__); \
   if (__builtin_##FUNC##l(ARG) != (RES) \
-    || CKSGN_L(__real__ __builtin_##FUNC##l(ARG), __real__ (RES)) \
-    || CKSGN_L(__imag__ __builtin_##FUNC##l(ARG), __imag__ (RES))) \
+    || COMPLEX_CKSGN_L(__builtin_##FUNC##l(ARG), (RES))) \
       link_error(__LINE__); \
   } while (0)

+/* Return TRUE if X differs from EXPECTED by more than 1%.  If
+   EXPECTED is zero, then any difference may return TRUE.  We don't
+   worry about signed zeros.  */
+#define DIFF1PCT_F(X,EXPECTED) \
+  (__builtin_fabsf((X)-(EXPECTED)) * 100 > __builtin_fabsf(EXPECTED))
+#define DIFF1PCT(X,EXPECTED) \
+  (__builtin_fabs((X)-(EXPECTED)) * 100 > __builtin_fabs(EXPECTED))
+#define DIFF1PCT_L(X,EXPECTED) \
+  (__builtin_fabsl((X)-(EXPECTED)) * 100 > __builtin_fabsl(EXPECTED))
+
+/* Return TRUE if complex value X differs from EXPECTED by more than
+   1% in either the real or imaginary parts.  */
+#define COMPLEX_DIFF1PCT_F(X,EXPECTED) \
+  (DIFF1PCT_F(__real__ (X), __real__ (EXPECTED)) \
+   || DIFF1PCT_F(__imag__ (X), __imag__ (EXPECTED)))
+#define COMPLEX_DIFF1PCT(X,EXPECTED) \
+  (DIFF1PCT(__real__ (X), __real__ (EXPECTED)) \
+   || DIFF1PCT(__imag__ (X), __imag__ (EXPECTED)))
+#define COMPLEX_DIFF1PCT_L(X,EXPECTED) \
+  (DIFF1PCT_L(__real__ (X), __real__ (EXPECTED)) \
+   || DIFF1PCT_L(__imag__ (X), __imag__ (EXPECTED)))
+
 /* Range test, for complex numbers check that FUNC(ARG) is within 1%
    of RES.  This is NOT a test for accuracy to the last-bit, we're
    merely checking that we get relatively sane results.  I.e. the GCC
    builtin is hooked up to the correct MPC function call.  We first
    check the magnitude and then the sign.  */
 #define TESTIT_COMPLEX_R(FUNC, ARG, RES) do { \
-  if (__builtin_fabsf(__real__ __builtin_##FUNC##f(ARG)) < __builtin_fabsf(__real__ (RES)) * 0.99F \
-      || __builtin_fabsf(__real__ __builtin_##FUNC##f(ARG)) > __builtin_fabsf(__real__ (RES)) * 1.01F \
-      || __builtin_fabsf(__imag__ __builtin_##FUNC##f(ARG)) < __builtin_fabsf(__imag__ (RES)) * 0.99F \
-      || __builtin_fabsf(__imag__ __builtin_##FUNC##f(ARG)) > __builtin_fabsf(__imag__ (RES)) * 1.01F \
-      || CKSGN_F(__real__ __builtin_##FUNC##f(ARG), __real__ (RES)) \
-      || CKSGN_F(__imag__ __builtin_##FUNC##f(ARG), __imag__ (RES))) \
+  if (COMPLEX_DIFF1PCT_F (__builtin_##FUNC##f(ARG), (RES)) \
+      || COMPLEX_CKSGN_F(__builtin_##FUNC##f(ARG), (RES))) \
     link_error(__LINE__); \
-  if (__builtin_fabs(__real__ __builtin_##FUNC(ARG)) < __builtin_fabs(__real__ (RES)) * 0.99F \
-      || __builtin_fabs(__real__ __builtin_##FUNC(ARG)) > __builtin_fabs(__real__ (RES)) * 1.01F \
-      || __builtin_fabs(__imag__ __builtin_##FUNC(ARG)) < __builtin_fabs(__imag__ (RES)) * 0.99F \
-      || __builtin_fabs(__imag__ __builtin_##FUNC(ARG)) > __builtin_fabs(__imag__ (RES)) * 1.01F \
-      || CKSGN(__real__ __builtin_##FUNC(ARG), __real__ (RES)) \
-      || CKSGN(__imag__ __builtin_##FUNC(ARG), __imag__ (RES))) \
+  if (COMPLEX_DIFF1PCT (__builtin_##FUNC(ARG), (RES)) \
+      || COMPLEX_CKSGN(__builtin_##FUNC(ARG), (RES))) \
     link_error(__LINE__); \
-  if (__builtin_fabsl(__real__ __builtin_##FUNC##l(ARG)) < __builtin_fabsl(__real__ (RES)) * 0.99F \
-      || __builtin_fabsl(__real__ __builtin_##FUNC##l(ARG)) > __builtin_fabsl(__real__ (RES)) * 1.01F \
-      || __builtin_fabsl(__imag__ __builtin_##FUNC##l(ARG)) < __builtin_fabsl(__imag__ (RES)) * 0.99F \
-      || __builtin_fabsl(__imag__ __builtin_##FUNC##l(ARG)) > __builtin_fabsl(__imag__ (RES)) * 1.01F \
-      || CKSGN_L(__real__ __builtin_##FUNC##l(ARG), __real__ (RES)) \
-      || CKSGN_L(__imag__ __builtin_##FUNC##l(ARG), __imag__ (RES))) \
+  if (COMPLEX_DIFF1PCT (__builtin_##FUNC(ARG), (RES)) \
+      || COMPLEX_CKSGN(__builtin_##FUNC(ARG), (RES))) \
     link_error(__LINE__); \
   } while (0)

@@ -130,7 +146,7 @@ int main (void)
   TESTIT_COMPLEX (clog, 1.0F, 0.0F);
   TESTIT_COMPLEX_R (clog, -1.0F, 3.141593FI);
   TESTIT_COMPLEX (clog, __builtin_conjf(1.0F), 0.0F);
-  TESTIT_COMPLEX_R (clog, __builtin_conjf(-1.0F), 3.141593FI);
+  TESTIT_COMPLEX_R (clog, __builtin_conjf(-1.0F), __builtin_conjf(3.141593FI));

   TESTIT_COMPLEX_R (clog, 3.45678F + 2.34567FI, 1.429713F + 0.596199FI);
   TESTIT_COMPLEX_R (clog, 3.45678F - 2.34567FI, 1.429713F - 0.596199FI);
Follow-Ups:
- Re: [PATCH TESTSUITE]: Fix gcc.dg/torture/builtin-math-6.c
  - From: Janis Johnson
Index Nav:	[Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav:	[Date Prev] [Date Next]	[Thread Prev] [Thread Next]