2 * TCC auto test program
6 /* identify the configured reference compiler in use */
11 /* Unfortunately, gcc version < 3 does not handle that! */
14 /* only gcc 3 handles _Bool correctly */
17 /* __VA_ARGS__ and __func__ support */
21 typedef __SIZE_TYPE__
uintptr_t;
25 || (defined(__arm__) \
26 && (defined(__FreeBSD__) \
27 || defined(__OpenBSD__) \
28 || defined(__NetBSD__) \
29 || defined __ANDROID__))
30 #define LONG_LONG_FORMAT "%lld"
31 #define ULONG_LONG_FORMAT "%llu"
32 #define XLONG_LONG_FORMAT "%llx"
34 #define LONG_LONG_FORMAT "%Ld"
35 #define ULONG_LONG_FORMAT "%Lu"
36 #define XLONG_LONG_FORMAT "%Lx"
39 // MinGW has 80-bit rather than 64-bit long double which isn't compatible with TCC or MSVC
40 #if defined(_WIN32) && defined(__GNUC__)
41 #define LONG_DOUBLE double
42 #define LONG_DOUBLE_LITERAL(x) x
44 #define LONG_DOUBLE long double
45 #define LONG_DOUBLE_LITERAL(x) x ## L
48 /* test various include syntaxes */
50 #define TCCLIB_INC <tcclib.h>
51 #define TCCLIB_INC1 <tcclib
52 #define TCCLIB_INC2 h>
53 #define TCCLIB_INC3 "tcclib.h"
57 #include TCCLIB_INC1.TCCLIB_INC2
59 #include TCCLIB_INC1.h>
69 /* Test two more ways to include a file named like a pp-number */
70 #define INC(name) <tests/name.h>
71 #define funnyname 42test.h
74 /* clang's preprocessor is broken in this regard and adds spaces
75 to the tokens 'incdir' and 'funnyname' when expanding */
76 #define incname <tests/42test.h>
78 #define incname < incdir funnyname >
80 #define __stringify(x) #x
81 #define stringify(x) __stringify(x)
84 #include stringify(funnyname)
86 int puts(const char *s
);
87 void *alloca(size_t size
);
91 void forward_ref(void);
94 /* Line joining happens before tokenization, so the following
95 must be parsed as ellipsis. */
96 void funny_line_continuation (int, ..\
102 #define M1(a, b) (a) + (b)
106 #define glue(a, b) a ## b
107 #define xglue(a, b) glue(a, b)
108 #define HIGHLOW "hello"
109 #define LOW LOW ", world"
111 static int onetwothree
= 123;
112 #define onetwothree4 onetwothree
113 #define onetwothree xglue(onetwothree,4)
115 #define min(a, b) ((a) < (b) ? (a) : (b))
118 #define dprintf(level,...) printf(__VA_ARGS__)
121 /* gcc vararg macros */
122 #define dprintf1(level, fmt, args...) printf(fmt, ## args)
124 #define MACRO_NOARGS()
126 #define TEST_CALL(f, ...) f(__VA_ARGS__)
127 #define TEST_CONST() 123
143 #define __INT64_C(c) c ## LL
144 #define INT64_MIN (-__INT64_C(9223372036854775807)-1)
152 #define spin_lock(lock) do { } while (0)
153 #define wq_spin_lock spin_lock
154 #define TEST2() wq_spin_lock(a)
156 void macro_test(void)
159 printf("aaa=%d\n", AAA
);
161 printf("min=%d\n", min(1, min(2, -1)));
163 printf("s1=%s\n", glue(HIGH
, LOW
));
164 printf("s2=%s\n", xglue(HIGH
, LOW
));
165 printf("s3=%s\n", str("c"));
166 printf("s4=%s\n", str(a1
));
167 printf("B3=%d\n", B3
);
169 printf("onetwothree=%d\n", onetwothree
);
172 printf("A defined\n");
175 printf("B defined\n");
178 printf("A defined\n");
180 printf("A not defined\n");
183 printf("B defined\n");
185 printf("B not defined\n");
189 printf("A defined\n");
191 printf("B1 defined\n");
193 printf("B1 not defined\n");
196 printf("A not defined\n");
198 printf("B2 defined\n");
200 printf("B2 not defined\n");
205 printf("test true1\n");
208 printf("test true2\n");
211 printf("test true3\n");
214 printf("test trueA\n");
217 printf("test trueB\n");
232 printf("%d\n", TEST_CALL(TEST_CONST
));
234 /* not strictly preprocessor, but we test it there */
236 printf("__func__ = %s\n", __func__
);
237 dprintf(1, "vaarg=%d\n", 1);
239 dprintf1(1, "vaarg1\n");
240 dprintf1(1, "vaarg1=%d\n", 2);
241 dprintf1(1, "vaarg1=%d %d\n", 1, 2);
244 printf("func='%s'\n", __FUNCTION__
);
246 /* complicated macros in glibc */
247 printf("INT64_MIN=" LONG_LONG_FORMAT
"\n", INT64_MIN
);
257 /* macro function with argument outside the macro string */
258 #define MF_s MF_hello
259 #define MF_hello(msg) printf("%s\n",msg)
261 #define MF_t printf("tralala\n"); MF_hello
266 /* test macro substitution inside args (should not eat stream) */
267 printf("qq=%d\n", qq(qq
)(2));
269 /* test zero argument case. NOTE: gcc 2.95.x does not accept a
270 null argument without a space. gcc 3.2 fixes that. */
273 printf("qq1=%d\n", qq1( ));
275 /* comment with stray handling *\
277 /* this is a valid *\/ comment */
278 /* this is a valid comment *\*/
282 /* test function macro substitution when the function name is
286 /* And again when the name and parentheses are separated by a
288 TEST2
/* the comment */ ();
290 printf("basefromheader %s\n", get_basefile_from_header());
291 printf("base %s\n", __BASE_FILE__
);
293 /* Some compilers (clang) prepend './' to __FILE__ from included
295 const char *fn
= get_file_from_header();
296 if (fn
[0] == '.' && fn
[1] == '/')
298 printf("filefromheader %s\n", fn
);
300 printf("file %s\n", __FILE__
);
302 /* Check that funnily named include was in fact included */
303 have_included_42test_h
= 1;
304 have_included_42test_h_second
= 1;
305 have_included_42test_h_third
= 1;
307 /* Check that we don't complain about stray \ here */
308 printf("print a backslash: %s\n", stringify(\\));
312 static void print_num(char *fn
, int line
, int num
) {
313 printf("fn %s, line %d, num %d\n", fn
, line
, num
);
316 void recursive_macro_test(void)
319 #define ELF32_ST_TYPE(val) ((val) & 0xf)
320 #define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
321 #define STB_WEAK 2 /* Weak symbol */
322 #define ELFW(type) ELF##32##_##type
323 printf("%d\n", ELFW(ST_INFO
)(STB_WEAK
, ELFW(ST_TYPE
)(123)));
327 #define print_num(x) print_num(__FILE__,__LINE__,x)
329 WRAP(print_num(123));
330 WRAP(WRAP(print_num(123)));
332 static struct recursive_macro
{ int rm_field
; } G
;
333 #define rm_field (G.rm_field)
334 printf("rm_field = %d\n", rm_field
);
335 printf("rm_field = %d\n", WRAP(rm_field
));
336 WRAP((printf("rm_field = %d %d\n", rm_field
, WRAP(rm_field
))));
355 #if !defined(__TINYC__) && (__GNUC__ >= 8)
356 /* Old GCCs don't regard "foo"[1] as constant, even in GNU dialect. */
357 #define CONSTANTINDEXEDSTRLIT
359 char str_ag1
[] = "b";
360 char str_ag2
[] = { "b" };
361 /*char str_bg1[] = ("cccc"); GCC accepts this with pedantic warning, TCC not */
362 #ifdef CONSTANTINDEXEDSTRLIT
363 char str_ag3
[] = { "ab"[1], 0 };
364 char str_x
[2] = { "xy" "z"[2], 0 };
366 char *str_ar
[] = { "one", "two" };
367 struct str_SS
{unsigned char a
[3], b
; };
368 struct str_SS str_sinit15
= { "r" };
369 struct str_SS str_sinit16
[] = { { "q" }, 2 };
371 static void string_test2()
374 char a3
[2] = { "p" };
375 char a4
[2] = { "ab" "c"[2], 0 };
376 char *pa1
= "def" + 1;
377 char *pa2
= { "xyz" + 1 };
379 struct str_SS ss
= { { [0 ... 1] = 'a' }, 0 };
380 #ifndef CONSTANTINDEXEDSTRLIT
381 char str_ag3
[] = { "ab"[1], 0 };
382 char str_x
[2] = { "xy" "z"[2], 0 };
384 puts("string_test2");
391 puts(str_sinit16
[0].a
);
396 printf("%s\n", "bla");
400 puts(i
>= 0 ? "one" : "two");
405 void ps(const char *s
)
417 const char foo1_string
[] = "\
426 printf("\141\1423\143\n");/* dezdez test */
427 printf("\x41\x42\x43\x3a\n");
428 printf("c=%c\n", 'r');
429 printf("wc=%C 0x%lx %C\n", L
'a', L
'\x1234', L
'c');
430 printf("foo1_string='%s'\n", foo1_string
);
432 printf("wstring=%S\n", L
"abc");
433 printf("wstring=%S\n", L
"abc" L
"def" "ghi");
434 printf("'\\377'=%d '\\xff'=%d\n", '\377', '\xff');
435 printf("L'\\377'=%d L'\\xff'=%d\n", L
'\377', L
'\xff');
439 while ((b
= b
+ 1) < 96) {
443 printf("fib=%d\n", fib(33));
445 while (b
!= 0x80000000) {
453 void if1t(int n
, int a
, int b
, int c
)
455 if (a
&& b
) printf("if1t: %d 1 %d %d\n", n
, a
, b
);
456 if (a
&& !b
) printf("if1t: %d 2 %d %d\n", n
, a
, b
);
457 if (!a
&& b
) printf("if1t: %d 3 %d %d\n", n
, a
, b
);
458 if (!a
&& !b
) printf("if1t: %d 4 %d %d\n", n
, a
, b
);
459 if (a
|| b
) printf("if1t: %d 5 %d %d\n", n
, a
, b
);
460 if (a
|| !b
) printf("if1t: %d 6 %d %d\n", n
, a
, b
);
461 if (!a
|| b
) printf("if1t: %d 7 %d %d\n", n
, a
, b
);
462 if (!a
|| !b
) printf("if1t: %d 8 %d %d\n", n
, a
, b
);
463 if (a
&& b
|| c
) printf("if1t: %d 9 %d %d %d\n", n
, a
, b
, c
);
464 if (a
|| b
&& c
) printf("if1t: %d 10 %d %d %d\n", n
, a
, b
, c
);
465 if (a
> b
- 1 && c
) printf("if1t: %d 11 %d %d %d\n", n
, a
, b
, c
);
466 if (a
> b
- 1 || c
) printf("if1t: %d 12 %d %d %d\n", n
, a
, b
, c
);
467 if (a
> 0 && 1) printf("if1t: %d 13 %d %d %d\n", n
, a
, b
, c
);
468 if (a
> 0 || 0) printf("if1t: %d 14 %d %d %d\n", n
, a
, b
, c
);
473 if (0 && 1 || printf("if2t:ok\n") || 1)
474 printf("if2t:ok2\n");
475 printf("if2t:ok3\n");
480 volatile long long i
= 1;
481 if (i
<= 18446744073709551615ULL)
484 printf ("if3t:wrong 1\n");
504 for(i
= 0; i
< 10;i
++)
514 /* c99 for loop init test */
515 for (size_t count
= 1; count
< 3; count
++)
516 printf("count=%d\n", count
);
517 printf("count = %d\n", count
);
519 /* break/continue tests */
531 /* break/continue tests */
543 for(i
= 0;i
< 10;i
++) {
551 typedef int typedef_and_label
;
556 static void *label_table
[3] = { &&label1
, &&label2
, &&label3
};
559 /* This needs to parse as typedef, not as label. */
560 typedef_and_label
: 32;
565 /* This is a normal decl. */
567 /* This needs to parse as label, not as start of decl. */
578 /* we also test computed gotos (GCC extension) */
580 goto *label_table
[i
];
606 enum {E6
= 42, E7
, E8
} e
:8;
610 /* This is either 0 on L32 machines, or a large number
611 on L64 machines. We should be able to store this. */
612 EL_large
= ((unsigned long)0xf000 << 31) << 1,
615 enum { BIASU
= -1U<<31 };
616 enum { BIASS
= -1 << 31 };
618 static int getint(int i
)
623 return (int)(-1U << 31);
629 /* The following should give no warning */
631 struct S_enum s
= {E7
};
632 printf("%d %d %d %d %d %d %d\n", s
.e
,
633 E0
, E1
, E2
, E3
, E4
, E5
);
635 printf("b1=%d\n", b1
);
636 printf("enum large: %ld\n", EL_large
);
638 if (getint(0) == BIASU
)
639 printf("enum unsigned: ok\n");
641 printf("enum unsigned: wrong\n");
642 if (getint(0) == BIASS
)
643 printf("enum unsigned: ok\n");
645 printf("enum unsigned: wrong\n");
661 printf("a=%d\n", *a
);
663 printf("mytype2=%d\n", mytype2
);
673 void forward_ref(void)
675 printf("forward ok\n");
678 typedef struct struct1
{
698 struct struct1 st1
, st2
;
712 printf("g1=%d\n", g
);
719 printf("g2=%d\n", g
);
723 printf("g3=%d\n", g
);
727 printf("g4=%d\n", g
);
730 printf("g5=%d\n", g
);
739 for (int st2_i
= 1; st2_i
< 10; st2_i
++) {
742 printf("exloc: %d\n", st2_i
);
744 printf("exloc: %d\n", *st2_p
);
747 /* C has tentative definition, and they may be repeated. */
748 extern int st_global1
;
750 extern int st_global1
;
752 extern int st_global2
;
754 extern int st_global2
;
761 printf("sizeof(a) = %d\n", sizeof(a
));
762 printf("sizeof(\"a\") = %d\n", sizeof("a"));
764 printf("sizeof(__func__) = %d\n", sizeof(__func__
));
766 printf("sizeof tab %d\n", sizeof(tab
));
767 printf("sizeof tab2 %d\n", sizeof tab2
);
771 printf("%d %d %d\n", tab
[0], tab
[1], tab
[2]);
774 tab2
[i
][j
] = 10 * i
+ j
;
776 printf(" %3d", ((int *)tab2
)[i
]);
779 printf("sizeof(size_t)=%d\n", sizeof(size_t));
780 printf("sizeof(ptrdiff_t)=%d\n", sizeof(ptrdiff_t));
787 printf("%d\n", a
+= 1);
788 printf("%d\n", a
-= 2);
789 printf("%d\n", a
*= 31232132);
790 printf("%d\n", a
/= 4);
791 printf("%d\n", a
%= 20);
792 printf("%d\n", a
&= 6);
793 printf("%d\n", a
^= 7);
794 printf("%d\n", a
|= 8);
795 printf("%d\n", a
>>= 3);
796 printf("%d\n", a
<<= 4);
800 printf("%d\n", a
+ 1);
801 printf("%d\n", a
- 2);
802 printf("%d\n", a
* 312);
803 printf("%d\n", a
/ 4);
804 printf("%d\n", b
/ 4);
805 printf("%d\n", (unsigned)b
/ 4);
806 printf("%d\n", a
% 20);
807 printf("%d\n", b
% 20);
808 printf("%d\n", (unsigned)b
% 20);
809 printf("%d\n", a
& 6);
810 printf("%d\n", a
^ 7);
811 printf("%d\n", a
| 8);
812 printf("%d\n", a
>> 3);
813 printf("%d\n", b
>> 3);
814 printf("%d\n", (unsigned)b
>> 3);
815 printf("%d\n", a
<< 4);
820 printf("%d\n", 12 + 1);
821 printf("%d\n", 12 - 2);
822 printf("%d\n", 12 * 312);
823 printf("%d\n", 12 / 4);
824 printf("%d\n", 12 % 20);
825 printf("%d\n", 12 & 6);
826 printf("%d\n", 12 ^ 7);
827 printf("%d\n", 12 | 8);
828 printf("%d\n", 12 >> 2);
829 printf("%d\n", 12 << 4);
833 printf("%d %d %d %d\n",
842 return (c
>= 'a' & c
<= 'z') | (c
>= 'A' & c
<= 'Z') | c
== '_';
845 /**********************/
847 int vstack
[10], *vstack_ptr
;
849 void vpush(int vt
, int vc
)
855 void vpop(int *ft
, int *fc
)
867 vstack_ptr
[-2] &= ~0xffffff80;
869 printf("res= %d %d\n", a
, b
);
872 int const_len_ar
[sizeof(1/0)]; /* div-by-zero, but in unevaluated context */
874 void constant_expr_test()
878 printf("%d\n", a
* 16);
879 printf("%d\n", a
* 1);
880 printf("%d\n", a
+ 0);
881 printf("%d\n", sizeof(const_len_ar
));
893 printf("diff=%d\n", q
- p
);
895 printf("inc=%d\n", p
- tab4
);
897 printf("dec=%d\n", p
- tab4
);
899 printf("inc=%d\n", p
- tab4
);
901 printf("dec=%d\n", p
- tab4
);
902 printf("add=%d\n", p
+ 3 - tab4
);
903 printf("add=%d\n", 3 + p
- tab4
);
905 /* check if 64bit support is ok */
908 printf("%p %p %ld\n", q
, p
, p
-q
);
909 printf("%d %d %d %d %d %d\n",
910 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
913 printf("%p %p %ld\n", q
, p
, p
-q
);
914 printf("%d %d %d %d %d %d\n",
915 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
916 p
= (int *)((char *)p
+ 0xf0000000);
917 printf("%p %p %ld\n", q
, p
, p
-q
);
918 printf("%d %d %d %d %d %d\n",
919 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
921 printf("%p %p %ld\n", q
, p
, p
-q
);
922 printf("%d %d %d %d %d %d\n",
923 p
== q
, p
!= q
, p
< q
, p
<= q
, p
>= q
, p
> q
);
928 struct size12 s
[2], *sp
= s
;
933 printf("%d\n", sp
[j
].i
);
937 p
= (int*)0x100000000UL
+ i
;
939 printf("largeptr: %p %d\n", p
, i
);
943 printf ("%d\n", (int)((p
- q
) / 3));
951 printf("%d\n", a
== a
);
952 printf("%d\n", a
!= a
);
954 printf("%d\n", a
< b
);
955 printf("%d\n", a
<= b
);
956 printf("%d\n", a
<= a
);
957 printf("%d\n", b
>= a
);
958 printf("%d\n", a
>= a
);
959 printf("%d\n", b
> a
);
961 printf("%d\n", (unsigned)a
< b
);
962 printf("%d\n", (unsigned)a
<= b
);
963 printf("%d\n", (unsigned)a
<= a
);
964 printf("%d\n", (unsigned)b
>= a
);
965 printf("%d\n", (unsigned)a
>= a
);
966 printf("%d\n", (unsigned)b
> a
);
989 struct __attribute__((aligned(16))) aligntest5
996 } __attribute__((aligned(16)));
1001 struct aligntest5 altest5
[2];
1002 struct aligntest6 altest6
[2];
1004 /* altest7 is correctly aligned to 16 bytes also with TCC,
1005 but __alignof__ returns the wrong result (4) because we
1006 can't store the alignment yet when specified on symbols
1007 directly (it's stored in the type so we'd need to make
1008 a copy of it). -- FIXED */
1009 struct aligntest7 altest7
[2] __attribute__((aligned(16)));
1014 } __attribute__((aligned(4096)));
1017 unsigned long flags
;
1025 unsigned long index
;
1029 unsigned long counters
;
1043 unsigned long compound_head
;
1044 unsigned int compound_dtor
;
1045 unsigned int compound_order
;
1048 } __attribute__((aligned(2 * sizeof(long))));
1050 typedef unsigned long long __attribute__((aligned(4))) unaligned_u64
;
1053 unsigned int buf_nr
;
1054 unaligned_u64 start_lba
;
1057 struct aligntest10
{
1058 unsigned int buf_nr
;
1059 unsigned long long start_lba
;
1068 printf("sizes: %d %d %d %d\n",
1069 sizeof(struct struct1
),
1070 sizeof(struct struct2
),
1071 sizeof(union union1
),
1072 sizeof(union union2
));
1073 printf("offsets: %d\n", (int)((char*)&st1
.u
.v1
- (char*)&st1
));
1077 printf("st1: %d %d %d\n",
1078 st1
.f1
, st1
.f2
, st1
.f3
);
1081 printf("union1: %d\n", st1
.u
.v1
);
1084 printf("union2: %d\n", u
.w1
);
1089 printf("st2: %d %d %d\n",
1090 s
->f1
, s
->f2
, s
->f3
);
1091 printf("str_addr=%x\n", (int)(uintptr_t)st1
.str
- (int)(uintptr_t)&st1
.f1
);
1093 /* align / size tests */
1094 printf("aligntest1 sizeof=%d alignof=%d\n",
1095 sizeof(struct aligntest1
), __alignof__(struct aligntest1
));
1096 printf("aligntest2 sizeof=%d alignof=%d\n",
1097 sizeof(struct aligntest2
), __alignof__(struct aligntest2
));
1098 printf("aligntest3 sizeof=%d alignof=%d\n",
1099 sizeof(struct aligntest3
), __alignof__(struct aligntest3
));
1100 printf("aligntest4 sizeof=%d alignof=%d\n",
1101 sizeof(struct aligntest4
), __alignof__(struct aligntest4
));
1102 printf("aligntest5 sizeof=%d alignof=%d\n",
1103 sizeof(struct aligntest5
), __alignof__(struct aligntest5
));
1104 printf("aligntest6 sizeof=%d alignof=%d\n",
1105 sizeof(struct aligntest6
), __alignof__(struct aligntest6
));
1106 printf("aligntest7 sizeof=%d alignof=%d\n",
1107 sizeof(struct aligntest7
), __alignof__(struct aligntest7
));
1108 printf("aligntest8 sizeof=%d alignof=%d\n",
1109 sizeof(struct aligntest8
), __alignof__(struct aligntest8
));
1110 printf("aligntest9 sizeof=%d alignof=%d\n",
1111 sizeof(struct aligntest9
), __alignof__(struct aligntest9
));
1112 printf("aligntest10 sizeof=%d alignof=%d\n",
1113 sizeof(struct aligntest10
), __alignof__(struct aligntest10
));
1114 printf("altest5 sizeof=%d alignof=%d\n",
1115 sizeof(altest5
), __alignof__(altest5
));
1116 printf("altest6 sizeof=%d alignof=%d\n",
1117 sizeof(altest6
), __alignof__(altest6
));
1118 printf("altest7 sizeof=%d alignof=%d\n",
1119 sizeof(altest7
), __alignof__(altest7
));
1121 /* empty structures (GCC extension) */
1122 printf("sizeof(struct empty) = %d\n", sizeof(struct empty
));
1123 printf("alignof(struct empty) = %d\n", __alignof__(struct empty
));
1125 printf("Large: sizeof=%d\n", sizeof(ls
));
1126 memset(&ls
, 0, sizeof(ls
));
1127 ls
.compound_head
= 42;
1128 printf("Large: offsetof(compound_head)=%d\n", (int)((char*)&ls
.compound_head
- (char*)&ls
));
1131 /* simulate char/short return value with undefined upper bits */
1132 static int __csf(int x
) { return x
; }
1133 static void *_csf
= __csf
;
1134 #define csf(t,n) ((t(*)(int))_csf)(n)
1136 /* XXX: depend on endianness */
1137 void char_short_test()
1145 printf("s8=%d %d\n",
1146 *(signed char *)&var1
, *(signed char *)&var2
);
1147 printf("u8=%d %d\n",
1148 *(unsigned char *)&var1
, *(unsigned char *)&var2
);
1149 printf("s16=%d %d\n",
1150 *(short *)&var1
, *(short *)&var2
);
1151 printf("u16=%d %d\n",
1152 *(unsigned short *)&var1
, *(unsigned short *)&var2
);
1153 printf("s32=%d %d\n",
1154 *(int *)&var1
, *(int *)&var2
);
1155 printf("u32=%d %d\n",
1156 *(unsigned int *)&var1
, *(unsigned int *)&var2
);
1157 *(signed char *)&var1
= 0x08;
1158 printf("var1=%x\n", var1
);
1159 *(short *)&var1
= 0x0809;
1160 printf("var1=%x\n", var1
);
1161 *(int *)&var1
= 0x08090a0b;
1162 printf("var1=%x\n", var1
);
1165 var4
= 0x11223344aa998877ULL
;
1166 var1
= var3
= var1
+ 1;
1167 var4
= var3
= var4
+ 1;
1168 printf("promote char/short assign %d "LONG_LONG_FORMAT
"\n", var1
, var4
);
1170 var4
= 0x11223344aa998877ULL
;
1171 printf("promote char/short assign VA %d %d\n", var3
= var1
+ 1, var3
= var4
+ 1);
1172 printf("promote char/short cast VA %d %d\n", (signed char)(var1
+ 1), (signed char)(var4
+ 1));
1173 #if !defined(__arm__)
1174 /* We can't really express GCC behaviour of return type promotion in
1175 the presence of undefined behaviour (like __csf is). */
1176 var1
= csf(unsigned char,0x89898989);
1177 var4
= csf(signed char,0xabababab);
1178 printf("promote char/short funcret %d "LONG_LONG_FORMAT
"\n", var1
, var4
);
1179 printf("promote char/short fumcret VA %d %d %d %d\n",
1180 csf(unsigned short,0xcdcdcdcd),
1181 csf(short,0xefefefef),
1182 csf(_Bool
,0x33221100),
1183 csf(_Bool
,0x33221101));
1186 var1
= (signed char)(unsigned char)(var3
+ 1);
1187 var4
= (signed char)(unsigned char)(var3
+ 1);
1188 printf("promote multicast (char)(unsigned char) %d "LONG_LONG_FORMAT
"\n", var1
, var4
);
1189 var4
= 0x11223344aa998877ULL
;
1190 var4
= (unsigned)(int)(var4
+ 1);
1191 printf("promote multicast (unsigned)(int) "LONG_LONG_FORMAT
"\n", var4
);
1192 var4
= 0x11223344bbaa9988ULL
;
1193 var4
= (unsigned)(signed char)(var4
+ 1);
1194 printf("promote multicast (unsigned)(char) "LONG_LONG_FORMAT
"\n", var4
);
1197 /******************/
1199 typedef struct Sym
{
1207 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
1208 #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
1210 static int toupper1(int a
)
1215 static unsigned int calc_vm_flags(unsigned int prot
)
1217 unsigned int prot_bits
;
1218 /* This used to segfault in some revisions: */
1219 prot_bits
= ((0x1==0x00000001)?(prot
&0x1):(prot
&0x1)?0x00000001:0);
1223 enum cast_enum
{ FIRST
, LAST
};
1225 static void tst_cast(enum cast_enum ce
)
1232 int *s
, a
, b
, t
, f
, i
;
1236 printf("!s=%d\n", !s
);
1240 printf("a=%d\n", a
);
1242 printf("a=%d %d %d\n", 0 || 0, 0 || 1, 1 || 1);
1243 printf("a=%d %d %d\n", 0 && 0, 0 && 1, 1 && 1);
1244 printf("a=%d %d\n", 1 ? 1 : 0, 0 ? 1 : 0);
1259 printf("b=%d\n", a
+ (0 ? 1 : a
/ 2));
1261 /* test register spilling */
1264 a
= (a
+ b
) * ((a
< b
) ?
1265 ((b
- a
) * (a
- b
)): a
+ b
);
1266 printf("a=%d\n", a
);
1268 /* test complex || or && expressions */
1272 printf("exp=%d\n", f
== (32 <= a
&& a
<= 3));
1273 printf("r=%d\n", (t
|| f
) + (t
&& f
));
1275 /* check that types of casted &&/|| are preserved (here the unsignedness) */
1277 printf("type of bool: %d\n", (int) ( (~ ((unsigned int) (t
&& 1))) / 2) );
1278 tst_cast(t
>= 0 ? FIRST
: LAST
);
1280 printf("type of cond: %d\n", (~(t
? 0U : (unsigned int)0)) / 2 );
1284 int aspect_native
= 65536;
1285 double bfu_aspect
= 1.0;
1287 for(aspect_on
= 0; aspect_on
< 2; aspect_on
++) {
1288 aspect
=aspect_on
?(aspect_native
*bfu_aspect
+0.5):65535UL;
1289 printf("aspect=%d\n", aspect
);
1293 /* test ? : GCC extension */
1295 static int v1
= 34 ? : -1; /* constant case */
1296 static int v2
= 0 ? : -1; /* constant case */
1299 printf("%d %d\n", v1
, v2
);
1300 printf("%d %d\n", a
- 30 ? : a
* 2, a
+ 1 ? : a
* 2);
1303 /* again complex expression */
1304 for(i
=0;i
<256;i
++) {
1305 if (toupper1 (i
) != TOUPPER (i
))
1306 printf("error %d\n", i
);
1308 printf ("bits = 0x%x\n", calc_vm_flags (0x1));
1311 extern int undefined_function(void);
1312 extern int defined_function(void);
1315 int undefined_function(void) {}
1318 static inline void refer_to_undefined(void)
1320 undefined_function();
1323 void optimize_out_test(void)
1325 int i
= 0 ? undefined_function() : defined_function();
1326 printf ("oo:%d\n", i
);
1327 int j
= 1 ? defined_function() : undefined_function();
1328 printf ("oo:%d\n", j
);
1330 printf("oo:%d\n", undefined_function());
1332 printf("oo:%d\n", defined_function());
1334 printf("oo:%d\n", defined_function());
1336 printf("oo:%d\n", undefined_function());
1338 printf("oow:%d\n", defined_function());
1340 printf("oow:%d\n", undefined_function());
1343 /* Following is a switch without {} block intentionally. */
1346 printf ("oos:%d\n", defined_function());
1347 /* The following break shouldn't lead to disabled code after
1351 printf ("ool1:%d\n", defined_function());
1352 /* Same for the other types of loops. */
1356 printf ("ool2:%d\n", defined_function());
1359 printf ("ool3:%d\n", defined_function());
1360 /* Normal {} blocks without controlling statements
1361 shouldn't reactivate code emission */
1366 printf ("ool4:%d\n", undefined_function());
1371 break; /* this break shouldn't disable code outside the if. */
1372 printf("ool5:%d\n", defined_function());
1382 printf("ool6:%d\n", defined_function());
1389 printf("ool7:%d\n", undefined_function());
1392 /* Test that constants in logical && are optimized: */
1393 i
= 0 && undefined_function();
1394 i
= defined_function() && 0 && undefined_function();
1395 if (0 && undefined_function())
1396 undefined_function();
1397 if (defined_function() && 0)
1398 undefined_function();
1400 undefined_function();
1401 if (defined_function() && 0 && undefined_function())
1402 undefined_function();
1403 /* The same for || : */
1404 i
= 1 || undefined_function();
1405 i
= defined_function() || 1 || undefined_function();
1406 if (1 || undefined_function())
1409 undefined_function();
1410 if (defined_function() || 1)
1413 undefined_function();
1417 undefined_function();
1418 if (defined_function() || 1 || undefined_function())
1421 undefined_function();
1423 if (defined_function() && 0)
1424 refer_to_undefined();
1431 undefined_function();
1435 switch (defined_function()) {
1436 case 0: undefined_function(); break;
1437 default: undefined_function(); break;
1441 /* Leave the "if(1)return; printf()" in this order and last in the function */
1444 printf ("oor:%d\n", undefined_function());
1447 int defined_function(void)
1453 /* GCC accepts that */
1454 static int tab_reinit
[];
1455 static int tab_reinit
[10];
1457 static int tentative_ar
[];
1458 static int tentative_ar
[] = {1,2,3};
1460 //int cinit1; /* a global variable can be defined several times without error ! */
1464 int *cinit2
= (int []){3, 2, 1};
1466 void compound_literal_test(void)
1471 p
= (int []){1, 2, 3};
1473 printf(" %d", p
[i
]);
1477 printf("%d", cinit2
[i
]);
1481 printf("q1=%s\n", q
);
1483 q
= (char *){ "tralala2" };
1484 printf("q2=%s\n", q
);
1487 printf("q3=%s\n", q3
);
1489 q
= (char []){ "tralala3" };
1490 printf("q4=%s\n", q
);
1493 p
= (int []){1, 2, cinit1
+ 3};
1495 printf(" %d", p
[i
]);
1499 p
= (int []){1, 2, 4 + i
};
1500 printf("%d %d %d\n",
1525 printf("func1=%d\n", kr_func1(3, 4));
1526 printf("func2=%d\n", kr_func2(3, 4));
1530 /* We try to handle this syntax. Make at least sure it doesn't segfault. */
1531 char invalid_function_def()[] {return 0;}
1534 # define kr_test() printf("func1=7\nfunc2=7\n")
1540 tab
= (char*)malloc(20);
1557 /* structure assignment tests */
1563 void struct_assign_test1(struct structa1 s1
, int t
, float f
)
1565 printf("%d %d %d %f\n", s1
.f1
, s1
.f2
, t
, f
);
1568 struct structa1
struct_assign_test2(struct structa1 s1
, int t
)
1575 void struct_assign_test(void)
1578 struct structa1 lsta1
, lsta2
;
1580 } s
= {{1,2}, {3,4}}, *ps
;
1585 struct_assign_test1(ps
->lsta2
, 3, 4.5);
1586 printf("before call: %d %d\n", s
.lsta2
.f1
, s
.lsta2
.f2
);
1587 ps
->lsta2
= struct_assign_test2(ps
->lsta2
, ps
->i
);
1588 printf("after call: %d %d\n", ps
->lsta2
.f1
, ps
->lsta2
.f2
);
1593 /* XXX: we should allow this even without braces */
1594 { struct_assign_test
}
1596 printf("%d\n", struct_assign_test
== t
[0].elem
);
1598 s
.lsta1
= s
.lsta2
= struct_assign_test2(s
.lsta1
, 1);
1599 printf("%d %d\n", s
.lsta1
.f1
, s
.lsta1
.f2
);
1602 /* casts to short/char */
1604 void cast1(char a
, short b
, unsigned char c
, unsigned short d
)
1606 printf("%d %d %d %d\n", a
, b
, c
, d
);
1620 unsigned long ul
= 0x80000000UL
;
1621 p
-= 0x700000000042;
1626 printf("%d %d %d %d\n",
1629 (unsigned char)(a
+ 1),
1630 (unsigned short)(a
+ 1));
1631 printf("%d %d %d %d\n",
1634 (unsigned char)0xfffff,
1635 (unsigned short)0xfffff);
1637 a
= (bcast
= 128) + 1;
1639 a
= (scast
= 65536) + 1;
1642 printf("sizeof(c) = %d, sizeof((int)c) = %d\n", sizeof(c
), sizeof((int)c
));
1644 /* test cast from unsigned to signed short to int */
1647 printf("((unsigned)(short)0x%08x) = 0x%08x\n", b
, d
);
1650 printf("((unsigned)(char)0x%08x) = 0x%08x\n", b
, d
);
1652 /* test implicit int casting for array accesses */
1656 printf("%d %d\n", tab
[0], tab
[1]);
1658 /* test implicit casting on some operators */
1659 printf("sizeof(+(char)'a') = %d\n", sizeof(+(char)'a'));
1660 printf("sizeof(-(char)'a') = %d\n", sizeof(-(char)'a'));
1661 printf("sizeof(~(char)'a') = %d\n", sizeof(-(char)'a'));
1663 #if CC_NAME != CC_clang /* clang doesn't support non-portable conversions */
1664 /* from pointer to integer types */
1665 printf("%d %d %ld %ld %lld %lld\n",
1666 (int)p
, (unsigned int)p
,
1667 (long)p
, (unsigned long)p
,
1668 (long long)p
, (unsigned long long)p
);
1671 /* from integers to pointers */
1672 printf("%p %p %p %p\n",
1673 (void *)a
, (void *)b
, (void *)c
, (void *)d
);
1675 /* int to int with sign set */
1676 printf("0x%lx\n", (unsigned long)(int)ul
);
1679 /* initializers tests */
1680 struct structinit1
{
1689 int sinit3
[3] = { 1, 2, {{3}}, };
1690 int sinit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1691 int sinit5
[3][2] = { 1, 2, 3, 4, 5, 6 };
1692 int sinit6
[] = { 1, 2, 3 };
1693 int sinit7
[] = { [2] = 3, [0] = 1, 2 };
1694 char sinit8
[] = "hello" "trala";
1696 struct structinit1 sinit9
= { 1, 2, 3 };
1697 struct structinit1 sinit10
= { .f2
= 2, 3, .f1
= 1 };
1698 struct structinit1 sinit11
= { .f2
= 2, 3, .f1
= 1,
1706 char *sinit12
= "hello world";
1712 char sinit14
[10] = { "abc" };
1713 int sinit15
[3] = { sizeof(sinit15
), 1, 2 };
1715 struct { int a
[3], b
; } sinit16
[] = { { 1 }, 2 };
1731 struct complexinit0
{
1736 struct complexinit
{
1738 const struct complexinit0
*b
;
1741 const static struct complexinit cix
[] = {
1744 .b
= (const struct complexinit0
[]) {
1752 struct complexinit2
{
1757 struct complexinit2 cix20
;
1759 struct complexinit2 cix21
= {
1761 .b
= { 3001, 3002, 3003 }
1764 struct complexinit2 cix22
= {
1766 .b
= { 4001, 4002, 4003, 4004, 4005, 4006 }
1769 typedef int arrtype1
[];
1770 arrtype1 sinit19
= {1};
1771 arrtype1 sinit20
= {2,3};
1772 typedef int arrtype2
[3];
1773 arrtype2 sinit21
= {4};
1774 arrtype2 sinit22
= {5,6,7};
1776 /* Address comparisons of non-weak symbols with zero can be const-folded */
1777 int sinit23
[2] = { "astring" ? sizeof("astring") : -1,
1778 &sinit23
? 42 : -1 };
1780 int sinit24
= 2 || 1 / 0; /* exception in constant but unevaluated context */
1783 struct bf_SS
{unsigned int bit
:1,bits31
:31; };
1784 struct bf_SS bf_init
= { .bit
= 1 };
1785 struct bfn_SS
{int a
,b
; struct bf_SS c
; int d
,e
; };
1786 struct bfn_SS bfn_init
= { .c
.bit
= 1 };
1787 struct bfa_SS
{int a
,b
; struct bf_SS c
[3]; int d
,e
; };
1788 struct bfa_SS bfa_init
= { .c
[1].bit
= 1 };
1789 struct bf_SS bfaa_init
[3] = { [1].bit
= 1 };
1790 struct bf_SS bfaa_vinit
[] = { [2].bit
= 1 };
1791 struct b2_SS
{long long int field
: 52; long long int pad
: 12; };
1792 struct b2_SS bf_init2
= {0xFFF000FFF000FLL
, 0x123};
1794 extern int external_inited
= 42;
1796 void init_test(void)
1800 int linit4
[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1801 int linit6
[] = { 1, 2, 3 };
1803 char linit8
[] = "hello" "trala";
1804 int linit12
[10] = { 1, 2 };
1805 int linit13
[10] = { 1, 2, [7] = 3, [3] = 4, };
1806 char linit14
[10] = "abc";
1807 int linit15
[10] = { linit1
, linit1
+ 1, [6] = linit1
+ 2, };
1808 struct linit16
{ int a1
, a2
, a3
, a4
; } linit16
= { 1, .a3
= 2 };
1809 int linit17
= sizeof(linit17
);
1811 /* Addresses on non-weak symbols are non-zero, but not the access itself */
1812 int linit18
[2] = {&zero
? 1 : -1, zero
? -1 : 1 };
1813 struct bf_SS bf_finit
= { .bit
= 1 };
1814 struct bfn_SS bfn_finit
= { .c
.bit
= 1 };
1815 struct bfa_SS bfa_finit
= { .c
[1].bit
= 1 };
1816 struct bf_SS bfaa_finit
[3] = { [1].bit
= 1 };
1817 struct bf_SS bfaa_fvinit
[] = { [2].bit
= 1 };
1818 struct b2_SS bf_finit2
= {0xFFF000FFF000FLL
, 0x123};
1820 printf("sinit1=%d\n", sinit1
);
1821 printf("sinit2=%d\n", sinit2
);
1822 printf("sinit3=%d %d %d %d\n",
1828 printf("sinit6=%d\n", sizeof(sinit6
));
1829 printf("sinit7=%d %d %d %d\n",
1835 printf("sinit8=%s\n", sinit8
);
1836 printf("sinit9=%d %d %d\n",
1841 printf("sinit10=%d %d %d\n",
1846 printf("sinit11=%d %d %d %d %d %d\n",
1857 printf("[%d][%d] = %d %d %d\n",
1858 i
, j
, sinit4
[i
][j
], sinit5
[i
][j
], linit4
[i
][j
]);
1859 printf("linit1=%d\n", linit1
);
1860 printf("linit2=%d\n", linit2
);
1861 printf("linit6=%d\n", sizeof(linit6
));
1862 printf("linit8=%d %s\n", sizeof(linit8
), linit8
);
1864 printf("sinit12=%s\n", sinit12
);
1865 printf("sinit13=%d %s %s %s\n",
1870 printf("sinit14=%s\n", sinit14
);
1872 for(i
=0;i
<10;i
++) printf(" %d", linit12
[i
]);
1874 for(i
=0;i
<10;i
++) printf(" %d", linit13
[i
]);
1876 for(i
=0;i
<10;i
++) printf(" %d", linit14
[i
]);
1878 for(i
=0;i
<10;i
++) printf(" %d", linit15
[i
]);
1880 printf("%d %d %d %d\n",
1885 /* test that initialisation is done after variable declare */
1886 printf("linit17=%d\n", linit17
);
1887 printf("sinit15=%d\n", sinit15
[0]);
1888 printf("sinit16=%d %d\n", sinit16
[0].a
[0], sinit16
[1].a
[0]);
1889 printf("sinit17=%s %d %s %d\n",
1890 sinit17
[0].s
, sinit17
[0].len
,
1891 sinit17
[1].s
, sinit17
[1].len
);
1893 printf("%x ", sinit18
[i
]);
1895 /* complex init check */
1896 printf("cix: %d %d %d %d %d %d %d\n",
1898 cix
[0].b
[0].a
, cix
[0].b
[0].b
,
1899 cix
[0].b
[1].a
, cix
[0].b
[1].b
,
1900 cix
[0].b
[2].a
, cix
[0].b
[2].b
);
1901 printf("cix2: %d %d\n", cix21
.b
[2], cix22
.b
[5]);
1902 printf("sizeof cix20 %d, cix21 %d, sizeof cix22 %d\n", sizeof cix20
, sizeof cix21
, sizeof cix22
);
1904 printf("arrtype1: %d %d %d\n", sinit19
[0], sinit20
[0], sinit20
[1]);
1905 printf("arrtype2: %d %d\n", sizeof(sinit19
), sizeof(sinit20
));
1906 printf("arrtype3: %d %d %d\n", sinit21
[0], sinit21
[1], sinit21
[2]);
1907 printf("arrtype4: %d %d %d\n", sinit22
[0], sinit22
[1], sinit22
[2]);
1908 printf("arrtype5: %d %d\n", sizeof(sinit21
), sizeof(sinit22
));
1909 printf("arrtype6: %d\n", sizeof(arrtype2
));
1911 printf("sinit23= %d %d\n", sinit23
[0], sinit23
[1]);
1912 printf("sinit24=%d\n", sinit24
);
1913 printf("linit18= %d %d\n", linit18
[0], linit18
[1]);
1914 printf ("bf1: %u %u\n", bf_init
.bit
, bf_init
.bits31
);
1915 printf ("bf2: %u %u\n", bf_finit
.bit
, bf_finit
.bits31
);
1916 printf ("bf3: %u %u\n", bfn_init
.c
.bit
, bfn_init
.c
.bits31
);
1917 printf ("bf4: %u %u\n", bfn_finit
.c
.bit
, bfn_finit
.c
.bits31
);
1918 for (i
= 0; i
< 3; i
++)
1919 printf ("bf5[%d]: %u %u\n", i
, bfa_init
.c
[i
].bit
, bfa_init
.c
[i
].bits31
);
1920 for (i
= 0; i
< 3; i
++)
1921 printf ("bf6[%d]: %u %u\n", i
, bfa_finit
.c
[i
].bit
, bfa_finit
.c
[i
].bits31
);
1922 for (i
= 0; i
< 3; i
++)
1923 printf ("bf7[%d]: %u %u\n", i
, bfaa_init
[i
].bit
, bfaa_init
[i
].bits31
);
1924 for (i
= 0; i
< 3; i
++)
1925 printf ("bf8[%d]: %u %u\n", i
, bfaa_finit
[i
].bit
, bfaa_finit
[i
].bits31
);
1926 for (i
= 0; i
< 3; i
++)
1927 printf ("bf9[%d]: %u %u\n", i
, bfaa_vinit
[i
].bit
, bfaa_vinit
[i
].bits31
);
1928 for (i
= 0; i
< 3; i
++)
1929 printf ("bf10[%d]: %u %u\n", i
, bfaa_fvinit
[i
].bit
, bfaa_fvinit
[i
].bits31
);
1932 void switch_uc(unsigned char uc
)
1945 printf("ucsw: broken!\n");
1949 void switch_sc(signed char sc
)
1962 printf("scsw: broken!\n");
1969 unsigned long long ull
;
1994 for (i
= 1; i
<= 5; i
++) {
1995 ull
= (unsigned long long)i
<< 61;
1998 printf("ullsw:1\n");
2001 printf("ullsw:2\n");
2004 printf("ullsw:3\n");
2007 printf("ullsw:4\n");
2010 printf("ullsw:5\n");
2013 printf("ullsw: broken!\n");
2017 for (i
= 1; i
<= 5; i
++) {
2018 ll
= (long long)i
<< 61;
2036 printf("llsw: broken!\n");
2040 for (i
= -5; i
<= 5; i
++) {
2041 switch_uc((unsigned char)i
);
2044 for (i
= -5; i
<= 5; i
++) {
2045 switch_sc ((signed char)i
);
2049 /* ISOC99 _Bool type */
2050 void c99_bool_test(void)
2056 printf("sizeof(_Bool) = %d\n", sizeof(_Bool
));
2058 printf("cast: %d %d %d\n", (_Bool
)10, (_Bool
)0, (_Bool
)a
);
2060 printf("b = %d\n", b
);
2062 printf("b = %d\n", b
);
2064 printf("sizeof(x ? _Bool : _Bool) = %d (should be sizeof int)\n",
2065 sizeof ((volatile int)a
? b
: b2
));
2069 void bitfield_test(void)
2081 unsigned int f5
: 7;
2083 printf("sizeof(st1) = %d\n", sizeof(st1
));
2092 printf("%d %d %d %d %d\n",
2093 st1
.f1
, st1
.f2
, st1
.f3
, st1
.f4
, st1
.f5
);
2096 printf("%d %d\n", sa
, ca
);
2100 printf("st1.f1 == -1\n");
2102 printf("st1.f1 != -1\n");
2104 printf("st1.f2 == -1\n");
2106 printf("st1.f2 != -1\n");
2112 unsigned long long f3
: 38;
2114 st2
.f1
= 0x123456789ULL
;
2116 st2
.f2
= (long long)a
<< 25;
2119 printf("%lld %lld %lld\n", st2
.f1
, st2
.f2
, st2
.f3
);
2122 Disabled
for now until further clarification re GCC compatibility
2131 printf("sizeof(st3) = %d\n", sizeof(st3
));
2139 printf("st4.y == %d\n", st4
.y
);
2143 int x
: 12, y
: 4, : 0, : 4, z
: 3;
2145 } st5
= { 1, 2, 3, 4, -3, 6 };
2146 printf("st5 = %d %d %d %d %d %d\n", st5
.a
, st5
.b
, st5
.x
, st5
.y
, st5
.z
, st5
.c
);
2149 unsigned char y
: 2;
2152 printf("st6.y == %d\n", st6
.y
);
2156 #define FLOAT_FMT "%f\n"
2158 /* x86's float isn't compatible with GCC */
2159 #define FLOAT_FMT "%.5f\n"
2162 /* declare strto* functions as they are C99 */
2163 double strtod(const char *nptr
, char **endptr
);
2166 float strtof(const char *nptr
, char **endptr
) {return (float)strtod(nptr
, endptr
);}
2167 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
) {return (LONG_DOUBLE
)strtod(nptr
, endptr
);}
2169 float strtof(const char *nptr
, char **endptr
);
2170 LONG_DOUBLE
strtold(const char *nptr
, char **endptr
);
2173 #if CC_NAME == CC_clang
2174 /* In clang 0.0/0.0 is nan and not -nan.
2175 Also some older clang version do v=-v
2177 static char enable_nan_test
= 0;
2179 static char enable_nan_test
= 1;
2182 #define FTEST(prefix, typename, type, fmt)\
2183 void prefix ## cmp(type a, type b)\
2185 printf("%d %d %d %d %d %d\n",\
2192 printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\
2200 printf(fmt "\n", ++a);\
2201 printf(fmt "\n", a++);\
2202 printf(fmt "\n", a);\
2204 printf("%d %d\n", !a, !b);\
2206 void prefix ## fcast(type a)\
2214 unsigned long long llua;\
2219 printf("ftof: %f %f %Lf\n", fa, da, la);\
2221 llia = (long long)a;\
2222 a = (a >= 0) ? a : -a;\
2223 ua = (unsigned int)a;\
2224 llua = (unsigned long long)a;\
2225 printf("ftoi: %d %u %lld %llu\n", ia, ua, llia, llua);\
2228 llia = -0x123456789012345LL;\
2229 llua = 0xf123456789012345LLU;\
2231 printf("itof: " fmt "\n", b);\
2233 printf("utof: " fmt "\n", b);\
2235 printf("lltof: " fmt "\n", b);\
2237 printf("ulltof: " fmt "\n", b);\
2240 float prefix ## retf(type a) { return a; }\
2241 double prefix ## retd(type a) { return a; }\
2242 LONG_DOUBLE prefix ## retld(type a) { return a; }\
2244 void prefix ## call(void)\
2246 printf("float: " FLOAT_FMT, prefix ## retf(42.123456789));\
2247 printf("double: %f\n", prefix ## retd(42.123456789));\
2248 printf("long double: %Lf\n", prefix ## retld(42.123456789));\
2249 printf("strto%s: %f\n", #prefix, (double)strto ## prefix("1.2", NULL));\
2252 void prefix ## signed_zeros(void) \
2254 type x = 0.0, y = -0.0, n, p;\
2256 printf ("Test 1.0 / x != 1.0 / y returns %d (should be 1).\n",\
2257 1.0 / x != 1.0 / y);\
2259 printf ("x != y; this is wrong!\n");\
2263 printf ("Test 1.0 / x != 1.0 / -x returns %d (should be 1).\n",\
2264 1.0 / x != 1.0 / n);\
2266 printf ("x != -x; this is wrong!\n");\
2270 printf ("Test 1.0 / x != 1.0 / +y returns %d (should be 1).\n",\
2271 1.0 / x != 1.0 / p);\
2273 printf ("x != +y; this is wrong!\n");\
2276 printf ("Test 1.0 / x != 1.0 / -y returns %d (should be 0).\n",\
2277 1.0 / x != 1.0 / p);\
2279 printf ("x != -y; this is wrong!\n");\
2281 void prefix ## nan(void)\
2283 type nan = 0.0/0.0;\
2285 printf("nantest: " fmt " " fmt "\n", nan, nnan);\
2287 void prefix ## test(void)\
2289 printf("testing '%s'\n", #typename);\
2290 prefix ## cmp(1, 2.5);\
2291 prefix ## cmp(2, 1.5);\
2292 prefix ## cmp(1, 1);\
2293 prefix ## fcast(234.6);\
2294 prefix ## fcast(-2334.6);\
2296 prefix ## signed_zeros();\
2297 if (enable_nan_test) prefix ## nan();\
2300 FTEST(f
, float, float, "%f")
2301 FTEST(d
, double, double, "%f")
2302 FTEST(ld
, long double, LONG_DOUBLE
, "%Lf")
2304 double ftab1
[3] = { 1.2, 3.4, -5.6 };
2307 void float_test(void)
2309 #if !defined(__arm__) || defined(__ARM_PCS_VFP) || defined __ANDROID__
2310 volatile float fa
, fb
;
2311 volatile double da
, db
;
2314 static double nan2
= 0.0/0.0;
2315 static double inf1
= 1.0/0.0;
2316 static double inf2
= 1e5000
;
2317 volatile LONG_DOUBLE la
;
2319 printf("sizeof(float) = %d\n", sizeof(float));
2320 printf("sizeof(double) = %d\n", sizeof(double));
2321 printf("sizeof(long double) = %d\n", sizeof(LONG_DOUBLE
));
2325 printf("%f %f %f\n", ftab1
[0], ftab1
[1], ftab1
[2]);
2326 printf("%f %f %f\n", 2.12, .5, 2.3e10
);
2327 // printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
2329 printf("da=%f\n", da
);
2331 printf("fa=%f\n", fa
);
2334 printf("da = %f\n", da
);
2337 printf("db = %f\n", db
);
2338 printf("nan != nan = %d, inf1 = %f, inf2 = %f\n", nan2
!= nan2
, inf1
, inf2
);
2339 da
= 0x0.88p
-1022; /* a subnormal */
2341 printf ("da subnormal = %a\n", da
);
2342 printf ("da subnormal = %.40g\n", da
);
2343 printf ("la subnormal = %La\n", la
);
2344 printf ("la subnormal = %.40Lg\n", la
);
2347 printf ("da/2 subnormal = %a\n", da
);
2348 printf ("da/2 subnormal = %.40g\n", da
);
2349 printf ("la/2 subnormal = %La\n", la
);
2350 printf ("la/2 subnormal = %.40Lg\n", la
);
2351 fa
= 0x0.88p
-126f
; /* a subnormal */
2353 printf ("fa subnormal = %a\n", fa
);
2354 printf ("fa subnormal = %.40g\n", fa
);
2355 printf ("la subnormal = %La\n", la
);
2356 printf ("la subnormal = %.40Lg\n", la
);
2359 printf ("fa/2 subnormal = %a\n", fa
);
2360 printf ("fa/2 subnormal = %.40g\n", fa
);
2361 printf ("la/2 subnormal = %La\n", la
);
2362 printf ("la/2 subnormal = %.40Lg\n", la
);
2371 return fib(n
-1) + fib(n
-2);
2374 #if __GNUC__ == 3 || __GNUC__ == 4
2375 # define aligned_function 0
2377 void __attribute__((aligned(16))) aligned_function(int i
) {}
2396 /* more complicated pointer computation */
2399 printf("sizeof1 = %d\n", sizeof(funcptr_test
));
2400 printf("sizeof2 = %d\n", sizeof funcptr_test
);
2401 printf("sizeof3 = %d\n", sizeof(&funcptr_test
));
2402 printf("sizeof4 = %d\n", sizeof &funcptr_test
);
2410 /* Check that we can align functions */
2411 func
= aligned_function
;
2412 printf("aligned_function (should be zero): %d\n", ((int)(uintptr_t)func
) & 15);
2415 void lloptest(long long a
, long long b
)
2417 unsigned long long ua
, ub
;
2422 printf("arith: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2428 printf("arith1: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2434 printf("bin: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2440 printf("test: %d %d %d %d %d %d\n",
2448 printf("utest: %d %d %d %d %d %d\n",
2459 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2460 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
++, b
++);
2461 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", --a
, --b
);
2462 printf("arith2: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2464 printf("not: %d %d %d %d\n", !a
, !ua
, !b
, !ub
);
2467 void llshift(long long a
, int b
)
2469 printf("shift: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2470 (unsigned long long)a
>> b
,
2473 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2474 (unsigned long long)a
>> 3,
2477 printf("shiftc: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n",
2478 (unsigned long long)a
>> 35,
2488 long long la
, lb
, lc
;
2489 unsigned long long ula
, ulb
, ulc
;
2492 la
= (la
<< 20) | 0x12345;
2494 printf("la=" LONG_LONG_FORMAT
" ula=" ULONG_LONG_FORMAT
"\n", la
, ula
);
2499 printf("lltof: %f %f %Lf\n", fa
, da
, lda
);
2504 printf("ftoll: " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", la
, lb
, lc
);
2509 printf("ulltof: %f %f %Lf\n", fa
, da
, lda
);
2514 printf("ftoull: " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
" " ULONG_LONG_FORMAT
"\n", ula
, ulb
, ulc
);
2517 long long llfunc1(int a
)
2527 long long int value(struct S
*v
)
2529 return ((long long int)v
->item
);
2532 long long llfunc2(long long x
, long long y
, int z
)
2537 void check_opl_save_regs(char *a
, long long b
, int c
)
2542 void longlong_test(void)
2547 printf("sizeof(long long) = %d\n", sizeof(long long));
2552 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"\n", a
, b
);
2553 printf(LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %Lx\n",
2557 0x1234567812345679);
2559 printf(LONG_LONG_FORMAT
"\n", a
);
2562 lloptest(0xff, 0x1234);
2563 b
= 0x72345678 << 10;
2567 b
= 0x72345678LL
<< 10;
2575 printf(XLONG_LONG_FORMAT
"\n", c
);
2578 /* long long reg spill test */
2583 printf("%lld\n", value(&a
));
2585 lloptest(0x80000000, 0);
2588 long long *p
, v
, **pp
;
2592 printf("another long long spill test : %lld\n", *p
);
2595 v
= llfunc2(**pp
, **pp
, ia
);
2596 printf("a long long function (arm-)reg-args test : %lld\n", v
);
2600 printf("%d %d %d %d\n", a
> b
, a
< b
, a
>= b
, a
<= b
);
2602 printf(LONG_LONG_FORMAT
"\n", 0x123456789LLU
);
2604 /* long long pointer deref in argument passing test */
2609 /* shortening followed by widening */
2610 unsigned long long u
= 0x8000000000000001ULL
;
2611 u
= (unsigned)(u
+ 1);
2612 printf("long long u=" ULONG_LONG_FORMAT
"\n", u
);
2613 u
= 0x11223344aa998877ULL
;
2614 u
= (unsigned)(int)(u
+ 1);
2615 printf("long long u=" ULONG_LONG_FORMAT
"\n", u
);
2617 /* was a problem with missing save_regs in gen_opl on 32-bit platforms */
2619 check_opl_save_regs(&cc
, -1, 0);
2620 printf("check_opl_save_regs: %d\n", cc
);
2623 void manyarg_test(void)
2625 LONG_DOUBLE ld
= 1234567891234LL;
2626 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2627 1, 2, 3, 4, 5, 6, 7, 8,
2628 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2629 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2630 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %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, 8.9, 9.0,
2633 1234567891234LL, 987654321986LL,
2635 printf("%Lf %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2636 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f\n",
2637 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2638 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2639 1234567891234LL, 987654321986LL,
2641 printf("%d %d %d %d %d %d %d %d %Lf\n",
2642 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2643 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2644 LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
"%f %f %Lf\n",
2645 1, 2, 3, 4, 5, 6, 7, 8,
2646 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2647 1234567891234LL, 987654321986LL,
2649 printf("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2650 "%Lf " LONG_LONG_FORMAT
" " LONG_LONG_FORMAT
" %f %f %Lf\n",
2651 1, 2, 3, 4, 5, 6, 7, 8,
2652 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2653 ld
, 1234567891234LL, 987654321986LL,
2658 va_arg_with_struct_ptr(va_list ap
) {
2660 * This was a BUG identified with FFTW-3.3.8 on arm64.
2661 * The test case only checks it compiles on all supported
2662 * architectures. This function is not currently called.
2664 struct X
{ int _x
; };
2665 struct X
*x
= va_arg(ap
, struct X
*);
2669 void vprintf1(const char *fmt
, ...)
2693 i
= va_arg(ap
, int);
2697 d
= va_arg(ap
, double);
2701 ll
= va_arg(ap
, long long);
2702 printf(LONG_LONG_FORMAT
, ll
);
2705 ld
= va_arg(ap
, LONG_DOUBLE
);
2723 #if CC_NAME == CC_clang /* clang7 doesn't support zero sized structs */
2736 void *foo
, *bar
, *baz
;
2739 struct mytest
stdarg_for_struct(struct myspace bob
, ...)
2741 struct myspace george
, bill
;
2742 struct myspace2 alex1
;
2743 struct myspace3 alex2
;
2744 struct myspace4 alex3
;
2749 alex1
= va_arg(ap
, struct myspace2
);
2750 alex2
= va_arg(ap
, struct myspace3
);
2751 alex3
= va_arg(ap
, struct myspace4
);
2752 bill
= va_arg(ap
, struct myspace
);
2753 george
= va_arg(ap
, struct myspace
);
2754 validate
= va_arg(ap
, int);
2755 printf("stdarg_for_struct: %d %d %d %d %d %d %d\n",
2756 alex2
.a
[0], alex3
.a
[0], alex3
.a
[1],
2757 bob
.profile
, bill
.profile
, george
.profile
, validate
);
2759 return (struct mytest
) {};
2762 void stdarg_for_libc(const char *fmt
, ...)
2765 va_start(args
, fmt
);
2770 void stdarg_syntax(int n
, ...)
2778 i
= va_arg(ap
, int);
2779 printf("stdarg_void_expr: %d\n", i
);
2786 point pts
[]={{1.0,2.0},{3.0,4.0},{5.0,6.0},{7.0,8.0},{9.0,10.0},{11.0,12.0}};
2788 static void stdarg_double_struct(int nargs
, int posd
,...)
2795 printf ("stdarg_double_struct: %d\n", posd
);
2796 va_start(args
,posd
);
2797 for(i
= 0; i
< nargs
; i
++) {
2799 d
= va_arg (args
, double);
2800 printf ("d %d = %g\n", i
, d
);
2803 pi
= va_arg (args
, point
);
2804 printf ("pts[%d] = %g %g\n", i
, pi
.x
, pi
.y
);
2810 void stdarg_test(void)
2812 LONG_DOUBLE ld
= 1234567891234LL;
2814 struct myspace2 bob2
;
2815 struct myspace3 bob3
;
2816 struct myspace4 bob4
;
2818 vprintf1("%d %d %d\n", 1, 2, 3);
2819 vprintf1("%f %d %f\n", 1.0, 2, 3.0);
2820 vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0);
2821 vprintf1("%F %F %F\n", LONG_DOUBLE_LITERAL(1.2), LONG_DOUBLE_LITERAL(2.3), LONG_DOUBLE_LITERAL(3.4));
2822 vprintf1("%d %f %l %F %d %f %l %F\n",
2823 1, 1.2, 3LL, LONG_DOUBLE_LITERAL(4.5), 6, 7.8, 9LL, LONG_DOUBLE_LITERAL(0.1));
2824 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f\n",
2825 1, 2, 3, 4, 5, 6, 7, 8,
2826 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8);
2827 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f\n",
2828 1, 2, 3, 4, 5, 6, 7, 8,
2829 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0);
2830 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2832 1, 2, 3, 4, 5, 6, 7, 8,
2833 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2834 1234567891234LL, 987654321986LL,
2836 vprintf1("%F %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2838 ld
, 1, 2, 3, 4, 5, 6, 7, 8,
2839 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2840 1234567891234LL, 987654321986LL,
2842 vprintf1("%d %d %d %d %d %d %d %d %F\n",
2843 1, 2, 3, 4, 5, 6, 7, 8, ld
);
2844 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2846 1, 2, 3, 4, 5, 6, 7, 8,
2847 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2848 1234567891234LL, 987654321986LL,
2850 vprintf1("%d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f "
2851 "%F %l %l %f %f %F\n",
2852 1, 2, 3, 4, 5, 6, 7, 8,
2853 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0,
2854 ld
, 1234567891234LL, 987654321986LL,
2861 stdarg_for_struct(bob
, bob2
, bob3
, bob4
, bob
, bob
, bob
.profile
);
2862 stdarg_for_libc("stdarg_for_libc: %s %.2f %d\n", "string", 1.23, 456);
2863 stdarg_syntax(1, 17);
2864 stdarg_double_struct(6,-1,pts
[0],pts
[1],pts
[2],pts
[3],pts
[4],pts
[5]);
2865 stdarg_double_struct(7,1,pts
[0],-1.0,pts
[1],pts
[2],pts
[3],pts
[4],pts
[5]);
2866 stdarg_double_struct(7,2,pts
[0],pts
[1],-1.0,pts
[2],pts
[3],pts
[4],pts
[5]);
2867 stdarg_double_struct(7,3,pts
[0],pts
[1],pts
[2],-1.0,pts
[3],pts
[4],pts
[5]);
2868 stdarg_double_struct(7,4,pts
[0],pts
[1],pts
[2],pts
[3],-1.0,pts
[4],pts
[5]);
2869 stdarg_double_struct(7,5,pts
[0],pts
[1],pts
[2],pts
[3],pts
[4],-1.0,pts
[5]);
2872 int reltab
[3] = { 1, 2, 3 };
2874 int *rel1
= &reltab
[1];
2875 int *rel2
= &reltab
[2];
2877 void getmyaddress(void)
2879 printf("in getmyaddress\n");
2883 long __pa_symbol(void)
2885 /* This 64bit constant was handled incorrectly, it was used as addend
2886 (which can hold 64bit just fine) in connection with a symbol,
2887 and TCC generates wrong code for that (displacements are 32bit only).
2888 This effectively is "+ 0x80000000", and if addresses of globals
2889 are below 2GB the result should be a number without high 32 bits set. */
2890 return ((long)(((unsigned long)(&rel1
))) - (0xffffffff80000000UL
));
2894 uintptr_t theaddress
= (uintptr_t)getmyaddress
;
2895 void relocation_test(void)
2897 void (*fptr
)(void) = (void (*)(void))theaddress
;
2898 printf("*rel1=%d\n", *rel1
);
2899 printf("*rel2=%d\n", *rel2
);
2902 // compare 'addend' displacement versus conventional arithmetics
2903 printf("pa_symbol: %d\n", (long)&rel1
== __pa_symbol() - 0x80000000);
2907 void old_style_f(a
,b
,c
)
2911 printf("a=%d b=%d b=%f\n", a
, b
, c
);
2914 void decl_func1(int cmpfn())
2916 printf("cmpfn=%lx\n", (long)cmpfn
);
2919 void decl_func2(cmpfn
)
2922 printf("cmpfn=%lx\n", (long)cmpfn
);
2925 void old_style_function_test(void)
2927 #if CC_NAME == CC_clang
2928 /* recent clang versions (at least 15.0) raise an error:
2929 incompatible pointer to integer conversion passing 'void *'
2930 For the purpose of this test, pass 1 instead.
2932 old_style_f(1, 2, 3.0);
2934 old_style_f((void *)1, 2, 3.0);
2942 #if defined __i386__ || defined __x86_64__ || defined __arm__
2943 char *p
= alloca(16);
2944 strcpy(p
,"123456789012345");
2945 printf("alloca: p is %s\n", p
);
2946 char *demo
= "This is only a test.\n";
2947 /* Test alloca embedded in a larger expression */
2948 printf("alloca: %s\n", strcpy(alloca(strlen(demo
)+1),demo
) );
2952 void *bounds_checking_is_enabled()
2954 char ca
[10], *cp
= ca
-1;
2955 return (ca
!= cp
+ 1) ? cp
: NULL
;
2958 typedef int constant_negative_array_size_as_compile_time_assertion_idiom
[(1 ? 2 : 0) - 1];
2960 void c99_vla_test_1(int size1
, int size2
)
2962 int size
= size1
* size2
;
2963 int tab1
[size
][2], tab2
[10][2];
2964 void *tab1_ptr
, *tab2_ptr
, *bad_ptr
;
2966 /* "size" should have been 'captured' at tab1 declaration,
2967 so modifying it should have no effect on VLA behaviour. */
2970 printf("Test C99 VLA 1 (sizeof): ");
2971 printf("%s\n", (sizeof tab1
== size1
* size2
* 2 * sizeof(int)) ? "PASSED" : "FAILED");
2974 printf("Test C99 VLA 2 (ptrs subtract): ");
2975 printf("%s\n", (tab2
- tab1
== (tab2_ptr
- tab1_ptr
) / (sizeof(int) * 2)) ? "PASSED" : "FAILED");
2976 printf("Test C99 VLA 3 (ptr add): ");
2977 printf("%s\n", &tab1
[5][1] == (tab1_ptr
+ (5 * 2 + 1) * sizeof(int)) ? "PASSED" : "FAILED");
2978 printf("Test C99 VLA 4 (ptr access): ");
2979 tab1
[size1
][1] = 42;
2980 printf("%s\n", (*((int *) (tab1_ptr
+ (size1
* 2 + 1) * sizeof(int))) == 42) ? "PASSED" : "FAILED");
2982 printf("Test C99 VLA 5 (bounds checking (might be disabled)): ");
2983 if (bad_ptr
= bounds_checking_is_enabled()) {
2984 int *t1
= &tab1
[size1
* size2
- 1][3];
2985 int *t2
= &tab2
[9][3];
2986 printf("%s ", bad_ptr
== t1
? "PASSED" : "FAILED");
2987 printf("%s ", bad_ptr
== t2
? "PASSED" : "FAILED");
2989 char*c1
= 1 + sizeof(tab1
) + (char*)tab1
;
2990 char*c2
= 1 + sizeof(tab2
) + (char*)tab2
;
2991 printf("%s ", bad_ptr
== c1
? "PASSED" : "FAILED");
2992 printf("%s ", bad_ptr
== c2
? "PASSED" : "FAILED");
2996 printf("%s ", bad_ptr
== i1
? "PASSED" : "FAILED");
2997 printf("%s ", bad_ptr
== i2
? "PASSED" : "FAILED");
2999 int *x1
= tab1
[size1
* size2
+ 1];
3000 int *x2
= tab2
[10 + 1];
3001 printf("%s ", bad_ptr
== x1
? "PASSED" : "FAILED");
3002 printf("%s ", bad_ptr
== x2
? "PASSED" : "FAILED");
3004 printf("PASSED PASSED PASSED PASSED PASSED PASSED PASSED PASSED ");
3009 void c99_vla_test_2(int d
, int h
, int w
)
3012 int (*arr
)[h
][w
] = malloc(sizeof(int) * d
*h
*w
);
3014 static int (*starr
)[h
][w
];
3016 printf("Test C99 VLA 6 (pointer)\n");
3018 for (z
=0; z
<d
; z
++) {
3019 for (y
=0; y
<h
; y
++) {
3020 for (x
=0; x
<w
; x
++) {
3025 for (z
=0; z
<d
; z
++) {
3026 for (y
=0; y
<h
; y
++) {
3027 for (x
=0; x
<w
; x
++) {
3028 printf(" %2d", arr
[z
][y
][x
]);
3035 printf(" sizes : %d %d %d\n"
3037 " tests : %d %d %d\n",
3038 sizeof (*arr
), sizeof (*arr
)[0], sizeof (*arr
)[0][0],
3039 arr
+ 2 - arr
, *arr
+ 3 - *arr
,
3040 0 == sizeof (*arr
+ 1) - sizeof arr
,
3041 0 == sizeof sizeof *arr
- sizeof arr
,
3042 starr
[0][2][3] == arr
[1][2][3]
3047 void c99_vla_test_3a (int arr
[2][3][4])
3049 printf ("%d\n", arr
[1][2][3]);
3052 void c99_vla_test_3b(int s
, int arr
[s
][3][4])
3054 printf ("%d\n", arr
[1][2][3]);
3057 void c99_vla_test_3c(int s
, int arr
[2][s
][4])
3059 printf ("%d\n", arr
[1][2][3]);
3062 void c99_vla_test_3d(int s
, int arr
[2][3][s
])
3064 printf ("%d\n", arr
[1][2][3]);
3067 void c99_vla_test_3e(int s
, int arr
[][3][--s
])
3069 printf ("%d %d %d\n", sizeof arr
, s
, arr
[1][2][3]);
3072 void c99_vla_test_3(void)
3076 memset (a
, 0, sizeof(a
));
3079 c99_vla_test_3b(2, a
);
3080 c99_vla_test_3c(3, a
);
3081 c99_vla_test_3d(4, a
);
3082 c99_vla_test_3e(5, a
);
3085 void c99_vla_test(void)
3087 c99_vla_test_1(5, 2);
3088 c99_vla_test_2(3, 4, 5);
3093 void sizeof_test(void)
3098 printf("sizeof(int) = %d\n", sizeof(int));
3099 printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
3100 printf("sizeof(long) = %d\n", sizeof(long));
3101 printf("sizeof(unsigned long) = %d\n", sizeof(unsigned long));
3102 printf("sizeof(short) = %d\n", sizeof(short));
3103 printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
3104 printf("sizeof(char) = %d\n", sizeof(char));
3105 printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
3106 printf("sizeof(func) = %d\n", sizeof sizeof_test());
3108 printf("sizeof(a++) = %d\n", sizeof a
++);
3109 printf("a=%d\n", a
);
3111 printf("sizeof(**ptr) = %d\n", sizeof (**ptr
));
3113 /* The type of sizeof should be as large as a pointer, actually
3114 it should be size_t. */
3115 printf("sizeof(sizeof(int) = %d\n", sizeof(sizeof(int)));
3118 /* Effectively <<32, but defined also on 32bit machines. */
3122 /* This checks that sizeof really can be used to manipulate
3123 uintptr_t objects, without truncation. */
3124 t2
= t
& -sizeof(uintptr_t);
3125 printf ("%lu %lu\n", t
, t2
);
3127 /* some alignof tests */
3128 printf("__alignof__(int) = %d\n", __alignof__(int));
3129 printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int));
3130 printf("__alignof__(short) = %d\n", __alignof__(short));
3131 printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short));
3132 printf("__alignof__(char) = %d\n", __alignof__(char));
3133 printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char));
3134 printf("__alignof__(func) = %d\n", __alignof__
sizeof_test());
3136 /* sizes of VLAs need to be evaluated even inside sizeof: */
3138 printf("sizeof(char[1+2*a]) = %d\n", sizeof(char[1+2*a
]));
3139 /* And checking if sizeof compound literal works. Parenthesized: */
3140 printf("sizeof( (struct {int i; int j;}){4,5} ) = %d\n",
3141 sizeof( (struct {int i
; int j
;}){4,5} ));
3142 /* And as direct sizeof argument (as unary expression): */
3143 printf("sizeof (struct {short i; short j;}){4,5} = %d\n",
3144 sizeof (struct {short i
; short j
;}){4,5} );
3146 /* sizeof(x && y) should be sizeof(int), even if constant
3147 evaluating is possible. */
3148 printf("sizeof(t && 0) = %d\n", sizeof(t
&& 0));
3149 printf("sizeof(1 && 1) = %d\n", sizeof(1 && 1));
3150 printf("sizeof(t || 1) = %d\n", sizeof(t
|| 1));
3151 printf("sizeof(0 || 0) = %d\n", sizeof(0 || 0));
3154 printf("sizeof(0, arr) = %d\n", sizeof(0, arr
));
3155 printf("sizeof(0, fn) = %d\n", sizeof(0, fn
));
3158 void typeof_test(void)
3167 printf("a=%f b=%f c=%f\n", a
, b
, c
);
3173 struct hlist_node
*first
, *last
;
3176 void consume_ulong (unsigned long i
)
3181 void statement_expr_test(void)
3185 /* Basic stmt expr test */
3195 printf("a=%d\n", a
);
3197 /* Test that symbols aren't freed prematurely.
3198 With SYM_DEBUG valgrind will show a read from a freed
3199 symbol, and tcc will show an (invalid) warning on the initialization
3200 of 'ptr' below, if symbols are popped after the stmt expr. */
3201 void *v
= (void*)39;
3203 (struct hlist_node
*)v
;
3206 ptr
= (struct hlist_node
*)v
;
3208 /* This part used to segfault when symbols were popped prematurely.
3209 The symbols for the static local would be overwritten with
3210 helper symbols from the pre-processor expansions in between. */
3211 #define some_attr __attribute__((aligned(1)))
3212 #define tps(str) ({ \
3213 static const char *t some_attr = str; \
3216 printf ("stmtexpr: %s %s\n",
3217 tps("somerandomlongstring"),
3218 tps("anotherlongstring"));
3220 /* Test that the three decls of 't' don't interact. */
3222 int b
= ({ int t
= 41; t
; });
3223 int c
= ({ int t
= 42; t
; });
3225 /* Test that aggregate return values work. */
3228 typedef struct hlist_head T
;
3230 T t
= { (void*)43, (void*)44 };
3234 printf ("stmtexpr: %d %d %d\n", t
, b
, c
);
3235 printf ("stmtexpr: %ld %ld\n", (long)h
.first
, (long)h
.last
);
3237 /* Test that we can give out addresses of local labels. */
3238 consume_ulong(({ __label__ __here
; __here
: (unsigned long)&&__here
; }));
3240 /* Test interaction between local and global label stacks and the
3241 need to defer popping symbol from them when within statement
3242 expressions. Note how the labels are both named LBL. */
3247 LBL
: if (i
++ == 0) goto LBL
;
3249 /* jump to a classical label out of an expr-stmt that had previously
3250 overshadowed that classical label */
3254 printf("stmtexpr: %d should be 2\n", i
);
3257 void local_label_test(void)
3263 __label__ l1
, l2
, l3
, l4
;
3277 printf("a=%d\n", a
);
3287 /* inline assembler test */
3288 #if defined(__i386__) || defined(__x86_64__)
3290 typedef __SIZE_TYPE__ word
;
3292 /* from linux kernel */
3293 static char * strncat1(char * dest
,const char * src
,size_t count
)
3295 word d0
, d1
, d2
, d3
;
3296 __asm__
__volatile__(
3305 "testb %%al,%%al\n\t"
3309 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
3310 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
3315 static char * strncat2(char * dest
,const char * src
,size_t count
)
3317 word d0
, d1
, d2
, d3
;
3318 __asm__
__volatile__(
3319 "repne scasb\n\t" /* one-line repne prefix + string op */
3326 "testb %%al,%%al\n\t"
3330 : "=&S" (d0
), "=&D" (d1
), "=&a" (d2
), "=&c" (d3
)
3331 : "0" (src
),"1" (dest
),"2" (0),"3" (0xffffffff), "g" (count
)
3336 static inline void * memcpy1(void * to
, const void * from
, size_t n
)
3339 __asm__
__volatile__(
3344 "1:\ttestb $1,%b4\n\t"
3348 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
3349 :"0" (n
/4), "q" (n
),"1" ((word
) to
),"2" ((word
) from
)
3354 static inline void * memcpy2(void * to
, const void * from
, size_t n
)
3357 __asm__
__volatile__(
3358 "rep movsl\n\t" /* one-line rep prefix + string op */
3362 "1:\ttestb $1,%b4\n\t"
3366 : "=&c" (d0
), "=&D" (d1
), "=&S" (d2
)
3367 :"0" (n
/4), "q" (n
),"1" ((word
) to
),"2" ((word
) from
)
3372 static __inline__
void sigaddset1(unsigned int *set
, int _sig
)
3374 __asm__("btsl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc");
3377 static __inline__
void sigdelset1(unsigned int *set
, int _sig
)
3379 asm("btrl %1,%0" : "=m"(*set
) : "Ir"(_sig
- 1) : "cc", "flags");
3383 /* clang's inline asm is uncapable of 'xchgb %b0,%h0' */
3384 static __inline__ __const__
unsigned int swab32(unsigned int x
)
3386 return ((x
>> 24) & 0xff) |
3387 ((x
>> 8) & 0xff00) |
3388 ((x
<< 8) & 0xff0000) |
3389 ((x
<< 24) & 0xff000000);
3392 static __inline__ __const__
unsigned int swab32(unsigned int x
)
3394 __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */
3395 "rorl $16,%0\n\t" /* swap words */
3396 "xchgb %b0,%h0" /* swap higher bytes */
3403 static __inline__
unsigned long long mul64(unsigned int a
, unsigned int b
)
3405 unsigned long long res
;
3407 /* Using the A constraint is wrong (it means rdx:rax, which is too large)
3408 but still test the 32bit->64bit mull. */
3409 unsigned int resh
, resl
;
3410 __asm__("mull %2" : "=a" (resl
), "=d" (resh
) : "a" (a
), "r" (b
));
3411 res
= ((unsigned long long)resh
<< 32) | resl
;
3413 __asm__("mull %2" : "=A" (res
) : "a" (a
), "r" (b
));
3418 static __inline__
unsigned long long inc64(unsigned long long a
)
3420 unsigned long long res
;
3422 /* Using the A constraint is wrong, and increments are tested
3426 __asm__("addl $1, %%eax ; adcl $0, %%edx" : "=A" (res
) : "A" (a
));
3439 word
mconstraint_test(struct struct1231
*r
)
3444 __asm__
volatile ("lea %2,%0; movl 4(%0),%k0; addl %2,%k0; movl $51,%2; movl $52,4%2; movl $63,%1"
3445 : "=&r" (ret
), "=m" (a
)
3446 : "m" (*(struct struct123
*)r
->addr
));
3451 int fls64(unsigned long long x
)
3461 void other_constraints_test(void)
3465 #if CC_NAME != CC_clang
3466 __asm__
volatile ("mov %P1,%0" : "=r" (ret
) : "p" (&var
));
3467 printf ("oc1: %d\n", ret
== (word
)&var
);
3472 /* Test global asm blocks playing with aliases. */
3473 void base_func(void)
3475 printf ("asmc: base\n");
3479 extern void override_func1 (void);
3480 extern void override_func2 (void);
3482 asm(".weak override_func1\n.set override_func1, base_func");
3483 asm(".set override_func1, base_func");
3484 asm(".set override_func2, base_func");
3486 void override_func2 (void)
3488 printf ("asmc: override2\n");
3491 /* This checks a construct used by the linux kernel to encode
3492 references to strings by PC relative references. */
3493 extern int bug_table
[] __attribute__((section("__bug_table")));
3494 char * get_asm_string (void)
3496 /* On i386 when -fPIC is enabled this would cause a compile error with GCC,
3497 the problem being the "i" constraint used with a symbolic operand
3498 resolving to a local label. That check is overly zealous as the code
3499 within the asm makes sure to use it only in PIC-possible contexts,
3500 but all GCC versions behave like so. We arrange for PIC to be disabled
3501 for compiling tcctest.c in the Makefile.
3503 Additionally the usage of 'c' in "%c0" in the template is actually wrong,
3504 as that would expect an operand that is a condition code. The operand
3505 as is (a local label) is accepted by GCC in non-PIC mode, and on x86-64.
3506 What the linux kernel really wanted is 'p' to disable the addition of '$'
3507 to the printed operand (as in "$.LC0" where the template only wants the
3508 bare operand ".LC0"). But the code below is what the linux kernel
3509 happens to use and as such is the one we want to test. */
3511 extern int some_symbol
;
3512 asm volatile (".globl some_symbol\n"
3515 "some_symbol: .long 0\n"
3516 ".pushsection __bug_table, \"a\"\n"
3517 ".globl bug_table\n"
3519 /* The first entry (1b-2b) is unused in this test,
3520 but we include it to check if cross-section
3521 PC-relative references work. */
3522 "2:\t.long 1b - 2b, %c0 - 2b\n"
3523 ".popsection\n" : : "i" ("A string"));
3524 char * str
= ((char*)bug_table
) + bug_table
[1];
3527 return (char *) "A string";
3531 /* This checks another constructs with local labels. */
3532 extern unsigned char alld_stuff
[];
3539 ".pushsection .data.ignore\n"
3540 ".long 661b - .\n" /* This reference to 661 generates an external sym
3541 which shouldn't somehow overwrite the offset that's
3542 already determined for it. */
3544 ".byte 662b - 661b\n" /* So that this value is undeniably 1. */);
3546 void asm_local_label_diff (void)
3548 printf ("asm_local_label_diff: %d %d\n", alld_stuff
[0], alld_stuff
[1]);
3553 /* This checks that static local variables are available from assembler. */
3554 void asm_local_statics (void)
3556 static int localint
= 41;
3557 asm("incl %0" : "+m" (localint
));
3558 printf ("asm_local_statics: %d\n", localint
);
3564 void fancy_copy (unsigned *in
, unsigned *out
)
3566 asm volatile ("" : "=r" (*out
) : "0" (*in
));
3569 void fancy_copy2 (unsigned *in
, unsigned *out
)
3571 asm volatile ("mov %0,(%1)" : : "r" (*in
), "r" (out
) : "memory");
3574 #if defined __x86_64__
3575 void clobber_r12(void)
3577 asm volatile("mov $1, %%r12" ::: "r12");
3581 void test_high_clobbers_really(void)
3583 #if defined __x86_64__
3584 register word val
asm("r12");
3586 /* This tests if asm clobbers correctly save/restore callee saved
3587 registers if they are clobbered and if it's the high 8 x86-64
3588 registers. This is fragile for GCC as the constraints do not
3589 correctly capture the data flow, but good enough for us. */
3590 asm volatile("mov $0x4542, %%r12" : "=r" (val
):: "memory");
3592 asm volatile("mov %%r12, %0" : "=r" (val2
) : "r" (val
): "memory");
3593 printf("asmhc: 0x%x\n", val2
);
3597 void test_high_clobbers(void)
3599 #if defined __x86_64__
3601 asm volatile("mov %%r12,%0" :: "m" (x1
)); /* save r12 */
3602 test_high_clobbers_really();
3603 asm volatile("mov %%r12,%0" :: "m" (x2
)); /* new r12 */
3604 asm volatile("mov %0,%%r12" :: "m" (x1
)); /* restore r12 */
3605 /* should be 0 but tcc doesn't save r12 automatically, which has
3606 bad effects when gcc helds TCCState *s in r12 in tcc.c:main */
3607 //printf("r12-clobber-diff: %lx\n", x2 - x1);
3611 static long cpu_number
;
3612 void trace_console(long len
, long len2
)
3615 /* This generated invalid code when the emission of the switch
3616 table isn't disabled. The asms are necessary to show the bug,
3617 normal statements don't work (they need to generate some code
3618 even under nocode_wanted, which normal statements don't do,
3619 but asms do). Also at least these number of cases is necessary
3620 to generate enough "random" bytes. They ultimately are enough
3621 to create invalid instruction patterns to which the first
3622 skip-to-decision-table jump jumps. If decision table emission
3623 is disabled all of this is no problem.
3625 It also is necessary that the switches are in a statement expression
3626 (which has the property of not being enterable from outside. no
3637 case 8: printf("bla"); pfo_ret__
= 42; break;
3639 pscr_ret__
= pfo_ret__
;
3646 case 1:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3647 case 2:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3648 case 4:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3649 case 8:asm("movq %1,%0": "=r" (pfo_ret__
) : "m" (cpu_number
)); break;
3650 default: printf("impossible\n");
3652 pscr_ret__
= pfo_ret__
;
3664 void test_asm_dead_code(void)
3667 /* Try to make sure that xdi contains a zero, and hence will
3668 lead to a segfault if the next asm is evaluated without
3669 arguments being set up. */
3670 asm volatile ("" : "=D" (rdi
) : "0" (0));
3673 /* This shouldn't trigger a segfault, either the argument
3674 registers need to be set up and the asm emitted despite
3675 this being in an unevaluated context, or both the argument
3676 setup _and_ the asm emission need to be suppressed. The latter
3677 is better. Disabling asm code gen when suppression is on
3678 also fixes the above trace_console bug, but that came earlier
3679 than asm suppression. */
3680 asm volatile ("movl $0,(%0)" : : "D" (&var
) : "memory");
3685 void test_asm_call(void)
3687 #if defined __x86_64__ && !defined _WIN64 && !defined(__APPLE__)
3688 static char str
[] = "PATH";
3690 /* This tests if a reference to an undefined symbol from an asm
3691 block, which isn't otherwise referenced in this file, is correctly
3692 regarded as global symbol, so that it's resolved by other object files
3693 or libraries. We chose getenv here, which isn't used anywhere else
3694 in this file. (If we used e.g. printf, which is used we already
3695 would have a global symbol entry, not triggering the bug which is
3697 /* two pushes so stack remains aligned */
3698 asm volatile ("push %%rdi; push %%rdi; mov %0, %%rdi;"
3699 #if 1 && !defined(__TINYC__) && (defined(__PIC__) || defined(__PIE__))
3704 "pop %%rdi; pop %%rdi"
3705 : "=a" (s
) : "r" (str
));
3706 printf("asmd: %s\n", s
);
3710 #if defined __x86_64__
3711 # define RX "(%rip)"
3716 void asm_dot_test(void)
3724 asm(".text; lea S"RX
",%eax; lea ."RX
",%ecx; sub %ecx,%eax; S=.; jmp p0");
3727 /* clangs internal assembler is broken */
3728 asm(".text; jmp .+6; .int 123; mov .-4"RX
",%eax; jmp p0");
3730 asm(".text; mov $123, %eax; jmp p0");
3733 #if !defined(_WIN32) && !defined(__clang__)
3734 asm(".pushsection \".data\"; Y=.; .int 999; X=Y; .int 456; X=.-4; .popsection");
3736 asm(".data; Y=.; .int 999; X=Y; .int 456; X=.-4; .text");
3738 asm(".text; mov X"RX
",%eax; jmp p0");
3741 /* Bah! Clang! Doesn't want to redefine 'X' */
3742 asm(".text; mov $789,%eax; jmp p0");
3745 asm(".data; X=.; .int 789; Y=.; .int 999; .previous");
3747 asm(".data; X=.; .int 789; Y=.; .int 999; .text");
3749 asm(".text; mov X"RX
",%eax; X=Y; jmp p0");
3752 asm(".text; p0=.; mov %%eax,%0;" : "=m"(r
)); break;
3756 printf("asm_dot_test %d: %d\n", x
, r
);
3761 void asm_pcrel_test(void)
3764 /* subtract text-section label from forward or other-section label */
3765 asm("1: mov $2f-1b,%%eax; mov %%eax,%0" : "=m"(o1
));
3767 asm("2: lea 2b"RX
",%eax; lea 1b"RX
",%ecx; sub %ecx,%eax");
3768 asm("mov %%eax,%0" : "=m"(o2
));
3769 printf("%s : %x\n", __FUNCTION__
, o1
- o2
); /* should be zero */
3775 unsigned int val
, val2
;
3776 struct struct123 s1
;
3777 struct struct1231 s2
= { (word
)&s1
};
3778 /* Hide the outer base_func, but check later that the inline
3779 asm block gets the outer one. */
3781 void override_func3 (void);
3786 register int regvar
asm("%esi");
3788 // parse 0x1E-1 as 3 tokens in asm mode
3789 asm volatile ("mov $0x1E-1,%eax");
3791 /* test the no operand case */
3792 asm volatile ("xorl %eax, %eax");
3794 memcpy1(buf
, "hello", 6);
3795 strncat1(buf
, " worldXXXXX", 3);
3796 printf("%s\n", buf
);
3798 memcpy2(buf
, "hello", 6);
3799 strncat2(buf
, " worldXXXXX", 3);
3800 printf("%s\n", buf
);
3802 /* 'A' constraint test */
3803 printf("mul64=0x%Lx\n", mul64(0x12345678, 0xabcd1234));
3804 printf("inc64=0x%Lx\n", inc64(0x12345678ffffffff));
3808 printf("mconstraint: %d", mconstraint_test(&s2
));
3809 printf(" %d %d\n", s1
.a
, s1
.b
);
3810 other_constraints_test();
3812 sigdelset1(&set
, 2);
3813 sigaddset1(&set
, 16);
3814 /* NOTE: we test here if C labels are correctly restored after the
3818 __asm__("btsl %1,%0" : "=m"(set
) : "Ir"(20) : "cc");
3819 printf("set=0x%x\n", set
);
3821 printf("swab32(0x%08x) = 0x%0x\n", val
, swab32(val
));
3826 /* The base_func ref from the following inline asm should find
3827 the global one, not the local decl from this function. */
3828 asm volatile(".weak override_func3\n.set override_func3, base_func");
3830 printf("asmstr: %s\n", get_asm_string());
3831 asm_local_label_diff();
3834 asm_local_statics();
3836 /* clang can't deal with the type change */
3837 /* Check that we can also load structs of appropriate layout
3839 asm volatile("" : "=r" (asmret
) : "0"(s2
));
3840 if (asmret
!= s2
.addr
)
3841 printf("asmstr: failed\n");
3844 /* Check that the typesize correctly sets the register size to
3846 asm volatile("cmp %1,%2; sete %0" : "=a"(somebool
) : "r"(1), "r"(2));
3848 printf("asmbool: failed\n");
3851 fancy_copy (&val
, &val2
);
3852 printf ("fancycpy(%d)=%d\n", val
, val2
);
3854 fancy_copy2 (&val
, &val2
);
3855 printf ("fancycpy2(%d)=%d\n", val
, val2
);
3856 asm volatile ("mov $0x4243, %%esi" : "=r" (regvar
));
3857 printf ("regvar=%x\n", regvar
);
3858 test_high_clobbers();
3859 trace_console(8, 8);
3860 test_asm_dead_code();
3877 #define COMPAT_TYPE(type1, type2) \
3879 printf("__builtin_types_compatible_p(%s, %s) = %d\n", #type1, #type2, \
3880 __builtin_types_compatible_p (type1, type2));\
3888 /* __builtin_clz and __builtin_ctz return random values for 0 */
3889 static void builtin_test_bits(unsigned long long x
, int cnt
[])
3892 cnt
[0] += __builtin_ffs(x
);
3893 cnt
[1] += __builtin_ffsl(x
);
3894 cnt
[2] += __builtin_ffsll(x
);
3896 if ((unsigned int) x
) cnt
[3] += __builtin_clz(x
);
3897 if ((unsigned long) x
) cnt
[4] += __builtin_clzl(x
);
3898 if ((unsigned long long) x
) cnt
[5] += __builtin_clzll(x
);
3900 if ((unsigned int) x
) cnt
[6] += __builtin_ctz(x
);
3901 if ((unsigned long) x
) cnt
[7] += __builtin_ctzl(x
);
3902 if ((unsigned long long) x
) cnt
[8] += __builtin_ctzll(x
);
3904 #if GCC_MAJOR >= 6 && (CC_NAME != CC_clang || GCC_MAJOR >= 11)
3905 /* Apple clang 10 does not have __builtin_clrsb[l[l]] */
3906 cnt
[9] += __builtin_clrsb(x
);
3907 cnt
[10] += __builtin_clrsbl(x
);
3908 cnt
[11] += __builtin_clrsbll(x
);
3911 cnt
[12] += __builtin_popcount(x
);
3912 cnt
[13] += __builtin_popcountl(x
);
3913 cnt
[14] += __builtin_popcountll(x
);
3915 cnt
[15] += __builtin_parity(x
);
3916 cnt
[16] += __builtin_parityl(x
);
3917 cnt
[17] += __builtin_parityll(x
);
3921 void builtin_test(void)
3927 COMPAT_TYPE(int, int);
3928 COMPAT_TYPE(int, unsigned int);
3929 COMPAT_TYPE(int, char);
3930 COMPAT_TYPE(int, const int);
3931 COMPAT_TYPE(int, volatile int);
3932 COMPAT_TYPE(int *, int *);
3933 COMPAT_TYPE(int *, void *);
3934 COMPAT_TYPE(int *, const int *);
3935 COMPAT_TYPE(char *, unsigned char *);
3936 COMPAT_TYPE(char *, signed char *);
3937 COMPAT_TYPE(char *, char *);
3938 COMPAT_TYPE(char **, void *);
3940 printf("res1 = %d\n", __builtin_constant_p(1));
3941 printf("res2 = %d\n", __builtin_constant_p(1 + 2));
3942 printf("res3 = %d\n", __builtin_constant_p(&constant_p_var
));
3943 printf("res4 = %d\n", __builtin_constant_p(constant_p_var
));
3944 printf("res5 = %d\n", __builtin_constant_p(100000 / constant_p_var
));
3945 printf("res6 = %d\n", __builtin_constant_p(i
&& 1));
3946 printf("res7 = %d\n", __builtin_constant_p("hi"));
3947 printf("res8 = %d\n", __builtin_constant_p(func()));
3949 printf("res10 = %d\n", __builtin_constant_p(i
&& 0));
3950 printf("res11 = %d\n", __builtin_constant_p(i
* 0));
3951 printf("res12 = %d\n", __builtin_constant_p(i
&& 0 ? i
: 34));
3952 printf("res13 = %d\n", __builtin_constant_p((1,7)));
3954 /* clang doesn't regard these as constant expression */
3955 printf("res10 = 1\n");
3956 printf("res11 = 1\n");
3957 printf("res12 = 1\n");
3958 printf("res13 = 0\n");
3963 i
= __builtin_choose_expr (1 != 0, ll
, s
);
3964 printf("bce: %d\n", i
);
3965 i
= __builtin_choose_expr (1 != 1, ll
, s
);
3966 printf("bce: %d\n", i
);
3967 i
= sizeof (__builtin_choose_expr (1, ll
, s
));
3968 printf("bce: %d\n", i
);
3969 i
= sizeof (__builtin_choose_expr (0, ll
, s
));
3970 printf("bce: %d\n", i
);
3972 //printf("bera: %p\n", __builtin_extract_return_addr((void*)43));
3976 unsigned long long r
= 0;
3978 memset(cnt
, 0, sizeof(cnt
));
3979 builtin_test_bits(0, cnt
);
3980 builtin_test_bits(0xffffffffffffffffull
, cnt
);
3981 for (i
= 0; i
< 64; i
++)
3982 builtin_test_bits(1ull << i
, cnt
);
3983 for (i
= 0; i
< 1000; i
++) {
3984 r
= 0x5851f42d4c957f2dull
* r
+ 0x14057b7ef767814full
;
3985 builtin_test_bits(r
, cnt
);
3987 for (i
= 0; i
< 18; i
++)
3988 printf ("%d %d\n", i
, cnt
[i
]);
3992 #if defined _WIN32 || (defined __APPLE__ && GCC_MAJOR >= 15)
3993 void weak_test(void) {}
3995 extern int __attribute__((weak
)) weak_f1(void);
3996 extern int __attribute__((weak
)) weak_f2(void);
3997 extern int weak_f3(void);
3998 extern int __attribute__((weak
)) weak_v1
;
3999 extern int __attribute__((weak
)) weak_v2
;
4002 extern int (*weak_fpa
)() __attribute__((weak
));
4003 extern int __attribute__((weak
)) (*weak_fpb
)();
4004 extern __attribute__((weak
)) int (*weak_fpc
)();
4006 extern int weak_asm_f1(void) asm("weak_asm_f1x") __attribute((weak
));
4007 extern int __attribute((weak
)) weak_asm_f2(void) asm("weak_asm_f2x") ;
4008 extern int __attribute((weak
)) weak_asm_f3(void) asm("weak_asm_f3x") __attribute((weak
));
4009 extern int weak_asm_v1
asm("weak_asm_v1x") __attribute((weak
));
4010 extern int __attribute((weak
)) weak_asm_v2
asm("weak_asm_v2x") ;
4011 extern int __attribute((weak
)) weak_asm_v3(void) asm("weak_asm_v3x") __attribute((weak
));
4014 static const size_t dummy
= 0;
4015 extern __typeof(dummy
) weak_dummy1
__attribute__((weak
, alias("dummy")));
4016 extern __typeof(dummy
) __attribute__((weak
, alias("dummy"))) weak_dummy2
;
4017 extern __attribute__((weak
, alias("dummy"))) __typeof(dummy
) weak_dummy3
;
4020 int some_lib_func(void);
4021 int dummy_impl_of_slf(void) { return 444; }
4023 int some_lib_func(void) __attribute__((weak
, alias("dummy_impl_of_slf")));
4026 int weak_toolate() __attribute__((weak
));
4027 int weak_toolate() { return 0; }
4029 void __attribute__((weak
)) weak_test(void)
4031 printf("weak_f1=%d\n", weak_f1
? weak_f1() : 123);
4032 printf("weak_f2=%d\n", weak_f2
? weak_f2() : 123);
4033 printf("weak_f3=%d\n", weak_f3
? weak_f3() : 123);
4034 printf("weak_v1=%d\n",&weak_v1
? weak_v1
: 123);
4035 printf("weak_v2=%d\n",&weak_v2
? weak_v2
: 123);
4036 printf("weak_v3=%d\n",&weak_v3
? weak_v3
: 123);
4038 printf("weak_fpa=%d\n",&weak_fpa
? weak_fpa() : 123);
4039 printf("weak_fpb=%d\n",&weak_fpb
? weak_fpb() : 123);
4040 printf("weak_fpc=%d\n",&weak_fpc
? weak_fpc() : 123);
4042 printf("weak_asm_f1=%d\n", weak_asm_f1
!= NULL
);
4043 printf("weak_asm_f2=%d\n", weak_asm_f2
!= NULL
);
4044 printf("weak_asm_f3=%d\n", weak_asm_f3
!= NULL
);
4045 printf("weak_asm_v1=%d\n",&weak_asm_v1
!= NULL
);
4046 printf("weak_asm_v2=%d\n",&weak_asm_v2
!= NULL
);
4047 printf("weak_asm_v3=%d\n",&weak_asm_v3
!= NULL
);
4049 printf("some_lib_func=444\n");
4051 printf("some_lib_func=%d\n", &some_lib_func
? some_lib_func() : 0);
4055 int __attribute__((weak
)) weak_f2() { return 222; }
4056 int __attribute__((weak
)) weak_f3() { return 333; }
4057 int __attribute__((weak
)) weak_v2
= 222;
4058 int __attribute__((weak
)) weak_v3
= 333;
4061 void const_func(const int a
)
4065 void const_warn_test(void)
4074 int getme (struct condstruct
*s
, int i
)
4076 int i1
= (i
== 0 ? 0 : s
)->i
;
4077 int i2
= (i
== 0 ? s
: 0)->i
;
4078 int i3
= (i
== 0 ? (void*)0 : s
)->i
;
4079 int i4
= (i
== 0 ? s
: (void*)0)->i
;
4080 return i1
+ i2
+ i3
+ i4
;
4089 struct global_data global_data
;
4091 int global_data_getstuff (int *, int);
4093 void global_data_callit (int i
)
4095 *global_data
.b
[i
] = global_data_getstuff (global_data
.b
[i
], 1);
4098 int global_data_getstuff (int *p
, int i
)
4103 void global_data_test (void)
4105 global_data
.a
[0] = 42;
4106 global_data
.b
[0] = &global_data
.a
[0];
4107 global_data_callit (0);
4108 printf ("%d\n", global_data
.a
[0]);
4113 unsigned char fill
: 3;
4114 unsigned char b1
: 1;
4115 unsigned char b2
: 1;
4116 unsigned char fill2
: 3;
4119 int glob1
, glob2
, glob3
;
4121 void compare_comparisons (struct cmpcmpS
*s
)
4123 if (s
->b1
!= (glob1
== glob2
)
4124 || (s
->b2
!= (glob1
== glob3
)))
4125 printf ("comparing comparisons broken\n");
4128 void cmp_comparison_test(void)
4132 glob1
= 42; glob2
= 42;
4135 compare_comparisons (&s
);
4138 int fcompare (double a
, double b
, int code
)
4141 case 0: return a
== b
;
4142 case 1: return a
!= b
;
4143 case 2: return a
< b
;
4144 case 3: return a
>= b
;
4145 case 4: return a
> b
;
4146 case 5: return a
<= b
;
4151 void math_cmp_test(void)
4153 double nan
= 0.0/0.0;
4158 #define bug(a,b,op,iop,part) printf("Test broken: %s %s %s %s %d\n", #a, #b, #op, #iop, part)
4160 /* This asserts that "a op b" is _not_ true, but "a iop b" is true.
4161 And it does this in various ways so that all code generation paths
4162 are checked (generating inverted tests, or non-inverted tests, or
4163 producing a 0/1 value without jumps (that's done in the fcompare
4165 #define FCMP(a,b,op,iop,code) \
4166 if (fcompare (a,b,code)) \
4167 bug (a,b,op,iop,1); \
4169 bug (a,b,op,iop,2); \
4173 bug (a,b,op,iop,3); \
4174 if ((a op b) || comp) \
4175 bug (a,b,op,iop,4); \
4176 if ((a iop b) || comp) \
4179 bug (a,b,op,iop,5); \
4180 if (v = !(a op b), !v) bug(a,b,op,iop,7);
4182 /* Equality tests. */
4183 FCMP(nan
, nan
, ==, !=, 0);
4184 FCMP(one
, two
, ==, !=, 0);
4185 FCMP(one
, one
, !=, ==, 1);
4186 /* Non-equality is a bit special. */
4187 if (!fcompare (nan
, nan
, 1))
4188 bug (nan
, nan
, !=, ==, 6);
4190 /* Relational tests on numbers. */
4191 FCMP(two
, one
, <, >=, 2);
4192 FCMP(one
, two
, >=, <, 3);
4193 FCMP(one
, two
, >, <=, 4);
4194 FCMP(two
, one
, <=, >, 5);
4196 /* Relational tests on NaNs. Note that the inverse op here is
4197 always !=, there's no operator in C that is equivalent to !(a < b),
4198 when NaNs are involved, same for the other relational ops. */
4199 FCMP(nan
, nan
, <, !=, 2);
4200 FCMP(nan
, nan
, >=, !=, 3);
4201 FCMP(nan
, nan
, >, !=, 4);
4202 FCMP(nan
, nan
, <=, !=, 5);
4205 double get100 () { return 100.0; }
4207 void callsave_test(void)
4209 #if defined __i386__ || defined __x86_64__ || defined __arm__
4210 int i
, s
; double *d
; double t
;
4211 s
= sizeof (double);
4212 printf ("callsavetest: %d\n", s
);
4213 d
= alloca (sizeof(double));
4215 /* x86-64 had a bug were the next call to get100 would evict
4216 the lvalue &d[0] as VT_LLOCAL, and the reload would be done
4217 in int type, not pointer type. When alloca returns a pointer
4218 with the high 32 bit set (which is likely on x86-64) the access
4219 generates a segfault. */
4220 i
= d
[0] > get100 ();
4226 void bfa3(ptrdiff_t str_offset
)
4228 printf("bfa3: %s\n", (char *)__builtin_frame_address(3) + str_offset
);
4230 void bfa2(ptrdiff_t str_offset
)
4232 printf("bfa2: %s\n", (char *)__builtin_frame_address(2) + str_offset
);
4235 void bfa1(ptrdiff_t str_offset
)
4237 printf("bfa1: %s\n", (char *)__builtin_frame_address(1) + str_offset
);
4241 void builtin_frame_address_test(void)
4243 /* builtin_frame_address fails on ARM with gcc which make test3 fail */
4245 char str
[] = "__builtin_frame_address";
4246 char *fp0
= __builtin_frame_address(0);
4248 printf("str: %s\n", str
);
4249 #ifndef __riscv // gcc dumps core. tcc, clang work
4255 char via_volatile (char i
)
4262 void volatile_test(void)
4264 if (via_volatile (42) != 42)
4265 printf (" broken\n");
4270 struct __attribute__((__packed__
)) Spacked
{
4275 struct Spacked spacked
;
4276 typedef struct __attribute__((__packed__
)) {
4282 typedef struct Spacked3_s
{
4286 } __attribute__((__packed__
)) Spacked3
;
4288 struct gate_struct64
{
4289 unsigned short offset_low
;
4290 unsigned short segment
;
4291 unsigned ist
: 3, zero0
: 5, type
: 5, dpl
: 2, p
: 1;
4292 unsigned short offset_middle
;
4293 unsigned offset_high
;
4295 } __attribute__((packed
));
4296 typedef struct gate_struct64 gate_desc
;
4297 gate_desc a_gate_desc
;
4298 void attrib_test(void)
4301 printf("attr: %d %d %d %d\n", sizeof(struct Spacked
),
4302 sizeof(spacked
), sizeof(Spacked2
), sizeof(spacked2
));
4303 printf("attr: %d %d\n", sizeof(Spacked3
), sizeof(spacked3
));
4304 printf("attr: %d %d\n", sizeof(gate_desc
), sizeof(a_gate_desc
));
4307 extern __attribute__((__unused__
)) char * __attribute__((__unused__
)) *
4308 strange_attrib_placement (void);
4310 void * __attribute__((__unused__
)) get_void_ptr (void *a
)
4315 /* This part checks for a bug in TOK_GET (used for inline expansion),
4316 where the large long long constant left the the high bits set for
4317 the integer constant token. */
4319 int __get_order(unsigned long long size
)
4322 size
-= 0xffff880000000000ULL
; // this const left high bits set in the token
4324 struct S
{ int i
: 1; } s
; // constructed for this '1'
4330 /* This just forces the above inline function to be actually emitted. */
4331 int force_get_order(unsigned long s
)
4333 return __get_order(s
);
4336 #define pv(m) printf(sizeof (s->m + 0) == 8 ? "%016llx\n" : "%02x\n", s->m)
4338 /* Test failed when using bounds checking */
4339 void bounds_check1_test (void)
4351 /* This failed on arm64/riscv64 */
4352 void map_add(int a
, int b
, int c
, int d
, int e
, int f
, int g
, int h
, int i
)
4354 printf ("%d %d %d %d %d %d %d %d %d\n", a
, b
, c
, d
, e
, f
, g
, h
, i
);
4357 void func_arg_test(void)
4361 map_add(0, 1, 2, 3, 4, 5, 6, 7, a
&& b
);
4364 /* gcc 2.95.3 does not handle correctly CR in strings or after strays */
4365 #define CORRECT_CR_HANDLING
4367 /* deprecated and no longer supported in gcc 3.3 */
4368 /* no longer supported by default in TinyCC */
4370 /* # define ACCEPT_LF_IN_STRINGS */
4375 /* keep this as the last test because GCC messes up line-numbers
4376 with the ^L^K^M characters below */
4377 void whitespace_test(void)
4384 ntf("whitspace:\n");\f\v
4388 #ifdef CORRECT_CR_HANDLING
4397 #ifdef ACCEPT_LF_IN_STRINGS
4398 printf("len1=%d\n", strlen("
4400 #ifdef CORRECT_CR_HANDLING
4403 printf("len1=%d str[0]=%d\n", strlen(str
), str
[0]);
4405 printf("len1=%d\n", strlen("
a
4408 printf("len1=1\nlen1=1 str[0]=10\nlen1=3\n");
4409 #endif /* ACCEPT_LF_IN_STRINGS */
4412 printf("__LINE__ defined\n");
4416 /* wrong with GCC */
4417 printf("__LINE__=%d __FILE__=%s\n", __LINE__
, __FILE__
);
4419 printf("__LINE__=%d __FILE__=%s\n", __LINE__
, __FILE__
);
4421 printf("__LINE__=%d __FILE__=%s\n", __LINE__
, __FILE__
);
4437 #define RUN(test) puts("---- " #test " ----"), test(), puts("")
4439 int main(int argc, char **argv)
4441 RUN(whitespace_test);
4443 RUN(recursive_macro_test);
4460 RUN(optimize_out_test);
4462 RUN(constant_expr_test);
4464 RUN(char_short_test);
4466 RUN(compound_literal_test);
4468 RUN(struct_assign_test);
4476 RUN(relocation_test);
4477 RUN(old_style_function_test);
4482 RUN(statement_expr_test);
4483 RUN(local_label_test);
4487 RUN(global_data_test);
4488 RUN(cmp_comparison_test);
4491 RUN(builtin_frame_address_test);
4494 RUN(bounds_check1_test);