gdb/testsuite/gdb.base/dfp-test.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2007-2020 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20
  21 #define DELTA (0.0001df)
  22 #define DELTA_B (0.001)
  23
  24 double double_val1 = 45.125;
  25 double double_val2 = -67.75;
  26 double double_val3 = 0.25;
  27 double double_val4 = 1.25;
  28 double double_val5 = 2.25;
  29 double double_val6 = 3.25;
  30 double double_val7 = 4.25;
  31 double double_val8 = 5.25;
  32 double double_val9 = 6.25;
  33 double double_val10 = 7.25;
  34 double double_val11 = 8.25;
  35 double double_val12 = 9.25;
  36 double double_val13 = 10.25;
  37 double double_val14 = 11.25;
  38
  39 _Decimal32 dec32_val1 = 3.14159df;
  40 _Decimal32 dec32_val2 = -2.3765df;
  41 _Decimal32 dec32_val3 = 0.2df;
  42 _Decimal32 dec32_val4 = 1.2df;
  43 _Decimal32 dec32_val5 = 2.2df;
  44 _Decimal32 dec32_val6 = 3.2df;
  45 _Decimal32 dec32_val7 = 4.2df;
  46 _Decimal32 dec32_val8 = 5.2df;
  47 _Decimal32 dec32_val9 = 6.2df;
  48 _Decimal32 dec32_val10 = 7.2df;
  49 _Decimal32 dec32_val11 = 8.2df;
  50 _Decimal32 dec32_val12 = 9.2df;
  51 _Decimal32 dec32_val13 = 10.2df;
  52 _Decimal32 dec32_val14 = 11.2df;
  53 _Decimal32 dec32_val15 = 12.2df;
  54 _Decimal32 dec32_val16 = 13.2df;
  55
  56 _Decimal64 dec64_val1 = 3.14159dd;
  57 _Decimal64 dec64_val2 = -2.3765dd;
  58 _Decimal64 dec64_val3 = 0.2dd;
  59 _Decimal64 dec64_val4 = 1.2dd;
  60 _Decimal64 dec64_val5 = 2.2dd;
  61 _Decimal64 dec64_val6 = 3.2dd;
  62 _Decimal64 dec64_val7 = 4.2dd;
  63 _Decimal64 dec64_val8 = 5.2dd;
  64 _Decimal64 dec64_val9 = 6.2dd;
  65 _Decimal64 dec64_val10 = 7.2dd;
  66 _Decimal64 dec64_val11 = 8.2dd;
  67 _Decimal64 dec64_val12 = 9.2dd;
  68 _Decimal64 dec64_val13 = 10.2dd;
  69 _Decimal64 dec64_val14 = 11.2dd;
  70 _Decimal64 dec64_val15 = 12.2dd;
  71 _Decimal64 dec64_val16 = 13.2dd;
  72
  73 _Decimal128 dec128_val1 = 3.14159dl;
  74 _Decimal128 dec128_val2 = -2.3765dl;
  75 _Decimal128 dec128_val3 = 0.2dl;
  76 _Decimal128 dec128_val4 = 1.2dl;
  77 _Decimal128 dec128_val5 = 2.2dl;
  78 _Decimal128 dec128_val6 = 3.2dl;
  79 _Decimal128 dec128_val7 = 4.2dl;
  80 _Decimal128 dec128_val8 = 5.2dl;
  81 _Decimal128 dec128_val9 = 6.2dl;
  82 _Decimal128 dec128_val10 = 7.2dl;
  83 _Decimal128 dec128_val11 = 8.2dl;
  84 _Decimal128 dec128_val12 = 9.2dl;
  85 _Decimal128 dec128_val13 = 10.2dl;
  86 _Decimal128 dec128_val14 = 11.2dl;
  87 _Decimal128 dec128_val15 = 12.2dl;
  88 _Decimal128 dec128_val16 = 13.2dl;
  89
  90 volatile _Decimal32 d32;
  91 volatile _Decimal64 d64;
  92 volatile _Decimal128 d128;
  93
  94 /* Typedefs and typedefs of typedefs, for ptype/whatis testing.  */
  95 typedef _Decimal32 d32_t;
  96 typedef _Decimal64 d64_t;
  97 typedef _Decimal128 d128_t;
  98
  99 typedef d32_t d32_t2;
 100 typedef d64_t d64_t2;
 101 typedef d128_t d128_t2;
 102
 103 d32_t v_d32_t;
 104 d64_t v_d64_t;
 105 d128_t v_d128_t;
 106
 107 d32_t2 v_d32_t2;
 108 d64_t2 v_d64_t2;
 109 d128_t2 v_d128_t2;
 110
 111 struct decstruct
 112 {
 113   int int4;
 114   long long8;
 115   float float4;
 116   double double8;
 117   _Decimal32 dec32;
 118   _Decimal64 dec64;
 119   _Decimal128 dec128;
 120 } ds;
 121
 122 static _Decimal32
 123 arg0_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
 124          _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
 125 {
 126   return arg0;
 127 }
 128
 129 static _Decimal64
 130 arg0_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
 131          _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
 132 {
 133   return arg0;
 134 }
 135
 136 static _Decimal128
 137 arg0_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
 138          _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
 139 {
 140   return arg0;
 141 }
 142
 143 /* Function to test if _Decimal128 argument interferes with stack slots
 144    because of alignment.  */
 145 int
 146 decimal_dec128_align (double arg0, _Decimal128 arg1, double arg2, double arg3,
 147                       double arg4, double arg5, double arg6, double arg7,
 148                       double arg8, double arg9, double arg10, double arg11,
 149                       double arg12, double arg13)
 150 {
 151   return ((arg0 - double_val1) < DELTA_B
 152           && (arg0 - double_val1) > -DELTA_B
 153           && (arg1 - dec128_val2) < DELTA
 154           && (arg1 - dec128_val2) > -DELTA
 155           && (arg2 - double_val3) < DELTA_B
 156           && (arg2 - double_val3) > -DELTA_B
 157           && (arg3 - double_val4) < DELTA_B
 158           && (arg3 - double_val4) > -DELTA_B
 159           && (arg4 - double_val5) < DELTA_B
 160           && (arg4 - double_val5) > -DELTA_B
 161           && (arg5 - double_val6) < DELTA_B
 162           && (arg5 - double_val6) > -DELTA_B
 163           && (arg6 - double_val7) < DELTA_B
 164           && (arg6 - double_val7) > -DELTA_B
 165           && (arg7 - double_val8) < DELTA_B
 166           && (arg7 - double_val8) > -DELTA_B
 167           && (arg8 - double_val9) < DELTA_B
 168           && (arg8 - double_val9) > -DELTA_B
 169           && (arg9 - double_val10) < DELTA_B
 170           && (arg9 - double_val10) > -DELTA_B
 171           && (arg10 - double_val11) < DELTA_B
 172           && (arg10 - double_val11) > -DELTA_B
 173           && (arg11 - double_val12) < DELTA_B
 174           && (arg11 - double_val12) > -DELTA_B
 175           && (arg12 - double_val13) < DELTA_B
 176           && (arg12 - double_val13) > -DELTA_B
 177           && (arg13 - double_val14) < DELTA_B
 178           && (arg13 - double_val14) > -DELTA_B);
 179 }
 180
 181 int
 182 decimal_mixed (_Decimal32 arg0, _Decimal64 arg1, _Decimal128 arg2)
 183 {
 184   return ((arg0 - dec32_val1) < DELTA
 185           && (arg0 - dec32_val1) > -DELTA
 186           && (arg1 - dec64_val1) < DELTA
 187           && (arg1 - dec64_val1) > -DELTA
 188           && (arg2 - dec128_val1) < DELTA
 189           && (arg2 - dec128_val1) > -DELTA);
 190 }
 191
 192 /* These functions have many arguments to force some of them to be passed via
 193    the stack instead of registers, to test that GDB can construct correctly
 194    the parameter save area. Note that Linux/ppc32 has 8 float registers to use
 195    for float parameter passing and Linux/ppc64 has 13, so the number of
 196    arguments has to be at least 14 to contemplate these platforms.  */
 197
 198 int
 199 decimal_many_args_dec32 (_Decimal32 f1, _Decimal32 f2, _Decimal32 f3,
 200                             _Decimal32 f4, _Decimal32 f5, _Decimal32 f6,
 201                             _Decimal32 f7, _Decimal32 f8, _Decimal32 f9,
 202                             _Decimal32 f10, _Decimal32 f11, _Decimal32 f12,
 203                             _Decimal32 f13, _Decimal32 f14, _Decimal32 f15,
 204                             _Decimal32 f16)
 205 {
 206   _Decimal32 sum_args;
 207   _Decimal32 sum_values;
 208
 209   sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
 210              + f13 + f14 + f15 + f16;
 211   sum_values = dec32_val1 + dec32_val2 + dec32_val3 + dec32_val4 + dec32_val5
 212                + dec32_val6 + dec32_val7 + dec32_val8 + dec32_val9
 213                + dec32_val10 + dec32_val11 + dec32_val12 + dec32_val13
 214                + dec32_val14 + dec32_val15 + dec32_val16;
 215
 216   return ((sum_args - sum_values) < DELTA
 217           && (sum_args - sum_values) > -DELTA);
 218 }
 219
 220 int
 221 decimal_many_args_dec64 (_Decimal64 f1, _Decimal64 f2, _Decimal64 f3,
 222                             _Decimal64 f4, _Decimal64 f5, _Decimal64 f6,
 223                             _Decimal64 f7, _Decimal64 f8, _Decimal64 f9,
 224                             _Decimal64 f10, _Decimal64 f11, _Decimal64 f12,
 225                             _Decimal64 f13, _Decimal64 f14, _Decimal64 f15,
 226                             _Decimal64 f16)
 227 {
 228   _Decimal64 sum_args;
 229   _Decimal64 sum_values;
 230
 231   sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
 232              + f13 + f14 + f15 + f16;
 233   sum_values = dec64_val1 + dec64_val2 + dec64_val3 + dec64_val4 + dec64_val5
 234                + dec64_val6 + dec64_val7 + dec64_val8 + dec64_val9
 235                + dec64_val10 + dec64_val11 + dec64_val12 + dec64_val13
 236                + dec64_val14 + dec64_val15 + dec64_val16;
 237
 238   return ((sum_args - sum_values) < DELTA
 239           && (sum_args - sum_values) > -DELTA);
 240 }
 241
 242 int
 243 decimal_many_args_dec128 (_Decimal128 f1, _Decimal128 f2, _Decimal128 f3,
 244                             _Decimal128 f4, _Decimal128 f5, _Decimal128 f6,
 245                             _Decimal128 f7, _Decimal128 f8, _Decimal128 f9,
 246                             _Decimal128 f10, _Decimal128 f11, _Decimal128 f12,
 247                             _Decimal128 f13, _Decimal128 f14, _Decimal128 f15,
 248                             _Decimal128 f16)
 249 {
 250   _Decimal128 sum_args;
 251   _Decimal128 sum_values;
 252
 253   sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
 254              + f13 + f14 + f15 + f16;
 255   sum_values = dec128_val1 + dec128_val2 + dec128_val3 + dec128_val4 + dec128_val5
 256                + dec128_val6 + dec128_val7 + dec128_val8 + dec128_val9
 257                + dec128_val10 + dec128_val11 + dec128_val12 + dec128_val13
 258                + dec128_val14 + dec128_val15 + dec128_val16;
 259
 260   return ((sum_args - sum_values) < DELTA
 261           && (sum_args - sum_values) > -DELTA);
 262 }
 263
 264 int
 265 decimal_many_args_mixed (_Decimal32 f1, _Decimal32 f2, _Decimal32 f3,
 266                            _Decimal64 f4, _Decimal64 f5, _Decimal64 f6,
 267                            _Decimal64 f7, _Decimal128 f8, _Decimal128 f9,
 268                            _Decimal128 f10, _Decimal32 f11, _Decimal64 f12,
 269                            _Decimal32 f13, _Decimal64 f14, _Decimal128 f15)
 270 {
 271   _Decimal128 sum_args;
 272   _Decimal128 sum_values;
 273
 274   sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
 275              + f13 + f14 + f15;
 276   sum_values = dec32_val1 + dec32_val2 + dec32_val3 + dec64_val4 + dec64_val5
 277                + dec64_val6 + dec64_val7 + dec128_val8 + dec128_val9
 278                + dec128_val10 + dec32_val11 + dec64_val12 + dec32_val13
 279                + dec64_val14 + dec128_val15;
 280
 281   return ((sum_args - sum_values) < DELTA
 282           && (sum_args - sum_values) > -DELTA);
 283 }
 284
 285 int main()
 286 {
 287   /* An finite 32-bits decimal floating point.  */
 288   d32 = 1.2345df;               /* Initialize d32.  */
 289
 290   /* Non-finite 32-bits decimal floating point: infinity and NaN.  */
 291   d32 = __builtin_infd32();     /* Positive infd32.  */
 292   d32 = -__builtin_infd32();    /* Negative infd32.  */
 293   d32 = __builtin_nand32("");
 294
 295   /* An finite 64-bits decimal floating point.  */
 296   d64 = 1.2345dd;               /* Initialize d64.  */
 297
 298   /* Non-finite 64-bits decimal floating point: infinity and NaN.  */
 299   d64 = __builtin_infd64();     /* Positive infd64.  */
 300   d64 = -__builtin_infd64();    /* Negative infd64.  */
 301   d64 = __builtin_nand64("");
 302
 303   /* An finite 128-bits decimal floating point.  */
 304   d128 = 1.2345dl;              /* Initialize d128.  */
 305
 306   /* Non-finite 128-bits decimal floating point: infinity and NaN.  */
 307   d128 = __builtin_infd128();   /* Positive infd128.  */
 308   d128 = -__builtin_infd128();  /* Negative infd128.  */
 309   d128 = __builtin_nand128("");
 310
 311   /* Functions with decimal floating point as parameter and return value. */
 312   d32 = arg0_32 (0.1df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df);
 313   d64 = arg0_64 (0.1dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd);
 314   d128 = arg0_128 (0.1dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl);
 315
 316   ds.int4 = 1;
 317   ds.long8 = 2;
 318   ds.float4 = 3.1;
 319   ds.double8 = 4.2;
 320   ds.dec32 = 1.2345df;
 321   ds.dec64 = 1.2345dd;
 322   ds.dec128 = 1.2345dl;
 323
 324   return 0;     /* Exit point.  */
 325 }