2 * TCC auto test program
8 /* Unfortunately, gcc version < 3 does not handle that! */
11 /* only gcc 3 handles _Bool correctly */
14 /* gcc 2.95.3 does not handle correctly CR in strings or after strays */
15 #define CORRECT_CR_HANDLING
20 #define LONG_LONG_FORMAT "%lld"
21 #define ULONG_LONG_FORMAT "%llu"
23 #define LONG_LONG_FORMAT "%Ld"
24 #define ULONG_LONG_FORMAT "%Lu"
27 // MinGW has 80-bit rather than 64-bit long double which isn't compatible with TCC or MSVC
28 #if defined(_WIN32) && defined(__GNUC__)
29 #define LONG_DOUBLE double
30 #define LONG_DOUBLE_LITERAL(x) x
32 #define LONG_DOUBLE long double
33 #define LONG_DOUBLE_LITERAL(x) x ## L
36 /* deprecated and no longer supported in gcc 3.3 */
37 //#define ACCEPT_CR_IN_STRINGS
39 /* __VA_ARGS__ and __func__ support */
42 /* test various include syntaxes */
44 #define TCCLIB_INC <tcclib.h>
45 #define TCCLIB_INC1 <tcclib
46 #define TCCLIB_INC2 h>
47 #define TCCLIB_INC3 "tcclib.h"
51 #include TCCLIB_INC1.TCCLIB_INC2
53 #include TCCLIB_INC1.h>
63 /* Test two more ways to include a file named like a pp-number */
64 #define INC(name) <tests/name.h>
65 #define funnyname 42test.h
67 #define incname < incdir funnyname >
68 #define __stringify(x) #x
69 #define stringify(x) __stringify(x)
72 #include stringify(funnyname)
78 void recursive_macro_test();
93 void constant_expr_test();
95 void char_short_test();
97 void compound_literal_test(void);
99 void struct_assign_test(void);
100 void cast_test(void);
101 void bitfield_test(void);
102 void c99_bool_test(void);
103 void float_test(void);
104 void longlong_test(void);
105 void manyarg_test(void);
106 void stdarg_test(void);
107 void whitespace_test(void);
108 void relocation_test(void);
109 void old_style_function(void);
110 void alloca_test(void);
111 void c99_vla_test(int size1
, int size2
);
112 void sizeof_test(void);
113 void typeof_test(void);
114 void local_label_test(void);
115 void statement_expr_test(void);
117 void builtin_test(void);
118 void weak_test(void);
119 void global_data_test(void);
120 void cmp_comparison_test(void);
121 void math_cmp_test(void);
122 void callsave_test(void);
123 void builtin_frame_address_test(void);
124 void attrib_test(void);
128 void forward_ref(void);
131 /* Line joining happens before tokenization, so the following
132 must be parsed as ellipsis. */
133 void funny_line_continuation (int, ..\
136 char via_volatile (char);
141 #define M1(a, b) (a) + (b)
145 #define glue(a, b) a ## b
146 #define xglue(a, b) glue(a, b)
147 #define HIGHLOW "hello"
148 #define LOW LOW ", world"
150 static int onetwothree
= 123;
151 #define onetwothree4 onetwothree
152 #define onetwothree xglue(onetwothree,4)
154 #define min(a, b) ((a) < (b) ? (a) : (b))
157 #define dprintf(level,...) printf(__VA_ARGS__)
160 /* gcc vararg macros */
161 #define dprintf1(level, fmt, args...) printf(fmt, ## args)
163 #define MACRO_NOARGS()
179 #define __INT64_C(c) c ## LL
180 #define INT64_MIN (-__INT64_C(9223372036854775807)-1)
188 #define spin_lock(lock) do { } while (0)
189 #define wq_spin_lock spin_lock
190 #define TEST2() wq_spin_lock(a)
192 #define UINT_MAX ((unsigned) -1)
194 void intdiv_test(void)
196 printf("18/21=%u\n", 18/21);
197 printf("18%%21=%u\n", 18%21);
198 printf("41/21=%u\n", 41/21);
199 printf("41%%21=%u\n", 41%21);
200 printf("42/21=%u\n", 42/21);
201 printf("42%%21=%u\n", 42%21);
202 printf("43/21=%u\n", 43/21);
203 printf("43%%21=%u\n", 43%21);
204 printf("126/21=%u\n", 126/21);
205 printf("126%%21=%u\n", 126%21);
206 printf("131/21=%u\n", 131/21);
207 printf("131%%21=%u\n", 131%21);
208 printf("(UINT_MAX/2+3)/2=%u\n", (UINT_MAX
/2+3)/2);
209 printf("(UINT_MAX/2+3)%%2=%u\n", (UINT_MAX
/2+3)%2);
211 printf("18/-21=%u\n", 18/-21);
212 printf("18%%-21=%u\n", 18%-21);
213 printf("41/-21=%u\n", 41/-21);
214 printf("41%%-21=%u\n", 41%-21);
215 printf("42/-21=%u\n", 42/-21);
216 printf("42%%-21=%u\n", 42%-21);
217 printf("43/-21=%u\n", 43/-21);
218 printf("43%%-21=%u\n", 43%-21);
219 printf("126/-21=%u\n", 126/-21);
220 printf("126%%-21=%u\n", 126%-21);
221 printf("131/-21=%u\n", 131/-21);
222 printf("131%%-21=%u\n", 131%-21);
223 printf("(UINT_MAX/2+3)/-2=%u\n", (UINT_MAX
/2+3)/-2);
224 printf("(UINT_MAX/2+3)%%-2=%u\n", (UINT_MAX
/2+3)%-2);
226 printf("-18/21=%u\n", -18/21);
227 printf("-18%%21=%u\n", -18%21);
228 printf("-41/21=%u\n", -41/21);
229 printf("-41%%21=%u\n", -41%21);
230 printf("-42/21=%u\n", -42/21);
231 printf("-42%%21=%u\n", -42%21);
232 printf("-43/21=%u\n", -43/21);
233 printf("-43%%21=%u\n", -43%21);
234 printf("-126/21=%u\n", -126/21);
235 printf("-126%%21=%u\n", -126%21);
236 printf("-131/21=%u\n", -131/21);
237 printf("-131%%21=%u\n", -131%21);
238 printf("-(UINT_MAX/2+3)/2=%u\n", (0-(UINT_MAX
/2+3))/2);
239 printf("-(UINT_MAX/2+3)%%2=%u\n", (0-(UINT_MAX
/2+3))%2);
241 printf("-18/-21=%u\n", -18/-21);
242 printf("-18%%-21=%u\n", -18%-21);
243 printf("-41/-21=%u\n", -41/-21);
244 printf("-41%%-21=%u\n", -41%-21);
245 printf("-42/-21=%u\n", -42/-21);
246 printf("-42%%-21=%u\n", -42%-21);
247 printf("-43/-21=%u\n", -43/-21);
248 printf("-43%%-21=%u\n", -43%-21);
249 printf("-126/-21=%u\n", -126/-21);
250 printf("-126%%-21=%u\n", -126%-21);
251 printf("-131/-21=%u\n", -131/-21);
252 printf("-131%%-21=%u\n", -131%-21);
253 printf("-(UINT_MAX/2+3)/-2=%u\n", (0-(UINT_MAX
/2+3))/-2);
254 printf("-(UINT_MAX/2+3)%%-2=%u\n", (0-(UINT_MAX
/2+3))%-2);
257 void macro_test(void)
259 printf("macro:\n");\f\v
261 printf("aaa=%d\n", AAA
);
263 printf("min=%d\n", min(1, min(2, -1)));
265 printf("s1=%s\n", glue(HIGH
, LOW
));
266 printf("s2=%s\n", xglue(HIGH
, LOW
));
267 printf("s3=%s\n", str("c"));
268 printf("s4=%s\n", str(a1
));
269 printf("B3=%d\n", B3
);
271 printf("onetwothree=%d\n", onetwothree
);
274 printf("A defined\n");
277 printf("B defined\n");
280 printf("A defined\n");
282 printf("A not defined\n");
285 printf("B defined\n");
287 printf("B not defined\n");
291 printf("A defined\n");
293 printf("B1 defined\n");
295 printf("B1 not defined\n");
298 printf("A not defined\n");
300 printf("B2 defined\n");
302 printf("B2 not defined\n");
307 printf("test true1\n");
310 printf("test true2\n");
313 printf("test true3\n");
316 printf("test trueA\n");
319 printf("test trueB\n");
335 printf("__LINE__ defined\n");
338 printf("__LINE__=%d __FILE__=%s\n",
342 printf("__LINE__=%d __FILE__=%s\n",
345 printf("__LINE__=%d __FILE__=%s\n",
347 #line 227 "tcctest.c"
350 /* not strictly preprocessor, but we test it there */
352 printf("__func__ = %s\n", __func__
);
353 dprintf(1, "vaarg=%d\n", 1);
355 dprintf1(1, "vaarg1\n");
356 dprintf1(1, "vaarg1=%d\n", 2);
357 dprintf1(1, "vaarg1=%d %d\n", 1, 2);
360 printf("func='%s'\n", __FUNCTION__
);
362 /* complicated macros in glibc */
363 printf("INT64_MIN=" LONG_LONG_FORMAT
"\n", INT64_MIN
);
373 /* macro function with argument outside the macro string */
374 #define MF_s MF_hello
375 #define MF_hello(msg) printf("%s\n",msg)
377 #define MF_t printf("tralala\n"); MF_hello
382 /* test macro substituion inside args (should not eat stream) */
383 printf("qq=%d\n", qq(qq
)(2));
385 /* test zero argument case. NOTE: gcc 2.95.x does not accept a
386 null argument without a space. gcc 3.2 fixes that. */
389 printf("qq1=%d\n", qq1( ));
391 /* comment with stray handling *\
393 /* this is a valid *\/ comment */
394 /* this is a valid comment *\*/
398 /* test function macro substitution when the function name is
402 /* And again when the name and parenthes are separated by a
404 TEST2
/* the comment */ ();
406 printf("%s\n", get_basefile_from_header());
407 printf("%s\n", __BASE_FILE__
);
408 printf("%s\n", get_file_from_header());
409 printf("%s\n", __FILE__
);
411 /* Check that funnily named include was in fact included */
412 have_included_42test_h
= 1;
413 have_included_42test_h_second
= 1;
414 have_included_42test_h_third
= 1;
418 static void print_num(char *fn
, int line
, int num
) {
419 printf("fn %s, line %d, num %d\n", fn
, line
, num
);
422 void recursive_macro_test(void)
425 #define ELF32_ST_TYPE(val) ((val) & 0xf)
426 #define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
427 #define STB_WEAK 2 /* Weak symbol */
428 #define ELFW(type) ELF##32##_##type
429 printf("%d\n", ELFW(ST_INFO
)(STB_WEAK
, ELFW(ST_TYPE
)(123)));
433 #define print_num(x) print_num(__FILE__,__LINE__,x)
435 WRAP(print_num(123));
436 WRAP(WRAP(print_num(123)));
438 static struct recursive_macro
{ int rm_field
; } G
;
439 #define rm_field (G.rm_field)
440 printf("rm_field = %d\n", rm_field
);
441 printf("rm_field = %d\n", WRAP(rm_field
));
442 WRAP((printf("rm_field = %d %d\n", rm_field
, WRAP(rm_field
))));
459 void ps(const char *s
)
471 const char foo1_string
[] = "\
480 printf("\141\1423\143\n");/* dezdez test */
481 printf("\x41\x42\x43\x3a\n");
482 printf("c=%c\n", 'r');
483 printf("wc=%C 0x%lx %C\n", L
'a', L
'\x1234', L
'c');
484 printf("foo1_string='%s'\n", foo1_string
);
486 printf("wstring=%S\n", L
"abc");
487 printf("wstring=%S\n", L
"abc" L
"def" "ghi");
488 printf("'\\377'=%d '\\xff'=%d\n", '\377', '\xff');
489 printf("L'\\377'=%d L'\\xff'=%d\n", L
'\377', L
'\xff');
493 while ((b
= b
+ 1) < 96) {
497 printf("fib=%d\n", fib(33));
499 while (b
!= 0x80000000) {
512 for(i
= 0; i
< 10;i
++)
522 /* c99 for loop init test */
523 for (size_t count
= 1; count
< 3; count
++)
524 printf("count=%d\n", count
);
525 printf("count = %d\n", count
);
527 /* break/continue tests */
539 /* break/continue tests */
551 for(i
= 0;i
< 10;i
++) {
559 typedef int typedef_and_label
;
564 static void *label_table
[3] = { &&label1
, &&label2
, &&label3
};
568 /* This needs to parse as label, not as start of decl. */
579 /* we also test computed gotos (GCC extension) */
581 goto *label_table
[i
];
607 enum {E6
= 42, E7
, E8
} e
:8;
611 /* This is either 0 on L32 machines, or a large number
612 on L64 machines. We should be able to store this. */
613 EL_large
= (unsigned long)0xf000 << 32,
616 enum { BIASU
= -1U<<31 };
617 enum { BIASS
= -1 << 31 };
619 static int getint(int i
)
624 return (int)(-1U << 31);
630 /* The following should give no warning */
632 struct S_enum s
= {E7
};
633 printf("enum: %d\n", s
.e
);
634 printf("enum:\n%d %d %d %d %d %d\n",
635 E0
, E1
, E2
, E3
, E4
, E5
);
637 printf("b1=%d\n", b1
);
638 printf("enum large: %ld\n", EL_large
);
640 if (getint(0) == BIASU
)
641 printf("enum unsigned: ok\n");
643 printf("enum unsigned: wrong\n");
644 if (getint(0) == BIASS
)
645 printf("enum unsigned: ok\n");
647 printf("enum unsigned: wrong\n");
663 printf("typedef:\n");
664 printf("a=%d\n", *a
);
666 printf("mytype2=%d\n", mytype2
);
671 printf("forward:\n");
677 void forward_ref(void)
679 printf("forward ok\n");
682 typedef struct struct1
{
702 struct struct1 st1
, st2
;
709 int main(int argc
, char **argv
)
714 recursive_macro_test();
729 constant_expr_test();
733 compound_literal_test();
735 struct_assign_test();
745 old_style_function();
750 statement_expr_test();
758 cmp_comparison_test();
761 builtin_frame_address_test();
763 if (via_volatile (42) != 42)
764 printf ("via_volatile broken\n");
776 printf("g1=%d\n", g
);
784 printf("g2=%d\n", g
);
788 printf("g3=%d\n", g
);
792 printf("g4=%d\n", g
);
795 printf("g5=%d\n", g
);
803 printf("sizeof(a) = %d\n", sizeof(a
));
804 printf("sizeof(\"a\") = %d\n", sizeof("a"));
806 printf("sizeof(__func__) = %d\n", sizeof(__func__
));
808 printf("sizeof tab %d\n", sizeof(tab
));
809 printf("sizeof tab2 %d\n", sizeof tab2
);
813 printf("%d %d %d\n", tab
[0], tab
[1], tab
[2]);
816 tab2
[i
][j
] = 10 * i
+ j
;
818 printf(" %3d", ((int *)tab2
)[i
]);
821 printf("sizeof(size_t)=%d\n", sizeof(size_t));
822 printf("sizeof(ptrdiff_t)=%d\n", sizeof(ptrdiff_t));
829 printf("%d\n", a
+= 1);
830 printf("%d\n", a
-= 2);
831 printf("%d\n", a
*= 31232132);
832 printf("%d\n", a
/= 4);
833 printf("%d\n", a
%= 20);
834 printf("%d\n", a
&= 6);
835 printf("%d\n", a
^= 7);
836 printf("%d\n", a
|= 8);
837 printf("%d\n", a
>>= 3);
838 printf("%d\n", a
<<= 4);
842 printf("%d\n", a
+ 1);
843 printf("%d\n", a
- 2);
844 printf("%d\n", a
* 312);
845 printf("%d\n", a
/ 4);
846 printf("%d\n", b
/ 4);
847 printf("%d\n", (unsigned)b
/ 4);
848 printf("%d\n", a
% 20);
849 printf("%d\n", b
% 20);
850 printf("%d\n", (unsigned)b
% 20);
851 printf("%d\n", a
& 6);
852 printf("%d\n", a
^ 7);
853 printf("%d\n", a
| 8);
854 printf("%d\n", a
>> 3);
855 printf("%d\n", b
>> 3);
856 printf("%d\n", (unsigned)b
>> 3);
857 printf("%d\n", a
<< 4);
862 printf("%d\n", 12 + 1);
863 printf("%d\n", 12 - 2);
864 printf("%d\n", 12 * 312);
865 printf("%d\n", 12 / 4);
866 printf("%d\n", 12 % 20);
867 printf("%d\n", 12 & 6);
868 printf("%d\n", 12 ^ 7);
869 printf("%d\n", 12 | 8);
870 printf("%d\n", 12 >> 2);
871 printf("%d\n", 12 << 4);
875 printf("%d %d %d %d\n",
884 return (c
>= 'a' & c
<= 'z') | (c
>= 'A' & c
<= 'Z') | c
== '_';
887 /**********************/
889 int vstack
[10], *vstack_ptr
;
891 void vpush(int vt
, int vc
)
897 void vpop(int *ft
, int *fc
)
910 vstack_ptr
[-2] &= ~0xffffff80;
912 printf("res= %d %d\n", a
, b
);
915 void constant_expr_test()
918 printf("constant_expr:\n");
920 printf("%d\n", a
* 16);
921 printf("%d\n", a
* 1);
922 printf("%d\n", a
+ 0);
932 printf("expr_ptr:\n");
935 printf("diff=%d\n", q
- p
);
937 printf("inc=%d\n", p
- tab4
);
939 printf("dec=%d\n", p
- tab4
);
941 printf("inc=%d\n", p
- tab4
);
943 printf("dec=%d\n", p
- tab4
);
944 printf("add=%d\n", p
+ 3 - tab4
);
945 printf("add=%d\n", 3 + p
- tab4
);
947 /* check if 64bit support is ok */
950 printf("%p %p %ld\n", q
, p
, p
-q
);
951 printf("%d %d %d %d %d %d\n",
952 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
955 printf("%p %p %ld\n", q
, p
, p
-q
);
956 printf("%d %d %d %d %d %d\n",
957 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
958 p
= (int *)((char *)p
+ 0xf0000000);
959 printf("%p %p %ld\n", q
, p
, p
-q
);
960 printf("%d %d %d %d %d %d\n",
961 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
963 printf("%p %p %ld\n", q
, p
, p
-q
);
964 printf("%d %d %d %d %d %d\n",
965 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
970 struct size12 s
[2], *sp
= s
;
975 printf("%d\n", sp
[j
].i
);
979 p
= (int*)0x100000000UL
+ i
;
981 printf("largeptr: %p %d\n", p
, i
);
988 printf("constant_expr:\n");
991 printf("%d\n", a
== a
);
992 printf("%d\n", a
!= a
);
994 printf("%d\n", a
< b
);
995 printf("%d\n", a
<= b
);
996 printf("%d\n", a
<= a
);
997 printf("%d\n", b
>= a
);
998 printf("%d\n", a
>= a
);
999 printf("%d\n", b
> a
);
1001 printf("%d\n", (unsigned)a
< b
);
1002 printf("%d\n", (unsigned)a
<= b
);
1003 printf("%d\n", (unsigned)a
<= a
);
1004 printf("%d\n", (unsigned)b
>= a
);
1005 printf("%d\n", (unsigned)a
>= a
);
1006 printf("%d\n", (unsigned)b
> a
);
1034 printf("struct:\n");
1035 printf("sizes: %d %d %d %d\n",
1036 sizeof(struct struct1
),
1037 sizeof(struct struct2
),
1038 sizeof(union union1
),
1039 sizeof(union union2
));
1043 printf("st1: %d %d %d\n",
1044 st1
.f1
, st1
.f2
, st1
.f3
);
1047 printf("union1: %d\n", st1
.u
.v1
);
1050 printf("union2: %d\n", u
.w1
);
1055 printf("st2: %d %d %d\n",
1056 s
->f1
, s
->f2
, s
->f3
);
1057 printf("str_addr=%x\n", (int)st1
.str
- (int)&st1
.f1
);
1059 /* align / size tests */
1060 printf("aligntest1 sizeof=%d alignof=%d\n",
1061 sizeof(struct aligntest1
), __alignof__(struct aligntest1
));
1062 printf("aligntest2 sizeof=%d alignof=%d\n",
1063 sizeof(struct aligntest2
), __alignof__(struct aligntest2
));
1064 printf("aligntest3 sizeof=%d alignof=%d\n",
1065 sizeof(struct aligntest3
), __alignof__(struct aligntest3
));
1066 printf("aligntest4 sizeof=%d alignof=%d\n",
1067 sizeof(struct aligntest4
), __alignof__(struct aligntest4
));
1069 /* empty structures (GCC extension) */
1070 printf("sizeof(struct empty) = %d\n", sizeof(struct empty
));
1071 printf("alignof(struct empty) = %d\n", __alignof__(struct empty
));
1074 /* XXX: depend on endianness */
1075 void char_short_test()
1079 printf("char_short:\n");
1083 printf("s8=%d %d\n",
1084 *(char *)&var1
, *(char *)&var2
);
1085 printf("u8=%d %d\n",
1086 *(unsigned char *)&var1
, *(unsigned char *)&var2
);
1087 printf("s16=%d %d\n",
1088 *(short *)&var1
, *(short *)&var2
);
1089 printf("u16=%d %d\n",
1090 *(unsigned short *)&var1
, *(unsigned short *)&var2
);
1091 printf("s32=%d %d\n",
1092 *(int *)&var1
, *(int *)&var2
);
1093 printf("u32=%d %d\n",
1094 *(unsigned int *)&var1
, *(unsigned int *)&var2
);
1095 *(char *)&var1
= 0x08;
1096 printf("var1=%x\n", var1
);
1097 *(short *)&var1
= 0x0809;
1098 printf("var1=%x\n", var1
);
1099 *(int *)&var1
= 0x08090a0b;
1100 printf("var1=%x\n", var1
);
1103 /******************/
1105 typedef struct Sym
{
1113 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
1114 #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
1116 static int toupper1(int a
)
1121 static unsigned int calc_vm_flags(unsigned int prot
)
1123 unsigned int prot_bits
;
1124 /* This used to segfault in some revisions: */
1125 prot_bits
= ((0x1==0x00000001)?(prot
&0x1):(prot
&0x1)?0x00000001:0);
1131 int *s
, a
, b
, t
, f
, i
;
1135 printf("!s=%d\n", !s
);
1139 printf("a=%d\n", a
);
1141 printf("a=%d %d %d\n", 0 || 0, 0 || 1, 1 || 1);
1142 printf("a=%d %d %d\n", 0 && 0, 0 && 1, 1 && 1);
1143 printf("a=%d %d\n", 1 ? 1 : 0, 0 ? 1 : 0);
1158 printf("b=%d\n", a
+ (0 ? 1 : a
/ 2));
1160 /* test register spilling */
1163 a
= (a
+ b
) * ((a
< b
) ?
1164 ((b
- a
) * (a
- b
)): a
+ b
);
1165 printf("a=%d\n", a
);
1167 /* test complex || or && expressions */
1171 printf("exp=%d\n", f
== (32 <= a
&& a
<= 3));
1172 printf("r=%d\n", (t
|| f
) + (t
&& f
));
1177 int aspect_native
= 65536;
1178 double bfu_aspect
= 1.0;
1180 for(aspect_on
= 0; aspect_on
< 2; aspect_on
++) {
1181 aspect
=aspect_on
?(aspect_native
*bfu_aspect
+0.5):65535UL;
1182 printf("aspect=%d\n", aspect
);
1186 /* test ? : GCC extension */
1188 static int v1
= 34 ? : -1; /* constant case */
1189 static int v2
= 0 ? : -1; /* constant case */
1192 printf("%d %d\n", v1
, v2
);
1193 printf("%d %d\n", a
- 30 ? : a
* 2, a
+ 1 ? : a
* 2);
1196 /* again complex expression */
1197 for(i
=0;i
<256;i
++) {
1198 if (toupper1 (i
) != TOUPPER (i
))
1199 printf("error %d\n", i
);
1201 printf ("bits = 0x%x\n", calc_vm_flags (0x1));
1204 extern int undefined_function(void);
1205 extern int defined_function(void);
1207 static inline void refer_to_undefined(void)
1209 undefined_function();
1212 void optimize_out(void)
1214 int i
= 0 ? undefined_function() : defined_function();
1215 printf ("oo:%d\n", i
);
1216 int j
= 1 ? defined_function() : undefined_function();
1217 printf ("oo:%d\n", j
);
1219 printf("oo:%d\n", undefined_function());
1221 printf("oo:%d\n", defined_function());
1223 printf("oo:%d\n", defined_function());
1225 printf("oo:%d\n", undefined_function());
1227 printf("oow:%d\n", defined_function());
1229 printf("oow:%d\n", undefined_function());
1232 /* Following is a switch without {} block intentionally. */
1235 printf ("oos:%d\n", defined_function());
1236 /* The following break shouldn't lead to disabled code after
1240 printf ("ool1:%d\n", defined_function());
1241 /* Same for the other types of loops. */
1245 printf ("ool2:%d\n", defined_function());
1248 printf ("ool3:%d\n", defined_function());
1249 /* Normal {} blocks without controlling statements
1250 shouldn't reactivate code emission */
1255 printf ("ool4:%d\n", undefined_function());
1260 break; /* this break shouldn't disable code outside the if. */
1261 printf("ool5:%d\n", defined_function());
1271 printf("ool6:%d\n", defined_function());
1275 /* Test that constants in logical && are optimized: */
1276 i
= 0 && undefined_function();
1277 i
= defined_function() && 0 && undefined_function();
1278 if (0 && undefined_function())
1279 undefined_function();
1280 if (defined_function() && 0)
1281 undefined_function();
1283 undefined_function();
1284 if (defined_function() && 0 && undefined_function())
1285 undefined_function();
1286 /* The same for || : */
1287 i
= 1 || undefined_function();
1288 i
= defined_function() || 1 || undefined_function();
1289 if (1 || undefined_function())
1292 undefined_function();
1293 if (defined_function() || 1)
1296 undefined_function();
1300 undefined_function();
1301 if (defined_function() || 1 || undefined_function())
1304 undefined_function();
1306 if (defined_function() && 0)
1307 refer_to_undefined();
1311 printf ("oor:%d\n", undefined_function());
1314 int defined_function(void)
1320 /* GCC accepts that */
1321 static int tab_reinit
[];
1322 static int tab_reinit
[10];
1324 //int cinit1; /* a global variable can be defined several times without error ! */
1328 int *cinit2
= (int []){3, 2, 1};
1330 void compound_literal_test(void)
1335 printf("compound_test:\n");
1337 p
= (int []){1, 2, 3};
1339 printf(" %d", p
[i
]);
1343 printf("%d", cinit2
[i
]);
1347 printf("q1=%s\n", q
);
1349 q
= (char *){ "tralala2" };
1350 printf("q2=%s\n", q
);
1353 printf("q3=%s\n", q3
);
1355 q
= (char []){ "tralala3" };
1356 printf("q4=%s\n", q
);
1359 p
= (int []){1, 2, cinit1
+ 3};
1361 printf(" %d", p
[i
]);
1365 p
= (int []){1, 2, 4 + i
};
1366 printf("%d %d %d\n",
1388 printf("kr_test:\n");
1389 printf("func1=%d\n", kr_func1(3, 4));
1390 printf("func2=%d\n", kr_func2(3, 4));
1397 tab
= (char*)malloc(20);
1414 /* structure assignment tests */
1420 struct structa1 ssta1
;
1422 void struct_assign_test1(struct structa1 s1
, int t
, float f
)
1424 printf("%d %d %d %f\n", s1
.f1
, s1
.f2
, t
, f
);
1427 struct structa1
struct_assign_test2(struct structa1 s1
, int t
)
1434 void struct_assign_test(void)
1437 struct structa1 lsta1
, lsta2
;
1444 printf("struct_assign_test:\n");
1448 printf("%d %d\n", s
.lsta1
.f1
, s
.lsta1
.f2
);
1450 printf("%d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1455 struct_assign_test1(ps
->lsta2
, 3, 4.5);
1457 printf("before call: %d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1458 ps
->lsta2
= struct_assign_test2(ps
->lsta2
, ps
->i
);
1459 printf("after call: %d %d\n", ps
->lsta2
.f1
, ps
->lsta2
.f2
);
1464 /* XXX: we should allow this even without braces */
1465 { struct_assign_test
}
1467 printf("%d\n", struct_assign_test
== t
[0].elem
);
1470 /* casts to short/char */
1472 void cast1(char a
, short b
, unsigned char c
, unsigned short d
)
1474 printf("%d %d %d %d\n", a
, b
, c
, d
);
1488 p
-= 0x700000000042;
1490 printf("cast_test:\n");
1494 printf("%d %d %d %d\n",
1497 (unsigned char)(a
+ 1),
1498 (unsigned short)(a
+ 1));
1499 printf("%d %d %d %d\n",
1502 (unsigned char)0xfffff,
1503 (unsigned short)0xfffff);
1505 a
= (bcast
= 128) + 1;
1507 a
= (scast
= 65536) + 1;
1510 printf("sizeof(c) = %d, sizeof((int)c) = %d\n", sizeof(c
), sizeof((int)c
));
1512 /* test cast from unsigned to signed short to int */
1515 printf("((unsigned)(short)0x%08x) = 0x%08x\n", b
, d
);
1518 printf("((unsigned)(char)0x%08x) = 0x%08x\n", b
, d
);
1520 /* test implicit int casting for array accesses */
1524 printf("%d %d\n", tab
[0], tab
[1]);
1526 /* test implicit casting on some operators */
1527 printf("sizeof(+(char)'a') = %d\n", sizeof(+(char)'a'));
1528 printf("sizeof(-(char)'a') = %d\n", sizeof(-(char)'a'));
1529 printf("sizeof(~(char)'a') = %d\n", sizeof(-(char)'a'));
1531 /* from pointer to integer types */
1532 printf("%d %d %ld %ld %lld %lld\n",
1533 (int)p
, (unsigned int)p
,
1534 (long)p
, (unsigned long)p
,
1535 (long long)p
, (unsigned long long)p
);
1537 /* from integers to pointers */
1538 printf("%p %p %p %p\n",
1539 (void *)a
, (void *)b
, (void *)c
, (void *)d
);
1542 /* initializers tests */
1543 struct structinit1
{
1552 int sinit3
[3] = { 1, 2, {{3}}, };
1553 int sinit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1554 int sinit5
[3][2] = { 1, 2, 3, 4, 5, 6 };
1555 int sinit6
[] = { 1, 2, 3 };
1556 int sinit7
[] = { [2] = 3, [0] = 1, 2 };
1557 char sinit8
[] = "hello" "trala";
1559 struct structinit1 sinit9
= { 1, 2, 3 };
1560 struct structinit1 sinit10
= { .f2
= 2, 3, .f1
= 1 };
1561 struct structinit1 sinit11
= { .f2
= 2, 3, .f1
= 1,
1569 char *sinit12
= "hello world";
1575 char sinit14
[10] = { "abc" };
1576 int sinit15
[3] = { sizeof(sinit15
), 1, 2 };
1578 struct { int a
[3], b
; } sinit16
[] = { { 1 }, 2 };
1594 struct complexinit0
{
1599 struct complexinit
{
1601 const struct complexinit0
*b
;
1604 const static struct complexinit cix
[] = {
1607 .b
= (const struct complexinit0
[]) {
1615 struct complexinit2
{
1620 struct complexinit2 cix20
;
1622 struct complexinit2 cix21
= {
1624 .b
= { 3001, 3002, 3003 }
1627 struct complexinit2 cix22
= {
1629 .b
= { 4001, 4002, 4003, 4004, 4005, 4006 }
1632 typedef int arrtype1
[];
1633 arrtype1 sinit19
= {1};
1634 arrtype1 sinit20
= {2,3};
1635 typedef int arrtype2
[3];
1636 arrtype2 sinit21
= {4};
1637 arrtype2 sinit22
= {5,6,7};
1639 /* Address comparisons of non-weak symbols with zero can be const-folded */
1640 int sinit23
[2] = { "astring" ? sizeof("astring") : -1,
1641 &sinit23
? 42 : -1 };
1643 void init_test(void)
1647 int linit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1648 int linit6
[] = { 1, 2, 3 };
1650 char linit8
[] = "hello" "trala";
1651 int linit12
[10] = { 1, 2 };
1652 int linit13
[10] = { 1, 2, [7] = 3, [3] = 4, };
1653 char linit14
[10] = "abc";
1654 int linit15
[10] = { linit1
, linit1
+ 1, [6] = linit1
+ 2, };
1655 struct linit16
{ int a1
, a2
, a3
, a4
; } linit16
= { 1, .a3
= 2 };
1656 int linit17
= sizeof(linit17
);
1658 /* Addresses on non-weak symbols are non-zero, but not the access itself */
1659 int linit18
[2] = {&zero
? 1 : -1, zero
? -1 : 1 };
1661 printf("init_test:\n");
1663 printf("sinit1=%d\n", sinit1
);
1664 printf("sinit2=%d\n", sinit2
);
1665 printf("sinit3=%d %d %d %d\n",
1671 printf("sinit6=%d\n", sizeof(sinit6
));
1672 printf("sinit7=%d %d %d %d\n",
1678 printf("sinit8=%s\n", sinit8
);
1679 printf("sinit9=%d %d %d\n",
1684 printf("sinit10=%d %d %d\n",
1689 printf("sinit11=%d %d %d %d %d %d\n",
1700 printf("[%d][%d] = %d %d %d\n",
1701 i
, j
, sinit4
[i
][j
], sinit5
[i
][j
], linit4
[i
][j
]);
1702 printf("linit1=%d\n", linit1
);
1703 printf("linit2=%d\n", linit2
);
1704 printf("linit6=%d\n", sizeof(linit6
));
1705 printf("linit8=%d %s\n", sizeof(linit8
), linit8
);
1707 printf("sinit12=%s\n", sinit12
);
1708 printf("sinit13=%d %s %s %s\n",
1713 printf("sinit14=%s\n", sinit14
);
1715 for(i
=0;i
<10;i
++) printf(" %d", linit12
[i
]);
1717 for(i
=0;i
<10;i
++) printf(" %d", linit13
[i
]);
1719 for(i
=0;i
<10;i
++) printf(" %d", linit14
[i
]);
1721 for(i
=0;i
<10;i
++) printf(" %d", linit15
[i
]);
1723 printf("%d %d %d %d\n",
1728 /* test that initialisation is done after variable declare */
1729 printf("linit17=%d\n", linit17
);
1730 printf("sinit15=%d\n", sinit15
[0]);
1731 printf("sinit16=%d %d\n", sinit16
[0].a
[0], sinit16
[1].a
[0]);
1732 printf("sinit17=%s %d %s %d\n",
1733 sinit17
[0].s
, sinit17
[0].len
,
1734 sinit17
[1].s
, sinit17
[1].len
);
1736 printf("%x ", sinit18
[i
]);
1738 /* complex init check */
1739 printf("cix: %d %d %d %d %d %d %d\n",
1741 cix
[0].b
[0].a
, cix
[0].b
[0].b
,
1742 cix
[0].b
[1].a
, cix
[0].b
[1].b
,
1743 cix
[0].b
[2].a
, cix
[0].b
[2].b
);
1744 printf("cix2: %d %d\n", cix21
.b
[2], cix22
.b
[5]);
1745 printf("sizeof cix20 %d, cix21 %d, sizeof cix22 %d\n", sizeof cix20
, sizeof cix21
, sizeof cix22
);
1747 printf("arrtype1: %d %d %d\n", sinit19
[0], sinit20
[0], sinit20
[1]);
1748 printf("arrtype2: %d %d\n", sizeof(sinit19
), sizeof(sinit20
));
1749 printf("arrtype3: %d %d %d\n", sinit21
[0], sinit21
[1], sinit21
[2]);
1750 printf("arrtype4: %d %d %d\n", sinit22
[0], sinit22
[1], sinit22
[2]);
1751 printf("arrtype5: %d %d\n", sizeof(sinit21
), sizeof(sinit22
));
1752 printf("arrtype6: %d\n", sizeof(arrtype2
));
1754 printf("sinit23= %d %d\n", sinit23
[0], sinit23
[1]);
1755 printf("linit18= %d %d\n", linit18
[0], linit18
[1]);
1758 void switch_uc(unsigned char uc
)
1771 printf("ucsw: broken!\n");
1775 void switch_sc(signed char sc
)
1788 printf("scsw: broken!\n");
1795 unsigned long long ull
;
1820 for (i
= 1; i
<= 5; i
++) {
1821 ull
= (unsigned long long)i
<< 61;
1824 printf("ullsw:1\n");
1827 printf("ullsw:2\n");
1830 printf("ullsw:3\n");
1833 printf("ullsw:4\n");
1836 printf("ullsw:5\n");
1839 printf("ullsw: broken!\n");
1843 for (i
= 1; i
<= 5; i
++) {
1844 ll
= (long long)i
<< 61;
1862 printf("llsw: broken!\n");
1866 for (i
= -5; i
<= 5; i
++) {
1867 switch_uc((unsigned char)i
);
1870 for (i
= -5; i
<= 5; i
++) {
1871 switch_sc ((signed char)i
);
1875 /* ISOC99 _Bool type */
1876 void c99_bool_test(void)
1882 printf("bool_test:\n");
1883 printf("sizeof(_Bool) = %d\n", sizeof(_Bool
));
1885 printf("cast: %d %d %d\n", (_Bool
)10, (_Bool
)0, (_Bool
)a
);
1887 printf("b = %d\n", b
);
1889 printf("b = %d\n", b
);
1893 void bitfield_test(void)
1905 unsigned int f5
: 7;
1907 printf("bitfield_test:");
1908 printf("sizeof(st1) = %d\n", sizeof(st1
));
1917 printf("%d %d %d %d %d\n",
1918 st1
.f1
, st1
.f2
, st1
.f3
, st1
.f4
, st1
.f5
);
1921 printf("%d %d\n", sa
, ca
);
1925 printf("st1.f1 == -1\n");
1927 printf("st1.f1 != -1\n");
1929 printf("st1.f2 == -1\n");
1931 printf("st1.f2 != -1\n");
1933 /* bit sizes below must be bigger than 32 since GCC doesn't allow
1934 long-long bitfields whose size is not bigger than int */
1939 unsigned long long f3
: 38;
1941 st2
.f1
= 0x123456789ULL
;
1943 st2
.f2
= (long long)a
<< 25;
1946 printf("%lld %lld %lld\n", st2
.f1
, st2
.f2
, st2
.f3
);
1950 #define FLOAT_FMT "%f\n"
1952 /* x86's float isn't compatible with GCC */
1953 #define FLOAT_FMT "%.5f\n"
1956 /* declare strto* functions as they are C99 */
1957 double strtod(const char *nptr
, char **endptr
);
1960 float strtof(const char *nptr
, char **endptr
) {return (float)strtod(nptr
, endptr
);}
1961 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
) {return (LONG_DOUBLE
)strtod(nptr
, endptr
);}
1963 float strtof(const char *nptr
, char **endptr
);
1964 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
);
1967 #define FTEST(prefix, typename, type, fmt)\
1968 void prefix ## cmp(type a, type b)\
1970 printf("%d %d %d %d %d %d\n",\
1977 printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\
1985 printf(fmt "\n", ++a);\
1986 printf(fmt "\n", a++);\
1987 printf(fmt "\n", a);\
1989 printf("%d %d\n", !a, !b);\
1991 void prefix ## fcast(type a)\
1999 unsigned long long llua;\
2004 printf("ftof: %f %f %Lf\n", fa, da, la);\
2006 llia = (long long)a;\
2007 a = (a >= 0) ? a : -a;\
2008 ua = (unsigned int)a;\
2009 llua = (unsigned long long)a;\
2010 printf("ftoi: %d %u %lld %llu\n", ia, ua, llia, llua);\
2013 llia = -0x123456789012345LL;\
2014 llua = 0xf123456789012345LLU;\
2016 printf("itof: " fmt "\n", b);\
2018 printf("utof: " fmt "\n", b);\
2020 printf("lltof: " fmt "\n", b);\
2022 printf("ulltof: " fmt "\n", b);\
2025 float prefix ## retf(type a) { return a; }\
2026 double prefix ## retd(type a) { return a; }\
2027 LONG_DOUBLE prefix ## retld(type a) { return a; }\
2029 void prefix ## call(void)\
2031 printf("float: " FLOAT_FMT, prefix ## retf(42.123456789));\
2032 printf("double: %f\n", prefix ## retd(42.123456789));\
2033 printf("long double: %Lf\n", prefix ## retld(42.123456789));\
2034 printf("strto%s: %f\n", #prefix, (double)strto ## prefix("1.2", NULL));\
2037 void prefix ## signed_zeros(void) \
2039 type x = 0.0, y = -0.0, n, p;\
2041 printf ("Test 1.0 / x != 1.0 / y returns %d (should be 1).\n",\
2042 1.0 / x != 1.0 / y);\
2044 printf ("x != y; this is wrong!\n");\
2048 printf ("Test 1.0 / x != 1.0 / -x returns %d (should be 1).\n",\
2049 1.0 / x != 1.0 / n);\
2051 printf ("x != -x; this is wrong!\n");\
2055 printf ("Test 1.0 / x != 1.0 / +y returns %d (should be 1).\n",\
2056 1.0 / x != 1.0 / p);\
2058 printf ("x != +y; this is wrong!\n");\
2061 printf ("Test 1.0 / x != 1.0 / -y returns %d (should be 0).\n",\
2062 1.0 / x != 1.0 / p);\
2064 printf ("x != -y; this is wrong!\n");\
2066 void prefix ## test(void)\
2068 printf("testing '%s'\n", #typename);\
2069 prefix ## cmp(1, 2.5);\
2070 prefix ## cmp(2, 1.5);\
2071 prefix ## cmp(1, 1);\
2072 prefix ## fcast(234.6);\
2073 prefix ## fcast(-2334.6);\
2075 prefix ## signed_zeros();\
2078 FTEST(f
, float, float, "%f")
2079 FTEST(d
, double, double, "%f")
2080 FTEST(ld
, long double, LONG_DOUBLE
, "%Lf")
2082 double ftab1
[3] = { 1.2, 3.4, -5.6 };
2085 void float_test(void)
2087 #if !defined(__arm__) || defined(__ARM_PCS_VFP)
2093 printf("float_test:\n");
2094 printf("sizeof(float) = %d\n", sizeof(float));
2095 printf("sizeof(double) = %d\n", sizeof(double));
2096 printf("sizeof(long double) = %d\n", sizeof(LONG_DOUBLE
));
2100 printf("%f %f %f\n", ftab1
[0], ftab1
[1], ftab1
[2]);
2101 printf("%f %f %f\n", 2.12, .5, 2.3e10
);
2102 // printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
2104 printf("da=%f\n", da
);
2106 printf("fa=%f\n", fa
);
2109 printf("da = %f\n", da
);
2112 printf("db = %f\n", db
);
2121 return fib(n
-1) + fib(n
-2);
2134 printf("funcptr:\n");
2141 /* more complicated pointer computation */
2144 printf("sizeof1 = %d\n", sizeof(funcptr_test
));
2145 printf("sizeof2 = %d\n", sizeof funcptr_test
);
2146 printf("sizeof3 = %d\n", sizeof(&funcptr_test
));
2147 printf("sizeof4 = %d\n", sizeof &funcptr_test
);
2156 void lloptest(long long a
, long long b
)
2158 unsigned long long ua
, ub
;
2163 printf("arith: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2169 printf("arith1: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2175 printf("bin: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2181 printf("test: %d %d %d %d %d %d\n",
2189 printf("utest: %d %d %d %d %d %d\n",
2200 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2201 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
++, b
++);
2202 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", --a
, --b
);
2203 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2205 printf("not: %d %d %d %d\n", !a
, !ua
, !b
, !ub
);
2208 void llshift(long long a
, int b
)
2210 printf("shift: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2211 (unsigned long long)a
>> b
,
2214 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2215 (unsigned long long)a
>> 3,
2218 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2219 (unsigned long long)a
>> 35,
2229 long long la
, lb
, lc
;
2230 unsigned long long ula
, ulb
, ulc
;
2233 la
= (la
<< 20) | 0x12345;
2235 printf("la=" LONG_LONG_FORMAT
" ula=" ULONG_LONG_FORMAT
"\n", la
, ula
);
2240 printf("lltof: %f %f %Lf\n", fa
, da
, lda
);
2245 printf("ftoll: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", la
, lb
, lc
);
2250 printf("ulltof: %f %f %Lf\n", fa
, da
, lda
);
2255 printf("ftoull: " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
"\n", ula
, ulb
, ulc
);
2258 long long llfunc1(int a
)
2268 long long int value(struct S
*v
)
2270 return ((long long int)v
->item
);
2273 long long llfunc2(long long x
, long long y
, int z
)
2278 void longlong_test(void)
2283 printf("longlong_test:\n");
2284 printf("sizeof(long long) = %d\n", sizeof(long long));
2289 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2290 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %Lx\n",
2294 0x1234567812345679);
2296 printf(LONG_LONG_FORMAT
"\n", a
);
2299 lloptest(0xff, 0x1234);
2300 b
= 0x72345678 << 10;
2304 b
= 0x72345678LL
<< 10;
2315 /* long long reg spill test */
2320 printf("%lld\n", value(&a
));
2322 lloptest(0x80000000, 0);
2325 long long *p
, v
, **pp
;
2329 printf("another long long spill test : %lld\n", *p
);
2332 v
= llfunc2(**pp
, **pp
, ia
);
2333 printf("a long long function (arm-)reg-args test : %lld\n", v
);
2337 printf("%d %d %d %d\n", a
> b
, a
< b
, a
>= b
, a
<= b
);
2339 printf(LONG_LONG_FORMAT
"\n", 0x123456789LLU
);
2341 /* long long pointer deref in argument passing test */
2347 void manyarg_test(void)
2349 LONG_DOUBLE ld
= 1234567891234LL;
2350 printf("manyarg_test:\n");
2351 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2352 1, 2, 3, 4, 5, 6, 7, 8,
2353 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2354 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2355 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2356 1, 2, 3, 4, 5, 6, 7, 8,
2357 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2358 1234567891234LL, 987654321986LL,
2360 printf("%Lf %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2361 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2362 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2363 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2364 1234567891234LL, 987654321986LL,
2366 printf("%d %d %d %d %d %d %d %d %Lf\n",
2367 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2368 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2369 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"%f %f %Lf\n",
2370 1, 2, 3, 4, 5, 6, 7, 8,
2371 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2372 1234567891234LL, 987654321986LL,
2374 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2375 "%Lf " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f %Lf\n",
2376 1, 2, 3, 4, 5, 6, 7, 8,
2377 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2378 ld
, 1234567891234LL, 987654321986LL,
2382 void vprintf1(const char *fmt
, ...)
2406 i
= va_arg(ap
, int);
2410 d
= va_arg(ap
, double);
2414 ll
= va_arg(ap
, long long);
2415 printf(LONG_LONG_FORMAT
, ll
);
2418 ld
= va_arg(ap
, LONG_DOUBLE
);
2436 void stdarg_for_struct(struct myspace bob
, ...)
2438 struct myspace george
, bill
;
2443 bill
= va_arg(ap
, struct myspace
);
2444 george
= va_arg(ap
, struct myspace
);
2445 validate
= va_arg(ap
, int);
2446 printf("stdarg_for_struct: %d %d %d %d\n",
2447 bob
.profile
, bill
.profile
, george
.profile
, validate
);
2451 void stdarg_for_libc(const char *fmt
, ...)
2454 va_start(args
, fmt
);
2459 void stdarg_test(void)
2461 LONG_DOUBLE ld
= 1234567891234LL;
2464 vprintf1("%d %d %d\n", 1, 2, 3);
2465 vprintf1("%f %d %f\n", 1.0, 2, 3.0);
2466 vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0);
2467 vprintf1("%F %F %F\n", LONG_DOUBLE_LITERAL(1.2), LONG_DOUBLE_LITERAL(2.3), LONG_DOUBLE_LITERAL(3.4));
2468 vprintf1("%d %f %l %F %d %f %l %F\n",
2469 1, 1.2, 3LL, LONG_DOUBLE_LITERAL(4.5), 6, 7.8, 9LL, LONG_DOUBLE_LITERAL(0.1));
2470 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f\n",
2471 1, 2, 3, 4, 5, 6, 7, 8,
2472 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8);
2473 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2474 1, 2, 3, 4, 5, 6, 7, 8,
2475 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2476 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2478 1, 2, 3, 4, 5, 6, 7, 8,
2479 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2480 1234567891234LL, 987654321986LL,
2482 vprintf1("%F %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2484 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2485 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2486 1234567891234LL, 987654321986LL,
2488 vprintf1("%d %d %d %d %d %d %d %d %F\n",
2489 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2490 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2492 1, 2, 3, 4, 5, 6, 7, 8,
2493 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2494 1234567891234LL, 987654321986LL,
2496 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2497 "%F %l %l %f %f %F\n",
2498 1, 2, 3, 4, 5, 6, 7, 8,
2499 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2500 ld
, 1234567891234LL, 987654321986LL,
2504 stdarg_for_struct(bob
, bob
, bob
, bob
.profile
);
2505 stdarg_for_libc("stdarg_for_libc: %s %.2f %d\n", "string", 1.23, 456);
2508 void whitespace_test(void)
2514 ntf("whitspace:\n");\f\v
2518 #ifdef CORRECT_CR_HANDLING
2527 #ifdef ACCEPT_CR_IN_STRINGS
2528 printf("len1=%d\n", strlen("
2530 #ifdef CORRECT_CR_HANDLING
2533 printf("len1=%d str[0]=%d\n", strlen(str
), str
[0]);
2535 printf("len1=%d\n", strlen("
a
2537 #endif /* ACCEPT_CR_IN_STRINGS */
2540 int reltab
[3] = { 1, 2, 3 };
2542 int *rel1
= &reltab
[1];
2543 int *rel2
= &reltab
[2];
2545 void getmyaddress(void)
2547 printf("in getmyaddress\n");
2551 long __pa_symbol(void)
2553 /* This 64bit constant was handled incorrectly, it was used as addend
2554 (which can hold 64bit just fine) in connection with a symbol,
2555 and TCC generates wrong code for that (displacements are 32bit only).
2556 This effectively is "+ 0x80000000", and if addresses of globals
2557 are below 2GB the result should be a number without high 32 bits set. */
2558 return ((long)(((unsigned long)(&rel1
))) - (0xffffffff80000000UL
));
2562 unsigned long theaddress
= (unsigned long)getmyaddress
;
2563 void relocation_test(void)
2565 void (*fptr
)(void) = (void (*)(void))theaddress
;
2566 printf("*rel1=%d\n", *rel1
);
2567 printf("*rel2=%d\n", *rel2
);
2570 printf("pa_symbol=0x%lx\n", __pa_symbol() >> 63);
2574 void old_style_f(a
,b
,c
)
2578 printf("a=%d b=%d b=%f\n", a
, b
, c
);
2581 void decl_func1(int cmpfn())
2583 printf("cmpfn=%lx\n", (long)cmpfn
);
2586 void decl_func2(cmpfn
)
2589 printf("cmpfn=%lx\n", (long)cmpfn
);
2592 void old_style_function(void)
2594 old_style_f((void *)1, 2, 3.0);
2601 #if defined __i386__ || defined __x86_64__ || defined __arm__
2602 char *p
= alloca(16);
2603 strcpy(p
,"123456789012345");
2604 printf("alloca: p is %s\n", p
);
2605 char *demo
= "This is only a test.\n";
2606 /* Test alloca embedded in a larger expression */
2607 printf("alloca: %s\n", strcpy(alloca(strlen(demo
)+1),demo
) );
2611 void *bounds_checking_is_enabled()
2613 char ca
[10], *cp
= ca
-1;
2614 return (ca
!= cp
+ 1) ? cp
: NULL
;
2617 typedef int constant_negative_array_size_as_compile_time_assertion_idiom
[(1 ? 2 : 0) - 1];
2619 void c99_vla_test(int size1
, int size2
)
2621 #if defined __i386__ || defined __x86_64__
2622 int size
= size1
* size2
;
2623 int tab1
[size
][2], tab2
[10][2];
2624 void *tab1_ptr
, *tab2_ptr
, *bad_ptr
;
2626 /* "size" should have been 'captured' at tab1 declaration,
2627 so modifying it should have no effect on VLA behaviour. */
2630 printf("Test C99 VLA 1 (sizeof): ");
2631 printf("%s\n", (sizeof tab1
== size1
* size2
* 2 * sizeof(int)) ? "PASSED" : "FAILED");
2634 printf("Test C99 VLA 2 (ptrs subtract): ");
2635 printf("%s\n", (tab2
- tab1
== (tab2_ptr
- tab1_ptr
) / (sizeof(int) * 2)) ? "PASSED" : "FAILED");
2636 printf("Test C99 VLA 3 (ptr add): ");
2637 printf("%s\n", &tab1
[5][1] == (tab1_ptr
+ (5 * 2 + 1) * sizeof(int)) ? "PASSED" : "FAILED");
2638 printf("Test C99 VLA 4 (ptr access): ");
2639 tab1
[size1
][1] = 42;
2640 printf("%s\n", (*((int *) (tab1_ptr
+ (size1
* 2 + 1) * sizeof(int))) == 42) ? "PASSED" : "FAILED");
2642 printf("Test C99 VLA 5 (bounds checking (might be disabled)): ");
2643 if (bad_ptr
= bounds_checking_is_enabled()) {
2644 int *t1
= &tab1
[size1
* size2
- 1][3];
2645 int *t2
= &tab2
[9][3];
2646 printf("%s ", bad_ptr
== t1
? "PASSED" : "FAILED");
2647 printf("%s ", bad_ptr
== t2
? "PASSED" : "FAILED");
2649 char*c1
= 1 + sizeof(tab1
) + (char*)tab1
;
2650 char*c2
= 1 + sizeof(tab2
) + (char*)tab2
;
2651 printf("%s ", bad_ptr
== c1
? "PASSED" : "FAILED");
2652 printf("%s ", bad_ptr
== c2
? "PASSED" : "FAILED");
2656 printf("%s ", bad_ptr
== i1
? "PASSED" : "FAILED");
2657 printf("%s ", bad_ptr
== i2
? "PASSED" : "FAILED");
2659 int *x1
= tab1
[size1
* size2
+ 1];
2660 int *x2
= tab2
[10 + 1];
2661 printf("%s ", bad_ptr
== x1
? "PASSED" : "FAILED");
2662 printf("%s ", bad_ptr
== x2
? "PASSED" : "FAILED");
2664 printf("PASSED PASSED PASSED PASSED PASSED PASSED PASSED PASSED ");
2671 typedef __SIZE_TYPE__
uintptr_t;
2674 void sizeof_test(void)
2679 printf("sizeof(int) = %d\n", sizeof(int));
2680 printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
2681 printf("sizeof(long) = %d\n", sizeof(long));
2682 printf("sizeof(unsigned long) = %d\n", sizeof(unsigned long));
2683 printf("sizeof(short) = %d\n", sizeof(short));
2684 printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
2685 printf("sizeof(char) = %d\n", sizeof(char));
2686 printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
2687 printf("sizeof(func) = %d\n", sizeof sizeof_test());
2689 printf("sizeof(a++) = %d\n", sizeof a
++);
2690 printf("a=%d\n", a
);
2692 printf("sizeof(**ptr) = %d\n", sizeof (**ptr
));
2694 /* The type of sizeof should be as large as a pointer, actually
2695 it should be size_t. */
2696 printf("sizeof(sizeof(int) = %d\n", sizeof(sizeof(int)));
2699 /* Effectively <<32, but defined also on 32bit machines. */
2703 /* This checks that sizeof really can be used to manipulate
2704 uintptr_t objects, without truncation. */
2705 t2
= t
& -sizeof(uintptr_t);
2706 printf ("%lu %lu\n", t
, t2
);
2708 /* some alignof tests */
2709 printf("__alignof__(int) = %d\n", __alignof__(int));
2710 printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int));
2711 printf("__alignof__(short) = %d\n", __alignof__(short));
2712 printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short));
2713 printf("__alignof__(char) = %d\n", __alignof__(char));
2714 printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char));
2715 printf("__alignof__(func) = %d\n", __alignof__
sizeof_test());
2717 /* sizes of VLAs need to be evaluated even inside sizeof: */
2719 printf("sizeof(char[1+2*a]) = %d\n", sizeof(char[1+2*a
]));
2720 /* And checking if sizeof compound literal works. Parenthesized: */
2721 printf("sizeof( (struct {int i; int j;}){4,5} ) = %d\n",
2722 sizeof( (struct {int i
; int j
;}){4,5} ));
2723 /* And as direct sizeof argument (as unary expression): */
2724 printf("sizeof (struct {short i; short j;}){4,5} = %d\n",
2725 sizeof (struct {short i
; short j
;}){4,5} );
2727 /* sizeof(x && y) should be sizeof(int), even if constant
2728 evaluating is possible. */
2729 printf("sizeof(t && 0) = %d\n", sizeof(t
&& 0));
2730 printf("sizeof(1 && 1) = %d\n", sizeof(1 && 1));
2731 printf("sizeof(t || 1) = %d\n", sizeof(t
|| 1));
2732 printf("sizeof(0 || 0) = %d\n", sizeof(0 || 0));
2735 void typeof_test(void)
2744 printf("a=%f b=%f c=%f\n", a
, b
, c
);
2750 struct hlist_node
*first
, *last
;
2753 void statement_expr_test(void)
2757 /* Basic stmt expr test */
2767 printf("a=%d\n", a
);
2769 /* Test that symbols aren't freed prematurely.
2770 With SYM_DEBUG valgrind will show a read from a freed
2771 symbol, and tcc will show an (invalid) warning on the initialization
2772 of 'ptr' below, if symbols are popped after the stmt expr. */
2773 void *v
= (void*)39;
2775 (struct hlist_node
*)v
;
2778 ptr
= (struct hlist_node
*)v
;
2780 /* This part used to segfault when symbols were popped prematurely.
2781 The symbols for the static local would be overwritten with
2782 helper symbols from the pre-processor expansions in between. */
2783 #define some_attr __attribute__((aligned(1)))
2784 #define tps(str) ({ \
2785 static const char *t some_attr = str; \
2788 printf ("stmtexpr: %s %s\n",
2789 tps("somerandomlongstring"),
2790 tps("anotherlongstring"));
2792 /* Test that the three decls of 't' don't interact. */
2794 int b
= ({ int t
= 41; t
; });
2795 int c
= ({ int t
= 42; t
; });
2797 /* Test that aggregate return values work. */
2800 typedef struct hlist_head T
;
2802 T t
= { (void*)43, (void*)44 };
2806 printf ("stmtexpr: %d %d %d\n", t
, b
, c
);
2807 printf ("stmtexpr: %ld %ld\n", (long)h
.first
, (long)h
.last
);
2810 void local_label_test(void)
2816 __label__ l1
, l2
, l3
, l4
;
2830 printf("a=%d\n", a
);
2840 /* inline assembler test */
2841 #if defined(__i386__) || defined(__x86_64__)
2843 /* from linux kernel */
2844 static char * strncat1(char * dest
,const char * src
,size_t count
)
2846 long d0
, d1
, d2
, d3
;
2847 __asm__
__volatile__(
2856 "testb %%al,%%al\n\t"
2860 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
2861 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
2866 static char * strncat2(char * dest
,const char * src
,size_t count
)
2868 long d0
, d1
, d2
, d3
;
2869 __asm__
__volatile__(
2870 "repne scasb\n\t" /* one-line repne prefix + string op */
2877 "testb %%al,%%al\n\t"
2881 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
2882 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
2887 static inline void * memcpy1(void * to
, const void * from
, size_t n
)
2890 __asm__
__volatile__(
2895 "1:\ttestb $1,%b4\n\t"
2899 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
2900 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
2905 static inline void * memcpy2(void * to
, const void * from
, size_t n
)
2908 __asm__
__volatile__(
2909 "rep movsl\n\t" /* one-line rep prefix + string op */
2913 "1:\ttestb $1,%b4\n\t"
2917 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
2918 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
2923 static __inline__
void sigaddset1(unsigned int *set
, int _sig
)
2925 __asm__("btsl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc");
2928 static __inline__
void sigdelset1(unsigned int *set
, int _sig
)
2930 asm("btrl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc", "flags");
2933 static __inline__ __const__
unsigned int swab32(unsigned int x
)
2935 __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */
2936 "rorl $16,%0\n\t" /* swap words */
2937 "xchgb %b0,%h0" /* swap higher bytes */
2943 static __inline__
unsigned long long mul64(unsigned int a
, unsigned int b
)
2945 unsigned long long res
;
2947 /* Using the A constraint is wrong (it means rdx:rax, which is too large)
2948 but still test the 32bit->64bit mull. */
2949 unsigned int resh
, resl
;
2950 __asm__("mull %2" : "=a" (resl
), "=d" (resh
) : "a" (a
), "r" (b
));
2951 res
= ((unsigned long long)resh
<< 32) | resl
;
2953 __asm__("mull %2" : "=A" (res
) : "a" (a
), "r" (b
));
2958 static __inline__
unsigned long long inc64(unsigned long long a
)
2960 unsigned long long res
;
2962 /* Using the A constraint is wrong, and increments are tested
2966 __asm__("addl $1, %%eax ; adcl $0, %%edx" : "=A" (res
) : "A" (a
));
2979 unsigned long mconstraint_test(struct struct1231
*r
)
2984 __asm__
volatile ("lea %2,%0; movl 4(%0),%k0; addl %2,%k0; movl $51,%2; movl $52,4%2; movl $63,%1"
2985 : "=&r" (ret
), "=m" (a
)
2986 : "m" (*(struct struct123
*)r
->addr
));
2991 int fls64(unsigned long long x
)
3001 void other_constraints_test(void)
3005 __asm__
volatile ("movq %P1,%0" : "=r" (ret
) : "p" (&var
));
3006 printf ("oc1: %d\n", ret
== (unsigned long)&var
);
3009 /* Test global asm blocks playing with aliases. */
3010 void base_func(void)
3012 printf ("asmc: base\n");
3015 extern void override_func1 (void);
3016 extern void override_func2 (void);
3018 asm(".weak override_func1\n.set override_func1, base_func");
3019 asm(".set override_func1, base_func");
3020 asm(".set override_func2, base_func");
3022 void override_func2 (void)
3024 printf ("asmc: override2\n");
3027 /* This checks a construct used by the linux kernel to encode
3028 references to strings by PC relative references. */
3029 extern int bug_table
[] __attribute__((section("__bug_table")));
3030 char * get_asm_string (void)
3032 extern int some_symbol
;
3033 asm volatile (".globl some_symbol\n"
3036 "some_symbol: .long 0\n"
3037 ".pushsection __bug_table, \"a\"\n"
3038 ".globl bug_table\n"
3040 /* The first entry (1b-2b) is unused in this test,
3041 but we include it to check if cross-section
3042 PC-relative references work. */
3043 "2:\t.long 1b - 2b, %c0 - 2b\n"
3044 ".popsection\n" : : "i" ("A string"));
3045 char * str
= ((char*)bug_table
) + bug_table
[1];
3051 void fancy_copy (unsigned *in
, unsigned *out
)
3053 asm volatile ("" : "=r" (*out
) : "0" (*in
));
3056 void fancy_copy2 (unsigned *in
, unsigned *out
)
3058 asm volatile ("mov %0,(%1)" : : "r" (*in
), "r" (out
) : "memory");
3062 void clobber_r12(void)
3064 asm volatile("mov $1, %%r12" ::: "r12");
3068 void test_high_clobbers(void)
3071 register long val
asm("r12");
3073 /* This tests if asm clobbers correctly save/restore callee saved
3074 registers if they are clobbered and if it's the high 8 x86-64
3075 registers. This is fragile for GCC as the constraints do not
3076 correctly capture the data flow, but good enough for us. */
3077 asm volatile("mov $0x4542, %%r12" : "=r" (val
):: "memory");
3079 asm volatile("mov %%r12, %0" : "=r" (val2
) : "r" (val
): "memory");
3080 printf("asmhc: 0x%x\n", val2
);
3084 static long cpu_number
;
3085 void trace_console(long len
, long len2
)
3087 /* This generated invalid code when the emission of the switch
3088 table isn't disabled. The asms are necessary to show the bug,
3089 normal statements don't work (they need to generate some code
3090 even under nocode_wanted, which normal statements don't do,
3091 but asms do). Also at least these number of cases is necessary
3092 to generate enough "random" bytes. They ultimately are enough
3093 to create invalid instruction patterns to which the first
3094 skip-to-decision-table jump jumps. If decision table emission
3095 is disabled all of this is no problem.
3097 It also is necessary that the switches are in a statement expression
3098 (which has the property of not being enterable from outside. no
3109 case 8: printf("bla"); pfo_ret__
= 42; break;
3111 pscr_ret__
= pfo_ret__
;
3118 case 1:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3119 case 2:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3120 case 4:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3121 case 8:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3122 default: printf("impossible\n");
3124 pscr_ret__
= pfo_ret__
;
3137 unsigned int val
, val2
;
3138 struct struct123 s1
;
3139 struct struct1231 s2
= { (unsigned long)&s1
};
3140 /* Hide the outer base_func, but check later that the inline
3141 asm block gets the outer one. */
3143 void override_func3 (void);
3144 unsigned long asmret
;
3148 register int regvar
asm("%esi");
3150 printf("inline asm:\n");
3152 // parse 0x1E-1 as 3 tokens in asm mode
3153 asm volatile ("mov $0x1E-1,%eax");
3155 /* test the no operand case */
3156 asm volatile ("xorl %eax, %eax");
3158 memcpy1(buf
, "hello", 6);
3159 strncat1(buf
, " worldXXXXX", 3);
3160 printf("%s\n", buf
);
3162 memcpy2(buf
, "hello", 6);
3163 strncat2(buf
, " worldXXXXX", 3);
3164 printf("%s\n", buf
);
3166 /* 'A' constraint test */
3167 printf("mul64=0x%Lx\n", mul64(0x12345678, 0xabcd1234));
3168 printf("inc64=0x%Lx\n", inc64(0x12345678ffffffff));
3172 printf("mconstraint: %d", mconstraint_test(&s2
));
3173 printf(" %d %d\n", s1
.a
, s1
.b
);
3174 other_constraints_test();
3176 sigdelset1(&set
, 2);
3177 sigaddset1(&set
, 16);
3178 /* NOTE: we test here if C labels are correctly restored after the
3182 __asm__("btsl %1,%0" : "=m"(set
) : "Ir"(20) : "cc");
3183 printf("set=0x%x\n", set
);
3185 printf("swab32(0x%08x) = 0x%0x\n", val
, swab32(val
));
3188 /* The base_func ref from the following inline asm should find
3189 the global one, not the local decl from this function. */
3190 asm volatile(".weak override_func3\n.set override_func3, base_func");
3192 /* Check that we can also load structs of appropriate layout
3194 asm volatile("" : "=r" (asmret
) : "0"(s2
));
3195 if (asmret
!= s2
.addr
)
3196 printf("asmstr: failed\n");
3198 /* Check that the typesize correctly sets the register size to
3200 asm volatile("cmp %1,%2; sete %0" : "=a"(somebool
) : "r"(1), "r"(2));
3202 printf("asmbool: failed\n");
3204 printf("asmstr: %s\n", get_asm_string());
3206 fancy_copy (&val
, &val2
);
3207 printf ("fancycpy(%d)=%d\n", val
, val2
);
3209 fancy_copy2 (&val
, &val2
);
3210 printf ("fancycpy2(%d)=%d\n", val
, val2
);
3211 asm volatile ("mov $0x4243, %%esi" : "=r" (regvar
));
3212 printf ("regvar=%x\n", regvar
);
3213 test_high_clobbers();
3214 trace_console(8, 8);
3228 #define COMPAT_TYPE(type1, type2) \
3230 printf("__builtin_types_compatible_p(%s, %s) = %d\n", #type1, #type2, \
3231 __builtin_types_compatible_p (type1, type2));\
3236 void builtin_test(void)
3242 COMPAT_TYPE(int, int);
3243 COMPAT_TYPE(int, unsigned int);
3244 COMPAT_TYPE(int, char);
3245 COMPAT_TYPE(int, const int);
3246 COMPAT_TYPE(int, volatile int);
3247 COMPAT_TYPE(int *, int *);
3248 COMPAT_TYPE(int *, void *);
3249 COMPAT_TYPE(int *, const int *);
3250 COMPAT_TYPE(char *, unsigned char *);
3251 COMPAT_TYPE(char *, signed char *);
3252 COMPAT_TYPE(char *, char *);
3253 /* space is needed because tcc preprocessor introduces a space between each token */
3254 COMPAT_TYPE(char * *, void *);
3256 printf("res = %d\n", __builtin_constant_p(1));
3257 printf("res = %d\n", __builtin_constant_p(1 + 2));
3258 printf("res = %d\n", __builtin_constant_p(&constant_p_var
));
3259 printf("res = %d\n", __builtin_constant_p(constant_p_var
));
3260 printf("res = %d\n", __builtin_constant_p(100000 / constant_p_var
));
3263 i
= __builtin_choose_expr (1 != 0, ll
, s
);
3264 printf("bce: %d\n", i
);
3265 i
= __builtin_choose_expr (1 != 1, ll
, s
);
3266 printf("bce: %d\n", i
);
3267 i
= sizeof (__builtin_choose_expr (1, ll
, s
));
3268 printf("bce: %d\n", i
);
3269 i
= sizeof (__builtin_choose_expr (0, ll
, s
));
3270 printf("bce: %d\n", i
);
3272 printf("bera: %p\n", __builtin_extract_return_addr((void*)43));
3276 extern int __attribute__((weak
)) weak_f1(void);
3277 extern int __attribute__((weak
)) weak_f2(void);
3278 extern int weak_f3(void);
3279 extern int __attribute__((weak
)) weak_v1
;
3280 extern int __attribute__((weak
)) weak_v2
;
3283 extern int (*weak_fpa
)() __attribute__((weak
));
3284 extern int __attribute__((weak
)) (*weak_fpb
)();
3285 extern __attribute__((weak
)) int (*weak_fpc
)();
3287 extern int weak_asm_f1(void) asm("weak_asm_f1x") __attribute((weak
));
3288 extern int __attribute((weak
)) weak_asm_f2(void) asm("weak_asm_f2x") ;
3289 extern int __attribute((weak
)) weak_asm_f3(void) asm("weak_asm_f3x") __attribute((weak
));
3290 extern int weak_asm_v1
asm("weak_asm_v1x") __attribute((weak
));
3291 extern int __attribute((weak
)) weak_asm_v2
asm("weak_asm_v2x") ;
3292 extern int __attribute((weak
)) weak_asm_v3(void) asm("weak_asm_v3x") __attribute((weak
));
3294 static const size_t dummy
= 0;
3295 extern __typeof(dummy
) weak_dummy1
__attribute__((weak
, alias("dummy")));
3296 extern __typeof(dummy
) __attribute__((weak
, alias("dummy"))) weak_dummy2
;
3297 extern __attribute__((weak
, alias("dummy"))) __typeof(dummy
) weak_dummy3
;
3299 int some_lib_func(void);
3300 int dummy_impl_of_slf(void) { return 444; }
3301 int some_lib_func(void) __attribute__((weak
, alias("dummy_impl_of_slf")));
3303 int weak_toolate() __attribute__((weak
));
3304 int weak_toolate() { return 0; }
3306 void __attribute__((weak
)) weak_test(void)
3308 printf("weak_f1=%d\n", weak_f1
? weak_f1() : 123);
3309 printf("weak_f2=%d\n", weak_f2
? weak_f2() : 123);
3310 printf("weak_f3=%d\n", weak_f3
? weak_f3() : 123);
3311 printf("weak_v1=%d\n",&weak_v1
? weak_v1
: 123);
3312 printf("weak_v2=%d\n",&weak_v2
? weak_v2
: 123);
3313 printf("weak_v3=%d\n",&weak_v3
? weak_v3
: 123);
3315 printf("weak_fpa=%d\n",&weak_fpa
? weak_fpa() : 123);
3316 printf("weak_fpb=%d\n",&weak_fpb
? weak_fpb() : 123);
3317 printf("weak_fpc=%d\n",&weak_fpc
? weak_fpc() : 123);
3319 printf("weak_asm_f1=%d\n", weak_asm_f1
!= NULL
);
3320 printf("weak_asm_f2=%d\n", weak_asm_f2
!= NULL
);
3321 printf("weak_asm_f3=%d\n", weak_asm_f3
!= NULL
);
3322 printf("weak_asm_v1=%d\n",&weak_asm_v1
!= NULL
);
3323 printf("weak_asm_v2=%d\n",&weak_asm_v2
!= NULL
);
3324 printf("weak_asm_v3=%d\n",&weak_asm_v3
!= NULL
);
3325 printf("some_lib_func=%d\n", &some_lib_func
? some_lib_func() : 0);
3328 int __attribute__((weak
)) weak_f2() { return 222; }
3329 int __attribute__((weak
)) weak_f3() { return 333; }
3330 int __attribute__((weak
)) weak_v2
= 222;
3331 int __attribute__((weak
)) weak_v3
= 333;
3334 void const_func(const int a
)
3338 void const_warn_test(void)
3347 int getme (struct condstruct
*s
, int i
)
3349 int i1
= (i
== 0 ? 0 : s
)->i
;
3350 int i2
= (i
== 0 ? s
: 0)->i
;
3351 int i3
= (i
== 0 ? (void*)0 : s
)->i
;
3352 int i4
= (i
== 0 ? s
: (void*)0)->i
;
3353 return i1
+ i2
+ i3
+ i4
;
3362 struct global_data global_data
;
3364 int global_data_getstuff (int *, int);
3366 void global_data_callit (int i
)
3368 *global_data
.b
[i
] = global_data_getstuff (global_data
.b
[i
], 1);
3371 int global_data_getstuff (int *p
, int i
)
3376 void global_data_test (void)
3378 global_data
.a
[0] = 42;
3379 global_data
.b
[0] = &global_data
.a
[0];
3380 global_data_callit (0);
3381 printf ("%d\n", global_data
.a
[0]);
3386 unsigned char fill
: 3;
3387 unsigned char b1
: 1;
3388 unsigned char b2
: 1;
3389 unsigned char fill2
: 3;
3392 int glob1
, glob2
, glob3
;
3394 void compare_comparisons (struct cmpcmpS
*s
)
3396 if (s
->b1
!= (glob1
== glob2
)
3397 || (s
->b2
!= (glob1
== glob3
)))
3398 printf ("comparing comparisons broken\n");
3401 void cmp_comparison_test(void)
3405 glob1
= 42; glob2
= 42;
3408 compare_comparisons (&s
);
3411 int fcompare (double a
, double b
, int code
)
3414 case 0: return a
== b
;
3415 case 1: return a
!= b
;
3416 case 2: return a
< b
;
3417 case 3: return a
>= b
;
3418 case 4: return a
> b
;
3419 case 5: return a
<= b
;
3423 void math_cmp_test(void)
3425 double nan
= 0.0/0.0;
3429 #define bug(a,b,op,iop,part) printf("Test broken: %s %s %s %s %d\n", #a, #b, #op, #iop, part)
3431 /* This asserts that "a op b" is _not_ true, but "a iop b" is true.
3432 And it does this in various ways so that all code generation paths
3433 are checked (generating inverted tests, or non-inverted tests, or
3434 producing a 0/1 value without jumps (that's done in the fcompare
3436 #define FCMP(a,b,op,iop,code) \
3437 if (fcompare (a,b,code)) \
3438 bug (a,b,op,iop,1); \
3440 bug (a,b,op,iop,2); \
3444 bug (a,b,op,iop,3); \
3445 if ((a op b) || comp) \
3446 bug (a,b,op,iop,4); \
3447 if ((a iop b) || comp) \
3452 /* Equality tests. */
3453 FCMP(nan
, nan
, ==, !=, 0);
3454 FCMP(one
, two
, ==, !=, 0);
3455 FCMP(one
, one
, !=, ==, 1);
3456 /* Non-equality is a bit special. */
3457 if (!fcompare (nan
, nan
, 1))
3458 bug (nan
, nan
, !=, ==, 6);
3460 /* Relational tests on numbers. */
3461 FCMP(two
, one
, <, >=, 2);
3462 FCMP(one
, two
, >=, <, 3);
3463 FCMP(one
, two
, >, <=, 4);
3464 FCMP(two
, one
, <=, >, 5);
3466 /* Relational tests on NaNs. Note that the inverse op here is
3467 always !=, there's no operator in C that is equivalent to !(a < b),
3468 when NaNs are involved, same for the other relational ops. */
3469 FCMP(nan
, nan
, <, !=, 2);
3470 FCMP(nan
, nan
, >=, !=, 3);
3471 FCMP(nan
, nan
, >, !=, 4);
3472 FCMP(nan
, nan
, <=, !=, 5);
3475 double get100 () { return 100.0; }
3477 void callsave_test(void)
3479 #if defined __i386__ || defined __x86_64__ || defined __arm__
3480 int i
, s
; double *d
; double t
;
3481 s
= sizeof (double);
3482 printf ("callsavetest: %d\n", s
);
3483 d
= alloca (sizeof(double));
3485 /* x86-64 had a bug were the next call to get100 would evict
3486 the lvalue &d[0] as VT_LLOCAL, and the reload would be done
3487 in int type, not pointer type. When alloca returns a pointer
3488 with the high 32 bit set (which is likely on x86-64) the access
3489 generates a segfault. */
3490 i
= d
[0] > get100 ();
3496 void bfa3(ptrdiff_t str_offset
)
3498 printf("bfa3: %s\n", (char *)__builtin_frame_address(3) + str_offset
);
3500 void bfa2(ptrdiff_t str_offset
)
3502 printf("bfa2: %s\n", (char *)__builtin_frame_address(2) + str_offset
);
3505 void bfa1(ptrdiff_t str_offset
)
3507 printf("bfa1: %s\n", (char *)__builtin_frame_address(1) + str_offset
);
3511 void builtin_frame_address_test(void)
3513 /* builtin_frame_address fails on ARM with gcc which make test3 fail */
3515 char str
[] = "__builtin_frame_address";
3516 char *fp0
= __builtin_frame_address(0);
3518 printf("str: %s\n", str
);
3523 char via_volatile (char i
)
3530 struct __attribute__((__packed__
)) Spacked
{
3535 struct Spacked spacked
;
3536 typedef struct __attribute__((__packed__
)) {
3543 /* This doesn't work for now. Requires adjusting field offsets/sizes
3544 after parsing the struct members. */
3545 typedef struct Spacked3_s
{
3549 } __attribute__((__packed__
)) Spacked3
;
3552 void attrib_test(void)
3554 printf("attr: %d %d %d %d\n", sizeof(struct Spacked
),
3555 sizeof(spacked
), sizeof(Spacked2
), sizeof(spacked2
));
3557 printf("attr: %d %d\n", sizeof(Spacked3
), sizeof(spacked3
));
3560 extern __attribute__((__unused__
)) char * __attribute__((__unused__
)) *
3561 strange_attrib_placement (void);
3563 void * __attribute__((__unused__
)) get_void_ptr (void *a
)