github-repos/tinycc
1
0
Fork 0
mirror of https://github.com/mirror/tinycc.git synced 2025-01-01 04:20:09 +08:00
Code Issues Packages Projects Releases Wiki Activity
ece74ceaaf
tinycc/tests/tests2/60_errors_and_warnings.expect

231 lines
7.1 KiB
Plaintext
Raw Normal View History

tcc -dt -run ... : simpler is better * -dt now with lowercase t * test snippets now separated by real preprocessor statements which is valid C also for other compilers #if defined test_xxx < test snippet x > #elif defined test_yyy < test snippet y > #elif ... #endif * simpler implementation, behaves like -run if no 'test_...' macros are seen, works with -E too * for demonstration I combined some of the small tests for errors and warnings (56..63,74) in "60_errors_and_warnings.c" Also: * libtcc.c: put tcc_preprocess() and tcc_assemble() under the setjmp clause to let them return to caller after errors. This is for -dt -E. * tccgen.c: - get rid of save/restore_parse_state(), macro_ptr is saved by begin_macro anyway, now line_num too. - use expr_eq for parsing _Generic's controlling_type - set nocode_wanted with const_wanted. too, This is to keep VT_JMP on vtop when parsing preprocessor expressions. * tccpp.c: tcc -E: suppress trailing whitespace from lines with comments (that -E removes) such as NO_GOTPLT_ENTRY,\t /* never generate ... */
2017-07-21 04:21:27 +08:00
[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]
tccrun.c: standalone backtraces with -bt[N] or -b This makes it possible to get backtraces with executables (including DLLs/SOs) like we had it already with -g -run. Option -b includes -bt, and -bt includes -g. - new file lib/bt-exe.c: used to link rt_printline and the exception handler from tccrun.c into executables/DLLs. - new file lib/bt-log.c: provides a function that may be called from user code to print out a backtrace with a message (currently for i386/x86_64 only): int (*tcc_backtrace)(const char *fmt, ...); As an extra hack, if 'fmt' is prefixed like "^file.c^..." then the backtrace will skip calls from within 'file.c'. - new file lib/bt-dll.c: used on win32 to link the backtrace and bcheck functions with the main module at runtime - bcheck.c: now uses the tcc_backtrace function from above - tccgen.c: minor cleanups - tccelf.c: stab sections get SHF_ALLOC for easy access. Also in relocate_section(): 64bit relocations for stabs in DLLs cannot work. To find DLL addresses, the DLL base is added manually in tccrun.c via rc.prog_base instead. - tccpe.c: there are some changes to allow merging sections, used to merge .finit_array into .data in the first place. - tccpp.c: tcc -run now #defines __TCC_RUN__ also: refactor a line in tal_realloc that was incompatible with bcheck - tcctest.c: fixed a problem with r12 which tcc cannot preserve as well as gcc does. - tests2/112_backtrace.c: test the feature and the bcheck test18 that previously was in boundtest.c
2020-01-18 05:58:39 +08:00
[returns 1]
tcc -dt -run ... : simpler is better * -dt now with lowercase t * test snippets now separated by real preprocessor statements which is valid C also for other compilers #if defined test_xxx < test snippet x > #elif defined test_yyy < test snippet y > #elif ... #endif * simpler implementation, behaves like -run if no 'test_...' macros are seen, works with -E too * for demonstration I combined some of the small tests for errors and warnings (56..63,74) in "60_errors_and_warnings.c" Also: * libtcc.c: put tcc_preprocess() and tcc_assemble() under the setjmp clause to let them return to caller after errors. This is for -dt -E. * tccgen.c: - get rid of save/restore_parse_state(), macro_ptr is saved by begin_macro anyway, now line_num too. - use expr_eq for parsing _Generic's controlling_type - set nocode_wanted with const_wanted. too, This is to keep VT_JMP on vtop when parsing preprocessor expressions. * tccpp.c: tcc -E: suppress trailing whitespace from lines with comments (that -E removes) such as NO_GOTPLT_ENTRY,\t /* never generate ... */
2017-07-21 04:21:27 +08:00
[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
tccgen.c: fix warning for incompatible struct- and function pointers see tests2/60_errors_and_warnings.c
2018-06-01 05:52:07 +08:00
[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'
Fix array pointer stringification. `int (*)[4];` should not be stringified as `int *[4];` Add stringification tests.
2018-11-13 00:11:24 +08:00
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
[test_enum_compat_2]
60_errors_and_warnings.c:126: error: incompatible types for redefinition of 'f4'
Fix array pointer stringification. `int (*)[4];` should not be stringified as `int *[4];` Add stringification tests.
2018-11-13 00:11:24 +08:00
[test_ptr_to_str]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:129: error: type 'const int **' does not match any association
Fix array pointer stringification. `int (*)[4];` should not be stringified as `int *[4];` Add stringification tests.
2018-11-13 00:11:24 +08:00
[test_fnptr_to_str]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:131: error: type 'int (*(*)(float, char))(double, int)' does not match any association
Fix array pointer stringification. `int (*)[4];` should not be stringified as `int *[4];` Add stringification tests.
2018-11-13 00:11:24 +08:00
[test_array_to_str]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:133: error: type 'int (*)[3]' does not match any association
Fix crash on invalid code like on 'enum myenum { L = -1 } L;'. It's a bit tedious as there are two paths (for global vs local symbols), and because the scope and enum_val share same storage.
2019-03-09 00:58:25 +08:00
[test_duplicate_def_1]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:135: error: redefinition of 'L'
Fix crash on invalid code like on 'enum myenum { L = -1 } L;'. It's a bit tedious as there are two paths (for global vs local symbols), and because the scope and enum_val share same storage.
2019-03-09 00:58:25 +08:00
[test_duplicate_def_2]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:138: error: redeclaration of 'L'
Handle corner case for abstract decls sometimes abstract decls in parameter lists left the returned name uninitialized potentially leading to segfaults, like in int f(int ()) { return 0; } Deal with this.
2019-03-13 00:27:15 +08:00
[test_abstract_decls]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:148: error: identifier expected
Detect more invalid initializers in presence of invalid source code we can't rely on the next token to determine if we have or haven't already parsed an initializer element, we really have to track it in some separate state; it's a flag, so merge it with the other two we have (size_only and first). Also add some syntax checks for situations which formerly lead to vstack leaks, see the added testcases.
2019-03-18 10:26:19 +08:00
[test_invalid_1]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:153: error: identifier expected
Detect more invalid initializers in presence of invalid source code we can't rely on the next token to determine if we have or haven't already parsed an initializer element, we really have to track it in some separate state; it's a flag, so merge it with the other two we have (size_only and first). Also add some syntax checks for situations which formerly lead to vstack leaks, see the added testcases.
2019-03-18 10:26:19 +08:00
[test_invalid_2]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:156: error: ';' expected (got "{")
Detect more invalid initializers in presence of invalid source code we can't rely on the next token to determine if we have or haven't already parsed an initializer element, we really have to track it in some separate state; it's a flag, so merge it with the other two we have (size_only and first). Also add some syntax checks for situations which formerly lead to vstack leaks, see the added testcases.
2019-03-18 10:26:19 +08:00
[test_invalid_3]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:160: error: ',' expected (got "a")
Fix local extern vardecl see testcases. A local 'extern int i' declaration needs to refer to the global declaration, not to a local one it might be shadowing. Doesn't seem to happen in the wild very often as this was broken forever.
2019-03-18 12:53:03 +08:00
Fix handling of unevaluated subexpression of const we were emitting error messages for something like 'static int i = 2 || 1/0', even though the exception would be in the unevaluated part. This doesn't destroy const-ness, so we must accept it. This requires splitting the nocode_wanted values a bit more, so that nocode_wanted due to const_wanted can be differentiated from nocode_wanted due to non-evaluation.
2020-01-16 06:32:40 +08:00
[test_invalid_4]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:164: error: division by zero in constant
Fix handling of unevaluated subexpression of const we were emitting error messages for something like 'static int i = 2 || 1/0', even though the exception would be in the unevaluated part. This doesn't destroy const-ness, so we must accept it. This requires splitting the nocode_wanted values a bit more, so that nocode_wanted due to const_wanted can be differentiated from nocode_wanted due to non-evaluation.
2020-01-16 06:32:40 +08:00
Fix local extern vardecl see testcases. A local 'extern int i' declaration needs to refer to the global declaration, not to a local one it might be shadowing. Doesn't seem to happen in the wild very often as this was broken forever.
2019-03-18 12:53:03 +08:00
[test_conflicting_types]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:170: error: incompatible types for redefinition of 'i'
Don't endlessly recurse on invalid nested typedefs see testcase.
2019-04-07 09:15:05 +08:00
[test_nested_types]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:177: error: struct/union/enum already defined
Detect invalid VLA decls see testcase, when the inner array dimension of multi-dimensional VLAs isn't given TCC was generating invalid vstack accesses. Those are actually invalid, so just diagnose them.
2019-04-07 10:09:25 +08:00
[test_vla_1]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:184: error: need explicit inner array size in VLAs
Fix _Alignas * don't accept _Alignas as type qualifier (after pointer '*'). * accept type-names within _Alignas * add testcases
2019-04-09 02:58:49 +08:00
[test_invalid_alignas]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:188: error: identifier expected
_Static_assert test
2019-04-28 14:27:33 +08:00
[test_static_assert]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:194: error: ONE is not 1
improve _Static_assert Fix static assert to support literal string instead of just printing the sring of the current token as it use to be so we can now use _Static_assert(0, "0" "1") which will print __FILE__ __LINE__ error: 01
2020-02-29 08:24:35 +08:00
[test_static_assert_2]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:198: error: 0 is 0
reject invalid arrays in post_type()
2019-06-24 16:28:36 +08:00
instruduce C2x _Static_assert syntaxe
2020-02-29 08:55:11 +08:00
[test_static_assert_c2x]
Fix type compatiblity of enums and ints an enum must be compatible with one or more integer type, so adjust the test accordingly. That means the following redeclarations should work: enum e6 { E1 = -1, E0 }; void f3(enum e6); void f3(int); // should work as int and e6 are compatible while the following should not: void f4(enum e6 e); void f4(unsigned e); // should error as unsigned and e6 are incompatible
2020-06-05 22:02:08 +08:00
60_errors_and_warnings.c:202: error: _Static_assert fail
instruduce C2x _Static_assert syntaxe
2020-02-29 08:55:11 +08:00
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
[test_static_assert_empty_string]
60_errors_and_warnings.c:205: error:
reject invalid arrays in post_type()
2019-06-24 16:28:36 +08:00
[test_void_array]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:208: error: declaration of an array of incomplete type elements
reject invalid arrays in post_type()
2019-06-24 16:28:36 +08:00
[test_incomplete_enum_array]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:211: error: declaration of an array of incomplete type elements
reject invalid arrays in post_type()
2019-06-24 16:28:36 +08:00
[test_incomplete_struct_array]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:214: error: declaration of an array of incomplete type elements
reject invalid arrays in post_type()
2019-06-24 16:28:36 +08:00
[test_const_fun_array]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:218: error: declaration of an array of functions
reject invalid arrays in post_type()
2019-06-24 16:28:36 +08:00
[test_incomplete_array_array]
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
[test_extern_array]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:234: error: incompatible types for redefinition of 'x'
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
[test_func_1]
hello: a = 123
[test_func_2]
hello: a = 123
[test_func_3]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:264: warning: static storage ignored for redefinition of 'hello'
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
hello: a = 123
[test_func_4]
hello: a = 123
[test_func_5]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:264: error: incompatible types for redefinition of 'hello'
Readd lost error on local static function decls see testcase: block scope decls for functions can't use static (allowed is only extern or none). This got lost in commit 85690480.
2019-12-16 13:54:18 +08:00
[test_func_6]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:252: error: function without file scope cannot be static
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
[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]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:296: error: incompatible types for redefinition of 'xxx'
tccgen.c: local extern decls: copy s->ref for VT_PTR too This fixes the issue int main() { extern char *x; } void main1() { extern char *x; } t2.c:5: error: incompatible types for redefinition of 'x' (reported by Giovanni Mascellani 2019/07/16)
2019-07-16 23:30:04 +08:00
[test_var_4]
win32: long double as distinct C-type On windows. there is no long double really IOW it is the same as double. However setting the VT_LONG flag in combination with VT_DOUBLE allows to keep track of the original type for the purpose of '_Generic() or more accurate type warnings.
2020-02-23 07:11:03 +08:00
[test_long_double_type_for_win32]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:327: warning: assignment from incompatible pointer type
pp: Move errors about stray backslashes they were emitted too early, in particular also in macro substitution which might turn out to not be stray in case it's further stringified. Check in next() instead. Add two testcases that an error is still emitted for obvious top-level baskslashes, and that stringifying such a thing works.
2020-06-04 00:38:11 +08:00
[test_stray_backslash]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:333: error: stray '\' in program
tccpp.c: compile 'tcc_predefs' from string It might have advantages in cases if tcc/libtcc does not depend on extern files. Also: - apply "stray \\ ..." check to macros only. For files it was already checked. Add positive test.
2020-05-14 05:52:48 +08:00
[test_stray_backslash2]
\n
Fix gcc testsuite problems arm-gen.c: - is_hgen_float_aggr/gfunc_sret: Fix for zero sized structs arm64-gen.c: - arm64_ldrs: Fix for zero sized structs - arm64_sym: Use R_AARCH64_ABS64 instead of R_AARCH64_MOVW_UABS_G* This has same speed. See 117_gcc_test.c(tst_adr) - load: Fix for zero sized structs and add VT_CONST | VT_LVAL support - store: add VT_CONST | VT_LVAL support - arm64_gen_bl_or_b: Allow branch. See 117_gcc_test.c(tst_branch) - gen_bounds_prolog: Use R_AARCH64_ABS64 for bound checking - gen_bounds_epilog: Use R_AARCH64_ABS64 for bound checking - gfunc_call: Allow large stack - arm64_gen_opic: Do not crash on large shift riscv64-gen.c: - load: Move type_size call. (move_reg set sv.type.ref NULL for VT_STRUCT) - gfunc_call: Allow large stack - gen_opil: Fix word mode calls x86_64-gen.c: - load: Fix for zero sized structs libtcc.c: - Add some defines for gcc testsuite (only most common) tccgen.c: - parse_builtin_params: Add types for builtins - unary: Add builtins: __builtin_abort __builtin_memcpy __builtin_memcmp __builtin_memmove __builtin_memset __builtin_strlen __builtin_strcpy __builtin_strncpy __builtin_strcmp __builtin_strncmp __builtin_strcat __builtin_strchr __builtin_strdup __builtin_malloc __builtin_realloc __builtin_calloc __builtin_free __builtin_alloca - decl_initializer: Fix crash. See 60_errors_and_warnings(test_var_array) tccmacho.c: - Remove 'ret = 0' tcctok.h: - Add builtin/bound checking tokens tests/gcctestsuite.sh: - Add more counters and run execute tests tests/bug.c - Some remaining bugs in tcc (not complete) tests/tests2/60_errors_and_warnings: - Add test_var_array test tests/tests2/117_gcc_test: - New test Results of gcctestsuite.sh for all targets: linux: x86_64: 3036 test(s) ok. 328 test(s) failed. 24 test(s) exe failed. i386: 3037 test(s) ok. 327 test(s) failed. 24 test(s) exe failed. arm: 2986 test(s) ok. 362 test(s) failed. 40 test(s) exe failed. arm64: 2996 test(s) ok. 367 test(s) failed. 25 test(s) exe failed. macos: 3031 test(s) ok. 332 test(s) failed. 25 test(s) exe failed. riscv: 2948 test(s) ok. 401 test(s) failed. 39 test(s) exe failed. windows: x86_64: 3027 test(s) ok. 333 test(s) failed. 28 test(s) exe failed. i386: 3029 test(s) ok. 331 test(s) failed. 28 test(s) exe failed. linux with bounds checking: x86_64: 3030 test(s) ok. 328 test(s) failed. 30 test(s) exe failed. i386: 3028 test(s) ok. 327 test(s) failed. 33 test(s) exe failed. arm: 2997 test(s) ok. 362 test(s) failed. 29 test(s) exe failed. arm64: 2986 test(s) ok. 367 test(s) failed. 35 test(s) exe failed. macos: 3026 test(s) ok. 332 test(s) failed. 30 test(s) exe failed. riscv: 2936 test(s) ok. 409 test(s) failed. 43 test(s) exe failed. windows with bounds checking: x86_64: 3029 test(s) ok. 332 test(s) failed. 27 test(s) exe failed. i386: 3027 test(s) ok. 331 test(s) failed. 30 test(s) exe failed. all: fail for complex and vector types, nested functions and a lot of gcc defines/buitins. arm/arm64/riscv: fail for asm and alloca. riscv: fail with 'error: unimp: store(struct)'
2020-07-05 20:01:50 +08:00
[test_var_array]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:348: error: flexible array has zero size in this context
tccgen: flex arrays etc. Fixes potential writes past the allocated space with mostly illegal flex array initializers. (60_errors_and_warnings.c :test_var_array) In exchange suspicious precautions such as section_reserve or checks with sec->data_allocated were removed. (There is an hard check 'init_assert()' for now but it's meant to be just temporary) Also, instead of filling holes, always memset(0) structures & arrays on stack. Sometimes more efficient, sometimes isn't. At least we can omit putting null initializers. About array range inititializers: Reparsing tokens has a small problem with sideeffects, for example int c = 0, dd[] = { [0 ... 1] = ++c, [2 ... 3] = ++c }; Also, instead of 'squeeze_multi_relocs()', delete pre-existing relocations in advance. This works even if secondary initializers don't even have relocations, as with [0 ... 7] = &stuff, [4] = NULL Also, in tcc.h: new macro "tcc_internal_error()"
2020-09-23 18:03:59 +08:00
[test_var_array2]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:358: error: flexible array has zero size in this context
three small fixes & three reverts - tcc.h: msvc doesn't grok __func__ (reverts previous commit) - tccgen.c: fortify tcc against bogus code: - n[sizeof({3;})]; // statement expression outside of function - f(){"123"4}; // tokens with values following each other (also, add "type defaults to int" warning for variables) - tccpe.c: removed a check that caused BSS symbols not to be exported. Whatever that check was meant to prevent. - win32/build-tcc.bat: cmd.exe sometimes doesn't grok '-' in labels - Revert "libtcc: no need to undef" This reverts commit 2b7aa2a1e11b3afc9907c47c52b8018b5a1fb108. - Revert "tcc.h libtcc.c: remove unused defines" This reverts commit 985d9637455929be5b19741de7ba47b245b0cab8. The point of these "unused defines" is to be unused, that is to remind people not to use malloc but please to "use_tcc_malloc", instead.
2020-10-24 03:38:53 +08:00
Fix segfault with nested flex array structs when used with string initialization the size of nested struct flex array member was tested too late for < 0. GCC accepts but discards such initializers (the flex array member will become zero sized). TCC supports flex arrays members only in top-level structs and gives an error in this case.
2021-02-16 06:58:18 +08:00
[test_var_array3]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:365: error: flexible array has zero size in this context
Fix segfault with nested flex array structs when used with string initialization the size of nested struct flex array member was tested too late for < 0. GCC accepts but discards such initializers (the flex array member will become zero sized). TCC supports flex arrays members only in top-level structs and gives an error in this case.
2021-02-16 06:58:18 +08:00
three small fixes & three reverts - tcc.h: msvc doesn't grok __func__ (reverts previous commit) - tccgen.c: fortify tcc against bogus code: - n[sizeof({3;})]; // statement expression outside of function - f(){"123"4}; // tokens with values following each other (also, add "type defaults to int" warning for variables) - tccpe.c: removed a check that caused BSS symbols not to be exported. Whatever that check was meant to prevent. - win32/build-tcc.bat: cmd.exe sometimes doesn't grok '-' in labels - Revert "libtcc: no need to undef" This reverts commit 2b7aa2a1e11b3afc9907c47c52b8018b5a1fb108. - Revert "tcc.h libtcc.c: remove unused defines" This reverts commit 985d9637455929be5b19741de7ba47b245b0cab8. The point of these "unused defines" is to be unused, that is to remind people not to use malloc but please to "use_tcc_malloc", instead.
2020-10-24 03:38:53 +08:00
[test_default_int_type]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:368: warning: type defaults to int
three small fixes & three reverts - tcc.h: msvc doesn't grok __func__ (reverts previous commit) - tccgen.c: fortify tcc against bogus code: - n[sizeof({3;})]; // statement expression outside of function - f(){"123"4}; // tokens with values following each other (also, add "type defaults to int" warning for variables) - tccpe.c: removed a check that caused BSS symbols not to be exported. Whatever that check was meant to prevent. - win32/build-tcc.bat: cmd.exe sometimes doesn't grok '-' in labels - Revert "libtcc: no need to undef" This reverts commit 2b7aa2a1e11b3afc9907c47c52b8018b5a1fb108. - Revert "tcc.h libtcc.c: remove unused defines" This reverts commit 985d9637455929be5b19741de7ba47b245b0cab8. The point of these "unused defines" is to be unused, that is to remind people not to use malloc but please to "use_tcc_malloc", instead.
2020-10-24 03:38:53 +08:00
[test_invalid_global_stmtexpr]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:372: error: statement expression outside of function
three small fixes & three reverts - tcc.h: msvc doesn't grok __func__ (reverts previous commit) - tccgen.c: fortify tcc against bogus code: - n[sizeof({3;})]; // statement expression outside of function - f(){"123"4}; // tokens with values following each other (also, add "type defaults to int" warning for variables) - tccpe.c: removed a check that caused BSS symbols not to be exported. Whatever that check was meant to prevent. - win32/build-tcc.bat: cmd.exe sometimes doesn't grok '-' in labels - Revert "libtcc: no need to undef" This reverts commit 2b7aa2a1e11b3afc9907c47c52b8018b5a1fb108. - Revert "tcc.h libtcc.c: remove unused defines" This reverts commit 985d9637455929be5b19741de7ba47b245b0cab8. The point of these "unused defines" is to be unused, that is to remind people not to use malloc but please to "use_tcc_malloc", instead.
2020-10-24 03:38:53 +08:00
[test_invalid_tokckill]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:375: error: ';' expected (got "3")
duplicate member Check duplicate struct/union member names tcc.h: Add cnt field in TokenSym tccgen.c: New function check_fields to find duplicate member names. This avoids quadratic behavior and can be used for large structs.
2020-12-03 14:53:44 +08:00
[test_duplicate_member]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:381: error: duplicate member 'a'
duplicate member Check duplicate struct/union member names tcc.h: Add cnt field in TokenSym tccgen.c: New function check_fields to find duplicate member names. This avoids quadratic behavior and can be used for large structs.
2020-12-03 14:53:44 +08:00
[test_duplicate_member_anon]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:394: error: duplicate member 'd'
Allow declared arrays to be initialized without an explicit size When defining an array with non-explicit size, one would get "incompatible types for redefinition of 'array' if the array was already declared with a different size. For example: extern int array[2]; int array[] = {1}; would fail to compile with tcc. Instead the above is now equivalent to: int array[] = {1, 0};
2021-02-14 10:37:25 +08:00
[test_conflicting_array_definition]
Fix static assert with empty string
2022-11-30 02:45:05 +08:00
60_errors_and_warnings.c:399: error: incompatible types for redefinition of 'array'
tccgen: gen_cast(): detect 'cast from void' error
2021-01-27 05:25:53 +08:00
Fix sym_scope of typedefs Sym.sym_scope and Sym.f (FuncAttr) share space, so blindly setting one clobbers the other. Right now this only leads to missing errors on incompatible typedefs (see testcase), which this commit fixes. But it points to a larger problem: Generally we can only manipulate Sym.f for anonymous and field symbols, not for anything that has a top-level name (basically any proper decl), because the latter use sym_scope. Luckily the functions type always contains an anonymous symbol (in sym->type.ref), so we can use that. But some of the functions attributes actually _do_ apply to the decl, not the type (e.g. always_inline), so we still have a problem possibly, when we update an pre-existing type that may already be shared with another decl. Would need untangling and perhaps using accessor functions that check that Sym.f and Sym.sym_scope aren't used for the same symbol.
2023-02-23 00:59:31 +08:00
[test_incompatible_local_redef]
60_errors_and_warnings.c:406: error: incompatible redefinition of 'localfunctype'
tccgen: gen_cast(): detect 'cast from void' error
2021-01-27 05:25:53 +08:00
[test_cast_from_void]
Fix sym_scope of typedefs Sym.sym_scope and Sym.f (FuncAttr) share space, so blindly setting one clobbers the other. Right now this only leads to missing errors on incompatible typedefs (see testcase), which this commit fixes. But it points to a larger problem: Generally we can only manipulate Sym.f for anonymous and field symbols, not for anything that has a top-level name (basically any proper decl), because the latter use sym_scope. Luckily the functions type always contains an anonymous symbol (in sym->type.ref), so we can use that. But some of the functions attributes actually _do_ apply to the decl, not the type (e.g. always_inline), so we still have a problem possibly, when we update an pre-existing type that may already be shared with another decl. Would need untangling and perhaps using accessor functions that check that Sym.f and Sym.sym_scope aren't used for the same symbol.
2023-02-23 00:59:31 +08:00
60_errors_and_warnings.c:411: error: cannot convert 'void' to 'int'
-W[no-]error...: features by shrinkage 136 insertions(+), 226 deletions(-), less 90 lines (except tests) only one set_flag() function required * can now turn off specific errors: -Werror -Wno-error=option * new interface: tcc_warning_c(warn_option)("format", args...); * new warning: -Wdiscarded-qualifiers (on by default) * new variable 'warn_all' for conditional warnings with -Wall see also the tests
2021-08-01 02:44:51 +08:00
[test_switch_W1]
Fix sym_scope of typedefs Sym.sym_scope and Sym.f (FuncAttr) share space, so blindly setting one clobbers the other. Right now this only leads to missing errors on incompatible typedefs (see testcase), which this commit fixes. But it points to a larger problem: Generally we can only manipulate Sym.f for anonymous and field symbols, not for anything that has a top-level name (basically any proper decl), because the latter use sym_scope. Luckily the functions type always contains an anonymous symbol (in sym->type.ref), so we can use that. But some of the functions attributes actually _do_ apply to the decl, not the type (e.g. always_inline), so we still have a problem possibly, when we update an pre-existing type that may already be shared with another decl. Would need untangling and perhaps using accessor functions that check that Sym.f and Sym.sym_scope aren't used for the same symbol.
2023-02-23 00:59:31 +08:00
60_errors_and_warnings.c:427: warning: implicit declaration of function 'fink'
-W[no-]error...: features by shrinkage 136 insertions(+), 226 deletions(-), less 90 lines (except tests) only one set_flag() function required * can now turn off specific errors: -Werror -Wno-error=option * new interface: tcc_warning_c(warn_option)("format", args...); * new warning: -Wdiscarded-qualifiers (on by default) * new variable 'warn_all' for conditional warnings with -Wall see also the tests
2021-08-01 02:44:51 +08:00
[test_switch_W2]
Fix sym_scope of typedefs Sym.sym_scope and Sym.f (FuncAttr) share space, so blindly setting one clobbers the other. Right now this only leads to missing errors on incompatible typedefs (see testcase), which this commit fixes. But it points to a larger problem: Generally we can only manipulate Sym.f for anonymous and field symbols, not for anything that has a top-level name (basically any proper decl), because the latter use sym_scope. Luckily the functions type always contains an anonymous symbol (in sym->type.ref), so we can use that. But some of the functions attributes actually _do_ apply to the decl, not the type (e.g. always_inline), so we still have a problem possibly, when we update an pre-existing type that may already be shared with another decl. Would need untangling and perhaps using accessor functions that check that Sym.f and Sym.sym_scope aren't used for the same symbol.
2023-02-23 00:59:31 +08:00
60_errors_and_warnings.c:418: warning: unsupported option '-Wstuff'
60_errors_and_warnings.c:429: warning: 'stuff' attribute ignored
-W[no-]error...: features by shrinkage 136 insertions(+), 226 deletions(-), less 90 lines (except tests) only one set_flag() function required * can now turn off specific errors: -Werror -Wno-error=option * new interface: tcc_warning_c(warn_option)("format", args...); * new warning: -Wdiscarded-qualifiers (on by default) * new variable 'warn_all' for conditional warnings with -Wall see also the tests
2021-08-01 02:44:51 +08:00
[test_switch_W3]
Fix sym_scope of typedefs Sym.sym_scope and Sym.f (FuncAttr) share space, so blindly setting one clobbers the other. Right now this only leads to missing errors on incompatible typedefs (see testcase), which this commit fixes. But it points to a larger problem: Generally we can only manipulate Sym.f for anonymous and field symbols, not for anything that has a top-level name (basically any proper decl), because the latter use sym_scope. Luckily the functions type always contains an anonymous symbol (in sym->type.ref), so we can use that. But some of the functions attributes actually _do_ apply to the decl, not the type (e.g. always_inline), so we still have a problem possibly, when we update an pre-existing type that may already be shared with another decl. Would need untangling and perhaps using accessor functions that check that Sym.f and Sym.sym_scope aren't used for the same symbol.
2023-02-23 00:59:31 +08:00
60_errors_and_warnings.c:426: error: assignment discards qualifiers from pointer target type
-W[no-]error...: features by shrinkage 136 insertions(+), 226 deletions(-), less 90 lines (except tests) only one set_flag() function required * can now turn off specific errors: -Werror -Wno-error=option * new interface: tcc_warning_c(warn_option)("format", args...); * new warning: -Wdiscarded-qualifiers (on by default) * new variable 'warn_all' for conditional warnings with -Wall see also the tests
2021-08-01 02:44:51 +08:00
[test_switch_W4]
Fix sym_scope of typedefs Sym.sym_scope and Sym.f (FuncAttr) share space, so blindly setting one clobbers the other. Right now this only leads to missing errors on incompatible typedefs (see testcase), which this commit fixes. But it points to a larger problem: Generally we can only manipulate Sym.f for anonymous and field symbols, not for anything that has a top-level name (basically any proper decl), because the latter use sym_scope. Luckily the functions type always contains an anonymous symbol (in sym->type.ref), so we can use that. But some of the functions attributes actually _do_ apply to the decl, not the type (e.g. always_inline), so we still have a problem possibly, when we update an pre-existing type that may already be shared with another decl. Would need untangling and perhaps using accessor functions that check that Sym.f and Sym.sym_scope aren't used for the same symbol.
2023-02-23 00:59:31 +08:00
60_errors_and_warnings.c:427: warning: implicit declaration of function 'fink'
60_errors_and_warnings.c:429: error: 'stuff' attribute ignored
tccgen: accept array-size expressions in function paramters Modify function parameter parser such that symbols are put into token-table temporarily. Benefits are: - detects redefinitions, as with int foo(int a, int a); - detects reserved symbols, as with int foo(int if); - can parse expressions like int main(int argc, char *argv[argc + 1]); - doesn't fix this one int main(int argc, char *argv[++argc]); Also: fix unexpected "function might return no value" with statement expression int f() { ({ return 0; }); }
2022-03-02 05:00:42 +08:00
[test_invalid_funcparam_1]
Fix sym_scope of typedefs Sym.sym_scope and Sym.f (FuncAttr) share space, so blindly setting one clobbers the other. Right now this only leads to missing errors on incompatible typedefs (see testcase), which this commit fixes. But it points to a larger problem: Generally we can only manipulate Sym.f for anonymous and field symbols, not for anything that has a top-level name (basically any proper decl), because the latter use sym_scope. Luckily the functions type always contains an anonymous symbol (in sym->type.ref), so we can use that. But some of the functions attributes actually _do_ apply to the decl, not the type (e.g. always_inline), so we still have a problem possibly, when we update an pre-existing type that may already be shared with another decl. Would need untangling and perhaps using accessor functions that check that Sym.f and Sym.sym_scope aren't used for the same symbol.
2023-02-23 00:59:31 +08:00
60_errors_and_warnings.c:432: error: redeclaration of 'a'
tccgen: accept array-size expressions in function paramters Modify function parameter parser such that symbols are put into token-table temporarily. Benefits are: - detects redefinitions, as with int foo(int a, int a); - detects reserved symbols, as with int foo(int if); - can parse expressions like int main(int argc, char *argv[argc + 1]); - doesn't fix this one int main(int argc, char *argv[++argc]); Also: fix unexpected "function might return no value" with statement expression int f() { ({ return 0; }); }
2022-03-02 05:00:42 +08:00
[test_invalid_funcparam_2]
Fix sym_scope of typedefs Sym.sym_scope and Sym.f (FuncAttr) share space, so blindly setting one clobbers the other. Right now this only leads to missing errors on incompatible typedefs (see testcase), which this commit fixes. But it points to a larger problem: Generally we can only manipulate Sym.f for anonymous and field symbols, not for anything that has a top-level name (basically any proper decl), because the latter use sym_scope. Luckily the functions type always contains an anonymous symbol (in sym->type.ref), so we can use that. But some of the functions attributes actually _do_ apply to the decl, not the type (e.g. always_inline), so we still have a problem possibly, when we update an pre-existing type that may already be shared with another decl. Would need untangling and perhaps using accessor functions that check that Sym.f and Sym.sym_scope aren't used for the same symbol.
2023-02-23 00:59:31 +08:00
60_errors_and_warnings.c:435: error: identifier expected
tccgen: accept array-size expressions in function paramters Modify function parameter parser such that symbols are put into token-table temporarily. Benefits are: - detects redefinitions, as with int foo(int a, int a); - detects reserved symbols, as with int foo(int if); - can parse expressions like int main(int argc, char *argv[argc + 1]); - doesn't fix this one int main(int argc, char *argv[++argc]); Also: fix unexpected "function might return no value" with statement expression int f() { ({ return 0; }); }
2022-03-02 05:00:42 +08:00
[test_array_funcparam]
arg[0] = "X"
arg[1] = "Y"
[test_return_from_statement_expr]
[returns 78]
Fix unicode compiler warning The compiler warned about the unicode_to_utf8 code. I fixed it by giving an error. This is the same as gcc does.
2022-05-12 17:18:37 +08:00
[test_illegal_unicode]
Fix sym_scope of typedefs Sym.sym_scope and Sym.f (FuncAttr) share space, so blindly setting one clobbers the other. Right now this only leads to missing errors on incompatible typedefs (see testcase), which this commit fixes. But it points to a larger problem: Generally we can only manipulate Sym.f for anonymous and field symbols, not for anything that has a top-level name (basically any proper decl), because the latter use sym_scope. Luckily the functions type always contains an anonymous symbol (in sym->type.ref), so we can use that. But some of the functions attributes actually _do_ apply to the decl, not the type (e.g. always_inline), so we still have a problem possibly, when we update an pre-existing type that may already be shared with another decl. Would need untangling and perhaps using accessor functions that check that Sym.f and Sym.sym_scope aren't used for the same symbol.
2023-02-23 00:59:31 +08:00
60_errors_and_warnings.c:459: error: 0xffffffff is not a valid universal character
tccpp : get rid of 'ch' - also simplify parse(_line)_comment() and parse_pp_string() - fixes a continuation problem in strings (see tcctest.c) - no differences in performance could be observed 161 insertions(+), 246 deletions(-), less 85 lines
2022-08-18 16:43:28 +08:00
[test_error_string]
Fix sym_scope of typedefs Sym.sym_scope and Sym.f (FuncAttr) share space, so blindly setting one clobbers the other. Right now this only leads to missing errors on incompatible typedefs (see testcase), which this commit fixes. But it points to a larger problem: Generally we can only manipulate Sym.f for anonymous and field symbols, not for anything that has a top-level name (basically any proper decl), because the latter use sym_scope. Luckily the functions type always contains an anonymous symbol (in sym->type.ref), so we can use that. But some of the functions attributes actually _do_ apply to the decl, not the type (e.g. always_inline), so we still have a problem possibly, when we update an pre-existing type that may already be shared with another decl. Would need untangling and perhaps using accessor functions that check that Sym.f and Sym.sym_scope aren't used for the same symbol.
2023-02-23 00:59:31 +08:00
60_errors_and_warnings.c:464: error: #error \123\456
Reference in New Issue Copy Permalink