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
);
1029 struct __attribute__((aligned(16))) aligntest5
1036 } __attribute__((aligned(16)));
1041 struct aligntest5 altest5
[2];
1042 struct aligntest6 altest6
[2];
1044 /* altest7 is correctly aligned to 16 bytes also with TCC,
1045 but __alignof__ returns the wrong result (4) because we
1046 can't store the alignment yet when specified on symbols
1047 directly (it's stored in the type so we'd need to make
1049 struct aligntest7 altest7[2] __attribute__((aligned(16)));*/
1054 } __attribute__((aligned(4096)));
1057 unsigned long flags
;
1065 unsigned long index
;
1069 unsigned long counters
;
1083 unsigned long compound_head
;
1084 unsigned int compound_dtor
;
1085 unsigned int compound_order
;
1088 } __attribute__((aligned(2 * sizeof(long))));
1090 typedef unsigned long long __attribute__((aligned(4))) unaligned_u64
;
1093 unsigned int buf_nr
;
1094 unaligned_u64 start_lba
;
1097 struct aligntest10
{
1098 unsigned int buf_nr
;
1099 unsigned long long start_lba
;
1108 printf("struct:\n");
1109 printf("sizes: %d %d %d %d\n",
1110 sizeof(struct struct1
),
1111 sizeof(struct struct2
),
1112 sizeof(union union1
),
1113 sizeof(union union2
));
1114 printf("offsets: %d\n", (int)((char*)&st1
.u
.v1
- (char*)&st1
));
1118 printf("st1: %d %d %d\n",
1119 st1
.f1
, st1
.f2
, st1
.f3
);
1122 printf("union1: %d\n", st1
.u
.v1
);
1125 printf("union2: %d\n", u
.w1
);
1130 printf("st2: %d %d %d\n",
1131 s
->f1
, s
->f2
, s
->f3
);
1132 printf("str_addr=%x\n", (int)st1
.str
- (int)&st1
.f1
);
1134 /* align / size tests */
1135 printf("aligntest1 sizeof=%d alignof=%d\n",
1136 sizeof(struct aligntest1
), __alignof__(struct aligntest1
));
1137 printf("aligntest2 sizeof=%d alignof=%d\n",
1138 sizeof(struct aligntest2
), __alignof__(struct aligntest2
));
1139 printf("aligntest3 sizeof=%d alignof=%d\n",
1140 sizeof(struct aligntest3
), __alignof__(struct aligntest3
));
1141 printf("aligntest4 sizeof=%d alignof=%d\n",
1142 sizeof(struct aligntest4
), __alignof__(struct aligntest4
));
1143 printf("aligntest5 sizeof=%d alignof=%d\n",
1144 sizeof(struct aligntest5
), __alignof__(struct aligntest5
));
1145 printf("aligntest6 sizeof=%d alignof=%d\n",
1146 sizeof(struct aligntest6
), __alignof__(struct aligntest6
));
1147 printf("aligntest7 sizeof=%d alignof=%d\n",
1148 sizeof(struct aligntest7
), __alignof__(struct aligntest7
));
1149 printf("aligntest8 sizeof=%d alignof=%d\n",
1150 sizeof(struct aligntest8
), __alignof__(struct aligntest8
));
1151 printf("aligntest9 sizeof=%d alignof=%d\n",
1152 sizeof(struct aligntest9
), __alignof__(struct aligntest9
));
1153 printf("aligntest10 sizeof=%d alignof=%d\n",
1154 sizeof(struct aligntest10
), __alignof__(struct aligntest10
));
1155 printf("altest5 sizeof=%d alignof=%d\n",
1156 sizeof(altest5
), __alignof__(altest5
));
1157 printf("altest6 sizeof=%d alignof=%d\n",
1158 sizeof(altest6
), __alignof__(altest6
));
1159 /*printf("altest7 sizeof=%d alignof=%d\n",
1160 sizeof(altest7), __alignof__(altest7));*/
1162 /* empty structures (GCC extension) */
1163 printf("sizeof(struct empty) = %d\n", sizeof(struct empty
));
1164 printf("alignof(struct empty) = %d\n", __alignof__(struct empty
));
1166 printf("Large: sizeof=%d\n", sizeof(ls
));
1167 memset(&ls
, 0, sizeof(ls
));
1168 ls
.compound_head
= 42;
1169 printf("Large: offsetof(compound_head)=%d\n", (int)((char*)&ls
.compound_head
- (char*)&ls
));
1172 /* XXX: depend on endianness */
1173 void char_short_test()
1177 printf("char_short:\n");
1181 printf("s8=%d %d\n",
1182 *(char *)&var1
, *(char *)&var2
);
1183 printf("u8=%d %d\n",
1184 *(unsigned char *)&var1
, *(unsigned char *)&var2
);
1185 printf("s16=%d %d\n",
1186 *(short *)&var1
, *(short *)&var2
);
1187 printf("u16=%d %d\n",
1188 *(unsigned short *)&var1
, *(unsigned short *)&var2
);
1189 printf("s32=%d %d\n",
1190 *(int *)&var1
, *(int *)&var2
);
1191 printf("u32=%d %d\n",
1192 *(unsigned int *)&var1
, *(unsigned int *)&var2
);
1193 *(char *)&var1
= 0x08;
1194 printf("var1=%x\n", var1
);
1195 *(short *)&var1
= 0x0809;
1196 printf("var1=%x\n", var1
);
1197 *(int *)&var1
= 0x08090a0b;
1198 printf("var1=%x\n", var1
);
1201 /******************/
1203 typedef struct Sym
{
1211 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
1212 #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
1214 static int toupper1(int a
)
1219 static unsigned int calc_vm_flags(unsigned int prot
)
1221 unsigned int prot_bits
;
1222 /* This used to segfault in some revisions: */
1223 prot_bits
= ((0x1==0x00000001)?(prot
&0x1):(prot
&0x1)?0x00000001:0);
1229 int *s
, a
, b
, t
, f
, i
;
1233 printf("!s=%d\n", !s
);
1237 printf("a=%d\n", a
);
1239 printf("a=%d %d %d\n", 0 || 0, 0 || 1, 1 || 1);
1240 printf("a=%d %d %d\n", 0 && 0, 0 && 1, 1 && 1);
1241 printf("a=%d %d\n", 1 ? 1 : 0, 0 ? 1 : 0);
1256 printf("b=%d\n", a
+ (0 ? 1 : a
/ 2));
1258 /* test register spilling */
1261 a
= (a
+ b
) * ((a
< b
) ?
1262 ((b
- a
) * (a
- b
)): a
+ b
);
1263 printf("a=%d\n", a
);
1265 /* test complex || or && expressions */
1269 printf("exp=%d\n", f
== (32 <= a
&& a
<= 3));
1270 printf("r=%d\n", (t
|| f
) + (t
&& f
));
1275 int aspect_native
= 65536;
1276 double bfu_aspect
= 1.0;
1278 for(aspect_on
= 0; aspect_on
< 2; aspect_on
++) {
1279 aspect
=aspect_on
?(aspect_native
*bfu_aspect
+0.5):65535UL;
1280 printf("aspect=%d\n", aspect
);
1284 /* test ? : GCC extension */
1286 static int v1
= 34 ? : -1; /* constant case */
1287 static int v2
= 0 ? : -1; /* constant case */
1290 printf("%d %d\n", v1
, v2
);
1291 printf("%d %d\n", a
- 30 ? : a
* 2, a
+ 1 ? : a
* 2);
1294 /* again complex expression */
1295 for(i
=0;i
<256;i
++) {
1296 if (toupper1 (i
) != TOUPPER (i
))
1297 printf("error %d\n", i
);
1299 printf ("bits = 0x%x\n", calc_vm_flags (0x1));
1302 extern int undefined_function(void);
1303 extern int defined_function(void);
1305 static inline void refer_to_undefined(void)
1307 undefined_function();
1310 void optimize_out(void)
1312 int i
= 0 ? undefined_function() : defined_function();
1313 printf ("oo:%d\n", i
);
1314 int j
= 1 ? defined_function() : undefined_function();
1315 printf ("oo:%d\n", j
);
1317 printf("oo:%d\n", undefined_function());
1319 printf("oo:%d\n", defined_function());
1321 printf("oo:%d\n", defined_function());
1323 printf("oo:%d\n", undefined_function());
1325 printf("oow:%d\n", defined_function());
1327 printf("oow:%d\n", undefined_function());
1330 /* Following is a switch without {} block intentionally. */
1333 printf ("oos:%d\n", defined_function());
1334 /* The following break shouldn't lead to disabled code after
1338 printf ("ool1:%d\n", defined_function());
1339 /* Same for the other types of loops. */
1343 printf ("ool2:%d\n", defined_function());
1346 printf ("ool3:%d\n", defined_function());
1347 /* Normal {} blocks without controlling statements
1348 shouldn't reactivate code emission */
1353 printf ("ool4:%d\n", undefined_function());
1358 break; /* this break shouldn't disable code outside the if. */
1359 printf("ool5:%d\n", defined_function());
1369 printf("ool6:%d\n", defined_function());
1373 /* Test that constants in logical && are optimized: */
1374 i
= 0 && undefined_function();
1375 i
= defined_function() && 0 && undefined_function();
1376 if (0 && undefined_function())
1377 undefined_function();
1378 if (defined_function() && 0)
1379 undefined_function();
1381 undefined_function();
1382 if (defined_function() && 0 && undefined_function())
1383 undefined_function();
1384 /* The same for || : */
1385 i
= 1 || undefined_function();
1386 i
= defined_function() || 1 || undefined_function();
1387 if (1 || undefined_function())
1390 undefined_function();
1391 if (defined_function() || 1)
1394 undefined_function();
1398 undefined_function();
1399 if (defined_function() || 1 || undefined_function())
1402 undefined_function();
1404 if (defined_function() && 0)
1405 refer_to_undefined();
1409 printf ("oor:%d\n", undefined_function());
1412 int defined_function(void)
1418 /* GCC accepts that */
1419 static int tab_reinit
[];
1420 static int tab_reinit
[10];
1422 //int cinit1; /* a global variable can be defined several times without error ! */
1426 int *cinit2
= (int []){3, 2, 1};
1428 void compound_literal_test(void)
1433 printf("compound_test:\n");
1435 p
= (int []){1, 2, 3};
1437 printf(" %d", p
[i
]);
1441 printf("%d", cinit2
[i
]);
1445 printf("q1=%s\n", q
);
1447 q
= (char *){ "tralala2" };
1448 printf("q2=%s\n", q
);
1451 printf("q3=%s\n", q3
);
1453 q
= (char []){ "tralala3" };
1454 printf("q4=%s\n", q
);
1457 p
= (int []){1, 2, cinit1
+ 3};
1459 printf(" %d", p
[i
]);
1463 p
= (int []){1, 2, 4 + i
};
1464 printf("%d %d %d\n",
1486 printf("kr_test:\n");
1487 printf("func1=%d\n", kr_func1(3, 4));
1488 printf("func2=%d\n", kr_func2(3, 4));
1495 tab
= (char*)malloc(20);
1512 /* structure assignment tests */
1518 struct structa1 ssta1
;
1520 void struct_assign_test1(struct structa1 s1
, int t
, float f
)
1522 printf("%d %d %d %f\n", s1
.f1
, s1
.f2
, t
, f
);
1525 struct structa1
struct_assign_test2(struct structa1 s1
, int t
)
1532 void struct_assign_test(void)
1535 struct structa1 lsta1
, lsta2
;
1542 printf("struct_assign_test:\n");
1546 printf("%d %d\n", s
.lsta1
.f1
, s
.lsta1
.f2
);
1548 printf("%d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1553 struct_assign_test1(ps
->lsta2
, 3, 4.5);
1555 printf("before call: %d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1556 ps
->lsta2
= struct_assign_test2(ps
->lsta2
, ps
->i
);
1557 printf("after call: %d %d\n", ps
->lsta2
.f1
, ps
->lsta2
.f2
);
1562 /* XXX: we should allow this even without braces */
1563 { struct_assign_test
}
1565 printf("%d\n", struct_assign_test
== t
[0].elem
);
1568 /* casts to short/char */
1570 void cast1(char a
, short b
, unsigned char c
, unsigned short d
)
1572 printf("%d %d %d %d\n", a
, b
, c
, d
);
1586 p
-= 0x700000000042;
1588 printf("cast_test:\n");
1592 printf("%d %d %d %d\n",
1595 (unsigned char)(a
+ 1),
1596 (unsigned short)(a
+ 1));
1597 printf("%d %d %d %d\n",
1600 (unsigned char)0xfffff,
1601 (unsigned short)0xfffff);
1603 a
= (bcast
= 128) + 1;
1605 a
= (scast
= 65536) + 1;
1608 printf("sizeof(c) = %d, sizeof((int)c) = %d\n", sizeof(c
), sizeof((int)c
));
1610 /* test cast from unsigned to signed short to int */
1613 printf("((unsigned)(short)0x%08x) = 0x%08x\n", b
, d
);
1616 printf("((unsigned)(char)0x%08x) = 0x%08x\n", b
, d
);
1618 /* test implicit int casting for array accesses */
1622 printf("%d %d\n", tab
[0], tab
[1]);
1624 /* test implicit casting on some operators */
1625 printf("sizeof(+(char)'a') = %d\n", sizeof(+(char)'a'));
1626 printf("sizeof(-(char)'a') = %d\n", sizeof(-(char)'a'));
1627 printf("sizeof(~(char)'a') = %d\n", sizeof(-(char)'a'));
1629 /* from pointer to integer types */
1630 printf("%d %d %ld %ld %lld %lld\n",
1631 (int)p
, (unsigned int)p
,
1632 (long)p
, (unsigned long)p
,
1633 (long long)p
, (unsigned long long)p
);
1635 /* from integers to pointers */
1636 printf("%p %p %p %p\n",
1637 (void *)a
, (void *)b
, (void *)c
, (void *)d
);
1640 /* initializers tests */
1641 struct structinit1
{
1650 int sinit3
[3] = { 1, 2, {{3}}, };
1651 int sinit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1652 int sinit5
[3][2] = { 1, 2, 3, 4, 5, 6 };
1653 int sinit6
[] = { 1, 2, 3 };
1654 int sinit7
[] = { [2] = 3, [0] = 1, 2 };
1655 char sinit8
[] = "hello" "trala";
1657 struct structinit1 sinit9
= { 1, 2, 3 };
1658 struct structinit1 sinit10
= { .f2
= 2, 3, .f1
= 1 };
1659 struct structinit1 sinit11
= { .f2
= 2, 3, .f1
= 1,
1667 char *sinit12
= "hello world";
1673 char sinit14
[10] = { "abc" };
1674 int sinit15
[3] = { sizeof(sinit15
), 1, 2 };
1676 struct { int a
[3], b
; } sinit16
[] = { { 1 }, 2 };
1692 struct complexinit0
{
1697 struct complexinit
{
1699 const struct complexinit0
*b
;
1702 const static struct complexinit cix
[] = {
1705 .b
= (const struct complexinit0
[]) {
1713 struct complexinit2
{
1718 struct complexinit2 cix20
;
1720 struct complexinit2 cix21
= {
1722 .b
= { 3001, 3002, 3003 }
1725 struct complexinit2 cix22
= {
1727 .b
= { 4001, 4002, 4003, 4004, 4005, 4006 }
1730 typedef int arrtype1
[];
1731 arrtype1 sinit19
= {1};
1732 arrtype1 sinit20
= {2,3};
1733 typedef int arrtype2
[3];
1734 arrtype2 sinit21
= {4};
1735 arrtype2 sinit22
= {5,6,7};
1737 /* Address comparisons of non-weak symbols with zero can be const-folded */
1738 int sinit23
[2] = { "astring" ? sizeof("astring") : -1,
1739 &sinit23
? 42 : -1 };
1741 void init_test(void)
1745 int linit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1746 int linit6
[] = { 1, 2, 3 };
1748 char linit8
[] = "hello" "trala";
1749 int linit12
[10] = { 1, 2 };
1750 int linit13
[10] = { 1, 2, [7] = 3, [3] = 4, };
1751 char linit14
[10] = "abc";
1752 int linit15
[10] = { linit1
, linit1
+ 1, [6] = linit1
+ 2, };
1753 struct linit16
{ int a1
, a2
, a3
, a4
; } linit16
= { 1, .a3
= 2 };
1754 int linit17
= sizeof(linit17
);
1756 /* Addresses on non-weak symbols are non-zero, but not the access itself */
1757 int linit18
[2] = {&zero
? 1 : -1, zero
? -1 : 1 };
1759 printf("init_test:\n");
1761 printf("sinit1=%d\n", sinit1
);
1762 printf("sinit2=%d\n", sinit2
);
1763 printf("sinit3=%d %d %d %d\n",
1769 printf("sinit6=%d\n", sizeof(sinit6
));
1770 printf("sinit7=%d %d %d %d\n",
1776 printf("sinit8=%s\n", sinit8
);
1777 printf("sinit9=%d %d %d\n",
1782 printf("sinit10=%d %d %d\n",
1787 printf("sinit11=%d %d %d %d %d %d\n",
1798 printf("[%d][%d] = %d %d %d\n",
1799 i
, j
, sinit4
[i
][j
], sinit5
[i
][j
], linit4
[i
][j
]);
1800 printf("linit1=%d\n", linit1
);
1801 printf("linit2=%d\n", linit2
);
1802 printf("linit6=%d\n", sizeof(linit6
));
1803 printf("linit8=%d %s\n", sizeof(linit8
), linit8
);
1805 printf("sinit12=%s\n", sinit12
);
1806 printf("sinit13=%d %s %s %s\n",
1811 printf("sinit14=%s\n", sinit14
);
1813 for(i
=0;i
<10;i
++) printf(" %d", linit12
[i
]);
1815 for(i
=0;i
<10;i
++) printf(" %d", linit13
[i
]);
1817 for(i
=0;i
<10;i
++) printf(" %d", linit14
[i
]);
1819 for(i
=0;i
<10;i
++) printf(" %d", linit15
[i
]);
1821 printf("%d %d %d %d\n",
1826 /* test that initialisation is done after variable declare */
1827 printf("linit17=%d\n", linit17
);
1828 printf("sinit15=%d\n", sinit15
[0]);
1829 printf("sinit16=%d %d\n", sinit16
[0].a
[0], sinit16
[1].a
[0]);
1830 printf("sinit17=%s %d %s %d\n",
1831 sinit17
[0].s
, sinit17
[0].len
,
1832 sinit17
[1].s
, sinit17
[1].len
);
1834 printf("%x ", sinit18
[i
]);
1836 /* complex init check */
1837 printf("cix: %d %d %d %d %d %d %d\n",
1839 cix
[0].b
[0].a
, cix
[0].b
[0].b
,
1840 cix
[0].b
[1].a
, cix
[0].b
[1].b
,
1841 cix
[0].b
[2].a
, cix
[0].b
[2].b
);
1842 printf("cix2: %d %d\n", cix21
.b
[2], cix22
.b
[5]);
1843 printf("sizeof cix20 %d, cix21 %d, sizeof cix22 %d\n", sizeof cix20
, sizeof cix21
, sizeof cix22
);
1845 printf("arrtype1: %d %d %d\n", sinit19
[0], sinit20
[0], sinit20
[1]);
1846 printf("arrtype2: %d %d\n", sizeof(sinit19
), sizeof(sinit20
));
1847 printf("arrtype3: %d %d %d\n", sinit21
[0], sinit21
[1], sinit21
[2]);
1848 printf("arrtype4: %d %d %d\n", sinit22
[0], sinit22
[1], sinit22
[2]);
1849 printf("arrtype5: %d %d\n", sizeof(sinit21
), sizeof(sinit22
));
1850 printf("arrtype6: %d\n", sizeof(arrtype2
));
1852 printf("sinit23= %d %d\n", sinit23
[0], sinit23
[1]);
1853 printf("linit18= %d %d\n", linit18
[0], linit18
[1]);
1856 void switch_uc(unsigned char uc
)
1869 printf("ucsw: broken!\n");
1873 void switch_sc(signed char sc
)
1886 printf("scsw: broken!\n");
1893 unsigned long long ull
;
1918 for (i
= 1; i
<= 5; i
++) {
1919 ull
= (unsigned long long)i
<< 61;
1922 printf("ullsw:1\n");
1925 printf("ullsw:2\n");
1928 printf("ullsw:3\n");
1931 printf("ullsw:4\n");
1934 printf("ullsw:5\n");
1937 printf("ullsw: broken!\n");
1941 for (i
= 1; i
<= 5; i
++) {
1942 ll
= (long long)i
<< 61;
1960 printf("llsw: broken!\n");
1964 for (i
= -5; i
<= 5; i
++) {
1965 switch_uc((unsigned char)i
);
1968 for (i
= -5; i
<= 5; i
++) {
1969 switch_sc ((signed char)i
);
1973 /* ISOC99 _Bool type */
1974 void c99_bool_test(void)
1980 printf("bool_test:\n");
1981 printf("sizeof(_Bool) = %d\n", sizeof(_Bool
));
1983 printf("cast: %d %d %d\n", (_Bool
)10, (_Bool
)0, (_Bool
)a
);
1985 printf("b = %d\n", b
);
1987 printf("b = %d\n", b
);
1991 void bitfield_test(void)
2003 unsigned int f5
: 7;
2005 printf("bitfield_test:");
2006 printf("sizeof(st1) = %d\n", sizeof(st1
));
2015 printf("%d %d %d %d %d\n",
2016 st1
.f1
, st1
.f2
, st1
.f3
, st1
.f4
, st1
.f5
);
2019 printf("%d %d\n", sa
, ca
);
2023 printf("st1.f1 == -1\n");
2025 printf("st1.f1 != -1\n");
2027 printf("st1.f2 == -1\n");
2029 printf("st1.f2 != -1\n");
2031 /* bit sizes below must be bigger than 32 since GCC doesn't allow
2032 long-long bitfields whose size is not bigger than int */
2037 unsigned long long f3
: 38;
2039 st2
.f1
= 0x123456789ULL
;
2041 st2
.f2
= (long long)a
<< 25;
2044 printf("%lld %lld %lld\n", st2
.f1
, st2
.f2
, st2
.f3
);
2048 #define FLOAT_FMT "%f\n"
2050 /* x86's float isn't compatible with GCC */
2051 #define FLOAT_FMT "%.5f\n"
2054 /* declare strto* functions as they are C99 */
2055 double strtod(const char *nptr
, char **endptr
);
2058 float strtof(const char *nptr
, char **endptr
) {return (float)strtod(nptr
, endptr
);}
2059 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
) {return (LONG_DOUBLE
)strtod(nptr
, endptr
);}
2061 float strtof(const char *nptr
, char **endptr
);
2062 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
);
2065 #define FTEST(prefix, typename, type, fmt)\
2066 void prefix ## cmp(type a, type b)\
2068 printf("%d %d %d %d %d %d\n",\
2075 printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\
2083 printf(fmt "\n", ++a);\
2084 printf(fmt "\n", a++);\
2085 printf(fmt "\n", a);\
2087 printf("%d %d\n", !a, !b);\
2089 void prefix ## fcast(type a)\
2097 unsigned long long llua;\
2102 printf("ftof: %f %f %Lf\n", fa, da, la);\
2104 llia = (long long)a;\
2105 a = (a >= 0) ? a : -a;\
2106 ua = (unsigned int)a;\
2107 llua = (unsigned long long)a;\
2108 printf("ftoi: %d %u %lld %llu\n", ia, ua, llia, llua);\
2111 llia = -0x123456789012345LL;\
2112 llua = 0xf123456789012345LLU;\
2114 printf("itof: " fmt "\n", b);\
2116 printf("utof: " fmt "\n", b);\
2118 printf("lltof: " fmt "\n", b);\
2120 printf("ulltof: " fmt "\n", b);\
2123 float prefix ## retf(type a) { return a; }\
2124 double prefix ## retd(type a) { return a; }\
2125 LONG_DOUBLE prefix ## retld(type a) { return a; }\
2127 void prefix ## call(void)\
2129 printf("float: " FLOAT_FMT, prefix ## retf(42.123456789));\
2130 printf("double: %f\n", prefix ## retd(42.123456789));\
2131 printf("long double: %Lf\n", prefix ## retld(42.123456789));\
2132 printf("strto%s: %f\n", #prefix, (double)strto ## prefix("1.2", NULL));\
2135 void prefix ## signed_zeros(void) \
2137 type x = 0.0, y = -0.0, n, p;\
2139 printf ("Test 1.0 / x != 1.0 / y returns %d (should be 1).\n",\
2140 1.0 / x != 1.0 / y);\
2142 printf ("x != y; this is wrong!\n");\
2146 printf ("Test 1.0 / x != 1.0 / -x returns %d (should be 1).\n",\
2147 1.0 / x != 1.0 / n);\
2149 printf ("x != -x; this is wrong!\n");\
2153 printf ("Test 1.0 / x != 1.0 / +y returns %d (should be 1).\n",\
2154 1.0 / x != 1.0 / p);\
2156 printf ("x != +y; this is wrong!\n");\
2159 printf ("Test 1.0 / x != 1.0 / -y returns %d (should be 0).\n",\
2160 1.0 / x != 1.0 / p);\
2162 printf ("x != -y; this is wrong!\n");\
2164 void prefix ## test(void)\
2166 printf("testing '%s'\n", #typename);\
2167 prefix ## cmp(1, 2.5);\
2168 prefix ## cmp(2, 1.5);\
2169 prefix ## cmp(1, 1);\
2170 prefix ## fcast(234.6);\
2171 prefix ## fcast(-2334.6);\
2173 prefix ## signed_zeros();\
2176 FTEST(f
, float, float, "%f")
2177 FTEST(d
, double, double, "%f")
2178 FTEST(ld
, long double, LONG_DOUBLE
, "%Lf")
2180 double ftab1
[3] = { 1.2, 3.4, -5.6 };
2183 void float_test(void)
2185 #if !defined(__arm__) || defined(__ARM_PCS_VFP)
2191 printf("float_test:\n");
2192 printf("sizeof(float) = %d\n", sizeof(float));
2193 printf("sizeof(double) = %d\n", sizeof(double));
2194 printf("sizeof(long double) = %d\n", sizeof(LONG_DOUBLE
));
2198 printf("%f %f %f\n", ftab1
[0], ftab1
[1], ftab1
[2]);
2199 printf("%f %f %f\n", 2.12, .5, 2.3e10
);
2200 // printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
2202 printf("da=%f\n", da
);
2204 printf("fa=%f\n", fa
);
2207 printf("da = %f\n", da
);
2210 printf("db = %f\n", db
);
2219 return fib(n
-1) + fib(n
-2);
2232 printf("funcptr:\n");
2239 /* more complicated pointer computation */
2242 printf("sizeof1 = %d\n", sizeof(funcptr_test
));
2243 printf("sizeof2 = %d\n", sizeof funcptr_test
);
2244 printf("sizeof3 = %d\n", sizeof(&funcptr_test
));
2245 printf("sizeof4 = %d\n", sizeof &funcptr_test
);
2254 void lloptest(long long a
, long long b
)
2256 unsigned long long ua
, ub
;
2261 printf("arith: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2267 printf("arith1: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2273 printf("bin: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2279 printf("test: %d %d %d %d %d %d\n",
2287 printf("utest: %d %d %d %d %d %d\n",
2298 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2299 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
++, b
++);
2300 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", --a
, --b
);
2301 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2303 printf("not: %d %d %d %d\n", !a
, !ua
, !b
, !ub
);
2306 void llshift(long long a
, int b
)
2308 printf("shift: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2309 (unsigned long long)a
>> b
,
2312 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2313 (unsigned long long)a
>> 3,
2316 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2317 (unsigned long long)a
>> 35,
2327 long long la
, lb
, lc
;
2328 unsigned long long ula
, ulb
, ulc
;
2331 la
= (la
<< 20) | 0x12345;
2333 printf("la=" LONG_LONG_FORMAT
" ula=" ULONG_LONG_FORMAT
"\n", la
, ula
);
2338 printf("lltof: %f %f %Lf\n", fa
, da
, lda
);
2343 printf("ftoll: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", la
, lb
, lc
);
2348 printf("ulltof: %f %f %Lf\n", fa
, da
, lda
);
2353 printf("ftoull: " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
"\n", ula
, ulb
, ulc
);
2356 long long llfunc1(int a
)
2366 long long int value(struct S
*v
)
2368 return ((long long int)v
->item
);
2371 long long llfunc2(long long x
, long long y
, int z
)
2376 void longlong_test(void)
2381 printf("longlong_test:\n");
2382 printf("sizeof(long long) = %d\n", sizeof(long long));
2387 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2388 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %Lx\n",
2392 0x1234567812345679);
2394 printf(LONG_LONG_FORMAT
"\n", a
);
2397 lloptest(0xff, 0x1234);
2398 b
= 0x72345678 << 10;
2402 b
= 0x72345678LL
<< 10;
2413 /* long long reg spill test */
2418 printf("%lld\n", value(&a
));
2420 lloptest(0x80000000, 0);
2423 long long *p
, v
, **pp
;
2427 printf("another long long spill test : %lld\n", *p
);
2430 v
= llfunc2(**pp
, **pp
, ia
);
2431 printf("a long long function (arm-)reg-args test : %lld\n", v
);
2435 printf("%d %d %d %d\n", a
> b
, a
< b
, a
>= b
, a
<= b
);
2437 printf(LONG_LONG_FORMAT
"\n", 0x123456789LLU
);
2439 /* long long pointer deref in argument passing test */
2445 void manyarg_test(void)
2447 LONG_DOUBLE ld
= 1234567891234LL;
2448 printf("manyarg_test:\n");
2449 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2450 1, 2, 3, 4, 5, 6, 7, 8,
2451 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2452 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2453 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2454 1, 2, 3, 4, 5, 6, 7, 8,
2455 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2456 1234567891234LL, 987654321986LL,
2458 printf("%Lf %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2459 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2460 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2461 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2462 1234567891234LL, 987654321986LL,
2464 printf("%d %d %d %d %d %d %d %d %Lf\n",
2465 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2466 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2467 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"%f %f %Lf\n",
2468 1, 2, 3, 4, 5, 6, 7, 8,
2469 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2470 1234567891234LL, 987654321986LL,
2472 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2473 "%Lf " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f %Lf\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 ld
, 1234567891234LL, 987654321986LL,
2480 void vprintf1(const char *fmt
, ...)
2504 i
= va_arg(ap
, int);
2508 d
= va_arg(ap
, double);
2512 ll
= va_arg(ap
, long long);
2513 printf(LONG_LONG_FORMAT
, ll
);
2516 ld
= va_arg(ap
, LONG_DOUBLE
);
2534 void stdarg_for_struct(struct myspace bob
, ...)
2536 struct myspace george
, bill
;
2541 bill
= va_arg(ap
, struct myspace
);
2542 george
= va_arg(ap
, struct myspace
);
2543 validate
= va_arg(ap
, int);
2544 printf("stdarg_for_struct: %d %d %d %d\n",
2545 bob
.profile
, bill
.profile
, george
.profile
, validate
);
2549 void stdarg_for_libc(const char *fmt
, ...)
2552 va_start(args
, fmt
);
2557 void stdarg_test(void)
2559 LONG_DOUBLE ld
= 1234567891234LL;
2562 vprintf1("%d %d %d\n", 1, 2, 3);
2563 vprintf1("%f %d %f\n", 1.0, 2, 3.0);
2564 vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0);
2565 vprintf1("%F %F %F\n", LONG_DOUBLE_LITERAL(1.2), LONG_DOUBLE_LITERAL(2.3), LONG_DOUBLE_LITERAL(3.4));
2566 vprintf1("%d %f %l %F %d %f %l %F\n",
2567 1, 1.2, 3LL, LONG_DOUBLE_LITERAL(4.5), 6, 7.8, 9LL, LONG_DOUBLE_LITERAL(0.1));
2568 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f\n",
2569 1, 2, 3, 4, 5, 6, 7, 8,
2570 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8);
2571 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2572 1, 2, 3, 4, 5, 6, 7, 8,
2573 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2574 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2576 1, 2, 3, 4, 5, 6, 7, 8,
2577 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2578 1234567891234LL, 987654321986LL,
2580 vprintf1("%F %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2582 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2583 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2584 1234567891234LL, 987654321986LL,
2586 vprintf1("%d %d %d %d %d %d %d %d %F\n",
2587 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2588 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2590 1, 2, 3, 4, 5, 6, 7, 8,
2591 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2592 1234567891234LL, 987654321986LL,
2594 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2595 "%F %l %l %f %f %F\n",
2596 1, 2, 3, 4, 5, 6, 7, 8,
2597 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2598 ld
, 1234567891234LL, 987654321986LL,
2602 stdarg_for_struct(bob
, bob
, bob
, bob
.profile
);
2603 stdarg_for_libc("stdarg_for_libc: %s %.2f %d\n", "string", 1.23, 456);
2606 void whitespace_test(void)
2612 ntf("whitspace:\n");\f\v
2616 #ifdef CORRECT_CR_HANDLING
2625 #ifdef ACCEPT_CR_IN_STRINGS
2626 printf("len1=%d\n", strlen("
2628 #ifdef CORRECT_CR_HANDLING
2631 printf("len1=%d str[0]=%d\n", strlen(str
), str
[0]);
2633 printf("len1=%d\n", strlen("
a
2635 #endif /* ACCEPT_CR_IN_STRINGS */
2638 int reltab
[3] = { 1, 2, 3 };
2640 int *rel1
= &reltab
[1];
2641 int *rel2
= &reltab
[2];
2643 void getmyaddress(void)
2645 printf("in getmyaddress\n");
2649 long __pa_symbol(void)
2651 /* This 64bit constant was handled incorrectly, it was used as addend
2652 (which can hold 64bit just fine) in connection with a symbol,
2653 and TCC generates wrong code for that (displacements are 32bit only).
2654 This effectively is "+ 0x80000000", and if addresses of globals
2655 are below 2GB the result should be a number without high 32 bits set. */
2656 return ((long)(((unsigned long)(&rel1
))) - (0xffffffff80000000UL
));
2660 unsigned long theaddress
= (unsigned long)getmyaddress
;
2661 void relocation_test(void)
2663 void (*fptr
)(void) = (void (*)(void))theaddress
;
2664 printf("*rel1=%d\n", *rel1
);
2665 printf("*rel2=%d\n", *rel2
);
2668 printf("pa_symbol=0x%lx\n", __pa_symbol() >> 63);
2672 void old_style_f(a
,b
,c
)
2676 printf("a=%d b=%d b=%f\n", a
, b
, c
);
2679 void decl_func1(int cmpfn())
2681 printf("cmpfn=%lx\n", (long)cmpfn
);
2684 void decl_func2(cmpfn
)
2687 printf("cmpfn=%lx\n", (long)cmpfn
);
2690 void old_style_function(void)
2692 old_style_f((void *)1, 2, 3.0);
2699 #if defined __i386__ || defined __x86_64__ || defined __arm__
2700 char *p
= alloca(16);
2701 strcpy(p
,"123456789012345");
2702 printf("alloca: p is %s\n", p
);
2703 char *demo
= "This is only a test.\n";
2704 /* Test alloca embedded in a larger expression */
2705 printf("alloca: %s\n", strcpy(alloca(strlen(demo
)+1),demo
) );
2709 void *bounds_checking_is_enabled()
2711 char ca
[10], *cp
= ca
-1;
2712 return (ca
!= cp
+ 1) ? cp
: NULL
;
2715 typedef int constant_negative_array_size_as_compile_time_assertion_idiom
[(1 ? 2 : 0) - 1];
2717 void c99_vla_test(int size1
, int size2
)
2719 #if defined __i386__ || defined __x86_64__
2720 int size
= size1
* size2
;
2721 int tab1
[size
][2], tab2
[10][2];
2722 void *tab1_ptr
, *tab2_ptr
, *bad_ptr
;
2724 /* "size" should have been 'captured' at tab1 declaration,
2725 so modifying it should have no effect on VLA behaviour. */
2728 printf("Test C99 VLA 1 (sizeof): ");
2729 printf("%s\n", (sizeof tab1
== size1
* size2
* 2 * sizeof(int)) ? "PASSED" : "FAILED");
2732 printf("Test C99 VLA 2 (ptrs subtract): ");
2733 printf("%s\n", (tab2
- tab1
== (tab2_ptr
- tab1_ptr
) / (sizeof(int) * 2)) ? "PASSED" : "FAILED");
2734 printf("Test C99 VLA 3 (ptr add): ");
2735 printf("%s\n", &tab1
[5][1] == (tab1_ptr
+ (5 * 2 + 1) * sizeof(int)) ? "PASSED" : "FAILED");
2736 printf("Test C99 VLA 4 (ptr access): ");
2737 tab1
[size1
][1] = 42;
2738 printf("%s\n", (*((int *) (tab1_ptr
+ (size1
* 2 + 1) * sizeof(int))) == 42) ? "PASSED" : "FAILED");
2740 printf("Test C99 VLA 5 (bounds checking (might be disabled)): ");
2741 if (bad_ptr
= bounds_checking_is_enabled()) {
2742 int *t1
= &tab1
[size1
* size2
- 1][3];
2743 int *t2
= &tab2
[9][3];
2744 printf("%s ", bad_ptr
== t1
? "PASSED" : "FAILED");
2745 printf("%s ", bad_ptr
== t2
? "PASSED" : "FAILED");
2747 char*c1
= 1 + sizeof(tab1
) + (char*)tab1
;
2748 char*c2
= 1 + sizeof(tab2
) + (char*)tab2
;
2749 printf("%s ", bad_ptr
== c1
? "PASSED" : "FAILED");
2750 printf("%s ", bad_ptr
== c2
? "PASSED" : "FAILED");
2754 printf("%s ", bad_ptr
== i1
? "PASSED" : "FAILED");
2755 printf("%s ", bad_ptr
== i2
? "PASSED" : "FAILED");
2757 int *x1
= tab1
[size1
* size2
+ 1];
2758 int *x2
= tab2
[10 + 1];
2759 printf("%s ", bad_ptr
== x1
? "PASSED" : "FAILED");
2760 printf("%s ", bad_ptr
== x2
? "PASSED" : "FAILED");
2762 printf("PASSED PASSED PASSED PASSED PASSED PASSED PASSED PASSED ");
2769 typedef __SIZE_TYPE__
uintptr_t;
2772 void sizeof_test(void)
2777 printf("sizeof(int) = %d\n", sizeof(int));
2778 printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
2779 printf("sizeof(long) = %d\n", sizeof(long));
2780 printf("sizeof(unsigned long) = %d\n", sizeof(unsigned long));
2781 printf("sizeof(short) = %d\n", sizeof(short));
2782 printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
2783 printf("sizeof(char) = %d\n", sizeof(char));
2784 printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
2785 printf("sizeof(func) = %d\n", sizeof sizeof_test());
2787 printf("sizeof(a++) = %d\n", sizeof a
++);
2788 printf("a=%d\n", a
);
2790 printf("sizeof(**ptr) = %d\n", sizeof (**ptr
));
2792 /* The type of sizeof should be as large as a pointer, actually
2793 it should be size_t. */
2794 printf("sizeof(sizeof(int) = %d\n", sizeof(sizeof(int)));
2797 /* Effectively <<32, but defined also on 32bit machines. */
2801 /* This checks that sizeof really can be used to manipulate
2802 uintptr_t objects, without truncation. */
2803 t2
= t
& -sizeof(uintptr_t);
2804 printf ("%lu %lu\n", t
, t2
);
2806 /* some alignof tests */
2807 printf("__alignof__(int) = %d\n", __alignof__(int));
2808 printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int));
2809 printf("__alignof__(short) = %d\n", __alignof__(short));
2810 printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short));
2811 printf("__alignof__(char) = %d\n", __alignof__(char));
2812 printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char));
2813 printf("__alignof__(func) = %d\n", __alignof__
sizeof_test());
2815 /* sizes of VLAs need to be evaluated even inside sizeof: */
2817 printf("sizeof(char[1+2*a]) = %d\n", sizeof(char[1+2*a
]));
2818 /* And checking if sizeof compound literal works. Parenthesized: */
2819 printf("sizeof( (struct {int i; int j;}){4,5} ) = %d\n",
2820 sizeof( (struct {int i
; int j
;}){4,5} ));
2821 /* And as direct sizeof argument (as unary expression): */
2822 printf("sizeof (struct {short i; short j;}){4,5} = %d\n",
2823 sizeof (struct {short i
; short j
;}){4,5} );
2825 /* sizeof(x && y) should be sizeof(int), even if constant
2826 evaluating is possible. */
2827 printf("sizeof(t && 0) = %d\n", sizeof(t
&& 0));
2828 printf("sizeof(1 && 1) = %d\n", sizeof(1 && 1));
2829 printf("sizeof(t || 1) = %d\n", sizeof(t
|| 1));
2830 printf("sizeof(0 || 0) = %d\n", sizeof(0 || 0));
2833 void typeof_test(void)
2842 printf("a=%f b=%f c=%f\n", a
, b
, c
);
2848 struct hlist_node
*first
, *last
;
2851 void statement_expr_test(void)
2855 /* Basic stmt expr test */
2865 printf("a=%d\n", a
);
2867 /* Test that symbols aren't freed prematurely.
2868 With SYM_DEBUG valgrind will show a read from a freed
2869 symbol, and tcc will show an (invalid) warning on the initialization
2870 of 'ptr' below, if symbols are popped after the stmt expr. */
2871 void *v
= (void*)39;
2873 (struct hlist_node
*)v
;
2876 ptr
= (struct hlist_node
*)v
;
2878 /* This part used to segfault when symbols were popped prematurely.
2879 The symbols for the static local would be overwritten with
2880 helper symbols from the pre-processor expansions in between. */
2881 #define some_attr __attribute__((aligned(1)))
2882 #define tps(str) ({ \
2883 static const char *t some_attr = str; \
2886 printf ("stmtexpr: %s %s\n",
2887 tps("somerandomlongstring"),
2888 tps("anotherlongstring"));
2890 /* Test that the three decls of 't' don't interact. */
2892 int b
= ({ int t
= 41; t
; });
2893 int c
= ({ int t
= 42; t
; });
2895 /* Test that aggregate return values work. */
2898 typedef struct hlist_head T
;
2900 T t
= { (void*)43, (void*)44 };
2904 printf ("stmtexpr: %d %d %d\n", t
, b
, c
);
2905 printf ("stmtexpr: %ld %ld\n", (long)h
.first
, (long)h
.last
);
2908 void local_label_test(void)
2914 __label__ l1
, l2
, l3
, l4
;
2928 printf("a=%d\n", a
);
2938 /* inline assembler test */
2939 #if defined(__i386__) || defined(__x86_64__)
2941 /* from linux kernel */
2942 static char * strncat1(char * dest
,const char * src
,size_t count
)
2944 long d0
, d1
, d2
, d3
;
2945 __asm__
__volatile__(
2954 "testb %%al,%%al\n\t"
2958 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
2959 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
2964 static char * strncat2(char * dest
,const char * src
,size_t count
)
2966 long d0
, d1
, d2
, d3
;
2967 __asm__
__volatile__(
2968 "repne scasb\n\t" /* one-line repne prefix + string op */
2975 "testb %%al,%%al\n\t"
2979 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
2980 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
2985 static inline void * memcpy1(void * to
, const void * from
, size_t n
)
2988 __asm__
__volatile__(
2993 "1:\ttestb $1,%b4\n\t"
2997 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
2998 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
3003 static inline void * memcpy2(void * to
, const void * from
, size_t n
)
3006 __asm__
__volatile__(
3007 "rep movsl\n\t" /* one-line rep prefix + string op */
3011 "1:\ttestb $1,%b4\n\t"
3015 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
3016 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
3021 static __inline__
void sigaddset1(unsigned int *set
, int _sig
)
3023 __asm__("btsl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc");
3026 static __inline__
void sigdelset1(unsigned int *set
, int _sig
)
3028 asm("btrl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc", "flags");
3031 static __inline__ __const__
unsigned int swab32(unsigned int x
)
3033 __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */
3034 "rorl $16,%0\n\t" /* swap words */
3035 "xchgb %b0,%h0" /* swap higher bytes */
3041 static __inline__
unsigned long long mul64(unsigned int a
, unsigned int b
)
3043 unsigned long long res
;
3045 /* Using the A constraint is wrong (it means rdx:rax, which is too large)
3046 but still test the 32bit->64bit mull. */
3047 unsigned int resh
, resl
;
3048 __asm__("mull %2" : "=a" (resl
), "=d" (resh
) : "a" (a
), "r" (b
));
3049 res
= ((unsigned long long)resh
<< 32) | resl
;
3051 __asm__("mull %2" : "=A" (res
) : "a" (a
), "r" (b
));
3056 static __inline__
unsigned long long inc64(unsigned long long a
)
3058 unsigned long long res
;
3060 /* Using the A constraint is wrong, and increments are tested
3064 __asm__("addl $1, %%eax ; adcl $0, %%edx" : "=A" (res
) : "A" (a
));
3077 unsigned long mconstraint_test(struct struct1231
*r
)
3082 __asm__
volatile ("lea %2,%0; movl 4(%0),%k0; addl %2,%k0; movl $51,%2; movl $52,4%2; movl $63,%1"
3083 : "=&r" (ret
), "=m" (a
)
3084 : "m" (*(struct struct123
*)r
->addr
));
3089 int fls64(unsigned long long x
)
3099 void other_constraints_test(void)
3103 __asm__
volatile ("movq %P1,%0" : "=r" (ret
) : "p" (&var
));
3104 printf ("oc1: %d\n", ret
== (unsigned long)&var
);
3107 /* Test global asm blocks playing with aliases. */
3108 void base_func(void)
3110 printf ("asmc: base\n");
3113 extern void override_func1 (void);
3114 extern void override_func2 (void);
3116 asm(".weak override_func1\n.set override_func1, base_func");
3117 asm(".set override_func1, base_func");
3118 asm(".set override_func2, base_func");
3120 void override_func2 (void)
3122 printf ("asmc: override2\n");
3125 /* This checks a construct used by the linux kernel to encode
3126 references to strings by PC relative references. */
3127 extern int bug_table
[] __attribute__((section("__bug_table")));
3128 char * get_asm_string (void)
3130 extern int some_symbol
;
3131 asm volatile (".globl some_symbol\n"
3134 "some_symbol: .long 0\n"
3135 ".pushsection __bug_table, \"a\"\n"
3136 ".globl bug_table\n"
3138 /* The first entry (1b-2b) is unused in this test,
3139 but we include it to check if cross-section
3140 PC-relative references work. */
3141 "2:\t.long 1b - 2b, %c0 - 2b\n"
3142 ".popsection\n" : : "i" ("A string"));
3143 char * str
= ((char*)bug_table
) + bug_table
[1];
3149 void fancy_copy (unsigned *in
, unsigned *out
)
3151 asm volatile ("" : "=r" (*out
) : "0" (*in
));
3154 void fancy_copy2 (unsigned *in
, unsigned *out
)
3156 asm volatile ("mov %0,(%1)" : : "r" (*in
), "r" (out
) : "memory");
3160 void clobber_r12(void)
3162 asm volatile("mov $1, %%r12" ::: "r12");
3166 void test_high_clobbers(void)
3169 register long val
asm("r12");
3171 /* This tests if asm clobbers correctly save/restore callee saved
3172 registers if they are clobbered and if it's the high 8 x86-64
3173 registers. This is fragile for GCC as the constraints do not
3174 correctly capture the data flow, but good enough for us. */
3175 asm volatile("mov $0x4542, %%r12" : "=r" (val
):: "memory");
3177 asm volatile("mov %%r12, %0" : "=r" (val2
) : "r" (val
): "memory");
3178 printf("asmhc: 0x%x\n", val2
);
3182 static long cpu_number
;
3183 void trace_console(long len
, long len2
)
3185 /* This generated invalid code when the emission of the switch
3186 table isn't disabled. The asms are necessary to show the bug,
3187 normal statements don't work (they need to generate some code
3188 even under nocode_wanted, which normal statements don't do,
3189 but asms do). Also at least these number of cases is necessary
3190 to generate enough "random" bytes. They ultimately are enough
3191 to create invalid instruction patterns to which the first
3192 skip-to-decision-table jump jumps. If decision table emission
3193 is disabled all of this is no problem.
3195 It also is necessary that the switches are in a statement expression
3196 (which has the property of not being enterable from outside. no
3207 case 8: printf("bla"); pfo_ret__
= 42; break;
3209 pscr_ret__
= pfo_ret__
;
3216 case 1:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3217 case 2:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3218 case 4:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3219 case 8:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3220 default: printf("impossible\n");
3222 pscr_ret__
= pfo_ret__
;
3235 unsigned int val
, val2
;
3236 struct struct123 s1
;
3237 struct struct1231 s2
= { (unsigned long)&s1
};
3238 /* Hide the outer base_func, but check later that the inline
3239 asm block gets the outer one. */
3241 void override_func3 (void);
3242 unsigned long asmret
;
3246 register int regvar
asm("%esi");
3248 printf("inline asm:\n");
3250 // parse 0x1E-1 as 3 tokens in asm mode
3251 asm volatile ("mov $0x1E-1,%eax");
3253 /* test the no operand case */
3254 asm volatile ("xorl %eax, %eax");
3256 memcpy1(buf
, "hello", 6);
3257 strncat1(buf
, " worldXXXXX", 3);
3258 printf("%s\n", buf
);
3260 memcpy2(buf
, "hello", 6);
3261 strncat2(buf
, " worldXXXXX", 3);
3262 printf("%s\n", buf
);
3264 /* 'A' constraint test */
3265 printf("mul64=0x%Lx\n", mul64(0x12345678, 0xabcd1234));
3266 printf("inc64=0x%Lx\n", inc64(0x12345678ffffffff));
3270 printf("mconstraint: %d", mconstraint_test(&s2
));
3271 printf(" %d %d\n", s1
.a
, s1
.b
);
3272 other_constraints_test();
3274 sigdelset1(&set
, 2);
3275 sigaddset1(&set
, 16);
3276 /* NOTE: we test here if C labels are correctly restored after the
3280 __asm__("btsl %1,%0" : "=m"(set
) : "Ir"(20) : "cc");
3281 printf("set=0x%x\n", set
);
3283 printf("swab32(0x%08x) = 0x%0x\n", val
, swab32(val
));
3286 /* The base_func ref from the following inline asm should find
3287 the global one, not the local decl from this function. */
3288 asm volatile(".weak override_func3\n.set override_func3, base_func");
3290 /* Check that we can also load structs of appropriate layout
3292 asm volatile("" : "=r" (asmret
) : "0"(s2
));
3293 if (asmret
!= s2
.addr
)
3294 printf("asmstr: failed\n");
3296 /* Check that the typesize correctly sets the register size to
3298 asm volatile("cmp %1,%2; sete %0" : "=a"(somebool
) : "r"(1), "r"(2));
3300 printf("asmbool: failed\n");
3302 printf("asmstr: %s\n", get_asm_string());
3304 fancy_copy (&val
, &val2
);
3305 printf ("fancycpy(%d)=%d\n", val
, val2
);
3307 fancy_copy2 (&val
, &val2
);
3308 printf ("fancycpy2(%d)=%d\n", val
, val2
);
3309 asm volatile ("mov $0x4243, %%esi" : "=r" (regvar
));
3310 printf ("regvar=%x\n", regvar
);
3311 test_high_clobbers();
3312 trace_console(8, 8);
3326 #define COMPAT_TYPE(type1, type2) \
3328 printf("__builtin_types_compatible_p(%s, %s) = %d\n", #type1, #type2, \
3329 __builtin_types_compatible_p (type1, type2));\
3334 void builtin_test(void)
3340 COMPAT_TYPE(int, int);
3341 COMPAT_TYPE(int, unsigned int);
3342 COMPAT_TYPE(int, char);
3343 COMPAT_TYPE(int, const int);
3344 COMPAT_TYPE(int, volatile int);
3345 COMPAT_TYPE(int *, int *);
3346 COMPAT_TYPE(int *, void *);
3347 COMPAT_TYPE(int *, const int *);
3348 COMPAT_TYPE(char *, unsigned char *);
3349 COMPAT_TYPE(char *, signed char *);
3350 COMPAT_TYPE(char *, char *);
3351 /* space is needed because tcc preprocessor introduces a space between each token */
3352 COMPAT_TYPE(char * *, void *);
3354 printf("res = %d\n", __builtin_constant_p(1));
3355 printf("res = %d\n", __builtin_constant_p(1 + 2));
3356 printf("res = %d\n", __builtin_constant_p(&constant_p_var
));
3357 printf("res = %d\n", __builtin_constant_p(constant_p_var
));
3358 printf("res = %d\n", __builtin_constant_p(100000 / constant_p_var
));
3361 i
= __builtin_choose_expr (1 != 0, ll
, s
);
3362 printf("bce: %d\n", i
);
3363 i
= __builtin_choose_expr (1 != 1, ll
, s
);
3364 printf("bce: %d\n", i
);
3365 i
= sizeof (__builtin_choose_expr (1, ll
, s
));
3366 printf("bce: %d\n", i
);
3367 i
= sizeof (__builtin_choose_expr (0, ll
, s
));
3368 printf("bce: %d\n", i
);
3370 printf("bera: %p\n", __builtin_extract_return_addr((void*)43));
3374 extern int __attribute__((weak
)) weak_f1(void);
3375 extern int __attribute__((weak
)) weak_f2(void);
3376 extern int weak_f3(void);
3377 extern int __attribute__((weak
)) weak_v1
;
3378 extern int __attribute__((weak
)) weak_v2
;
3381 extern int (*weak_fpa
)() __attribute__((weak
));
3382 extern int __attribute__((weak
)) (*weak_fpb
)();
3383 extern __attribute__((weak
)) int (*weak_fpc
)();
3385 extern int weak_asm_f1(void) asm("weak_asm_f1x") __attribute((weak
));
3386 extern int __attribute((weak
)) weak_asm_f2(void) asm("weak_asm_f2x") ;
3387 extern int __attribute((weak
)) weak_asm_f3(void) asm("weak_asm_f3x") __attribute((weak
));
3388 extern int weak_asm_v1
asm("weak_asm_v1x") __attribute((weak
));
3389 extern int __attribute((weak
)) weak_asm_v2
asm("weak_asm_v2x") ;
3390 extern int __attribute((weak
)) weak_asm_v3(void) asm("weak_asm_v3x") __attribute((weak
));
3392 static const size_t dummy
= 0;
3393 extern __typeof(dummy
) weak_dummy1
__attribute__((weak
, alias("dummy")));
3394 extern __typeof(dummy
) __attribute__((weak
, alias("dummy"))) weak_dummy2
;
3395 extern __attribute__((weak
, alias("dummy"))) __typeof(dummy
) weak_dummy3
;
3397 int some_lib_func(void);
3398 int dummy_impl_of_slf(void) { return 444; }
3399 int some_lib_func(void) __attribute__((weak
, alias("dummy_impl_of_slf")));
3401 int weak_toolate() __attribute__((weak
));
3402 int weak_toolate() { return 0; }
3404 void __attribute__((weak
)) weak_test(void)
3406 printf("weak_f1=%d\n", weak_f1
? weak_f1() : 123);
3407 printf("weak_f2=%d\n", weak_f2
? weak_f2() : 123);
3408 printf("weak_f3=%d\n", weak_f3
? weak_f3() : 123);
3409 printf("weak_v1=%d\n",&weak_v1
? weak_v1
: 123);
3410 printf("weak_v2=%d\n",&weak_v2
? weak_v2
: 123);
3411 printf("weak_v3=%d\n",&weak_v3
? weak_v3
: 123);
3413 printf("weak_fpa=%d\n",&weak_fpa
? weak_fpa() : 123);
3414 printf("weak_fpb=%d\n",&weak_fpb
? weak_fpb() : 123);
3415 printf("weak_fpc=%d\n",&weak_fpc
? weak_fpc() : 123);
3417 printf("weak_asm_f1=%d\n", weak_asm_f1
!= NULL
);
3418 printf("weak_asm_f2=%d\n", weak_asm_f2
!= NULL
);
3419 printf("weak_asm_f3=%d\n", weak_asm_f3
!= NULL
);
3420 printf("weak_asm_v1=%d\n",&weak_asm_v1
!= NULL
);
3421 printf("weak_asm_v2=%d\n",&weak_asm_v2
!= NULL
);
3422 printf("weak_asm_v3=%d\n",&weak_asm_v3
!= NULL
);
3423 printf("some_lib_func=%d\n", &some_lib_func
? some_lib_func() : 0);
3426 int __attribute__((weak
)) weak_f2() { return 222; }
3427 int __attribute__((weak
)) weak_f3() { return 333; }
3428 int __attribute__((weak
)) weak_v2
= 222;
3429 int __attribute__((weak
)) weak_v3
= 333;
3432 void const_func(const int a
)
3436 void const_warn_test(void)
3445 int getme (struct condstruct
*s
, int i
)
3447 int i1
= (i
== 0 ? 0 : s
)->i
;
3448 int i2
= (i
== 0 ? s
: 0)->i
;
3449 int i3
= (i
== 0 ? (void*)0 : s
)->i
;
3450 int i4
= (i
== 0 ? s
: (void*)0)->i
;
3451 return i1
+ i2
+ i3
+ i4
;
3460 struct global_data global_data
;
3462 int global_data_getstuff (int *, int);
3464 void global_data_callit (int i
)
3466 *global_data
.b
[i
] = global_data_getstuff (global_data
.b
[i
], 1);
3469 int global_data_getstuff (int *p
, int i
)
3474 void global_data_test (void)
3476 global_data
.a
[0] = 42;
3477 global_data
.b
[0] = &global_data
.a
[0];
3478 global_data_callit (0);
3479 printf ("%d\n", global_data
.a
[0]);
3484 unsigned char fill
: 3;
3485 unsigned char b1
: 1;
3486 unsigned char b2
: 1;
3487 unsigned char fill2
: 3;
3490 int glob1
, glob2
, glob3
;
3492 void compare_comparisons (struct cmpcmpS
*s
)
3494 if (s
->b1
!= (glob1
== glob2
)
3495 || (s
->b2
!= (glob1
== glob3
)))
3496 printf ("comparing comparisons broken\n");
3499 void cmp_comparison_test(void)
3503 glob1
= 42; glob2
= 42;
3506 compare_comparisons (&s
);
3509 int fcompare (double a
, double b
, int code
)
3512 case 0: return a
== b
;
3513 case 1: return a
!= b
;
3514 case 2: return a
< b
;
3515 case 3: return a
>= b
;
3516 case 4: return a
> b
;
3517 case 5: return a
<= b
;
3521 void math_cmp_test(void)
3523 double nan
= 0.0/0.0;
3527 #define bug(a,b,op,iop,part) printf("Test broken: %s %s %s %s %d\n", #a, #b, #op, #iop, part)
3529 /* This asserts that "a op b" is _not_ true, but "a iop b" is true.
3530 And it does this in various ways so that all code generation paths
3531 are checked (generating inverted tests, or non-inverted tests, or
3532 producing a 0/1 value without jumps (that's done in the fcompare
3534 #define FCMP(a,b,op,iop,code) \
3535 if (fcompare (a,b,code)) \
3536 bug (a,b,op,iop,1); \
3538 bug (a,b,op,iop,2); \
3542 bug (a,b,op,iop,3); \
3543 if ((a op b) || comp) \
3544 bug (a,b,op,iop,4); \
3545 if ((a iop b) || comp) \
3550 /* Equality tests. */
3551 FCMP(nan
, nan
, ==, !=, 0);
3552 FCMP(one
, two
, ==, !=, 0);
3553 FCMP(one
, one
, !=, ==, 1);
3554 /* Non-equality is a bit special. */
3555 if (!fcompare (nan
, nan
, 1))
3556 bug (nan
, nan
, !=, ==, 6);
3558 /* Relational tests on numbers. */
3559 FCMP(two
, one
, <, >=, 2);
3560 FCMP(one
, two
, >=, <, 3);
3561 FCMP(one
, two
, >, <=, 4);
3562 FCMP(two
, one
, <=, >, 5);
3564 /* Relational tests on NaNs. Note that the inverse op here is
3565 always !=, there's no operator in C that is equivalent to !(a < b),
3566 when NaNs are involved, same for the other relational ops. */
3567 FCMP(nan
, nan
, <, !=, 2);
3568 FCMP(nan
, nan
, >=, !=, 3);
3569 FCMP(nan
, nan
, >, !=, 4);
3570 FCMP(nan
, nan
, <=, !=, 5);
3573 double get100 () { return 100.0; }
3575 void callsave_test(void)
3577 #if defined __i386__ || defined __x86_64__ || defined __arm__
3578 int i
, s
; double *d
; double t
;
3579 s
= sizeof (double);
3580 printf ("callsavetest: %d\n", s
);
3581 d
= alloca (sizeof(double));
3583 /* x86-64 had a bug were the next call to get100 would evict
3584 the lvalue &d[0] as VT_LLOCAL, and the reload would be done
3585 in int type, not pointer type. When alloca returns a pointer
3586 with the high 32 bit set (which is likely on x86-64) the access
3587 generates a segfault. */
3588 i
= d
[0] > get100 ();
3594 void bfa3(ptrdiff_t str_offset
)
3596 printf("bfa3: %s\n", (char *)__builtin_frame_address(3) + str_offset
);
3598 void bfa2(ptrdiff_t str_offset
)
3600 printf("bfa2: %s\n", (char *)__builtin_frame_address(2) + str_offset
);
3603 void bfa1(ptrdiff_t str_offset
)
3605 printf("bfa1: %s\n", (char *)__builtin_frame_address(1) + str_offset
);
3609 void builtin_frame_address_test(void)
3611 /* builtin_frame_address fails on ARM with gcc which make test3 fail */
3613 char str
[] = "__builtin_frame_address";
3614 char *fp0
= __builtin_frame_address(0);
3616 printf("str: %s\n", str
);
3621 char via_volatile (char i
)
3628 struct __attribute__((__packed__
)) Spacked
{
3633 struct Spacked spacked
;
3634 typedef struct __attribute__((__packed__
)) {
3640 /* This doesn't work for now. Requires adjusting field offsets/sizes
3641 after parsing the struct members. */
3642 typedef struct Spacked3_s
{
3646 } __attribute__((__packed__
)) Spacked3
;
3648 struct gate_struct64
{
3649 unsigned short offset_low
;
3650 unsigned short segment
;
3651 unsigned ist
: 3, zero0
: 5, type
: 5, dpl
: 2, p
: 1;
3652 unsigned short offset_middle
;
3653 unsigned offset_high
;
3655 } __attribute__((packed
));
3656 typedef struct gate_struct64 gate_desc
;
3657 gate_desc a_gate_desc
;
3658 void attrib_test(void)
3660 printf("attr: %d %d %d %d\n", sizeof(struct Spacked
),
3661 sizeof(spacked
), sizeof(Spacked2
), sizeof(spacked2
));
3662 printf("attr: %d %d\n", sizeof(Spacked3
), sizeof(spacked3
));
3663 printf("attr: %d %d\n", sizeof(gate_desc
), sizeof(a_gate_desc
));
3665 extern __attribute__((__unused__
)) char * __attribute__((__unused__
)) *
3666 strange_attrib_placement (void);
3668 void * __attribute__((__unused__
)) get_void_ptr (void *a
)