diff options
Diffstat (limited to 'tinycc/tests/tests2')
246 files changed, 10731 insertions, 0 deletions
diff --git a/tinycc/tests/tests2/00_assignment.c b/tinycc/tests/tests2/00_assignment.c new file mode 100644 index 0000000..c96109f --- /dev/null +++ b/tinycc/tests/tests2/00_assignment.c @@ -0,0 +1,18 @@ +#include <stdio.h> + +int main() +{ + int a; + a = 42; + printf("%d\n", a); + + int b = 64; + printf("%d\n", b); + + int c = 12, d = 34; + printf("%d, %d\n", c, d); + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/00_assignment.expect b/tinycc/tests/tests2/00_assignment.expect new file mode 100644 index 0000000..d4407f3 --- /dev/null +++ b/tinycc/tests/tests2/00_assignment.expect @@ -0,0 +1,3 @@ +42 +64 +12, 34 diff --git a/tinycc/tests/tests2/01_comment.c b/tinycc/tests/tests2/01_comment.c new file mode 100644 index 0000000..a2e6bc6 --- /dev/null +++ b/tinycc/tests/tests2/01_comment.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +int main() +{ + printf("Hello\n"); + printf("Hello\n"); /* this is a comment */ printf("Hello\n"); + printf("Hello\n"); + // this is also a comment sayhello(); + printf("Hello\n"); + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/01_comment.expect b/tinycc/tests/tests2/01_comment.expect new file mode 100644 index 0000000..b1387ad --- /dev/null +++ b/tinycc/tests/tests2/01_comment.expect @@ -0,0 +1,5 @@ +Hello +Hello +Hello +Hello +Hello diff --git a/tinycc/tests/tests2/02_printf.c b/tinycc/tests/tests2/02_printf.c new file mode 100644 index 0000000..4c34dd8 --- /dev/null +++ b/tinycc/tests/tests2/02_printf.c @@ -0,0 +1,18 @@ +#include <stdio.h> + +int main() +{ + printf("Hello world\n"); + + int Count; + for (Count = -5; Count <= 5; Count++) + printf("Count = %d\n", Count); + + printf("String 'hello', 'there' is '%s', '%s'\n", "hello", "there"); + printf("Character 'A' is '%c'\n", 65); + printf("Character 'a' is '%c'\n", 'a'); + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/02_printf.expect b/tinycc/tests/tests2/02_printf.expect new file mode 100644 index 0000000..f67a0f6 --- /dev/null +++ b/tinycc/tests/tests2/02_printf.expect @@ -0,0 +1,15 @@ +Hello world +Count = -5 +Count = -4 +Count = -3 +Count = -2 +Count = -1 +Count = 0 +Count = 1 +Count = 2 +Count = 3 +Count = 4 +Count = 5 +String 'hello', 'there' is 'hello', 'there' +Character 'A' is 'A' +Character 'a' is 'a' diff --git a/tinycc/tests/tests2/03_struct.c b/tinycc/tests/tests2/03_struct.c new file mode 100644 index 0000000..fd73133 --- /dev/null +++ b/tinycc/tests/tests2/03_struct.c @@ -0,0 +1,38 @@ +extern int printf(const char*, ...); + +struct fred; + +void fred$(struct fred* this) +{ + printf("~fred()\n"); +} + +struct __attribute__((__cleanup__(fred$))) fred +{ + int boris; + int natasha; +}; + +int main() +{ + struct fred __attribute__((__cleanup__(fred$))) bloggs; + + bloggs.boris = 12; + bloggs.natasha = 34; + + printf("%d\n", bloggs.boris); + printf("%d\n", bloggs.natasha); + + struct fred jones[2]; + jones[0].boris = 12; + jones[0].natasha = 34; + jones[1].boris = 56; + jones[1].natasha = 78; + + printf("%d\n", jones[0].boris); + printf("%d\n", jones[0].natasha); + printf("%d\n", jones[1].boris); + printf("%d\n", jones[1].natasha); + + return 0; +} diff --git a/tinycc/tests/tests2/03_struct.expect b/tinycc/tests/tests2/03_struct.expect new file mode 100644 index 0000000..be8df37 --- /dev/null +++ b/tinycc/tests/tests2/03_struct.expect @@ -0,0 +1,8 @@ +03_struct.c:14: warning: attribute '__cleanup__' ignored on type +12 +34 +12 +34 +56 +78 +~fred() diff --git a/tinycc/tests/tests2/04_for.c b/tinycc/tests/tests2/04_for.c new file mode 100644 index 0000000..312fed8 --- /dev/null +++ b/tinycc/tests/tests2/04_for.c @@ -0,0 +1,15 @@ +#include <stdio.h> + +int main() +{ + int Count; + + for (Count = 1; Count <= 10; Count++) + { + printf("%d\n", Count); + } + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/04_for.expect b/tinycc/tests/tests2/04_for.expect new file mode 100644 index 0000000..f00c965 --- /dev/null +++ b/tinycc/tests/tests2/04_for.expect @@ -0,0 +1,10 @@ +1 +2 +3 +4 +5 +6 +7 +8 +9 +10 diff --git a/tinycc/tests/tests2/05_array.c b/tinycc/tests/tests2/05_array.c new file mode 100644 index 0000000..c218f31 --- /dev/null +++ b/tinycc/tests/tests2/05_array.c @@ -0,0 +1,21 @@ +#include <stdio.h> + +int main() +{ + int Count; + int Array[10]; + + for (Count = 1; Count <= 10; Count++) + { + Array[Count-1] = Count * Count; + } + + for (Count = 0; Count < 10; Count++) + { + printf("%d\n", Array[Count]); + } + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/05_array.expect b/tinycc/tests/tests2/05_array.expect new file mode 100644 index 0000000..bc7257c --- /dev/null +++ b/tinycc/tests/tests2/05_array.expect @@ -0,0 +1,10 @@ +1 +4 +9 +16 +25 +36 +49 +64 +81 +100 diff --git a/tinycc/tests/tests2/06_case.c b/tinycc/tests/tests2/06_case.c new file mode 100644 index 0000000..c0191e2 --- /dev/null +++ b/tinycc/tests/tests2/06_case.c @@ -0,0 +1,29 @@ +#include <stdio.h> + +int main() +{ + int Count; + + for (Count = 0; Count < 4; Count++) + { + printf("%d\n", Count); + switch (Count) + { + case 1: + printf("%d\n", 1); + break; + + case 2: + printf("%d\n", 2); + break; + + default: + printf("%d\n", 0); + break; + } + } + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/06_case.expect b/tinycc/tests/tests2/06_case.expect new file mode 100644 index 0000000..fab2c20 --- /dev/null +++ b/tinycc/tests/tests2/06_case.expect @@ -0,0 +1,8 @@ +0 +0 +1 +1 +2 +2 +3 +0 diff --git a/tinycc/tests/tests2/07_function.c b/tinycc/tests/tests2/07_function.c new file mode 100644 index 0000000..006e0a7 --- /dev/null +++ b/tinycc/tests/tests2/07_function.c @@ -0,0 +1,35 @@ +#include <stdio.h> + +int myfunc(int x) +{ + return x * x; +} + +void vfunc(int a) +{ + printf("a=%d\n", a); +} + +void qfunc() +{ + printf("qfunc()\n"); +} + +void zfunc() +{ + ((void (*)(void))0) (); +} + +int main() +{ + printf("%d\n", myfunc(3)); + printf("%d\n", myfunc(4)); + + vfunc(1234); + + qfunc(); + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/07_function.expect b/tinycc/tests/tests2/07_function.expect new file mode 100644 index 0000000..8ffb0a7 --- /dev/null +++ b/tinycc/tests/tests2/07_function.expect @@ -0,0 +1,4 @@ +9 +16 +a=1234 +qfunc() diff --git a/tinycc/tests/tests2/08_while.c b/tinycc/tests/tests2/08_while.c new file mode 100644 index 0000000..602ffc7 --- /dev/null +++ b/tinycc/tests/tests2/08_while.c @@ -0,0 +1,24 @@ +#include <stdio.h> + +int main() +{ + int a; + int p; + int t; + + a = 1; + p = 0; + t = 0; + + while (a < 100) + { + printf("%d\n", a); + t = a; + a = t + p; + p = t; + } + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/08_while.expect b/tinycc/tests/tests2/08_while.expect new file mode 100644 index 0000000..702d4c0 --- /dev/null +++ b/tinycc/tests/tests2/08_while.expect @@ -0,0 +1,11 @@ +1 +1 +2 +3 +5 +8 +13 +21 +34 +55 +89 diff --git a/tinycc/tests/tests2/09_do_while.c b/tinycc/tests/tests2/09_do_while.c new file mode 100644 index 0000000..1d3315d --- /dev/null +++ b/tinycc/tests/tests2/09_do_while.c @@ -0,0 +1,24 @@ +#include <stdio.h> + +int main() +{ + int a; + int p; + int t; + + a = 1; + p = 0; + t = 0; + + do + { + printf("%d\n", a); + t = a; + a = t + p; + p = t; + } while (a < 100); + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/09_do_while.expect b/tinycc/tests/tests2/09_do_while.expect new file mode 100644 index 0000000..702d4c0 --- /dev/null +++ b/tinycc/tests/tests2/09_do_while.expect @@ -0,0 +1,11 @@ +1 +1 +2 +3 +5 +8 +13 +21 +34 +55 +89 diff --git a/tinycc/tests/tests2/100_c99array-decls.c b/tinycc/tests/tests2/100_c99array-decls.c new file mode 100644 index 0000000..46950aa --- /dev/null +++ b/tinycc/tests/tests2/100_c99array-decls.c @@ -0,0 +1,34 @@ +void foo(int [5]); +void fooc(int x[const 5]); +void foos(int x[static 5]); +void foov(int x[volatile 5]); +void foor(int x[restrict 5]); +void fooc(int [const 5]); +void foos(int [static 5]); +void foov(int [volatile 5]); +void foor(int [restrict 5]); +void fooc(int (* const x)); +void foos(int *x); +void foov(int * volatile x); +void foor(int * restrict x); +void fooc(int x[volatile 5]) +{ + x[3] = 42; +#ifdef INVALID + x = 0; +#endif +} +void foovm(int x[const *]); +void foovm(int * const x); +#ifdef INVALID +void wrongc(int x[3][const 4]); +void wrongvm(int x[static *]); +void foovm(int x[const *]) +{ + x[2] = 1; +} +#endif +int main() +{ + return 0; +} diff --git a/tinycc/tests/tests2/100_c99array-decls.expect b/tinycc/tests/tests2/100_c99array-decls.expect new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tinycc/tests/tests2/100_c99array-decls.expect diff --git a/tinycc/tests/tests2/101_cleanup.c b/tinycc/tests/tests2/101_cleanup.c new file mode 100644 index 0000000..de5dca2 --- /dev/null +++ b/tinycc/tests/tests2/101_cleanup.c @@ -0,0 +1,227 @@ +extern int printf(const char*, ...); +static int glob_i = 0; + +void incr_glob_i(int *i) +{ + glob_i += *i; +} + +#define INCR_GI { \ + int i __attribute__ ((__cleanup__(incr_glob_i))) = 1; \ + } + +#define INCR_GI0 INCR_GI INCR_GI INCR_GI INCR_GI +#define INCR_GI1 INCR_GI0 INCR_GI0 INCR_GI0 INCR_GI0 +#define INCR_GI2 INCR_GI1 INCR_GI1 INCR_GI1 INCR_GI1 +#define INCR_GI3 INCR_GI2 INCR_GI2 INCR_GI2 INCR_GI2 +#define INCR_GI4 INCR_GI3 INCR_GI3 INCR_GI3 INCR_GI3 +#define INCR_GI5 INCR_GI4 INCR_GI4 INCR_GI4 INCR_GI4 +#define INCR_GI6 INCR_GI5 INCR_GI5 INCR_GI5 INCR_GI5 +#define INCR_GI7 INCR_GI6 INCR_GI6 INCR_GI6 INCR_GI6 + + +void check2(char **hum); + +void check(int *j) +{ + char * __attribute__ ((cleanup(check2))) stop_that = "wololo"; + int chk = 0; + + { + char * __attribute__ ((cleanup(check2))) stop_that = "plop"; + + { + non_plopage: + printf("---- %d\n", chk); + } + if (!chk) { + chk = 1; + goto non_plopage; + } + } + + { + char * __attribute__ ((cleanup(check2))) stop_that = "tata !"; + + goto out; + stop_that = "titi"; + } + again: + chk = 2; + { + char * __attribute__ ((cleanup(check2))) cascade1 = "1"; + { + char * __attribute__ ((cleanup(check2))) cascade2 = "2"; + { + char * __attribute__ ((cleanup(check2))) cascade3 = "3"; + + goto out; + cascade3 = "nope"; + } + } + } + out: + if (chk != 2) + goto again; + { + { + char * __attribute__ ((cleanup(check2))) out = "last goto out"; + ++chk; + if (chk != 3) + goto out; + } + } + return; +} + +void check_oh_i(char *oh_i) +{ + printf("c: %c\n", *oh_i); +} + +void goto_hell(double *f) +{ + printf("oo: %f\n", *f); +} + +char *test() +{ + char *__attribute__ ((cleanup(check2))) str = "I don't think this should be print(but gcc got it wrong too)"; + + return str; +} + +void test_ret_subcall(char *that) +{ + printf("should be print before\n"); +} + +void test_ret() +{ + char *__attribute__ ((cleanup(check2))) that = "that"; + return test_ret_subcall(that); +} + +void test_ret2() +{ + char *__attribute__ ((cleanup(check2))) that = "-that"; + { + char *__attribute__ ((cleanup(check2))) that = "this should appear only once"; + } + { + char *__attribute__ ((cleanup(check2))) that = "-that2"; + return; + } +} + +void test2(void) { + int chk = 0; +again: + if (!chk) { + char * __attribute__ ((cleanup(check2))) stop_that = "test2"; + chk++; + goto again; + } +} + +int test3(void) { + char * __attribute__ ((cleanup(check2))) stop_that = "three"; + int chk = 0; + + if (chk) { + { + outside: + { + char * __attribute__ ((cleanup(check2))) stop_that = "two"; + printf("---- %d\n", chk); + } + } + } + if (!chk) + { + char * __attribute__ ((cleanup(check2))) stop_that = "one"; + + if (!chk) { + chk = 1; + goto outside; + } + } + return 0; +} + +void cl(int *ip) +{ + printf("%d\n", *ip); +} + +void loop_cleanups(void) +{ + __attribute__((cleanup(cl))) int l = 1000; + + printf("-- loop 0 --\n"); + for ( __attribute__((cleanup(cl))) int i = 0; i < 10; ++i) { + __attribute__((cleanup(cl))) int j = 100; + } + + printf("-- loop 1 --\n"); + for (__attribute__((cleanup(cl))) int i = 0; i < 10; ++i) { + __attribute__((cleanup(cl))) int j = 200; + continue; + } + + printf("-- loop 2 --\n"); + for (__attribute__((cleanup(cl))) int i = 0; i < 10; ++i) { + __attribute__((cleanup(cl))) int j = 300; + break; + } + + printf("-- loop 3 --\n"); + for (int i = 0; i < 2; ++i) { + __attribute__((cleanup(cl))) int j = 400; + switch (i) { + case 0: + continue; + default: + { + __attribute__((cleanup(cl))) int jj = 500; + break; + } + } + } + printf("after break\n"); +} + +int main() +{ + int i __attribute__ ((__cleanup__(check))) = 0, not_i; + int chk = 0; + (void)not_i; + + { + __attribute__ ((__cleanup__(check_oh_i))) char oh_i = 'o', o = 'a'; + } + + INCR_GI7; + printf("glob_i: %d\n", glob_i); + naaaaaaaa: + if (!chk) { + __attribute__ ((__cleanup__(check_oh_i))) char oh_i = 'f'; + double __attribute__ ((__cleanup__(goto_hell))) f = 2.6; + + chk = 1; + goto naaaaaaaa; + } + i = 105; + printf("because what if free was call inside cleanup function %s\n", test()); + test_ret(); + test_ret2(); + test2(); + test3(); + loop_cleanups(); + return i; +} + +void check2(char **hum) +{ + printf("str: %s\n", *hum); +} diff --git a/tinycc/tests/tests2/101_cleanup.expect b/tinycc/tests/tests2/101_cleanup.expect new file mode 100644 index 0000000..84960cd --- /dev/null +++ b/tinycc/tests/tests2/101_cleanup.expect @@ -0,0 +1,59 @@ +c: a +c: o +glob_i: 65536 +oo: 2.600000 +c: f +str: I don't think this should be print(but gcc got it wrong too) +because what if free was call inside cleanup function I don't think this should be print(but gcc got it wrong too) +should be print before +str: that +str: this should appear only once +str: -that2 +str: -that +str: test2 +str: one +---- 1 +str: two +str: three +-- loop 0 -- +100 +100 +100 +100 +100 +100 +100 +100 +100 +100 +10 +-- loop 1 -- +200 +200 +200 +200 +200 +200 +200 +200 +200 +200 +10 +-- loop 2 -- +300 +0 +-- loop 3 -- +400 +500 +400 +after break +1000 +---- 0 +---- 1 +str: plop +str: tata ! +str: 3 +str: 2 +str: 1 +str: last goto out +str: wololo diff --git a/tinycc/tests/tests2/102_alignas.c b/tinycc/tests/tests2/102_alignas.c new file mode 100644 index 0000000..62d3ed2 --- /dev/null +++ b/tinycc/tests/tests2/102_alignas.c @@ -0,0 +1,29 @@ +_Alignas(16) int i1; +int _Alignas(16) i2; +void _Alignas(16) *p2; +_Alignas(16) i3; +int _Alignas(double) i4; +int _Alignas(int) i5; +#if 0 +/* The following are currently wrongly accepted by TCC but really shouldn't. */ +int _Alignas(int _Alignas(16)) i6; //wrong, 'int _Alignas(16)' is no type-name +typedef int _Alignas(16) int16aligned_t; //wrong, _Alignas invalid on typedef +int16aligned_t i7; +#endif +/* i8 should get an alignment of 16, because unlike _Alignas the + corresponding attribute _does_ apply to type-name, though not in + some clang versions. */ +int _Alignas(int __attribute__((aligned(16)))) i8; +extern int printf(const char*, ...); +#ifdef _MSC_VER +#define alignof(x) (int)__alignof(x) +#else +#define alignof(x) (int)__alignof__(x) +#endif +int main() +{ + printf("%d %d %d %d\n", + alignof(i1) == 16, alignof(i4) == alignof(double), + alignof(i5) == alignof(int) , alignof(i8) == 16); + return 0; +} diff --git a/tinycc/tests/tests2/102_alignas.expect b/tinycc/tests/tests2/102_alignas.expect new file mode 100644 index 0000000..b458e07 --- /dev/null +++ b/tinycc/tests/tests2/102_alignas.expect @@ -0,0 +1,2 @@ +102_alignas.c:4: warning: type defaults to int +1 1 1 1 diff --git a/tinycc/tests/tests2/103_implicit_memmove.c b/tinycc/tests/tests2/103_implicit_memmove.c new file mode 100644 index 0000000..1592fb2 --- /dev/null +++ b/tinycc/tests/tests2/103_implicit_memmove.c @@ -0,0 +1,20 @@ +/* Test that the memmove TCC is emitting for the struct copy + and hence implicitely declares can be declared properly also + later. */ +struct S { int a,b,c,d, e[1024];}; +int foo (struct S *a, struct S *b) +{ + *a = *b; + return 0; +} + +void *memmove(void*,const void*,__SIZE_TYPE__); +void foo2 (struct S *a, struct S *b) +{ + memmove(a, b, sizeof *a); +} + +int main() +{ + return 0; +} diff --git a/tinycc/tests/tests2/103_implicit_memmove.expect b/tinycc/tests/tests2/103_implicit_memmove.expect new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tinycc/tests/tests2/103_implicit_memmove.expect diff --git a/tinycc/tests/tests2/104+_inline.c b/tinycc/tests/tests2/104+_inline.c new file mode 100644 index 0000000..3c48eb8 --- /dev/null +++ b/tinycc/tests/tests2/104+_inline.c @@ -0,0 +1,54 @@ + +#define GOT(f) \ + __attribute__((weak)) void f(void); \ + printf("%d %s\n", !!((__SIZE_TYPE__)f & ~0u), #f); + +int printf(const char*, ...); + +void check_exports() +{ + // 0 + GOT(inline_inline_2decl_only) + GOT(inline_inline_undeclared) + GOT(inline_inline_predeclared) + GOT(inline_inline_postdeclared) + GOT(inline_inline_prepostdeclared) + GOT(inline_inline_undeclared2) + GOT(inline_inline_predeclared2) + GOT(inline_inline_postdeclared2) + GOT(inline_inline_prepostdeclared2) + + // 1 + GOT(extern_extern_postdeclared) + GOT(extern_extern_postdeclared2) + GOT(extern_extern_predeclared) + GOT(extern_extern_predeclared2) + GOT(extern_extern_prepostdeclared) + GOT(extern_extern_prepostdeclared2) + GOT(extern_extern_undeclared) + GOT(extern_extern_undeclared2) + GOT(extern_postdeclared) + GOT(extern_postdeclared2) + GOT(extern_predeclared) + GOT(extern_predeclared2) + GOT(extern_prepostdeclared) + GOT(extern_undeclared) + GOT(extern_undeclared2) + GOT(inst2_extern_inline_postdeclared) + GOT(inst2_extern_inline_predeclared) + GOT(inst3_extern_inline_predeclared) + GOT(inst_extern_inline_postdeclared) + GOT(inst_extern_inline_predeclared) + GOT(main) + GOT(noinst_extern_inline_func) + GOT(noinst_extern_inline_postdeclared) + GOT(noinst_extern_inline_postdeclared2) + GOT(noinst_extern_inline_undeclared) + + // 0 + GOT(noinst_static_inline_postdeclared) + GOT(noinst2_static_inline_postdeclared) + GOT(noinst_static_inline_predeclared) + GOT(noinst2_static_inline_predeclared) + GOT(static_func) +} diff --git a/tinycc/tests/tests2/104_inline.c b/tinycc/tests/tests2/104_inline.c new file mode 100644 index 0000000..766f94a --- /dev/null +++ b/tinycc/tests/tests2/104_inline.c @@ -0,0 +1,132 @@ +inline void inline_inline_2decl_only(void); +inline void inline_inline_2decl_only(void); + +inline void inline_inline_undeclared(void){} + +inline void inline_inline_predeclared(void); +inline void inline_inline_predeclared(void){} + +inline void inline_inline_postdeclared(void){} +inline void inline_inline_postdeclared(void); + +inline void inline_inline_prepostdeclared(void); +inline void inline_inline_prepostdeclared(void){} +inline void inline_inline_prepostdeclared(void); + +inline void inline_inline_undeclared2(void){} + +inline void inline_inline_predeclared2(void); +inline void inline_inline_predeclared2(void); +inline void inline_inline_predeclared2(void){} + +inline void inline_inline_postdeclared2(void){} +inline void inline_inline_postdeclared2(void); +inline void inline_inline_postdeclared2(void); + +inline void inline_inline_prepostdeclared2(void); +inline void inline_inline_prepostdeclared2(void); +inline void inline_inline_prepostdeclared2(void){} +inline void inline_inline_prepostdeclared2(void); +inline void inline_inline_prepostdeclared2(void); + +extern void extern_extern_undeclared(void){} + +extern void extern_extern_predeclared(void); +extern void extern_extern_predeclared(void){} + +extern void extern_extern_postdeclared(void){} +extern void extern_extern_postdeclared(void); + +extern void extern_extern_prepostdeclared(void); +extern void extern_extern_prepostdeclared(void){} +extern void extern_extern_prepostdeclared(void); + +extern void extern_extern_undeclared2(void){} + +extern void extern_extern_predeclared2(void); +extern void extern_extern_predeclared2(void); +extern void extern_extern_predeclared2(void){} + +extern void extern_extern_postdeclared2(void){} +extern void extern_extern_postdeclared2(void); +extern void extern_extern_postdeclared2(void); + +extern void extern_extern_prepostdeclared2(void); +extern void extern_extern_prepostdeclared2(void); +extern void extern_extern_prepostdeclared2(void){} +extern void extern_extern_prepostdeclared2(void); +extern void extern_extern_prepostdeclared2(void); + +void extern_undeclared(void){} + +void extern_predeclared(void); +void extern_predeclared(void){} + +void extern_postdeclared(void){} +void extern_postdeclared(void); + +void extern_prepostdeclared(void); +void extern_prepostdeclared(void){} +void extern_prepostdeclared(void); + +void extern_undeclared2(void){} + +void extern_predeclared2(void); +void extern_predeclared2(void); +void extern_predeclared2(void){} + +void extern_postdeclared2(void){} +void extern_postdeclared2(void); +void extern_postdeclared2(void); + + +extern inline void noinst_extern_inline_undeclared(void){} + +extern inline void noinst_extern_inline_postdeclared(void){} +inline void noinst_extern_inline_postdeclared(void); + +extern inline void noinst_extern_inline_postdeclared2(void){} +inline void noinst_extern_inline_postdeclared2(void); +inline void noinst_extern_inline_postdeclared2(void); + +extern inline void inst_extern_inline_postdeclared(void){} +extern inline void inst_extern_inline_postdeclared(void); +inline void inst2_extern_inline_postdeclared(void){} +void inst2_extern_inline_postdeclared(void); + +void inst_extern_inline_predeclared(void); +extern inline void inst_extern_inline_predeclared(void){} +void inst2_extern_inline_predeclared(void); +inline void inst2_extern_inline_predeclared(void){} +extern inline void inst3_extern_inline_predeclared(void); +inline void inst3_extern_inline_predeclared(void){} + +static inline void noinst_static_inline_postdeclared(void){} +static inline void noinst_static_inline_postdeclared(void); +static inline void noinst2_static_inline_postdeclared(void){} +static void noinst2_static_inline_postdeclared(void); + +static void noinst_static_inline_predeclared(void); +static inline void noinst_static_inline_predeclared(void){} +static void noinst2_static_inline_predeclared(void); +static inline void noinst2_static_inline_predeclared(void){} + +static void static_func(void); +void static_func(void) { } + +inline void noinst_extern_inline_func(void); +void noinst_extern_inline_func(void) { } + +int main() +{ + inline_inline_undeclared(); inline_inline_predeclared(); inline_inline_postdeclared(); + inline_inline_undeclared2(); inline_inline_predeclared2(); inline_inline_postdeclared2(); + noinst_static_inline_predeclared(); + noinst2_static_inline_predeclared(); + noinst_static_inline_predeclared(); + noinst2_static_inline_predeclared(); + + void check_exports(); + check_exports(); + return 0; +} diff --git a/tinycc/tests/tests2/104_inline.expect b/tinycc/tests/tests2/104_inline.expect new file mode 100644 index 0000000..bdb0994 --- /dev/null +++ b/tinycc/tests/tests2/104_inline.expect @@ -0,0 +1,39 @@ +0 inline_inline_2decl_only +0 inline_inline_undeclared +0 inline_inline_predeclared +0 inline_inline_postdeclared +0 inline_inline_prepostdeclared +0 inline_inline_undeclared2 +0 inline_inline_predeclared2 +0 inline_inline_postdeclared2 +0 inline_inline_prepostdeclared2 +1 extern_extern_postdeclared +1 extern_extern_postdeclared2 +1 extern_extern_predeclared +1 extern_extern_predeclared2 +1 extern_extern_prepostdeclared +1 extern_extern_prepostdeclared2 +1 extern_extern_undeclared +1 extern_extern_undeclared2 +1 extern_postdeclared +1 extern_postdeclared2 +1 extern_predeclared +1 extern_predeclared2 +1 extern_prepostdeclared +1 extern_undeclared +1 extern_undeclared2 +1 inst2_extern_inline_postdeclared +1 inst2_extern_inline_predeclared +1 inst3_extern_inline_predeclared +1 inst_extern_inline_postdeclared +1 inst_extern_inline_predeclared +1 main +1 noinst_extern_inline_func +1 noinst_extern_inline_postdeclared +1 noinst_extern_inline_postdeclared2 +1 noinst_extern_inline_undeclared +0 noinst_static_inline_postdeclared +0 noinst2_static_inline_postdeclared +0 noinst_static_inline_predeclared +0 noinst2_static_inline_predeclared +0 static_func diff --git a/tinycc/tests/tests2/105_local_extern.c b/tinycc/tests/tests2/105_local_extern.c new file mode 100644 index 0000000..a248bb4 --- /dev/null +++ b/tinycc/tests/tests2/105_local_extern.c @@ -0,0 +1,12 @@ +extern int printf(const char *, ...); +void f(void); +void bar(void) { void f(void); f(); } +void foo(void) { extern void f(void); f(); } +void f(void) { printf("f\n"); } + +int main() +{ + bar(); + foo(); + return 0; +} diff --git a/tinycc/tests/tests2/105_local_extern.expect b/tinycc/tests/tests2/105_local_extern.expect new file mode 100644 index 0000000..445ae74 --- /dev/null +++ b/tinycc/tests/tests2/105_local_extern.expect @@ -0,0 +1,2 @@ +f +f diff --git a/tinycc/tests/tests2/106_versym.c b/tinycc/tests/tests2/106_versym.c new file mode 100644 index 0000000..dcce508 --- /dev/null +++ b/tinycc/tests/tests2/106_versym.c @@ -0,0 +1,18 @@ +#include <stdio.h> +#include <pthread.h> +#include <errno.h> + +int +main(void) +{ + int ret; + pthread_condattr_t attr; + pthread_cond_t condition; + + /* This test fails if symbol versioning does not work */ + pthread_condattr_init (&attr); + pthread_condattr_setpshared (&attr, PTHREAD_PROCESS_SHARED); + printf ("%s\n", pthread_cond_init (&condition, &attr) ? "fail":"ok"); + pthread_condattr_destroy (&attr); + return 0; +} diff --git a/tinycc/tests/tests2/106_versym.expect b/tinycc/tests/tests2/106_versym.expect new file mode 100644 index 0000000..9766475 --- /dev/null +++ b/tinycc/tests/tests2/106_versym.expect @@ -0,0 +1 @@ +ok diff --git a/tinycc/tests/tests2/107_stack_safe.c b/tinycc/tests/tests2/107_stack_safe.c new file mode 100644 index 0000000..479c84d --- /dev/null +++ b/tinycc/tests/tests2/107_stack_safe.c @@ -0,0 +1,13 @@ +extern int printf(const char *, ...); + +static void func_ull_ull(unsigned long long l1,unsigned long long l2){ +} + +int main() +{ + int a,b,c,d; + a=1;b=2;c=3;d=4; + func_ull_ull((unsigned long long)a/1.0,(unsigned long long)b/1.0); + printf("%d %d %d %d",a,b,c,d); + return 0; +} diff --git a/tinycc/tests/tests2/107_stack_safe.expect b/tinycc/tests/tests2/107_stack_safe.expect new file mode 100644 index 0000000..e9e9cd7 --- /dev/null +++ b/tinycc/tests/tests2/107_stack_safe.expect @@ -0,0 +1 @@ +1 2 3 4
\ No newline at end of file diff --git a/tinycc/tests/tests2/108_constructor.c b/tinycc/tests/tests2/108_constructor.c new file mode 100644 index 0000000..145d0da --- /dev/null +++ b/tinycc/tests/tests2/108_constructor.c @@ -0,0 +1,20 @@ +extern int write (int fd, void *buf, int len); + +static void __attribute__ ((constructor)) +testc (void) +{ + write (1, "constructor\n", 12); +} + +static void __attribute__ ((destructor)) +testd (void) +{ + write (1, "destructor\n", 11); +} + +int +main (void) +{ + write (1, "main\n", 5); + return 0; +} diff --git a/tinycc/tests/tests2/108_constructor.expect b/tinycc/tests/tests2/108_constructor.expect new file mode 100644 index 0000000..167ca51 --- /dev/null +++ b/tinycc/tests/tests2/108_constructor.expect @@ -0,0 +1,3 @@ +constructor +main +destructor diff --git a/tinycc/tests/tests2/109_float_struct_calling.c b/tinycc/tests/tests2/109_float_struct_calling.c new file mode 100644 index 0000000..90fc045 --- /dev/null +++ b/tinycc/tests/tests2/109_float_struct_calling.c @@ -0,0 +1,24 @@ +#include <stdio.h> + +/* This test used to fail on x86_64 on linux with sse registers */ + +struct Point { + float x; + float y; +}; + +struct Rect { + struct Point top_left; + struct Point size; +}; + +float foo(struct Point p, struct Rect r) { + return r.size.x; +} + +int main(int argc, char **argv) { + struct Point p = {1, 2}; + struct Rect r = {{3, 4}, {5, 6}}; + printf("%f\n", foo(p, r)); + return 0; +} diff --git a/tinycc/tests/tests2/109_float_struct_calling.expect b/tinycc/tests/tests2/109_float_struct_calling.expect new file mode 100644 index 0000000..eaa6787 --- /dev/null +++ b/tinycc/tests/tests2/109_float_struct_calling.expect @@ -0,0 +1 @@ +5.000000 diff --git a/tinycc/tests/tests2/10_pointer.c b/tinycc/tests/tests2/10_pointer.c new file mode 100644 index 0000000..0177f4d --- /dev/null +++ b/tinycc/tests/tests2/10_pointer.c @@ -0,0 +1,40 @@ +#include <stdio.h> + +struct ziggy +{ + int a; + int b; + int c; +} bolshevic; + +int main() +{ + int a; + int *b; + int c; + + a = 42; + b = &a; + printf("a = %d\n", *b); + + bolshevic.a = 12; + bolshevic.b = 34; + bolshevic.c = 56; + + printf("bolshevic.a = %d\n", bolshevic.a); + printf("bolshevic.b = %d\n", bolshevic.b); + printf("bolshevic.c = %d\n", bolshevic.c); + + struct ziggy *tsar = &bolshevic; + + printf("tsar->a = %d\n", tsar->a); + printf("tsar->b = %d\n", tsar->b); + printf("tsar->c = %d\n", tsar->c); + + b = &(bolshevic.b); + printf("bolshevic.b = %d\n", *b); + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/10_pointer.expect b/tinycc/tests/tests2/10_pointer.expect new file mode 100644 index 0000000..1e3c473 --- /dev/null +++ b/tinycc/tests/tests2/10_pointer.expect @@ -0,0 +1,8 @@ +a = 42 +bolshevic.a = 12 +bolshevic.b = 34 +bolshevic.c = 56 +tsar->a = 12 +tsar->b = 34 +tsar->c = 56 +bolshevic.b = 34 diff --git a/tinycc/tests/tests2/110_average.c b/tinycc/tests/tests2/110_average.c new file mode 100644 index 0000000..273b511 --- /dev/null +++ b/tinycc/tests/tests2/110_average.c @@ -0,0 +1,27 @@ +#include <stdio.h> + +typedef struct +{ + double average; + int count; +} +stats_type; + +static void +testc (stats_type *s, long long data) +{ + s->average = (s->average * s->count + data) / (s->count + 1); + s->count++; +} + +int main (void) +{ + stats_type s; + + s.average = 0; + s.count = 0; + testc (&s, 10); + testc (&s, 20); + printf ("%g %d\n", s.average, s.count); + return 0; +} diff --git a/tinycc/tests/tests2/110_average.expect b/tinycc/tests/tests2/110_average.expect new file mode 100644 index 0000000..4955335 --- /dev/null +++ b/tinycc/tests/tests2/110_average.expect @@ -0,0 +1 @@ +15 2 diff --git a/tinycc/tests/tests2/111_conversion.c b/tinycc/tests/tests2/111_conversion.c new file mode 100644 index 0000000..c0815e1 --- /dev/null +++ b/tinycc/tests/tests2/111_conversion.c @@ -0,0 +1,22 @@ +#include <stdio.h> + +union u { + unsigned long ul; + long double ld; +}; + +void +conv (union u *p) +{ + p->ul = (unsigned int) p->ld; +} + +int main (void) +{ + union u v; + + v.ld = 42; + conv (&v); + printf ("%lu\n", v.ul); + return 0; +} diff --git a/tinycc/tests/tests2/111_conversion.expect b/tinycc/tests/tests2/111_conversion.expect new file mode 100644 index 0000000..d81cc07 --- /dev/null +++ b/tinycc/tests/tests2/111_conversion.expect @@ -0,0 +1 @@ +42 diff --git a/tinycc/tests/tests2/112_backtrace.c b/tinycc/tests/tests2/112_backtrace.c new file mode 100644 index 0000000..0b596d0 --- /dev/null +++ b/tinycc/tests/tests2/112_backtrace.c @@ -0,0 +1,175 @@ +#include <stdio.h> + +/* ------------------------------------------------------- */ +#if defined test_backtrace_1 + +void f3() +{ + printf("* f3()\n"), fflush(stdout); + *(void**)0 = 0; +} +void f2() +{ + printf("* f2()\n"), fflush(stdout); + f3(); +} +void f1() +{ + printf("* f1()\n"), fflush(stdout); + f2(); +} +int main(int argc, char **argv) +{ + printf("* main\n"), fflush(stdout); + f1(); + printf("* exit main\n"), fflush(stdout); + return 0; +} + +/* ------------------------------------------------------- */ +#elif defined test_bcheck_1 + +struct s { int a,b,c,d,e; }; +struct s s[3]; +struct s *ps = s; +void f1() +{ + printf("* f1()\n"), fflush(stdout); + ps[3] = ps[2]; +} +int main(int argc, char **argv) +{ + printf("* main\n"), fflush(stdout); + f1(); + printf("* exit main\n"), fflush(stdout); + return 0; +} + +/* ------------------------------------------------------- */ +#elif defined test_tcc_backtrace_2 + +/* test custom backtrace and 'exit()' redirection */ +int tcc_backtrace(const char *fmt, ...); +void exit(int); + +void f2() +{ + printf("* f2()\n"); + printf("* exit f2\n"), fflush(stdout); + exit(34); +} +void f1() +{ + printf("* f1()\n"), fflush(stdout); + tcc_backtrace("Hello from %s!", "f1"); + f2(); +} +int main(int argc, char **argv) +{ + printf("* main\n"), fflush(stdout); + f1(); + printf("* exit main\n"), fflush(stdout); + return 0; +} + +/* ------------------------------------------------------- */ +#elif defined test_tcc_backtrace_3 + +/* this test should be run despite of the exit(34) above */ +int main(int argc, char **argv) +{ + printf("* main\n"), fflush(stdout); + return 1; +} + +/* ------------------------------------------------------- */ +#else +#include <stdlib.h> +#include <string.h> +char *strdup(); +int main() +{ + char pad1[10]; + char a[10]; + char pad2[10]; + char b[10]; + char pad3[10]; + memset (pad1, 0, sizeof(pad1)); + memset (pad2, 0, sizeof(pad2)); + memset (pad3, 0, sizeof(pad3)); + + memset (a, 'a', 10); + a[3] = 0; + a[9] = 0; + memset (b, 'b', 10); + +#if defined test_bcheck_100 + memcpy(&a[1],&b[0],10); +#elif defined test_bcheck_101 + memcpy(&a[0],&b[1],10); +#elif defined test_bcheck_102 + memcpy(&a[0],&a[3],4); +#elif defined test_bcheck_103 + memcpy(&a[3],&a[0],4); +#elif defined test_bcheck_104 + memcmp(&b[1],&b[0],10); +#elif defined test_bcheck_105 + memcmp(&b[0],&b[1],10); +#elif defined test_bcheck_106 + memmove(&b[1],&b[0],10); +#elif defined test_bcheck_107 + memmove(&b[0],&b[1],10); +#elif defined test_bcheck_108 + memset(&b[1],'b',10); +#elif defined test_bcheck_109 + strlen(&b[0]); +#elif defined test_bcheck_110 + strcpy(&a[7], &a[0]); +#elif defined test_bcheck_111 + strcpy(&a[0], &b[7]); +#elif defined test_bcheck_112 + strcpy(&a[0], &a[1]); +#elif defined test_bcheck_113 + strcpy(&a[2], &a[0]); +#elif defined test_bcheck_114 + strncpy(&a[7], &a[0], 10); +#elif defined test_bcheck_115 + strncpy(&a[0], &b[7], 10); +#elif defined test_bcheck_116 + strncpy(&a[0], &a[1], 10); +#elif defined test_bcheck_117 + strncpy(&a[2], &a[0], 10); +#elif defined test_bcheck_118 + strcmp(&b[2], &b[0]); +#elif defined test_bcheck_119 + strcmp(&b[0], &b[2]); +#elif defined test_bcheck_120 + strncmp(&b[5], &b[0], 10); +#elif defined test_bcheck_121 + strncmp(&b[0], &b[5], 10); +#elif defined test_bcheck_122 + strcat(&a[7], &a[0]); +#elif defined test_bcheck_123 + strcat(&a[0], &b[3]); +#elif defined test_bcheck_124 + strcat(&a[0], &a[4]); +#elif defined test_bcheck_125 + strcat(&a[3], &a[0]); +#elif defined test_bcheck_126 + strncat(&a[7], &a[0], 3); +#elif defined test_bcheck_127 + strncat(&a[0], &b[3], 8); +#elif defined test_bcheck_128 + strncat(&a[0], &a[4], 3); +#elif defined test_bcheck_129 + strncat(&a[3], &a[0], 10); +#elif defined test_bcheck_130 + strchr(&b[0], 'a'); +#elif defined test_bcheck_131 + strrchr(&b[0], 'a'); +#elif defined test_bcheck_132 + free(strdup(&b[0])); +#endif +} +/* ------------------------------------------------------- */ +#endif diff --git a/tinycc/tests/tests2/112_backtrace.expect b/tinycc/tests/tests2/112_backtrace.expect new file mode 100644 index 0000000..ec2c6b8 --- /dev/null +++ b/tinycc/tests/tests2/112_backtrace.expect @@ -0,0 +1,162 @@ +[test_backtrace_1] +* main +* f1() +* f2() +* f3() +112_backtrace.c:9: at f3: RUNTIME ERROR: invalid memory access +112_backtrace.c:14: by f2 +112_backtrace.c:19: by f1 +112_backtrace.c:24: by main +[returns 255] + +[test_bcheck_1] +* main +* f1() +112_backtrace.c:38: at f1: BCHECK: invalid pointer ........, size 0x? in memmove dest +112_backtrace.c:43: by main +[returns 255] + +[test_tcc_backtrace_2] +* main +* f1() +112_backtrace.c:64: at f1: Hello from f1! +112_backtrace.c:70: by main +* f2() +* exit f2 +[returns 34] + +[test_tcc_backtrace_3] +* main +[returns 1] + +[test_bcheck_100] +112_backtrace.c:107: at main: BCHECK: invalid pointer ........, size 0x? in memcpy dest +[returns 255] + +[test_bcheck_101] +112_backtrace.c:109: at main: BCHECK: invalid pointer ........, size 0x? in memcpy src +[returns 255] + +[test_bcheck_102] +112_backtrace.c:111: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in memcpy +[returns 255] + +[test_bcheck_103] +112_backtrace.c:113: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in memcpy +[returns 255] + +[test_bcheck_104] +112_backtrace.c:115: at main: BCHECK: invalid pointer ........, size 0x? in memcmp s1 +[returns 255] + +[test_bcheck_105] +112_backtrace.c:117: at main: BCHECK: invalid pointer ........, size 0x? in memcmp s2 +[returns 255] + +[test_bcheck_106] +112_backtrace.c:119: at main: BCHECK: invalid pointer ........, size 0x? in memmove dest +[returns 255] + +[test_bcheck_107] +112_backtrace.c:121: at main: BCHECK: invalid pointer ........, size 0x? in memmove src +[returns 255] + +[test_bcheck_108] +112_backtrace.c:123: at main: BCHECK: invalid pointer ........, size 0x? in memset +[returns 255] + +[test_bcheck_109] +112_backtrace.c:125: at main: BCHECK: invalid pointer ........, size 0x? in strlen +[returns 255] + +[test_bcheck_110] +112_backtrace.c:127: at main: BCHECK: invalid pointer ........, size 0x? in strcpy dest +[returns 255] + +[test_bcheck_111] +112_backtrace.c:129: at main: BCHECK: invalid pointer ........, size 0x? in strcpy src +[returns 255] + +[test_bcheck_112] +112_backtrace.c:131: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in strcpy +[returns 255] + +[test_bcheck_113] +112_backtrace.c:133: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in strcpy +[returns 255] + +[test_bcheck_114] +112_backtrace.c:135: at main: BCHECK: invalid pointer ........, size 0x? in strncpy dest +[returns 255] + +[test_bcheck_115] +112_backtrace.c:137: at main: BCHECK: invalid pointer ........, size 0x? in strncpy src +[returns 255] + +[test_bcheck_116] +112_backtrace.c:139: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in strncpy +[returns 255] + +[test_bcheck_117] +112_backtrace.c:141: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in strncpy +[returns 255] + +[test_bcheck_118] +112_backtrace.c:143: at main: BCHECK: invalid pointer ........, size 0x? in strcmp s1 +[returns 255] + +[test_bcheck_119] +112_backtrace.c:145: at main: BCHECK: invalid pointer ........, size 0x? in strcmp s2 +[returns 255] + +[test_bcheck_120] +112_backtrace.c:147: at main: BCHECK: invalid pointer ........, size 0x? in strncmp s1 +[returns 255] + +[test_bcheck_121] +112_backtrace.c:149: at main: BCHECK: invalid pointer ........, size 0x? in strncmp s2 +[returns 255] + +[test_bcheck_122] +112_backtrace.c:151: at main: BCHECK: invalid pointer ........, size 0x? in strcat dest +[returns 255] + +[test_bcheck_123] +112_backtrace.c:153: at main: BCHECK: invalid pointer ........, size 0x? in strcat dest +[returns 255] + +[test_bcheck_124] +112_backtrace.c:155: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in strcat +[returns 255] + +[test_bcheck_125] +112_backtrace.c:157: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in strcat +[returns 255] + +[test_bcheck_126] +112_backtrace.c:159: at main: BCHECK: invalid pointer ........, size 0x? in strncat dest +[returns 255] + +[test_bcheck_127] +112_backtrace.c:161: at main: BCHECK: invalid pointer ........, size 0x? in strncat dest +[returns 255] + +[test_bcheck_128] +112_backtrace.c:163: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in strncat +[returns 255] + +[test_bcheck_129] +112_backtrace.c:165: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in strncat +[returns 255] + +[test_bcheck_130] +112_backtrace.c:167: at main: BCHECK: invalid pointer ........, size 0x? in strchr +[returns 255] + +[test_bcheck_131] +112_backtrace.c:169: at main: BCHECK: invalid pointer ........, size 0x? in strrchr +[returns 255] + +[test_bcheck_132] +112_backtrace.c:171: at main: BCHECK: invalid pointer ........, size 0x? in strdup +[returns 255] diff --git a/tinycc/tests/tests2/113_btdll.c b/tinycc/tests/tests2/113_btdll.c new file mode 100644 index 0000000..8ae8981 --- /dev/null +++ b/tinycc/tests/tests2/113_btdll.c @@ -0,0 +1,43 @@ +int tcc_backtrace(const char*, ...); +#define hello() \ + tcc_backtrace("hello from %s() / %s:%d",__FUNCTION__,__FILE__,__LINE__) + +#ifndef _WIN32 +# define __declspec(n) +#endif + +#if DLL==1 +__declspec(dllexport) int f_1() +{ + hello(); + return 0; +} + + +#elif DLL==2 +__declspec(dllexport) int f_2() +{ + hello(); + return 0; +} + + +#else + +int f_1(); +int f_2(); +int f_main() +{ + hello(); + return 0; +} + +int main () +{ + f_1(); + f_2(); + f_main(); + return 0; +} + +#endif diff --git a/tinycc/tests/tests2/113_btdll.expect b/tinycc/tests/tests2/113_btdll.expect new file mode 100644 index 0000000..34de481 --- /dev/null +++ b/tinycc/tests/tests2/113_btdll.expect @@ -0,0 +1,6 @@ +113_btdll.c:12: at f_1: hello from f_1() / 113_btdll.c:12 +113_btdll.c:37: by main +113_btdll.c:20: at f_2: hello from f_2() / 113_btdll.c:20 +113_btdll.c:38: by main +113_btdll.c:31: at f_main: hello from f_main() / 113_btdll.c:31 +113_btdll.c:39: by main diff --git a/tinycc/tests/tests2/114_bound_signal.c b/tinycc/tests/tests2/114_bound_signal.c new file mode 100644 index 0000000..d11b146 --- /dev/null +++ b/tinycc/tests/tests2/114_bound_signal.c @@ -0,0 +1,143 @@ +#include <stdio.h> +#include <pthread.h> +#include <semaphore.h> +#include <signal.h> +#include <string.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> +#include <stdlib.h> +#include <errno.h> +#include <setjmp.h> + +static volatile int run = 1; +static sem_t sem; +static sem_t sem_child; + +static void +add (int n) +{ + int i; + int arr[n]; + + for (i = 0; i < n; i++) { + arr[i]++; + } + memset (&arr[0], 0, n * sizeof(int)); +} + +static void * +high_load (void *unused) +{ + while (run) { + add(10); + add(20); + } + return NULL; +} + +static void * +do_signal (void *unused) +{ + while (run) { + kill (getpid(), SIGUSR1); + while (sem_wait(&sem) < 0 && errno == EINTR); + } + return NULL; +} + +static void * +do_fork (void *unused) +{ + pid_t pid; + + while (run) { + switch ((pid = fork())) { + case 0: + add(1000); + add(2000); + exit(0); + break; + case -1: + return NULL; + default: + while (sem_wait(&sem_child) < 0 && errno == EINTR); + wait(NULL); + break; + } + } + return NULL; +} + +static void signal_handler(int sig) +{ + add(10); + add(20); + sem_post (&sem); +} + +static void child_handler(int sig) +{ + add(10); + add(20); + sem_post (&sem_child); +} + +int +main (void) +{ + int i; + pthread_t id1, id2, id3; + struct sigaction act; + sigjmp_buf sj; + sigset_t m; + time_t end; + + memset (&act, 0, sizeof (act)); + act.sa_handler = signal_handler; + act.sa_flags = 0; + sigemptyset (&act.sa_mask); + sigaction (SIGUSR1, &act, NULL); + act.sa_handler = child_handler; + sigaction (SIGCHLD, &act, NULL); + + printf ("start\n"); fflush(stdout); + + sem_init (&sem, 0, 0); + sem_init (&sem_child, 0, 0); + pthread_create(&id1, NULL, high_load, NULL); + pthread_create(&id2, NULL, do_signal, NULL); +#if !defined(__APPLE__) + pthread_create(&id3, NULL, do_fork, NULL); +#endif + + /* sleep does not work !!! */ + end = time(NULL) + 2; + while (time(NULL) < end) ; + run = 0; + + pthread_join(id1, NULL); + pthread_join(id2, NULL); +#if !defined(__APPLE__) + pthread_join(id3, NULL); +#endif + sem_destroy (&sem); + sem_destroy (&sem_child); + + printf ("end\n"); fflush(stdout); + + sigemptyset (&m); + sigprocmask (SIG_SETMASK, &m, NULL); + if (sigsetjmp (sj, 0) == 0) + { + sigaddset (&m, SIGUSR1); + sigprocmask (SIG_SETMASK, &m, NULL); + siglongjmp (sj, 1); + printf ("failed"); + return 1; + } + sigprocmask (SIG_SETMASK, NULL, &m); + if (!sigismember (&m, SIGUSR1)) + printf ("failed"); + return 0; +} diff --git a/tinycc/tests/tests2/114_bound_signal.expect b/tinycc/tests/tests2/114_bound_signal.expect new file mode 100644 index 0000000..5d0fb3b --- /dev/null +++ b/tinycc/tests/tests2/114_bound_signal.expect @@ -0,0 +1,2 @@ +start +end diff --git a/tinycc/tests/tests2/115_bound_setjmp.c b/tinycc/tests/tests2/115_bound_setjmp.c new file mode 100644 index 0000000..793db58 --- /dev/null +++ b/tinycc/tests/tests2/115_bound_setjmp.c @@ -0,0 +1,172 @@ +#include <stdio.h> +#include <string.h> +#include <setjmp.h> + +#define TST int i, a[2], b[2]; \ + for (i = 0; i < 2; i++) a[i] = 0; \ + for (i = 0; i < 2; i++) b[i] = 0 + +static jmp_buf jmp; + +static void tst1 (void) +{ + TST; + longjmp(jmp, 1); +} + +static void tst2(void) +{ + jmp_buf jmp; + + setjmp (jmp); + TST; + tst1(); +} + +static void tst3 (jmp_buf loc) +{ + TST; + longjmp(loc, 1); +} + +static void tst4(jmp_buf loc) +{ + jmp_buf jmp; + + setjmp (jmp); + TST; + tst3(loc); +} + +static void tst (void) +{ + jmp_buf loc; + static int cnt; + + cnt = 0; + if (setjmp (jmp) == 0) { + TST; + tst2(); + } + else { + cnt++; + } + if (setjmp (loc) == 0) { + TST; + tst4(loc); + } + else { + cnt++; + } + if (cnt != 2) + printf ("incorrect cnt %d\n", cnt); +} + +static jmp_buf buf1; +static jmp_buf buf2; +static int *p; +static int n_x = 6; +static int g_counter; + +static void stack (void) +{ + static int counter; + static int way_point1; + static int way_point2; + + counter = 0; + way_point1 = 3; + way_point2 = 2; + g_counter = 0; + if (setjmp (buf1) != 101) { + int a[n_x]; + g_counter++; + p = &a[0]; + if (g_counter < 5) + longjmp (buf1, 2); + else if (g_counter == 5) + longjmp (buf1, 101); + else { + setjmp (buf2); + longjmp (buf1, 101); + } + } + + way_point1--; + + if (counter == 0) { + counter++; + { + int a[n_x]; + g_counter++; + p = &a[0]; + if (g_counter < 5) + longjmp (buf1, 2); + else if (g_counter == 5) + longjmp (buf1, 101); + else { + setjmp (buf2); + longjmp (buf1, 101); + } + } + } + + way_point2--; + + if (counter == 1) { + counter++; + longjmp (buf2, 2); + } + + if (!(way_point1 == 0 && way_point2 == 0 && + g_counter == 6 && counter == 2)) + printf ("Failed %d %d %d %d\n", + way_point1, way_point2, g_counter, counter); +} + +static jmp_buf env; +static int last_value; + +static void jump (int val) +{ + longjmp (env, val); +} + +static void check (void) +{ + int value; + + last_value = -1; + value = setjmp (env); + if (value != last_value + 1) { + printf ("incorrect value %d %d\n", + value, last_value + 1); + return; + } + last_value = value; + switch (value) { +#if !(defined(__FreeBSD__) || defined(__NetBSD__)) + /* longjmp(jmp_buf, 0) not supported */ + case 0: + jump (0); +#endif + default: + if (value < 10) + jump (value + 1); + } +} + +int +main (void) +{ + int i; + + for (i = 0; i < 10; i++) { + tst(); + stack(); + check(); + } + return 0; +} + + diff --git a/tinycc/tests/tests2/115_bound_setjmp.expect b/tinycc/tests/tests2/115_bound_setjmp.expect new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tinycc/tests/tests2/115_bound_setjmp.expect diff --git a/tinycc/tests/tests2/116_bound_setjmp2.c b/tinycc/tests/tests2/116_bound_setjmp2.c new file mode 100644 index 0000000..151114d --- /dev/null +++ b/tinycc/tests/tests2/116_bound_setjmp2.c @@ -0,0 +1,84 @@ +#include <stdio.h> +#include <string.h> +#include <setjmp.h> +#if !defined(_WIN32) +#include <pthread.h> +#else +#include <windows.h> +#endif + +#define SIZE 10 +#define COUNT 10 + +#define TST int i, a[2], b[2]; \ + for (i = 0; i < 2; i++) a[i] = 0; \ + for (i = 0; i < 2; i++) b[i] = 0 + +static int count[SIZE]; + +static void tst1 (jmp_buf loc) +{ + TST; + longjmp(loc, 1); +} + +static void tst2(jmp_buf loc) +{ + jmp_buf jmp; + + setjmp (jmp); + TST; + tst1(loc); +} + +static void *tst (void * index) +{ + jmp_buf loc; + int i = *(int *) index; + static int v[SIZE]; + + for (v[i] = 0; v[i] < COUNT; v[i]++) { + if (setjmp (loc) == 0) { + TST; + tst2(loc); + } + else { + count[i]++; + } + i = *(int *) index; + } + return NULL; +} + +int +main (void) +{ + int i; +#if !defined(_WIN32) + pthread_t id[SIZE]; +#else + HANDLE id[SIZE]; +#endif + int index[SIZE]; + + for (i = 0; i < SIZE; i++) { + index[i] = i; +#if !defined(_WIN32) + pthread_create (&id[i], NULL, tst, (void *) &index[i]); +#else + id[i] = CreateThread(NULL, 8192, (LPTHREAD_START_ROUTINE) tst, (void *) &index[i], 0, NULL); +#endif + } + for (i = 0; i < SIZE; i++) { +#if !defined(_WIN32) + pthread_join (id[i], NULL); +#else + WaitForSingleObject(id[i], INFINITE); +#endif + } + for (i = 0; i < SIZE; i++) { + if (count[i] != COUNT) + printf ("error: %d %d\n", i, count[i]); + } + return 0; +} diff --git a/tinycc/tests/tests2/116_bound_setjmp2.expect b/tinycc/tests/tests2/116_bound_setjmp2.expect new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tinycc/tests/tests2/116_bound_setjmp2.expect diff --git a/tinycc/tests/tests2/117_builtins.c b/tinycc/tests/tests2/117_builtins.c new file mode 100644 index 0000000..b57a73e --- /dev/null +++ b/tinycc/tests/tests2/117_builtins.c @@ -0,0 +1,94 @@ +#include <stdio.h> + +struct big_struct { char a[262144]; }; + +static const char str[] = "abcdefghijklmnopqrstuvwxyz"; + +int +main (void) +{ + char *p; + char tmp[100]; + int r = 0; + +#if defined __TCC_BCHECK__ + printf("BOUNDS ON:\n"); +#else + printf("BOUNDS OFF:\n"); +#endif + + if (r != 0) + __builtin_abort(); + + r = (__builtin_offsetof(struct big_struct, a) != 0); + printf(" 1:%d", !r); + + p = __builtin_memcpy (tmp, str, sizeof(str)); + r = (p != tmp); + printf(" 2:%d", !r); + + r = __builtin_memcmp (p, str, sizeof(str)); + printf(" 3:%d", !r); + + p = __builtin_memmove(tmp, str, sizeof(str)); + r = (__builtin_memcmp (p, str, sizeof(str))); + printf(" 4:%d", !r); + + p = __builtin_memset(tmp, 0, sizeof (tmp)); + r = (p != tmp || tmp[0] != 0 || tmp[99] != 0); + printf(" 5:%d", !r); + + r = (__builtin_strlen(str) != sizeof(str) - 1); + printf(" 6:%d", !r); + + p = __builtin_strcpy(tmp, str); + r = (__builtin_memcmp (p, str, sizeof(str))); + printf(" 7:%d", !r); + + p = __builtin_strncpy(tmp, str, sizeof(str)); + r = (__builtin_memcmp (p, str, sizeof(str))); + printf(" 8:%d", !r); + + r = (__builtin_strcmp (p, str)); + printf(" 9:%d", !r); + + r = (__builtin_strncmp (p, str, sizeof(str))); + printf(" 10:%d", !r); + + tmp[0] = '\0'; + p = __builtin_strcat(tmp, str); + r = (__builtin_memcmp (p, str, sizeof(str))); + printf(" 11:%d", !r); + + tmp[0] = '\0'; + p = __builtin_strncat(tmp, str, __builtin_strlen(str)); + r = (__builtin_memcmp (p, str, sizeof(str))); + printf(" 12:%d", !r); + + r = (__builtin_strchr(p, 'z') != &p[25]); + printf(" 13:%d", !r); + + r = (__builtin_strrchr(p, 'z') != &p[25]); + printf(" 14:%d", !r); + + p = __builtin_strdup (str); + r = (__builtin_memcmp (p, str, sizeof(str))); + printf(" 15:%d", !r); + __builtin_free(p); + + p = __builtin_malloc (100); + __builtin_memset(p, 0, 100); + p = __builtin_realloc (p, 1000); + __builtin_memset(p, 0, 1000); + __builtin_free(p); + + p = __builtin_calloc(10, 10); + __builtin_memset(p, 0, 100); + __builtin_free(p); + +#if defined(__i386__) || defined(__x86_64__) + p = __builtin_alloca(100); + __builtin_memset(p, 0, 100); +#endif + printf("\n"); +} diff --git a/tinycc/tests/tests2/117_builtins.expect b/tinycc/tests/tests2/117_builtins.expect new file mode 100644 index 0000000..f2c78ba --- /dev/null +++ b/tinycc/tests/tests2/117_builtins.expect @@ -0,0 +1,4 @@ +BOUNDS OFF: + 1:1 2:1 3:1 4:1 5:1 6:1 7:1 8:1 9:1 10:1 11:1 12:1 13:1 14:1 15:1 +BOUNDS ON: + 1:1 2:1 3:1 4:1 5:1 6:1 7:1 8:1 9:1 10:1 11:1 12:1 13:1 14:1 15:1 diff --git a/tinycc/tests/tests2/118_switch.c b/tinycc/tests/tests2/118_switch.c new file mode 100644 index 0000000..789dd06 --- /dev/null +++ b/tinycc/tests/tests2/118_switch.c @@ -0,0 +1,75 @@ +#include <limits.h> +#include <stdio.h> +#include <stdlib.h> + +int ibdg(long long n) +{ + switch (n) { + case 1LL ... 9LL: return 1; + case 10LL ... 99LL: return 2; + case 100LL ... 999LL: return 3; + case 1000LL ... 9999LL: return 4; + case 10000LL ... 99999LL: return 5; + case 100000LL ... 999999LL: return 6; + case 1000000LL ... 9999999LL: return 7; + case 10000000LL ... 99999999LL: return 8; + case 100000000LL ... 999999999LL: return 9; + case 1000000000LL ... 9999999999LL: return 10; + case 10000000000LL ... 99999999999LL: return 11; + case 100000000000LL ... 999999999999LL: return 12; + case 1000000000000LL ... 9999999999999LL: return 13; + case 10000000000000LL ... 99999999999999LL: return 14; + case 100000000000000LL ... 999999999999999LL: return 15; + case 1000000000000000LL ... 9999999999999999LL: return 16; + case 10000000000000000LL ... 99999999999999999LL: return 17; + case 100000000000000000LL ... 999999999999999999LL: return 18; + case 1000000000000000000LL ... 9223372036854775807LL: return 19; + case -9223372036854775807LL-1LL ... -1LL: return 20; + } + return 0; +} + +int ubdg(unsigned long long n) +{ + switch (n) { + case 1ULL ... 9ULL: return 1; + case 10ULL ... 99ULL: return 2; + case 100ULL ... 999ULL: return 3; + case 1000ULL ... 9999ULL: return 4; + case 10000ULL ... 99999ULL: return 5; + case 100000ULL ... 999999ULL: return 6; + case 1000000ULL ... 9999999ULL: return 7; + case 10000000ULL ... 99999999ULL: return 8; + case 100000000ULL ... 999999999ULL: return 9; + case 1000000000ULL ... 9999999999ULL: return 10; + case 10000000000ULL ... 99999999999ULL: return 11; + case 100000000000ULL ... 999999999999ULL: return 12; + case 1000000000000ULL ... 9999999999999ULL: return 13; + case 10000000000000ULL ... 99999999999999ULL: return 14; + case 100000000000000ULL ... 999999999999999ULL: return 15; + case 1000000000000000ULL ... 9999999999999999ULL: return 16; + case 10000000000000000ULL ... 99999999999999999ULL: return 17; + case 100000000000000000ULL ... 999999999999999999ULL: return 18; + case 1000000000000000000ULL ... 9999999999999999999ULL: return 19; + case 10000000000000000000ULL ... 18446744073709551615ULL: return 20; + } + return 0; +} + +int main(int argc, char **argv) +{ + unsigned int i; + unsigned long long v = 1; + + v = 1; + for (i = 1; i <= 20; i++) { + printf("%lld : %d\n", (long long) v, ibdg((long long)v)); + v *= 10; + } + v = 1; + for (i = 1; i <= 20; i++) { + printf("%llu : %d\n", v, ubdg(v)); + v *= 10; + } + return 0; +} diff --git a/tinycc/tests/tests2/118_switch.expect b/tinycc/tests/tests2/118_switch.expect new file mode 100644 index 0000000..4155eb4 --- /dev/null +++ b/tinycc/tests/tests2/118_switch.expect @@ -0,0 +1,40 @@ +1 : 1 +10 : 2 +100 : 3 +1000 : 4 +10000 : 5 +100000 : 6 +1000000 : 7 +10000000 : 8 +100000000 : 9 +1000000000 : 10 +10000000000 : 11 +100000000000 : 12 +1000000000000 : 13 +10000000000000 : 14 +100000000000000 : 15 +1000000000000000 : 16 +10000000000000000 : 17 +100000000000000000 : 18 +1000000000000000000 : 19 +-8446744073709551616 : 20 +1 : 1 +10 : 2 +100 : 3 +1000 : 4 +10000 : 5 +100000 : 6 +1000000 : 7 +10000000 : 8 +100000000 : 9 +1000000000 : 10 +10000000000 : 11 +100000000000 : 12 +1000000000000 : 13 +10000000000000 : 14 +100000000000000 : 15 +1000000000000000 : 16 +10000000000000000 : 17 +100000000000000000 : 18 +1000000000000000000 : 19 +10000000000000000000 : 20 diff --git a/tinycc/tests/tests2/119_random_stuff.c b/tinycc/tests/tests2/119_random_stuff.c new file mode 100644 index 0000000..0b7a4e5 --- /dev/null +++ b/tinycc/tests/tests2/119_random_stuff.c @@ -0,0 +1,120 @@ +#include <stdio.h> + +struct big_struct { char a[262144]; }; + +static const char str[] = "abcdefghijklmnopqrstuvwxyz"; + +void tst_branch(void) +{ + printf("tst_branch --"); + goto *&&a; + printf (" dummy"); +a: ; + printf(" --\n"); +} + +void tst_void_ptr(void *pv, int i) +{ + i ? *pv : *pv; // dr106 +} + +void tst_shift(void) +{ + int i = 1; + long long l = 1; + i = i << 32; // illegal. just test + l = l << 64; // illegal. just test +} + +#if !defined(_WIN32) +#include <sys/mman.h> + +void tst_const_addr(void) +{ + void *addr = mmap ((void *)0x20000000, 4096, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_ANONYMOUS, -1, 0); + if (addr != (void *) -1) { + *(int *)0x20000000 += 42; + munmap (addr, 4096); + } +} +#endif + +struct zero_struct {}; + +struct zero_struct tst_zero_struct(void) +{ + struct zero_struct ret; + return ret; +} + +struct big_struct tst_big(struct big_struct tst) +{ + return tst; +} + +void tst_adr (int (*fp)(char *, const char *, ...)) +{ + char buf[10]; + (*fp)(buf, "%.0f", 5.0); + printf("tst_adr %s\n", buf); +} + +int tst(void) +{ + long long value = 3; + return -value; +} + +void tst_compare(void) +{ + /* This failed on risc64 */ + printf ("tst_compare: %s\n", tst() > 0 ? "error" : "ok"); +} + +#pragma pack(1) +struct S { int d:24; int f:14; } i, j; +#pragma pack() + +void tst_pack (void) +{ + i.f = 5; j.f = 5; + printf("tst_pack: j.f = %d, i.f = %d\n", j.f, i.f); +} + +void tst_cast(void) +{ + signed char c = (signed char) 0xaaaaaaaa; + int r = (unsigned short) c ^ (signed char) 0x99999999; + printf ("schar to ushort cast: %x\n", r); +} + +struct { + int (*print)(const char *format, ...); +} tst_indir = { + printf +}; + +void tst_indir_func(void) +{ + tst_indir.print("tst_indir_func %d\n", 10); +} + +int +main (void) +{ + struct big_struct big; + + tst_branch(); + tst_shift(); + tst_void_ptr(&big.a[0], 0); +#if !defined(_WIN32) + tst_const_addr(); +#endif + tst_zero_struct(); + tst_big(big); + tst_adr(&sprintf); + tst_compare(); + tst_pack(); + tst_cast(); + tst_indir_func(); +} diff --git a/tinycc/tests/tests2/119_random_stuff.expect b/tinycc/tests/tests2/119_random_stuff.expect new file mode 100644 index 0000000..3bd4a87 --- /dev/null +++ b/tinycc/tests/tests2/119_random_stuff.expect @@ -0,0 +1,6 @@ +tst_branch -- -- +tst_adr 5 +tst_compare: ok +tst_pack: j.f = 5, i.f = 5 +schar to ushort cast: ffff0033 +tst_indir_func 10 diff --git a/tinycc/tests/tests2/11_precedence.c b/tinycc/tests/tests2/11_precedence.c new file mode 100644 index 0000000..845b6bf --- /dev/null +++ b/tinycc/tests/tests2/11_precedence.c @@ -0,0 +1,41 @@ +//#include <stdio.h> +extern int printf(const char *, ...); + +int main() +{ + int a; + int b; + int c; + int d; + int e; + int f; + int x; + int y; + + a = 12; + b = 34; + c = 56; + d = 78; + e = 0; + f = 1; + + printf("%d\n", c + d); + printf("%d\n", (y = c + d)); + printf("%d\n", e || e && f); + printf("%d\n", e || f && f); + printf("%d\n", e && e || f); + printf("%d\n", e && f || f); + printf("%d\n", a && f | f); + printf("%d\n", a | b ^ c & d); + printf("%d, %d\n", a == a, a == b); + printf("%d, %d\n", a != a, a != b); + printf("%d\n", a != b && c != d); + printf("%d\n", a + b * c / f); + printf("%d\n", a + b * c / f); + printf("%d\n", (4 << 4)); + printf("%d\n", (64 >> 4)); + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/11_precedence.expect b/tinycc/tests/tests2/11_precedence.expect new file mode 100644 index 0000000..b692396 --- /dev/null +++ b/tinycc/tests/tests2/11_precedence.expect @@ -0,0 +1,15 @@ +134 +134 +0 +1 +1 +1 +1 +46 +1, 0 +0, 1 +1 +1916 +1916 +64 +4 diff --git a/tinycc/tests/tests2/120+_alias.c b/tinycc/tests/tests2/120+_alias.c new file mode 100644 index 0000000..8f29d8d --- /dev/null +++ b/tinycc/tests/tests2/120+_alias.c @@ -0,0 +1,15 @@ +extern int printf (const char *, ...); +extern void target(void); +extern void alias_for_target(void); +extern void asm_for_target(void); + +void inunit2(void); + +void inunit2(void) +{ + target(); + alias_for_target(); + /* This symbol is not supposed to be available in this unit: + asm_for_target(); + */ +} diff --git a/tinycc/tests/tests2/120_alias.c b/tinycc/tests/tests2/120_alias.c new file mode 100644 index 0000000..5bead0f --- /dev/null +++ b/tinycc/tests/tests2/120_alias.c @@ -0,0 +1,29 @@ +/* Check semantics of various constructs to generate renamed symbols. */ +extern int printf (const char *, ...); +void target(void); +void target(void) { + printf("in target function\n"); +} + +void alias_for_target(void) __attribute__((alias("target"))); +#ifdef __leading_underscore +void asm_for_target(void) __asm__("_target"); +#else +void asm_for_target(void) __asm__("target"); +#endif + +/* This is not supposed to compile, alias targets must be defined in the + same unit. In TCC they even must be defined before the reference +void alias_for_undef(void) __attribute__((alias("undefined"))); +*/ + +extern void inunit2(void); + +int main(void) +{ + target(); + alias_for_target(); + asm_for_target(); + inunit2(); + return 0; +} diff --git a/tinycc/tests/tests2/120_alias.expect b/tinycc/tests/tests2/120_alias.expect new file mode 100644 index 0000000..021e3f0 --- /dev/null +++ b/tinycc/tests/tests2/120_alias.expect @@ -0,0 +1,5 @@ +in target function +in target function +in target function +in target function +in target function diff --git a/tinycc/tests/tests2/121_struct_return.c b/tinycc/tests/tests2/121_struct_return.c new file mode 100644 index 0000000..147761b --- /dev/null +++ b/tinycc/tests/tests2/121_struct_return.c @@ -0,0 +1,35 @@ +#include <stdio.h> + +typedef struct { + int data[4]; + double d1; + double d2; +} Node; + +Node init(Node self) { + self.data[0] = 0; + self.data[1] = 1; + self.data[2] = 2; + self.data[3] = 3; + self.d1 = 1234; + self.d2 = 2345; + return self; +} + +void dummy(Node self) { +} + +void print_data(Node data) { + printf ("%d %d %d %d %g %g\n", + data.data[0], data.data[1], data.data[2], data.data[3], + data.d1, data.d2); +} + +int main(void) { + /* This code resulted in a bounds checking error */ + Node data; + dummy (data); + char val; + data = init (data); + print_data(data); +} diff --git a/tinycc/tests/tests2/121_struct_return.expect b/tinycc/tests/tests2/121_struct_return.expect new file mode 100644 index 0000000..fa68b11 --- /dev/null +++ b/tinycc/tests/tests2/121_struct_return.expect @@ -0,0 +1 @@ +0 1 2 3 1234 2345 diff --git a/tinycc/tests/tests2/122_vla_reuse.c b/tinycc/tests/tests2/122_vla_reuse.c new file mode 100644 index 0000000..feb47de --- /dev/null +++ b/tinycc/tests/tests2/122_vla_reuse.c @@ -0,0 +1,31 @@ +#include <stdio.h> + +int +main (void) +{ + int n = 0; + int first=1; + int *p[101]; + if (0) { + lab:; + } + int x[n % 100 + 1]; + if (first == 0) { + if (&x[0] != p[n % 100 + 1]) { + printf ("ERROR: %p %p\n", &x[0], p[n % 100 + 1]); + return(1); + } + } + else { + p[n % 100 + 1] = &x[0]; + first = n < 100; + } + x[0] = 1; + x[n % 100] = 2; + n++; + if (n < 100000) + goto lab; + printf ("OK\n"); + return 0; +} + diff --git a/tinycc/tests/tests2/122_vla_reuse.expect b/tinycc/tests/tests2/122_vla_reuse.expect new file mode 100644 index 0000000..d86bac9 --- /dev/null +++ b/tinycc/tests/tests2/122_vla_reuse.expect @@ -0,0 +1 @@ +OK diff --git a/tinycc/tests/tests2/123_vla_bug.c b/tinycc/tests/tests2/123_vla_bug.c new file mode 100644 index 0000000..6d92c27 --- /dev/null +++ b/tinycc/tests/tests2/123_vla_bug.c @@ -0,0 +1,40 @@ +typedef __SIZE_TYPE__ size_t; +extern int printf(const char*, ...); +extern size_t strlen(const char*); +char str[] = "blabla"; +int g; +int main() +{ + //char helpme[strlen(str) + 1]; + int i = 0; +#if 0 + if (g) { + char buf[strlen(str) + 10]; + buf[0] = 0; + } +alabel: + printf("default: i = %d\n", i); +#else + for (i = 0; i < 5; i++) { + switch (i) { + case 10: + if (g) { + char buf[strlen(str) + 10]; + buf[0] = 0; + goto do_cmd; + } + break; + case 1: + printf("reached 3\n"); + do_cmd: + printf("after do_cmd"); + break; + default: + g++; + printf("default: i = %d\n", i); + break; + } + } +#endif + return 0; +} diff --git a/tinycc/tests/tests2/123_vla_bug.expect b/tinycc/tests/tests2/123_vla_bug.expect new file mode 100644 index 0000000..2468f80 --- /dev/null +++ b/tinycc/tests/tests2/123_vla_bug.expect @@ -0,0 +1,5 @@ +default: i = 0 +reached 3 +after do_cmddefault: i = 2 +default: i = 3 +default: i = 4 diff --git a/tinycc/tests/tests2/124_atomic_counter.c b/tinycc/tests/tests2/124_atomic_counter.c new file mode 100644 index 0000000..67a500a --- /dev/null +++ b/tinycc/tests/tests2/124_atomic_counter.c @@ -0,0 +1,152 @@ +#include <stddef.h> +#include <stdint.h> +#include <stdlib.h> +#include <stdio.h> +#include <pthread.h> +#include <stdatomic.h> + +#define NR_THREADS 16 +#define NR_STEPS ((uint32_t)UINT16_MAX) + +#define BUG_ON(COND) \ + do { \ + if (!!(COND)) \ + abort(); \ + } while (0) + +#if defined __x86_64__ || defined __aarch64__ || defined __riscv +#define HAS_64BITS +#endif + +typedef struct { + atomic_flag flag; + atomic_uchar uc; + atomic_ushort us; + atomic_uint ui; +#ifdef HAS_64BITS + atomic_size_t ul; +#endif +} counter_type; + +static +void *adder_simple(void *arg) +{ + size_t step; + counter_type *counter = arg; + + for (step = 0; step < NR_STEPS; ++step) { + atomic_fetch_add_explicit(&counter->uc, 1, memory_order_relaxed); + atomic_fetch_add_explicit(&counter->us, 1, memory_order_relaxed); + atomic_fetch_add_explicit(&counter->ui, 1, memory_order_relaxed); +#ifdef HAS_64BITS + atomic_fetch_add_explicit(&counter->ul, 1, memory_order_relaxed); +#endif + } + + return NULL; +} + +static +void *adder_cmpxchg(void *arg) +{ + size_t step; + counter_type *counter = arg; + + for (step = 0; step < NR_STEPS; ++step) { + unsigned char xchgc; + unsigned short xchgs; + unsigned int xchgi; +#ifdef HAS_64BITS + size_t xchgl; +#endif + unsigned char cmpc = atomic_load_explicit(&counter->uc, memory_order_relaxed); + unsigned short cmps = atomic_load_explicit(&counter->us, memory_order_relaxed); + unsigned int cmpi = atomic_load_explicit(&counter->ui, memory_order_relaxed); +#ifdef HAS_64BITS + size_t cmpl = atomic_load_explicit(&counter->ul, memory_order_relaxed); +#endif + + do { + xchgc = (cmpc + 1); + } while (!atomic_compare_exchange_strong_explicit(&counter->uc, + &cmpc, xchgc, memory_order_relaxed, memory_order_relaxed)); + do { + xchgs = (cmps + 1); + } while (!atomic_compare_exchange_strong_explicit(&counter->us, + &cmps, xchgs, memory_order_relaxed, memory_order_relaxed)); + do { + xchgi = (cmpi + 1); + } while (!atomic_compare_exchange_strong_explicit(&counter->ui, + &cmpi, xchgi, memory_order_relaxed, memory_order_relaxed)); +#ifdef HAS_64BITS + do { + xchgl = (cmpl + 1); + } while (!atomic_compare_exchange_strong_explicit(&counter->ul, + &cmpl, xchgl, memory_order_relaxed, memory_order_relaxed)); +#endif + } + + return NULL; +} + +static +void *adder_test_and_set(void *arg) +{ + size_t step; + counter_type *counter = arg; + + for (step = 0; step < NR_STEPS; ++step) { + while (atomic_flag_test_and_set(&counter->flag)); + ++counter->uc; + ++counter->us; + ++counter->ui; +#ifdef HAS_64BITS + ++counter->ul; +#endif + atomic_flag_clear(&counter->flag); + } + + return NULL; +} + +static +void atomic_counter_test(void *(*adder)(void *arg)) +{ + size_t index; + counter_type counter; + pthread_t thread[NR_THREADS]; + + atomic_flag_clear(&counter.flag); + atomic_init(&counter.uc, 0); + atomic_init(&counter.us, 0); + atomic_init(&counter.ui, 0); +#ifdef HAS_64BITS + atomic_init(&counter.ul, 0); +#endif + + for (index = 0; index < NR_THREADS; ++index) + BUG_ON(pthread_create(&thread[index], NULL, adder, (void *)&counter)); + + for (index = 0; index < NR_THREADS; ++index) + BUG_ON(pthread_join(thread[index], NULL)); + + if (atomic_load(&counter.uc) == ((NR_THREADS * NR_STEPS) & 0xffu) + && atomic_load(&counter.us) == ((NR_THREADS * NR_STEPS) & 0xffffu) + && atomic_load(&counter.ui) == (NR_THREADS * NR_STEPS) +#ifdef HAS_64BITS + && atomic_load(&counter.ul) == (NR_THREADS * NR_STEPS) +#endif + ) + printf("SUCCESS\n"); + else + printf("FAILURE\n"); +} + +int main(void) +{ + atomic_counter_test(adder_simple); + atomic_counter_test(adder_cmpxchg); + atomic_counter_test(adder_test_and_set); + + return 0; +} diff --git a/tinycc/tests/tests2/124_atomic_counter.expect b/tinycc/tests/tests2/124_atomic_counter.expect new file mode 100644 index 0000000..21667a7 --- /dev/null +++ b/tinycc/tests/tests2/124_atomic_counter.expect @@ -0,0 +1,3 @@ +SUCCESS +SUCCESS +SUCCESS diff --git a/tinycc/tests/tests2/125_atomic_misc.c b/tinycc/tests/tests2/125_atomic_misc.c new file mode 100644 index 0000000..2d10631 --- /dev/null +++ b/tinycc/tests/tests2/125_atomic_misc.c @@ -0,0 +1,227 @@ +#include <stdatomic.h> +int printf(const char*,...); + +#if defined test_atomic_compare_exchange +int main() +{ + _Atomic int a = 12; + int b = 77; + int r; + + atomic_store(&a, b + 0); + r = atomic_compare_exchange_strong(&a, &b, 99); + printf("%d %d %d\n", r, a, b); + + atomic_store(&a, b + 3); + r = atomic_compare_exchange_strong(&a, &b, 99); + printf("%d %d %d\n", r, a, b); + + atomic_store(&a, b + 5); + r = atomic_exchange(&a, 33); + printf("%d %d %d\n", r, a, b); + + atomic_store(&a, b + 10); + r = atomic_exchange(&a, 66); + printf("%d %d %d\n", r, a, b); + + return 0; +} + +#elif defined test_atomic_store +int main() +{ + int _Atomic i; + int r; + atomic_store(&i, 12); + r = atomic_fetch_add(&i, i); + printf("r = %d, i = %d\n", r, i); +} + +#elif defined test_atomic_store_pointer +typedef struct { char c[4]; } c4; +int main() +{ + int i = 1; + int _Atomic *p = &i; + int k = 2; + atomic_store(&p, &k); + printf("*p = %d\n", *p); +} + +#elif defined test_atomic_store_struct +typedef struct { char c[4]; } c4; +int main() +{ + c4 _Atomic p; + c4 v = { 1,2,3,4 }; + atomic_store(&p, v); + printf("%d %d %d %d\n", p.c[0], p.c[1], p.c[2], p.c[3]); +} + +#elif defined test_atomic_op + +#define OP1(func, v, e1, e2) atomic_##func(&c, v) == e1 && c == e2 +#define OP2(func, v, e1, e2) atomic_##func(&s, v) == e1 && s == e2 +#define OP4(func, v, e1, e2) atomic_##func(&i, v) == e1 && i == e2 +#if defined __x86_64__ || defined __aarch64__ || defined __riscv +#define OP8(func, v, e1, e2) atomic_##func(&l, v) == e1 && l == e2 +#define HAS_64BITS +#else +#define OP8(func, v, e1, e2) 1 +#endif + +#define OP(func, v, e1, e2) printf ("%s: %s\n", #func, \ + OP1(func,v,e1,e2) && OP2(func,v,e1,e2) && \ + OP4(func,v,e1,e2) && OP8(func,v,e1,e2) \ + ? "SUCCESS" : "FAIL"); + +int main() +{ + atomic_char c; + atomic_short s; + atomic_int i; +#ifdef HAS_64BITS + atomic_size_t l; +#endif + + atomic_init(&c, 0); + atomic_init(&s, 0); + atomic_init(&i, 0); +#ifdef HAS_64BITS + atomic_init(&l, 0); +#endif + + OP(fetch_add, 10, 0, 10); + OP(fetch_sub, 5, 10, 5); + OP(fetch_or, 0x10, 5, 21); + OP(fetch_xor, 0x20, 21, 53); + OP(fetch_and, 0x0f, 53, 5); +} + +#elif defined test_atomic_op2 + +typedef __SIZE_TYPE__ size64_t; + +#define OP1(func, v, e1, e2) \ + __atomic_##func(&c, v, __ATOMIC_SEQ_CST) == e1 && c == e2 +#define OP2(func, v, e1, e2)\ + __atomic_##func(&s, v, __ATOMIC_SEQ_CST) == e1 && s == e2 +#define OP4(func, v, e1, e2)\ + __atomic_##func(&i, v, __ATOMIC_SEQ_CST) == e1 && i == e2 +#if defined __x86_64__ || defined __aarch64__ || defined __riscv +#define OP8(func, v, e1, e2)\ + __atomic_##func(&l, v, __ATOMIC_SEQ_CST) == e1 && l == e2 +#define HAS_64BITS +#else +#define OP8(func, v, e1, e2) 1 +#endif + +#define OP(func, v, e1, e2) printf ("%s: %s\n", #func, \ + OP1(func,v,e1,e2) && OP2(func,v,e1,e2) && \ + OP4(func,v,e1,e2) && OP8(func,v,e1,e2) \ + ? "SUCCESS" : "FAIL"); + +int main() +{ + signed char c; + short s; + int i; +#ifdef HAS_64BITS + size64_t l; +#endif + + atomic_init(&c, 0); + atomic_init(&s, 0); + atomic_init(&i, 0); +#ifdef HAS_64BITS + atomic_init(&l, 0); +#endif + + OP(fetch_add, 10, 0, 10); + OP(fetch_sub, 5, 10, 5); + OP(fetch_or, 0x10, 5, 21); + OP(fetch_xor, 0x20, 21, 53); + OP(fetch_and, 0x0f, 53, 5); + OP(fetch_nand, 0x01, 5, -2); + + atomic_init(&c, 0); + atomic_init(&s, 0); + atomic_init(&i, 0); +#ifdef HAS_64BITS + atomic_init(&l, 0); +#endif + + OP(add_fetch, 10, 10, 10); + OP(sub_fetch, 5, 5, 5); + OP(or_fetch, 0x10, 21, 21); + OP(xor_fetch, 0x20, 53, 53); + OP(and_fetch, 0x0f, 5, 5); + OP(nand_fetch, 0x01, -2, -2); +} + +#elif defined test_atomic_thread_signal +int main() +{ + int c; + + atomic_thread_fence(__ATOMIC_SEQ_CST); + atomic_signal_fence(__ATOMIC_SEQ_CST); + printf ("%d\n", atomic_is_lock_free(&c)); +} + +#elif defined test_atomic_error_1 +int main() +{ + int _Atomic i; + atomic_load(i); +} + +#elif defined test_atomic_error_2 +int main() +{ + struct { char c[3]; } _Atomic c3; + atomic_load(&c3); +} + +#elif defined test_atomic_error_3 +int main() +{ + _Atomic int *p = 0; + atomic_fetch_add(&p, 1); +} + +#elif defined test_atomic_error_4 +int main() +{ + int _Atomic i = 1; + char c = 2; + atomic_compare_exchange_strong(&i, &c, 0); +} + +#elif defined test_atomic_warn_1 +int main() +{ + size_t _Atomic i = 1; + /* assignment to integer from pointer */ + atomic_store(&i, &i); +} + +#elif defined test_atomic_warn_2 +int main() +{ + int i = 1; + char c = 2; + int _Atomic *p = &i; + /* assignment from incompatible pointer */ + atomic_store(&p, &c); +} + +#elif defined test_atomic_warn_3 +int main() +{ + int const i = 1; + /* assignment to read-only -location */ + atomic_fetch_add(&i, 2); +} + +#endif diff --git a/tinycc/tests/tests2/125_atomic_misc.expect b/tinycc/tests/tests2/125_atomic_misc.expect new file mode 100644 index 0000000..61bd29f --- /dev/null +++ b/tinycc/tests/tests2/125_atomic_misc.expect @@ -0,0 +1,59 @@ +[test_atomic_compare_exchange] +1 99 77 +0 80 80 +85 33 80 +90 66 80 + +[test_atomic_store] +r = 12, i = 24 + +[test_atomic_store_pointer] +*p = 2 + +[test_atomic_store_struct] +1 2 3 4 + +[test_atomic_op] +fetch_add: SUCCESS +fetch_sub: SUCCESS +fetch_or: SUCCESS +fetch_xor: SUCCESS +fetch_and: SUCCESS + +[test_atomic_op2] +fetch_add: SUCCESS +fetch_sub: SUCCESS +fetch_or: SUCCESS +fetch_xor: SUCCESS +fetch_and: SUCCESS +fetch_nand: SUCCESS +add_fetch: SUCCESS +sub_fetch: SUCCESS +or_fetch: SUCCESS +xor_fetch: SUCCESS +and_fetch: SUCCESS +nand_fetch: SUCCESS + +[test_atomic_thread_signal] +1 + +[test_atomic_error_1] +125_atomic_misc.c:176: error: pointer expected + +[test_atomic_error_2] +125_atomic_misc.c:183: error: integral or integer-sized pointer target type expected + +[test_atomic_error_3] +125_atomic_misc.c:190: error: integral or integer-sized pointer target type expected + +[test_atomic_error_4] +125_atomic_misc.c:198: error: pointer target type mismatch in argument 2 + +[test_atomic_warn_1] +125_atomic_misc.c:206: warning: assignment makes integer from pointer without a cast + +[test_atomic_warn_2] +125_atomic_misc.c:216: warning: assignment from incompatible pointer type + +[test_atomic_warn_3] +125_atomic_misc.c:224: warning: assignment of read-only location diff --git a/tinycc/tests/tests2/126_bound_global.c b/tinycc/tests/tests2/126_bound_global.c new file mode 100644 index 0000000..d3a5c3b --- /dev/null +++ b/tinycc/tests/tests2/126_bound_global.c @@ -0,0 +1,13 @@ +/* test bound checking code without -run */ + +int arr[10]; + +int +main(int argc, char **argv) +{ + int i; + + for (i = 0; i <= sizeof(arr)/sizeof(arr[0]); i++) + arr[i] = 0; + return 0; +} diff --git a/tinycc/tests/tests2/126_bound_global.expect b/tinycc/tests/tests2/126_bound_global.expect new file mode 100644 index 0000000..fcdea90 --- /dev/null +++ b/tinycc/tests/tests2/126_bound_global.expect @@ -0,0 +1,2 @@ +126_bound_global.c:11: at main: BCHECK: ........ is outside of the region +126_bound_global.c:11: at main: RUNTIME ERROR: invalid memory access diff --git a/tinycc/tests/tests2/127_asm_goto.c b/tinycc/tests/tests2/127_asm_goto.c new file mode 100644 index 0000000..de631aa --- /dev/null +++ b/tinycc/tests/tests2/127_asm_goto.c @@ -0,0 +1,62 @@ +static int simple_jump(void) +{ + asm goto ("jmp %l[label]" : : : : label); + return 0; +label: + return 1; +} + +static int three_way_jump(int val, int *addr) +{ + *addr = 42; + asm goto ("cmp $0, %1\n\t" + "jg %l[larger]\n\t" + "jl %l[smaller]\n\t" + "incl %0\n\t" + : "=m" (*addr) + : "r" (val) + : + : smaller, larger); + return 1; +smaller: + return 2; +larger: + return 3; +} + +static int another_jump(void) +{ + asm goto ("jmp %l[label]" : : : : label); + return 70; + /* Use the same label name as in simple_jump to check that + that doesn't confuse our C/ASM symbol tables */ +label: + return 71; +} + +extern int printf (const char *, ...); +int main(void) +{ + int i; + if (simple_jump () == 1) + printf ("simple_jump: okay\n"); + else + printf ("simple_jump: wrong\n"); + if (another_jump () == 71) + printf ("another_jump: okay\n"); + else + printf ("another_jump: wrong\n"); + if (three_way_jump(0, &i) == 1 && i == 43) + printf ("three_way_jump(0): okay\n"); + else + printf ("three_way_jump(0): wrong (i=%d)\n", i); + if (three_way_jump(1, &i) == 3 && i == 42) + printf ("three_way_jump(1): okay\n"); + else + printf ("three_way_jump(1): wrong (i=%d)\n", i); + if (three_way_jump(-1, &i) == 2 && i == 42) + printf ("three_way_jump(-1): okay\n"); + else + printf ("three_way_jump(-1): wrong (i=%d)\n", i); + return 0; +} diff --git a/tinycc/tests/tests2/127_asm_goto.expect b/tinycc/tests/tests2/127_asm_goto.expect new file mode 100644 index 0000000..e1b7169 --- /dev/null +++ b/tinycc/tests/tests2/127_asm_goto.expect @@ -0,0 +1,5 @@ +simple_jump: okay +another_jump: okay +three_way_jump(0): okay +three_way_jump(1): okay +three_way_jump(-1): okay diff --git a/tinycc/tests/tests2/128_run_atexit.c b/tinycc/tests/tests2/128_run_atexit.c new file mode 100644 index 0000000..0748c86 --- /dev/null +++ b/tinycc/tests/tests2/128_run_atexit.c @@ -0,0 +1,54 @@ +#include <stdio.h> + +int atexit(void (*function)(void)); +int on_exit(void (*function)(int, void *), void *arg); +void exit(int status); + +void cleanup1(void) +{ + printf ("cleanup1\n"); + fflush(stdout); +} + +void cleanup2(void) +{ + printf ("cleanup2\n"); +} + +void cleanup3(int ret, void *arg) +{ + printf ("%d %s\n", ret, (char *) arg); +} + +void cleanup4(int ret, void *arg) +{ + printf ("%d %s\n", ret, (char *) arg); +} + +void __attribute((destructor)) cleanup5(void) +{ + printf ("cleanup5\n"); +} + +void test(void) +{ + atexit(cleanup1); + atexit(cleanup2); + on_exit(cleanup3, "cleanup3"); + on_exit(cleanup4, "cleanup4"); +} + +#if defined test_128_return +int main(int argc, char **argv) +{ + test(); + return 1; +} + +#elif defined test_128_exit +int main(int argc, char **argv) +{ + test(); + exit(2); +} +#endif diff --git a/tinycc/tests/tests2/128_run_atexit.expect b/tinycc/tests/tests2/128_run_atexit.expect new file mode 100644 index 0000000..3305785 --- /dev/null +++ b/tinycc/tests/tests2/128_run_atexit.expect @@ -0,0 +1,15 @@ +[test_128_return] +cleanup5 +1 cleanup4 +1 cleanup3 +cleanup2 +cleanup1 +[returns 1] + +[test_128_exit] +cleanup5 +2 cleanup4 +2 cleanup3 +cleanup2 +cleanup1 +[returns 2] diff --git a/tinycc/tests/tests2/129_scopes.c b/tinycc/tests/tests2/129_scopes.c new file mode 100644 index 0000000..b63b682 --- /dev/null +++ b/tinycc/tests/tests2/129_scopes.c @@ -0,0 +1,43 @@ +#include <stdio.h> +enum{ in = 0}; +#define myassert(X) do{ if(!X) printf("%d: assertion failed\n", __LINE__); }while(0) +int main(){ + { + myassert(!in); + if(sizeof(enum{in=1})) myassert(in); + myassert(!in); //OOPS + } + { + myassert(!in); + switch(sizeof(enum{in=1})) { default: myassert(in); } + myassert(!in); //OOPS + } + { + myassert(!in); + while(sizeof(enum{in=1})) { myassert(in); break; } + myassert(!in); //OOPS + } + { + myassert(!in); + do{ myassert(!in);}while(0*sizeof(enum{in=1})); + myassert(!in); //OOPS + } + + { + myassert(!in); + for(sizeof(enum{in=1});;){ myassert(in); break; } + myassert(!in); //OK + } + { + myassert(!in); + for(;;sizeof(enum{in=1})){ myassert(in); break; } + myassert(!in); //OK + } + { + myassert(!in); + for(;sizeof(enum{in=1});){ myassert(in); break; } + myassert(!in); //OK + } + +} + diff --git a/tinycc/tests/tests2/129_scopes.expect b/tinycc/tests/tests2/129_scopes.expect new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tinycc/tests/tests2/129_scopes.expect diff --git a/tinycc/tests/tests2/12_hashdefine.c b/tinycc/tests/tests2/12_hashdefine.c new file mode 100644 index 0000000..5c521e0 --- /dev/null +++ b/tinycc/tests/tests2/12_hashdefine.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +#define FRED 12 +#define BLOGGS(x) (12*(x)) + +int main() +{ + printf("%d\n", FRED); + printf("%d, %d, %d\n", BLOGGS(1), BLOGGS(2), BLOGGS(3)); + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/12_hashdefine.expect b/tinycc/tests/tests2/12_hashdefine.expect new file mode 100644 index 0000000..99f2ed5 --- /dev/null +++ b/tinycc/tests/tests2/12_hashdefine.expect @@ -0,0 +1,2 @@ +12 +12, 24, 36 diff --git a/tinycc/tests/tests2/130_large_argument.c b/tinycc/tests/tests2/130_large_argument.c new file mode 100644 index 0000000..8415c85 --- /dev/null +++ b/tinycc/tests/tests2/130_large_argument.c @@ -0,0 +1,41 @@ +#include<stdio.h> + +struct large1 { + int a[768]; +}; + +struct large2 { + int a[1920]; +}; + +void pass_large_struct1(struct large1 in) +{ + printf("%d %d\n", in.a[200], in.a[767]); + return; +} + +void pass_large_struct2(struct large2 in) +{ + printf("%d %d %d\n", in.a[200], in.a[1023], in.a[1919]); + return; +} + +void pass_many_args(int a, int b, int c, int d, int e, int f, int g, int h, int i, + int j, int k, int l, int m) +{ + printf("%d %d %d %d %d %d %d %d %d %d %d %d %d\n", a, b, c, d, e, f, g, h, i, + j, k, l, m); + return; +} + +struct large1 l1 = { .a = { [200] = 1, [767] = 2 } }; +struct large2 l2 = { .a = { [200] = 3, [1023] = 4, [1919] = 5} }; + +int main(void) +{ + pass_large_struct1(l1); + pass_large_struct2(l2); + pass_many_args(13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1); + + return 0; +} diff --git a/tinycc/tests/tests2/130_large_argument.expect b/tinycc/tests/tests2/130_large_argument.expect new file mode 100644 index 0000000..8c5d9cd --- /dev/null +++ b/tinycc/tests/tests2/130_large_argument.expect @@ -0,0 +1,3 @@ +1 2 +3 4 5 +13 12 11 10 9 8 7 6 5 4 3 2 1 diff --git a/tinycc/tests/tests2/13_integer_literals.c b/tinycc/tests/tests2/13_integer_literals.c new file mode 100644 index 0000000..7cee98b --- /dev/null +++ b/tinycc/tests/tests2/13_integer_literals.c @@ -0,0 +1,20 @@ +#include <stdio.h> + +int main() +{ + int a = 24680; + int b = 01234567; + int c = 0x2468ac; + int d = 0x2468AC; + int e = 0b010101010101; + + printf("%d\n", a); + printf("%d\n", b); + printf("%d\n", c); + printf("%d\n", d); + printf("%d\n", e); + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/13_integer_literals.expect b/tinycc/tests/tests2/13_integer_literals.expect new file mode 100644 index 0000000..f5aca06 --- /dev/null +++ b/tinycc/tests/tests2/13_integer_literals.expect @@ -0,0 +1,5 @@ +24680 +342391 +2386092 +2386092 +1365 diff --git a/tinycc/tests/tests2/14_if.c b/tinycc/tests/tests2/14_if.c new file mode 100644 index 0000000..2bd2550 --- /dev/null +++ b/tinycc/tests/tests2/14_if.c @@ -0,0 +1,21 @@ +#include <stdio.h> + +int main() +{ + int a = 1; + + if (a) + printf("a is true\n"); + else + printf("a is false\n"); + + int b = 0; + if (b) + printf("b is true\n"); + else + printf("b is false\n"); + + return 0; +} + +// vim: set expandtab ts=4 sw=3 sts=3 tw=80 : diff --git a/tinycc/tests/tests2/14_if.expect b/tinycc/tests/tests2/14_if.expect new file mode 100644 index 0000000..c32c415 --- /dev/null +++ b/tinycc/tests/tests2/14_if.expect @@ -0,0 +1,2 @@ +a is true +b is false diff --git a/tinycc/tests/tests2/15_recursion.c b/tinycc/tests/tests2/15_recursion.c new file mode 100644 index 0000000..f79a00d --- /dev/null +++ b/tinycc/tests/tests2/15_recursion.c @@ -0,0 +1,21 @@ +#include <stdio.h> + +int factorial(int i) +{ + if (i < 2) + return i; + else + return i * factorial(i - 1); +} + +int main() +{ + int Count; + + for (Count = 1; Count <= 10; Count++) + printf("%d\n", factorial(Count)); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/15_recursion.expect b/tinycc/tests/tests2/15_recursion.expect new file mode 100644 index 0000000..db47b28 --- /dev/null +++ b/tinycc/tests/tests2/15_recursion.expect @@ -0,0 +1,10 @@ +1 +2 +6 +24 +120 +720 +5040 +40320 +362880 +3628800 diff --git a/tinycc/tests/tests2/16_nesting.c b/tinycc/tests/tests2/16_nesting.c new file mode 100644 index 0000000..2b72cc0 --- /dev/null +++ b/tinycc/tests/tests2/16_nesting.c @@ -0,0 +1,21 @@ +#include <stdio.h> + +int main() +{ + int x, y, z; + + for (x = 0; x < 2; x++) + { + for (y = 0; y < 3; y++) + { + for (z = 0; z < 3; z++) + { + printf("%d %d %d\n", x, y, z); + } + } + } + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/16_nesting.expect b/tinycc/tests/tests2/16_nesting.expect new file mode 100644 index 0000000..5a3431e --- /dev/null +++ b/tinycc/tests/tests2/16_nesting.expect @@ -0,0 +1,18 @@ +0 0 0 +0 0 1 +0 0 2 +0 1 0 +0 1 1 +0 1 2 +0 2 0 +0 2 1 +0 2 2 +1 0 0 +1 0 1 +1 0 2 +1 1 0 +1 1 1 +1 1 2 +1 2 0 +1 2 1 +1 2 2 diff --git a/tinycc/tests/tests2/17_enum.c b/tinycc/tests/tests2/17_enum.c new file mode 100644 index 0000000..e2bc736 --- /dev/null +++ b/tinycc/tests/tests2/17_enum.c @@ -0,0 +1,72 @@ +#include <stdio.h> + +enum fred +{ + a, + b, + c, + d, + e = 54, + f = 73, + g, + h +}; + +/* All following uses of enum efoo should compile + without warning. While forward enums aren't ISO C, + it's accepted by GCC also in strict mode, and only warned + about with -pedantic. This happens in the real world. */ +/* Strict ISO C doesn't allow this kind of forward declaration of + enums, but GCC accepts it (and gives only pedantic warning), and + it occurs in the wild. */ +enum efoo; +struct Sforward_use { + int (*fmember) (enum efoo x); +}; + +extern enum efoo it_real_fn(void); +enum efoo { + ONE, + TWO, +}; +struct S2 { + enum efoo (*f2) (void); +}; +void should_compile(struct S2 *s) +{ + s->f2 = it_real_fn; +} + +enum efoo it_real_fn(void) +{ + return TWO; +} + +static unsigned int deref_uintptr(unsigned int *p) +{ + return *p; +} + +enum Epositive { + epos_one, epos_two +}; + +int main() +{ + enum fred frod; + enum Epositive epos = epos_two; + + printf("%d %d %d %d %d %d %d %d\n", a, b, c, d, e, f, g, h); + /* printf("%d\n", frod); */ + frod = 12; + printf("%d\n", frod); + frod = e; + printf("%d\n", frod); + + /* Following should compile without warning. */ + printf ("enum to int: %u\n", deref_uintptr(&epos)); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/17_enum.expect b/tinycc/tests/tests2/17_enum.expect new file mode 100644 index 0000000..d453a61 --- /dev/null +++ b/tinycc/tests/tests2/17_enum.expect @@ -0,0 +1,4 @@ +0 1 2 3 54 73 74 75 +12 +54 +enum to int: 1 diff --git a/tinycc/tests/tests2/18_include.c b/tinycc/tests/tests2/18_include.c new file mode 100644 index 0000000..9ff60c9 --- /dev/null +++ b/tinycc/tests/tests2/18_include.c @@ -0,0 +1,47 @@ +#include <stdio.h> + +int main() +{ + printf("including\n"); +#include "18_include.h" +#define test_missing_nl + printf("done\n"); + +#define INC "18_include.h" + +#ifdef __has_include +#if defined __has_include +#if __has_include("18_include.h") + printf("has_include\n"); +#endif +#if __has_include(INC) + printf("has_include\n"); +#endif +#if __has_include("not_found_18_include.h") + printf("has_include not found\n"); +#endif +#endif +#endif + +#ifdef __has_include_next +#if defined __has_include_next +#if __has_include_next("18_include.h") + printf("has_include_next\n"); +#endif +#if __has_include_next(INC) + printf("has_include_next\n"); +#endif +#if __has_include_next("not_found_18_include.h") + printf("has_include_next not found\n"); +#endif +#endif +#endif + +#include "18_include2.h" +#include "./18_include2.h" +#include "../tests2/18_include2.h" + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/18_include.expect b/tinycc/tests/tests2/18_include.expect new file mode 100644 index 0000000..fbc6d13 --- /dev/null +++ b/tinycc/tests/tests2/18_include.expect @@ -0,0 +1,8 @@ +including +included +done +has_include +has_include +has_include_next +has_include_next +counter 0 diff --git a/tinycc/tests/tests2/18_include.h b/tinycc/tests/tests2/18_include.h new file mode 100644 index 0000000..cad2433 --- /dev/null +++ b/tinycc/tests/tests2/18_include.h @@ -0,0 +1,5 @@ +printf("included\n"); +/* test file with missing newline */ +#ifndef INCLUDE +#define INCLUDE +#endif /* INCLUDE */
\ No newline at end of file diff --git a/tinycc/tests/tests2/18_include2.h b/tinycc/tests/tests2/18_include2.h new file mode 100644 index 0000000..2a89c3d --- /dev/null +++ b/tinycc/tests/tests2/18_include2.h @@ -0,0 +1,2 @@ +#pragma once +printf ("counter %d\n", __COUNTER__); diff --git a/tinycc/tests/tests2/19_pointer_arithmetic.c b/tinycc/tests/tests2/19_pointer_arithmetic.c new file mode 100644 index 0000000..aff65e5 --- /dev/null +++ b/tinycc/tests/tests2/19_pointer_arithmetic.c @@ -0,0 +1,28 @@ +#include <stdio.h> + +int main() +{ + int a; + int *b; + int *c; + + a = 42; + b = &a; + c = NULL; + + printf("%d\n", *b); + + if (b == NULL) + printf("b is NULL\n"); + else + printf("b is not NULL\n"); + + if (c == NULL) + printf("c is NULL\n"); + else + printf("c is not NULL\n"); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/19_pointer_arithmetic.expect b/tinycc/tests/tests2/19_pointer_arithmetic.expect new file mode 100644 index 0000000..0cf781b --- /dev/null +++ b/tinycc/tests/tests2/19_pointer_arithmetic.expect @@ -0,0 +1,3 @@ +42 +b is not NULL +c is NULL diff --git a/tinycc/tests/tests2/20_pointer_comparison.c b/tinycc/tests/tests2/20_pointer_comparison.c new file mode 100644 index 0000000..825f778 --- /dev/null +++ b/tinycc/tests/tests2/20_pointer_comparison.c @@ -0,0 +1,24 @@ +#include <stdio.h> + +int main() +{ + int a; + int b; + int *d; + int *e; + d = &a; + e = &b; + a = 12; + b = 34; + printf("%d\n", *d); + printf("%d\n", *e); + printf("%d\n", d == e); + printf("%d\n", d != e); + d = e; + printf("%d\n", d == e); + printf("%d\n", d != e); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/20_pointer_comparison.expect b/tinycc/tests/tests2/20_pointer_comparison.expect new file mode 100644 index 0000000..5d1e5f5 --- /dev/null +++ b/tinycc/tests/tests2/20_pointer_comparison.expect @@ -0,0 +1,6 @@ +12 +34 +0 +1 +1 +0 diff --git a/tinycc/tests/tests2/21_char_array.c b/tinycc/tests/tests2/21_char_array.c new file mode 100644 index 0000000..f22f527 --- /dev/null +++ b/tinycc/tests/tests2/21_char_array.c @@ -0,0 +1,33 @@ +#include <stdio.h> + +int main() +{ + int x = 'a'; + char y = x; + + char *a = "hello"; + + printf("%s\n", a); + + int c; + c = *a; + + char *b; + for (b = a; *b != 0; b++) + printf("%c: %d\n", *b, *b); + + char destarray[10]; + char *dest = &destarray[0]; + char *src = a; + + while (*src != 0) + *dest++ = *src++; + + *dest = 0; + + printf("copied string is %s\n", destarray); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/21_char_array.expect b/tinycc/tests/tests2/21_char_array.expect new file mode 100644 index 0000000..dbc6068 --- /dev/null +++ b/tinycc/tests/tests2/21_char_array.expect @@ -0,0 +1,7 @@ +hello +h: 104 +e: 101 +l: 108 +l: 108 +o: 111 +copied string is hello diff --git a/tinycc/tests/tests2/22_floating_point.c b/tinycc/tests/tests2/22_floating_point.c new file mode 100644 index 0000000..5dc7b74 --- /dev/null +++ b/tinycc/tests/tests2/22_floating_point.c @@ -0,0 +1,70 @@ +#include <stdio.h> +#include <math.h> + +float fd; + +int +test() +{ + // was an internal tcc compiler error with arm64 backend until 2019-11-08 + if (fd < 5.5) { + return 1; + } else { + return 0; + } +} + +int main() +{ + static int e1 = -1.0 == 0.0; + static int e2 = -1.0 != 0.0; + static int e3 = -1.0 < 0.0; + static int e4 = -1.0 >= 0.0; + static int e5 = -1.0 <= 0.0; + static int e6 = -1.0 > 0.0; + // variables + float a = 12.34 + 56.78; + printf("%f\n", a); + + // infix operators + printf("%f\n", 12.34 + 56.78); + printf("%f\n", 12.34 - 56.78); + printf("%f\n", 12.34 * 56.78); + printf("%f\n", 12.34 / 56.78); + + // comparison operators + printf("%d %d %d %d %d %d\n", 12.34 < 56.78, 12.34 <= 56.78, 12.34 == 56.78, 12.34 >= 56.78, 12.34 > 56.78, 12.34 != 56.78); + printf("%d %d %d %d %d %d\n", 12.34 < 12.34, 12.34 <= 12.34, 12.34 == 12.34, 12.34 >= 12.34, 12.34 > 12.34, 12.34 != 12.34); + printf("%d %d %d %d %d %d\n", 56.78 < 12.34, 56.78 <= 12.34, 56.78 == 12.34, 56.78 >= 12.34, 56.78 > 12.34, 56.78 != 12.34); + printf("%d %d %d %d %d %d\n", e1, e2, e3, e4, e5, e6); + + // assignment operators + a = 12.34; + a += 56.78; + printf("%f\n", a); + + a = 12.34; + a -= 56.78; + printf("%f\n", a); + + a = 12.34; + a *= 56.78; + printf("%f\n", a); + + a = 12.34; + a /= 56.78; + printf("%f\n", a); + + // prefix operators + printf("%f\n", +12.34); + printf("%f\n", -12.34); + + // type coercion + a = 2; + printf("%f\n", a); + printf("%f\n", sin(2)); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/22_floating_point.expect b/tinycc/tests/tests2/22_floating_point.expect new file mode 100644 index 0000000..a989eca --- /dev/null +++ b/tinycc/tests/tests2/22_floating_point.expect @@ -0,0 +1,17 @@ +69.120003 +69.120000 +-44.440000 +700.665200 +0.217330 +1 1 0 0 0 1 +0 1 1 1 0 0 +0 0 0 1 1 1 +0 1 1 0 1 0 +69.120003 +-44.439999 +700.665222 +0.217330 +12.340000 +-12.340000 +2.000000 +0.909297 diff --git a/tinycc/tests/tests2/23_type_coercion.c b/tinycc/tests/tests2/23_type_coercion.c new file mode 100644 index 0000000..1fcc335 --- /dev/null +++ b/tinycc/tests/tests2/23_type_coercion.c @@ -0,0 +1,54 @@ +#include <stdio.h> + +void charfunc(char a) +{ + printf("char: %c\n", a); +} + +void intfunc(int a) +{ + printf("int: %d\n", a); +} + +void floatfunc(float a) +{ + printf("float: %f\n", a); +} + +int main() +{ + charfunc('a'); + charfunc(98); + charfunc(99.0); + + intfunc('a'); + intfunc(98); + intfunc(99.0); + + floatfunc('a'); + floatfunc(98); + floatfunc(99.0); + + /* printf("%c %d %f\n", 'a', 'b', 'c'); */ + /* printf("%c %d %f\n", 97, 98, 99); */ + /* printf("%c %d %f\n", 97.0, 98.0, 99.0); */ + + char b = 97; + char c = 97.0; + + printf("%d %d\n", b, c); + + int d = 'a'; + int e = 97.0; + + printf("%d %d\n", d, e); + + float f = 'a'; + float g = 97; + + printf("%f %f\n", f, g); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/23_type_coercion.expect b/tinycc/tests/tests2/23_type_coercion.expect new file mode 100644 index 0000000..d9076f0 --- /dev/null +++ b/tinycc/tests/tests2/23_type_coercion.expect @@ -0,0 +1,12 @@ +char: a +char: b +char: c +int: 97 +int: 98 +int: 99 +float: 97.000000 +float: 98.000000 +float: 99.000000 +97 97 +97 97 +97.000000 97.000000 diff --git a/tinycc/tests/tests2/24_math_library.c b/tinycc/tests/tests2/24_math_library.c new file mode 100644 index 0000000..514a25f --- /dev/null +++ b/tinycc/tests/tests2/24_math_library.c @@ -0,0 +1,30 @@ +#define _ISOC99_SOURCE 1 + +#include <stdio.h> +#include <math.h> + +int main() +{ + printf("%f\n", sin(0.12)); + printf("%f\n", cos(0.12)); + printf("%f\n", tan(0.12)); + printf("%f\n", asin(0.12)); + printf("%f\n", acos(0.12)); + printf("%f\n", atan(0.12)); + printf("%f\n", sinh(0.12)); + printf("%f\n", cosh(0.12)); + printf("%f\n", tanh(0.12)); + printf("%f\n", exp(0.12)); + printf("%f\n", fabs(-0.12)); + printf("%f\n", log(0.12)); + printf("%f\n", log10(0.12)); + printf("%f\n", pow(0.12, 0.12)); + printf("%f\n", sqrt(0.12)); + printf("%f\n", round(12.34)); + printf("%f\n", ceil(12.34)); + printf("%f\n", floor(12.34)); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/24_math_library.expect b/tinycc/tests/tests2/24_math_library.expect new file mode 100644 index 0000000..99f7299 --- /dev/null +++ b/tinycc/tests/tests2/24_math_library.expect @@ -0,0 +1,18 @@ +0.119712 +0.992809 +0.120579 +0.120290 +1.450506 +0.119429 +0.120288 +1.007209 +0.119427 +1.127497 +0.120000 +-2.120264 +-0.920819 +0.775357 +0.346410 +12.000000 +13.000000 +12.000000 diff --git a/tinycc/tests/tests2/25_quicksort.c b/tinycc/tests/tests2/25_quicksort.c new file mode 100644 index 0000000..5cc08bd --- /dev/null +++ b/tinycc/tests/tests2/25_quicksort.c @@ -0,0 +1,83 @@ +#include <stdio.h> + +int array[16]; + +//Swap integer values by array indexes +void swap(int a, int b) +{ + int tmp = array[a]; + array[a] = array[b]; + array[b] = tmp; +} + +//Partition the array into two halves and return the +//index about which the array is partitioned +int partition(int left, int right) +{ + int pivotIndex = left; + int pivotValue = array[pivotIndex]; + int index = left; + int i; + + swap(pivotIndex, right); + for(i = left; i < right; i++) + { + if(array[i] < pivotValue) + { + swap(i, index); + index += 1; + } + } + swap(right, index); + + return index; +} + +//Quicksort the array +void quicksort(int left, int right) +{ + if(left >= right) + return; + + int index = partition(left, right); + quicksort(left, index - 1); + quicksort(index + 1, right); +} + +int main() +{ + int i; + + array[0] = 62; + array[1] = 83; + array[2] = 4; + array[3] = 89; + array[4] = 36; + array[5] = 21; + array[6] = 74; + array[7] = 37; + array[8] = 65; + array[9] = 33; + array[10] = 96; + array[11] = 38; + array[12] = 53; + array[13] = 16; + array[14] = 74; + array[15] = 55; + + for (i = 0; i < 16; i++) + printf("%d ", array[i]); + + printf("\n"); + + quicksort(0, 15); + + for (i = 0; i < 16; i++) + printf("%d ", array[i]); + + printf("\n"); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/25_quicksort.expect b/tinycc/tests/tests2/25_quicksort.expect new file mode 100644 index 0000000..2d39cd3 --- /dev/null +++ b/tinycc/tests/tests2/25_quicksort.expect @@ -0,0 +1,2 @@ +62 83 4 89 36 21 74 37 65 33 96 38 53 16 74 55 +4 16 21 33 36 37 38 53 55 62 65 74 74 83 89 96 diff --git a/tinycc/tests/tests2/26_character_constants.c b/tinycc/tests/tests2/26_character_constants.c new file mode 100644 index 0000000..95c4423 --- /dev/null +++ b/tinycc/tests/tests2/26_character_constants.c @@ -0,0 +1,17 @@ +#include <stdio.h> + +int main() +{ + printf("%d\n", '\1'); + printf("%d\n", '\10'); + printf("%d\n", '\100'); + printf("%d\n", '\x01'); + printf("%d\n", '\x0e'); + printf("%d\n", '\x10'); + printf("%d\n", '\x40'); + printf("test \x40\n"); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/26_character_constants.expect b/tinycc/tests/tests2/26_character_constants.expect new file mode 100644 index 0000000..8f8bfa4 --- /dev/null +++ b/tinycc/tests/tests2/26_character_constants.expect @@ -0,0 +1,8 @@ +1 +8 +64 +1 +14 +16 +64 +test @ diff --git a/tinycc/tests/tests2/27_sizeof.c b/tinycc/tests/tests2/27_sizeof.c new file mode 100644 index 0000000..5ae0ede --- /dev/null +++ b/tinycc/tests/tests2/27_sizeof.c @@ -0,0 +1,18 @@ +#include <stdio.h> + +int main() +{ + char a; + int b; + double c; + + printf("%d\n", sizeof(a)); + printf("%d\n", sizeof(b)); + printf("%d\n", sizeof(c)); + + printf("%d\n", sizeof(!a)); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/27_sizeof.expect b/tinycc/tests/tests2/27_sizeof.expect new file mode 100644 index 0000000..a47ea3a --- /dev/null +++ b/tinycc/tests/tests2/27_sizeof.expect @@ -0,0 +1,4 @@ +1 +4 +8 +4 diff --git a/tinycc/tests/tests2/28_strings.c b/tinycc/tests/tests2/28_strings.c new file mode 100644 index 0000000..2db2298 --- /dev/null +++ b/tinycc/tests/tests2/28_strings.c @@ -0,0 +1,45 @@ +#include <stdio.h> +#include <string.h> + +int main() +{ + char a[10]; + + strcpy(a, "hello"); + printf("%s\n", a); + + strncpy(a, "gosh", 2); + printf("%s\n", a); + + printf("%d\n", strcmp(a, "apple") > 0); + printf("%d\n", strcmp(a, "goere") > 0); + printf("%d\n", strcmp(a, "zebra") < 0); + + printf("%d\n", strlen(a)); + + strcat(a, "!"); + printf("%s\n", a); + + printf("%d\n", strncmp(a, "apple", 2) > 0); + printf("%d\n", strncmp(a, "goere", 2) == 0); + printf("%d\n", strncmp(a, "goerg", 2) == 0); + printf("%d\n", strncmp(a, "zebra", 2) < 0); + + printf("%s\n", strchr(a, 'o')); + printf("%s\n", strrchr(a, 'l')); + printf("%d\n", strrchr(a, 'x') == NULL); + + memset(&a[1], 'r', 4); + printf("%s\n", a); + + memcpy(&a[2], a, 2); + printf("%s\n", a); + + printf("%d\n", memcmp(a, "apple", 4) > 0); + printf("%d\n", memcmp(a, "grgr", 4) == 0); + printf("%d\n", memcmp(a, "zebra", 4) < 0); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/28_strings.expect b/tinycc/tests/tests2/28_strings.expect new file mode 100644 index 0000000..fd9217a --- /dev/null +++ b/tinycc/tests/tests2/28_strings.expect @@ -0,0 +1,19 @@ +hello +gollo +1 +1 +1 +5 +gollo! +1 +1 +1 +1 +ollo! +lo! +1 +grrrr! +grgrr! +1 +1 +1 diff --git a/tinycc/tests/tests2/29_array_address.c b/tinycc/tests/tests2/29_array_address.c new file mode 100644 index 0000000..bda5ddd --- /dev/null +++ b/tinycc/tests/tests2/29_array_address.c @@ -0,0 +1,13 @@ +#include <stdio.h> +#include <string.h> + +int main() +{ + char a[10]; + strcpy(a, "abcdef"); + printf("%s\n", &a[1]); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/29_array_address.expect b/tinycc/tests/tests2/29_array_address.expect new file mode 100644 index 0000000..9bc8683 --- /dev/null +++ b/tinycc/tests/tests2/29_array_address.expect @@ -0,0 +1 @@ +bcdef diff --git a/tinycc/tests/tests2/30_hanoi.c b/tinycc/tests/tests2/30_hanoi.c new file mode 100644 index 0000000..7c0893b --- /dev/null +++ b/tinycc/tests/tests2/30_hanoi.c @@ -0,0 +1,122 @@ +/* example from http://barnyard.syr.edu/quickies/hanoi.c */ + +/* hanoi.c: solves the tower of hanoi problem. (Programming exercise.) */ +/* By Terry R. McConnell (12/2/97) */ +/* Compile: cc -o hanoi hanoi.c */ + +/* This program does no error checking. But then, if it's right, + it's right ... right ? */ + + +/* The original towers of hanoi problem seems to have been originally posed + by one M. Claus in 1883. There is a popular legend that goes along with + it that has been often repeated and paraphrased. It goes something like this: + In the great temple at Benares there are 3 golden spikes. On one of them, + God placed 64 disks increasing in size from bottom to top, at the beginning + of time. Since then, and to this day, the priest on duty constantly transfers + disks, one at a time, in such a way that no larger disk is ever put on top + of a smaller one. When the disks have been transferred entirely to another + spike the Universe will come to an end in a large thunderclap. + + This paraphrases the original legend due to DeParville, La Nature, Paris 1884, + Part I, 285-286. For this and further information see: Mathematical + Recreations & Essays, W.W. Rouse Ball, MacMillan, NewYork, 11th Ed. 1967, + 303-305. + * + * + */ + +#include <stdio.h> +#include <stdlib.h> + +#define TRUE 1 +#define FALSE 0 + +/* This is the number of "disks" on tower A initially. Taken to be 64 in the + * legend. The number of moves required, in general, is 2^N - 1. For N = 64, + * this is 18,446,744,073,709,551,615 */ +#define N 4 + +/* These are the three towers. For example if the state of A is 0,1,3,4, that + * means that there are three discs on A of sizes 1, 3, and 4. (Think of right + * as being the "down" direction.) */ +int A[N], B[N], C[N]; + +void Hanoi(int,int*,int*,int*); + +/* Print the current configuration of A, B, and C to the screen */ +void PrintAll() +{ + int i; + + printf("A: "); + for(i=0;i<N;i++)printf(" %d ",A[i]); + printf("\n"); + + printf("B: "); + for(i=0;i<N;i++)printf(" %d ",B[i]); + printf("\n"); + + printf("C: "); + for(i=0;i<N;i++)printf(" %d ",C[i]); + printf("\n"); + printf("------------------------------------------\n"); + return; +} + +/* Move the leftmost nonzero element of source to dest, leave behind 0. */ +/* Returns the value moved (not used.) */ +int Move(int *source, int *dest) +{ + int i = 0, j = 0; + + while (i<N && (source[i])==0) i++; + while (j<N && (dest[j])==0) j++; + + dest[j-1] = source[i]; + source[i] = 0; + PrintAll(); /* Print configuration after each move. */ + return dest[j-1]; +} + + +/* Moves first n nonzero numbers from source to dest using the rules of Hanoi. + Calls itself recursively. + */ +void Hanoi(int n,int *source, int *dest, int *spare) +{ + int i; + if(n==1){ + Move(source,dest); + return; + } + + Hanoi(n-1,source,spare,dest); + Move(source,dest); + Hanoi(n-1,spare,dest,source); + return; +} + +int main() +{ + int i; + + /* initialize the towers */ + for(i=0;i<N;i++)A[i]=i+1; + for(i=0;i<N;i++)B[i]=0; + for(i=0;i<N;i++)C[i]=0; + + printf("Solution of Tower of Hanoi Problem with %d Disks\n\n",N); + + /* Print the starting state */ + printf("Starting state:\n"); + PrintAll(); + printf("\n\nSubsequent states:\n\n"); + + /* Do it! Use A = Source, B = Destination, C = Spare */ + Hanoi(N,A,B,C); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/30_hanoi.expect b/tinycc/tests/tests2/30_hanoi.expect new file mode 100644 index 0000000..7798ee0 --- /dev/null +++ b/tinycc/tests/tests2/30_hanoi.expect @@ -0,0 +1,71 @@ +Solution of Tower of Hanoi Problem with 4 Disks + +Starting state: +A: 1 2 3 4 +B: 0 0 0 0 +C: 0 0 0 0 +------------------------------------------ + + +Subsequent states: + +A: 0 2 3 4 +B: 0 0 0 0 +C: 0 0 0 1 +------------------------------------------ +A: 0 0 3 4 +B: 0 0 0 2 +C: 0 0 0 1 +------------------------------------------ +A: 0 0 3 4 +B: 0 0 1 2 +C: 0 0 0 0 +------------------------------------------ +A: 0 0 0 4 +B: 0 0 1 2 +C: 0 0 0 3 +------------------------------------------ +A: 0 0 1 4 +B: 0 0 0 2 +C: 0 0 0 3 +------------------------------------------ +A: 0 0 1 4 +B: 0 0 0 0 +C: 0 0 2 3 +------------------------------------------ +A: 0 0 0 4 +B: 0 0 0 0 +C: 0 1 2 3 +------------------------------------------ +A: 0 0 0 0 +B: 0 0 0 4 +C: 0 1 2 3 +------------------------------------------ +A: 0 0 0 0 +B: 0 0 1 4 +C: 0 0 2 3 +------------------------------------------ +A: 0 0 0 2 +B: 0 0 1 4 +C: 0 0 0 3 +------------------------------------------ +A: 0 0 1 2 +B: 0 0 0 4 +C: 0 0 0 3 +------------------------------------------ +A: 0 0 1 2 +B: 0 0 3 4 +C: 0 0 0 0 +------------------------------------------ +A: 0 0 0 2 +B: 0 0 3 4 +C: 0 0 0 1 +------------------------------------------ +A: 0 0 0 0 +B: 0 2 3 4 +C: 0 0 0 1 +------------------------------------------ +A: 0 0 0 0 +B: 1 2 3 4 +C: 0 0 0 0 +------------------------------------------ diff --git a/tinycc/tests/tests2/31_args.c b/tinycc/tests/tests2/31_args.c new file mode 100644 index 0000000..dcafed5 --- /dev/null +++ b/tinycc/tests/tests2/31_args.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +int main(int argc, char **argv) +{ + int Count; + + printf("hello world %d\n", argc); + for (Count = 1; Count < argc; Count++) + printf("arg %d: %s\n", Count, argv[Count]); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/31_args.expect b/tinycc/tests/tests2/31_args.expect new file mode 100644 index 0000000..8c60bfc --- /dev/null +++ b/tinycc/tests/tests2/31_args.expect @@ -0,0 +1,6 @@ +hello world 6 +arg 1: arg1 +arg 2: arg2 +arg 3: arg3 +arg 4: arg4 +arg 5: arg5 diff --git a/tinycc/tests/tests2/32_led.c b/tinycc/tests/tests2/32_led.c new file mode 100644 index 0000000..5596cbf --- /dev/null +++ b/tinycc/tests/tests2/32_led.c @@ -0,0 +1,266 @@ +/* example from http://barnyard.syr.edu/quickies/led.c */ + +/* led.c: print out number as if on 7 line led display. I.e., write integer + given on command line like this: + _ _ _ + | _| _| |_| |_ + | |_ _| | _| etc. + + We assume the terminal behaves like a classical teletype. So the top + lines of all digits have to be printed first, then the middle lines of + all digits, etc. + + By Terry R. McConnell + +compile: cc -o led led.c + +If you just want to link in the subroutine print_led that does all the +work, compile with -DNO_MAIN, and declare the following in any source file +that uses the call: + +extern void print_led(unsigned long x, char *buf); + +Bug: you cannot call repeatedly to print more than one number to a line. +That would require curses or some other terminal API that allows moving the +cursor to a previous line. + +*/ + + + +#include <stdlib.h> +#include <stdio.h> + +#define MAX_DIGITS 32 +#define NO_MAIN + + +/* Print the top line of the digit d into buffer. + Does not null terminate buffer. */ + +void topline(int d, char *p){ + + *p++ = ' '; + switch(d){ + + /* all these have _ on top line */ + + case 0: + case 2: + case 3: + case 5: + case 7: + case 8: + case 9: + *p++ = '_'; + break; + default: + *p++=' '; + + } + *p++=' '; +} + +/* Print the middle line of the digit d into the buffer. + Does not null terminate. */ + +void midline(int d, char *p){ + + switch(d){ + + /* those that have leading | on middle line */ + + case 0: + case 4: + case 5: + case 6: + case 8: + case 9: + *p++='|'; + break; + default: + *p++=' '; + } + switch(d){ + + /* those that have _ on middle line */ + + case 2: + case 3: + case 4: + case 5: + case 6: + case 8: + case 9: + *p++='_'; + break; + default: + *p++=' '; + + } + switch(d){ + + /* those that have closing | on middle line */ + + case 0: + case 1: + case 2: + case 3: + case 4: + case 7: + case 8: + case 9: + *p++='|'; + break; + default: + *p++=' '; + + } +} + +/* Print the bottom line of the digit d. Does not null terminate. */ + +void botline(int d, char *p){ + + + switch(d){ + + /* those that have leading | on bottom line */ + + case 0: + case 2: + case 6: + case 8: + *p++='|'; + break; + default: + *p++=' '; + } + switch(d){ + + /* those that have _ on bottom line */ + + case 0: + case 2: + case 3: + case 5: + case 6: + case 8: + *p++='_'; + break; + default: + *p++=' '; + + } + switch(d){ + + /* those that have closing | on bottom line */ + + case 0: + case 1: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + *p++='|'; + break; + default: + *p++=' '; + + } +} + +/* Write the led representation of integer to string buffer. */ + +void print_led(unsigned long x, char *buf) +{ + + int i=0,n; + static int d[MAX_DIGITS]; + + + /* extract digits from x */ + + n = ( x == 0L ? 1 : 0 ); /* 0 is a digit, hence a special case */ + + while(x){ + d[n++] = (int)(x%10L); + if(n >= MAX_DIGITS)break; + x = x/10L; + } + + /* print top lines of all digits */ + + for(i=n-1;i>=0;i--){ + topline(d[i],buf); + buf += 3; + *buf++=' '; + } + *buf++='\n'; /* move teletype to next line */ + + /* print middle lines of all digits */ + + for(i=n-1;i>=0;i--){ + midline(d[i],buf); + buf += 3; + *buf++=' '; + } + *buf++='\n'; + + /* print bottom lines of all digits */ + + for(i=n-1;i>=0;i--){ + botline(d[i],buf); + buf += 3; + *buf++=' '; + } + *buf++='\n'; + *buf='\0'; +} + +int main() +{ + char buf[5*MAX_DIGITS]; + print_led(1234567, buf); + printf("%s\n",buf); + + return 0; +} + +#ifndef NO_MAIN +int main(int argc, char **argv) +{ + + int i=0,n; + long x; + static int d[MAX_DIGITS]; + char buf[5*MAX_DIGITS]; + + if(argc != 2){ + fprintf(stderr,"led: usage: led integer\n"); + return 1; + } + + /* fetch argument from command line */ + + x = atol(argv[1]); + + /* sanity check */ + + if(x<0){ + fprintf(stderr,"led: %d must be non-negative\n",x); + return 1; + } + + print_led(x,buf); + printf("%s\n",buf); + + return 0; + +} +#endif + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/32_led.expect b/tinycc/tests/tests2/32_led.expect new file mode 100644 index 0000000..c53b58a --- /dev/null +++ b/tinycc/tests/tests2/32_led.expect @@ -0,0 +1,4 @@ + _ _ _ _ + | _| _| |_| |_ |_ | + | |_ _| | _| |_| | + diff --git a/tinycc/tests/tests2/33_ternary_op.c b/tinycc/tests/tests2/33_ternary_op.c new file mode 100644 index 0000000..8305438 --- /dev/null +++ b/tinycc/tests/tests2/33_ternary_op.c @@ -0,0 +1,119 @@ +#include <assert.h> +extern int printf(const char*, ...); + +char arr[1]; +static void f (void){} +void (*fp)(void) = f; +void call_fp() +{ + (fp?f:f)(); + (fp?fp:fp)(); + (fp?fp:&f)(); + (fp?&f:fp)(); + (fp?&f:&f)(); + _Generic(0?arr:arr, char*: (void)0); + _Generic(0?&arr[0]:arr, char*: (void)0); + _Generic(0?arr:&arr[0], char*: (void)0); + _Generic(1?arr:arr, char*: (void)0); + _Generic(1?&arr[0]:arr, char*: (void)0); + _Generic(1?arr:&arr[0], char*: (void)0); + _Generic((__typeof(1?f:f)*){0}, void (**)(void): (void)0); + (fp?&f:f)(); + (fp?f:&f)(); + _Generic((__typeof(fp?0L:(void)0)*){0}, void*: (void)0); + + /* The following line causes a warning */ + void *xx = fp?f:1; +} + +struct condstruct { + int i; +}; + +static int getme(struct condstruct* s, int i) +{ + int i1 = (i != 0 ? 0 : s)->i; + int i2 = (i == 0 ? s : 0)->i; + int i3 = (i != 0 ? (void*)0 : s)->i; + int i4 = (i == 0 ? s : (void*)0)->i; + return i1 + i2 + i3 + i4; +} + +int someglobal; + +void constantcond(void) +{ + /* This was broken by 8227db3a2, it saved/restored the CODE_OFF state + during the expression and that bled out to the outer one disabling + codegen for if-body. */ + if (( (someglobal ? 0 : 0) ? 8 : 9)) + printf("okay\n"); +} + +unsigned short tf_4_var_2 = 29886; +const unsigned short tf_4_var_34 = 54077; +const unsigned short tf_4_var_86 = 1129; +long int tf_4_var_98 = -4448775496354969734L; + +unsigned short tf_4_array_8 [9] = + {52593, 34626, 28127, 8124, 11473, 14634, 8370, 31153, 31060}; +unsigned short tf_4_array_2 [6] = + {7493, 64504, 22566, 54931, 44752, 18026}; +unsigned short tf_4_array_3 [9] = + {22671, 46595, 24007, 22460, 12020, 19732, 46148, 3906, 26139}; +unsigned short tf_4_array_7 [9] = + {24530, 26236, 61122, 9019, 26099, 31028, 1078, 27042, 36756}; +unsigned short tf_4_array_4 [9] = + {32711, 2853, 55531, 52731, 6621, 38797, 23543, 64627, 55640}; + +long int tf_4_var_132 = -6396431410421938408L; + +static void tst_yarpgen(void) +{ + /* generated by yarpgen */ + tf_4_var_132 = (long int) (((unsigned long long int) (((((((int) (tf_4_var_86)) && ((int) (tf_4_array_8 [0]))) ? (((int) (tf_4_var_2)) || ((int) (8))) : (((int) (tf_4_array_2 [0])) || (-4096)))) || ((((int) (tf_4_array_3 [6])) || ((int) (tf_4_var_34))) && (((int) (tf_4_array_3 [7])) || ((int) (tf_4_var_98))))) % ((+((int) ((unsigned short) (-6)))) && ((((int) (tf_4_array_7 [5])) & ((int) (tf_4_array_7 [1]))) | (((int) (tf_4_array_4 [0])) & ((int) (tf_4_array_4 [0]))))))) <= (((unsigned long long int) ((int) ((unsigned short) (((7192886880476152731ULL) * (7192886880476152731ULL)) * ((unsigned long long int) (((-9223372036854775807L - 1L)) * ((long int) ((int) (0))))))))) * (((unsigned long long int) (((-6) * ((int) (3))) * (-((int) (4))))) * (((8ULL) * (4ULL)) * ((unsigned long long int) (((long int) (-6)) * (-3L))))))); + printf("%ld\n", tf_4_var_132); +} + +int main() +{ + int Count; + + for (Count = 0; Count < 10; Count++) + { + printf("%d\n", (Count < 5) ? (Count*Count) : (Count * 3)); + } + + { + int c = 0; + #define ASSERT(X) assert(X) + static struct stru { int x; } a={'A'},b={'B'}; + static const struct stru2 { int x; } d = { 'D' }; + ASSERT('A'==(*(1?&a:&b)).x); + ASSERT('A'==(1?a:b).x); + ASSERT('A'==(c?b:a).x); + ASSERT('A'==(0?b:a).x); + c=1; + ASSERT('A'==(c?a:b).x); + ASSERT(sizeof(int) == sizeof(0 ? 'a' : c)); + ASSERT(sizeof(double) == sizeof(0 ? 'a' : 1.0)); + ASSERT(sizeof(double) == sizeof(0 ? 0.0 : 'a')); + ASSERT(sizeof(float) == sizeof(0 ? 'a' : 1.0f)); + ASSERT(sizeof(double) == sizeof(0 ? 0.0 : 1.0f)); + struct condstruct cs = { 38 }; + printf("%d\n", getme(&cs, 0)); + + // the following lines contain type mismatch errors in every ternary expression + //printf("comparing double with pointer : size = %d\n", sizeof(0 ? &c : 0.0)); + //printf("'%c' <> '%c'\n", (0 ? a : d).x, (1 ? a : d).x); + //0 ? a : 0.0; + } + + constantcond(); + + tst_yarpgen(); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/33_ternary_op.expect b/tinycc/tests/tests2/33_ternary_op.expect new file mode 100644 index 0000000..c21f5fb --- /dev/null +++ b/tinycc/tests/tests2/33_ternary_op.expect @@ -0,0 +1,14 @@ +33_ternary_op.c:26: warning: pointer/integer mismatch in conditional expression +0 +1 +4 +9 +16 +15 +18 +21 +24 +27 +152 +okay +1 diff --git a/tinycc/tests/tests2/34_array_assignment.c b/tinycc/tests/tests2/34_array_assignment.c new file mode 100644 index 0000000..5885c97 --- /dev/null +++ b/tinycc/tests/tests2/34_array_assignment.c @@ -0,0 +1,23 @@ +#include <stdio.h> + +int main() +{ + int a[4]; + + a[0] = 12; + a[1] = 23; + a[2] = 34; + a[3] = 45; + + printf("%d %d %d %d\n", a[0], a[1], a[2], a[3]); + + int b[4]; + + b = a; + + printf("%d %d %d %d\n", b[0], b[1], b[2], b[3]); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/34_array_assignment.expect b/tinycc/tests/tests2/34_array_assignment.expect new file mode 100644 index 0000000..9736bf5 --- /dev/null +++ b/tinycc/tests/tests2/34_array_assignment.expect @@ -0,0 +1,2 @@ +12 23 34 45 +12 23 34 45 diff --git a/tinycc/tests/tests2/35_sizeof.c b/tinycc/tests/tests2/35_sizeof.c new file mode 100644 index 0000000..672e87e --- /dev/null +++ b/tinycc/tests/tests2/35_sizeof.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +int main() +{ + char a; + short b; + + printf("%d %d\n", sizeof(char), sizeof(a)); + printf("%d %d\n", sizeof(short), sizeof(b)); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/35_sizeof.expect b/tinycc/tests/tests2/35_sizeof.expect new file mode 100644 index 0000000..534fb83 --- /dev/null +++ b/tinycc/tests/tests2/35_sizeof.expect @@ -0,0 +1,2 @@ +1 1 +2 2 diff --git a/tinycc/tests/tests2/36_array_initialisers.c b/tinycc/tests/tests2/36_array_initialisers.c new file mode 100644 index 0000000..ac56f5a --- /dev/null +++ b/tinycc/tests/tests2/36_array_initialisers.c @@ -0,0 +1,25 @@ +#include <stdio.h> + +extern int Array3[10]; +int Array3[] = { 12, 34, }; +int main() +{ + int Count; + + int Array[10] = { 12, 34, 56, 78, 90, 123, 456, 789, 8642, 9753 }; + + for (Count = 0; Count < 10; Count++) + printf("%d: %d\n", Count, Array[Count]); + + int Array2[10] = { 12, 34, 56, 78, 90, 123, 456, 789, 8642, 9753, }; + + for (Count = 0; Count < 10; Count++) + printf("%d: %d\n", Count, Array2[Count]); + + for (Count = 0; Count < 10; Count++) + printf("%d: %d\n", Count, Array3[Count]); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/36_array_initialisers.expect b/tinycc/tests/tests2/36_array_initialisers.expect new file mode 100644 index 0000000..4bb5ab7 --- /dev/null +++ b/tinycc/tests/tests2/36_array_initialisers.expect @@ -0,0 +1,30 @@ +0: 12 +1: 34 +2: 56 +3: 78 +4: 90 +5: 123 +6: 456 +7: 789 +8: 8642 +9: 9753 +0: 12 +1: 34 +2: 56 +3: 78 +4: 90 +5: 123 +6: 456 +7: 789 +8: 8642 +9: 9753 +0: 12 +1: 34 +2: 0 +3: 0 +4: 0 +5: 0 +6: 0 +7: 0 +8: 0 +9: 0 diff --git a/tinycc/tests/tests2/37_sprintf.c b/tinycc/tests/tests2/37_sprintf.c new file mode 100644 index 0000000..1dd1dce --- /dev/null +++ b/tinycc/tests/tests2/37_sprintf.c @@ -0,0 +1,17 @@ +#include <stdio.h> + +int main() +{ + char Buf[100]; + int Count; + + for (Count = 1; Count <= 20; Count++) + { + sprintf(Buf, "->%02d<-\n", Count); + printf("%s", Buf); + } + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/37_sprintf.expect b/tinycc/tests/tests2/37_sprintf.expect new file mode 100644 index 0000000..a643da8 --- /dev/null +++ b/tinycc/tests/tests2/37_sprintf.expect @@ -0,0 +1,20 @@ +->01<- +->02<- +->03<- +->04<- +->05<- +->06<- +->07<- +->08<- +->09<- +->10<- +->11<- +->12<- +->13<- +->14<- +->15<- +->16<- +->17<- +->18<- +->19<- +->20<- diff --git a/tinycc/tests/tests2/38_multiple_array_index.c b/tinycc/tests/tests2/38_multiple_array_index.c new file mode 100644 index 0000000..4e1868e --- /dev/null +++ b/tinycc/tests/tests2/38_multiple_array_index.c @@ -0,0 +1,32 @@ +#include <stdio.h> + +int main() +{ + int a[4][4]; + int b = 0; + int x; + int y; + + for (x = 0; x < 4; x++) + { + for (y = 0; y < 4; y++) + { + b++; + a[x][y] = b; + } + } + + for (x = 0; x < 4; x++) + { + printf("x=%d: ", x); + for (y = 0; y < 4; y++) + { + printf("%d ", a[x][y]); + } + printf("\n"); + } + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/38_multiple_array_index.expect b/tinycc/tests/tests2/38_multiple_array_index.expect new file mode 100644 index 0000000..747ad75 --- /dev/null +++ b/tinycc/tests/tests2/38_multiple_array_index.expect @@ -0,0 +1,4 @@ +x=0: 1 2 3 4 +x=1: 5 6 7 8 +x=2: 9 10 11 12 +x=3: 13 14 15 16 diff --git a/tinycc/tests/tests2/39_typedef.c b/tinycc/tests/tests2/39_typedef.c new file mode 100644 index 0000000..da73f71 --- /dev/null +++ b/tinycc/tests/tests2/39_typedef.c @@ -0,0 +1,65 @@ +#include <stdio.h> + +typedef int MyInt; + +struct FunStruct +{ + int i; + int j; +}; + +typedef struct FunStruct MyFunStruct; + +typedef MyFunStruct *MoreFunThanEver; + +int main() +{ + MyInt a = 1; + printf("%d\n", a); + + MyFunStruct b; + b.i = 12; + b.j = 34; + printf("%d,%d\n", b.i, b.j); + + MoreFunThanEver c = &b; + printf("%d,%d\n", c->i, c->j); + + return 0; +} + +/* "If the specification of an array type includes any type qualifiers, + the element type is so-qualified, not the array type." */ + +typedef int A[3]; +extern A const ca; +extern const A ca; +extern const int ca[3]; + +typedef A B[1][2]; +extern B const cb; +extern const B cb; +extern const int cb[1][2][3]; + +extern B b; +extern int b[1][2][3]; + +/* Funny but valid function declaration. */ +typedef int functype (int); +extern functype func; +int func(int i) +{ + return i + 1; +} + +/* Even funnier function decl and definition using typeof. */ +int set_anon_super(void); +int set_anon_super(void) +{ + return 42; +} +typedef int sas_type (void); +extern typeof(set_anon_super) set_anon_super; +extern sas_type set_anon_super; + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/39_typedef.expect b/tinycc/tests/tests2/39_typedef.expect new file mode 100644 index 0000000..b9050a9 --- /dev/null +++ b/tinycc/tests/tests2/39_typedef.expect @@ -0,0 +1,3 @@ +1 +12,34 +12,34 diff --git a/tinycc/tests/tests2/40_stdio.c b/tinycc/tests/tests2/40_stdio.c new file mode 100644 index 0000000..b986093 --- /dev/null +++ b/tinycc/tests/tests2/40_stdio.c @@ -0,0 +1,52 @@ +#include <stdio.h> + +int main() +{ + FILE *f = fopen("fred.txt", "w"); + fwrite("hello\nhello\n", 1, 12, f); + fclose(f); + + char freddy[7]; + f = fopen("fred.txt", "r"); + if (fread(freddy, 1, 6, f) != 6) + printf("couldn't read fred.txt\n"); + + freddy[6] = '\0'; + fclose(f); + + printf("%s", freddy); + + int InChar; + char ShowChar; + f = fopen("fred.txt", "r"); + while ( (InChar = fgetc(f)) != EOF) + { + ShowChar = InChar; + if (ShowChar < ' ') + ShowChar = '.'; + + printf("ch: %d '%c'\n", InChar, ShowChar); + } + fclose(f); + + f = fopen("fred.txt", "r"); + while ( (InChar = getc(f)) != EOF) + { + ShowChar = InChar; + if (ShowChar < ' ') + ShowChar = '.'; + + printf("ch: %d '%c'\n", InChar, ShowChar); + } + fclose(f); + + f = fopen("fred.txt", "r"); + while (fgets(freddy, sizeof(freddy), f) != NULL) + printf("x: %s", freddy); + + fclose(f); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/40_stdio.expect b/tinycc/tests/tests2/40_stdio.expect new file mode 100644 index 0000000..e08167a --- /dev/null +++ b/tinycc/tests/tests2/40_stdio.expect @@ -0,0 +1,27 @@ +hello +ch: 104 'h' +ch: 101 'e' +ch: 108 'l' +ch: 108 'l' +ch: 111 'o' +ch: 10 '.' +ch: 104 'h' +ch: 101 'e' +ch: 108 'l' +ch: 108 'l' +ch: 111 'o' +ch: 10 '.' +ch: 104 'h' +ch: 101 'e' +ch: 108 'l' +ch: 108 'l' +ch: 111 'o' +ch: 10 '.' +ch: 104 'h' +ch: 101 'e' +ch: 108 'l' +ch: 108 'l' +ch: 111 'o' +ch: 10 '.' +x: hello +x: hello diff --git a/tinycc/tests/tests2/41_hashif.c b/tinycc/tests/tests2/41_hashif.c new file mode 100644 index 0000000..cb37b9e --- /dev/null +++ b/tinycc/tests/tests2/41_hashif.c @@ -0,0 +1,85 @@ +#include <stdio.h> + +int main() +{ + printf("#include test\n"); + +#if 1 +#if 0 + printf("a\n"); +#else + printf("b\n"); +#endif +#else +#if 0 + printf("c\n"); +#else + printf("d\n"); +#endif +#endif + +#if 0 +#if 1 + printf("e\n"); +#else + printf("f\n"); +#endif +#else +#if 1 + printf("g\n"); +#else + printf("h\n"); +#endif +#endif + +#define DEF + +#ifdef DEF +#ifdef DEF + printf("i\n"); +#else + printf("j\n"); +#endif +#else +#ifdef DEF + printf("k\n"); +#else + printf("l\n"); +#endif +#endif + +#ifndef DEF +#ifndef DEF + printf("m\n"); +#else + printf("n\n"); +#endif +#else +#ifndef DEF + printf("o\n"); +#else + printf("p\n"); +#endif +#endif + +#define ONE 1 +#define ZERO 0 + +#if ONE +#if ZERO + printf("q\n"); +#else + printf("r\n"); +#endif +#else +#if ZERO + printf("s\n"); +#else + printf("t\n"); +#endif +#endif + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/41_hashif.expect b/tinycc/tests/tests2/41_hashif.expect new file mode 100644 index 0000000..5fd414b --- /dev/null +++ b/tinycc/tests/tests2/41_hashif.expect @@ -0,0 +1,6 @@ +#include test +b +g +i +p +r diff --git a/tinycc/tests/tests2/42_function_pointer.c b/tinycc/tests/tests2/42_function_pointer.c new file mode 100644 index 0000000..697bd79 --- /dev/null +++ b/tinycc/tests/tests2/42_function_pointer.c @@ -0,0 +1,22 @@ +#include <stdio.h> + +int fred(int p) +{ + printf("yo %d\n", p); + return 42; +} + +int (*f)(int) = &fred; + +/* To test what this is supposed to test the destination function + (fprint here) must not be called directly anywhere in the test. */ +int (*fprintfptr)(FILE *, const char *, ...) = &fprintf; + +int main() +{ + fprintfptr(stdout, "%d\n", (*f)(24)); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/42_function_pointer.expect b/tinycc/tests/tests2/42_function_pointer.expect new file mode 100644 index 0000000..6c8b6ce --- /dev/null +++ b/tinycc/tests/tests2/42_function_pointer.expect @@ -0,0 +1,2 @@ +yo 24 +42 diff --git a/tinycc/tests/tests2/43_void_param.c b/tinycc/tests/tests2/43_void_param.c new file mode 100644 index 0000000..de17098 --- /dev/null +++ b/tinycc/tests/tests2/43_void_param.c @@ -0,0 +1,15 @@ +#include <stdio.h> + +void fred(void) +{ + printf("yo\n"); +} + +int main() +{ + fred(); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/43_void_param.expect b/tinycc/tests/tests2/43_void_param.expect new file mode 100644 index 0000000..092bfb9 --- /dev/null +++ b/tinycc/tests/tests2/43_void_param.expect @@ -0,0 +1 @@ +yo diff --git a/tinycc/tests/tests2/44_scoped_declarations.c b/tinycc/tests/tests2/44_scoped_declarations.c new file mode 100644 index 0000000..f38664f --- /dev/null +++ b/tinycc/tests/tests2/44_scoped_declarations.c @@ -0,0 +1,17 @@ +#include <stdio.h> + +int main() +{ + int a; + + for (a = 0; a < 2; a++) + { + int b = a; + } + + printf("it's all good\n"); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/44_scoped_declarations.expect b/tinycc/tests/tests2/44_scoped_declarations.expect new file mode 100644 index 0000000..231ccc0 --- /dev/null +++ b/tinycc/tests/tests2/44_scoped_declarations.expect @@ -0,0 +1 @@ +it's all good diff --git a/tinycc/tests/tests2/45_empty_for.c b/tinycc/tests/tests2/45_empty_for.c new file mode 100644 index 0000000..7cef513 --- /dev/null +++ b/tinycc/tests/tests2/45_empty_for.c @@ -0,0 +1,18 @@ +#include <stdio.h> + +int main() +{ + int Count = 0; + + for (;;) + { + Count++; + printf("%d\n", Count); + if (Count >= 10) + break; + } + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/45_empty_for.expect b/tinycc/tests/tests2/45_empty_for.expect new file mode 100644 index 0000000..f00c965 --- /dev/null +++ b/tinycc/tests/tests2/45_empty_for.expect @@ -0,0 +1,10 @@ +1 +2 +3 +4 +5 +6 +7 +8 +9 +10 diff --git a/tinycc/tests/tests2/46_grep.c b/tinycc/tests/tests2/46_grep.c new file mode 100644 index 0000000..acda793 --- /dev/null +++ b/tinycc/tests/tests2/46_grep.c @@ -0,0 +1,570 @@ +/* + * The information in this document is subject to change + * without notice and should not be construed as a commitment + * by Digital Equipment Corporation or by DECUS. + * + * Neither Digital Equipment Corporation, DECUS, nor the authors + * assume any responsibility for the use or reliability of this + * document or the described software. + * + * Copyright (C) 1980, DECUS + * + * General permission to copy or modify, but not for profit, is + * hereby granted, provided that the above copyright notice is + * included and reference made to the fact that reproduction + * privileges were granted by DECUS. + */ +#include <stdio.h> +#include <stdlib.h> +#include <ctype.h> // tolower() + +/* + * grep + * + * Runs on the Decus compiler or on vms, On vms, define as: + * grep :== "$disk:[account]grep" (native) + * grep :== "$disk:[account]grep grep" (Decus) + * See below for more information. + */ + +char *documentation[] = { + "grep searches a file for a given pattern. Execute by", + " grep [flags] regular_expression file_list\n", + "Flags are single characters preceded by '-':", + " -c Only a count of matching lines is printed", + " -f Print file name for matching lines switch, see below", + " -n Each line is preceded by its line number", + " -v Only print non-matching lines\n", + "The file_list is a list of files (wildcards are acceptable on RSX modes).", + "\nThe file name is normally printed if there is a file given.", + "The -f flag reverses this action (print name no file, not if more).\n", + 0 }; + +char *patdoc[] = { + "The regular_expression defines the pattern to search for. Upper- and", + "lower-case are always ignored. Blank lines never match. The expression", + "should be quoted to prevent file-name translation.", + "x An ordinary character (not mentioned below) matches that character.", + "'\\' The backslash quotes any character. \"\\$\" matches a dollar-sign.", + "'^' A circumflex at the beginning of an expression matches the", + " beginning of a line.", + "'$' A dollar-sign at the end of an expression matches the end of a line.", + "'.' A period matches any character except \"new-line\".", + "':a' A colon matches a class of characters described by the following", + "':d' character. \":a\" matches any alphabetic, \":d\" matches digits,", + "':n' \":n\" matches alphanumerics, \": \" matches spaces, tabs, and", + "': ' other control characters, such as new-line.", + "'*' An expression followed by an asterisk matches zero or more", + " occurrences of that expression: \"fo*\" matches \"f\", \"fo\"", + " \"foo\", etc.", + "'+' An expression followed by a plus sign matches one or more", + " occurrences of that expression: \"fo+\" matches \"fo\", etc.", + "'-' An expression followed by a minus sign optionally matches", + " the expression.", + "'[]' A string enclosed in square brackets matches any character in", + " that string, but no others. If the first character in the", + " string is a circumflex, the expression matches any character", + " except \"new-line\" and the characters in the string. For", + " example, \"[xyz]\" matches \"xx\" and \"zyx\", while \"[^xyz]\"", + " matches \"abc\" but not \"axb\". A range of characters may be", + " specified by two characters separated by \"-\". Note that,", + " [a-z] matches alphabetics, while [z-a] never matches.", + "The concatenation of regular expressions is a regular expression.", + 0}; + +#define LMAX 512 +#define PMAX 256 + +#define CHAR 1 +#define BOL 2 +#define EOL 3 +#define ANY 4 +#define CLASS 5 +#define NCLASS 6 +#define STAR 7 +#define PLUS 8 +#define MINUS 9 +#define ALPHA 10 +#define DIGIT 11 +#define NALPHA 12 +#define PUNCT 13 +#define RANGE 14 +#define ENDPAT 15 + +int cflag=0, fflag=0, nflag=0, vflag=0, nfile=0, debug=0; + +char *pp, lbuf[LMAX], pbuf[PMAX]; + +char *cclass(); +char *pmatch(); +void store(int); +void error(char *); +void badpat(char *, char *, char *); +int match(void); + + +/*** Display a file name *******************************/ +void file(char *s) +{ + printf("File %s:\n", s); +} + +/*** Report unopenable file ****************************/ +void cant(char *s) +{ + fprintf(stderr, "%s: cannot open\n", s); +} + +/*** Give good help ************************************/ +void help(char **hp) +{ + char **dp; + + for (dp = hp; *dp; ++dp) + printf("%s\n", *dp); +} + +/*** Display usage summary *****************************/ +void usage(char *s) +{ + fprintf(stderr, "?GREP-E-%s\n", s); + fprintf(stderr, + "Usage: grep [-cfnv] pattern [file ...]. grep ? for help\n"); + exit(1); +} + +/*** Compile the pattern into global pbuf[] ************/ +void compile(char *source) +{ + char *s; /* Source string pointer */ + char *lp; /* Last pattern pointer */ + int c; /* Current character */ + int o; /* Temp */ + char *spp; /* Save beginning of pattern */ + + s = source; + if (debug) + printf("Pattern = \"%s\"\n", s); + pp = pbuf; + while (c = *s++) { + /* + * STAR, PLUS and MINUS are special. + */ + if (c == '*' || c == '+' || c == '-') { + if (pp == pbuf || + (o=pp[-1]) == BOL || + o == EOL || + o == STAR || + o == PLUS || + o == MINUS) + badpat("Illegal occurrence op.", source, s); + store(ENDPAT); + store(ENDPAT); + spp = pp; /* Save pattern end */ + while (--pp > lp) /* Move pattern down */ + *pp = pp[-1]; /* one byte */ + *pp = (c == '*') ? STAR : + (c == '-') ? MINUS : PLUS; + pp = spp; /* Restore pattern end */ + continue; + } + /* + * All the rest. + */ + lp = pp; /* Remember start */ + switch(c) { + + case '^': + store(BOL); + break; + + case '$': + store(EOL); + break; + + case '.': + store(ANY); + break; + + case '[': + s = cclass(source, s); + break; + + case ':': + if (*s) { + switch(tolower(c = *s++)) { + + case 'a': + case 'A': + store(ALPHA); + break; + + case 'd': + case 'D': + store(DIGIT); + break; + + case 'n': + case 'N': + store(NALPHA); + break; + + case ' ': + store(PUNCT); + break; + + default: + badpat("Unknown : type", source, s); + + } + break; + } + else badpat("No : type", source, s); + + case '\\': + if (*s) + c = *s++; + + default: + store(CHAR); + store(tolower(c)); + } + } + store(ENDPAT); + store(0); /* Terminate string */ + if (debug) { + for (lp = pbuf; lp < pp;) { + if ((c = (*lp++ & 0377)) < ' ') + printf("\\%o ", c); + else printf("%c ", c); + } + printf("\n"); + } +} + +/*** Compile a class (within []) ***********************/ +char *cclass(char *source, char *src) + /* char *source; // Pattern start -- for error msg. */ + /* char *src; // Class start */ +{ + char *s; /* Source pointer */ + char *cp; /* Pattern start */ + int c; /* Current character */ + int o; /* Temp */ + + s = src; + o = CLASS; + if (*s == '^') { + ++s; + o = NCLASS; + } + store(o); + cp = pp; + store(0); /* Byte count */ + while ((c = *s++) && c!=']') { + if (c == '\\') { /* Store quoted char */ + if ((c = *s++) == '\0') /* Gotta get something */ + badpat("Class terminates badly", source, s); + else store(tolower(c)); + } + else if (c == '-' && + (pp - cp) > 1 && *s != ']' && *s != '\0') { + c = pp[-1]; /* Range start */ + pp[-1] = RANGE; /* Range signal */ + store(c); /* Re-store start */ + c = *s++; /* Get end char and*/ + store(tolower(c)); /* Store it */ + } + else { + store(tolower(c)); /* Store normal char */ + } + } + if (c != ']') + badpat("Unterminated class", source, s); + if ((c = (pp - cp)) >= 256) + badpat("Class too large", source, s); + if (c == 0) + badpat("Empty class", source, s); + *cp = c; + return(s); +} + +/*** Store an entry in the pattern buffer **************/ +void store(int op) +{ + if (pp >= &pbuf[PMAX]) + error("Pattern too complex\n"); + *pp++ = op; +} + +/*** Report a bad pattern specification ****************/ +void badpat(char *message, char *source, char *stop) + /* char *message; // Error message */ + /* char *source; // Pattern start */ + /* char *stop; // Pattern end */ +{ + fprintf(stderr, "-GREP-E-%s, pattern is\"%s\"\n", message, source); + fprintf(stderr, "-GREP-E-Stopped at byte %ld, '%c'\n", + stop-source, stop[-1]); + error("?GREP-E-Bad pattern\n"); +} + +/*** Scan the file for the pattern in pbuf[] ***********/ +void grep(FILE *fp, char *fn) + /* FILE *fp; // File to process */ + /* char *fn; // File name (for -f option) */ +{ + int lno, count, m; + + lno = 0; + count = 0; + while (fgets(lbuf, LMAX, fp)) { + ++lno; + m = match(); + if ((m && !vflag) || (!m && vflag)) { + ++count; + if (!cflag) { + if (fflag && fn) { + file(fn); + fn = 0; + } + if (nflag) + printf("%d\t", lno); + printf("%s\n", lbuf); + } + } + } + if (cflag) { + if (fflag && fn) + file(fn); + printf("%d\n", count); + } +} + +/*** Match line (lbuf) with pattern (pbuf) return 1 if match ***/ +int match() +{ + char *l; /* Line pointer */ + + for (l = lbuf; *l; ++l) { + if (pmatch(l, pbuf)) + return(1); + } + return(0); +} + +/*** Match partial line with pattern *******************/ +char *pmatch(char *line, char *pattern) + /* char *line; // (partial) line to match */ + /* char *pattern; // (partial) pattern to match */ +{ + char *l; /* Current line pointer */ + char *p; /* Current pattern pointer */ + char c; /* Current character */ + char *e; /* End for STAR and PLUS match */ + int op; /* Pattern operation */ + int n; /* Class counter */ + char *are; /* Start of STAR match */ + + l = line; + if (debug > 1) + printf("pmatch(\"%s\")\n", line); + p = pattern; + while ((op = *p++) != ENDPAT) { + if (debug > 1) + printf("byte[%ld] = 0%o, '%c', op = 0%o\n", + l-line, *l, *l, op); + switch(op) { + + case CHAR: + if (tolower(*l++) != *p++) + return(0); + break; + + case BOL: + if (l != lbuf) + return(0); + break; + + case EOL: + if (*l != '\0') + return(0); + break; + + case ANY: + if (*l++ == '\0') + return(0); + break; + + case DIGIT: + if ((c = *l++) < '0' || (c > '9')) + return(0); + break; + + case ALPHA: + c = tolower(*l++); + if (c < 'a' || c > 'z') + return(0); + break; + + case NALPHA: + c = tolower(*l++); + if (c >= 'a' && c <= 'z') + break; + else if (c < '0' || c > '9') + return(0); + break; + + case PUNCT: + c = *l++; + if (c == 0 || c > ' ') + return(0); + break; + + case CLASS: + case NCLASS: + c = tolower(*l++); + n = *p++ & 0377; + do { + if (*p == RANGE) { + p += 3; + n -= 2; + if (c >= p[-2] && c <= p[-1]) + break; + } + else if (c == *p++) + break; + } while (--n > 1); + if ((op == CLASS) == (n <= 1)) + return(0); + if (op == CLASS) + p += n - 2; + break; + + case MINUS: + e = pmatch(l, p); /* Look for a match */ + while (*p++ != ENDPAT); /* Skip over pattern */ + if (e) /* Got a match? */ + l = e; /* Yes, update string */ + break; /* Always succeeds */ + + case PLUS: /* One or more ... */ + if ((l = pmatch(l, p)) == 0) + return(0); /* Gotta have a match */ + case STAR: /* Zero or more ... */ + are = l; /* Remember line start */ + while (*l && (e = pmatch(l, p))) + l = e; /* Get longest match */ + while (*p++ != ENDPAT); /* Skip over pattern */ + while (l > are) { /* Try to match rest */ + if (e = pmatch(l, p)) + return(e); + --l; /* Nope, try earlier */ + } + if (e = pmatch(l, p)) + return(e); + return(0); /* Nothing else worked */ + + default: + printf("Bad op code %d\n", op); + error("Cannot happen -- match\n"); + } + } + return(l); +} + +/*** Report an error ***********************************/ +void error(char *s) +{ + fprintf(stderr, "%s", s); + exit(1); +} + +/*** Main program - parse arguments & grep *************/ +int main(int argc, char **argv) +{ + char *p; + int c, i; + int gotpattern; + + FILE *f; + + if (argc <= 1) + usage("No arguments"); + if (argc == 2 && argv[1][0] == '?' && argv[1][1] == 0) { + help(documentation); + help(patdoc); + return 0; + } + nfile = argc-1; + gotpattern = 0; + for (i=1; i < argc; ++i) { + p = argv[i]; + if (*p == '-') { + ++p; + while (c = *p++) { + switch(tolower(c)) { + + case '?': + help(documentation); + break; + + case 'C': + case 'c': + ++cflag; + break; + + case 'D': + case 'd': + ++debug; + break; + + case 'F': + case 'f': + ++fflag; + break; + + case 'n': + case 'N': + ++nflag; + break; + + case 'v': + case 'V': + ++vflag; + break; + + default: + usage("Unknown flag"); + } + } + argv[i] = 0; + --nfile; + } else if (!gotpattern) { + compile(p); + argv[i] = 0; + ++gotpattern; + --nfile; + } + } + if (!gotpattern) + usage("No pattern"); + if (nfile == 0) + grep(stdin, 0); + else { + fflag = fflag ^ (nfile > 0); + for (i=1; i < argc; ++i) { + if (p = argv[i]) { + if ((f=fopen(p, "r")) == NULL) + cant(p); + else { + grep(f, p); + fclose(f); + } + } + } + } + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/46_grep.expect b/tinycc/tests/tests2/46_grep.expect new file mode 100644 index 0000000..e8a6791 --- /dev/null +++ b/tinycc/tests/tests2/46_grep.expect @@ -0,0 +1,3 @@ +File 46_grep.c: +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ + diff --git a/tinycc/tests/tests2/47_switch_return.c b/tinycc/tests/tests2/47_switch_return.c new file mode 100644 index 0000000..1ec7924 --- /dev/null +++ b/tinycc/tests/tests2/47_switch_return.c @@ -0,0 +1,24 @@ +#include <stdio.h> + +void fred(int x) +{ + switch (x) + { + case 1: printf("1\n"); return; + case 2: printf("2\n"); break; + case 3: printf("3\n"); return; + } + + printf("out\n"); +} + +int main() +{ + fred(1); + fred(2); + fred(3); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/47_switch_return.expect b/tinycc/tests/tests2/47_switch_return.expect new file mode 100644 index 0000000..b6deb7e --- /dev/null +++ b/tinycc/tests/tests2/47_switch_return.expect @@ -0,0 +1,4 @@ +1 +2 +out +3 diff --git a/tinycc/tests/tests2/48_nested_break.c b/tinycc/tests/tests2/48_nested_break.c new file mode 100644 index 0000000..5bc5ba4 --- /dev/null +++ b/tinycc/tests/tests2/48_nested_break.c @@ -0,0 +1,26 @@ +#include <stdio.h> + +int main() +{ + int a; + char b; + + a = 0; + while (a < 2) + { + printf("%d", a++); + break; + + b = 'A'; + while (b < 'C') + { + printf("%c", b++); + } + printf("e"); + } + printf("\n"); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/48_nested_break.expect b/tinycc/tests/tests2/48_nested_break.expect new file mode 100644 index 0000000..573541a --- /dev/null +++ b/tinycc/tests/tests2/48_nested_break.expect @@ -0,0 +1 @@ +0 diff --git a/tinycc/tests/tests2/49_bracket_evaluation.c b/tinycc/tests/tests2/49_bracket_evaluation.c new file mode 100644 index 0000000..0cbe57d --- /dev/null +++ b/tinycc/tests/tests2/49_bracket_evaluation.c @@ -0,0 +1,23 @@ +#include <stdio.h> + +struct point +{ + double x; + double y; +}; + +struct point point_array[100]; + +int main() +{ + int my_point = 10; + + point_array[my_point].x = 12.34; + point_array[my_point].y = 56.78; + + printf("%f, %f\n", point_array[my_point].x, point_array[my_point].y); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/49_bracket_evaluation.expect b/tinycc/tests/tests2/49_bracket_evaluation.expect new file mode 100644 index 0000000..1da66db --- /dev/null +++ b/tinycc/tests/tests2/49_bracket_evaluation.expect @@ -0,0 +1 @@ +12.340000, 56.780000 diff --git a/tinycc/tests/tests2/50_logical_second_arg.c b/tinycc/tests/tests2/50_logical_second_arg.c new file mode 100644 index 0000000..ddec08c --- /dev/null +++ b/tinycc/tests/tests2/50_logical_second_arg.c @@ -0,0 +1,29 @@ +#include <stdio.h> + +int fred() +{ + printf("fred\n"); + return 0; +} + +int joe() +{ + printf("joe\n"); + return 1; +} + +int main() +{ + printf("%d\n", fred() && joe()); + printf("%d\n", fred() || joe()); + printf("%d\n", joe() && fred()); + printf("%d\n", joe() || fred()); + printf("%d\n", fred() && (1 + joe())); + printf("%d\n", fred() || (0 + joe())); + printf("%d\n", joe() && (0 + fred())); + printf("%d\n", joe() || (1 + fred())); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/50_logical_second_arg.expect b/tinycc/tests/tests2/50_logical_second_arg.expect new file mode 100644 index 0000000..d6174ae --- /dev/null +++ b/tinycc/tests/tests2/50_logical_second_arg.expect @@ -0,0 +1,20 @@ +fred +0 +fred +joe +1 +joe +fred +0 +joe +1 +fred +0 +fred +joe +1 +joe +fred +0 +joe +1 diff --git a/tinycc/tests/tests2/51_static.c b/tinycc/tests/tests2/51_static.c new file mode 100644 index 0000000..d6c0917 --- /dev/null +++ b/tinycc/tests/tests2/51_static.c @@ -0,0 +1,30 @@ +#include <stdio.h> + +static int fred = 1234; +static int joe; + +void henry() +{ + static int fred = 4567; + + printf("%d\n", fred); + fred++; +} + +int main() +{ + printf("%d\n", fred); + henry(); + henry(); + henry(); + henry(); + printf("%d\n", fred); + fred = 8901; + joe = 2345; + printf("%d\n", fred); + printf("%d\n", joe); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/51_static.expect b/tinycc/tests/tests2/51_static.expect new file mode 100644 index 0000000..18224fa --- /dev/null +++ b/tinycc/tests/tests2/51_static.expect @@ -0,0 +1,8 @@ +1234 +4567 +4568 +4569 +4570 +1234 +8901 +2345 diff --git a/tinycc/tests/tests2/52_unnamed_enum.c b/tinycc/tests/tests2/52_unnamed_enum.c new file mode 100644 index 0000000..d0395b2 --- /dev/null +++ b/tinycc/tests/tests2/52_unnamed_enum.c @@ -0,0 +1,27 @@ +#include <stdio.h> + +enum fred { a, b, c }; + +int main() +{ + printf("a=%d\n", a); + printf("b=%d\n", b); + printf("c=%d\n", c); + + enum fred d; + + typedef enum { e, f, g } h; + typedef enum { i, j, k } m; + + printf("e=%d\n", e); + printf("f=%d\n", f); + printf("g=%d\n", g); + + printf("i=%d\n", i); + printf("j=%d\n", j); + printf("k=%d\n", k); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/52_unnamed_enum.expect b/tinycc/tests/tests2/52_unnamed_enum.expect new file mode 100644 index 0000000..84f2ac8 --- /dev/null +++ b/tinycc/tests/tests2/52_unnamed_enum.expect @@ -0,0 +1,9 @@ +a=0 +b=1 +c=2 +e=0 +f=1 +g=2 +i=0 +j=1 +k=2 diff --git a/tinycc/tests/tests2/54_goto.c b/tinycc/tests/tests2/54_goto.c new file mode 100644 index 0000000..2e151bb --- /dev/null +++ b/tinycc/tests/tests2/54_goto.c @@ -0,0 +1,56 @@ +#include <stdio.h> + +void fred() +{ + printf("In fred()\n"); + goto done; + printf("In middle\n"); +done: + printf("At end\n"); +} + +void joe() +{ + int b = 5678; + + printf("In joe()\n"); + + { + int c = 1234; + printf("c = %d\n", c); + goto outer; + printf("uh-oh\n"); + } + +outer: + + printf("done\n"); +} + +void henry() +{ + int a; + + printf("In henry()\n"); + goto inner; + + { + int b; +inner: + b = 1234; + printf("b = %d\n", b); + } + + printf("done\n"); +} + +int main() +{ + fred(); + joe(); + henry(); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/54_goto.expect b/tinycc/tests/tests2/54_goto.expect new file mode 100644 index 0000000..8e553fa --- /dev/null +++ b/tinycc/tests/tests2/54_goto.expect @@ -0,0 +1,8 @@ +In fred() +At end +In joe() +c = 1234 +done +In henry() +b = 1234 +done diff --git a/tinycc/tests/tests2/55_lshift_type.c b/tinycc/tests/tests2/55_lshift_type.c new file mode 100644 index 0000000..aa3e51a --- /dev/null +++ b/tinycc/tests/tests2/55_lshift_type.c @@ -0,0 +1,52 @@ +/* $Id: lshift-type.c 53089 2012-07-06 11:18:26Z vinc17/ypig $ + +Tests on left-shift type, written by Vincent Lefevre <vincent@vinc17.net>. + +ISO C99 TC3 says: [6.5.7#3] "The integer promotions are performed on +each of the operands. The type of the result is that of the promoted +left operand." +*/ + +#include <stdio.h> + +#define PTYPE(M) ((M) < 0 || -(M) < 0 ? -1 : 1) * (int) sizeof((M)+0) +#define CHECK(X,T) check(#X, PTYPE(X), PTYPE((X) << (T) 1)) +#define TEST1(X,T) do { CHECK(X,T); CHECK(X,unsigned T); } while (0) +#define TEST2(X) \ + do \ + { \ + TEST1((X),short); \ + TEST1((X),int); \ + TEST1((X),long); \ + TEST1((X),long long); \ + } \ + while (0) +#define TEST3(X,T) do { TEST2((T)(X)); TEST2((unsigned T)(X)); } while (0) +#define TEST4(X) \ + do \ + { \ + TEST3((X),short); \ + TEST3((X),int); \ + TEST3((X),long); \ + TEST3((X),long long); \ + } \ + while (0) + +static int debug, nfailed = 0; + +static void check (const char *s, int arg1, int shift) +{ + int failed = arg1 != shift; + if (debug || failed) + printf ("%s %d %d\n", s, arg1, shift); + nfailed += failed; +} + +int main (int argc, char **argv) +{ + debug = argc > 1; + TEST4(1); + TEST4(-1); + printf ("%d test(s) failed\n", nfailed); + return nfailed != 0; +} diff --git a/tinycc/tests/tests2/55_lshift_type.expect b/tinycc/tests/tests2/55_lshift_type.expect new file mode 100644 index 0000000..8523767 --- /dev/null +++ b/tinycc/tests/tests2/55_lshift_type.expect @@ -0,0 +1 @@ +0 test(s) failed diff --git a/tinycc/tests/tests2/60_errors_and_warnings.c b/tinycc/tests/tests2/60_errors_and_warnings.c new file mode 100644 index 0000000..960c64f --- /dev/null +++ b/tinycc/tests/tests2/60_errors_and_warnings.c @@ -0,0 +1,466 @@ +#if defined test_56_btype_excess_1 +struct A {} int i; + +#elif defined test_57_btype_excess_2 +char int i; + +#elif defined test_58_function_redefinition +int f(void) { return 0; } +int f(void) { return 1; } + +#elif defined test_global_redefinition +int xxx = 1; +int xxx; +int xxx = 2; + +#elif defined test_59_function_array +int (*fct)[42](int x); + +#elif defined test_60_enum_redefinition +enum color { RED, GREEN, BLUE }; +enum color { R, G, B }; +enum color c; + +#elif defined test_62_enumerator_redefinition +enum color { RED, GREEN, BLUE }; +enum rgb { RED, G, B}; +enum color c = RED; + +#elif defined test_63_local_enumerator_redefinition +enum { + FOO, + BAR +}; + +int main(void) +{ + enum { + FOO = 2, + BAR + }; + + return BAR - FOO; +} + +#elif defined test_61_undefined_enum +enum rgb3 c = 42; + +#elif defined test_74_non_const_init +int i = i++; + +#elif defined test_pointer_assignment + +void (*f1)(void); +void f2(void) {} + +struct s1 *ps1; +struct s2 *ps2; + +void *v1, **v2, ***v3; + +enum e1 { a = 4 } e10, *e11, *e12; +enum e2 { b = -4 } e20, *e21; +enum e3 { c = 5000000000LL } e30; + +int *ip; +unsigned int *up; +long *lp; +long long *llp; + +char **c1; +char const **c2; +unsigned char **u1; + +int no_main () +{ + // function + f1 = f2; + // struct + ps1 = ps2; + // void* + v1 = v3; + v2 = v3; + + // enum + e11 = e12; + e11 = e21; + e11 = &e10; + ip = &e10; + ip = &e20; + up = &e10; + up = &e20; + up = &e30; + + lp = ip; + lp = llp; + + // constness + c1 = c2; + *c1 = *c2; + **c1 = **c2; + + // unsigned = signed + u1 = c2; + *u1 = *c2; + **u1 = **c2; + + c2 = c1; + *c2 = *c1; + **c2 = **c1; + + return 0; +} + + +#elif defined test_enum_compat +enum e4; +enum e5; +void f3(enum e4 e); +void f3(enum e5 e); + +#elif defined test_enum_compat_2 +enum e6 { E1 = -1, E0 }; +void f3(enum e6); +void f3(int); // should work as int and e6 are compatible +void f4(enum e6 e); +void f4(unsigned e); // should error as unsigned and e6 are incompatible + +#elif defined test_ptr_to_str +void f() { _Generic((int const *[]){0}, int:0); } +#elif defined test_fnptr_to_str +void f() { _Generic((int (*(*)(float,char))(double,int)){0}, int:0); } +#elif defined test_array_to_str +void f() { _Generic((int(*)[3]){0}, int:0); } +#elif defined test_duplicate_def_1 +static enum myenum { L = -1 } L; +#elif defined test_duplicate_def_2 +void foo(void) { +static enum myenum { L = -1 } L; +} +#elif defined test_abstract_decls +int bar(const char *()); // abstract declarator here is okay +int bar (const char *(*g)()) // should match this 'g' argument +{ + g(); + return 42; +} +int foo(int ()) // abstract decl is wrong in definitions +{ + return 0; +#elif defined test_invalid_1 +void f(char*); +void g(void) { + f((char[]){1, ,}); +} +#elif defined test_invalid_2 +int ga = 0.42 { 2 }; +#elif defined test_invalid_3 +struct S { int a, b; }; +struct T { struct S x; }; +struct T gt = { 42 a: 1, 43 }; +#elif defined test_invalid_4 +enum E { + x = 1 / 0 +}; +#elif defined test_conflicting_types +int i; +void foo(void) { + int i; + { + extern double i; + i = 42.2; + } +} +#elif defined test_nested_types +union u { + union u { + int i; + } m; +}; +#elif defined test_vla_1 +int X=1; + +int main(void) { + int t[][][X]; +} +#elif defined test_invalid_alignas +/* _Alignas is no type qualifier */ +void * _Alignas(16) p1; + +#elif defined test_static_assert + +#define ONE 0 + _Static_assert(ONE == 0, "don't show me this"); + struct x{ _Static_assert(ONE == 1, "ONE is not 1"); }; + +#elif defined test_static_assert_2 + _Static_assert(1, "1"" is 1"); +struct y { _Static_assert(0, "0"" is 0"); }; + +#elif defined test_static_assert_c2x + _Static_assert(1); +struct z { _Static_assert(0); } + +#elif defined test_static_assert_empty_string + _Static_assert(0,""); + +#elif defined test_void_array + void t[3]; + +#elif defined test_incomplete_enum_array + enum e t[3]; + +#elif defined test_incomplete_struct_array + struct s t[3]; + +#elif defined test_const_fun_array + typedef void f(void); + const f t[3]; + +#elif defined test_incomplete_array_array + int t[][3]; // gr: not an error, see below + +/******************************************************************/ +#elif defined test_extern_array +int iii[] = { 1,2,3 }; +extern int iii[]; +int x[]; +int x[2]; +int x[]; +int x[2]; +int x[]; +extern int x[2]; +extern int x[]; +int x[3]; + +/******************************************************************/ +#elif defined test_func_1 \ + || defined test_func_2 \ + || defined test_func_3 \ + || defined test_func_4 \ + || defined test_func_5 \ + || defined test_func_6 +#if defined test_func_1 +int hello(int); +#elif defined test_func_4 +static int hello(int); +#endif +int main () { +#if defined test_func_6 + static +#endif + int hello(int); + hello(123); + return 0; +} +int printf(const char*, ...); +#if defined test_func_3 +static int hello(int a) +#elif defined test_func_5 +int hello(int a, int b) +#else +int hello(int a) +#endif +{ printf("%s: a = %d\n", __FUNCTION__, a); return 0; } + +/******************************************************************/ +#elif defined test_var_1 \ + || defined test_var_2 \ + || defined test_var_3 +#define P(n,v) printf("%-5s: %d ; %d\n", __FUNCTION__, n, v) +#if defined test_var_1 +int xxx[]; +#endif +int bar(); +int printf(const char*, ...); +int main () +{ +#if !defined test_var_3 + int xxx = 2; +#endif + { + extern int xxx[ +#if defined test_var_3 + 2 +#endif + ]; + P(1, xxx[0]); + xxx[0] += 2; + } +#if !defined test_var_3 + P(2, xxx); +#endif + bar(123); + return 0; +} +int xxx[1] = {1}; +int bar() { P(3, xxx[0]); return 0; } + +#elif defined test_var_4 +struct yyy { int y; }; +struct zzz; +void f1() { + extern char *x; + extern char **xx; + extern struct yyy y; + extern struct yyy *yy; + extern struct zzz z; + extern struct zzz *zz; +} +void f2() { + extern char *x; + extern char **xx; + extern struct yyy y; + extern struct yyy *yy; + extern struct zzz z; + extern struct zzz *zz; +} +struct yyy y, *yy; +struct zzz { int z; } z, *zz; + +/******************************************************************/ +#elif defined test_long_double_type_for_win32 + +int main() +{ + double *a = 0; + long double *b = a; + int n = _Generic(*a, double:0, long double:1); +} + +#elif defined test_stray_backslash +#define x \a +x + +#elif defined test_stray_backslash2 +int printf(const char*, ...); +int main() +{ +#define _S(x) #x +#define S(x) _S(x) + printf("%sn\n", S(\\)); +} + +/******************************************************************/ +#elif defined test_var_array + +static struct var_len { int i; const char str[]; } var_array[] = +{ { 1, "abcdefghijklmnopqrstuvwxyz" }, + { 2, "longlonglonglonglong" }, + { 3, "tst3" } }; + +#elif defined test_var_array2 + +struct c1 { int a; int b[]; }; +struct c1 c1 = { 1, { 2, 3, 4 } }; + +struct c2 { int c; struct c1 c1; }; +struct c2 c2 = { 1, { 2, { 3, 4, 5 }}}; + +#elif defined test_var_array3 +/* similar to test_var_array2 but with string initializers */ +struct A { int a; char b[]; }; +struct A a = { 1, "1" }; +struct B { struct A a; }; +struct B b = { { 1, "1" } }; +/******************************************************************/ +#elif defined test_default_int_type +n; // warn +f(); // don't warn + +#elif defined test_invalid_global_stmtexpr +n[sizeof({3;})]; // crashed in block() due to missing local scope + +#elif defined test_invalid_tokckill +f(){"12"3;} // second const token killed the value of the first + +/******************************************************************/ +#elif defined test_duplicate_member +struct S { + int a, a; +}; +#elif defined test_duplicate_member_anon +struct S1 { + int b; + struct { + int b; + } c; +}; +struct S2 { + int d; + struct { + int d; + }; +}; + +/******************************************************************/ +#elif defined test_conflicting_array_definition +extern int array[2]; +int array[] = { 1, 2, 3 }; + +#elif defined test_incompatible_local_redef +void foo (void) +{ + typedef int localfunctype (int); + extern localfunctype func2; + typedef void localfunctype (int, int); +} + +#elif defined test_cast_from_void +void v() {} +int f() { return v(); } + +#elif defined test_switch_W1 || defined test_switch_W2 \ + || defined test_switch_W3 || defined test_switch_W4 +#if defined test_switch_W1 +#pragma comment(option, "-Wall") +#elif defined test_switch_W2 +#pragma comment(option, "-Wunsupported -Wno-implicit-function-declaration -Wstuff") +#elif defined test_switch_W3 +#pragma comment(option, "-Wwrite-strings -Werror=discarded-qualifiers") +#elif defined test_switch_W4 +#pragma comment(option, "-Wunsupported -Wno-error=implicit-function-declaration -Werror") +#endif +void func() +{ + char *ccp = "123"; + fink(); +} +__attribute__((stuff)) int fink() {return 0;} + +#elif defined test_invalid_funcparam_1 +void func(int a, int b, int a); + +#elif defined test_invalid_funcparam_2 +void func(int a, int if); + +#elif defined test_array_funcparam +int amain(int argc, char *argv[static argc + 1]) +{ + int i; + int printf(const char*, ...); + for (i = 0; i < argc; ++i) + printf("arg[%d] = \"%s\"\n", i, argv[i]); + return 0; +} +int main() +{ + return amain(2, (char *[]){ "X", "Y", 0 }); +} + +#elif defined test_return_from_statement_expr +int f() { ({ return 78; }); } +int main() { return f(); } + +/******************************************************************/ + +#elif defined test_illegal_unicode +int main() { + char *str = "\Uffffffff"; +} + +#elif defined test_error_string +#error \123\\ +456 + +#endif diff --git a/tinycc/tests/tests2/60_errors_and_warnings.expect b/tinycc/tests/tests2/60_errors_and_warnings.expect new file mode 100644 index 0000000..9a95e93 --- /dev/null +++ b/tinycc/tests/tests2/60_errors_and_warnings.expect @@ -0,0 +1,230 @@ +[test_56_btype_excess_1] +60_errors_and_warnings.c:2: error: too many basic types + +[test_57_btype_excess_2] +60_errors_and_warnings.c:5: error: too many basic types + +[test_58_function_redefinition] +60_errors_and_warnings.c:9: error: redefinition of 'f' + +[test_global_redefinition] +60_errors_and_warnings.c:14: error: redefinition of 'xxx' + +[test_59_function_array] +60_errors_and_warnings.c:17: error: declaration of an array of functions + +[test_60_enum_redefinition] +60_errors_and_warnings.c:21: error: struct/union/enum already defined + +[test_62_enumerator_redefinition] +60_errors_and_warnings.c:26: error: redefinition of enumerator 'RED' + +[test_63_local_enumerator_redefinition] +[returns 1] + +[test_61_undefined_enum] +60_errors_and_warnings.c:46: error: unknown type size + +[test_74_non_const_init] +60_errors_and_warnings.c:49: error: initializer element is not constant + +[test_pointer_assignment] +60_errors_and_warnings.c:79: warning: assignment from incompatible pointer type +60_errors_and_warnings.c:82: warning: assignment from incompatible pointer type +60_errors_and_warnings.c:86: warning: assignment from incompatible pointer type +60_errors_and_warnings.c:88: warning: assignment from incompatible pointer type +60_errors_and_warnings.c:91: warning: assignment from incompatible pointer type +60_errors_and_warnings.c:92: warning: assignment from incompatible pointer type +60_errors_and_warnings.c:94: warning: assignment from incompatible pointer type +60_errors_and_warnings.c:95: warning: assignment from incompatible pointer type +60_errors_and_warnings.c:98: warning: assignment discards qualifiers from pointer target type +60_errors_and_warnings.c:99: warning: assignment discards qualifiers from pointer target type +60_errors_and_warnings.c:103: warning: assignment discards qualifiers from pointer target type +60_errors_and_warnings.c:104: warning: assignment discards qualifiers from pointer target type +60_errors_and_warnings.c:109: warning: assignment of read-only location + +[test_enum_compat] +60_errors_and_warnings.c:119: error: incompatible types for redefinition of 'f3' + +[test_enum_compat_2] +60_errors_and_warnings.c:126: error: incompatible types for redefinition of 'f4' + +[test_ptr_to_str] +60_errors_and_warnings.c:129: error: type 'const int **' does not match any association + +[test_fnptr_to_str] +60_errors_and_warnings.c:131: error: type 'int (*(*)(float, char))(double, int)' does not match any association + +[test_array_to_str] +60_errors_and_warnings.c:133: error: type 'int (*)[3]' does not match any association + +[test_duplicate_def_1] +60_errors_and_warnings.c:135: error: redefinition of 'L' + +[test_duplicate_def_2] +60_errors_and_warnings.c:138: error: redeclaration of 'L' + +[test_abstract_decls] +60_errors_and_warnings.c:148: error: identifier expected + +[test_invalid_1] +60_errors_and_warnings.c:153: error: identifier expected + +[test_invalid_2] +60_errors_and_warnings.c:156: error: ';' expected (got "{") + +[test_invalid_3] +60_errors_and_warnings.c:160: error: ',' expected (got "a") + +[test_invalid_4] +60_errors_and_warnings.c:164: error: division by zero in constant + +[test_conflicting_types] +60_errors_and_warnings.c:170: error: incompatible types for redefinition of 'i' + +[test_nested_types] +60_errors_and_warnings.c:177: error: struct/union/enum already defined + +[test_vla_1] +60_errors_and_warnings.c:184: error: need explicit inner array size in VLAs + +[test_invalid_alignas] +60_errors_and_warnings.c:188: error: identifier expected + +[test_static_assert] +60_errors_and_warnings.c:194: error: ONE is not 1 + +[test_static_assert_2] +60_errors_and_warnings.c:198: error: 0 is 0 + +[test_static_assert_c2x] +60_errors_and_warnings.c:202: error: _Static_assert fail + +[test_static_assert_empty_string] +60_errors_and_warnings.c:205: error: + +[test_void_array] +60_errors_and_warnings.c:208: error: declaration of an array of incomplete type elements + +[test_incomplete_enum_array] +60_errors_and_warnings.c:211: error: declaration of an array of incomplete type elements + +[test_incomplete_struct_array] +60_errors_and_warnings.c:214: error: declaration of an array of incomplete type elements + +[test_const_fun_array] +60_errors_and_warnings.c:218: error: declaration of an array of functions + +[test_incomplete_array_array] + +[test_extern_array] +60_errors_and_warnings.c:234: error: incompatible types for redefinition of 'x' + +[test_func_1] +hello: a = 123 + +[test_func_2] +hello: a = 123 + +[test_func_3] +60_errors_and_warnings.c:264: warning: static storage ignored for redefinition of 'hello' +hello: a = 123 + +[test_func_4] +hello: a = 123 + +[test_func_5] +60_errors_and_warnings.c:264: error: incompatible types for redefinition of 'hello' + +[test_func_6] +60_errors_and_warnings.c:252: error: function without file scope cannot be static + +[test_var_1] +main : 1 ; 1 +main : 2 ; 2 +bar : 3 ; 3 + +[test_var_2] +main : 1 ; 1 +main : 2 ; 2 +bar : 3 ; 3 + +[test_var_3] +60_errors_and_warnings.c:296: error: incompatible types for redefinition of 'xxx' + +[test_var_4] + +[test_long_double_type_for_win32] +60_errors_and_warnings.c:327: warning: assignment from incompatible pointer type + +[test_stray_backslash] +60_errors_and_warnings.c:333: error: stray '\' in program + +[test_stray_backslash2] +\n + +[test_var_array] +60_errors_and_warnings.c:348: error: flexible array has zero size in this context + +[test_var_array2] +60_errors_and_warnings.c:358: error: flexible array has zero size in this context + +[test_var_array3] +60_errors_and_warnings.c:365: error: flexible array has zero size in this context + +[test_default_int_type] +60_errors_and_warnings.c:368: warning: type defaults to int + +[test_invalid_global_stmtexpr] +60_errors_and_warnings.c:372: error: statement expression outside of function + +[test_invalid_tokckill] +60_errors_and_warnings.c:375: error: ';' expected (got "3") + +[test_duplicate_member] +60_errors_and_warnings.c:381: error: duplicate member 'a' + +[test_duplicate_member_anon] +60_errors_and_warnings.c:394: error: duplicate member 'd' + +[test_conflicting_array_definition] +60_errors_and_warnings.c:399: error: incompatible types for redefinition of 'array' + +[test_incompatible_local_redef] +60_errors_and_warnings.c:406: error: incompatible redefinition of 'localfunctype' + +[test_cast_from_void] +60_errors_and_warnings.c:411: error: cannot convert 'void' to 'int' + +[test_switch_W1] +60_errors_and_warnings.c:427: warning: implicit declaration of function 'fink' + +[test_switch_W2] +60_errors_and_warnings.c:418: warning: unsupported option '-Wstuff' +60_errors_and_warnings.c:429: warning: 'stuff' attribute ignored + +[test_switch_W3] +60_errors_and_warnings.c:426: error: assignment discards qualifiers from pointer target type + +[test_switch_W4] +60_errors_and_warnings.c:427: warning: implicit declaration of function 'fink' +60_errors_and_warnings.c:429: error: 'stuff' attribute ignored + +[test_invalid_funcparam_1] +60_errors_and_warnings.c:432: error: redeclaration of 'a' + +[test_invalid_funcparam_2] +60_errors_and_warnings.c:435: error: identifier expected + +[test_array_funcparam] +arg[0] = "X" +arg[1] = "Y" + +[test_return_from_statement_expr] +[returns 78] + +[test_illegal_unicode] +60_errors_and_warnings.c:459: error: 0xffffffff is not a valid universal character + +[test_error_string] +60_errors_and_warnings.c:464: error: #error \123\456 diff --git a/tinycc/tests/tests2/61_integers.c b/tinycc/tests/tests2/61_integers.c new file mode 100644 index 0000000..de29b3c --- /dev/null +++ b/tinycc/tests/tests2/61_integers.c @@ -0,0 +1,70 @@ +#include <stdio.h> + +/* This was first introduced to test the ARM port */ + +#define UINT_MAX ((unsigned) -1) + +int main() +{ + printf("18/21=%u\n", 18/21); + printf("18%%21=%u\n", 18%21); + printf("41/21=%u\n", 41/21); + printf("41%%21=%u\n", 41%21); + printf("42/21=%u\n", 42/21); + printf("42%%21=%u\n", 42%21); + printf("43/21=%u\n", 43/21); + printf("43%%21=%u\n", 43%21); + printf("126/21=%u\n", 126/21); + printf("126%%21=%u\n", 126%21); + printf("131/21=%u\n", 131/21); + printf("131%%21=%u\n", 131%21); + printf("(UINT_MAX/2+3)/2=%u\n", (UINT_MAX/2+3)/2); + printf("(UINT_MAX/2+3)%%2=%u\n", (UINT_MAX/2+3)%2); + + printf("18/-21=%u\n", 18/-21); + printf("18%%-21=%u\n", 18%-21); + printf("41/-21=%u\n", 41/-21); + printf("41%%-21=%u\n", 41%-21); + printf("42/-21=%u\n", 42/-21); + printf("42%%-21=%u\n", 42%-21); + printf("43/-21=%u\n", 43/-21); + printf("43%%-21=%u\n", 43%-21); + printf("126/-21=%u\n", 126/-21); + printf("126%%-21=%u\n", 126%-21); + printf("131/-21=%u\n", 131/-21); + printf("131%%-21=%u\n", 131%-21); + printf("(UINT_MAX/2+3)/-2=%u\n", (UINT_MAX/2+3)/-2); + printf("(UINT_MAX/2+3)%%-2=%u\n", (UINT_MAX/2+3)%-2); + + printf("-18/21=%u\n", -18/21); + printf("-18%%21=%u\n", -18%21); + printf("-41/21=%u\n", -41/21); + printf("-41%%21=%u\n", -41%21); + printf("-42/21=%u\n", -42/21); + printf("-42%%21=%u\n", -42%21); + printf("-43/21=%u\n", -43/21); + printf("-43%%21=%u\n", -43%21); + printf("-126/21=%u\n", -126/21); + printf("-126%%21=%u\n", -126%21); + printf("-131/21=%u\n", -131/21); + printf("-131%%21=%u\n", -131%21); + printf("-(UINT_MAX/2+3)/2=%u\n", (0-(UINT_MAX/2+3))/2); + printf("-(UINT_MAX/2+3)%%2=%u\n", (0-(UINT_MAX/2+3))%2); + + printf("-18/-21=%u\n", -18/-21); + printf("-18%%-21=%u\n", -18%-21); + printf("-41/-21=%u\n", -41/-21); + printf("-41%%-21=%u\n", -41%-21); + printf("-42/-21=%u\n", -42/-21); + printf("-42%%-21=%u\n", -42%-21); + printf("-43/-21=%u\n", -43/-21); + printf("-43%%-21=%u\n", -43%-21); + printf("-126/-21=%u\n", -126/-21); + printf("-126%%-21=%u\n", -126%-21); + printf("-131/-21=%u\n", -131/-21); + printf("-131%%-21=%u\n", -131%-21); + printf("-(UINT_MAX/2+3)/-2=%u\n", (0-(UINT_MAX/2+3))/-2); + printf("-(UINT_MAX/2+3)%%-2=%u\n", (0-(UINT_MAX/2+3))%-2); + + return 0; +} diff --git a/tinycc/tests/tests2/61_integers.expect b/tinycc/tests/tests2/61_integers.expect new file mode 100644 index 0000000..22c8d1b --- /dev/null +++ b/tinycc/tests/tests2/61_integers.expect @@ -0,0 +1,56 @@ +18/21=0 +18%21=18 +41/21=1 +41%21=20 +42/21=2 +42%21=0 +43/21=2 +43%21=1 +126/21=6 +126%21=0 +131/21=6 +131%21=5 +(UINT_MAX/2+3)/2=1073741825 +(UINT_MAX/2+3)%2=0 +18/-21=0 +18%-21=18 +41/-21=4294967295 +41%-21=20 +42/-21=4294967294 +42%-21=0 +43/-21=4294967294 +43%-21=1 +126/-21=4294967290 +126%-21=0 +131/-21=4294967290 +131%-21=5 +(UINT_MAX/2+3)/-2=0 +(UINT_MAX/2+3)%-2=2147483650 +-18/21=0 +-18%21=4294967278 +-41/21=4294967295 +-41%21=4294967276 +-42/21=4294967294 +-42%21=0 +-43/21=4294967294 +-43%21=4294967295 +-126/21=4294967290 +-126%21=0 +-131/21=4294967290 +-131%21=4294967291 +-(UINT_MAX/2+3)/2=1073741823 +-(UINT_MAX/2+3)%2=0 +-18/-21=0 +-18%-21=4294967278 +-41/-21=1 +-41%-21=4294967276 +-42/-21=2 +-42%-21=0 +-43/-21=2 +-43%-21=4294967295 +-126/-21=6 +-126%-21=0 +-131/-21=6 +-131%-21=4294967291 +-(UINT_MAX/2+3)/-2=0 +-(UINT_MAX/2+3)%-2=2147483646 diff --git a/tinycc/tests/tests2/64_macro_nesting.c b/tinycc/tests/tests2/64_macro_nesting.c new file mode 100644 index 0000000..676e5d3 --- /dev/null +++ b/tinycc/tests/tests2/64_macro_nesting.c @@ -0,0 +1,12 @@ +#include <stdio.h> // printf() + +#define CAT2(a,b) a##b +#define CAT(a,b) CAT2(a,b) +#define AB(x) CAT(x,y) + +int main(void) +{ + int xy = 42; + printf("%d\n", CAT(A,B)(x)); + return 0; +} diff --git a/tinycc/tests/tests2/64_macro_nesting.expect b/tinycc/tests/tests2/64_macro_nesting.expect new file mode 100644 index 0000000..d81cc07 --- /dev/null +++ b/tinycc/tests/tests2/64_macro_nesting.expect @@ -0,0 +1 @@ +42 diff --git a/tinycc/tests/tests2/67_macro_concat.c b/tinycc/tests/tests2/67_macro_concat.c new file mode 100644 index 0000000..c580d3a --- /dev/null +++ b/tinycc/tests/tests2/67_macro_concat.c @@ -0,0 +1,14 @@ +#include <stdio.h> + +#define P(A,B) A ## B ; bob +#define Q(A,B) A ## B+ + +int main(void) +{ + int bob, jim = 21; + bob = P(jim,) *= 2; + printf("jim: %d, bob: %d\n", jim, bob); + jim = 60 Q(+,)3; + printf("jim: %d\n", jim); + return 0; +} diff --git a/tinycc/tests/tests2/67_macro_concat.expect b/tinycc/tests/tests2/67_macro_concat.expect new file mode 100644 index 0000000..8386c2d --- /dev/null +++ b/tinycc/tests/tests2/67_macro_concat.expect @@ -0,0 +1,2 @@ +jim: 21, bob: 42 +jim: 63 diff --git a/tinycc/tests/tests2/70_floating_point_literals.c b/tinycc/tests/tests2/70_floating_point_literals.c new file mode 100644 index 0000000..012fb4f --- /dev/null +++ b/tinycc/tests/tests2/70_floating_point_literals.c @@ -0,0 +1,77 @@ +#include <stdio.h> + +int main() +{ + /* decimal floating constant */ + float fa0 = .123f; + float fa1 = .123E12F; + float fa2 = .123e-12f; + float fa3 = .123e+12f; + printf("%f\n%f\n%f\n%f\n\n", fa0, fa1, fa2, fa3); + + float fb0 = 123.123f; + float fb1 = 123.123E12F; + float fb2 = 123.123e-12f; + float fb3 = 123.123e+12f; + printf("%f\n%f\n%f\n%f\n\n", fb0, fb1, fb2, fb3); + + float fc0 = 123.f; + float fc1 = 123.E12F; + float fc2 = 123.e-12f; + float fc3 = 123.e+12f; + printf("%f\n%f\n%f\n%f\n\n", fc0, fc1, fc2, fc3); + + float fd0 = 123E12F; + float fd1 = 123e-12f; + float fd2 = 123e+12f; + printf("%f\n%f\n%f\n\n", fd0, fd1, fd2); + printf("\n"); + + /* hexadecimal floating constant */ + double da0 = 0X.1ACP12; + double da1 = 0x.1acp-12; + double da2 = 0x.1acp+12; + printf("%f\n%f\n%f\n\n", da0, da1, da2); + + double db0 = 0X1AC.BDP12; + double db1 = 0x1ac.bdp-12; + double db2 = 0x1ac.dbp+12; + printf("%f\n%f\n%f\n\n", db0, db1, db2); + + double dc0 = 0X1AC.P12; + double dc1 = 0x1ac.p-12; + double dc2 = 0x1ac.p+12; + printf("%f\n%f\n%f\n\n", dc0, dc1, dc2); + + double dd0 = 0X1ACP12; + double dd1 = 0x1acp-12; + double dd2 = 0x1acp+12; + printf("%f\n%f\n%f\n\n", dd0, dd1, dd2); + printf("\n"); + +#ifdef __TINYC__ + /* TCC extension + binary floating constant */ + long double la0 = 0B.110101100P12L; + long double la1 = 0b.110101100p-12l; + long double la2 = 0b.110101100p+12l; + printf("%Lf\n%Lf\n%Lf\n\n", la0, la1, la2); + + long double lb0 = 0B110101100.10111101P12L; + long double lb1 = 0b110101100.10111101p-12l; + long double lb2 = 0b110101100.10111101p+12l; + printf("%Lf\n%Lf\n%Lf\n\n", lb0, lb1, lb2); + + long double lc0 = 0B110101100.P12L; + long double lc1 = 0b110101100.p-12l; + long double lc2 = 0b110101100.p+12l; + printf("%Lf\n%Lf\n%Lf\n\n", lc0, lc1, lc2); + + long double ld0 = 0B110101100P12L; + long double ld1 = 0b110101100p-12l; + long double ld2 = 0b110101100p+12l; + printf("%Lf\n%Lf\n%Lf\n\n", ld0, ld1, ld2); +#endif + + return 0; +} diff --git a/tinycc/tests/tests2/70_floating_point_literals.expect b/tinycc/tests/tests2/70_floating_point_literals.expect new file mode 100644 index 0000000..7eb1efb --- /dev/null +++ b/tinycc/tests/tests2/70_floating_point_literals.expect @@ -0,0 +1,53 @@ +0.123000 +122999996416.000000 +0.000000 +122999996416.000000 + +123.123001 +123122997002240.000000 +0.000000 +123122997002240.000000 + +123.000000 +123000003231744.000000 +0.000000 +123000003231744.000000 + +123000003231744.000000 +0.000000 +123000003231744.000000 + + +428.000000 +0.000026 +428.000000 + +1756112.000000 +0.104672 +1756592.000000 + +1753088.000000 +0.104492 +1753088.000000 + +1753088.000000 +0.104492 +1753088.000000 + + +3424.000000 +0.000204 +3424.000000 + +1756112.000000 +0.104672 +1756112.000000 + +1753088.000000 +0.104492 +1753088.000000 + +1753088.000000 +0.104492 +1753088.000000 + diff --git a/tinycc/tests/tests2/71_macro_empty_arg.c b/tinycc/tests/tests2/71_macro_empty_arg.c new file mode 100644 index 0000000..f0d3511 --- /dev/null +++ b/tinycc/tests/tests2/71_macro_empty_arg.c @@ -0,0 +1,9 @@ +#include <stdio.h> + +#define T(a,b,c) a b c + +int main(void) +{ + printf("%d", T(1,+,2) T(+,,) T(,2,*) T(,7,) T(,,)); + return 0; +} diff --git a/tinycc/tests/tests2/71_macro_empty_arg.expect b/tinycc/tests/tests2/71_macro_empty_arg.expect new file mode 100644 index 0000000..98d9bcb --- /dev/null +++ b/tinycc/tests/tests2/71_macro_empty_arg.expect @@ -0,0 +1 @@ +17 diff --git a/tinycc/tests/tests2/72_long_long_constant.c b/tinycc/tests/tests2/72_long_long_constant.c new file mode 100644 index 0000000..6608213 --- /dev/null +++ b/tinycc/tests/tests2/72_long_long_constant.c @@ -0,0 +1,19 @@ +#include <stdio.h> + +int main() +{ + long long int res = 0; + + if (res < -2147483648LL) { + printf("Error: 0 < -2147483648\n"); + return 1; + } + else + if (2147483647LL < res) { + printf("Error: 2147483647 < 0\n"); + return 2; + } + else + printf("long long constant test ok.\n"); + return 0; +} diff --git a/tinycc/tests/tests2/72_long_long_constant.expect b/tinycc/tests/tests2/72_long_long_constant.expect new file mode 100644 index 0000000..dda9e66 --- /dev/null +++ b/tinycc/tests/tests2/72_long_long_constant.expect @@ -0,0 +1 @@ +long long constant test ok. diff --git a/tinycc/tests/tests2/73_arm64.c b/tinycc/tests/tests2/73_arm64.c new file mode 100644 index 0000000..855c476 --- /dev/null +++ b/tinycc/tests/tests2/73_arm64.c @@ -0,0 +1,538 @@ +// This program is designed to test some arm64-specific things, such as the +// calling convention, but should give the same results on any architecture. + +#include <stdarg.h> +#include <stdint.h> +#include <stdio.h> + +struct s1 { char x[1]; } s1 = { "0" }; +struct s2 { char x[2]; } s2 = { "12" }; +struct s3 { char x[3]; } s3 = { "345" }; +struct s4 { char x[4]; } s4 = { "6789" }; +struct s5 { char x[5]; } s5 = { "abcde" }; +struct s6 { char x[6]; } s6 = { "fghijk" }; +struct s7 { char x[7]; } s7 = { "lmnopqr" }; +struct s8 { char x[8]; } s8 = { "stuvwxyz" }; +struct s9 { char x[9]; } s9 = { "ABCDEFGHI" }; +struct s10 { char x[10]; } s10 = { "JKLMNOPQRS" }; +struct s11 { char x[11]; } s11 = { "TUVWXYZ0123" }; +struct s12 { char x[12]; } s12 = { "456789abcdef" }; +struct s13 { char x[13]; } s13 = { "ghijklmnopqrs" }; +struct s14 { char x[14]; } s14 = { "tuvwxyzABCDEFG" }; +struct s15 { char x[15]; } s15 = { "HIJKLMNOPQRSTUV" }; +struct s16 { char x[16]; } s16 = { "WXYZ0123456789ab" }; +struct s17 { char x[17]; } s17 = { "cdefghijklmnopqrs" }; + +struct hfa11 { float a; } hfa11 = { 11.1 }; +struct hfa12 { float a, b; } hfa12 = { 12.1, 12.2 }; +struct hfa13 { float a, b, c; } hfa13 = { 13.1, 13.2, 13.3 }; +struct hfa14 { float a, b, c, d; } hfa14 = { 14.1, 14.2, 14.3, 14.4 }; + +struct hfa21 { double a; } hfa21 = { 21.1 }; +struct hfa22 { double a, b; } hfa22 = { 22.1, 22.2 }; +struct hfa23 { double a, b, c; } hfa23 = { 23.1, 23.2, 23.3 }; +struct hfa24 { double a, b, c, d; } hfa24 = { 24.1, 24.2, 24.3, 24.4 }; + +struct hfa31 { long double a; } hfa31 = { 31.1 }; +struct hfa32 { long double a, b; } hfa32 = { 32.1, 32.2 }; +struct hfa33 { long double a, b, c; } hfa33 = { 33.1, 33.2, 33.3 }; +struct hfa34 { long double a, b, c, d; } hfa34 = { 34.1, 34.2, 34.3, 34.4 }; + +void fa_s1(struct s1 a) { printf("%.1s\n", a.x); } +void fa_s2(struct s2 a) { printf("%.2s\n", a.x); } +void fa_s3(struct s3 a) { printf("%.3s\n", a.x); } +void fa_s4(struct s4 a) { printf("%.4s\n", a.x); } +void fa_s5(struct s5 a) { printf("%.5s\n", a.x); } +void fa_s6(struct s6 a) { printf("%.6s\n", a.x); } +void fa_s7(struct s7 a) { printf("%.7s\n", a.x); } +void fa_s8(struct s8 a) { printf("%.8s\n", a.x); } +void fa_s9(struct s9 a) { printf("%.9s\n", a.x); } +void fa_s10(struct s10 a) { printf("%.10s\n", a.x); } +void fa_s11(struct s11 a) { printf("%.11s\n", a.x); } +void fa_s12(struct s12 a) { printf("%.12s\n", a.x); } +void fa_s13(struct s13 a) { printf("%.13s\n", a.x); } +void fa_s14(struct s14 a) { printf("%.14s\n", a.x); } +void fa_s15(struct s15 a) { printf("%.15s\n", a.x); } +void fa_s16(struct s16 a) { printf("%.16s\n", a.x); } +void fa_s17(struct s17 a) { printf("%.17s\n", a.x); } + +void fa_hfa11(struct hfa11 a) +{ printf("%.1f\n", a.a); } +void fa_hfa12(struct hfa12 a) +{ printf("%.1f %.1f\n", a.a, a.a); } +void fa_hfa13(struct hfa13 a) +{ printf("%.1f %.1f %.1f\n", a.a, a.b, a.c); } +void fa_hfa14(struct hfa14 a) +{ printf("%.1f %.1f %.1f %.1f\n", a.a, a.b, a.c, a.d); } + +void fa_hfa21(struct hfa21 a) +{ printf("%.1f\n", a.a); } +void fa_hfa22(struct hfa22 a) +{ printf("%.1f %.1f\n", a.a, a.a); } +void fa_hfa23(struct hfa23 a) +{ printf("%.1f %.1f %.1f\n", a.a, a.b, a.c); } +void fa_hfa24(struct hfa24 a) +{ printf("%.1f %.1f %.1f %.1f\n", a.a, a.b, a.c, a.d); } + +void fa_hfa31(struct hfa31 a) +{ printf("%.1Lf\n", a.a); } +void fa_hfa32(struct hfa32 a) +{ printf("%.1Lf %.1Lf\n", a.a, a.a); } +void fa_hfa33(struct hfa33 a) +{ printf("%.1Lf %.1Lf %.1Lf\n", a.a, a.b, a.c); } +void fa_hfa34(struct hfa34 a) +{ printf("%.1Lf %.1Lf %.1Lf %.1Lf\n", a.a, a.b, a.c, a.d); } + +void fa1(struct s8 a, struct s9 b, struct s10 c, struct s11 d, + struct s12 e, struct s13 f) +{ + printf("%.3s %.3s %.3s %.3s %.3s %.3s\n", a.x, b.x, c.x, d.x, e.x, f.x); +} + +void fa2(struct s9 a, struct s10 b, struct s11 c, struct s12 d, + struct s13 e, struct s14 f) +{ + printf("%.3s %.3s %.3s %.3s %.3s %.3s\n", a.x, b.x, c.x, d.x, e.x, f.x); +} + +void fa3(struct hfa14 a, struct hfa23 b, struct hfa32 c) +{ + printf("%.1f %.1f %.1f %.1f %.1Lf %.1Lf\n", + a.a, a.d, b.a, b.c, c.a, c.b); +} + +void fa4(struct s1 a, struct hfa14 b, struct s2 c, struct hfa24 d, + struct s3 e, struct hfa34 f) +{ + printf("%.1s %.1f %.1f %.2s %.1f %.1f %.3s %.1Lf %.1Lf\n", + a.x, b.a, b.d, c.x, d.a, d.d, e.x, f.a, f.d); +} + +void arg(void) +{ + printf("Arguments:\n"); + fa_s1(s1); + fa_s2(s2); + fa_s3(s3); + fa_s4(s4); + fa_s5(s5); + fa_s6(s6); + fa_s7(s7); + fa_s8(s8); + fa_s9(s9); + fa_s10(s10); + fa_s11(s11); + fa_s12(s12); + fa_s13(s13); + fa_s14(s14); + fa_s15(s15); + fa_s16(s16); + fa_s17(s17); + fa_hfa11(hfa11); + fa_hfa12(hfa12); + fa_hfa13(hfa13); + fa_hfa14(hfa14); + fa_hfa21(hfa21); + fa_hfa22(hfa22); + fa_hfa23(hfa23); + fa_hfa24(hfa24); + fa_hfa31(hfa31); + fa_hfa32(hfa32); + fa_hfa33(hfa33); + fa_hfa34(hfa34); + fa1(s8, s9, s10, s11, s12, s13); + fa2(s9, s10, s11, s12, s13, s14); + fa3(hfa14, hfa23, hfa32); + fa4(s1, hfa14, s2, hfa24, s3, hfa34); +} + +struct s1 fr_s1(void) { return s1; } +struct s2 fr_s2(void) { return s2; } +struct s3 fr_s3(void) { return s3; } +struct s4 fr_s4(void) { return s4; } +struct s5 fr_s5(void) { return s5; } +struct s6 fr_s6(void) { return s6; } +struct s7 fr_s7(void) { return s7; } +struct s8 fr_s8(void) { return s8; } +struct s9 fr_s9(void) { return s9; } +struct s10 fr_s10(void) { return s10; } +struct s11 fr_s11(void) { return s11; } +struct s12 fr_s12(void) { return s12; } +struct s13 fr_s13(void) { return s13; } +struct s14 fr_s14(void) { return s14; } +struct s15 fr_s15(void) { return s15; } +struct s16 fr_s16(void) { return s16; } +struct s17 fr_s17(void) { return s17; } + +struct hfa11 fr_hfa11(void) { return hfa11; } +struct hfa12 fr_hfa12(void) { return hfa12; } +struct hfa13 fr_hfa13(void) { return hfa13; } +struct hfa14 fr_hfa14(void) { return hfa14; } + +struct hfa21 fr_hfa21(void) { return hfa21; } +struct hfa22 fr_hfa22(void) { return hfa22; } +struct hfa23 fr_hfa23(void) { return hfa23; } +struct hfa24 fr_hfa24(void) { return hfa24; } + +struct hfa31 fr_hfa31(void) { return hfa31; } +struct hfa32 fr_hfa32(void) { return hfa32; } +struct hfa33 fr_hfa33(void) { return hfa33; } +struct hfa34 fr_hfa34(void) { return hfa34; } + +void ret(void) +{ + struct s1 t1 = fr_s1(); + struct s2 t2 = fr_s2(); + struct s3 t3 = fr_s3(); + struct s4 t4 = fr_s4(); + struct s5 t5 = fr_s5(); + struct s6 t6 = fr_s6(); + struct s7 t7 = fr_s7(); + struct s8 t8 = fr_s8(); + struct s9 t9 = fr_s9(); + struct s10 t10 = fr_s10(); + struct s11 t11 = fr_s11(); + struct s12 t12 = fr_s12(); + struct s13 t13 = fr_s13(); + struct s14 t14 = fr_s14(); + struct s15 t15 = fr_s15(); + struct s16 t16 = fr_s16(); + struct s17 t17 = fr_s17(); + printf("Return values:\n"); + printf("%.1s\n", t1.x); + printf("%.2s\n", t2.x); + printf("%.3s\n", t3.x); + printf("%.4s\n", t4.x); + printf("%.5s\n", t5.x); + printf("%.6s\n", t6.x); + printf("%.7s\n", t7.x); + printf("%.8s\n", t8.x); + printf("%.9s\n", t9.x); + printf("%.10s\n", t10.x); + printf("%.11s\n", t11.x); + printf("%.12s\n", t12.x); + printf("%.13s\n", t13.x); + printf("%.14s\n", t14.x); + printf("%.15s\n", t15.x); + printf("%.16s\n", t16.x); + printf("%.17s\n", t17.x); + printf("%.1f\n", fr_hfa11().a); + printf("%.1f %.1f\n", fr_hfa12().a, fr_hfa12().b); + printf("%.1f %.1f\n", fr_hfa13().a, fr_hfa13().c); + printf("%.1f %.1f\n", fr_hfa14().a, fr_hfa14().d); + printf("%.1f\n", fr_hfa21().a); + printf("%.1f %.1f\n", fr_hfa22().a, fr_hfa22().b); + printf("%.1f %.1f\n", fr_hfa23().a, fr_hfa23().c); + printf("%.1f %.1f\n", fr_hfa24().a, fr_hfa24().d); + printf("%.1Lf\n", fr_hfa31().a); + printf("%.1Lf %.1Lf\n", fr_hfa32().a, fr_hfa32().b); + printf("%.1Lf %.1Lf\n", fr_hfa33().a, fr_hfa33().c); + printf("%.1Lf %.1Lf\n", fr_hfa34().a, fr_hfa34().d); +} + +void* +va_arg_with_struct_ptr(va_list ap) { + /* + * This was a BUG identified with FFTW-3.3.8 on arm64. + * The test case only checks it compiles. + */ + struct X { int _x; }; + struct X *x = va_arg(ap, struct X *); + return x; +} + +int match(const char **s, const char *f) +{ + const char *p = *s; + for (p = *s; *f && *f == *p; f++, p++) + ; + if (!*f) { + *s = p - 1; + return 1; + } + return 0; +} + +void myprintf(const char *format, ...) +{ + const char *s; + va_list ap; + va_start(ap, format); + for (s = format; *s; s++) { + if (match(&s, "%7s")) { + struct s7 t7 = va_arg(ap, struct s7); + printf("%.7s", t7.x); + } + else if (match(&s, "%9s")) { + struct s9 t9 = va_arg(ap, struct s9); + printf("%.9s", t9.x); + } + else if (match(&s, "%hfa11")) { + struct hfa11 x = va_arg(ap, struct hfa11); + printf("%.1f,%.1f", x.a, x.a); + } + else if (match(&s, "%hfa12")) { + struct hfa12 x = va_arg(ap, struct hfa12); + printf("%.1f,%.1f", x.a, x.b); + } + else if (match(&s, "%hfa13")) { + struct hfa13 x = va_arg(ap, struct hfa13); + printf("%.1f,%.1f", x.a, x.c); + } + else if (match(&s, "%hfa14")) { + struct hfa14 x = va_arg(ap, struct hfa14); + printf("%.1f,%.1f", x.a, x.d); + } + else if (match(&s, "%hfa21")) { + struct hfa21 x = va_arg(ap, struct hfa21); + printf("%.1f,%.1f", x.a, x.a); + } + else if (match(&s, "%hfa22")) { + struct hfa22 x = va_arg(ap, struct hfa22); + printf("%.1f,%.1f", x.a, x.b); + } + else if (match(&s, "%hfa23")) { + struct hfa23 x = va_arg(ap, struct hfa23); + printf("%.1f,%.1f", x.a, x.c); + } + else if (match(&s, "%hfa24")) { + struct hfa24 x = va_arg(ap, struct hfa24); + printf("%.1f,%.1f", x.a, x.d); + } + else if (match(&s, "%hfa31")) { + struct hfa31 x = va_arg(ap, struct hfa31); + printf("%.1Lf,%.1Lf", x.a, x.a); + } + else if (match(&s, "%hfa32")) { + struct hfa32 x = va_arg(ap, struct hfa32); + printf("%.1Lf,%.1Lf", x.a, x.b); + } + else if (match(&s, "%hfa33")) { + struct hfa33 x = va_arg(ap, struct hfa33); + printf("%.1Lf,%.1Lf", x.a, x.c); + } + else if (match(&s, "%hfa34")) { + struct hfa34 x = va_arg(ap, struct hfa34); + printf("%.1Lf,%.1Lf", x.a, x.d); + } + else + putchar(*s); + } + putchar('\n'); +} + +void stdarg(void) +{ + printf("stdarg:\n"); + myprintf("%9s %9s %9s %9s %9s %9s", s9, s9, s9, s9, s9, s9); + myprintf("%7s %9s %9s %9s %9s %9s", s7, s9, s9, s9, s9, s9); + + myprintf("HFA long double:"); + myprintf("%hfa34 %hfa34 %hfa34 %hfa34", hfa34, hfa34, hfa34, hfa34); + myprintf("%hfa33 %hfa34 %hfa34 %hfa34", hfa33, hfa34, hfa34, hfa34); + myprintf("%hfa32 %hfa34 %hfa34 %hfa34", hfa32, hfa34, hfa34, hfa34); + myprintf("%hfa31 %hfa34 %hfa34 %hfa34", hfa31, hfa34, hfa34, hfa34); + + myprintf("%hfa32 %hfa33 %hfa33 %hfa33 %hfa33", + hfa32, hfa33, hfa33, hfa33, hfa33); + myprintf("%hfa31 %hfa33 %hfa33 %hfa33 %hfa33", + hfa31, hfa33, hfa33, hfa33, hfa33); + myprintf("%hfa33 %hfa33 %hfa33 %hfa33", + hfa33, hfa33, hfa33, hfa33); + + myprintf("%hfa34 %hfa32 %hfa32 %hfa32 %hfa32", + hfa34, hfa32, hfa32, hfa32, hfa32); + myprintf("%hfa33 %hfa32 %hfa32 %hfa32 %hfa32", + hfa33, hfa32, hfa32, hfa32, hfa32); + + myprintf("%hfa34 %hfa32 %hfa31 %hfa31 %hfa31 %hfa31", + hfa34, hfa32, hfa31, hfa31, hfa31, hfa31); + + myprintf("HFA double:"); + myprintf("%hfa24 %hfa24 %hfa24 %hfa24", hfa24, hfa24, hfa24, hfa24); + myprintf("%hfa23 %hfa24 %hfa24 %hfa24", hfa23, hfa24, hfa24, hfa24); + myprintf("%hfa22 %hfa24 %hfa24 %hfa24", hfa22, hfa24, hfa24, hfa24); + myprintf("%hfa21 %hfa24 %hfa24 %hfa24", hfa21, hfa24, hfa24, hfa24); + + myprintf("%hfa22 %hfa23 %hfa23 %hfa23 %hfa23", + hfa22, hfa23, hfa23, hfa23, hfa23); + myprintf("%hfa21 %hfa23 %hfa23 %hfa23 %hfa23", + hfa21, hfa23, hfa23, hfa23, hfa23); + myprintf("%hfa23 %hfa23 %hfa23 %hfa23", + hfa23, hfa23, hfa23, hfa23); + + myprintf("%hfa24 %hfa22 %hfa22 %hfa22 %hfa22", + hfa24, hfa22, hfa22, hfa22, hfa22); + myprintf("%hfa23 %hfa22 %hfa22 %hfa22 %hfa22", + hfa23, hfa22, hfa22, hfa22, hfa22); + + myprintf("%hfa24 %hfa22 %hfa21 %hfa21 %hfa21 %hfa21", + hfa24, hfa22, hfa21, hfa21, hfa21, hfa21); + + myprintf("HFA float:"); + myprintf("%hfa14 %hfa14 %hfa14 %hfa14", hfa14, hfa14, hfa14, hfa14); + myprintf("%hfa13 %hfa14 %hfa14 %hfa14", hfa13, hfa14, hfa14, hfa14); + myprintf("%hfa12 %hfa14 %hfa14 %hfa14", hfa12, hfa14, hfa14, hfa14); + myprintf("%hfa11 %hfa14 %hfa14 %hfa14", hfa11, hfa14, hfa14, hfa14); + + myprintf("%hfa12 %hfa13 %hfa13 %hfa13 %hfa13", + hfa12, hfa13, hfa13, hfa13, hfa13); + myprintf("%hfa11 %hfa13 %hfa13 %hfa13 %hfa13", + hfa11, hfa13, hfa13, hfa13, hfa13); + myprintf("%hfa13 %hfa13 %hfa13 %hfa13", + hfa13, hfa13, hfa13, hfa13); + + myprintf("%hfa14 %hfa12 %hfa12 %hfa12 %hfa12", + hfa14, hfa12, hfa12, hfa12, hfa12); + myprintf("%hfa13 %hfa12 %hfa12 %hfa12 %hfa12", + hfa13, hfa12, hfa12, hfa12, hfa12); + + myprintf("%hfa14 %hfa12 %hfa11 %hfa11 %hfa11 %hfa11", + hfa14, hfa12, hfa11, hfa11, hfa11, hfa11); +} + +void pll(unsigned long long x) +{ + printf("%llx\n", x); +} + +void movi(void) +{ + printf("MOVI:\n"); + pll(0); + pll(0xabcd); + pll(0xabcd0000); + pll(0xabcd00000000); + pll(0xabcd000000000000); + pll(0xffffabcd); + pll(0xabcdffff); + pll(0xffffffffffffabcd); + pll(0xffffffffabcdffff); + pll(0xffffabcdffffffff); + pll(0xabcdffffffffffff); + pll(0xaaaaaaaa); + pll(0x5555555555555555); + pll(0x77777777); + pll(0x3333333333333333); + pll(0xf8f8f8f8); + pll(0x1e1e1e1e1e1e1e1e); + pll(0x3f803f80); + pll(0x01ff01ff01ff01ff); + pll(0x007fffc0); + pll(0x03fff80003fff800); + pll(0x0007fffffffffe00); + + pll(0xabcd1234); + pll(0xabcd00001234); + pll(0xabcd000000001234); + pll(0xabcd12340000); + pll(0xabcd000012340000); + pll(0xabcd123400000000); + pll(0xffffffffabcd1234); + pll(0xffffabcdffff1234); + pll(0xabcdffffffff1234); + pll(0xffffabcd1234ffff); + pll(0xabcdffff1234ffff); + pll(0xabcd1234ffffffff); + + pll(0xffffef0123456789); + pll(0xabcdef012345ffff); + + pll(0xabcdef0123456789); +} + +static uint32_t addip0(uint32_t x) { return x + 0; } +static uint64_t sublp0(uint64_t x) { return x - 0; } +static uint32_t addip123(uint32_t x) { return x + 123; } +static uint64_t addlm123(uint64_t x) { return x + -123; } +static uint64_t sublp4095(uint64_t x) { return x - 4095; } +static uint32_t subim503808(uint32_t x) { return x - -503808; } +static uint64_t addp12345(uint64_t x) { return x + 12345; } +static uint32_t subp12345(uint32_t x) { return x - 12345; } + +static uint32_t mvni(uint32_t x) { return 0xffffffff - x; } +static uint64_t negl(uint64_t x) { return 0 - x; } +static uint32_t rsbi123(uint32_t x) { return 123 - x; } +static uint64_t rsbl123(uint64_t x) { return 123 - x; } + +static uint32_t andi0(uint32_t x) { return x & 0; } +static uint64_t andlm1(uint64_t x) { return x & -1; } +static uint64_t orrl0(uint64_t x) { return x | 0; } +static uint32_t orrim1(uint32_t x) { return x | -1; } +static uint32_t eori0(uint32_t x) { return x ^ 0; } +static uint64_t eorlm1(uint64_t x) { return x ^ -1; } +static uint32_t and0xf0(uint32_t x) { return x & 0xf0; } +static uint64_t orr0xf0(uint64_t x) { return x | 0xf0; } +static uint64_t eor0xf0(uint64_t x) { return x ^ 0xf0; } + +static uint32_t lsli0(uint32_t x) { return x << 0; } +static uint32_t lsri0(uint32_t x) { return x >> 0; } +static int64_t asrl0(int64_t x) { return x >> 0; } +static uint32_t lsli1(uint32_t x) { return x << 1; } +static uint32_t lsli31(uint32_t x) { return x << 31; } +static uint64_t lsll1(uint64_t x) { return x << 1; } +static uint64_t lsll63(uint64_t x) { return x << 63; } +static uint32_t lsri1(uint32_t x) { return x >> 1; } +static uint32_t lsri31(uint32_t x) { return x >> 31; } +static uint64_t lsrl1(uint64_t x) { return x >> 1; } +static uint64_t lsrl63(uint64_t x) { return x >> 63; } +static int32_t asri1(int32_t x) { return x >> 1; } +static int32_t asri31(int32_t x) { return x >> 31; } +static int64_t asrl1(int64_t x) { return x >> 1; } +static int64_t asrl63(int64_t x) { return x >> 63; } + +void opi(void) +{ + int x = 1000; + pll(addip0(x)); + pll(sublp0(x)); + pll(addip123(x)); + pll(addlm123(x)); + pll(sublp4095(x)); + pll(subim503808(x)); + pll(addp12345(x)); + pll(subp12345(x)); + pll(mvni(x)); + pll(negl(x)); + pll(rsbi123(x)); + pll(rsbl123(x)); + pll(andi0(x)); + pll(andlm1(x)); + pll(orrl0(x)); + pll(orrim1(x)); + pll(eori0(x)); + pll(eorlm1(x)); + pll(and0xf0(x)); + pll(orr0xf0(x)); + pll(eor0xf0(x)); + pll(lsli0(x)); + pll(lsri0(x)); + pll(asrl0(x)); + pll(lsli1(x)); + pll(lsli31(x)); + pll(lsll1(x)); + pll(lsll63(x)); + pll(lsri1(x)); + pll(lsri31(x)); + pll(lsrl1(x)); + pll(lsrl63(x)); + pll(asri1(x)); + pll(asri31(x)); + pll(asrl1(x)); + pll(asrl63(x)); +} + +void pcs(void) +{ + arg(); + ret(); + stdarg(); + movi(); + opi(); +} + +int main() +{ + pcs(); + return 0; +} diff --git a/tinycc/tests/tests2/73_arm64.expect b/tinycc/tests/tests2/73_arm64.expect new file mode 100644 index 0000000..7bdebd3 --- /dev/null +++ b/tinycc/tests/tests2/73_arm64.expect @@ -0,0 +1,174 @@ +Arguments: +0 +12 +345 +6789 +abcde +fghijk +lmnopqr +stuvwxyz +ABCDEFGHI +JKLMNOPQRS +TUVWXYZ0123 +456789abcdef +ghijklmnopqrs +tuvwxyzABCDEFG +HIJKLMNOPQRSTUV +WXYZ0123456789ab +cdefghijklmnopqrs +11.1 +12.1 12.1 +13.1 13.2 13.3 +14.1 14.2 14.3 14.4 +21.1 +22.1 22.1 +23.1 23.2 23.3 +24.1 24.2 24.3 24.4 +31.1 +32.1 32.1 +33.1 33.2 33.3 +34.1 34.2 34.3 34.4 +stu ABC JKL TUV 456 ghi +ABC JKL TUV 456 ghi tuv +14.1 14.4 23.1 23.3 32.1 32.2 +0 14.1 14.4 12 24.1 24.4 345 34.1 34.4 +Return values: +0 +12 +345 +6789 +abcde +fghijk +lmnopqr +stuvwxyz +ABCDEFGHI +JKLMNOPQRS +TUVWXYZ0123 +456789abcdef +ghijklmnopqrs +tuvwxyzABCDEFG +HIJKLMNOPQRSTUV +WXYZ0123456789ab +cdefghijklmnopqrs +11.1 +12.1 12.2 +13.1 13.3 +14.1 14.4 +21.1 +22.1 22.2 +23.1 23.3 +24.1 24.4 +31.1 +32.1 32.2 +33.1 33.3 +34.1 34.4 +stdarg: +ABCDEFGHI ABCDEFGHI ABCDEFGHI ABCDEFGHI ABCDEFGHI ABCDEFGHI +lmnopqr ABCDEFGHI ABCDEFGHI ABCDEFGHI ABCDEFGHI ABCDEFGHI +HFA long double: +34.1,34.4 34.1,34.4 34.1,34.4 34.1,34.4 +33.1,33.3 34.1,34.4 34.1,34.4 34.1,34.4 +32.1,32.2 34.1,34.4 34.1,34.4 34.1,34.4 +31.1,31.1 34.1,34.4 34.1,34.4 34.1,34.4 +32.1,32.2 33.1,33.3 33.1,33.3 33.1,33.3 33.1,33.3 +31.1,31.1 33.1,33.3 33.1,33.3 33.1,33.3 33.1,33.3 +33.1,33.3 33.1,33.3 33.1,33.3 33.1,33.3 +34.1,34.4 32.1,32.2 32.1,32.2 32.1,32.2 32.1,32.2 +33.1,33.3 32.1,32.2 32.1,32.2 32.1,32.2 32.1,32.2 +34.1,34.4 32.1,32.2 31.1,31.1 31.1,31.1 31.1,31.1 31.1,31.1 +HFA double: +24.1,24.4 24.1,24.4 24.1,24.4 24.1,24.4 +23.1,23.3 24.1,24.4 24.1,24.4 24.1,24.4 +22.1,22.2 24.1,24.4 24.1,24.4 24.1,24.4 +21.1,21.1 24.1,24.4 24.1,24.4 24.1,24.4 +22.1,22.2 23.1,23.3 23.1,23.3 23.1,23.3 23.1,23.3 +21.1,21.1 23.1,23.3 23.1,23.3 23.1,23.3 23.1,23.3 +23.1,23.3 23.1,23.3 23.1,23.3 23.1,23.3 +24.1,24.4 22.1,22.2 22.1,22.2 22.1,22.2 22.1,22.2 +23.1,23.3 22.1,22.2 22.1,22.2 22.1,22.2 22.1,22.2 +24.1,24.4 22.1,22.2 21.1,21.1 21.1,21.1 21.1,21.1 21.1,21.1 +HFA float: +14.1,14.4 14.1,14.4 14.1,14.4 14.1,14.4 +13.1,13.3 14.1,14.4 14.1,14.4 14.1,14.4 +12.1,12.2 14.1,14.4 14.1,14.4 14.1,14.4 +11.1,11.1 14.1,14.4 14.1,14.4 14.1,14.4 +12.1,12.2 13.1,13.3 13.1,13.3 13.1,13.3 13.1,13.3 +11.1,11.1 13.1,13.3 13.1,13.3 13.1,13.3 13.1,13.3 +13.1,13.3 13.1,13.3 13.1,13.3 13.1,13.3 +14.1,14.4 12.1,12.2 12.1,12.2 12.1,12.2 12.1,12.2 +13.1,13.3 12.1,12.2 12.1,12.2 12.1,12.2 12.1,12.2 +14.1,14.4 12.1,12.2 11.1,11.1 11.1,11.1 11.1,11.1 11.1,11.1 +MOVI: +0 +abcd +abcd0000 +abcd00000000 +abcd000000000000 +ffffabcd +abcdffff +ffffffffffffabcd +ffffffffabcdffff +ffffabcdffffffff +abcdffffffffffff +aaaaaaaa +5555555555555555 +77777777 +3333333333333333 +f8f8f8f8 +1e1e1e1e1e1e1e1e +3f803f80 +1ff01ff01ff01ff +7fffc0 +3fff80003fff800 +7fffffffffe00 +abcd1234 +abcd00001234 +abcd000000001234 +abcd12340000 +abcd000012340000 +abcd123400000000 +ffffffffabcd1234 +ffffabcdffff1234 +abcdffffffff1234 +ffffabcd1234ffff +abcdffff1234ffff +abcd1234ffffffff +ffffef0123456789 +abcdef012345ffff +abcdef0123456789 +3e8 +3e8 +463 +36d +fffffffffffff3e9 +7b3e8 +3421 +ffffd3af +fffffc17 +fffffffffffffc18 +fffffc93 +fffffffffffffc93 +0 +3e8 +3e8 +ffffffff +3e8 +fffffffffffffc17 +e0 +3f8 +318 +3e8 +3e8 +3e8 +7d0 +0 +7d0 +0 +1f4 +0 +1f4 +0 +1f4 +0 +1f4 +0 diff --git a/tinycc/tests/tests2/75_array_in_struct_init.c b/tinycc/tests/tests2/75_array_in_struct_init.c new file mode 100644 index 0000000..234e3c4 --- /dev/null +++ b/tinycc/tests/tests2/75_array_in_struct_init.c @@ -0,0 +1,33 @@ +#include <stdio.h> + +/* This test is a snippet from the J interpreter */ + +typedef long I; +typedef struct{I c[4];I b,e,k;} PT; + +PT cases[] = { + ((I)4194304L +(I)2097152L +(I)67108864L), (I)262144L, (((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L), -1L, 1,2,1, + ((I)+4194304L +(I)2097152L +(I)67108864L)+( (I)524288L +(I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L)), (I)262144L, (I)262144L, (((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L), 2,3,2, + ((I)4194304L +(I)2097152L +(I)67108864L)+( (I)524288L +(I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L)), (((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L), (I)262144L, (((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L), 1,3,2, + ((I)4194304L +(I)2097152L +(I)67108864L)+( (I)524288L +(I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L)), (I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L), (I)524288L, -1L, 1,2,1, + ((I)4194304L +(I)2097152L +(I)67108864L)+( (I)524288L +(I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L)), (I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L), (I)1048576L, (I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L), 1,3,1, + ((I)4194304L +(I)2097152L +(I)67108864L)+( (I)524288L +(I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L)), (I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L), (I)262144L, (I)262144L, 1,3,1, + ((I)4194304L +(I)2097152L +(I)67108864L), ((I)1048576L +(I)524288L +(I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L)), ((I)1048576L +(I)524288L +(I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L)), -1L, 1,2,1, + (I)33554432L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L), (I)2097152L, ((I)1048576L +(I)524288L +(I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L)), -1L, 0,2,1, + (I)67108864L, ((I)1048576L +(I)524288L +(I)262144L +(((I)1L +(I)256L +(I)4L +(I)8L +(I)16L +(I)64L +(I)128L +(I)268435456L +(I)536870912L +(I)1024L +(I)4096L +(I)8192L +(I)16384L)+((I)2L +(I)131072L +(I)2048L)+(I)32L +(I)32768L +(I)65536L)), (I)134217728L, -1L, 0,2,0, +}; + +int main() { + int i, j; + + for(j=0; j < sizeof(cases)/sizeof(cases[0]); j++) { + for(i=0; i < sizeof(cases->c)/sizeof(cases->c[0]); i++) + printf("cases[%d].c[%d]=%ld\n", j, i, cases[j].c[i]); + + printf("cases[%d].b=%ld\n", j, cases[j].b); + printf("cases[%d].e=%ld\n", j, cases[j].e); + printf("cases[%d].k=%ld\n", j, cases[j].k); + printf("\n"); + } + return 0; +} diff --git a/tinycc/tests/tests2/75_array_in_struct_init.expect b/tinycc/tests/tests2/75_array_in_struct_init.expect new file mode 100644 index 0000000..2b75aa5 --- /dev/null +++ b/tinycc/tests/tests2/75_array_in_struct_init.expect @@ -0,0 +1,72 @@ +cases[0].c[0]=73400320 +cases[0].c[1]=262144 +cases[0].c[2]=805567999 +cases[0].c[3]=-1 +cases[0].b=1 +cases[0].e=2 +cases[0].k=1 + +cases[1].c[0]=879754751 +cases[1].c[1]=262144 +cases[1].c[2]=262144 +cases[1].c[3]=805567999 +cases[1].b=2 +cases[1].e=3 +cases[1].k=2 + +cases[2].c[0]=879754751 +cases[2].c[1]=805567999 +cases[2].c[2]=262144 +cases[2].c[3]=805567999 +cases[2].b=1 +cases[2].e=3 +cases[2].k=2 + +cases[3].c[0]=879754751 +cases[3].c[1]=805830143 +cases[3].c[2]=524288 +cases[3].c[3]=-1 +cases[3].b=1 +cases[3].e=2 +cases[3].k=1 + +cases[4].c[0]=879754751 +cases[4].c[1]=805830143 +cases[4].c[2]=1048576 +cases[4].c[3]=805830143 +cases[4].b=1 +cases[4].e=3 +cases[4].k=1 + +cases[5].c[0]=879754751 +cases[5].c[1]=805830143 +cases[5].c[2]=262144 +cases[5].c[3]=262144 +cases[5].b=1 +cases[5].e=3 +cases[5].k=1 + +cases[6].c[0]=73400320 +cases[6].c[1]=807403007 +cases[6].c[2]=807403007 +cases[6].c[3]=-1 +cases[6].b=1 +cases[6].e=2 +cases[6].k=1 + +cases[7].c[0]=839122431 +cases[7].c[1]=2097152 +cases[7].c[2]=807403007 +cases[7].c[3]=-1 +cases[7].b=0 +cases[7].e=2 +cases[7].k=1 + +cases[8].c[0]=67108864 +cases[8].c[1]=807403007 +cases[8].c[2]=134217728 +cases[8].c[3]=-1 +cases[8].b=0 +cases[8].e=2 +cases[8].k=0 + diff --git a/tinycc/tests/tests2/76_dollars_in_identifiers.c b/tinycc/tests/tests2/76_dollars_in_identifiers.c new file mode 100644 index 0000000..c5fcf99 --- /dev/null +++ b/tinycc/tests/tests2/76_dollars_in_identifiers.c @@ -0,0 +1,41 @@ +#include <stdio.h> + +#define $(x) x +#define $fred 10 +#define joe$ 20 +#define hen$y 30 + +#define $10(x) x*10 +#define _$10(x) x/10 + +int main() +{ + printf("fred=%d\n", $fred); + printf("joe=%d\n", joe$); + printf("henry=%d\n", hen$y); + + printf("fred2=%d\n", $($fred)); + printf("joe2=%d\n", $(joe$)); + printf("henry2=%d\n", $(hen$y)); + + printf("fred10=%d\n", $10($fred)); + printf("joe_10=%d\n", _$10(joe$)); + + int $ = 10; + int a100$ = 100; + int a$$ = 1000; + int a$c$b = 2121; + int $100 = 10000; + const char *$$$ = "money"; + + printf("local=%d\n", $); + printf("a100$=%d\n", a100$); + printf("a$$=%d\n", a$$); + printf("a$c$b=%d\n", a$c$b); + printf("$100=%d\n", $100); + printf("$$$=%s", $$$); + + return 0; +} + +/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/ diff --git a/tinycc/tests/tests2/76_dollars_in_identifiers.expect b/tinycc/tests/tests2/76_dollars_in_identifiers.expect new file mode 100644 index 0000000..4a20a52 --- /dev/null +++ b/tinycc/tests/tests2/76_dollars_in_identifiers.expect @@ -0,0 +1,14 @@ +fred=10 +joe=20 +henry=30 +fred2=10 +joe2=20 +henry2=30 +fred10=100 +joe_10=2 +local=10 +a100$=100 +a$$=1000 +a$c$b=2121 +$100=10000 +$$$=money diff --git a/tinycc/tests/tests2/77_push_pop_macro.c b/tinycc/tests/tests2/77_push_pop_macro.c new file mode 100644 index 0000000..d38e0bf --- /dev/null +++ b/tinycc/tests/tests2/77_push_pop_macro.c @@ -0,0 +1,30 @@ +#include <stdio.h> + +int main() +{ + /* must not affect how #pragma ppop_macro works */ + #define pop_macro foobar1 + + /* must not affect how #pragma push_macro works */ + #define push_macro foobar2 + + #undef abort + #define abort "111" + printf("abort = %s\n", abort); + + #pragma push_macro("abort") + #undef abort + #define abort "222" + printf("abort = %s\n", abort); + + #pragma push_macro("abort") + #undef abort + #define abort "333" + printf("abort = %s\n", abort); + + #pragma pop_macro("abort") + printf("abort = %s\n", abort); + + #pragma pop_macro("abort") + printf("abort = %s\n", abort); +} diff --git a/tinycc/tests/tests2/77_push_pop_macro.expect b/tinycc/tests/tests2/77_push_pop_macro.expect new file mode 100644 index 0000000..d8a5530 --- /dev/null +++ b/tinycc/tests/tests2/77_push_pop_macro.expect @@ -0,0 +1,5 @@ +abort = 111 +abort = 222 +abort = 333 +abort = 222 +abort = 111 diff --git a/tinycc/tests/tests2/78_vla_label.c b/tinycc/tests/tests2/78_vla_label.c new file mode 100644 index 0000000..4096495 --- /dev/null +++ b/tinycc/tests/tests2/78_vla_label.c @@ -0,0 +1,45 @@ +#include <stdio.h> + +/* This test segfaults as of April 27, 2015. */ +void f1(int argc) +{ + char test[argc]; + if(0) + label: + printf("boom!\n"); + if(argc-- == 0) + return; + goto label; +} + +/* This segfaulted on 2015-11-19. */ +void f2(void) +{ + goto start; + { + int a[1 && 1]; /* not a variable-length array */ + int b[1 || 1]; /* not a variable-length array */ + int c[1 ? 1 : 1]; /* not a variable-length array */ + start: + a[0] = 0; + b[0] = 0; + c[0] = 0; + } +} + +void f3(void) +{ + printf("%d\n", 0 ? printf("x1\n") : 11); + printf("%d\n", 1 ? 12 : printf("x2\n")); + printf("%d\n", 0 && printf("x3\n")); + printf("%d\n", 1 || printf("x4\n")); +} + +int main() +{ + f1(2); + f2(); + f3(); + + return 0; +} diff --git a/tinycc/tests/tests2/78_vla_label.expect b/tinycc/tests/tests2/78_vla_label.expect new file mode 100644 index 0000000..3f4063b --- /dev/null +++ b/tinycc/tests/tests2/78_vla_label.expect @@ -0,0 +1,6 @@ +boom! +boom! +11 +12 +0 +1 diff --git a/tinycc/tests/tests2/79_vla_continue.c b/tinycc/tests/tests2/79_vla_continue.c new file mode 100644 index 0000000..dd63790 --- /dev/null +++ b/tinycc/tests/tests2/79_vla_continue.c @@ -0,0 +1,119 @@ +#include <stdio.h> + +int f(void) +{ + return 5; +} + +void test1() +{ + int count = 10; + void *addr[10]; + for(;count--;) { + int a[f()]; + + addr[count] = a; + + continue; + } + + if(addr[9] == addr[0]) { + printf("OK\n"); + } else { + printf("NOT OK\n"); + } +} + +void test2() +{ + int count = 10; + void *addr[count]; + for(;count--;) { + int a[f()]; + + addr[count] = a; + + continue; + } + + if(addr[9] == addr[0]) { + printf("OK\n"); + } else { + printf("NOT OK\n"); + } +} + +void test3() +{ + int count = 10; + void *addr[count]; + while(count--) { + int b[f()]; + if (count >= 0) { + int a[f()]; + + addr[count] = a; + + continue; + } + } + + if(addr[9] == addr[0]) { + printf("OK\n"); + } else { + printf("NOT OK\n"); + } +} + +void test4() +{ + int count = 10; + void *addr[count]; + do { + int a[f()]; + + addr[--count] = a; + + continue; + } while (count); + + if(addr[9] == addr[0]) { + printf("OK\n"); + } else { + printf("NOT OK\n"); + } +} + +void test5() +{ + int count = 10; + int a[f()]; + int c[f()]; + + c[0] = 42; + + for(;count--;) { + int b[f()]; + int i; + for (i=0; i<f(); i++) { + b[i] = count; + } + } + + if (c[0] == 42) { + printf("OK\n"); + } else { + printf("NOT OK\n"); + } +} + +int main(void) +{ + test1(); + test2(); + test3(); + test4(); + test5(); + + return 0; +} diff --git a/tinycc/tests/tests2/79_vla_continue.expect b/tinycc/tests/tests2/79_vla_continue.expect new file mode 100644 index 0000000..21da4d2 --- /dev/null +++ b/tinycc/tests/tests2/79_vla_continue.expect @@ -0,0 +1,5 @@ +OK +OK +OK +OK +OK diff --git a/tinycc/tests/tests2/80_flexarray.c b/tinycc/tests/tests2/80_flexarray.c new file mode 100644 index 0000000..864d429 --- /dev/null +++ b/tinycc/tests/tests2/80_flexarray.c @@ -0,0 +1,26 @@ +#include <stdio.h> +struct wchar { + char *data; char mem[]; +}; +struct wint { + char *data; int mem[]; +}; +int f1char (void) { + char s[9]="nonono"; + struct wchar q = {"bugs"}; + return !s[0]; +} +int f1int (void) { + char s[9]="nonono"; + struct wint q = {"bugs"}; + return !s[0]; +} +int empty[] = {}; // GNU extension +int main (void) { + char s[9]="nonono"; + static struct wchar q = {"bugs", {'c'}}; + //printf ("tcc has %s %s\n", s, q.data); + if (f1char() || f1int()) + printf ("bla\n"); + return !s[0]; +} diff --git a/tinycc/tests/tests2/80_flexarray.expect b/tinycc/tests/tests2/80_flexarray.expect new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tinycc/tests/tests2/80_flexarray.expect diff --git a/tinycc/tests/tests2/81_types.c b/tinycc/tests/tests2/81_types.c new file mode 100644 index 0000000..0bc3bae --- /dev/null +++ b/tinycc/tests/tests2/81_types.c @@ -0,0 +1,55 @@ +/* The following are all valid decls, even though some subtypes + are incomplete. */ +enum E *e; +const enum E *e1; +enum E const *e2; +struct S *s; +const struct S *s1; +struct S const *s2; + +/* Various strangely looking declarators, which are all valid + and have to map to the same numbered typedefs. */ +typedef int (*fptr1)(); +int f1 (int (), int); +typedef int (*fptr2)(int x); +int f2 (int (int x), int); +typedef int (*fptr3)(int); +int f3 (int (int), int); +typedef int (*fptr4[4])(int); +int f4 (int (*[4])(int), int); +typedef int (*fptr5)(fptr1); +int f5 (int (int()), fptr1); +int f1 (fptr1 fp, int i) +{ + return (*fp)(i); +} +int f2 (fptr2 fp, int i) +{ + return (*fp)(i); +} +int f3 (fptr3 fp, int i) +{ + return (*fp)(i); +} +int f4 (fptr4 fp, int i) +{ + return (*fp[i])(i); +} +int f5 (fptr5 fp, fptr1 i) +{ + return fp(i); +} +typedef int intx4[4]; +int f8 (intx4, int); +int f8 (int ([4]), int); +int f8 (int y[4], int i) +{ + return y[i]; +} +int f9 (int (*)(int), int); +int f9 (int ((int)), int); +int f9 (int f(int), int i) +{ + return f(i); +} +int main () { return 0; } diff --git a/tinycc/tests/tests2/81_types.expect b/tinycc/tests/tests2/81_types.expect new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tinycc/tests/tests2/81_types.expect diff --git a/tinycc/tests/tests2/82_attribs_position.c b/tinycc/tests/tests2/82_attribs_position.c new file mode 100644 index 0000000..d8c9fe5 --- /dev/null +++ b/tinycc/tests/tests2/82_attribs_position.c @@ -0,0 +1,71 @@ +typedef unsigned short uint16_t; +typedef unsigned char uint8_t; + +typedef union Unaligned16a { + uint16_t u; + uint8_t b[2]; +} __attribute__((packed)) Unaligned16a; + +typedef union __attribute__((packed)) Unaligned16b { + uint16_t u; + uint8_t b[2]; +} Unaligned16b; + +extern void foo (void) __attribute__((stdcall)); +void __attribute__((stdcall)) foo (void) +{ +} + +#define __stdcall __attribute__((stdcall)) +extern int some_stdcall_func (int, int, int) __stdcall; +__stdcall int __stdcall some_stdcall_func(int foo, int bar, int baz) { + //printf("Hello from stdcall: %i %i %i\n", foo, bar, baz); + return 43; +} + +/* The actual attribute isn't important, must just be + parsable. */ +#define ATTR __attribute__((__noinline__)) +int ATTR actual_function() { + return 42; +} + +int label_attribute (void) +{ +lab1: __attribute__((__unused__)); + return 0; +} + +extern int printf (const char *, ...); +static int globalvar; +int main() +{ + void *function_pointer = &actual_function; + int localvar = 42, i; + + int a = ((ATTR int(*) (void)) function_pointer)(); + printf("%i\n", a); + + /* In the following we once misparsed 'ATTR *' is a btype + and hence the whole type was garbled. */ + int b = ( (int(ATTR *)(void)) function_pointer)(); + printf("%i\n", b); + + /* All these should work and leave the stack pointer in its original + position. */ + some_stdcall_func(1, 10, 100); + ((int __stdcall (*)(int, int, int))some_stdcall_func) (2, 20, 200); + ((int(*__stdcall)(int, int, int))some_stdcall_func) (3, 30, 300); + for (i = 0; i < 1024; i++) { + globalvar = i; + /* This was once misparsed at <= gitrev 325241c0, forgetting + the stdcall attribute on the function pointer leading to + stack increment being done twice (in callee and caller). + This will clobber 'i' and 'localvar' which is how we detect + this. */ + ((int(__stdcall*)(int, int, int))some_stdcall_func) (4, 40, 400); + if (localvar != 42 || globalvar != i) + printf("error, localvar=%d i=%d globalvar=%d\n", localvar, i, globalvar); + } + return 0; +} diff --git a/tinycc/tests/tests2/82_attribs_position.expect b/tinycc/tests/tests2/82_attribs_position.expect new file mode 100644 index 0000000..daaac9e --- /dev/null +++ b/tinycc/tests/tests2/82_attribs_position.expect @@ -0,0 +1,2 @@ +42 +42 diff --git a/tinycc/tests/tests2/83_utf8_in_identifiers.c b/tinycc/tests/tests2/83_utf8_in_identifiers.c new file mode 100644 index 0000000..1f86095 --- /dev/null +++ b/tinycc/tests/tests2/83_utf8_in_identifiers.c @@ -0,0 +1,9 @@ +#include <stdio.h> +double привет=0.1; +int Lefèvre=2; +int main(){ + printf("привет=%g\n",привет); + printf("Lefèvre=%d\n",Lefèvre); + return 0; +} +// pcc & tcc only diff --git a/tinycc/tests/tests2/83_utf8_in_identifiers.expect b/tinycc/tests/tests2/83_utf8_in_identifiers.expect new file mode 100644 index 0000000..1553f5f --- /dev/null +++ b/tinycc/tests/tests2/83_utf8_in_identifiers.expect @@ -0,0 +1,2 @@ +привет=0.1 +Lefèvre=2 diff --git a/tinycc/tests/tests2/84_hex-float.c b/tinycc/tests/tests2/84_hex-float.c new file mode 100644 index 0000000..0ef09bf --- /dev/null +++ b/tinycc/tests/tests2/84_hex-float.c @@ -0,0 +1,12 @@ +extern int printf(const char *format, ...); + +#define ACPI_TYPE_INVALID 0x1E +#define NUM_NS_TYPES ACPI_TYPE_INVALID+1 +int array[NUM_NS_TYPES]; + +#define n 0xe +int main() +{ + printf("n+1 = %d\n", n+1); +// printf("n+1 = %d\n", 0xe+1); +} diff --git a/tinycc/tests/tests2/84_hex-float.expect b/tinycc/tests/tests2/84_hex-float.expect new file mode 100644 index 0000000..2175385 --- /dev/null +++ b/tinycc/tests/tests2/84_hex-float.expect @@ -0,0 +1 @@ +n+1 = 15 diff --git a/tinycc/tests/tests2/85_asm-outside-function.c b/tinycc/tests/tests2/85_asm-outside-function.c new file mode 100644 index 0000000..3d7434d --- /dev/null +++ b/tinycc/tests/tests2/85_asm-outside-function.c @@ -0,0 +1,15 @@ +#ifdef __leading_underscore +# define _ "_" +#else +# define _ +#endif + +extern int printf (const char *, ...); +extern void vide(void); +__asm__(_"vide: ret"); + +int main() { + vide(); + printf ("okay\n"); + return 0; +} diff --git a/tinycc/tests/tests2/85_asm-outside-function.expect b/tinycc/tests/tests2/85_asm-outside-function.expect new file mode 100644 index 0000000..dcf02b2 --- /dev/null +++ b/tinycc/tests/tests2/85_asm-outside-function.expect @@ -0,0 +1 @@ +okay diff --git a/tinycc/tests/tests2/86_memory-model.c b/tinycc/tests/tests2/86_memory-model.c new file mode 100644 index 0000000..744c3e2 --- /dev/null +++ b/tinycc/tests/tests2/86_memory-model.c @@ -0,0 +1,38 @@ +#include <stdio.h> + +int +main() +{ +#if defined(__LLP64__) + if (sizeof(short) == 2 + && sizeof(int) == 4 + && sizeof(long int) == 4 + && sizeof(long long int) == 8 + && sizeof(void*) == 8) { + (void)printf("Ok\n"); + } else { + (void)printf("KO __LLP64__\n"); + } +#elif defined(__LP64__) + if (sizeof(short) == 2 + && sizeof(int) == 4 + && sizeof(long int) == 8 + && sizeof(long long int) == 8 + && sizeof(void*) == 8) { + (void)printf("Ok\n"); + } else { + (void)printf("KO __LP64__\n"); + } +#elif defined(__ILP32__) + if (sizeof(short) == 2 + && sizeof(int) == 4 + && sizeof(long int) == 4 + && sizeof(void*) == 4) { + (void)printf("Ok\n"); + } else { + (void)printf("KO __ILP32__\n"); + } +#else + (void)printf("KO no __*LP*__ defined.\n"); +#endif +} diff --git a/tinycc/tests/tests2/86_memory-model.expect b/tinycc/tests/tests2/86_memory-model.expect new file mode 100644 index 0000000..7326d96 --- /dev/null +++ b/tinycc/tests/tests2/86_memory-model.expect @@ -0,0 +1 @@ +Ok diff --git a/tinycc/tests/tests2/87_dead_code.c b/tinycc/tests/tests2/87_dead_code.c new file mode 100644 index 0000000..369f4ba --- /dev/null +++ b/tinycc/tests/tests2/87_dead_code.c @@ -0,0 +1,165 @@ +/* This checks various ways of dead code inside if statements + where there are non-obvious ways of how the code is actually + not dead due to reachable by labels. */ +extern int printf (const char *, ...); +static void kb_wait_1(void) +{ + unsigned long timeout = 2; + do { + /* Here the else arm is a statement expression that's supposed + to be suppressed. The label inside the while would unsuppress + code generation again if not handled correctly. And that + would wreak havoc to the cond-expression because there's no + jump-around emitted, the whole statement expression really + needs to not generate code (perhaps except useless forward jumps). */ + (1 ? + printf("timeout=%ld\n", timeout) : + ({ + int i = 1; + while (1) + while (i--) + some_label: + printf("error\n"); + goto some_label; + }) + ); + timeout--; + } while (timeout); +} + +static int global; + +static void foo(int i) +{ + global+=i; + printf ("g=%d\n", global); +} + +static int check(void) +{ + printf ("check %d\n", global); + return 1; +} + +static void dowhile(void) +{ + do { + foo(1); + if (global == 1) { + continue; + } else if (global == 2) { + continue; + } + /* The following break shouldn't disable the check() call, + as it's reachable by the continues above. */ + break; + } while (check()); +} + +static void nondead_after_dead_return(void) +{ + /* This statement expr is not entered, and hence that fact that it + doesn't fall-through should not influence the surrounding code. */ + 0 && ({ return; 0;}); + printf ("nondead works\n"); + return; +} + +int main (void) +{ + int i = 1; + kb_wait_1(); + + /* Simple test of dead code at first sight which isn't actually dead. */ + if (0) { +yeah: + printf ("yeah\n"); + } else { + printf ("boo\n"); + } + if (i--) + goto yeah; + + /* Some more non-obvious uses where the problems are loops, so that even + the first loop statements aren't actually dead. */ + i = 1; + if (0) { + while (i--) { + printf ("once\n"); +enterloop: + printf ("twice\n"); + } + } + if (i >= 0) + goto enterloop; + + /* The same with statement expressions. One might be tempted to + handle them specially by counting if inside statement exprs and + not unsuppressing code at loops at all then. + See kb_wait_1 for the other side of the medal where that wouldn't work. */ + i = ({ + int j = 1; + if (0) { + while (j--) { + printf ("SEonce\n"); + enterexprloop: + printf ("SEtwice\n"); + } + } + if (j >= 0) + goto enterexprloop; + j; }); + + /* The other two loop forms: */ + i = 1; + if (0) { + for (i = 1; i--;) { + printf ("once2\n"); +enterloop2: + printf ("twice2\n"); + } + } + if (i > 0) + goto enterloop2; + + i = 1; + if (0) { + do { + printf ("once3\n"); +enterloop3: + printf ("twice3\n"); + } while (i--); + } + if (i > 0) + goto enterloop3; + + /* And check that case and default labels have the same effect + of disabling code suppression. */ + i = 41; + switch (i) { + if (0) { + printf ("error\n"); + case 42: + printf ("error2\n"); + case 41: + printf ("caseok\n"); + } + } + + i = 41; + switch (i) { + if (0) { + printf ("error3\n"); + default: + printf ("caseok2\n"); + break; + case 42: + printf ("error4\n"); + } + } + + dowhile(); + nondead_after_dead_return(); + + return 0; +} diff --git a/tinycc/tests/tests2/87_dead_code.expect b/tinycc/tests/tests2/87_dead_code.expect new file mode 100644 index 0000000..781ff51 --- /dev/null +++ b/tinycc/tests/tests2/87_dead_code.expect @@ -0,0 +1,24 @@ +timeout=2 +timeout=1 +boo +yeah +twice +once +twice +SEtwice +SEonce +SEtwice +twice2 +once2 +twice2 +twice3 +once3 +twice3 +caseok +caseok2 +g=1 +check 1 +g=2 +check 2 +g=3 +nondead works diff --git a/tinycc/tests/tests2/88_codeopt.c b/tinycc/tests/tests2/88_codeopt.c new file mode 100644 index 0000000..3faa5fa --- /dev/null +++ b/tinycc/tests/tests2/88_codeopt.c @@ -0,0 +1,80 @@ +/* Check some way in where code suppression caused various + miscompilations. */ +extern int printf (const char *, ...); +typedef __SIZE_TYPE__ size_t; + +size_t _brk_start, _brk_end; +void * extend_brk(size_t size, size_t align) +{ + size_t mask = align - 1; + void *ret = 0; + + do { + if (__builtin_expect(!!(_brk_start == 0), 0)) + do { + printf("wrong1\n"); + } while (0); + } while (0); + _brk_end = (_brk_end + mask) & ~mask; + ret = (void *)_brk_end; + _brk_end += size; + + return ret; +} + +static void get_args (int a, int b) +{ + if (a != 1) + printf("wrong2\n"); + else + printf("okay\n"); +} + +void bla(void) +{ + int __ret = 42; + ({ + if (__builtin_expect(!!(0), 0)) { + if (__builtin_expect(!!__ret, 0)) + printf("wrong3\n"); + int x = !!(__ret); + } + __ret; + }); + get_args(!!__ret, sizeof(__ret)); +} + +int ext; + +void broken_jumpopt (int xxx) +{ + /* This was broken in 8227db3a2 by code suppression during suppressed + code :) */ + ext = (xxx || 1) || ((xxx && 1) || 1); + printf("okay: %d %d\n", xxx, ext); +} + +_Bool chk(unsigned long addr, unsigned long limit, unsigned long size) +{ + _Bool ret; + /* This just needs to compile, no runtime test. (And it doesn't compile + only with certain internal checking added that's not committed). */ + if (0) + ret = 0 != (!!(addr > limit - size)); + return 0; +} + +int main() +{ + void *r; + _brk_start = 1024; + _brk_end = 1024; + r = extend_brk (4096, 16); + if (!r) + printf("wrong4\n"); + else + printf("okay\n"); + bla(); + broken_jumpopt(42); + return 0; +} diff --git a/tinycc/tests/tests2/88_codeopt.expect b/tinycc/tests/tests2/88_codeopt.expect new file mode 100644 index 0000000..76b582b --- /dev/null +++ b/tinycc/tests/tests2/88_codeopt.expect @@ -0,0 +1,3 @@ +okay +okay +okay: 42 1 diff --git a/tinycc/tests/tests2/89_nocode_wanted.c b/tinycc/tests/tests2/89_nocode_wanted.c new file mode 100644 index 0000000..73e0a4b --- /dev/null +++ b/tinycc/tests/tests2/89_nocode_wanted.c @@ -0,0 +1,112 @@ +extern int printf(const char *format, ...); +static void kb_wait_1(void) +{ + unsigned long timeout = 2; + do { + (1 ? + printf("timeout=%ld\n", timeout) : + ({ + while (1) + printf("error\n"); + }) + ); + timeout--; + } while (timeout); +} +static void kb_wait_2(void) +{ + unsigned long timeout = 2; + do { + (1 ? + printf("timeout=%ld\n", timeout) : + ({ + for (;;) + printf("error\n"); + }) + ); + timeout--; + } while (timeout); +} +static void kb_wait_2_1(void) +{ + unsigned long timeout = 2; + do { + (1 ? + printf("timeout=%ld\n", timeout) : + ({ + do { + printf("error\n"); + } while (1); + }) + ); + timeout--; + } while (timeout); +} +static void kb_wait_2_2(void) +{ + unsigned long timeout = 2; + do { + (1 ? + printf("timeout=%ld\n", timeout) : + ({ + label: + printf("error\n"); + goto label; + }) + ); + timeout--; + } while (timeout); +} +static void kb_wait_3(void) +{ + unsigned long timeout = 2; + do { + (1 ? + printf("timeout=%ld\n", timeout) : + ({ + int i = 1; + goto label; + i = i + 2; + label: + i = i + 3; + }) + ); + timeout--; + } while (timeout); +} +static void kb_wait_4(void) +{ + unsigned long timeout = 2; + do { + (1 ? + printf("timeout=%ld\n", timeout) : + ({ + switch(timeout) { + case 2: + printf("timeout is 2"); + break; + case 1: + printf("timeout is 1"); + break; + default: + printf("timeout is 0?"); + break; + }; + // return; + }) + ); + timeout--; + } while (timeout); +} +int main() +{ + printf("begin\n"); + kb_wait_1(); + kb_wait_2(); + kb_wait_2_1(); + kb_wait_2_2(); + kb_wait_3(); + kb_wait_4(); + printf("end\n"); + return 0; +} diff --git a/tinycc/tests/tests2/89_nocode_wanted.expect b/tinycc/tests/tests2/89_nocode_wanted.expect new file mode 100644 index 0000000..c44d4ea --- /dev/null +++ b/tinycc/tests/tests2/89_nocode_wanted.expect @@ -0,0 +1,14 @@ +begin +timeout=2 +timeout=1 +timeout=2 +timeout=1 +timeout=2 +timeout=1 +timeout=2 +timeout=1 +timeout=2 +timeout=1 +timeout=2 +timeout=1 +end diff --git a/tinycc/tests/tests2/90_struct-init.c b/tinycc/tests/tests2/90_struct-init.c new file mode 100644 index 0000000..4a71a93 --- /dev/null +++ b/tinycc/tests/tests2/90_struct-init.c @@ -0,0 +1,424 @@ +typedef unsigned char u8; +typedef struct {} empty_s; +struct contains_empty { + u8 a; + empty_s empty; + u8 b; +}; +struct contains_empty ce = { { (1) }, (empty_s){}, 022, }; +/* The following decl of 'q' would demonstrate the TCC bug in init_putv when + handling copying compound literals. (Compound literals + aren't acceptable constant initializers in isoc99, but + we accept them like gcc, except for this case) +//char *q = (char *){ "trara" }; */ +struct SS {u8 a[3], b; }; +struct SS sinit16[] = { { 1 }, 2 }; +struct S +{ + u8 a,b; + u8 c[2]; +}; + +struct T +{ + u8 s[16]; + u8 a; +}; + +struct U +{ + u8 a; + struct S s; + u8 b; + struct T t; +}; + +struct V +{ + struct S s; + struct T t; + u8 a; +}; + +struct W +{ + struct V t; + struct S s[]; +}; + +struct S gs = ((struct S){1, 2, 3, 4}); +struct S gs2 = {1, 2, {3, 4}}; +struct T gt = {"hello", 42}; +struct U gu = {3, 5,6,7,8, 4, "huhu", 43}; +struct U gu2 = {3, {5,6,7,8}, 4, {"huhu", 43}}; +/* Optional braces around scalar initializers. Accepted, but with + a warning. */ +struct U gu3 = { {3}, {5,6,7,8,}, 4, {"huhu", 43}}; +/* Many superfluous braces and leaving out one initializer for U.s.c[1] */ +struct U gu4 = { 3, {5,6,7,}, 5, { "bla", {44}} }; +/* Superfluous braces and useless parens around values */ +struct S gs3 = { (1), {(2)}, {(((3))), {4}}}; +/* Superfluous braces, and leaving out braces for V.t, plus cast */ +struct V gv = {{{3},4,{5,6}}, "haha", (u8)45, 46}; +/* Compound literal */ +struct V gv2 = {(struct S){7,8,{9,10}}, {"hihi", 47}, 48}; +/* Parens around compound literal */ +struct V gv3 = {((struct S){7,8,{9,10}}), {"hoho", 49}, 50}; +/* Initialization of a flex array member (warns in GCC) */ +struct W gw = {{1,2,3,4}, {1,2,3,4,5}}; + +union UU { + u8 a; + u8 b; +}; +struct SU { + union UU u; + u8 c; +}; +struct SU gsu = {5,6}; + +/* Unnamed struct/union members aren't ISO C, but it's a widely accepted + extension. See below for further extensions to that under -fms-extension.*/ +union UV { + struct {u8 a,b;}; + struct S s; +}; +union UV guv = {{6,5}}; +union UV guv2 = {{.b = 7, .a = 8}}; +union UV guv3 = {.b = 8, .a = 7}; + +struct SSU { + int y; + struct { int x; }; +}; +struct SSU gssu1 = { .y = 5, .x = 3 }; +struct SSU gssu2 = { 5, 3 }; + +/* Under -fms-extensions also the following is valid: +union UV2 { + struct Anon {u8 a,b;}; // unnamed member, but tagged struct, ... + struct S s; +}; +struct Anon gan = { 10, 11 }; // ... which makes it available here. +union UV2 guv4 = {{4,3}}; // and the other inits from above as well +*/ + +struct in6_addr { + union { + u8 u6_addr8[16]; + unsigned short u6_addr16[8]; + } u; +}; +struct flowi6 { + struct in6_addr saddr, daddr; +}; +struct pkthdr { + struct in6_addr daddr, saddr; +}; +struct pkthdr phdr = { { { 6,5,4,3 } }, { { 9,8,7,6 } } }; + +struct Wrap { + void *func; +}; +int global; +void inc_global (void) +{ + global++; +} + +struct Wrap global_wrap[] = { + ((struct Wrap) {inc_global}), + inc_global, +}; + +#include <stdio.h> +void print_ (const char *name, const u8 *p, long size) +{ + printf ("%s:", name); + while (size--) { + printf (" %x", *p++); + } + printf ("\n"); +} +#define print(x) print_(#x, (u8*)&x, sizeof (x)) +#if 1 +void foo (struct W *w, struct pkthdr *phdr_) +{ + struct S ls = {1, 2, 3, 4}; + struct S ls2 = {1, 2, {3, 4}}; + struct T lt = {"hello", 42}; + struct U lu = {3, 5,6,7,8, 4, "huhu", 43}; + struct U lu1 = {3, ls, 4, {"huhu", 43}}; + struct U lu2 = {3, (ls), 4, {"huhu", 43}}; + const struct S *pls = &ls; + struct S ls21 = *pls; + struct U lu22 = {3, *pls, 4, {"huhu", 43}}; + /* Incomplete bracing. */ + struct U lu21 = {3, ls, 4, "huhu", 43}; + /* Optional braces around scalar initializers. Accepted, but with + a warning. */ + struct U lu3 = { 3, {5,6,7,8,}, 4, {"huhu", 43}}; + /* Many superfluous braces and leaving out one initializer for U.s.c[1] */ + struct U lu4 = { 3, {5,6,7,}, 5, { "bla", 44} }; + /* Superfluous braces and useless parens around values */ + struct S ls3 = { (1), (2), {(((3))), 4}}; + /* Superfluous braces, and leaving out braces for V.t, plus cast */ + struct V lv = {{3,4,{5,6}}, "haha", (u8)45, 46}; + /* Compound literal */ + struct V lv2 = {(struct S)w->t.s, {"hihi", 47}, 48}; + /* Parens around compound literal */ + struct V lv3 = {((struct S){7,8,{9,10}}), ((const struct W *)w)->t.t, 50}; + const struct pkthdr *phdr = phdr_; + struct flowi6 flow = { .daddr = phdr->daddr, .saddr = phdr->saddr }; + int elt = 0x42; + /* Range init, overlapping */ + struct T lt2 = { { [1 ... 5] = 9, [6 ... 10] = elt, [4 ... 7] = elt+1 }, 1 }; + struct SSU lssu1 = { 5, 3 }; + struct SSU lssu2 = { .y = 5, .x = 3 }; + /* designated initializers in GNU form */ +#if defined(__GNUC__) || defined(__TINYC__) + struct S ls4 = {a: 1, b: 2, c: {3, 4}}; +#else + struct S ls4 = {.a = 1, .b = 2, .c = {3, 4}}; +#endif + print(ls); + print(ls2); + print(lt); + print(lu); + print(lu1); + print(lu2); + print(ls21); + print(lu21); + print(lu22); + print(lu3); + print(lu4); + print(ls3); + print(lv); + print(lv2); + print(lv3); + print(lt2); + print(lssu1); + print(lssu2); + print(flow); + print(ls4); +} +#endif + +void test_compound_with_relocs (void) +{ + struct Wrap local_wrap[] = { + ((struct Wrap) {inc_global}), + inc_global, + }; + void (*p)(void); + p = global_wrap[0].func; p(); + p = global_wrap[1].func; p(); + p = local_wrap[0].func; p(); + p = local_wrap[1].func; p(); +} + +void sys_ni(void) { printf("ni\n"); } +void sys_one(void) { printf("one\n"); } +void sys_two(void) { printf("two\n"); } +void sys_three(void) { printf("three\n"); } +void sys_four(void) { printf("four\n"); } +typedef void (*fptr)(void); + +#define array_size(a) (sizeof a / sizeof a[0]) + +void test_multi_relocs(void) +{ + int i; + + static const fptr tabl1[4] = { + [0 ... 3] = &sys_ni, + [0] = sys_one, + [1] = sys_two, + [2] = sys_three, + sys_four, + [1 ... 2] = &sys_ni, + [1] = 0, + }; + for (i = 0; i < array_size(tabl1); i++) + if (tabl1[i]) + tabl1[i](); + else + printf("(0)\n"); + + const fptr tabl2[4] = { + [0 ... 3] = &sys_ni, + [0] = sys_one, + [1] = sys_two, + [2] = sys_three, + sys_four, + [1 ... 2] = &sys_ni, + [1] = 0, + }; + for (i = 0; i < array_size(tabl2); i++) + if (tabl2[i]) + tabl2[i](); + else + printf("(0)\n"); + + int c = 0; + int dd[] = { + [0 ... 1] = ++c, + [2 ... 3] = ++c + }; + for (i = 0; i < array_size(dd); i++) + printf(" %d", dd[i]); + printf("\n"); + + /* multi-dimensional flex array with range initializers */ + static char m1[][2][3] = {[0 ... 2]={{3,4,5},{6,7,8}},{{9},10},"abc"}; + char m2[][2][3] = {[0 ... 2]={{3,4,5},{6,7,8}},{{9},10},"abc"}; + int g, j, k; + for (g = 2; g-- > 0;) { + printf("mdfa %s: %d -", "locl\0glob" + g * 5, sizeof m1); + for (i = 0; i < array_size(m1); i++) + for (j = 0; j < array_size(m1[0]); j++) + for (k = 0; k < array_size(m1[0][0]); k++) + printf(" %d", (g ? m1:m2)[i][j][k]); + printf("\n"); + } +} + +void test_init_ranges(void) { + int i,c=0; + static void *gostring[] = { + [0 ... 31] = &&l_bad, [127] = &&l_bad, + [32 ... 126] = &&l_loop, + ['\\'] = &&l_esc, ['"'] = &&l_qdown, + [128 ... 191] = &&l_bad, + [192 ... 223] = &&l_utf8_2, + [224 ... 239] = &&l_utf8_3, + [240 ... 247] = &&l_utf8_4, + [248 ... 255] = &&l_bad + }; + + for (i = 0; i < 256; i++) { + goto *gostring[i]; + l_bad: c++; + l_loop: c++; + l_esc: c++; + l_qdown: c++; + l_utf8_2: c++; + l_utf8_3: c++; + l_utf8_4: c++; + } + printf ("%d\n", c); +} + + +/* Following is from GCC gcc.c-torture/execute/20050613-1.c. */ + +struct SEA { int i; int j; int k; int l; }; +struct SEB { struct SEA a; int r[1]; }; +struct SEC { struct SEA a; int r[0]; }; +struct SED { struct SEA a; int r[]; }; + +static void +test_correct_filling (struct SEA *x) +{ + static int i; + if (x->i != 0 || x->j != 5 || x->k != 0 || x->l != 0) + printf("sea_fill%d: wrong\n", i); + else + printf("sea_fill%d: okay\n", i); + i++; +} + +int +test_zero_init (void) +{ + /* The peculiarity here is that only a.j is initialized. That + means that all other members must be zero initialized. TCC + once didn't do that for sub-level designators. */ + struct SEB b = { .a.j = 5 }; + struct SEC c = { .a.j = 5 }; + struct SED d = { .a.j = 5 }; + test_correct_filling (&b.a); + test_correct_filling (&c.a); + test_correct_filling (&d.a); + return 0; +} + +void test_init_struct_from_struct(void) +{ + int i = 0; + struct S {int x,y;} + a = {1,2}, + b = {3,4}, + c[] = {a,b}, + d[] = {++i, ++i, ++i, ++i}, + e[] = {b, (struct S){5,6}} + ; + + printf("%s: %d %d %d %d - %d %d %d %d - %d %d %d %d\n", + __FUNCTION__, + c[0].x, + c[0].y, + c[1].x, + c[1].y, + d[0].x, + d[0].y, + d[1].x, + d[1].y, + e[0].x, + e[0].y, + e[1].x, + e[1].y + ); +} + +typedef struct { + unsigned int a; + unsigned int : 32; + unsigned int b; + unsigned long long : 64; + unsigned int c; +} tst_bf; + +tst_bf arr[] = { { 1, 2, 3 } }; + +void +test_init_bf(void) +{ + printf ("%s: %d %d %d\n", __FUNCTION__, arr[0].a, arr[0].b, arr[0].c); +} + + +int main() +{ + print(ce); + print(gs); + print(gs2); + print(gt); + print(gu); + print(gu2); + print(gu3); + print(gu4); + print(gs3); + print(gv); + print(gv2); + print(gv3); + print(sinit16); + print(gw); + print(gsu); + print(guv); + print(guv.b); + print(guv2); + print(guv3); + print(gssu1); + print(gssu2); + print(phdr); + foo(&gw, &phdr); + //printf("q: %s\n", q); + test_compound_with_relocs(); + test_multi_relocs(); + test_zero_init(); + test_init_ranges(); + test_init_struct_from_struct(); + test_init_bf(); + return 0; +} diff --git a/tinycc/tests/tests2/90_struct-init.expect b/tinycc/tests/tests2/90_struct-init.expect new file mode 100644 index 0000000..5014f82 --- /dev/null +++ b/tinycc/tests/tests2/90_struct-init.expect @@ -0,0 +1,59 @@ +ce: 1 12 +gs: 1 2 3 4 +gs2: 1 2 3 4 +gt: 68 65 6c 6c 6f 0 0 0 0 0 0 0 0 0 0 0 2a +gu: 3 5 6 7 8 4 68 75 68 75 0 0 0 0 0 0 0 0 0 0 0 0 2b +gu2: 3 5 6 7 8 4 68 75 68 75 0 0 0 0 0 0 0 0 0 0 0 0 2b +gu3: 3 5 6 7 8 4 68 75 68 75 0 0 0 0 0 0 0 0 0 0 0 0 2b +gu4: 3 5 6 7 0 5 62 6c 61 0 0 0 0 0 0 0 0 0 0 0 0 0 2c +gs3: 1 2 3 4 +gv: 3 4 5 6 68 61 68 61 0 0 0 0 0 0 0 0 0 0 0 0 2d 2e +gv2: 7 8 9 a 68 69 68 69 0 0 0 0 0 0 0 0 0 0 0 0 2f 30 +gv3: 7 8 9 a 68 6f 68 6f 0 0 0 0 0 0 0 0 0 0 0 0 31 32 +sinit16: 1 0 0 0 2 0 0 0 +gw: 1 2 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +gsu: 5 6 +guv: 6 5 0 0 +guv.b: 5 +guv2: 8 7 0 0 +guv3: 7 8 0 0 +gssu1: 5 0 0 0 3 0 0 0 +gssu2: 5 0 0 0 3 0 0 0 +phdr: 6 5 4 3 0 0 0 0 0 0 0 0 0 0 0 0 9 8 7 6 0 0 0 0 0 0 0 0 0 0 0 0 +ls: 1 2 3 4 +ls2: 1 2 3 4 +lt: 68 65 6c 6c 6f 0 0 0 0 0 0 0 0 0 0 0 2a +lu: 3 5 6 7 8 4 68 75 68 75 0 0 0 0 0 0 0 0 0 0 0 0 2b +lu1: 3 1 2 3 4 4 68 75 68 75 0 0 0 0 0 0 0 0 0 0 0 0 2b +lu2: 3 1 2 3 4 4 68 75 68 75 0 0 0 0 0 0 0 0 0 0 0 0 2b +ls21: 1 2 3 4 +lu21: 3 1 2 3 4 4 68 75 68 75 0 0 0 0 0 0 0 0 0 0 0 0 2b +lu22: 3 1 2 3 4 4 68 75 68 75 0 0 0 0 0 0 0 0 0 0 0 0 2b +lu3: 3 5 6 7 8 4 68 75 68 75 0 0 0 0 0 0 0 0 0 0 0 0 2b +lu4: 3 5 6 7 0 5 62 6c 61 0 0 0 0 0 0 0 0 0 0 0 0 0 2c +ls3: 1 2 3 4 +lv: 3 4 5 6 68 61 68 61 0 0 0 0 0 0 0 0 0 0 0 0 2d 2e +lv2: 1 2 3 4 68 69 68 69 0 0 0 0 0 0 0 0 0 0 0 0 2f 30 +lv3: 7 8 9 a 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 32 +lt2: 0 9 9 9 43 43 43 43 42 42 42 0 0 0 0 0 1 +lssu1: 5 0 0 0 3 0 0 0 +lssu2: 5 0 0 0 3 0 0 0 +flow: 9 8 7 6 0 0 0 0 0 0 0 0 0 0 0 0 6 5 4 3 0 0 0 0 0 0 0 0 0 0 0 0 +ls4: 1 2 3 4 +one +(0) +ni +four +one +(0) +ni +four + 1 1 2 2 +mdfa glob: 30 - 3 4 5 6 7 8 3 4 5 6 7 8 3 4 5 6 7 8 9 0 0 10 0 0 97 98 99 0 0 0 +mdfa locl: 30 - 3 4 5 6 7 8 3 4 5 6 7 8 3 4 5 6 7 8 9 0 0 10 0 0 97 98 99 0 0 0 +sea_fill0: okay +sea_fill1: okay +sea_fill2: okay +1438 +test_init_struct_from_struct: 1 2 3 4 - 1 2 3 4 - 3 4 5 6 +test_init_bf: 1 2 3 diff --git a/tinycc/tests/tests2/91_ptr_longlong_arith32.c b/tinycc/tests/tests2/91_ptr_longlong_arith32.c new file mode 100644 index 0000000..bf07915 --- /dev/null +++ b/tinycc/tests/tests2/91_ptr_longlong_arith32.c @@ -0,0 +1,15 @@ +int printf(const char *, ...); +char t[] = "012345678"; + +int main(void) +{ + char *data = t; + unsigned long long r = 4; + unsigned a = 5; + unsigned long long b = 12; + + *(unsigned*)(data + r) += a - b; + + printf("data = \"%s\"\n", data); + return 0; +} diff --git a/tinycc/tests/tests2/91_ptr_longlong_arith32.expect b/tinycc/tests/tests2/91_ptr_longlong_arith32.expect new file mode 100644 index 0000000..f91e4b4 --- /dev/null +++ b/tinycc/tests/tests2/91_ptr_longlong_arith32.expect @@ -0,0 +1 @@ +data = "0123-5678" diff --git a/tinycc/tests/tests2/92_enum_bitfield.c b/tinycc/tests/tests2/92_enum_bitfield.c new file mode 100644 index 0000000..fb8f7a3 --- /dev/null +++ b/tinycc/tests/tests2/92_enum_bitfield.c @@ -0,0 +1,58 @@ +/* This checks if enums needing 8 bit but only having positive + values are correctly zero extended (instead of sign extended) + when stored into/loaded from a 8 bit bit-field of enum type (which + itself is implementation defined, so isn't necessarily supported by all + other compilers). */ +enum tree_code { + SOME_CODE = 148, /* has bit 7 set, and hence all further enum values as well */ + LAST_AND_UNUSED_TREE_CODE +}; +typedef union tree_node *tree; +struct tree_common +{ + union tree_node *chain; + union tree_node *type; + enum tree_code code : 8; + unsigned side_effects_flag : 1; +}; +union tree_node +{ + struct tree_common common; + }; +enum c_tree_code { + C_DUMMY_TREE_CODE = LAST_AND_UNUSED_TREE_CODE, + STMT_EXPR, + LAST_C_TREE_CODE +}; +enum cplus_tree_code { + CP_DUMMY_TREE_CODE = LAST_C_TREE_CODE, + AMBIG_CONV, + LAST_CPLUS_TREE_CODE +}; + +extern int printf(const char *, ...); +int blah(){return 0;} + +int convert_like_real (tree convs) +{ + switch (((enum tree_code) (convs)->common.code)) + { + case AMBIG_CONV: /* This has bit 7 set, which must not be the sign + bit in tree_common.code, i.e. the bitfield must + be somehow marked unsigned. */ + return blah(); + default: + break; + }; + printf("unsigned enum bit-fields broken\n"); + return 0; +} + +int main() +{ + union tree_node convs; + + convs.common.code = AMBIG_CONV; + convert_like_real (&convs); + return 0; +} diff --git a/tinycc/tests/tests2/92_enum_bitfield.expect b/tinycc/tests/tests2/92_enum_bitfield.expect new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tinycc/tests/tests2/92_enum_bitfield.expect diff --git a/tinycc/tests/tests2/93_integer_promotion.c b/tinycc/tests/tests2/93_integer_promotion.c new file mode 100644 index 0000000..a1176fc --- /dev/null +++ b/tinycc/tests/tests2/93_integer_promotion.c @@ -0,0 +1,71 @@ +/* integer promotion */ + +int printf(const char*, ...); +#define promote(s) printf(" %ssigned : %s\n", (s) - 100 < 0 ? " " : "un", #s); + +int main (void) +{ + struct { + unsigned ub:3; + unsigned u:32; + unsigned long long ullb:35; + unsigned long long ull:64; + unsigned char c; + } s = { 1, 1, 1 }; + + promote(s.ub); + promote(s.u); + promote(s.ullb); + promote(s.ull); + promote(s.c); + printf("\n"); + + promote((1 ? s.ub : 1)); + promote((1 ? s.u : 1)); + promote((1 ? s.ullb : 1)); + promote((1 ? s.ull : 1)); + promote((1 ? s.c : 1)); + printf("\n"); + + promote(s.ub << 1); + promote(s.u << 1); + promote(s.ullb << 1); + promote(s.ull << 1); + promote(s.c << 1); + printf("\n"); + + promote(+s.ub); + promote(+s.u); + promote(+s.ullb); + promote(+s.ull); + promote(+s.c); + printf("\n"); + + promote(-s.ub); + promote(-s.u); + promote(-s.ullb); + promote(-s.ull); + promote(-s.c); + printf("\n"); + + promote(~s.ub); + promote(~s.u); + promote(~s.ullb); + promote(~s.ull); + promote(~s.c); + printf("\n"); + + promote(!s.ub); + promote(!s.u); + promote(!s.ullb); + promote(!s.ull); + promote(!s.c); + printf("\n"); + + promote(+(unsigned)s.ub); + promote(-(unsigned)s.ub); + promote(~(unsigned)s.ub); + promote(!(unsigned)s.ub); + + return 0; +} diff --git a/tinycc/tests/tests2/93_integer_promotion.expect b/tinycc/tests/tests2/93_integer_promotion.expect new file mode 100644 index 0000000..34b9c14 --- /dev/null +++ b/tinycc/tests/tests2/93_integer_promotion.expect @@ -0,0 +1,46 @@ + signed : s.ub + unsigned : s.u + signed : s.ullb + unsigned : s.ull + signed : s.c + + signed : (1 ? s.ub : 1) + unsigned : (1 ? s.u : 1) + signed : (1 ? s.ullb : 1) + unsigned : (1 ? s.ull : 1) + signed : (1 ? s.c : 1) + + signed : s.ub << 1 + unsigned : s.u << 1 + signed : s.ullb << 1 + unsigned : s.ull << 1 + signed : s.c << 1 + + signed : +s.ub + unsigned : +s.u + signed : +s.ullb + unsigned : +s.ull + signed : +s.c + + signed : -s.ub + unsigned : -s.u + signed : -s.ullb + unsigned : -s.ull + signed : -s.c + + signed : ~s.ub + unsigned : ~s.u + signed : ~s.ullb + unsigned : ~s.ull + signed : ~s.c + + signed : !s.ub + signed : !s.u + signed : !s.ullb + signed : !s.ull + signed : !s.c + + unsigned : +(unsigned)s.ub + unsigned : -(unsigned)s.ub + unsigned : ~(unsigned)s.ub + signed : !(unsigned)s.ub diff --git a/tinycc/tests/tests2/94_generic.c b/tinycc/tests/tests2/94_generic.c new file mode 100644 index 0000000..1cb0164 --- /dev/null +++ b/tinycc/tests/tests2/94_generic.c @@ -0,0 +1,122 @@ +#include <stdio.h> + +const int a = 0; + +struct a { + int a; +}; + +struct b { + int a; +}; + +int a_f() +{ + return 20; +} + +int b_f() +{ + return 10; +} + +typedef int (*fptr)(int); +typedef void (*vfptr)(int); +int foo(int i) +{ + return i; +} +void void_foo(int i) {} + +typedef int int_type1; + +#define gen_sw(a) _Generic(a, const char *: 1, default: 8, int: 123); + +int main() +{ + int i = 0; + signed long int l = 2; + struct b titi; + const int * const ptr; + const char *ti; + int_type1 i2; + + i = _Generic(a, int: a_f, const int: b_f)(); + printf("%d\n", i); + i = _Generic(a, int: a_f() / 2, const int: b_f() / 2); + printf("%d\n", i); + i = _Generic(ptr, int *:1, int * const:2, default:20); + printf("%d\n", i); + i = gen_sw(a); + printf("%d\n", i); + i = _Generic(titi, struct a:1, struct b:2, default:20); + printf("%d\n", i); + i = _Generic(i2, char: 1, int : 0); + printf("%d\n", i); + i = _Generic(a, char:1, int[4]:2, default:5); + printf("%d\n", i); + i = _Generic(17, int :1, int **:2); + printf("%d\n", i); + i = _Generic(17L, int :1, long :2, long long : 3); + printf("%d\n", i); + i = _Generic("17, io", char *: 3, const char *: 1); + printf("%d\n", i); + i = _Generic(ti, const unsigned char *:1, const char *:4, char *:3, + const signed char *:2); + printf("%d\n", i); + printf("%s\n", _Generic(i + 2L, long: "long", int: "int", + long long: "long long")); + i = _Generic(l, long: 1, int: 2); + printf("%d\n", i); + i = _Generic(foo, fptr: 3, int: 4, vfptr: 5); + printf("%d\n", i); + i = _Generic(void_foo, fptr: 3, int: 4, vfptr: 5); + printf("%d\n", i); + + (void)_Generic((int(*)[2]){0}, int(*)[2]:0, int(*)[4]:0); //shouldn't match twice + + //should accept ({ }) in the controlling expr of _Generic even in const_wanted contexts + struct { _Bool x_0: _Generic(({0;}),default:1); } my_x; + + _Generic((__typeof((float const)((float const){42}))*){0}, float*: 0); //casts lose top-level qualifiers + int const x = 42; __typeof((__typeof(x))x) *xp = 0; (void)_Generic(xp, int*: 0); //casts lose top-level qualifiers + + //TEST TERNARY: + //Same type + _Generic( 0?(long*)0:(long*)0, long*: (void)0); + //combining of qualifiers + _Generic( 0?(long volatile*)0:(long const*)0, long const volatile*: (void)0); + //nul-ptr constant selects other type + _Generic( 0?(long*)0:0, long*: (void)0); + _Generic( 0?(long*)0:(void*)0, long*: (void)0); + + //void ptrs get chosen preferentially; qualifs still combine + _Generic( 0?(int volatile*)0: (void const*)1, void volatile const*: (void)0); + //but this is no null-ptr constant, so fallback to void-choice + i = 0; + _Generic( 1?(void*)(i*0LL):&i, void*:0); + //like gcc but not clang, don't treat (void* const as the null-ptr constant) + _Generic( 0?(int volatile*)0: (void const*)0, void volatile const*: (void)0); + + //ptrs to incomplete types get completed + (void)(sizeof(struct { int x:_Generic( 0?(int (*)[4])0 : (int (*)[])0, int (*)[4]:+1, int (*)[5]:(void)0); })); + (void)(sizeof(struct { int x:_Generic( 0?(int (*)[])0 : (int (*)[4])0, int (*)[4]:+1, int (*)[5]:(void)0); })); + + { + /* completion shouldn't affect the type of decl */ + char **argv; + _Generic(argv, char**: (void)0); + _Generic(0?(char const*)0:argv[0], char const*: (void)0); + _Generic(argv, char**: (void)0); + } + { + extern int (*ar)[]; + (void)(sizeof(struct { int x:_Generic( 0?(int (*)[4])0 : (int (*)[])0, int (*)[4]:+1, int (*)[5]:(void)0); })); + (void)(sizeof(struct { int x:_Generic( 0?(int (*)[])0 : (int (*)[4])0, int (*)[4]:+1, int (*)[5]:(void)0); })); + (void)(sizeof(struct { int x:_Generic( 0?ar : (int (*)[4])0, int (*)[4]:+1, int (*)[5]:(void)0); })); + (void)(sizeof(struct { int x:_Generic( 0?(int (*)[4])0 : ar, int (*)[4]:+1, int (*)[5]:(void)0); })); + (void)(sizeof(struct { int x:_Generic( 0?(int (*)[5])0 : ar, int (*)[5]:+1, int (*)[4]:(void)0); })); + } + + return 0; +} diff --git a/tinycc/tests/tests2/94_generic.expect b/tinycc/tests/tests2/94_generic.expect new file mode 100644 index 0000000..80d4ed9 --- /dev/null +++ b/tinycc/tests/tests2/94_generic.expect @@ -0,0 +1,15 @@ +20 +10 +20 +123 +2 +0 +5 +1 +2 +3 +4 +long +1 +3 +5 diff --git a/tinycc/tests/tests2/95_bitfields.c b/tinycc/tests/tests2/95_bitfields.c new file mode 100644 index 0000000..4ac38da --- /dev/null +++ b/tinycc/tests/tests2/95_bitfields.c @@ -0,0 +1,241 @@ +/* ----------------------------------------------------------------------- */ +#if TEST == 1 +{ + struct M P A __s + { + unsigned x : 12; + unsigned char y : 7; + unsigned z : 28; + unsigned a: 4; + unsigned b: 5; + }; + TEST_STRUCT(0x333,0x44,0x555555,6,7); +} + +/* ----------------------------------------------------------------------- */ +#elif TEST == 2 +{ + struct M P __s + { + int x: 12; + char y: 6; + long long z:63; + A char a:4; + long long b:2; + + }; + TEST_STRUCT(3,30,0x123456789abcdef0LL,5,2); +} + +/* ----------------------------------------------------------------------- */ +#elif TEST == 3 +{ + struct M P __s + { + unsigned x:5, y:5, :0, z:5; char a:5; A short b:5; + }; + TEST_STRUCT(21,23,25,6,14); +} + +/* ----------------------------------------------------------------------- */ +#elif TEST == 4 +{ + struct M P __s { + int x : 3; + int : 2; + int y : 1; + int : 0; + int z : 5; + int a : 7; + unsigned int b : 7; + }; + TEST_STRUCT(3,1,15,120,120); +} + +/* ----------------------------------------------------------------------- */ +#elif TEST == 5 +{ + struct M P __s { + long long x : 45; + long long : 2; + long long y : 30; + unsigned long long z : 38; + char a; short b; + }; + TEST_STRUCT(0x123456789ULL, 120<<25, 120, 0x44, 0x77); +} + +/* ----------------------------------------------------------------------- */ +#elif TEST == 6 +{ + struct M P __s { + int a; + signed char b; + int x : 12, y : 4, : 0, : 4, z : 3; + char d; + }; + TEST_STRUCT(1,2,3,4,-3); +} + +/* ----------------------------------------------------------------------- */ +#elif TEST == 7 +{ +#ifdef _WIN32 + typedef long long int ll; +#else + typedef long int ll; +#endif + struct M P __s { + ll d : 16; + ll b : 16; + ll x : 16; + ll y : 1; + ll z : 2; + ll a : 11; + ll e : 1; + ll f : 1; + }; + TEST_STRUCT(1,2,3,4,5); +} + +/* ----------------------------------------------------------------------- */ +#elif defined PACK + +#if PACK +# pragma pack(push,1) +# define P //_P +#else +# define P +#endif + +printf("\n\n" + 2*top); +#define TEST 1 +#include SELF +top = 0; +#define TEST 2 +#include SELF +#define TEST 3 +#include SELF +#define TEST 4 +#include SELF +#define TEST 5 +#include SELF +#define TEST 6 +#include SELF +#define TEST 7 +#include SELF + +#if PACK +# pragma pack(pop) +#endif + +#undef P +#undef PACK + +/* ----------------------------------------------------------------------- */ +#elif defined ALIGN + +#if ALIGN +# define A _A(16) +#else +# define A +#endif + +#define PACK 0 +#include SELF +#define PACK 1 +#include SELF + +#undef A +#undef ALIGN + +/* ----------------------------------------------------------------------- */ +#elif defined MS_BF + +#if MS_BF +# ifdef __TINYC__ +# pragma comment(option, "-mms-bitfields") +# elif defined __GNUC__ +# define M __attribute__((ms_struct)) +# endif +#else +# ifdef __TINYC__ +# pragma comment(option, "-mno-ms-bitfields") +# elif defined __GNUC__ +# define M __attribute__((gcc_struct)) +# endif +#endif +#ifndef M +# define M +#endif + +#define ALIGN 0 +#include SELF +#define ALIGN 1 +#include SELF + +#undef M +#undef MS_BF + +/* ----------------------------------------------------------------------- */ +#else + +#include <stdio.h> +#include <string.h> +/* some gcc headers #define __attribute__ to empty if it's not gcc */ +#undef __attribute__ + +void dump(void *p, int s) +{ + int i; + for (i = s; --i >= 0;) + printf("%02X", ((unsigned char*)p)[i]); + printf("\n"); +} + +#define pv(m) \ + printf(sizeof (s->m + 0) == 8 ? " %016llx" : " %02x", s->m) + +#define TEST_STRUCT(v1,v2,v3,v4,v5) { \ + struct __s _s, *s = & _s; \ + printf("\n---- TEST %d%s%s%s ----\n" + top, \ + TEST, MS_BF?" - MS-BITFIELDS":"", \ + PACK?" - PACKED":"", \ + ALIGN?" - WITH ALIGN":""); \ + memset(s, 0, sizeof *s); \ + s->x = -1, s->y = -1, s->z = -1, s->a = -1, s->b = -1; \ + printf("bits in use : "), dump(s, sizeof *s); \ + s->x = v1, s->y = v2, s->z = v3, s->a += v4, ++s->a, s->b = v5; \ + printf("bits as set : "), dump(s, sizeof *s); \ + printf("values :"), pv(x), pv(y), pv(z), pv(a), pv(b), printf("\n"); \ + printf("align/size : %d %d\n", alignof(struct __s),sizeof(struct __s)); \ + } + +#ifdef _MSC_VER +# define _A(n) __declspec(align(n)) +# define _P +# define alignof(x) __alignof(x) +#else +# define _A(n) __attribute__((aligned(n))) +# define _P __attribute__((packed)) +# define alignof(x) __alignof__(x) +#endif + +#ifndef MS_BITFIELDS +# define MS_BITFIELDS 0 +#endif + +#define SELF "95_bitfields.c" + +int top = 1; + +int main() +{ +#define MS_BF MS_BITFIELDS +#include SELF + return 0; +} + +/* ----------------------------------------------------------------------- */ +#endif +#undef TEST diff --git a/tinycc/tests/tests2/95_bitfields.expect b/tinycc/tests/tests2/95_bitfields.expect new file mode 100644 index 0000000..215055d --- /dev/null +++ b/tinycc/tests/tests2/95_bitfields.expect @@ -0,0 +1,173 @@ +---- TEST 1 ---- +bits in use : 0000001FFFFFFFFF007F0FFF +bits as set : 000000076055555500440333 +values : 333 44 555555 06 07 +align/size : 4 12 + +---- TEST 2 ---- +bits in use : 000000000000003F7FFFFFFFFFFFFFFF00000000003F0FFF +bits as set : 0000000000000025123456789ABCDEF000000000001E0003 +values : 03 1e 123456789abcdef0 05 fffffffe +align/size : 8 24 + +---- TEST 3 ---- +bits in use : 001F1F1F000003FF +bits as set : 000E0619000002F5 +values : 15 17 19 06 0e +align/size : 4 8 + +---- TEST 4 ---- +bits in use : 0007FFFF00000027 +bits as set : 00078F0F00000023 +values : 03 ffffffff 0f fffffff8 78 +align/size : 4 8 + +---- TEST 5 ---- +bits in use : FFFFFF3FFFFFFFFF000000003FFFFFFF00001FFFFFFFFFFF +bits as set : 007744000000007800000000300000000000000123456789 +values : 0000000123456789 f0000000 0000000000000078 44 77 +align/size : 8 24 + +---- TEST 6 ---- +bits in use : 0000007000FFFFFFFFFFFFFF +bits as set : 00000030002001FD00000004 +values : 01 02 03 04 fffffffd +align/size : 4 12 + +---- TEST 7 ---- +bits in use : 3FFFFFFFFFFF0000 +bits as set : 0026000100050000 +values : 01 00 ffffffff 04 05 +align/size : 8 8 + + + +---- TEST 1 - PACKED ---- +bits in use : FFFFFFFFFFFFFF +bits as set : 3B02AAAAAC4333 +values : 333 44 555555 06 07 +align/size : 1 7 + +---- TEST 2 - PACKED ---- +bits in use : 7FFFFFFFFFFFFFFFFFFFFF +bits as set : 4A48D159E26AF37BC1E003 +values : 03 1e 123456789abcdef0 05 fffffffe +align/size : 1 11 + +---- TEST 3 - PACKED ---- +bits in use : 7FFF000003FF +bits as set : 38D9000002F5 +values : 15 17 19 06 0e +align/size : 1 6 + +---- TEST 4 - PACKED ---- +bits in use : 07FFFF00000027 +bits as set : 078F0F00000023 +values : 03 ffffffff 0f fffffff8 78 +align/size : 1 7 + +---- TEST 5 - PACKED ---- +bits in use : FFFFFF07FFFFFFFFFFFFFFFF9FFFFFFFFFFF +bits as set : 007744000000000F18000000000123456789 +values : 0000000123456789 f0000000 0000000000000078 44 77 +align/size : 1 18 + +---- TEST 6 - PACKED ---- +bits in use : 007000FFFFFFFFFFFFFF +bits as set : 0030002001FD00000004 +values : 01 02 03 04 fffffffd +align/size : 1 10 + +---- TEST 7 - PACKED ---- +bits in use : 3FFFFFFFFFFF0000 +bits as set : 0026000100050000 +values : 01 00 ffffffff 04 05 +align/size : 1 8 + + + +---- TEST 1 - WITH ALIGN ---- +bits in use : 000000000000001FFFFFFFFF007F0FFF +bits as set : 00000000000000076055555500440333 +values : 333 44 555555 06 07 +align/size : 16 16 + +---- TEST 2 - WITH ALIGN ---- +bits in use : 0000000000000000000000000000003F7FFFFFFFFFFFFFFF00000000003F0FFF +bits as set : 00000000000000000000000000000025123456789ABCDEF000000000001E0003 +values : 03 1e 123456789abcdef0 05 fffffffe +align/size : 16 32 + +---- TEST 3 - WITH ALIGN ---- +bits in use : 0000000000000000000000000000001F000000000000000000001F1F000003FF +bits as set : 0000000000000000000000000000000E000000000000000000000619000002F5 +values : 15 17 19 06 0e +align/size : 16 32 + +---- TEST 4 - WITH ALIGN ---- +bits in use : 0007FFFF00000027 +bits as set : 00078F0F00000023 +values : 03 ffffffff 0f fffffff8 78 +align/size : 4 8 + +---- TEST 5 - WITH ALIGN ---- +bits in use : FFFFFF3FFFFFFFFF000000003FFFFFFF00001FFFFFFFFFFF +bits as set : 007744000000007800000000300000000000000123456789 +values : 0000000123456789 f0000000 0000000000000078 44 77 +align/size : 8 24 + +---- TEST 6 - WITH ALIGN ---- +bits in use : 0000007000FFFFFFFFFFFFFF +bits as set : 00000030002001FD00000004 +values : 01 02 03 04 fffffffd +align/size : 4 12 + +---- TEST 7 - WITH ALIGN ---- +bits in use : 3FFFFFFFFFFF0000 +bits as set : 0026000100050000 +values : 01 00 ffffffff 04 05 +align/size : 8 8 + + + +---- TEST 1 - PACKED - WITH ALIGN ---- +bits in use : 000000000000000000FFFFFFFFFFFFFF +bits as set : 0000000000000000003B02AAAAAC4333 +values : 333 44 555555 06 07 +align/size : 16 16 + +---- TEST 2 - PACKED - WITH ALIGN ---- +bits in use : 3F01FFFFFFFFFFFFFFFFFFFF +bits as set : 250048D159E26AF37BC1E003 +values : 03 1e 123456789abcdef0 05 fffffffe +align/size : 1 12 + +---- TEST 3 - PACKED - WITH ALIGN ---- +bits in use : 1F03FF000003FF +bits as set : 0E00D9000002F5 +values : 15 17 19 06 0e +align/size : 1 7 + +---- TEST 4 - PACKED - WITH ALIGN ---- +bits in use : 07FFFF00000027 +bits as set : 078F0F00000023 +values : 03 ffffffff 0f fffffff8 78 +align/size : 1 7 + +---- TEST 5 - PACKED - WITH ALIGN ---- +bits in use : FFFFFF07FFFFFFFFFFFFFFFF9FFFFFFFFFFF +bits as set : 007744000000000F18000000000123456789 +values : 0000000123456789 f0000000 0000000000000078 44 77 +align/size : 1 18 + +---- TEST 6 - PACKED - WITH ALIGN ---- +bits in use : 007000FFFFFFFFFFFFFF +bits as set : 0030002001FD00000004 +values : 01 02 03 04 fffffffd +align/size : 1 10 + +---- TEST 7 - PACKED - WITH ALIGN ---- +bits in use : 3FFFFFFFFFFF0000 +bits as set : 0026000100050000 +values : 01 00 ffffffff 04 05 +align/size : 1 8 diff --git a/tinycc/tests/tests2/95_bitfields_ms.c b/tinycc/tests/tests2/95_bitfields_ms.c new file mode 100644 index 0000000..b196fbd --- /dev/null +++ b/tinycc/tests/tests2/95_bitfields_ms.c @@ -0,0 +1,2 @@ +#define MS_BITFIELDS 1 +#include "95_bitfields.c" diff --git a/tinycc/tests/tests2/95_bitfields_ms.expect b/tinycc/tests/tests2/95_bitfields_ms.expect new file mode 100644 index 0000000..97c46be --- /dev/null +++ b/tinycc/tests/tests2/95_bitfields_ms.expect @@ -0,0 +1,173 @@ +---- TEST 1 - MS-BITFIELDS ---- +bits in use : 0000001FFFFFFFFF0000007F00000FFF +bits as set : 00000007605555550000004400000333 +values : 333 44 555555 06 07 +align/size : 4 16 + +---- TEST 2 - MS-BITFIELDS ---- +bits in use : 0000000000000003000000000000000F7FFFFFFFFFFFFFFF0000003F00000FFF +bits as set : 00000000000000020000000000000005123456789ABCDEF00000001E00000003 +values : 03 1e 123456789abcdef0 05 fffffffffffffffe +align/size : 8 32 + +---- TEST 3 - MS-BITFIELDS ---- +bits in use : 001F001F0000001F000003FF +bits as set : 000E000600000019000002F5 +values : 15 17 19 06 0e +align/size : 4 12 + +---- TEST 4 - MS-BITFIELDS ---- +bits in use : 0007FFFF00000027 +bits as set : 00078F0F00000023 +values : 03 ffffffff 0f fffffff8 78 +align/size : 4 8 + +---- TEST 5 - MS-BITFIELDS ---- +bits in use : 00000000FFFF00FF0000003FFFFFFFFF000000003FFFFFFF00001FFFFFFFFFFF +bits as set : 0000000000770044000000000000007800000000300000000000000123456789 +values : 0000000123456789 fffffffff0000000 0000000000000078 44 77 +align/size : 8 32 + +---- TEST 6 - MS-BITFIELDS ---- +bits in use : 00000000000000700000FFFF000000FFFFFFFFFF +bits as set : 000000000000003000002001000000FD00000004 +values : 01 02 03 04 fffffffd +align/size : 4 20 + +---- TEST 7 - MS-BITFIELDS ---- +bits in use : 3FFFFFFFFFFF0000 +bits as set : 0026000100050000 +values : 0000000000000001 0000000000000000 ffffffffffffffff 0000000000000004 0000000000000005 +align/size : 8 8 + + + +---- TEST 1 - MS-BITFIELDS - PACKED ---- +bits in use : 0000001FFFFFFFFF7F00000FFF +bits as set : 00000007605555554400000333 +values : 333 44 555555 06 07 +align/size : 1 13 + +---- TEST 2 - MS-BITFIELDS - PACKED ---- +bits in use : 00000000000000030F7FFFFFFFFFFFFFFF3F00000FFF +bits as set : 000000000000000205123456789ABCDEF01E00000003 +values : 03 1e 123456789abcdef0 05 fffffffffffffffe +align/size : 1 22 + +---- TEST 3 - MS-BITFIELDS - PACKED ---- +bits in use : 001F1F0000001F000003FF +bits as set : 000E0600000019000002F5 +values : 15 17 19 06 0e +align/size : 1 11 + +---- TEST 4 - MS-BITFIELDS - PACKED ---- +bits in use : 0007FFFF00000027 +bits as set : 00078F0F00000023 +values : 03 ffffffff 0f fffffff8 78 +align/size : 1 8 + +---- TEST 5 - MS-BITFIELDS - PACKED ---- +bits in use : FFFFFF0000003FFFFFFFFF000000003FFFFFFF00001FFFFFFFFFFF +bits as set : 007744000000000000007800000000300000000000000123456789 +values : 0000000123456789 fffffffff0000000 0000000000000078 44 77 +align/size : 1 27 + +---- TEST 6 - MS-BITFIELDS - PACKED ---- +bits in use : 00000000700000FFFFFFFFFFFFFF +bits as set : 000000003000002001FD00000004 +values : 01 02 03 04 fffffffd +align/size : 1 14 + +---- TEST 7 - MS-BITFIELDS - PACKED ---- +bits in use : 3FFFFFFFFFFF0000 +bits as set : 0026000100050000 +values : 0000000000000001 0000000000000000 ffffffffffffffff 0000000000000004 0000000000000005 +align/size : 1 8 + + + +---- TEST 1 - MS-BITFIELDS - WITH ALIGN ---- +bits in use : 0000001FFFFFFFFF0000007F00000FFF +bits as set : 00000007605555550000004400000333 +values : 333 44 555555 06 07 +align/size : 16 16 + +---- TEST 2 - MS-BITFIELDS - WITH ALIGN ---- +bits in use : 0000000000000003000000000000000F7FFFFFFFFFFFFFFF0000003F00000FFF +bits as set : 00000000000000020000000000000005123456789ABCDEF00000001E00000003 +values : 03 1e 123456789abcdef0 05 fffffffffffffffe +align/size : 16 32 + +---- TEST 3 - MS-BITFIELDS - WITH ALIGN ---- +bits in use : 0000000000000000000000000000001F000000000000001F0000001F000003FF +bits as set : 0000000000000000000000000000000E000000000000000600000019000002F5 +values : 15 17 19 06 0e +align/size : 16 32 + +---- TEST 4 - MS-BITFIELDS - WITH ALIGN ---- +bits in use : 0007FFFF00000027 +bits as set : 00078F0F00000023 +values : 03 ffffffff 0f fffffff8 78 +align/size : 4 8 + +---- TEST 5 - MS-BITFIELDS - WITH ALIGN ---- +bits in use : 00000000FFFF00FF0000003FFFFFFFFF000000003FFFFFFF00001FFFFFFFFFFF +bits as set : 0000000000770044000000000000007800000000300000000000000123456789 +values : 0000000123456789 fffffffff0000000 0000000000000078 44 77 +align/size : 8 32 + +---- TEST 6 - MS-BITFIELDS - WITH ALIGN ---- +bits in use : 00000000000000700000FFFF000000FFFFFFFFFF +bits as set : 000000000000003000002001000000FD00000004 +values : 01 02 03 04 fffffffd +align/size : 4 20 + +---- TEST 7 - MS-BITFIELDS - WITH ALIGN ---- +bits in use : 3FFFFFFFFFFF0000 +bits as set : 0026000100050000 +values : 0000000000000001 0000000000000000 ffffffffffffffff 0000000000000004 0000000000000005 +align/size : 8 8 + + + +---- TEST 1 - MS-BITFIELDS - PACKED - WITH ALIGN ---- +bits in use : 0000000000001FFFFFFFFF7F00000FFF +bits as set : 00000000000007605555554400000333 +values : 333 44 555555 06 07 +align/size : 16 16 + +---- TEST 2 - MS-BITFIELDS - PACKED - WITH ALIGN ---- +bits in use : 00000000000000030F0000007FFFFFFFFFFFFFFF3F00000FFF +bits as set : 000000000000000205000000123456789ABCDEF01E00000003 +values : 03 1e 123456789abcdef0 05 fffffffffffffffe +align/size : 16 25 + +---- TEST 3 - MS-BITFIELDS - PACKED - WITH ALIGN ---- +bits in use : 001F000000000000001F0000001F000003FF +bits as set : 000E000000000000000600000019000002F5 +values : 15 17 19 06 0e +align/size : 16 18 + +---- TEST 4 - MS-BITFIELDS - PACKED - WITH ALIGN ---- +bits in use : 0007FFFF00000027 +bits as set : 00078F0F00000023 +values : 03 ffffffff 0f fffffff8 78 +align/size : 1 8 + +---- TEST 5 - MS-BITFIELDS - PACKED - WITH ALIGN ---- +bits in use : FFFFFF0000003FFFFFFFFF000000003FFFFFFF00001FFFFFFFFFFF +bits as set : 007744000000000000007800000000300000000000000123456789 +values : 0000000123456789 fffffffff0000000 0000000000000078 44 77 +align/size : 1 27 + +---- TEST 6 - MS-BITFIELDS - PACKED - WITH ALIGN ---- +bits in use : 00000000700000FFFFFFFFFFFFFF +bits as set : 000000003000002001FD00000004 +values : 01 02 03 04 fffffffd +align/size : 1 14 + +---- TEST 7 - MS-BITFIELDS - PACKED - WITH ALIGN ---- +bits in use : 3FFFFFFFFFFF0000 +bits as set : 0026000100050000 +values : 0000000000000001 0000000000000000 ffffffffffffffff 0000000000000004 0000000000000005 +align/size : 1 8 diff --git a/tinycc/tests/tests2/96_nodata_wanted.c b/tinycc/tests/tests2/96_nodata_wanted.c new file mode 100644 index 0000000..95938b5 --- /dev/null +++ b/tinycc/tests/tests2/96_nodata_wanted.c @@ -0,0 +1,102 @@ +/*****************************************************************************/ +/* test 'nodata_wanted' data output suppression */ + +#if defined test_static_data_error +void foo() { + if (1) { + static short w = (int)&foo; /* initializer not computable */ + } +} + +#elif defined test_static_nodata_error +void foo() { + if (0) { + static short w = (int)&foo; /* initializer not computable */ + } +} + +#elif defined test_global_data_error +void foo(); +static short w = (int)&foo; /* initializer not computable */ + + +#elif defined test_local_data_noerror +void foo() { + short w = &foo; /* 2 cast warnings */ +} + +#elif defined test_data_suppression_off || defined test_data_suppression_on + +#if defined test_data_suppression_on +# define SKIP 1 +#else +# define SKIP 0 +#endif + +#include <stdio.h> +/* some gcc headers #define __attribute__ to empty if it's not gcc */ +#undef __attribute__ + +int main() +{ + __label__ ts0, te0, ts1, te1; + int tl, dl; + + static const char ds0 = 0; + static const char de0 = 0; + /* get reference size of empty jmp */ +ts0:; + if (!SKIP) {} +te0:; + dl = -(&de0 - &ds0); + tl = -(&&te0 - &&ts0); + + /* test data and code suppression */ + static const char ds1 = 0; +ts1:; + if (!SKIP) { + void *p = (void*)&main; + char cc[] = "static string"; + double d = 8.0; + struct +#ifndef __arm__ + __attribute__((packed)) +#endif + { + unsigned x : 12; + unsigned char y : 7; + unsigned z : 28, a: 4, b: 5; + } s = { 0x333,0x44,0x555555,6,7 }; + + printf("data:\n"); + printf(" %d - %.1f - %.1f - %s - %s\n", + sizeof 8.0, 8.0, d, __FUNCTION__, cc); + printf(" %x %x %x %x %x\n", + s.x, s.y, s.z, s.a, s.b); + } +te1:; + static const char de1 = 0; + + dl += &de1 - &ds1; + tl += &&te1 - &&ts1; + printf("size of data/text:\n %s/%s\n", + dl ? "non-zero":"zero", tl ? "non-zero":"zero"); + /*printf("# %d/%d\n", dl, tl);*/ +} + +#elif defined test_static_data + +#include <stdio.h> +int main(int argc, char **argv) +{ + goto there; + if (0) { + static int a = 1; + printf("hello\n"); /* the "hello\n" string is still suppressed */ +there: + printf("a = %d\n", a); + } + return 0; +} + +#endif diff --git a/tinycc/tests/tests2/96_nodata_wanted.expect b/tinycc/tests/tests2/96_nodata_wanted.expect new file mode 100644 index 0000000..92dc9c4 --- /dev/null +++ b/tinycc/tests/tests2/96_nodata_wanted.expect @@ -0,0 +1,26 @@ +[test_static_data_error] +96_nodata_wanted.c:7: error: initializer element is not computable at load time + +[test_static_nodata_error] +96_nodata_wanted.c:14: error: initializer element is not computable at load time + +[test_global_data_error] +96_nodata_wanted.c:20: error: initializer element is not computable at load time + +[test_local_data_noerror] +96_nodata_wanted.c:25: warning: assignment makes integer from pointer without a cast +96_nodata_wanted.c:25: warning: cast between pointer and integer of different size + +[test_data_suppression_off] +data: + 8 - 8.0 - 8.0 - main - static string + 333 44 555555 6 7 +size of data/text: + non-zero/non-zero + +[test_data_suppression_on] +size of data/text: + zero/zero + +[test_static_data] +a = 1 diff --git a/tinycc/tests/tests2/97_utf8_string_literal.c b/tinycc/tests/tests2/97_utf8_string_literal.c new file mode 100644 index 0000000..5bfb6c8 --- /dev/null +++ b/tinycc/tests/tests2/97_utf8_string_literal.c @@ -0,0 +1,20 @@ +// this file contains BMP chars encoded in UTF-8 +#include <stdio.h> +#include <wchar.h> +#include <stdlib.h> +#include <string.h> + +int main() +{ + char hello_world_in_czech[] = "čau, světe"; + char hello_world_in_czech_ucn[] = "\u010dau, sv\u011bte"; + if (sizeof(hello_world_in_czech) != sizeof(hello_world_in_czech_ucn) + || strcmp(hello_world_in_czech, hello_world_in_czech_ucn)) + abort(); + + wchar_t s[] = L"hello$$你好¢¢世界€€world"; + wchar_t *p; + for (p = s; *p; p++) printf("%04X ", (unsigned) *p); + printf("\n"); + return 0; +} diff --git a/tinycc/tests/tests2/97_utf8_string_literal.expect b/tinycc/tests/tests2/97_utf8_string_literal.expect new file mode 100644 index 0000000..9a1593c --- /dev/null +++ b/tinycc/tests/tests2/97_utf8_string_literal.expect @@ -0,0 +1 @@ +0068 0065 006C 006C 006F 0024 0024 4F60 597D 00A2 00A2 4E16 754C 20AC 20AC 0077 006F 0072 006C 0064 diff --git a/tinycc/tests/tests2/98_al_ax_extend.c b/tinycc/tests/tests2/98_al_ax_extend.c new file mode 100644 index 0000000..1cd6585 --- /dev/null +++ b/tinycc/tests/tests2/98_al_ax_extend.c @@ -0,0 +1,41 @@ +#include <stdio.h> +#include <stdlib.h> +asm ( + ".text;" + ".globl _us;.globl _ss;.globl _uc;.globl _sc;" + "_us:;_ss:;_uc:;_sc:;" + "movl $0x1234ABCD, %eax;" + "ret;" +); + +#ifndef __leading_underscore +#define us _us +#define ss _ss +#define uc _uc +#define sc _sc +#endif + +int main() +{ + unsigned short us(void); + short ss(void); + unsigned char uc(void); + signed char sc(void); + + unsigned short (*fpus)(void) = us; + short (*fpss)(void) = ss; + unsigned char (*fpuc)(void) = uc; + signed char (*fpsc)(void) = sc; + + printf("%08X %08X\n", us() + 1, fpus() + 1); + printf("%08X %08X\n", ss() + 1, fpss() + 1); + printf("%08X %08X\n", uc() + 1, fpuc() + 1); + printf("%08X %08X\n", sc() + 1, fpsc() + 1); + printf("\n"); + printf("%08X %08X\n", fpus() + 1, us() + 1); + printf("%08X %08X\n", fpss() + 1, ss() + 1); + printf("%08X %08X\n", fpuc() + 1, uc() + 1); + printf("%08X %08X\n", fpsc() + 1, sc() + 1); + + return 0; +} diff --git a/tinycc/tests/tests2/98_al_ax_extend.expect b/tinycc/tests/tests2/98_al_ax_extend.expect new file mode 100644 index 0000000..c5752e8 --- /dev/null +++ b/tinycc/tests/tests2/98_al_ax_extend.expect @@ -0,0 +1,9 @@ +0000ABCE 0000ABCE +FFFFABCE FFFFABCE +000000CE 000000CE +FFFFFFCE FFFFFFCE + +0000ABCE 0000ABCE +FFFFABCE FFFFABCE +000000CE 000000CE +FFFFFFCE FFFFFFCE diff --git a/tinycc/tests/tests2/99_fastcall.c b/tinycc/tests/tests2/99_fastcall.c new file mode 100644 index 0000000..db97acb --- /dev/null +++ b/tinycc/tests/tests2/99_fastcall.c @@ -0,0 +1,276 @@ +#include <stdio.h> +#include <assert.h> + +#if !(defined( _WIN32) || (defined(__FreeBSD__) && defined(__i386__))) +#define __fastcall __attribute((fastcall)) +#endif + +#ifndef __leading_underscore +#define SYMBOL(x) _##x +#else +#define SYMBOL(x) x +#endif + +///////////////////////////////////////////////////////////////////////// +////////// TRAP FRAMEWORK +///////////////////////////////////////////////////////////////////////// +// if you cast 'TRAP' to a function pointer and call it, +// it will save all 8 registers, +// and jump into C-code (previously set using 'SET_TRAP_HANDLER(x)'), +// in C-code you can pop DWORDs from stack and modify registers +// + +void *SYMBOL(trap_handler); + +extern unsigned char SYMBOL(trap)[]; +asm ( + ".text;" + "_trap:;" + "pushl %esp;" + "pusha;" + "addl $0x4, 0xc(%esp);" + "pushl %esp;" + "call *_trap_handler;" + "addl $0x4, %esp;" + "movl 0xc(%esp), %eax;" + "movl %eax, 0x20(%esp);" + "popa;" + "popl %esp;" + "ret;" +); + +struct trapframe { + unsigned edi, esi, ebp, esp, ebx, edx, ecx, eax; +}; + + +#define M_FLOAT(addr) (*(float *)(addr)) +#define M_DWORD(addr) (*(unsigned *)(addr)) +#define M_WORD(addr) (*(unsigned short *)(addr)) +#define M_BYTE(addr) (*(unsigned char *)(addr)) +#define R_EAX ((tf)->eax) +#define R_ECX ((tf)->ecx) +#define R_EDX ((tf)->edx) +#define R_EBX ((tf)->ebx) +#define R_ESP ((tf)->esp) +#define R_EBP ((tf)->ebp) +#define R_ESI ((tf)->esi) +#define R_EDI ((tf)->edi) + +#define ARG(x) (M_DWORD(R_ESP + (x) * 4)) + +#define RETN(x) do { \ + M_DWORD(R_ESP + (x)) = M_DWORD(R_ESP); \ + R_ESP += (x); \ +} while (0) + +#define DUMP() do { \ + unsigned i; \ + printf("EAX: %08X\n", R_EAX); \ + printf("ECX: %08X\n", R_ECX); \ + printf("EDX: %08X\n", R_EDX); \ + printf("EBX: %08X\n", R_EBX); \ + printf("ESP: %08X\n", R_ESP); \ + printf("EBP: %08X\n", R_EBP); \ + printf("ESI: %08X\n", R_ESI); \ + printf("EDI: %08X\n", R_EDI); \ + printf("\n"); \ + printf("[RETADDR]: %08X\n", M_DWORD(R_ESP)); \ + for (i = 1; i <= 8; i++) { \ + printf("[ARG%4d]: %08X\n", i, ARG(i)); \ + } \ +} while (0) + +#define SET_TRAP_HANDLER(x) ((SYMBOL(trap_handler)) = (x)) +#define TRAP ((void *) &SYMBOL(trap)) + + + +///////////////////////////////////////////////////////////////////////// +////////// SAFECALL FRAMEWORK +///////////////////////////////////////////////////////////////////////// +// this framework will convert any calling convention to cdecl +// usage: first set call target with 'SET_SAFECALL_TARGET(x)' +// then cast 'SAFECALL' to target function pointer type and invoke it +// after calling, 'ESPDIFF' is the difference of old and new esp + +void *SYMBOL(sc_call_target); +unsigned SYMBOL(sc_retn_addr); +unsigned SYMBOL(sc_old_esp); +unsigned SYMBOL(sc_new_esp); + +extern unsigned char SYMBOL(safecall)[]; +asm ( + ".text;" + "_safecall:;" + "popl _sc_retn_addr;" + "movl %esp, _sc_old_esp;" + "call *_sc_call_target;" + "movl %esp, _sc_new_esp;" + "movl _sc_old_esp, %esp;" + "jmp *_sc_retn_addr;" +); + +#define SET_SAFECALL_TARGET(x) ((SYMBOL(sc_call_target)) = (x)) +#define SAFECALL ((void *) &SYMBOL(safecall)) +#define ESPDIFF (SYMBOL(sc_new_esp) - SYMBOL(sc_old_esp)) + + +///////////////////////////////////////////////////////////////////////// +////////// TEST FASTCALL INVOKE +///////////////////////////////////////////////////////////////////////// + +void check_fastcall_invoke_0(struct trapframe *tf) +{ + //DUMP(); + RETN(0); +} + +void check_fastcall_invoke_1(struct trapframe *tf) +{ + //DUMP(); + assert(R_ECX == 0x11111111); + RETN(0); +} +void check_fastcall_invoke_2(struct trapframe *tf) +{ + //DUMP(); + assert(R_ECX == 0x11111111); + assert(R_EDX == 0x22222222); + RETN(0); +} +void check_fastcall_invoke_3(struct trapframe *tf) +{ + //DUMP(); + assert(R_ECX == 0x11111111); + assert(R_EDX == 0x22222222); + assert(ARG(1) == 0x33333333); + RETN(1*4); +} +void check_fastcall_invoke_4(struct trapframe *tf) +{ + //DUMP(); + assert(R_ECX == 0x11111111); + assert(R_EDX == 0x22222222); + assert(ARG(1) == 0x33333333); + assert(ARG(2) == 0x44444444); + RETN(2*4); +} + +void check_fastcall_invoke_5(struct trapframe *tf) +{ + //DUMP(); + assert(R_ECX == 0x11111111); + assert(R_EDX == 0x22222222); + assert(ARG(1) == 0x33333333); + assert(ARG(2) == 0x44444444); + assert(ARG(3) == 0x55555555); + RETN(3*4); +} + +void test_fastcall_invoke() +{ + SET_TRAP_HANDLER(check_fastcall_invoke_0); + ((void __fastcall (*)(void)) TRAP)(); + + SET_TRAP_HANDLER(check_fastcall_invoke_1); + ((void __fastcall (*)(unsigned)) TRAP)(0x11111111); + + SET_TRAP_HANDLER(check_fastcall_invoke_2); + ((void __fastcall (*)(unsigned, unsigned)) TRAP)(0x11111111, 0x22222222); + + SET_TRAP_HANDLER(check_fastcall_invoke_3); + ((void __fastcall (*)(unsigned, unsigned, unsigned)) TRAP)(0x11111111, 0x22222222, 0x33333333); + + SET_TRAP_HANDLER(check_fastcall_invoke_4); + ((void __fastcall (*)(unsigned, unsigned, unsigned, unsigned)) TRAP)(0x11111111, 0x22222222, 0x33333333, 0x44444444); + + SET_TRAP_HANDLER(check_fastcall_invoke_5); + ((void __fastcall (*)(unsigned, unsigned, unsigned, unsigned, unsigned)) TRAP)(0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555); +} + + +///////////////////////////////////////////////////////////////////////// +////////// TEST FUNCTION CODE GENERATION +///////////////////////////////////////////////////////////////////////// + +int __fastcall check_fastcall_espdiff_0(void) +{ + return 0; +} + +int __fastcall check_fastcall_espdiff_1(int a) +{ + return a; +} + +int __fastcall check_fastcall_espdiff_2(int a, int b) +{ + return a + b; +} + +int __fastcall check_fastcall_espdiff_3(int a, int b, int c) +{ + return a + b + c; +} + +int __fastcall check_fastcall_espdiff_4(int a, int b, int c, int d) +{ + return a + b + c + d; +} + +int __fastcall check_fastcall_espdiff_5(int a, int b, int c, int d, int e) +{ + return a + b + c + d + e; +} + +void test_fastcall_espdiff() +{ + int x; + SET_SAFECALL_TARGET(check_fastcall_espdiff_0); + x = ((typeof(&check_fastcall_espdiff_0))SAFECALL)(); + assert(x == 0); + assert(ESPDIFF == 0); + + SET_SAFECALL_TARGET(check_fastcall_espdiff_1); + x = ((typeof(&check_fastcall_espdiff_1))SAFECALL)(1); + assert(x == 1); + assert(ESPDIFF == 0); + + SET_SAFECALL_TARGET(check_fastcall_espdiff_2); + x = ((typeof(&check_fastcall_espdiff_2))SAFECALL)(1, 2); + assert(x == 1 + 2); + assert(ESPDIFF == 0); + + SET_SAFECALL_TARGET(check_fastcall_espdiff_3); + x = ((typeof(&check_fastcall_espdiff_3))SAFECALL)(1, 2, 3); + assert(x == 1 + 2 + 3); + assert(ESPDIFF == 1*4); + + SET_SAFECALL_TARGET(check_fastcall_espdiff_4); + x = ((typeof(&check_fastcall_espdiff_4))SAFECALL)(1, 2, 3, 4); + assert(x == 1 + 2 + 3 + 4); + assert(ESPDIFF == 2*4); + + SET_SAFECALL_TARGET(check_fastcall_espdiff_5); + x = ((typeof(&check_fastcall_espdiff_5))SAFECALL)(1, 2, 3, 4, 5); + assert(x == 1 + 2 + 3 + 4 + 5); + assert(ESPDIFF == 3*4); +} + +int main() +{ +#define N 10000 + int i; + + for (i = 1; i <= N; i++) { + test_fastcall_espdiff(); + } + + for (i = 1; i <= N; i++) { + test_fastcall_invoke(); + } + + puts("TEST OK"); + return 0; +} diff --git a/tinycc/tests/tests2/99_fastcall.expect b/tinycc/tests/tests2/99_fastcall.expect new file mode 100644 index 0000000..3835d63 --- /dev/null +++ b/tinycc/tests/tests2/99_fastcall.expect @@ -0,0 +1 @@ +TEST OK diff --git a/tinycc/tests/tests2/LICENSE b/tinycc/tests/tests2/LICENSE new file mode 100644 index 0000000..b08a652 --- /dev/null +++ b/tinycc/tests/tests2/LICENSE @@ -0,0 +1,37 @@ +The tests in this directory are either directly copied from the picoc project or +are subsequently modified and added to for the purpose of TinyCC project. All +these modifications are licensed under the same terms as TinyCC as specified in +the file COPYING. + +=== picoc license === + +Copyright (c) 2009-2011, Zik Saleeba +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + * Neither the name of the Zik Saleeba nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/tinycc/tests/tests2/Makefile b/tinycc/tests/tests2/Makefile new file mode 100644 index 0000000..92da80e --- /dev/null +++ b/tinycc/tests/tests2/Makefile @@ -0,0 +1,175 @@ +TOP = ../.. +include $(TOP)/Makefile +SRC = $(TOPSRC)/tests/tests2 +VPATH = $(SRC) + +TESTS = $(patsubst %.c,%.test,\ + $(sort $(notdir $(wildcard $(SRC)/??_*.c)))\ + $(sort $(notdir $(wildcard $(SRC)/???_*.c)))) + +# some tests do not pass on all platforms, remove them for now +SKIP = 34_array_assignment.test # array assignment is not in C standard +ifeq (-$(CONFIG_arm_eabi)-$(CONFIG_arm_vfp)-,-yes--) + SKIP += 22_floating_point.test +endif +ifeq (,$(filter i386,$(ARCH))) + SKIP += 98_al_ax_extend.test 99_fastcall.test +endif +ifeq (,$(filter i386 x86_64,$(ARCH))) + SKIP += 85_asm-outside-function.test # x86 asm + SKIP += 127_asm_goto.test # hardcodes x86 asm +endif +ifeq ($(CONFIG_backtrace),no) + SKIP += 113_btdll.test + CONFIG_bcheck = no +# no bcheck without backtrace +endif +ifeq ($(CONFIG_bcheck),no) + SKIP += 112_backtrace.test + SKIP += 114_bound_signal.test + SKIP += 115_bound_setjmp.test + SKIP += 116_bound_setjmp2.test + SKIP += 117_builtins.test + SKIP += 126_bound_global.test +endif +ifeq ($(CONFIG_dll),no) + SKIP += 113_btdll.test # no shared lib support yet +endif +ifeq (-$(findstring gcc,$(CC))-,--) + SKIP += $(patsubst %.expect,%.test,$(GEN-ALWAYS)) +endif +ifeq (-$(CONFIG_WIN32)-$(CONFIG_i386)$(CONFIG_arm)-,--yes-) + SKIP += 95_bitfields%.test # type_align is different on 32bit-non-windows +endif +ifeq (-$(CONFIG_WIN32)-,-yes-) + SKIP += 106_versym.test # No pthread support + SKIP += 114_bound_signal.test # No pthread support + SKIP += 117_builtins.test # win32 port doesn't define __builtins + SKIP += 124_atomic_counter.test # No pthread support +endif +ifneq (,$(filter OpenBSD FreeBSD NetBSD,$(TARGETOS))) + SKIP += 106_versym.test # no pthread_condattr_setpshared + SKIP += 114_bound_signal.test # libc problem signal/fork + SKIP += 116_bound_setjmp2.test # No TLS_FUNC/TLS_VAR in bcheck.c +endif + +# Some tests might need arguments +ARGS = +31_args.test : ARGS = arg1 arg2 arg3 arg4 arg5 +46_grep.test : ARGS = '[^* ]*[:a:d: ]+\:\*-/: $$' $(SRC)/46_grep.c + +# And some tests don't test the right thing with -run +NORUN = +42_function_pointer.test : NORUN = true + +# Some tests might need different flags +FLAGS = +76_dollars_in_identifiers.test : FLAGS += -fdollars-in-identifiers + +# These tests run several snippets from the same file one by one +60_errors_and_warnings.test : FLAGS += -dt +96_nodata_wanted.test : FLAGS += -dt + +# Always generate certain .expects (don't put these in the GIT), +GEN-ALWAYS = +# GEN-ALWAYS += 95_bitfields.expect # does not work + +# using the ms compiler for the really ms-compatible bitfields +95_bitfields_ms.test : GEN = $(GEN-MSC) + +# this test compiles/links two files: +104_inline.test : FLAGS += $(subst 104,104+,$1) +104_inline.test : GEN = $(GEN-TCC) + +# this test needs two files, and we want to invoke the linker +120_alias.test : FLAGS += $(subst 120,120+,$1) +120_alias.test : GEN = $(GEN-TCC) +120_alias.test : NORUN = true + +# this test needs pthread +106_versym.test: FLAGS += -pthread +106_versym.test: NORUN = true + +# constructor/destructor +108_constructor.test: NORUN = true + +112_backtrace.test: FLAGS += -dt -b +112_backtrace.test 113_btdll.test 126_bound_global.test: FILTER += \ + -e 's;[0-9A-Fa-fx]\{5,\};........;g' \ + -e 's;0x[0-9A-Fa-f]\{1,\};0x?;g' + +# this test creates two DLLs and an EXE +113_btdll.test: T1 = \ + $(TCC) -bt $1 -shared -D DLL=1 -o a1$(DLLSUF) && \ + $(TCC) -bt $1 -shared -D DLL=2 -o a2$(DLLSUF) && \ + $(TCC) -bt $1 a1$(DLLSUF) a2$(DLLSUF) -Wl,-rpath=. -o $(basename $@).exe && \ + ./$(basename $@).exe + +114_bound_signal.test: FLAGS += -b +114_bound_signal.test: NORUN = true # tcc -run does not support fork and -b and SELINUX +115_bound_setjmp.test: FLAGS += -b +116_bound_setjmp2.test: FLAGS += -b +117_builtins.test: T1 = ( $(TCC) -run $1 && $(TCC) -b -run $1 ) +ifneq ($(CONFIG_bcheck),no) +121_struct_return.test: FLAGS += -b +122_vla_reuse.test: FLAGS += -b +endif +125_atomic_misc.test: FLAGS += -dt +124_atomic_counter.test: FLAGS += -pthread +126_bound_global.test: FLAGS += -b +126_bound_global.test: NORUN = true +128_run_atexit.test: FLAGS += -dt + +# Filter source directory in warnings/errors (out-of-tree builds) +FILTER = 2>&1 | sed -e 's,$(SRC)/,,g' + +all test tests2.all: $(filter-out $(SKIP),$(TESTS)) + @$(MAKE) clean --no-print-directory -s + +%.test: %.c %.expect + @echo Test: $*... + @$(call T1,$<) $(T3) + +T1 = $(TCC) $(FLAGS) $(T2) $(ARGS) +T2 = $(if $(NORUN),$1 -o $(basename $@).exe && ./$(basename $@).exe,-run $1) +T3 = $(FILTER) >$*.output 2>&1 || true \ + && diff -Nbu $(filter %.expect,$^) $*.output \ + && rm -f $*.output $(filter $*.expect,$(GEN-ALWAYS)) + +# run single test and update .expect file, e.g. "make tests2.37+" +tests2.%+: + @$(MAKE) $(call F2,$(call F1,$*)) --no-print-directory + +# just run tcc to see the output, e.g. "make tests2.37-" +tests2.%-: + @$(MAKE) $(call F1,$*) T3= --no-print-directory + +# run single test, e.g. "make tests2.37" +tests2.%: + @$(MAKE) $(call F1,$*) --no-print-directory + +F1 = $(or $(filter $1_%,$(TESTS)),$1_???.test) +F2 = $1 UPDATE="$(patsubst %.test,%.expect,$1)" + +# automatically generate .expect files with gcc: +%.expect : + @echo Generating: $@ + @$(call GEN,$(SRC)/$*.c) $(FILTER) >$@ 2>&1 + @rm -f *.exe *.obj *.pdb + +# using TCC for .expect if -dt in FLAGS +GEN = $(if $(filter -dt -bt -b,$(FLAGS)),$(GEN-TCC),$(GEN-CC)) +GEN-CC = $(CC) -w -std=gnu99 $(FLAGS) $1 -o $(basename $@).exe && ./$(basename $@).exe $(ARGS) +GEN-TCC = $(T1) +GEN-MSC = $(MS-CC) $1 && ./$(basename $@).exe +MS-CC = cl + +# tell make not to delete +.PRECIOUS: %.expect + +# force .expect generation for these files +$(sort $(GEN-ALWAYS) $(UPDATE)) : force +force: + +clean : + rm -f fred.txt *.output *.exe *.dll *.so *.def $(GEN-ALWAYS) |