gcc/testsuite/gcc.target/arm/fp16-builtins-1.c

   1 /* Test type-generic builtins with __fp16 arguments.
   2    Except as otherwise noted, they should behave exactly
   3    the same as those with float arguments.  */
   4
   5 /* { dg-do run } */
   6 /* { dg-options "-mfp16-format=ieee -std=gnu99" } */
   7
   8 #include <stdlib.h>
   9 #include <math.h>
  10
  11 volatile __fp16 h1, h2;
  12 volatile float f1, f2;
  13
  14 void
  15 set1 (double x)
  16 {
  17   h1 = x;
  18   f1 = h1;
  19 }
  20
  21 void
  22 set2 (double x, double y)
  23 {
  24   h1 = x;
  25   f1 = h1;
  26   h2 = y;
  27   f2 = h2;
  28 }
  29
  30 #define test1(p,x)                              \
  31   set1 (x);                                     \
  32   hp = (p (h1) ? 1 : 0);                        \
  33   fp = (p (f1) ? 1 : 0);                        \
  34   if (hp ^ fp) abort ()
  35
  36 #define test2(p,x,y)                            \
  37   set2 (x,y);                                   \
  38   hp = (p (h1, h2) ? 1 : 0);                    \
  39   fp = (p (f1, f2) ? 1 : 0);                    \
  40   if (hp ^ fp) abort ()
  41
  42 int
  43 main (void)
  44 {
  45   int hp, fp;
  46
  47   test1 (__builtin_isfinite, 17.0);
  48   test1 (__builtin_isfinite, INFINITY);
  49   test1 (__builtin_isinf, -0.5);
  50   test1 (__builtin_isinf, INFINITY);
  51   test1 (__builtin_isnan, 493.0);
  52   test1 (__builtin_isnan, NAN);
  53   test1 (__builtin_isnormal, 3.14159);
  54
  55   test2 (__builtin_isgreater, 5.0, 3.0);
  56   test2 (__builtin_isgreater, 3.0, 5.0);
  57   test2 (__builtin_isgreater, 73.5, 73.5);
  58   test2 (__builtin_isgreater, 1.0, NAN);
  59
  60   test2 (__builtin_isgreaterequal, 5.0, 3.0);
  61   test2 (__builtin_isgreaterequal, 3.0, 5.0);
  62   test2 (__builtin_isgreaterequal, 73.5, 73.5);
  63   test2 (__builtin_isgreaterequal, 1.0, NAN);
  64
  65   test2 (__builtin_isless, 5.0, 3.0);
  66   test2 (__builtin_isless, 3.0, 5.0);
  67   test2 (__builtin_isless, 73.5, 73.5);
  68   test2 (__builtin_isless, 1.0, NAN);
  69
  70   test2 (__builtin_islessequal, 5.0, 3.0);
  71   test2 (__builtin_islessequal, 3.0, 5.0);
  72   test2 (__builtin_islessequal, 73.5, 73.5);
  73   test2 (__builtin_islessequal, 1.0, NAN);
  74
  75   test2 (__builtin_islessgreater, 5.0, 3.0);
  76   test2 (__builtin_islessgreater, 3.0, 5.0);
  77   test2 (__builtin_islessgreater, 73.5, 73.5);
  78   test2 (__builtin_islessgreater, 1.0, NAN);
  79
  80   test2 (__builtin_isunordered, 5.0, 3.0);
  81   test2 (__builtin_isunordered, 3.0, 5.0);
  82   test2 (__builtin_isunordered, 73.5, 73.5);
  83   test2 (__builtin_isunordered, 1.0, NAN);
  84
  85   /* Test that __builtin_isnormal recognizes a denormalized __fp16 value,
  86      even if it's representable as a normalized float.  */
  87   h1 = 5.96046E-8;
  88   if (__builtin_isnormal (h1))
  89     abort ();
  90
  91   return 0;
  92 }