2 * TCC auto test program
8 /* Unfortunately, gcc version < 3 does not handle that! */
11 /* only gcc 3 handles _Bool correctly */
14 /* gcc 2.95.3 does not handle correctly CR in strings or after strays */
15 #define CORRECT_CR_HANDLING
20 #define LONG_LONG_FORMAT "%lld"
21 #define ULONG_LONG_FORMAT "%llu"
23 #define LONG_LONG_FORMAT "%Ld"
24 #define ULONG_LONG_FORMAT "%Lu"
27 // MinGW has 80-bit rather than 64-bit long double which isn't compatible with TCC or MSVC
28 #if defined(_WIN32) && defined(__GNUC__)
29 #define LONG_DOUBLE double
30 #define LONG_DOUBLE_LITERAL(x) x
32 #define LONG_DOUBLE long double
33 #define LONG_DOUBLE_LITERAL(x) x ## L
36 /* deprecated and no longer supported in gcc 3.3 */
37 //#define ACCEPT_CR_IN_STRINGS
39 /* __VA_ARGS__ and __func__ support */
42 /* test various include syntaxes */
44 #define TCCLIB_INC <tcclib.h>
45 #define TCCLIB_INC1 <tcclib
46 #define TCCLIB_INC2 h>
47 #define TCCLIB_INC3 "tcclib.h"
51 #include TCCLIB_INC1.TCCLIB_INC2
53 #include TCCLIB_INC1.h>
63 /* Test two more ways to include a file named like a pp-number */
64 #define INC(name) <tests/name.h>
65 #define funnyname 42test.h
67 #define incname < incdir funnyname >
68 #define __stringify(x) #x
69 #define stringify(x) __stringify(x)
72 #include stringify(funnyname)
78 void recursive_macro_test();
93 void constant_expr_test();
95 void char_short_test();
97 void compound_literal_test(void);
99 void struct_assign_test(void);
100 void cast_test(void);
101 void bitfield_test(void);
102 void c99_bool_test(void);
103 void float_test(void);
104 void longlong_test(void);
105 void manyarg_test(void);
106 void stdarg_test(void);
107 void whitespace_test(void);
108 void relocation_test(void);
109 void old_style_function(void);
110 void alloca_test(void);
111 void c99_vla_test(int size1
, int size2
);
112 void sizeof_test(void);
113 void typeof_test(void);
114 void local_label_test(void);
115 void statement_expr_test(void);
117 void builtin_test(void);
118 void weak_test(void);
119 void global_data_test(void);
120 void cmp_comparison_test(void);
121 void math_cmp_test(void);
122 void callsave_test(void);
123 void builtin_frame_address_test(void);
124 void attrib_test(void);
128 void forward_ref(void);
131 /* Line joining happens before tokenization, so the following
132 must be parsed as ellipsis. */
133 void funny_line_continuation (int, ..\
136 char via_volatile (char);
141 #define M1(a, b) (a) + (b)
145 #define glue(a, b) a ## b
146 #define xglue(a, b) glue(a, b)
147 #define HIGHLOW "hello"
148 #define LOW LOW ", world"
150 static int onetwothree
= 123;
151 #define onetwothree4 onetwothree
152 #define onetwothree xglue(onetwothree,4)
154 #define min(a, b) ((a) < (b) ? (a) : (b))
157 #define dprintf(level,...) printf(__VA_ARGS__)
160 /* gcc vararg macros */
161 #define dprintf1(level, fmt, args...) printf(fmt, ## args)
163 #define MACRO_NOARGS()
179 #define __INT64_C(c) c ## LL
180 #define INT64_MIN (-__INT64_C(9223372036854775807)-1)
188 #define spin_lock(lock) do { } while (0)
189 #define wq_spin_lock spin_lock
190 #define TEST2() wq_spin_lock(a)
192 #define UINT_MAX ((unsigned) -1)
194 void intdiv_test(void)
196 printf("18/21=%u\n", 18/21);
197 printf("18%%21=%u\n", 18%21);
198 printf("41/21=%u\n", 41/21);
199 printf("41%%21=%u\n", 41%21);
200 printf("42/21=%u\n", 42/21);
201 printf("42%%21=%u\n", 42%21);
202 printf("43/21=%u\n", 43/21);
203 printf("43%%21=%u\n", 43%21);
204 printf("126/21=%u\n", 126/21);
205 printf("126%%21=%u\n", 126%21);
206 printf("131/21=%u\n", 131/21);
207 printf("131%%21=%u\n", 131%21);
208 printf("(UINT_MAX/2+3)/2=%u\n", (UINT_MAX
/2+3)/2);
209 printf("(UINT_MAX/2+3)%%2=%u\n", (UINT_MAX
/2+3)%2);
211 printf("18/-21=%u\n", 18/-21);
212 printf("18%%-21=%u\n", 18%-21);
213 printf("41/-21=%u\n", 41/-21);
214 printf("41%%-21=%u\n", 41%-21);
215 printf("42/-21=%u\n", 42/-21);
216 printf("42%%-21=%u\n", 42%-21);
217 printf("43/-21=%u\n", 43/-21);
218 printf("43%%-21=%u\n", 43%-21);
219 printf("126/-21=%u\n", 126/-21);
220 printf("126%%-21=%u\n", 126%-21);
221 printf("131/-21=%u\n", 131/-21);
222 printf("131%%-21=%u\n", 131%-21);
223 printf("(UINT_MAX/2+3)/-2=%u\n", (UINT_MAX
/2+3)/-2);
224 printf("(UINT_MAX/2+3)%%-2=%u\n", (UINT_MAX
/2+3)%-2);
226 printf("-18/21=%u\n", -18/21);
227 printf("-18%%21=%u\n", -18%21);
228 printf("-41/21=%u\n", -41/21);
229 printf("-41%%21=%u\n", -41%21);
230 printf("-42/21=%u\n", -42/21);
231 printf("-42%%21=%u\n", -42%21);
232 printf("-43/21=%u\n", -43/21);
233 printf("-43%%21=%u\n", -43%21);
234 printf("-126/21=%u\n", -126/21);
235 printf("-126%%21=%u\n", -126%21);
236 printf("-131/21=%u\n", -131/21);
237 printf("-131%%21=%u\n", -131%21);
238 printf("-(UINT_MAX/2+3)/2=%u\n", (0-(UINT_MAX
/2+3))/2);
239 printf("-(UINT_MAX/2+3)%%2=%u\n", (0-(UINT_MAX
/2+3))%2);
241 printf("-18/-21=%u\n", -18/-21);
242 printf("-18%%-21=%u\n", -18%-21);
243 printf("-41/-21=%u\n", -41/-21);
244 printf("-41%%-21=%u\n", -41%-21);
245 printf("-42/-21=%u\n", -42/-21);
246 printf("-42%%-21=%u\n", -42%-21);
247 printf("-43/-21=%u\n", -43/-21);
248 printf("-43%%-21=%u\n", -43%-21);
249 printf("-126/-21=%u\n", -126/-21);
250 printf("-126%%-21=%u\n", -126%-21);
251 printf("-131/-21=%u\n", -131/-21);
252 printf("-131%%-21=%u\n", -131%-21);
253 printf("-(UINT_MAX/2+3)/-2=%u\n", (0-(UINT_MAX
/2+3))/-2);
254 printf("-(UINT_MAX/2+3)%%-2=%u\n", (0-(UINT_MAX
/2+3))%-2);
257 void macro_test(void)
259 printf("macro:\n");\f\v
261 printf("aaa=%d\n", AAA
);
263 printf("min=%d\n", min(1, min(2, -1)));
265 printf("s1=%s\n", glue(HIGH
, LOW
));
266 printf("s2=%s\n", xglue(HIGH
, LOW
));
267 printf("s3=%s\n", str("c"));
268 printf("s4=%s\n", str(a1
));
269 printf("B3=%d\n", B3
);
271 printf("onetwothree=%d\n", onetwothree
);
274 printf("A defined\n");
277 printf("B defined\n");
280 printf("A defined\n");
282 printf("A not defined\n");
285 printf("B defined\n");
287 printf("B not defined\n");
291 printf("A defined\n");
293 printf("B1 defined\n");
295 printf("B1 not defined\n");
298 printf("A not defined\n");
300 printf("B2 defined\n");
302 printf("B2 not defined\n");
307 printf("test true1\n");
310 printf("test true2\n");
313 printf("test true3\n");
316 printf("test trueA\n");
319 printf("test trueB\n");
335 printf("__LINE__ defined\n");
338 printf("__LINE__=%d __FILE__=%s\n",
342 printf("__LINE__=%d __FILE__=%s\n",
345 printf("__LINE__=%d __FILE__=%s\n",
347 #line 227 "tcctest.c"
350 /* not strictly preprocessor, but we test it there */
352 printf("__func__ = %s\n", __func__
);
353 dprintf(1, "vaarg=%d\n", 1);
355 dprintf1(1, "vaarg1\n");
356 dprintf1(1, "vaarg1=%d\n", 2);
357 dprintf1(1, "vaarg1=%d %d\n", 1, 2);
360 printf("func='%s'\n", __FUNCTION__
);
362 /* complicated macros in glibc */
363 printf("INT64_MIN=" LONG_LONG_FORMAT
"\n", INT64_MIN
);
373 /* macro function with argument outside the macro string */
374 #define MF_s MF_hello
375 #define MF_hello(msg) printf("%s\n",msg)
377 #define MF_t printf("tralala\n"); MF_hello
382 /* test macro substituion inside args (should not eat stream) */
383 printf("qq=%d\n", qq(qq
)(2));
385 /* test zero argument case. NOTE: gcc 2.95.x does not accept a
386 null argument without a space. gcc 3.2 fixes that. */
389 printf("qq1=%d\n", qq1( ));
391 /* comment with stray handling *\
393 /* this is a valid *\/ comment */
394 /* this is a valid comment *\*/
398 /* test function macro substitution when the function name is
402 /* And again when the name and parenthes are separated by a
404 TEST2
/* the comment */ ();
406 printf("%s\n", get_basefile_from_header());
407 printf("%s\n", __BASE_FILE__
);
408 printf("%s\n", get_file_from_header());
409 printf("%s\n", __FILE__
);
411 /* Check that funnily named include was in fact included */
412 have_included_42test_h
= 1;
413 have_included_42test_h_second
= 1;
414 have_included_42test_h_third
= 1;
418 static void print_num(char *fn
, int line
, int num
) {
419 printf("fn %s, line %d, num %d\n", fn
, line
, num
);
422 void recursive_macro_test(void)
425 #define ELF32_ST_TYPE(val) ((val) & 0xf)
426 #define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
427 #define STB_WEAK 2 /* Weak symbol */
428 #define ELFW(type) ELF##32##_##type
429 printf("%d\n", ELFW(ST_INFO
)(STB_WEAK
, ELFW(ST_TYPE
)(123)));
433 #define print_num(x) print_num(__FILE__,__LINE__,x)
435 WRAP(print_num(123));
436 WRAP(WRAP(print_num(123)));
438 static struct recursive_macro
{ int rm_field
; } G
;
439 #define rm_field (G.rm_field)
440 printf("rm_field = %d\n", rm_field
);
441 printf("rm_field = %d\n", WRAP(rm_field
));
442 WRAP((printf("rm_field = %d %d\n", rm_field
, WRAP(rm_field
))));
459 void ps(const char *s
)
471 const char foo1_string
[] = "\
480 printf("\141\1423\143\n");/* dezdez test */
481 printf("\x41\x42\x43\x3a\n");
482 printf("c=%c\n", 'r');
483 printf("wc=%C 0x%lx %C\n", L
'a', L
'\x1234', L
'c');
484 printf("foo1_string='%s'\n", foo1_string
);
486 printf("wstring=%S\n", L
"abc");
487 printf("wstring=%S\n", L
"abc" L
"def" "ghi");
488 printf("'\\377'=%d '\\xff'=%d\n", '\377', '\xff');
489 printf("L'\\377'=%d L'\\xff'=%d\n", L
'\377', L
'\xff');
493 while ((b
= b
+ 1) < 96) {
497 printf("fib=%d\n", fib(33));
499 while (b
!= 0x80000000) {
512 for(i
= 0; i
< 10;i
++)
522 /* c99 for loop init test */
523 for (size_t count
= 1; count
< 3; count
++)
524 printf("count=%d\n", count
);
525 printf("count = %d\n", count
);
527 /* break/continue tests */
539 /* break/continue tests */
551 for(i
= 0;i
< 10;i
++) {
559 typedef int typedef_and_label
;
564 static void *label_table
[3] = { &&label1
, &&label2
, &&label3
};
568 /* This needs to parse as label, not as start of decl. */
579 /* we also test computed gotos (GCC extension) */
581 goto *label_table
[i
];
607 enum {E6
= 42, E7
, E8
} e
:8;
611 /* This is either 0 on L32 machines, or a large number
612 on L64 machines. We should be able to store this. */
613 EL_large
= (unsigned long)0xf000 << 32,
616 enum { BIASU
= -1U<<31 };
617 enum { BIASS
= -1 << 31 };
619 static int getint(int i
)
624 return (int)(-1U << 31);
630 /* The following should give no warning */
632 struct S_enum s
= {E7
};
633 printf("enum: %d\n", s
.e
);
634 printf("enum:\n%d %d %d %d %d %d\n",
635 E0
, E1
, E2
, E3
, E4
, E5
);
637 printf("b1=%d\n", b1
);
638 printf("enum large: %ld\n", EL_large
);
640 if (getint(0) == BIASU
)
641 printf("enum unsigned: ok\n");
643 printf("enum unsigned: wrong\n");
644 if (getint(0) == BIASS
)
645 printf("enum unsigned: ok\n");
647 printf("enum unsigned: wrong\n");
663 printf("typedef:\n");
664 printf("a=%d\n", *a
);
666 printf("mytype2=%d\n", mytype2
);
671 printf("forward:\n");
677 void forward_ref(void)
679 printf("forward ok\n");
682 typedef struct struct1
{
702 struct struct1 st1
, st2
;
709 int main(int argc
, char **argv
)
714 recursive_macro_test();
729 constant_expr_test();
733 compound_literal_test();
735 struct_assign_test();
745 old_style_function();
750 statement_expr_test();
758 cmp_comparison_test();
761 builtin_frame_address_test();
763 if (via_volatile (42) != 42)
764 printf ("via_volatile broken\n");
776 printf("g1=%d\n", g
);
784 printf("g2=%d\n", g
);
788 printf("g3=%d\n", g
);
792 printf("g4=%d\n", g
);
795 printf("g5=%d\n", g
);
803 printf("sizeof(a) = %d\n", sizeof(a
));
804 printf("sizeof(\"a\") = %d\n", sizeof("a"));
806 printf("sizeof(__func__) = %d\n", sizeof(__func__
));
808 printf("sizeof tab %d\n", sizeof(tab
));
809 printf("sizeof tab2 %d\n", sizeof tab2
);
813 printf("%d %d %d\n", tab
[0], tab
[1], tab
[2]);
816 tab2
[i
][j
] = 10 * i
+ j
;
818 printf(" %3d", ((int *)tab2
)[i
]);
821 printf("sizeof(size_t)=%d\n", sizeof(size_t));
822 printf("sizeof(ptrdiff_t)=%d\n", sizeof(ptrdiff_t));
829 printf("%d\n", a
+= 1);
830 printf("%d\n", a
-= 2);
831 printf("%d\n", a
*= 31232132);
832 printf("%d\n", a
/= 4);
833 printf("%d\n", a
%= 20);
834 printf("%d\n", a
&= 6);
835 printf("%d\n", a
^= 7);
836 printf("%d\n", a
|= 8);
837 printf("%d\n", a
>>= 3);
838 printf("%d\n", a
<<= 4);
842 printf("%d\n", a
+ 1);
843 printf("%d\n", a
- 2);
844 printf("%d\n", a
* 312);
845 printf("%d\n", a
/ 4);
846 printf("%d\n", b
/ 4);
847 printf("%d\n", (unsigned)b
/ 4);
848 printf("%d\n", a
% 20);
849 printf("%d\n", b
% 20);
850 printf("%d\n", (unsigned)b
% 20);
851 printf("%d\n", a
& 6);
852 printf("%d\n", a
^ 7);
853 printf("%d\n", a
| 8);
854 printf("%d\n", a
>> 3);
855 printf("%d\n", b
>> 3);
856 printf("%d\n", (unsigned)b
>> 3);
857 printf("%d\n", a
<< 4);
862 printf("%d\n", 12 + 1);
863 printf("%d\n", 12 - 2);
864 printf("%d\n", 12 * 312);
865 printf("%d\n", 12 / 4);
866 printf("%d\n", 12 % 20);
867 printf("%d\n", 12 & 6);
868 printf("%d\n", 12 ^ 7);
869 printf("%d\n", 12 | 8);
870 printf("%d\n", 12 >> 2);
871 printf("%d\n", 12 << 4);
875 printf("%d %d %d %d\n",
884 return (c
>= 'a' & c
<= 'z') | (c
>= 'A' & c
<= 'Z') | c
== '_';
887 /**********************/
889 int vstack
[10], *vstack_ptr
;
891 void vpush(int vt
, int vc
)
897 void vpop(int *ft
, int *fc
)
910 vstack_ptr
[-2] &= ~0xffffff80;
912 printf("res= %d %d\n", a
, b
);
915 void constant_expr_test()
918 printf("constant_expr:\n");
920 printf("%d\n", a
* 16);
921 printf("%d\n", a
* 1);
922 printf("%d\n", a
+ 0);
932 printf("expr_ptr:\n");
935 printf("diff=%d\n", q
- p
);
937 printf("inc=%d\n", p
- tab4
);
939 printf("dec=%d\n", p
- tab4
);
941 printf("inc=%d\n", p
- tab4
);
943 printf("dec=%d\n", p
- tab4
);
944 printf("add=%d\n", p
+ 3 - tab4
);
945 printf("add=%d\n", 3 + p
- tab4
);
947 /* check if 64bit support is ok */
950 printf("%p %p %ld\n", q
, p
, p
-q
);
951 printf("%d %d %d %d %d %d\n",
952 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
955 printf("%p %p %ld\n", q
, p
, p
-q
);
956 printf("%d %d %d %d %d %d\n",
957 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
958 p
= (int *)((char *)p
+ 0xf0000000);
959 printf("%p %p %ld\n", q
, p
, p
-q
);
960 printf("%d %d %d %d %d %d\n",
961 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
963 printf("%p %p %ld\n", q
, p
, p
-q
);
964 printf("%d %d %d %d %d %d\n",
965 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
970 struct size12 s
[2], *sp
= s
;
975 printf("%d\n", sp
[j
].i
);
979 p
= (int*)0x100000000UL
+ i
;
981 printf("largeptr: %p %d\n", p
, i
);
988 printf("constant_expr:\n");
991 printf("%d\n", a
== a
);
992 printf("%d\n", a
!= a
);
994 printf("%d\n", a
< b
);
995 printf("%d\n", a
<= b
);
996 printf("%d\n", a
<= a
);
997 printf("%d\n", b
>= a
);
998 printf("%d\n", a
>= a
);
999 printf("%d\n", b
> a
);
1001 printf("%d\n", (unsigned)a
< b
);
1002 printf("%d\n", (unsigned)a
<= b
);
1003 printf("%d\n", (unsigned)a
<= a
);
1004 printf("%d\n", (unsigned)b
>= a
);
1005 printf("%d\n", (unsigned)a
>= a
);
1006 printf("%d\n", (unsigned)b
> a
);
1029 struct __attribute__((aligned(16))) aligntest5
1036 } __attribute__((aligned(16)));
1041 struct aligntest5 altest5
[2];
1042 struct aligntest6 altest6
[2];
1044 /* altest7 is correctly aligned to 16 bytes also with TCC,
1045 but __alignof__ returns the wrong result (4) because we
1046 can't store the alignment yet when specified on symbols
1047 directly (it's stored in the type so we'd need to make
1049 struct aligntest7 altest7[2] __attribute__((aligned(16)));*/
1052 unsigned long flags
;
1060 unsigned long index
;
1064 unsigned long counters
;
1078 unsigned long compound_head
;
1079 unsigned int compound_dtor
;
1080 unsigned int compound_order
;
1083 } __attribute__((aligned(2 * sizeof(long))));
1091 printf("struct:\n");
1092 printf("sizes: %d %d %d %d\n",
1093 sizeof(struct struct1
),
1094 sizeof(struct struct2
),
1095 sizeof(union union1
),
1096 sizeof(union union2
));
1097 printf("offsets: %d\n", (int)((char*)&st1
.u
.v1
- (char*)&st1
));
1101 printf("st1: %d %d %d\n",
1102 st1
.f1
, st1
.f2
, st1
.f3
);
1105 printf("union1: %d\n", st1
.u
.v1
);
1108 printf("union2: %d\n", u
.w1
);
1113 printf("st2: %d %d %d\n",
1114 s
->f1
, s
->f2
, s
->f3
);
1115 printf("str_addr=%x\n", (int)st1
.str
- (int)&st1
.f1
);
1117 /* align / size tests */
1118 printf("aligntest1 sizeof=%d alignof=%d\n",
1119 sizeof(struct aligntest1
), __alignof__(struct aligntest1
));
1120 printf("aligntest2 sizeof=%d alignof=%d\n",
1121 sizeof(struct aligntest2
), __alignof__(struct aligntest2
));
1122 printf("aligntest3 sizeof=%d alignof=%d\n",
1123 sizeof(struct aligntest3
), __alignof__(struct aligntest3
));
1124 printf("aligntest4 sizeof=%d alignof=%d\n",
1125 sizeof(struct aligntest4
), __alignof__(struct aligntest4
));
1126 printf("aligntest5 sizeof=%d alignof=%d\n",
1127 sizeof(struct aligntest5
), __alignof__(struct aligntest5
));
1128 printf("aligntest6 sizeof=%d alignof=%d\n",
1129 sizeof(struct aligntest6
), __alignof__(struct aligntest6
));
1130 printf("aligntest7 sizeof=%d alignof=%d\n",
1131 sizeof(struct aligntest7
), __alignof__(struct aligntest7
));
1132 printf("altest5 sizeof=%d alignof=%d\n",
1133 sizeof(altest5
), __alignof__(altest5
));
1134 printf("altest6 sizeof=%d alignof=%d\n",
1135 sizeof(altest6
), __alignof__(altest6
));
1136 /*printf("altest7 sizeof=%d alignof=%d\n",
1137 sizeof(altest7), __alignof__(altest7));*/
1139 /* empty structures (GCC extension) */
1140 printf("sizeof(struct empty) = %d\n", sizeof(struct empty
));
1141 printf("alignof(struct empty) = %d\n", __alignof__(struct empty
));
1143 printf("Large: sizeof=%d\n", sizeof(ls
));
1144 memset(&ls
, 0, sizeof(ls
));
1145 ls
.compound_head
= 42;
1146 printf("Large: offsetof(compound_head)=%d\n", (int)((char*)&ls
.compound_head
- (char*)&ls
));
1149 /* XXX: depend on endianness */
1150 void char_short_test()
1154 printf("char_short:\n");
1158 printf("s8=%d %d\n",
1159 *(char *)&var1
, *(char *)&var2
);
1160 printf("u8=%d %d\n",
1161 *(unsigned char *)&var1
, *(unsigned char *)&var2
);
1162 printf("s16=%d %d\n",
1163 *(short *)&var1
, *(short *)&var2
);
1164 printf("u16=%d %d\n",
1165 *(unsigned short *)&var1
, *(unsigned short *)&var2
);
1166 printf("s32=%d %d\n",
1167 *(int *)&var1
, *(int *)&var2
);
1168 printf("u32=%d %d\n",
1169 *(unsigned int *)&var1
, *(unsigned int *)&var2
);
1170 *(char *)&var1
= 0x08;
1171 printf("var1=%x\n", var1
);
1172 *(short *)&var1
= 0x0809;
1173 printf("var1=%x\n", var1
);
1174 *(int *)&var1
= 0x08090a0b;
1175 printf("var1=%x\n", var1
);
1178 /******************/
1180 typedef struct Sym
{
1188 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
1189 #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
1191 static int toupper1(int a
)
1196 static unsigned int calc_vm_flags(unsigned int prot
)
1198 unsigned int prot_bits
;
1199 /* This used to segfault in some revisions: */
1200 prot_bits
= ((0x1==0x00000001)?(prot
&0x1):(prot
&0x1)?0x00000001:0);
1206 int *s
, a
, b
, t
, f
, i
;
1210 printf("!s=%d\n", !s
);
1214 printf("a=%d\n", a
);
1216 printf("a=%d %d %d\n", 0 || 0, 0 || 1, 1 || 1);
1217 printf("a=%d %d %d\n", 0 && 0, 0 && 1, 1 && 1);
1218 printf("a=%d %d\n", 1 ? 1 : 0, 0 ? 1 : 0);
1233 printf("b=%d\n", a
+ (0 ? 1 : a
/ 2));
1235 /* test register spilling */
1238 a
= (a
+ b
) * ((a
< b
) ?
1239 ((b
- a
) * (a
- b
)): a
+ b
);
1240 printf("a=%d\n", a
);
1242 /* test complex || or && expressions */
1246 printf("exp=%d\n", f
== (32 <= a
&& a
<= 3));
1247 printf("r=%d\n", (t
|| f
) + (t
&& f
));
1252 int aspect_native
= 65536;
1253 double bfu_aspect
= 1.0;
1255 for(aspect_on
= 0; aspect_on
< 2; aspect_on
++) {
1256 aspect
=aspect_on
?(aspect_native
*bfu_aspect
+0.5):65535UL;
1257 printf("aspect=%d\n", aspect
);
1261 /* test ? : GCC extension */
1263 static int v1
= 34 ? : -1; /* constant case */
1264 static int v2
= 0 ? : -1; /* constant case */
1267 printf("%d %d\n", v1
, v2
);
1268 printf("%d %d\n", a
- 30 ? : a
* 2, a
+ 1 ? : a
* 2);
1271 /* again complex expression */
1272 for(i
=0;i
<256;i
++) {
1273 if (toupper1 (i
) != TOUPPER (i
))
1274 printf("error %d\n", i
);
1276 printf ("bits = 0x%x\n", calc_vm_flags (0x1));
1279 extern int undefined_function(void);
1280 extern int defined_function(void);
1282 static inline void refer_to_undefined(void)
1284 undefined_function();
1287 void optimize_out(void)
1289 int i
= 0 ? undefined_function() : defined_function();
1290 printf ("oo:%d\n", i
);
1291 int j
= 1 ? defined_function() : undefined_function();
1292 printf ("oo:%d\n", j
);
1294 printf("oo:%d\n", undefined_function());
1296 printf("oo:%d\n", defined_function());
1298 printf("oo:%d\n", defined_function());
1300 printf("oo:%d\n", undefined_function());
1302 printf("oow:%d\n", defined_function());
1304 printf("oow:%d\n", undefined_function());
1307 /* Following is a switch without {} block intentionally. */
1310 printf ("oos:%d\n", defined_function());
1311 /* The following break shouldn't lead to disabled code after
1315 printf ("ool1:%d\n", defined_function());
1316 /* Same for the other types of loops. */
1320 printf ("ool2:%d\n", defined_function());
1323 printf ("ool3:%d\n", defined_function());
1324 /* Normal {} blocks without controlling statements
1325 shouldn't reactivate code emission */
1330 printf ("ool4:%d\n", undefined_function());
1335 break; /* this break shouldn't disable code outside the if. */
1336 printf("ool5:%d\n", defined_function());
1346 printf("ool6:%d\n", defined_function());
1350 /* Test that constants in logical && are optimized: */
1351 i
= 0 && undefined_function();
1352 i
= defined_function() && 0 && undefined_function();
1353 if (0 && undefined_function())
1354 undefined_function();
1355 if (defined_function() && 0)
1356 undefined_function();
1358 undefined_function();
1359 if (defined_function() && 0 && undefined_function())
1360 undefined_function();
1361 /* The same for || : */
1362 i
= 1 || undefined_function();
1363 i
= defined_function() || 1 || undefined_function();
1364 if (1 || undefined_function())
1367 undefined_function();
1368 if (defined_function() || 1)
1371 undefined_function();
1375 undefined_function();
1376 if (defined_function() || 1 || undefined_function())
1379 undefined_function();
1381 if (defined_function() && 0)
1382 refer_to_undefined();
1386 printf ("oor:%d\n", undefined_function());
1389 int defined_function(void)
1395 /* GCC accepts that */
1396 static int tab_reinit
[];
1397 static int tab_reinit
[10];
1399 //int cinit1; /* a global variable can be defined several times without error ! */
1403 int *cinit2
= (int []){3, 2, 1};
1405 void compound_literal_test(void)
1410 printf("compound_test:\n");
1412 p
= (int []){1, 2, 3};
1414 printf(" %d", p
[i
]);
1418 printf("%d", cinit2
[i
]);
1422 printf("q1=%s\n", q
);
1424 q
= (char *){ "tralala2" };
1425 printf("q2=%s\n", q
);
1428 printf("q3=%s\n", q3
);
1430 q
= (char []){ "tralala3" };
1431 printf("q4=%s\n", q
);
1434 p
= (int []){1, 2, cinit1
+ 3};
1436 printf(" %d", p
[i
]);
1440 p
= (int []){1, 2, 4 + i
};
1441 printf("%d %d %d\n",
1463 printf("kr_test:\n");
1464 printf("func1=%d\n", kr_func1(3, 4));
1465 printf("func2=%d\n", kr_func2(3, 4));
1472 tab
= (char*)malloc(20);
1489 /* structure assignment tests */
1495 struct structa1 ssta1
;
1497 void struct_assign_test1(struct structa1 s1
, int t
, float f
)
1499 printf("%d %d %d %f\n", s1
.f1
, s1
.f2
, t
, f
);
1502 struct structa1
struct_assign_test2(struct structa1 s1
, int t
)
1509 void struct_assign_test(void)
1512 struct structa1 lsta1
, lsta2
;
1519 printf("struct_assign_test:\n");
1523 printf("%d %d\n", s
.lsta1
.f1
, s
.lsta1
.f2
);
1525 printf("%d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1530 struct_assign_test1(ps
->lsta2
, 3, 4.5);
1532 printf("before call: %d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1533 ps
->lsta2
= struct_assign_test2(ps
->lsta2
, ps
->i
);
1534 printf("after call: %d %d\n", ps
->lsta2
.f1
, ps
->lsta2
.f2
);
1539 /* XXX: we should allow this even without braces */
1540 { struct_assign_test
}
1542 printf("%d\n", struct_assign_test
== t
[0].elem
);
1545 /* casts to short/char */
1547 void cast1(char a
, short b
, unsigned char c
, unsigned short d
)
1549 printf("%d %d %d %d\n", a
, b
, c
, d
);
1563 p
-= 0x700000000042;
1565 printf("cast_test:\n");
1569 printf("%d %d %d %d\n",
1572 (unsigned char)(a
+ 1),
1573 (unsigned short)(a
+ 1));
1574 printf("%d %d %d %d\n",
1577 (unsigned char)0xfffff,
1578 (unsigned short)0xfffff);
1580 a
= (bcast
= 128) + 1;
1582 a
= (scast
= 65536) + 1;
1585 printf("sizeof(c) = %d, sizeof((int)c) = %d\n", sizeof(c
), sizeof((int)c
));
1587 /* test cast from unsigned to signed short to int */
1590 printf("((unsigned)(short)0x%08x) = 0x%08x\n", b
, d
);
1593 printf("((unsigned)(char)0x%08x) = 0x%08x\n", b
, d
);
1595 /* test implicit int casting for array accesses */
1599 printf("%d %d\n", tab
[0], tab
[1]);
1601 /* test implicit casting on some operators */
1602 printf("sizeof(+(char)'a') = %d\n", sizeof(+(char)'a'));
1603 printf("sizeof(-(char)'a') = %d\n", sizeof(-(char)'a'));
1604 printf("sizeof(~(char)'a') = %d\n", sizeof(-(char)'a'));
1606 /* from pointer to integer types */
1607 printf("%d %d %ld %ld %lld %lld\n",
1608 (int)p
, (unsigned int)p
,
1609 (long)p
, (unsigned long)p
,
1610 (long long)p
, (unsigned long long)p
);
1612 /* from integers to pointers */
1613 printf("%p %p %p %p\n",
1614 (void *)a
, (void *)b
, (void *)c
, (void *)d
);
1617 /* initializers tests */
1618 struct structinit1
{
1627 int sinit3
[3] = { 1, 2, {{3}}, };
1628 int sinit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1629 int sinit5
[3][2] = { 1, 2, 3, 4, 5, 6 };
1630 int sinit6
[] = { 1, 2, 3 };
1631 int sinit7
[] = { [2] = 3, [0] = 1, 2 };
1632 char sinit8
[] = "hello" "trala";
1634 struct structinit1 sinit9
= { 1, 2, 3 };
1635 struct structinit1 sinit10
= { .f2
= 2, 3, .f1
= 1 };
1636 struct structinit1 sinit11
= { .f2
= 2, 3, .f1
= 1,
1644 char *sinit12
= "hello world";
1650 char sinit14
[10] = { "abc" };
1651 int sinit15
[3] = { sizeof(sinit15
), 1, 2 };
1653 struct { int a
[3], b
; } sinit16
[] = { { 1 }, 2 };
1669 struct complexinit0
{
1674 struct complexinit
{
1676 const struct complexinit0
*b
;
1679 const static struct complexinit cix
[] = {
1682 .b
= (const struct complexinit0
[]) {
1690 struct complexinit2
{
1695 struct complexinit2 cix20
;
1697 struct complexinit2 cix21
= {
1699 .b
= { 3001, 3002, 3003 }
1702 struct complexinit2 cix22
= {
1704 .b
= { 4001, 4002, 4003, 4004, 4005, 4006 }
1707 typedef int arrtype1
[];
1708 arrtype1 sinit19
= {1};
1709 arrtype1 sinit20
= {2,3};
1710 typedef int arrtype2
[3];
1711 arrtype2 sinit21
= {4};
1712 arrtype2 sinit22
= {5,6,7};
1714 /* Address comparisons of non-weak symbols with zero can be const-folded */
1715 int sinit23
[2] = { "astring" ? sizeof("astring") : -1,
1716 &sinit23
? 42 : -1 };
1718 void init_test(void)
1722 int linit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1723 int linit6
[] = { 1, 2, 3 };
1725 char linit8
[] = "hello" "trala";
1726 int linit12
[10] = { 1, 2 };
1727 int linit13
[10] = { 1, 2, [7] = 3, [3] = 4, };
1728 char linit14
[10] = "abc";
1729 int linit15
[10] = { linit1
, linit1
+ 1, [6] = linit1
+ 2, };
1730 struct linit16
{ int a1
, a2
, a3
, a4
; } linit16
= { 1, .a3
= 2 };
1731 int linit17
= sizeof(linit17
);
1733 /* Addresses on non-weak symbols are non-zero, but not the access itself */
1734 int linit18
[2] = {&zero
? 1 : -1, zero
? -1 : 1 };
1736 printf("init_test:\n");
1738 printf("sinit1=%d\n", sinit1
);
1739 printf("sinit2=%d\n", sinit2
);
1740 printf("sinit3=%d %d %d %d\n",
1746 printf("sinit6=%d\n", sizeof(sinit6
));
1747 printf("sinit7=%d %d %d %d\n",
1753 printf("sinit8=%s\n", sinit8
);
1754 printf("sinit9=%d %d %d\n",
1759 printf("sinit10=%d %d %d\n",
1764 printf("sinit11=%d %d %d %d %d %d\n",
1775 printf("[%d][%d] = %d %d %d\n",
1776 i
, j
, sinit4
[i
][j
], sinit5
[i
][j
], linit4
[i
][j
]);
1777 printf("linit1=%d\n", linit1
);
1778 printf("linit2=%d\n", linit2
);
1779 printf("linit6=%d\n", sizeof(linit6
));
1780 printf("linit8=%d %s\n", sizeof(linit8
), linit8
);
1782 printf("sinit12=%s\n", sinit12
);
1783 printf("sinit13=%d %s %s %s\n",
1788 printf("sinit14=%s\n", sinit14
);
1790 for(i
=0;i
<10;i
++) printf(" %d", linit12
[i
]);
1792 for(i
=0;i
<10;i
++) printf(" %d", linit13
[i
]);
1794 for(i
=0;i
<10;i
++) printf(" %d", linit14
[i
]);
1796 for(i
=0;i
<10;i
++) printf(" %d", linit15
[i
]);
1798 printf("%d %d %d %d\n",
1803 /* test that initialisation is done after variable declare */
1804 printf("linit17=%d\n", linit17
);
1805 printf("sinit15=%d\n", sinit15
[0]);
1806 printf("sinit16=%d %d\n", sinit16
[0].a
[0], sinit16
[1].a
[0]);
1807 printf("sinit17=%s %d %s %d\n",
1808 sinit17
[0].s
, sinit17
[0].len
,
1809 sinit17
[1].s
, sinit17
[1].len
);
1811 printf("%x ", sinit18
[i
]);
1813 /* complex init check */
1814 printf("cix: %d %d %d %d %d %d %d\n",
1816 cix
[0].b
[0].a
, cix
[0].b
[0].b
,
1817 cix
[0].b
[1].a
, cix
[0].b
[1].b
,
1818 cix
[0].b
[2].a
, cix
[0].b
[2].b
);
1819 printf("cix2: %d %d\n", cix21
.b
[2], cix22
.b
[5]);
1820 printf("sizeof cix20 %d, cix21 %d, sizeof cix22 %d\n", sizeof cix20
, sizeof cix21
, sizeof cix22
);
1822 printf("arrtype1: %d %d %d\n", sinit19
[0], sinit20
[0], sinit20
[1]);
1823 printf("arrtype2: %d %d\n", sizeof(sinit19
), sizeof(sinit20
));
1824 printf("arrtype3: %d %d %d\n", sinit21
[0], sinit21
[1], sinit21
[2]);
1825 printf("arrtype4: %d %d %d\n", sinit22
[0], sinit22
[1], sinit22
[2]);
1826 printf("arrtype5: %d %d\n", sizeof(sinit21
), sizeof(sinit22
));
1827 printf("arrtype6: %d\n", sizeof(arrtype2
));
1829 printf("sinit23= %d %d\n", sinit23
[0], sinit23
[1]);
1830 printf("linit18= %d %d\n", linit18
[0], linit18
[1]);
1833 void switch_uc(unsigned char uc
)
1846 printf("ucsw: broken!\n");
1850 void switch_sc(signed char sc
)
1863 printf("scsw: broken!\n");
1870 unsigned long long ull
;
1895 for (i
= 1; i
<= 5; i
++) {
1896 ull
= (unsigned long long)i
<< 61;
1899 printf("ullsw:1\n");
1902 printf("ullsw:2\n");
1905 printf("ullsw:3\n");
1908 printf("ullsw:4\n");
1911 printf("ullsw:5\n");
1914 printf("ullsw: broken!\n");
1918 for (i
= 1; i
<= 5; i
++) {
1919 ll
= (long long)i
<< 61;
1937 printf("llsw: broken!\n");
1941 for (i
= -5; i
<= 5; i
++) {
1942 switch_uc((unsigned char)i
);
1945 for (i
= -5; i
<= 5; i
++) {
1946 switch_sc ((signed char)i
);
1950 /* ISOC99 _Bool type */
1951 void c99_bool_test(void)
1957 printf("bool_test:\n");
1958 printf("sizeof(_Bool) = %d\n", sizeof(_Bool
));
1960 printf("cast: %d %d %d\n", (_Bool
)10, (_Bool
)0, (_Bool
)a
);
1962 printf("b = %d\n", b
);
1964 printf("b = %d\n", b
);
1968 void bitfield_test(void)
1980 unsigned int f5
: 7;
1982 printf("bitfield_test:");
1983 printf("sizeof(st1) = %d\n", sizeof(st1
));
1992 printf("%d %d %d %d %d\n",
1993 st1
.f1
, st1
.f2
, st1
.f3
, st1
.f4
, st1
.f5
);
1996 printf("%d %d\n", sa
, ca
);
2000 printf("st1.f1 == -1\n");
2002 printf("st1.f1 != -1\n");
2004 printf("st1.f2 == -1\n");
2006 printf("st1.f2 != -1\n");
2008 /* bit sizes below must be bigger than 32 since GCC doesn't allow
2009 long-long bitfields whose size is not bigger than int */
2014 unsigned long long f3
: 38;
2016 st2
.f1
= 0x123456789ULL
;
2018 st2
.f2
= (long long)a
<< 25;
2021 printf("%lld %lld %lld\n", st2
.f1
, st2
.f2
, st2
.f3
);
2025 #define FLOAT_FMT "%f\n"
2027 /* x86's float isn't compatible with GCC */
2028 #define FLOAT_FMT "%.5f\n"
2031 /* declare strto* functions as they are C99 */
2032 double strtod(const char *nptr
, char **endptr
);
2035 float strtof(const char *nptr
, char **endptr
) {return (float)strtod(nptr
, endptr
);}
2036 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
) {return (LONG_DOUBLE
)strtod(nptr
, endptr
);}
2038 float strtof(const char *nptr
, char **endptr
);
2039 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
);
2042 #define FTEST(prefix, typename, type, fmt)\
2043 void prefix ## cmp(type a, type b)\
2045 printf("%d %d %d %d %d %d\n",\
2052 printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\
2060 printf(fmt "\n", ++a);\
2061 printf(fmt "\n", a++);\
2062 printf(fmt "\n", a);\
2064 printf("%d %d\n", !a, !b);\
2066 void prefix ## fcast(type a)\
2074 unsigned long long llua;\
2079 printf("ftof: %f %f %Lf\n", fa, da, la);\
2081 llia = (long long)a;\
2082 a = (a >= 0) ? a : -a;\
2083 ua = (unsigned int)a;\
2084 llua = (unsigned long long)a;\
2085 printf("ftoi: %d %u %lld %llu\n", ia, ua, llia, llua);\
2088 llia = -0x123456789012345LL;\
2089 llua = 0xf123456789012345LLU;\
2091 printf("itof: " fmt "\n", b);\
2093 printf("utof: " fmt "\n", b);\
2095 printf("lltof: " fmt "\n", b);\
2097 printf("ulltof: " fmt "\n", b);\
2100 float prefix ## retf(type a) { return a; }\
2101 double prefix ## retd(type a) { return a; }\
2102 LONG_DOUBLE prefix ## retld(type a) { return a; }\
2104 void prefix ## call(void)\
2106 printf("float: " FLOAT_FMT, prefix ## retf(42.123456789));\
2107 printf("double: %f\n", prefix ## retd(42.123456789));\
2108 printf("long double: %Lf\n", prefix ## retld(42.123456789));\
2109 printf("strto%s: %f\n", #prefix, (double)strto ## prefix("1.2", NULL));\
2112 void prefix ## signed_zeros(void) \
2114 type x = 0.0, y = -0.0, n, p;\
2116 printf ("Test 1.0 / x != 1.0 / y returns %d (should be 1).\n",\
2117 1.0 / x != 1.0 / y);\
2119 printf ("x != y; this is wrong!\n");\
2123 printf ("Test 1.0 / x != 1.0 / -x returns %d (should be 1).\n",\
2124 1.0 / x != 1.0 / n);\
2126 printf ("x != -x; this is wrong!\n");\
2130 printf ("Test 1.0 / x != 1.0 / +y returns %d (should be 1).\n",\
2131 1.0 / x != 1.0 / p);\
2133 printf ("x != +y; this is wrong!\n");\
2136 printf ("Test 1.0 / x != 1.0 / -y returns %d (should be 0).\n",\
2137 1.0 / x != 1.0 / p);\
2139 printf ("x != -y; this is wrong!\n");\
2141 void prefix ## test(void)\
2143 printf("testing '%s'\n", #typename);\
2144 prefix ## cmp(1, 2.5);\
2145 prefix ## cmp(2, 1.5);\
2146 prefix ## cmp(1, 1);\
2147 prefix ## fcast(234.6);\
2148 prefix ## fcast(-2334.6);\
2150 prefix ## signed_zeros();\
2153 FTEST(f
, float, float, "%f")
2154 FTEST(d
, double, double, "%f")
2155 FTEST(ld
, long double, LONG_DOUBLE
, "%Lf")
2157 double ftab1
[3] = { 1.2, 3.4, -5.6 };
2160 void float_test(void)
2162 #if !defined(__arm__) || defined(__ARM_PCS_VFP)
2168 printf("float_test:\n");
2169 printf("sizeof(float) = %d\n", sizeof(float));
2170 printf("sizeof(double) = %d\n", sizeof(double));
2171 printf("sizeof(long double) = %d\n", sizeof(LONG_DOUBLE
));
2175 printf("%f %f %f\n", ftab1
[0], ftab1
[1], ftab1
[2]);
2176 printf("%f %f %f\n", 2.12, .5, 2.3e10
);
2177 // printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
2179 printf("da=%f\n", da
);
2181 printf("fa=%f\n", fa
);
2184 printf("da = %f\n", da
);
2187 printf("db = %f\n", db
);
2196 return fib(n
-1) + fib(n
-2);
2209 printf("funcptr:\n");
2216 /* more complicated pointer computation */
2219 printf("sizeof1 = %d\n", sizeof(funcptr_test
));
2220 printf("sizeof2 = %d\n", sizeof funcptr_test
);
2221 printf("sizeof3 = %d\n", sizeof(&funcptr_test
));
2222 printf("sizeof4 = %d\n", sizeof &funcptr_test
);
2231 void lloptest(long long a
, long long b
)
2233 unsigned long long ua
, ub
;
2238 printf("arith: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2244 printf("arith1: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2250 printf("bin: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2256 printf("test: %d %d %d %d %d %d\n",
2264 printf("utest: %d %d %d %d %d %d\n",
2275 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2276 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
++, b
++);
2277 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", --a
, --b
);
2278 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2280 printf("not: %d %d %d %d\n", !a
, !ua
, !b
, !ub
);
2283 void llshift(long long a
, int b
)
2285 printf("shift: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2286 (unsigned long long)a
>> b
,
2289 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2290 (unsigned long long)a
>> 3,
2293 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2294 (unsigned long long)a
>> 35,
2304 long long la
, lb
, lc
;
2305 unsigned long long ula
, ulb
, ulc
;
2308 la
= (la
<< 20) | 0x12345;
2310 printf("la=" LONG_LONG_FORMAT
" ula=" ULONG_LONG_FORMAT
"\n", la
, ula
);
2315 printf("lltof: %f %f %Lf\n", fa
, da
, lda
);
2320 printf("ftoll: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", la
, lb
, lc
);
2325 printf("ulltof: %f %f %Lf\n", fa
, da
, lda
);
2330 printf("ftoull: " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
"\n", ula
, ulb
, ulc
);
2333 long long llfunc1(int a
)
2343 long long int value(struct S
*v
)
2345 return ((long long int)v
->item
);
2348 long long llfunc2(long long x
, long long y
, int z
)
2353 void longlong_test(void)
2358 printf("longlong_test:\n");
2359 printf("sizeof(long long) = %d\n", sizeof(long long));
2364 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2365 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %Lx\n",
2369 0x1234567812345679);
2371 printf(LONG_LONG_FORMAT
"\n", a
);
2374 lloptest(0xff, 0x1234);
2375 b
= 0x72345678 << 10;
2379 b
= 0x72345678LL
<< 10;
2390 /* long long reg spill test */
2395 printf("%lld\n", value(&a
));
2397 lloptest(0x80000000, 0);
2400 long long *p
, v
, **pp
;
2404 printf("another long long spill test : %lld\n", *p
);
2407 v
= llfunc2(**pp
, **pp
, ia
);
2408 printf("a long long function (arm-)reg-args test : %lld\n", v
);
2412 printf("%d %d %d %d\n", a
> b
, a
< b
, a
>= b
, a
<= b
);
2414 printf(LONG_LONG_FORMAT
"\n", 0x123456789LLU
);
2416 /* long long pointer deref in argument passing test */
2422 void manyarg_test(void)
2424 LONG_DOUBLE ld
= 1234567891234LL;
2425 printf("manyarg_test:\n");
2426 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2427 1, 2, 3, 4, 5, 6, 7, 8,
2428 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2429 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2430 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2431 1, 2, 3, 4, 5, 6, 7, 8,
2432 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2433 1234567891234LL, 987654321986LL,
2435 printf("%Lf %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2436 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2437 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2438 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2439 1234567891234LL, 987654321986LL,
2441 printf("%d %d %d %d %d %d %d %d %Lf\n",
2442 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2443 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2444 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"%f %f %Lf\n",
2445 1, 2, 3, 4, 5, 6, 7, 8,
2446 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2447 1234567891234LL, 987654321986LL,
2449 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2450 "%Lf " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f %Lf\n",
2451 1, 2, 3, 4, 5, 6, 7, 8,
2452 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2453 ld
, 1234567891234LL, 987654321986LL,
2457 void vprintf1(const char *fmt
, ...)
2481 i
= va_arg(ap
, int);
2485 d
= va_arg(ap
, double);
2489 ll
= va_arg(ap
, long long);
2490 printf(LONG_LONG_FORMAT
, ll
);
2493 ld
= va_arg(ap
, LONG_DOUBLE
);
2511 void stdarg_for_struct(struct myspace bob
, ...)
2513 struct myspace george
, bill
;
2518 bill
= va_arg(ap
, struct myspace
);
2519 george
= va_arg(ap
, struct myspace
);
2520 validate
= va_arg(ap
, int);
2521 printf("stdarg_for_struct: %d %d %d %d\n",
2522 bob
.profile
, bill
.profile
, george
.profile
, validate
);
2526 void stdarg_for_libc(const char *fmt
, ...)
2529 va_start(args
, fmt
);
2534 void stdarg_test(void)
2536 LONG_DOUBLE ld
= 1234567891234LL;
2539 vprintf1("%d %d %d\n", 1, 2, 3);
2540 vprintf1("%f %d %f\n", 1.0, 2, 3.0);
2541 vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0);
2542 vprintf1("%F %F %F\n", LONG_DOUBLE_LITERAL(1.2), LONG_DOUBLE_LITERAL(2.3), LONG_DOUBLE_LITERAL(3.4));
2543 vprintf1("%d %f %l %F %d %f %l %F\n",
2544 1, 1.2, 3LL, LONG_DOUBLE_LITERAL(4.5), 6, 7.8, 9LL, LONG_DOUBLE_LITERAL(0.1));
2545 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f\n",
2546 1, 2, 3, 4, 5, 6, 7, 8,
2547 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8);
2548 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2549 1, 2, 3, 4, 5, 6, 7, 8,
2550 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2551 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2553 1, 2, 3, 4, 5, 6, 7, 8,
2554 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2555 1234567891234LL, 987654321986LL,
2557 vprintf1("%F %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2559 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2560 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2561 1234567891234LL, 987654321986LL,
2563 vprintf1("%d %d %d %d %d %d %d %d %F\n",
2564 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2565 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2567 1, 2, 3, 4, 5, 6, 7, 8,
2568 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2569 1234567891234LL, 987654321986LL,
2571 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2572 "%F %l %l %f %f %F\n",
2573 1, 2, 3, 4, 5, 6, 7, 8,
2574 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2575 ld
, 1234567891234LL, 987654321986LL,
2579 stdarg_for_struct(bob
, bob
, bob
, bob
.profile
);
2580 stdarg_for_libc("stdarg_for_libc: %s %.2f %d\n", "string", 1.23, 456);
2583 void whitespace_test(void)
2589 ntf("whitspace:\n");\f\v
2593 #ifdef CORRECT_CR_HANDLING
2602 #ifdef ACCEPT_CR_IN_STRINGS
2603 printf("len1=%d\n", strlen("
2605 #ifdef CORRECT_CR_HANDLING
2608 printf("len1=%d str[0]=%d\n", strlen(str
), str
[0]);
2610 printf("len1=%d\n", strlen("
a
2612 #endif /* ACCEPT_CR_IN_STRINGS */
2615 int reltab
[3] = { 1, 2, 3 };
2617 int *rel1
= &reltab
[1];
2618 int *rel2
= &reltab
[2];
2620 void getmyaddress(void)
2622 printf("in getmyaddress\n");
2626 long __pa_symbol(void)
2628 /* This 64bit constant was handled incorrectly, it was used as addend
2629 (which can hold 64bit just fine) in connection with a symbol,
2630 and TCC generates wrong code for that (displacements are 32bit only).
2631 This effectively is "+ 0x80000000", and if addresses of globals
2632 are below 2GB the result should be a number without high 32 bits set. */
2633 return ((long)(((unsigned long)(&rel1
))) - (0xffffffff80000000UL
));
2637 unsigned long theaddress
= (unsigned long)getmyaddress
;
2638 void relocation_test(void)
2640 void (*fptr
)(void) = (void (*)(void))theaddress
;
2641 printf("*rel1=%d\n", *rel1
);
2642 printf("*rel2=%d\n", *rel2
);
2645 printf("pa_symbol=0x%lx\n", __pa_symbol() >> 63);
2649 void old_style_f(a
,b
,c
)
2653 printf("a=%d b=%d b=%f\n", a
, b
, c
);
2656 void decl_func1(int cmpfn())
2658 printf("cmpfn=%lx\n", (long)cmpfn
);
2661 void decl_func2(cmpfn
)
2664 printf("cmpfn=%lx\n", (long)cmpfn
);
2667 void old_style_function(void)
2669 old_style_f((void *)1, 2, 3.0);
2676 #if defined __i386__ || defined __x86_64__ || defined __arm__
2677 char *p
= alloca(16);
2678 strcpy(p
,"123456789012345");
2679 printf("alloca: p is %s\n", p
);
2680 char *demo
= "This is only a test.\n";
2681 /* Test alloca embedded in a larger expression */
2682 printf("alloca: %s\n", strcpy(alloca(strlen(demo
)+1),demo
) );
2686 void *bounds_checking_is_enabled()
2688 char ca
[10], *cp
= ca
-1;
2689 return (ca
!= cp
+ 1) ? cp
: NULL
;
2692 typedef int constant_negative_array_size_as_compile_time_assertion_idiom
[(1 ? 2 : 0) - 1];
2694 void c99_vla_test(int size1
, int size2
)
2696 #if defined __i386__ || defined __x86_64__
2697 int size
= size1
* size2
;
2698 int tab1
[size
][2], tab2
[10][2];
2699 void *tab1_ptr
, *tab2_ptr
, *bad_ptr
;
2701 /* "size" should have been 'captured' at tab1 declaration,
2702 so modifying it should have no effect on VLA behaviour. */
2705 printf("Test C99 VLA 1 (sizeof): ");
2706 printf("%s\n", (sizeof tab1
== size1
* size2
* 2 * sizeof(int)) ? "PASSED" : "FAILED");
2709 printf("Test C99 VLA 2 (ptrs subtract): ");
2710 printf("%s\n", (tab2
- tab1
== (tab2_ptr
- tab1_ptr
) / (sizeof(int) * 2)) ? "PASSED" : "FAILED");
2711 printf("Test C99 VLA 3 (ptr add): ");
2712 printf("%s\n", &tab1
[5][1] == (tab1_ptr
+ (5 * 2 + 1) * sizeof(int)) ? "PASSED" : "FAILED");
2713 printf("Test C99 VLA 4 (ptr access): ");
2714 tab1
[size1
][1] = 42;
2715 printf("%s\n", (*((int *) (tab1_ptr
+ (size1
* 2 + 1) * sizeof(int))) == 42) ? "PASSED" : "FAILED");
2717 printf("Test C99 VLA 5 (bounds checking (might be disabled)): ");
2718 if (bad_ptr
= bounds_checking_is_enabled()) {
2719 int *t1
= &tab1
[size1
* size2
- 1][3];
2720 int *t2
= &tab2
[9][3];
2721 printf("%s ", bad_ptr
== t1
? "PASSED" : "FAILED");
2722 printf("%s ", bad_ptr
== t2
? "PASSED" : "FAILED");
2724 char*c1
= 1 + sizeof(tab1
) + (char*)tab1
;
2725 char*c2
= 1 + sizeof(tab2
) + (char*)tab2
;
2726 printf("%s ", bad_ptr
== c1
? "PASSED" : "FAILED");
2727 printf("%s ", bad_ptr
== c2
? "PASSED" : "FAILED");
2731 printf("%s ", bad_ptr
== i1
? "PASSED" : "FAILED");
2732 printf("%s ", bad_ptr
== i2
? "PASSED" : "FAILED");
2734 int *x1
= tab1
[size1
* size2
+ 1];
2735 int *x2
= tab2
[10 + 1];
2736 printf("%s ", bad_ptr
== x1
? "PASSED" : "FAILED");
2737 printf("%s ", bad_ptr
== x2
? "PASSED" : "FAILED");
2739 printf("PASSED PASSED PASSED PASSED PASSED PASSED PASSED PASSED ");
2746 typedef __SIZE_TYPE__
uintptr_t;
2749 void sizeof_test(void)
2754 printf("sizeof(int) = %d\n", sizeof(int));
2755 printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
2756 printf("sizeof(long) = %d\n", sizeof(long));
2757 printf("sizeof(unsigned long) = %d\n", sizeof(unsigned long));
2758 printf("sizeof(short) = %d\n", sizeof(short));
2759 printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
2760 printf("sizeof(char) = %d\n", sizeof(char));
2761 printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
2762 printf("sizeof(func) = %d\n", sizeof sizeof_test());
2764 printf("sizeof(a++) = %d\n", sizeof a
++);
2765 printf("a=%d\n", a
);
2767 printf("sizeof(**ptr) = %d\n", sizeof (**ptr
));
2769 /* The type of sizeof should be as large as a pointer, actually
2770 it should be size_t. */
2771 printf("sizeof(sizeof(int) = %d\n", sizeof(sizeof(int)));
2774 /* Effectively <<32, but defined also on 32bit machines. */
2778 /* This checks that sizeof really can be used to manipulate
2779 uintptr_t objects, without truncation. */
2780 t2
= t
& -sizeof(uintptr_t);
2781 printf ("%lu %lu\n", t
, t2
);
2783 /* some alignof tests */
2784 printf("__alignof__(int) = %d\n", __alignof__(int));
2785 printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int));
2786 printf("__alignof__(short) = %d\n", __alignof__(short));
2787 printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short));
2788 printf("__alignof__(char) = %d\n", __alignof__(char));
2789 printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char));
2790 printf("__alignof__(func) = %d\n", __alignof__
sizeof_test());
2792 /* sizes of VLAs need to be evaluated even inside sizeof: */
2794 printf("sizeof(char[1+2*a]) = %d\n", sizeof(char[1+2*a
]));
2795 /* And checking if sizeof compound literal works. Parenthesized: */
2796 printf("sizeof( (struct {int i; int j;}){4,5} ) = %d\n",
2797 sizeof( (struct {int i
; int j
;}){4,5} ));
2798 /* And as direct sizeof argument (as unary expression): */
2799 printf("sizeof (struct {short i; short j;}){4,5} = %d\n",
2800 sizeof (struct {short i
; short j
;}){4,5} );
2802 /* sizeof(x && y) should be sizeof(int), even if constant
2803 evaluating is possible. */
2804 printf("sizeof(t && 0) = %d\n", sizeof(t
&& 0));
2805 printf("sizeof(1 && 1) = %d\n", sizeof(1 && 1));
2806 printf("sizeof(t || 1) = %d\n", sizeof(t
|| 1));
2807 printf("sizeof(0 || 0) = %d\n", sizeof(0 || 0));
2810 void typeof_test(void)
2819 printf("a=%f b=%f c=%f\n", a
, b
, c
);
2825 struct hlist_node
*first
, *last
;
2828 void statement_expr_test(void)
2832 /* Basic stmt expr test */
2842 printf("a=%d\n", a
);
2844 /* Test that symbols aren't freed prematurely.
2845 With SYM_DEBUG valgrind will show a read from a freed
2846 symbol, and tcc will show an (invalid) warning on the initialization
2847 of 'ptr' below, if symbols are popped after the stmt expr. */
2848 void *v
= (void*)39;
2850 (struct hlist_node
*)v
;
2853 ptr
= (struct hlist_node
*)v
;
2855 /* This part used to segfault when symbols were popped prematurely.
2856 The symbols for the static local would be overwritten with
2857 helper symbols from the pre-processor expansions in between. */
2858 #define some_attr __attribute__((aligned(1)))
2859 #define tps(str) ({ \
2860 static const char *t some_attr = str; \
2863 printf ("stmtexpr: %s %s\n",
2864 tps("somerandomlongstring"),
2865 tps("anotherlongstring"));
2867 /* Test that the three decls of 't' don't interact. */
2869 int b
= ({ int t
= 41; t
; });
2870 int c
= ({ int t
= 42; t
; });
2872 /* Test that aggregate return values work. */
2875 typedef struct hlist_head T
;
2877 T t
= { (void*)43, (void*)44 };
2881 printf ("stmtexpr: %d %d %d\n", t
, b
, c
);
2882 printf ("stmtexpr: %ld %ld\n", (long)h
.first
, (long)h
.last
);
2885 void local_label_test(void)
2891 __label__ l1
, l2
, l3
, l4
;
2905 printf("a=%d\n", a
);
2915 /* inline assembler test */
2916 #if defined(__i386__) || defined(__x86_64__)
2918 /* from linux kernel */
2919 static char * strncat1(char * dest
,const char * src
,size_t count
)
2921 long d0
, d1
, d2
, d3
;
2922 __asm__
__volatile__(
2931 "testb %%al,%%al\n\t"
2935 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
2936 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
2941 static char * strncat2(char * dest
,const char * src
,size_t count
)
2943 long d0
, d1
, d2
, d3
;
2944 __asm__
__volatile__(
2945 "repne scasb\n\t" /* one-line repne prefix + string op */
2952 "testb %%al,%%al\n\t"
2956 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
2957 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
2962 static inline void * memcpy1(void * to
, const void * from
, size_t n
)
2965 __asm__
__volatile__(
2970 "1:\ttestb $1,%b4\n\t"
2974 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
2975 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
2980 static inline void * memcpy2(void * to
, const void * from
, size_t n
)
2983 __asm__
__volatile__(
2984 "rep movsl\n\t" /* one-line rep prefix + string op */
2988 "1:\ttestb $1,%b4\n\t"
2992 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
2993 :"0" (n
/4), "q" (n
),"1" ((long) to
),"2" ((long) from
)
2998 static __inline__
void sigaddset1(unsigned int *set
, int _sig
)
3000 __asm__("btsl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc");
3003 static __inline__
void sigdelset1(unsigned int *set
, int _sig
)
3005 asm("btrl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc", "flags");
3008 static __inline__ __const__
unsigned int swab32(unsigned int x
)
3010 __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */
3011 "rorl $16,%0\n\t" /* swap words */
3012 "xchgb %b0,%h0" /* swap higher bytes */
3018 static __inline__
unsigned long long mul64(unsigned int a
, unsigned int b
)
3020 unsigned long long res
;
3022 /* Using the A constraint is wrong (it means rdx:rax, which is too large)
3023 but still test the 32bit->64bit mull. */
3024 unsigned int resh
, resl
;
3025 __asm__("mull %2" : "=a" (resl
), "=d" (resh
) : "a" (a
), "r" (b
));
3026 res
= ((unsigned long long)resh
<< 32) | resl
;
3028 __asm__("mull %2" : "=A" (res
) : "a" (a
), "r" (b
));
3033 static __inline__
unsigned long long inc64(unsigned long long a
)
3035 unsigned long long res
;
3037 /* Using the A constraint is wrong, and increments are tested
3041 __asm__("addl $1, %%eax ; adcl $0, %%edx" : "=A" (res
) : "A" (a
));
3054 unsigned long mconstraint_test(struct struct1231
*r
)
3059 __asm__
volatile ("lea %2,%0; movl 4(%0),%k0; addl %2,%k0; movl $51,%2; movl $52,4%2; movl $63,%1"
3060 : "=&r" (ret
), "=m" (a
)
3061 : "m" (*(struct struct123
*)r
->addr
));
3066 int fls64(unsigned long long x
)
3076 void other_constraints_test(void)
3080 __asm__
volatile ("movq %P1,%0" : "=r" (ret
) : "p" (&var
));
3081 printf ("oc1: %d\n", ret
== (unsigned long)&var
);
3084 /* Test global asm blocks playing with aliases. */
3085 void base_func(void)
3087 printf ("asmc: base\n");
3090 extern void override_func1 (void);
3091 extern void override_func2 (void);
3093 asm(".weak override_func1\n.set override_func1, base_func");
3094 asm(".set override_func1, base_func");
3095 asm(".set override_func2, base_func");
3097 void override_func2 (void)
3099 printf ("asmc: override2\n");
3102 /* This checks a construct used by the linux kernel to encode
3103 references to strings by PC relative references. */
3104 extern int bug_table
[] __attribute__((section("__bug_table")));
3105 char * get_asm_string (void)
3107 extern int some_symbol
;
3108 asm volatile (".globl some_symbol\n"
3111 "some_symbol: .long 0\n"
3112 ".pushsection __bug_table, \"a\"\n"
3113 ".globl bug_table\n"
3115 /* The first entry (1b-2b) is unused in this test,
3116 but we include it to check if cross-section
3117 PC-relative references work. */
3118 "2:\t.long 1b - 2b, %c0 - 2b\n"
3119 ".popsection\n" : : "i" ("A string"));
3120 char * str
= ((char*)bug_table
) + bug_table
[1];
3126 void fancy_copy (unsigned *in
, unsigned *out
)
3128 asm volatile ("" : "=r" (*out
) : "0" (*in
));
3131 void fancy_copy2 (unsigned *in
, unsigned *out
)
3133 asm volatile ("mov %0,(%1)" : : "r" (*in
), "r" (out
) : "memory");
3137 void clobber_r12(void)
3139 asm volatile("mov $1, %%r12" ::: "r12");
3143 void test_high_clobbers(void)
3146 register long val
asm("r12");
3148 /* This tests if asm clobbers correctly save/restore callee saved
3149 registers if they are clobbered and if it's the high 8 x86-64
3150 registers. This is fragile for GCC as the constraints do not
3151 correctly capture the data flow, but good enough for us. */
3152 asm volatile("mov $0x4542, %%r12" : "=r" (val
):: "memory");
3154 asm volatile("mov %%r12, %0" : "=r" (val2
) : "r" (val
): "memory");
3155 printf("asmhc: 0x%x\n", val2
);
3159 static long cpu_number
;
3160 void trace_console(long len
, long len2
)
3162 /* This generated invalid code when the emission of the switch
3163 table isn't disabled. The asms are necessary to show the bug,
3164 normal statements don't work (they need to generate some code
3165 even under nocode_wanted, which normal statements don't do,
3166 but asms do). Also at least these number of cases is necessary
3167 to generate enough "random" bytes. They ultimately are enough
3168 to create invalid instruction patterns to which the first
3169 skip-to-decision-table jump jumps. If decision table emission
3170 is disabled all of this is no problem.
3172 It also is necessary that the switches are in a statement expression
3173 (which has the property of not being enterable from outside. no
3184 case 8: printf("bla"); pfo_ret__
= 42; break;
3186 pscr_ret__
= pfo_ret__
;
3193 case 1:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3194 case 2:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3195 case 4:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3196 case 8:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3197 default: printf("impossible\n");
3199 pscr_ret__
= pfo_ret__
;
3212 unsigned int val
, val2
;
3213 struct struct123 s1
;
3214 struct struct1231 s2
= { (unsigned long)&s1
};
3215 /* Hide the outer base_func, but check later that the inline
3216 asm block gets the outer one. */
3218 void override_func3 (void);
3219 unsigned long asmret
;
3223 register int regvar
asm("%esi");
3225 printf("inline asm:\n");
3227 // parse 0x1E-1 as 3 tokens in asm mode
3228 asm volatile ("mov $0x1E-1,%eax");
3230 /* test the no operand case */
3231 asm volatile ("xorl %eax, %eax");
3233 memcpy1(buf
, "hello", 6);
3234 strncat1(buf
, " worldXXXXX", 3);
3235 printf("%s\n", buf
);
3237 memcpy2(buf
, "hello", 6);
3238 strncat2(buf
, " worldXXXXX", 3);
3239 printf("%s\n", buf
);
3241 /* 'A' constraint test */
3242 printf("mul64=0x%Lx\n", mul64(0x12345678, 0xabcd1234));
3243 printf("inc64=0x%Lx\n", inc64(0x12345678ffffffff));
3247 printf("mconstraint: %d", mconstraint_test(&s2
));
3248 printf(" %d %d\n", s1
.a
, s1
.b
);
3249 other_constraints_test();
3251 sigdelset1(&set
, 2);
3252 sigaddset1(&set
, 16);
3253 /* NOTE: we test here if C labels are correctly restored after the
3257 __asm__("btsl %1,%0" : "=m"(set
) : "Ir"(20) : "cc");
3258 printf("set=0x%x\n", set
);
3260 printf("swab32(0x%08x) = 0x%0x\n", val
, swab32(val
));
3263 /* The base_func ref from the following inline asm should find
3264 the global one, not the local decl from this function. */
3265 asm volatile(".weak override_func3\n.set override_func3, base_func");
3267 /* Check that we can also load structs of appropriate layout
3269 asm volatile("" : "=r" (asmret
) : "0"(s2
));
3270 if (asmret
!= s2
.addr
)
3271 printf("asmstr: failed\n");
3273 /* Check that the typesize correctly sets the register size to
3275 asm volatile("cmp %1,%2; sete %0" : "=a"(somebool
) : "r"(1), "r"(2));
3277 printf("asmbool: failed\n");
3279 printf("asmstr: %s\n", get_asm_string());
3281 fancy_copy (&val
, &val2
);
3282 printf ("fancycpy(%d)=%d\n", val
, val2
);
3284 fancy_copy2 (&val
, &val2
);
3285 printf ("fancycpy2(%d)=%d\n", val
, val2
);
3286 asm volatile ("mov $0x4243, %%esi" : "=r" (regvar
));
3287 printf ("regvar=%x\n", regvar
);
3288 test_high_clobbers();
3289 trace_console(8, 8);
3303 #define COMPAT_TYPE(type1, type2) \
3305 printf("__builtin_types_compatible_p(%s, %s) = %d\n", #type1, #type2, \
3306 __builtin_types_compatible_p (type1, type2));\
3311 void builtin_test(void)
3317 COMPAT_TYPE(int, int);
3318 COMPAT_TYPE(int, unsigned int);
3319 COMPAT_TYPE(int, char);
3320 COMPAT_TYPE(int, const int);
3321 COMPAT_TYPE(int, volatile int);
3322 COMPAT_TYPE(int *, int *);
3323 COMPAT_TYPE(int *, void *);
3324 COMPAT_TYPE(int *, const int *);
3325 COMPAT_TYPE(char *, unsigned char *);
3326 COMPAT_TYPE(char *, signed char *);
3327 COMPAT_TYPE(char *, char *);
3328 /* space is needed because tcc preprocessor introduces a space between each token */
3329 COMPAT_TYPE(char * *, void *);
3331 printf("res = %d\n", __builtin_constant_p(1));
3332 printf("res = %d\n", __builtin_constant_p(1 + 2));
3333 printf("res = %d\n", __builtin_constant_p(&constant_p_var
));
3334 printf("res = %d\n", __builtin_constant_p(constant_p_var
));
3335 printf("res = %d\n", __builtin_constant_p(100000 / constant_p_var
));
3338 i
= __builtin_choose_expr (1 != 0, ll
, s
);
3339 printf("bce: %d\n", i
);
3340 i
= __builtin_choose_expr (1 != 1, ll
, s
);
3341 printf("bce: %d\n", i
);
3342 i
= sizeof (__builtin_choose_expr (1, ll
, s
));
3343 printf("bce: %d\n", i
);
3344 i
= sizeof (__builtin_choose_expr (0, ll
, s
));
3345 printf("bce: %d\n", i
);
3347 printf("bera: %p\n", __builtin_extract_return_addr((void*)43));
3351 extern int __attribute__((weak
)) weak_f1(void);
3352 extern int __attribute__((weak
)) weak_f2(void);
3353 extern int weak_f3(void);
3354 extern int __attribute__((weak
)) weak_v1
;
3355 extern int __attribute__((weak
)) weak_v2
;
3358 extern int (*weak_fpa
)() __attribute__((weak
));
3359 extern int __attribute__((weak
)) (*weak_fpb
)();
3360 extern __attribute__((weak
)) int (*weak_fpc
)();
3362 extern int weak_asm_f1(void) asm("weak_asm_f1x") __attribute((weak
));
3363 extern int __attribute((weak
)) weak_asm_f2(void) asm("weak_asm_f2x") ;
3364 extern int __attribute((weak
)) weak_asm_f3(void) asm("weak_asm_f3x") __attribute((weak
));
3365 extern int weak_asm_v1
asm("weak_asm_v1x") __attribute((weak
));
3366 extern int __attribute((weak
)) weak_asm_v2
asm("weak_asm_v2x") ;
3367 extern int __attribute((weak
)) weak_asm_v3(void) asm("weak_asm_v3x") __attribute((weak
));
3369 static const size_t dummy
= 0;
3370 extern __typeof(dummy
) weak_dummy1
__attribute__((weak
, alias("dummy")));
3371 extern __typeof(dummy
) __attribute__((weak
, alias("dummy"))) weak_dummy2
;
3372 extern __attribute__((weak
, alias("dummy"))) __typeof(dummy
) weak_dummy3
;
3374 int some_lib_func(void);
3375 int dummy_impl_of_slf(void) { return 444; }
3376 int some_lib_func(void) __attribute__((weak
, alias("dummy_impl_of_slf")));
3378 int weak_toolate() __attribute__((weak
));
3379 int weak_toolate() { return 0; }
3381 void __attribute__((weak
)) weak_test(void)
3383 printf("weak_f1=%d\n", weak_f1
? weak_f1() : 123);
3384 printf("weak_f2=%d\n", weak_f2
? weak_f2() : 123);
3385 printf("weak_f3=%d\n", weak_f3
? weak_f3() : 123);
3386 printf("weak_v1=%d\n",&weak_v1
? weak_v1
: 123);
3387 printf("weak_v2=%d\n",&weak_v2
? weak_v2
: 123);
3388 printf("weak_v3=%d\n",&weak_v3
? weak_v3
: 123);
3390 printf("weak_fpa=%d\n",&weak_fpa
? weak_fpa() : 123);
3391 printf("weak_fpb=%d\n",&weak_fpb
? weak_fpb() : 123);
3392 printf("weak_fpc=%d\n",&weak_fpc
? weak_fpc() : 123);
3394 printf("weak_asm_f1=%d\n", weak_asm_f1
!= NULL
);
3395 printf("weak_asm_f2=%d\n", weak_asm_f2
!= NULL
);
3396 printf("weak_asm_f3=%d\n", weak_asm_f3
!= NULL
);
3397 printf("weak_asm_v1=%d\n",&weak_asm_v1
!= NULL
);
3398 printf("weak_asm_v2=%d\n",&weak_asm_v2
!= NULL
);
3399 printf("weak_asm_v3=%d\n",&weak_asm_v3
!= NULL
);
3400 printf("some_lib_func=%d\n", &some_lib_func
? some_lib_func() : 0);
3403 int __attribute__((weak
)) weak_f2() { return 222; }
3404 int __attribute__((weak
)) weak_f3() { return 333; }
3405 int __attribute__((weak
)) weak_v2
= 222;
3406 int __attribute__((weak
)) weak_v3
= 333;
3409 void const_func(const int a
)
3413 void const_warn_test(void)
3422 int getme (struct condstruct
*s
, int i
)
3424 int i1
= (i
== 0 ? 0 : s
)->i
;
3425 int i2
= (i
== 0 ? s
: 0)->i
;
3426 int i3
= (i
== 0 ? (void*)0 : s
)->i
;
3427 int i4
= (i
== 0 ? s
: (void*)0)->i
;
3428 return i1
+ i2
+ i3
+ i4
;
3437 struct global_data global_data
;
3439 int global_data_getstuff (int *, int);
3441 void global_data_callit (int i
)
3443 *global_data
.b
[i
] = global_data_getstuff (global_data
.b
[i
], 1);
3446 int global_data_getstuff (int *p
, int i
)
3451 void global_data_test (void)
3453 global_data
.a
[0] = 42;
3454 global_data
.b
[0] = &global_data
.a
[0];
3455 global_data_callit (0);
3456 printf ("%d\n", global_data
.a
[0]);
3461 unsigned char fill
: 3;
3462 unsigned char b1
: 1;
3463 unsigned char b2
: 1;
3464 unsigned char fill2
: 3;
3467 int glob1
, glob2
, glob3
;
3469 void compare_comparisons (struct cmpcmpS
*s
)
3471 if (s
->b1
!= (glob1
== glob2
)
3472 || (s
->b2
!= (glob1
== glob3
)))
3473 printf ("comparing comparisons broken\n");
3476 void cmp_comparison_test(void)
3480 glob1
= 42; glob2
= 42;
3483 compare_comparisons (&s
);
3486 int fcompare (double a
, double b
, int code
)
3489 case 0: return a
== b
;
3490 case 1: return a
!= b
;
3491 case 2: return a
< b
;
3492 case 3: return a
>= b
;
3493 case 4: return a
> b
;
3494 case 5: return a
<= b
;
3498 void math_cmp_test(void)
3500 double nan
= 0.0/0.0;
3504 #define bug(a,b,op,iop,part) printf("Test broken: %s %s %s %s %d\n", #a, #b, #op, #iop, part)
3506 /* This asserts that "a op b" is _not_ true, but "a iop b" is true.
3507 And it does this in various ways so that all code generation paths
3508 are checked (generating inverted tests, or non-inverted tests, or
3509 producing a 0/1 value without jumps (that's done in the fcompare
3511 #define FCMP(a,b,op,iop,code) \
3512 if (fcompare (a,b,code)) \
3513 bug (a,b,op,iop,1); \
3515 bug (a,b,op,iop,2); \
3519 bug (a,b,op,iop,3); \
3520 if ((a op b) || comp) \
3521 bug (a,b,op,iop,4); \
3522 if ((a iop b) || comp) \
3527 /* Equality tests. */
3528 FCMP(nan
, nan
, ==, !=, 0);
3529 FCMP(one
, two
, ==, !=, 0);
3530 FCMP(one
, one
, !=, ==, 1);
3531 /* Non-equality is a bit special. */
3532 if (!fcompare (nan
, nan
, 1))
3533 bug (nan
, nan
, !=, ==, 6);
3535 /* Relational tests on numbers. */
3536 FCMP(two
, one
, <, >=, 2);
3537 FCMP(one
, two
, >=, <, 3);
3538 FCMP(one
, two
, >, <=, 4);
3539 FCMP(two
, one
, <=, >, 5);
3541 /* Relational tests on NaNs. Note that the inverse op here is
3542 always !=, there's no operator in C that is equivalent to !(a < b),
3543 when NaNs are involved, same for the other relational ops. */
3544 FCMP(nan
, nan
, <, !=, 2);
3545 FCMP(nan
, nan
, >=, !=, 3);
3546 FCMP(nan
, nan
, >, !=, 4);
3547 FCMP(nan
, nan
, <=, !=, 5);
3550 double get100 () { return 100.0; }
3552 void callsave_test(void)
3554 #if defined __i386__ || defined __x86_64__ || defined __arm__
3555 int i
, s
; double *d
; double t
;
3556 s
= sizeof (double);
3557 printf ("callsavetest: %d\n", s
);
3558 d
= alloca (sizeof(double));
3560 /* x86-64 had a bug were the next call to get100 would evict
3561 the lvalue &d[0] as VT_LLOCAL, and the reload would be done
3562 in int type, not pointer type. When alloca returns a pointer
3563 with the high 32 bit set (which is likely on x86-64) the access
3564 generates a segfault. */
3565 i
= d
[0] > get100 ();
3571 void bfa3(ptrdiff_t str_offset
)
3573 printf("bfa3: %s\n", (char *)__builtin_frame_address(3) + str_offset
);
3575 void bfa2(ptrdiff_t str_offset
)
3577 printf("bfa2: %s\n", (char *)__builtin_frame_address(2) + str_offset
);
3580 void bfa1(ptrdiff_t str_offset
)
3582 printf("bfa1: %s\n", (char *)__builtin_frame_address(1) + str_offset
);
3586 void builtin_frame_address_test(void)
3588 /* builtin_frame_address fails on ARM with gcc which make test3 fail */
3590 char str
[] = "__builtin_frame_address";
3591 char *fp0
= __builtin_frame_address(0);
3593 printf("str: %s\n", str
);
3598 char via_volatile (char i
)
3605 struct __attribute__((__packed__
)) Spacked
{
3610 struct Spacked spacked
;
3611 typedef struct __attribute__((__packed__
)) {
3617 /* This doesn't work for now. Requires adjusting field offsets/sizes
3618 after parsing the struct members. */
3619 typedef struct Spacked3_s
{
3623 } __attribute__((__packed__
)) Spacked3
;
3625 struct gate_struct64
{
3626 unsigned short offset_low
;
3627 unsigned short segment
;
3628 unsigned ist
: 3, zero0
: 5, type
: 5, dpl
: 2, p
: 1;
3629 unsigned short offset_middle
;
3630 unsigned offset_high
;
3632 } __attribute__((packed
));
3633 typedef struct gate_struct64 gate_desc
;
3634 gate_desc a_gate_desc
;
3635 void attrib_test(void)
3637 printf("attr: %d %d %d %d\n", sizeof(struct Spacked
),
3638 sizeof(spacked
), sizeof(Spacked2
), sizeof(spacked2
));
3639 printf("attr: %d %d\n", sizeof(Spacked3
), sizeof(spacked3
));
3640 printf("attr: %d %d\n", sizeof(gate_desc
), sizeof(a_gate_desc
));
3642 extern __attribute__((__unused__
)) char * __attribute__((__unused__
)) *
3643 strange_attrib_placement (void);
3645 void * __attribute__((__unused__
)) get_void_ptr (void *a
)