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

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2007-2016 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 struct decstruct
  95 {
  96   int int4;
  97   long long8;
  98   float float4;
  99   double double8;
 100   _Decimal32 dec32;
 101   _Decimal64 dec64;
 102   _Decimal128 dec128;
 103 } ds;
 104
 105 static _Decimal32
 106 arg0_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
 107          _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
 108 {
 109   return arg0;
 110 }
 111
 112 static _Decimal64
 113 arg0_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
 114          _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
 115 {
 116   return arg0;
 117 }
 118
 119 static _Decimal128
 120 arg0_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
 121          _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
 122 {
 123   return arg0;
 124 }
 125
 126 /* Function to test if _Decimal128 argument interferes with stack slots
 127    because of alignment.  */
 128 int
 129 decimal_dec128_align (double arg0, _Decimal128 arg1, double arg2, double arg3,
 130                       double arg4, double arg5, double arg6, double arg7,
 131                       double arg8, double arg9, double arg10, double arg11,
 132                       double arg12, double arg13)
 133 {
 134   return ((arg0 - double_val1) < DELTA_B
 135           && (arg0 - double_val1) > -DELTA_B
 136           && (arg1 - dec128_val2) < DELTA
 137           && (arg1 - dec128_val2) > -DELTA
 138           && (arg2 - double_val3) < DELTA_B
 139           && (arg2 - double_val3) > -DELTA_B
 140           && (arg3 - double_val4) < DELTA_B
 141           && (arg3 - double_val4) > -DELTA_B
 142           && (arg4 - double_val5) < DELTA_B
 143           && (arg4 - double_val5) > -DELTA_B
 144           && (arg5 - double_val6) < DELTA_B
 145           && (arg5 - double_val6) > -DELTA_B
 146           && (arg6 - double_val7) < DELTA_B
 147           && (arg6 - double_val7) > -DELTA_B
 148           && (arg7 - double_val8) < DELTA_B
 149           && (arg7 - double_val8) > -DELTA_B
 150           && (arg8 - double_val9) < DELTA_B
 151           && (arg8 - double_val9) > -DELTA_B
 152           && (arg9 - double_val10) < DELTA_B
 153           && (arg9 - double_val10) > -DELTA_B
 154           && (arg10 - double_val11) < DELTA_B
 155           && (arg10 - double_val11) > -DELTA_B
 156           && (arg11 - double_val12) < DELTA_B
 157           && (arg11 - double_val12) > -DELTA_B
 158           && (arg12 - double_val13) < DELTA_B
 159           && (arg12 - double_val13) > -DELTA_B
 160           && (arg13 - double_val14) < DELTA_B
 161           && (arg13 - double_val14) > -DELTA_B);
 162 }
 163
 164 int
 165 decimal_mixed (_Decimal32 arg0, _Decimal64 arg1, _Decimal128 arg2)
 166 {
 167   return ((arg0 - dec32_val1) < DELTA
 168           && (arg0 - dec32_val1) > -DELTA
 169           && (arg1 - dec64_val1) < DELTA
 170           && (arg1 - dec64_val1) > -DELTA
 171           && (arg2 - dec128_val1) < DELTA
 172           && (arg2 - dec128_val1) > -DELTA);
 173 }
 174
 175 /* These functions have many arguments to force some of them to be passed via
 176    the stack instead of registers, to test that GDB can construct correctly
 177    the parameter save area. Note that Linux/ppc32 has 8 float registers to use
 178    for float parameter passing and Linux/ppc64 has 13, so the number of
 179    arguments has to be at least 14 to contemplate these platforms.  */
 180
 181 int
 182 decimal_many_args_dec32 (_Decimal32 f1, _Decimal32 f2, _Decimal32 f3,
 183                             _Decimal32 f4, _Decimal32 f5, _Decimal32 f6,
 184                             _Decimal32 f7, _Decimal32 f8, _Decimal32 f9,
 185                             _Decimal32 f10, _Decimal32 f11, _Decimal32 f12,
 186                             _Decimal32 f13, _Decimal32 f14, _Decimal32 f15,
 187                             _Decimal32 f16)
 188 {
 189   _Decimal32 sum_args;
 190   _Decimal32 sum_values;
 191
 192   sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
 193              + f13 + f14 + f15 + f16;
 194   sum_values = dec32_val1 + dec32_val2 + dec32_val3 + dec32_val4 + dec32_val5
 195                + dec32_val6 + dec32_val7 + dec32_val8 + dec32_val9
 196                + dec32_val10 + dec32_val11 + dec32_val12 + dec32_val13
 197                + dec32_val14 + dec32_val15 + dec32_val16;
 198
 199   return ((sum_args - sum_values) < DELTA
 200           && (sum_args - sum_values) > -DELTA);
 201 }
 202
 203 int
 204 decimal_many_args_dec64 (_Decimal64 f1, _Decimal64 f2, _Decimal64 f3,
 205                             _Decimal64 f4, _Decimal64 f5, _Decimal64 f6,
 206                             _Decimal64 f7, _Decimal64 f8, _Decimal64 f9,
 207                             _Decimal64 f10, _Decimal64 f11, _Decimal64 f12,
 208                             _Decimal64 f13, _Decimal64 f14, _Decimal64 f15,
 209                             _Decimal64 f16)
 210 {
 211   _Decimal64 sum_args;
 212   _Decimal64 sum_values;
 213
 214   sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
 215              + f13 + f14 + f15 + f16;
 216   sum_values = dec64_val1 + dec64_val2 + dec64_val3 + dec64_val4 + dec64_val5
 217                + dec64_val6 + dec64_val7 + dec64_val8 + dec64_val9
 218                + dec64_val10 + dec64_val11 + dec64_val12 + dec64_val13
 219                + dec64_val14 + dec64_val15 + dec64_val16;
 220
 221   return ((sum_args - sum_values) < DELTA
 222           && (sum_args - sum_values) > -DELTA);
 223 }
 224
 225 int
 226 decimal_many_args_dec128 (_Decimal128 f1, _Decimal128 f2, _Decimal128 f3,
 227                             _Decimal128 f4, _Decimal128 f5, _Decimal128 f6,
 228                             _Decimal128 f7, _Decimal128 f8, _Decimal128 f9,
 229                             _Decimal128 f10, _Decimal128 f11, _Decimal128 f12,
 230                             _Decimal128 f13, _Decimal128 f14, _Decimal128 f15,
 231                             _Decimal128 f16)
 232 {
 233   _Decimal128 sum_args;
 234   _Decimal128 sum_values;
 235
 236   sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
 237              + f13 + f14 + f15 + f16;
 238   sum_values = dec128_val1 + dec128_val2 + dec128_val3 + dec128_val4 + dec128_val5
 239                + dec128_val6 + dec128_val7 + dec128_val8 + dec128_val9
 240                + dec128_val10 + dec128_val11 + dec128_val12 + dec128_val13
 241                + dec128_val14 + dec128_val15 + dec128_val16;
 242
 243   return ((sum_args - sum_values) < DELTA
 244           && (sum_args - sum_values) > -DELTA);
 245 }
 246
 247 int
 248 decimal_many_args_mixed (_Decimal32 f1, _Decimal32 f2, _Decimal32 f3,
 249                            _Decimal64 f4, _Decimal64 f5, _Decimal64 f6,
 250                            _Decimal64 f7, _Decimal128 f8, _Decimal128 f9,
 251                            _Decimal128 f10, _Decimal32 f11, _Decimal64 f12,
 252                            _Decimal32 f13, _Decimal64 f14, _Decimal128 f15)
 253 {
 254   _Decimal128 sum_args;
 255   _Decimal128 sum_values;
 256
 257   sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
 258              + f13 + f14 + f15;
 259   sum_values = dec32_val1 + dec32_val2 + dec32_val3 + dec64_val4 + dec64_val5
 260                + dec64_val6 + dec64_val7 + dec128_val8 + dec128_val9
 261                + dec128_val10 + dec32_val11 + dec64_val12 + dec32_val13
 262                + dec64_val14 + dec128_val15;
 263
 264   return ((sum_args - sum_values) < DELTA
 265           && (sum_args - sum_values) > -DELTA);
 266 }
 267
 268 int main()
 269 {
 270   /* An finite 32-bits decimal floating point.  */
 271   d32 = 1.2345df;               /* Initialize d32.  */
 272
 273   /* Non-finite 32-bits decimal floating point: infinity and NaN.  */
 274   d32 = __builtin_infd32();     /* Positive infd32.  */
 275   d32 = -__builtin_infd32();    /* Negative infd32.  */
 276   d32 = __builtin_nand32("");
 277
 278   /* An finite 64-bits decimal floating point.  */
 279   d64 = 1.2345dd;               /* Initialize d64.  */
 280
 281   /* Non-finite 64-bits decimal floating point: infinity and NaN.  */
 282   d64 = __builtin_infd64();     /* Positive infd64.  */
 283   d64 = -__builtin_infd64();    /* Negative infd64.  */
 284   d64 = __builtin_nand64("");
 285
 286   /* An finite 128-bits decimal floating point.  */
 287   d128 = 1.2345dl;              /* Initialize d128.  */
 288
 289   /* Non-finite 128-bits decimal floating point: infinity and NaN.  */
 290   d128 = __builtin_infd128();   /* Positive infd128.  */
 291   d128 = -__builtin_infd128();  /* Negative infd128.  */
 292   d128 = __builtin_nand128("");
 293
 294   /* Functions with decimal floating point as parameter and return value. */
 295   d32 = arg0_32 (0.1df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df);
 296   d64 = arg0_64 (0.1dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd);
 297   d128 = arg0_128 (0.1dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl);
 298
 299   ds.int4 = 1;
 300   ds.long8 = 2;
 301   ds.float4 = 3.1;
 302   ds.double8 = 4.2;
 303   ds.dec32 = 1.2345df;
 304   ds.dec64 = 1.2345dd;
 305   ds.dec128 = 1.2345dl;
 306
 307   return 0;     /* Exit point.  */
 308 }