History

new subdirs: include, lib, tests

grischka committed 17 years ago

Commit ea5e81b1 parent e8a52a816 files · +0 −6Browse files

Showing the changes to tests (5 of 16 files). Show all

Unified · Split

5 files
  1. tests/asmtest.S +558 −0
  2. tests/boundtest.c +214 −0
  3. tests/gcctestsuite.sh +33 −0
  4. tests/libtcc_test.c +84 −0
  5. tests/tcctest.c +2188 −0
tests/asmtest.S+558−0
@@ -0,0 +1,558 @@
1
2/* some directive tests */
3
4 .byte 0xff
5 .byte 1, 2, 3
6 .short 1, 2, 3
7 .word 1, 2, 3
8 .long 1, 2, 3
9 .int 1, 2, 3
10 .align 8
11 .byte 1
12 .align 16, 0x90
13 .skip 3
14 .skip 15, 0x90
15 .string "hello\0world"
16
17/* some label tests */
18
19 movl %eax, %ebx
20L1:
21 movl %eax, %ebx
22 mov 0x10000, %eax
23L2:
24 movl $L2 - L1, %ecx
25var1:
26 nop ; nop ; nop ; nop
27
28 mov var1, %eax
29
30/* instruction tests */
31movl %eax, %ebx
32mov 0x10000, %eax
33mov 0x10000, %ax
34mov 0x10000, %al
35mov %al, 0x10000
36
37mov $1, %edx
38mov $1, %dx
39mov $1, %dl
40movb $2, 0x100(%ebx,%edx,2)
41movw $2, 0x100(%ebx,%edx,2)
42movl $2, 0x100(%ebx,%edx,2)
43movl %eax, 0x100(%ebx,%edx,2)
44movl 0x100(%ebx,%edx,2), %edx
45movw %ax, 0x100(%ebx,%edx,2)
46
47mov %eax, 0x12(,%edx,2)
48
49mov %cr3, %edx
50mov %ecx, %cr3
51movl %cr3, %eax
52movl %tr3, %eax
53movl %db3, %ebx
54movl %dr6, %eax
55movl %fs, %ecx
56movl %ebx, %fs
57
58 movsbl 0x1000, %eax
59 movsbw 0x1000, %ax
60 movswl 0x1000, %eax
61
62 movzbl 0x1000, %eax
63 movzbw 0x1000, %ax
64 movzwl 0x1000, %eax
65
66 movzb 0x1000, %eax
67 movzb 0x1000, %ax
68
69
70 pushl %eax
71 pushw %ax
72 push %eax
73 push %cs
74 push %gs
75 push $1
76 push $100
77
78 popl %eax
79 popw %ax
80 pop %eax
81 pop %ds
82 pop %fs
83
84 xchg %eax, %ecx
85 xchg %edx, %eax
86 xchg %bx, 0x10000
87 xchg 0x10000, %ebx
88 xchg 0x10000, %dl
89
90 in $100, %al
91 in $100, %ax
92 in $100, %eax
93 in %dx, %al
94 in %dx, %ax
95 in %dx, %eax
96 inb %dx
97 inw %dx
98 inl %dx
99
100 out %al, $100
101 out %ax, $100
102 out %eax, $100
103
104 /* NOTE: gas is bugged here, so size must be added */
105 outb %al, %dx
106 outw %ax, %dx
107 outl %eax, %dx
108
109 leal 0x1000(%ebx), %ecx
110 lea 0x1000(%ebx), %ecx
111
112 les 0x2000, %eax
113 lds 0x2000, %ebx
114 lfs 0x2000, %ecx
115 lgs 0x2000, %edx
116 lss 0x2000, %edx
117
118addl $0x123, %eax
119add $0x123, %ebx
120addl $0x123, 0x100
121addl $0x123, 0x100(%ebx)
122addl $0x123, 0x100(%ebx,%edx,2)
123addl $0x123, 0x100(%esp)
124addl $0x123, (%ebp)
125addl $0x123, (%esp)
126cmpl $0x123, (%esp)
127
128add %eax, (%ebx)
129add (%ebx), %eax
130
131or %dx, (%ebx)
132or (%ebx), %si
133
134add %cl, (%ebx)
135add (%ebx), %dl
136
137 inc %edx
138 incl 0x10000
139 incb 0x10000
140 dec %dx
141
142 test $1, %al
143 test $1, %cl
144
145 testl $1, 0x1000
146 testb $1, 0x1000
147 testw $1, 0x1000
148 test %eax, %ebx
149 test %eax, 0x1000
150 test 0x1000, %edx
151
152 not %edx
153 notw 0x10000
154 notl 0x10000
155 notb 0x10000
156
157 neg %edx
158 negw 0x10000
159 negl 0x10000
160 negb 0x10000
161
162 imul %ecx
163 mul %edx
164 mulb %cl
165
166 imul %eax, %ecx
167 imul 0x1000, %cx
168 imul $10, %eax, %ecx
169 imul $10, %ax, %cx
170 imul $10, %eax
171 imul $0x1100000, %eax
172 imul $1, %eax
173
174 idivw 0x1000
175 div %ecx
176 div %bl
177 div %ecx, %eax
178
179
180shl %edx
181shl $10, %edx
182shl %cl, %edx
183
184shld $1, %eax, %edx
185shld %cl, %eax, %edx
186shld %eax, %edx
187
188shrd $1, %eax, %edx
189shrd %cl, %eax, %edx
190shrd %eax, %edx
191
192L4:
193call 0x1000
194call L4
195call *%eax
196call *0x1000
197call func1
198
199lcall $0x100, $0x1000
200
201jmp 0x1000
202jmp *%eax
203jmp *0x1000
204
205ljmp $0x100, $0x1000
206
207ret
208
209ret $10
210
211lret
212
213lret $10
214
215enter $1234, $10
216
217L3:
218 jo 0x1000
219 jnp 0x1001
220 jne 0x1002
221 jg 0x1003
222
223 jo L3
224 jnp L3
225 jne L3
226 jg L3
227
228 loopne L3
229 loopnz L3
230 loope L3
231 loopz L3
232 loop L3
233 jecxz L3
234
235
236 seto %al
237 setnp 0x1000
238 setl 0xaaaa
239 setg %dl
240
241 fadd
242 fadd %st(1), %st
243 fadd %st(3)
244
245 faddp %st(5)
246 faddp
247 faddp %st(1), %st
248
249 fadds 0x1000
250 fiadds 0x1002
251 faddl 0x1004
252 fiaddl 0x1006
253
254 fmul
255 fmul %st(1), %st
256 fmul %st(3)
257
258 fmulp %st(5)
259 fmulp
260 fmulp %st(1), %st
261
262 fmuls 0x1000
263 fimuls 0x1002
264 fmull 0x1004
265 fimull 0x1006
266
267 fsub
268 fsub %st(1), %st
269 fsub %st(3)
270
271 fsubp %st(5)
272 fsubp
273 fsubp %st(1), %st
274
275 fsubs 0x1000
276 fisubs 0x1002
277 fsubl 0x1004
278 fisubl 0x1006
279
280 fsubr
281 fsubr %st(1), %st
282 fsubr %st(3)
283
284 fsubrp %st(5)
285 fsubrp
286 fsubrp %st(1), %st
287
288 fsubrs 0x1000
289 fisubrs 0x1002
290 fsubrl 0x1004
291 fisubrl 0x1006
292
293 fdiv
294 fdiv %st(1), %st
295 fdiv %st(3)
296
297 fdivp %st(5)
298 fdivp
299 fdivp %st(1), %st
300
301 fdivs 0x1000
302 fidivs 0x1002
303 fdivl 0x1004
304 fidivl 0x1006
305
306 fcom %st(3)
307
308 fcoms 0x1000
309 ficoms 0x1002
310 fcoml 0x1004
311 ficoml 0x1006
312
313 fcomp %st(5)
314 fcomp
315 fcompp
316
317 fcomps 0x1000
318 ficomps 0x1002
319 fcompl 0x1004
320 ficompl 0x1006
321
322 fld %st(5)
323 fldl 0x1000
324 flds 0x1002
325 fildl 0x1004
326 fst %st(4)
327 fstp %st(6)
328 fstpt 0x1006
329 fbstp 0x1008
330
331 fxch
332 fxch %st(4)
333
334 fucom %st(6)
335 fucomp %st(3)
336 fucompp
337
338 finit
339 fninit
340 fldcw 0x1000
341 fnstcw 0x1002
342 fstcw 0x1002
343 fnstsw 0x1004
344 fnstsw %eax
345 fstsw 0x1004
346 fstsw %eax
347 fnclex
348 fclex
349 fnstenv 0x1000
350 fstenv 0x1000
351 fldenv 0x1000
352 fnsave 0x1002
353 fsave 0x1000
354 frstor 0x1000
355 ffree %st(7)
356 ffreep %st(6)
357
358 ftst
359 fxam
360 fld1
361 fldl2t
362 fldl2e
363 fldpi
364 fldlg2
365 fldln2
366 fldz
367
368 f2xm1
369 fyl2x
370 fptan
371 fpatan
372 fxtract
373 fprem1
374 fdecstp
375 fincstp
376 fprem
377 fyl2xp1
378 fsqrt
379 fsincos
380 frndint
381 fscale
382 fsin
383 fcos
384 fchs
385 fabs
386 fnop
387 fwait
388
389bswap %edx
390xadd %ecx, %edx
391xaddb %dl, 0x1000
392xaddw %ax, 0x1000
393xaddl %eax, 0x1000
394cmpxchg %ecx, %edx
395cmpxchgb %dl, 0x1000
396cmpxchgw %ax, 0x1000
397cmpxchgl %eax, 0x1000
398invlpg 0x1000
399cmpxchg8b 0x1002
400
401fcmovb %st(5), %st
402fcmove %st(5), %st
403fcmovbe %st(5), %st
404fcmovu %st(5), %st
405fcmovnb %st(5), %st
406fcmovne %st(5), %st
407fcmovnbe %st(5), %st
408fcmovnu %st(5), %st
409fcomi %st(5), %st
410fucomi %st(5), %st
411fcomip %st(5), %st
412fucomip %st(5), %st
413
414
415
416 cmovo 0x1000, %eax
417 cmovs 0x1000, %eax
418 cmovns %edx, %edi
419
420int $3
421int $0x10
422
423 pusha
424 popa
425 clc
426 cld
427 cli
428 clts
429 cmc
430 lahf
431 sahf
432 pushfl
433 popfl
434 pushf
435 popf
436 stc
437 std
438 sti
439 aaa
440 aas
441 daa
442 das
443 aad
444 aam
445 cbw
446 cwd
447 cwde
448 cdq
449 cbtw
450 cwtd
451 cwtl
452 cltd
453 leave
454 int3
455 into
456 iret
457 rsm
458 hlt
459 wait
460 nop
461
462 /* XXX: handle prefixes */
463#if 0
464 aword
465 addr16
466#endif
467 lock
468 rep
469 repe
470 repz
471 repne
472 repnz
473
474 invd
475 wbinvd
476 cpuid
477 wrmsr
478 rdtsc
479 rdmsr
480 rdpmc
481 ud2
482
483 emms
484 movd %edx, %mm3
485 movd 0x1000, %mm2
486 movd %mm4, %ecx
487 movd %mm5, 0x1000
488
489 movq 0x1000, %mm2
490 movq %mm4, 0x1000
491
492 pand 0x1000, %mm3
493 pand %mm4, %mm5
494
495 psllw $1, %mm6
496 psllw 0x1000, %mm7
497 psllw %mm2, %mm7
498
499 xlat
500 cmpsb
501 scmpw
502 insl
503 outsw
504 lodsb
505 slodl
506 movsb
507 movsl
508 smovb
509 scasb
510 sscaw
511 stosw
512 sstol
513
514 bsf 0x1000, %ebx
515 bsr 0x1000, %ebx
516 bt %edx, 0x1000
517 btl $2, 0x1000
518 btc %edx, 0x1000
519 btcl $2, 0x1000
520 btr %edx, 0x1000
521 btrl $2, 0x1000
522 bts %edx, 0x1000
523 btsl $2, 0x1000
524
525
526
527 boundl %edx, 0x10000
528 boundw %bx, 0x1000
529
530 arpl %bx, 0x1000
531 lar 0x1000, %eax
532 lgdt 0x1000
533 lidt 0x1000
534 lldt 0x1000
535 lmsw 0x1000
536 lsl 0x1000, %ecx
537 ltr 0x1000
538
539 sgdt 0x1000
540 sidt 0x1000
541 sldt 0x1000
542 smsw 0x1000
543 str 0x1000
544
545 verr 0x1000
546 verw 0x1000
547
548 push %ds
549 pushw %ds
550 pushl %ds
551 pop %ds
552 popw %ds
553 popl %ds
554 fxsave 1(%ebx)
555 fxrstor 1(%ecx)
556 pushl $1
557 pushw $1
558 push $1
tests/boundtest.c+214−0
@@ -0,0 +1,214 @@
1#include <stdlib.h>
2#include <stdio.h>
3
4#define NB_ITS 1000000
5//#define NB_ITS 1
6#define TAB_SIZE 100
7
8int tab[TAB_SIZE];
9int ret_sum;
10char tab3[256];
11
12int test1(void)
13{
14 int i, sum = 0;
15 for(i=0;i<TAB_SIZE;i++) {
16 sum += tab[i];
17 }
18 return sum;
19}
20
21/* error */
22int test2(void)
23{
24 int i, sum = 0;
25 for(i=0;i<TAB_SIZE + 1;i++) {
26 sum += tab[i];
27 }
28 return sum;
29}
30
31/* actually, profiling test */
32int test3(void)
33{
34 int sum;
35 int i, it;
36
37 sum = 0;
38 for(it=0;it<NB_ITS;it++) {
39 for(i=0;i<TAB_SIZE;i++) {
40 sum += tab[i];
41 }
42 }
43 return sum;
44}
45
46/* ok */
47int test4(void)
48{
49 int i, sum = 0;
50 int *tab4;
51
52 tab4 = malloc(20 * sizeof(int));
53 for(i=0;i<20;i++) {
54 sum += tab4[i];
55 }
56 free(tab4);
57
58 return sum;
59}
60
61/* error */
62int test5(void)
63{
64 int i, sum = 0;
65 int *tab4;
66
67 tab4 = malloc(20 * sizeof(int));
68 for(i=0;i<21;i++) {
69 sum += tab4[i];
70 }
71 free(tab4);
72
73 return sum;
74}
75
76/* error */
77/* XXX: currently: bug */
78int test6(void)
79{
80 int i, sum = 0;
81 int *tab4;
82
83 tab4 = malloc(20 * sizeof(int));
84 free(tab4);
85 for(i=0;i<21;i++) {
86 sum += tab4[i];
87 }
88
89 return sum;
90}
91
92/* error */
93int test7(void)
94{
95 int i, sum = 0;
96 int *p;
97
98 for(i=0;i<TAB_SIZE + 1;i++) {
99 p = &tab[i];
100 if (i == TAB_SIZE)
101 printf("i=%d %x\n", i, p);
102 sum += *p;
103 }
104 return sum;
105}
106
107/* ok */
108int test8(void)
109{
110 int i, sum = 0;
111 int tab[10];
112
113 for(i=0;i<10;i++) {
114 sum += tab[i];
115 }
116 return sum;
117}
118
119/* error */
120int test9(void)
121{
122 int i, sum = 0;
123 char tab[10];
124
125 for(i=0;i<11;i++) {
126 sum += tab[i];
127 }
128 return sum;
129}
130
131/* ok */
132int test10(void)
133{
134 char tab[10];
135 char tab1[10];
136
137 memset(tab, 0, 10);
138 memcpy(tab, tab1, 10);
139 memmove(tab, tab1, 10);
140 return 0;
141}
142
143/* error */
144int test11(void)
145{
146 char tab[10];
147
148 memset(tab, 0, 11);
149 return 0;
150}
151
152/* error */
153int test12(void)
154{
155 void *ptr;
156 ptr = malloc(10);
157 free(ptr);
158 free(ptr);
159 return 0;
160}
161
162/* error */
163int test13(void)
164{
165 char pad1 = 0;
166 char tab[10];
167 char pad2 = 0;
168 memset(tab, 'a', sizeof(tab));
169 return strlen(tab);
170}
171
172int (*table_test[])(void) = {
173 test1,
174 test1,
175 test2,
176 test3,
177 test4,
178 test5,
179 test6,
180 test7,
181 test8,
182 test9,
183 test10,
184 test11,
185 test12,
186 test13,
187};
188
189int main(int argc, char **argv)
190{
191 int index;
192 int (*ftest)(void);
193
194 if (argc < 2) {
195 printf("usage: boundtest n\n"
196 "test TCC bound checking system\n"
197 );
198 exit(1);
199 }
200
201 index = 0;
202 if (argc >= 2)
203 index = atoi(argv[1]);
204 /* well, we also use bounds on this ! */
205 ftest = table_test[index];
206 ftest();
207
208 return 0;
209}
210
211/*
212 * without bound 0.77 s
213 * with bounds 4.73
214 */
tests/gcctestsuite.sh+33−0
@@ -0,0 +1,33 @@
1#!/bin/sh
2
3TESTSUITE_PATH=$HOME/gcc/gcc-3.2/gcc/testsuite/gcc.c-torture
4TCC="./tcc -B. -I. -DNO_TRAMPOLINES"
5rm -f tcc.sum tcc.log
6nb_failed="0"
7
8for src in $TESTSUITE_PATH/compile/*.c ; do
9 echo $TCC -o /tmp/test.o -c $src
10 $TCC -o /tmp/test.o -c $src >> tcc.log 2>&1
11 if [ "$?" == "0" ] ; then
12 result="PASS"
13 else
14 result="FAIL"
15 nb_failed=$[ $nb_failed + 1 ]
16 fi
17 echo "$result: $src" >> tcc.sum
18done
19
20for src in $TESTSUITE_PATH/execute/*.c ; do
21 echo $TCC $src
22 $TCC $src >> tcc.log 2>&1
23 if [ "$?" == "0" ] ; then
24 result="PASS"
25 else
26 result="FAIL"
27 nb_failed=$[ $nb_failed + 1 ]
28 fi
29 echo "$result: $src" >> tcc.sum
30done
31
32echo "$nb_failed test(s) failed." >> tcc.sum
33echo "$nb_failed test(s) failed."
tests/libtcc_test.c+84−0
@@ -0,0 +1,84 @@
1/*
2 * Simple Test program for libtcc
3 *
4 * libtcc can be useful to use tcc as a "backend" for a code generator.
5 */
6#include <stdlib.h>
7#include <stdio.h>
8#include <string.h>
9
10#include "libtcc.h"
11
12/* this function is called by the generated code */
13int add(int a, int b)
14{
15 return a + b;
16}
17
18char my_program[] =
19"int fib(int n)\n"
20"{\n"
21" if (n <= 2)\n"
22" return 1;\n"
23" else\n"
24" return fib(n-1) + fib(n-2);\n"
25"}\n"
26"\n"
27"int foo(int n)\n"
28"{\n"
29" printf(\"Hello World!\\n\");\n"
30" printf(\"fib(%d) = %d\\n\", n, fib(n));\n"
31" printf(\"add(%d, %d) = %d\\n\", n, 2 * n, add(n, 2 * n));\n"
32" return 0;\n"
33"}\n";
34
35int main(int argc, char **argv)
36{
37 TCCState *s;
38 int (*func)(int);
39 void *mem;
40 int size;
41
42 s = tcc_new();
43 if (!s) {
44 fprintf(stderr, "Could not create tcc state\n");
45 exit(1);
46 }
47
48 /* if tcclib.h and libtcc1.a are not installed, where can we find them */
49 if (argc == 2 && !memcmp(argv[1], "lib_path=",9))
50 tcc_set_lib_path(s, argv[1]+9);
51
52 /* MUST BE CALLED before any compilation */
53 tcc_set_output_type(s, TCC_OUTPUT_MEMORY);
54
55 if (tcc_compile_string(s, my_program) == -1)
56 return 1;
57
58 /* as a test, we add a symbol that the compiled program can use.
59 You may also open a dll with tcc_add_dll() and use symbols from that */
60 tcc_add_symbol(s, "add", add);
61
62 /* get needed size of the code */
63 size = tcc_relocate(s, NULL);
64 if (size == -1)
65 return 1;
66
67 /* allocate memory and copy the code into it */
68 mem = malloc(size);
69 tcc_relocate(s, mem);
70
71 /* get entry symbol */
72 func = tcc_get_symbol(s, "foo");
73 if (!func)
74 return 1;
75
76 /* delete the state */
77 tcc_delete(s);
78
79 /* run the code */
80 func(32);
81
82 free(mem);
83 return 0;
84}
tests/tcctest.c+2188−0
@@ -0,0 +1,2188 @@
1/*
2 * TCC auto test program
3 */
4#include "config.h"
5
6#if GCC_MAJOR >= 3
7
8/* Unfortunately, gcc version < 3 does not handle that! */
9#define ALL_ISOC99
10
11/* only gcc 3 handles _Bool correctly */
12#define BOOL_ISOC99
13
14/* gcc 2.95.3 does not handle correctly CR in strings or after strays */
15#define CORRECT_CR_HANDLING
16
17#endif
18
19/* deprecated and no longer supported in gcc 3.3 */
20//#define ACCEPT_CR_IN_STRINGS
21
22/* __VA_ARGS__ and __func__ support */
23#define C99_MACROS
24
25/* test various include syntaxes */
26
27#define TCCLIB_INC <tcclib.h>
28#define TCCLIB_INC1 <tcclib
29#define TCCLIB_INC2 h>
30#define TCCLIB_INC3 "tcclib"
31
32#include TCCLIB_INC
33
34#include TCCLIB_INC1.TCCLIB_INC2
35
36#include TCCLIB_INC1.h>
37
38/* gcc 3.2 does not accept that (bug ?) */
39//#include TCCLIB_INC3 ".h"
40
41#include <tcclib.h>
42
43#include "tcclib.h"
44
45void string_test();
46void expr_test();
47void macro_test();
48void scope_test();
49void forward_test();
50void funcptr_test();
51void loop_test();
52void switch_test();
53void goto_test();
54void enum_test();
55void typedef_test();
56void struct_test();
57void array_test();
58void expr_ptr_test();
59void bool_test();
60void expr2_test();
61void constant_expr_test();
62void expr_cmp_test();
63void char_short_test();
64void init_test(void);
65void compound_literal_test(void);
66int kr_test();
67void struct_assign_test(void);
68void cast_test(void);
69void bitfield_test(void);
70void c99_bool_test(void);
71void float_test(void);
72void longlong_test(void);
73void manyarg_test(void);
74void stdarg_test(void);
75void whitespace_test(void);
76void relocation_test(void);
77void old_style_function(void);
78void sizeof_test(void);
79void typeof_test(void);
80void local_label_test(void);
81void statement_expr_test(void);
82void asm_test(void);
83void builtin_test(void);
84
85int fib(int n);
86void num(int n);
87void forward_ref(void);
88int isid(int c);
89
90#define A 2
91#define N 1234 + A
92#define pf printf
93#define M1(a, b) (a) + (b)
94
95#define str\
96(s) # s
97#define glue(a, b) a ## b
98#define xglue(a, b) glue(a, b)
99#define HIGHLOW "hello"
100#define LOW LOW ", world"
101
102#define min(a, b) ((a) < (b) ? (a) : (b))
103
104#ifdef C99_MACROS
105#define dprintf(level,...) printf(__VA_ARGS__)
106#endif
107
108/* gcc vararg macros */
109#define dprintf1(level, fmt, args...) printf(fmt, ## args)
110
111#define MACRO_NOARGS()
112
113#define AAA 3
114#undef AAA
115#define AAA 4
116
117#if 1
118#define B3 1
119#elif 1
120#define B3 2
121#elif 0
122#define B3 3
123#else
124#define B3 4
125#endif
126
127#define __INT64_C(c) c ## LL
128#define INT64_MIN (-__INT64_C(9223372036854775807)-1)
129
130int qq(int x)
131{
132 return x + 40;
133}
134#define qq(x) x
135
136#define spin_lock(lock) do { } while (0)
137#define wq_spin_lock spin_lock
138#define TEST2() wq_spin_lock(a)
139
140void macro_test(void)
141{
142 printf("macro:\n");
143 pf("N=%d\n", N);
144 printf("aaa=%d\n", AAA);
145
146 printf("min=%d\n", min(1, min(2, -1)));
147
148 printf("s1=%s\n", glue(HIGH, LOW));
149 printf("s2=%s\n", xglue(HIGH, LOW));
150 printf("s3=%s\n", str("c"));
151 printf("s4=%s\n", str(a1));
152 printf("B3=%d\n", B3);
153
154#ifdef A
155 printf("A defined\n");
156#endif
157#ifdef B
158 printf("B defined\n");
159#endif
160#ifdef A
161 printf("A defined\n");
162#else
163 printf("A not defined\n");
164#endif
165#ifdef B
166 printf("B defined\n");
167#else
168 printf("B not defined\n");
169#endif
170
171#ifdef A
172 printf("A defined\n");
173#ifdef B
174 printf("B1 defined\n");
175#else
176 printf("B1 not defined\n");
177#endif
178#else
179 printf("A not defined\n");
180#ifdef B
181 printf("B2 defined\n");
182#else
183 printf("B2 not defined\n");
184#endif
185#endif
186
187#if 1+1
188 printf("test true1\n");
189#endif
190#if 0
191 printf("test true2\n");
192#endif
193#if 1-1
194 printf("test true3\n");
195#endif
196#if defined(A)
197 printf("test trueA\n");
198#endif
199#if defined(B)
200 printf("test trueB\n");
201#endif
202
203#if 0
204 printf("test 0\n");
205#elif 0
206 printf("test 1\n");
207#elif 2
208 printf("test 2\n");
209#else
210 printf("test 3\n");
211#endif
212
213 MACRO_NOARGS();
214
215#ifdef __LINE__
216 printf("__LINE__ defined\n");
217#endif
218
219 printf("__LINE__=%d __FILE__=%s\n",
220 __LINE__, __FILE__);
221#line 200
222 printf("__LINE__=%d __FILE__=%s\n",
223 __LINE__, __FILE__);
224#line 203 "test"
225 printf("__LINE__=%d __FILE__=%s\n",
226 __LINE__, __FILE__);
227#line 227 "tcctest.c"
228
229 /* not strictly preprocessor, but we test it there */
230#ifdef C99_MACROS
231 printf("__func__ = %s\n", __func__);
232 dprintf(1, "vaarg=%d\n", 1);
233#endif
234 dprintf1(1, "vaarg1\n");
235 dprintf1(1, "vaarg1=%d\n", 2);
236 dprintf1(1, "vaarg1=%d %d\n", 1, 2);
237
238 /* gcc extension */
239 printf("func='%s'\n", __FUNCTION__);
240
241 /* complicated macros in glibc */
242 printf("INT64_MIN=%Ld\n", INT64_MIN);
243 {
244 int a;
245 a = 1;
246 glue(a+, +);
247 printf("a=%d\n", a);
248 glue(a <, <= 2);
249 printf("a=%d\n", a);
250 }
251
252 /* macro function with argument outside the macro string */
253#define MF_s MF_hello
254#define MF_hello(msg) printf("%s\n",msg)
255
256#define MF_t printf("tralala\n"); MF_hello
257
258 MF_s("hi");
259 MF_t("hi");
260
261 /* test macro substituion inside args (should not eat stream) */
262 printf("qq=%d\n", qq(qq)(2));
263
264 /* test zero argument case. NOTE: gcc 2.95.x does not accept a
265 null argument without a space. gcc 3.2 fixes that. */
266
267#define qq1(x) 1
268 printf("qq1=%d\n", qq1( ));
269
270 /* comment with stray handling *\
271/
272 /* this is a valid *\/ comment */
273 /* this is a valid comment *\*/
274 // this is a valid\
275comment
276
277 /* test function macro substitution when the function name is
278 substituted */
279 TEST2();
280}
281
282int op(a,b)
283{
284 return a / b;
285}
286
287int ret(a)
288{
289 if (a == 2)
290 return 1;
291 if (a == 3)
292 return 2;
293 return 0;
294}
295
296void ps(const char *s)
297{
298 int c;
299 while (1) {
300 c = *s;
301 if (c == 0)
302 break;
303 printf("%c", c);
304 s++;
305 }
306}
307
308const char foo1_string[] = "\
309bar\n\
310test\14\
3111";
312
313void string_test()
314{
315 unsigned int b;
316 printf("string:\n");
317 printf("\141\1423\143\n");/* dezdez test */
318 printf("\x41\x42\x43\x3a\n");
319 printf("c=%c\n", 'r');
320 printf("wc=%C 0x%lx %C\n", L'a', L'\x1234', L'c');
321 printf("foo1_string='%s'\n", foo1_string);
322#if 0
323 printf("wstring=%S\n", L"abc");
324 printf("wstring=%S\n", L"abc" L"def" "ghi");
325 printf("'\\377'=%d '\\xff'=%d\n", '\377', '\xff');
326 printf("L'\\377'=%d L'\\xff'=%d\n", L'\377', L'\xff');
327#endif
328 ps("test\n");
329 b = 32;
330 while ((b = b + 1) < 96) {
331 printf("%c", b);
332 }
333 printf("\n");
334 printf("fib=%d\n", fib(33));
335 b = 262144;
336 while (b != 0x80000000) {
337 num(b);
338 b = b * 2;
339 }
340}
341
342void loop_test()
343{
344 int i;
345 i = 0;
346 while (i < 10)
347 printf("%d", i++);
348 printf("\n");
349 for(i = 0; i < 10;i++)
350 printf("%d", i);
351 printf("\n");
352 i = 0;
353 do {
354 printf("%d", i++);
355 } while (i < 10);
356 printf("\n");
357
358 /* break/continue tests */
359 i = 0;
360 while (1) {
361 if (i == 6)
362 break;
363 i++;
364 if (i == 3)
365 continue;
366 printf("%d", i);
367 }
368 printf("\n");
369
370 /* break/continue tests */
371 i = 0;
372 do {
373 if (i == 6)
374 break;
375 i++;
376 if (i == 3)
377 continue;
378 printf("%d", i);
379 } while(1);
380 printf("\n");
381
382 for(i = 0;i < 10;i++) {
383 if (i == 3)
384 continue;
385 printf("%d", i);
386 }
387 printf("\n");
388}
389
390
391void goto_test()
392{
393 int i;
394 static void *label_table[3] = { &&label1, &&label2, &&label3 };
395
396 printf("goto:\n");
397 i = 0;
398 s_loop:
399 if (i >= 10)
400 goto s_end;
401 printf("%d", i);
402 i++;
403 goto s_loop;
404 s_end:
405 printf("\n");
406
407 /* we also test computed gotos (GCC extension) */
408 for(i=0;i<3;i++) {
409 goto *label_table[i];
410 label1:
411 printf("label1\n");
412 goto next;
413 label2:
414 printf("label2\n");
415 goto next;
416 label3:
417 printf("label3\n");
418 next: ;
419 }
420}
421
422enum {
423 E0,
424 E1 = 2,
425 E2 = 4,
426 E3,
427 E4,
428};
429
430enum test {
431 E5 = 1000,
432};
433
434void enum_test()
435{
436 enum test b1;
437 printf("enum:\n%d %d %d %d %d %d\n",
438 E0, E1, E2, E3, E4, E5);
439 b1 = 1;
440 printf("b1=%d\n", b1);
441}
442
443typedef int *my_ptr;
444
445typedef int mytype1;
446typedef int mytype2;
447
448void typedef_test()
449{
450 my_ptr a;
451 mytype1 mytype2;
452 int b;
453
454 a = &b;
455 *a = 1234;
456 printf("typedef:\n");
457 printf("a=%d\n", *a);
458 mytype2 = 2;
459 printf("mytype2=%d\n", mytype2);
460}
461
462void forward_test()
463{
464 printf("forward:\n");
465 forward_ref();
466 forward_ref();
467}
468
469
470void forward_ref(void)
471{
472 printf("forward ok\n");
473}
474
475typedef struct struct1 {
476 int f1;
477 int f2, f3;
478 union union1 {
479 int v1;
480 int v2;
481 } u;
482 char str[3];
483} struct1;
484
485struct struct2 {
486 int a;
487 char b;
488};
489
490union union2 {
491 int w1;
492 int w2;
493};
494
495struct struct1 st1, st2;
496
497int main(int argc, char **argv)
498{
499 string_test();
500 expr_test();
501 macro_test();
502 scope_test();
503 forward_test();
504 funcptr_test();
505 loop_test();
506 switch_test();
507 goto_test();
508 enum_test();
509 typedef_test();
510 struct_test();
511 array_test();
512 expr_ptr_test();
513 bool_test();
514 expr2_test();
515 constant_expr_test();
516 expr_cmp_test();
517 char_short_test();
518 init_test();
519 compound_literal_test();
520 kr_test();
521 struct_assign_test();
522 cast_test();
523 bitfield_test();
524 c99_bool_test();
525 float_test();
526 longlong_test();
527 manyarg_test();
528 stdarg_test();
529 whitespace_test();
530 relocation_test();
531 old_style_function();
532 sizeof_test();
533 typeof_test();
534 statement_expr_test();
535 local_label_test();
536 asm_test();
537 builtin_test();
538 return 0;
539}
540
541int tab[3];
542int tab2[3][2];
543
544int g;
545
546void f1(g)
547{
548 printf("g1=%d\n", g);
549}
550
551void scope_test()
552{
553 printf("scope:\n");
554 g = 2;
555 f1(1);
556 printf("g2=%d\n", g);
557 {
558 int g;
559 g = 3;
560 printf("g3=%d\n", g);
561 {
562 int g;
563 g = 4;
564 printf("g4=%d\n", g);
565 }
566 }
567 printf("g5=%d\n", g);
568}
569
570void array_test(int a[4])
571{
572 int i, j;
573
574 printf("array:\n");
575 printf("sizeof(a) = %d\n", sizeof(a));
576 printf("sizeof(\"a\") = %d\n", sizeof("a"));
577#ifdef C99_MACROS
578 printf("sizeof(__func__) = %d\n", sizeof(__func__));
579#endif
580 printf("sizeof tab %d\n", sizeof(tab));
581 printf("sizeof tab2 %d\n", sizeof tab2);
582 tab[0] = 1;
583 tab[1] = 2;
584 tab[2] = 3;
585 printf("%d %d %d\n", tab[0], tab[1], tab[2]);
586 for(i=0;i<3;i++)
587 for(j=0;j<2;j++)
588 tab2[i][j] = 10 * i + j;
589 for(i=0;i<3*2;i++) {
590 printf(" %3d", ((int *)tab2)[i]);
591 }
592 printf("\n");
593}
594
595void expr_test()
596{
597 int a, b;
598 a = 0;
599 printf("%d\n", a += 1);
600 printf("%d\n", a -= 2);
601 printf("%d\n", a *= 31232132);
602 printf("%d\n", a /= 4);
603 printf("%d\n", a %= 20);
604 printf("%d\n", a &= 6);
605 printf("%d\n", a ^= 7);
606 printf("%d\n", a |= 8);
607 printf("%d\n", a >>= 3);
608 printf("%d\n", a <<= 4);
609
610 a = 22321;
611 b = -22321;
612 printf("%d\n", a + 1);
613 printf("%d\n", a - 2);
614 printf("%d\n", a * 312);
615 printf("%d\n", a / 4);
616 printf("%d\n", b / 4);
617 printf("%d\n", (unsigned)b / 4);
618 printf("%d\n", a % 20);
619 printf("%d\n", b % 20);
620 printf("%d\n", (unsigned)b % 20);
621 printf("%d\n", a & 6);
622 printf("%d\n", a ^ 7);
623 printf("%d\n", a | 8);
624 printf("%d\n", a >> 3);
625 printf("%d\n", b >> 3);
626 printf("%d\n", (unsigned)b >> 3);
627 printf("%d\n", a << 4);
628 printf("%d\n", ~a);
629 printf("%d\n", -a);
630 printf("%d\n", +a);
631
632 printf("%d\n", 12 + 1);
633 printf("%d\n", 12 - 2);
634 printf("%d\n", 12 * 312);
635 printf("%d\n", 12 / 4);
636 printf("%d\n", 12 % 20);
637 printf("%d\n", 12 & 6);
638 printf("%d\n", 12 ^ 7);
639 printf("%d\n", 12 | 8);
640 printf("%d\n", 12 >> 2);
641 printf("%d\n", 12 << 4);
642 printf("%d\n", ~12);
643 printf("%d\n", -12);
644 printf("%d\n", +12);
645 printf("%d %d %d %d\n",
646 isid('a'),
647 isid('g'),
648 isid('T'),
649 isid('('));
650}
651
652int isid(int c)
653{
654 return (c >= 'a' & c <= 'z') | (c >= 'A' & c <= 'Z') | c == '_';
655}
656
657/**********************/
658
659int vstack[10], *vstack_ptr;
660
661void vpush(int vt, int vc)
662{
663 *vstack_ptr++ = vt;
664 *vstack_ptr++ = vc;
665}
666
667void vpop(int *ft, int *fc)
668{
669 *fc = *--vstack_ptr;
670 *ft = *--vstack_ptr;
671}
672
673void expr2_test()
674{
675 int a, b;
676
677 printf("expr2:\n");
678 vstack_ptr = vstack;
679 vpush(1432432, 2);
680 vstack_ptr[-2] &= ~0xffffff80;
681 vpop(&a, &b);
682 printf("res= %d %d\n", a, b);
683}
684
685void constant_expr_test()
686{
687 int a;
688 printf("constant_expr:\n");
689 a = 3;
690 printf("%d\n", a * 16);
691 printf("%d\n", a * 1);
692 printf("%d\n", a + 0);
693}
694
695int tab4[10];
696
697void expr_ptr_test()
698{
699 int *p, *q;
700 int i = -1;
701
702 printf("expr_ptr:\n");
703 p = tab4;
704 q = tab4 + 10;
705 printf("diff=%d\n", q - p);
706 p++;
707 printf("inc=%d\n", p - tab4);
708 p--;
709 printf("dec=%d\n", p - tab4);
710 ++p;
711 printf("inc=%d\n", p - tab4);
712 --p;
713 printf("dec=%d\n", p - tab4);
714 printf("add=%d\n", p + 3 - tab4);
715 printf("add=%d\n", 3 + p - tab4);
716
717 /* check if 64bit support is ok */
718 q = p = 0;
719 q += i;
720 printf("%p %p %ld\n", q, p, p-q);
721 printf("%d %d %d %d %d %d\n",
722 p == q, p != q, p < q, p <= q, p >= q, p > q);
723 i = 0xf0000000;
724 p += i;
725 printf("%p %p %ld\n", q, p, p-q);
726 printf("%d %d %d %d %d %d\n",
727 p == q, p != q, p < q, p <= q, p >= q, p > q);
728 p = (int *)((char *)p + 0xf0000000);
729 printf("%p %p %ld\n", q, p, p-q);
730 printf("%d %d %d %d %d %d\n",
731 p == q, p != q, p < q, p <= q, p >= q, p > q);
732 p += 0xf0000000;
733 printf("%p %p %ld\n", q, p, p-q);
734 printf("%d %d %d %d %d %d\n",
735 p == q, p != q, p < q, p <= q, p >= q, p > q);
736 {
737 struct size12 {
738 int i, j, k;
739 };
740 struct size12 s[2], *sp = s;
741 int i, j;
742 sp->i = 42;
743 sp++;
744 j = -1;
745 printf("%d\n", sp[j].i);
746 }
747}
748
749void expr_cmp_test()
750{
751 int a, b;
752 printf("constant_expr:\n");
753 a = -1;
754 b = 1;
755 printf("%d\n", a == a);
756 printf("%d\n", a != a);
757
758 printf("%d\n", a < b);
759 printf("%d\n", a <= b);
760 printf("%d\n", a <= a);
761 printf("%d\n", b >= a);
762 printf("%d\n", a >= a);
763 printf("%d\n", b > a);
764
765 printf("%d\n", (unsigned)a < b);
766 printf("%d\n", (unsigned)a <= b);
767 printf("%d\n", (unsigned)a <= a);
768 printf("%d\n", (unsigned)b >= a);
769 printf("%d\n", (unsigned)a >= a);
770 printf("%d\n", (unsigned)b > a);
771}
772
773struct empty {
774};
775
776struct aligntest1 {
777 char a[10];
778};
779
780struct aligntest2 {
781 int a;
782 char b[10];
783};
784
785struct aligntest3 {
786 double a, b;
787};
788
789struct aligntest4 {
790 double a[0];
791};
792
793void struct_test()
794{
795 struct1 *s;
796 union union2 u;
797
798 printf("struct:\n");
799 printf("sizes: %d %d %d %d\n",
800 sizeof(struct struct1),
801 sizeof(struct struct2),
802 sizeof(union union1),
803 sizeof(union union2));
804 st1.f1 = 1;
805 st1.f2 = 2;
806 st1.f3 = 3;
807 printf("st1: %d %d %d\n",
808 st1.f1, st1.f2, st1.f3);
809 st1.u.v1 = 1;
810 st1.u.v2 = 2;
811 printf("union1: %d\n", st1.u.v1);
812 u.w1 = 1;
813 u.w2 = 2;
814 printf("union2: %d\n", u.w1);
815 s = &st2;
816 s->f1 = 3;
817 s->f2 = 2;
818 s->f3 = 1;
819 printf("st2: %d %d %d\n",
820 s->f1, s->f2, s->f3);
821 printf("str_addr=%x\n", (int)st1.str - (int)&st1.f1);
822
823 /* align / size tests */
824 printf("aligntest1 sizeof=%d alignof=%d\n",
825 sizeof(struct aligntest1), __alignof__(struct aligntest1));
826 printf("aligntest2 sizeof=%d alignof=%d\n",
827 sizeof(struct aligntest2), __alignof__(struct aligntest2));
828 printf("aligntest3 sizeof=%d alignof=%d\n",
829 sizeof(struct aligntest3), __alignof__(struct aligntest3));
830 printf("aligntest4 sizeof=%d alignof=%d\n",
831 sizeof(struct aligntest4), __alignof__(struct aligntest4));
832
833 /* empty structures (GCC extension) */
834 printf("sizeof(struct empty) = %d\n", sizeof(struct empty));
835 printf("alignof(struct empty) = %d\n", __alignof__(struct empty));
836}
837
838/* XXX: depend on endianness */
839void char_short_test()
840{
841 int var1, var2;
842
843 printf("char_short:\n");
844
845 var1 = 0x01020304;
846 var2 = 0xfffefdfc;
847 printf("s8=%d %d\n",
848 *(char *)&var1, *(char *)&var2);
849 printf("u8=%d %d\n",
850 *(unsigned char *)&var1, *(unsigned char *)&var2);
851 printf("s16=%d %d\n",
852 *(short *)&var1, *(short *)&var2);
853 printf("u16=%d %d\n",
854 *(unsigned short *)&var1, *(unsigned short *)&var2);
855 printf("s32=%d %d\n",
856 *(int *)&var1, *(int *)&var2);
857 printf("u32=%d %d\n",
858 *(unsigned int *)&var1, *(unsigned int *)&var2);
859 *(char *)&var1 = 0x08;
860 printf("var1=%x\n", var1);
861 *(short *)&var1 = 0x0809;
862 printf("var1=%x\n", var1);
863 *(int *)&var1 = 0x08090a0b;
864 printf("var1=%x\n", var1);
865}
866
867/******************/
868
869typedef struct Sym {
870 int v;
871 int t;
872 int c;
873 struct Sym *next;
874 struct Sym *prev;
875} Sym;
876
877#define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
878#define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
879
880static int toupper1(int a)
881{
882 return TOUPPER(a);
883}
884
885void bool_test()
886{
887 int *s, a, b, t, f, i;
888
889 a = 0;
890 s = (void*)0;
891 printf("!s=%d\n", !s);
892
893 if (!s || !s[0])
894 a = 1;
895 printf("a=%d\n", a);
896
897 printf("a=%d %d %d\n", 0 || 0, 0 || 1, 1 || 1);
898 printf("a=%d %d %d\n", 0 && 0, 0 && 1, 1 && 1);
899 printf("a=%d %d\n", 1 ? 1 : 0, 0 ? 1 : 0);
900#if 1 && 1
901 printf("a1\n");
902#endif
903#if 1 || 0
904 printf("a2\n");
905#endif
906#if 1 ? 0 : 1
907 printf("a3\n");
908#endif
909#if 0 ? 0 : 1
910 printf("a4\n");
911#endif
912
913 a = 4;
914 printf("b=%d\n", a + (0 ? 1 : a / 2));
915
916 /* test register spilling */
917 a = 10;
918 b = 10;
919 a = (a + b) * ((a < b) ?
920 ((b - a) * (a - b)): a + b);
921 printf("a=%d\n", a);
922
923 /* test complex || or && expressions */
924 t = 1;
925 f = 0;
926 a = 32;
927 printf("exp=%d\n", f == (32 <= a && a <= 3));
928 printf("r=%d\n", (t || f) + (t && f));
929
930 /* test ? : cast */
931 {
932 int aspect_on;
933 int aspect_native = 65536;
934 double bfu_aspect = 1.0;
935 int aspect;
936 for(aspect_on = 0; aspect_on < 2; aspect_on++) {
937 aspect=aspect_on?(aspect_native*bfu_aspect+0.5):65535UL;
938 printf("aspect=%d\n", aspect);
939 }
940 }
941
942 /* test ? : GCC extension */
943 {
944 static int v1 = 34 ? : -1; /* constant case */
945 static int v2 = 0 ? : -1; /* constant case */
946 int a = 30;
947
948 printf("%d %d\n", v1, v2);
949 printf("%d %d\n", a - 30 ? : a * 2, a + 1 ? : a * 2);
950 }
951
952 /* again complex expression */
953 for(i=0;i<256;i++) {
954 if (toupper1 (i) != TOUPPER (i))
955 printf("error %d\n", i);
956 }
957}
958
959/* GCC accepts that */
960static int tab_reinit[];
961static int tab_reinit[10];
962
963//int cinit1; /* a global variable can be defined several times without error ! */
964int cinit1;
965int cinit1;
966int cinit1 = 0;
967int *cinit2 = (int []){3, 2, 1};
968
969void compound_literal_test(void)
970{
971 int *p, i;
972 char *q, *q3;
973
974 printf("compound_test:\n");
975
976 p = (int []){1, 2, 3};
977 for(i=0;i<3;i++)
978 printf(" %d", p[i]);
979 printf("\n");
980
981 for(i=0;i<3;i++)
982 printf("%d", cinit2[i]);
983 printf("\n");
984
985 q = "tralala1";
986 printf("q1=%s\n", q);
987
988 q = (char *){ "tralala2" };
989 printf("q2=%s\n", q);
990
991 q3 = (char *){ q };
992 printf("q3=%s\n", q3);
993
994 q = (char []){ "tralala3" };
995 printf("q4=%s\n", q);
996
997#ifdef ALL_ISOC99
998 p = (int []){1, 2, cinit1 + 3};
999 for(i=0;i<3;i++)
1000 printf(" %d", p[i]);
1001 printf("\n");
1002
1003 for(i=0;i<3;i++) {
1004 p = (int []){1, 2, 4 + i};
1005 printf("%d %d %d\n",
1006 p[0],
1007 p[1],
1008 p[2]);
1009 }
1010#endif
1011}
1012
1013/* K & R protos */
1014
1015kr_func1(a, b)
1016{
1017 return a + b;
1018}
1019
1020int kr_func2(a, b)
1021{
1022 return a + b;
1023}
1024
1025kr_test()
1026{
1027 printf("kr_test:\n");
1028 printf("func1=%d\n", kr_func1(3, 4));
1029 printf("func2=%d\n", kr_func2(3, 4));
1030 return 0;
1031}
1032
1033void num(int n)
1034{
1035 char *tab, *p;
1036 tab = (char*)malloc(20);
1037 p = tab;
1038 while (1) {
1039 *p = 48 + (n % 10);
1040 p++;
1041 n = n / 10;
1042 if (n == 0)
1043 break;
1044 }
1045 while (p != tab) {
1046 p--;
1047 printf("%c", *p);
1048 }
1049 printf("\n");
1050}
1051
1052/* structure assignment tests */
1053struct structa1 {
1054 int f1;
1055 char f2;
1056};
1057
1058struct structa1 ssta1;
1059
1060void struct_assign_test1(struct structa1 s1, int t)
1061{
1062 printf("%d %d %d\n", s1.f1, s1.f2, t);
1063}
1064
1065struct structa1 struct_assign_test2(struct structa1 s1, int t)
1066{
1067 s1.f1 += t;
1068 s1.f2 -= t;
1069 return s1;
1070}
1071
1072void struct_assign_test(void)
1073{
1074 struct structa1 lsta1, lsta2;
1075
1076#if 0
1077 printf("struct_assign_test:\n");
1078
1079 lsta1.f1 = 1;
1080 lsta1.f2 = 2;
1081 printf("%d %d\n", lsta1.f1, lsta1.f2);
1082 lsta2 = lsta1;
1083 printf("%d %d\n", lsta2.f1, lsta2.f2);
1084#else
1085 lsta2.f1 = 1;
1086 lsta2.f2 = 2;
1087#endif
1088 struct_assign_test1(lsta2, 3);
1089
1090 printf("before call: %d %d\n", lsta2.f1, lsta2.f2);
1091 lsta2 = struct_assign_test2(lsta2, 4);
1092 printf("after call: %d %d\n", lsta2.f1, lsta2.f2);
1093}
1094
1095/* casts to short/char */
1096
1097void cast1(char a, short b, unsigned char c, unsigned short d)
1098{
1099 printf("%d %d %d %d\n", a, b, c, d);
1100}
1101
1102char bcast;
1103short scast;
1104
1105void cast_test()
1106{
1107 int a;
1108 char c;
1109 char tab[10];
1110 unsigned b,d;
1111 short s;
1112 char *p = NULL;
1113 p -= 0x700000000042;
1114
1115 printf("cast_test:\n");
1116 a = 0xfffff;
1117 cast1(a, a, a, a);
1118 a = 0xffffe;
1119 printf("%d %d %d %d\n",
1120 (char)(a + 1),
1121 (short)(a + 1),
1122 (unsigned char)(a + 1),
1123 (unsigned short)(a + 1));
1124 printf("%d %d %d %d\n",
1125 (char)0xfffff,
1126 (short)0xfffff,
1127 (unsigned char)0xfffff,
1128 (unsigned short)0xfffff);
1129
1130 a = (bcast = 128) + 1;
1131 printf("%d\n", a);
1132 a = (scast = 65536) + 1;
1133 printf("%d\n", a);
1134
1135 printf("sizeof(c) = %d, sizeof((int)c) = %d\n", sizeof(c), sizeof((int)c));
1136
1137 /* test cast from unsigned to signed short to int */
1138 b = 0xf000;
1139 d = (short)b;
1140 printf("((unsigned)(short)0x%08x) = 0x%08x\n", b, d);
1141 b = 0xf0f0;
1142 d = (char)b;
1143 printf("((unsigned)(char)0x%08x) = 0x%08x\n", b, d);
1144
1145 /* test implicit int casting for array accesses */
1146 c = 0;
1147 tab[1] = 2;
1148 tab[c] = 1;
1149 printf("%d %d\n", tab[0], tab[1]);
1150
1151 /* test implicit casting on some operators */
1152 printf("sizeof(+(char)'a') = %d\n", sizeof(+(char)'a'));
1153 printf("sizeof(-(char)'a') = %d\n", sizeof(-(char)'a'));
1154 printf("sizeof(~(char)'a') = %d\n", sizeof(-(char)'a'));
1155
1156 /* from pointer to integer types */
1157 printf("%d %d %ld %ld %lld %lld\n",
1158 (int)p, (unsigned int)p,
1159 (long)p, (unsigned long)p,
1160 (long long)p, (unsigned long long)p);
1161
1162 /* from integers to pointers */
1163 printf("%p %p %p %p\n",
1164 (void *)a, (void *)b, (void *)c, (void *)d);
1165}
1166
1167/* initializers tests */
1168struct structinit1 {
1169 int f1;
1170 char f2;
1171 short f3;
1172 int farray[3];
1173};
1174
1175int sinit1 = 2;
1176int sinit2 = { 3 };
1177int sinit3[3] = { 1, 2, {{3}}, };
1178int sinit4[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1179int sinit5[3][2] = { 1, 2, 3, 4, 5, 6 };
1180int sinit6[] = { 1, 2, 3 };
1181int sinit7[] = { [2] = 3, [0] = 1, 2 };
1182char sinit8[] = "hello" "trala";
1183
1184struct structinit1 sinit9 = { 1, 2, 3 };
1185struct structinit1 sinit10 = { .f2 = 2, 3, .f1 = 1 };
1186struct structinit1 sinit11 = { .f2 = 2, 3, .f1 = 1,
1187#ifdef ALL_ISOC99
1188 .farray[0] = 10,
1189 .farray[1] = 11,
1190 .farray[2] = 12,
1191#endif
1192};
1193
1194char *sinit12 = "hello world";
1195char *sinit13[] = {
1196 "test1",
1197 "test2",
1198 "test3",
1199};
1200char sinit14[10] = { "abc" };
1201int sinit15[3] = { sizeof(sinit15), 1, 2 };
1202
1203struct { int a[3], b; } sinit16[] = { { 1 }, 2 };
1204
1205struct bar {
1206 char *s;
1207 int len;
1208} sinit17[] = {
1209 "a1", 4,
1210 "a2", 1
1211};
1212
1213int sinit18[10] = {
1214 [2 ... 5] = 20,
1215 2,
1216 [8] = 10,
1217};
1218
1219void init_test(void)
1220{
1221 int linit1 = 2;
1222 int linit2 = { 3 };
1223 int linit4[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1224 int linit6[] = { 1, 2, 3 };
1225 int i, j;
1226 char linit8[] = "hello" "trala";
1227 int linit12[10] = { 1, 2 };
1228 int linit13[10] = { 1, 2, [7] = 3, [3] = 4, };
1229 char linit14[10] = "abc";
1230 int linit15[10] = { linit1, linit1 + 1, [6] = linit1 + 2, };
1231 struct linit16 { int a1, a2, a3, a4; } linit16 = { 1, .a3 = 2 };
1232 int linit17 = sizeof(linit17);
1233
1234 printf("init_test:\n");
1235
1236 printf("sinit1=%d\n", sinit1);
1237 printf("sinit2=%d\n", sinit2);
1238 printf("sinit3=%d %d %d %d\n",
1239 sizeof(sinit3),
1240 sinit3[0],
1241 sinit3[1],
1242 sinit3[2]
1243 );
1244 printf("sinit6=%d\n", sizeof(sinit6));
1245 printf("sinit7=%d %d %d %d\n",
1246 sizeof(sinit7),
1247 sinit7[0],
1248 sinit7[1],
1249 sinit7[2]
1250 );
1251 printf("sinit8=%s\n", sinit8);
1252 printf("sinit9=%d %d %d\n",
1253 sinit9.f1,
1254 sinit9.f2,
1255 sinit9.f3
1256 );
1257 printf("sinit10=%d %d %d\n",
1258 sinit10.f1,
1259 sinit10.f2,
1260 sinit10.f3
1261 );
1262 printf("sinit11=%d %d %d %d %d %d\n",
1263 sinit11.f1,
1264 sinit11.f2,
1265 sinit11.f3,
1266 sinit11.farray[0],
1267 sinit11.farray[1],
1268 sinit11.farray[2]
1269 );
1270
1271 for(i=0;i<3;i++)
1272 for(j=0;j<2;j++)
1273 printf("[%d][%d] = %d %d %d\n",
1274 i, j, sinit4[i][j], sinit5[i][j], linit4[i][j]);
1275 printf("linit1=%d\n", linit1);
1276 printf("linit2=%d\n", linit2);
1277 printf("linit6=%d\n", sizeof(linit6));
1278 printf("linit8=%d %s\n", sizeof(linit8), linit8);
1279
1280 printf("sinit12=%s\n", sinit12);
1281 printf("sinit13=%d %s %s %s\n",
1282 sizeof(sinit13),
1283 sinit13[0],
1284 sinit13[1],
1285 sinit13[2]);
1286 printf("sinit14=%s\n", sinit14);
1287
1288 for(i=0;i<10;i++) printf(" %d", linit12[i]);
1289 printf("\n");
1290 for(i=0;i<10;i++) printf(" %d", linit13[i]);
1291 printf("\n");
1292 for(i=0;i<10;i++) printf(" %d", linit14[i]);
1293 printf("\n");
1294 for(i=0;i<10;i++) printf(" %d", linit15[i]);
1295 printf("\n");
1296 printf("%d %d %d %d\n",
1297 linit16.a1,
1298 linit16.a2,
1299 linit16.a3,
1300 linit16.a4);
1301 /* test that initialisation is done after variable declare */
1302 printf("linit17=%d\n", linit17);
1303 printf("sinit15=%d\n", sinit15[0]);
1304 printf("sinit16=%d %d\n", sinit16[0].a[0], sinit16[1].a[0]);
1305 printf("sinit17=%s %d %s %d\n",
1306 sinit17[0].s, sinit17[0].len,
1307 sinit17[1].s, sinit17[1].len);
1308 for(i=0;i<10;i++)
1309 printf("%x ", sinit18[i]);
1310 printf("\n");
1311}
1312
1313
1314void switch_test()
1315{
1316 int i;
1317
1318 for(i=0;i<15;i++) {
1319 switch(i) {
1320 case 0:
1321 case 1:
1322 printf("a");
1323 break;
1324 default:
1325 printf("%d", i);
1326 break;
1327 case 8 ... 12:
1328 printf("c");
1329 break;
1330 case 3:
1331 printf("b");
1332 break;
1333 }
1334 }
1335 printf("\n");
1336}
1337
1338/* ISOC99 _Bool type */
1339void c99_bool_test(void)
1340{
1341#ifdef BOOL_ISOC99
1342 int a;
1343 _Bool b;
1344
1345 printf("bool_test:\n");
1346 printf("sizeof(_Bool) = %d\n", sizeof(_Bool));
1347 a = 3;
1348 printf("cast: %d %d %d\n", (_Bool)10, (_Bool)0, (_Bool)a);
1349 b = 3;
1350 printf("b = %d\n", b);
1351 b++;
1352 printf("b = %d\n", b);
1353#endif
1354}
1355
1356void bitfield_test(void)
1357{
1358 int a;
1359 struct sbf1 {
1360 int f1 : 3;
1361 int : 2;
1362 int f2 : 1;
1363 int : 0;
1364 int f3 : 5;
1365 int f4 : 7;
1366 unsigned int f5 : 7;
1367 } st1;
1368 printf("bitfield_test:");
1369 printf("sizeof(st1) = %d\n", sizeof(st1));
1370
1371 st1.f1 = 3;
1372 st1.f2 = 1;
1373 st1.f3 = 15;
1374 a = 120;
1375 st1.f4 = a;
1376 st1.f5 = a;
1377 st1.f5++;
1378 printf("%d %d %d %d %d\n",
1379 st1.f1, st1.f2, st1.f3, st1.f4, st1.f5);
1380
1381 st1.f1 = 7;
1382 if (st1.f1 == -1)
1383 printf("st1.f1 == -1\n");
1384 else
1385 printf("st1.f1 != -1\n");
1386 if (st1.f2 == -1)
1387 printf("st1.f2 == -1\n");
1388 else
1389 printf("st1.f2 != -1\n");
1390
1391 /* bit sizes below must be bigger than 32 since GCC doesn't allow
1392 long-long bitfields whose size is not bigger than int */
1393 struct sbf2 {
1394 long long f1 : 45;
1395 long long : 2;
1396 long long f2 : 35;
1397 unsigned long long f3 : 38;
1398 } st2;
1399 st2.f1 = 0x123456789ULL;
1400 a = 120;
1401 st2.f2 = (long long)a << 25;
1402 st2.f3 = a;
1403 st2.f2++;
1404 printf("%lld %lld %lld\n", st2.f1, st2.f2, st2.f3);
1405}
1406
1407#ifdef __x86_64__
1408#define FLOAT_FMT "%f\n"
1409#else
1410/* x86's float isn't compatible with GCC */
1411#define FLOAT_FMT "%.5f\n"
1412#endif
1413
1414/* declare strto* functions as they are C99 */
1415double strtod(const char *nptr, char **endptr);
1416float strtof(const char *nptr, char **endptr);
1417long double strtold(const char *nptr, char **endptr);
1418
1419#define FTEST(prefix, type, fmt)\
1420void prefix ## cmp(type a, type b)\
1421{\
1422 printf("%d %d %d %d %d %d\n",\
1423 a == b,\
1424 a != b,\
1425 a < b,\
1426 a > b,\
1427 a >= b,\
1428 a <= b);\
1429 printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\
1430 a,\
1431 b,\
1432 a + b,\
1433 a - b,\
1434 a * b,\
1435 a / b,\
1436 -a);\
1437 printf(fmt "\n", ++a);\
1438 printf(fmt "\n", a++);\
1439 printf(fmt "\n", a);\
1440 b = 0;\
1441 printf("%d %d\n", !a, !b);\
1442}\
1443void prefix ## fcast(type a)\
1444{\
1445 float fa;\
1446 double da;\
1447 long double la;\
1448 int ia;\
1449 unsigned int ua;\
1450 type b;\
1451 fa = a;\
1452 da = a;\
1453 la = a;\
1454 printf("ftof: %f %f %Lf\n", fa, da, la);\
1455 ia = (int)a;\
1456 ua = (unsigned int)a;\
1457 printf("ftoi: %d %u\n", ia, ua);\
1458 ia = -1234;\
1459 ua = 0x81234500;\
1460 b = ia;\
1461 printf("itof: " fmt "\n", b);\
1462 b = ua;\
1463 printf("utof: " fmt "\n", b);\
1464}\
1465\
1466float prefix ## retf(type a) { return a; }\
1467double prefix ## retd(type a) { return a; }\
1468long double prefix ## retld(type a) { return a; }\
1469\
1470void prefix ## call(void)\
1471{\
1472 printf("float: " FLOAT_FMT, prefix ## retf(42.123456789));\
1473 printf("double: %f\n", prefix ## retd(42.123456789));\
1474 printf("long double: %Lf\n", prefix ## retld(42.123456789));\
1475 printf("strto%s: %f\n", #prefix, (double)strto ## prefix("1.2", NULL));\
1476}\
1477\
1478void prefix ## test(void)\
1479{\
1480 printf("testing '%s'\n", #type);\
1481 prefix ## cmp(1, 2.5);\
1482 prefix ## cmp(2, 1.5);\
1483 prefix ## cmp(1, 1);\
1484 prefix ## fcast(234.6);\
1485 prefix ## fcast(-2334.6);\
1486 prefix ## call();\
1487}
1488
1489FTEST(f, float, "%f")
1490FTEST(d, double, "%f")
1491FTEST(ld, long double, "%Lf")
1492
1493double ftab1[3] = { 1.2, 3.4, -5.6 };
1494
1495
1496void float_test(void)
1497{
1498 float fa, fb;
1499 double da, db;
1500 int a;
1501 unsigned int b;
1502
1503 printf("float_test:\n");
1504 printf("sizeof(float) = %d\n", sizeof(float));
1505 printf("sizeof(double) = %d\n", sizeof(double));
1506 printf("sizeof(long double) = %d\n", sizeof(long double));
1507 ftest();
1508 dtest();
1509 ldtest();
1510 printf("%f %f %f\n", ftab1[0], ftab1[1], ftab1[2]);
1511 printf("%f %f %f\n", 2.12, .5, 2.3e10);
1512 // printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
1513 da = 123;
1514 printf("da=%f\n", da);
1515 fa = 123;
1516 printf("fa=%f\n", fa);
1517 a = 4000000000;
1518 da = a;
1519 printf("da = %f\n", da);
1520 b = 4000000000;
1521 db = b;
1522 printf("db = %f\n", db);
1523}
1524
1525int fib(int n)
1526{
1527 if (n <= 2)
1528 return 1;
1529 else
1530 return fib(n-1) + fib(n-2);
1531}
1532
1533void funcptr_test()
1534{
1535 void (*func)(int);
1536 int a;
1537 struct {
1538 int dummy;
1539 void (*func)(int);
1540 } st1;
1541
1542 printf("funcptr:\n");
1543 func = &num;
1544 (*func)(12345);
1545 func = num;
1546 a = 1;
1547 a = 1;
1548 func(12345);
1549 /* more complicated pointer computation */
1550 st1.func = num;
1551 st1.func(12346);
1552 printf("sizeof1 = %d\n", sizeof(funcptr_test));
1553 printf("sizeof2 = %d\n", sizeof funcptr_test);
1554 printf("sizeof3 = %d\n", sizeof(&funcptr_test));
1555 printf("sizeof4 = %d\n", sizeof &funcptr_test);
1556}
1557
1558void lloptest(long long a, long long b)
1559{
1560 unsigned long long ua, ub;
1561
1562 ua = a;
1563 ub = b;
1564 /* arith */
1565 printf("arith: %Ld %Ld %Ld\n",
1566 a + b,
1567 a - b,
1568 a * b);
1569
1570 if (b != 0) {
1571 printf("arith1: %Ld %Ld\n",
1572 a / b,
1573 a % b);
1574 }
1575
1576 /* binary */
1577 printf("bin: %Ld %Ld %Ld\n",
1578 a & b,
1579 a | b,
1580 a ^ b);
1581
1582 /* tests */
1583 printf("test: %d %d %d %d %d %d\n",
1584 a == b,
1585 a != b,
1586 a < b,
1587 a > b,
1588 a >= b,
1589 a <= b);
1590
1591 printf("utest: %d %d %d %d %d %d\n",
1592 ua == ub,
1593 ua != ub,
1594 ua < ub,
1595 ua > ub,
1596 ua >= ub,
1597 ua <= ub);
1598
1599 /* arith2 */
1600 a++;
1601 b++;
1602 printf("arith2: %Ld %Ld\n", a, b);
1603 printf("arith2: %Ld %Ld\n", a++, b++);
1604 printf("arith2: %Ld %Ld\n", --a, --b);
1605 printf("arith2: %Ld %Ld\n", a, b);
1606 b = ub = 0;
1607 printf("not: %d %d %d %d\n", !a, !ua, !b, !ub);
1608}
1609
1610void llshift(long long a, int b)
1611{
1612 printf("shift: %Ld %Ld %Ld\n",
1613 (unsigned long long)a >> b,
1614 a >> b,
1615 a << b);
1616 printf("shiftc: %Ld %Ld %Ld\n",
1617 (unsigned long long)a >> 3,
1618 a >> 3,
1619 a << 3);
1620 printf("shiftc: %Ld %Ld %Ld\n",
1621 (unsigned long long)a >> 35,
1622 a >> 35,
1623 a << 35);
1624}
1625
1626void llfloat(void)
1627{
1628 float fa;
1629 double da;
1630 long double lda;
1631 long long la, lb, lc;
1632 unsigned long long ula, ulb, ulc;
1633 la = 0x12345678;
1634 ula = 0x72345678;
1635 la = (la << 20) | 0x12345;
1636 ula = ula << 33;
1637 printf("la=%Ld ula=%Lu\n", la, ula);
1638
1639 fa = la;
1640 da = la;
1641 lda = la;
1642 printf("lltof: %f %f %Lf\n", fa, da, lda);
1643
1644 la = fa;
1645 lb = da;
1646 lc = lda;
1647 printf("ftoll: %Ld %Ld %Ld\n", la, lb, lc);
1648
1649 fa = ula;
1650 da = ula;
1651 lda = ula;
1652 printf("ulltof: %f %f %Lf\n", fa, da, lda);
1653
1654 ula = fa;
1655 ulb = da;
1656 ulc = lda;
1657 printf("ftoull: %Lu %Lu %Lu\n", ula, ulb, ulc);
1658}
1659
1660long long llfunc1(int a)
1661{
1662 return a * 2;
1663}
1664
1665struct S {
1666 int id;
1667 char item;
1668};
1669
1670long long int value(struct S *v)
1671{
1672 return ((long long int)v->item);
1673}
1674
1675void longlong_test(void)
1676{
1677 long long a, b, c;
1678 int ia;
1679 unsigned int ua;
1680 printf("longlong_test:\n");
1681 printf("sizeof(long long) = %d\n", sizeof(long long));
1682 ia = -1;
1683 ua = -2;
1684 a = ia;
1685 b = ua;
1686 printf("%Ld %Ld\n", a, b);
1687 printf("%Ld %Ld %Ld %Lx\n",
1688 (long long)1,
1689 (long long)-2,
1690 1LL,
1691 0x1234567812345679);
1692 a = llfunc1(-3);
1693 printf("%Ld\n", a);
1694
1695 lloptest(1000, 23);
1696 lloptest(0xff, 0x1234);
1697 b = 0x72345678 << 10;
1698 lloptest(-3, b);
1699 llshift(0x123, 5);
1700 llshift(-23, 5);
1701 b = 0x72345678LL << 10;
1702 llshift(b, 47);
1703
1704 llfloat();
1705#if 1
1706 b = 0x12345678;
1707 a = -1;
1708 c = a + b;
1709 printf("%Lx\n", c);
1710#endif
1711
1712 /* long long reg spill test */
1713 {
1714 struct S a;
1715
1716 a.item = 3;
1717 printf("%lld\n", value(&a));
1718 }
1719 lloptest(0x80000000, 0);
1720
1721 /* another long long spill test */
1722 {
1723 long long *p, v;
1724 v = 1;
1725 p = &v;
1726 p[0]++;
1727 printf("%lld\n", *p);
1728 }
1729
1730 a = 68719476720LL;
1731 b = 4294967295LL;
1732 printf("%d %d %d %d\n", a > b, a < b, a >= b, a <= b);
1733
1734 printf("%Ld\n", 0x123456789LLU);
1735}
1736
1737void manyarg_test(void)
1738{
1739 long double ld = 1234567891234LL;
1740 printf("manyarg_test:\n");
1741 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
1742 1, 2, 3, 4, 5, 6, 7, 8,
1743 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
1744 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
1745 "%Ld %Ld %f %f\n",
1746 1, 2, 3, 4, 5, 6, 7, 8,
1747 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
1748 1234567891234LL, 987654321986LL,
1749 42.0, 43.0);
1750 printf("%Lf %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
1751 "%Ld %Ld %f %f\n",
1752 ld, 1, 2, 3, 4, 5, 6, 7, 8,
1753 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
1754 1234567891234LL, 987654321986LL,
1755 42.0, 43.0);
1756 /* XXX: known bug of x86-64 */
1757#ifndef __x86_64__
1758 printf("%d %d %d %d %d %d %d %d %Lf\n",
1759 1, 2, 3, 4, 5, 6, 7, 8, ld);
1760 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
1761 "%Ld %Ld %f %f %Lf\n",
1762 1, 2, 3, 4, 5, 6, 7, 8,
1763 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
1764 1234567891234LL, 987654321986LL,
1765 42.0, 43.0, ld);
1766 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
1767 "%Lf %Ld %Ld %f %f %Lf\n",
1768 1, 2, 3, 4, 5, 6, 7, 8,
1769 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
1770 ld, 1234567891234LL, 987654321986LL,
1771 42.0, 43.0, ld);
1772#endif
1773}
1774
1775void vprintf1(const char *fmt, ...)
1776{
1777 va_list ap;
1778 const char *p;
1779 int c, i;
1780 double d;
1781 long long ll;
1782 long double ld;
1783
1784 va_start(ap, fmt);
1785
1786 p = fmt;
1787 for(;;) {
1788 c = *p;
1789 if (c == '\0')
1790 break;
1791 p++;
1792 if (c == '%') {
1793 c = *p;
1794 switch(c) {
1795 case '\0':
1796 goto the_end;
1797 case 'd':
1798 i = va_arg(ap, int);
1799 printf("%d", i);
1800 break;
1801 case 'f':
1802 d = va_arg(ap, double);
1803 printf("%f", d);
1804 break;
1805 case 'l':
1806 ll = va_arg(ap, long long);
1807 printf("%Ld", ll);
1808 break;
1809 case 'F':
1810 ld = va_arg(ap, long double);
1811 printf("%Lf", ld);
1812 break;
1813 }
1814 p++;
1815 } else {
1816 putchar(c);
1817 }
1818 }
1819 the_end:
1820 va_end(ap);
1821}
1822
1823
1824void stdarg_test(void)
1825{
1826 long double ld = 1234567891234LL;
1827 vprintf1("%d %d %d\n", 1, 2, 3);
1828 vprintf1("%f %d %f\n", 1.0, 2, 3.0);
1829 vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0);
1830 vprintf1("%F %F %F\n", 1.2L, 2.3L, 3.4L);
1831#ifdef __x86_64__
1832 /* a bug of x86's TCC */
1833 vprintf1("%d %f %l %F %d %f %l %F\n",
1834 1, 1.2, 3L, 4.5L, 6, 7.8, 9L, 0.1L);
1835#endif
1836 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f\n",
1837 1, 2, 3, 4, 5, 6, 7, 8,
1838 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8);
1839 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
1840 1, 2, 3, 4, 5, 6, 7, 8,
1841 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
1842 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
1843 "%l %l %f %f\n",
1844 1, 2, 3, 4, 5, 6, 7, 8,
1845 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
1846 1234567891234LL, 987654321986LL,
1847 42.0, 43.0);
1848 vprintf1("%F %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
1849 "%l %l %f %f\n",
1850 ld, 1, 2, 3, 4, 5, 6, 7, 8,
1851 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
1852 1234567891234LL, 987654321986LL,
1853 42.0, 43.0);
1854 vprintf1("%d %d %d %d %d %d %d %d %F\n",
1855 1, 2, 3, 4, 5, 6, 7, 8, ld);
1856 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
1857 "%l %l %f %f %F\n",
1858 1, 2, 3, 4, 5, 6, 7, 8,
1859 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
1860 1234567891234LL, 987654321986LL,
1861 42.0, 43.0, ld);
1862 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
1863 "%F %l %l %f %f %F\n",
1864 1, 2, 3, 4, 5, 6, 7, 8,
1865 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
1866 ld, 1234567891234LL, 987654321986LL,
1867 42.0, 43.0, ld);
1868}
1869
1870void whitespace_test(void)
1871{
1872 char *str;
1873
1874 #if 1
1875 pri\
1876ntf("whitspace:\n");
1877#endif
1878 pf("N=%d\n", 2);
1879
1880#ifdef CORRECT_CR_HANDLING
1881 pri\
1882ntf("aaa=%d\n", 3);
1883#endif
1884
1885 pri\
1886\
1887ntf("min=%d\n", 4);
1888
1889#ifdef ACCEPT_CR_IN_STRINGS
1890 printf("len1=%d\n", strlen("
1891"));
1892#ifdef CORRECT_CR_HANDLING
1893 str = "
1894";
1895 printf("len1=%d str[0]=%d\n", strlen(str), str[0]);
1896#endif
1897 printf("len1=%d\n", strlen(" a
1898"));
1899#endif /* ACCEPT_CR_IN_STRINGS */
1900}
1901
1902int reltab[3] = { 1, 2, 3 };
1903
1904int *rel1 = &reltab[1];
1905int *rel2 = &reltab[2];
1906
1907void relocation_test(void)
1908{
1909 printf("*rel1=%d\n", *rel1);
1910 printf("*rel2=%d\n", *rel2);
1911}
1912
1913void old_style_f(a,b,c)
1914 int a, b;
1915 double c;
1916{
1917 printf("a=%d b=%d b=%f\n", a, b, c);
1918}
1919
1920void decl_func1(int cmpfn())
1921{
1922 printf("cmpfn=%lx\n", (long)cmpfn);
1923}
1924
1925void decl_func2(cmpfn)
1926int cmpfn();
1927{
1928 printf("cmpfn=%lx\n", (long)cmpfn);
1929}
1930
1931void old_style_function(void)
1932{
1933 old_style_f((void *)1, 2, 3.0);
1934 decl_func1(NULL);
1935 decl_func2(NULL);
1936}
1937
1938void sizeof_test(void)
1939{
1940 int a;
1941 int **ptr;
1942
1943 printf("sizeof(int) = %d\n", sizeof(int));
1944 printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
1945 printf("sizeof(long) = %d\n", sizeof(long));
1946 printf("sizeof(unsigned long) = %d\n", sizeof(unsigned long));
1947 printf("sizeof(short) = %d\n", sizeof(short));
1948 printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
1949 printf("sizeof(char) = %d\n", sizeof(char));
1950 printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
1951 printf("sizeof(func) = %d\n", sizeof sizeof_test());
1952 a = 1;
1953 printf("sizeof(a++) = %d\n", sizeof a++);
1954 printf("a=%d\n", a);
1955 ptr = NULL;
1956 printf("sizeof(**ptr) = %d\n", sizeof (**ptr));
1957
1958 /* some alignof tests */
1959 printf("__alignof__(int) = %d\n", __alignof__(int));
1960 printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int));
1961 printf("__alignof__(short) = %d\n", __alignof__(short));
1962 printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short));
1963 printf("__alignof__(char) = %d\n", __alignof__(char));
1964 printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char));
1965 printf("__alignof__(func) = %d\n", __alignof__ sizeof_test());
1966}
1967
1968void typeof_test(void)
1969{
1970 double a;
1971 typeof(a) b;
1972 typeof(float) c;
1973
1974 a = 1.5;
1975 b = 2.5;
1976 c = 3.5;
1977 printf("a=%f b=%f c=%f\n", a, b, c);
1978}
1979
1980void statement_expr_test(void)
1981{
1982 int a, i;
1983
1984 a = 0;
1985 for(i=0;i<10;i++) {
1986 a += 1 +
1987 ( { int b, j;
1988 b = 0;
1989 for(j=0;j<5;j++)
1990 b += j; b;
1991 } );
1992 }
1993 printf("a=%d\n", a);
1994
1995}
1996
1997void local_label_test(void)
1998{
1999 int a;
2000 goto l1;
2001 l2:
2002 a = 1 + ({
2003 __label__ l1, l2, l3, l4;
2004 goto l1;
2005 l4:
2006 printf("aa1\n");
2007 goto l3;
2008 l2:
2009 printf("aa3\n");
2010 goto l4;
2011 l1:
2012 printf("aa2\n");
2013 goto l2;
2014 l3:;
2015 1;
2016 });
2017 printf("a=%d\n", a);
2018 return;
2019 l4:
2020 printf("bb1\n");
2021 goto l2;
2022 l1:
2023 printf("bb2\n");
2024 goto l4;
2025}
2026
2027/* inline assembler test */
2028#ifdef __i386__
2029
2030/* from linux kernel */
2031static char * strncat1(char * dest,const char * src,size_t count)
2032{
2033int d0, d1, d2, d3;
2034__asm__ __volatile__(
2035 "repne\n\t"
2036 "scasb\n\t"
2037 "decl %1\n\t"
2038 "movl %8,%3\n"
2039 "1:\tdecl %3\n\t"
2040 "js 2f\n\t"
2041 "lodsb\n\t"
2042 "stosb\n\t"
2043 "testb %%al,%%al\n\t"
2044 "jne 1b\n"
2045 "2:\txorl %2,%2\n\t"
2046 "stosb"
2047 : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
2048 : "0" (src),"1" (dest),"2" (0),"3" (0xffffffff), "g" (count)
2049 : "memory");
2050return dest;
2051}
2052
2053static inline void * memcpy1(void * to, const void * from, size_t n)
2054{
2055int d0, d1, d2;
2056__asm__ __volatile__(
2057 "rep ; movsl\n\t"
2058 "testb $2,%b4\n\t"
2059 "je 1f\n\t"
2060 "movsw\n"
2061 "1:\ttestb $1,%b4\n\t"
2062 "je 2f\n\t"
2063 "movsb\n"
2064 "2:"
2065 : "=&c" (d0), "=&D" (d1), "=&S" (d2)
2066 :"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from)
2067 : "memory");
2068return (to);
2069}
2070
2071static __inline__ void sigaddset1(unsigned int *set, int _sig)
2072{
2073 __asm__("btsl %1,%0" : "=m"(*set) : "Ir"(_sig - 1) : "cc");
2074}
2075
2076static __inline__ void sigdelset1(unsigned int *set, int _sig)
2077{
2078 asm("btrl %1,%0" : "=m"(*set) : "Ir"(_sig - 1) : "cc");
2079}
2080
2081static __inline__ __const__ unsigned int swab32(unsigned int x)
2082{
2083 __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */
2084 "rorl $16,%0\n\t" /* swap words */
2085 "xchgb %b0,%h0" /* swap higher bytes */
2086 :"=q" (x)
2087 : "0" (x));
2088 return x;
2089}
2090
2091static __inline__ unsigned long long mul64(unsigned int a, unsigned int b)
2092{
2093 unsigned long long res;
2094 __asm__("mull %2" : "=A" (res) : "a" (a), "r" (b));
2095 return res;
2096}
2097
2098static __inline__ unsigned long long inc64(unsigned long long a)
2099{
2100 unsigned long long res;
2101 __asm__("addl $1, %%eax ; adcl $0, %%edx" : "=A" (res) : "A" (a));
2102 return res;
2103}
2104
2105unsigned int set;
2106
2107void asm_test(void)
2108{
2109 char buf[128];
2110 unsigned int val;
2111
2112 printf("inline asm:\n");
2113 /* test the no operand case */
2114 asm volatile ("xorl %eax, %eax");
2115
2116 memcpy1(buf, "hello", 6);
2117 strncat1(buf, " worldXXXXX", 3);
2118 printf("%s\n", buf);
2119
2120 /* 'A' constraint test */
2121 printf("mul64=0x%Lx\n", mul64(0x12345678, 0xabcd1234));
2122 printf("inc64=0x%Lx\n", inc64(0x12345678ffffffff));
2123
2124 set = 0xff;
2125 sigdelset1(&set, 2);
2126 sigaddset1(&set, 16);
2127 /* NOTE: we test here if C labels are correctly restored after the
2128 asm statement */
2129 goto label1;
2130 label2:
2131 __asm__("btsl %1,%0" : "=m"(set) : "Ir"(20) : "cc");
2132#ifdef __GNUC__ // works strange with GCC 4.3
2133 set=0x1080fd;
2134#endif
2135 printf("set=0x%x\n", set);
2136 val = 0x01020304;
2137 printf("swab32(0x%08x) = 0x%0x\n", val, swab32(val));
2138 return;
2139 label1:
2140 goto label2;
2141}
2142
2143#else
2144
2145void asm_test(void)
2146{
2147}
2148
2149#endif
2150
2151#define COMPAT_TYPE(type1, type2) \
2152{\
2153 printf("__builtin_types_compatible_p(%s, %s) = %d\n", #type1, #type2, \
2154 __builtin_types_compatible_p (type1, type2));\
2155}
2156
2157int constant_p_var;
2158
2159void builtin_test(void)
2160{
2161#if GCC_MAJOR >= 3
2162 COMPAT_TYPE(int, int);
2163 COMPAT_TYPE(int, unsigned int);
2164 COMPAT_TYPE(int, char);
2165 COMPAT_TYPE(int, const int);
2166 COMPAT_TYPE(int, volatile int);
2167 COMPAT_TYPE(int *, int *);
2168 COMPAT_TYPE(int *, void *);
2169 COMPAT_TYPE(int *, const int *);
2170 COMPAT_TYPE(char *, unsigned char *);
2171/* space is needed because tcc preprocessor introduces a space between each token */
2172 COMPAT_TYPE(char * *, void *);
2173#endif
2174 printf("res = %d\n", __builtin_constant_p(1));
2175 printf("res = %d\n", __builtin_constant_p(1 + 2));
2176 printf("res = %d\n", __builtin_constant_p(&constant_p_var));
2177 printf("res = %d\n", __builtin_constant_p(constant_p_var));
2178}
2179
2180
2181void const_func(const int a)
2182{
2183}
2184
2185void const_warn_test(void)
2186{
2187 const_func(1);
2188}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t