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()
180 /* We try to handle this syntax. Make at least sure it doesn't segfault. */
181 char invalid_function_def()[] {}
184 #define __INT64_C(c) c ## LL
185 #define INT64_MIN (-__INT64_C(9223372036854775807)-1)
193 #define spin_lock(lock) do { } while (0)
194 #define wq_spin_lock spin_lock
195 #define TEST2() wq_spin_lock(a)
197 #define UINT_MAX ((unsigned) -1)
199 void intdiv_test(void)
201 printf("18/21=%u\n", 18/21);
202 printf("18%%21=%u\n", 18%21);
203 printf("41/21=%u\n", 41/21);
204 printf("41%%21=%u\n", 41%21);
205 printf("42/21=%u\n", 42/21);
206 printf("42%%21=%u\n", 42%21);
207 printf("43/21=%u\n", 43/21);
208 printf("43%%21=%u\n", 43%21);
209 printf("126/21=%u\n", 126/21);
210 printf("126%%21=%u\n", 126%21);
211 printf("131/21=%u\n", 131/21);
212 printf("131%%21=%u\n", 131%21);
213 printf("(UINT_MAX/2+3)/2=%u\n", (UINT_MAX
/2+3)/2);
214 printf("(UINT_MAX/2+3)%%2=%u\n", (UINT_MAX
/2+3)%2);
216 printf("18/-21=%u\n", 18/-21);
217 printf("18%%-21=%u\n", 18%-21);
218 printf("41/-21=%u\n", 41/-21);
219 printf("41%%-21=%u\n", 41%-21);
220 printf("42/-21=%u\n", 42/-21);
221 printf("42%%-21=%u\n", 42%-21);
222 printf("43/-21=%u\n", 43/-21);
223 printf("43%%-21=%u\n", 43%-21);
224 printf("126/-21=%u\n", 126/-21);
225 printf("126%%-21=%u\n", 126%-21);
226 printf("131/-21=%u\n", 131/-21);
227 printf("131%%-21=%u\n", 131%-21);
228 printf("(UINT_MAX/2+3)/-2=%u\n", (UINT_MAX
/2+3)/-2);
229 printf("(UINT_MAX/2+3)%%-2=%u\n", (UINT_MAX
/2+3)%-2);
231 printf("-18/21=%u\n", -18/21);
232 printf("-18%%21=%u\n", -18%21);
233 printf("-41/21=%u\n", -41/21);
234 printf("-41%%21=%u\n", -41%21);
235 printf("-42/21=%u\n", -42/21);
236 printf("-42%%21=%u\n", -42%21);
237 printf("-43/21=%u\n", -43/21);
238 printf("-43%%21=%u\n", -43%21);
239 printf("-126/21=%u\n", -126/21);
240 printf("-126%%21=%u\n", -126%21);
241 printf("-131/21=%u\n", -131/21);
242 printf("-131%%21=%u\n", -131%21);
243 printf("-(UINT_MAX/2+3)/2=%u\n", (0-(UINT_MAX
/2+3))/2);
244 printf("-(UINT_MAX/2+3)%%2=%u\n", (0-(UINT_MAX
/2+3))%2);
246 printf("-18/-21=%u\n", -18/-21);
247 printf("-18%%-21=%u\n", -18%-21);
248 printf("-41/-21=%u\n", -41/-21);
249 printf("-41%%-21=%u\n", -41%-21);
250 printf("-42/-21=%u\n", -42/-21);
251 printf("-42%%-21=%u\n", -42%-21);
252 printf("-43/-21=%u\n", -43/-21);
253 printf("-43%%-21=%u\n", -43%-21);
254 printf("-126/-21=%u\n", -126/-21);
255 printf("-126%%-21=%u\n", -126%-21);
256 printf("-131/-21=%u\n", -131/-21);
257 printf("-131%%-21=%u\n", -131%-21);
258 printf("-(UINT_MAX/2+3)/-2=%u\n", (0-(UINT_MAX
/2+3))/-2);
259 printf("-(UINT_MAX/2+3)%%-2=%u\n", (0-(UINT_MAX
/2+3))%-2);
262 void macro_test(void)
264 printf("macro:\n");\f\v
266 printf("aaa=%d\n", AAA
);
268 printf("min=%d\n", min(1, min(2, -1)));
270 printf("s1=%s\n", glue(HIGH
, LOW
));
271 printf("s2=%s\n", xglue(HIGH
, LOW
));
272 printf("s3=%s\n", str("c"));
273 printf("s4=%s\n", str(a1
));
274 printf("B3=%d\n", B3
);
276 printf("onetwothree=%d\n", onetwothree
);
279 printf("A defined\n");
282 printf("B defined\n");
285 printf("A defined\n");
287 printf("A not defined\n");
290 printf("B defined\n");
292 printf("B not defined\n");
296 printf("A defined\n");
298 printf("B1 defined\n");
300 printf("B1 not defined\n");
303 printf("A not defined\n");
305 printf("B2 defined\n");
307 printf("B2 not defined\n");
312 printf("test true1\n");
315 printf("test true2\n");
318 printf("test true3\n");
321 printf("test trueA\n");
324 printf("test trueB\n");
340 printf("__LINE__ defined\n");
343 printf("__LINE__=%d __FILE__=%s\n",
347 printf("__LINE__=%d __FILE__=%s\n",
350 printf("__LINE__=%d __FILE__=%s\n",
352 #line 227 "tcctest.c"
355 /* not strictly preprocessor, but we test it there */
357 printf("__func__ = %s\n", __func__
);
358 dprintf(1, "vaarg=%d\n", 1);
360 dprintf1(1, "vaarg1\n");
361 dprintf1(1, "vaarg1=%d\n", 2);
362 dprintf1(1, "vaarg1=%d %d\n", 1, 2);
365 printf("func='%s'\n", __FUNCTION__
);
367 /* complicated macros in glibc */
368 printf("INT64_MIN=" LONG_LONG_FORMAT
"\n", INT64_MIN
);
378 /* macro function with argument outside the macro string */
379 #define MF_s MF_hello
380 #define MF_hello(msg) printf("%s\n",msg)
382 #define MF_t printf("tralala\n"); MF_hello
387 /* test macro substituion inside args (should not eat stream) */
388 printf("qq=%d\n", qq(qq
)(2));
390 /* test zero argument case. NOTE: gcc 2.95.x does not accept a
391 null argument without a space. gcc 3.2 fixes that. */
394 printf("qq1=%d\n", qq1( ));
396 /* comment with stray handling *\
398 /* this is a valid *\/ comment */
399 /* this is a valid comment *\*/
403 /* test function macro substitution when the function name is
407 /* And again when the name and parenthes are separated by a
409 TEST2
/* the comment */ ();
411 printf("%s\n", get_basefile_from_header());
412 printf("%s\n", __BASE_FILE__
);
413 printf("%s\n", get_file_from_header());
414 printf("%s\n", __FILE__
);
416 /* Check that funnily named include was in fact included */
417 have_included_42test_h
= 1;
418 have_included_42test_h_second
= 1;
419 have_included_42test_h_third
= 1;
423 static void print_num(char *fn
, int line
, int num
) {
424 printf("fn %s, line %d, num %d\n", fn
, line
, num
);
427 void recursive_macro_test(void)
430 #define ELF32_ST_TYPE(val) ((val) & 0xf)
431 #define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
432 #define STB_WEAK 2 /* Weak symbol */
433 #define ELFW(type) ELF##32##_##type
434 printf("%d\n", ELFW(ST_INFO
)(STB_WEAK
, ELFW(ST_TYPE
)(123)));
438 #define print_num(x) print_num(__FILE__,__LINE__,x)
440 WRAP(print_num(123));
441 WRAP(WRAP(print_num(123)));
443 static struct recursive_macro
{ int rm_field
; } G
;
444 #define rm_field (G.rm_field)
445 printf("rm_field = %d\n", rm_field
);
446 printf("rm_field = %d\n", WRAP(rm_field
));
447 WRAP((printf("rm_field = %d %d\n", rm_field
, WRAP(rm_field
))));
464 void ps(const char *s
)
476 const char foo1_string
[] = "\
485 printf("\141\1423\143\n");/* dezdez test */
486 printf("\x41\x42\x43\x3a\n");
487 printf("c=%c\n", 'r');
488 printf("wc=%C 0x%lx %C\n", L
'a', L
'\x1234', L
'c');
489 printf("foo1_string='%s'\n", foo1_string
);
491 printf("wstring=%S\n", L
"abc");
492 printf("wstring=%S\n", L
"abc" L
"def" "ghi");
493 printf("'\\377'=%d '\\xff'=%d\n", '\377', '\xff');
494 printf("L'\\377'=%d L'\\xff'=%d\n", L
'\377', L
'\xff');
498 while ((b
= b
+ 1) < 96) {
502 printf("fib=%d\n", fib(33));
504 while (b
!= 0x80000000) {
517 for(i
= 0; i
< 10;i
++)
527 /* c99 for loop init test */
528 for (size_t count
= 1; count
< 3; count
++)
529 printf("count=%d\n", count
);
530 printf("count = %d\n", count
);
532 /* break/continue tests */
544 /* break/continue tests */
556 for(i
= 0;i
< 10;i
++) {
564 typedef int typedef_and_label
;
569 static void *label_table
[3] = { &&label1
, &&label2
, &&label3
};
573 /* This needs to parse as label, not as start of decl. */
584 /* we also test computed gotos (GCC extension) */
586 goto *label_table
[i
];
612 enum {E6
= 42, E7
, E8
} e
:8;
616 /* This is either 0 on L32 machines, or a large number
617 on L64 machines. We should be able to store this. */
618 EL_large
= ((unsigned long)0xf000 << 31) << 1,
621 enum { BIASU
= -1U<<31 };
622 enum { BIASS
= -1 << 31 };
624 static int getint(int i
)
629 return (int)(-1U << 31);
635 /* The following should give no warning */
637 struct S_enum s
= {E7
};
638 printf("enum: %d\n", s
.e
);
639 printf("enum:\n%d %d %d %d %d %d\n",
640 E0
, E1
, E2
, E3
, E4
, E5
);
642 printf("b1=%d\n", b1
);
643 printf("enum large: %ld\n", EL_large
);
645 if (getint(0) == BIASU
)
646 printf("enum unsigned: ok\n");
648 printf("enum unsigned: wrong\n");
649 if (getint(0) == BIASS
)
650 printf("enum unsigned: ok\n");
652 printf("enum unsigned: wrong\n");
668 printf("typedef:\n");
669 printf("a=%d\n", *a
);
671 printf("mytype2=%d\n", mytype2
);
676 printf("forward:\n");
682 void forward_ref(void)
684 printf("forward ok\n");
687 typedef struct struct1
{
707 struct struct1 st1
, st2
;
714 int main(int argc
, char **argv
)
719 recursive_macro_test();
734 constant_expr_test();
738 compound_literal_test();
740 struct_assign_test();
750 old_style_function();
755 statement_expr_test();
763 cmp_comparison_test();
766 builtin_frame_address_test();
768 if (via_volatile (42) != 42)
769 printf ("via_volatile broken\n");
781 printf("g1=%d\n", g
);
789 printf("g2=%d\n", g
);
793 printf("g3=%d\n", g
);
797 printf("g4=%d\n", g
);
800 printf("g5=%d\n", g
);
808 printf("sizeof(a) = %d\n", sizeof(a
));
809 printf("sizeof(\"a\") = %d\n", sizeof("a"));
811 printf("sizeof(__func__) = %d\n", sizeof(__func__
));
813 printf("sizeof tab %d\n", sizeof(tab
));
814 printf("sizeof tab2 %d\n", sizeof tab2
);
818 printf("%d %d %d\n", tab
[0], tab
[1], tab
[2]);
821 tab2
[i
][j
] = 10 * i
+ j
;
823 printf(" %3d", ((int *)tab2
)[i
]);
826 printf("sizeof(size_t)=%d\n", sizeof(size_t));
827 printf("sizeof(ptrdiff_t)=%d\n", sizeof(ptrdiff_t));
834 printf("%d\n", a
+= 1);
835 printf("%d\n", a
-= 2);
836 printf("%d\n", a
*= 31232132);
837 printf("%d\n", a
/= 4);
838 printf("%d\n", a
%= 20);
839 printf("%d\n", a
&= 6);
840 printf("%d\n", a
^= 7);
841 printf("%d\n", a
|= 8);
842 printf("%d\n", a
>>= 3);
843 printf("%d\n", a
<<= 4);
847 printf("%d\n", a
+ 1);
848 printf("%d\n", a
- 2);
849 printf("%d\n", a
* 312);
850 printf("%d\n", a
/ 4);
851 printf("%d\n", b
/ 4);
852 printf("%d\n", (unsigned)b
/ 4);
853 printf("%d\n", a
% 20);
854 printf("%d\n", b
% 20);
855 printf("%d\n", (unsigned)b
% 20);
856 printf("%d\n", a
& 6);
857 printf("%d\n", a
^ 7);
858 printf("%d\n", a
| 8);
859 printf("%d\n", a
>> 3);
860 printf("%d\n", b
>> 3);
861 printf("%d\n", (unsigned)b
>> 3);
862 printf("%d\n", a
<< 4);
867 printf("%d\n", 12 + 1);
868 printf("%d\n", 12 - 2);
869 printf("%d\n", 12 * 312);
870 printf("%d\n", 12 / 4);
871 printf("%d\n", 12 % 20);
872 printf("%d\n", 12 & 6);
873 printf("%d\n", 12 ^ 7);
874 printf("%d\n", 12 | 8);
875 printf("%d\n", 12 >> 2);
876 printf("%d\n", 12 << 4);
880 printf("%d %d %d %d\n",
889 return (c
>= 'a' & c
<= 'z') | (c
>= 'A' & c
<= 'Z') | c
== '_';
892 /**********************/
894 int vstack
[10], *vstack_ptr
;
896 void vpush(int vt
, int vc
)
902 void vpop(int *ft
, int *fc
)
915 vstack_ptr
[-2] &= ~0xffffff80;
917 printf("res= %d %d\n", a
, b
);
920 void constant_expr_test()
923 printf("constant_expr:\n");
925 printf("%d\n", a
* 16);
926 printf("%d\n", a
* 1);
927 printf("%d\n", a
+ 0);
937 printf("expr_ptr:\n");
940 printf("diff=%d\n", q
- p
);
942 printf("inc=%d\n", p
- tab4
);
944 printf("dec=%d\n", p
- tab4
);
946 printf("inc=%d\n", p
- tab4
);
948 printf("dec=%d\n", p
- tab4
);
949 printf("add=%d\n", p
+ 3 - tab4
);
950 printf("add=%d\n", 3 + p
- tab4
);
952 /* check if 64bit support is ok */
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
);
960 printf("%p %p %ld\n", q
, p
, p
-q
);
961 printf("%d %d %d %d %d %d\n",
962 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
963 p
= (int *)((char *)p
+ 0xf0000000);
964 printf("%p %p %ld\n", q
, p
, p
-q
);
965 printf("%d %d %d %d %d %d\n",
966 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
968 printf("%p %p %ld\n", q
, p
, p
-q
);
969 printf("%d %d %d %d %d %d\n",
970 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
975 struct size12 s
[2], *sp
= s
;
980 printf("%d\n", sp
[j
].i
);
984 p
= (int*)0x100000000UL
+ i
;
986 printf("largeptr: %p %d\n", p
, i
);
993 printf("constant_expr:\n");
996 printf("%d\n", a
== a
);
997 printf("%d\n", a
!= a
);
999 printf("%d\n", a
< b
);
1000 printf("%d\n", a
<= b
);
1001 printf("%d\n", a
<= a
);
1002 printf("%d\n", b
>= a
);
1003 printf("%d\n", a
>= a
);
1004 printf("%d\n", b
> a
);
1006 printf("%d\n", (unsigned)a
< b
);
1007 printf("%d\n", (unsigned)a
<= b
);
1008 printf("%d\n", (unsigned)a
<= a
);
1009 printf("%d\n", (unsigned)b
>= a
);
1010 printf("%d\n", (unsigned)a
>= a
);
1011 printf("%d\n", (unsigned)b
> a
);
1034 struct __attribute__((aligned(16))) aligntest5
1041 } __attribute__((aligned(16)));
1046 struct aligntest5 altest5
[2];
1047 struct aligntest6 altest6
[2];
1049 /* altest7 is correctly aligned to 16 bytes also with TCC,
1050 but __alignof__ returns the wrong result (4) because we
1051 can't store the alignment yet when specified on symbols
1052 directly (it's stored in the type so we'd need to make
1054 struct aligntest7 altest7[2] __attribute__((aligned(16)));*/
1059 } __attribute__((aligned(4096)));
1062 unsigned long flags
;
1070 unsigned long index
;
1074 unsigned long counters
;
1088 unsigned long compound_head
;
1089 unsigned int compound_dtor
;
1090 unsigned int compound_order
;
1093 } __attribute__((aligned(2 * sizeof(long))));
1095 typedef unsigned long long __attribute__((aligned(4))) unaligned_u64
;
1098 unsigned int buf_nr
;
1099 unaligned_u64 start_lba
;
1102 struct aligntest10
{
1103 unsigned int buf_nr
;
1104 unsigned long long start_lba
;
1113 printf("struct:\n");
1114 printf("sizes: %d %d %d %d\n",
1115 sizeof(struct struct1
),
1116 sizeof(struct struct2
),
1117 sizeof(union union1
),
1118 sizeof(union union2
));
1119 printf("offsets: %d\n", (int)((char*)&st1
.u
.v1
- (char*)&st1
));
1123 printf("st1: %d %d %d\n",
1124 st1
.f1
, st1
.f2
, st1
.f3
);
1127 printf("union1: %d\n", st1
.u
.v1
);
1130 printf("union2: %d\n", u
.w1
);
1135 printf("st2: %d %d %d\n",
1136 s
->f1
, s
->f2
, s
->f3
);
1137 printf("str_addr=%x\n", (int)st1
.str
- (int)&st1
.f1
);
1139 /* align / size tests */
1140 printf("aligntest1 sizeof=%d alignof=%d\n",
1141 sizeof(struct aligntest1
), __alignof__(struct aligntest1
));
1142 printf("aligntest2 sizeof=%d alignof=%d\n",
1143 sizeof(struct aligntest2
), __alignof__(struct aligntest2
));
1144 printf("aligntest3 sizeof=%d alignof=%d\n",
1145 sizeof(struct aligntest3
), __alignof__(struct aligntest3
));
1146 printf("aligntest4 sizeof=%d alignof=%d\n",
1147 sizeof(struct aligntest4
), __alignof__(struct aligntest4
));
1148 printf("aligntest5 sizeof=%d alignof=%d\n",
1149 sizeof(struct aligntest5
), __alignof__(struct aligntest5
));
1150 printf("aligntest6 sizeof=%d alignof=%d\n",
1151 sizeof(struct aligntest6
), __alignof__(struct aligntest6
));
1152 printf("aligntest7 sizeof=%d alignof=%d\n",
1153 sizeof(struct aligntest7
), __alignof__(struct aligntest7
));
1154 printf("aligntest8 sizeof=%d alignof=%d\n",
1155 sizeof(struct aligntest8
), __alignof__(struct aligntest8
));
1156 printf("aligntest9 sizeof=%d alignof=%d\n",
1157 sizeof(struct aligntest9
), __alignof__(struct aligntest9
));
1158 printf("aligntest10 sizeof=%d alignof=%d\n",
1159 sizeof(struct aligntest10
), __alignof__(struct aligntest10
));
1160 printf("altest5 sizeof=%d alignof=%d\n",
1161 sizeof(altest5
), __alignof__(altest5
));
1162 printf("altest6 sizeof=%d alignof=%d\n",
1163 sizeof(altest6
), __alignof__(altest6
));
1164 /*printf("altest7 sizeof=%d alignof=%d\n",
1165 sizeof(altest7), __alignof__(altest7));*/
1167 /* empty structures (GCC extension) */
1168 printf("sizeof(struct empty) = %d\n", sizeof(struct empty
));
1169 printf("alignof(struct empty) = %d\n", __alignof__(struct empty
));
1171 printf("Large: sizeof=%d\n", sizeof(ls
));
1172 memset(&ls
, 0, sizeof(ls
));
1173 ls
.compound_head
= 42;
1174 printf("Large: offsetof(compound_head)=%d\n", (int)((char*)&ls
.compound_head
- (char*)&ls
));
1177 /* XXX: depend on endianness */
1178 void char_short_test()
1182 printf("char_short:\n");
1186 printf("s8=%d %d\n",
1187 *(char *)&var1
, *(char *)&var2
);
1188 printf("u8=%d %d\n",
1189 *(unsigned char *)&var1
, *(unsigned char *)&var2
);
1190 printf("s16=%d %d\n",
1191 *(short *)&var1
, *(short *)&var2
);
1192 printf("u16=%d %d\n",
1193 *(unsigned short *)&var1
, *(unsigned short *)&var2
);
1194 printf("s32=%d %d\n",
1195 *(int *)&var1
, *(int *)&var2
);
1196 printf("u32=%d %d\n",
1197 *(unsigned int *)&var1
, *(unsigned int *)&var2
);
1198 *(char *)&var1
= 0x08;
1199 printf("var1=%x\n", var1
);
1200 *(short *)&var1
= 0x0809;
1201 printf("var1=%x\n", var1
);
1202 *(int *)&var1
= 0x08090a0b;
1203 printf("var1=%x\n", var1
);
1206 /******************/
1208 typedef struct Sym
{
1216 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
1217 #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
1219 static int toupper1(int a
)
1224 static unsigned int calc_vm_flags(unsigned int prot
)
1226 unsigned int prot_bits
;
1227 /* This used to segfault in some revisions: */
1228 prot_bits
= ((0x1==0x00000001)?(prot
&0x1):(prot
&0x1)?0x00000001:0);
1234 int *s
, a
, b
, t
, f
, i
;
1238 printf("!s=%d\n", !s
);
1242 printf("a=%d\n", a
);
1244 printf("a=%d %d %d\n", 0 || 0, 0 || 1, 1 || 1);
1245 printf("a=%d %d %d\n", 0 && 0, 0 && 1, 1 && 1);
1246 printf("a=%d %d\n", 1 ? 1 : 0, 0 ? 1 : 0);
1261 printf("b=%d\n", a
+ (0 ? 1 : a
/ 2));
1263 /* test register spilling */
1266 a
= (a
+ b
) * ((a
< b
) ?
1267 ((b
- a
) * (a
- b
)): a
+ b
);
1268 printf("a=%d\n", a
);
1270 /* test complex || or && expressions */
1274 printf("exp=%d\n", f
== (32 <= a
&& a
<= 3));
1275 printf("r=%d\n", (t
|| f
) + (t
&& f
));
1280 int aspect_native
= 65536;
1281 double bfu_aspect
= 1.0;
1283 for(aspect_on
= 0; aspect_on
< 2; aspect_on
++) {
1284 aspect
=aspect_on
?(aspect_native
*bfu_aspect
+0.5):65535UL;
1285 printf("aspect=%d\n", aspect
);
1289 /* test ? : GCC extension */
1291 static int v1
= 34 ? : -1; /* constant case */
1292 static int v2
= 0 ? : -1; /* constant case */
1295 printf("%d %d\n", v1
, v2
);
1296 printf("%d %d\n", a
- 30 ? : a
* 2, a
+ 1 ? : a
* 2);
1299 /* again complex expression */
1300 for(i
=0;i
<256;i
++) {
1301 if (toupper1 (i
) != TOUPPER (i
))
1302 printf("error %d\n", i
);
1304 printf ("bits = 0x%x\n", calc_vm_flags (0x1));
1307 extern int undefined_function(void);
1308 extern int defined_function(void);
1310 static inline void refer_to_undefined(void)
1312 undefined_function();
1315 void optimize_out(void)
1317 int i
= 0 ? undefined_function() : defined_function();
1318 printf ("oo:%d\n", i
);
1319 int j
= 1 ? defined_function() : undefined_function();
1320 printf ("oo:%d\n", j
);
1322 printf("oo:%d\n", undefined_function());
1324 printf("oo:%d\n", defined_function());
1326 printf("oo:%d\n", defined_function());
1328 printf("oo:%d\n", undefined_function());
1330 printf("oow:%d\n", defined_function());
1332 printf("oow:%d\n", undefined_function());
1335 /* Following is a switch without {} block intentionally. */
1338 printf ("oos:%d\n", defined_function());
1339 /* The following break shouldn't lead to disabled code after
1343 printf ("ool1:%d\n", defined_function());
1344 /* Same for the other types of loops. */
1348 printf ("ool2:%d\n", defined_function());
1351 printf ("ool3:%d\n", defined_function());
1352 /* Normal {} blocks without controlling statements
1353 shouldn't reactivate code emission */
1358 printf ("ool4:%d\n", undefined_function());
1363 break; /* this break shouldn't disable code outside the if. */
1364 printf("ool5:%d\n", defined_function());
1374 printf("ool6:%d\n", defined_function());
1378 /* Test that constants in logical && are optimized: */
1379 i
= 0 && undefined_function();
1380 i
= defined_function() && 0 && undefined_function();
1381 if (0 && undefined_function())
1382 undefined_function();
1383 if (defined_function() && 0)
1384 undefined_function();
1386 undefined_function();
1387 if (defined_function() && 0 && undefined_function())
1388 undefined_function();
1389 /* The same for || : */
1390 i
= 1 || undefined_function();
1391 i
= defined_function() || 1 || undefined_function();
1392 if (1 || undefined_function())
1395 undefined_function();
1396 if (defined_function() || 1)
1399 undefined_function();
1403 undefined_function();
1404 if (defined_function() || 1 || undefined_function())
1407 undefined_function();
1409 if (defined_function() && 0)
1410 refer_to_undefined();
1417 undefined_function();
1420 /* Leave the "if(1)return; printf()" in this order and last in the function */
1423 printf ("oor:%d\n", undefined_function());
1426 int defined_function(void)
1432 /* GCC accepts that */
1433 static int tab_reinit
[];
1434 static int tab_reinit
[10];
1436 //int cinit1; /* a global variable can be defined several times without error ! */
1440 int *cinit2
= (int []){3, 2, 1};
1442 void compound_literal_test(void)
1447 printf("compound_test:\n");
1449 p
= (int []){1, 2, 3};
1451 printf(" %d", p
[i
]);
1455 printf("%d", cinit2
[i
]);
1459 printf("q1=%s\n", q
);
1461 q
= (char *){ "tralala2" };
1462 printf("q2=%s\n", q
);
1465 printf("q3=%s\n", q3
);
1467 q
= (char []){ "tralala3" };
1468 printf("q4=%s\n", q
);
1471 p
= (int []){1, 2, cinit1
+ 3};
1473 printf(" %d", p
[i
]);
1477 p
= (int []){1, 2, 4 + i
};
1478 printf("%d %d %d\n",
1500 printf("kr_test:\n");
1501 printf("func1=%d\n", kr_func1(3, 4));
1502 printf("func2=%d\n", kr_func2(3, 4));
1509 tab
= (char*)malloc(20);
1526 /* structure assignment tests */
1532 struct structa1 ssta1
;
1534 void struct_assign_test1(struct structa1 s1
, int t
, float f
)
1536 printf("%d %d %d %f\n", s1
.f1
, s1
.f2
, t
, f
);
1539 struct structa1
struct_assign_test2(struct structa1 s1
, int t
)
1546 void struct_assign_test(void)
1549 struct structa1 lsta1
, lsta2
;
1556 printf("struct_assign_test:\n");
1560 printf("%d %d\n", s
.lsta1
.f1
, s
.lsta1
.f2
);
1562 printf("%d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1567 struct_assign_test1(ps
->lsta2
, 3, 4.5);
1569 printf("before call: %d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1570 ps
->lsta2
= struct_assign_test2(ps
->lsta2
, ps
->i
);
1571 printf("after call: %d %d\n", ps
->lsta2
.f1
, ps
->lsta2
.f2
);
1576 /* XXX: we should allow this even without braces */
1577 { struct_assign_test
}
1579 printf("%d\n", struct_assign_test
== t
[0].elem
);
1582 /* casts to short/char */
1584 void cast1(char a
, short b
, unsigned char c
, unsigned short d
)
1586 printf("%d %d %d %d\n", a
, b
, c
, d
);
1600 p
-= 0x700000000042;
1602 printf("cast_test:\n");
1606 printf("%d %d %d %d\n",
1609 (unsigned char)(a
+ 1),
1610 (unsigned short)(a
+ 1));
1611 printf("%d %d %d %d\n",
1614 (unsigned char)0xfffff,
1615 (unsigned short)0xfffff);
1617 a
= (bcast
= 128) + 1;
1619 a
= (scast
= 65536) + 1;
1622 printf("sizeof(c) = %d, sizeof((int)c) = %d\n", sizeof(c
), sizeof((int)c
));
1624 /* test cast from unsigned to signed short to int */
1627 printf("((unsigned)(short)0x%08x) = 0x%08x\n", b
, d
);
1630 printf("((unsigned)(char)0x%08x) = 0x%08x\n", b
, d
);
1632 /* test implicit int casting for array accesses */
1636 printf("%d %d\n", tab
[0], tab
[1]);
1638 /* test implicit casting on some operators */
1639 printf("sizeof(+(char)'a') = %d\n", sizeof(+(char)'a'));
1640 printf("sizeof(-(char)'a') = %d\n", sizeof(-(char)'a'));
1641 printf("sizeof(~(char)'a') = %d\n", sizeof(-(char)'a'));
1643 /* from pointer to integer types */
1644 printf("%d %d %ld %ld %lld %lld\n",
1645 (int)p
, (unsigned int)p
,
1646 (long)p
, (unsigned long)p
,
1647 (long long)p
, (unsigned long long)p
);
1649 /* from integers to pointers */
1650 printf("%p %p %p %p\n",
1651 (void *)a
, (void *)b
, (void *)c
, (void *)d
);
1654 /* initializers tests */
1655 struct structinit1
{
1664 int sinit3
[3] = { 1, 2, {{3}}, };
1665 int sinit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1666 int sinit5
[3][2] = { 1, 2, 3, 4, 5, 6 };
1667 int sinit6
[] = { 1, 2, 3 };
1668 int sinit7
[] = { [2] = 3, [0] = 1, 2 };
1669 char sinit8
[] = "hello" "trala";
1671 struct structinit1 sinit9
= { 1, 2, 3 };
1672 struct structinit1 sinit10
= { .f2
= 2, 3, .f1
= 1 };
1673 struct structinit1 sinit11
= { .f2
= 2, 3, .f1
= 1,
1681 char *sinit12
= "hello world";
1687 char sinit14
[10] = { "abc" };
1688 int sinit15
[3] = { sizeof(sinit15
), 1, 2 };
1690 struct { int a
[3], b
; } sinit16
[] = { { 1 }, 2 };
1706 struct complexinit0
{
1711 struct complexinit
{
1713 const struct complexinit0
*b
;
1716 const static struct complexinit cix
[] = {
1719 .b
= (const struct complexinit0
[]) {
1727 struct complexinit2
{
1732 struct complexinit2 cix20
;
1734 struct complexinit2 cix21
= {
1736 .b
= { 3001, 3002, 3003 }
1739 struct complexinit2 cix22
= {
1741 .b
= { 4001, 4002, 4003, 4004, 4005, 4006 }
1744 typedef int arrtype1
[];
1745 arrtype1 sinit19
= {1};
1746 arrtype1 sinit20
= {2,3};
1747 typedef int arrtype2
[3];
1748 arrtype2 sinit21
= {4};
1749 arrtype2 sinit22
= {5,6,7};
1751 /* Address comparisons of non-weak symbols with zero can be const-folded */
1752 int sinit23
[2] = { "astring" ? sizeof("astring") : -1,
1753 &sinit23
? 42 : -1 };
1755 extern int external_inited
= 42;
1757 void init_test(void)
1761 int linit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1762 int linit6
[] = { 1, 2, 3 };
1764 char linit8
[] = "hello" "trala";
1765 int linit12
[10] = { 1, 2 };
1766 int linit13
[10] = { 1, 2, [7] = 3, [3] = 4, };
1767 char linit14
[10] = "abc";
1768 int linit15
[10] = { linit1
, linit1
+ 1, [6] = linit1
+ 2, };
1769 struct linit16
{ int a1
, a2
, a3
, a4
; } linit16
= { 1, .a3
= 2 };
1770 int linit17
= sizeof(linit17
);
1772 /* Addresses on non-weak symbols are non-zero, but not the access itself */
1773 int linit18
[2] = {&zero
? 1 : -1, zero
? -1 : 1 };
1775 printf("init_test:\n");
1777 printf("sinit1=%d\n", sinit1
);
1778 printf("sinit2=%d\n", sinit2
);
1779 printf("sinit3=%d %d %d %d\n",
1785 printf("sinit6=%d\n", sizeof(sinit6
));
1786 printf("sinit7=%d %d %d %d\n",
1792 printf("sinit8=%s\n", sinit8
);
1793 printf("sinit9=%d %d %d\n",
1798 printf("sinit10=%d %d %d\n",
1803 printf("sinit11=%d %d %d %d %d %d\n",
1814 printf("[%d][%d] = %d %d %d\n",
1815 i
, j
, sinit4
[i
][j
], sinit5
[i
][j
], linit4
[i
][j
]);
1816 printf("linit1=%d\n", linit1
);
1817 printf("linit2=%d\n", linit2
);
1818 printf("linit6=%d\n", sizeof(linit6
));
1819 printf("linit8=%d %s\n", sizeof(linit8
), linit8
);
1821 printf("sinit12=%s\n", sinit12
);
1822 printf("sinit13=%d %s %s %s\n",
1827 printf("sinit14=%s\n", sinit14
);
1829 for(i
=0;i
<10;i
++) printf(" %d", linit12
[i
]);
1831 for(i
=0;i
<10;i
++) printf(" %d", linit13
[i
]);
1833 for(i
=0;i
<10;i
++) printf(" %d", linit14
[i
]);
1835 for(i
=0;i
<10;i
++) printf(" %d", linit15
[i
]);
1837 printf("%d %d %d %d\n",
1842 /* test that initialisation is done after variable declare */
1843 printf("linit17=%d\n", linit17
);
1844 printf("sinit15=%d\n", sinit15
[0]);
1845 printf("sinit16=%d %d\n", sinit16
[0].a
[0], sinit16
[1].a
[0]);
1846 printf("sinit17=%s %d %s %d\n",
1847 sinit17
[0].s
, sinit17
[0].len
,
1848 sinit17
[1].s
, sinit17
[1].len
);
1850 printf("%x ", sinit18
[i
]);
1852 /* complex init check */
1853 printf("cix: %d %d %d %d %d %d %d\n",
1855 cix
[0].b
[0].a
, cix
[0].b
[0].b
,
1856 cix
[0].b
[1].a
, cix
[0].b
[1].b
,
1857 cix
[0].b
[2].a
, cix
[0].b
[2].b
);
1858 printf("cix2: %d %d\n", cix21
.b
[2], cix22
.b
[5]);
1859 printf("sizeof cix20 %d, cix21 %d, sizeof cix22 %d\n", sizeof cix20
, sizeof cix21
, sizeof cix22
);
1861 printf("arrtype1: %d %d %d\n", sinit19
[0], sinit20
[0], sinit20
[1]);
1862 printf("arrtype2: %d %d\n", sizeof(sinit19
), sizeof(sinit20
));
1863 printf("arrtype3: %d %d %d\n", sinit21
[0], sinit21
[1], sinit21
[2]);
1864 printf("arrtype4: %d %d %d\n", sinit22
[0], sinit22
[1], sinit22
[2]);
1865 printf("arrtype5: %d %d\n", sizeof(sinit21
), sizeof(sinit22
));
1866 printf("arrtype6: %d\n", sizeof(arrtype2
));
1868 printf("sinit23= %d %d\n", sinit23
[0], sinit23
[1]);
1869 printf("linit18= %d %d\n", linit18
[0], linit18
[1]);
1872 void switch_uc(unsigned char uc
)
1885 printf("ucsw: broken!\n");
1889 void switch_sc(signed char sc
)
1902 printf("scsw: broken!\n");
1909 unsigned long long ull
;
1934 for (i
= 1; i
<= 5; i
++) {
1935 ull
= (unsigned long long)i
<< 61;
1938 printf("ullsw:1\n");
1941 printf("ullsw:2\n");
1944 printf("ullsw:3\n");
1947 printf("ullsw:4\n");
1950 printf("ullsw:5\n");
1953 printf("ullsw: broken!\n");
1957 for (i
= 1; i
<= 5; i
++) {
1958 ll
= (long long)i
<< 61;
1976 printf("llsw: broken!\n");
1980 for (i
= -5; i
<= 5; i
++) {
1981 switch_uc((unsigned char)i
);
1984 for (i
= -5; i
<= 5; i
++) {
1985 switch_sc ((signed char)i
);
1989 /* ISOC99 _Bool type */
1990 void c99_bool_test(void)
1996 printf("bool_test:\n");
1997 printf("sizeof(_Bool) = %d\n", sizeof(_Bool
));
1999 printf("cast: %d %d %d\n", (_Bool
)10, (_Bool
)0, (_Bool
)a
);
2001 printf("b = %d\n", b
);
2003 printf("b = %d\n", b
);
2007 void bitfield_test(void)
2019 unsigned int f5
: 7;
2021 printf("bitfield_test:");
2022 printf("sizeof(st1) = %d\n", sizeof(st1
));
2031 printf("%d %d %d %d %d\n",
2032 st1
.f1
, st1
.f2
, st1
.f3
, st1
.f4
, st1
.f5
);
2035 printf("%d %d\n", sa
, ca
);
2039 printf("st1.f1 == -1\n");
2041 printf("st1.f1 != -1\n");
2043 printf("st1.f2 == -1\n");
2045 printf("st1.f2 != -1\n");
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
));
2078 printf("st4.y == %d\n", st4
.y
);
2082 int x
: 12, y
: 4, : 0, : 4, z
: 3;
2084 } st5
= { 1, 2, 3, 4, -3, 6 };
2085 printf("st5 = %d %d %d %d %d %d\n", st5
.a
, st5
.b
, st5
.x
, st5
.y
, st5
.z
, st5
.c
);
2088 unsigned char y
: 2;
2091 printf("st6.y == %d\n", st6
.y
);
2095 #define FLOAT_FMT "%f\n"
2097 /* x86's float isn't compatible with GCC */
2098 #define FLOAT_FMT "%.5f\n"
2101 /* declare strto* functions as they are C99 */
2102 double strtod(const char *nptr
, char **endptr
);
2105 float strtof(const char *nptr
, char **endptr
) {return (float)strtod(nptr
, endptr
);}
2106 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
) {return (LONG_DOUBLE
)strtod(nptr
, endptr
);}
2108 float strtof(const char *nptr
, char **endptr
);
2109 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
);
2112 #define FTEST(prefix, typename, type, fmt)\
2113 void prefix ## cmp(type a, type b)\
2115 printf("%d %d %d %d %d %d\n",\
2122 printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\
2130 printf(fmt "\n", ++a);\
2131 printf(fmt "\n", a++);\
2132 printf(fmt "\n", a);\
2134 printf("%d %d\n", !a, !b);\
2136 void prefix ## fcast(type a)\
2144 unsigned long long llua;\
2149 printf("ftof: %f %f %Lf\n", fa, da, la);\
2151 llia = (long long)a;\
2152 a = (a >= 0) ? a : -a;\
2153 ua = (unsigned int)a;\
2154 llua = (unsigned long long)a;\
2155 printf("ftoi: %d %u %lld %llu\n", ia, ua, llia, llua);\
2158 llia = -0x123456789012345LL;\
2159 llua = 0xf123456789012345LLU;\
2161 printf("itof: " fmt "\n", b);\
2163 printf("utof: " fmt "\n", b);\
2165 printf("lltof: " fmt "\n", b);\
2167 printf("ulltof: " fmt "\n", b);\
2170 float prefix ## retf(type a) { return a; }\
2171 double prefix ## retd(type a) { return a; }\
2172 LONG_DOUBLE prefix ## retld(type a) { return a; }\
2174 void prefix ## call(void)\
2176 printf("float: " FLOAT_FMT, prefix ## retf(42.123456789));\
2177 printf("double: %f\n", prefix ## retd(42.123456789));\
2178 printf("long double: %Lf\n", prefix ## retld(42.123456789));\
2179 printf("strto%s: %f\n", #prefix, (double)strto ## prefix("1.2", NULL));\
2182 void prefix ## signed_zeros(void) \
2184 type x = 0.0, y = -0.0, n, p;\
2186 printf ("Test 1.0 / x != 1.0 / y returns %d (should be 1).\n",\
2187 1.0 / x != 1.0 / y);\
2189 printf ("x != y; this is wrong!\n");\
2193 printf ("Test 1.0 / x != 1.0 / -x returns %d (should be 1).\n",\
2194 1.0 / x != 1.0 / n);\
2196 printf ("x != -x; this is wrong!\n");\
2200 printf ("Test 1.0 / x != 1.0 / +y returns %d (should be 1).\n",\
2201 1.0 / x != 1.0 / p);\
2203 printf ("x != +y; this is wrong!\n");\
2206 printf ("Test 1.0 / x != 1.0 / -y returns %d (should be 0).\n",\
2207 1.0 / x != 1.0 / p);\
2209 printf ("x != -y; this is wrong!\n");\
2211 void prefix ## test(void)\
2213 printf("testing '%s'\n", #typename);\
2214 prefix ## cmp(1, 2.5);\
2215 prefix ## cmp(2, 1.5);\
2216 prefix ## cmp(1, 1);\
2217 prefix ## fcast(234.6);\
2218 prefix ## fcast(-2334.6);\
2220 prefix ## signed_zeros();\
2223 FTEST(f
, float, float, "%f")
2224 FTEST(d
, double, double, "%f")
2225 FTEST(ld
, long double, LONG_DOUBLE
, "%Lf")
2227 double ftab1
[3] = { 1.2, 3.4, -5.6 };
2230 void float_test(void)
2232 #if !defined(__arm__) || defined(__ARM_PCS_VFP)
2238 printf("float_test:\n");
2239 printf("sizeof(float) = %d\n", sizeof(float));
2240 printf("sizeof(double) = %d\n", sizeof(double));
2241 printf("sizeof(long double) = %d\n", sizeof(LONG_DOUBLE
));
2245 printf("%f %f %f\n", ftab1
[0], ftab1
[1], ftab1
[2]);
2246 printf("%f %f %f\n", 2.12, .5, 2.3e10
);
2247 // printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
2249 printf("da=%f\n", da
);
2251 printf("fa=%f\n", fa
);
2254 printf("da = %f\n", da
);
2257 printf("db = %f\n", db
);
2266 return fib(n
-1) + fib(n
-2);
2279 printf("funcptr:\n");
2286 /* more complicated pointer computation */
2289 printf("sizeof1 = %d\n", sizeof(funcptr_test
));
2290 printf("sizeof2 = %d\n", sizeof funcptr_test
);
2291 printf("sizeof3 = %d\n", sizeof(&funcptr_test
));
2292 printf("sizeof4 = %d\n", sizeof &funcptr_test
);
2301 void lloptest(long long a
, long long b
)
2303 unsigned long long ua
, ub
;
2308 printf("arith: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2314 printf("arith1: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2320 printf("bin: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2326 printf("test: %d %d %d %d %d %d\n",
2334 printf("utest: %d %d %d %d %d %d\n",
2345 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2346 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
++, b
++);
2347 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", --a
, --b
);
2348 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2350 printf("not: %d %d %d %d\n", !a
, !ua
, !b
, !ub
);
2353 void llshift(long long a
, int b
)
2355 printf("shift: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2356 (unsigned long long)a
>> b
,
2359 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2360 (unsigned long long)a
>> 3,
2363 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2364 (unsigned long long)a
>> 35,
2374 long long la
, lb
, lc
;
2375 unsigned long long ula
, ulb
, ulc
;
2378 la
= (la
<< 20) | 0x12345;
2380 printf("la=" LONG_LONG_FORMAT
" ula=" ULONG_LONG_FORMAT
"\n", la
, ula
);
2385 printf("lltof: %f %f %Lf\n", fa
, da
, lda
);
2390 printf("ftoll: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", la
, lb
, lc
);
2395 printf("ulltof: %f %f %Lf\n", fa
, da
, lda
);
2400 printf("ftoull: " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
"\n", ula
, ulb
, ulc
);
2403 long long llfunc1(int a
)
2413 long long int value(struct S
*v
)
2415 return ((long long int)v
->item
);
2418 long long llfunc2(long long x
, long long y
, int z
)
2423 void longlong_test(void)
2428 printf("longlong_test:\n");
2429 printf("sizeof(long long) = %d\n", sizeof(long long));
2434 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2435 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %Lx\n",
2439 0x1234567812345679);
2441 printf(LONG_LONG_FORMAT
"\n", a
);
2444 lloptest(0xff, 0x1234);
2445 b
= 0x72345678 << 10;
2449 b
= 0x72345678LL
<< 10;
2460 /* long long reg spill test */
2465 printf("%lld\n", value(&a
));
2467 lloptest(0x80000000, 0);
2470 long long *p
, v
, **pp
;
2474 printf("another long long spill test : %lld\n", *p
);
2477 v
= llfunc2(**pp
, **pp
, ia
);
2478 printf("a long long function (arm-)reg-args test : %lld\n", v
);
2482 printf("%d %d %d %d\n", a
> b
, a
< b
, a
>= b
, a
<= b
);
2484 printf(LONG_LONG_FORMAT
"\n", 0x123456789LLU
);
2486 /* long long pointer deref in argument passing test */
2492 void manyarg_test(void)
2494 LONG_DOUBLE ld
= 1234567891234LL;
2495 printf("manyarg_test:\n");
2496 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2497 1, 2, 3, 4, 5, 6, 7, 8,
2498 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2499 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2500 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2501 1, 2, 3, 4, 5, 6, 7, 8,
2502 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2503 1234567891234LL, 987654321986LL,
2505 printf("%Lf %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2506 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2507 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2508 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2509 1234567891234LL, 987654321986LL,
2511 printf("%d %d %d %d %d %d %d %d %Lf\n",
2512 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2513 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2514 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"%f %f %Lf\n",
2515 1, 2, 3, 4, 5, 6, 7, 8,
2516 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2517 1234567891234LL, 987654321986LL,
2519 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2520 "%Lf " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f %Lf\n",
2521 1, 2, 3, 4, 5, 6, 7, 8,
2522 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2523 ld
, 1234567891234LL, 987654321986LL,
2527 void vprintf1(const char *fmt
, ...)
2551 i
= va_arg(ap
, int);
2555 d
= va_arg(ap
, double);
2559 ll
= va_arg(ap
, long long);
2560 printf(LONG_LONG_FORMAT
, ll
);
2563 ld
= va_arg(ap
, LONG_DOUBLE
);
2581 void stdarg_for_struct(struct myspace bob
, ...)
2583 struct myspace george
, bill
;
2588 bill
= va_arg(ap
, struct myspace
);
2589 george
= va_arg(ap
, struct myspace
);
2590 validate
= va_arg(ap
, int);
2591 printf("stdarg_for_struct: %d %d %d %d\n",
2592 bob
.profile
, bill
.profile
, george
.profile
, validate
);
2596 void stdarg_for_libc(const char *fmt
, ...)
2599 va_start(args
, fmt
);
2604 void stdarg_test(void)
2606 LONG_DOUBLE ld
= 1234567891234LL;
2609 vprintf1("%d %d %d\n", 1, 2, 3);
2610 vprintf1("%f %d %f\n", 1.0, 2, 3.0);
2611 vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0);
2612 vprintf1("%F %F %F\n", LONG_DOUBLE_LITERAL(1.2), LONG_DOUBLE_LITERAL(2.3), LONG_DOUBLE_LITERAL(3.4));
2613 vprintf1("%d %f %l %F %d %f %l %F\n",
2614 1, 1.2, 3LL, LONG_DOUBLE_LITERAL(4.5), 6, 7.8, 9LL, LONG_DOUBLE_LITERAL(0.1));
2615 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f\n",
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);
2618 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2619 1, 2, 3, 4, 5, 6, 7, 8,
2620 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2621 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2623 1, 2, 3, 4, 5, 6, 7, 8,
2624 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2625 1234567891234LL, 987654321986LL,
2627 vprintf1("%F %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2629 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2630 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2631 1234567891234LL, 987654321986LL,
2633 vprintf1("%d %d %d %d %d %d %d %d %F\n",
2634 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2635 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2637 1, 2, 3, 4, 5, 6, 7, 8,
2638 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2639 1234567891234LL, 987654321986LL,
2641 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2642 "%F %l %l %f %f %F\n",
2643 1, 2, 3, 4, 5, 6, 7, 8,
2644 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2645 ld
, 1234567891234LL, 987654321986LL,
2649 stdarg_for_struct(bob
, bob
, bob
, bob
.profile
);
2650 stdarg_for_libc("stdarg_for_libc: %s %.2f %d\n", "string", 1.23, 456);
2653 void whitespace_test(void)
2659 ntf("whitspace:\n");\f\v
2663 #ifdef CORRECT_CR_HANDLING
2672 #ifdef ACCEPT_CR_IN_STRINGS
2673 printf("len1=%d\n", strlen("
2675 #ifdef CORRECT_CR_HANDLING
2678 printf("len1=%d str[0]=%d\n", strlen(str
), str
[0]);
2680 printf("len1=%d\n", strlen("
a
2682 #endif /* ACCEPT_CR_IN_STRINGS */
2685 int reltab
[3] = { 1, 2, 3 };
2687 int *rel1
= &reltab
[1];
2688 int *rel2
= &reltab
[2];
2691 void relocation_test(void) {}
2693 void getmyaddress(void)
2695 printf("in getmyaddress\n");
2699 long __pa_symbol(void)
2701 /* This 64bit constant was handled incorrectly, it was used as addend
2702 (which can hold 64bit just fine) in connection with a symbol,
2703 and TCC generates wrong code for that (displacements are 32bit only).
2704 This effectively is "+ 0x80000000", and if addresses of globals
2705 are below 2GB the result should be a number without high 32 bits set. */
2706 return ((long)(((unsigned long)(&rel1
))) - (0xffffffff80000000UL
));
2710 unsigned long theaddress
= (unsigned long)getmyaddress
;
2711 void relocation_test(void)
2713 void (*fptr
)(void) = (void (*)(void))theaddress
;
2714 printf("*rel1=%d\n", *rel1
);
2715 printf("*rel2=%d\n", *rel2
);
2718 printf("pa_symbol=0x%lx\n", __pa_symbol() >> 63);
2723 void old_style_f(a
,b
,c
)
2727 printf("a=%d b=%d b=%f\n", a
, b
, c
);
2730 void decl_func1(int cmpfn())
2732 printf("cmpfn=%lx\n", (long)cmpfn
);
2735 void decl_func2(cmpfn
)
2738 printf("cmpfn=%lx\n", (long)cmpfn
);
2741 void old_style_function(void)
2743 old_style_f((void *)1, 2, 3.0);
2750 #if defined __i386__ || defined __x86_64__ || defined __arm__
2751 char *p
= alloca(16);
2752 strcpy(p
,"123456789012345");
2753 printf("alloca: p is %s\n", p
);
2754 char *demo
= "This is only a test.\n";
2755 /* Test alloca embedded in a larger expression */
2756 printf("alloca: %s\n", strcpy(alloca(strlen(demo
)+1),demo
) );
2760 void *bounds_checking_is_enabled()
2762 char ca
[10], *cp
= ca
-1;
2763 return (ca
!= cp
+ 1) ? cp
: NULL
;
2766 typedef int constant_negative_array_size_as_compile_time_assertion_idiom
[(1 ? 2 : 0) - 1];
2768 void c99_vla_test(int size1
, int size2
)
2770 #if defined __i386__ || defined __x86_64__
2771 int size
= size1
* size2
;
2772 int tab1
[size
][2], tab2
[10][2];
2773 void *tab1_ptr
, *tab2_ptr
, *bad_ptr
;
2775 /* "size" should have been 'captured' at tab1 declaration,
2776 so modifying it should have no effect on VLA behaviour. */
2779 printf("Test C99 VLA 1 (sizeof): ");
2780 printf("%s\n", (sizeof tab1
== size1
* size2
* 2 * sizeof(int)) ? "PASSED" : "FAILED");
2783 printf("Test C99 VLA 2 (ptrs subtract): ");
2784 printf("%s\n", (tab2
- tab1
== (tab2_ptr
- tab1_ptr
) / (sizeof(int) * 2)) ? "PASSED" : "FAILED");
2785 printf("Test C99 VLA 3 (ptr add): ");
2786 printf("%s\n", &tab1
[5][1] == (tab1_ptr
+ (5 * 2 + 1) * sizeof(int)) ? "PASSED" : "FAILED");
2787 printf("Test C99 VLA 4 (ptr access): ");
2788 tab1
[size1
][1] = 42;
2789 printf("%s\n", (*((int *) (tab1_ptr
+ (size1
* 2 + 1) * sizeof(int))) == 42) ? "PASSED" : "FAILED");
2791 printf("Test C99 VLA 5 (bounds checking (might be disabled)): ");
2792 if (bad_ptr
= bounds_checking_is_enabled()) {
2793 int *t1
= &tab1
[size1
* size2
- 1][3];
2794 int *t2
= &tab2
[9][3];
2795 printf("%s ", bad_ptr
== t1
? "PASSED" : "FAILED");
2796 printf("%s ", bad_ptr
== t2
? "PASSED" : "FAILED");
2798 char*c1
= 1 + sizeof(tab1
) + (char*)tab1
;
2799 char*c2
= 1 + sizeof(tab2
) + (char*)tab2
;
2800 printf("%s ", bad_ptr
== c1
? "PASSED" : "FAILED");
2801 printf("%s ", bad_ptr
== c2
? "PASSED" : "FAILED");
2805 printf("%s ", bad_ptr
== i1
? "PASSED" : "FAILED");
2806 printf("%s ", bad_ptr
== i2
? "PASSED" : "FAILED");
2808 int *x1
= tab1
[size1
* size2
+ 1];
2809 int *x2
= tab2
[10 + 1];
2810 printf("%s ", bad_ptr
== x1
? "PASSED" : "FAILED");
2811 printf("%s ", bad_ptr
== x2
? "PASSED" : "FAILED");
2813 printf("PASSED PASSED PASSED PASSED PASSED PASSED PASSED PASSED ");
2820 typedef __SIZE_TYPE__
uintptr_t;
2823 void sizeof_test(void)
2828 printf("sizeof(int) = %d\n", sizeof(int));
2829 printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
2830 printf("sizeof(long) = %d\n", sizeof(long));
2831 printf("sizeof(unsigned long) = %d\n", sizeof(unsigned long));
2832 printf("sizeof(short) = %d\n", sizeof(short));
2833 printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
2834 printf("sizeof(char) = %d\n", sizeof(char));
2835 printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
2836 printf("sizeof(func) = %d\n", sizeof sizeof_test());
2838 printf("sizeof(a++) = %d\n", sizeof a
++);
2839 printf("a=%d\n", a
);
2841 printf("sizeof(**ptr) = %d\n", sizeof (**ptr
));
2843 /* The type of sizeof should be as large as a pointer, actually
2844 it should be size_t. */
2845 printf("sizeof(sizeof(int) = %d\n", sizeof(sizeof(int)));
2848 /* Effectively <<32, but defined also on 32bit machines. */
2852 /* This checks that sizeof really can be used to manipulate
2853 uintptr_t objects, without truncation. */
2854 t2
= t
& -sizeof(uintptr_t);
2855 printf ("%lu %lu\n", t
, t2
);
2857 /* some alignof tests */
2858 printf("__alignof__(int) = %d\n", __alignof__(int));
2859 printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int));
2860 printf("__alignof__(short) = %d\n", __alignof__(short));
2861 printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short));
2862 printf("__alignof__(char) = %d\n", __alignof__(char));
2863 printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char));
2864 printf("__alignof__(func) = %d\n", __alignof__
sizeof_test());
2866 /* sizes of VLAs need to be evaluated even inside sizeof: */
2868 printf("sizeof(char[1+2*a]) = %d\n", sizeof(char[1+2*a
]));
2869 /* And checking if sizeof compound literal works. Parenthesized: */
2870 printf("sizeof( (struct {int i; int j;}){4,5} ) = %d\n",
2871 sizeof( (struct {int i
; int j
;}){4,5} ));
2872 /* And as direct sizeof argument (as unary expression): */
2873 printf("sizeof (struct {short i; short j;}){4,5} = %d\n",
2874 sizeof (struct {short i
; short j
;}){4,5} );
2876 /* sizeof(x && y) should be sizeof(int), even if constant
2877 evaluating is possible. */
2878 printf("sizeof(t && 0) = %d\n", sizeof(t
&& 0));
2879 printf("sizeof(1 && 1) = %d\n", sizeof(1 && 1));
2880 printf("sizeof(t || 1) = %d\n", sizeof(t
|| 1));
2881 printf("sizeof(0 || 0) = %d\n", sizeof(0 || 0));
2884 void typeof_test(void)
2893 printf("a=%f b=%f c=%f\n", a
, b
, c
);
2899 struct hlist_node
*first
, *last
;
2902 void statement_expr_test(void)
2906 /* Basic stmt expr test */
2916 printf("a=%d\n", a
);
2918 /* Test that symbols aren't freed prematurely.
2919 With SYM_DEBUG valgrind will show a read from a freed
2920 symbol, and tcc will show an (invalid) warning on the initialization
2921 of 'ptr' below, if symbols are popped after the stmt expr. */
2922 void *v
= (void*)39;
2924 (struct hlist_node
*)v
;
2927 ptr
= (struct hlist_node
*)v
;
2929 /* This part used to segfault when symbols were popped prematurely.
2930 The symbols for the static local would be overwritten with
2931 helper symbols from the pre-processor expansions in between. */
2932 #define some_attr __attribute__((aligned(1)))
2933 #define tps(str) ({ \
2934 static const char *t some_attr = str; \
2937 printf ("stmtexpr: %s %s\n",
2938 tps("somerandomlongstring"),
2939 tps("anotherlongstring"));
2941 /* Test that the three decls of 't' don't interact. */
2943 int b
= ({ int t
= 41; t
; });
2944 int c
= ({ int t
= 42; t
; });
2946 /* Test that aggregate return values work. */
2949 typedef struct hlist_head T
;
2951 T t
= { (void*)43, (void*)44 };
2955 printf ("stmtexpr: %d %d %d\n", t
, b
, c
);
2956 printf ("stmtexpr: %ld %ld\n", (long)h
.first
, (long)h
.last
);
2959 void local_label_test(void)
2965 __label__ l1
, l2
, l3
, l4
;
2979 printf("a=%d\n", a
);
2989 /* inline assembler test */
2990 #if defined(__i386__) || defined(__x86_64__)
2992 /* from linux kernel */
2993 static char * strncat1(char * dest
,const char * src
,size_t count
)
2995 long d0
, d1
, d2
, d3
;
2996 __asm__
__volatile__(
3005 "testb %%al,%%al\n\t"
3009 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
3010 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
3015 static char * strncat2(char * dest
,const char * src
,size_t count
)
3017 long d0
, d1
, d2
, d3
;
3018 __asm__
__volatile__(
3019 "repne scasb\n\t" /* one-line repne prefix + string op */
3026 "testb %%al,%%al\n\t"
3030 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
3031 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
3036 static inline void * memcpy1(void * to
, const void * from
, size_t n
)
3039 __asm__
__volatile__(
3044 "1:\ttestb $1,%b4\n\t"
3048 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
3049 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
3054 static inline void * memcpy2(void * to
, const void * from
, size_t n
)
3057 __asm__
__volatile__(
3058 "rep movsl\n\t" /* one-line rep prefix + string op */
3062 "1:\ttestb $1,%b4\n\t"
3066 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
3067 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
3072 static __inline__
void sigaddset1(unsigned int *set
, int _sig
)
3074 __asm__("btsl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc");
3077 static __inline__
void sigdelset1(unsigned int *set
, int _sig
)
3079 asm("btrl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc", "flags");
3082 static __inline__ __const__
unsigned int swab32(unsigned int x
)
3084 __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */
3085 "rorl $16,%0\n\t" /* swap words */
3086 "xchgb %b0,%h0" /* swap higher bytes */
3092 static __inline__
unsigned long long mul64(unsigned int a
, unsigned int b
)
3094 unsigned long long res
;
3096 /* Using the A constraint is wrong (it means rdx:rax, which is too large)
3097 but still test the 32bit->64bit mull. */
3098 unsigned int resh
, resl
;
3099 __asm__("mull %2" : "=a" (resl
), "=d" (resh
) : "a" (a
), "r" (b
));
3100 res
= ((unsigned long long)resh
<< 32) | resl
;
3102 __asm__("mull %2" : "=A" (res
) : "a" (a
), "r" (b
));
3107 static __inline__
unsigned long long inc64(unsigned long long a
)
3109 unsigned long long res
;
3111 /* Using the A constraint is wrong, and increments are tested
3115 __asm__("addl $1, %%eax ; adcl $0, %%edx" : "=A" (res
) : "A" (a
));
3128 unsigned long mconstraint_test(struct struct1231
*r
)
3133 __asm__
volatile ("lea %2,%0; movl 4(%0),%k0; addl %2,%k0; movl $51,%2; movl $52,4%2; movl $63,%1"
3134 : "=&r" (ret
), "=m" (a
)
3135 : "m" (*(struct struct123
*)r
->addr
));
3140 int fls64(unsigned long long x
)
3150 void other_constraints_test(void)
3155 __asm__
volatile ("mov %P1,%0" : "=r" (ret
) : "p" (&var
));
3156 printf ("oc1: %d\n", ret
== (unsigned long)&var
);
3161 /* Test global asm blocks playing with aliases. */
3162 void base_func(void)
3164 printf ("asmc: base\n");
3167 extern void override_func1 (void);
3168 extern void override_func2 (void);
3170 asm(".weak override_func1\n.set override_func1, base_func");
3171 asm(".set override_func1, base_func");
3172 asm(".set override_func2, base_func");
3174 void override_func2 (void)
3176 printf ("asmc: override2\n");
3179 /* This checks a construct used by the linux kernel to encode
3180 references to strings by PC relative references. */
3181 extern int bug_table
[] __attribute__((section("__bug_table")));
3182 char * get_asm_string (void)
3184 extern int some_symbol
;
3185 asm volatile (".globl some_symbol\n"
3188 "some_symbol: .long 0\n"
3189 ".pushsection __bug_table, \"a\"\n"
3190 ".globl bug_table\n"
3192 /* The first entry (1b-2b) is unused in this test,
3193 but we include it to check if cross-section
3194 PC-relative references work. */
3195 "2:\t.long 1b - 2b, %c0 - 2b\n"
3196 ".popsection\n" : : "i" ("A string"));
3197 char * str
= ((char*)bug_table
) + bug_table
[1];
3204 void fancy_copy (unsigned *in
, unsigned *out
)
3206 asm volatile ("" : "=r" (*out
) : "0" (*in
));
3209 void fancy_copy2 (unsigned *in
, unsigned *out
)
3211 asm volatile ("mov %0,(%1)" : : "r" (*in
), "r" (out
) : "memory");
3215 void clobber_r12(void)
3217 asm volatile("mov $1, %%r12" ::: "r12");
3221 void test_high_clobbers(void)
3224 register long val
asm("r12");
3226 /* This tests if asm clobbers correctly save/restore callee saved
3227 registers if they are clobbered and if it's the high 8 x86-64
3228 registers. This is fragile for GCC as the constraints do not
3229 correctly capture the data flow, but good enough for us. */
3230 asm volatile("mov $0x4542, %%r12" : "=r" (val
):: "memory");
3233 asm volatile("mov %%r12, %0" : "=r" (val2
) : "r" (val
): "memory");
3234 printf("asmhc: 0x%x\n", val2
);
3239 static long cpu_number
;
3240 void trace_console(long len
, long len2
)
3243 /* This generated invalid code when the emission of the switch
3244 table isn't disabled. The asms are necessary to show the bug,
3245 normal statements don't work (they need to generate some code
3246 even under nocode_wanted, which normal statements don't do,
3247 but asms do). Also at least these number of cases is necessary
3248 to generate enough "random" bytes. They ultimately are enough
3249 to create invalid instruction patterns to which the first
3250 skip-to-decision-table jump jumps. If decision table emission
3251 is disabled all of this is no problem.
3253 It also is necessary that the switches are in a statement expression
3254 (which has the property of not being enterable from outside. no
3265 case 8: printf("bla"); pfo_ret__
= 42; break;
3267 pscr_ret__
= pfo_ret__
;
3274 case 1:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3275 case 2:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3276 case 4:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3277 case 8:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3278 default: printf("impossible\n");
3280 pscr_ret__
= pfo_ret__
;
3292 void test_asm_dead_code(void)
3295 /* Try to make sure that xdi contains a zero, and hence will
3296 lead to a segfault if the next asm is evaluated without
3297 arguments being set up. */
3298 asm volatile ("" : "=D" (rdi
) : "0" (0));
3301 /* This shouldn't trigger a segfault, either the argument
3302 registers need to be set up and the asm emitted despite
3303 this being in an unevaluated context, or both the argument
3304 setup _and_ the asm emission need to be suppressed. The latter
3305 is better. Disabling asm code gen when suppression is on
3306 also fixes the above trace_console bug, but that came earlier
3307 than asm suppression. */
3308 asm volatile ("movl $0,(%0)" : : "D" (&var
) : "memory");
3316 unsigned int val
, val2
;
3317 struct struct123 s1
;
3318 struct struct1231 s2
= { (unsigned long)&s1
};
3319 /* Hide the outer base_func, but check later that the inline
3320 asm block gets the outer one. */
3322 void override_func3 (void);
3323 unsigned long asmret
;
3327 register int regvar
asm("%esi");
3329 printf("inline asm:\n");
3331 // parse 0x1E-1 as 3 tokens in asm mode
3332 asm volatile ("mov $0x1E-1,%eax");
3334 /* test the no operand case */
3335 asm volatile ("xorl %eax, %eax");
3337 memcpy1(buf
, "hello", 6);
3338 strncat1(buf
, " worldXXXXX", 3);
3339 printf("%s\n", buf
);
3341 memcpy2(buf
, "hello", 6);
3342 strncat2(buf
, " worldXXXXX", 3);
3343 printf("%s\n", buf
);
3345 /* 'A' constraint test */
3346 printf("mul64=0x%Lx\n", mul64(0x12345678, 0xabcd1234));
3347 printf("inc64=0x%Lx\n", inc64(0x12345678ffffffff));
3351 printf("mconstraint: %d", mconstraint_test(&s2
));
3352 printf(" %d %d\n", s1
.a
, s1
.b
);
3353 other_constraints_test();
3355 sigdelset1(&set
, 2);
3356 sigaddset1(&set
, 16);
3357 /* NOTE: we test here if C labels are correctly restored after the
3361 __asm__("btsl %1,%0" : "=m"(set
) : "Ir"(20) : "cc");
3362 printf("set=0x%x\n", set
);
3364 printf("swab32(0x%08x) = 0x%0x\n", val
, swab32(val
));
3368 /* The base_func ref from the following inline asm should find
3369 the global one, not the local decl from this function. */
3370 asm volatile(".weak override_func3\n.set override_func3, base_func");
3372 printf("asmstr: %s\n", get_asm_string());
3374 /* Check that we can also load structs of appropriate layout
3376 asm volatile("" : "=r" (asmret
) : "0"(s2
));
3377 if (asmret
!= s2
.addr
)
3378 printf("asmstr: failed\n");
3380 /* Check that the typesize correctly sets the register size to
3382 asm volatile("cmp %1,%2; sete %0" : "=a"(somebool
) : "r"(1), "r"(2));
3384 printf("asmbool: failed\n");
3387 fancy_copy (&val
, &val2
);
3388 printf ("fancycpy(%d)=%d\n", val
, val2
);
3390 fancy_copy2 (&val
, &val2
);
3391 printf ("fancycpy2(%d)=%d\n", val
, val2
);
3392 asm volatile ("mov $0x4243, %%esi" : "=r" (regvar
));
3393 printf ("regvar=%x\n", regvar
);
3394 test_high_clobbers();
3395 trace_console(8, 8);
3396 test_asm_dead_code();
3410 #define COMPAT_TYPE(type1, type2) \
3412 printf("__builtin_types_compatible_p(%s, %s) = %d\n", #type1, #type2, \
3413 __builtin_types_compatible_p (type1, type2));\
3418 void builtin_test(void)
3424 COMPAT_TYPE(int, int);
3425 COMPAT_TYPE(int, unsigned int);
3426 COMPAT_TYPE(int, char);
3427 COMPAT_TYPE(int, const int);
3428 COMPAT_TYPE(int, volatile int);
3429 COMPAT_TYPE(int *, int *);
3430 COMPAT_TYPE(int *, void *);
3431 COMPAT_TYPE(int *, const int *);
3432 COMPAT_TYPE(char *, unsigned char *);
3433 COMPAT_TYPE(char *, signed char *);
3434 COMPAT_TYPE(char *, char *);
3435 /* space is needed because tcc preprocessor introduces a space between each token */
3436 COMPAT_TYPE(char * *, void *);
3438 printf("res = %d\n", __builtin_constant_p(1));
3439 printf("res = %d\n", __builtin_constant_p(1 + 2));
3440 printf("res = %d\n", __builtin_constant_p(&constant_p_var
));
3441 printf("res = %d\n", __builtin_constant_p(constant_p_var
));
3442 printf("res = %d\n", __builtin_constant_p(100000 / constant_p_var
));
3445 i
= __builtin_choose_expr (1 != 0, ll
, s
);
3446 printf("bce: %d\n", i
);
3447 i
= __builtin_choose_expr (1 != 1, ll
, s
);
3448 printf("bce: %d\n", i
);
3449 i
= sizeof (__builtin_choose_expr (1, ll
, s
));
3450 printf("bce: %d\n", i
);
3451 i
= sizeof (__builtin_choose_expr (0, ll
, s
));
3452 printf("bce: %d\n", i
);
3454 //printf("bera: %p\n", __builtin_extract_return_addr((void*)43));
3458 extern int __attribute__((weak
)) weak_f1(void);
3459 extern int __attribute__((weak
)) weak_f2(void);
3460 extern int weak_f3(void);
3461 extern int __attribute__((weak
)) weak_v1
;
3462 extern int __attribute__((weak
)) weak_v2
;
3465 extern int (*weak_fpa
)() __attribute__((weak
));
3466 extern int __attribute__((weak
)) (*weak_fpb
)();
3467 extern __attribute__((weak
)) int (*weak_fpc
)();
3469 extern int weak_asm_f1(void) asm("weak_asm_f1x") __attribute((weak
));
3470 extern int __attribute((weak
)) weak_asm_f2(void) asm("weak_asm_f2x") ;
3471 extern int __attribute((weak
)) weak_asm_f3(void) asm("weak_asm_f3x") __attribute((weak
));
3472 extern int weak_asm_v1
asm("weak_asm_v1x") __attribute((weak
));
3473 extern int __attribute((weak
)) weak_asm_v2
asm("weak_asm_v2x") ;
3474 extern int __attribute((weak
)) weak_asm_v3(void) asm("weak_asm_v3x") __attribute((weak
));
3476 static const size_t dummy
= 0;
3477 extern __typeof(dummy
) weak_dummy1
__attribute__((weak
, alias("dummy")));
3478 extern __typeof(dummy
) __attribute__((weak
, alias("dummy"))) weak_dummy2
;
3479 extern __attribute__((weak
, alias("dummy"))) __typeof(dummy
) weak_dummy3
;
3481 int some_lib_func(void);
3482 int dummy_impl_of_slf(void) { return 444; }
3483 int some_lib_func(void) __attribute__((weak
, alias("dummy_impl_of_slf")));
3485 int weak_toolate() __attribute__((weak
));
3486 int weak_toolate() { return 0; }
3488 void __attribute__((weak
)) weak_test(void)
3490 printf("weak_f1=%d\n", weak_f1
? weak_f1() : 123);
3491 printf("weak_f2=%d\n", weak_f2
? weak_f2() : 123);
3492 printf("weak_f3=%d\n", weak_f3
? weak_f3() : 123);
3493 printf("weak_v1=%d\n",&weak_v1
? weak_v1
: 123);
3494 printf("weak_v2=%d\n",&weak_v2
? weak_v2
: 123);
3495 printf("weak_v3=%d\n",&weak_v3
? weak_v3
: 123);
3497 printf("weak_fpa=%d\n",&weak_fpa
? weak_fpa() : 123);
3498 printf("weak_fpb=%d\n",&weak_fpb
? weak_fpb() : 123);
3499 printf("weak_fpc=%d\n",&weak_fpc
? weak_fpc() : 123);
3501 printf("weak_asm_f1=%d\n", weak_asm_f1
!= NULL
);
3502 printf("weak_asm_f2=%d\n", weak_asm_f2
!= NULL
);
3503 printf("weak_asm_f3=%d\n", weak_asm_f3
!= NULL
);
3504 printf("weak_asm_v1=%d\n",&weak_asm_v1
!= NULL
);
3505 printf("weak_asm_v2=%d\n",&weak_asm_v2
!= NULL
);
3506 printf("weak_asm_v3=%d\n",&weak_asm_v3
!= NULL
);
3507 printf("some_lib_func=%d\n", &some_lib_func
? some_lib_func() : 0);
3510 int __attribute__((weak
)) weak_f2() { return 222; }
3511 int __attribute__((weak
)) weak_f3() { return 333; }
3512 int __attribute__((weak
)) weak_v2
= 222;
3513 int __attribute__((weak
)) weak_v3
= 333;
3516 void const_func(const int a
)
3520 void const_warn_test(void)
3529 int getme (struct condstruct
*s
, int i
)
3531 int i1
= (i
== 0 ? 0 : s
)->i
;
3532 int i2
= (i
== 0 ? s
: 0)->i
;
3533 int i3
= (i
== 0 ? (void*)0 : s
)->i
;
3534 int i4
= (i
== 0 ? s
: (void*)0)->i
;
3535 return i1
+ i2
+ i3
+ i4
;
3544 struct global_data global_data
;
3546 int global_data_getstuff (int *, int);
3548 void global_data_callit (int i
)
3550 *global_data
.b
[i
] = global_data_getstuff (global_data
.b
[i
], 1);
3553 int global_data_getstuff (int *p
, int i
)
3558 void global_data_test (void)
3560 global_data
.a
[0] = 42;
3561 global_data
.b
[0] = &global_data
.a
[0];
3562 global_data_callit (0);
3563 printf ("%d\n", global_data
.a
[0]);
3568 unsigned char fill
: 3;
3569 unsigned char b1
: 1;
3570 unsigned char b2
: 1;
3571 unsigned char fill2
: 3;
3574 int glob1
, glob2
, glob3
;
3576 void compare_comparisons (struct cmpcmpS
*s
)
3578 if (s
->b1
!= (glob1
== glob2
)
3579 || (s
->b2
!= (glob1
== glob3
)))
3580 printf ("comparing comparisons broken\n");
3583 void cmp_comparison_test(void)
3587 glob1
= 42; glob2
= 42;
3590 compare_comparisons (&s
);
3593 int fcompare (double a
, double b
, int code
)
3596 case 0: return a
== b
;
3597 case 1: return a
!= b
;
3598 case 2: return a
< b
;
3599 case 3: return a
>= b
;
3600 case 4: return a
> b
;
3601 case 5: return a
<= b
;
3605 void math_cmp_test(void)
3607 double nan
= 0.0/0.0;
3611 #define bug(a,b,op,iop,part) printf("Test broken: %s %s %s %s %d\n", #a, #b, #op, #iop, part)
3613 /* This asserts that "a op b" is _not_ true, but "a iop b" is true.
3614 And it does this in various ways so that all code generation paths
3615 are checked (generating inverted tests, or non-inverted tests, or
3616 producing a 0/1 value without jumps (that's done in the fcompare
3618 #define FCMP(a,b,op,iop,code) \
3619 if (fcompare (a,b,code)) \
3620 bug (a,b,op,iop,1); \
3622 bug (a,b,op,iop,2); \
3626 bug (a,b,op,iop,3); \
3627 if ((a op b) || comp) \
3628 bug (a,b,op,iop,4); \
3629 if ((a iop b) || comp) \
3634 /* Equality tests. */
3635 FCMP(nan
, nan
, ==, !=, 0);
3636 FCMP(one
, two
, ==, !=, 0);
3637 FCMP(one
, one
, !=, ==, 1);
3638 /* Non-equality is a bit special. */
3639 if (!fcompare (nan
, nan
, 1))
3640 bug (nan
, nan
, !=, ==, 6);
3642 /* Relational tests on numbers. */
3643 FCMP(two
, one
, <, >=, 2);
3644 FCMP(one
, two
, >=, <, 3);
3645 FCMP(one
, two
, >, <=, 4);
3646 FCMP(two
, one
, <=, >, 5);
3648 /* Relational tests on NaNs. Note that the inverse op here is
3649 always !=, there's no operator in C that is equivalent to !(a < b),
3650 when NaNs are involved, same for the other relational ops. */
3651 FCMP(nan
, nan
, <, !=, 2);
3652 FCMP(nan
, nan
, >=, !=, 3);
3653 FCMP(nan
, nan
, >, !=, 4);
3654 FCMP(nan
, nan
, <=, !=, 5);
3657 double get100 () { return 100.0; }
3659 void callsave_test(void)
3661 #if defined __i386__ || defined __x86_64__ || defined __arm__
3662 int i
, s
; double *d
; double t
;
3663 s
= sizeof (double);
3664 printf ("callsavetest: %d\n", s
);
3665 d
= alloca (sizeof(double));
3667 /* x86-64 had a bug were the next call to get100 would evict
3668 the lvalue &d[0] as VT_LLOCAL, and the reload would be done
3669 in int type, not pointer type. When alloca returns a pointer
3670 with the high 32 bit set (which is likely on x86-64) the access
3671 generates a segfault. */
3672 i
= d
[0] > get100 ();
3678 void bfa3(ptrdiff_t str_offset
)
3680 printf("bfa3: %s\n", (char *)__builtin_frame_address(3) + str_offset
);
3682 void bfa2(ptrdiff_t str_offset
)
3684 printf("bfa2: %s\n", (char *)__builtin_frame_address(2) + str_offset
);
3687 void bfa1(ptrdiff_t str_offset
)
3689 printf("bfa1: %s\n", (char *)__builtin_frame_address(1) + str_offset
);
3693 void builtin_frame_address_test(void)
3695 /* builtin_frame_address fails on ARM with gcc which make test3 fail */
3697 char str
[] = "__builtin_frame_address";
3698 char *fp0
= __builtin_frame_address(0);
3700 printf("str: %s\n", str
);
3705 char via_volatile (char i
)
3712 struct __attribute__((__packed__
)) Spacked
{
3717 struct Spacked spacked
;
3718 typedef struct __attribute__((__packed__
)) {
3724 typedef struct Spacked3_s
{
3728 } __attribute__((__packed__
)) Spacked3
;
3730 struct gate_struct64
{
3731 unsigned short offset_low
;
3732 unsigned short segment
;
3733 unsigned ist
: 3, zero0
: 5, type
: 5, dpl
: 2, p
: 1;
3734 unsigned short offset_middle
;
3735 unsigned offset_high
;
3737 } __attribute__((packed
));
3738 typedef struct gate_struct64 gate_desc
;
3739 gate_desc a_gate_desc
;
3740 void attrib_test(void)
3743 printf("attr: %d %d %d %d\n", sizeof(struct Spacked
),
3744 sizeof(spacked
), sizeof(Spacked2
), sizeof(spacked2
));
3745 printf("attr: %d %d\n", sizeof(Spacked3
), sizeof(spacked3
));
3746 printf("attr: %d %d\n", sizeof(gate_desc
), sizeof(a_gate_desc
));
3749 extern __attribute__((__unused__
)) char * __attribute__((__unused__
)) *
3750 strange_attrib_placement (void);
3752 void * __attribute__((__unused__
)) get_void_ptr (void *a
)
3757 /* This part checks for a bug in TOK_GET (used for inline expansion),
3758 where the large long long constant left the the high bits set for
3759 the integer constant token. */
3761 int __get_order(unsigned long long size
)
3764 size
-= 0xffff880000000000ULL
; // this const left high bits set in the token
3766 struct S
{ int i
: 1; } s
; // constructed for this '1'
3772 /* This just forces the above inline function to be actually emitted. */
3773 int force_get_order(unsigned long s
)
3775 return __get_order(s
);