1  /* Test of isnanl() substitute.
       2     Copyright (C) 2007-2021 Free Software Foundation, Inc.
       3  
       4     This program is free software: you can redistribute it and/or modify
       5     it under the terms of the GNU General Public License as published by
       6     the Free Software Foundation; either version 3 of the License, or
       7     (at your option) any later version.
       8  
       9     This program is distributed in the hope that it will be useful,
      10     but WITHOUT ANY WARRANTY; without even the implied warranty of
      11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12     GNU General Public License for more details.
      13  
      14     You should have received a copy of the GNU General Public License
      15     along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
      16  
      17  /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
      18  
      19  #include <float.h>
      20  #include <limits.h>
      21  
      22  #include "minus-zero.h"
      23  #include "infinity.h"
      24  #include "nan.h"
      25  #include "macros.h"
      26  
      27  int
      28  main ()
      29  {
      30    #define NWORDS \
      31      ((sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
      32    typedef union { unsigned int word[NWORDS]; long double value; }
      33            memory_long_double;
      34  
      35    /* Finite values.  */
      36    ASSERT (!isnanl (3.141L));
      37    ASSERT (!isnanl (3.141e30L));
      38    ASSERT (!isnanl (3.141e-30L));
      39    ASSERT (!isnanl (-2.718L));
      40    ASSERT (!isnanl (-2.718e30L));
      41    ASSERT (!isnanl (-2.718e-30L));
      42    ASSERT (!isnanl (0.0L));
      43    ASSERT (!isnanl (minus_zerol));
      44    /* Infinite values.  */
      45    ASSERT (!isnanl (Infinityl ()));
      46    ASSERT (!isnanl (- Infinityl ()));
      47    /* Quiet NaN.  */
      48    ASSERT (isnanl (NaNl ()));
      49  
      50  #if defined LDBL_EXPBIT0_WORD && defined LDBL_EXPBIT0_BIT
      51    /* A bit pattern that is different from a Quiet NaN.  With a bit of luck,
      52       it's a Signalling NaN.  */
      53    {
      54  #if defined __powerpc__ && LDBL_MANT_DIG == 106
      55      /* This is PowerPC "double double", a pair of two doubles.  Inf and Nan are
      56         represented as the corresponding 64-bit IEEE values in the first double;
      57         the second is ignored.  Manipulate only the first double.  */
      58      #undef NWORDS
      59      #define NWORDS \
      60        ((sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
      61  #endif
      62  
      63      memory_long_double m;
      64      m.value = NaNl ();
      65  # if LDBL_EXPBIT0_BIT > 0
      66      m.word[LDBL_EXPBIT0_WORD] ^= (unsigned int) 1 << (LDBL_EXPBIT0_BIT - 1);
      67  # else
      68      m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
      69        ^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
      70  # endif
      71      m.word[LDBL_EXPBIT0_WORD + (LDBL_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
      72        |= (unsigned int) 1 << LDBL_EXPBIT0_BIT;
      73      ASSERT (isnanl (m.value));
      74    }
      75  #endif
      76  
      77  #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
      78  /* Representation of an 80-bit 'long double' as an initializer for a sequence
      79     of 'unsigned int' words.  */
      80  # ifdef WORDS_BIGENDIAN
      81  #  define LDBL80_WORDS(exponent,manthi,mantlo) \
      82       { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
      83         ((unsigned int) (manthi) << 16) | ((unsigned int) (mantlo) >> 16),   \
      84         (unsigned int) (mantlo) << 16                                        \
      85       }
      86  # else
      87  #  define LDBL80_WORDS(exponent,manthi,mantlo) \
      88       { mantlo, manthi, exponent }
      89  # endif
      90    { /* Quiet NaN.  */
      91      static memory_long_double x =
      92        { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
      93      ASSERT (isnanl (x.value));
      94    }
      95    {
      96      /* Signalling NaN.  */
      97      static memory_long_double x =
      98        { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
      99      ASSERT (isnanl (x.value));
     100    }
     101    /* isnanl should return something for noncanonical values.  */
     102    { /* Pseudo-NaN.  */
     103      static memory_long_double x =
     104        { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
     105      ASSERT (isnanl (x.value) || !isnanl (x.value));
     106    }
     107    { /* Pseudo-Infinity.  */
     108      static memory_long_double x =
     109        { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
     110      ASSERT (isnanl (x.value) || !isnanl (x.value));
     111    }
     112    { /* Pseudo-Zero.  */
     113      static memory_long_double x =
     114        { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
     115      ASSERT (isnanl (x.value) || !isnanl (x.value));
     116    }
     117    { /* Unnormalized number.  */
     118      static memory_long_double x =
     119        { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
     120      ASSERT (isnanl (x.value) || !isnanl (x.value));
     121    }
     122    { /* Pseudo-Denormal.  */
     123      static memory_long_double x =
     124        { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
     125      ASSERT (isnanl (x.value) || !isnanl (x.value));
     126    }
     127  #endif
     128  
     129    return 0;
     130  }