m4/isinf.m4

   1 # isinf.m4 serial 12
   2 dnl Copyright (C) 2007-2017 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_ISINF],
   8 [
   9   AC_REQUIRE([gl_MATH_H_DEFAULTS])
  10   dnl Persuade glibc <math.h> to declare isinf.
  11   AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS])
  12   AC_CHECK_DECLS([isinf], , ,
  13     [[#include <math.h>
  14       #ifndef isinf
  15       #error "isinf must be a macro, not a function"
  16       #endif
  17     ]])
  18   if test "$ac_cv_have_decl_isinf" = yes; then
  19     gl_CHECK_MATH_LIB([ISINF_LIBM], [x = isinf (x) + isinf ((float) x);])
  20     if test "$ISINF_LIBM" != missing; then
  21       dnl Test whether isinf() on 'long double' works.
  22       gl_ISINFL_WORKS
  23       case "$gl_cv_func_isinfl_works" in
  24         *yes) ;;
  25         *)    ISINF_LIBM=missing;;
  26       esac
  27     fi
  28   fi
  29   if test "$ac_cv_have_decl_isinf" != yes ||
  30      test "$ISINF_LIBM" = missing; then
  31     REPLACE_ISINF=1
  32     dnl No libraries are needed to link lib/isinf.c.
  33     ISINF_LIBM=
  34   fi
  35   AC_SUBST([ISINF_LIBM])
  36 ])
  37
  38 dnl Test whether isinf() works:
  39 dnl 1) Whether it correctly returns false for LDBL_MAX.
  40 dnl 2) Whether on 'long double' recognizes all canonical values which are
  41 dnl    infinite.
  42 AC_DEFUN([gl_ISINFL_WORKS],
  43 [
  44   AC_REQUIRE([AC_PROG_CC])
  45   AC_REQUIRE([gl_BIGENDIAN])
  46   AC_REQUIRE([gl_LONG_DOUBLE_VS_DOUBLE])
  47   AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
  48   AC_CACHE_CHECK([whether isinf(long double) works], [gl_cv_func_isinfl_works],
  49     [
  50       AC_RUN_IFELSE(
  51         [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   if (isinf (LDBL_MAX))
  75     result |= 1;
  76
  77   {
  78     memory_long_double m;
  79     unsigned int i;
  80
  81     /* The isinf macro should be immune against changes in the sign bit and
  82        in the mantissa bits.  The xor operation twiddles a bit that can only be
  83        a sign bit or a mantissa bit (since the exponent never extends to
  84        bit 31).  */
  85     m.value = NaNl ();
  86     m.word[NWORDS / 2] ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
  87     for (i = 0; i < NWORDS; i++)
  88       m.word[i] |= 1;
  89     if (isinf (m.value))
  90       result |= 2;
  91   }
  92
  93 #if ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
  94 /* Representation of an 80-bit 'long double' as an initializer for a sequence
  95    of 'unsigned int' words.  */
  96 # ifdef WORDS_BIGENDIAN
  97 #  define LDBL80_WORDS(exponent,manthi,mantlo) \
  98      { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
  99        ((unsigned int) (manthi) << 16) | ((unsigned int) (mantlo) >> 16),   \
 100        (unsigned int) (mantlo) << 16                                        \
 101      }
 102 # else
 103 #  define LDBL80_WORDS(exponent,manthi,mantlo) \
 104      { mantlo, manthi, exponent }
 105 # endif
 106   { /* Quiet NaN.  */
 107     static memory_long_double x =
 108       { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
 109     if (isinf (x.value))
 110       result |= 2;
 111   }
 112   {
 113     /* Signalling NaN.  */
 114     static memory_long_double x =
 115       { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
 116     if (isinf (x.value))
 117       result |= 2;
 118   }
 119   /* isinf should return something even for noncanonical values.  */
 120   { /* Pseudo-NaN.  */
 121     static memory_long_double x =
 122       { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
 123     if (isinf (x.value) && !isinf (x.value))
 124       result |= 4;
 125   }
 126   { /* Pseudo-Infinity.  */
 127     static memory_long_double x =
 128       { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
 129     if (isinf (x.value) && !isinf (x.value))
 130       result |= 8;
 131   }
 132   { /* Pseudo-Zero.  */
 133     static memory_long_double x =
 134       { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
 135     if (isinf (x.value) && !isinf (x.value))
 136       result |= 16;
 137   }
 138   { /* Unnormalized number.  */
 139     static memory_long_double x =
 140       { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
 141     if (isinf (x.value) && !isinf (x.value))
 142       result |= 32;
 143   }
 144   { /* Pseudo-Denormal.  */
 145     static memory_long_double x =
 146       { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
 147     if (isinf (x.value) && !isinf (x.value))
 148       result |= 64;
 149   }
 150 #endif
 151
 152   return result;
 153 }]])],
 154       [gl_cv_func_isinfl_works=yes],
 155       [gl_cv_func_isinfl_works=no],
 156       [case "$host_os" in
 157          mingw*) # Guess yes on mingw, no on MSVC.
 158            AC_EGREP_CPP([Known], [
 159 #ifdef __MINGW32__
 160  Known
 161 #endif
 162              ],
 163              [gl_cv_func_isinfl_works="guessing yes"],
 164              [gl_cv_func_isinfl_works="guessing no"])
 165            ;;
 166          *)
 167            gl_cv_func_isinfl_works="guessing yes"
 168            ;;
 169        esac
 170       ])
 171     ])
 172 ])