tcctest.c

   1 /*
   2  * TCC auto test program
   3  */
   4
   5 /* Unfortunately, gcc version < 3 does not handle that! */
   6 //#define ALL_ISOC99
   7
   8 /* only gcc 3 handles _Bool correctly */
   9 //#define BOOL_ISOC99
  10
  11 #define C99_MACROS
  12
  13 /* test various include syntaxes */
  14
  15 #define TCCLIB_INC <tcclib.h>
  16 #define TCCLIB_INC1 <tcclib
  17 #define TCCLIB_INC2 h>
  18 #define TCCLIB_INC3 "tcclib"
  19
  20 #include TCCLIB_INC
  21
  22 #include TCCLIB_INC1.TCCLIB_INC2
  23
  24 #include TCCLIB_INC1.h>
  25
  26 #include TCCLIB_INC3 ".h"
  27
  28 #include <tcclib.h>
  29
  30 #include "tcclib.h"
  31
  32 void string_test();
  33 void expr_test();
  34 void macro_test();
  35 void scope_test();
  36 void forward_test();
  37 void funcptr_test();
  38 void loop_test();
  39 void switch_test();
  40 void goto_test();
  41 void enum_test();
  42 void typedef_test();
  43 void struct_test();
  44 void array_test();
  45 void expr_ptr_test();
  46 void bool_test();
  47 void expr2_test();
  48 void constant_expr_test();
  49 void expr_cmp_test();
  50 void char_short_test();
  51 void init_test(void);
  52 void compound_literal_test(void);
  53 int kr_test();
  54 void struct_assign_test(void);
  55 void cast_test(void);
  56 void bitfield_test(void);
  57 void c99_bool_test(void);
  58 void float_test(void);
  59 void longlong_test(void);
  60 void stdarg_test(void);
  61 void whitespace_test(void);
  62 void relocation_test(void);
  63 void old_style_function(void);
  64 void sizeof_test(void);
  65 void typeof_test(void);
  66
  67 int fib(int n);
  68 void num(int n);
  69 void forward_ref(void);
  70 int isid(int c);
  71
  72 #define A 2
  73 #define N 1234 + A
  74 #define pf printf
  75 #define M1(a, b)  (a) + (b)
  76
  77 #define str(s) # s
  78 #define glue(a, b) a ## b
  79 #define xglue(a, b) glue(a, b)
  80 #define HIGHLOW "hello"
  81 #define LOW LOW ", world"
  82
  83 #define min(a, b) ((a) < (b) ? (a) : (b))
  84
  85 #ifdef C99_MACROS
  86 #define dprintf(level,...) printf(__VA_ARGS__)
  87 #endif
  88
  89 /* gcc vararg macros */
  90 #define dprintf1(level, fmt, args...) printf(fmt, ## args)
  91
  92 #define MACRO_NOARGS()
  93
  94 #define AAA 3
  95 #undef AAA
  96 #define AAA 4
  97
  98 #if 1
  99 #define B3 1
 100 #elif 1
 101 #define B3 2
 102 #elif 0
 103 #define B3 3
 104 #else
 105 #define B3 4
 106 #endif
 107
 108 #define __INT64_C(c)    c ## LL
 109 #define INT64_MIN       (-__INT64_C(9223372036854775807)-1)
 110
 111 void macro_test(void)
 112 {
 113     printf("macro:\n");\f\v
 114     pf("N=%d\n", N);
 115     printf("aaa=%d\n", AAA);
 116
 117     printf("min=%d\n", min(1, min(2, -1)));
 118
 119     printf("s1=%s\n", glue(HIGH, LOW));
 120     printf("s2=%s\n", xglue(HIGH, LOW));
 121     printf("s3=%s\n", str("c"));
 122     printf("s4=%s\n", str(a1));
 123     printf("B3=%d\n", B3);
 124
 125 #ifdef A
 126     printf("A defined\n");
 127 #endif
 128 #ifdef B
 129     printf("B defined\n");
 130 #endif
 131 #ifdef A
 132     printf("A defined\n");
 133 #else
 134     printf("A not defined\n");
 135 #endif
 136 #ifdef B
 137     printf("B defined\n");
 138 #else
 139     printf("B not defined\n");
 140 #endif
 141
 142 #ifdef A
 143     printf("A defined\n");
 144 #ifdef B
 145     printf("B1 defined\n");
 146 #else
 147     printf("B1 not defined\n");
 148 #endif
 149 #else
 150     printf("A not defined\n");
 151 #ifdef B
 152     printf("B2 defined\n");
 153 #else
 154     printf("B2 not defined\n");
 155 #endif
 156 #endif
 157
 158 #if 1+1
 159     printf("test true1\n");
 160 #endif
 161 #if 0
 162     printf("test true2\n");
 163 #endif
 164 #if 1-1
 165     printf("test true3\n");
 166 #endif
 167 #if defined(A)
 168     printf("test trueA\n");
 169 #endif
 170 #if defined(B)
 171     printf("test trueB\n");
 172 #endif
 173
 174 #if 0
 175     printf("test 0\n");
 176 #elif 0
 177     printf("test 1\n");
 178 #elif 2
 179     printf("test 2\n");
 180 #else
 181     printf("test 3\n");
 182 #endif
 183
 184     MACRO_NOARGS();
 185
 186 #ifdef __LINE__
 187     printf("__LINE__ defined\n");
 188 #endif
 189
 190     printf("__LINE__=%d __FILE__=%s\n",
 191            __LINE__, __FILE__);
 192 #line 200
 193     printf("__LINE__=%d __FILE__=%s\n",
 194            __LINE__, __FILE__);
 195 #line 203 "test"
 196     printf("__LINE__=%d __FILE__=%s\n",
 197            __LINE__, __FILE__);
 198 #line 198 "tcctest.c"
 199
 200     /* not strictly preprocessor, but we test it there */
 201 #ifdef C99_MACROS
 202     printf("__func__ = %s\n", __func__);
 203     dprintf(1, "vaarg=%d\n", 1);
 204 #endif
 205     dprintf1(1, "vaarg1\n");
 206     dprintf1(1, "vaarg1=%d\n", 2);
 207     dprintf1(1, "vaarg1=%d %d\n", 1, 2);
 208
 209     /* gcc extension */
 210     printf("func='%s'\n", __FUNCTION__);
 211
 212     /* complicated macros in glibc */
 213     printf("INT64_MIN=%Ld\n", INT64_MIN);
 214     {
 215         int a;
 216         a = 1;
 217         glue(a+, +);
 218         printf("a=%d\n", a);
 219         glue(a <, <= 2);
 220         printf("a=%d\n", a);
 221     }
 222 }
 223
 224 int op(a,b)
 225 {
 226     return a / b;
 227 }
 228
 229 int ret(a)
 230 {
 231     if (a == 2)
 232         return 1;
 233     if (a == 3)
 234         return 2;
 235     return 0;
 236 }
 237
 238 void ps(char *s)
 239 {
 240     int c;
 241     while (1) {
 242         c = *s;
 243         if (c == 0)
 244             break;
 245         printf("%c", c);
 246         s++;
 247     }
 248 }
 249
 250 void string_test()
 251 {
 252     int b;
 253     printf("string:\n");
 254     printf("\141\1423\143\n");/* dezdez test */
 255     printf("\x41\x42\x43\x3a\n");
 256     printf("c=%c\n", 'r');
 257     printf("wc=%C 0x%lx %C\n", L'a', L'\x1234', L'c');
 258     printf("wstring=%S\n", L"abc");
 259     printf("wstring=%S\n", L"abc" L"def" "ghi");
 260     printf("'\\377'=%d '\\xff'=%d\n", '\377', '\xff');
 261     printf("L'\\377'=%d L'\\xff'=%d\n", L'\377', L'\xff');
 262     ps("test\n");
 263     b = 32;
 264     while ((b = b + 1) < 96) {
 265         printf("%c", b);
 266     }
 267     printf("\n");
 268     printf("fib=%d\n", fib(33));
 269     b = 262144;
 270     while (b != 0x80000000) {
 271         num(b);
 272         b = b * 2;
 273     }
 274 }
 275
 276 void loop_test()
 277 {
 278     int i;
 279     i = 0;
 280     while (i < 10)
 281         printf("%d", i++);
 282     printf("\n");
 283     for(i = 0; i < 10;i++)
 284         printf("%d", i);
 285     printf("\n");
 286     i = 0;
 287     do {
 288         printf("%d", i++);
 289     } while (i < 10);
 290     printf("\n");
 291
 292     /* break/continue tests */
 293     i = 0;
 294     while (1) {
 295         if (i == 6)
 296             break;
 297         i++;
 298         if (i == 3)
 299             continue;
 300         printf("%d", i);
 301     }
 302     printf("\n");
 303
 304     /* break/continue tests */
 305     i = 0;
 306     do {
 307         if (i == 6)
 308             break;
 309         i++;
 310         if (i == 3)
 311             continue;
 312         printf("%d", i);
 313     } while(1);
 314     printf("\n");
 315
 316     for(i = 0;i < 10;i++) {
 317         if (i == 3)
 318             continue;
 319         printf("%d", i);
 320     }
 321     printf("\n");
 322 }
 323
 324
 325 void goto_test()
 326 {
 327     int i;
 328
 329     printf("goto:\n");
 330     i = 0;
 331  s_loop:
 332     if (i >= 10)
 333         goto s_end;
 334     printf("%d", i);
 335     i++;
 336     goto s_loop;
 337  s_end:
 338     printf("\n");
 339 }
 340
 341 enum {
 342     E0,
 343     E1 = 2,
 344     E2 = 4,
 345     E3,
 346     E4,
 347 };
 348
 349 enum test {
 350     E5 = 1000,
 351 };
 352
 353 void enum_test()
 354 {
 355     enum test b1;
 356     printf("enum:\n%d %d %d %d %d %d\n",
 357            E0, E1, E2, E3, E4, E5);
 358     b1 = 1;
 359     printf("b1=%d\n", b1);
 360 }
 361
 362 typedef int *my_ptr;
 363
 364 void typedef_test()
 365 {
 366     my_ptr a;
 367     int b;
 368     a = &b;
 369     *a = 1234;
 370     printf("typedef:\n");
 371     printf("a=%d\n", *a);
 372 }
 373
 374 void forward_test()
 375 {
 376     printf("forward:\n");
 377     forward_ref();
 378     forward_ref();
 379 }
 380
 381
 382 void forward_ref(void)
 383 {
 384     printf("forward ok\n");
 385 }
 386
 387 typedef struct struct1 {
 388     int f1;
 389     int f2, f3;
 390     union union1 {
 391         int v1;
 392         int v2;
 393     } u;
 394     char str[3];
 395 } struct1;
 396
 397 struct struct2 {
 398     int a;
 399     char b;
 400 };
 401
 402 union union2 {
 403     int w1;
 404     int w2;
 405 };
 406
 407 struct struct1 st1, st2;
 408
 409 int main(int argc, char **argv)
 410 {
 411     string_test();
 412     expr_test();
 413     macro_test();
 414     scope_test();
 415     forward_test();
 416     funcptr_test();
 417     loop_test();
 418     switch_test();
 419     goto_test();
 420     enum_test();
 421     typedef_test();
 422     struct_test();
 423     array_test();
 424     expr_ptr_test();
 425     bool_test();
 426     expr2_test();
 427     constant_expr_test();
 428     expr_cmp_test();
 429     char_short_test();
 430     init_test();
 431     compound_literal_test();
 432     kr_test();
 433     struct_assign_test();
 434     cast_test();
 435     bitfield_test();
 436     c99_bool_test();
 437     float_test();
 438     longlong_test();
 439     stdarg_test();
 440     whitespace_test();
 441     relocation_test();
 442     old_style_function();
 443     sizeof_test();
 444     typeof_test();
 445     return 0;
 446 }
 447
 448 int tab[3];
 449 int tab2[3][2];
 450
 451 int g;
 452
 453 void f1(g)
 454 {
 455     printf("g1=%d\n", g);
 456 }
 457
 458 void scope_test()
 459 {
 460     printf("scope:\n");
 461     g = 2;
 462     f1(1);
 463     printf("g2=%d\n", g);
 464     {
 465         int g;
 466         g = 3;
 467         printf("g3=%d\n", g);
 468         {
 469             int g;
 470             g = 4;
 471             printf("g4=%d\n", g);
 472         }
 473     }
 474     printf("g5=%d\n", g);
 475 }
 476
 477 void array_test(int a[4])
 478 {
 479     int i, j;
 480
 481     printf("array:\n");
 482     printf("sizeof(a) = %d\n", sizeof(a));
 483     printf("sizeof(\"a\") = %d\n", sizeof("a"));
 484 #ifdef C99_MACROS
 485     printf("sizeof(__func__) = %d\n", sizeof(__func__));
 486 #endif
 487     printf("sizeof tab %d\n", sizeof(tab));
 488     printf("sizeof tab2 %d\n", sizeof tab2);
 489     tab[0] = 1;
 490     tab[1] = 2;
 491     tab[2] = 3;
 492     printf("%d %d %d\n", tab[0], tab[1], tab[2]);
 493     for(i=0;i<3;i++)
 494         for(j=0;j<2;j++)
 495             tab2[i][j] = 10 * i + j;
 496     for(i=0;i<3*2;i++) {
 497         printf(" %3d", ((int *)tab2)[i]);
 498     }
 499     printf("\n");
 500 }
 501
 502 void expr_test()
 503 {
 504     int a, b;
 505     a = 0;
 506     printf("%d\n", a += 1);
 507     printf("%d\n", a -= 2);
 508     printf("%d\n", a *= 31232132);
 509     printf("%d\n", a /= 4);
 510     printf("%d\n", a %= 20);
 511     printf("%d\n", a &= 6);
 512     printf("%d\n", a ^= 7);
 513     printf("%d\n", a |= 8);
 514     printf("%d\n", a >>= 3);
 515     printf("%d\n", a <<= 4);
 516
 517     a = 22321;
 518     b = -22321;
 519     printf("%d\n", a + 1);
 520     printf("%d\n", a - 2);
 521     printf("%d\n", a * 312);
 522     printf("%d\n", a / 4);
 523     printf("%d\n", b / 4);
 524     printf("%d\n", (unsigned)b / 4);
 525     printf("%d\n", a % 20);
 526     printf("%d\n", b % 20);
 527     printf("%d\n", (unsigned)b % 20);
 528     printf("%d\n", a & 6);
 529     printf("%d\n", a ^ 7);
 530     printf("%d\n", a | 8);
 531     printf("%d\n", a >> 3);
 532     printf("%d\n", b >> 3);
 533     printf("%d\n", (unsigned)b >> 3);
 534     printf("%d\n", a << 4);
 535     printf("%d\n", ~a);
 536     printf("%d\n", -a);
 537     printf("%d\n", +a);
 538
 539     printf("%d\n", 12 + 1);
 540     printf("%d\n", 12 - 2);
 541     printf("%d\n", 12 * 312);
 542     printf("%d\n", 12 / 4);
 543     printf("%d\n", 12 % 20);
 544     printf("%d\n", 12 & 6);
 545     printf("%d\n", 12 ^ 7);
 546     printf("%d\n", 12 | 8);
 547     printf("%d\n", 12 >> 2);
 548     printf("%d\n", 12 << 4);
 549     printf("%d\n", ~12);
 550     printf("%d\n", -12);
 551     printf("%d\n", +12);
 552     printf("%d %d %d %d\n",
 553            isid('a'),
 554            isid('g'),
 555            isid('T'),
 556            isid('('));
 557 }
 558
 559 int isid(int c)
 560 {
 561     return (c >= 'a' & c <= 'z') | (c >= 'A' & c <= 'Z') | c == '_';
 562 }
 563
 564 /**********************/
 565
 566 int vstack[10], *vstack_ptr;
 567
 568 void vpush(int vt, int vc)
 569 {
 570     *vstack_ptr++ = vt;
 571     *vstack_ptr++ = vc;
 572 }
 573
 574 void vpop(int *ft, int *fc)
 575 {
 576     *fc = *--vstack_ptr;
 577     *ft = *--vstack_ptr;
 578 }
 579
 580 void expr2_test()
 581 {
 582     int a, b;
 583
 584     printf("expr2:\n");
 585     vstack_ptr = vstack;
 586     vpush(1432432, 2);
 587     vstack_ptr[-2] &= ~0xffffff80;
 588     vpop(&a, &b);
 589     printf("res= %d %d\n", a, b);
 590 }
 591
 592 void constant_expr_test()
 593 {
 594     int a;
 595     printf("constant_expr:\n");
 596     a = 3;
 597     printf("%d\n", a * 16);
 598     printf("%d\n", a * 1);
 599     printf("%d\n", a + 0);
 600 }
 601
 602 int tab4[10];
 603
 604 void expr_ptr_test()
 605 {
 606     int *p, *q;
 607
 608     printf("expr_ptr:\n");
 609     p = tab4;
 610     q = tab4 + 10;
 611     printf("diff=%d\n", q - p);
 612     p++;
 613     printf("inc=%d\n", p - tab4);
 614     p--;
 615     printf("dec=%d\n", p - tab4);
 616     ++p;
 617     printf("inc=%d\n", p - tab4);
 618     --p;
 619     printf("dec=%d\n", p - tab4);
 620     printf("add=%d\n", p + 3 - tab4);
 621     printf("add=%d\n", 3 + p - tab4);
 622 }
 623
 624 void expr_cmp_test()
 625 {
 626     int a, b;
 627     printf("constant_expr:\n");
 628     a = -1;
 629     b = 1;
 630     printf("%d\n", a == a);
 631     printf("%d\n", a != a);
 632
 633     printf("%d\n", a < b);
 634     printf("%d\n", a <= b);
 635     printf("%d\n", a <= a);
 636     printf("%d\n", b >= a);
 637     printf("%d\n", a >= a);
 638     printf("%d\n", b > a);
 639
 640     printf("%d\n", (unsigned)a < b);
 641     printf("%d\n", (unsigned)a <= b);
 642     printf("%d\n", (unsigned)a <= a);
 643     printf("%d\n", (unsigned)b >= a);
 644     printf("%d\n", (unsigned)a >= a);
 645     printf("%d\n", (unsigned)b > a);
 646 }
 647
 648 void struct_test()
 649 {
 650     struct1 *s;
 651     union union2 u;
 652
 653     printf("struct:\n");
 654     printf("sizes: %d %d %d %d\n",
 655            sizeof(struct struct1),
 656            sizeof(struct struct2),
 657            sizeof(union union1),
 658            sizeof(union union2));
 659     st1.f1 = 1;
 660     st1.f2 = 2;
 661     st1.f3 = 3;
 662     printf("st1: %d %d %d\n",
 663            st1.f1, st1.f2, st1.f3);
 664     st1.u.v1 = 1;
 665     st1.u.v2 = 2;
 666     printf("union1: %d\n", st1.u.v1);
 667     u.w1 = 1;
 668     u.w2 = 2;
 669     printf("union2: %d\n", u.w1);
 670     s = &st2;
 671     s->f1 = 3;
 672     s->f2 = 2;
 673     s->f3 = 1;
 674     printf("st2: %d %d %d\n",
 675            s->f1, s->f2, s->f3);
 676     printf("str_addr=%x\n", (int)st1.str - (int)&st1.f1);
 677 }
 678
 679 /* XXX: depend on endianness */
 680 void char_short_test()
 681 {
 682     int var1, var2;
 683
 684     printf("char_short:\n");
 685
 686     var1 = 0x01020304;
 687     var2 = 0xfffefdfc;
 688     printf("s8=%d %d\n",
 689            *(char *)&var1, *(char *)&var2);
 690     printf("u8=%d %d\n",
 691            *(unsigned char *)&var1, *(unsigned char *)&var2);
 692     printf("s16=%d %d\n",
 693            *(short *)&var1, *(short *)&var2);
 694     printf("u16=%d %d\n",
 695            *(unsigned short *)&var1, *(unsigned short *)&var2);
 696     printf("s32=%d %d\n",
 697            *(int *)&var1, *(int *)&var2);
 698     printf("u32=%d %d\n",
 699            *(unsigned int *)&var1, *(unsigned int *)&var2);
 700     *(char *)&var1 = 0x08;
 701     printf("var1=%x\n", var1);
 702     *(short *)&var1 = 0x0809;
 703     printf("var1=%x\n", var1);
 704     *(int *)&var1 = 0x08090a0b;
 705     printf("var1=%x\n", var1);
 706 }
 707
 708 /******************/
 709
 710 typedef struct Sym {
 711     int v;
 712     int t;
 713     int c;
 714     struct Sym *next;
 715     struct Sym *prev;
 716 } Sym;
 717
 718 void bool_test()
 719 {
 720     int *s, a, b, t, f;
 721
 722     a = 0;
 723     s = (void*)0;
 724     printf("!s=%d\n", !s);
 725
 726     if (!s || !s[0])
 727         a = 1;
 728     printf("a=%d\n", a);
 729
 730     printf("a=%d %d %d\n", 0 || 0, 0 || 1, 1 || 1);
 731     printf("a=%d %d %d\n", 0 && 0, 0 && 1, 1 && 1);
 732     printf("a=%d %d\n", 1 ? 1 : 0, 0 ? 1 : 0);
 733 #if 1 && 1
 734     printf("a1\n");
 735 #endif
 736 #if 1 || 0
 737     printf("a2\n");
 738 #endif
 739 #if 1 ? 0 : 1
 740     printf("a3\n");
 741 #endif
 742 #if 0 ? 0 : 1
 743     printf("a4\n");
 744 #endif
 745
 746     a = 4;
 747     printf("b=%d\n", a + (0 ? 1 : a / 2));
 748
 749     /* test register spilling */
 750     a = 10;
 751     b = 10;
 752     a = (a + b) * ((a < b) ?
 753                    ((b - a) * (a - b)): a + b);
 754     printf("a=%d\n", a);
 755
 756     /* test complex || or && expressions */
 757     t = 1;
 758     f = 0;
 759     a = 32;
 760     printf("exp=%d\n", f == (32 <= a && a <= 3));
 761     printf("r=%d\n", (t || f) + (t && f));
 762
 763     /* test ? : cast */
 764     {
 765         int aspect_on;
 766         int aspect_native = 65536;
 767         double bfu_aspect = 1.0;
 768         int aspect;
 769         for(aspect_on = 0; aspect_on < 2; aspect_on++) {
 770             aspect=aspect_on?(aspect_native*bfu_aspect+0.5):65535UL;
 771             printf("aspect=%d\n", aspect);
 772         }
 773     }
 774 }
 775
 776
 777 int cinit1 = 0;
 778 int *cinit2 = (int []){3, 2, 1};
 779
 780 void compound_literal_test(void)
 781 {
 782     int *p, i;
 783     char *q, *q3;
 784
 785     printf("compound_test:\n");
 786
 787     p = (int []){1, 2, 3};
 788     for(i=0;i<3;i++)
 789         printf(" %d", p[i]);
 790     printf("\n");
 791
 792     for(i=0;i<3;i++)
 793         printf("%d", cinit2[i]);
 794     printf("\n");
 795
 796     q = "tralala1";
 797     printf("q1=%s\n", q);
 798
 799     q = (char *){ "tralala2" };
 800     printf("q2=%s\n", q);
 801
 802     q3 = (char *){ q };
 803     printf("q3=%s\n", q3);
 804
 805     q = (char []){ "tralala3" };
 806     printf("q4=%s\n", q);
 807
 808 #ifdef ALL_ISOC99
 809     p = (int []){1, 2, cinit1 + 3};
 810     for(i=0;i<3;i++)
 811         printf(" %d", p[i]);
 812     printf("\n");
 813
 814     for(i=0;i<3;i++) {
 815         p = (int []){1, 2, 4 + i};
 816         printf("%d %d %d\n",
 817                p[0],
 818                p[1],
 819                p[2]);
 820     }
 821 #endif
 822 }
 823
 824 /* K & R protos */
 825
 826 kr_func1(a, b)
 827 {
 828     return a + b;
 829 }
 830
 831 int kr_func2(a, b)
 832 {
 833     return a + b;
 834 }
 835
 836 kr_test()
 837 {
 838     printf("kr_test:\n");
 839     printf("func1=%d\n", kr_func1(3, 4));
 840     printf("func2=%d\n", kr_func2(3, 4));
 841     return 0;
 842 }
 843
 844 void num(int n)
 845 {
 846     char *tab, *p;
 847     tab = (char*)malloc(20);
 848     p = tab;
 849     while (1) {
 850         *p = 48 + (n % 10);
 851         p++;
 852         n = n / 10;
 853         if (n == 0)
 854             break;
 855     }
 856     while (p != tab) {
 857         p--;
 858         printf("%c", *p);
 859     }
 860     printf("\n");
 861 }
 862
 863 /* structure assignment tests */
 864 struct structa1 {
 865     int f1;
 866     char f2;
 867 };
 868
 869 struct structa1 ssta1;
 870
 871 void struct_assign_test1(struct structa1 s1, int t)
 872 {
 873     printf("%d %d %d\n", s1.f1, s1.f2, t);
 874 }
 875
 876 struct structa1 struct_assign_test2(struct structa1 s1, int t)
 877 {
 878     s1.f1 += t;
 879     s1.f2 -= t;
 880     return s1;
 881 }
 882
 883 void struct_assign_test(void)
 884 {
 885     struct structa1 lsta1, lsta2;
 886
 887 #if 0
 888     printf("struct_assign_test:\n");
 889
 890     lsta1.f1 = 1;
 891     lsta1.f2 = 2;
 892     printf("%d %d\n", lsta1.f1, lsta1.f2);
 893     lsta2 = lsta1;
 894     printf("%d %d\n", lsta2.f1, lsta2.f2);
 895 #else
 896     lsta2.f1 = 1;
 897     lsta2.f2 = 2;
 898 #endif
 899     struct_assign_test1(lsta2, 3);
 900
 901     printf("before call: %d %d\n", lsta2.f1, lsta2.f2);
 902     lsta2 = struct_assign_test2(lsta2, 4);
 903     printf("after call: %d %d\n", lsta2.f1, lsta2.f2);
 904 }
 905
 906 /* casts to short/char */
 907
 908 void cast1(char a, short b, unsigned char c, unsigned short d)
 909 {
 910     printf("%d %d %d %d\n", a, b, c, d);
 911 }
 912
 913 char bcast;
 914 short scast;
 915
 916 void cast_test()
 917 {
 918     int a;
 919     char c;
 920     char tab[10];
 921
 922     printf("cast_test:\n");
 923     a = 0xfffff;
 924     cast1(a, a, a, a);
 925     a = 0xffffe;
 926     printf("%d %d %d %d\n",
 927            (char)(a + 1),
 928            (short)(a + 1),
 929            (unsigned char)(a + 1),
 930            (unsigned short)(a + 1));
 931     printf("%d %d %d %d\n",
 932            (char)0xfffff,
 933            (short)0xfffff,
 934            (unsigned char)0xfffff,
 935            (unsigned short)0xfffff);
 936
 937     a = (bcast = 128) + 1;
 938     printf("%d\n", a);
 939     a = (scast = 65536) + 1;
 940     printf("%d\n", a);
 941
 942     printf("sizeof(c) = %d, sizeof((int)c) = %d\n", sizeof(c), sizeof((int)c));
 943
 944     /* test implicit int casting for array accesses */
 945     c = 0;
 946     tab[1] = 2;
 947     tab[c] = 1;
 948     printf("%d %d\n", tab[0], tab[1]);
 949
 950     /* test implicit casting on some operators */
 951     printf("sizeof(+(char)'a') = %d\n", sizeof(+(char)'a'));
 952     printf("sizeof(-(char)'a') = %d\n", sizeof(-(char)'a'));
 953     printf("sizeof(~(char)'a') = %d\n", sizeof(-(char)'a'));
 954 }
 955
 956 /* initializers tests */
 957 struct structinit1 {
 958     int f1;
 959     char f2;
 960     short f3;
 961     int farray[3];
 962 };
 963
 964 int sinit1 = 2;
 965 int sinit2 = { 3 };
 966 int sinit3[3] = { 1, 2, {{3}}, };
 967 int sinit4[3][2] = { {1, 2}, {3, 4}, {5, 6} };
 968 int sinit5[3][2] = { 1, 2, 3, 4, 5, 6 };
 969 int sinit6[] = { 1, 2, 3 };
 970 int sinit7[] = { [2] = 3, [0] = 1, 2 };
 971 char sinit8[] = "hello" "trala";
 972
 973 struct structinit1 sinit9 = { 1, 2, 3 };
 974 struct structinit1 sinit10 = { .f2 = 2, 3, .f1 = 1 };
 975 struct structinit1 sinit11 = { .f2 = 2, 3, .f1 = 1,
 976 #ifdef ALL_ISOC99
 977                                .farray[0] = 10,
 978                                .farray[1] = 11,
 979                                .farray[2] = 12,
 980 #endif
 981 };
 982
 983 char *sinit12 = "hello world";
 984 char *sinit13[] = {
 985     "test1",
 986     "test2",
 987     "test3",
 988 };
 989 char sinit14[10] = { "abc" };
 990 int sinit15[3] = { sizeof(sinit15), 1, 2 };
 991
 992 void init_test(void)
 993 {
 994     int linit1 = 2;
 995     int linit2 = { 3 };
 996     int linit4[3][2] = { {1, 2}, {3, 4}, {5, 6} };
 997     int linit6[] = { 1, 2, 3 };
 998     int i, j;
 999     char linit8[] = "hello" "trala";
1000     int linit12[10] = { 1, 2 };
1001     int linit13[10] = { 1, 2, [7] = 3, [3] = 4, };
1002     char linit14[10] = "abc";
1003     int linit15[10] = { linit1, linit1 + 1, [6] = linit1 + 2, };
1004     struct linit16 { int a1, a2, a3, a4; } linit16 = { 1, .a3 = 2 };
1005     int linit17 = sizeof(linit17);
1006
1007     printf("init_test:\n");
1008
1009     printf("sinit1=%d\n", sinit1);
1010     printf("sinit2=%d\n", sinit2);
1011     printf("sinit3=%d %d %d %d\n",
1012            sizeof(sinit3),
1013            sinit3[0],
1014            sinit3[1],
1015            sinit3[2]
1016            );
1017     printf("sinit6=%d\n", sizeof(sinit6));
1018     printf("sinit7=%d %d %d %d\n",
1019            sizeof(sinit7),
1020            sinit7[0],
1021            sinit7[1],
1022            sinit7[2]
1023            );
1024     printf("sinit8=%s\n", sinit8);
1025     printf("sinit9=%d %d %d\n",
1026            sinit9.f1,
1027            sinit9.f2,
1028            sinit9.f3
1029            );
1030     printf("sinit10=%d %d %d\n",
1031            sinit10.f1,
1032            sinit10.f2,
1033            sinit10.f3
1034            );
1035     printf("sinit11=%d %d %d %d %d %d\n",
1036            sinit11.f1,
1037            sinit11.f2,
1038            sinit11.f3,
1039            sinit11.farray[0],
1040            sinit11.farray[1],
1041            sinit11.farray[2]
1042            );
1043
1044     for(i=0;i<3;i++)
1045         for(j=0;j<2;j++)
1046             printf("[%d][%d] = %d %d %d\n",
1047                    i, j, sinit4[i][j], sinit5[i][j], linit4[i][j]);
1048     printf("linit1=%d\n", linit1);
1049     printf("linit2=%d\n", linit2);
1050     printf("linit6=%d\n", sizeof(linit6));
1051     printf("linit8=%d %s\n", sizeof(linit8), linit8);
1052
1053     printf("sinit12=%s\n", sinit12);
1054     printf("sinit13=%d %s %s %s\n",
1055            sizeof(sinit13),
1056            sinit13[0],
1057            sinit13[1],
1058            sinit13[2]);
1059     printf("sinit14=%s\n", sinit14);
1060
1061     for(i=0;i<10;i++) printf(" %d", linit12[i]);
1062     printf("\n");
1063     for(i=0;i<10;i++) printf(" %d", linit13[i]);
1064     printf("\n");
1065     for(i=0;i<10;i++) printf(" %d", linit14[i]);
1066     printf("\n");
1067     for(i=0;i<10;i++) printf(" %d", linit15[i]);
1068     printf("\n");
1069     printf("%d %d %d %d\n",
1070            linit16.a1,
1071            linit16.a2,
1072            linit16.a3,
1073            linit16.a4);
1074     /* test that initialisation is done after variable declare */
1075     printf("linit17=%d\n", linit17);
1076     printf("sinit15=%d\n", sinit15[0]);
1077 }
1078
1079 void switch_test()
1080 {
1081     int i;
1082
1083     for(i=0;i<15;i++) {
1084         switch(i) {
1085         case 0:
1086         case 1:
1087             printf("a");
1088             break;
1089         default:
1090             printf("%d", i);
1091             break;
1092         case 8 ... 12:
1093             printf("c");
1094             break;
1095         case 3:
1096             printf("b");
1097             break;
1098         }
1099     }
1100     printf("\n");
1101 }
1102
1103 /* ISOC99 _Bool type */
1104 void c99_bool_test(void)
1105 {
1106 #ifdef BOOL_ISOC99
1107     int a;
1108     _Bool b;
1109
1110     printf("bool_test:\n");
1111     printf("sizeof(_Bool) = %d\n", sizeof(_Bool));
1112     a = 3;
1113     printf("cast: %d %d %d\n", (_Bool)10, (_Bool)0, (_Bool)a);
1114     b = 3;
1115     printf("b = %d\n", b);
1116     b++;
1117     printf("b = %d\n", b);
1118 #endif
1119 }
1120
1121 void bitfield_test(void)
1122 {
1123     int a;
1124     struct sbf1 {
1125         int f1 : 3;
1126         int : 2;
1127         int f2 : 1;
1128         int : 0;
1129         int f3 : 5;
1130         int f4 : 7;
1131         unsigned int f5 : 7;
1132     } st1;
1133     printf("bitfield_test:");
1134     printf("sizeof(st1) = %d\n", sizeof(st1));
1135
1136     st1.f1 = 3;
1137     st1.f2 = 1;
1138     st1.f3 = 15;
1139     a = 120;
1140     st1.f4 = a;
1141     st1.f5 = a;
1142     st1.f5++;
1143     printf("%d %d %d %d %d\n",
1144            st1.f1, st1.f2, st1.f3, st1.f4, st1.f5);
1145 }
1146
1147 #define FTEST(prefix, type, fmt)\
1148 void prefix ## cmp(type a, type b)\
1149 {\
1150     printf("%d %d %d %d %d %d\n",\
1151            a == b,\
1152            a != b,\
1153            a < b,\
1154            a > b,\
1155            a >= b,\
1156            a <= b);\
1157     printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\
1158            a,\
1159            b,\
1160            a + b,\
1161            a - b,\
1162            a * b,\
1163            a / b,\
1164            -a);\
1165     printf(fmt "\n", ++a);\
1166     printf(fmt "\n", a++);\
1167     printf(fmt "\n", a);\
1168 }\
1169 void prefix ## fcast(type a)\
1170 {\
1171     float fa;\
1172     double da;\
1173     long double la;\
1174     int ia;\
1175     unsigned int ua;\
1176     type b;\
1177     fa = a;\
1178     da = a;\
1179     la = a;\
1180     printf("ftof: %f %f %Lf\n", fa, da, la);\
1181     ia = (int)a;\
1182     ua = (unsigned int)a;\
1183     printf("ftoi: %d %u\n", ia, ua);\
1184     ia = -1234;\
1185     ua = 0x81234500;\
1186     b = ia;\
1187     printf("itof: " fmt "\n", b);\
1188     b = ua;\
1189     printf("utof: " fmt "\n", b);\
1190 }\
1191 \
1192 void prefix ## test(void)\
1193 {\
1194     printf("testing '%s'\n", #type);\
1195     prefix ## cmp(1, 2.5);\
1196     prefix ## cmp(2, 1.5);\
1197     prefix ## cmp(1, 1);\
1198     prefix ## fcast(234.6);\
1199     prefix ## fcast(-2334.6);\
1200 }
1201
1202 FTEST(f, float, "%f")
1203 FTEST(d, double, "%f")
1204 FTEST(ld, long double, "%Lf")
1205
1206 double ftab1[3] = { 1.2, 3.4, -5.6 };
1207
1208
1209 void float_test(void)
1210 {
1211     float fa, fb;
1212     double da, db;
1213     int a;
1214     unsigned int b;
1215
1216     printf("float_test:\n");
1217     printf("sizeof(float) = %d\n", sizeof(float));
1218     printf("sizeof(double) = %d\n", sizeof(double));
1219     printf("sizeof(long double) = %d\n", sizeof(long double));
1220     ftest();
1221     dtest();
1222     ldtest();
1223     printf("%f %f %f\n", ftab1[0], ftab1[1], ftab1[2]);
1224     printf("%f %f %f\n", 2.12, .5, 2.3e10);
1225     //    printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
1226     da = 123;
1227     printf("da=%f\n", da);
1228     fa = 123;
1229     printf("fa=%f\n", fa);
1230     a = 4000000000;
1231     da = a;
1232     printf("da = %f\n", da);
1233     b = 4000000000;
1234     db = b;
1235     printf("db = %f\n", db);
1236 }
1237
1238 int fib(int n)
1239 {
1240     if (n <= 2)
1241         return 1;
1242     else
1243         return fib(n-1) + fib(n-2);
1244 }
1245
1246 void funcptr_test()
1247 {
1248     void (*func)(int);
1249     int a;
1250     struct {
1251         int dummy;
1252         void (*func)(int);
1253     } st1;
1254
1255     printf("funcptr:\n");
1256     func = &num;
1257     (*func)(12345);
1258     func = num;
1259     a = 1;
1260     a = 1;
1261     func(12345);
1262     /* more complicated pointer computation */
1263     st1.func = num;
1264     st1.func(12346);
1265     printf("sizeof1 = %d\n", sizeof(funcptr_test));
1266     printf("sizeof2 = %d\n", sizeof funcptr_test);
1267     printf("sizeof3 = %d\n", sizeof(&funcptr_test));
1268     printf("sizeof4 = %d\n", sizeof &funcptr_test);
1269 }
1270
1271 void lloptest(long long a, long long b)
1272 {
1273     unsigned long long ua, ub;
1274
1275     ua = a;
1276     ub = b;
1277     /* arith */
1278     printf("arith: %Ld %Ld %Ld %Ld %Ld\n",
1279            a + b,
1280            a - b,
1281            a * b,
1282            a / b,
1283            a % b);
1284
1285     /* binary */
1286     printf("bin: %Ld %Ld %Ld\n",
1287            a & b,
1288            a | b,
1289            a ^ b);
1290
1291     /* tests */
1292     printf("test: %d %d %d %d %d %d\n",
1293            a == b,
1294            a != b,
1295            a < b,
1296            a > b,
1297            a >= b,
1298            a <= b);
1299
1300     printf("utest: %d %d %d %d %d %d\n",
1301            ua == ub,
1302            ua != ub,
1303            ua < ub,
1304            ua > ub,
1305            ua >= ub,
1306            ua <= ub);
1307
1308     /* arith2 */
1309     a++;
1310     b++;
1311     printf("arith2: %Ld %Ld\n", a, b);
1312     printf("arith2: %Ld %Ld\n", a++, b++);
1313     printf("arith2: %Ld %Ld\n", --a, --b);
1314     printf("arith2: %Ld %Ld\n", a, b);
1315 }
1316
1317 void llshift(long long a, int b)
1318 {
1319     printf("shift: %Ld %Ld %Ld\n",
1320            (unsigned long long)a >> b,
1321            a >> b,
1322            a << b);
1323     printf("shiftc: %Ld %Ld %Ld\n",
1324            (unsigned long long)a >> 3,
1325            a >> 3,
1326            a << 3);
1327     printf("shiftc: %Ld %Ld %Ld\n",
1328            (unsigned long long)a >> 35,
1329            a >> 35,
1330            a << 35);
1331 }
1332
1333 void llfloat(void)
1334 {
1335     float fa;
1336     double da;
1337     long double lda;
1338     long long la, lb, lc;
1339     unsigned long long ula, ulb, ulc;
1340     la = 0x12345678;
1341     ula = 0x72345678;
1342     la = (la << 20) | 0x12345;
1343     ula = ula << 33;
1344     printf("la=%Ld ula=%Lu\n", la, ula);
1345
1346     fa = la;
1347     da = la;
1348     lda = la;
1349     printf("lltof: %f %f %Lf\n", fa, da, lda);
1350
1351     la = fa;
1352     lb = da;
1353     lc = lda;
1354     printf("ftoll: %Ld %Ld %Ld\n", la, lb, lc);
1355
1356     fa = ula;
1357     da = ula;
1358     lda = ula;
1359     printf("ulltof: %f %f %Lf\n", fa, da, lda);
1360
1361     ula = fa;
1362     ulb = da;
1363     ulc = lda;
1364     printf("ftoull: %Lu %Lu %Lu\n", ula, ulb, ulc);
1365 }
1366
1367 long long llfunc1(int a)
1368 {
1369     return a * 2;
1370 }
1371
1372 struct S {
1373     int id;
1374     char item;
1375 };
1376
1377 long long int value(struct S *v)
1378 {
1379     return ((long long int)v->item);
1380 }
1381
1382 void longlong_test(void)
1383 {
1384     long long a, b, c;
1385     int ia;
1386     unsigned int ua;
1387     printf("longlong_test:\n");
1388     printf("sizeof(long long) = %d\n", sizeof(long long));
1389     ia = -1;
1390     ua = -2;
1391     a = ia;
1392     b = ua;
1393     printf("%Ld %Ld\n", a, b);
1394     printf("%Ld %Ld %Ld %Lx\n",
1395            (long long)1,
1396            (long long)-2,
1397            1LL,
1398            0x1234567812345679);
1399     a = llfunc1(-3);
1400     printf("%Ld\n", a);
1401
1402     lloptest(1000, 23);
1403     lloptest(0xff, 0x1234);
1404     b = 0x72345678 << 10;
1405     lloptest(-3, b);
1406     llshift(0x123, 5);
1407     llshift(-23, 5);
1408     b = 0x72345678LL << 10;
1409     llshift(b, 47);
1410
1411     llfloat();
1412 #if 1
1413     b = 0x12345678;
1414     a = -1;
1415     c = a + b;
1416     printf("%Lx\n", c);
1417 #endif
1418
1419     /* long long reg spill test */
1420     {
1421           struct S a;
1422
1423           a.item = 3;
1424           printf("%lld\n", value(&a));
1425     }
1426 }
1427
1428 void vprintf1(const char *fmt, ...)
1429 {
1430     va_list ap;
1431     const char *p;
1432     int c, i;
1433     double d;
1434     long long ll;
1435
1436     va_start(ap, fmt);
1437
1438     p = fmt;
1439     for(;;) {
1440         c = *p;
1441         if (c == '\0')
1442             break;
1443         p++;
1444         if (c == '%') {
1445             c = *p;
1446             switch(c) {
1447             case '\0':
1448                 goto the_end;
1449             case 'd':
1450                 i = va_arg(ap, int);
1451                 printf("%d", i);
1452                 break;
1453             case 'f':
1454                 d = va_arg(ap, double);
1455                 printf("%f", d);
1456                 break;
1457             case 'l':
1458                 ll = va_arg(ap, long long);
1459                 printf("%Ld", ll);
1460                 break;
1461             }
1462             p++;
1463         } else {
1464             putchar(c);
1465         }
1466     }
1467  the_end:
1468     va_end(ap);
1469 }
1470
1471
1472 void stdarg_test(void)
1473 {
1474     vprintf1("%d %d %d\n", 1, 2, 3);
1475     vprintf1("%f %d %f\n", 1.0, 2, 3.0);
1476     vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0);
1477 }
1478
1479 void whitespace_test(void)
1480 {
1481     char *str;
1482
1483 \f\v
#if 1
1484     pri\
1485 ntf("whitspace:\n");\f\v
1486 #endif
1487     pf("N=%d\n", 2);
1488     pri\
1489 ntf("aaa=%d\n", 3);
1490
1491     pri\
1492 \
1493 ntf("min=%d\n", 4);
1494     printf("len1=%d\n", strlen("
1495 "));
1496     str = "
1497 ";
1498     printf("len1=%d str[0]=%d\n", strlen(str), str[0]);
1499     printf("len1=%d\n", strlen("
a
1500 "));
1501 }
1502
1503 int reltab[3] = { 1, 2, 3 };
1504
1505 int *rel1 = &reltab[1];
1506 int *rel2 = &reltab[2];
1507
1508 void relocation_test(void)
1509 {
1510     printf("*rel1=%d\n", *rel1);
1511     printf("*rel2=%d\n", *rel2);
1512 }
1513
1514 void old_style_f(a,b,c)
1515      int a, b;
1516      double c;
1517 {
1518     printf("a=%d b=%d b=%f\n", a, b, c);
1519 }
1520
1521 void old_style_function(void)
1522 {
1523     old_style_f((void *)1, 2, 3.0);
1524 }
1525
1526 void sizeof_test(void)
1527 {
1528     int a;
1529     int **ptr;
1530
1531     printf("sizeof(int) = %d\n", sizeof(int));
1532     printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
1533     printf("sizeof(short) = %d\n", sizeof(short));
1534     printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
1535     printf("sizeof(char) = %d\n", sizeof(char));
1536     printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
1537     printf("sizeof(func) = %d\n", sizeof sizeof_test());
1538     a = 1;
1539     printf("sizeof(a++) = %d\n", sizeof a++);
1540     printf("a=%d\n", a);
1541     ptr = NULL;
1542     printf("sizeof(**ptr) = %d\n", sizeof (**ptr));
1543
1544     /* some alignof tests */
1545     printf("__alignof__(int) = %d\n", __alignof__(int));
1546     printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int));
1547     printf("__alignof__(short) = %d\n", __alignof__(short));
1548     printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short));
1549     printf("__alignof__(char) = %d\n", __alignof__(char));
1550     printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char));
1551     printf("__alignof__(func) = %d\n", __alignof__ sizeof_test());
1552 }
1553
1554 void typeof_test(void)
1555 {
1556     double a;
1557     typeof(a) b;
1558     typeof(float) c;
1559
1560     a = 1.5;
1561     b = 2.5;
1562     c = 3.5;
1563     printf("a=%f b=%f c=%f\n", a, b, c);
1564 }