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 } 326