m4/isfinite.m4

   1 # isfinite.m4 serial 11
   2 dnl Copyright (C) 2007-2011 Free Software Foundation, Inc.
   3 dnl This file is free software; the Free Software Foundation
   4 dnl gives unlimited permission to copy and/or distribute it,
   5 dnl with or without modifications, as long as this notice is preserved.
   6
   7 AC_DEFUN([gl_ISFINITE],
   8 [
   9   AC_REQUIRE([gl_MATH_H_DEFAULTS])
  10   dnl Persuade glibc <math.h> to declare isfinite.
  11   AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS])
  12   AC_CHECK_DECLS([isfinite], , , [[#include <math.h>]])
  13   if test "$ac_cv_have_decl_isfinite" = yes; then
  14     gl_CHECK_MATH_LIB([ISFINITE_LIBM],
  15      [x = isfinite (x) + isfinite ((float) x);])
  16     if test "$ISFINITE_LIBM" != missing; then
  17       dnl Test whether isfinite() on 'long double' works.
  18       gl_ISFINITEL_WORKS
  19       case "$gl_cv_func_isfinitel_works" in
  20         *yes) ;;
  21         *)    ISFINITE_LIBM=missing;;
  22       esac
  23       dnl Also, isfinite() on 'double' does not work on Linux/ia64 (because of
  24       dnl signalling NaNs). But this does not have to be tested, since
  25       dnl isfinite(long double) also does not work in this situation.
  26     fi
  27   fi
  28   if test "$ac_cv_have_decl_isfinite" != yes ||
  29      test "$ISFINITE_LIBM" = missing; then
  30     REPLACE_ISFINITE=1
  31     dnl No libraries are needed to link lib/isfinite.c.
  32     ISFINITE_LIBM=
  33   fi
  34   AC_SUBST([ISFINITE_LIBM])
  35 ])
  36
  37 dnl Test whether isfinite() on 'long double' recognizes all numbers which are
  38 dnl neither finite nor infinite. This test fails e.g. on i686, x86_64, ia64,
  39 dnl because of
  40 dnl - pseudo-denormals on x86_64,
  41 dnl - pseudo-zeroes, unnormalized numbers, and pseudo-denormals on i686,
  42 dnl - pseudo-NaN, pseudo-Infinity, pseudo-zeroes, unnormalized numbers, and
  43 dnl   pseudo-denormals on ia64.
  44 AC_DEFUN([gl_ISFINITEL_WORKS],
  45 [
  46   AC_REQUIRE([AC_PROG_CC])
  47   AC_REQUIRE([gl_BIGENDIAN])
  48   AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
  49   AC_CACHE_CHECK([whether isfinite(long double) works], [gl_cv_func_isfinitel_works],
  50     [
  51       AC_RUN_IFELSE([AC_LANG_SOURCE([[
  52 #include <float.h>
  53 #include <limits.h>
  54 #include <math.h>
  55 #define NWORDS \
  56   ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
  57 typedef union { unsigned int word[NWORDS]; long double value; }
  58         memory_long_double;
  59 /* On Irix 6.5, gcc 3.4.3 can't compute compile-time NaN, and needs the
  60    runtime type conversion.  */
  61 #ifdef __sgi
  62 static long double NaNl ()
  63 {
  64   double zero = 0.0;
  65   return zero / zero;
  66 }
  67 #else
  68 # define NaNl() (0.0L / 0.0L)
  69 #endif
  70 int main ()
  71 {
  72   int result = 0;
  73
  74   {
  75     memory_long_double m;
  76     unsigned int i;
  77
  78     /* The isfinite macro should be immune against changes in the sign bit and
  79        in the mantissa bits.  The xor operation twiddles a bit that can only be
  80        a sign bit or a mantissa bit (since the exponent never extends to
  81        bit 31).  */
  82     m.value = NaNl ();
  83     m.word[NWORDS / 2] ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
  84     for (i = 0; i < NWORDS; i++)
  85       m.word[i] |= 1;
  86     if (isfinite (m.value))
  87       result |= 1;
  88   }
  89
  90 #if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
  91 /* Representation of an 80-bit 'long double' as an initializer for a sequence
  92    of 'unsigned int' words.  */
  93 # ifdef WORDS_BIGENDIAN
  94 #  define LDBL80_WORDS(exponent,manthi,mantlo) \
  95      { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
  96        ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16),    \
  97        (unsigned int) (mantlo) << 16                                        \
  98      }
  99 # else
 100 #  define LDBL80_WORDS(exponent,manthi,mantlo) \
 101      { mantlo, manthi, exponent }
 102 # endif
 103   { /* Quiet NaN.  */
 104     static memory_long_double x =
 105       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
 106     if (isfinite (x.value))
 107       result |= 2;
 108   }
 109   {
 110     /* Signalling NaN.  */
 111     static memory_long_double x =
 112       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
 113     if (isfinite (x.value))
 114       result |= 2;
 115   }
 116   /* The isfinite macro should recognize Pseudo-NaNs, Pseudo-Infinities,
 117      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
 118        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
 119        Application Architecture.
 120        Table 5-2 "Floating-Point Register Encodings"
 121        Figure 5-6 "Memory to Floating-Point Register Data Translation"
 122    */
 123   { /* Pseudo-NaN.  */
 124     static memory_long_double x =
 125       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
 126     if (isfinite (x.value))
 127       result |= 4;
 128   }
 129   { /* Pseudo-Infinity.  */
 130     static memory_long_double x =
 131       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
 132     if (isfinite (x.value))
 133       result |= 8;
 134   }
 135   { /* Pseudo-Zero.  */
 136     static memory_long_double x =
 137       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
 138     if (isfinite (x.value))
 139       result |= 16;
 140   }
 141   { /* Unnormalized number.  */
 142     static memory_long_double x =
 143       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
 144     if (isfinite (x.value))
 145       result |= 32;
 146   }
 147   { /* Pseudo-Denormal.  */
 148     static memory_long_double x =
 149       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
 150     if (isfinite (x.value))
 151       return |= 64;
 152   }
 153 #endif
 154
 155   return result;
 156 }]])], [gl_cv_func_isfinitel_works=yes], [gl_cv_func_isfinitel_works=no],
 157       [case "$host_cpu" in
 158                                # Guess no on ia64, x86_64, i386.
 159          ia64 | x86_64 | i*86) gl_cv_func_isnanl_works="guessing no";;
 160          *)                    gl_cv_func_isnanl_works="guessing yes";;
 161        esac
 162       ])
 163     ])
 164 ])