1/* This testcase is part of GDB, the GNU debugger.
2
3   Copyright 2007, 2008, 2009, 2010, 2011 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
24double double_val1 = 45.125;
25double double_val2 = -67.75;
26double double_val3 = 0.25;
27double double_val4 = 1.25;
28double double_val5 = 2.25;
29double double_val6 = 3.25;
30double double_val7 = 4.25;
31double double_val8 = 5.25;
32double double_val9 = 6.25;
33double double_val10 = 7.25;
34double double_val11 = 8.25;
35double double_val12 = 9.25;
36double double_val13 = 10.25;
37double 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
90volatile _Decimal32 d32;
91volatile _Decimal64 d64;
92volatile _Decimal128 d128;
93
94struct 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
105static _Decimal32
106arg0_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
107         _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
108{
109  return arg0;
110}
111
112static _Decimal64
113arg0_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
114         _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
115{
116  return arg0;
117}
118
119static _Decimal128
120arg0_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.  */
128int
129decimal_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
164int
165decimal_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
181int
182decimal_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
203int
204decimal_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
225int
226decimal_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
247int
248decimal_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
268int 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}
309