Mercurial > pub > dyncall > dyncall

comparison test/plain/test_aggrs.c @ 627:c477ddd64718 r1.4-RC5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- test/plain: * added some aggregate-by-val-as-vararg cases * made output be more in line w/ sig format
author Tassilo Philipp
date Fri, 28 Oct 2022 15:08:21 +0200
parents 71c884e610f0
children 4754d195d2b5
comparison
equal deleted inserted replaced
626:667fe7b2be62 627:c477ddd64718
27 27
28 #include "../../dyncall/dyncall.h" 28 #include "../../dyncall/dyncall.h"
29 #include "../../dyncall/dyncall_signature.h" 29 #include "../../dyncall/dyncall_signature.h"
30 #include "../../dyncall/dyncall_aggregate.h" 30 #include "../../dyncall/dyncall_aggregate.h"
31 #include <stdio.h> 31 #include <stdio.h>
32 #include <stdarg.h>
32 33
33 34
34 #if defined(DC__Feature_AggrByVal) 35 #if defined(DC__Feature_AggrByVal)
35 36
36 #if !defined(DC__OS_Win32) 37 #if !defined(DC__OS_Win32)
136 137
137 dcCallAggr(vm, (DCpointer) &fun_return_u8, s, &returned); 138 dcCallAggr(vm, (DCpointer) &fun_return_u8, s, &returned);
138 139
139 dcFreeAggr(s); 140 dcFreeAggr(s);
140 141
141 printf("r:{C} (cdecl): %d\n", (returned.a == expected.a)); 142 printf("C){C} (cdecl): %d\n", (returned.a == expected.a));
142 ret = returned.a == expected.a && ret; 143 ret = returned.a == expected.a && ret;
143 } 144 }
144 { 145 {
145 U8_Double expected = fun_return_u8_double(5, 5.5), returned = { 6, 7.8 }; 146 U8_Double expected = fun_return_u8_double(5, 5.5), returned = { 6, 7.8 };
146 147
157 158
158 dcCallAggr(vm, (DCpointer) &fun_return_u8_double, s, &returned); 159 dcCallAggr(vm, (DCpointer) &fun_return_u8_double, s, &returned);
159 160
160 dcFreeAggr(s); 161 dcFreeAggr(s);
161 162
162 printf("r:{Cd} (cdecl): %d\n", (returned.a == expected.a && returned.b == expected.b)); 163 printf("Cd){Cd} (cdecl): %d\n", (returned.a == expected.a && returned.b == expected.b));
163 ret = returned.a == expected.a && returned.b == expected.b && ret; 164 ret = returned.a == expected.a && returned.b == expected.b && ret;
164 } 165 }
165 { 166 {
166 Double_U8 expected = fun_return_double_u8(5.5, 42), returned = { 6.7, 8 }; 167 Double_U8 expected = fun_return_double_u8(5.5, 42), returned = { 6.7, 8 };
167 168
178 179
179 dcCallAggr(vm, (DCpointer) &fun_return_double_u8, s, &returned); 180 dcCallAggr(vm, (DCpointer) &fun_return_double_u8, s, &returned);
180 181
181 dcFreeAggr(s); 182 dcFreeAggr(s);
182 183
183 printf("r:{dC} (cdecl): %d\n", (returned.a == expected.a && returned.b == expected.b)); 184 printf("dC){dC} (cdecl): %d\n", (returned.a == expected.a && returned.b == expected.b));
184 ret = returned.a == expected.a && returned.b == expected.b && ret; 185 ret = returned.a == expected.a && returned.b == expected.b && ret;
185 } 186 }
186 { 187 {
187 Int_NestedFloat expected = fun_return_int_nested_float(24, 2.5f), returned = { 25, { 3.5f } }; 188 Int_NestedFloat expected = fun_return_int_nested_float(24, 2.5f), returned = { 25, { 3.5f } };
188 DCaggr *s, *s_; 189 DCaggr *s, *s_;
204 dcCallAggr(vm, (DCpointer) &fun_return_int_nested_float, s, &returned); 205 dcCallAggr(vm, (DCpointer) &fun_return_int_nested_float, s, &returned);
205 206
206 dcFreeAggr(s_); 207 dcFreeAggr(s_);
207 dcFreeAggr(s); 208 dcFreeAggr(s);
208 209
209 printf("r:{i{f}} (cdecl): %d\n", (returned.a == expected.a && returned.b.f == expected.b.f)); 210 printf("if){i{f}} (cdecl): %d\n", (returned.a == expected.a && returned.b.f == expected.b.f));
210 ret = returned.a == expected.a && returned.b.f == expected.b.f && ret; 211 ret = returned.a == expected.a && returned.b.f == expected.b.f && ret;
211 } 212 }
212 { 213 {
213 Int_NestedDouble expected = fun_return_int_nested_double(24, 2.5), returned = { 25, { 3.5f } }; 214 Int_NestedDouble expected = fun_return_int_nested_double(24, 2.5), returned = { 25, { 3.5f } };
214 DCaggr *s, *s_; 215 DCaggr *s, *s_;
230 dcCallAggr(vm, (DCpointer) &fun_return_int_nested_double, s, &returned); 231 dcCallAggr(vm, (DCpointer) &fun_return_int_nested_double, s, &returned);
231 232
232 dcFreeAggr(s_); 233 dcFreeAggr(s_);
233 dcFreeAggr(s); 234 dcFreeAggr(s);
234 235
235 printf("r:{i{d}} (cdecl): %d\n", (returned.a == expected.a && returned.b.f == expected.b.f)); 236 printf("id){i{d}} (cdecl): %d\n", (returned.a == expected.a && returned.b.f == expected.b.f));
236 ret = returned.a == expected.a && returned.b.f == expected.b.f && ret; 237 ret = returned.a == expected.a && returned.b.f == expected.b.f && ret;
237 } 238 }
238 { 239 {
239 Three_Double expected = fun_return_three_double(1.5, 2.5, 3.5), returned = { 2.5, 3.5, 4.5 }; 240 Three_Double expected = fun_return_three_double(1.5, 2.5, 3.5), returned = { 2.5, 3.5, 4.5 };
240 241
253 254
254 dcCallAggr(vm, (DCpointer) &fun_return_three_double, s, &returned); 255 dcCallAggr(vm, (DCpointer) &fun_return_three_double, s, &returned);
255 256
256 dcFreeAggr(s); 257 dcFreeAggr(s);
257 258
258 printf("r:{ddd} (cdecl): %d\n", (returned.a == expected.a && returned.b == expected.b && returned.c == expected.c)); 259 printf("ddd){ddd} (cdecl): %d\n", (returned.a == expected.a && returned.b == expected.b && returned.c == expected.c));
259 ret = returned.a == expected.a && returned.b == expected.b && returned.c == expected.c && ret; 260 ret = returned.a == expected.a && returned.b == expected.b && returned.c == expected.c && ret;
260 } 261 }
261 262
262 dcFree(vm); 263 dcFree(vm);
263 264
272 static double __cdecl fun_take_int_nested_double(Int_NestedDouble s) { return s.a + s.b.f; } 273 static double __cdecl fun_take_int_nested_double(Int_NestedDouble s) { return s.a + s.b.f; }
273 static double __cdecl fun_take_three_double(Three_Double s) { return s.a + s.b + s.c; } 274 static double __cdecl fun_take_three_double(Three_Double s) { return s.a + s.b + s.c; }
274 static double __cdecl fun_take_mixed_fp(double a, float b, float c, int d, float e, double f, float g, Three_Double s) { return a + 2.*b + 3.*c + 4.*d + 5.*e + 6.*f + 7.*g + 8.*s.a + 9.*s.b + 10.*s.c; } 275 static double __cdecl fun_take_mixed_fp(double a, float b, float c, int d, float e, double f, float g, Three_Double s) { return a + 2.*b + 3.*c + 4.*d + 5.*e + 6.*f + 7.*g + 8.*s.a + 9.*s.b + 10.*s.c; }
275 static int __cdecl fun_take_iiiii_il(int a, int b, int c, int d, int e, Int_LongLong f) { return a + b + c + d + e + f.a + (int)f.b; } 276 static int __cdecl fun_take_iiiii_il(int a, int b, int c, int d, int e, Int_LongLong f) { return a + b + c + d + e + f.a + (int)f.b; }
276 static double __cdecl fun_take_more_than_regs(More_Than_Regs s) { return s.a + s.b + s.c + s.d + s.e + s.f + s.g + s.h + s.i + s.j + s.k + s.l + s.m + s.n + s.o + s.p + s.q + s.r; } 277 static double __cdecl fun_take_more_than_regs(More_Than_Regs s) { return s.a + s.b + s.c + s.d + s.e + s.f + s.g + s.h + s.i + s.j + s.k + s.l + s.m + s.n + s.o + s.p + s.q + s.r; }
278 static double __cdecl fun_take_mixed_fp_vararg(double a, float b, float c, int d, ...) { double r = a + 2.*b + 3.*c + 4.*d; va_list v; va_start(v,d); r += 5.*va_arg(v,double); r += 6.*va_arg(v,double); r += 7.*va_arg(v,double); Three_Double s = va_arg(v,Three_Double); va_end(v); return r + 8.*s.a + 9.*s.b + 10.*s.c; }
279 static int __cdecl fun_take_iiiii_il_vararg(int a, int b, int c, int d, int e, ...) { int r = a + b + c + d + e; va_list v; va_start(v,e); Int_LongLong f = va_arg(v,Int_LongLong); va_end(v); return r + f.a + (int)f.b; }
280 static double __cdecl fun_take_aggrs_vararg(Int_NestedDouble a, ...) { double r = a.a + a.b.f; va_list v; va_start(v,a); Int_NestedFloat b = va_arg(v,Int_NestedFloat); va_end(v); return r + b.a + b.b.f; }
277 281
278 282
279 int testAggrParameters() 283 int testAggrParameters()
280 { 284 {
281 int ret = 1; 285 int ret = 1;
294 dcArgAggr(vm, s, &t); 298 dcArgAggr(vm, s, &t);
295 returned = dcCallDouble(vm, (DCpointer) &fun_take_u8); 299 returned = dcCallDouble(vm, (DCpointer) &fun_take_u8);
296 300
297 dcFreeAggr(s); 301 dcFreeAggr(s);
298 302
299 printf("{C} (cdecl): %d\n", returned == t.a); 303 printf("{C})d (cdecl): %d\n", returned == t.a);
300 ret = returned == t.a && ret; 304 ret = returned == t.a && ret;
301 } 305 }
302 { 306 {
303 U8_Double t = { 5, 5.5 }; 307 U8_Double t = { 5, 5.5 };
304 double returned; 308 double returned;
312 dcArgAggr(vm, s, &t); 316 dcArgAggr(vm, s, &t);
313 returned = dcCallDouble(vm, (DCpointer) &fun_take_u8_double); 317 returned = dcCallDouble(vm, (DCpointer) &fun_take_u8_double);
314 318
315 dcFreeAggr(s); 319 dcFreeAggr(s);
316 320
317 printf("{Cd} (cdecl): %d\n", returned == t.a + t.b); 321 printf("{Cd})d (cdecl): %d\n", returned == t.a + t.b);
318 ret = returned == t.a + t.b && ret; 322 ret = returned == t.a + t.b && ret;
319 } 323 }
320 { 324 {
321 Float_Float t = { 1.5, 5.5 }; 325 Float_Float t = { 1.5, 5.5 };
322 double returned; 326 double returned;
330 dcArgAggr(vm, s, &t); 334 dcArgAggr(vm, s, &t);
331 returned = dcCallDouble(vm, (DCpointer) &fun_take_float_float); 335 returned = dcCallDouble(vm, (DCpointer) &fun_take_float_float);
332 336
333 dcFreeAggr(s); 337 dcFreeAggr(s);
334 338
335 printf("{ff} (cdecl): %d\n", returned == t.a + t.b); 339 printf("{ff})d (cdecl): %d\n", returned == t.a + t.b);
336 ret = returned == t.a + t.b && ret; 340 ret = returned == t.a + t.b && ret;
337 } 341 }
338 { 342 {
339 Double_U8 t = { 5.5, 42 }; 343 Double_U8 t = { 5.5, 42 };
340 double returned; 344 double returned;
348 dcArgAggr(vm, s, &t); 352 dcArgAggr(vm, s, &t);
349 returned = dcCallDouble(vm, (DCpointer) &fun_take_double_u8); 353 returned = dcCallDouble(vm, (DCpointer) &fun_take_double_u8);
350 354
351 dcFreeAggr(s); 355 dcFreeAggr(s);
352 356
353 printf("{dC} (cdecl): %d\n", returned == t.a + t.b); 357 printf("{dC})d (cdecl): %d\n", returned == t.a + t.b);
354 ret = returned == t.a + t.b && ret; 358 ret = returned == t.a + t.b && ret;
355 } 359 }
356 { 360 {
357 Int_NestedFloat t = { 24, { 2.5f } }; 361 Int_NestedFloat t = { 24, { 2.5f } };
358 double returned; 362 double returned;
372 returned = dcCallDouble(vm, (DCpointer) &fun_take_int_nested_float); 376 returned = dcCallDouble(vm, (DCpointer) &fun_take_int_nested_float);
373 377
374 dcFreeAggr(s_); 378 dcFreeAggr(s_);
375 dcFreeAggr(s); 379 dcFreeAggr(s);
376 380
377 printf("{i{f}} (cdecl): %d\n", returned == t.a + t.b.f); 381 printf("{i{f}})d (cdecl): %d\n", returned == t.a + t.b.f);
378 ret = returned == t.a + t.b.f && ret; 382 ret = returned == t.a + t.b.f && ret;
379 } 383 }
380 { 384 {
381 Int_NestedDouble t = { 24, { 2.5} }; 385 Int_NestedDouble t = { 24, { 2.5} };
382 double returned; 386 double returned;
396 returned = dcCallDouble(vm, (DCpointer) &fun_take_int_nested_double); 400 returned = dcCallDouble(vm, (DCpointer) &fun_take_int_nested_double);
397 401
398 dcFreeAggr(s_); 402 dcFreeAggr(s_);
399 dcFreeAggr(s); 403 dcFreeAggr(s);
400 404
401 printf("{i{d}} (cdecl): %d\n", returned == t.a + t.b.f); 405 printf("{i{d}})d (cdecl): %d\n", returned == t.a + t.b.f);
402 ret = returned == t.a + t.b.f && ret; 406 ret = returned == t.a + t.b.f && ret;
403 } 407 }
404 { 408 {
405 Three_Double t = { 1.5, 2.5, 3.5 }; 409 Three_Double t = { 1.5, 2.5, 3.5 };
406 double returned; 410 double returned;
415 dcArgAggr(vm, s, &t); 419 dcArgAggr(vm, s, &t);
416 returned = dcCallDouble(vm, (DCpointer) &fun_take_three_double); 420 returned = dcCallDouble(vm, (DCpointer) &fun_take_three_double);
417 421
418 dcFreeAggr(s); 422 dcFreeAggr(s);
419 423
420 printf("{fff} (cdecl): %d\n", returned == t.a + t.b + t.c); 424 printf("{fff})d (cdecl): %d\n", returned == t.a + t.b + t.c);
421 ret = returned == t.a + t.b + t.c && ret; 425 ret = returned == t.a + t.b + t.c && ret;
422 } 426 }
423 { 427 {
424 /* w/ some prev params, so not fitting into float regs anymore (on win and sysv) */ 428 /* w/ some prev params, so not fitting into float regs anymore (on win and sysv) */
425 Three_Double t = { 1.5, 2.5, 3.5 }; 429 Three_Double t = { 1.5, 2.5, 3.5 };
444 if(returned < 0.) 448 if(returned < 0.)
445 returned = -returned; 449 returned = -returned;
446 450
447 dcFreeAggr(s); 451 dcFreeAggr(s);
448 452
449 printf("dffifdf{fff} (cdecl): %d\n", returned < .00001); 453 printf("dffifdf{fff})d (cdecl): %d\n", returned < .00001);
450 ret = returned < .00001 && ret; 454 ret = returned < .00001 && ret;
451 } 455 }
452 { 456 {
453 Int_LongLong t = { -17, 822LL }; 457 Int_LongLong t = { -17, 822LL };
454 int returned; 458 int returned;
467 dcArgAggr(vm, s, &t); 471 dcArgAggr(vm, s, &t);
468 returned = dcCallInt(vm, (DCpointer) &fun_take_iiiii_il); 472 returned = dcCallInt(vm, (DCpointer) &fun_take_iiiii_il);
469 473
470 dcFreeAggr(s); 474 dcFreeAggr(s);
471 475
472 printf("iiiii{il} (cdecl): %d\n", returned == -18528); 476 printf("iiiii{il})i (cdecl): %d\n", returned == -18528);
473 ret = returned == -18528 && ret; 477 ret = returned == -18528 && ret;
474 } 478 }
475 { 479 {
476 More_Than_Regs t = { 1., 2., 3., 4, 5, 6, 7., 8., 9., 10.f, 11, 12.f, 13., 14, 15, 16, 17, 18 }; 480 More_Than_Regs t = { 1., 2., 3., 4, 5, 6, 7., 8., 9., 10.f, 11, 12.f, 13., 14, 15, 16, 17, 18 };
477 double returned; 481 double returned;
501 dcArgAggr(vm, s, &t); 505 dcArgAggr(vm, s, &t);
502 returned = dcCallDouble(vm, (DCpointer) &fun_take_more_than_regs); 506 returned = dcCallDouble(vm, (DCpointer) &fun_take_more_than_regs);
503 507
504 dcFreeAggr(s); 508 dcFreeAggr(s);
505 509
506 printf("{dddlccdddfifdsjiIl} (cdecl): %d\n", returned == 171.); 510 printf("{dddlccdddfifdsjiIl})d (cdecl): %d\n", returned == 171.);
507 ret = returned == 171. && ret; 511 ret = returned == 171. && ret;
512 }
513 {
514 /* w/ some prev params, so not fitting into float regs anymore (on win and sysv) */
515 Three_Double t = { 1.4, 3.6, 4.7 };
516 double returned;
517
518 DCaggr *s = dcNewAggr(3, sizeof(t));
519 dcAggrField(s, DC_SIGCHAR_DOUBLE, offsetof(Three_Double, a), 1);
520 dcAggrField(s, DC_SIGCHAR_DOUBLE, offsetof(Three_Double, b), 1);
521 dcAggrField(s, DC_SIGCHAR_DOUBLE, offsetof(Three_Double, c), 1);
522 dcCloseAggr(s);
523
524 dcReset(vm);
525 dcMode(vm,DC_CALL_C_ELLIPSIS);
526 dcArgDouble(vm, 234.6);
527 dcArgFloat(vm, 29.4f);
528 dcArgFloat(vm, 5.0f);
529 dcArgInt(vm, -11);
530 dcMode(vm,DC_CALL_C_ELLIPSIS_VARARGS);
531 dcArgDouble(vm, -83.9f);
532 dcArgDouble(vm, -.9);
533 dcArgDouble(vm, .6f);
534 dcArgAggr(vm, s, &t);
535 returned = dcCallDouble(vm, (DCpointer) &fun_take_mixed_fp_vararg) + 65.7;
536 if(returned < 0.)
537 returned = -returned;
538
539 dcFreeAggr(s);
540
541 printf("dffi.fdf{fff})d (cdecl): %d\n", returned < .00001);
542 ret = returned < .00001 && ret;
543 }
544 {
545 Int_LongLong t = { 71, -1177LL };
546 int returned;
547
548 DCaggr *s = dcNewAggr(2, sizeof(t));
549 dcAggrField(s, DC_SIGCHAR_INT, offsetof(Int_LongLong, a), 1);
550 dcAggrField(s, DC_SIGCHAR_LONGLONG, offsetof(Int_LongLong, b), 1);
551 dcCloseAggr(s);
552
553 dcReset(vm);
554 dcMode(vm,DC_CALL_C_ELLIPSIS);
555 dcArgInt(vm, 31);
556 dcArgInt(vm, -123);
557 dcArgInt(vm, 108);
558 dcArgInt(vm, 133);
559 dcArgInt(vm, -17933);
560 dcMode(vm,DC_CALL_C_ELLIPSIS_VARARGS);
561 dcArgAggr(vm, s, &t);
562 returned = dcCallInt(vm, (DCpointer) &fun_take_iiiii_il_vararg);
563
564 dcFreeAggr(s);
565
566 printf("iiiii.{il})i (cdecl): %d\n", returned == -18890);
567 ret = returned == -18890 && ret;
568 }
569 {
570 Int_NestedDouble t0 = { -64, { -6.6} };
571 Int_NestedFloat t1 = { 112, { 7.5f } };
572 int returned;
573
574 DCaggr *s0_ = dcNewAggr(1, sizeof(NestedDouble));
575 dcAggrField(s0_, DC_SIGCHAR_DOUBLE, offsetof(NestedDouble, f), 1);
576 dcCloseAggr(s0_);
577
578 DCaggr *s0 = dcNewAggr(2, sizeof(t0));
579 dcAggrField(s0, DC_SIGCHAR_INT, offsetof(Int_NestedDouble, a), 1);
580 dcAggrField(s0, DC_SIGCHAR_AGGREGATE, offsetof(Int_NestedDouble, b), 1, s0_);
581 dcCloseAggr(s0);
582
583 DCaggr *s1_ = dcNewAggr(1, sizeof(NestedFloat));
584 dcAggrField(s1_, DC_SIGCHAR_FLOAT, offsetof(NestedFloat, f), 1);
585 dcCloseAggr(s1_);
586
587 DCaggr *s1 = dcNewAggr(2, sizeof(t1));
588 dcAggrField(s1, DC_SIGCHAR_INT, offsetof(Int_NestedFloat, a), 1);
589 dcAggrField(s1, DC_SIGCHAR_AGGREGATE, offsetof(Int_NestedFloat, b), 1, s1_);
590 dcCloseAggr(s1);
591
592 dcReset(vm);
593 dcMode(vm,DC_CALL_C_ELLIPSIS);
594 dcArgAggr(vm, s0, &t0);
595 dcMode(vm,DC_CALL_C_ELLIPSIS_VARARGS);
596 dcArgAggr(vm, s1, &t1);
597 returned = dcCallDouble(vm, (DCpointer) &fun_take_aggrs_vararg) - 48.9;
598
599 dcFreeAggr(s0_);
600 dcFreeAggr(s0);
601 dcFreeAggr(s1_);
602 dcFreeAggr(s1);
603
604 printf("{i{d}}.{i{f}})d (cdecl): %d\n", returned < .00001);
605 ret = returned < .00001 && ret;
508 } 606 }
509 607
510 dcFree(vm); 608 dcFree(vm);
511 609
512 return ret; 610 return ret;