ffi 1.9.23 → 1.9.24

Sign up to get free protection for your applications and to get access to all the features.
Files changed (78) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +66 -0
  3. data/Rakefile +1 -1
  4. data/ext/ffi_c/Call.c +5 -2
  5. data/ext/ffi_c/Function.c +8 -5
  6. data/ext/ffi_c/Thread.c +1 -0
  7. data/ext/ffi_c/extconf.rb +1 -0
  8. data/ext/ffi_c/libffi/.appveyor.yml +6 -4
  9. data/ext/ffi_c/libffi/.github/issue_template.md +10 -0
  10. data/ext/ffi_c/libffi/.gitignore +2 -0
  11. data/ext/ffi_c/libffi/.travis.yml +20 -16
  12. data/ext/ffi_c/libffi/.travis/ar-lib +270 -0
  13. data/ext/ffi_c/libffi/.travis/build.sh +34 -0
  14. data/ext/ffi_c/libffi/.travis/compile +351 -0
  15. data/ext/ffi_c/libffi/.travis/install.sh +11 -3
  16. data/ext/ffi_c/libffi/.travis/moxie-sim.exp +60 -0
  17. data/ext/ffi_c/libffi/.travis/site.exp +18 -0
  18. data/ext/ffi_c/libffi/LICENSE-BUILDTOOLS +352 -0
  19. data/ext/ffi_c/libffi/Makefile.am +4 -45
  20. data/ext/ffi_c/libffi/{README → README.md} +237 -230
  21. data/ext/ffi_c/libffi/configure.ac +10 -8
  22. data/ext/ffi_c/libffi/configure.host +5 -0
  23. data/ext/ffi_c/libffi/include/ffi.h.in +48 -26
  24. data/ext/ffi_c/libffi/include/ffi_common.h +2 -0
  25. data/ext/ffi_c/libffi/m4/ax_append_flag.m4 +18 -16
  26. data/ext/ffi_c/libffi/m4/ax_cc_maxopt.m4 +21 -8
  27. data/ext/ffi_c/libffi/m4/ax_cflags_warn_all.m4 +4 -4
  28. data/ext/ffi_c/libffi/m4/ax_check_compile_flag.m4 +9 -7
  29. data/ext/ffi_c/libffi/m4/ax_compiler_vendor.m4 +8 -5
  30. data/ext/ffi_c/libffi/m4/ax_configure_args.m4 +5 -5
  31. data/ext/ffi_c/libffi/m4/ax_enable_builddir.m4 +7 -6
  32. data/ext/ffi_c/libffi/m4/ax_gcc_archflag.m4 +99 -61
  33. data/ext/ffi_c/libffi/m4/ax_gcc_x86_cpuid.m4 +18 -8
  34. data/ext/ffi_c/libffi/m4/ax_require_defined.m4 +37 -0
  35. data/ext/ffi_c/libffi/msvcc.sh +82 -14
  36. data/ext/ffi_c/libffi/src/aarch64/ffi.c +8 -31
  37. data/ext/ffi_c/libffi/src/closures.c +31 -1
  38. data/ext/ffi_c/libffi/src/ia64/ffi.c +24 -6
  39. data/ext/ffi_c/libffi/src/ia64/ffitarget.h +2 -1
  40. data/ext/ffi_c/libffi/src/ia64/unix.S +6 -1
  41. data/ext/ffi_c/libffi/src/mips/ffi.c +29 -12
  42. data/ext/ffi_c/libffi/src/mips/ffitarget.h +7 -12
  43. data/ext/ffi_c/libffi/src/moxie/eabi.S +1 -1
  44. data/ext/ffi_c/libffi/src/moxie/ffi.c +18 -5
  45. data/ext/ffi_c/libffi/src/powerpc/ffi_linux64.c +45 -16
  46. data/ext/ffi_c/libffi/src/riscv/ffi.c +445 -0
  47. data/ext/ffi_c/libffi/src/riscv/ffitarget.h +68 -0
  48. data/ext/ffi_c/libffi/src/riscv/sysv.S +214 -0
  49. data/ext/ffi_c/libffi/src/types.c +3 -1
  50. data/ext/ffi_c/libffi/src/x86/ffi.c +18 -0
  51. data/ext/ffi_c/libffi/src/x86/ffi64.c +15 -9
  52. data/ext/ffi_c/libffi/src/x86/ffitarget.h +8 -2
  53. data/ext/ffi_c/libffi/src/x86/ffiw64.c +30 -9
  54. data/ext/ffi_c/libffi/src/xtensa/sysv.S +6 -1
  55. data/ext/ffi_c/libffi/testsuite/Makefile.am +108 -77
  56. data/ext/ffi_c/libffi/testsuite/lib/libffi.exp +195 -5
  57. data/ext/ffi_c/libffi/testsuite/libffi.bhaible/Makefile +28 -0
  58. data/ext/ffi_c/libffi/testsuite/libffi.bhaible/README +78 -0
  59. data/ext/ffi_c/libffi/testsuite/libffi.bhaible/alignof.h +50 -0
  60. data/ext/ffi_c/libffi/testsuite/libffi.bhaible/bhaible.exp +58 -0
  61. data/ext/ffi_c/libffi/testsuite/libffi.bhaible/test-call.c +1745 -0
  62. data/ext/ffi_c/libffi/testsuite/libffi.bhaible/test-callback.c +2885 -0
  63. data/ext/ffi_c/libffi/testsuite/libffi.bhaible/testcases.c +743 -0
  64. data/ext/ffi_c/libffi/testsuite/libffi.call/align_stdcall.c +46 -0
  65. data/ext/ffi_c/libffi/testsuite/libffi.call/call.exp +14 -1
  66. data/ext/ffi_c/libffi/testsuite/libffi.call/ffitest.h +3 -1
  67. data/ext/ffi_c/libffi/testsuite/libffi.call/nested_struct10.c +1 -0
  68. data/ext/ffi_c/libffi/testsuite/libffi.call/struct10.c +57 -0
  69. data/ext/ffi_c/libffi/testsuite/libffi.call/unwindtest.cc +1 -1
  70. data/ext/ffi_c/libffi/testsuite/libffi.call/unwindtest_ffi_call.cc +1 -1
  71. data/lib/ffi/library.rb +2 -4
  72. data/lib/ffi/platform/mips64-linux/types.conf +104 -0
  73. data/lib/ffi/platform/mipsisa32r6-linux/types.conf +102 -0
  74. data/lib/ffi/platform/mipsisa32r6el-linux/types.conf +102 -0
  75. data/lib/ffi/platform/mipsisa64r6-linux/types.conf +104 -0
  76. data/lib/ffi/platform/mipsisa64r6el-linux/types.conf +104 -0
  77. data/lib/ffi/version.rb +1 -1
  78. metadata +29 -3
@@ -0,0 +1,2885 @@
1
+ /*
2
+ * Copyright 1993 Bill Triggs <Bill.Triggs@inrialpes.fr>
3
+ * Copyright 1995-2017 Bruno Haible <bruno@clisp.org>
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 2 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
+
19
+ /* { dg-do run { xfail gccbug } }*/
20
+
21
+ #include <stdio.h>
22
+ #include <stdlib.h>
23
+ #include <string.h>
24
+ #include <ffi.h>
25
+ #include "alignof.h"
26
+ #include <stdarg.h>
27
+
28
+ /* libffi testsuite local changes -------------------------------- */
29
+ #ifdef DGTEST
30
+ /* Redefine exit(1) as a test failure */
31
+ #define exit(V) (void)((V) ? (abort(), 1) : exit(0))
32
+ int count = 0;
33
+ char rbuf1[2048];
34
+ char rbuf2[2048];
35
+ int _fprintf(FILE *stream, const char *format, ...)
36
+ {
37
+ va_list args;
38
+ va_start(args, format);
39
+
40
+ switch (count++)
41
+ {
42
+ case 0:
43
+ case 1:
44
+ vsprintf(&rbuf1[strlen(rbuf1)], format, args);
45
+ break;
46
+ case 2:
47
+ printf("%s", rbuf1);
48
+ vsprintf(rbuf2, format, args);
49
+ break;
50
+ case 3:
51
+ vsprintf(&rbuf2[strlen(rbuf2)], format, args);
52
+ printf("%s", rbuf2);
53
+ if (strcmp (rbuf1, rbuf2)) abort();
54
+ break;
55
+ }
56
+
57
+ va_end(args);
58
+
59
+ return 0;
60
+ }
61
+ #define fprintf _fprintf
62
+ #endif
63
+ /* --------------------------------------------------------------- */
64
+
65
+ #include "testcases.c"
66
+
67
+ #ifndef ABI_NUM
68
+ #define ABI_NUM FFI_DEFAULT_ABI
69
+ #endif
70
+
71
+ /* Definitions that ought to be part of libffi. */
72
+ static ffi_type ffi_type_char;
73
+ #define ffi_type_slonglong ffi_type_sint64
74
+ #define ffi_type_ulonglong ffi_type_uint64
75
+
76
+ /* libffi does not support arrays inside structs. */
77
+ #define SKIP_EXTRA_STRUCTS
78
+
79
+ #define FFI_PREP_CIF(cif,argtypes,rettype) \
80
+ if (ffi_prep_cif(&(cif),ABI_NUM,sizeof(argtypes)/sizeof(argtypes[0]),&rettype,argtypes) != FFI_OK) abort()
81
+ #define FFI_PREP_CIF_NOARGS(cif,rettype) \
82
+ if (ffi_prep_cif(&(cif),ABI_NUM,0,&rettype,NULL) != FFI_OK) abort()
83
+
84
+ #if defined(__sparc__) && defined(__sun) && defined(__SUNPRO_C) /* SUNWspro cc */
85
+ /* SunPRO cc miscompiles the simulator function for X_BcdB: d.i[1] is
86
+ * temporarily stored in %l2 and put onto the stack from %l2, but in between
87
+ * the copy of X has used %l2 as a counter without saving and restoring its
88
+ * value.
89
+ */
90
+ #define SKIP_X
91
+ #endif
92
+ #if defined(__mipsn32__) && !defined(__GNUC__)
93
+ /* The X test crashes for an unknown reason. */
94
+ #define SKIP_X
95
+ #endif
96
+
97
+
98
+ /* These functions simulate the behaviour of the functions defined in testcases.c. */
99
+
100
+ /* void tests */
101
+ void v_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
102
+ {
103
+ if (data != (void*)&v_v) { fprintf(out,"wrong data for v_v\n"); exit(1); }
104
+ fprintf(out,"void f(void):\n");
105
+ fflush(out);
106
+ }
107
+
108
+ /* int tests */
109
+ void i_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
110
+ {
111
+ if (data != (void*)&i_v) { fprintf(out,"wrong data for i_v\n"); exit(1); }
112
+ {int r=99;
113
+ fprintf(out,"int f(void):");
114
+ fflush(out);
115
+ *(ffi_arg*)retp = r;
116
+ }}
117
+ void i_i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
118
+ {
119
+ if (data != (void*)&i_i) { fprintf(out,"wrong data for i_i\n"); exit(1); }
120
+ int a = *(int*)(*args++);
121
+ int r=a+1;
122
+ fprintf(out,"int f(int):(%d)",a);
123
+ fflush(out);
124
+ *(ffi_arg*)retp = r;
125
+ }
126
+ void i_i2_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
127
+ {
128
+ if (data != (void*)&i_i2) { fprintf(out,"wrong data for i_i2\n"); exit(1); }
129
+ {int a = *(int*)(*args++);
130
+ int b = *(int*)(*args++);
131
+ int r=a+b;
132
+ fprintf(out,"int f(2*int):(%d,%d)",a,b);
133
+ fflush(out);
134
+ *(ffi_arg*)retp = r;
135
+ }}
136
+ void i_i4_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
137
+ {
138
+ if (data != (void*)&i_i4) { fprintf(out,"wrong data for i_i4\n"); exit(1); }
139
+ {int a = *(int*)(*args++);
140
+ int b = *(int*)(*args++);
141
+ int c = *(int*)(*args++);
142
+ int d = *(int*)(*args++);
143
+ int r=a+b+c+d;
144
+ fprintf(out,"int f(4*int):(%d,%d,%d,%d)",a,b,c,d);
145
+ fflush(out);
146
+ *(ffi_arg*)retp = r;
147
+ }}
148
+ void i_i8_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
149
+ {
150
+ if (data != (void*)&i_i8) { fprintf(out,"wrong data for i_i8\n"); exit(1); }
151
+ {int a = *(int*)(*args++);
152
+ int b = *(int*)(*args++);
153
+ int c = *(int*)(*args++);
154
+ int d = *(int*)(*args++);
155
+ int e = *(int*)(*args++);
156
+ int f = *(int*)(*args++);
157
+ int g = *(int*)(*args++);
158
+ int h = *(int*)(*args++);
159
+ int r=a+b+c+d+e+f+g+h;
160
+ fprintf(out,"int f(8*int):(%d,%d,%d,%d,%d,%d,%d,%d)",a,b,c,d,e,f,g,h);
161
+ fflush(out);
162
+ *(ffi_arg*)retp = r;
163
+ }}
164
+ void i_i16_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
165
+ {
166
+ if (data != (void*)&i_i16) { fprintf(out,"wrong data for i_i16\n"); exit(1); }
167
+ {int a = *(int*)(*args++);
168
+ int b = *(int*)(*args++);
169
+ int c = *(int*)(*args++);
170
+ int d = *(int*)(*args++);
171
+ int e = *(int*)(*args++);
172
+ int f = *(int*)(*args++);
173
+ int g = *(int*)(*args++);
174
+ int h = *(int*)(*args++);
175
+ int i = *(int*)(*args++);
176
+ int j = *(int*)(*args++);
177
+ int k = *(int*)(*args++);
178
+ int l = *(int*)(*args++);
179
+ int m = *(int*)(*args++);
180
+ int n = *(int*)(*args++);
181
+ int o = *(int*)(*args++);
182
+ int p = *(int*)(*args++);
183
+ int r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
184
+ fprintf(out,"int f(16*int):(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
185
+ a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
186
+ fflush(out);
187
+ *(ffi_arg*)retp = r;
188
+ }}
189
+
190
+ /* float tests */
191
+ void f_f_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
192
+ {
193
+ if (data != (void*)&f_f) { fprintf(out,"wrong data for f_f\n"); exit(1); }
194
+ {float a = *(float*)(*args++);
195
+ float r=a+1.0;
196
+ fprintf(out,"float f(float):(%g)",a);
197
+ fflush(out);
198
+ *(float*)retp = r;
199
+ }}
200
+ void f_f2_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
201
+ {
202
+ if (data != (void*)&f_f2) { fprintf(out,"wrong data for f_f2\n"); exit(1); }
203
+ {float a = *(float*)(*args++);
204
+ float b = *(float*)(*args++);
205
+ float r=a+b;
206
+ fprintf(out,"float f(2*float):(%g,%g)",a,b);
207
+ fflush(out);
208
+ *(float*)retp = r;
209
+ }}
210
+ void f_f4_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
211
+ {
212
+ if (data != (void*)&f_f4) { fprintf(out,"wrong data for f_f4\n"); exit(1); }
213
+ {float a = *(float*)(*args++);
214
+ float b = *(float*)(*args++);
215
+ float c = *(float*)(*args++);
216
+ float d = *(float*)(*args++);
217
+ float r=a+b+c+d;
218
+ fprintf(out,"float f(4*float):(%g,%g,%g,%g)",a,b,c,d);
219
+ fflush(out);
220
+ *(float*)retp = r;
221
+ }}
222
+ void f_f8_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
223
+ {
224
+ if (data != (void*)&f_f8) { fprintf(out,"wrong data for f_f8\n"); exit(1); }
225
+ {float a = *(float*)(*args++);
226
+ float b = *(float*)(*args++);
227
+ float c = *(float*)(*args++);
228
+ float d = *(float*)(*args++);
229
+ float e = *(float*)(*args++);
230
+ float f = *(float*)(*args++);
231
+ float g = *(float*)(*args++);
232
+ float h = *(float*)(*args++);
233
+ float r=a+b+c+d+e+f+g+h;
234
+ fprintf(out,"float f(8*float):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
235
+ fflush(out);
236
+ *(float*)retp = r;
237
+ }}
238
+ void f_f16_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
239
+ {
240
+ if (data != (void*)&f_f16) { fprintf(out,"wrong data for f_f16\n"); exit(1); }
241
+ {float a = *(float*)(*args++);
242
+ float b = *(float*)(*args++);
243
+ float c = *(float*)(*args++);
244
+ float d = *(float*)(*args++);
245
+ float e = *(float*)(*args++);
246
+ float f = *(float*)(*args++);
247
+ float g = *(float*)(*args++);
248
+ float h = *(float*)(*args++);
249
+ float i = *(float*)(*args++);
250
+ float j = *(float*)(*args++);
251
+ float k = *(float*)(*args++);
252
+ float l = *(float*)(*args++);
253
+ float m = *(float*)(*args++);
254
+ float n = *(float*)(*args++);
255
+ float o = *(float*)(*args++);
256
+ float p = *(float*)(*args++);
257
+ float r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
258
+ 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);
259
+ fflush(out);
260
+ *(float*)retp = r;
261
+ }}
262
+ void f_f24_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
263
+ {
264
+ if (data != (void*)&f_f24) { fprintf(out,"wrong data for f_f24\n"); exit(1); }
265
+ {float a = *(float*)(*args++);
266
+ float b = *(float*)(*args++);
267
+ float c = *(float*)(*args++);
268
+ float d = *(float*)(*args++);
269
+ float e = *(float*)(*args++);
270
+ float f = *(float*)(*args++);
271
+ float g = *(float*)(*args++);
272
+ float h = *(float*)(*args++);
273
+ float i = *(float*)(*args++);
274
+ float j = *(float*)(*args++);
275
+ float k = *(float*)(*args++);
276
+ float l = *(float*)(*args++);
277
+ float m = *(float*)(*args++);
278
+ float n = *(float*)(*args++);
279
+ float o = *(float*)(*args++);
280
+ float p = *(float*)(*args++);
281
+ float q = *(float*)(*args++);
282
+ float s = *(float*)(*args++);
283
+ float t = *(float*)(*args++);
284
+ float u = *(float*)(*args++);
285
+ float v = *(float*)(*args++);
286
+ float w = *(float*)(*args++);
287
+ float x = *(float*)(*args++);
288
+ float y = *(float*)(*args++);
289
+ 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;
290
+ 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);
291
+ fflush(out);
292
+ *(float*)retp = r;
293
+ }}
294
+
295
+ /* double tests */
296
+ void d_d_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
297
+ {
298
+ if (data != (void*)&d_d) { fprintf(out,"wrong data for d_d\n"); exit(1); }
299
+ {double a = *(double*)(*args++);
300
+ double r=a+1.0;
301
+ fprintf(out,"double f(double):(%g)",a);
302
+ fflush(out);
303
+ *(double*)retp = r;
304
+ }}
305
+ void d_d2_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
306
+ {
307
+ if (data != (void*)&d_d2) { fprintf(out,"wrong data for d_d2\n"); exit(1); }
308
+ {double a = *(double*)(*args++);
309
+ double b = *(double*)(*args++);
310
+ double r=a+b;
311
+ fprintf(out,"double f(2*double):(%g,%g)",a,b);
312
+ fflush(out);
313
+ *(double*)retp = r;
314
+ }}
315
+ void d_d4_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
316
+ {
317
+ if (data != (void*)&d_d4) { fprintf(out,"wrong data for d_d4\n"); exit(1); }
318
+ {double a = *(double*)(*args++);
319
+ double b = *(double*)(*args++);
320
+ double c = *(double*)(*args++);
321
+ double d = *(double*)(*args++);
322
+ double r=a+b+c+d;
323
+ fprintf(out,"double f(4*double):(%g,%g,%g,%g)",a,b,c,d);
324
+ fflush(out);
325
+ *(double*)retp = r;
326
+ }}
327
+ void d_d8_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
328
+ {
329
+ if (data != (void*)&d_d8) { fprintf(out,"wrong data for d_d8\n"); exit(1); }
330
+ {double a = *(double*)(*args++);
331
+ double b = *(double*)(*args++);
332
+ double c = *(double*)(*args++);
333
+ double d = *(double*)(*args++);
334
+ double e = *(double*)(*args++);
335
+ double f = *(double*)(*args++);
336
+ double g = *(double*)(*args++);
337
+ double h = *(double*)(*args++);
338
+ double r=a+b+c+d+e+f+g+h;
339
+ fprintf(out,"double f(8*double):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
340
+ fflush(out);
341
+ *(double*)retp = r;
342
+ }}
343
+ void d_d16_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
344
+ {
345
+ if (data != (void*)&d_d16) { fprintf(out,"wrong data for d_d16\n"); exit(1); }
346
+ {double a = *(double*)(*args++);
347
+ double b = *(double*)(*args++);
348
+ double c = *(double*)(*args++);
349
+ double d = *(double*)(*args++);
350
+ double e = *(double*)(*args++);
351
+ double f = *(double*)(*args++);
352
+ double g = *(double*)(*args++);
353
+ double h = *(double*)(*args++);
354
+ double i = *(double*)(*args++);
355
+ double j = *(double*)(*args++);
356
+ double k = *(double*)(*args++);
357
+ double l = *(double*)(*args++);
358
+ double m = *(double*)(*args++);
359
+ double n = *(double*)(*args++);
360
+ double o = *(double*)(*args++);
361
+ double p = *(double*)(*args++);
362
+ double r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
363
+ 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);
364
+ fflush(out);
365
+ *(double*)retp = r;
366
+ }}
367
+
368
+ /* pointer tests */
369
+ void vp_vpdpcpsp_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
370
+ {
371
+ if (data != (void*)&vp_vpdpcpsp) { fprintf(out,"wrong data for vp_vpdpcpsp\n"); exit(1); }
372
+ {void* a = *(void* *)(*args++);
373
+ double* b = *(double* *)(*args++);
374
+ char* c = *(char* *)(*args++);
375
+ Int* d = *(Int* *)(*args++);
376
+ void* ret = (char*)b + 1;
377
+ fprintf(out,"void* f(void*,double*,char*,Int*):(0x%p,0x%p,0x%p,0x%p)",a,b,c,d);
378
+ fflush(out);
379
+ *(void* *)retp = ret;
380
+ }}
381
+
382
+ /* mixed number tests */
383
+ void uc_ucsil_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
384
+ {
385
+ if (data != (void*)&uc_ucsil) { fprintf(out,"wrong data for uc_ucsil\n"); exit(1); }
386
+ {uchar a = *(unsigned char *)(*args++);
387
+ ushort b = *(unsigned short *)(*args++);
388
+ uint c = *(unsigned int *)(*args++);
389
+ ulong d = *(unsigned long *)(*args++);
390
+ uchar r = (uchar)-1;
391
+ fprintf(out,"uchar f(uchar,ushort,uint,ulong):(%u,%u,%u,%lu)",a,b,c,d);
392
+ fflush(out);
393
+ *(ffi_arg *)retp = r;
394
+ }}
395
+ void d_iidd_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
396
+ {
397
+ if (data != (void*)&d_iidd) { fprintf(out,"wrong data for d_iidd\n"); exit(1); }
398
+ {int a = *(int*)(*args++);
399
+ int b = *(int*)(*args++);
400
+ double c = *(double*)(*args++);
401
+ double d = *(double*)(*args++);
402
+ double r=a+b+c+d;
403
+ fprintf(out,"double f(int,int,double,double):(%d,%d,%g,%g)",a,b,c,d);
404
+ fflush(out);
405
+ *(double*)retp = r;
406
+ }}
407
+ void d_iiidi_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
408
+ {
409
+ if (data != (void*)&d_iiidi) { fprintf(out,"wrong data for d_iiidi\n"); exit(1); }
410
+ {int a = *(int*)(*args++);
411
+ int b = *(int*)(*args++);
412
+ int c = *(int*)(*args++);
413
+ double d = *(double*)(*args++);
414
+ int e = *(int*)(*args++);
415
+ double r=a+b+c+d+e;
416
+ fprintf(out,"double f(int,int,int,double,int):(%d,%d,%d,%g,%d)",a,b,c,d,e);
417
+ fflush(out);
418
+ *(double*)retp = r;
419
+ }}
420
+ void d_idid_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
421
+ {
422
+ if (data != (void*)&d_idid) { fprintf(out,"wrong data for d_idid\n"); exit(1); }
423
+ {int a = *(int*)(*args++);
424
+ double b = *(double*)(*args++);
425
+ int c = *(int*)(*args++);
426
+ double d = *(double*)(*args++);
427
+ double r=a+b+c+d;
428
+ fprintf(out,"double f(int,double,int,double):(%d,%g,%d,%g)",a,b,c,d);
429
+ fflush(out);
430
+ *(double*)retp = r;
431
+ }}
432
+ void d_fdi_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
433
+ {
434
+ if (data != (void*)&d_fdi) { fprintf(out,"wrong data for d_fdi\n"); exit(1); }
435
+ {float a = *(float*)(*args++);
436
+ double b = *(double*)(*args++);
437
+ int c = *(int*)(*args++);
438
+ double r=a+b+c;
439
+ fprintf(out,"double f(float,double,int):(%g,%g,%d)",a,b,c);
440
+ fflush(out);
441
+ *(double*)retp = r;
442
+ }}
443
+ void us_cdcd_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
444
+ {
445
+ if (data != (void*)&us_cdcd) { fprintf(out,"wrong data for us_cdcd\n"); exit(1); }
446
+ {char a = *(char*)(*args++);
447
+ double b = *(double*)(*args++);
448
+ char c = *(char*)(*args++);
449
+ double d = *(double*)(*args++);
450
+ ushort r = (ushort)(a + b + c + d);
451
+ fprintf(out,"ushort f(char,double,char,double):('%c',%g,'%c',%g)",a,b,c,d);
452
+ fflush(out);
453
+ *(ffi_arg *)retp = r;
454
+ }}
455
+ void ll_iiilli_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
456
+ {
457
+ if (data != (void*)&ll_iiilli) { fprintf(out,"wrong data for ll_iiilli\n"); exit(1); }
458
+ {int a = *(int*)(*args++);
459
+ int b = *(int*)(*args++);
460
+ int c = *(int*)(*args++);
461
+ long long d = *(long long *)(*args++);
462
+ int e = *(int*)(*args++);
463
+ long long r = (long long)(int)a + (long long)(int)b + (long long)(int)c + d + (long long)e;
464
+ 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);
465
+ fflush(out);
466
+ *(long long *)retp = r;
467
+ }}
468
+ void ll_flli_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
469
+ {
470
+ if (data != (void*)&ll_flli) { fprintf(out,"wrong data for ll_flli\n"); exit(1); }
471
+ {float a = *(float*)(*args++);
472
+ long long b = *(long long *)(*args++);
473
+ int c = *(int*)(*args++);
474
+ long long r = (long long)(int)a + b + (long long)c;
475
+ fprintf(out,"long long f(float,long long,int):(%g,0x%lx%08lx,0x%lx)",a,(long)(b>>32),(long)(b&0xffffffff),(long)c);
476
+ fflush(out);
477
+ *(long long *)retp = r;
478
+ }}
479
+ void f_fi_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
480
+ {
481
+ if (data != (void*)&f_fi) { fprintf(out,"wrong data for f_fi\n"); exit(1); }
482
+ {float a = *(float*)(*args++);
483
+ int z = *(int*)(*args++);
484
+ float r=a+z;
485
+ fprintf(out,"float f(float,int):(%g,%d)",a,z);
486
+ fflush(out);
487
+ *(float*)retp = r;
488
+ }}
489
+ void f_f2i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
490
+ {
491
+ if (data != (void*)&f_f2i) { fprintf(out,"wrong data for f_f2i\n"); exit(1); }
492
+ {float a = *(float*)(*args++);
493
+ float b = *(float*)(*args++);
494
+ int z = *(int*)(*args++);
495
+ float r=a+b+z;
496
+ fprintf(out,"float f(2*float,int):(%g,%g,%d)",a,b,z);
497
+ fflush(out);
498
+ *(float*)retp = r;
499
+ }}
500
+ void f_f3i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
501
+ {
502
+ if (data != (void*)&f_f3i) { fprintf(out,"wrong data for f_f3i\n"); exit(1); }
503
+ {float a = *(float*)(*args++);
504
+ float b = *(float*)(*args++);
505
+ float c = *(float*)(*args++);
506
+ int z = *(int*)(*args++);
507
+ float r=a+b+c+z;
508
+ fprintf(out,"float f(3*float,int):(%g,%g,%g,%d)",a,b,c,z);
509
+ fflush(out);
510
+ *(float*)retp = r;
511
+ }}
512
+ void f_f4i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
513
+ {
514
+ if (data != (void*)&f_f4i) { fprintf(out,"wrong data for f_f4i\n"); exit(1); }
515
+ {float a = *(float*)(*args++);
516
+ float b = *(float*)(*args++);
517
+ float c = *(float*)(*args++);
518
+ float d = *(float*)(*args++);
519
+ int z = *(int*)(*args++);
520
+ float r=a+b+c+d+z;
521
+ fprintf(out,"float f(4*float,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
522
+ fflush(out);
523
+ *(float*)retp = r;
524
+ }}
525
+ void f_f7i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
526
+ {
527
+ if (data != (void*)&f_f7i) { fprintf(out,"wrong data for f_f7i\n"); exit(1); }
528
+ {float a = *(float*)(*args++);
529
+ float b = *(float*)(*args++);
530
+ float c = *(float*)(*args++);
531
+ float d = *(float*)(*args++);
532
+ float e = *(float*)(*args++);
533
+ float f = *(float*)(*args++);
534
+ float g = *(float*)(*args++);
535
+ int z = *(int*)(*args++);
536
+ float r=a+b+c+d+e+f+g+z;
537
+ fprintf(out,"float f(7*float,int):(%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,z);
538
+ fflush(out);
539
+ *(float*)retp = r;
540
+ }}
541
+ void f_f8i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
542
+ {
543
+ if (data != (void*)&f_f8i) { fprintf(out,"wrong data for f_f8i\n"); exit(1); }
544
+ {float a = *(float*)(*args++);
545
+ float b = *(float*)(*args++);
546
+ float c = *(float*)(*args++);
547
+ float d = *(float*)(*args++);
548
+ float e = *(float*)(*args++);
549
+ float f = *(float*)(*args++);
550
+ float g = *(float*)(*args++);
551
+ float h = *(float*)(*args++);
552
+ int z = *(int*)(*args++);
553
+ float r=a+b+c+d+e+f+g+h+z;
554
+ 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);
555
+ fflush(out);
556
+ *(float*)retp = r;
557
+ }}
558
+ void f_f12i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
559
+ {
560
+ if (data != (void*)&f_f12i) { fprintf(out,"wrong data for f_f12i\n"); exit(1); }
561
+ {float a = *(float*)(*args++);
562
+ float b = *(float*)(*args++);
563
+ float c = *(float*)(*args++);
564
+ float d = *(float*)(*args++);
565
+ float e = *(float*)(*args++);
566
+ float f = *(float*)(*args++);
567
+ float g = *(float*)(*args++);
568
+ float h = *(float*)(*args++);
569
+ float i = *(float*)(*args++);
570
+ float j = *(float*)(*args++);
571
+ float k = *(float*)(*args++);
572
+ float l = *(float*)(*args++);
573
+ int z = *(int*)(*args++);
574
+ float r=a+b+c+d+e+f+g+h+i+j+k+l+z;
575
+ 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);
576
+ fflush(out);
577
+ *(float*)retp = r;
578
+ }}
579
+ void f_f13i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
580
+ {
581
+ if (data != (void*)&f_f13i) { fprintf(out,"wrong data for f_f13i\n"); exit(1); }
582
+ {float a = *(float*)(*args++);
583
+ float b = *(float*)(*args++);
584
+ float c = *(float*)(*args++);
585
+ float d = *(float*)(*args++);
586
+ float e = *(float*)(*args++);
587
+ float f = *(float*)(*args++);
588
+ float g = *(float*)(*args++);
589
+ float h = *(float*)(*args++);
590
+ float i = *(float*)(*args++);
591
+ float j = *(float*)(*args++);
592
+ float k = *(float*)(*args++);
593
+ float l = *(float*)(*args++);
594
+ float m = *(float*)(*args++);
595
+ int z = *(int*)(*args++);
596
+ float r=a+b+c+d+e+f+g+h+i+j+k+l+m+z;
597
+ 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);
598
+ fflush(out);
599
+ *(float*)retp = r;
600
+ }}
601
+ void d_di_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
602
+ {
603
+ if (data != (void*)&d_di) { fprintf(out,"wrong data for d_di\n"); exit(1); }
604
+ {double a = *(double*)(*args++);
605
+ int z = *(int*)(*args++);
606
+ double r=a+z;
607
+ fprintf(out,"double f(double,int):(%g,%d)",a,z);
608
+ fflush(out);
609
+ *(double*)retp = r;
610
+ }}
611
+ void d_d2i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
612
+ {
613
+ if (data != (void*)&d_d2i) { fprintf(out,"wrong data for d_d2i\n"); exit(1); }
614
+ {double a = *(double*)(*args++);
615
+ double b = *(double*)(*args++);
616
+ int z = *(int*)(*args++);
617
+ double r=a+b+z;
618
+ fprintf(out,"double f(2*double,int):(%g,%g,%d)",a,b,z);
619
+ fflush(out);
620
+ *(double*)retp = r;
621
+ }}
622
+ void d_d3i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
623
+ {
624
+ if (data != (void*)&d_d3i) { fprintf(out,"wrong data for d_d3i\n"); exit(1); }
625
+ {double a = *(double*)(*args++);
626
+ double b = *(double*)(*args++);
627
+ double c = *(double*)(*args++);
628
+ int z = *(int*)(*args++);
629
+ double r=a+b+c+z;
630
+ fprintf(out,"double f(3*double,int):(%g,%g,%g,%d)",a,b,c,z);
631
+ fflush(out);
632
+ *(double*)retp = r;
633
+ }}
634
+ void d_d4i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
635
+ {
636
+ if (data != (void*)&d_d4i) { fprintf(out,"wrong data for d_d4i\n"); exit(1); }
637
+ {double a = *(double*)(*args++);
638
+ double b = *(double*)(*args++);
639
+ double c = *(double*)(*args++);
640
+ double d = *(double*)(*args++);
641
+ int z = *(int*)(*args++);
642
+ double r=a+b+c+d+z;
643
+ fprintf(out,"double f(4*double,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
644
+ fflush(out);
645
+ *(double*)retp = r;
646
+ }}
647
+ void d_d7i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
648
+ {
649
+ if (data != (void*)&d_d7i) { fprintf(out,"wrong data for d_d7i\n"); exit(1); }
650
+ {double a = *(double*)(*args++);
651
+ double b = *(double*)(*args++);
652
+ double c = *(double*)(*args++);
653
+ double d = *(double*)(*args++);
654
+ double e = *(double*)(*args++);
655
+ double f = *(double*)(*args++);
656
+ double g = *(double*)(*args++);
657
+ int z = *(int*)(*args++);
658
+ double r=a+b+c+d+e+f+g+z;
659
+ fprintf(out,"double f(7*double,int):(%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,z);
660
+ fflush(out);
661
+ *(double*)retp = r;
662
+ }}
663
+ void d_d8i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
664
+ {
665
+ if (data != (void*)&d_d8i) { fprintf(out,"wrong data for d_d8i\n"); exit(1); }
666
+ {double a = *(double*)(*args++);
667
+ double b = *(double*)(*args++);
668
+ double c = *(double*)(*args++);
669
+ double d = *(double*)(*args++);
670
+ double e = *(double*)(*args++);
671
+ double f = *(double*)(*args++);
672
+ double g = *(double*)(*args++);
673
+ double h = *(double*)(*args++);
674
+ int z = *(int*)(*args++);
675
+ double r=a+b+c+d+e+f+g+h+z;
676
+ 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);
677
+ fflush(out);
678
+ *(double*)retp = r;
679
+ }}
680
+ void d_d12i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
681
+ {
682
+ if (data != (void*)&d_d12i) { fprintf(out,"wrong data for d_d12i\n"); exit(1); }
683
+ {double a = *(double*)(*args++);
684
+ double b = *(double*)(*args++);
685
+ double c = *(double*)(*args++);
686
+ double d = *(double*)(*args++);
687
+ double e = *(double*)(*args++);
688
+ double f = *(double*)(*args++);
689
+ double g = *(double*)(*args++);
690
+ double h = *(double*)(*args++);
691
+ double i = *(double*)(*args++);
692
+ double j = *(double*)(*args++);
693
+ double k = *(double*)(*args++);
694
+ double l = *(double*)(*args++);
695
+ int z = *(int*)(*args++);
696
+ double r=a+b+c+d+e+f+g+h+i+j+k+l+z;
697
+ 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);
698
+ fflush(out);
699
+ *(double*)retp = r;
700
+ }}
701
+ void d_d13i_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
702
+ {
703
+ if (data != (void*)&d_d13i) { fprintf(out,"wrong data for d_d13i\n"); exit(1); }
704
+ {double a = *(double*)(*args++);
705
+ double b = *(double*)(*args++);
706
+ double c = *(double*)(*args++);
707
+ double d = *(double*)(*args++);
708
+ double e = *(double*)(*args++);
709
+ double f = *(double*)(*args++);
710
+ double g = *(double*)(*args++);
711
+ double h = *(double*)(*args++);
712
+ double i = *(double*)(*args++);
713
+ double j = *(double*)(*args++);
714
+ double k = *(double*)(*args++);
715
+ double l = *(double*)(*args++);
716
+ double m = *(double*)(*args++);
717
+ int z = *(int*)(*args++);
718
+ double r=a+b+c+d+e+f+g+h+i+j+k+l+m+z;
719
+ 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);
720
+ fflush(out);
721
+ *(double*)retp = r;
722
+ }}
723
+
724
+ /* small structure return tests */
725
+ void S1_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
726
+ {
727
+ if (data != (void*)&S1_v) { fprintf(out,"wrong data for S1_v\n"); exit(1); }
728
+ {Size1 r = Size1_1;
729
+ fprintf(out,"Size1 f(void):");
730
+ fflush(out);
731
+ *(Size1*)retp = r;
732
+ }}
733
+ void S2_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
734
+ {
735
+ if (data != (void*)&S2_v) { fprintf(out,"wrong data for S2_v\n"); exit(1); }
736
+ {Size2 r = Size2_1;
737
+ fprintf(out,"Size2 f(void):");
738
+ fflush(out);
739
+ *(Size2*)retp = r;
740
+ }}
741
+ void S3_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
742
+ {
743
+ if (data != (void*)&S3_v) { fprintf(out,"wrong data for S3_v\n"); exit(1); }
744
+ {Size3 r = Size3_1;
745
+ fprintf(out,"Size3 f(void):");
746
+ fflush(out);
747
+ *(Size3*)retp = r;
748
+ }}
749
+ void S4_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
750
+ {
751
+ if (data != (void*)&S4_v) { fprintf(out,"wrong data for S4_v\n"); exit(1); }
752
+ {Size4 r = Size4_1;
753
+ fprintf(out,"Size4 f(void):");
754
+ fflush(out);
755
+ *(Size4*)retp = r;
756
+ }}
757
+ void S7_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
758
+ {
759
+ if (data != (void*)&S7_v) { fprintf(out,"wrong data for S7_v\n"); exit(1); }
760
+ {Size7 r = Size7_1;
761
+ fprintf(out,"Size7 f(void):");
762
+ fflush(out);
763
+ *(Size7*)retp = r;
764
+ }}
765
+ void S8_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
766
+ {
767
+ if (data != (void*)&S8_v) { fprintf(out,"wrong data for S8_v\n"); exit(1); }
768
+ {Size8 r = Size8_1;
769
+ fprintf(out,"Size8 f(void):");
770
+ fflush(out);
771
+ *(Size8*)retp = r;
772
+ }}
773
+ void S12_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
774
+ {
775
+ if (data != (void*)&S12_v) { fprintf(out,"wrong data for S12_v\n"); exit(1); }
776
+ {Size12 r = Size12_1;
777
+ fprintf(out,"Size12 f(void):");
778
+ fflush(out);
779
+ *(Size12*)retp = r;
780
+ }}
781
+ void S15_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
782
+ {
783
+ if (data != (void*)&S15_v) { fprintf(out,"wrong data for S15_v\n"); exit(1); }
784
+ {Size15 r = Size15_1;
785
+ fprintf(out,"Size15 f(void):");
786
+ fflush(out);
787
+ *(Size15*)retp = r;
788
+ }}
789
+ void S16_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
790
+ {
791
+ if (data != (void*)&S16_v) { fprintf(out,"wrong data for S16_v\n"); exit(1); }
792
+ {Size16 r = Size16_1;
793
+ fprintf(out,"Size16 f(void):");
794
+ fflush(out);
795
+ *(Size16*)retp = r;
796
+ }}
797
+
798
+ /* structure tests */
799
+ void I_III_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
800
+ {
801
+ if (data != (void*)&I_III) { fprintf(out,"wrong data for I_III\n"); exit(1); }
802
+ {Int a = *(Int*)(*args++);
803
+ Int b = *(Int*)(*args++);
804
+ Int c = *(Int*)(*args++);
805
+ Int r;
806
+ r.x = a.x + b.x + c.x;
807
+ fprintf(out,"Int f(Int,Int,Int):({%d},{%d},{%d})",a.x,b.x,c.x);
808
+ fflush(out);
809
+ *(Int*)retp = r;
810
+ }}
811
+ void C_CdC_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
812
+ {
813
+ if (data != (void*)&C_CdC) { fprintf(out,"wrong data for C_CdC\n"); exit(1); }
814
+ {Char a = *(Char*)(*args++);
815
+ double b = *(double*)(*args++);
816
+ Char c = *(Char*)(*args++);
817
+ Char r;
818
+ r.x = (a.x + c.x)/2;
819
+ fprintf(out,"Char f(Char,double,Char):({'%c'},%g,{'%c'})",a.x,b,c.x);
820
+ fflush(out);
821
+ *(Char*)retp = r;
822
+ }}
823
+ void F_Ffd_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
824
+ {
825
+ if (data != (void*)&F_Ffd) { fprintf(out,"wrong data for F_Ffd\n"); exit(1); }
826
+ {Float a = *(Float*)(*args++);
827
+ float b = *(float*)(*args++);
828
+ double c = *(double*)(*args++);
829
+ Float r;
830
+ r.x = a.x + b + c;
831
+ fprintf(out,"Float f(Float,float,double):({%g},%g,%g)",a.x,b,c);
832
+ fflush(out);
833
+ *(Float*)retp = r;
834
+ }}
835
+ void D_fDd_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
836
+ {
837
+ if (data != (void*)&D_fDd) { fprintf(out,"wrong data for D_fDd\n"); exit(1); }
838
+ {float a = *(float*)(*args++);
839
+ Double b = *(Double*)(*args++);
840
+ double c = *(double*)(*args++);
841
+ Double r;
842
+ r.x = a + b.x + c;
843
+ fprintf(out,"Double f(float,Double,double):(%g,{%g},%g)",a,b.x,c);
844
+ fflush(out);
845
+ *(Double*)retp = r;
846
+ }}
847
+ void D_Dfd_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
848
+ {
849
+ if (data != (void*)&D_Dfd) { fprintf(out,"wrong data for D_Dfd\n"); exit(1); }
850
+ {Double a = *(Double*)(*args++);
851
+ float b = *(float*)(*args++);
852
+ double c = *(double*)(*args++);
853
+ Double r;
854
+ r.x = a.x + b + c;
855
+ fprintf(out,"Double f(Double,float,double):({%g},%g,%g)",a.x,b,c);
856
+ fflush(out);
857
+ *(Double*)retp = r;
858
+ }}
859
+ void J_JiJ_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
860
+ {
861
+ if (data != (void*)&J_JiJ) { fprintf(out,"wrong data for J_JiJ\n"); exit(1); }
862
+ {J a = *(J*)(*args++);
863
+ int b= *(int*)(*args++);
864
+ J c = *(J*)(*args++);
865
+ J r;
866
+ r.l1 = a.l1+c.l1; r.l2 = a.l2+b+c.l2;
867
+ fprintf(out,"J f(J,int,J):({%ld,%ld},%d,{%ld,%ld})",a.l1,a.l2,b,c.l1,c.l2);
868
+ fflush(out);
869
+ *(J*)retp = r;
870
+ }}
871
+ #ifndef SKIP_EXTRA_STRUCTS
872
+ void T_TcT_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
873
+ {
874
+ if (data != (void*)&T_TcT) { fprintf(out,"wrong data for T_TcT\n"); exit(1); }
875
+ {T a = *(T*)(*args++);
876
+ char b = *(char*)(*args++);
877
+ T c = *(T*)(*args++);
878
+ T r;
879
+ r.c[0]='b'; r.c[1]=c.c[1]; r.c[2]=c.c[2];
880
+ 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]);
881
+ fflush(out);
882
+ *(T*)retp = r;
883
+ }}
884
+ void X_BcdB_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
885
+ {
886
+ if (data != (void*)&X_BcdB) { fprintf(out,"wrong data for X_BcdB\n"); exit(1); }
887
+ {B a = *(B*)(*args++);
888
+ char b = *(char*)(*args++);
889
+ double c = *(double*)(*args++);
890
+ B d = *(B*)(*args++);
891
+ static X xr={"return val",'R'};
892
+ X r;
893
+ r = xr;
894
+ r.c1 = b;
895
+ fprintf(out,"X f(B,char,double,B):({%g,{%d,%d,%d}},'%c',%g,{%g,{%d,%d,%d}})",
896
+ a.d,a.i[0],a.i[1],a.i[2],b,c,d.d,d.i[0],d.i[1],d.i[2]);
897
+ fflush(out);
898
+ *(X*)retp = r;
899
+ }}
900
+ #endif
901
+
902
+ /* gpargs boundary tests */
903
+ void l_l0K_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
904
+ {
905
+ if (data != (void*)&l_l0K) { fprintf(out,"wrong data for l_l0K\n"); exit(1); }
906
+ {K b = *(K*)(*args++);
907
+ long c = *(long*)(*args++);
908
+ long r = b.l1 + b.l2 + b.l3 + b.l4 + c;
909
+ fprintf(out,"long f(K,long):(%ld,%ld,%ld,%ld,%ld)",b.l1,b.l2,b.l3,b.l4,c);
910
+ fflush(out);
911
+ *(ffi_arg*)retp = r;
912
+ }}
913
+ void l_l1K_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
914
+ {
915
+ if (data != (void*)&l_l1K) { fprintf(out,"wrong data for l_l1K\n"); exit(1); }
916
+ {long a1 = *(long*)(*args++);
917
+ K b = *(K*)(*args++);
918
+ long c = *(long*)(*args++);
919
+ long r = a1 + b.l1 + b.l2 + b.l3 + b.l4 + c;
920
+ fprintf(out,"long f(long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld)",a1,b.l1,b.l2,b.l3,b.l4,c);
921
+ fflush(out);
922
+ *(ffi_arg*)retp = r;
923
+ }}
924
+ void l_l2K_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
925
+ {
926
+ if (data != (void*)&l_l2K) { fprintf(out,"wrong data for l_l2K\n"); exit(1); }
927
+ {long a1 = *(long*)(*args++);
928
+ long a2 = *(long*)(*args++);
929
+ K b = *(K*)(*args++);
930
+ long c = *(long*)(*args++);
931
+ long r = a1 + a2 + b.l1 + b.l2 + b.l3 + b.l4 + c;
932
+ 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);
933
+ fflush(out);
934
+ *(ffi_arg*)retp = r;
935
+ }}
936
+ void l_l3K_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
937
+ {
938
+ if (data != (void*)&l_l3K) { fprintf(out,"wrong data for l_l3K\n"); exit(1); }
939
+ {long a1 = *(long*)(*args++);
940
+ long a2 = *(long*)(*args++);
941
+ long a3 = *(long*)(*args++);
942
+ K b = *(K*)(*args++);
943
+ long c = *(long*)(*args++);
944
+ long r = a1 + a2 + a3 + b.l1 + b.l2 + b.l3 + b.l4 + c;
945
+ 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);
946
+ fflush(out);
947
+ *(ffi_arg*)retp = r;
948
+ }}
949
+ void l_l4K_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
950
+ {
951
+ if (data != (void*)&l_l4K) { fprintf(out,"wrong data for l_l4K\n"); exit(1); }
952
+ {long a1 = *(long*)(*args++);
953
+ long a2 = *(long*)(*args++);
954
+ long a3 = *(long*)(*args++);
955
+ long a4 = *(long*)(*args++);
956
+ K b = *(K*)(*args++);
957
+ long c = *(long*)(*args++);
958
+ long r = a1 + a2 + a3 + a4 + b.l1 + b.l2 + b.l3 + b.l4 + c;
959
+ 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);
960
+ fflush(out);
961
+ *(ffi_arg*)retp = r;
962
+ }}
963
+ void l_l5K_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
964
+ {
965
+ if (data != (void*)&l_l5K) { fprintf(out,"wrong data for l_l5K\n"); exit(1); }
966
+ {long a1 = *(long*)(*args++);
967
+ long a2 = *(long*)(*args++);
968
+ long a3 = *(long*)(*args++);
969
+ long a4 = *(long*)(*args++);
970
+ long a5 = *(long*)(*args++);
971
+ K b = *(K*)(*args++);
972
+ long c = *(long*)(*args++);
973
+ long r = a1 + a2 + a3 + a4 + a5 + b.l1 + b.l2 + b.l3 + b.l4 + c;
974
+ 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);
975
+ fflush(out);
976
+ *(ffi_arg*)retp = r;
977
+ }}
978
+ void l_l6K_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
979
+ {
980
+ if (data != (void*)&l_l6K) { fprintf(out,"wrong data for l_l6K\n"); exit(1); }
981
+ {long a1 = *(long*)(*args++);
982
+ long a2 = *(long*)(*args++);
983
+ long a3 = *(long*)(*args++);
984
+ long a4 = *(long*)(*args++);
985
+ long a5 = *(long*)(*args++);
986
+ long a6 = *(long*)(*args++);
987
+ K b = *(K*)(*args++);
988
+ long c = *(long*)(*args++);
989
+ long r = a1 + a2 + a3 + a4 + a5 + a6 + b.l1 + b.l2 + b.l3 + b.l4 + c;
990
+ 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);
991
+ fflush(out);
992
+ *(ffi_arg*)retp = r;
993
+ }}
994
+ void f_f17l3L_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
995
+ {
996
+ if (data != (void*)&f_f17l3L) { fprintf(out,"wrong data for f_f17l3L\n"); exit(1); }
997
+ {float a = *(float*)(*args++);
998
+ float b = *(float*)(*args++);
999
+ float c = *(float*)(*args++);
1000
+ float d = *(float*)(*args++);
1001
+ float e = *(float*)(*args++);
1002
+ float f = *(float*)(*args++);
1003
+ float g = *(float*)(*args++);
1004
+ float h = *(float*)(*args++);
1005
+ float i = *(float*)(*args++);
1006
+ float j = *(float*)(*args++);
1007
+ float k = *(float*)(*args++);
1008
+ float l = *(float*)(*args++);
1009
+ float m = *(float*)(*args++);
1010
+ float n = *(float*)(*args++);
1011
+ float o = *(float*)(*args++);
1012
+ float p = *(float*)(*args++);
1013
+ float q = *(float*)(*args++);
1014
+ long s = *(long*)(*args++);
1015
+ long t = *(long*)(*args++);
1016
+ long u = *(long*)(*args++);
1017
+ L z = *(L*)(*args++);
1018
+ 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;
1019
+ 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);
1020
+ fflush(out);
1021
+ *(float*)retp = r;
1022
+ }}
1023
+ void d_d17l3L_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1024
+ {
1025
+ if (data != (void*)&d_d17l3L) { fprintf(out,"wrong data for d_d17l3L\n"); exit(1); }
1026
+ {double a = *(double*)(*args++);
1027
+ double b = *(double*)(*args++);
1028
+ double c = *(double*)(*args++);
1029
+ double d = *(double*)(*args++);
1030
+ double e = *(double*)(*args++);
1031
+ double f = *(double*)(*args++);
1032
+ double g = *(double*)(*args++);
1033
+ double h = *(double*)(*args++);
1034
+ double i = *(double*)(*args++);
1035
+ double j = *(double*)(*args++);
1036
+ double k = *(double*)(*args++);
1037
+ double l = *(double*)(*args++);
1038
+ double m = *(double*)(*args++);
1039
+ double n = *(double*)(*args++);
1040
+ double o = *(double*)(*args++);
1041
+ double p = *(double*)(*args++);
1042
+ double q = *(double*)(*args++);
1043
+ long s = *(long*)(*args++);
1044
+ long t = *(long*)(*args++);
1045
+ long u = *(long*)(*args++);
1046
+ L z = *(L*)(*args++);
1047
+ 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;
1048
+ 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);
1049
+ fflush(out);
1050
+ *(double*)retp = r;
1051
+ }}
1052
+ void ll_l2ll_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1053
+ {
1054
+ if (data != (void*)&ll_l2ll) { fprintf(out,"wrong data for ll_l2ll\n"); exit(1); }
1055
+ {long a1 = *(long*)(*args++);
1056
+ long a2 = *(long*)(*args++);
1057
+ long long b = *(long long *)(*args++);
1058
+ long c = *(long*)(*args++);
1059
+ long long r = (long long) (a1 + a2) + b + c;
1060
+ 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);
1061
+ fflush(out);
1062
+ *(long long *)retp = r;
1063
+ }}
1064
+ void ll_l3ll_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1065
+ {
1066
+ if (data != (void*)&ll_l3ll) { fprintf(out,"wrong data for ll_l3ll\n"); exit(1); }
1067
+ {long a1 = *(long*)(*args++);
1068
+ long a2 = *(long*)(*args++);
1069
+ long a3 = *(long*)(*args++);
1070
+ long long b = *(long long *)(*args++);
1071
+ long c = *(long*)(*args++);
1072
+ long long r = (long long) (a1 + a2 + a3) + b + c;
1073
+ 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);
1074
+ fflush(out);
1075
+ *(long long *)retp = r;
1076
+ }}
1077
+ void ll_l4ll_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1078
+ {
1079
+ if (data != (void*)&ll_l4ll) { fprintf(out,"wrong data for ll_l4ll\n"); exit(1); }
1080
+ {long a1 = *(long*)(*args++);
1081
+ long a2 = *(long*)(*args++);
1082
+ long a3 = *(long*)(*args++);
1083
+ long a4 = *(long*)(*args++);
1084
+ long long b = *(long long *)(*args++);
1085
+ long c = *(long*)(*args++);
1086
+ long long r = (long long) (a1 + a2 + a3 + a4) + b + c;
1087
+ 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);
1088
+ fflush(out);
1089
+ *(long long *)retp = r;
1090
+ }}
1091
+ void ll_l5ll_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1092
+ {
1093
+ if (data != (void*)&ll_l5ll) { fprintf(out,"wrong data for ll_l5ll\n"); exit(1); }
1094
+ {long a1 = *(long*)(*args++);
1095
+ long a2 = *(long*)(*args++);
1096
+ long a3 = *(long*)(*args++);
1097
+ long a4 = *(long*)(*args++);
1098
+ long a5 = *(long*)(*args++);
1099
+ long long b = *(long long *)(*args++);
1100
+ long c = *(long*)(*args++);
1101
+ long long r = (long long) (a1 + a2 + a3 + a4 + a5) + b + c;
1102
+ 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);
1103
+ fflush(out);
1104
+ *(long long *)retp = r;
1105
+ }}
1106
+ void ll_l6ll_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1107
+ {
1108
+ if (data != (void*)&ll_l6ll) { fprintf(out,"wrong data for ll_l6ll\n"); exit(1); }
1109
+ {long a1 = *(long*)(*args++);
1110
+ long a2 = *(long*)(*args++);
1111
+ long a3 = *(long*)(*args++);
1112
+ long a4 = *(long*)(*args++);
1113
+ long a5 = *(long*)(*args++);
1114
+ long a6 = *(long*)(*args++);
1115
+ long long b = *(long long *)(*args++);
1116
+ long c = *(long*)(*args++);
1117
+ long long r = (long long) (a1 + a2 + a3 + a4 + a5 + a6) + b + c;
1118
+ 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);
1119
+ fflush(out);
1120
+ *(long long *)retp = r;
1121
+ }}
1122
+ void ll_l7ll_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1123
+ {
1124
+ if (data != (void*)&ll_l7ll) { fprintf(out,"wrong data for ll_l7ll\n"); exit(1); }
1125
+ {long a1 = *(long*)(*args++);
1126
+ long a2 = *(long*)(*args++);
1127
+ long a3 = *(long*)(*args++);
1128
+ long a4 = *(long*)(*args++);
1129
+ long a5 = *(long*)(*args++);
1130
+ long a6 = *(long*)(*args++);
1131
+ long a7 = *(long*)(*args++);
1132
+ long long b = *(long long *)(*args++);
1133
+ long c = *(long*)(*args++);
1134
+ long long r = (long long) (a1 + a2 + a3 + a4 + a5 + a6 + a7) + b + c;
1135
+ 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);
1136
+ fflush(out);
1137
+ *(long long *)retp = r;
1138
+ }}
1139
+ void d_l2d_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1140
+ {
1141
+ if (data != (void*)&d_l2d) { fprintf(out,"wrong data for d_l2d\n"); exit(1); }
1142
+ {long a1 = *(long*)(*args++);
1143
+ long a2 = *(long*)(*args++);
1144
+ double b = *(double*)(*args++);
1145
+ long c = *(long*)(*args++);
1146
+ double r = (double) (a1 + a2) + b + c;
1147
+ fprintf(out,"double f(2*long,double,long):(%ld,%ld,%g,%ld)",a1,a2,b,c);
1148
+ fflush(out);
1149
+ *(double*)retp = r;
1150
+ }}
1151
+ void d_l3d_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1152
+ {
1153
+ if (data != (void*)&d_l3d) { fprintf(out,"wrong data for d_l3d\n"); exit(1); }
1154
+ {long a1 = *(long*)(*args++);
1155
+ long a2 = *(long*)(*args++);
1156
+ long a3 = *(long*)(*args++);
1157
+ double b = *(double*)(*args++);
1158
+ long c = *(long*)(*args++);
1159
+ double r = (double) (a1 + a2 + a3) + b + c;
1160
+ fprintf(out,"double f(3*long,double,long):(%ld,%ld,%ld,%g,%ld)",a1,a2,a3,b,c);
1161
+ fflush(out);
1162
+ *(double*)retp = r;
1163
+ }}
1164
+ void d_l4d_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1165
+ {
1166
+ if (data != (void*)&d_l4d) { fprintf(out,"wrong data for d_l4d\n"); exit(1); }
1167
+ {long a1 = *(long*)(*args++);
1168
+ long a2 = *(long*)(*args++);
1169
+ long a3 = *(long*)(*args++);
1170
+ long a4 = *(long*)(*args++);
1171
+ double b = *(double*)(*args++);
1172
+ long c = *(long*)(*args++);
1173
+ double r = (double) (a1 + a2 + a3 + a4) + b + c;
1174
+ fprintf(out,"double f(4*long,double,long):(%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,b,c);
1175
+ fflush(out);
1176
+ *(double*)retp = r;
1177
+ }}
1178
+ void d_l5d_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1179
+ {
1180
+ if (data != (void*)&d_l5d) { fprintf(out,"wrong data for d_l5d\n"); exit(1); }
1181
+ {long a1 = *(long*)(*args++);
1182
+ long a2 = *(long*)(*args++);
1183
+ long a3 = *(long*)(*args++);
1184
+ long a4 = *(long*)(*args++);
1185
+ long a5 = *(long*)(*args++);
1186
+ double b = *(double*)(*args++);
1187
+ long c = *(long*)(*args++);
1188
+ double r = (double) (a1 + a2 + a3 + a4 + a5) + b + c;
1189
+ fprintf(out,"double f(5*long,double,long):(%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,b,c);
1190
+ fflush(out);
1191
+ *(double*)retp = r;
1192
+ }}
1193
+ void d_l6d_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1194
+ {
1195
+ if (data != (void*)&d_l6d) { fprintf(out,"wrong data for d_l6d\n"); exit(1); }
1196
+ {long a1 = *(long*)(*args++);
1197
+ long a2 = *(long*)(*args++);
1198
+ long a3 = *(long*)(*args++);
1199
+ long a4 = *(long*)(*args++);
1200
+ long a5 = *(long*)(*args++);
1201
+ long a6 = *(long*)(*args++);
1202
+ double b = *(double*)(*args++);
1203
+ long c = *(long*)(*args++);
1204
+ double r = (double) (a1 + a2 + a3 + a4 + a5 + a6) + b + c;
1205
+ fprintf(out,"double f(6*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,b,c);
1206
+ fflush(out);
1207
+ *(double*)retp = r;
1208
+ }}
1209
+ void d_l7d_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
1210
+ {
1211
+ if (data != (void*)&d_l7d) { fprintf(out,"wrong data for d_l7d\n"); exit(1); }
1212
+ {long a1 = *(long*)(*args++);
1213
+ long a2 = *(long*)(*args++);
1214
+ long a3 = *(long*)(*args++);
1215
+ long a4 = *(long*)(*args++);
1216
+ long a5 = *(long*)(*args++);
1217
+ long a6 = *(long*)(*args++);
1218
+ long a7 = *(long*)(*args++);
1219
+ double b = *(double*)(*args++);
1220
+ long c = *(long*)(*args++);
1221
+ double r = (double) (a1 + a2 + a3 + a4 + a5 + a6 + a7) + b + c;
1222
+ 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);
1223
+ fflush(out);
1224
+ *(double*)retp = r;
1225
+ }}
1226
+
1227
+
1228
+ /*
1229
+ * The way we run these tests - first call the function directly, then
1230
+ * through vacall() - there is the danger that arguments or results seem
1231
+ * to be passed correctly, but what we are seeing are in fact the vestiges
1232
+ * (traces) or the previous call. This may seriously fake the test.
1233
+ * Avoid this by clearing the registers between the first and the second call.
1234
+ */
1235
+ long clear_traces_i (long a, long b, long c, long d, long e, long f, long g, long h,
1236
+ long i, long j, long k, long l, long m, long n, long o, long p)
1237
+ { return 0; }
1238
+ float clear_traces_f (float a, float b, float c, float d, float e, float f, float g,
1239
+ float h, float i, float j, float k, float l, float m, float n,
1240
+ float o, float p)
1241
+ { return 0.0; }
1242
+ double clear_traces_d (double a, double b, double c, double d, double e, double f, double g,
1243
+ double h, double i, double j, double k, double l, double m, double n,
1244
+ double o, double p)
1245
+ { return 0.0; }
1246
+ J clear_traces_J (void)
1247
+ { J j; j.l1 = j.l2 = 0; return j; }
1248
+ void clear_traces (void)
1249
+ { clear_traces_i(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
1250
+ 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);
1251
+ 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);
1252
+ clear_traces_J();
1253
+ }
1254
+
1255
+ int main (void)
1256
+ {
1257
+ void* callback_code;
1258
+ void* callback_writable;
1259
+ #define ALLOC_CALLBACK() \
1260
+ callback_writable = ffi_closure_alloc(sizeof(ffi_closure),&callback_code); \
1261
+ if (!callback_writable) abort()
1262
+ #define PREP_CALLBACK(cif,simulator,data) \
1263
+ if (ffi_prep_closure_loc(callback_writable,&(cif),simulator,data,callback_code) != FFI_OK) abort()
1264
+ #define FREE_CALLBACK() \
1265
+ ffi_closure_free(callback_writable)
1266
+
1267
+ ffi_type_char = (char)(-1) < 0 ? ffi_type_schar : ffi_type_uchar;
1268
+ out = stdout;
1269
+
1270
+ #if (!defined(DGTEST)) || DGTEST == 1
1271
+ /* void tests */
1272
+ v_v();
1273
+ clear_traces();
1274
+ ALLOC_CALLBACK();
1275
+ {
1276
+ ffi_cif cif;
1277
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_void);
1278
+ PREP_CALLBACK(cif,v_v_simulator,(void*)&v_v);
1279
+ ((void (ABI_ATTR *) (void)) callback_code) ();
1280
+ }
1281
+ FREE_CALLBACK();
1282
+ #endif
1283
+
1284
+ /* int tests */
1285
+ { int ir;
1286
+
1287
+ #if (!defined(DGTEST)) || DGTEST == 2
1288
+ ir = i_v();
1289
+ fprintf(out,"->%d\n",ir);
1290
+ fflush(out);
1291
+ ir = 0; clear_traces();
1292
+ ALLOC_CALLBACK();
1293
+ {
1294
+ ffi_cif cif;
1295
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_sint);
1296
+ PREP_CALLBACK(cif,i_v_simulator,(void*)&i_v);
1297
+ ir = ((int (ABI_ATTR *) (void)) callback_code) ();
1298
+ }
1299
+ FREE_CALLBACK();
1300
+ fprintf(out,"->%d\n",ir);
1301
+ fflush(out);
1302
+ #endif
1303
+
1304
+ #if (!defined(DGTEST)) || DGTEST == 3
1305
+ ir = i_i(i1);
1306
+ fprintf(out,"->%d\n",ir);
1307
+ fflush(out);
1308
+ ir = 0; clear_traces();
1309
+ ALLOC_CALLBACK();
1310
+ {
1311
+ ffi_type* argtypes[] = { &ffi_type_sint };
1312
+ ffi_cif cif;
1313
+ FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
1314
+ PREP_CALLBACK(cif,i_i_simulator,(void*)&i_i);
1315
+ ir = ((int (ABI_ATTR *) (int)) callback_code) (i1);
1316
+ }
1317
+ FREE_CALLBACK();
1318
+ fprintf(out,"->%d\n",ir);
1319
+ fflush(out);
1320
+ #endif
1321
+
1322
+ #if (!defined(DGTEST)) || DGTEST == 4
1323
+ ir = i_i2(i1,i2);
1324
+ fprintf(out,"->%d\n",ir);
1325
+ fflush(out);
1326
+ ir = 0; clear_traces();
1327
+ ALLOC_CALLBACK();
1328
+ {
1329
+ ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint };
1330
+ ffi_cif cif;
1331
+ FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
1332
+ PREP_CALLBACK(cif,i_i2_simulator,(void*)&i_i2);
1333
+ ir = ((int (ABI_ATTR *) (int,int)) callback_code) (i1,i2);
1334
+ }
1335
+ FREE_CALLBACK();
1336
+ fprintf(out,"->%d\n",ir);
1337
+ fflush(out);
1338
+ #endif
1339
+
1340
+ #if (!defined(DGTEST)) || DGTEST == 5
1341
+ ir = i_i4(i1,i2,i3,i4);
1342
+ fprintf(out,"->%d\n",ir);
1343
+ fflush(out);
1344
+ ir = 0; clear_traces();
1345
+ ALLOC_CALLBACK();
1346
+ {
1347
+ ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint };
1348
+ ffi_cif cif;
1349
+ FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
1350
+ PREP_CALLBACK(cif,i_i4_simulator,(void*)&i_i4);
1351
+ ir = ((int (ABI_ATTR *) (int,int,int,int)) callback_code) (i1,i2,i3,i4);
1352
+ }
1353
+ FREE_CALLBACK();
1354
+ fprintf(out,"->%d\n",ir);
1355
+ fflush(out);
1356
+ #endif
1357
+
1358
+ #if (!defined(DGTEST)) || DGTEST == 6
1359
+ ir = i_i8(i1,i2,i3,i4,i5,i6,i7,i8);
1360
+ fprintf(out,"->%d\n",ir);
1361
+ fflush(out);
1362
+ ir = 0; clear_traces();
1363
+ ALLOC_CALLBACK();
1364
+ {
1365
+ ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint };
1366
+ ffi_cif cif;
1367
+ FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
1368
+ PREP_CALLBACK(cif,i_i8_simulator,(void*)&i_i8);
1369
+ ir = ((int (ABI_ATTR *) (int,int,int,int,int,int,int,int)) callback_code) (i1,i2,i3,i4,i5,i6,i7,i8);
1370
+ }
1371
+ FREE_CALLBACK();
1372
+ fprintf(out,"->%d\n",ir);
1373
+ fflush(out);
1374
+ #endif
1375
+
1376
+ #if (!defined(DGTEST)) || DGTEST == 7
1377
+ ir = i_i16(i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16);
1378
+ fprintf(out,"->%d\n",ir);
1379
+ fflush(out);
1380
+ ir = 0; clear_traces();
1381
+ ALLOC_CALLBACK();
1382
+ {
1383
+ ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint };
1384
+ ffi_cif cif;
1385
+ FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
1386
+ PREP_CALLBACK(cif,i_i16_simulator,(void*)&i_i16);
1387
+ ir = ((int (ABI_ATTR *) (int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int)) callback_code) (i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16);
1388
+ }
1389
+ FREE_CALLBACK();
1390
+ fprintf(out,"->%d\n",ir);
1391
+ fflush(out);
1392
+ #endif
1393
+ }
1394
+
1395
+ /* float tests */
1396
+ { float fr;
1397
+
1398
+ #if (!defined(DGTEST)) || DGTEST == 8
1399
+ fr = f_f(f1);
1400
+ fprintf(out,"->%g\n",fr);
1401
+ fflush(out);
1402
+ fr = 0.0; clear_traces();
1403
+ ALLOC_CALLBACK();
1404
+ {
1405
+ ffi_type* argtypes[] = { &ffi_type_float };
1406
+ ffi_cif cif;
1407
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1408
+ PREP_CALLBACK(cif,f_f_simulator,(void*)&f_f);
1409
+ fr = ((float (ABI_ATTR *) (float)) callback_code) (f1);
1410
+ }
1411
+ FREE_CALLBACK();
1412
+ fprintf(out,"->%g\n",fr);
1413
+ fflush(out);
1414
+ #endif
1415
+
1416
+ #if (!defined(DGTEST)) || DGTEST == 9
1417
+ fr = f_f2(f1,f2);
1418
+ fprintf(out,"->%g\n",fr);
1419
+ fflush(out);
1420
+ fr = 0.0; clear_traces();
1421
+ ALLOC_CALLBACK();
1422
+ {
1423
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float };
1424
+ ffi_cif cif;
1425
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1426
+ PREP_CALLBACK(cif,f_f2_simulator,(void*)&f_f2);
1427
+ fr = ((float (ABI_ATTR *) (float,float)) callback_code) (f1,f2);
1428
+ }
1429
+ FREE_CALLBACK();
1430
+ fprintf(out,"->%g\n",fr);
1431
+ fflush(out);
1432
+ #endif
1433
+
1434
+ #if (!defined(DGTEST)) || DGTEST == 10
1435
+ fr = f_f4(f1,f2,f3,f4);
1436
+ fprintf(out,"->%g\n",fr);
1437
+ fflush(out);
1438
+ fr = 0.0; clear_traces();
1439
+ ALLOC_CALLBACK();
1440
+ {
1441
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
1442
+ ffi_cif cif;
1443
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1444
+ PREP_CALLBACK(cif,f_f4_simulator,(void*)&f_f4);
1445
+ fr = ((float (ABI_ATTR *) (float,float,float,float)) callback_code) (f1,f2,f3,f4);
1446
+ }
1447
+ FREE_CALLBACK();
1448
+ fprintf(out,"->%g\n",fr);
1449
+ fflush(out);
1450
+ #endif
1451
+
1452
+ #if (!defined(DGTEST)) || DGTEST == 11
1453
+ fr = f_f8(f1,f2,f3,f4,f5,f6,f7,f8);
1454
+ fprintf(out,"->%g\n",fr);
1455
+ fflush(out);
1456
+ fr = 0.0; clear_traces();
1457
+ ALLOC_CALLBACK();
1458
+ {
1459
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
1460
+ ffi_cif cif;
1461
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1462
+ PREP_CALLBACK(cif,f_f8_simulator,(void*)&f_f8);
1463
+ fr = ((float (ABI_ATTR *) (float,float,float,float,float,float,float,float)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8);
1464
+ }
1465
+ FREE_CALLBACK();
1466
+ fprintf(out,"->%g\n",fr);
1467
+ fflush(out);
1468
+ #endif
1469
+
1470
+ #if (!defined(DGTEST)) || DGTEST == 12
1471
+ fr = f_f16(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16);
1472
+ fprintf(out,"->%g\n",fr);
1473
+ fflush(out);
1474
+ fr = 0.0; clear_traces();
1475
+ ALLOC_CALLBACK();
1476
+ {
1477
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
1478
+ ffi_cif cif;
1479
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1480
+ PREP_CALLBACK(cif,f_f16_simulator,(void*)&f_f16);
1481
+ fr = ((float (ABI_ATTR *) (float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16);
1482
+ }
1483
+ FREE_CALLBACK();
1484
+ fprintf(out,"->%g\n",fr);
1485
+ fflush(out);
1486
+ #endif
1487
+
1488
+ #if (!defined(DGTEST)) || DGTEST == 13
1489
+ 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);
1490
+ fprintf(out,"->%g\n",fr);
1491
+ fflush(out);
1492
+ fr = 0.0; clear_traces();
1493
+ ALLOC_CALLBACK();
1494
+ {
1495
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
1496
+ ffi_cif cif;
1497
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1498
+ PREP_CALLBACK(cif,f_f24_simulator,(void*)&f_f24);
1499
+ fr = ((float (ABI_ATTR *) (float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18,f19,f20,f21,f22,f23,f24);
1500
+ }
1501
+ FREE_CALLBACK();
1502
+ fprintf(out,"->%g\n",fr);
1503
+ fflush(out);
1504
+ #endif
1505
+
1506
+ }
1507
+
1508
+ /* double tests */
1509
+ { double dr;
1510
+
1511
+ #if (!defined(DGTEST)) || DGTEST == 14
1512
+ dr = d_d(d1);
1513
+ fprintf(out,"->%g\n",dr);
1514
+ fflush(out);
1515
+ dr = 0.0; clear_traces();
1516
+ ALLOC_CALLBACK();
1517
+ {
1518
+ ffi_type* argtypes[] = { &ffi_type_double };
1519
+ ffi_cif cif;
1520
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1521
+ PREP_CALLBACK(cif,d_d_simulator,(void*)&d_d);
1522
+ dr = ((double (ABI_ATTR *) (double)) callback_code) (d1);
1523
+ }
1524
+ FREE_CALLBACK();
1525
+ fprintf(out,"->%g\n",dr);
1526
+ fflush(out);
1527
+ #endif
1528
+
1529
+ #if (!defined(DGTEST)) || DGTEST == 15
1530
+ dr = d_d2(d1,d2);
1531
+ fprintf(out,"->%g\n",dr);
1532
+ fflush(out);
1533
+ dr = 0.0; clear_traces();
1534
+ ALLOC_CALLBACK();
1535
+ {
1536
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double };
1537
+ ffi_cif cif;
1538
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1539
+ PREP_CALLBACK(cif,d_d2_simulator,(void*)&d_d2);
1540
+ dr = ((double (ABI_ATTR *) (double,double)) callback_code) (d1,d2);
1541
+ }
1542
+ FREE_CALLBACK();
1543
+ fprintf(out,"->%g\n",dr);
1544
+ fflush(out);
1545
+ #endif
1546
+
1547
+ #if (!defined(DGTEST)) || DGTEST == 16
1548
+ dr = d_d4(d1,d2,d3,d4);
1549
+ fprintf(out,"->%g\n",dr);
1550
+ fflush(out);
1551
+ dr = 0.0; clear_traces();
1552
+ ALLOC_CALLBACK();
1553
+ {
1554
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double };
1555
+ ffi_cif cif;
1556
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1557
+ PREP_CALLBACK(cif,d_d4_simulator,(void*)&d_d4);
1558
+ dr = ((double (ABI_ATTR *) (double,double,double,double)) callback_code) (d1,d2,d3,d4);
1559
+ }
1560
+ FREE_CALLBACK();
1561
+ fprintf(out,"->%g\n",dr);
1562
+ fflush(out);
1563
+ #endif
1564
+
1565
+ #if (!defined(DGTEST)) || DGTEST == 17
1566
+ dr = d_d8(d1,d2,d3,d4,d5,d6,d7,d8);
1567
+ fprintf(out,"->%g\n",dr);
1568
+ fflush(out);
1569
+ dr = 0.0; clear_traces();
1570
+ ALLOC_CALLBACK();
1571
+ {
1572
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double };
1573
+ ffi_cif cif;
1574
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1575
+ PREP_CALLBACK(cif,d_d8_simulator,(void*)&d_d8);
1576
+ dr = ((double (ABI_ATTR *) (double,double,double,double,double,double,double,double)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8);
1577
+ }
1578
+ FREE_CALLBACK();
1579
+ fprintf(out,"->%g\n",dr);
1580
+ fflush(out);
1581
+ #endif
1582
+
1583
+ #if (!defined(DGTEST)) || DGTEST == 18
1584
+ dr = d_d16(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16);
1585
+ fprintf(out,"->%g\n",dr);
1586
+ fflush(out);
1587
+ dr = 0.0; clear_traces();
1588
+ ALLOC_CALLBACK();
1589
+ {
1590
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double };
1591
+ ffi_cif cif;
1592
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1593
+ PREP_CALLBACK(cif,d_d16_simulator,(void*)&d_d16);
1594
+ dr = ((double (ABI_ATTR *) (double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,double)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16);
1595
+ }
1596
+ FREE_CALLBACK();
1597
+ fprintf(out,"->%g\n",dr);
1598
+ fflush(out);
1599
+ #endif
1600
+ }
1601
+
1602
+ /* pointer tests */
1603
+ { void* vpr;
1604
+
1605
+ #if (!defined(DGTEST)) || DGTEST == 19
1606
+ vpr = vp_vpdpcpsp(&uc1,&d2,str3,&I4);
1607
+ fprintf(out,"->0x%p\n",vpr);
1608
+ fflush(out);
1609
+ vpr = 0; clear_traces();
1610
+ ALLOC_CALLBACK();
1611
+ {
1612
+ ffi_type* argtypes[] = { &ffi_type_pointer, &ffi_type_pointer, &ffi_type_pointer, &ffi_type_pointer };
1613
+ ffi_cif cif;
1614
+ FFI_PREP_CIF(cif,argtypes,ffi_type_pointer);
1615
+ PREP_CALLBACK(cif,vp_vpdpcpsp_simulator,(void*)&vp_vpdpcpsp);
1616
+ vpr = ((void* (ABI_ATTR *) (void*,double*,char*,Int*)) callback_code) (&uc1,&d2,str3,&I4);
1617
+ }
1618
+ FREE_CALLBACK();
1619
+ fprintf(out,"->0x%p\n",vpr);
1620
+ fflush(out);
1621
+ #endif
1622
+ }
1623
+
1624
+ /* mixed number tests */
1625
+ { uchar ucr;
1626
+ ushort usr;
1627
+ float fr;
1628
+ double dr;
1629
+ long long llr;
1630
+
1631
+ #if (!defined(DGTEST)) || DGTEST == 20
1632
+ ucr = uc_ucsil(uc1,us2,ui3,ul4);
1633
+ fprintf(out,"->%u\n",ucr);
1634
+ fflush(out);
1635
+ ucr = 0; clear_traces();
1636
+ ALLOC_CALLBACK();
1637
+ {
1638
+ ffi_type* argtypes[] = { &ffi_type_uchar, &ffi_type_ushort, &ffi_type_uint, &ffi_type_ulong };
1639
+ ffi_cif cif;
1640
+ FFI_PREP_CIF(cif,argtypes,ffi_type_uchar);
1641
+ PREP_CALLBACK(cif,uc_ucsil_simulator,(void*)&uc_ucsil);
1642
+ ucr = ((uchar (ABI_ATTR *) (uchar,ushort,uint,ulong)) callback_code) (uc1,us2,ui3,ul4);
1643
+ }
1644
+ FREE_CALLBACK();
1645
+ fprintf(out,"->%u\n",ucr);
1646
+ fflush(out);
1647
+ #endif
1648
+
1649
+ #if (!defined(DGTEST)) || DGTEST == 21
1650
+ dr = d_iidd(i1,i2,d3,d4);
1651
+ fprintf(out,"->%g\n",dr);
1652
+ fflush(out);
1653
+ dr = 0.0; clear_traces();
1654
+ ALLOC_CALLBACK();
1655
+ {
1656
+ ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_double, &ffi_type_double };
1657
+ ffi_cif cif;
1658
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1659
+ PREP_CALLBACK(cif,d_iidd_simulator,(void*)&d_iidd);
1660
+ dr = ((double (ABI_ATTR *) (int,int,double,double)) callback_code) (i1,i2,d3,d4);
1661
+ }
1662
+ FREE_CALLBACK();
1663
+ fprintf(out,"->%g\n",dr);
1664
+ fflush(out);
1665
+ #endif
1666
+
1667
+ #if (!defined(DGTEST)) || DGTEST == 22
1668
+ dr = d_iiidi(i1,i2,i3,d4,i5);
1669
+ fprintf(out,"->%g\n",dr);
1670
+ fflush(out);
1671
+ dr = 0.0; clear_traces();
1672
+ ALLOC_CALLBACK();
1673
+ {
1674
+ ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_double, &ffi_type_sint };
1675
+ ffi_cif cif;
1676
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1677
+ PREP_CALLBACK(cif,d_iiidi_simulator,(void*)&d_iiidi);
1678
+ dr = ((double (ABI_ATTR *) (int,int,int,double,int)) callback_code) (i1,i2,i3,d4,i5);
1679
+ }
1680
+ FREE_CALLBACK();
1681
+ fprintf(out,"->%g\n",dr);
1682
+ fflush(out);
1683
+ #endif
1684
+
1685
+ #if (!defined(DGTEST)) || DGTEST == 23
1686
+ dr = d_idid(i1,d2,i3,d4);
1687
+ fprintf(out,"->%g\n",dr);
1688
+ fflush(out);
1689
+ dr = 0.0; clear_traces();
1690
+ ALLOC_CALLBACK();
1691
+ {
1692
+ ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_double, &ffi_type_sint, &ffi_type_double };
1693
+ ffi_cif cif;
1694
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1695
+ PREP_CALLBACK(cif,d_idid_simulator,(void*)&d_idid);
1696
+ dr = ((double (ABI_ATTR *) (int,double,int,double)) callback_code) (i1,d2,i3,d4);
1697
+ }
1698
+ FREE_CALLBACK();
1699
+ fprintf(out,"->%g\n",dr);
1700
+ fflush(out);
1701
+ #endif
1702
+
1703
+ #if (!defined(DGTEST)) || DGTEST == 24
1704
+ dr = d_fdi(f1,d2,i3);
1705
+ fprintf(out,"->%g\n",dr);
1706
+ fflush(out);
1707
+ dr = 0.0; clear_traces();
1708
+ ALLOC_CALLBACK();
1709
+ {
1710
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_double, &ffi_type_sint };
1711
+ ffi_cif cif;
1712
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1713
+ PREP_CALLBACK(cif,d_fdi_simulator,(void*)&d_fdi);
1714
+ dr = ((double (ABI_ATTR *) (float,double,int)) callback_code) (f1,d2,i3);
1715
+ }
1716
+ FREE_CALLBACK();
1717
+ fprintf(out,"->%g\n",dr);
1718
+ fflush(out);
1719
+ #endif
1720
+
1721
+ #if (!defined(DGTEST)) || DGTEST == 25
1722
+ usr = us_cdcd(c1,d2,c3,d4);
1723
+ fprintf(out,"->%u\n",usr);
1724
+ fflush(out);
1725
+ usr = 0; clear_traces();
1726
+ ALLOC_CALLBACK();
1727
+ {
1728
+ ffi_type* argtypes[] = { &ffi_type_char, &ffi_type_double, &ffi_type_char, &ffi_type_double };
1729
+ ffi_cif cif;
1730
+ FFI_PREP_CIF(cif,argtypes,ffi_type_ushort);
1731
+ PREP_CALLBACK(cif,us_cdcd_simulator,(void*)&us_cdcd);
1732
+ usr = ((ushort (ABI_ATTR *) (char,double,char,double)) callback_code) (c1,d2,c3,d4);
1733
+ }
1734
+ FREE_CALLBACK();
1735
+ fprintf(out,"->%u\n",usr);
1736
+ fflush(out);
1737
+ #endif
1738
+
1739
+ #if (!defined(DGTEST)) || DGTEST == 26
1740
+ llr = ll_iiilli(i1,i2,i3,ll1,i13);
1741
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
1742
+ fflush(out);
1743
+ llr = 0; clear_traces();
1744
+ ALLOC_CALLBACK();
1745
+ {
1746
+ ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_slonglong, &ffi_type_sint };
1747
+ ffi_cif cif;
1748
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
1749
+ PREP_CALLBACK(cif,ll_iiilli_simulator,(void*)&ll_iiilli);
1750
+ llr = ((long long (ABI_ATTR *) (int,int,int,long long,int)) callback_code) (i1,i2,i3,ll1,i13);
1751
+ }
1752
+ FREE_CALLBACK();
1753
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
1754
+ fflush(out);
1755
+ #endif
1756
+
1757
+ #if (!defined(DGTEST)) || DGTEST == 27
1758
+ llr = ll_flli(f13,ll1,i13);
1759
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
1760
+ fflush(out);
1761
+ llr = 0; clear_traces();
1762
+ ALLOC_CALLBACK();
1763
+ {
1764
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_slonglong, &ffi_type_sint };
1765
+ ffi_cif cif;
1766
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
1767
+ PREP_CALLBACK(cif,ll_flli_simulator,(void*)&ll_flli);
1768
+ llr = ((long long (ABI_ATTR *) (float,long long,int)) callback_code) (f13,ll1,i13);
1769
+ }
1770
+ FREE_CALLBACK();
1771
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
1772
+ fflush(out);
1773
+ #endif
1774
+
1775
+ #if (!defined(DGTEST)) || DGTEST == 28
1776
+ fr = f_fi(f1,i9);
1777
+ fprintf(out,"->%g\n",fr);
1778
+ fflush(out);
1779
+ fr = 0.0; clear_traces();
1780
+ ALLOC_CALLBACK();
1781
+ {
1782
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_sint };
1783
+ ffi_cif cif;
1784
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1785
+ PREP_CALLBACK(cif,f_fi_simulator,(void*)&f_fi);
1786
+ fr = ((float (ABI_ATTR *) (float,int)) callback_code) (f1,i9);
1787
+ }
1788
+ FREE_CALLBACK();
1789
+ fprintf(out,"->%g\n",fr);
1790
+ fflush(out);
1791
+ #endif
1792
+
1793
+ #if (!defined(DGTEST)) || DGTEST == 29
1794
+ fr = f_f2i(f1,f2,i9);
1795
+ fprintf(out,"->%g\n",fr);
1796
+ fflush(out);
1797
+ fr = 0.0; clear_traces();
1798
+ ALLOC_CALLBACK();
1799
+ {
1800
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_sint };
1801
+ ffi_cif cif;
1802
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1803
+ PREP_CALLBACK(cif,f_f2i_simulator,(void*)&f_f2i);
1804
+ fr = ((float (ABI_ATTR *) (float,float,int)) callback_code) (f1,f2,i9);
1805
+ }
1806
+ FREE_CALLBACK();
1807
+ fprintf(out,"->%g\n",fr);
1808
+ fflush(out);
1809
+ #endif
1810
+
1811
+ #if (!defined(DGTEST)) || DGTEST == 30
1812
+ fr = f_f3i(f1,f2,f3,i9);
1813
+ fprintf(out,"->%g\n",fr);
1814
+ fflush(out);
1815
+ fr = 0.0; clear_traces();
1816
+ ALLOC_CALLBACK();
1817
+ {
1818
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
1819
+ ffi_cif cif;
1820
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1821
+ PREP_CALLBACK(cif,f_f3i_simulator,(void*)&f_f3i);
1822
+ fr = ((float (ABI_ATTR *) (float,float,float,int)) callback_code) (f1,f2,f3,i9);
1823
+ }
1824
+ FREE_CALLBACK();
1825
+ fprintf(out,"->%g\n",fr);
1826
+ fflush(out);
1827
+ #endif
1828
+
1829
+ #if (!defined(DGTEST)) || DGTEST == 31
1830
+ fr = f_f4i(f1,f2,f3,f4,i9);
1831
+ fprintf(out,"->%g\n",fr);
1832
+ fflush(out);
1833
+ fr = 0.0; clear_traces();
1834
+ ALLOC_CALLBACK();
1835
+ {
1836
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
1837
+ ffi_cif cif;
1838
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1839
+ PREP_CALLBACK(cif,f_f4i_simulator,(void*)&f_f4i);
1840
+ fr = ((float (ABI_ATTR *) (float,float,float,float,int)) callback_code) (f1,f2,f3,f4,i9);
1841
+ }
1842
+ FREE_CALLBACK();
1843
+ fprintf(out,"->%g\n",fr);
1844
+ fflush(out);
1845
+ #endif
1846
+
1847
+ #if (!defined(DGTEST)) || DGTEST == 32
1848
+ fr = f_f7i(f1,f2,f3,f4,f5,f6,f7,i9);
1849
+ fprintf(out,"->%g\n",fr);
1850
+ fflush(out);
1851
+ fr = 0.0; clear_traces();
1852
+ ALLOC_CALLBACK();
1853
+ {
1854
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
1855
+ ffi_cif cif;
1856
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1857
+ PREP_CALLBACK(cif,f_f7i_simulator,(void*)&f_f7i);
1858
+ fr = ((float (ABI_ATTR *) (float,float,float,float,float,float,float,int)) callback_code) (f1,f2,f3,f4,f5,f6,f7,i9);
1859
+ }
1860
+ FREE_CALLBACK();
1861
+ fprintf(out,"->%g\n",fr);
1862
+ fflush(out);
1863
+ #endif
1864
+
1865
+ #if (!defined(DGTEST)) || DGTEST == 33
1866
+ fr = f_f8i(f1,f2,f3,f4,f5,f6,f7,f8,i9);
1867
+ fprintf(out,"->%g\n",fr);
1868
+ fflush(out);
1869
+ fr = 0.0; clear_traces();
1870
+ ALLOC_CALLBACK();
1871
+ {
1872
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
1873
+ ffi_cif cif;
1874
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1875
+ PREP_CALLBACK(cif,f_f8i_simulator,(void*)&f_f8i);
1876
+ fr = ((float (ABI_ATTR *) (float,float,float,float,float,float,float,float,int)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8,i9);
1877
+ }
1878
+ FREE_CALLBACK();
1879
+ fprintf(out,"->%g\n",fr);
1880
+ fflush(out);
1881
+ #endif
1882
+
1883
+ #if (!defined(DGTEST)) || DGTEST == 34
1884
+ fr = f_f13i(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,i9);
1885
+ fprintf(out,"->%g\n",fr);
1886
+ fflush(out);
1887
+ fr = 0.0; clear_traces();
1888
+ ALLOC_CALLBACK();
1889
+ {
1890
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
1891
+ ffi_cif cif;
1892
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
1893
+ PREP_CALLBACK(cif,f_f13i_simulator,(void*)&f_f13i);
1894
+ fr = ((float (ABI_ATTR *) (float,float,float,float,float,float,float,float,float,float,float,float,float,int)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,i9);
1895
+ }
1896
+ FREE_CALLBACK();
1897
+ fprintf(out,"->%g\n",fr);
1898
+ fflush(out);
1899
+ #endif
1900
+
1901
+ #if (!defined(DGTEST)) || DGTEST == 35
1902
+ dr = d_di(d1,i9);
1903
+ fprintf(out,"->%g\n",dr);
1904
+ fflush(out);
1905
+ dr = 0.0; clear_traces();
1906
+ ALLOC_CALLBACK();
1907
+ {
1908
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_sint };
1909
+ ffi_cif cif;
1910
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1911
+ PREP_CALLBACK(cif,d_di_simulator,(void*)&d_di);
1912
+ dr = ((double (ABI_ATTR *) (double,int)) callback_code) (d1,i9);
1913
+ }
1914
+ FREE_CALLBACK();
1915
+ fprintf(out,"->%g\n",dr);
1916
+ fflush(out);
1917
+ #endif
1918
+
1919
+ #if (!defined(DGTEST)) || DGTEST == 36
1920
+ dr = d_d2i(d1,d2,i9);
1921
+ fprintf(out,"->%g\n",dr);
1922
+ fflush(out);
1923
+ dr = 0.0; clear_traces();
1924
+ ALLOC_CALLBACK();
1925
+ {
1926
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_sint };
1927
+ ffi_cif cif;
1928
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1929
+ PREP_CALLBACK(cif,d_d2i_simulator,(void*)&d_d2i);
1930
+ dr = ((double (ABI_ATTR *) (double,double,int)) callback_code) (d1,d2,i9);
1931
+ }
1932
+ FREE_CALLBACK();
1933
+ fprintf(out,"->%g\n",dr);
1934
+ fflush(out);
1935
+ #endif
1936
+
1937
+ #if (!defined(DGTEST)) || DGTEST == 37
1938
+ dr = d_d3i(d1,d2,d3,i9);
1939
+ fprintf(out,"->%g\n",dr);
1940
+ fflush(out);
1941
+ dr = 0.0; clear_traces();
1942
+ ALLOC_CALLBACK();
1943
+ {
1944
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
1945
+ ffi_cif cif;
1946
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1947
+ PREP_CALLBACK(cif,d_d3i_simulator,(void*)&d_d3i);
1948
+ dr = ((double (ABI_ATTR *) (double,double,double,int)) callback_code) (d1,d2,d3,i9);
1949
+ }
1950
+ FREE_CALLBACK();
1951
+ fprintf(out,"->%g\n",dr);
1952
+ fflush(out);
1953
+ #endif
1954
+
1955
+ #if (!defined(DGTEST)) || DGTEST == 38
1956
+ dr = d_d4i(d1,d2,d3,d4,i9);
1957
+ fprintf(out,"->%g\n",dr);
1958
+ fflush(out);
1959
+ dr = 0.0; clear_traces();
1960
+ ALLOC_CALLBACK();
1961
+ {
1962
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
1963
+ ffi_cif cif;
1964
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1965
+ PREP_CALLBACK(cif,d_d4i_simulator,(void*)&d_d4i);
1966
+ dr = ((double (ABI_ATTR *) (double,double,double,double,int)) callback_code) (d1,d2,d3,d4,i9);
1967
+ }
1968
+ FREE_CALLBACK();
1969
+ fprintf(out,"->%g\n",dr);
1970
+ fflush(out);
1971
+ #endif
1972
+
1973
+ #if (!defined(DGTEST)) || DGTEST == 39
1974
+ dr = d_d7i(d1,d2,d3,d4,d5,d6,d7,i9);
1975
+ fprintf(out,"->%g\n",dr);
1976
+ fflush(out);
1977
+ dr = 0.0; clear_traces();
1978
+ ALLOC_CALLBACK();
1979
+ {
1980
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
1981
+ ffi_cif cif;
1982
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
1983
+ PREP_CALLBACK(cif,d_d7i_simulator,(void*)&d_d7i);
1984
+ dr = ((double (ABI_ATTR *) (double,double,double,double,double,double,double,int)) callback_code) (d1,d2,d3,d4,d5,d6,d7,i9);
1985
+ }
1986
+ FREE_CALLBACK();
1987
+ fprintf(out,"->%g\n",dr);
1988
+ fflush(out);
1989
+ #endif
1990
+
1991
+ #if (!defined(DGTEST)) || DGTEST == 40
1992
+ dr = d_d8i(d1,d2,d3,d4,d5,d6,d7,d8,i9);
1993
+ fprintf(out,"->%g\n",dr);
1994
+ fflush(out);
1995
+ dr = 0.0; clear_traces();
1996
+ ALLOC_CALLBACK();
1997
+ {
1998
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
1999
+ ffi_cif cif;
2000
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
2001
+ PREP_CALLBACK(cif,d_d8i_simulator,(void*)&d_d8i);
2002
+ dr = ((double (ABI_ATTR *) (double,double,double,double,double,double,double,double,int)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8,i9);
2003
+ }
2004
+ FREE_CALLBACK();
2005
+ fprintf(out,"->%g\n",dr);
2006
+ fflush(out);
2007
+ #endif
2008
+
2009
+ #if (!defined(DGTEST)) || DGTEST == 41
2010
+ dr = d_d12i(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,i9);
2011
+ fprintf(out,"->%g\n",dr);
2012
+ fflush(out);
2013
+ dr = 0.0; clear_traces();
2014
+ ALLOC_CALLBACK();
2015
+ {
2016
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
2017
+ ffi_cif cif;
2018
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
2019
+ PREP_CALLBACK(cif,d_d12i_simulator,(void*)&d_d12i);
2020
+ dr = ((double (ABI_ATTR *) (double,double,double,double,double,double,double,double,double,double,double,double,int)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,i9);
2021
+ }
2022
+ FREE_CALLBACK();
2023
+ fprintf(out,"->%g\n",dr);
2024
+ fflush(out);
2025
+ #endif
2026
+
2027
+ #if (!defined(DGTEST)) || DGTEST == 42
2028
+ dr = d_d13i(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,i9);
2029
+ fprintf(out,"->%g\n",dr);
2030
+ fflush(out);
2031
+ dr = 0.0; clear_traces();
2032
+ ALLOC_CALLBACK();
2033
+ {
2034
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
2035
+ ffi_cif cif;
2036
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
2037
+ PREP_CALLBACK(cif,d_d13i_simulator,(void*)&d_d13i);
2038
+ dr = ((double (ABI_ATTR *) (double,double,double,double,double,double,double,double,double,double,double,double,double,int)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,i9);
2039
+ }
2040
+ FREE_CALLBACK();
2041
+ fprintf(out,"->%g\n",dr);
2042
+ fflush(out);
2043
+ #endif
2044
+ }
2045
+
2046
+ /* small structure return tests */
2047
+ #if (!defined(DGTEST)) || DGTEST == 43
2048
+ {
2049
+ Size1 r = S1_v();
2050
+ fprintf(out,"->{%c}\n",r.x1);
2051
+ fflush(out);
2052
+ memset(&r,0,sizeof(r)); clear_traces();
2053
+ ALLOC_CALLBACK();
2054
+ {
2055
+ ffi_type* ffi_type_Size1_elements[] = { &ffi_type_char, NULL };
2056
+ ffi_type ffi_type_Size1;
2057
+ ffi_type_Size1.type = FFI_TYPE_STRUCT;
2058
+ ffi_type_Size1.size = sizeof(Size1);
2059
+ ffi_type_Size1.alignment = alignof_slot(Size1);
2060
+ ffi_type_Size1.elements = ffi_type_Size1_elements;
2061
+ ffi_cif cif;
2062
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_Size1);
2063
+ PREP_CALLBACK(cif,S1_v_simulator,(void*)&S1_v);
2064
+ r = ((Size1 (ABI_ATTR *) (void)) callback_code) ();
2065
+ }
2066
+ FREE_CALLBACK();
2067
+ fprintf(out,"->{%c}\n",r.x1);
2068
+ fflush(out);
2069
+ }
2070
+ #endif
2071
+
2072
+ #if (!defined(DGTEST)) || DGTEST == 44
2073
+ {
2074
+ Size2 r = S2_v();
2075
+ fprintf(out,"->{%c%c}\n",r.x1,r.x2);
2076
+ fflush(out);
2077
+ memset(&r,0,sizeof(r)); clear_traces();
2078
+ ALLOC_CALLBACK();
2079
+ {
2080
+ ffi_type* ffi_type_Size2_elements[] = { &ffi_type_char, &ffi_type_char, NULL };
2081
+ ffi_type ffi_type_Size2;
2082
+ ffi_type_Size2.type = FFI_TYPE_STRUCT;
2083
+ ffi_type_Size2.size = sizeof(Size2);
2084
+ ffi_type_Size2.alignment = alignof_slot(Size2);
2085
+ ffi_type_Size2.elements = ffi_type_Size2_elements;
2086
+ ffi_cif cif;
2087
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_Size2);
2088
+ PREP_CALLBACK(cif,S2_v_simulator,(void*)&S2_v);
2089
+ r = ((Size2 (ABI_ATTR *) (void)) callback_code) ();
2090
+ }
2091
+ FREE_CALLBACK();
2092
+ fprintf(out,"->{%c%c}\n",r.x1,r.x2);
2093
+ fflush(out);
2094
+ }
2095
+ #endif
2096
+
2097
+ #if (!defined(DGTEST)) || DGTEST == 45
2098
+ {
2099
+ Size3 r = S3_v();
2100
+ fprintf(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
2101
+ fflush(out);
2102
+ memset(&r,0,sizeof(r)); clear_traces();
2103
+ ALLOC_CALLBACK();
2104
+ {
2105
+ ffi_type* ffi_type_Size3_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
2106
+ ffi_type ffi_type_Size3;
2107
+ ffi_type_Size3.type = FFI_TYPE_STRUCT;
2108
+ ffi_type_Size3.size = sizeof(Size3);
2109
+ ffi_type_Size3.alignment = alignof_slot(Size3);
2110
+ ffi_type_Size3.elements = ffi_type_Size3_elements;
2111
+ ffi_cif cif;
2112
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_Size3);
2113
+ PREP_CALLBACK(cif,S3_v_simulator,(void*)&S3_v);
2114
+ r = ((Size3 (ABI_ATTR *) (void)) callback_code) ();
2115
+ }
2116
+ FREE_CALLBACK();
2117
+ fprintf(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
2118
+ fflush(out);
2119
+ }
2120
+ #endif
2121
+
2122
+ #if (!defined(DGTEST)) || DGTEST == 46
2123
+ {
2124
+ Size4 r = S4_v();
2125
+ fprintf(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
2126
+ fflush(out);
2127
+ memset(&r,0,sizeof(r)); clear_traces();
2128
+ ALLOC_CALLBACK();
2129
+ {
2130
+ ffi_type* ffi_type_Size4_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
2131
+ ffi_type ffi_type_Size4;
2132
+ ffi_type_Size4.type = FFI_TYPE_STRUCT;
2133
+ ffi_type_Size4.size = sizeof(Size4);
2134
+ ffi_type_Size4.alignment = alignof_slot(Size4);
2135
+ ffi_type_Size4.elements = ffi_type_Size4_elements;
2136
+ ffi_cif cif;
2137
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_Size4);
2138
+ PREP_CALLBACK(cif,S4_v_simulator,(void*)&S4_v);
2139
+ r = ((Size4 (ABI_ATTR *) (void)) callback_code) ();
2140
+ }
2141
+ FREE_CALLBACK();
2142
+ fprintf(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
2143
+ fflush(out);
2144
+ }
2145
+ #endif
2146
+
2147
+ #if (!defined(DGTEST)) || DGTEST == 47
2148
+ {
2149
+ Size7 r = S7_v();
2150
+ fprintf(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
2151
+ fflush(out);
2152
+ memset(&r,0,sizeof(r)); clear_traces();
2153
+ ALLOC_CALLBACK();
2154
+ {
2155
+ ffi_type* ffi_type_Size7_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
2156
+ ffi_type ffi_type_Size7;
2157
+ ffi_type_Size7.type = FFI_TYPE_STRUCT;
2158
+ ffi_type_Size7.size = sizeof(Size7);
2159
+ ffi_type_Size7.alignment = alignof_slot(Size7);
2160
+ ffi_type_Size7.elements = ffi_type_Size7_elements;
2161
+ ffi_cif cif;
2162
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_Size7);
2163
+ PREP_CALLBACK(cif,S7_v_simulator,(void*)&S7_v);
2164
+ r = ((Size7 (ABI_ATTR *) (void)) callback_code) ();
2165
+ }
2166
+ FREE_CALLBACK();
2167
+ fprintf(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
2168
+ fflush(out);
2169
+ }
2170
+ #endif
2171
+
2172
+ #if (!defined(DGTEST)) || DGTEST == 48
2173
+ {
2174
+ Size8 r = S8_v();
2175
+ 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);
2176
+ fflush(out);
2177
+ memset(&r,0,sizeof(r)); clear_traces();
2178
+ ALLOC_CALLBACK();
2179
+ {
2180
+ ffi_type* ffi_type_Size8_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
2181
+ ffi_type ffi_type_Size8;
2182
+ ffi_type_Size8.type = FFI_TYPE_STRUCT;
2183
+ ffi_type_Size8.size = sizeof(Size8);
2184
+ ffi_type_Size8.alignment = alignof_slot(Size8);
2185
+ ffi_type_Size8.elements = ffi_type_Size8_elements;
2186
+ ffi_cif cif;
2187
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_Size8);
2188
+ PREP_CALLBACK(cif,S8_v_simulator,(void*)&S8_v);
2189
+ r = ((Size8 (ABI_ATTR *) (void)) callback_code) ();
2190
+ }
2191
+ FREE_CALLBACK();
2192
+ 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);
2193
+ fflush(out);
2194
+ }
2195
+ #endif
2196
+
2197
+ #if (!defined(DGTEST)) || DGTEST == 49
2198
+ {
2199
+ Size12 r = S12_v();
2200
+ 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);
2201
+ fflush(out);
2202
+ memset(&r,0,sizeof(r)); clear_traces();
2203
+ ALLOC_CALLBACK();
2204
+ {
2205
+ ffi_type* ffi_type_Size12_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
2206
+ ffi_type ffi_type_Size12;
2207
+ ffi_type_Size12.type = FFI_TYPE_STRUCT;
2208
+ ffi_type_Size12.size = sizeof(Size12);
2209
+ ffi_type_Size12.alignment = alignof_slot(Size12);
2210
+ ffi_type_Size12.elements = ffi_type_Size12_elements;
2211
+ ffi_cif cif;
2212
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_Size12);
2213
+ PREP_CALLBACK(cif,S12_v_simulator,(void*)&S12_v);
2214
+ r = ((Size12 (ABI_ATTR *) (void)) callback_code) ();
2215
+ }
2216
+ FREE_CALLBACK();
2217
+ 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);
2218
+ fflush(out);
2219
+ }
2220
+ #endif
2221
+
2222
+ #if (!defined(DGTEST)) || DGTEST == 50
2223
+ {
2224
+ Size15 r = S15_v();
2225
+ 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);
2226
+ fflush(out);
2227
+ memset(&r,0,sizeof(r)); clear_traces();
2228
+ ALLOC_CALLBACK();
2229
+ {
2230
+ ffi_type* ffi_type_Size15_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
2231
+ ffi_type ffi_type_Size15;
2232
+ ffi_type_Size15.type = FFI_TYPE_STRUCT;
2233
+ ffi_type_Size15.size = sizeof(Size15);
2234
+ ffi_type_Size15.alignment = alignof_slot(Size15);
2235
+ ffi_type_Size15.elements = ffi_type_Size15_elements;
2236
+ ffi_cif cif;
2237
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_Size15);
2238
+ PREP_CALLBACK(cif,S15_v_simulator,(void*)&S15_v);
2239
+ r = ((Size15 (ABI_ATTR *) (void)) callback_code) ();
2240
+ }
2241
+ FREE_CALLBACK();
2242
+ 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);
2243
+ fflush(out);
2244
+ }
2245
+ #endif
2246
+
2247
+ #if (!defined(DGTEST)) || DGTEST == 51
2248
+ {
2249
+ Size16 r = S16_v();
2250
+ 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);
2251
+ fflush(out);
2252
+ memset(&r,0,sizeof(r)); clear_traces();
2253
+ ALLOC_CALLBACK();
2254
+ {
2255
+ ffi_type* ffi_type_Size16_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
2256
+ ffi_type ffi_type_Size16;
2257
+ ffi_type_Size16.type = FFI_TYPE_STRUCT;
2258
+ ffi_type_Size16.size = sizeof(Size16);
2259
+ ffi_type_Size16.alignment = alignof_slot(Size16);
2260
+ ffi_type_Size16.elements = ffi_type_Size16_elements;
2261
+ ffi_cif cif;
2262
+ FFI_PREP_CIF_NOARGS(cif,ffi_type_Size16);
2263
+ PREP_CALLBACK(cif,S16_v_simulator,(void*)&S16_v);
2264
+ r = ((Size16 (ABI_ATTR *) (void)) callback_code) ();
2265
+ }
2266
+ FREE_CALLBACK();
2267
+ 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);
2268
+ fflush(out);
2269
+ }
2270
+ #endif
2271
+
2272
+
2273
+ /* structure tests */
2274
+ { Int Ir;
2275
+ Char Cr;
2276
+ Float Fr;
2277
+ Double Dr;
2278
+ J Jr;
2279
+ #ifndef SKIP_EXTRA_STRUCTS
2280
+ T Tr;
2281
+ X Xr;
2282
+ #endif
2283
+
2284
+ #if (!defined(DGTEST)) || DGTEST == 52
2285
+ Ir = I_III(I1,I2,I3);
2286
+ fprintf(out,"->{%d}\n",Ir.x);
2287
+ fflush(out);
2288
+ Ir.x = 0; clear_traces();
2289
+ ALLOC_CALLBACK();
2290
+ {
2291
+ ffi_type* ffi_type_Int_elements[] = { &ffi_type_sint, NULL };
2292
+ ffi_type ffi_type_Int;
2293
+ ffi_type_Int.type = FFI_TYPE_STRUCT;
2294
+ ffi_type_Int.size = sizeof(Int);
2295
+ ffi_type_Int.alignment = alignof_slot(Int);
2296
+ ffi_type_Int.elements = ffi_type_Int_elements;
2297
+ ffi_type* argtypes[] = { &ffi_type_Int, &ffi_type_Int, &ffi_type_Int };
2298
+ ffi_cif cif;
2299
+ FFI_PREP_CIF(cif,argtypes,ffi_type_Int);
2300
+ PREP_CALLBACK(cif,I_III_simulator,(void*)&I_III);
2301
+ Ir = ((Int (ABI_ATTR *) (Int,Int,Int)) callback_code) (I1,I2,I3);
2302
+ }
2303
+ FREE_CALLBACK();
2304
+ fprintf(out,"->{%d}\n",Ir.x);
2305
+ fflush(out);
2306
+ #endif
2307
+
2308
+ #if (!defined(DGTEST)) || DGTEST == 53
2309
+ Cr = C_CdC(C1,d2,C3);
2310
+ fprintf(out,"->{'%c'}\n",Cr.x);
2311
+ fflush(out);
2312
+ Cr.x = '\0'; clear_traces();
2313
+ ALLOC_CALLBACK();
2314
+ {
2315
+ ffi_type* ffi_type_Char_elements[] = { &ffi_type_char, NULL };
2316
+ ffi_type ffi_type_Char;
2317
+ ffi_type_Char.type = FFI_TYPE_STRUCT;
2318
+ ffi_type_Char.size = sizeof(Char);
2319
+ ffi_type_Char.alignment = alignof_slot(Char);
2320
+ ffi_type_Char.elements = ffi_type_Char_elements;
2321
+ ffi_type* argtypes[] = { &ffi_type_Char, &ffi_type_double, &ffi_type_Char };
2322
+ ffi_cif cif;
2323
+ FFI_PREP_CIF(cif,argtypes,ffi_type_Char);
2324
+ PREP_CALLBACK(cif,C_CdC_simulator,(void*)&C_CdC);
2325
+ Cr = ((Char (ABI_ATTR *) (Char,double,Char)) callback_code) (C1,d2,C3);
2326
+ }
2327
+ FREE_CALLBACK();
2328
+ fprintf(out,"->{'%c'}\n",Cr.x);
2329
+ fflush(out);
2330
+ #endif
2331
+
2332
+ #if (!defined(DGTEST)) || DGTEST == 54
2333
+ Fr = F_Ffd(F1,f2,d3);
2334
+ fprintf(out,"->{%g}\n",Fr.x);
2335
+ fflush(out);
2336
+ Fr.x = 0.0; clear_traces();
2337
+ ALLOC_CALLBACK();
2338
+ {
2339
+ ffi_type* ffi_type_Float_elements[] = { &ffi_type_float, NULL };
2340
+ ffi_type ffi_type_Float;
2341
+ ffi_type_Float.type = FFI_TYPE_STRUCT;
2342
+ ffi_type_Float.size = sizeof(Float);
2343
+ ffi_type_Float.alignment = alignof_slot(Float);
2344
+ ffi_type_Float.elements = ffi_type_Float_elements;
2345
+ ffi_type* argtypes[] = { &ffi_type_Float, &ffi_type_float, &ffi_type_double };
2346
+ ffi_cif cif;
2347
+ FFI_PREP_CIF(cif,argtypes,ffi_type_Float);
2348
+ PREP_CALLBACK(cif,F_Ffd_simulator,(void*)&F_Ffd);
2349
+ Fr = ((Float (ABI_ATTR *) (Float,float,double)) callback_code) (F1,f2,d3);
2350
+ }
2351
+ FREE_CALLBACK();
2352
+ fprintf(out,"->{%g}\n",Fr.x);
2353
+ fflush(out);
2354
+ #endif
2355
+
2356
+ #if (!defined(DGTEST)) || DGTEST == 55
2357
+ Dr = D_fDd(f1,D2,d3);
2358
+ fprintf(out,"->{%g}\n",Dr.x);
2359
+ fflush(out);
2360
+ Dr.x = 0.0; clear_traces();
2361
+ ALLOC_CALLBACK();
2362
+ {
2363
+ ffi_type* ffi_type_Double_elements[] = { &ffi_type_double, NULL };
2364
+ ffi_type ffi_type_Double;
2365
+ ffi_type_Double.type = FFI_TYPE_STRUCT;
2366
+ ffi_type_Double.size = sizeof(Double);
2367
+ ffi_type_Double.alignment = alignof_slot(Double);
2368
+ ffi_type_Double.elements = ffi_type_Double_elements;
2369
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_Double, &ffi_type_double };
2370
+ ffi_cif cif;
2371
+ FFI_PREP_CIF(cif,argtypes,ffi_type_Double);
2372
+ PREP_CALLBACK(cif,D_fDd_simulator,(void*)&D_fDd);
2373
+ Dr = ((Double (ABI_ATTR *) (float,Double,double)) callback_code) (f1,D2,d3);
2374
+ }
2375
+ FREE_CALLBACK();
2376
+ fprintf(out,"->{%g}\n",Dr.x);
2377
+ fflush(out);
2378
+ #endif
2379
+
2380
+ #if (!defined(DGTEST)) || DGTEST == 56
2381
+ Dr = D_Dfd(D1,f2,d3);
2382
+ fprintf(out,"->{%g}\n",Dr.x);
2383
+ fflush(out);
2384
+ Dr.x = 0.0; clear_traces();
2385
+ ALLOC_CALLBACK();
2386
+ {
2387
+ ffi_type* ffi_type_Double_elements[] = { &ffi_type_double, NULL };
2388
+ ffi_type ffi_type_Double;
2389
+ ffi_type_Double.type = FFI_TYPE_STRUCT;
2390
+ ffi_type_Double.size = sizeof(Double);
2391
+ ffi_type_Double.alignment = alignof_slot(Double);
2392
+ ffi_type_Double.elements = ffi_type_Double_elements;
2393
+ ffi_type* argtypes[] = { &ffi_type_Double, &ffi_type_float, &ffi_type_double };
2394
+ ffi_cif cif;
2395
+ FFI_PREP_CIF(cif,argtypes,ffi_type_Double);
2396
+ PREP_CALLBACK(cif,D_Dfd_simulator,(void*)&D_Dfd);
2397
+ Dr = ((Double (ABI_ATTR *) (Double,float,double)) callback_code) (D1,f2,d3);
2398
+ }
2399
+ FREE_CALLBACK();
2400
+ fprintf(out,"->{%g}\n",Dr.x);
2401
+ fflush(out);
2402
+ #endif
2403
+
2404
+ #if (!defined(DGTEST)) || DGTEST == 57
2405
+ Jr = J_JiJ(J1,i2,J2);
2406
+ fprintf(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
2407
+ fflush(out);
2408
+ Jr.l1 = Jr.l2 = 0; clear_traces();
2409
+ ALLOC_CALLBACK();
2410
+ {
2411
+ ffi_type* ffi_type_J_elements[] = { &ffi_type_slong, &ffi_type_slong, NULL };
2412
+ ffi_type ffi_type_J;
2413
+ ffi_type_J.type = FFI_TYPE_STRUCT;
2414
+ ffi_type_J.size = sizeof(J);
2415
+ ffi_type_J.alignment = alignof_slot(J);
2416
+ ffi_type_J.elements = ffi_type_J_elements;
2417
+ ffi_type* argtypes[] = { &ffi_type_J, &ffi_type_sint, &ffi_type_J };
2418
+ ffi_cif cif;
2419
+ FFI_PREP_CIF(cif,argtypes,ffi_type_J);
2420
+ PREP_CALLBACK(cif,J_JiJ_simulator,(void*)&J_JiJ);
2421
+ Jr = ((J (ABI_ATTR *) (J,int,J)) callback_code) (J1,i2,J2);
2422
+ }
2423
+ FREE_CALLBACK();
2424
+ fprintf(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
2425
+ fflush(out);
2426
+ #endif
2427
+
2428
+ #ifndef SKIP_EXTRA_STRUCTS
2429
+ #if (!defined(DGTEST)) || DGTEST == 58
2430
+ Tr = T_TcT(T1,' ',T2);
2431
+ fprintf(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
2432
+ fflush(out);
2433
+ Tr.c[0] = Tr.c[1] = Tr.c[2] = 0; clear_traces();
2434
+ ALLOC_CALLBACK();
2435
+ {
2436
+ ffi_type* ffi_type_T_elements[] = { ??, NULL };
2437
+ ffi_type ffi_type_T;
2438
+ ffi_type_T.type = FFI_TYPE_STRUCT;
2439
+ ffi_type_T.size = sizeof(T);
2440
+ ffi_type_T.alignment = alignof_slot(T);
2441
+ ffi_type_T.elements = ffi_type_T_elements;
2442
+ ffi_type* argtypes[] = { &ffi_type_T, &ffi_type_char, &ffi_type_T };
2443
+ ffi_cif cif;
2444
+ FFI_PREP_CIF(cif,argtypes,ffi_type_T);
2445
+ PREP_CALLBACK(cif,T_TcT_simulator,(void*)&T_TcT);
2446
+ Tr = ((T (ABI_ATTR *) (T,char,T)) callback_code) (T1,' ',T2);
2447
+ }
2448
+ FREE_CALLBACK();
2449
+ fprintf(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
2450
+ fflush(out);
2451
+ #endif
2452
+
2453
+ #ifndef SKIP_X
2454
+ #if (!defined(DGTEST)) || DGTEST == 59
2455
+ Xr = X_BcdB(B1,c2,d3,B2);
2456
+ fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
2457
+ fflush(out);
2458
+ Xr.c[0]=Xr.c1='\0'; clear_traces();
2459
+ ALLOC_CALLBACK();
2460
+ {
2461
+ ffi_type* ffi_type_X_elements[] = { ??, NULL };
2462
+ ffi_type ffi_type_X;
2463
+ ffi_type_X.type = FFI_TYPE_STRUCT;
2464
+ ffi_type_X.size = sizeof(X);
2465
+ ffi_type_X.alignment = alignof_slot(X);
2466
+ ffi_type_X.elements = ffi_type_X_elements;
2467
+ ffi_type* argtypes[] = { &ffi_type_X, &ffi_type_char, &ffi_type_double, &ffi_type_X };
2468
+ ffi_cif cif;
2469
+ FFI_PREP_CIF(cif,argtypes,ffi_type_X);
2470
+ PREP_CALLBACK(cif,X_BcdB_simulator,(void*)&X_BcdB);
2471
+ Xr = ((X (ABI_ATTR *) (B,char,double,B)) callback_code) (B1,c2,d3,B2);
2472
+ }
2473
+ FREE_CALLBACK();
2474
+ fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
2475
+ fflush(out);
2476
+ #endif
2477
+ #endif
2478
+ #endif
2479
+ }
2480
+
2481
+
2482
+ /* gpargs boundary tests */
2483
+ {
2484
+ ffi_type* ffi_type_K_elements[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, NULL };
2485
+ ffi_type ffi_type_K;
2486
+ ffi_type* ffi_type_L_elements[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, NULL };
2487
+ ffi_type ffi_type_L;
2488
+ long lr;
2489
+ long long llr;
2490
+ float fr;
2491
+ double dr;
2492
+
2493
+ ffi_type_K.type = FFI_TYPE_STRUCT;
2494
+ ffi_type_K.size = sizeof(K);
2495
+ ffi_type_K.alignment = alignof_slot(K);
2496
+ ffi_type_K.elements = ffi_type_K_elements;
2497
+
2498
+ ffi_type_L.type = FFI_TYPE_STRUCT;
2499
+ ffi_type_L.size = sizeof(L);
2500
+ ffi_type_L.alignment = alignof_slot(L);
2501
+ ffi_type_L.elements = ffi_type_L_elements;
2502
+
2503
+ #if (!defined(DGTEST)) || DGTEST == 60
2504
+ lr = l_l0K(K1,l9);
2505
+ fprintf(out,"->%ld\n",lr);
2506
+ fflush(out);
2507
+ lr = 0; clear_traces();
2508
+ ALLOC_CALLBACK();
2509
+ {
2510
+ ffi_type* argtypes[] = { &ffi_type_K, &ffi_type_slong };
2511
+ ffi_cif cif;
2512
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
2513
+ PREP_CALLBACK(cif,l_l0K_simulator,(void*)l_l0K);
2514
+ lr = ((long (ABI_ATTR *) (K,long)) callback_code) (K1,l9);
2515
+ }
2516
+ FREE_CALLBACK();
2517
+ fprintf(out,"->%ld\n",lr);
2518
+ fflush(out);
2519
+ #endif
2520
+
2521
+ #if (!defined(DGTEST)) || DGTEST == 61
2522
+ lr = l_l1K(l1,K1,l9);
2523
+ fprintf(out,"->%ld\n",lr);
2524
+ fflush(out);
2525
+ lr = 0; clear_traces();
2526
+ ALLOC_CALLBACK();
2527
+ {
2528
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
2529
+ ffi_cif cif;
2530
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
2531
+ PREP_CALLBACK(cif,l_l1K_simulator,(void*)l_l1K);
2532
+ lr = ((long (ABI_ATTR *) (long,K,long)) callback_code) (l1,K1,l9);
2533
+ }
2534
+ FREE_CALLBACK();
2535
+ fprintf(out,"->%ld\n",lr);
2536
+ fflush(out);
2537
+ #endif
2538
+
2539
+ #if (!defined(DGTEST)) || DGTEST == 62
2540
+ lr = l_l2K(l1,l2,K1,l9);
2541
+ fprintf(out,"->%ld\n",lr);
2542
+ fflush(out);
2543
+ lr = 0; clear_traces();
2544
+ ALLOC_CALLBACK();
2545
+ {
2546
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
2547
+ ffi_cif cif;
2548
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
2549
+ PREP_CALLBACK(cif,l_l2K_simulator,(void*)l_l2K);
2550
+ lr = ((long (ABI_ATTR *) (long,long,K,long)) callback_code) (l1,l2,K1,l9);
2551
+ }
2552
+ FREE_CALLBACK();
2553
+ fprintf(out,"->%ld\n",lr);
2554
+ fflush(out);
2555
+ #endif
2556
+
2557
+ #if (!defined(DGTEST)) || DGTEST == 63
2558
+ lr = l_l3K(l1,l2,l3,K1,l9);
2559
+ fprintf(out,"->%ld\n",lr);
2560
+ fflush(out);
2561
+ lr = 0; clear_traces();
2562
+ ALLOC_CALLBACK();
2563
+ {
2564
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
2565
+ ffi_cif cif;
2566
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
2567
+ PREP_CALLBACK(cif,l_l3K_simulator,(void*)l_l3K);
2568
+ lr = ((long (ABI_ATTR *) (long,long,long,K,long)) callback_code) (l1,l2,l3,K1,l9);
2569
+ }
2570
+ FREE_CALLBACK();
2571
+ fprintf(out,"->%ld\n",lr);
2572
+ fflush(out);
2573
+ #endif
2574
+
2575
+ #if (!defined(DGTEST)) || DGTEST == 64
2576
+ lr = l_l4K(l1,l2,l3,l4,K1,l9);
2577
+ fprintf(out,"->%ld\n",lr);
2578
+ fflush(out);
2579
+ lr = 0; clear_traces();
2580
+ ALLOC_CALLBACK();
2581
+ {
2582
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
2583
+ ffi_cif cif;
2584
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
2585
+ PREP_CALLBACK(cif,l_l4K_simulator,(void*)l_l4K);
2586
+ lr = ((long (ABI_ATTR *) (long,long,long,long,K,long)) callback_code) (l1,l2,l3,l4,K1,l9);
2587
+ }
2588
+ FREE_CALLBACK();
2589
+ fprintf(out,"->%ld\n",lr);
2590
+ fflush(out);
2591
+ #endif
2592
+
2593
+ #if (!defined(DGTEST)) || DGTEST == 65
2594
+ lr = l_l5K(l1,l2,l3,l4,l5,K1,l9);
2595
+ fprintf(out,"->%ld\n",lr);
2596
+ fflush(out);
2597
+ lr = 0; clear_traces();
2598
+ ALLOC_CALLBACK();
2599
+ {
2600
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
2601
+ ffi_cif cif;
2602
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
2603
+ PREP_CALLBACK(cif,l_l5K_simulator,(void*)l_l5K);
2604
+ lr = ((long (ABI_ATTR *) (long,long,long,long,long,K,long)) callback_code) (l1,l2,l3,l4,l5,K1,l9);
2605
+ }
2606
+ FREE_CALLBACK();
2607
+ fprintf(out,"->%ld\n",lr);
2608
+ fflush(out);
2609
+ #endif
2610
+
2611
+ #if (!defined(DGTEST)) || DGTEST == 66
2612
+ lr = l_l6K(l1,l2,l3,l4,l5,l6,K1,l9);
2613
+ fprintf(out,"->%ld\n",lr);
2614
+ fflush(out);
2615
+ lr = 0; clear_traces();
2616
+ ALLOC_CALLBACK();
2617
+ {
2618
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
2619
+ ffi_cif cif;
2620
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
2621
+ PREP_CALLBACK(cif,l_l6K_simulator,(void*)l_l6K);
2622
+ lr = ((long (ABI_ATTR *) (long,long,long,long,long,long,K,long)) callback_code) (l1,l2,l3,l4,l5,l6,K1,l9);
2623
+ }
2624
+ FREE_CALLBACK();
2625
+ fprintf(out,"->%ld\n",lr);
2626
+ fflush(out);
2627
+ #endif
2628
+
2629
+ #if (!defined(DGTEST)) || DGTEST == 67
2630
+ fr = f_f17l3L(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,l6,l7,l8,L1);
2631
+ fprintf(out,"->%g\n",fr);
2632
+ fflush(out);
2633
+ fr = 0.0; clear_traces();
2634
+ ALLOC_CALLBACK();
2635
+ {
2636
+ ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_L };
2637
+ ffi_cif cif;
2638
+ FFI_PREP_CIF(cif,argtypes,ffi_type_float);
2639
+ PREP_CALLBACK(cif,f_f17l3L_simulator,(void*)&f_f17l3L);
2640
+ fr = ((float (ABI_ATTR *) (float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,long,long,long,L)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,l6,l7,l8,L1);
2641
+ }
2642
+ FREE_CALLBACK();
2643
+ fprintf(out,"->%g\n",fr);
2644
+ fflush(out);
2645
+ #endif
2646
+
2647
+ #if (!defined(DGTEST)) || DGTEST == 68
2648
+ dr = d_d17l3L(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,d17,l6,l7,l8,L1);
2649
+ fprintf(out,"->%g\n",dr);
2650
+ fflush(out);
2651
+ dr = 0.0; clear_traces();
2652
+ ALLOC_CALLBACK();
2653
+ {
2654
+ ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_L };
2655
+ ffi_cif cif;
2656
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
2657
+ PREP_CALLBACK(cif,d_d17l3L_simulator,(void*)&d_d17l3L);
2658
+ dr = ((double (ABI_ATTR *) (double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,long,long,long,L)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,d17,l6,l7,l8,L1);
2659
+ }
2660
+ FREE_CALLBACK();
2661
+ fprintf(out,"->%g\n",dr);
2662
+ fflush(out);
2663
+ #endif
2664
+
2665
+ #if (!defined(DGTEST)) || DGTEST == 69
2666
+ llr = ll_l2ll(l1,l2,ll1,l9);
2667
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2668
+ fflush(out);
2669
+ llr = 0; clear_traces();
2670
+ ALLOC_CALLBACK();
2671
+ {
2672
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
2673
+ ffi_cif cif;
2674
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
2675
+ PREP_CALLBACK(cif,ll_l2ll_simulator,(void*)ll_l2ll);
2676
+ llr = ((long long (ABI_ATTR *) (long,long,long long,long)) callback_code) (l1,l2,ll1,l9);
2677
+ }
2678
+ FREE_CALLBACK();
2679
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2680
+ fflush(out);
2681
+ #endif
2682
+
2683
+ #if (!defined(DGTEST)) || DGTEST == 70
2684
+ llr = ll_l3ll(l1,l2,l3,ll1,l9);
2685
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2686
+ fflush(out);
2687
+ llr = 0; clear_traces();
2688
+ ALLOC_CALLBACK();
2689
+ {
2690
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
2691
+ ffi_cif cif;
2692
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
2693
+ PREP_CALLBACK(cif,ll_l3ll_simulator,(void*)ll_l3ll);
2694
+ llr = ((long long (ABI_ATTR *) (long,long,long,long long,long)) callback_code) (l1,l2,l3,ll1,l9);
2695
+ }
2696
+ FREE_CALLBACK();
2697
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2698
+ fflush(out);
2699
+ #endif
2700
+
2701
+ #if (!defined(DGTEST)) || DGTEST == 71
2702
+ llr = ll_l4ll(l1,l2,l3,l4,ll1,l9);
2703
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2704
+ fflush(out);
2705
+ llr = 0; clear_traces();
2706
+ ALLOC_CALLBACK();
2707
+ {
2708
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
2709
+ ffi_cif cif;
2710
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
2711
+ PREP_CALLBACK(cif,ll_l4ll_simulator,(void*)ll_l4ll);
2712
+ llr = ((long long (ABI_ATTR *) (long,long,long,long,long long,long)) callback_code) (l1,l2,l3,l4,ll1,l9);
2713
+ }
2714
+ FREE_CALLBACK();
2715
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2716
+ fflush(out);
2717
+ #endif
2718
+
2719
+ #if (!defined(DGTEST)) || DGTEST == 72
2720
+ llr = ll_l5ll(l1,l2,l3,l4,l5,ll1,l9);
2721
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2722
+ fflush(out);
2723
+ llr = 0; clear_traces();
2724
+ ALLOC_CALLBACK();
2725
+ {
2726
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
2727
+ ffi_cif cif;
2728
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
2729
+ PREP_CALLBACK(cif,ll_l5ll_simulator,(void*)ll_l5ll);
2730
+ llr = ((long long (ABI_ATTR *) (long,long,long,long,long,long long,long)) callback_code) (l1,l2,l3,l4,l5,ll1,l9);
2731
+ }
2732
+ FREE_CALLBACK();
2733
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2734
+ fflush(out);
2735
+ #endif
2736
+
2737
+ #if (!defined(DGTEST)) || DGTEST == 73
2738
+ llr = ll_l6ll(l1,l2,l3,l4,l5,l6,ll1,l9);
2739
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2740
+ fflush(out);
2741
+ llr = 0; clear_traces();
2742
+ ALLOC_CALLBACK();
2743
+ {
2744
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
2745
+ ffi_cif cif;
2746
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
2747
+ PREP_CALLBACK(cif,ll_l6ll_simulator,(void*)ll_l6ll);
2748
+ llr = ((long long (ABI_ATTR *) (long,long,long,long,long,long,long long,long)) callback_code) (l1,l2,l3,l4,l5,l6,ll1,l9);
2749
+ }
2750
+ FREE_CALLBACK();
2751
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2752
+ fflush(out);
2753
+ #endif
2754
+
2755
+ #if (!defined(DGTEST)) || DGTEST == 74
2756
+ llr = ll_l7ll(l1,l2,l3,l4,l5,l6,l7,ll1,l9);
2757
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2758
+ fflush(out);
2759
+ llr = 0; clear_traces();
2760
+ ALLOC_CALLBACK();
2761
+ {
2762
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
2763
+ ffi_cif cif;
2764
+ FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
2765
+ PREP_CALLBACK(cif,ll_l7ll_simulator,(void*)ll_l7ll);
2766
+ llr = ((long long (ABI_ATTR *) (long,long,long,long,long,long,long,long long,long)) callback_code) (l1,l2,l3,l4,l5,l6,l7,ll1,l9);
2767
+ }
2768
+ FREE_CALLBACK();
2769
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
2770
+ fflush(out);
2771
+ #endif
2772
+
2773
+ #if (!defined(DGTEST)) || DGTEST == 75
2774
+ dr = d_l2d(l1,l2,ll1,l9);
2775
+ fprintf(out,"->%g\n",dr);
2776
+ fflush(out);
2777
+ dr = 0.0; clear_traces();
2778
+ ALLOC_CALLBACK();
2779
+ {
2780
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
2781
+ ffi_cif cif;
2782
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
2783
+ PREP_CALLBACK(cif,d_l2d_simulator,(void*)d_l2d);
2784
+ dr = ((double (ABI_ATTR *) (long,long,double,long)) callback_code) (l1,l2,ll1,l9);
2785
+ }
2786
+ FREE_CALLBACK();
2787
+ fprintf(out,"->%g\n",dr);
2788
+ fflush(out);
2789
+ #endif
2790
+
2791
+ #if (!defined(DGTEST)) || DGTEST == 76
2792
+ dr = d_l3d(l1,l2,l3,ll1,l9);
2793
+ fprintf(out,"->%g\n",dr);
2794
+ fflush(out);
2795
+ dr = 0.0; clear_traces();
2796
+ ALLOC_CALLBACK();
2797
+ {
2798
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
2799
+ ffi_cif cif;
2800
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
2801
+ PREP_CALLBACK(cif,d_l3d_simulator,(void*)d_l3d);
2802
+ dr = ((double (ABI_ATTR *) (long,long,long,double,long)) callback_code) (l1,l2,l3,ll1,l9);
2803
+ }
2804
+ FREE_CALLBACK();
2805
+ fprintf(out,"->%g\n",dr);
2806
+ fflush(out);
2807
+ #endif
2808
+
2809
+ #if (!defined(DGTEST)) || DGTEST == 77
2810
+ dr = d_l4d(l1,l2,l3,l4,ll1,l9);
2811
+ fprintf(out,"->%g\n",dr);
2812
+ fflush(out);
2813
+ dr = 0.0; clear_traces();
2814
+ ALLOC_CALLBACK();
2815
+ {
2816
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
2817
+ ffi_cif cif;
2818
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
2819
+ PREP_CALLBACK(cif,d_l4d_simulator,(void*)d_l4d);
2820
+ dr = ((double (ABI_ATTR *) (long,long,long,long,double,long)) callback_code) (l1,l2,l3,l4,ll1,l9);
2821
+ }
2822
+ FREE_CALLBACK();
2823
+ fprintf(out,"->%g\n",dr);
2824
+ fflush(out);
2825
+ #endif
2826
+
2827
+ #if (!defined(DGTEST)) || DGTEST == 78
2828
+ dr = d_l5d(l1,l2,l3,l4,l5,ll1,l9);
2829
+ fprintf(out,"->%g\n",dr);
2830
+ fflush(out);
2831
+ dr = 0.0; clear_traces();
2832
+ ALLOC_CALLBACK();
2833
+ {
2834
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
2835
+ ffi_cif cif;
2836
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
2837
+ PREP_CALLBACK(cif,d_l5d_simulator,(void*)d_l5d);
2838
+ dr = ((double (ABI_ATTR *) (long,long,long,long,long,double,long)) callback_code) (l1,l2,l3,l4,l5,ll1,l9);
2839
+ }
2840
+ FREE_CALLBACK();
2841
+ fprintf(out,"->%g\n",dr);
2842
+ fflush(out);
2843
+ #endif
2844
+
2845
+ #if (!defined(DGTEST)) || DGTEST == 79
2846
+ dr = d_l6d(l1,l2,l3,l4,l5,l6,ll1,l9);
2847
+ fprintf(out,"->%g\n",dr);
2848
+ fflush(out);
2849
+ dr = 0.0; clear_traces();
2850
+ ALLOC_CALLBACK();
2851
+ {
2852
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
2853
+ ffi_cif cif;
2854
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
2855
+ PREP_CALLBACK(cif,d_l6d_simulator,(void*)d_l6d);
2856
+ dr = ((double (ABI_ATTR *) (long,long,long,long,long,long,double,long)) callback_code) (l1,l2,l3,l4,l5,l6,ll1,l9);
2857
+ }
2858
+ FREE_CALLBACK();
2859
+ fprintf(out,"->%g\n",dr);
2860
+ fflush(out);
2861
+ #endif
2862
+
2863
+ #if (!defined(DGTEST)) || DGTEST == 80
2864
+ dr = d_l7d(l1,l2,l3,l4,l5,l6,l7,ll1,l9);
2865
+ fprintf(out,"->%g\n",dr);
2866
+ fflush(out);
2867
+ dr = 0.0; clear_traces();
2868
+ ALLOC_CALLBACK();
2869
+ {
2870
+ ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
2871
+ ffi_cif cif;
2872
+ FFI_PREP_CIF(cif,argtypes,ffi_type_double);
2873
+ PREP_CALLBACK(cif,d_l7d_simulator,(void*)d_l7d);
2874
+ dr = ((double (ABI_ATTR *) (long,long,long,long,long,long,long,double,long)) callback_code) (l1,l2,l3,l4,l5,l6,l7,ll1,l9);
2875
+ }
2876
+ FREE_CALLBACK();
2877
+ fprintf(out,"->%g\n",dr);
2878
+ fflush(out);
2879
+ #endif
2880
+
2881
+ }
2882
+
2883
+ exit(0);
2884
+ }
2885
+