m4/isfinite.m4

   1 # isfinite.m4 serial 6
   2 dnl Copyright (C) 2007-2009 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], [x = isfinite (x);])
  15     if test "$ISFINITE_LIBM" != missing; then
  16       dnl Test whether isfinite() on 'long double' works.
  17       gl_ISFINITEL_WORKS
  18       case "$gl_cv_func_isfinitel_works" in
  19         *yes) ;;
  20         *)    ISFINITE_LIBM=missing;;
  21       esac
  22       dnl Also, isfinite() on 'double' does not work on Linux/ia64 (because of
  23       dnl signalling NaNs). But this does not have to be tested, since
  24       dnl isfinite(long double) also does not work in this situation.
  25     fi
  26   fi
  27   if test "$ac_cv_have_decl_isfinite" != yes ||
  28      test "$ISFINITE_LIBM" = missing; then
  29     REPLACE_ISFINITE=1
  30     AC_LIBOBJ([isfinite])
  31     ISFINITE_LIBM=
  32   fi
  33   AC_SUBST([REPLACE_ISFINITE])
  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   memory_long_double m;
  73   unsigned int i;
  74
  75   /* The isfinite macro should be immune against changes in the sign bit and
  76      in the mantissa bits.  The xor operation twiddles a bit that can only be
  77      a sign bit or a mantissa bit (since the exponent never extends to
  78      bit 31).  */
  79   m.value = NaNl ();
  80   m.word[NWORDS / 2] ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
  81   for (i = 0; i < NWORDS; i++)
  82     m.word[i] |= 1;
  83   if (isfinite (m.value))
  84     return 1;
  85
  86 #if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_))
  87 /* Representation of an 80-bit 'long double' as an initializer for a sequence
  88    of 'unsigned int' words.  */
  89 # ifdef WORDS_BIGENDIAN
  90 #  define LDBL80_WORDS(exponent,manthi,mantlo) \
  91      { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
  92        ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16),    \
  93        (unsigned int) (mantlo) << 16                                        \
  94      }
  95 # else
  96 #  define LDBL80_WORDS(exponent,manthi,mantlo) \
  97      { mantlo, manthi, exponent }
  98 # endif
  99   { /* Quiet NaN.  */
 100     static memory_long_double x =
 101       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
 102     if (isfinite (x.value))
 103       return 1;
 104   }
 105   {
 106     /* Signalling NaN.  */
 107     static memory_long_double x =
 108       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
 109     if (isfinite (x.value))
 110       return 1;
 111   }
 112   /* The isfinite macro should recognize Pseudo-NaNs, Pseudo-Infinities,
 113      Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
 114        Intel IA-64 Architecture Software Developer's Manual, Volume 1:
 115        Application Architecture.
 116        Table 5-2 "Floating-Point Register Encodings"
 117        Figure 5-6 "Memory to Floating-Point Register Data Translation"
 118    */
 119   { /* Pseudo-NaN.  */
 120     static memory_long_double x =
 121       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
 122     if (isfinite (x.value))
 123       return 1;
 124   }
 125   { /* Pseudo-Infinity.  */
 126     static memory_long_double x =
 127       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
 128     if (isfinite (x.value))
 129       return 1;
 130   }
 131   { /* Pseudo-Zero.  */
 132     static memory_long_double x =
 133       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
 134     if (isfinite (x.value))
 135       return 1;
 136   }
 137   { /* Unnormalized number.  */
 138     static memory_long_double x =
 139       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
 140     if (isfinite (x.value))
 141       return 1;
 142   }
 143   { /* Pseudo-Denormal.  */
 144     static memory_long_double x =
 145       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
 146     if (isfinite (x.value))
 147       return 1;
 148   }
 149 #endif
 150
 151   return 0;
 152 }]])], [gl_cv_func_isfinitel_works=yes], [gl_cv_func_isfinitel_works=no],
 153       [case "$host_cpu" in
 154                                # Guess no on ia64, x86_64, i386.
 155          ia64 | x86_64 | i*86) gl_cv_func_isnanl_works="guessing no";;
 156          *)                    gl_cv_func_isnanl_works="guessing yes";;
 157        esac
 158       ])
 159     ])
 160 ])