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 substitution 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 parentheses 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
1053 a copy of it). -- FIXED */
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)
2237 static double nan2
= 0.0/0.0;
2238 static double inf1
= 1.0/0.0;
2239 static double inf2
= 1e5000
;
2241 printf("float_test:\n");
2242 printf("sizeof(float) = %d\n", sizeof(float));
2243 printf("sizeof(double) = %d\n", sizeof(double));
2244 printf("sizeof(long double) = %d\n", sizeof(LONG_DOUBLE
));
2248 printf("%f %f %f\n", ftab1
[0], ftab1
[1], ftab1
[2]);
2249 printf("%f %f %f\n", 2.12, .5, 2.3e10
);
2250 // printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
2252 printf("da=%f\n", da
);
2254 printf("fa=%f\n", fa
);
2257 printf("da = %f\n", da
);
2260 printf("db = %f\n", db
);
2261 printf("nan != nan = %d, inf1 = %f, inf2 = %f\n", nan2
!= nan2
, inf1
, inf2
);
2270 return fib(n
-1) + fib(n
-2);
2273 void __attribute__((aligned(16))) aligned_function(int i
) {}
2285 printf("funcptr:\n");
2292 /* more complicated pointer computation */
2295 printf("sizeof1 = %d\n", sizeof(funcptr_test
));
2296 printf("sizeof2 = %d\n", sizeof funcptr_test
);
2297 printf("sizeof3 = %d\n", sizeof(&funcptr_test
));
2298 printf("sizeof4 = %d\n", sizeof &funcptr_test
);
2306 /* Check that we can align functions */
2307 func
= aligned_function
;
2308 printf("aligned_function (should be zero): %d\n", ((int)func
) & 15);
2311 void lloptest(long long a
, long long b
)
2313 unsigned long long ua
, ub
;
2318 printf("arith: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2324 printf("arith1: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2330 printf("bin: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2336 printf("test: %d %d %d %d %d %d\n",
2344 printf("utest: %d %d %d %d %d %d\n",
2355 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2356 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
++, b
++);
2357 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", --a
, --b
);
2358 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2360 printf("not: %d %d %d %d\n", !a
, !ua
, !b
, !ub
);
2363 void llshift(long long a
, int b
)
2365 printf("shift: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2366 (unsigned long long)a
>> b
,
2369 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2370 (unsigned long long)a
>> 3,
2373 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2374 (unsigned long long)a
>> 35,
2384 long long la
, lb
, lc
;
2385 unsigned long long ula
, ulb
, ulc
;
2388 la
= (la
<< 20) | 0x12345;
2390 printf("la=" LONG_LONG_FORMAT
" ula=" ULONG_LONG_FORMAT
"\n", la
, ula
);
2395 printf("lltof: %f %f %Lf\n", fa
, da
, lda
);
2400 printf("ftoll: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", la
, lb
, lc
);
2405 printf("ulltof: %f %f %Lf\n", fa
, da
, lda
);
2410 printf("ftoull: " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
"\n", ula
, ulb
, ulc
);
2413 long long llfunc1(int a
)
2423 long long int value(struct S
*v
)
2425 return ((long long int)v
->item
);
2428 long long llfunc2(long long x
, long long y
, int z
)
2433 void longlong_test(void)
2438 printf("longlong_test:\n");
2439 printf("sizeof(long long) = %d\n", sizeof(long long));
2444 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2445 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %Lx\n",
2449 0x1234567812345679);
2451 printf(LONG_LONG_FORMAT
"\n", a
);
2454 lloptest(0xff, 0x1234);
2455 b
= 0x72345678 << 10;
2459 b
= 0x72345678LL
<< 10;
2470 /* long long reg spill test */
2475 printf("%lld\n", value(&a
));
2477 lloptest(0x80000000, 0);
2480 long long *p
, v
, **pp
;
2484 printf("another long long spill test : %lld\n", *p
);
2487 v
= llfunc2(**pp
, **pp
, ia
);
2488 printf("a long long function (arm-)reg-args test : %lld\n", v
);
2492 printf("%d %d %d %d\n", a
> b
, a
< b
, a
>= b
, a
<= b
);
2494 printf(LONG_LONG_FORMAT
"\n", 0x123456789LLU
);
2496 /* long long pointer deref in argument passing test */
2501 /* shortening followed by widening */
2502 unsigned long long u
= 0x8000000000000001ULL
;
2503 u
= (unsigned)(u
+ 1);
2504 printf("long long u=" ULONG_LONG_FORMAT
"\n", u
);
2507 void manyarg_test(void)
2509 LONG_DOUBLE ld
= 1234567891234LL;
2510 printf("manyarg_test:\n");
2511 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2512 1, 2, 3, 4, 5, 6, 7, 8,
2513 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2514 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2515 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2516 1, 2, 3, 4, 5, 6, 7, 8,
2517 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2518 1234567891234LL, 987654321986LL,
2520 printf("%Lf %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2521 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2522 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2523 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2524 1234567891234LL, 987654321986LL,
2526 printf("%d %d %d %d %d %d %d %d %Lf\n",
2527 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2528 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2529 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"%f %f %Lf\n",
2530 1, 2, 3, 4, 5, 6, 7, 8,
2531 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2532 1234567891234LL, 987654321986LL,
2534 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2535 "%Lf " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f %Lf\n",
2536 1, 2, 3, 4, 5, 6, 7, 8,
2537 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2538 ld
, 1234567891234LL, 987654321986LL,
2542 void vprintf1(const char *fmt
, ...)
2566 i
= va_arg(ap
, int);
2570 d
= va_arg(ap
, double);
2574 ll
= va_arg(ap
, long long);
2575 printf(LONG_LONG_FORMAT
, ll
);
2578 ld
= va_arg(ap
, LONG_DOUBLE
);
2596 void stdarg_for_struct(struct myspace bob
, ...)
2598 struct myspace george
, bill
;
2603 bill
= va_arg(ap
, struct myspace
);
2604 george
= va_arg(ap
, struct myspace
);
2605 validate
= va_arg(ap
, int);
2606 printf("stdarg_for_struct: %d %d %d %d\n",
2607 bob
.profile
, bill
.profile
, george
.profile
, validate
);
2611 void stdarg_for_libc(const char *fmt
, ...)
2614 va_start(args
, fmt
);
2619 void stdarg_test(void)
2621 LONG_DOUBLE ld
= 1234567891234LL;
2624 vprintf1("%d %d %d\n", 1, 2, 3);
2625 vprintf1("%f %d %f\n", 1.0, 2, 3.0);
2626 vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0);
2627 vprintf1("%F %F %F\n", LONG_DOUBLE_LITERAL(1.2), LONG_DOUBLE_LITERAL(2.3), LONG_DOUBLE_LITERAL(3.4));
2628 vprintf1("%d %f %l %F %d %f %l %F\n",
2629 1, 1.2, 3LL, LONG_DOUBLE_LITERAL(4.5), 6, 7.8, 9LL, LONG_DOUBLE_LITERAL(0.1));
2630 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f\n",
2631 1, 2, 3, 4, 5, 6, 7, 8,
2632 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8);
2633 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2634 1, 2, 3, 4, 5, 6, 7, 8,
2635 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2636 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2638 1, 2, 3, 4, 5, 6, 7, 8,
2639 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2640 1234567891234LL, 987654321986LL,
2642 vprintf1("%F %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2644 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2645 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2646 1234567891234LL, 987654321986LL,
2648 vprintf1("%d %d %d %d %d %d %d %d %F\n",
2649 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2650 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2652 1, 2, 3, 4, 5, 6, 7, 8,
2653 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2654 1234567891234LL, 987654321986LL,
2656 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2657 "%F %l %l %f %f %F\n",
2658 1, 2, 3, 4, 5, 6, 7, 8,
2659 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2660 ld
, 1234567891234LL, 987654321986LL,
2664 stdarg_for_struct(bob
, bob
, bob
, bob
.profile
);
2665 stdarg_for_libc("stdarg_for_libc: %s %.2f %d\n", "string", 1.23, 456);
2668 void whitespace_test(void)
2674 ntf("whitspace:\n");\f\v
2678 #ifdef CORRECT_CR_HANDLING
2687 #ifdef ACCEPT_CR_IN_STRINGS
2688 printf("len1=%d\n", strlen("
2690 #ifdef CORRECT_CR_HANDLING
2693 printf("len1=%d str[0]=%d\n", strlen(str
), str
[0]);
2695 printf("len1=%d\n", strlen("
a
2697 #endif /* ACCEPT_CR_IN_STRINGS */
2700 int reltab
[3] = { 1, 2, 3 };
2702 int *rel1
= &reltab
[1];
2703 int *rel2
= &reltab
[2];
2706 void relocation_test(void) {}
2708 void getmyaddress(void)
2710 printf("in getmyaddress\n");
2714 long __pa_symbol(void)
2716 /* This 64bit constant was handled incorrectly, it was used as addend
2717 (which can hold 64bit just fine) in connection with a symbol,
2718 and TCC generates wrong code for that (displacements are 32bit only).
2719 This effectively is "+ 0x80000000", and if addresses of globals
2720 are below 2GB the result should be a number without high 32 bits set. */
2721 return ((long)(((unsigned long)(&rel1
))) - (0xffffffff80000000UL
));
2725 unsigned long theaddress
= (unsigned long)getmyaddress
;
2726 void relocation_test(void)
2728 void (*fptr
)(void) = (void (*)(void))theaddress
;
2729 printf("*rel1=%d\n", *rel1
);
2730 printf("*rel2=%d\n", *rel2
);
2733 printf("pa_symbol=0x%lx\n", __pa_symbol() >> 63);
2738 void old_style_f(a
,b
,c
)
2742 printf("a=%d b=%d b=%f\n", a
, b
, c
);
2745 void decl_func1(int cmpfn())
2747 printf("cmpfn=%lx\n", (long)cmpfn
);
2750 void decl_func2(cmpfn
)
2753 printf("cmpfn=%lx\n", (long)cmpfn
);
2756 void old_style_function(void)
2758 old_style_f((void *)1, 2, 3.0);
2765 #if defined __i386__ || defined __x86_64__ || defined __arm__
2766 char *p
= alloca(16);
2767 strcpy(p
,"123456789012345");
2768 printf("alloca: p is %s\n", p
);
2769 char *demo
= "This is only a test.\n";
2770 /* Test alloca embedded in a larger expression */
2771 printf("alloca: %s\n", strcpy(alloca(strlen(demo
)+1),demo
) );
2775 void *bounds_checking_is_enabled()
2777 char ca
[10], *cp
= ca
-1;
2778 return (ca
!= cp
+ 1) ? cp
: NULL
;
2781 typedef int constant_negative_array_size_as_compile_time_assertion_idiom
[(1 ? 2 : 0) - 1];
2783 void c99_vla_test(int size1
, int size2
)
2785 #if defined __i386__ || defined __x86_64__
2786 int size
= size1
* size2
;
2787 int tab1
[size
][2], tab2
[10][2];
2788 void *tab1_ptr
, *tab2_ptr
, *bad_ptr
;
2790 /* "size" should have been 'captured' at tab1 declaration,
2791 so modifying it should have no effect on VLA behaviour. */
2794 printf("Test C99 VLA 1 (sizeof): ");
2795 printf("%s\n", (sizeof tab1
== size1
* size2
* 2 * sizeof(int)) ? "PASSED" : "FAILED");
2798 printf("Test C99 VLA 2 (ptrs subtract): ");
2799 printf("%s\n", (tab2
- tab1
== (tab2_ptr
- tab1_ptr
) / (sizeof(int) * 2)) ? "PASSED" : "FAILED");
2800 printf("Test C99 VLA 3 (ptr add): ");
2801 printf("%s\n", &tab1
[5][1] == (tab1_ptr
+ (5 * 2 + 1) * sizeof(int)) ? "PASSED" : "FAILED");
2802 printf("Test C99 VLA 4 (ptr access): ");
2803 tab1
[size1
][1] = 42;
2804 printf("%s\n", (*((int *) (tab1_ptr
+ (size1
* 2 + 1) * sizeof(int))) == 42) ? "PASSED" : "FAILED");
2806 printf("Test C99 VLA 5 (bounds checking (might be disabled)): ");
2807 if (bad_ptr
= bounds_checking_is_enabled()) {
2808 int *t1
= &tab1
[size1
* size2
- 1][3];
2809 int *t2
= &tab2
[9][3];
2810 printf("%s ", bad_ptr
== t1
? "PASSED" : "FAILED");
2811 printf("%s ", bad_ptr
== t2
? "PASSED" : "FAILED");
2813 char*c1
= 1 + sizeof(tab1
) + (char*)tab1
;
2814 char*c2
= 1 + sizeof(tab2
) + (char*)tab2
;
2815 printf("%s ", bad_ptr
== c1
? "PASSED" : "FAILED");
2816 printf("%s ", bad_ptr
== c2
? "PASSED" : "FAILED");
2820 printf("%s ", bad_ptr
== i1
? "PASSED" : "FAILED");
2821 printf("%s ", bad_ptr
== i2
? "PASSED" : "FAILED");
2823 int *x1
= tab1
[size1
* size2
+ 1];
2824 int *x2
= tab2
[10 + 1];
2825 printf("%s ", bad_ptr
== x1
? "PASSED" : "FAILED");
2826 printf("%s ", bad_ptr
== x2
? "PASSED" : "FAILED");
2828 printf("PASSED PASSED PASSED PASSED PASSED PASSED PASSED PASSED ");
2835 typedef __SIZE_TYPE__
uintptr_t;
2838 void sizeof_test(void)
2843 printf("sizeof(int) = %d\n", sizeof(int));
2844 printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
2845 printf("sizeof(long) = %d\n", sizeof(long));
2846 printf("sizeof(unsigned long) = %d\n", sizeof(unsigned long));
2847 printf("sizeof(short) = %d\n", sizeof(short));
2848 printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
2849 printf("sizeof(char) = %d\n", sizeof(char));
2850 printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
2851 printf("sizeof(func) = %d\n", sizeof sizeof_test());
2853 printf("sizeof(a++) = %d\n", sizeof a
++);
2854 printf("a=%d\n", a
);
2856 printf("sizeof(**ptr) = %d\n", sizeof (**ptr
));
2858 /* The type of sizeof should be as large as a pointer, actually
2859 it should be size_t. */
2860 printf("sizeof(sizeof(int) = %d\n", sizeof(sizeof(int)));
2863 /* Effectively <<32, but defined also on 32bit machines. */
2867 /* This checks that sizeof really can be used to manipulate
2868 uintptr_t objects, without truncation. */
2869 t2
= t
& -sizeof(uintptr_t);
2870 printf ("%lu %lu\n", t
, t2
);
2872 /* some alignof tests */
2873 printf("__alignof__(int) = %d\n", __alignof__(int));
2874 printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int));
2875 printf("__alignof__(short) = %d\n", __alignof__(short));
2876 printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short));
2877 printf("__alignof__(char) = %d\n", __alignof__(char));
2878 printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char));
2879 printf("__alignof__(func) = %d\n", __alignof__
sizeof_test());
2881 /* sizes of VLAs need to be evaluated even inside sizeof: */
2883 printf("sizeof(char[1+2*a]) = %d\n", sizeof(char[1+2*a
]));
2884 /* And checking if sizeof compound literal works. Parenthesized: */
2885 printf("sizeof( (struct {int i; int j;}){4,5} ) = %d\n",
2886 sizeof( (struct {int i
; int j
;}){4,5} ));
2887 /* And as direct sizeof argument (as unary expression): */
2888 printf("sizeof (struct {short i; short j;}){4,5} = %d\n",
2889 sizeof (struct {short i
; short j
;}){4,5} );
2891 /* sizeof(x && y) should be sizeof(int), even if constant
2892 evaluating is possible. */
2893 printf("sizeof(t && 0) = %d\n", sizeof(t
&& 0));
2894 printf("sizeof(1 && 1) = %d\n", sizeof(1 && 1));
2895 printf("sizeof(t || 1) = %d\n", sizeof(t
|| 1));
2896 printf("sizeof(0 || 0) = %d\n", sizeof(0 || 0));
2899 void typeof_test(void)
2908 printf("a=%f b=%f c=%f\n", a
, b
, c
);
2914 struct hlist_node
*first
, *last
;
2917 void consume_ulong (unsigned long i
)
2922 void statement_expr_test(void)
2926 /* Basic stmt expr test */
2936 printf("a=%d\n", a
);
2938 /* Test that symbols aren't freed prematurely.
2939 With SYM_DEBUG valgrind will show a read from a freed
2940 symbol, and tcc will show an (invalid) warning on the initialization
2941 of 'ptr' below, if symbols are popped after the stmt expr. */
2942 void *v
= (void*)39;
2944 (struct hlist_node
*)v
;
2947 ptr
= (struct hlist_node
*)v
;
2949 /* This part used to segfault when symbols were popped prematurely.
2950 The symbols for the static local would be overwritten with
2951 helper symbols from the pre-processor expansions in between. */
2952 #define some_attr __attribute__((aligned(1)))
2953 #define tps(str) ({ \
2954 static const char *t some_attr = str; \
2957 printf ("stmtexpr: %s %s\n",
2958 tps("somerandomlongstring"),
2959 tps("anotherlongstring"));
2961 /* Test that the three decls of 't' don't interact. */
2963 int b
= ({ int t
= 41; t
; });
2964 int c
= ({ int t
= 42; t
; });
2966 /* Test that aggregate return values work. */
2969 typedef struct hlist_head T
;
2971 T t
= { (void*)43, (void*)44 };
2975 printf ("stmtexpr: %d %d %d\n", t
, b
, c
);
2976 printf ("stmtexpr: %ld %ld\n", (long)h
.first
, (long)h
.last
);
2978 /* Test that we can give out addresses of local labels. */
2979 consume_ulong(({ __label__ __here
; __here
: (unsigned long)&&__here
; }));
2982 void local_label_test(void)
2988 __label__ l1
, l2
, l3
, l4
;
3002 printf("a=%d\n", a
);
3012 /* inline assembler test */
3013 #if defined(__i386__) || defined(__x86_64__)
3015 /* from linux kernel */
3016 static char * strncat1(char * dest
,const char * src
,size_t count
)
3018 long d0
, d1
, d2
, d3
;
3019 __asm__
__volatile__(
3028 "testb %%al,%%al\n\t"
3032 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
3033 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
3038 static char * strncat2(char * dest
,const char * src
,size_t count
)
3040 long d0
, d1
, d2
, d3
;
3041 __asm__
__volatile__(
3042 "repne scasb\n\t" /* one-line repne prefix + string op */
3049 "testb %%al,%%al\n\t"
3053 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
3054 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
3059 static inline void * memcpy1(void * to
, const void * from
, size_t n
)
3062 __asm__
__volatile__(
3067 "1:\ttestb $1,%b4\n\t"
3071 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
3072 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
3077 static inline void * memcpy2(void * to
, const void * from
, size_t n
)
3080 __asm__
__volatile__(
3081 "rep movsl\n\t" /* one-line rep prefix + string op */
3085 "1:\ttestb $1,%b4\n\t"
3089 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
3090 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
3095 static __inline__
void sigaddset1(unsigned int *set
, int _sig
)
3097 __asm__("btsl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc");
3100 static __inline__
void sigdelset1(unsigned int *set
, int _sig
)
3102 asm("btrl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc", "flags");
3105 static __inline__ __const__
unsigned int swab32(unsigned int x
)
3107 __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */
3108 "rorl $16,%0\n\t" /* swap words */
3109 "xchgb %b0,%h0" /* swap higher bytes */
3115 static __inline__
unsigned long long mul64(unsigned int a
, unsigned int b
)
3117 unsigned long long res
;
3119 /* Using the A constraint is wrong (it means rdx:rax, which is too large)
3120 but still test the 32bit->64bit mull. */
3121 unsigned int resh
, resl
;
3122 __asm__("mull %2" : "=a" (resl
), "=d" (resh
) : "a" (a
), "r" (b
));
3123 res
= ((unsigned long long)resh
<< 32) | resl
;
3125 __asm__("mull %2" : "=A" (res
) : "a" (a
), "r" (b
));
3130 static __inline__
unsigned long long inc64(unsigned long long a
)
3132 unsigned long long res
;
3134 /* Using the A constraint is wrong, and increments are tested
3138 __asm__("addl $1, %%eax ; adcl $0, %%edx" : "=A" (res
) : "A" (a
));
3151 unsigned long mconstraint_test(struct struct1231
*r
)
3156 __asm__
volatile ("lea %2,%0; movl 4(%0),%k0; addl %2,%k0; movl $51,%2; movl $52,4%2; movl $63,%1"
3157 : "=&r" (ret
), "=m" (a
)
3158 : "m" (*(struct struct123
*)r
->addr
));
3163 int fls64(unsigned long long x
)
3173 void other_constraints_test(void)
3178 __asm__
volatile ("mov %P1,%0" : "=r" (ret
) : "p" (&var
));
3179 printf ("oc1: %d\n", ret
== (unsigned long)&var
);
3184 /* Test global asm blocks playing with aliases. */
3185 void base_func(void)
3187 printf ("asmc: base\n");
3190 extern void override_func1 (void);
3191 extern void override_func2 (void);
3193 asm(".weak override_func1\n.set override_func1, base_func");
3194 asm(".set override_func1, base_func");
3195 asm(".set override_func2, base_func");
3197 void override_func2 (void)
3199 printf ("asmc: override2\n");
3202 /* This checks a construct used by the linux kernel to encode
3203 references to strings by PC relative references. */
3204 extern int bug_table
[] __attribute__((section("__bug_table")));
3205 char * get_asm_string (void)
3207 extern int some_symbol
;
3208 asm volatile (".globl some_symbol\n"
3211 "some_symbol: .long 0\n"
3212 ".pushsection __bug_table, \"a\"\n"
3213 ".globl bug_table\n"
3215 /* The first entry (1b-2b) is unused in this test,
3216 but we include it to check if cross-section
3217 PC-relative references work. */
3218 "2:\t.long 1b - 2b, %c0 - 2b\n"
3219 ".popsection\n" : : "i" ("A string"));
3220 char * str
= ((char*)bug_table
) + bug_table
[1];
3224 /* This checks another constructs with local labels. */
3225 extern unsigned char alld_stuff
[];
3232 ".pushsection .data.ignore\n"
3233 ".long 661b - .\n" /* This reference to 661 generates an external sym
3234 which shouldn't somehow overwrite the offset that's
3235 already determined for it. */
3237 ".byte 662b - 661b\n" /* So that this value is undeniably 1. */);
3239 void asm_local_label_diff (void)
3241 printf ("asm_local_label_diff: %d %d\n", alld_stuff
[0], alld_stuff
[1]);
3244 /* This checks that static local variables are available from assembler. */
3245 void asm_local_statics (void)
3247 static int localint
= 41;
3248 asm("incl %0" : "+m" (localint
));
3249 printf ("asm_local_statics: %d\n", localint
);
3256 void fancy_copy (unsigned *in
, unsigned *out
)
3258 asm volatile ("" : "=r" (*out
) : "0" (*in
));
3261 void fancy_copy2 (unsigned *in
, unsigned *out
)
3263 asm volatile ("mov %0,(%1)" : : "r" (*in
), "r" (out
) : "memory");
3266 #if defined __x86_64__ && !defined _WIN64
3267 void clobber_r12(void)
3269 asm volatile("mov $1, %%r12" ::: "r12");
3273 void test_high_clobbers(void)
3275 #if defined __x86_64__ && !defined _WIN64
3276 register long val
asm("r12");
3278 /* This tests if asm clobbers correctly save/restore callee saved
3279 registers if they are clobbered and if it's the high 8 x86-64
3280 registers. This is fragile for GCC as the constraints do not
3281 correctly capture the data flow, but good enough for us. */
3282 asm volatile("mov $0x4542, %%r12" : "=r" (val
):: "memory");
3284 asm volatile("mov %%r12, %0" : "=r" (val2
) : "r" (val
): "memory");
3285 printf("asmhc: 0x%x\n", val2
);
3289 static long cpu_number
;
3290 void trace_console(long len
, long len2
)
3293 /* This generated invalid code when the emission of the switch
3294 table isn't disabled. The asms are necessary to show the bug,
3295 normal statements don't work (they need to generate some code
3296 even under nocode_wanted, which normal statements don't do,
3297 but asms do). Also at least these number of cases is necessary
3298 to generate enough "random" bytes. They ultimately are enough
3299 to create invalid instruction patterns to which the first
3300 skip-to-decision-table jump jumps. If decision table emission
3301 is disabled all of this is no problem.
3303 It also is necessary that the switches are in a statement expression
3304 (which has the property of not being enterable from outside. no
3315 case 8: printf("bla"); pfo_ret__
= 42; break;
3317 pscr_ret__
= pfo_ret__
;
3324 case 1:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3325 case 2:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3326 case 4:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3327 case 8:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3328 default: printf("impossible\n");
3330 pscr_ret__
= pfo_ret__
;
3342 void test_asm_dead_code(void)
3345 /* Try to make sure that xdi contains a zero, and hence will
3346 lead to a segfault if the next asm is evaluated without
3347 arguments being set up. */
3348 asm volatile ("" : "=D" (rdi
) : "0" (0));
3351 /* This shouldn't trigger a segfault, either the argument
3352 registers need to be set up and the asm emitted despite
3353 this being in an unevaluated context, or both the argument
3354 setup _and_ the asm emission need to be suppressed. The latter
3355 is better. Disabling asm code gen when suppression is on
3356 also fixes the above trace_console bug, but that came earlier
3357 than asm suppression. */
3358 asm volatile ("movl $0,(%0)" : : "D" (&var
) : "memory");
3363 void test_asm_call(void)
3365 #if defined __x86_64__ && !defined _WIN64
3366 static char str
[] = "PATH";
3368 /* This tests if a reference to an undefined symbol from an asm
3369 block, which isn't otherwise referenced in this file, is correctly
3370 regarded as global symbol, so that it's resolved by other object files
3371 or libraries. We chose getenv here, which isn't used anywhere else
3372 in this file. (If we used e.g. printf, which is used we already
3373 would have a global symbol entry, not triggering the bug which is
3375 /* two pushes so stack remains aligned */
3376 asm volatile ("push %%rdi; push %%rdi; mov %0, %%rdi;"
3377 #if 1 && !defined(__TINYC__) && (defined(__PIC__) || defined(__PIE__))
3382 "pop %%rdi; pop %%rdi"
3383 : "=a" (s
) : "r" (str
));
3384 printf("asmd: %s\n", s
);
3388 #if defined __x86_64__
3389 # define RX "(%rip)"
3394 void asm_dot_test(void)
3401 asm(".text; lea S"RX
",%eax; lea ."RX
",%ecx; sub %ecx,%eax; S=.; jmp p0");
3403 asm(".text; jmp .+6; .int 123; mov .-4"RX
",%eax; jmp p0");
3405 asm(".data; Y=.; .int 999; X=Y; .int 456; X=.-4");
3406 asm(".text; mov X"RX
",%eax; jmp p0");
3408 asm(".data; X=.; .int 789; Y=.; .int 999");
3409 asm(".text; mov X"RX
",%eax; X=Y; jmp p0");
3411 asm(".text; p0=.; mov %%eax,%0;" : "=m"(r
)); break;
3415 printf("asm_dot_test %d: %d\n", x
, r
);
3422 unsigned int val
, val2
;
3423 struct struct123 s1
;
3424 struct struct1231 s2
= { (unsigned long)&s1
};
3425 /* Hide the outer base_func, but check later that the inline
3426 asm block gets the outer one. */
3428 void override_func3 (void);
3429 unsigned long asmret
;
3433 register int regvar
asm("%esi");
3435 printf("inline asm:\n");
3437 // parse 0x1E-1 as 3 tokens in asm mode
3438 asm volatile ("mov $0x1E-1,%eax");
3440 /* test the no operand case */
3441 asm volatile ("xorl %eax, %eax");
3443 memcpy1(buf
, "hello", 6);
3444 strncat1(buf
, " worldXXXXX", 3);
3445 printf("%s\n", buf
);
3447 memcpy2(buf
, "hello", 6);
3448 strncat2(buf
, " worldXXXXX", 3);
3449 printf("%s\n", buf
);
3451 /* 'A' constraint test */
3452 printf("mul64=0x%Lx\n", mul64(0x12345678, 0xabcd1234));
3453 printf("inc64=0x%Lx\n", inc64(0x12345678ffffffff));
3457 printf("mconstraint: %d", mconstraint_test(&s2
));
3458 printf(" %d %d\n", s1
.a
, s1
.b
);
3459 other_constraints_test();
3461 sigdelset1(&set
, 2);
3462 sigaddset1(&set
, 16);
3463 /* NOTE: we test here if C labels are correctly restored after the
3467 __asm__("btsl %1,%0" : "=m"(set
) : "Ir"(20) : "cc");
3468 printf("set=0x%x\n", set
);
3470 printf("swab32(0x%08x) = 0x%0x\n", val
, swab32(val
));
3474 /* The base_func ref from the following inline asm should find
3475 the global one, not the local decl from this function. */
3476 asm volatile(".weak override_func3\n.set override_func3, base_func");
3478 printf("asmstr: %s\n", get_asm_string());
3479 asm_local_label_diff();
3480 asm_local_statics();
3482 /* Check that we can also load structs of appropriate layout
3484 asm volatile("" : "=r" (asmret
) : "0"(s2
));
3485 if (asmret
!= s2
.addr
)
3486 printf("asmstr: failed\n");
3488 /* Check that the typesize correctly sets the register size to
3490 asm volatile("cmp %1,%2; sete %0" : "=a"(somebool
) : "r"(1), "r"(2));
3492 printf("asmbool: failed\n");
3495 fancy_copy (&val
, &val2
);
3496 printf ("fancycpy(%d)=%d\n", val
, val2
);
3498 fancy_copy2 (&val
, &val2
);
3499 printf ("fancycpy2(%d)=%d\n", val
, val2
);
3500 asm volatile ("mov $0x4243, %%esi" : "=r" (regvar
));
3501 printf ("regvar=%x\n", regvar
);
3502 test_high_clobbers();
3503 trace_console(8, 8);
3504 test_asm_dead_code();
3520 #define COMPAT_TYPE(type1, type2) \
3522 printf("__builtin_types_compatible_p(%s, %s) = %d\n", #type1, #type2, \
3523 __builtin_types_compatible_p (type1, type2));\
3528 void builtin_test(void)
3534 COMPAT_TYPE(int, int);
3535 COMPAT_TYPE(int, unsigned int);
3536 COMPAT_TYPE(int, char);
3537 COMPAT_TYPE(int, const int);
3538 COMPAT_TYPE(int, volatile int);
3539 COMPAT_TYPE(int *, int *);
3540 COMPAT_TYPE(int *, void *);
3541 COMPAT_TYPE(int *, const int *);
3542 COMPAT_TYPE(char *, unsigned char *);
3543 COMPAT_TYPE(char *, signed char *);
3544 COMPAT_TYPE(char *, char *);
3545 /* space is needed because tcc preprocessor introduces a space between each token */
3546 COMPAT_TYPE(char * *, void *);
3548 printf("res = %d\n", __builtin_constant_p(1));
3549 printf("res = %d\n", __builtin_constant_p(1 + 2));
3550 printf("res = %d\n", __builtin_constant_p(&constant_p_var
));
3551 printf("res = %d\n", __builtin_constant_p(constant_p_var
));
3552 printf("res = %d\n", __builtin_constant_p(100000 / constant_p_var
));
3555 i
= __builtin_choose_expr (1 != 0, ll
, s
);
3556 printf("bce: %d\n", i
);
3557 i
= __builtin_choose_expr (1 != 1, ll
, s
);
3558 printf("bce: %d\n", i
);
3559 i
= sizeof (__builtin_choose_expr (1, ll
, s
));
3560 printf("bce: %d\n", i
);
3561 i
= sizeof (__builtin_choose_expr (0, ll
, s
));
3562 printf("bce: %d\n", i
);
3564 //printf("bera: %p\n", __builtin_extract_return_addr((void*)43));
3568 extern int __attribute__((weak
)) weak_f1(void);
3569 extern int __attribute__((weak
)) weak_f2(void);
3570 extern int weak_f3(void);
3571 extern int __attribute__((weak
)) weak_v1
;
3572 extern int __attribute__((weak
)) weak_v2
;
3575 extern int (*weak_fpa
)() __attribute__((weak
));
3576 extern int __attribute__((weak
)) (*weak_fpb
)();
3577 extern __attribute__((weak
)) int (*weak_fpc
)();
3579 extern int weak_asm_f1(void) asm("weak_asm_f1x") __attribute((weak
));
3580 extern int __attribute((weak
)) weak_asm_f2(void) asm("weak_asm_f2x") ;
3581 extern int __attribute((weak
)) weak_asm_f3(void) asm("weak_asm_f3x") __attribute((weak
));
3582 extern int weak_asm_v1
asm("weak_asm_v1x") __attribute((weak
));
3583 extern int __attribute((weak
)) weak_asm_v2
asm("weak_asm_v2x") ;
3584 extern int __attribute((weak
)) weak_asm_v3(void) asm("weak_asm_v3x") __attribute((weak
));
3586 static const size_t dummy
= 0;
3587 extern __typeof(dummy
) weak_dummy1
__attribute__((weak
, alias("dummy")));
3588 extern __typeof(dummy
) __attribute__((weak
, alias("dummy"))) weak_dummy2
;
3589 extern __attribute__((weak
, alias("dummy"))) __typeof(dummy
) weak_dummy3
;
3591 int some_lib_func(void);
3592 int dummy_impl_of_slf(void) { return 444; }
3593 int some_lib_func(void) __attribute__((weak
, alias("dummy_impl_of_slf")));
3595 int weak_toolate() __attribute__((weak
));
3596 int weak_toolate() { return 0; }
3598 void __attribute__((weak
)) weak_test(void)
3600 printf("weak_f1=%d\n", weak_f1
? weak_f1() : 123);
3601 printf("weak_f2=%d\n", weak_f2
? weak_f2() : 123);
3602 printf("weak_f3=%d\n", weak_f3
? weak_f3() : 123);
3603 printf("weak_v1=%d\n",&weak_v1
? weak_v1
: 123);
3604 printf("weak_v2=%d\n",&weak_v2
? weak_v2
: 123);
3605 printf("weak_v3=%d\n",&weak_v3
? weak_v3
: 123);
3607 printf("weak_fpa=%d\n",&weak_fpa
? weak_fpa() : 123);
3608 printf("weak_fpb=%d\n",&weak_fpb
? weak_fpb() : 123);
3609 printf("weak_fpc=%d\n",&weak_fpc
? weak_fpc() : 123);
3611 printf("weak_asm_f1=%d\n", weak_asm_f1
!= NULL
);
3612 printf("weak_asm_f2=%d\n", weak_asm_f2
!= NULL
);
3613 printf("weak_asm_f3=%d\n", weak_asm_f3
!= NULL
);
3614 printf("weak_asm_v1=%d\n",&weak_asm_v1
!= NULL
);
3615 printf("weak_asm_v2=%d\n",&weak_asm_v2
!= NULL
);
3616 printf("weak_asm_v3=%d\n",&weak_asm_v3
!= NULL
);
3617 printf("some_lib_func=%d\n", &some_lib_func
? some_lib_func() : 0);
3620 int __attribute__((weak
)) weak_f2() { return 222; }
3621 int __attribute__((weak
)) weak_f3() { return 333; }
3622 int __attribute__((weak
)) weak_v2
= 222;
3623 int __attribute__((weak
)) weak_v3
= 333;
3626 void const_func(const int a
)
3630 void const_warn_test(void)
3639 int getme (struct condstruct
*s
, int i
)
3641 int i1
= (i
== 0 ? 0 : s
)->i
;
3642 int i2
= (i
== 0 ? s
: 0)->i
;
3643 int i3
= (i
== 0 ? (void*)0 : s
)->i
;
3644 int i4
= (i
== 0 ? s
: (void*)0)->i
;
3645 return i1
+ i2
+ i3
+ i4
;
3654 struct global_data global_data
;
3656 int global_data_getstuff (int *, int);
3658 void global_data_callit (int i
)
3660 *global_data
.b
[i
] = global_data_getstuff (global_data
.b
[i
], 1);
3663 int global_data_getstuff (int *p
, int i
)
3668 void global_data_test (void)
3670 global_data
.a
[0] = 42;
3671 global_data
.b
[0] = &global_data
.a
[0];
3672 global_data_callit (0);
3673 printf ("%d\n", global_data
.a
[0]);
3678 unsigned char fill
: 3;
3679 unsigned char b1
: 1;
3680 unsigned char b2
: 1;
3681 unsigned char fill2
: 3;
3684 int glob1
, glob2
, glob3
;
3686 void compare_comparisons (struct cmpcmpS
*s
)
3688 if (s
->b1
!= (glob1
== glob2
)
3689 || (s
->b2
!= (glob1
== glob3
)))
3690 printf ("comparing comparisons broken\n");
3693 void cmp_comparison_test(void)
3697 glob1
= 42; glob2
= 42;
3700 compare_comparisons (&s
);
3703 int fcompare (double a
, double b
, int code
)
3706 case 0: return a
== b
;
3707 case 1: return a
!= b
;
3708 case 2: return a
< b
;
3709 case 3: return a
>= b
;
3710 case 4: return a
> b
;
3711 case 5: return a
<= b
;
3715 void math_cmp_test(void)
3717 double nan
= 0.0/0.0;
3721 #define bug(a,b,op,iop,part) printf("Test broken: %s %s %s %s %d\n", #a, #b, #op, #iop, part)
3723 /* This asserts that "a op b" is _not_ true, but "a iop b" is true.
3724 And it does this in various ways so that all code generation paths
3725 are checked (generating inverted tests, or non-inverted tests, or
3726 producing a 0/1 value without jumps (that's done in the fcompare
3728 #define FCMP(a,b,op,iop,code) \
3729 if (fcompare (a,b,code)) \
3730 bug (a,b,op,iop,1); \
3732 bug (a,b,op,iop,2); \
3736 bug (a,b,op,iop,3); \
3737 if ((a op b) || comp) \
3738 bug (a,b,op,iop,4); \
3739 if ((a iop b) || comp) \
3744 /* Equality tests. */
3745 FCMP(nan
, nan
, ==, !=, 0);
3746 FCMP(one
, two
, ==, !=, 0);
3747 FCMP(one
, one
, !=, ==, 1);
3748 /* Non-equality is a bit special. */
3749 if (!fcompare (nan
, nan
, 1))
3750 bug (nan
, nan
, !=, ==, 6);
3752 /* Relational tests on numbers. */
3753 FCMP(two
, one
, <, >=, 2);
3754 FCMP(one
, two
, >=, <, 3);
3755 FCMP(one
, two
, >, <=, 4);
3756 FCMP(two
, one
, <=, >, 5);
3758 /* Relational tests on NaNs. Note that the inverse op here is
3759 always !=, there's no operator in C that is equivalent to !(a < b),
3760 when NaNs are involved, same for the other relational ops. */
3761 FCMP(nan
, nan
, <, !=, 2);
3762 FCMP(nan
, nan
, >=, !=, 3);
3763 FCMP(nan
, nan
, >, !=, 4);
3764 FCMP(nan
, nan
, <=, !=, 5);
3767 double get100 () { return 100.0; }
3769 void callsave_test(void)
3771 #if defined __i386__ || defined __x86_64__ || defined __arm__
3772 int i
, s
; double *d
; double t
;
3773 s
= sizeof (double);
3774 printf ("callsavetest: %d\n", s
);
3775 d
= alloca (sizeof(double));
3777 /* x86-64 had a bug were the next call to get100 would evict
3778 the lvalue &d[0] as VT_LLOCAL, and the reload would be done
3779 in int type, not pointer type. When alloca returns a pointer
3780 with the high 32 bit set (which is likely on x86-64) the access
3781 generates a segfault. */
3782 i
= d
[0] > get100 ();
3788 void bfa3(ptrdiff_t str_offset
)
3790 printf("bfa3: %s\n", (char *)__builtin_frame_address(3) + str_offset
);
3792 void bfa2(ptrdiff_t str_offset
)
3794 printf("bfa2: %s\n", (char *)__builtin_frame_address(2) + str_offset
);
3797 void bfa1(ptrdiff_t str_offset
)
3799 printf("bfa1: %s\n", (char *)__builtin_frame_address(1) + str_offset
);
3803 void builtin_frame_address_test(void)
3805 /* builtin_frame_address fails on ARM with gcc which make test3 fail */
3807 char str
[] = "__builtin_frame_address";
3808 char *fp0
= __builtin_frame_address(0);
3810 printf("str: %s\n", str
);
3815 char via_volatile (char i
)
3822 struct __attribute__((__packed__
)) Spacked
{
3827 struct Spacked spacked
;
3828 typedef struct __attribute__((__packed__
)) {
3834 typedef struct Spacked3_s
{
3838 } __attribute__((__packed__
)) Spacked3
;
3840 struct gate_struct64
{
3841 unsigned short offset_low
;
3842 unsigned short segment
;
3843 unsigned ist
: 3, zero0
: 5, type
: 5, dpl
: 2, p
: 1;
3844 unsigned short offset_middle
;
3845 unsigned offset_high
;
3847 } __attribute__((packed
));
3848 typedef struct gate_struct64 gate_desc
;
3849 gate_desc a_gate_desc
;
3850 void attrib_test(void)
3853 printf("attr: %d %d %d %d\n", sizeof(struct Spacked
),
3854 sizeof(spacked
), sizeof(Spacked2
), sizeof(spacked2
));
3855 printf("attr: %d %d\n", sizeof(Spacked3
), sizeof(spacked3
));
3856 printf("attr: %d %d\n", sizeof(gate_desc
), sizeof(a_gate_desc
));
3859 extern __attribute__((__unused__
)) char * __attribute__((__unused__
)) *
3860 strange_attrib_placement (void);
3862 void * __attribute__((__unused__
)) get_void_ptr (void *a
)
3867 /* This part checks for a bug in TOK_GET (used for inline expansion),
3868 where the large long long constant left the the high bits set for
3869 the integer constant token. */
3871 int __get_order(unsigned long long size
)
3874 size
-= 0xffff880000000000ULL
; // this const left high bits set in the token
3876 struct S
{ int i
: 1; } s
; // constructed for this '1'
3882 /* This just forces the above inline function to be actually emitted. */
3883 int force_get_order(unsigned long s
)
3885 return __get_order(s
);