1 /* Some random tests for vacall. */
2
3 /*
4 * Copyright 1993 Bill Triggs <Bill.Triggs@inrialpes.fr>
5 * Copyright 1995-2021 Bruno Haible <bruno@clisp.org>
6 *
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <https://www.gnu.org/licenses/>.
19 */
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include "vacall.h"
25
26 #include "testcases.c"
27
28 #if defined(__m68k__) && defined(__GNUC__)
29 /* "gcc-2.6.3 -freg-struct-return" returns T = struct { char c[3]; } (which
30 * has size 4 !) in memory, in contrast to struct { char a,b,c; } and
31 * struct { char c[4]; } and struct { char a,b,c,d; } which have the same
32 * size and the same alignment but are returned in registers. I don't know why.
33 */
34 #define SKIP_T
35 #endif
36 #if defined(__sparc__) && defined(__sun) && defined(__SUNPRO_C) /* SUNWspro cc */
37 /* SunPRO cc miscompiles the simulator function for X_BcdB: d.i[1] is
38 * temporarily stored in %l2 and put onto the stack from %l2, but in between
39 * the copy of X has used %l2 as a counter without saving and restoring its
40 * value.
41 */
42 #define SKIP_X
43 #endif
44 #if defined(__mipsn32__) && !defined(__GNUC__)
45 /* The X test crashes for an unknown reason. */
46 #define SKIP_X
47 #endif
48
49
50 void* current_function;
51
52 /* This function simulates the behaviour of current_function. */
simulator(va_alist alist)53 void simulator (va_alist alist)
54 {
55 /* void tests */
56 if (current_function == (void*)&v_v)
57 {
58 va_start_void(alist);
59 fprintf(out,"void f(void):\n");
60 fflush(out);
61 va_return_void(alist);
62 }
63
64 /* int tests */
65 else if (current_function == (void*)&i_v)
66 {
67 va_start_int(alist);
68 {int r=99;
69 fprintf(out,"int f(void):");
70 fflush(out);
71 va_return_int(alist, r);
72 }}
73 else if (current_function == (void*)&i_i)
74 {
75 va_start_int(alist);
76 {int a = va_arg_int(alist);
77 int r=a+1;
78 fprintf(out,"int f(int):(%d)",a);
79 fflush(out);
80 va_return_int(alist, r);
81 }}
82 else if (current_function == (void*)&i_i2)
83 {
84 va_start_int(alist);
85 {int a = va_arg_int(alist);
86 int b = va_arg_int(alist);
87 int r=a+b;
88 fprintf(out,"int f(2*int):(%d,%d)",a,b);
89 fflush(out);
90 va_return_int(alist, r);
91 }}
92 else if (current_function == (void*)&i_i4)
93 {
94 va_start_int(alist);
95 {int a = va_arg_int(alist);
96 int b = va_arg_int(alist);
97 int c = va_arg_int(alist);
98 int d = va_arg_int(alist);
99 int r=a+b+c+d;
100 fprintf(out,"int f(4*int):(%d,%d,%d,%d)",a,b,c,d);
101 fflush(out);
102 va_return_int(alist, r);
103 }}
104 else if (current_function == (void*)&i_i8)
105 {
106 va_start_int(alist);
107 {int a = va_arg_int(alist);
108 int b = va_arg_int(alist);
109 int c = va_arg_int(alist);
110 int d = va_arg_int(alist);
111 int e = va_arg_int(alist);
112 int f = va_arg_int(alist);
113 int g = va_arg_int(alist);
114 int h = va_arg_int(alist);
115 int r=a+b+c+d+e+f+g+h;
116 fprintf(out,"int f(8*int):(%d,%d,%d,%d,%d,%d,%d,%d)",a,b,c,d,e,f,g,h);
117 fflush(out);
118 va_return_int(alist, r);
119 }}
120 else if (current_function == (void*)&i_i16)
121 {
122 va_start_int(alist);
123 {int a = va_arg_int(alist);
124 int b = va_arg_int(alist);
125 int c = va_arg_int(alist);
126 int d = va_arg_int(alist);
127 int e = va_arg_int(alist);
128 int f = va_arg_int(alist);
129 int g = va_arg_int(alist);
130 int h = va_arg_int(alist);
131 int i = va_arg_int(alist);
132 int j = va_arg_int(alist);
133 int k = va_arg_int(alist);
134 int l = va_arg_int(alist);
135 int m = va_arg_int(alist);
136 int n = va_arg_int(alist);
137 int o = va_arg_int(alist);
138 int p = va_arg_int(alist);
139 int r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
140 fprintf(out,"int f(16*int):(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
141 a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
142 fflush(out);
143 va_return_int(alist, r);
144 }}
145 else if (current_function == (void*)&i_i32)
146 {
147 va_start_int(alist);
148 {int a = va_arg_int(alist);
149 int b = va_arg_int(alist);
150 int c = va_arg_int(alist);
151 int d = va_arg_int(alist);
152 int e = va_arg_int(alist);
153 int f = va_arg_int(alist);
154 int g = va_arg_int(alist);
155 int h = va_arg_int(alist);
156 int i = va_arg_int(alist);
157 int j = va_arg_int(alist);
158 int k = va_arg_int(alist);
159 int l = va_arg_int(alist);
160 int m = va_arg_int(alist);
161 int n = va_arg_int(alist);
162 int o = va_arg_int(alist);
163 int p = va_arg_int(alist);
164 int aa = va_arg_int(alist);
165 int ab = va_arg_int(alist);
166 int ac = va_arg_int(alist);
167 int ad = va_arg_int(alist);
168 int ae = va_arg_int(alist);
169 int af = va_arg_int(alist);
170 int ag = va_arg_int(alist);
171 int ah = va_arg_int(alist);
172 int ai = va_arg_int(alist);
173 int aj = va_arg_int(alist);
174 int ak = va_arg_int(alist);
175 int al = va_arg_int(alist);
176 int am = va_arg_int(alist);
177 int an = va_arg_int(alist);
178 int ao = va_arg_int(alist);
179 int ap = va_arg_int(alist);
180 int r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+aa+ab+ac+ad+ae+af+ag+ah+ai+aj+ak+al+am+an+ao+ap;
181 fprintf(out,"int f(32*int):(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
182 a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap);
183 fflush(out);
184 va_return_int(alist, r);
185 }}
186
187 /* float tests */
188 else if (current_function == (void*)&f_f)
189 {
190 va_start_float(alist);
191 {float a = va_arg_float(alist);
192 float r=a+1.0;
193 fprintf(out,"float f(float):(%g)",a);
194 fflush(out);
195 va_return_float(alist, r);
196 }}
197 else if (current_function == (void*)&f_f2)
198 {
199 va_start_float(alist);
200 {float a = va_arg_float(alist);
201 float b = va_arg_float(alist);
202 float r=a+b;
203 fprintf(out,"float f(2*float):(%g,%g)",a,b);
204 fflush(out);
205 va_return_float(alist, r);
206 }}
207 else if (current_function == (void*)&f_f4)
208 {
209 va_start_float(alist);
210 {float a = va_arg_float(alist);
211 float b = va_arg_float(alist);
212 float c = va_arg_float(alist);
213 float d = va_arg_float(alist);
214 float r=a+b+c+d;
215 fprintf(out,"float f(4*float):(%g,%g,%g,%g)",a,b,c,d);
216 fflush(out);
217 va_return_float(alist, r);
218 }}
219 else if (current_function == (void*)&f_f8)
220 {
221 va_start_float(alist);
222 {float a = va_arg_float(alist);
223 float b = va_arg_float(alist);
224 float c = va_arg_float(alist);
225 float d = va_arg_float(alist);
226 float e = va_arg_float(alist);
227 float f = va_arg_float(alist);
228 float g = va_arg_float(alist);
229 float h = va_arg_float(alist);
230 float r=a+b+c+d+e+f+g+h;
231 fprintf(out,"float f(8*float):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
232 fflush(out);
233 va_return_float(alist, r);
234 }}
235 else if (current_function == (void*)&f_f16)
236 {
237 va_start_float(alist);
238 {float a = va_arg_float(alist);
239 float b = va_arg_float(alist);
240 float c = va_arg_float(alist);
241 float d = va_arg_float(alist);
242 float e = va_arg_float(alist);
243 float f = va_arg_float(alist);
244 float g = va_arg_float(alist);
245 float h = va_arg_float(alist);
246 float i = va_arg_float(alist);
247 float j = va_arg_float(alist);
248 float k = va_arg_float(alist);
249 float l = va_arg_float(alist);
250 float m = va_arg_float(alist);
251 float n = va_arg_float(alist);
252 float o = va_arg_float(alist);
253 float p = va_arg_float(alist);
254 float r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
255 fprintf(out,"float f(16*float):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
256 fflush(out);
257 va_return_float(alist, r);
258 }}
259 else if (current_function == (void*)&f_f24)
260 {
261 va_start_float(alist);
262 {float a = va_arg_float(alist);
263 float b = va_arg_float(alist);
264 float c = va_arg_float(alist);
265 float d = va_arg_float(alist);
266 float e = va_arg_float(alist);
267 float f = va_arg_float(alist);
268 float g = va_arg_float(alist);
269 float h = va_arg_float(alist);
270 float i = va_arg_float(alist);
271 float j = va_arg_float(alist);
272 float k = va_arg_float(alist);
273 float l = va_arg_float(alist);
274 float m = va_arg_float(alist);
275 float n = va_arg_float(alist);
276 float o = va_arg_float(alist);
277 float p = va_arg_float(alist);
278 float q = va_arg_float(alist);
279 float s = va_arg_float(alist);
280 float t = va_arg_float(alist);
281 float u = va_arg_float(alist);
282 float v = va_arg_float(alist);
283 float w = va_arg_float(alist);
284 float x = va_arg_float(alist);
285 float y = va_arg_float(alist);
286 float r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+s+t+u+v+w+x+y;
287 fprintf(out,"float f(24*float):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,v,w,x,y);
288 fflush(out);
289 va_return_float(alist, r);
290 }}
291
292 /* double tests */
293 else if (current_function == (void*)&d_d)
294 {
295 va_start_double(alist);
296 {double a = va_arg_double(alist);
297 double r=a+1.0;
298 fprintf(out,"double f(double):(%g)",a);
299 fflush(out);
300 va_return_double(alist, r);
301 }}
302 else if (current_function == (void*)&d_d2)
303 {
304 va_start_double(alist);
305 {double a = va_arg_double(alist);
306 double b = va_arg_double(alist);
307 double r=a+b;
308 fprintf(out,"double f(2*double):(%g,%g)",a,b);
309 fflush(out);
310 va_return_double(alist, r);
311 }}
312 else if (current_function == (void*)&d_d4)
313 {
314 va_start_double(alist);
315 {double a = va_arg_double(alist);
316 double b = va_arg_double(alist);
317 double c = va_arg_double(alist);
318 double d = va_arg_double(alist);
319 double r=a+b+c+d;
320 fprintf(out,"double f(4*double):(%g,%g,%g,%g)",a,b,c,d);
321 fflush(out);
322 va_return_double(alist, r);
323 }}
324 else if (current_function == (void*)&d_d8)
325 {
326 va_start_double(alist);
327 {double a = va_arg_double(alist);
328 double b = va_arg_double(alist);
329 double c = va_arg_double(alist);
330 double d = va_arg_double(alist);
331 double e = va_arg_double(alist);
332 double f = va_arg_double(alist);
333 double g = va_arg_double(alist);
334 double h = va_arg_double(alist);
335 double r=a+b+c+d+e+f+g+h;
336 fprintf(out,"double f(8*double):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
337 fflush(out);
338 va_return_double(alist, r);
339 }}
340 else if (current_function == (void*)&d_d16)
341 {
342 va_start_double(alist);
343 {double a = va_arg_double(alist);
344 double b = va_arg_double(alist);
345 double c = va_arg_double(alist);
346 double d = va_arg_double(alist);
347 double e = va_arg_double(alist);
348 double f = va_arg_double(alist);
349 double g = va_arg_double(alist);
350 double h = va_arg_double(alist);
351 double i = va_arg_double(alist);
352 double j = va_arg_double(alist);
353 double k = va_arg_double(alist);
354 double l = va_arg_double(alist);
355 double m = va_arg_double(alist);
356 double n = va_arg_double(alist);
357 double o = va_arg_double(alist);
358 double p = va_arg_double(alist);
359 double r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
360 fprintf(out,"double f(16*double):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
361 fflush(out);
362 va_return_double(alist, r);
363 }}
364
365 /* pointer tests */
366 else if (current_function == (void*)&vp_vpdpcpsp)
367 {
368 va_start_ptr(alist, void*);
369 {void* a = va_arg_ptr(alist, void*);
370 double* b = va_arg_ptr(alist, double*);
371 char* c = va_arg_ptr(alist, char*);
372 Int* d = va_arg_ptr(alist, Int*);
373 void* ret = (char*)b + 1;
374 fprintf(out,"void* f(void*,double*,char*,Int*):(0x%p,0x%p,0x%p,0x%p)",a,b,c,d);
375 fflush(out);
376 va_return_ptr(alist, void*, ret);
377 }}
378
379 /* mixed number tests */
380 else if (current_function == (void*)&uc_ucsil)
381 {
382 va_start_uchar(alist);
383 {uchar a = va_arg_uchar(alist);
384 ushort b = va_arg_ushort(alist);
385 uint c = va_arg_uint(alist);
386 ulong d = va_arg_ulong(alist);
387 uchar r = (uchar)-1;
388 fprintf(out,"uchar f(uchar,ushort,uint,ulong):(%u,%u,%u,%lu)",a,b,c,d);
389 fflush(out);
390 va_return_uchar(alist, r);
391 }}
392 else if (current_function == (void*)&d_iidd)
393 {
394 va_start_double(alist);
395 {int a = va_arg_int(alist);
396 int b = va_arg_int(alist);
397 double c = va_arg_double(alist);
398 double d = va_arg_double(alist);
399 double r=a+b+c+d;
400 fprintf(out,"double f(int,int,double,double):(%d,%d,%g,%g)",a,b,c,d);
401 fflush(out);
402 va_return_double(alist, r);
403 }}
404 else if (current_function == (void*)&d_iiidi)
405 {
406 va_start_double(alist);
407 {int a = va_arg_int(alist);
408 int b = va_arg_int(alist);
409 int c = va_arg_int(alist);
410 double d = va_arg_double(alist);
411 int e = va_arg_int(alist);
412 double r=a+b+c+d+e;
413 fprintf(out,"double f(int,int,int,double,int):(%d,%d,%d,%g,%d)",a,b,c,d,e);
414 fflush(out);
415 va_return_double(alist, r);
416 }}
417 else if (current_function == (void*)&d_idid)
418 {
419 va_start_double(alist);
420 {int a = va_arg_int(alist);
421 double b = va_arg_double(alist);
422 int c = va_arg_int(alist);
423 double d = va_arg_double(alist);
424 double r=a+b+c+d;
425 fprintf(out,"double f(int,double,int,double):(%d,%g,%d,%g)",a,b,c,d);
426 fflush(out);
427 va_return_double(alist, r);
428 }}
429 else if (current_function == (void*)&d_fdi)
430 {
431 va_start_double(alist);
432 {float a = va_arg_float(alist);
433 double b = va_arg_double(alist);
434 int c = va_arg_int(alist);
435 double r=a+b+c;
436 fprintf(out,"double f(float,double,int):(%g,%g,%d)",a,b,c);
437 fflush(out);
438 va_return_double(alist, r);
439 }}
440 else if (current_function == (void*)&us_cdcd)
441 {
442 va_start_ushort(alist);
443 {char a = va_arg_char(alist);
444 double b = va_arg_double(alist);
445 char c = va_arg_char(alist);
446 double d = va_arg_double(alist);
447 ushort r = (ushort)(int)(a + b + c + d);
448 fprintf(out,"ushort f(char,double,char,double):('%c',%g,'%c',%g)",a,b,c,d);
449 fflush(out);
450 va_return_ushort(alist, r);
451 }}
452 else if (current_function == (void*)&ll_iiilli)
453 {
454 va_start_longlong(alist);
455 {int a = va_arg_int(alist);
456 int b = va_arg_int(alist);
457 int c = va_arg_int(alist);
458 long long d = va_arg_longlong(alist);
459 int e = va_arg_int(alist);
460 long long r = (long long)a + (long long)b + (long long)c + d + (long long)e;
461 fprintf(out,"long long f(int,int,int,long long,int):(%d,%d,%d,0x%lx%08lx,%d)",a,b,c,(long)(d>>32),(long)(d&0xffffffff),e);
462 fflush(out);
463 va_return_longlong(alist, r);
464 }}
465 else if (current_function == (void*)&ll_flli)
466 {
467 va_start_longlong(alist);
468 {float a = va_arg_float(alist);
469 long long b = va_arg_longlong(alist);
470 int c = va_arg_int(alist);
471 long long r = (long long)(int)a + b + (long long)c;
472 fprintf(out,"long long f(float,long long,int):(%g,0x%lx%08lx,0x%lx)",a,(long)(b>>32),(long)(b&0xffffffff),(long)c);
473 fflush(out);
474 va_return_longlong(alist, r);
475 }}
476 else if (current_function == (void*)&f_fi)
477 {
478 va_start_float(alist);
479 {float a = va_arg_float(alist);
480 int z = va_arg_int(alist);
481 float r = a+z;
482 fprintf(out,"float f(float,int):(%g,%d)",a,z);
483 fflush(out);
484 va_return_float(alist, r);
485 }}
486 else if (current_function == (void*)&f_f2i)
487 {
488 va_start_float(alist);
489 {float a = va_arg_float(alist);
490 float b = va_arg_float(alist);
491 int z = va_arg_int(alist);
492 float r = a+b+z;
493 fprintf(out,"float f(2*float,int):(%g,%g,%d)",a,b,z);
494 fflush(out);
495 va_return_float(alist, r);
496 }}
497 else if (current_function == (void*)&f_f3i)
498 {
499 va_start_float(alist);
500 {float a = va_arg_float(alist);
501 float b = va_arg_float(alist);
502 float c = va_arg_float(alist);
503 int z = va_arg_int(alist);
504 float r = a+b+c+z;
505 fprintf(out,"float f(3*float,int):(%g,%g,%g,%d)",a,b,c,z);
506 fflush(out);
507 va_return_float(alist, r);
508 }}
509 else if (current_function == (void*)&f_f4i)
510 {
511 va_start_float(alist);
512 {float a = va_arg_float(alist);
513 float b = va_arg_float(alist);
514 float c = va_arg_float(alist);
515 float d = va_arg_float(alist);
516 int z = va_arg_int(alist);
517 float r = a+b+c+d+z;
518 fprintf(out,"float f(4*float,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
519 fflush(out);
520 va_return_float(alist, r);
521 }}
522 else if (current_function == (void*)&f_f7i)
523 {
524 va_start_float(alist);
525 {float a = va_arg_float(alist);
526 float b = va_arg_float(alist);
527 float c = va_arg_float(alist);
528 float d = va_arg_float(alist);
529 float e = va_arg_float(alist);
530 float f = va_arg_float(alist);
531 float g = va_arg_float(alist);
532 int z = va_arg_int(alist);
533 float r = a+b+c+d+e+f+g+z;
534 fprintf(out,"float f(7*float,int):(%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,z);
535 fflush(out);
536 va_return_float(alist, r);
537 }}
538 else if (current_function == (void*)&f_f8i)
539 {
540 va_start_float(alist);
541 {float a = va_arg_float(alist);
542 float b = va_arg_float(alist);
543 float c = va_arg_float(alist);
544 float d = va_arg_float(alist);
545 float e = va_arg_float(alist);
546 float f = va_arg_float(alist);
547 float g = va_arg_float(alist);
548 float h = va_arg_float(alist);
549 int z = va_arg_int(alist);
550 float r = a+b+c+d+e+f+g+h+z;
551 fprintf(out,"float f(8*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,z);
552 fflush(out);
553 va_return_float(alist, r);
554 }}
555 else if (current_function == (void*)&f_f12i)
556 {
557 va_start_float(alist);
558 {float a = va_arg_float(alist);
559 float b = va_arg_float(alist);
560 float c = va_arg_float(alist);
561 float d = va_arg_float(alist);
562 float e = va_arg_float(alist);
563 float f = va_arg_float(alist);
564 float g = va_arg_float(alist);
565 float h = va_arg_float(alist);
566 float i = va_arg_float(alist);
567 float j = va_arg_float(alist);
568 float k = va_arg_float(alist);
569 float l = va_arg_float(alist);
570 int z = va_arg_int(alist);
571 float r = a+b+c+d+e+f+g+h+i+j+k+l+z;
572 fprintf(out,"float f(12*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,z);
573 fflush(out);
574 va_return_float(alist, r);
575 }}
576 else if (current_function == (void*)&f_f13i)
577 {
578 va_start_float(alist);
579 {float a = va_arg_float(alist);
580 float b = va_arg_float(alist);
581 float c = va_arg_float(alist);
582 float d = va_arg_float(alist);
583 float e = va_arg_float(alist);
584 float f = va_arg_float(alist);
585 float g = va_arg_float(alist);
586 float h = va_arg_float(alist);
587 float i = va_arg_float(alist);
588 float j = va_arg_float(alist);
589 float k = va_arg_float(alist);
590 float l = va_arg_float(alist);
591 float m = va_arg_float(alist);
592 int z = va_arg_int(alist);
593 float r = a+b+c+d+e+f+g+h+i+j+k+l+m+z;
594 fprintf(out,"float f(13*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,m,z);
595 fflush(out);
596 va_return_float(alist, r);
597 }}
598 else if (current_function == (void*)&d_di)
599 {
600 va_start_double(alist);
601 {double a = va_arg_double(alist);
602 int z = va_arg_int(alist);
603 double r = a+z;
604 fprintf(out,"double f(double,int):(%g,%d)",a,z);
605 fflush(out);
606 va_return_double(alist, r);
607 }}
608 else if (current_function == (void*)&d_d2i)
609 {
610 va_start_double(alist);
611 {double a = va_arg_double(alist);
612 double b = va_arg_double(alist);
613 int z = va_arg_int(alist);
614 double r = a+b+z;
615 fprintf(out,"double f(2*double,int):(%g,%g,%d)",a,b,z);
616 fflush(out);
617 va_return_double(alist, r);
618 }}
619 else if (current_function == (void*)&d_d3i)
620 {
621 va_start_double(alist);
622 {double a = va_arg_double(alist);
623 double b = va_arg_double(alist);
624 double c = va_arg_double(alist);
625 int z = va_arg_int(alist);
626 double r = a+b+c+z;
627 fprintf(out,"double f(3*double,int):(%g,%g,%g,%d)",a,b,c,z);
628 fflush(out);
629 va_return_double(alist, r);
630 }}
631 else if (current_function == (void*)&d_d4i)
632 {
633 va_start_double(alist);
634 {double a = va_arg_double(alist);
635 double b = va_arg_double(alist);
636 double c = va_arg_double(alist);
637 double d = va_arg_double(alist);
638 int z = va_arg_int(alist);
639 double r = a+b+c+d+z;
640 fprintf(out,"double f(4*double,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
641 fflush(out);
642 va_return_double(alist, r);
643 }}
644 else if (current_function == (void*)&d_d7i)
645 {
646 va_start_double(alist);
647 {double a = va_arg_double(alist);
648 double b = va_arg_double(alist);
649 double c = va_arg_double(alist);
650 double d = va_arg_double(alist);
651 double e = va_arg_double(alist);
652 double f = va_arg_double(alist);
653 double g = va_arg_double(alist);
654 int z = va_arg_int(alist);
655 double r = a+b+c+d+e+f+g+z;
656 fprintf(out,"double f(7*double,int):(%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,z);
657 fflush(out);
658 va_return_double(alist, r);
659 }}
660 else if (current_function == (void*)&d_d8i)
661 {
662 va_start_double(alist);
663 {double a = va_arg_double(alist);
664 double b = va_arg_double(alist);
665 double c = va_arg_double(alist);
666 double d = va_arg_double(alist);
667 double e = va_arg_double(alist);
668 double f = va_arg_double(alist);
669 double g = va_arg_double(alist);
670 double h = va_arg_double(alist);
671 int z = va_arg_int(alist);
672 double r = a+b+c+d+e+f+g+h+z;
673 fprintf(out,"double f(8*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,z);
674 fflush(out);
675 va_return_double(alist, r);
676 }}
677 else if (current_function == (void*)&d_d12i)
678 {
679 va_start_double(alist);
680 {double a = va_arg_double(alist);
681 double b = va_arg_double(alist);
682 double c = va_arg_double(alist);
683 double d = va_arg_double(alist);
684 double e = va_arg_double(alist);
685 double f = va_arg_double(alist);
686 double g = va_arg_double(alist);
687 double h = va_arg_double(alist);
688 double i = va_arg_double(alist);
689 double j = va_arg_double(alist);
690 double k = va_arg_double(alist);
691 double l = va_arg_double(alist);
692 int z = va_arg_int(alist);
693 double r = a+b+c+d+e+f+g+h+i+j+k+l+z;
694 fprintf(out,"double f(12*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,z);
695 fflush(out);
696 va_return_double(alist, r);
697 }}
698 else if (current_function == (void*)&d_d13i)
699 {
700 va_start_double(alist);
701 {double a = va_arg_double(alist);
702 double b = va_arg_double(alist);
703 double c = va_arg_double(alist);
704 double d = va_arg_double(alist);
705 double e = va_arg_double(alist);
706 double f = va_arg_double(alist);
707 double g = va_arg_double(alist);
708 double h = va_arg_double(alist);
709 double i = va_arg_double(alist);
710 double j = va_arg_double(alist);
711 double k = va_arg_double(alist);
712 double l = va_arg_double(alist);
713 double m = va_arg_double(alist);
714 int z = va_arg_int(alist);
715 double r = a+b+c+d+e+f+g+h+i+j+k+l+m+z;
716 fprintf(out,"double f(13*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,m,z);
717 fflush(out);
718 va_return_double(alist, r);
719 }}
720
721 /* small structure return tests */
722 else if (current_function == (void*)&S1_v)
723 {
724 Size1 r;
725 va_start_struct(alist, Size1, 1);
726 r = Size1_1;
727 fprintf(out,"Size1 f(void):");
728 fflush(out);
729 va_return_struct(alist, Size1, r);
730 }
731 else if (current_function == (void*)&S2_v)
732 {
733 Size2 r;
734 va_start_struct(alist, Size2, 1);
735 r = Size2_1;
736 fprintf(out,"Size2 f(void):");
737 fflush(out);
738 va_return_struct(alist, Size2, r);
739 }
740 else if (current_function == (void*)&S3_v)
741 {
742 Size3 r;
743 va_start_struct(alist, Size3, 1);
744 r = Size3_1;
745 fprintf(out,"Size3 f(void):");
746 fflush(out);
747 va_return_struct(alist, Size3, r);
748 }
749 else if (current_function == (void*)&S4_v)
750 {
751 Size4 r;
752 va_start_struct(alist, Size4, 1);
753 r = Size4_1;
754 fprintf(out,"Size4 f(void):");
755 fflush(out);
756 va_return_struct(alist, Size4, r);
757 }
758 else if (current_function == (void*)&S7_v)
759 {
760 Size7 r;
761 va_start_struct(alist, Size7, 1);
762 r = Size7_1;
763 fprintf(out,"Size7 f(void):");
764 fflush(out);
765 va_return_struct(alist, Size7, r);
766 }
767 else if (current_function == (void*)&S8_v)
768 {
769 Size8 r;
770 va_start_struct(alist, Size8, 1);
771 r = Size8_1;
772 fprintf(out,"Size8 f(void):");
773 fflush(out);
774 va_return_struct(alist, Size8, r);
775 }
776 else if (current_function == (void*)&S12_v)
777 {
778 Size12 r;
779 va_start_struct(alist, Size12, 1);
780 r = Size12_1;
781 fprintf(out,"Size12 f(void):");
782 fflush(out);
783 va_return_struct(alist, Size12, r);
784 }
785 else if (current_function == (void*)&S15_v)
786 {
787 Size15 r;
788 va_start_struct(alist, Size15, 1);
789 r = Size15_1;
790 fprintf(out,"Size15 f(void):");
791 fflush(out);
792 va_return_struct(alist, Size15, r);
793 }
794 else if (current_function == (void*)&S16_v)
795 {
796 Size16 r;
797 va_start_struct(alist, Size16, 1);
798 r = Size16_1;
799 fprintf(out,"Size16 f(void):");
800 fflush(out);
801 va_return_struct(alist, Size16, r);
802 }
803
804 /* structure tests */
805 else if (current_function == (void*)&I_III)
806 {
807 Int a;
808 Int b;
809 Int c;
810 Int r;
811 va_start_struct(alist, Int, 1);
812 a = va_arg_struct(alist, Int);
813 b = va_arg_struct(alist, Int);
814 c = va_arg_struct(alist, Int);
815 r.x = a.x + b.x + c.x;
816 fprintf(out,"Int f(Int,Int,Int):({%d},{%d},{%d})",a.x,b.x,c.x);
817 fflush(out);
818 va_return_struct(alist, Int, r);
819 }
820 #ifndef SKIP_EXTRA_STRUCTS
821 else if (current_function == (void*)&C_CdC)
822 {
823 Char a;
824 double b;
825 Char c;
826 Char r;
827 va_start_struct(alist, Char, 1);
828 a = va_arg_struct(alist, Char);
829 b = va_arg_double(alist);
830 c = va_arg_struct(alist, Char);
831 r.x = (a.x + c.x)/2;
832 fprintf(out,"Char f(Char,double,Char):({'%c'},%g,{'%c'})",a.x,b,c.x);
833 fflush(out);
834 va_return_struct(alist, Char, r);
835 }
836 else if (current_function == (void*)&F_Ffd)
837 {
838 Float a;
839 float b;
840 double c;
841 Float r;
842 va_start_struct(alist, Float, va_word_splittable_1(float));
843 a = va_arg_struct(alist, Float);
844 b = va_arg_float(alist);
845 c = va_arg_double(alist);
846 r.x = a.x + b + c;
847 fprintf(out,"Float f(Float,float,double):({%g},%g,%g)",a.x,b,c);
848 fflush(out);
849 va_return_struct(alist, Float, r);
850 }
851 else if (current_function == (void*)&D_fDd)
852 {
853 float a;
854 Double b;
855 double c;
856 Double r;
857 va_start_struct(alist, Double, va_word_splittable_1(double));
858 a = va_arg_float(alist);
859 b = va_arg_struct(alist, Double);
860 c = va_arg_double(alist);
861 r.x = a + b.x + c;
862 fprintf(out,"Double f(float,Double,double):(%g,{%g},%g)",a,b.x,c);
863 fflush(out);
864 va_return_struct(alist, Double, r);
865 }
866 else if (current_function == (void*)&D_Dfd)
867 {
868 Double a;
869 float b;
870 double c;
871 Double r;
872 va_start_struct(alist, Double, va_word_splittable_1(double));
873 a = va_arg_struct(alist, Double);
874 b = va_arg_float(alist);
875 c = va_arg_double(alist);
876 r.x = a.x + b + c;
877 fprintf(out,"Double f(Double,float,double):({%g},%g,%g)",a.x,b,c);
878 fflush(out);
879 va_return_struct(alist, Double, r);
880 }
881 #endif
882 else if (current_function == (void*)&J_JiJ)
883 {
884 J a;
885 int b;
886 J c;
887 J r;
888 va_start_struct(alist, J, va_word_splittable_2(long,long));
889 a = va_arg_struct(alist, J);
890 b = va_arg_int(alist);
891 c = va_arg_struct(alist, J);
892 r.l1 = a.l1+c.l1; r.l2 = a.l2+b+c.l2;
893 fprintf(out,"J f(J,int,J):({%ld,%ld},%d,{%ld,%ld})",a.l1,a.l2,b,c.l1,c.l2);
894 fflush(out);
895 va_return_struct(alist, J, r);
896 }
897 #ifndef SKIP_EXTRA_STRUCTS
898 else if (current_function == (void*)&T_TcT)
899 {
900 T a;
901 char b;
902 T c;
903 T r;
904 va_start_struct(alist, T, 1);
905 a = va_arg_struct(alist, T);
906 b = va_arg_char(alist);
907 c = va_arg_struct(alist, T);
908 r.c[0]='b'; r.c[1]=c.c[1]; r.c[2]=c.c[2];
909 fprintf(out,"T f(T,char,T):({\"%c%c%c\"},'%c',{\"%c%c%c\"})",a.c[0],a.c[1],a.c[2],b,c.c[0],c.c[1],c.c[2]);
910 fflush(out);
911 va_return_struct(alist, T, r);
912 }
913 else if (current_function == (void*)&X_BcdB)
914 {
915 B a;
916 char b;
917 double c;
918 B d;
919 static X xr={"return val",'R'};
920 X r;
921 va_start_struct(alist, X, 0);
922 a = va_arg_struct(alist, B);
923 b = va_arg_char(alist);
924 c = va_arg_double(alist);
925 d = va_arg_struct(alist, B);
926 r = xr;
927 r.c1 = b;
928 fprintf(out,"X f(B,char,double,B):({%g,{%d,%d,%d}},'%c',%g,{%g,{%d,%d,%d}})",
929 a.d,a.i[0],a.i[1],a.i[2],b,c,d.d,d.i[0],d.i[1],d.i[2]);
930 fflush(out);
931 va_return_struct(alist, X, r);
932 }
933 #endif
934
935 /* gpargs boundary tests */
936 else if (current_function == (void*)&l_l0J)
937 {
938 va_start_long(alist);
939 {J b = va_arg_struct(alist, J);
940 long c = va_arg_long(alist);
941 long r = b.l1 + b.l2 + c;
942 fprintf(out,"long f(J,long):(%ld,%ld,%ld)",b.l1,b.l2,c);
943 fflush(out);
944 va_return_long(alist, r);
945 }}
946 else if (current_function == (void*)&l_l1J)
947 {
948 va_start_long(alist);
949 {long a1 = va_arg_long(alist);
950 J b = va_arg_struct(alist, J);
951 long c = va_arg_long(alist);
952 long r = a1 + b.l1 + b.l2 + c;
953 fprintf(out,"long f(long,J,long):(%ld,%ld,%ld,%ld)",a1,b.l1,b.l2,c);
954 fflush(out);
955 va_return_long(alist, r);
956 }}
957 else if (current_function == (void*)&l_l2J)
958 {
959 va_start_long(alist);
960 {long a1 = va_arg_long(alist);
961 long a2 = va_arg_long(alist);
962 J b = va_arg_struct(alist, J);
963 long c = va_arg_long(alist);
964 long r = a1 + a2 + b.l1 + b.l2 + c;
965 fprintf(out,"long f(2*long,J,long):(%ld,%ld,%ld,%ld,%ld)",a1,a2,b.l1,b.l2,c);
966 fflush(out);
967 va_return_long(alist, r);
968 }}
969 else if (current_function == (void*)&l_l3J)
970 {
971 va_start_long(alist);
972 {long a1 = va_arg_long(alist);
973 long a2 = va_arg_long(alist);
974 long a3 = va_arg_long(alist);
975 J b = va_arg_struct(alist, J);
976 long c = va_arg_long(alist);
977 long r = a1 + a2 + a3 + b.l1 + b.l2 + c;
978 fprintf(out,"long f(3*long,J,long):(%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,b.l1,b.l2,c);
979 fflush(out);
980 va_return_long(alist, r);
981 }}
982 else if (current_function == (void*)&l_l4J)
983 {
984 va_start_long(alist);
985 {long a1 = va_arg_long(alist);
986 long a2 = va_arg_long(alist);
987 long a3 = va_arg_long(alist);
988 long a4 = va_arg_long(alist);
989 J b = va_arg_struct(alist, J);
990 long c = va_arg_long(alist);
991 long r = a1 + a2 + a3 + a4 + b.l1 + b.l2 + c;
992 fprintf(out,"long f(4*long,J,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,b.l1,b.l2,c);
993 fflush(out);
994 va_return_long(alist, r);
995 }}
996 else if (current_function == (void*)&l_l5J)
997 {
998 va_start_long(alist);
999 {long a1 = va_arg_long(alist);
1000 long a2 = va_arg_long(alist);
1001 long a3 = va_arg_long(alist);
1002 long a4 = va_arg_long(alist);
1003 long a5 = va_arg_long(alist);
1004 J b = va_arg_struct(alist, J);
1005 long c = va_arg_long(alist);
1006 long r = a1 + a2 + a3 + a4 + a5 + b.l1 + b.l2 + c;
1007 fprintf(out,"long f(5*long,J,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,b.l1,b.l2,c);
1008 fflush(out);
1009 va_return_long(alist, r);
1010 }}
1011 else if (current_function == (void*)&l_l6J)
1012 {
1013 va_start_long(alist);
1014 {long a1 = va_arg_long(alist);
1015 long a2 = va_arg_long(alist);
1016 long a3 = va_arg_long(alist);
1017 long a4 = va_arg_long(alist);
1018 long a5 = va_arg_long(alist);
1019 long a6 = va_arg_long(alist);
1020 J b = va_arg_struct(alist, J);
1021 long c = va_arg_long(alist);
1022 long r = a1 + a2 + a3 + a4 + a5 + a6 + b.l1 + b.l2 + c;
1023 fprintf(out,"long f(6*long,J,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,a6,b.l1,b.l2,c);
1024 fflush(out);
1025 va_return_long(alist, r);
1026 }}
1027 else if (current_function == (void*)&l_l7J)
1028 {
1029 va_start_long(alist);
1030 {long a1 = va_arg_long(alist);
1031 long a2 = va_arg_long(alist);
1032 long a3 = va_arg_long(alist);
1033 long a4 = va_arg_long(alist);
1034 long a5 = va_arg_long(alist);
1035 long a6 = va_arg_long(alist);
1036 long a7 = va_arg_long(alist);
1037 J b = va_arg_struct(alist, J);
1038 long c = va_arg_long(alist);
1039 long r = a1 + a2 + a3 + a4 + a5 + a6 + a7 + b.l1 + b.l2 + c;
1040 fprintf(out,"long f(7*long,J,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,a6,a7,b.l1,b.l2,c);
1041 fflush(out);
1042 va_return_long(alist, r);
1043 }}
1044 else if (current_function == (void*)&l_l0K)
1045 {
1046 va_start_long(alist);
1047 {K b = va_arg_struct(alist, K);
1048 long c = va_arg_long(alist);
1049 long r = b.l1 + b.l2 + b.l3 + b.l4 + c;
1050 fprintf(out,"long f(K,long):(%ld,%ld,%ld,%ld,%ld)",b.l1,b.l2,b.l3,b.l4,c);
1051 fflush(out);
1052 va_return_long(alist, r);
1053 }}
1054 else if (current_function == (void*)&l_l1K)
1055 {
1056 va_start_long(alist);
1057 {long a1 = va_arg_long(alist);
1058 K b = va_arg_struct(alist, K);
1059 long c = va_arg_long(alist);
1060 long r = a1 + b.l1 + b.l2 + b.l3 + b.l4 + c;
1061 fprintf(out,"long f(long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld)",a1,b.l1,b.l2,b.l3,b.l4,c);
1062 fflush(out);
1063 va_return_long(alist, r);
1064 }}
1065 else if (current_function == (void*)&l_l2K)
1066 {
1067 va_start_long(alist);
1068 {long a1 = va_arg_long(alist);
1069 long a2 = va_arg_long(alist);
1070 K b = va_arg_struct(alist, K);
1071 long c = va_arg_long(alist);
1072 long r = a1 + a2 + b.l1 + b.l2 + b.l3 + b.l4 + c;
1073 fprintf(out,"long f(2*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,b.l1,b.l2,b.l3,b.l4,c);
1074 fflush(out);
1075 va_return_long(alist, r);
1076 }}
1077 else if (current_function == (void*)&l_l3K)
1078 {
1079 va_start_long(alist);
1080 {long a1 = va_arg_long(alist);
1081 long a2 = va_arg_long(alist);
1082 long a3 = va_arg_long(alist);
1083 K b = va_arg_struct(alist, K);
1084 long c = va_arg_long(alist);
1085 long r = a1 + a2 + a3 + b.l1 + b.l2 + b.l3 + b.l4 + c;
1086 fprintf(out,"long f(3*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,b.l1,b.l2,b.l3,b.l4,c);
1087 fflush(out);
1088 va_return_long(alist, r);
1089 }}
1090 else if (current_function == (void*)&l_l4K)
1091 {
1092 va_start_long(alist);
1093 {long a1 = va_arg_long(alist);
1094 long a2 = va_arg_long(alist);
1095 long a3 = va_arg_long(alist);
1096 long a4 = va_arg_long(alist);
1097 K b = va_arg_struct(alist, K);
1098 long c = va_arg_long(alist);
1099 long r = a1 + a2 + a3 + a4 + b.l1 + b.l2 + b.l3 + b.l4 + c;
1100 fprintf(out,"long f(4*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,b.l1,b.l2,b.l3,b.l4,c);
1101 fflush(out);
1102 va_return_long(alist, r);
1103 }}
1104 else if (current_function == (void*)&l_l5K)
1105 {
1106 va_start_long(alist);
1107 {long a1 = va_arg_long(alist);
1108 long a2 = va_arg_long(alist);
1109 long a3 = va_arg_long(alist);
1110 long a4 = va_arg_long(alist);
1111 long a5 = va_arg_long(alist);
1112 K b = va_arg_struct(alist, K);
1113 long c = va_arg_long(alist);
1114 long r = a1 + a2 + a3 + a4 + a5 + b.l1 + b.l2 + b.l3 + b.l4 + c;
1115 fprintf(out,"long f(5*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,b.l1,b.l2,b.l3,b.l4,c);
1116 fflush(out);
1117 va_return_long(alist, r);
1118 }}
1119 else if (current_function == (void*)&l_l6K)
1120 {
1121 va_start_long(alist);
1122 {long a1 = va_arg_long(alist);
1123 long a2 = va_arg_long(alist);
1124 long a3 = va_arg_long(alist);
1125 long a4 = va_arg_long(alist);
1126 long a5 = va_arg_long(alist);
1127 long a6 = va_arg_long(alist);
1128 K b = va_arg_struct(alist, K);
1129 long c = va_arg_long(alist);
1130 long r = a1 + a2 + a3 + a4 + a5 + a6 + b.l1 + b.l2 + b.l3 + b.l4 + c;
1131 fprintf(out,"long f(6*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,a6,b.l1,b.l2,b.l3,b.l4,c);
1132 fflush(out);
1133 va_return_long(alist, r);
1134 }}
1135 else if (current_function == (void*)&f_f17l3L)
1136 {
1137 va_start_float(alist);
1138 {float a = va_arg_float(alist);
1139 float b = va_arg_float(alist);
1140 float c = va_arg_float(alist);
1141 float d = va_arg_float(alist);
1142 float e = va_arg_float(alist);
1143 float f = va_arg_float(alist);
1144 float g = va_arg_float(alist);
1145 float h = va_arg_float(alist);
1146 float i = va_arg_float(alist);
1147 float j = va_arg_float(alist);
1148 float k = va_arg_float(alist);
1149 float l = va_arg_float(alist);
1150 float m = va_arg_float(alist);
1151 float n = va_arg_float(alist);
1152 float o = va_arg_float(alist);
1153 float p = va_arg_float(alist);
1154 float q = va_arg_float(alist);
1155 long s = va_arg_long(alist);
1156 long t = va_arg_long(alist);
1157 long u = va_arg_long(alist);
1158 L z = va_arg_struct(alist, L);
1159 float r = a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+s+t+u+z.l1+z.l2+z.l3+z.l4+z.l5+z.l6;
1160 fprintf(out,"float f(17*float,3*int,L):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,z.l1,z.l2,z.l3,z.l4,z.l5,z.l6);
1161 fflush(out);
1162 va_return_float(alist, r);
1163 }}
1164 else if (current_function == (void*)&d_d17l3L)
1165 {
1166 va_start_double(alist);
1167 {double a = va_arg_double(alist);
1168 double b = va_arg_double(alist);
1169 double c = va_arg_double(alist);
1170 double d = va_arg_double(alist);
1171 double e = va_arg_double(alist);
1172 double f = va_arg_double(alist);
1173 double g = va_arg_double(alist);
1174 double h = va_arg_double(alist);
1175 double i = va_arg_double(alist);
1176 double j = va_arg_double(alist);
1177 double k = va_arg_double(alist);
1178 double l = va_arg_double(alist);
1179 double m = va_arg_double(alist);
1180 double n = va_arg_double(alist);
1181 double o = va_arg_double(alist);
1182 double p = va_arg_double(alist);
1183 double q = va_arg_double(alist);
1184 long s = va_arg_long(alist);
1185 long t = va_arg_long(alist);
1186 long u = va_arg_long(alist);
1187 L z = va_arg_struct(alist, L);
1188 double r = a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+s+t+u+z.l1+z.l2+z.l3+z.l4+z.l5+z.l6;
1189 fprintf(out,"double f(17*double,3*int,L):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,z.l1,z.l2,z.l3,z.l4,z.l5,z.l6);
1190 fflush(out);
1191 va_return_double(alist, r);
1192 }}
1193 else if (current_function == (void*)&ll_l2ll)
1194 {
1195 va_start_longlong(alist);
1196 {long a1 = va_arg_long(alist);
1197 long a2 = va_arg_long(alist);
1198 long long b = va_arg_longlong(alist);
1199 long c = va_arg_long(alist);
1200 long long r = (long long) (a1 + a2) + b + c;
1201 fprintf(out,"long long f(2*long,long long,long):(%ld,%ld,0x%lx%08lx,%ld)",a1,a2,(long)(b>>32),(long)(b&0xffffffff),c);
1202 fflush(out);
1203 va_return_longlong(alist, r);
1204 }}
1205 else if (current_function == (void*)&ll_l3ll)
1206 {
1207 va_start_longlong(alist);
1208 {long a1 = va_arg_long(alist);
1209 long a2 = va_arg_long(alist);
1210 long a3 = va_arg_long(alist);
1211 long long b = va_arg_longlong(alist);
1212 long c = va_arg_long(alist);
1213 long long r = (long long) (a1 + a2 + a3) + b + c;
1214 fprintf(out,"long long f(3*long,long long,long):(%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,(long)(b>>32),(long)(b&0xffffffff),c);
1215 fflush(out);
1216 va_return_longlong(alist, r);
1217 }}
1218 else if (current_function == (void*)&ll_l4ll)
1219 {
1220 va_start_longlong(alist);
1221 {long a1 = va_arg_long(alist);
1222 long a2 = va_arg_long(alist);
1223 long a3 = va_arg_long(alist);
1224 long a4 = va_arg_long(alist);
1225 long long b = va_arg_longlong(alist);
1226 long c = va_arg_long(alist);
1227 long long r = (long long) (a1 + a2 + a3 + a4) + b + c;
1228 fprintf(out,"long long f(4*long,long long,long):(%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,(long)(b>>32),(long)(b&0xffffffff),c);
1229 fflush(out);
1230 va_return_longlong(alist, r);
1231 }}
1232 else if (current_function == (void*)&ll_l5ll)
1233 {
1234 va_start_longlong(alist);
1235 {long a1 = va_arg_long(alist);
1236 long a2 = va_arg_long(alist);
1237 long a3 = va_arg_long(alist);
1238 long a4 = va_arg_long(alist);
1239 long a5 = va_arg_long(alist);
1240 long long b = va_arg_longlong(alist);
1241 long c = va_arg_long(alist);
1242 long long r = (long long) (a1 + a2 + a3 + a4 + a5) + b + c;
1243 fprintf(out,"long long f(5*long,long long,long):(%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,(long)(b>>32),(long)(b&0xffffffff),c);
1244 fflush(out);
1245 va_return_longlong(alist, r);
1246 }}
1247 else if (current_function == (void*)&ll_l6ll)
1248 {
1249 va_start_longlong(alist);
1250 {long a1 = va_arg_long(alist);
1251 long a2 = va_arg_long(alist);
1252 long a3 = va_arg_long(alist);
1253 long a4 = va_arg_long(alist);
1254 long a5 = va_arg_long(alist);
1255 long a6 = va_arg_long(alist);
1256 long long b = va_arg_longlong(alist);
1257 long c = va_arg_long(alist);
1258 long long r = (long long) (a1 + a2 + a3 + a4 + a5 + a6) + b + c;
1259 fprintf(out,"long long f(6*long,long long,long):(%ld,%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,a6,(long)(b>>32),(long)(b&0xffffffff),c);
1260 fflush(out);
1261 va_return_longlong(alist, r);
1262 }}
1263 else if (current_function == (void*)&ll_l7ll)
1264 {
1265 va_start_longlong(alist);
1266 {long a1 = va_arg_long(alist);
1267 long a2 = va_arg_long(alist);
1268 long a3 = va_arg_long(alist);
1269 long a4 = va_arg_long(alist);
1270 long a5 = va_arg_long(alist);
1271 long a6 = va_arg_long(alist);
1272 long a7 = va_arg_long(alist);
1273 long long b = va_arg_longlong(alist);
1274 long c = va_arg_long(alist);
1275 long long r = (long long) (a1 + a2 + a3 + a4 + a5 + a6 + a7) + b + c;
1276 fprintf(out,"long long f(7*long,long long,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,a6,a7,(long)(b>>32),(long)(b&0xffffffff),c);
1277 fflush(out);
1278 va_return_longlong(alist, r);
1279 }}
1280 else if (current_function == (void*)&d_l2d)
1281 {
1282 va_start_double(alist);
1283 {long a1 = va_arg_long(alist);
1284 long a2 = va_arg_long(alist);
1285 double b = va_arg_double(alist);
1286 long c = va_arg_long(alist);
1287 double r = (double) (a1 + a2) + b + c;
1288 fprintf(out,"double f(2*long,double,long):(%ld,%ld,%g,%ld)",a1,a2,b,c);
1289 fflush(out);
1290 va_return_double(alist, r);
1291 }}
1292 else if (current_function == (void*)&d_l3d)
1293 {
1294 va_start_double(alist);
1295 {long a1 = va_arg_long(alist);
1296 long a2 = va_arg_long(alist);
1297 long a3 = va_arg_long(alist);
1298 double b = va_arg_double(alist);
1299 long c = va_arg_long(alist);
1300 double r = (double) (a1 + a2 + a3) + b + c;
1301 fprintf(out,"double f(3*long,double,long):(%ld,%ld,%ld,%g,%ld)",a1,a2,a3,b,c);
1302 fflush(out);
1303 va_return_double(alist, r);
1304 }}
1305 else if (current_function == (void*)&d_l4d)
1306 {
1307 va_start_double(alist);
1308 {long a1 = va_arg_long(alist);
1309 long a2 = va_arg_long(alist);
1310 long a3 = va_arg_long(alist);
1311 long a4 = va_arg_long(alist);
1312 double b = va_arg_double(alist);
1313 long c = va_arg_long(alist);
1314 double r = (double) (a1 + a2 + a3 + a4) + b + c;
1315 fprintf(out,"double f(4*long,double,long):(%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,b,c);
1316 fflush(out);
1317 va_return_double(alist, r);
1318 }}
1319 else if (current_function == (void*)&d_l5d)
1320 {
1321 va_start_double(alist);
1322 {long a1 = va_arg_long(alist);
1323 long a2 = va_arg_long(alist);
1324 long a3 = va_arg_long(alist);
1325 long a4 = va_arg_long(alist);
1326 long a5 = va_arg_long(alist);
1327 double b = va_arg_double(alist);
1328 long c = va_arg_long(alist);
1329 double r = (double) (a1 + a2 + a3 + a4 + a5) + b + c;
1330 fprintf(out,"double f(5*long,double,long):(%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,b,c);
1331 fflush(out);
1332 va_return_double(alist, r);
1333 }}
1334 else if (current_function == (void*)&d_l6d)
1335 {
1336 va_start_double(alist);
1337 {long a1 = va_arg_long(alist);
1338 long a2 = va_arg_long(alist);
1339 long a3 = va_arg_long(alist);
1340 long a4 = va_arg_long(alist);
1341 long a5 = va_arg_long(alist);
1342 long a6 = va_arg_long(alist);
1343 double b = va_arg_double(alist);
1344 long c = va_arg_long(alist);
1345 double r = (double) (a1 + a2 + a3 + a4 + a5 + a6) + b + c;
1346 fprintf(out,"double f(6*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,b,c);
1347 fflush(out);
1348 va_return_double(alist, r);
1349 }}
1350 else if (current_function == (void*)&d_l7d)
1351 {
1352 va_start_double(alist);
1353 {long a1 = va_arg_long(alist);
1354 long a2 = va_arg_long(alist);
1355 long a3 = va_arg_long(alist);
1356 long a4 = va_arg_long(alist);
1357 long a5 = va_arg_long(alist);
1358 long a6 = va_arg_long(alist);
1359 long a7 = va_arg_long(alist);
1360 double b = va_arg_double(alist);
1361 long c = va_arg_long(alist);
1362 double r = (double) (a1 + a2 + a3 + a4 + a5 + a6 + a7) + b + c;
1363 fprintf(out,"double f(7*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,a7,b,c);
1364 fflush(out);
1365 va_return_double(alist, r);
1366 }}
1367
1368 /* by-value tests */
1369 else if (current_function == (void*)&v_clobber_K)
1370 {
1371 va_start_void(alist);
1372 {K k = va_arg_struct(alist, K);
1373 k.l1 += 1;
1374 k.l2 += 10;
1375 k.l3 += 100;
1376 k.l4 += 1000;
1377 va_return_void(alist);
1378 }}
1379
1380 else
1381 {
1382 fprintf(out,"simulate: unknown function\n");
1383 fflush(out);
1384 }
1385 }
1386
1387
1388 /*
1389 * The way we run these tests - first call the function directly, then
1390 * through vacall() - there is the danger that arguments or results seem
1391 * to be passed correctly, but what we are seeing are in fact the vestiges
1392 * (traces) or the previous call. This may seriously fake the test.
1393 * Avoid this by clearing the registers between the first and the second call.
1394 */
clear_traces_i(long a,long b,long c,long d,long e,long f,long g,long h,long i,long j,long k,long l,long m,long n,long o,long p)1395 long clear_traces_i (long a, long b, long c, long d, long e, long f, long g, long h,
1396 long i, long j, long k, long l, long m, long n, long o, long p)
1397 { return 0; }
clear_traces_f(float a,float b,float c,float d,float e,float f,float g,float h,float i,float j,float k,float l,float m,float n,float o,float p)1398 float clear_traces_f (float a, float b, float c, float d, float e, float f, float g,
1399 float h, float i, float j, float k, float l, float m, float n,
1400 float o, float p)
1401 { return 0.0; }
clear_traces_d(double a,double b,double c,double d,double e,double f,double g,double h,double i,double j,double k,double l,double m,double n,double o,double p)1402 double clear_traces_d (double a, double b, double c, double d, double e, double f, double g,
1403 double h, double i, double j, double k, double l, double m, double n,
1404 double o, double p)
1405 { return 0.0; }
clear_traces_J(void)1406 J clear_traces_J (void)
1407 { J j; j.l1 = j.l2 = 0; return j; }
clear_traces(void)1408 void clear_traces (void)
1409 { clear_traces_i(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
1410 clear_traces_f(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0);
1411 clear_traces_d(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0);
1412 clear_traces_J();
1413 }
1414
main(void)1415 int main (void)
1416 {
1417 out = stdout;
1418
1419 vacall_function = &simulator;
1420
1421 /* void tests */
1422 v_v();
1423 clear_traces();
1424 current_function = (void*) &v_v; ((void (*) (void)) vacall) ();
1425
1426 /* int tests */
1427 { int ir;
1428
1429 ir = i_v();
1430 fprintf(out,"->%d\n",ir);
1431 fflush(out);
1432 ir = 0; clear_traces();
1433 current_function = (void*) &i_v; ir = ((int (*) (void)) vacall) ();
1434 fprintf(out,"->%d\n",ir);
1435 fflush(out);
1436
1437 ir = i_i(i1);
1438 fprintf(out,"->%d\n",ir);
1439 fflush(out);
1440 ir = 0; clear_traces();
1441 current_function = (void*) &i_i; ir = ((int (*) (int)) vacall) (i1);
1442 fprintf(out,"->%d\n",ir);
1443 fflush(out);
1444
1445 ir = i_i2(i1,i2);
1446 fprintf(out,"->%d\n",ir);
1447 fflush(out);
1448 ir = 0; clear_traces();
1449 current_function = (void*) &i_i2; ir = ((int (*) (int,int)) vacall) (i1,i2);
1450 fprintf(out,"->%d\n",ir);
1451 fflush(out);
1452
1453 ir = i_i4(i1,i2,i3,i4);
1454 fprintf(out,"->%d\n",ir);
1455 fflush(out);
1456 ir = 0; clear_traces();
1457 current_function = (void*) &i_i4; ir = ((int (*) (int,int,int,int)) vacall) (i1,i2,i3,i4);
1458 fprintf(out,"->%d\n",ir);
1459 fflush(out);
1460
1461 ir = i_i8(i1,i2,i3,i4,i5,i6,i7,i8);
1462 fprintf(out,"->%d\n",ir);
1463 fflush(out);
1464 ir = 0; clear_traces();
1465 current_function = (void*) &i_i8; ir = ((int (*) (int,int,int,int,int,int,int,int)) vacall) (i1,i2,i3,i4,i5,i6,i7,i8);
1466 fprintf(out,"->%d\n",ir);
1467 fflush(out);
1468
1469 ir = i_i16(i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16);
1470 fprintf(out,"->%d\n",ir);
1471 fflush(out);
1472 ir = 0; clear_traces();
1473 current_function = (void*) &i_i16; ir = ((int (*) (int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int)) vacall) (i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16);
1474 fprintf(out,"->%d\n",ir);
1475 fflush(out);
1476
1477 ir = i_i32(i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16,i17,i18,i19,i20,i21,i22,i23,i24,i25,i26,i27,i28,i29,i30,i31,i32);
1478 fprintf(out,"->%d\n",ir);
1479 fflush(out);
1480 ir = 0; clear_traces();
1481 current_function = (void*) &i_i32; ir = ((int (*) (int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int)) vacall) (i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16,i17,i18,i19,i20,i21,i22,i23,i24,i25,i26,i27,i28,i29,i30,i31,i32);
1482 fprintf(out,"->%d\n",ir);
1483 fflush(out);
1484 }
1485
1486 /* float tests */
1487 { float fr;
1488
1489 fr = f_f(f1);
1490 fprintf(out,"->%g\n",fr);
1491 fflush(out);
1492 fr = 0.0; clear_traces();
1493 current_function = (void*) &f_f; fr = ((float (*) (float)) vacall) (f1);
1494 fprintf(out,"->%g\n",fr);
1495 fflush(out);
1496
1497 fr = f_f2(f1,f2);
1498 fprintf(out,"->%g\n",fr);
1499 fflush(out);
1500 fr = 0.0; clear_traces();
1501 current_function = (void*) &f_f2; fr = ((float (*) (float,float)) vacall) (f1,f2);
1502 fprintf(out,"->%g\n",fr);
1503 fflush(out);
1504
1505 fr = f_f4(f1,f2,f3,f4);
1506 fprintf(out,"->%g\n",fr);
1507 fflush(out);
1508 fr = 0.0; clear_traces();
1509 current_function = (void*) &f_f4; fr = ((float (*) (float,float,float,float)) vacall) (f1,f2,f3,f4);
1510 fprintf(out,"->%g\n",fr);
1511 fflush(out);
1512
1513 fr = f_f8(f1,f2,f3,f4,f5,f6,f7,f8);
1514 fprintf(out,"->%g\n",fr);
1515 fflush(out);
1516 fr = 0.0; clear_traces();
1517 current_function = (void*) &f_f8; fr = ((float (*) (float,float,float,float,float,float,float,float)) vacall) (f1,f2,f3,f4,f5,f6,f7,f8);
1518 fprintf(out,"->%g\n",fr);
1519 fflush(out);
1520
1521 fr = f_f16(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16);
1522 fprintf(out,"->%g\n",fr);
1523 fflush(out);
1524 fr = 0.0; clear_traces();
1525 current_function = (void*) &f_f16; fr = ((float (*) (float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)) vacall) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16);
1526 fprintf(out,"->%g\n",fr);
1527 fflush(out);
1528
1529 fr = f_f24(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18,f19,f20,f21,f22,f23,f24);
1530 fprintf(out,"->%g\n",fr);
1531 fflush(out);
1532 fr = 0.0; clear_traces();
1533 current_function = (void*) &f_f24; fr = ((float (*) (float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)) vacall) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18,f19,f20,f21,f22,f23,f24);
1534 fprintf(out,"->%g\n",fr);
1535 fflush(out);
1536 }
1537
1538 /* double tests */
1539 { double dr;
1540
1541 dr = d_d(d1);
1542 fprintf(out,"->%g\n",dr);
1543 fflush(out);
1544 dr = 0.0; clear_traces();
1545 current_function = (void*) &d_d; dr = ((double (*) (double)) vacall) (d1);
1546 fprintf(out,"->%g\n",dr);
1547 fflush(out);
1548
1549 dr = d_d2(d1,d2);
1550 fprintf(out,"->%g\n",dr);
1551 fflush(out);
1552 dr = 0.0; clear_traces();
1553 current_function = (void*) &d_d2; dr = ((double (*) (double,double)) vacall) (d1,d2);
1554 fprintf(out,"->%g\n",dr);
1555 fflush(out);
1556
1557 dr = d_d4(d1,d2,d3,d4);
1558 fprintf(out,"->%g\n",dr);
1559 fflush(out);
1560 dr = 0.0; clear_traces();
1561 current_function = (void*) &d_d4; dr = ((double (*) (double,double,double,double)) vacall) (d1,d2,d3,d4);
1562 fprintf(out,"->%g\n",dr);
1563 fflush(out);
1564
1565 dr = d_d8(d1,d2,d3,d4,d5,d6,d7,d8);
1566 fprintf(out,"->%g\n",dr);
1567 fflush(out);
1568 dr = 0.0; clear_traces();
1569 current_function = (void*) &d_d8; dr = ((double (*) (double,double,double,double,double,double,double,double)) vacall) (d1,d2,d3,d4,d5,d6,d7,d8);
1570 fprintf(out,"->%g\n",dr);
1571 fflush(out);
1572
1573 dr = d_d16(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16);
1574 fprintf(out,"->%g\n",dr);
1575 fflush(out);
1576 dr = 0.0; clear_traces();
1577 current_function = (void*) &d_d16; dr = ((double (*) (double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,double)) vacall) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16);
1578 fprintf(out,"->%g\n",dr);
1579 fflush(out);
1580 }
1581
1582 /* pointer tests */
1583 { void* vpr;
1584
1585 vpr = vp_vpdpcpsp(&uc1,&d2,str3,&I4);
1586 fprintf(out,"->0x%p\n",vpr);
1587 fflush(out);
1588 vpr = 0; clear_traces();
1589 current_function = (void*) &vp_vpdpcpsp; vpr = ((void* (*) (void*,double*,char*,Int*)) vacall) (&uc1,&d2,str3,&I4);
1590 fprintf(out,"->0x%p\n",vpr);
1591 fflush(out);
1592 }
1593
1594 /* mixed number tests */
1595 { uchar ucr;
1596 ushort usr;
1597 float fr;
1598 double dr;
1599 long long llr;
1600
1601 ucr = uc_ucsil(uc1,us2,ui3,ul4);
1602 fprintf(out,"->%u\n",ucr);
1603 fflush(out);
1604 ucr = 0; clear_traces();
1605 current_function = (void*) &uc_ucsil; ucr = ((uchar (*) (uchar,ushort,uint,ulong)) vacall) (uc1,us2,ui3,ul4);
1606 fprintf(out,"->%u\n",ucr);
1607 fflush(out);
1608
1609 dr = d_iidd(i1,i2,d3,d4);
1610 fprintf(out,"->%g\n",dr);
1611 fflush(out);
1612 dr = 0.0; clear_traces();
1613 current_function = (void*) &d_iidd; dr = ((double (*) (int,int,double,double)) vacall) (i1,i2,d3,d4);
1614 fprintf(out,"->%g\n",dr);
1615 fflush(out);
1616
1617 dr = d_iiidi(i1,i2,i3,d4,i5);
1618 fprintf(out,"->%g\n",dr);
1619 fflush(out);
1620 dr = 0.0; clear_traces();
1621 current_function = (void*) &d_iiidi; dr = ((double (*) (int,int,int,double,int)) vacall) (i1,i2,i3,d4,i5);
1622 fprintf(out,"->%g\n",dr);
1623 fflush(out);
1624
1625 dr = d_idid(i1,d2,i3,d4);
1626 fprintf(out,"->%g\n",dr);
1627 fflush(out);
1628 dr = 0.0; clear_traces();
1629 current_function = (void*) &d_idid; dr = ((double (*) (int,double,int,double)) vacall) (i1,d2,i3,d4);
1630 fprintf(out,"->%g\n",dr);
1631 fflush(out);
1632
1633 dr = d_fdi(f1,d2,i3);
1634 fprintf(out,"->%g\n",dr);
1635 fflush(out);
1636 dr = 0.0; clear_traces();
1637 current_function = (void*) &d_fdi; dr = ((double (*) (float,double,int)) vacall) (f1,d2,i3);
1638 fprintf(out,"->%g\n",dr);
1639 fflush(out);
1640
1641 usr = us_cdcd(c1,d2,c3,d4);
1642 fprintf(out,"->%u\n",usr);
1643 fflush(out);
1644 usr = 0; clear_traces();
1645 current_function = (void*) &us_cdcd; usr = ((ushort (*) (char,double,char,double)) vacall) (c1,d2,c3,d4);
1646 fprintf(out,"->%u\n",usr);
1647 fflush(out);
1648
1649 llr = ll_iiilli(i1,i2,i3,ll1,i13);
1650 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
1651 fflush(out);
1652 llr = 0; clear_traces();
1653 current_function = (void*) &ll_iiilli; llr = ((long long (*) (int,int,int,long long,int)) vacall) (i1,i2,i3,ll1,i13);
1654 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
1655 fflush(out);
1656
1657 llr = ll_flli(f13,ll1,i13);
1658 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
1659 fflush(out);
1660 llr = 0; clear_traces();
1661 current_function = (void*) &ll_flli; llr = ((long long (*) (float,long long,int)) vacall) (f13,ll1,i13);
1662 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
1663 fflush(out);
1664
1665 fr = f_fi(f1,i9);
1666 fprintf(out,"->%g\n",fr);
1667 fflush(out);
1668 fr = 0.0; clear_traces();
1669 current_function = (void*) &f_fi; fr = ((float (*) (float,int)) vacall) (f1,i9);
1670 fprintf(out,"->%g\n",fr);
1671 fflush(out);
1672
1673 fr = f_f2i(f1,f2,i9);
1674 fprintf(out,"->%g\n",fr);
1675 fflush(out);
1676 fr = 0.0; clear_traces();
1677 current_function = (void*) &f_f2i; fr = ((float (*) (float,float,int)) vacall) (f1,f2,i9);
1678 fprintf(out,"->%g\n",fr);
1679 fflush(out);
1680
1681 fr = f_f3i(f1,f2,f3,i9);
1682 fprintf(out,"->%g\n",fr);
1683 fflush(out);
1684 fr = 0.0; clear_traces();
1685 current_function = (void*) &f_f3i; fr = ((float (*) (float,float,float,int)) vacall) (f1,f2,f3,i9);
1686 fprintf(out,"->%g\n",fr);
1687 fflush(out);
1688
1689 fr = f_f4i(f1,f2,f3,f4,i9);
1690 fprintf(out,"->%g\n",fr);
1691 fflush(out);
1692 fr = 0.0; clear_traces();
1693 current_function = (void*) &f_f4i; fr = ((float (*) (float,float,float,float,int)) vacall) (f1,f2,f3,f4,i9);
1694 fprintf(out,"->%g\n",fr);
1695 fflush(out);
1696
1697 fr = f_f7i(f1,f2,f3,f4,f5,f6,f7,i9);
1698 fprintf(out,"->%g\n",fr);
1699 fflush(out);
1700 fr = 0.0; clear_traces();
1701 current_function = (void*) &f_f7i; fr = ((float (*) (float,float,float,float,float,float,float,int)) vacall) (f1,f2,f3,f4,f5,f6,f7,i9);
1702 fprintf(out,"->%g\n",fr);
1703 fflush(out);
1704
1705 fr = f_f8i(f1,f2,f3,f4,f5,f6,f7,f8,i9);
1706 fprintf(out,"->%g\n",fr);
1707 fflush(out);
1708 fr = 0.0; clear_traces();
1709 current_function = (void*) &f_f8i; fr = ((float (*) (float,float,float,float,float,float,float,float,int)) vacall) (f1,f2,f3,f4,f5,f6,f7,f8,i9);
1710 fprintf(out,"->%g\n",fr);
1711 fflush(out);
1712
1713 fr = f_f12i(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,i9);
1714 fprintf(out,"->%g\n",fr);
1715 fflush(out);
1716 fr = 0.0; clear_traces();
1717 current_function = (void*) &f_f12i; fr = ((float (*) (float,float,float,float,float,float,float,float,float,float,float,float,int)) vacall) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,i9);
1718 fprintf(out,"->%g\n",fr);
1719 fflush(out);
1720
1721 fr = f_f13i(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,i9);
1722 fprintf(out,"->%g\n",fr);
1723 fflush(out);
1724 fr = 0.0; clear_traces();
1725 current_function = (void*) &f_f13i; fr = ((float (*) (float,float,float,float,float,float,float,float,float,float,float,float,float,int)) vacall) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,i9);
1726 fprintf(out,"->%g\n",fr);
1727 fflush(out);
1728
1729 dr = d_di(d1,i9);
1730 fprintf(out,"->%g\n",dr);
1731 fflush(out);
1732 dr = 0.0; clear_traces();
1733 current_function = (void*) &d_di; dr = ((double (*) (double,int)) vacall) (d1,i9);
1734 fprintf(out,"->%g\n",dr);
1735 fflush(out);
1736
1737 dr = d_d2i(d1,d2,i9);
1738 fprintf(out,"->%g\n",dr);
1739 fflush(out);
1740 dr = 0.0; clear_traces();
1741 current_function = (void*) &d_d2i; dr = ((double (*) (double,double,int)) vacall) (d1,d2,i9);
1742 fprintf(out,"->%g\n",dr);
1743 fflush(out);
1744
1745 dr = d_d3i(d1,d2,d3,i9);
1746 fprintf(out,"->%g\n",dr);
1747 fflush(out);
1748 dr = 0.0; clear_traces();
1749 current_function = (void*) &d_d3i; dr = ((double (*) (double,double,double,int)) vacall) (d1,d2,d3,i9);
1750 fprintf(out,"->%g\n",dr);
1751 fflush(out);
1752
1753 dr = d_d4i(d1,d2,d3,d4,i9);
1754 fprintf(out,"->%g\n",dr);
1755 fflush(out);
1756 dr = 0.0; clear_traces();
1757 current_function = (void*) &d_d4i; dr = ((double (*) (double,double,double,double,int)) vacall) (d1,d2,d3,d4,i9);
1758 fprintf(out,"->%g\n",dr);
1759 fflush(out);
1760
1761 dr = d_d7i(d1,d2,d3,d4,d5,d6,d7,i9);
1762 fprintf(out,"->%g\n",dr);
1763 fflush(out);
1764 dr = 0.0; clear_traces();
1765 current_function = (void*) &d_d7i; dr = ((double (*) (double,double,double,double,double,double,double,int)) vacall) (d1,d2,d3,d4,d5,d6,d7,i9);
1766 fprintf(out,"->%g\n",dr);
1767 fflush(out);
1768
1769 dr = d_d8i(d1,d2,d3,d4,d5,d6,d7,d8,i9);
1770 fprintf(out,"->%g\n",dr);
1771 fflush(out);
1772 dr = 0.0; clear_traces();
1773 current_function = (void*) &d_d8i; dr = ((double (*) (double,double,double,double,double,double,double,double,int)) vacall) (d1,d2,d3,d4,d5,d6,d7,d8,i9);
1774 fprintf(out,"->%g\n",dr);
1775 fflush(out);
1776
1777 dr = d_d12i(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,i9);
1778 fprintf(out,"->%g\n",dr);
1779 fflush(out);
1780 dr = 0.0; clear_traces();
1781 current_function = (void*) &d_d12i; dr = ((double (*) (double,double,double,double,double,double,double,double,double,double,double,double,int)) vacall) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,i9);
1782 fprintf(out,"->%g\n",dr);
1783 fflush(out);
1784
1785 dr = d_d13i(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,i9);
1786 fprintf(out,"->%g\n",dr);
1787 fflush(out);
1788 dr = 0.0; clear_traces();
1789 current_function = (void*) &d_d13i; dr = ((double (*) (double,double,double,double,double,double,double,double,double,double,double,double,double,int)) vacall) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,i9);
1790 fprintf(out,"->%g\n",dr);
1791 fflush(out);
1792 }
1793
1794 /* small structure return tests */
1795 {
1796 Size1 r = S1_v();
1797 fprintf(out,"->{%c}\n",r.x1);
1798 fflush(out);
1799 memset(&r,0,sizeof(r)); clear_traces();
1800 current_function = (void*) &S1_v; r = ((Size1 (*) (void)) vacall) ();
1801 fprintf(out,"->{%c}\n",r.x1);
1802 fflush(out);
1803 }
1804 {
1805 Size2 r = S2_v();
1806 fprintf(out,"->{%c%c}\n",r.x1,r.x2);
1807 fflush(out);
1808 memset(&r,0,sizeof(r)); clear_traces();
1809 current_function = (void*) &S2_v; r = ((Size2 (*) (void)) vacall) ();
1810 fprintf(out,"->{%c%c}\n",r.x1,r.x2);
1811 fflush(out);
1812 }
1813 {
1814 Size3 r = S3_v();
1815 fprintf(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
1816 fflush(out);
1817 memset(&r,0,sizeof(r)); clear_traces();
1818 current_function = (void*) &S3_v; r = ((Size3 (*) (void)) vacall) ();
1819 fprintf(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
1820 fflush(out);
1821 }
1822 {
1823 Size4 r = S4_v();
1824 fprintf(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
1825 fflush(out);
1826 memset(&r,0,sizeof(r)); clear_traces();
1827 current_function = (void*) &S4_v; r = ((Size4 (*) (void)) vacall) ();
1828 fprintf(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
1829 fflush(out);
1830 }
1831 {
1832 Size7 r = S7_v();
1833 fprintf(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
1834 fflush(out);
1835 memset(&r,0,sizeof(r)); clear_traces();
1836 current_function = (void*) &S7_v; r = ((Size7 (*) (void)) vacall) ();
1837 fprintf(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
1838 fflush(out);
1839 }
1840 {
1841 Size8 r = S8_v();
1842 fprintf(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
1843 fflush(out);
1844 memset(&r,0,sizeof(r)); clear_traces();
1845 current_function = (void*) &S8_v; r = ((Size8 (*) (void)) vacall) ();
1846 fprintf(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
1847 fflush(out);
1848 }
1849 {
1850 Size12 r = S12_v();
1851 fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
1852 fflush(out);
1853 memset(&r,0,sizeof(r)); clear_traces();
1854 current_function = (void*) &S12_v; r = ((Size12 (*) (void)) vacall) ();
1855 fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
1856 fflush(out);
1857 }
1858 {
1859 Size15 r = S15_v();
1860 fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
1861 fflush(out);
1862 memset(&r,0,sizeof(r)); clear_traces();
1863 current_function = (void*) &S15_v; r = ((Size15 (*) (void)) vacall) ();
1864 fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
1865 fflush(out);
1866 }
1867 {
1868 Size16 r = S16_v();
1869 fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
1870 fflush(out);
1871 memset(&r,0,sizeof(r)); clear_traces();
1872 current_function = (void*) &S16_v; r = ((Size16 (*) (void)) vacall) ();
1873 fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
1874 fflush(out);
1875 }
1876
1877 /* structure tests */
1878 { Int Ir;
1879 Char Cr;
1880 Float Fr;
1881 Double Dr;
1882 J Jr;
1883 T Tr;
1884 X Xr;
1885
1886 Ir = I_III(I1,I2,I3);
1887 fprintf(out,"->{%d}\n",Ir.x);
1888 fflush(out);
1889 Ir.x = 0; clear_traces();
1890 current_function = (void*) &I_III; Ir = ((Int (*) (Int,Int,Int)) vacall) (I1,I2,I3);
1891 fprintf(out,"->{%d}\n",Ir.x);
1892 fflush(out);
1893
1894 #ifndef SKIP_EXTRA_STRUCTS
1895 Cr = C_CdC(C1,d2,C3);
1896 fprintf(out,"->{'%c'}\n",Cr.x);
1897 fflush(out);
1898 Cr.x = '\0'; clear_traces();
1899 current_function = (void*) &C_CdC; Cr = ((Char (*) (Char,double,Char)) vacall) (C1,d2,C3);
1900 fprintf(out,"->{'%c'}\n",Cr.x);
1901 fflush(out);
1902
1903 Fr = F_Ffd(F1,f2,d3);
1904 fprintf(out,"->{%g}\n",Fr.x);
1905 fflush(out);
1906 Fr.x = 0.0; clear_traces();
1907 current_function = (void*) &F_Ffd; Fr = ((Float (*) (Float,float,double)) vacall) (F1,f2,d3);
1908 fprintf(out,"->{%g}\n",Fr.x);
1909 fflush(out);
1910
1911 Dr = D_fDd(f1,D2,d3);
1912 fprintf(out,"->{%g}\n",Dr.x);
1913 fflush(out);
1914 Dr.x = 0.0; clear_traces();
1915 current_function = (void*) &D_fDd; Dr = ((Double (*) (float,Double,double)) vacall) (f1,D2,d3);
1916 fprintf(out,"->{%g}\n",Dr.x);
1917 fflush(out);
1918
1919 Dr = D_Dfd(D1,f2,d3);
1920 fprintf(out,"->{%g}\n",Dr.x);
1921 fflush(out);
1922 Dr.x = 0.0; clear_traces();
1923 current_function = (void*) &D_Dfd; Dr = ((Double (*) (Double,float,double)) vacall) (D1,f2,d3);
1924 fprintf(out,"->{%g}\n",Dr.x);
1925 fflush(out);
1926 #endif
1927
1928 Jr = J_JiJ(J1,i2,J2);
1929 fprintf(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
1930 fflush(out);
1931 Jr.l1 = Jr.l2 = 0; clear_traces();
1932 current_function = (void*) &J_JiJ; Jr = ((J (*) (J,int,J)) vacall) (J1,i2,J2);
1933 fprintf(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
1934 fflush(out);
1935
1936 #ifndef SKIP_EXTRA_STRUCTS
1937 #ifndef SKIP_T
1938 Tr = T_TcT(T1,' ',T2);
1939 fprintf(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
1940 fflush(out);
1941 Tr.c[0] = Tr.c[1] = Tr.c[2] = 0; clear_traces();
1942 current_function = (void*) &T_TcT; Tr = ((T (*) (T,char,T)) vacall) (T1,' ',T2);
1943 fprintf(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
1944 fflush(out);
1945 #endif
1946
1947 #ifndef SKIP_X
1948 Xr = X_BcdB(B1,c2,d3,B2);
1949 fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
1950 fflush(out);
1951 Xr.c[0]=Xr.c1='\0'; clear_traces();
1952 current_function = (void*) &X_BcdB; Xr = ((X (*) (B,char,double,B)) vacall) (B1,c2,d3,B2);
1953 fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
1954 fflush(out);
1955 #endif
1956 #endif
1957 }
1958
1959 /* gpargs boundary tests */
1960 { long lr;
1961 long long llr;
1962 float fr;
1963 double dr;
1964
1965 lr = l_l0J(J1,l9);
1966 fprintf(out,"->%ld\n",lr);
1967 fflush(out);
1968 lr = 0; clear_traces();
1969 current_function = (void*) &l_l0J; lr = ((long (*) (J,long)) vacall) (J1,l9);
1970 fprintf(out,"->%ld\n",lr);
1971 fflush(out);
1972
1973 lr = l_l1J(l1,J1,l9);
1974 fprintf(out,"->%ld\n",lr);
1975 fflush(out);
1976 lr = 0; clear_traces();
1977 current_function = (void*) &l_l1J; lr = ((long (*) (long,J,long)) vacall) (l1,J1,l9);
1978 fprintf(out,"->%ld\n",lr);
1979 fflush(out);
1980
1981 lr = l_l2J(l1,l2,J1,l9);
1982 fprintf(out,"->%ld\n",lr);
1983 fflush(out);
1984 lr = 0; clear_traces();
1985 current_function = (void*) &l_l2J; lr = ((long (*) (long,long,J,long)) vacall) (l1,l2,J1,l9);
1986 fprintf(out,"->%ld\n",lr);
1987 fflush(out);
1988
1989 lr = l_l3J(l1,l2,l3,J1,l9);
1990 fprintf(out,"->%ld\n",lr);
1991 fflush(out);
1992 lr = 0; clear_traces();
1993 current_function = (void*) &l_l3J; lr = ((long (*) (long,long,long,J,long)) vacall) (l1,l2,l3,J1,l9);
1994 fprintf(out,"->%ld\n",lr);
1995 fflush(out);
1996
1997 lr = l_l4J(l1,l2,l3,l4,J1,l9);
1998 fprintf(out,"->%ld\n",lr);
1999 fflush(out);
2000 lr = 0; clear_traces();
2001 current_function = (void*) &l_l4J; lr = ((long (*) (long,long,long,long,J,long)) vacall) (l1,l2,l3,l4,J1,l9);
2002 fprintf(out,"->%ld\n",lr);
2003 fflush(out);
2004
2005 lr = l_l5J(l1,l2,l3,l4,l5,J1,l9);
2006 fprintf(out,"->%ld\n",lr);
2007 fflush(out);
2008 lr = 0; clear_traces();
2009 current_function = (void*) &l_l5J; lr = ((long (*) (long,long,long,long,long,J,long)) vacall) (l1,l2,l3,l4,l5,J1,l9);
2010 fprintf(out,"->%ld\n",lr);
2011 fflush(out);
2012
2013 lr = l_l6J(l1,l2,l3,l4,l5,l6,J1,l9);
2014 fprintf(out,"->%ld\n",lr);
2015 fflush(out);
2016 lr = 0; clear_traces();
2017 current_function = (void*) &l_l6J; lr = ((long (*) (long,long,long,long,long,long,J,long)) vacall) (l1,l2,l3,l4,l5,l6,J1,l9);
2018 fprintf(out,"->%ld\n",lr);
2019 fflush(out);
2020
2021 lr = l_l7J(l1,l2,l3,l4,l5,l6,l7,J1,l9);
2022 fprintf(out,"->%ld\n",lr);
2023 fflush(out);
2024 lr = 0; clear_traces();
2025 current_function = (void*) &l_l7J; lr = ((long (*) (long,long,long,long,long,long,long,J,long)) vacall) (l1,l2,l3,l4,l5,l6,l7,J1,l9);
2026 fprintf(out,"->%ld\n",lr);
2027 fflush(out);
2028
2029 lr = l_l0K(K1,l9);
2030 fprintf(out,"->%ld\n",lr);
2031 fflush(out);
2032 lr = 0; clear_traces();
2033 current_function = (void*) &l_l0K; lr = ((long (*) (K,long)) vacall) (K1,l9);
2034 fprintf(out,"->%ld\n",lr);
2035 fflush(out);
2036
2037 lr = l_l1K(l1,K1,l9);
2038 fprintf(out,"->%ld\n",lr);
2039 fflush(out);
2040 lr = 0; clear_traces();
2041 current_function = (void*) &l_l1K; lr = ((long (*) (long,K,long)) vacall) (l1,K1,l9);
2042 fprintf(out,"->%ld\n",lr);
2043 fflush(out);
2044
2045 lr = l_l2K(l1,l2,K1,l9);
2046 fprintf(out,"->%ld\n",lr);
2047 fflush(out);
2048 lr = 0; clear_traces();
2049 current_function = (void*) &l_l2K; lr = ((long (*) (long,long,K,long)) vacall) (l1,l2,K1,l9);
2050 fprintf(out,"->%ld\n",lr);
2051 fflush(out);
2052
2053 lr = l_l3K(l1,l2,l3,K1,l9);
2054 fprintf(out,"->%ld\n",lr);
2055 fflush(out);
2056 lr = 0; clear_traces();
2057 current_function = (void*) &l_l3K; lr = ((long (*) (long,long,long,K,long)) vacall) (l1,l2,l3,K1,l9);
2058 fprintf(out,"->%ld\n",lr);
2059 fflush(out);
2060
2061 lr = l_l4K(l1,l2,l3,l4,K1,l9);
2062 fprintf(out,"->%ld\n",lr);
2063 fflush(out);
2064 lr = 0; clear_traces();
2065 current_function = (void*) &l_l4K; lr = ((long (*) (long,long,long,long,K,long)) vacall) (l1,l2,l3,l4,K1,l9);
2066 fprintf(out,"->%ld\n",lr);
2067 fflush(out);
2068
2069 lr = l_l5K(l1,l2,l3,l4,l5,K1,l9);
2070 fprintf(out,"->%ld\n",lr);
2071 fflush(out);
2072 lr = 0; clear_traces();
2073 current_function = (void*) &l_l5K; lr = ((long (*) (long,long,long,long,long,K,long)) vacall) (l1,l2,l3,l4,l5,K1,l9);
2074 fprintf(out,"->%ld\n",lr);
2075 fflush(out);
2076
2077 lr = l_l6K(l1,l2,l3,l4,l5,l6,K1,l9);
2078 fprintf(out,"->%ld\n",lr);
2079 fflush(out);
2080 lr = 0; clear_traces();
2081 current_function = (void*) &l_l6K; lr = ((long (*) (long,long,long,long,long,long,K,long)) vacall) (l1,l2,l3,l4,l5,l6,K1,l9);
2082 fprintf(out,"->%ld\n",lr);
2083 fflush(out);
2084
2085 fr = f_f17l3L(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,l6,l7,l8,L1);
2086 fprintf(out,"->%g\n",fr);
2087 fflush(out);
2088 fr = 0.0; clear_traces();
2089 current_function = (void*) &f_f17l3L; fr = ((float (*) (float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,long,long,long,L)) vacall) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,l6,l7,l8,L1);
2090 fprintf(out,"->%g\n",fr);
2091 fflush(out);
2092
2093 dr = d_d17l3L(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,d17,l6,l7,l8,L1);
2094 fprintf(out,"->%g\n",dr);
2095 fflush(out);
2096 dr = 0.0; clear_traces();
2097 current_function = (void*) &d_d17l3L; dr = ((double (*) (double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,long,long,long,L)) vacall) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,d17,l6,l7,l8,L1);
2098 fprintf(out,"->%g\n",dr);
2099 fflush(out);
2100
2101 llr = ll_l2ll(l1,l2,ll1,l9);
2102 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2103 fflush(out);
2104 llr = 0; clear_traces();
2105 current_function = (void*) &ll_l2ll; llr = ((long long (*) (long,long,long long,long)) vacall) (l1,l2,ll1,l9);
2106 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2107 fflush(out);
2108
2109 llr = ll_l3ll(l1,l2,l3,ll1,l9);
2110 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2111 fflush(out);
2112 llr = 0; clear_traces();
2113 current_function = (void*) &ll_l3ll; llr = ((long long (*) (long,long,long,long long,long)) vacall) (l1,l2,l3,ll1,l9);
2114 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2115 fflush(out);
2116
2117 llr = ll_l4ll(l1,l2,l3,l4,ll1,l9);
2118 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2119 fflush(out);
2120 llr = 0; clear_traces();
2121 current_function = (void*) &ll_l4ll; llr = ((long long (*) (long,long,long,long,long long,long)) vacall) (l1,l2,l3,l4,ll1,l9);
2122 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2123 fflush(out);
2124
2125 llr = ll_l5ll(l1,l2,l3,l4,l5,ll1,l9);
2126 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2127 fflush(out);
2128 llr = 0; clear_traces();
2129 current_function = (void*) &ll_l5ll; llr = ((long long (*) (long,long,long,long,long,long long,long)) vacall) (l1,l2,l3,l4,l5,ll1,l9);
2130 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2131 fflush(out);
2132
2133 llr = ll_l6ll(l1,l2,l3,l4,l5,l6,ll1,l9);
2134 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2135 fflush(out);
2136 llr = 0; clear_traces();
2137 current_function = (void*) &ll_l6ll; llr = ((long long (*) (long,long,long,long,long,long,long long,long)) vacall) (l1,l2,l3,l4,l5,l6,ll1,l9);
2138 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2139 fflush(out);
2140
2141 llr = ll_l7ll(l1,l2,l3,l4,l5,l6,l7,ll1,l9);
2142 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2143 fflush(out);
2144 llr = 0; clear_traces();
2145 current_function = (void*) &ll_l7ll; llr = ((long long (*) (long,long,long,long,long,long,long,long long,long)) vacall) (l1,l2,l3,l4,l5,l6,l7,ll1,l9);
2146 fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2147 fflush(out);
2148
2149 dr = d_l2d(l1,l2,ll1,l9);
2150 fprintf(out,"->%g\n",dr);
2151 fflush(out);
2152 dr = 0.0; clear_traces();
2153 current_function = (void*) &d_l2d; dr = ((double (*) (long,long,double,long)) vacall) (l1,l2,ll1,l9);
2154 fprintf(out,"->%g\n",dr);
2155 fflush(out);
2156
2157 dr = d_l3d(l1,l2,l3,ll1,l9);
2158 fprintf(out,"->%g\n",dr);
2159 fflush(out);
2160 dr = 0.0; clear_traces();
2161 current_function = (void*) &d_l3d; dr = ((double (*) (long,long,long,double,long)) vacall) (l1,l2,l3,ll1,l9);
2162 fprintf(out,"->%g\n",dr);
2163 fflush(out);
2164
2165 dr = d_l4d(l1,l2,l3,l4,ll1,l9);
2166 fprintf(out,"->%g\n",dr);
2167 fflush(out);
2168 dr = 0.0; clear_traces();
2169 current_function = (void*) &d_l4d; dr = ((double (*) (long,long,long,long,double,long)) vacall) (l1,l2,l3,l4,ll1,l9);
2170 fprintf(out,"->%g\n",dr);
2171 fflush(out);
2172
2173 dr = d_l5d(l1,l2,l3,l4,l5,ll1,l9);
2174 fprintf(out,"->%g\n",dr);
2175 fflush(out);
2176 dr = 0.0; clear_traces();
2177 current_function = (void*) &d_l5d; dr = ((double (*) (long,long,long,long,long,double,long)) vacall) (l1,l2,l3,l4,l5,ll1,l9);
2178 fprintf(out,"->%g\n",dr);
2179 fflush(out);
2180
2181 dr = d_l6d(l1,l2,l3,l4,l5,l6,ll1,l9);
2182 fprintf(out,"->%g\n",dr);
2183 fflush(out);
2184 dr = 0.0; clear_traces();
2185 current_function = (void*) &d_l6d; dr = ((double (*) (long,long,long,long,long,long,double,long)) vacall) (l1,l2,l3,l4,l5,l6,ll1,l9);
2186 fprintf(out,"->%g\n",dr);
2187 fflush(out);
2188
2189 dr = d_l7d(l1,l2,l3,l4,l5,l6,l7,ll1,l9);
2190 fprintf(out,"->%g\n",dr);
2191 fflush(out);
2192 dr = 0.0; clear_traces();
2193 current_function = (void*) &d_l7d; dr = ((double (*) (long,long,long,long,long,long,long,double,long)) vacall) (l1,l2,l3,l4,l5,l6,l7,ll1,l9);
2194 fprintf(out,"->%g\n",dr);
2195 fflush(out);
2196 }
2197
2198 /* by-value tests */
2199 /* This test is trivial, since a copy of k is allocated on the callee's stack.
2200 But anyway... */
2201 { K k;
2202
2203 k.l1 = l1;
2204 k.l2 = l2;
2205 k.l3 = l3;
2206 k.l4 = l4;
2207 fprintf(out,"by_value:%ld,%ld,%ld,%ld\n",k.l1,k.l2,k.l3,k.l4);
2208 fflush(out);
2209 clear_traces();
2210 current_function = (void*) &v_clobber_K; ((void (*) (K)) vacall) (k);
2211 fprintf(out,"by_value:%ld,%ld,%ld,%ld\n",k.l1,k.l2,k.l3,k.l4);
2212 fflush(out);
2213 }
2214
2215 exit(0);
2216 }
2217