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 << 31) << 1,
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();
1412 undefined_function();
1415 /* Leave the "if(1)return; printf()" in this order and last in the function */
1418 printf ("oor:%d\n", undefined_function());
1421 int defined_function(void)
1427 /* GCC accepts that */
1428 static int tab_reinit
[];
1429 static int tab_reinit
[10];
1431 //int cinit1; /* a global variable can be defined several times without error ! */
1435 int *cinit2
= (int []){3, 2, 1};
1437 void compound_literal_test(void)
1442 printf("compound_test:\n");
1444 p
= (int []){1, 2, 3};
1446 printf(" %d", p
[i
]);
1450 printf("%d", cinit2
[i
]);
1454 printf("q1=%s\n", q
);
1456 q
= (char *){ "tralala2" };
1457 printf("q2=%s\n", q
);
1460 printf("q3=%s\n", q3
);
1462 q
= (char []){ "tralala3" };
1463 printf("q4=%s\n", q
);
1466 p
= (int []){1, 2, cinit1
+ 3};
1468 printf(" %d", p
[i
]);
1472 p
= (int []){1, 2, 4 + i
};
1473 printf("%d %d %d\n",
1495 printf("kr_test:\n");
1496 printf("func1=%d\n", kr_func1(3, 4));
1497 printf("func2=%d\n", kr_func2(3, 4));
1504 tab
= (char*)malloc(20);
1521 /* structure assignment tests */
1527 struct structa1 ssta1
;
1529 void struct_assign_test1(struct structa1 s1
, int t
, float f
)
1531 printf("%d %d %d %f\n", s1
.f1
, s1
.f2
, t
, f
);
1534 struct structa1
struct_assign_test2(struct structa1 s1
, int t
)
1541 void struct_assign_test(void)
1544 struct structa1 lsta1
, lsta2
;
1551 printf("struct_assign_test:\n");
1555 printf("%d %d\n", s
.lsta1
.f1
, s
.lsta1
.f2
);
1557 printf("%d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1562 struct_assign_test1(ps
->lsta2
, 3, 4.5);
1564 printf("before call: %d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1565 ps
->lsta2
= struct_assign_test2(ps
->lsta2
, ps
->i
);
1566 printf("after call: %d %d\n", ps
->lsta2
.f1
, ps
->lsta2
.f2
);
1571 /* XXX: we should allow this even without braces */
1572 { struct_assign_test
}
1574 printf("%d\n", struct_assign_test
== t
[0].elem
);
1577 /* casts to short/char */
1579 void cast1(char a
, short b
, unsigned char c
, unsigned short d
)
1581 printf("%d %d %d %d\n", a
, b
, c
, d
);
1595 p
-= 0x700000000042;
1597 printf("cast_test:\n");
1601 printf("%d %d %d %d\n",
1604 (unsigned char)(a
+ 1),
1605 (unsigned short)(a
+ 1));
1606 printf("%d %d %d %d\n",
1609 (unsigned char)0xfffff,
1610 (unsigned short)0xfffff);
1612 a
= (bcast
= 128) + 1;
1614 a
= (scast
= 65536) + 1;
1617 printf("sizeof(c) = %d, sizeof((int)c) = %d\n", sizeof(c
), sizeof((int)c
));
1619 /* test cast from unsigned to signed short to int */
1622 printf("((unsigned)(short)0x%08x) = 0x%08x\n", b
, d
);
1625 printf("((unsigned)(char)0x%08x) = 0x%08x\n", b
, d
);
1627 /* test implicit int casting for array accesses */
1631 printf("%d %d\n", tab
[0], tab
[1]);
1633 /* test implicit casting on some operators */
1634 printf("sizeof(+(char)'a') = %d\n", sizeof(+(char)'a'));
1635 printf("sizeof(-(char)'a') = %d\n", sizeof(-(char)'a'));
1636 printf("sizeof(~(char)'a') = %d\n", sizeof(-(char)'a'));
1638 /* from pointer to integer types */
1639 printf("%d %d %ld %ld %lld %lld\n",
1640 (int)p
, (unsigned int)p
,
1641 (long)p
, (unsigned long)p
,
1642 (long long)p
, (unsigned long long)p
);
1644 /* from integers to pointers */
1645 printf("%p %p %p %p\n",
1646 (void *)a
, (void *)b
, (void *)c
, (void *)d
);
1649 /* initializers tests */
1650 struct structinit1
{
1659 int sinit3
[3] = { 1, 2, {{3}}, };
1660 int sinit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1661 int sinit5
[3][2] = { 1, 2, 3, 4, 5, 6 };
1662 int sinit6
[] = { 1, 2, 3 };
1663 int sinit7
[] = { [2] = 3, [0] = 1, 2 };
1664 char sinit8
[] = "hello" "trala";
1666 struct structinit1 sinit9
= { 1, 2, 3 };
1667 struct structinit1 sinit10
= { .f2
= 2, 3, .f1
= 1 };
1668 struct structinit1 sinit11
= { .f2
= 2, 3, .f1
= 1,
1676 char *sinit12
= "hello world";
1682 char sinit14
[10] = { "abc" };
1683 int sinit15
[3] = { sizeof(sinit15
), 1, 2 };
1685 struct { int a
[3], b
; } sinit16
[] = { { 1 }, 2 };
1701 struct complexinit0
{
1706 struct complexinit
{
1708 const struct complexinit0
*b
;
1711 const static struct complexinit cix
[] = {
1714 .b
= (const struct complexinit0
[]) {
1722 struct complexinit2
{
1727 struct complexinit2 cix20
;
1729 struct complexinit2 cix21
= {
1731 .b
= { 3001, 3002, 3003 }
1734 struct complexinit2 cix22
= {
1736 .b
= { 4001, 4002, 4003, 4004, 4005, 4006 }
1739 typedef int arrtype1
[];
1740 arrtype1 sinit19
= {1};
1741 arrtype1 sinit20
= {2,3};
1742 typedef int arrtype2
[3];
1743 arrtype2 sinit21
= {4};
1744 arrtype2 sinit22
= {5,6,7};
1746 /* Address comparisons of non-weak symbols with zero can be const-folded */
1747 int sinit23
[2] = { "astring" ? sizeof("astring") : -1,
1748 &sinit23
? 42 : -1 };
1750 void init_test(void)
1754 int linit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1755 int linit6
[] = { 1, 2, 3 };
1757 char linit8
[] = "hello" "trala";
1758 int linit12
[10] = { 1, 2 };
1759 int linit13
[10] = { 1, 2, [7] = 3, [3] = 4, };
1760 char linit14
[10] = "abc";
1761 int linit15
[10] = { linit1
, linit1
+ 1, [6] = linit1
+ 2, };
1762 struct linit16
{ int a1
, a2
, a3
, a4
; } linit16
= { 1, .a3
= 2 };
1763 int linit17
= sizeof(linit17
);
1765 /* Addresses on non-weak symbols are non-zero, but not the access itself */
1766 int linit18
[2] = {&zero
? 1 : -1, zero
? -1 : 1 };
1768 printf("init_test:\n");
1770 printf("sinit1=%d\n", sinit1
);
1771 printf("sinit2=%d\n", sinit2
);
1772 printf("sinit3=%d %d %d %d\n",
1778 printf("sinit6=%d\n", sizeof(sinit6
));
1779 printf("sinit7=%d %d %d %d\n",
1785 printf("sinit8=%s\n", sinit8
);
1786 printf("sinit9=%d %d %d\n",
1791 printf("sinit10=%d %d %d\n",
1796 printf("sinit11=%d %d %d %d %d %d\n",
1807 printf("[%d][%d] = %d %d %d\n",
1808 i
, j
, sinit4
[i
][j
], sinit5
[i
][j
], linit4
[i
][j
]);
1809 printf("linit1=%d\n", linit1
);
1810 printf("linit2=%d\n", linit2
);
1811 printf("linit6=%d\n", sizeof(linit6
));
1812 printf("linit8=%d %s\n", sizeof(linit8
), linit8
);
1814 printf("sinit12=%s\n", sinit12
);
1815 printf("sinit13=%d %s %s %s\n",
1820 printf("sinit14=%s\n", sinit14
);
1822 for(i
=0;i
<10;i
++) printf(" %d", linit12
[i
]);
1824 for(i
=0;i
<10;i
++) printf(" %d", linit13
[i
]);
1826 for(i
=0;i
<10;i
++) printf(" %d", linit14
[i
]);
1828 for(i
=0;i
<10;i
++) printf(" %d", linit15
[i
]);
1830 printf("%d %d %d %d\n",
1835 /* test that initialisation is done after variable declare */
1836 printf("linit17=%d\n", linit17
);
1837 printf("sinit15=%d\n", sinit15
[0]);
1838 printf("sinit16=%d %d\n", sinit16
[0].a
[0], sinit16
[1].a
[0]);
1839 printf("sinit17=%s %d %s %d\n",
1840 sinit17
[0].s
, sinit17
[0].len
,
1841 sinit17
[1].s
, sinit17
[1].len
);
1843 printf("%x ", sinit18
[i
]);
1845 /* complex init check */
1846 printf("cix: %d %d %d %d %d %d %d\n",
1848 cix
[0].b
[0].a
, cix
[0].b
[0].b
,
1849 cix
[0].b
[1].a
, cix
[0].b
[1].b
,
1850 cix
[0].b
[2].a
, cix
[0].b
[2].b
);
1851 printf("cix2: %d %d\n", cix21
.b
[2], cix22
.b
[5]);
1852 printf("sizeof cix20 %d, cix21 %d, sizeof cix22 %d\n", sizeof cix20
, sizeof cix21
, sizeof cix22
);
1854 printf("arrtype1: %d %d %d\n", sinit19
[0], sinit20
[0], sinit20
[1]);
1855 printf("arrtype2: %d %d\n", sizeof(sinit19
), sizeof(sinit20
));
1856 printf("arrtype3: %d %d %d\n", sinit21
[0], sinit21
[1], sinit21
[2]);
1857 printf("arrtype4: %d %d %d\n", sinit22
[0], sinit22
[1], sinit22
[2]);
1858 printf("arrtype5: %d %d\n", sizeof(sinit21
), sizeof(sinit22
));
1859 printf("arrtype6: %d\n", sizeof(arrtype2
));
1861 printf("sinit23= %d %d\n", sinit23
[0], sinit23
[1]);
1862 printf("linit18= %d %d\n", linit18
[0], linit18
[1]);
1865 void switch_uc(unsigned char uc
)
1878 printf("ucsw: broken!\n");
1882 void switch_sc(signed char sc
)
1895 printf("scsw: broken!\n");
1902 unsigned long long ull
;
1927 for (i
= 1; i
<= 5; i
++) {
1928 ull
= (unsigned long long)i
<< 61;
1931 printf("ullsw:1\n");
1934 printf("ullsw:2\n");
1937 printf("ullsw:3\n");
1940 printf("ullsw:4\n");
1943 printf("ullsw:5\n");
1946 printf("ullsw: broken!\n");
1950 for (i
= 1; i
<= 5; i
++) {
1951 ll
= (long long)i
<< 61;
1969 printf("llsw: broken!\n");
1973 for (i
= -5; i
<= 5; i
++) {
1974 switch_uc((unsigned char)i
);
1977 for (i
= -5; i
<= 5; i
++) {
1978 switch_sc ((signed char)i
);
1982 /* ISOC99 _Bool type */
1983 void c99_bool_test(void)
1989 printf("bool_test:\n");
1990 printf("sizeof(_Bool) = %d\n", sizeof(_Bool
));
1992 printf("cast: %d %d %d\n", (_Bool
)10, (_Bool
)0, (_Bool
)a
);
1994 printf("b = %d\n", b
);
1996 printf("b = %d\n", b
);
2000 void bitfield_test(void)
2012 unsigned int f5
: 7;
2014 printf("bitfield_test:");
2015 printf("sizeof(st1) = %d\n", sizeof(st1
));
2024 printf("%d %d %d %d %d\n",
2025 st1
.f1
, st1
.f2
, st1
.f3
, st1
.f4
, st1
.f5
);
2028 printf("%d %d\n", sa
, ca
);
2032 printf("st1.f1 == -1\n");
2034 printf("st1.f1 != -1\n");
2036 printf("st1.f2 == -1\n");
2038 printf("st1.f2 != -1\n");
2041 /* on i386 we don't correctly support long long bit-fields.
2042 The bitfields can straddle long long boundaries (at least with
2043 GCC bitfield layout) and code generation isn't prepared for this
2044 (would have to work with two words in that case). */
2045 /* bit sizes below must be bigger than 32 since GCC doesn't allow
2046 long-long bitfields whose size is not bigger than int */
2051 unsigned long long f3
: 38;
2053 st2
.f1
= 0x123456789ULL
;
2055 st2
.f2
= (long long)a
<< 25;
2058 printf("%lld %lld %lld\n", st2
.f1
, st2
.f2
, st2
.f3
);
2061 Disabled
for now until further clarification re GCC compatibility
2070 printf("sizeof(st3) = %d\n", sizeof(st3
));
2077 printf("st4.y == %d\n", st4
.y
);
2081 int x
: 12, y
: 4, : 0, : 4, z
: 3;
2083 } st5
= { 1, 2, 3, 4, -3, 6 };
2084 printf("st5 = %d %d %d %d %d %d\n", st5
.a
, st5
.b
, st5
.x
, st5
.y
, st5
.z
, st5
.c
);
2088 #define FLOAT_FMT "%f\n"
2090 /* x86's float isn't compatible with GCC */
2091 #define FLOAT_FMT "%.5f\n"
2094 /* declare strto* functions as they are C99 */
2095 double strtod(const char *nptr
, char **endptr
);
2098 float strtof(const char *nptr
, char **endptr
) {return (float)strtod(nptr
, endptr
);}
2099 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
) {return (LONG_DOUBLE
)strtod(nptr
, endptr
);}
2101 float strtof(const char *nptr
, char **endptr
);
2102 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
);
2105 #define FTEST(prefix, typename, type, fmt)\
2106 void prefix ## cmp(type a, type b)\
2108 printf("%d %d %d %d %d %d\n",\
2115 printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\
2123 printf(fmt "\n", ++a);\
2124 printf(fmt "\n", a++);\
2125 printf(fmt "\n", a);\
2127 printf("%d %d\n", !a, !b);\
2129 void prefix ## fcast(type a)\
2137 unsigned long long llua;\
2142 printf("ftof: %f %f %Lf\n", fa, da, la);\
2144 llia = (long long)a;\
2145 a = (a >= 0) ? a : -a;\
2146 ua = (unsigned int)a;\
2147 llua = (unsigned long long)a;\
2148 printf("ftoi: %d %u %lld %llu\n", ia, ua, llia, llua);\
2151 llia = -0x123456789012345LL;\
2152 llua = 0xf123456789012345LLU;\
2154 printf("itof: " fmt "\n", b);\
2156 printf("utof: " fmt "\n", b);\
2158 printf("lltof: " fmt "\n", b);\
2160 printf("ulltof: " fmt "\n", b);\
2163 float prefix ## retf(type a) { return a; }\
2164 double prefix ## retd(type a) { return a; }\
2165 LONG_DOUBLE prefix ## retld(type a) { return a; }\
2167 void prefix ## call(void)\
2169 printf("float: " FLOAT_FMT, prefix ## retf(42.123456789));\
2170 printf("double: %f\n", prefix ## retd(42.123456789));\
2171 printf("long double: %Lf\n", prefix ## retld(42.123456789));\
2172 printf("strto%s: %f\n", #prefix, (double)strto ## prefix("1.2", NULL));\
2175 void prefix ## signed_zeros(void) \
2177 type x = 0.0, y = -0.0, n, p;\
2179 printf ("Test 1.0 / x != 1.0 / y returns %d (should be 1).\n",\
2180 1.0 / x != 1.0 / y);\
2182 printf ("x != y; this is wrong!\n");\
2186 printf ("Test 1.0 / x != 1.0 / -x returns %d (should be 1).\n",\
2187 1.0 / x != 1.0 / n);\
2189 printf ("x != -x; this is wrong!\n");\
2193 printf ("Test 1.0 / x != 1.0 / +y returns %d (should be 1).\n",\
2194 1.0 / x != 1.0 / p);\
2196 printf ("x != +y; this is wrong!\n");\
2199 printf ("Test 1.0 / x != 1.0 / -y returns %d (should be 0).\n",\
2200 1.0 / x != 1.0 / p);\
2202 printf ("x != -y; this is wrong!\n");\
2204 void prefix ## test(void)\
2206 printf("testing '%s'\n", #typename);\
2207 prefix ## cmp(1, 2.5);\
2208 prefix ## cmp(2, 1.5);\
2209 prefix ## cmp(1, 1);\
2210 prefix ## fcast(234.6);\
2211 prefix ## fcast(-2334.6);\
2213 prefix ## signed_zeros();\
2216 FTEST(f
, float, float, "%f")
2217 FTEST(d
, double, double, "%f")
2218 FTEST(ld
, long double, LONG_DOUBLE
, "%Lf")
2220 double ftab1
[3] = { 1.2, 3.4, -5.6 };
2223 void float_test(void)
2225 #if !defined(__arm__) || defined(__ARM_PCS_VFP)
2231 printf("float_test:\n");
2232 printf("sizeof(float) = %d\n", sizeof(float));
2233 printf("sizeof(double) = %d\n", sizeof(double));
2234 printf("sizeof(long double) = %d\n", sizeof(LONG_DOUBLE
));
2238 printf("%f %f %f\n", ftab1
[0], ftab1
[1], ftab1
[2]);
2239 printf("%f %f %f\n", 2.12, .5, 2.3e10
);
2240 // printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
2242 printf("da=%f\n", da
);
2244 printf("fa=%f\n", fa
);
2247 printf("da = %f\n", da
);
2250 printf("db = %f\n", db
);
2259 return fib(n
-1) + fib(n
-2);
2272 printf("funcptr:\n");
2279 /* more complicated pointer computation */
2282 printf("sizeof1 = %d\n", sizeof(funcptr_test
));
2283 printf("sizeof2 = %d\n", sizeof funcptr_test
);
2284 printf("sizeof3 = %d\n", sizeof(&funcptr_test
));
2285 printf("sizeof4 = %d\n", sizeof &funcptr_test
);
2294 void lloptest(long long a
, long long b
)
2296 unsigned long long ua
, ub
;
2301 printf("arith: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2307 printf("arith1: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2313 printf("bin: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2319 printf("test: %d %d %d %d %d %d\n",
2327 printf("utest: %d %d %d %d %d %d\n",
2338 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2339 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
++, b
++);
2340 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", --a
, --b
);
2341 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2343 printf("not: %d %d %d %d\n", !a
, !ua
, !b
, !ub
);
2346 void llshift(long long a
, int b
)
2348 printf("shift: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2349 (unsigned long long)a
>> b
,
2352 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2353 (unsigned long long)a
>> 3,
2356 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2357 (unsigned long long)a
>> 35,
2367 long long la
, lb
, lc
;
2368 unsigned long long ula
, ulb
, ulc
;
2371 la
= (la
<< 20) | 0x12345;
2373 printf("la=" LONG_LONG_FORMAT
" ula=" ULONG_LONG_FORMAT
"\n", la
, ula
);
2378 printf("lltof: %f %f %Lf\n", fa
, da
, lda
);
2383 printf("ftoll: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", la
, lb
, lc
);
2388 printf("ulltof: %f %f %Lf\n", fa
, da
, lda
);
2393 printf("ftoull: " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
"\n", ula
, ulb
, ulc
);
2396 long long llfunc1(int a
)
2406 long long int value(struct S
*v
)
2408 return ((long long int)v
->item
);
2411 long long llfunc2(long long x
, long long y
, int z
)
2416 void longlong_test(void)
2421 printf("longlong_test:\n");
2422 printf("sizeof(long long) = %d\n", sizeof(long long));
2427 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2428 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %Lx\n",
2432 0x1234567812345679);
2434 printf(LONG_LONG_FORMAT
"\n", a
);
2437 lloptest(0xff, 0x1234);
2438 b
= 0x72345678 << 10;
2442 b
= 0x72345678LL
<< 10;
2453 /* long long reg spill test */
2458 printf("%lld\n", value(&a
));
2460 lloptest(0x80000000, 0);
2463 long long *p
, v
, **pp
;
2467 printf("another long long spill test : %lld\n", *p
);
2470 v
= llfunc2(**pp
, **pp
, ia
);
2471 printf("a long long function (arm-)reg-args test : %lld\n", v
);
2475 printf("%d %d %d %d\n", a
> b
, a
< b
, a
>= b
, a
<= b
);
2477 printf(LONG_LONG_FORMAT
"\n", 0x123456789LLU
);
2479 /* long long pointer deref in argument passing test */
2485 void manyarg_test(void)
2487 LONG_DOUBLE ld
= 1234567891234LL;
2488 printf("manyarg_test:\n");
2489 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2490 1, 2, 3, 4, 5, 6, 7, 8,
2491 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2492 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2493 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2494 1, 2, 3, 4, 5, 6, 7, 8,
2495 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2496 1234567891234LL, 987654321986LL,
2498 printf("%Lf %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2499 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2500 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2501 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2502 1234567891234LL, 987654321986LL,
2504 printf("%d %d %d %d %d %d %d %d %Lf\n",
2505 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2506 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2507 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"%f %f %Lf\n",
2508 1, 2, 3, 4, 5, 6, 7, 8,
2509 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2510 1234567891234LL, 987654321986LL,
2512 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2513 "%Lf " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f %Lf\n",
2514 1, 2, 3, 4, 5, 6, 7, 8,
2515 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2516 ld
, 1234567891234LL, 987654321986LL,
2520 void vprintf1(const char *fmt
, ...)
2544 i
= va_arg(ap
, int);
2548 d
= va_arg(ap
, double);
2552 ll
= va_arg(ap
, long long);
2553 printf(LONG_LONG_FORMAT
, ll
);
2556 ld
= va_arg(ap
, LONG_DOUBLE
);
2574 void stdarg_for_struct(struct myspace bob
, ...)
2576 struct myspace george
, bill
;
2581 bill
= va_arg(ap
, struct myspace
);
2582 george
= va_arg(ap
, struct myspace
);
2583 validate
= va_arg(ap
, int);
2584 printf("stdarg_for_struct: %d %d %d %d\n",
2585 bob
.profile
, bill
.profile
, george
.profile
, validate
);
2589 void stdarg_for_libc(const char *fmt
, ...)
2592 va_start(args
, fmt
);
2597 void stdarg_test(void)
2599 LONG_DOUBLE ld
= 1234567891234LL;
2602 vprintf1("%d %d %d\n", 1, 2, 3);
2603 vprintf1("%f %d %f\n", 1.0, 2, 3.0);
2604 vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0);
2605 vprintf1("%F %F %F\n", LONG_DOUBLE_LITERAL(1.2), LONG_DOUBLE_LITERAL(2.3), LONG_DOUBLE_LITERAL(3.4));
2606 vprintf1("%d %f %l %F %d %f %l %F\n",
2607 1, 1.2, 3LL, LONG_DOUBLE_LITERAL(4.5), 6, 7.8, 9LL, LONG_DOUBLE_LITERAL(0.1));
2608 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f\n",
2609 1, 2, 3, 4, 5, 6, 7, 8,
2610 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8);
2611 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2612 1, 2, 3, 4, 5, 6, 7, 8,
2613 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2614 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2616 1, 2, 3, 4, 5, 6, 7, 8,
2617 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2618 1234567891234LL, 987654321986LL,
2620 vprintf1("%F %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2622 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2623 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2624 1234567891234LL, 987654321986LL,
2626 vprintf1("%d %d %d %d %d %d %d %d %F\n",
2627 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2628 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2630 1, 2, 3, 4, 5, 6, 7, 8,
2631 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2632 1234567891234LL, 987654321986LL,
2634 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2635 "%F %l %l %f %f %F\n",
2636 1, 2, 3, 4, 5, 6, 7, 8,
2637 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2638 ld
, 1234567891234LL, 987654321986LL,
2642 stdarg_for_struct(bob
, bob
, bob
, bob
.profile
);
2643 stdarg_for_libc("stdarg_for_libc: %s %.2f %d\n", "string", 1.23, 456);
2646 void whitespace_test(void)
2652 ntf("whitspace:\n");\f\v
2656 #ifdef CORRECT_CR_HANDLING
2665 #ifdef ACCEPT_CR_IN_STRINGS
2666 printf("len1=%d\n", strlen("
2668 #ifdef CORRECT_CR_HANDLING
2671 printf("len1=%d str[0]=%d\n", strlen(str
), str
[0]);
2673 printf("len1=%d\n", strlen("
a
2675 #endif /* ACCEPT_CR_IN_STRINGS */
2678 int reltab
[3] = { 1, 2, 3 };
2680 int *rel1
= &reltab
[1];
2681 int *rel2
= &reltab
[2];
2684 void relocation_test(void) {}
2686 void getmyaddress(void)
2688 printf("in getmyaddress\n");
2692 long __pa_symbol(void)
2694 /* This 64bit constant was handled incorrectly, it was used as addend
2695 (which can hold 64bit just fine) in connection with a symbol,
2696 and TCC generates wrong code for that (displacements are 32bit only).
2697 This effectively is "+ 0x80000000", and if addresses of globals
2698 are below 2GB the result should be a number without high 32 bits set. */
2699 return ((long)(((unsigned long)(&rel1
))) - (0xffffffff80000000UL
));
2703 unsigned long theaddress
= (unsigned long)getmyaddress
;
2704 void relocation_test(void)
2706 void (*fptr
)(void) = (void (*)(void))theaddress
;
2707 printf("*rel1=%d\n", *rel1
);
2708 printf("*rel2=%d\n", *rel2
);
2711 printf("pa_symbol=0x%lx\n", __pa_symbol() >> 63);
2716 void old_style_f(a
,b
,c
)
2720 printf("a=%d b=%d b=%f\n", a
, b
, c
);
2723 void decl_func1(int cmpfn())
2725 printf("cmpfn=%lx\n", (long)cmpfn
);
2728 void decl_func2(cmpfn
)
2731 printf("cmpfn=%lx\n", (long)cmpfn
);
2734 void old_style_function(void)
2736 old_style_f((void *)1, 2, 3.0);
2743 #if defined __i386__ || defined __x86_64__ || defined __arm__
2744 char *p
= alloca(16);
2745 strcpy(p
,"123456789012345");
2746 printf("alloca: p is %s\n", p
);
2747 char *demo
= "This is only a test.\n";
2748 /* Test alloca embedded in a larger expression */
2749 printf("alloca: %s\n", strcpy(alloca(strlen(demo
)+1),demo
) );
2753 void *bounds_checking_is_enabled()
2755 char ca
[10], *cp
= ca
-1;
2756 return (ca
!= cp
+ 1) ? cp
: NULL
;
2759 typedef int constant_negative_array_size_as_compile_time_assertion_idiom
[(1 ? 2 : 0) - 1];
2761 void c99_vla_test(int size1
, int size2
)
2763 #if defined __i386__ || defined __x86_64__
2764 int size
= size1
* size2
;
2765 int tab1
[size
][2], tab2
[10][2];
2766 void *tab1_ptr
, *tab2_ptr
, *bad_ptr
;
2768 /* "size" should have been 'captured' at tab1 declaration,
2769 so modifying it should have no effect on VLA behaviour. */
2772 printf("Test C99 VLA 1 (sizeof): ");
2773 printf("%s\n", (sizeof tab1
== size1
* size2
* 2 * sizeof(int)) ? "PASSED" : "FAILED");
2776 printf("Test C99 VLA 2 (ptrs subtract): ");
2777 printf("%s\n", (tab2
- tab1
== (tab2_ptr
- tab1_ptr
) / (sizeof(int) * 2)) ? "PASSED" : "FAILED");
2778 printf("Test C99 VLA 3 (ptr add): ");
2779 printf("%s\n", &tab1
[5][1] == (tab1_ptr
+ (5 * 2 + 1) * sizeof(int)) ? "PASSED" : "FAILED");
2780 printf("Test C99 VLA 4 (ptr access): ");
2781 tab1
[size1
][1] = 42;
2782 printf("%s\n", (*((int *) (tab1_ptr
+ (size1
* 2 + 1) * sizeof(int))) == 42) ? "PASSED" : "FAILED");
2784 printf("Test C99 VLA 5 (bounds checking (might be disabled)): ");
2785 if (bad_ptr
= bounds_checking_is_enabled()) {
2786 int *t1
= &tab1
[size1
* size2
- 1][3];
2787 int *t2
= &tab2
[9][3];
2788 printf("%s ", bad_ptr
== t1
? "PASSED" : "FAILED");
2789 printf("%s ", bad_ptr
== t2
? "PASSED" : "FAILED");
2791 char*c1
= 1 + sizeof(tab1
) + (char*)tab1
;
2792 char*c2
= 1 + sizeof(tab2
) + (char*)tab2
;
2793 printf("%s ", bad_ptr
== c1
? "PASSED" : "FAILED");
2794 printf("%s ", bad_ptr
== c2
? "PASSED" : "FAILED");
2798 printf("%s ", bad_ptr
== i1
? "PASSED" : "FAILED");
2799 printf("%s ", bad_ptr
== i2
? "PASSED" : "FAILED");
2801 int *x1
= tab1
[size1
* size2
+ 1];
2802 int *x2
= tab2
[10 + 1];
2803 printf("%s ", bad_ptr
== x1
? "PASSED" : "FAILED");
2804 printf("%s ", bad_ptr
== x2
? "PASSED" : "FAILED");
2806 printf("PASSED PASSED PASSED PASSED PASSED PASSED PASSED PASSED ");
2813 typedef __SIZE_TYPE__
uintptr_t;
2816 void sizeof_test(void)
2821 printf("sizeof(int) = %d\n", sizeof(int));
2822 printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
2823 printf("sizeof(long) = %d\n", sizeof(long));
2824 printf("sizeof(unsigned long) = %d\n", sizeof(unsigned long));
2825 printf("sizeof(short) = %d\n", sizeof(short));
2826 printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
2827 printf("sizeof(char) = %d\n", sizeof(char));
2828 printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
2829 printf("sizeof(func) = %d\n", sizeof sizeof_test());
2831 printf("sizeof(a++) = %d\n", sizeof a
++);
2832 printf("a=%d\n", a
);
2834 printf("sizeof(**ptr) = %d\n", sizeof (**ptr
));
2836 /* The type of sizeof should be as large as a pointer, actually
2837 it should be size_t. */
2838 printf("sizeof(sizeof(int) = %d\n", sizeof(sizeof(int)));
2841 /* Effectively <<32, but defined also on 32bit machines. */
2845 /* This checks that sizeof really can be used to manipulate
2846 uintptr_t objects, without truncation. */
2847 t2
= t
& -sizeof(uintptr_t);
2848 printf ("%lu %lu\n", t
, t2
);
2850 /* some alignof tests */
2851 printf("__alignof__(int) = %d\n", __alignof__(int));
2852 printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int));
2853 printf("__alignof__(short) = %d\n", __alignof__(short));
2854 printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short));
2855 printf("__alignof__(char) = %d\n", __alignof__(char));
2856 printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char));
2857 printf("__alignof__(func) = %d\n", __alignof__
sizeof_test());
2859 /* sizes of VLAs need to be evaluated even inside sizeof: */
2861 printf("sizeof(char[1+2*a]) = %d\n", sizeof(char[1+2*a
]));
2862 /* And checking if sizeof compound literal works. Parenthesized: */
2863 printf("sizeof( (struct {int i; int j;}){4,5} ) = %d\n",
2864 sizeof( (struct {int i
; int j
;}){4,5} ));
2865 /* And as direct sizeof argument (as unary expression): */
2866 printf("sizeof (struct {short i; short j;}){4,5} = %d\n",
2867 sizeof (struct {short i
; short j
;}){4,5} );
2869 /* sizeof(x && y) should be sizeof(int), even if constant
2870 evaluating is possible. */
2871 printf("sizeof(t && 0) = %d\n", sizeof(t
&& 0));
2872 printf("sizeof(1 && 1) = %d\n", sizeof(1 && 1));
2873 printf("sizeof(t || 1) = %d\n", sizeof(t
|| 1));
2874 printf("sizeof(0 || 0) = %d\n", sizeof(0 || 0));
2877 void typeof_test(void)
2886 printf("a=%f b=%f c=%f\n", a
, b
, c
);
2892 struct hlist_node
*first
, *last
;
2895 void statement_expr_test(void)
2899 /* Basic stmt expr test */
2909 printf("a=%d\n", a
);
2911 /* Test that symbols aren't freed prematurely.
2912 With SYM_DEBUG valgrind will show a read from a freed
2913 symbol, and tcc will show an (invalid) warning on the initialization
2914 of 'ptr' below, if symbols are popped after the stmt expr. */
2915 void *v
= (void*)39;
2917 (struct hlist_node
*)v
;
2920 ptr
= (struct hlist_node
*)v
;
2922 /* This part used to segfault when symbols were popped prematurely.
2923 The symbols for the static local would be overwritten with
2924 helper symbols from the pre-processor expansions in between. */
2925 #define some_attr __attribute__((aligned(1)))
2926 #define tps(str) ({ \
2927 static const char *t some_attr = str; \
2930 printf ("stmtexpr: %s %s\n",
2931 tps("somerandomlongstring"),
2932 tps("anotherlongstring"));
2934 /* Test that the three decls of 't' don't interact. */
2936 int b
= ({ int t
= 41; t
; });
2937 int c
= ({ int t
= 42; t
; });
2939 /* Test that aggregate return values work. */
2942 typedef struct hlist_head T
;
2944 T t
= { (void*)43, (void*)44 };
2948 printf ("stmtexpr: %d %d %d\n", t
, b
, c
);
2949 printf ("stmtexpr: %ld %ld\n", (long)h
.first
, (long)h
.last
);
2952 void local_label_test(void)
2958 __label__ l1
, l2
, l3
, l4
;
2972 printf("a=%d\n", a
);
2982 /* inline assembler test */
2983 #if defined(__i386__) || defined(__x86_64__)
2985 /* from linux kernel */
2986 static char * strncat1(char * dest
,const char * src
,size_t count
)
2988 long d0
, d1
, d2
, d3
;
2989 __asm__
__volatile__(
2998 "testb %%al,%%al\n\t"
3002 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
3003 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
3008 static char * strncat2(char * dest
,const char * src
,size_t count
)
3010 long d0
, d1
, d2
, d3
;
3011 __asm__
__volatile__(
3012 "repne scasb\n\t" /* one-line repne prefix + string op */
3019 "testb %%al,%%al\n\t"
3023 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
3024 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
3029 static inline void * memcpy1(void * to
, const void * from
, size_t n
)
3032 __asm__
__volatile__(
3037 "1:\ttestb $1,%b4\n\t"
3041 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
3042 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
3047 static inline void * memcpy2(void * to
, const void * from
, size_t n
)
3050 __asm__
__volatile__(
3051 "rep movsl\n\t" /* one-line rep prefix + string op */
3055 "1:\ttestb $1,%b4\n\t"
3059 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
3060 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
3065 static __inline__
void sigaddset1(unsigned int *set
, int _sig
)
3067 __asm__("btsl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc");
3070 static __inline__
void sigdelset1(unsigned int *set
, int _sig
)
3072 asm("btrl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc", "flags");
3075 static __inline__ __const__
unsigned int swab32(unsigned int x
)
3077 __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */
3078 "rorl $16,%0\n\t" /* swap words */
3079 "xchgb %b0,%h0" /* swap higher bytes */
3085 static __inline__
unsigned long long mul64(unsigned int a
, unsigned int b
)
3087 unsigned long long res
;
3089 /* Using the A constraint is wrong (it means rdx:rax, which is too large)
3090 but still test the 32bit->64bit mull. */
3091 unsigned int resh
, resl
;
3092 __asm__("mull %2" : "=a" (resl
), "=d" (resh
) : "a" (a
), "r" (b
));
3093 res
= ((unsigned long long)resh
<< 32) | resl
;
3095 __asm__("mull %2" : "=A" (res
) : "a" (a
), "r" (b
));
3100 static __inline__
unsigned long long inc64(unsigned long long a
)
3102 unsigned long long res
;
3104 /* Using the A constraint is wrong, and increments are tested
3108 __asm__("addl $1, %%eax ; adcl $0, %%edx" : "=A" (res
) : "A" (a
));
3121 unsigned long mconstraint_test(struct struct1231
*r
)
3126 __asm__
volatile ("lea %2,%0; movl 4(%0),%k0; addl %2,%k0; movl $51,%2; movl $52,4%2; movl $63,%1"
3127 : "=&r" (ret
), "=m" (a
)
3128 : "m" (*(struct struct123
*)r
->addr
));
3133 int fls64(unsigned long long x
)
3143 void other_constraints_test(void)
3148 __asm__
volatile ("mov %P1,%0" : "=r" (ret
) : "p" (&var
));
3149 printf ("oc1: %d\n", ret
== (unsigned long)&var
);
3154 /* Test global asm blocks playing with aliases. */
3155 void base_func(void)
3157 printf ("asmc: base\n");
3160 extern void override_func1 (void);
3161 extern void override_func2 (void);
3163 asm(".weak override_func1\n.set override_func1, base_func");
3164 asm(".set override_func1, base_func");
3165 asm(".set override_func2, base_func");
3167 void override_func2 (void)
3169 printf ("asmc: override2\n");
3172 /* This checks a construct used by the linux kernel to encode
3173 references to strings by PC relative references. */
3174 extern int bug_table
[] __attribute__((section("__bug_table")));
3175 char * get_asm_string (void)
3177 extern int some_symbol
;
3178 asm volatile (".globl some_symbol\n"
3181 "some_symbol: .long 0\n"
3182 ".pushsection __bug_table, \"a\"\n"
3183 ".globl bug_table\n"
3185 /* The first entry (1b-2b) is unused in this test,
3186 but we include it to check if cross-section
3187 PC-relative references work. */
3188 "2:\t.long 1b - 2b, %c0 - 2b\n"
3189 ".popsection\n" : : "i" ("A string"));
3190 char * str
= ((char*)bug_table
) + bug_table
[1];
3197 void fancy_copy (unsigned *in
, unsigned *out
)
3199 asm volatile ("" : "=r" (*out
) : "0" (*in
));
3202 void fancy_copy2 (unsigned *in
, unsigned *out
)
3204 asm volatile ("mov %0,(%1)" : : "r" (*in
), "r" (out
) : "memory");
3208 void clobber_r12(void)
3210 asm volatile("mov $1, %%r12" ::: "r12");
3214 void test_high_clobbers(void)
3217 register long val
asm("r12");
3219 /* This tests if asm clobbers correctly save/restore callee saved
3220 registers if they are clobbered and if it's the high 8 x86-64
3221 registers. This is fragile for GCC as the constraints do not
3222 correctly capture the data flow, but good enough for us. */
3223 asm volatile("mov $0x4542, %%r12" : "=r" (val
):: "memory");
3226 asm volatile("mov %%r12, %0" : "=r" (val2
) : "r" (val
): "memory");
3227 printf("asmhc: 0x%x\n", val2
);
3232 static long cpu_number
;
3233 void trace_console(long len
, long len2
)
3236 /* This generated invalid code when the emission of the switch
3237 table isn't disabled. The asms are necessary to show the bug,
3238 normal statements don't work (they need to generate some code
3239 even under nocode_wanted, which normal statements don't do,
3240 but asms do). Also at least these number of cases is necessary
3241 to generate enough "random" bytes. They ultimately are enough
3242 to create invalid instruction patterns to which the first
3243 skip-to-decision-table jump jumps. If decision table emission
3244 is disabled all of this is no problem.
3246 It also is necessary that the switches are in a statement expression
3247 (which has the property of not being enterable from outside. no
3258 case 8: printf("bla"); pfo_ret__
= 42; break;
3260 pscr_ret__
= pfo_ret__
;
3267 case 1:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3268 case 2:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3269 case 4:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3270 case 8:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3271 default: printf("impossible\n");
3273 pscr_ret__
= pfo_ret__
;
3285 void test_asm_dead_code(void)
3288 /* Try to make sure that xdi contains a zero, and hence will
3289 lead to a segfault if the next asm is evaluated without
3290 arguments being set up. */
3291 asm volatile ("" : "=D" (rdi
) : "0" (0));
3294 /* This shouldn't trigger a segfault, either the argument
3295 registers need to be set up and the asm emitted despite
3296 this being in an unevaluated context, or both the argument
3297 setup _and_ the asm emission need to be suppressed. The latter
3298 is better. Disabling asm code gen when suppression is on
3299 also fixes the above trace_console bug, but that came earlier
3300 than asm suppression. */
3301 asm volatile ("movl $0,(%0)" : : "D" (&var
) : "memory");
3309 unsigned int val
, val2
;
3310 struct struct123 s1
;
3311 struct struct1231 s2
= { (unsigned long)&s1
};
3312 /* Hide the outer base_func, but check later that the inline
3313 asm block gets the outer one. */
3315 void override_func3 (void);
3316 unsigned long asmret
;
3320 register int regvar
asm("%esi");
3322 printf("inline asm:\n");
3324 // parse 0x1E-1 as 3 tokens in asm mode
3325 asm volatile ("mov $0x1E-1,%eax");
3327 /* test the no operand case */
3328 asm volatile ("xorl %eax, %eax");
3330 memcpy1(buf
, "hello", 6);
3331 strncat1(buf
, " worldXXXXX", 3);
3332 printf("%s\n", buf
);
3334 memcpy2(buf
, "hello", 6);
3335 strncat2(buf
, " worldXXXXX", 3);
3336 printf("%s\n", buf
);
3338 /* 'A' constraint test */
3339 printf("mul64=0x%Lx\n", mul64(0x12345678, 0xabcd1234));
3340 printf("inc64=0x%Lx\n", inc64(0x12345678ffffffff));
3344 printf("mconstraint: %d", mconstraint_test(&s2
));
3345 printf(" %d %d\n", s1
.a
, s1
.b
);
3346 other_constraints_test();
3348 sigdelset1(&set
, 2);
3349 sigaddset1(&set
, 16);
3350 /* NOTE: we test here if C labels are correctly restored after the
3354 __asm__("btsl %1,%0" : "=m"(set
) : "Ir"(20) : "cc");
3355 printf("set=0x%x\n", set
);
3357 printf("swab32(0x%08x) = 0x%0x\n", val
, swab32(val
));
3361 /* The base_func ref from the following inline asm should find
3362 the global one, not the local decl from this function. */
3363 asm volatile(".weak override_func3\n.set override_func3, base_func");
3365 printf("asmstr: %s\n", get_asm_string());
3367 /* Check that we can also load structs of appropriate layout
3369 asm volatile("" : "=r" (asmret
) : "0"(s2
));
3370 if (asmret
!= s2
.addr
)
3371 printf("asmstr: failed\n");
3373 /* Check that the typesize correctly sets the register size to
3375 asm volatile("cmp %1,%2; sete %0" : "=a"(somebool
) : "r"(1), "r"(2));
3377 printf("asmbool: failed\n");
3380 fancy_copy (&val
, &val2
);
3381 printf ("fancycpy(%d)=%d\n", val
, val2
);
3383 fancy_copy2 (&val
, &val2
);
3384 printf ("fancycpy2(%d)=%d\n", val
, val2
);
3385 asm volatile ("mov $0x4243, %%esi" : "=r" (regvar
));
3386 printf ("regvar=%x\n", regvar
);
3387 test_high_clobbers();
3388 trace_console(8, 8);
3389 test_asm_dead_code();
3403 #define COMPAT_TYPE(type1, type2) \
3405 printf("__builtin_types_compatible_p(%s, %s) = %d\n", #type1, #type2, \
3406 __builtin_types_compatible_p (type1, type2));\
3411 void builtin_test(void)
3417 COMPAT_TYPE(int, int);
3418 COMPAT_TYPE(int, unsigned int);
3419 COMPAT_TYPE(int, char);
3420 COMPAT_TYPE(int, const int);
3421 COMPAT_TYPE(int, volatile int);
3422 COMPAT_TYPE(int *, int *);
3423 COMPAT_TYPE(int *, void *);
3424 COMPAT_TYPE(int *, const int *);
3425 COMPAT_TYPE(char *, unsigned char *);
3426 COMPAT_TYPE(char *, signed char *);
3427 COMPAT_TYPE(char *, char *);
3428 /* space is needed because tcc preprocessor introduces a space between each token */
3429 COMPAT_TYPE(char * *, void *);
3431 printf("res = %d\n", __builtin_constant_p(1));
3432 printf("res = %d\n", __builtin_constant_p(1 + 2));
3433 printf("res = %d\n", __builtin_constant_p(&constant_p_var
));
3434 printf("res = %d\n", __builtin_constant_p(constant_p_var
));
3435 printf("res = %d\n", __builtin_constant_p(100000 / constant_p_var
));
3438 i
= __builtin_choose_expr (1 != 0, ll
, s
);
3439 printf("bce: %d\n", i
);
3440 i
= __builtin_choose_expr (1 != 1, ll
, s
);
3441 printf("bce: %d\n", i
);
3442 i
= sizeof (__builtin_choose_expr (1, ll
, s
));
3443 printf("bce: %d\n", i
);
3444 i
= sizeof (__builtin_choose_expr (0, ll
, s
));
3445 printf("bce: %d\n", i
);
3447 //printf("bera: %p\n", __builtin_extract_return_addr((void*)43));
3451 extern int __attribute__((weak
)) weak_f1(void);
3452 extern int __attribute__((weak
)) weak_f2(void);
3453 extern int weak_f3(void);
3454 extern int __attribute__((weak
)) weak_v1
;
3455 extern int __attribute__((weak
)) weak_v2
;
3458 extern int (*weak_fpa
)() __attribute__((weak
));
3459 extern int __attribute__((weak
)) (*weak_fpb
)();
3460 extern __attribute__((weak
)) int (*weak_fpc
)();
3462 extern int weak_asm_f1(void) asm("weak_asm_f1x") __attribute((weak
));
3463 extern int __attribute((weak
)) weak_asm_f2(void) asm("weak_asm_f2x") ;
3464 extern int __attribute((weak
)) weak_asm_f3(void) asm("weak_asm_f3x") __attribute((weak
));
3465 extern int weak_asm_v1
asm("weak_asm_v1x") __attribute((weak
));
3466 extern int __attribute((weak
)) weak_asm_v2
asm("weak_asm_v2x") ;
3467 extern int __attribute((weak
)) weak_asm_v3(void) asm("weak_asm_v3x") __attribute((weak
));
3469 static const size_t dummy
= 0;
3470 extern __typeof(dummy
) weak_dummy1
__attribute__((weak
, alias("dummy")));
3471 extern __typeof(dummy
) __attribute__((weak
, alias("dummy"))) weak_dummy2
;
3472 extern __attribute__((weak
, alias("dummy"))) __typeof(dummy
) weak_dummy3
;
3474 int some_lib_func(void);
3475 int dummy_impl_of_slf(void) { return 444; }
3476 int some_lib_func(void) __attribute__((weak
, alias("dummy_impl_of_slf")));
3478 int weak_toolate() __attribute__((weak
));
3479 int weak_toolate() { return 0; }
3481 void __attribute__((weak
)) weak_test(void)
3483 printf("weak_f1=%d\n", weak_f1
? weak_f1() : 123);
3484 printf("weak_f2=%d\n", weak_f2
? weak_f2() : 123);
3485 printf("weak_f3=%d\n", weak_f3
? weak_f3() : 123);
3486 printf("weak_v1=%d\n",&weak_v1
? weak_v1
: 123);
3487 printf("weak_v2=%d\n",&weak_v2
? weak_v2
: 123);
3488 printf("weak_v3=%d\n",&weak_v3
? weak_v3
: 123);
3490 printf("weak_fpa=%d\n",&weak_fpa
? weak_fpa() : 123);
3491 printf("weak_fpb=%d\n",&weak_fpb
? weak_fpb() : 123);
3492 printf("weak_fpc=%d\n",&weak_fpc
? weak_fpc() : 123);
3494 printf("weak_asm_f1=%d\n", weak_asm_f1
!= NULL
);
3495 printf("weak_asm_f2=%d\n", weak_asm_f2
!= NULL
);
3496 printf("weak_asm_f3=%d\n", weak_asm_f3
!= NULL
);
3497 printf("weak_asm_v1=%d\n",&weak_asm_v1
!= NULL
);
3498 printf("weak_asm_v2=%d\n",&weak_asm_v2
!= NULL
);
3499 printf("weak_asm_v3=%d\n",&weak_asm_v3
!= NULL
);
3500 printf("some_lib_func=%d\n", &some_lib_func
? some_lib_func() : 0);
3503 int __attribute__((weak
)) weak_f2() { return 222; }
3504 int __attribute__((weak
)) weak_f3() { return 333; }
3505 int __attribute__((weak
)) weak_v2
= 222;
3506 int __attribute__((weak
)) weak_v3
= 333;
3509 void const_func(const int a
)
3513 void const_warn_test(void)
3522 int getme (struct condstruct
*s
, int i
)
3524 int i1
= (i
== 0 ? 0 : s
)->i
;
3525 int i2
= (i
== 0 ? s
: 0)->i
;
3526 int i3
= (i
== 0 ? (void*)0 : s
)->i
;
3527 int i4
= (i
== 0 ? s
: (void*)0)->i
;
3528 return i1
+ i2
+ i3
+ i4
;
3537 struct global_data global_data
;
3539 int global_data_getstuff (int *, int);
3541 void global_data_callit (int i
)
3543 *global_data
.b
[i
] = global_data_getstuff (global_data
.b
[i
], 1);
3546 int global_data_getstuff (int *p
, int i
)
3551 void global_data_test (void)
3553 global_data
.a
[0] = 42;
3554 global_data
.b
[0] = &global_data
.a
[0];
3555 global_data_callit (0);
3556 printf ("%d\n", global_data
.a
[0]);
3561 unsigned char fill
: 3;
3562 unsigned char b1
: 1;
3563 unsigned char b2
: 1;
3564 unsigned char fill2
: 3;
3567 int glob1
, glob2
, glob3
;
3569 void compare_comparisons (struct cmpcmpS
*s
)
3571 if (s
->b1
!= (glob1
== glob2
)
3572 || (s
->b2
!= (glob1
== glob3
)))
3573 printf ("comparing comparisons broken\n");
3576 void cmp_comparison_test(void)
3580 glob1
= 42; glob2
= 42;
3583 compare_comparisons (&s
);
3586 int fcompare (double a
, double b
, int code
)
3589 case 0: return a
== b
;
3590 case 1: return a
!= b
;
3591 case 2: return a
< b
;
3592 case 3: return a
>= b
;
3593 case 4: return a
> b
;
3594 case 5: return a
<= b
;
3598 void math_cmp_test(void)
3600 double nan
= 0.0/0.0;
3604 #define bug(a,b,op,iop,part) printf("Test broken: %s %s %s %s %d\n", #a, #b, #op, #iop, part)
3606 /* This asserts that "a op b" is _not_ true, but "a iop b" is true.
3607 And it does this in various ways so that all code generation paths
3608 are checked (generating inverted tests, or non-inverted tests, or
3609 producing a 0/1 value without jumps (that's done in the fcompare
3611 #define FCMP(a,b,op,iop,code) \
3612 if (fcompare (a,b,code)) \
3613 bug (a,b,op,iop,1); \
3615 bug (a,b,op,iop,2); \
3619 bug (a,b,op,iop,3); \
3620 if ((a op b) || comp) \
3621 bug (a,b,op,iop,4); \
3622 if ((a iop b) || comp) \
3627 /* Equality tests. */
3628 FCMP(nan
, nan
, ==, !=, 0);
3629 FCMP(one
, two
, ==, !=, 0);
3630 FCMP(one
, one
, !=, ==, 1);
3631 /* Non-equality is a bit special. */
3632 if (!fcompare (nan
, nan
, 1))
3633 bug (nan
, nan
, !=, ==, 6);
3635 /* Relational tests on numbers. */
3636 FCMP(two
, one
, <, >=, 2);
3637 FCMP(one
, two
, >=, <, 3);
3638 FCMP(one
, two
, >, <=, 4);
3639 FCMP(two
, one
, <=, >, 5);
3641 /* Relational tests on NaNs. Note that the inverse op here is
3642 always !=, there's no operator in C that is equivalent to !(a < b),
3643 when NaNs are involved, same for the other relational ops. */
3644 FCMP(nan
, nan
, <, !=, 2);
3645 FCMP(nan
, nan
, >=, !=, 3);
3646 FCMP(nan
, nan
, >, !=, 4);
3647 FCMP(nan
, nan
, <=, !=, 5);
3650 double get100 () { return 100.0; }
3652 void callsave_test(void)
3654 #if defined __i386__ || defined __x86_64__ || defined __arm__
3655 int i
, s
; double *d
; double t
;
3656 s
= sizeof (double);
3657 printf ("callsavetest: %d\n", s
);
3658 d
= alloca (sizeof(double));
3660 /* x86-64 had a bug were the next call to get100 would evict
3661 the lvalue &d[0] as VT_LLOCAL, and the reload would be done
3662 in int type, not pointer type. When alloca returns a pointer
3663 with the high 32 bit set (which is likely on x86-64) the access
3664 generates a segfault. */
3665 i
= d
[0] > get100 ();
3671 void bfa3(ptrdiff_t str_offset
)
3673 printf("bfa3: %s\n", (char *)__builtin_frame_address(3) + str_offset
);
3675 void bfa2(ptrdiff_t str_offset
)
3677 printf("bfa2: %s\n", (char *)__builtin_frame_address(2) + str_offset
);
3680 void bfa1(ptrdiff_t str_offset
)
3682 printf("bfa1: %s\n", (char *)__builtin_frame_address(1) + str_offset
);
3686 void builtin_frame_address_test(void)
3688 /* builtin_frame_address fails on ARM with gcc which make test3 fail */
3690 char str
[] = "__builtin_frame_address";
3691 char *fp0
= __builtin_frame_address(0);
3693 printf("str: %s\n", str
);
3698 char via_volatile (char i
)
3705 struct __attribute__((__packed__
)) Spacked
{
3710 struct Spacked spacked
;
3711 typedef struct __attribute__((__packed__
)) {
3717 /* This doesn't work for now. Requires adjusting field offsets/sizes
3718 after parsing the struct members. */
3719 typedef struct Spacked3_s
{
3723 } __attribute__((__packed__
)) Spacked3
;
3725 struct gate_struct64
{
3726 unsigned short offset_low
;
3727 unsigned short segment
;
3728 unsigned ist
: 3, zero0
: 5, type
: 5, dpl
: 2, p
: 1;
3729 unsigned short offset_middle
;
3730 unsigned offset_high
;
3732 } __attribute__((packed
));
3733 typedef struct gate_struct64 gate_desc
;
3734 gate_desc a_gate_desc
;
3735 void attrib_test(void)
3738 printf("attr: %d %d %d %d\n", sizeof(struct Spacked
),
3739 sizeof(spacked
), sizeof(Spacked2
), sizeof(spacked2
));
3740 printf("attr: %d %d\n", sizeof(Spacked3
), sizeof(spacked3
));
3741 printf("attr: %d %d\n", sizeof(gate_desc
), sizeof(a_gate_desc
));
3744 extern __attribute__((__unused__
)) char * __attribute__((__unused__
)) *
3745 strange_attrib_placement (void);
3747 void * __attribute__((__unused__
)) get_void_ptr (void *a
)