github-repos/tinycc
1
0
Fork 0
mirror of https://github.com/mirror/tinycc.git synced 2024-12-30 04:10:08 +08:00
Code Issues Packages Projects Releases Wiki Activity
c3f0937012
tinycc/tccgen.c

7719 lines
227 KiB
C
Raw Normal View History

new files: tcc.h libtcc.c tccpp.c tccgen.c
2009-05-06 02:17:11 +08:00
/*
* TCC - Tiny C Compiler
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
*
new files: tcc.h libtcc.c tccpp.c tccgen.c
2009-05-06 02:17:11 +08:00
* Copyright (c) 2001-2004 Fabrice Bellard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
#include "tcc.h"
/********************************************************/
/* global variables */
/* loc : local variable index
ind : output code index
rsym: return symbol
anon_sym: anonymous symbol index
*/
ST_DATA int rsym, anon_sym, ind, loc;
ST_DATA Sym *sym_free_first;
ST_DATA void **sym_pools;
ST_DATA int nb_sym_pools;
ST_DATA Sym *global_stack;
ST_DATA Sym *local_stack;
ST_DATA Sym *define_stack;
ST_DATA Sym *global_label_stack;
ST_DATA Sym *local_label_stack;
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
static Sym *all_cleanups, *current_cleanups, *pending_gotos;
static int ncleanups;
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
static int local_scope;
Misc. fixes Makefile : - do not 'uninstall' peoples /usr/local/doc entirely libtcc.c : - MEM_DEBUG : IDE-friendly output "file:line: ..." - always ELF for objects tccgen.c : - fix memory leak in new switch code - move static 'in_sizeof' out of function profiling : - define 'static' to empty resolve_sym() : - replace by dlsym() win32/64: fix R_XXX_RELATIVE fixme - was fixed for i386 already in 8e4d64be2fc1d707c7800c5096f6e0ea22cbd - do not -Lsystemdir if compiling to .o
2016-10-06 00:34:17 +08:00
static int in_sizeof;
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
static int section_sym;
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
ST_DATA int vlas_in_scope; /* number of VLAs that are currently in scope */
Improved variable length array support. VLA storage is now freed when it goes out of scope. This makes it possible to use a VLA inside a loop without consuming an unlimited amount of memory. Combining VLAs with alloca() should work as in GCC - when a VLA is freed, memory allocated by alloca() after the VLA was created is also freed. There are some exceptions to this rule when using goto: if a VLA is in scope at the goto, jumping to a label will reset the stack pointer to where it was immediately after the last VLA was created prior to the label, or to what it was before the first VLA was created if the label is outside the scope of any VLA. This means that in some cases combining alloca() and VLAs will free alloca() memory where GCC would not.
2013-04-28 03:39:34 +08:00
ST_DATA int vla_sp_root_loc; /* vla_sp_loc for SP before any VLAs were pushed */
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
ST_DATA int vla_sp_loc; /* Pointer to variable holding location to store stack pointer on the stack when modifying stack pointer */
Improved variable length array support. VLA storage is now freed when it goes out of scope. This makes it possible to use a VLA inside a loop without consuming an unlimited amount of memory. Combining VLAs with alloca() should work as in GCC - when a VLA is freed, memory allocated by alloca() after the VLA was created is also freed. There are some exceptions to this rule when using goto: if a VLA is in scope at the goto, jumping to a label will reset the stack pointer to where it was immediately after the last VLA was created prior to the label, or to what it was before the first VLA was created if the label is outside the scope of any VLA. This means that in some cases combining alloca() and VLAs will free alloca() memory where GCC would not.
2013-04-28 03:39:34 +08:00
tccpp: fix issues, add tests * fix some macro expansion issues * add some pp tests in tests/pp * improved tcc -E output for better diff'ability * remove -dD feature (quirky code, exotic feature, didn't work well) Based partially on ideas / researches from PipCet Some issues remain with VA_ARGS macros (if used in a rather tricky way). Also, to keep it simple, the pp doesn't automtically add any extra spaces to separate tokens which otherwise would form wrong tokens if re-read from tcc -E output (such as '+' '=') GCC does that, other compilers don't. * cleanups - #line 01 "file" / # 01 "file" processing - #pragma comment(lib,"foo") - tcc -E: forward some pragmas to output (pack, comment(lib)) - fix macro parameter list parsing mess from a3fc54345949535524d01319e1ca6378b7c2c201 a715d7143d9d17da17e67fec6af1c01409a71a31 (some coffee might help, next time ;) - introduce TOK_PPSTR - to have character constants as written in the file (similar to TOK_PPNUM) - allow '\' appear in macros - new functions begin/end_macro to: - fix switching macro levels during expansion - allow unget_tok to unget more than one tok - slight speedup by using bitflags in isidnum_table Also: - x86_64.c : fix decl after statements - i386-gen,c : fix a vstack leak with VLA on windows - configure/Makefile : build on windows (MSYS) was broken - tcc_warning: fflush stderr to keep output order (win32)
2015-05-09 20:29:39 +08:00
ST_DATA SValue __vstack[1+VSTACK_SIZE], *vtop, *pvtop;
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_DATA int const_wanted; /* true if constant wanted */
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
ST_DATA int nocode_wanted; /* no code generation wanted */
#define NODATA_WANTED (nocode_wanted > 0) /* no static data output wanted either */
#define STATIC_DATA_WANTED (nocode_wanted & 0xC0000000) /* only static data output */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_DATA int global_expr; /* true if compound literals must be allocated globally (used during initializers parsing */
ST_DATA CType func_vt; /* current function return type (used by return instruction) */
Fix struct ret in variadic fct with ARM hardfloat The procedure calling standard for ARM architecture mandate the use of the base standard for variadic function. Therefore, hgen float aggregate must be returned via stack when greater than 4 bytes and via core registers else in case of variadic function. This patch improve gfunc_sret() to take into account whether the function is variadic or not and make use of gfunc_sret() return value to determine whether to pass a structure via stack in gfunc_prolog(). It also take advantage of knowing if a function is variadic or not move float result value from VFP register to core register in gfunc_epilog().
2014-01-06 22:27:39 +08:00
ST_DATA int func_var; /* true if current function is variadic (used by return instruction) */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_DATA int func_vc;
ST_DATA int last_line_num, last_ind, func_ind; /* debug last line number and pc */
tccpp: fix issues, add tests * fix some macro expansion issues * add some pp tests in tests/pp * improved tcc -E output for better diff'ability * remove -dD feature (quirky code, exotic feature, didn't work well) Based partially on ideas / researches from PipCet Some issues remain with VA_ARGS macros (if used in a rather tricky way). Also, to keep it simple, the pp doesn't automtically add any extra spaces to separate tokens which otherwise would form wrong tokens if re-read from tcc -E output (such as '+' '=') GCC does that, other compilers don't. * cleanups - #line 01 "file" / # 01 "file" processing - #pragma comment(lib,"foo") - tcc -E: forward some pragmas to output (pack, comment(lib)) - fix macro parameter list parsing mess from a3fc54345949535524d01319e1ca6378b7c2c201 a715d7143d9d17da17e67fec6af1c01409a71a31 (some coffee might help, next time ;) - introduce TOK_PPSTR - to have character constants as written in the file (similar to TOK_PPNUM) - allow '\' appear in macros - new functions begin/end_macro to: - fix switching macro levels during expansion - allow unget_tok to unget more than one tok - slight speedup by using bitflags in isidnum_table Also: - x86_64.c : fix decl after statements - i386-gen,c : fix a vstack leak with VLA on windows - configure/Makefile : build on windows (MSYS) was broken - tcc_warning: fflush stderr to keep output order (win32)
2015-05-09 20:29:39 +08:00
ST_DATA const char *funcname;
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
ST_DATA int g_debug;
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
ST_DATA CType char_pointer_type, func_old_type, int_type, size_type, ptrdiff_type;
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
ST_DATA struct switch_t {
struct case_t {
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
int64_t v1, v2;
int sym;
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
} **p; int n; /* list of case ranges */
int def_sym; /* default symbol */
} *cur_switch; /* current switch */
optimize the generated code when save_reg is required Before this patch, save_reg can't reuse the temporary local variable created before to save register. It may consume a lot of stack memory. this patch make save_reg reuse the temporary local variable.
2019-01-10 03:32:23 +08:00
#define MAX_TEMP_LOCAL_VARIABLE_NUMBER 0x4
/*list of temporary local variables on the stack in current function. */
ST_DATA struct temp_local_variable {
int location; //offset on stack. Svalue.c.i
short size;
short align;
} arr_temp_local_vars[MAX_TEMP_LOCAL_VARIABLE_NUMBER];
short nb_temp_local_vars;
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
/* ------------------------------------------------------------------------- */
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void gen_cast(CType *type);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
static void gen_cast_s(int t);
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static inline CType *pointed_type(CType *type);
static int is_compatible_types(CType *type1, CType *type2);
static int parse_btype(CType *type, AttributeDef *ad);
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
static CType *type_decl(CType *type, AttributeDef *ad, int *v, int td);
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void parse_expr_type(CType *type);
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
static void init_putv(CType *type, Section *sec, unsigned long c);
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
static void decl_initializer(CType *type, Section *sec, unsigned long c, int flags);
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
static void block(int *bsym, Sym *bcl, int *csym, Sym *ccl, int is_expr);
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, int has_init, int v, int scope);
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
static void decl(int l);
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
static int decl0(int l, int is_for_loop_init, Sym *);
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void expr_eq(void);
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
static void vla_runtime_type_size(CType *type, int *a);
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
static void vla_sp_restore(void);
static void vla_sp_restore_root(void);
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
static int is_compatible_unqualified_types(CType *type1, CType *type2);
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
static inline int64_t expr_const64(void);
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
static void vpush64(int ty, unsigned long long v);
static void vpush(CType *type);
static int gvtst(int inv, int t);
tccpp_new/delete and other cleanups
2016-10-18 05:24:01 +08:00
static void gen_inline_functions(TCCState *s);
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
static void skip_or_save_block(TokenString **str);
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
static void gv_dup(void);
optimize the generated code when save_reg is required Before this patch, save_reg can't reuse the temporary local variable created before to save register. It may consume a lot of stack memory. this patch make save_reg reuse the temporary local variable.
2019-01-10 03:32:23 +08:00
static int get_temp_local_var(int size,int align);
static void clear_temp_local_var_list();
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
static void reset_local_scope(void)
{
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
if (current_cleanups)
tcc_error("ICE current_cleanups");
sym_pop(&all_cleanups, NULL, 0);
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
local_scope = 0;
}
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_INLN int is_float(int t)
{
int bt;
bt = t & VT_BTYPE;
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
return bt == VT_LDOUBLE || bt == VT_DOUBLE || bt == VT_FLOAT || bt == VT_QFLOAT;
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
}
Accept colon separated paths with -L and -I This allows passing colon separated paths to tcc_add_library_path tcc_add_sysinclude_path tcc_add_include_path Also there are new configure variables CONFIG_TCC_LIBPATH CONFIG_TCC_SYSINCLUDE_PATHS which define the lib/sysinclude paths all in one and can be overridden from configure/make For TCC_TARGET_PE semicolons (;) are used as separators Also, \b in the path string is replaced by s->tcc_lib_path (CONFIG_TCCDIR rsp. -B option)
2011-08-01 07:10:36 +08:00
/* we use our own 'finite' function to avoid potential problems with
non standard math libs */
/* XXX: endianness dependent */
ST_FUNC int ieee_finite(double d)
{
be stricter with aliasing Refactoring (no logical changes): - use memcpy in tccgen.c:ieee_finite(double d) - use union to store attribute flags in Sym Makefile: "CFLAGS+=-fno-strict-aliasing" basically not necessary anymore but I left it for now because gcc sometimes behaves unexpectedly without. Also: - configure: back to mode 100755 - tcc.h: remove unused variables tdata/tbss_section - x86_64-gen.c: adjust gfunc_sret for prototype
2014-01-07 21:57:07 +08:00
int p[4];
memcpy(p, &d, sizeof(double));
Accept colon separated paths with -L and -I This allows passing colon separated paths to tcc_add_library_path tcc_add_sysinclude_path tcc_add_include_path Also there are new configure variables CONFIG_TCC_LIBPATH CONFIG_TCC_SYSINCLUDE_PATHS which define the lib/sysinclude paths all in one and can be overridden from configure/make For TCC_TARGET_PE semicolons (;) are used as separators Also, \b in the path string is replaced by s->tcc_lib_path (CONFIG_TCCDIR rsp. -B option)
2011-08-01 07:10:36 +08:00
return ((unsigned)((p[1] | 0x800fffff) + 1)) >> 31;
}
various stuff win32/Makefile ("for cygwin") removed - On cygwin, the normal ./configure && make can be used with either cygwin's "GCC for Win32 Toolchain" ./configure --cross-prefix=i686-w64-mingw32- or with an existing tcc: ./configure --cc=<old-tccdir>/tcc.exe tcctest.c: - exclude test_high_clobbers() on _WIN64 (does not work) tests2/95_bitfield.c: - use 'signed char' for ARM (where default 'char' is unsigned) tests: - remove -I "expr" diff option to allow tests with busybox-diff. libtcc.c, tcc.c: - removed -iwithprefix option. It is supposed to be combined with -iprefix which we don't have either. tccgen.c: - fix assignments and return of 'void', as in void f() { void *p, *q; *p = *q: return *p; } This appears to be allowed but should do nothing. tcc.h, libtcc.c, tccpp.c: - Revert "Introduce VIP sysinclude paths which are always searched first" This reverts commit 1d5e386b0a78393ac6b670c209a185849ec798a1. The patch was giving tcc's system includes priority over -I which is not how it should be. tccelf.c: - add DT_TEXTREL tag only if text relocations are actually used (which is likely not the case on x86_64) - prepare_dynamic_rel(): avoid relocation of unresolved (weak) symbols tccrun.c: - for HAVE_SELINUX, use two mappings to the same (real) file. (it was so once except the RX mapping wasn't used at all). tccpe.c: - fix relocation constant used for x86_64 (by Andrei E. Warentin) - #ifndef _WIN32 do "chmod 755 ..." to get runnable exes on cygwin. tccasm.c: - keep forward asm labels static, otherwise they will endup in dynsym eventually. configure, Makefile: - mingw32: respect ./configure options --bindir --docdir --libdir - allow overriding tcc when building libtcc1.a and libtcc.def with make XTCC=<tcc program to use> - use $(wildcard ...) for install to allow installing just a cross compiler for example make cross-arm make install - use name <target>-libtcc1.a build-tcc.bat: - add options: -clean, -b bindir
2017-10-12 00:13:43 +08:00
/* compiling intel long double natively */
#if (defined __i386__ || defined __x86_64__) \
&& (defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64)
# define TCC_IS_NATIVE_387
#endif
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void test_lvalue(void)
{
if (!(vtop->r & VT_LVAL))
expect("lvalue");
}
tccpp: fix issues, add tests * fix some macro expansion issues * add some pp tests in tests/pp * improved tcc -E output for better diff'ability * remove -dD feature (quirky code, exotic feature, didn't work well) Based partially on ideas / researches from PipCet Some issues remain with VA_ARGS macros (if used in a rather tricky way). Also, to keep it simple, the pp doesn't automtically add any extra spaces to separate tokens which otherwise would form wrong tokens if re-read from tcc -E output (such as '+' '=') GCC does that, other compilers don't. * cleanups - #line 01 "file" / # 01 "file" processing - #pragma comment(lib,"foo") - tcc -E: forward some pragmas to output (pack, comment(lib)) - fix macro parameter list parsing mess from a3fc54345949535524d01319e1ca6378b7c2c201 a715d7143d9d17da17e67fec6af1c01409a71a31 (some coffee might help, next time ;) - introduce TOK_PPSTR - to have character constants as written in the file (similar to TOK_PPNUM) - allow '\' appear in macros - new functions begin/end_macro to: - fix switching macro levels during expansion - allow unget_tok to unget more than one tok - slight speedup by using bitflags in isidnum_table Also: - x86_64.c : fix decl after statements - i386-gen,c : fix a vstack leak with VLA on windows - configure/Makefile : build on windows (MSYS) was broken - tcc_warning: fflush stderr to keep output order (win32)
2015-05-09 20:29:39 +08:00
ST_FUNC void check_vstack(void)
{
if (pvtop != vtop)
tcc_error("internal compiler error: vstack leak (%d)", vtop - pvtop);
}
tccgen: 32bits: fix PTR +/- long long Previously in order to perform a ll+ll operation tcc was trying to 'lexpand' PTR in gen_opl which did not work well. The case: 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; }
2016-10-14 01:21:43 +08:00
/* ------------------------------------------------------------------------- */
/* vstack debugging aid */
#if 0
void pv (const char *lbl, int a, int b)
{
int i;
for (i = a; i < a + b; ++i) {
SValue *p = &vtop[-i];
printf("%s vtop[-%d] : type.t:%04x r:%04x r2:%04x c.i:%d\n",
lbl, i, p->type.t, p->r, p->r2, (int)p->c.i);
}
}
#endif
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
/* ------------------------------------------------------------------------- */
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
/* start of translation unit info */
ST_FUNC void tcc_debug_start(TCCState *s1)
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
{
if (s1->do_debug) {
char buf[512];
/* file info: full path + filename */
section_sym = put_elf_sym(symtab_section, 0, 0,
ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
text_section->sh_num, NULL);
getcwd(buf, sizeof(buf));
#ifdef _WIN32
normalize_slashes(buf);
#endif
pstrcat(buf, sizeof(buf), "/");
put_stabs_r(buf, N_SO, 0, 0,
text_section->data_offset, text_section, section_sym);
put_stabs_r(file->filename, N_SO, 0, 0,
text_section->data_offset, text_section, section_sym);
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
last_ind = 0;
last_line_num = 0;
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
}
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
/* an elf symbol of type STT_FILE must be put so that STB_LOCAL
symbols can be safely used */
put_elf_sym(symtab_section, 0, 0,
ELFW(ST_INFO)(STB_LOCAL, STT_FILE), 0,
SHN_ABS, file->filename);
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
}
/* put end of translation unit info */
ST_FUNC void tcc_debug_end(TCCState *s1)
{
if (!s1->do_debug)
return;
put_stabs_r(NULL, N_SO, 0, 0,
text_section->data_offset, text_section, section_sym);
}
/* generate line number info */
ST_FUNC void tcc_debug_line(TCCState *s1)
{
if (!s1->do_debug)
return;
if ((last_line_num != file->line_num || last_ind != ind)) {
put_stabn(N_SLINE, 0, file->line_num, ind - func_ind);
last_ind = ind;
last_line_num = file->line_num;
}
}
/* put function symbol */
ST_FUNC void tcc_debug_funcstart(TCCState *s1, Sym *sym)
{
char buf[512];
if (!s1->do_debug)
return;
/* stabs info */
/* XXX: we put here a dummy type */
snprintf(buf, sizeof(buf), "%s:%c1",
funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
put_stabs_r(buf, N_FUN, 0, file->line_num, 0,
cur_text_section, sym->c);
/* //gr gdb wants a line at the function */
put_stabn(N_SLINE, 0, file->line_num, 0);
last_ind = 0;
last_line_num = 0;
}
/* put function size */
ST_FUNC void tcc_debug_funcend(TCCState *s1, int size)
{
if (!s1->do_debug)
return;
put_stabn(N_FUN, 0, 0, size);
}
/* ------------------------------------------------------------------------- */
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
ST_FUNC int tccgen_compile(TCCState *s1)
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
{
cur_text_section = NULL;
funcname = "";
anon_sym = SYM_FIRST_ANOM;
section_sym = 0;
const_wanted = 0;
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
nocode_wanted = 0x80000000;
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
/* define some often used types */
int_type.t = VT_INT;
char_pointer_type.t = VT_BYTE;
mk_pointer(&char_pointer_type);
#if PTR_SIZE == 4
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
size_type.t = VT_INT | VT_UNSIGNED;
ptrdiff_type.t = VT_INT;
#elif LONG_SIZE == 4
size_type.t = VT_LLONG | VT_UNSIGNED;
ptrdiff_type.t = VT_LLONG;
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
#else
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
size_type.t = VT_LONG | VT_LLONG | VT_UNSIGNED;
ptrdiff_type.t = VT_LONG | VT_LLONG;
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
#endif
func_old_type.t = VT_FUNC;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
func_old_type.ref = sym_push(SYM_FIELD, &int_type, 0, 0);
func_old_type.ref->f.func_call = FUNC_CDECL;
func_old_type.ref->f.func_type = FUNC_OLD;
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
tcc_debug_start(s1);
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
#ifdef TCC_TARGET_ARM
arm_init(s1);
#endif
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
#ifdef INC_DEBUG
printf("%s: **** new file\n", file->filename);
#endif
parse_flags = PARSE_FLAG_PREPROCESS | PARSE_FLAG_TOK_NUM | PARSE_FLAG_TOK_STR;
next();
decl(VT_CONST);
tccpp_new/delete and other cleanups
2016-10-18 05:24:01 +08:00
gen_inline_functions(s1);
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
check_vstack();
/* end of translation unit info */
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
tcc_debug_end(s1);
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
return 0;
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
}
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
/* ------------------------------------------------------------------------- */
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
ST_FUNC ElfSym *elfsym(Sym *s)
{
if (!s || !s->c)
return NULL;
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
return &((ElfSym *)symtab_section->data)[s->c];
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
}
Spelling fixes in C comments only
2017-05-08 12:38:09 +08:00
/* apply storage attributes to Elf symbol */
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
ST_FUNC void update_storage(Sym *sym)
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
{
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
ElfSym *esym;
int sym_bind, old_sym_bind;
esym = elfsym(sym);
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
if (!esym)
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
return;
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (sym->a.visibility)
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
| sym->a.visibility;
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
TLC for C99 inline implementation there's no need for two new flags in type.t . We just can't use VT_EXTERN as marker if functions are defined or not (like we can for objects), and then can simply implement the rules of C99/C11 by not overwriting VT_STATIC/VT_EXTERN at all but rather only look at them. A function already on the inline list can be forced by removing the VT_INLINE flag, and then linkage follows from some combination of VT_STATIC, VT_EXTERN and VT_INLINE.
2019-06-17 09:34:03 +08:00
if ((sym->type.t & VT_STATIC)
|| (sym->type.t & (VT_EXTERN | VT_INLINE)) == VT_INLINE)
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
sym_bind = STB_LOCAL;
else if (sym->a.weak)
sym_bind = STB_WEAK;
else
sym_bind = STB_GLOBAL;
old_sym_bind = ELFW(ST_BIND)(esym->st_info);
if (sym_bind != old_sym_bind) {
esym->st_info = ELFW(ST_INFO)(sym_bind, ELFW(ST_TYPE)(esym->st_info));
}
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
#ifdef TCC_TARGET_PE
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (sym->a.dllimport)
esym->st_other |= ST_PE_IMPORT;
if (sym->a.dllexport)
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
esym->st_other |= ST_PE_EXPORT;
#endif
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
#if 0
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
printf("storage %s: bind=%c vis=%d exp=%d imp=%d\n",
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
get_tok_str(sym->v, NULL),
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
sym_bind == STB_WEAK ? 'w' : sym_bind == STB_LOCAL ? 'l' : 'g',
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
sym->a.visibility,
sym->a.dllexport,
sym->a.dllimport
);
#endif
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
}
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
/* ------------------------------------------------------------------------- */
/* update sym->c so that it points to an external symbol in section
'section' with value 'value' */
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
ST_FUNC void put_extern_sym2(Sym *sym, int sh_num,
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
addr_t value, unsigned long size,
int can_add_underscore)
{
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
int sym_type, sym_bind, info, other, t;
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
ElfSym *esym;
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
const char *name;
char buf1[256];
#ifdef CONFIG_TCC_BCHECK
char buf[32];
#endif
if (!sym->c) {
name = get_tok_str(sym->v, NULL);
#ifdef CONFIG_TCC_BCHECK
if (tcc_state->do_bounds_check) {
/* XXX: avoid doing that for statics ? */
/* if bound checking is activated, we change some function
names by adding the "__bound" prefix */
switch(sym->v) {
#ifdef TCC_TARGET_PE
/* XXX: we rely only on malloc hooks */
case TOK_malloc:
case TOK_free:
case TOK_realloc:
case TOK_memalign:
case TOK_calloc:
#endif
case TOK_memcpy:
case TOK_memmove:
case TOK_memset:
case TOK_strlen:
case TOK_strcpy:
case TOK_alloca:
strcpy(buf, "__bound_");
strcat(buf, name);
name = buf;
break;
}
}
#endif
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
t = sym->type.t;
if ((t & VT_BTYPE) == VT_FUNC) {
sym_type = STT_FUNC;
} else if ((t & VT_BTYPE) == VT_VOID) {
sym_type = STT_NOTYPE;
} else {
sym_type = STT_OBJECT;
}
TLC for C99 inline implementation there's no need for two new flags in type.t . We just can't use VT_EXTERN as marker if functions are defined or not (like we can for objects), and then can simply implement the rules of C99/C11 by not overwriting VT_STATIC/VT_EXTERN at all but rather only look at them. A function already on the inline list can be forced by removing the VT_INLINE flag, and then linkage follows from some combination of VT_STATIC, VT_EXTERN and VT_INLINE.
2019-06-17 09:34:03 +08:00
if ((t & VT_STATIC) || (t & (VT_EXTERN | VT_INLINE)) == VT_INLINE)
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
sym_bind = STB_LOCAL;
else
sym_bind = STB_GLOBAL;
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
other = 0;
#ifdef TCC_TARGET_PE
if (sym_type == STT_FUNC && sym->type.ref) {
Sym *ref = sym->type.ref;
Implement __attribute__((nodecorate)) Prevent any decoration that would otherwise affect an exported PE function. For example, given the following: __declspec(dllexport) __stdcall int decorated(int arg) { return 0; } __declspec(dllexport) __stdcall __attribute__((nodecorate)) int undecorated(int arg) { return 0; } The following exported functions can now be seen in the DLL: _decorated@4 undecorated The attribute is recognised for all targets but only affects PE codegen. I'm not sure whether this would be useful for other targets; its intended use was to allow the creation of a DLL matching an existing set of signatures.
2018-07-22 07:54:01 +08:00
if (ref->a.nodecorate) {
can_add_underscore = 0;
}
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (ref->f.func_call == FUNC_STDCALL && can_add_underscore) {
sprintf(buf1, "_%s@%d", name, ref->f.func_args * PTR_SIZE);
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
name = buf1;
other |= ST_PE_STDCALL;
can_add_underscore = 0;
}
}
#endif
if (tcc_state->leading_underscore && can_add_underscore) {
buf1[0] = '_';
pstrcpy(buf1 + 1, sizeof(buf1) - 1, name);
name = buf1;
}
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
if (sym->asm_label)
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
name = get_tok_str(sym->asm_label, NULL);
info = ELFW(ST_INFO)(sym_bind, sym_type);
tccgen_begin/end_file This is supposed to make compilation and linking with multiple source files (tcc f1.c f2.S ...) behave just the same as linking object files. tccgen.c:put_extern_sym2(): - use put_elf_sym to enter new symbols unconditionally tccelf.c: - save section state before compilation - disable symbol hashing during compilation - merge symbols and update relocations after compilation tccpe.c: - re-create s1->uw_sym for each compilation (because it may change)
2017-12-13 00:33:37 +08:00
sym->c = put_elf_sym(symtab_section, value, size, info, other, sh_num, name);
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
} else {
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
esym = elfsym(sym);
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
esym->st_value = value;
esym->st_size = size;
esym->st_shndx = sh_num;
}
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
update_storage(sym);
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
}
ST_FUNC void put_extern_sym(Sym *sym, Section *section,
addr_t value, unsigned long size)
{
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
int sh_num = section ? section->sh_num : SHN_UNDEF;
put_extern_sym2(sym, sh_num, value, size, 1);
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
}
/* add a new relocation entry to symbol 'sym' in section 's' */
ST_FUNC void greloca(Section *s, Sym *sym, unsigned long offset, int type,
addr_t addend)
{
int c = 0;
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
if (nocode_wanted && s == cur_text_section)
return;
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
if (sym) {
if (0 == sym->c)
put_extern_sym(sym, NULL, 0, 0);
c = sym->c;
}
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
/* now we can add ELF relocation info */
put_elf_reloca(symtab_section, s, offset, type, c, addend);
}
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 4
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
ST_FUNC void greloc(Section *s, Sym *sym, unsigned long offset, int type)
{
greloca(s, sym, offset, type, 0);
}
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#endif
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
/* ------------------------------------------------------------------------- */
/* symbol allocator */
static Sym *__sym_malloc(void)
{
Sym *sym_pool, *sym, *last_sym;
int i;
sym_pool = tcc_malloc(SYM_POOL_NB * sizeof(Sym));
dynarray_add(&sym_pools, &nb_sym_pools, sym_pool);
last_sym = sym_free_first;
sym = sym_pool;
for(i = 0; i < SYM_POOL_NB; i++) {
sym->next = last_sym;
last_sym = sym;
sym++;
}
sym_free_first = last_sym;
return last_sym;
}
static inline Sym *sym_malloc(void)
{
Sym *sym;
Fix access-after-free with statement expressions The return value of statement expressions might refer to local symbols, so those can't be popped. The old error message always was just a band-aid, and since disabling it for pointer types it wasn't effective anyway. It also never considered that also the vtop->sym member might have referred to such symbols (see the testcase with the local static, that used to segfault). For fixing this (can be seen better with valgrind and SYM_DEBUG) simply leave local symbols of stmt exprs on the stack.
2016-08-15 11:09:31 +08:00
#ifndef SYM_DEBUG
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
sym = sym_free_first;
if (!sym)
sym = __sym_malloc();
sym_free_first = sym->next;
return sym;
Fix access-after-free with statement expressions The return value of statement expressions might refer to local symbols, so those can't be popped. The old error message always was just a band-aid, and since disabling it for pointer types it wasn't effective anyway. It also never considered that also the vtop->sym member might have referred to such symbols (see the testcase with the local static, that used to segfault). For fixing this (can be seen better with valgrind and SYM_DEBUG) simply leave local symbols of stmt exprs on the stack.
2016-08-15 11:09:31 +08:00
#else
sym = tcc_malloc(sizeof(Sym));
return sym;
#endif
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
}
ST_INLN void sym_free(Sym *sym)
{
Fix access-after-free with statement expressions The return value of statement expressions might refer to local symbols, so those can't be popped. The old error message always was just a band-aid, and since disabling it for pointer types it wasn't effective anyway. It also never considered that also the vtop->sym member might have referred to such symbols (see the testcase with the local static, that used to segfault). For fixing this (can be seen better with valgrind and SYM_DEBUG) simply leave local symbols of stmt exprs on the stack.
2016-08-15 11:09:31 +08:00
#ifndef SYM_DEBUG
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
sym->next = sym_free_first;
sym_free_first = sym;
Fix access-after-free with statement expressions The return value of statement expressions might refer to local symbols, so those can't be popped. The old error message always was just a band-aid, and since disabling it for pointer types it wasn't effective anyway. It also never considered that also the vtop->sym member might have referred to such symbols (see the testcase with the local static, that used to segfault). For fixing this (can be seen better with valgrind and SYM_DEBUG) simply leave local symbols of stmt exprs on the stack.
2016-08-15 11:09:31 +08:00
#else
tcc_free(sym);
#endif
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
}
/* push, without hashing */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ST_FUNC Sym *sym_push2(Sym **ps, int v, int t, int c)
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
{
Sym *s;
tccgen: scope levels for local symbols ... for fast redeclaration checks Also, check function parameters too: void foo(int a) { int a; ... } Also, try to fix struct/union/enum's on different scopes: { struct xxx { int x; }; { struct xxx { int y; }; ... }} and some (probably not all) combination with incomplete declarations "struct xxx;" Replaces 2bfedb18675228c3837c23fa523231f55e102c12 and 07d896c8e5d1b46bf4aebd403c78e5f7ffebe02a Fixes cf95ac399cbce1ea8a519f91dd36a5cfd4ea7943
2016-05-05 16:39:09 +08:00
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
s = sym_malloc();
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
memset(s, 0, sizeof *s);
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
s->v = v;
s->type.t = t;
s->c = c;
/* add in stack */
s->prev = *ps;
*ps = s;
return s;
}
/* find a symbol and return its associated structure. 's' is the top
of the symbol stack */
ST_FUNC Sym *sym_find2(Sym *s, int v)
{
while (s) {
if (s->v == v)
return s;
Fix test for macro nesting
2014-04-07 21:12:08 +08:00
else if (s->v == -1)
return NULL;
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
s = s->prev;
}
return NULL;
}
/* structure lookup */
ST_INLN Sym *struct_find(int v)
{
v -= TOK_IDENT;
if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
return NULL;
return table_ident[v]->sym_struct;
}
/* find an identifier */
ST_INLN Sym *sym_find(int v)
{
v -= TOK_IDENT;
if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
return NULL;
return table_ident[v]->sym_identifier;
}
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
static int sym_scope(Sym *s)
{
if (IS_ENUM_VAL (s->type.t))
return s->type.ref->sym_scope;
else
return s->sym_scope;
}
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
/* push a given symbol on the symbol stack */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ST_FUNC Sym *sym_push(int v, CType *type, int r, int c)
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
{
Sym *s, **ps;
TokenSym *ts;
if (local_stack)
ps = &local_stack;
else
ps = &global_stack;
s = sym_push2(ps, v, type->t, c);
s->type.ref = type->ref;
s->r = r;
/* don't record fields or anonymous symbols */
/* XXX: simplify */
if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
/* record symbol in token array */
ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
if (v & SYM_STRUCT)
ps = &ts->sym_struct;
else
ps = &ts->sym_identifier;
s->prev_tok = *ps;
*ps = s;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
s->sym_scope = local_scope;
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
if (s->prev_tok && sym_scope(s->prev_tok) == s->sym_scope)
tccgen: scopes levels for local symbols (update 1) Catch top level redeclarations too. Also fix mistakes in tcctest.c and the tcc sources (win32) showing up now.
2016-05-06 02:04:00 +08:00
tcc_error("redeclaration of '%s'",
get_tok_str(v & ~SYM_STRUCT, NULL));
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
}
return s;
}
/* push a global identifier */
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
ST_FUNC Sym *global_identifier_push(int v, int t, int c)
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
{
Sym *s, **ps;
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
s = sym_push2(&global_stack, v, t, c);
Tidy some code the real difference is in decl0 where we can use external_sym just fine also for function definitions, we don't have to use external_global_sym. Setting VT_EXTERN in external_sym isn't necessary either (the type will have it set if necessary). The rest is tidying: removing unused arguments and moving some code around.
2019-04-18 09:36:39 +08:00
s->r = VT_CONST | VT_SYM;
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
/* don't record anonymous symbol */
if (v < SYM_FIRST_ANOM) {
ps = &table_ident[v - TOK_IDENT]->sym_identifier;
Tidy some code the real difference is in decl0 where we can use external_sym just fine also for function definitions, we don't have to use external_global_sym. Setting VT_EXTERN in external_sym isn't necessary either (the type will have it set if necessary). The rest is tidying: removing unused arguments and moving some code around.
2019-04-18 09:36:39 +08:00
/* modify the top most local identifier, so that sym_identifier will
point to 's' when popped; happens when called from inline asm */
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
while (*ps != NULL && (*ps)->sym_scope)
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ps = &(*ps)->prev_tok;
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
s->prev_tok = *ps;
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
*ps = s;
}
return s;
}
Fix access-after-free with statement expressions The return value of statement expressions might refer to local symbols, so those can't be popped. The old error message always was just a band-aid, and since disabling it for pointer types it wasn't effective anyway. It also never considered that also the vtop->sym member might have referred to such symbols (see the testcase with the local static, that used to segfault). For fixing this (can be seen better with valgrind and SYM_DEBUG) simply leave local symbols of stmt exprs on the stack.
2016-08-15 11:09:31 +08:00
/* pop symbols until top reaches 'b'. If KEEP is non-zero don't really
pop them yet from the list, but do remove them from the token array. */
ST_FUNC void sym_pop(Sym **ptop, Sym *b, int keep)
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
{
Sym *s, *ss, **ps;
TokenSym *ts;
int v;
s = *ptop;
while(s != b) {
ss = s->prev;
v = s->v;
/* remove symbol in token array */
/* XXX: simplify */
if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
if (v & SYM_STRUCT)
ps = &ts->sym_struct;
else
ps = &ts->sym_identifier;
*ps = s->prev_tok;
}
Fix access-after-free with statement expressions The return value of statement expressions might refer to local symbols, so those can't be popped. The old error message always was just a band-aid, and since disabling it for pointer types it wasn't effective anyway. It also never considered that also the vtop->sym member might have referred to such symbols (see the testcase with the local static, that used to segfault). For fixing this (can be seen better with valgrind and SYM_DEBUG) simply leave local symbols of stmt exprs on the stack.
2016-08-15 11:09:31 +08:00
if (!keep)
sym_free(s);
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
s = ss;
}
Fix access-after-free with statement expressions The return value of statement expressions might refer to local symbols, so those can't be popped. The old error message always was just a band-aid, and since disabling it for pointer types it wasn't effective anyway. It also never considered that also the vtop->sym member might have referred to such symbols (see the testcase with the local static, that used to segfault). For fixing this (can be seen better with valgrind and SYM_DEBUG) simply leave local symbols of stmt exprs on the stack.
2016-08-15 11:09:31 +08:00
if (!keep)
*ptop = b;
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
}
/* ------------------------------------------------------------------------- */
static void vsetc(CType *type, int r, CValue *vc)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int v;
if (vtop >= vstack + (VSTACK_SIZE - 1))
misc. fixes - tccgen: error out for cast to void, as in void foo(void) { return 1; } This avoids an assertion failure in x86_64-gen.c, also. also fix tests2/03_struct.c accordingly - Error: "memory full" - be more specific - Makefiles: remove circular dependencies, lookup tcctest.c from VPATH - tcc.h: cleanup lib, include, crt and libgcc search paths" avoid duplication or trailing slashes with no CONFIG_MULTIARCHDIR (as from 9382d6f1a0e2d0104a82ed805207d9e742c6b068) - tcc.h: remove ";{B}" from PE search path in ce5e12c2f950052d8109b6b7a56d900547705c08 James Lyon wrote: "... I'm not sure this is the right way to fix this problem." And the answer is: No, please. (copying libtcc1.a for tests instead) - win32/build_tcc.bat: do not move away a versioned file
2014-01-07 02:56:26 +08:00
tcc_error("memory full (vstack)");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* cannot let cpu flags if other instruction are generated. Also
avoid leaving VT_JMP anywhere except on the top of the stack
Fix some code suppression fallout Some more subtle issues with code suppression: - outputting asms but not their operand setup is broken - but global asms must always be output - statement expressions are transparent to code suppression - vtop can't be transformed from VT_CMP/VT_JMP when nocode_wanted Also remove .exe files from tests2 if they don't fail.
2016-12-20 11:49:22 +08:00
because it would complicate the code generator.
Don't do this when nocode_wanted. vtop might come from
!nocode_wanted regions (see 88_codeopt.c) and transforming
it to a register without actually generating code is wrong
as their value might still be used for real. All values
we push under nocode_wanted will eventually be popped
again, so that the VT_CMP/VT_JMP value will be in vtop
tccgen: factor out gfunc_return Also: - on windows i386 and x86-64, structures of size <= 8 are NOT returned in registers if size is not one of 1,2,4,8. - cleanup: put all tv-push/pop/swap/rot into one place
2017-02-09 02:45:31 +08:00
when code is unsuppressed again.
Same logic below in vswap(); */
Fix some code suppression fallout Some more subtle issues with code suppression: - outputting asms but not their operand setup is broken - but global asms must always be output - statement expressions are transparent to code suppression - vtop can't be transformed from VT_CMP/VT_JMP when nocode_wanted Also remove .exe files from tests2 if they don't fail.
2016-12-20 11:49:22 +08:00
if (vtop >= vstack && !nocode_wanted) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
v = vtop->r & VT_VALMASK;
if (v == VT_CMP || (v & ~1) == VT_JMP)
gv(RC_INT);
}
tccgen: factor out gfunc_return Also: - on windows i386 and x86-64, structures of size <= 8 are NOT returned in registers if size is not one of 1,2,4,8. - cleanup: put all tv-push/pop/swap/rot into one place
2017-02-09 02:45:31 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop++;
vtop->type = *type;
vtop->r = r;
vtop->r2 = VT_CONST;
vtop->c = *vc;
Support local register variables Similar to GCC a local asm register variable enforces the use of a specified register in asm operands (and doesn't otherwise matter). Works only if the variable is directly mentioned as operand. For that we now generally store a backpointer from an SValue to a Sym when the SValue was the result of unary() parsing a symbol identifier.
2016-10-06 10:05:30 +08:00
vtop->sym = NULL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen: factor out gfunc_return Also: - on windows i386 and x86-64, structures of size <= 8 are NOT returned in registers if size is not one of 1,2,4,8. - cleanup: put all tv-push/pop/swap/rot into one place
2017-02-09 02:45:31 +08:00
ST_FUNC void vswap(void)
{
SValue tmp;
/* cannot vswap cpu flags. See comment at vsetc() above */
if (vtop >= vstack && !nocode_wanted) {
int v = vtop->r & VT_VALMASK;
if (v == VT_CMP || (v & ~1) == VT_JMP)
gv(RC_INT);
}
tmp = vtop[0];
vtop[0] = vtop[-1];
vtop[-1] = tmp;
}
/* pop stack value */
ST_FUNC void vpop(void)
{
int v;
v = vtop->r & VT_VALMASK;
#if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
/* for x86, we need to pop the FP stack */
if (v == TREG_ST0) {
o(0xd8dd); /* fstp %st(0) */
} else
#endif
if (v == VT_JMP || v == VT_JMPI) {
/* need to put correct jump if && or || without test */
gsym(vtop->c.i);
}
vtop--;
}
Correctly support all unary expression with sizeof Unary expression can start with a parenthesis. Thus, the current test to detect which sizeof form is being parsed is inaccurate. This patch makes tcc able to handle things like sizeof (x)[1] where x is declared as char x[5]; wich is a valid unary expression
2010-04-11 07:53:40 +08:00
/* push constant of type "type" with useless value */
add missing prototypes
2014-04-10 17:53:54 +08:00
ST_FUNC void vpush(CType *type)
Correctly support all unary expression with sizeof Unary expression can start with a parenthesis. Thus, the current test to detect which sizeof form is being parsed is inaccurate. This patch makes tcc able to handle things like sizeof (x)[1] where x is declared as char x[5]; wich is a valid unary expression
2010-04-11 07:53:40 +08:00
{
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
vset(type, VT_CONST, 0);
Correctly support all unary expression with sizeof Unary expression can start with a parenthesis. Thus, the current test to detect which sizeof form is being parsed is inaccurate. This patch makes tcc able to handle things like sizeof (x)[1] where x is declared as char x[5]; wich is a valid unary expression
2010-04-11 07:53:40 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* push integer constant */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void vpushi(int v)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
CValue cval;
cval.i = v;
vsetc(&int_type, VT_CONST, &cval);
}
Make sizeof() be of type size_t This matters when sizeof is directly used in arithmetic, ala "uintptr_t t; t &= -sizeof(long)" (for alignment). When sizeof isn't size_t (as it's specified to be) this masking will truncate the high bits of the uintptr_t object (if uintptr_t is larger than uint).
2012-04-16 07:13:25 +08:00
/* push a pointer sized constant */
tccgen: x86_64: fix garbage in the SValue upper bits This was going wrong (case TOK_LAND in unary: computed labels) - vset(&s->type, VT_CONST | VT_SYM, 0); - vtop->sym = s; This does the right thing and is shorter: + vpushsym(&s->type, s); Test case was: int main(int argc, char **argv) { int x; static void *label_return = &&lbl_return; printf("label_return = %p\n", label_return); goto *label_return; //<<<<< here segfault on linux X86_64 without the memset on vset printf("unreachable\n"); lbl_return: return 0; } Also:: - Rename "void* CValue.ptr" to more usable "addr_t ptr_offset" and start to use it in obvious cases. - use __attribute__ ((noreturn)) only with gnu compiler - Revert CValue memsets ("After several days searching ...") commit 4bc83ac3933efa565ae3326b55fcd711b63c073d Doesn't mean that the vsetX/vpush thingy isn't brittle and there still might be bugs as to differences in how the CValue union was set and is then interpreted later on. However the big memset hammer was just too slow (-3% overall).
2014-04-05 02:18:39 +08:00
static void vpushs(addr_t v)
Make sizeof() be of type size_t This matters when sizeof is directly used in arithmetic, ala "uintptr_t t; t &= -sizeof(long)" (for alignment). When sizeof isn't size_t (as it's specified to be) this masking will truncate the high bits of the uintptr_t object (if uintptr_t is larger than uint).
2012-04-16 07:13:25 +08:00
{
CValue cval;
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
cval.i = v;
Make sizeof() be of type size_t This matters when sizeof is directly used in arithmetic, ala "uintptr_t t; t &= -sizeof(long)" (for alignment). When sizeof isn't size_t (as it's specified to be) this masking will truncate the high bits of the uintptr_t object (if uintptr_t is larger than uint).
2012-04-16 07:13:25 +08:00
vsetc(&size_type, VT_CONST, &cval);
}
Add nan, snan and inf float constants
2010-05-06 08:19:00 +08:00
/* push arbitrary 64bit constant */
add missing prototypes
2014-04-10 17:53:54 +08:00
ST_FUNC void vpush64(int ty, unsigned long long v)
Add nan, snan and inf float constants
2010-05-06 08:19:00 +08:00
{
After several days searching why my code refactoring to remove globals was crashing, I found the problem it was because CValue stack variables have rubish as it inital values and assigning to a member that is smaller than the big union item and trying to recover it later as a different member gives bak garbage. ST_FUNC void vset(TCCState* tcc_state, CType *type, int r, int v) { CValue cval; memset(&cval, 0, sizeof(CValue)); cval.i = v; //,<<<<<<<<<<< here is the main bug that mix with garbage vsetc(tcc_state, type, r, &cval); } /* store a value or an expression directly in global data or in local array */ static void init_putv(TCCState* tcc_state, CType *type, Section *sec, unsigned long c, int v, int expr_type) { ... case VT_PTR: if (tcc_state->tccgen_vtop->r & VT_SYM) { greloc(tcc_state, sec, tcc_state->tccgen_vtop->sym, c, R_DATA_PTR); } //<<< on the next line is where we try to get the assigned value to cvalue.i as cvalue.ull *(addr_t *)ptr |= (tcc_state->tccgen_vtop->c.ull & bit_mask) << bit_pos; break; Also this patch makes vla tests pass on linux 32 bits
2014-03-27 04:14:39 +08:00
CValue cval;
tccgen: x86_64: fix garbage in the SValue upper bits This was going wrong (case TOK_LAND in unary: computed labels) - vset(&s->type, VT_CONST | VT_SYM, 0); - vtop->sym = s; This does the right thing and is shorter: + vpushsym(&s->type, s); Test case was: int main(int argc, char **argv) { int x; static void *label_return = &&lbl_return; printf("label_return = %p\n", label_return); goto *label_return; //<<<<< here segfault on linux X86_64 without the memset on vset printf("unreachable\n"); lbl_return: return 0; } Also:: - Rename "void* CValue.ptr" to more usable "addr_t ptr_offset" and start to use it in obvious cases. - use __attribute__ ((noreturn)) only with gnu compiler - Revert CValue memsets ("After several days searching ...") commit 4bc83ac3933efa565ae3326b55fcd711b63c073d Doesn't mean that the vsetX/vpush thingy isn't brittle and there still might be bugs as to differences in how the CValue union was set and is then interpreted later on. However the big memset hammer was just too slow (-3% overall).
2014-04-05 02:18:39 +08:00
CType ctype;
Add nan, snan and inf float constants
2010-05-06 08:19:00 +08:00
ctype.t = ty;
tcc.h: declare CValue.tab[LDOUBLE_SIZE/4] Should fix some warnings wrt. access out of array bounds. tccelf.c: fix "static function unused" warning x86_64-gen.c: fix "ctype.ref uninitialzed" warning and cleanup tcc-win32.txt: remove obsolete limitation notes.
2013-02-09 02:07:11 +08:00
ctype.ref = NULL;
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
cval.i = v;
Add nan, snan and inf float constants
2010-05-06 08:19:00 +08:00
vsetc(&ctype, VT_CONST, &cval);
}
tcc.h: declare CValue.tab[LDOUBLE_SIZE/4] Should fix some warnings wrt. access out of array bounds. tccelf.c: fix "static function unused" warning x86_64-gen.c: fix "ctype.ref uninitialzed" warning and cleanup tcc-win32.txt: remove obsolete limitation notes.
2013-02-09 02:07:11 +08:00
/* push long long constant */
static inline void vpushll(long long v)
{
vpush64(VT_LLONG, v);
}
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ST_FUNC void vset(CType *type, int r, int v)
tccgen: factor out gfunc_return Also: - on windows i386 and x86-64, structures of size <= 8 are NOT returned in registers if size is not one of 1,2,4,8. - cleanup: put all tv-push/pop/swap/rot into one place
2017-02-09 02:45:31 +08:00
{
CValue cval;
cval.i = v;
vsetc(type, r, &cval);
}
static void vseti(int r, int v)
{
CType type;
type.t = VT_INT;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
type.ref = NULL;
tccgen: factor out gfunc_return Also: - on windows i386 and x86-64, structures of size <= 8 are NOT returned in registers if size is not one of 1,2,4,8. - cleanup: put all tv-push/pop/swap/rot into one place
2017-02-09 02:45:31 +08:00
vset(&type, r, v);
}
ST_FUNC void vpushv(SValue *v)
{
if (vtop >= vstack + (VSTACK_SIZE - 1))
tcc_error("memory full (vstack)");
vtop++;
*vtop = *v;
}
static void vdup(void)
{
vpushv(vtop);
}
/* rotate n first stack elements to the bottom
I1 ... In -> I2 ... In I1 [top is right]
*/
ST_FUNC void vrotb(int n)
{
int i;
SValue tmp;
tmp = vtop[-n + 1];
for(i=-n+1;i!=0;i++)
vtop[i] = vtop[i+1];
vtop[0] = tmp;
}
/* rotate the n elements before entry e towards the top
I1 ... In ... -> In I1 ... I(n-1) ... [top is right]
*/
ST_FUNC void vrote(SValue *e, int n)
{
int i;
SValue tmp;
tmp = *e;
for(i = 0;i < n - 1; i++)
e[-i] = e[-i - 1];
e[-n + 1] = tmp;
}
/* rotate n first stack elements to the top
I1 ... In -> In I1 ... I(n-1) [top is right]
*/
ST_FUNC void vrott(int n)
{
vrote(vtop, n);
}
Fix Fixes for PE x86_64 for fail in code Applying 64bit relocs assumes that the CVal is initialized to zero for the whole 64bit. Consolidate this a bit, at the same time zeroing the .ull member more consistently when needed. Fixes segfault on x86_64-linux using global vars in tcctest.c.
2014-01-12 06:42:58 +08:00
/* push a symbol value of TYPE */
static inline void vpushsym(CType *type, Sym *sym)
{
CValue cval;
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
cval.i = 0;
Fix Fixes for PE x86_64 for fail in code Applying 64bit relocs assumes that the CVal is initialized to zero for the whole 64bit. Consolidate this a bit, at the same time zeroing the .ull member more consistently when needed. Fixes segfault on x86_64-linux using global vars in tcctest.c.
2014-01-12 06:42:58 +08:00
vsetc(type, VT_CONST | VT_SYM, &cval);
vtop->sym = sym;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* Return a static symbol pointing to a section */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC Sym *get_sym_ref(CType *type, Section *sec, unsigned long offset, unsigned long size)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int v;
Sym *sym;
v = anon_sym++;
Tidy some code the real difference is in decl0 where we can use external_sym just fine also for function definitions, we don't have to use external_global_sym. Setting VT_EXTERN in external_sym isn't necessary either (the type will have it set if necessary). The rest is tidying: removing unused arguments and moving some code around.
2019-04-18 09:36:39 +08:00
sym = sym_push(v, type, VT_CONST | VT_SYM, 0);
sym->type.t |= VT_STATIC;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
put_extern_sym(sym, sec, offset, size);
return sym;
}
/* push a reference to a section offset by adding a dummy symbol */
static void vpush_ref(CType *type, Section *sec, unsigned long offset, unsigned long size)
{
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
vpushsym(type, get_sym_ref(type, sec, offset, size));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
/* define a new external reference to a symbol 'v' of type 'u' */
Tidy some code the real difference is in decl0 where we can use external_sym just fine also for function definitions, we don't have to use external_global_sym. Setting VT_EXTERN in external_sym isn't necessary either (the type will have it set if necessary). The rest is tidying: removing unused arguments and moving some code around.
2019-04-18 09:36:39 +08:00
ST_FUNC Sym *external_global_sym(int v, CType *type)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Sym *s;
s = sym_find(v);
if (!s) {
/* push forward reference */
s = global_identifier_push(v, type->t | VT_EXTERN, 0);
s->type.ref = type->ref;
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
} else if (IS_ASM_SYM(s)) {
s->type.t = type->t | (s->type.t & VT_EXTERN);
s->type.ref = type->ref;
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
update_storage(s);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
return s;
}
Fix more attribute placements when parsing the type in this cast: (int (__attribute__(X) *)(int))foo we ignored the attribute, which matters if it's e.g. a 'stdcall' attribute on the function pointer. Only this particular placement was misparsed. Putting the attribute after the '*' or outside the inner parens worked. This idiom seems to be used on SQLite, perhaps this fixes a compilation problem on win32 with that.
2019-01-01 05:00:31 +08:00
/* Merge symbol attributes. */
static void merge_symattr(struct SymAttr *sa, struct SymAttr *sa1)
{
if (sa1->aligned && !sa->aligned)
sa->aligned = sa1->aligned;
sa->packed |= sa1->packed;
sa->weak |= sa1->weak;
if (sa1->visibility != STV_DEFAULT) {
int vis = sa->visibility;
if (vis == STV_DEFAULT
|| vis > sa1->visibility)
vis = sa1->visibility;
sa->visibility = vis;
}
sa->dllexport |= sa1->dllexport;
sa->nodecorate |= sa1->nodecorate;
sa->dllimport |= sa1->dllimport;
}
/* Merge function attributes. */
static void merge_funcattr(struct FuncAttr *fa, struct FuncAttr *fa1)
{
if (fa1->func_call && !fa->func_call)
fa->func_call = fa1->func_call;
if (fa1->func_type && !fa->func_type)
fa->func_type = fa1->func_type;
if (fa1->func_args && !fa->func_args)
fa->func_args = fa1->func_args;
}
/* Merge attributes. */
static void merge_attr(AttributeDef *ad, AttributeDef *ad1)
{
merge_symattr(&ad->a, &ad1->a);
merge_funcattr(&ad->f, &ad1->f);
if (ad1->section)
ad->section = ad1->section;
if (ad1->alias_target)
ad->alias_target = ad1->alias_target;
if (ad1->asm_label)
ad->asm_label = ad1->asm_label;
if (ad1->attr_mode)
ad->attr_mode = ad1->attr_mode;
}
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
/* Merge some type attributes. */
static void patch_type(Sym *sym, CType *type)
{
TLC for C99 inline implementation there's no need for two new flags in type.t . We just can't use VT_EXTERN as marker if functions are defined or not (like we can for objects), and then can simply implement the rules of C99/C11 by not overwriting VT_STATIC/VT_EXTERN at all but rather only look at them. A function already on the inline list can be forced by removing the VT_INLINE flag, and then linkage follows from some combination of VT_STATIC, VT_EXTERN and VT_INLINE.
2019-06-17 09:34:03 +08:00
if ((!(type->t & VT_EXTERN) || IS_ENUM_VAL(sym->type.t))
&& (type->t & VT_BTYPE) != VT_FUNC) {
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
if (!(sym->type.t & VT_EXTERN))
tcc_error("redefinition of '%s'", get_tok_str(sym->v, NULL));
sym->type.t &= ~VT_EXTERN;
}
if (IS_ASM_SYM(sym)) {
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
/* stay static if both are static */
sym->type.t = type->t & (sym->type.t | ~VT_STATIC);
sym->type.ref = type->ref;
}
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
if (!is_compatible_types(&sym->type, type)) {
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
tcc_error("incompatible types for redefinition of '%s'",
get_tok_str(sym->v, NULL));
} else if ((sym->type.t & VT_BTYPE) == VT_FUNC) {
int static_proto = sym->type.t & VT_STATIC;
/* warn if static follows non-static function declaration */
Make mingw work again my last inline changes caused parameter names to be overwritten always (as VT_EXTERN now doesn't mark the current def anymore), leading to a compile error when including windows.h. Rework this. Also silence a warning that currently happens for mingw, which is written with gnu-inline behaviour in mind. Our work-arounds of using "static inline" actually create invalid C (which we warn about). Until we implement this properly, just silence the warning.
2019-06-18 00:28:56 +08:00
if ((type->t & VT_STATIC) && !static_proto
/* XXX this test for inline shouldn't be here. Until we
implement gnu-inline mode again it silences a warning for
mingw caused by our workarounds. */
&& !((type->t | sym->type.t) & VT_INLINE))
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
tcc_warning("static storage ignored for redefinition of '%s'",
get_tok_str(sym->v, NULL));
TLC for C99 inline implementation there's no need for two new flags in type.t . We just can't use VT_EXTERN as marker if functions are defined or not (like we can for objects), and then can simply implement the rules of C99/C11 by not overwriting VT_STATIC/VT_EXTERN at all but rather only look at them. A function already on the inline list can be forced by removing the VT_INLINE flag, and then linkage follows from some combination of VT_STATIC, VT_EXTERN and VT_INLINE.
2019-06-17 09:34:03 +08:00
/* Force external definition if unequal inline specifier
or an explicit extern one. */
if ((type->t & VT_INLINE) != (sym->type.t & VT_INLINE)
|| (type->t | sym->type.t) & VT_EXTERN) {
type->t &= ~VT_INLINE;
sym->type.t &= ~VT_INLINE;
}
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
if (0 == (type->t & VT_EXTERN)) {
Make mingw work again my last inline changes caused parameter names to be overwritten always (as VT_EXTERN now doesn't mark the current def anymore), leading to a compile error when including windows.h. Rework this. Also silence a warning that currently happens for mingw, which is written with gnu-inline behaviour in mind. Our work-arounds of using "static inline" actually create invalid C (which we warn about). Until we implement this properly, just silence the warning.
2019-06-18 00:28:56 +08:00
/* put complete type, use static from prototype, but don't
overwrite type.ref, it might contain parameter names */
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
sym->type.t = (type->t & ~VT_STATIC) | static_proto;
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
}
} else {
if ((sym->type.t & VT_ARRAY) && type->ref->c >= 0) {
/* set array size if it was omitted in extern declaration */
if (sym->type.ref->c < 0)
sym->type.ref->c = type->ref->c;
else if (sym->type.ref->c != type->ref->c)
tcc_error("conflicting type for '%s'", get_tok_str(sym->v, NULL));
}
if ((type->t ^ sym->type.t) & VT_STATIC)
tcc_warning("storage mismatch for redefinition of '%s'",
get_tok_str(sym->v, NULL));
}
}
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
/* Merge some storage attributes. */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
static void patch_storage(Sym *sym, AttributeDef *ad, CType *type)
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
{
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
if (type)
patch_type(sym, type);
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
#ifdef TCC_TARGET_PE
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (sym->a.dllimport != ad->a.dllimport)
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
tcc_error("incompatible dll linkage for redefinition of '%s'",
get_tok_str(sym->v, NULL));
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
#endif
Fix more attribute placements when parsing the type in this cast: (int (__attribute__(X) *)(int))foo we ignored the attribute, which matters if it's e.g. a 'stdcall' attribute on the function pointer. Only this particular placement was misparsed. Putting the attribute after the '*' or outside the inner parens worked. This idiom seems to be used on SQLite, perhaps this fixes a compilation problem on win32 with that.
2019-01-01 05:00:31 +08:00
merge_symattr(&sym->a, &ad->a);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (ad->asm_label)
sym->asm_label = ad->asm_label;
update_storage(sym);
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
}
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
/* define a new external reference to a symbol 'v' */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
static Sym *external_sym(int v, CType *type, int r, AttributeDef *ad)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Sym *s;
s = sym_find(v);
Fix 98_al_ax_extend.c compile error this test is run only on i386 so its failing went unnoticed for a while, since 1fd3709379. IS_ASM_SYMs should not be tested for conflicting types, the C typing overrides.
2019-04-07 08:44:32 +08:00
if (!s || (!IS_ASM_SYM(s) && !(s->type.t & VT_EXTERN)
Deal with more tentative definitions see testcase.
2019-06-18 00:52:49 +08:00
&& (!(type->t & VT_EXTERN) || s->sym_scope)
Fix 98_al_ax_extend.c compile error this test is run only on i386 so its failing went unnoticed for a while, since 1fd3709379. IS_ASM_SYMs should not be tested for conflicting types, the C typing overrides.
2019-04-07 08:44:32 +08:00
&& (s->type.t & VT_BTYPE) != VT_FUNC)) {
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
if (s && !is_compatible_types(&s->type, type))
tcc_error("conflicting types for '%s'", get_tok_str(s->v, NULL));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* push forward reference */
s = sym_push(v, type, r | VT_CONST | VT_SYM, 0);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
s->a = ad->a;
Don't drop asm_label hack on external symbols for win32 DLL exports
2019-05-15 03:34:28 +08:00
s->asm_label = ad->asm_label;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
s->sym_scope = 0;
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
} else {
if (s->type.ref == func_old_type.ref) {
s->type.ref = type->ref;
s->r = r | VT_CONST | VT_SYM;
s->type.t |= VT_EXTERN;
}
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
patch_storage(s, ad, type);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
return s;
}
/* push a reference to global symbol v */
build from multiple objects: fix other targets
2009-12-21 03:33:41 +08:00
ST_FUNC void vpush_global_sym(CType *type, int v)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Tidy some code the real difference is in decl0 where we can use external_sym just fine also for function definitions, we don't have to use external_global_sym. Setting VT_EXTERN in external_sym isn't necessary either (the type will have it set if necessary). The rest is tidying: removing unused arguments and moving some code around.
2019-04-18 09:36:39 +08:00
vpushsym(type, external_global_sym(v, type));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen: arm/i386: save_reg_upstack tccgen.c:gv() when loading long long from lvalue, before was saving all registers which caused problems in the arm function call register parameter preparation, as with void foo(long long y, int x); int main(void) { unsigned int *xx[1], x; unsigned long long *yy[1], y; foo(**yy, **xx); return 0; } Now only the modified register is saved if necessary, as in this case where it is used to store the result of the post-inc: long long *p, v, **pp; v = 1; p = &v; p[0]++; printf("another long long spill test : %lld\n", *p); i386-gen.c : - found a similar problem with TOK_UMULL caused by the vstack juggle in tccgen:gen_opl() (bug seen only when using EBX as 4th register)
2016-10-04 23:36:51 +08:00
/* save registers up to (vtop - n) stack entry */
ST_FUNC void save_regs(int n)
{
SValue *p, *p1;
for(p = vstack, p1 = vtop - n; p <= p1; p++)
save_reg(p->r);
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* save r to the memory stack, and mark it as being free */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void save_reg(int r)
tccgen: arm/i386: save_reg_upstack tccgen.c:gv() when loading long long from lvalue, before was saving all registers which caused problems in the arm function call register parameter preparation, as with void foo(long long y, int x); int main(void) { unsigned int *xx[1], x; unsigned long long *yy[1], y; foo(**yy, **xx); return 0; } Now only the modified register is saved if necessary, as in this case where it is used to store the result of the post-inc: long long *p, v, **pp; v = 1; p = &v; p[0]++; printf("another long long spill test : %lld\n", *p); i386-gen.c : - found a similar problem with TOK_UMULL caused by the vstack juggle in tccgen:gen_opl() (bug seen only when using EBX as 4th register)
2016-10-04 23:36:51 +08:00
{
save_reg_upstack(r, 0);
}
/* save r to the memory stack, and mark it as being free,
if seen up to (vtop - n) stack entry */
ST_FUNC void save_reg_upstack(int r, int n)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int l, saved, size, align;
tccgen: arm/i386: save_reg_upstack tccgen.c:gv() when loading long long from lvalue, before was saving all registers which caused problems in the arm function call register parameter preparation, as with void foo(long long y, int x); int main(void) { unsigned int *xx[1], x; unsigned long long *yy[1], y; foo(**yy, **xx); return 0; } Now only the modified register is saved if necessary, as in this case where it is used to store the result of the post-inc: long long *p, v, **pp; v = 1; p = &v; p[0]++; printf("another long long spill test : %lld\n", *p); i386-gen.c : - found a similar problem with TOK_UMULL caused by the vstack juggle in tccgen:gen_opl() (bug seen only when using EBX as 4th register)
2016-10-04 23:36:51 +08:00
SValue *p, *p1, sv;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
CType *type;
tccgen: arm/i386: save_reg_upstack tccgen.c:gv() when loading long long from lvalue, before was saving all registers which caused problems in the arm function call register parameter preparation, as with void foo(long long y, int x); int main(void) { unsigned int *xx[1], x; unsigned long long *yy[1], y; foo(**yy, **xx); return 0; } Now only the modified register is saved if necessary, as in this case where it is used to store the result of the post-inc: long long *p, v, **pp; v = 1; p = &v; p[0]++; printf("another long long spill test : %lld\n", *p); i386-gen.c : - found a similar problem with TOK_UMULL caused by the vstack juggle in tccgen:gen_opl() (bug seen only when using EBX as 4th register)
2016-10-04 23:36:51 +08:00
if ((r &= VT_VALMASK) >= VT_CONST)
return;
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
if (nocode_wanted)
return;
tccgen: arm/i386: save_reg_upstack tccgen.c:gv() when loading long long from lvalue, before was saving all registers which caused problems in the arm function call register parameter preparation, as with void foo(long long y, int x); int main(void) { unsigned int *xx[1], x; unsigned long long *yy[1], y; foo(**yy, **xx); return 0; } Now only the modified register is saved if necessary, as in this case where it is used to store the result of the post-inc: long long *p, v, **pp; v = 1; p = &v; p[0]++; printf("another long long spill test : %lld\n", *p); i386-gen.c : - found a similar problem with TOK_UMULL caused by the vstack juggle in tccgen:gen_opl() (bug seen only when using EBX as 4th register)
2016-10-04 23:36:51 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* modify all stack values */
saved = 0;
l = 0;
tccgen: arm/i386: save_reg_upstack tccgen.c:gv() when loading long long from lvalue, before was saving all registers which caused problems in the arm function call register parameter preparation, as with void foo(long long y, int x); int main(void) { unsigned int *xx[1], x; unsigned long long *yy[1], y; foo(**yy, **xx); return 0; } Now only the modified register is saved if necessary, as in this case where it is used to store the result of the post-inc: long long *p, v, **pp; v = 1; p = &v; p[0]++; printf("another long long spill test : %lld\n", *p); i386-gen.c : - found a similar problem with TOK_UMULL caused by the vstack juggle in tccgen:gen_opl() (bug seen only when using EBX as 4th register)
2016-10-04 23:36:51 +08:00
for(p = vstack, p1 = vtop - n; p <= p1; p++) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if ((p->r & VT_VALMASK) == r ||
((p->type.t & VT_BTYPE) == VT_LLONG && (p->r2 & VT_VALMASK) == r)) {
/* must save value on stack if not already done */
if (!saved) {
/* NOTE: must reload 'r' because r might be equal to r2 */
r = p->r & VT_VALMASK;
/* store register in the stack */
type = &p->type;
if ((p->r & VT_LVAL) ||
(!is_float(type->t) && (type->t & VT_BTYPE) != VT_LLONG))
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type = &char_pointer_type;
#else
type = &int_type;
#endif
size = type_size(type, &align);
optimize the generated code when save_reg is required Before this patch, save_reg can't reuse the temporary local variable created before to save register. It may consume a lot of stack memory. this patch make save_reg reuse the temporary local variable.
2019-01-10 03:32:23 +08:00
l=get_temp_local_var(size,align);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
sv.type.t = type->t;
sv.r = VT_LOCAL | VT_LVAL;
optimize the generated code when save_reg is required Before this patch, save_reg can't reuse the temporary local variable created before to save register. It may consume a lot of stack memory. this patch make save_reg reuse the temporary local variable.
2019-01-10 03:32:23 +08:00
sv.c.i = l;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
store(r, &sv);
#if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
/* x86 specific: need to pop fp register ST0 if saved */
if (r == TREG_ST0) {
trying to fix the bug of unclean FPU st(0) Date: Mon, 8 Jun 2009 19:06:56 +0800 From: Soloist Deng <soloist.deng-gmail-com> Subject: [Tinycc-devel] trying to fix the bug of unclean FPU st(0) Hi all: I am using tcc-0.9.25, and the FPU bug brought a big trouble to me. I read the source and tried to fix it. Below is my solution. There are two places where program(`o(0xd9dd)') will generates `fstp %st(1)': vpop() in tccgen.c:689 and save_reg() in tccgen.c:210. We should first change both of them to `o(0xd8dd) // fstp %st(0)'. But these changes are not enough. Let's check the following code. void foo() { double var = 2.7; var++; } Using the changed tcc will generate following machine code: .text:08000000 public foo .text:08000000 foo proc near .text:08000000 .text:08000000 var_18 = qword ptr -18h .text:08000000 var_10 = qword ptr -10h .text:08000000 var_8 = qword ptr -8 .text:08000000 .text:08000000 push ebp .text:08000001 mov ebp, esp .text:08000003 sub esp, 18h .text:08000009 nop .text:0800000A fld L_0 .text:08000010 fst [ebp+var_8] .text:08000013 fstp st(0) .text:08000015 fld [ebp+var_8] .text:08000018 fst [ebp+var_10] .text:0800001B fstp st(0) .text:0800001D fst [ebp+var_18] .text:08000020 fstp st(0) .text:08000022 fld L_1 .text:08000028 fadd [ebp+var_10] .text:0800002B fst [ebp+var_8] .text:0800002E fstp st(0) .text:08000030 leave .text:08000031 retn .text:08000031 foo endp .text:08000031 .text:08000031 _text ends -------------------------------------------------- .data:08000040 ; Segment type: Pure data .data:08000040 ; Segment permissions: Read/Write .data:08000040 ; Segment alignment '32byte' can not be represented in assembly .data:08000040 _data segment page public 'DATA' use32 .data:08000040 assume cs:_data .data:08000040 ;org 8000040h .data:08000040 L_0 dq 400599999999999Ah .data:08000048 L_1 dq 3FF0000000000000h .data:08000048 _data ends Please notice the code snippet from 0800000A to 08000020 // double var = 2.7; load constant to st(0) .text:0800000A fld L_0 // double var = 2.7; store st(0) to `var' .text:08000010 fst [ebp+var_8] // double var = 2.7; poping st(0) will empty the floating registers stack .text:08000013 fstp st(0) After that ,tcc will call `void inc(int post, int c)" in tccgen.c:2150, and produce 08000015 to 0800001B through the calling chain (inc ->gv_dup) // load from `var' to st(0) .text:08000015 fld [ebp+var_8] // store st(0) to a temporary location .text:08000018 fst [ebp+var_10] // poping st(0) will empty the floating registers stack .text:0800001B fstp st(0) And the calling chain (gen_op('+')->gen_opif('+')->gen_opf('+')->gv(rc=2)->get_reg(rc=2)->save_reg(r=3)) will produce 0800001D to 08000020 . // store st(0) to a temporary location, but floating stack is empty! .text:0800001D fst [ebp+var_18] // poping st(0) will empty the floating registers stack .text:08000020 fstp st(0) The `0800001D fst [ebp+var_18]' will store st(0) to a memory location, but st(0) is empty. That will cause FPU invalid operation exception(#IE). Why does tcc do that? Please read `gv_dup' called by `inc' carefully. Notice these lines: (1): r = gv(rc); (2): r1 = get_reg(rc); (3): sv.r = r; sv.c.ul = 0; (4) load(r1, &sv); /* move r to r1 */ (5) vdup(); /* duplicates value */ (6) vtop->r = r1; (1) let the vtop occupy TREG_ST0, and `r' will be TREG_ST0. (2) try to get a free floating register,but tcc assume there is only one, so it wil force vtop goto memory and assign `r1' with TREG_ST0. When executing (3), it will do nothing because `r' equals `r1'. (5) duplicates vtop. Then (6) let the new vtop occupy TREG_ST0, but this will cause problem because the old vtop has been moved to memory, so the new duplicated vtop does not reside in TREG_ST0 but also in memory after that. TREG_ST0 is not occupied but freely availabe now. `gen_op('+')' need at least one oprand in register, so it will incorrectly think TREG_ST0 is occupied by vtop and produce instructions(0800001D and 08000020) to store it to a temporary memory location. According program above, if `r' == `r1' it is impossible for the old vtop to still occupy the `r' register . And `load' will do nothing too at this condition. So the `gv_dup' can not promise the semantics that old vtop in one register and the new duplicated vtop in another register at the same time. I changed (6) to if (r != r1) { vtop->r = r1; } Then the new generated machine code will be : .text:08000000 push ebp .text:08000001 mov ebp, esp .text:08000003 sub esp, 10h .text:08000009 nop .text:0800000A fld L_0 .text:08000010 fst [ebp+var_8] .text:08000013 fstp st(0) .text:08000015 fld [ebp+var_8] .text:08000018 fst [ebp+var_10] .text:0800001B fstp st(0) .text:0800001D fld L_1 .text:08000023 fadd [ebp+var_10] .text:08000026 fst [ebp+var_8] .text:08000029 fstp st(0) .text:0800002B leave .text:0800002C retn It works well, and will clean the floating registers stack when return. Finally, I want to know there is any potential problem of this fixing ? soloist
2009-06-09 01:26:19 +08:00
o(0xd8dd); /* fstp %st(0) */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
#endif
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 4
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* special long long case */
if ((type->t & VT_BTYPE) == VT_LLONG) {
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
sv.c.i += 4;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
store(p->r2, &sv);
}
#endif
saved = 1;
}
/* mark that stack entry as being saved on the stack */
if (p->r & VT_LVAL) {
/* also clear the bounded flag because the
relocation address of the function was stored in
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
p->c.i */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
p->r = (p->r & ~(VT_VALMASK | VT_BOUNDED)) | VT_LLOCAL;
} else {
p->r = lvalue_type(p->type.t) | VT_LOCAL;
}
p->r2 = VT_CONST;
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
p->c.i = l;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
}
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
#ifdef TCC_TARGET_ARM
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* find a register of class 'rc2' with at most one reference on stack.
* If none, call get_reg(rc) */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC int get_reg_ex(int rc, int rc2)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int r;
SValue *p;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
for(r=0;r<NB_REGS;r++) {
if (reg_classes[r] & rc2) {
int n;
n=0;
for(p = vstack; p <= vtop; p++) {
if ((p->r & VT_VALMASK) == r ||
(p->r2 & VT_VALMASK) == r)
n++;
}
if (n <= 1)
return r;
}
}
return get_reg(rc);
}
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* find a free register of class 'rc'. If none, save one register */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC int get_reg(int rc)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int r;
SValue *p;
/* find a free register */
for(r=0;r<NB_REGS;r++) {
if (reg_classes[r] & rc) {
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
if (nocode_wanted)
return r;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
for(p=vstack;p<=vtop;p++) {
if ((p->r & VT_VALMASK) == r ||
(p->r2 & VT_VALMASK) == r)
goto notfound;
}
return r;
}
notfound: ;
}
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* no register left : free the first one on the stack (VERY
IMPORTANT to start from the bottom to ensure that we don't
spill registers used in gen_opi()) */
for(p=vstack;p<=vtop;p++) {
get_reg(): try to free r2 for an SValue first To be able to load a long long value correctly on i386, gv() rely on the fact that when get_reg() look at an SValue it tries first to free the register in r2 and then r. More information about the context can be found at http://lists.nongnu.org/archive/html/tinycc-devel/2012-06/msg00017.html and later at http://lists.nongnu.org/archive/html/tinycc-devel/2012-07/msg00021.html
2012-07-12 05:39:05 +08:00
/* look at second register (if long long) */
r = p->r2 & VT_VALMASK;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (r < VT_CONST && (reg_classes[r] & rc))
goto save_found;
get_reg(): try to free r2 for an SValue first To be able to load a long long value correctly on i386, gv() rely on the fact that when get_reg() look at an SValue it tries first to free the register in r2 and then r. More information about the context can be found at http://lists.nongnu.org/archive/html/tinycc-devel/2012-06/msg00017.html and later at http://lists.nongnu.org/archive/html/tinycc-devel/2012-07/msg00021.html
2012-07-12 05:39:05 +08:00
r = p->r & VT_VALMASK;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (r < VT_CONST && (reg_classes[r] & rc)) {
save_found:
save_reg(r);
return r;
}
}
/* Should never comes here */
return -1;
}
optimize the generated code when save_reg is required Before this patch, save_reg can't reuse the temporary local variable created before to save register. It may consume a lot of stack memory. this patch make save_reg reuse the temporary local variable.
2019-01-10 03:32:23 +08:00
/* find a free temporary local variable (return the offset on stack) match the size and align. If none, add new temporary stack variable*/
static int get_temp_local_var(int size,int align){
int i;
struct temp_local_variable *temp_var;
int found_var;
SValue *p;
int r;
char free;
char found;
found=0;
for(i=0;i<nb_temp_local_vars;i++){
temp_var=&arr_temp_local_vars[i];
if(temp_var->size<size||align!=temp_var->align){
continue;
}
/*check if temp_var is free*/
free=1;
for(p=vstack;p<=vtop;p++) {
r=p->r&VT_VALMASK;
if(r==VT_LOCAL||r==VT_LLOCAL){
if(p->c.i==temp_var->location){
free=0;
break;
}
}
}
if(free){
found_var=temp_var->location;
found=1;
break;
}
}
if(!found){
loc = (loc - size) & -align;
if(nb_temp_local_vars<MAX_TEMP_LOCAL_VARIABLE_NUMBER){
temp_var=&arr_temp_local_vars[i];
temp_var->location=loc;
temp_var->size=size;
temp_var->align=align;
nb_temp_local_vars++;
}
found_var=loc;
}
return found_var;
}
static void clear_temp_local_var_list(){
nb_temp_local_vars=0;
}
Fixed problems with XMM1 use on Linux/x86-64. All tests pass. I think I've caught all the cases assuming only XMM0 is used. I expect that Win64 is horribly broken by this point though, because I haven't altered it to cope with XMM1.
2013-04-20 01:31:24 +08:00
/* move register 's' (of type 't') to 'r', and flush previous value of r to memory
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if needed */
Fixed problems with XMM1 use on Linux/x86-64. All tests pass. I think I've caught all the cases assuming only XMM0 is used. I expect that Win64 is horribly broken by this point though, because I haven't altered it to cope with XMM1.
2013-04-20 01:31:24 +08:00
static void move_reg(int r, int s, int t)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
SValue sv;
if (r != s) {
save_reg(r);
Fixed problems with XMM1 use on Linux/x86-64. All tests pass. I think I've caught all the cases assuming only XMM0 is used. I expect that Win64 is horribly broken by this point though, because I haven't altered it to cope with XMM1.
2013-04-20 01:31:24 +08:00
sv.type.t = t;
sv.type.ref = NULL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
sv.r = s;
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
sv.c.i = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
load(r, &sv);
}
}
/* get address of vtop (vtop MUST BE an lvalue) */
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
ST_FUNC void gaddrof(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
vtop->r &= ~VT_LVAL;
/* tricky: if saved lvalue, then we can go back to lvalue */
if ((vtop->r & VT_VALMASK) == VT_LLOCAL)
vtop->r = (vtop->r & ~(VT_VALMASK | VT_LVAL_TYPE)) | VT_LOCAL | VT_LVAL;
win64: va_arg with structures
2010-12-17 20:15:01 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
#ifdef CONFIG_TCC_BCHECK
/* generate lvalue bound code */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void gbound(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int lval_type;
CType type1;
vtop->r &= ~VT_MUSTBOUND;
/* if lvalue, then use checking code before dereferencing */
if (vtop->r & VT_LVAL) {
/* if not VT_BOUNDED value, then make one */
if (!(vtop->r & VT_BOUNDED)) {
lval_type = vtop->r & (VT_LVAL_TYPE | VT_LVAL);
/* must save type because we must set it to int to get pointer */
type1 = vtop->type;
a bounds checking code for the ARCH=x86_64
2015-04-10 20:17:22 +08:00
vtop->type.t = VT_PTR;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gaddrof();
vpushi(0);
gen_bounded_ptr_add();
vtop->r |= lval_type;
vtop->type = type1;
}
/* then check for dereferencing */
gen_bounded_ptr_deref();
}
}
#endif
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
static void incr_bf_adr(int o)
{
vtop->type = char_pointer_type;
gaddrof();
vpushi(o);
gen_op('+');
vtop->type.t = (vtop->type.t & ~(VT_BTYPE|VT_DEFSIGN))
| (VT_BYTE|VT_UNSIGNED);
vtop->r = (vtop->r & ~VT_LVAL_TYPE)
| (VT_LVAL_BYTE|VT_LVAL_UNSIGNED|VT_LVAL);
}
/* single-byte load mode for packed or otherwise unaligned bitfields */
static void load_packed_bf(CType *type, int bit_pos, int bit_size)
{
int n, o, bits;
save_reg_upstack(vtop->r, 1);
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
vpush64(type->t & VT_BTYPE, 0); // B X
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
bits = 0, o = bit_pos >> 3, bit_pos &= 7;
do {
vswap(); // X B
incr_bf_adr(o);
vdup(); // X B B
n = 8 - bit_pos;
if (n > bit_size)
n = bit_size;
if (bit_pos)
vpushi(bit_pos), gen_op(TOK_SHR), bit_pos = 0; // X B Y
if (n < 8)
vpushi((1 << n) - 1), gen_op('&');
gen_cast(type);
if (bits)
vpushi(bits), gen_op(TOK_SHL);
vrotb(3); // B Y X
gen_op('|'); // B X
bits += n, bit_size -= n, o = 1;
} while (bit_size);
vswap(), vpop();
if (!(type->t & VT_UNSIGNED)) {
n = ((type->t & VT_BTYPE) == VT_LLONG ? 64 : 32) - bits;
vpushi(n), gen_op(TOK_SHL);
vpushi(n), gen_op(TOK_SAR);
}
}
/* single-byte store mode for packed or otherwise unaligned bitfields */
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
static void store_packed_bf(int bit_pos, int bit_size)
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
{
int bits, n, o, m, c;
c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
vswap(); // X B
save_reg_upstack(vtop->r, 1);
bits = 0, o = bit_pos >> 3, bit_pos &= 7;
do {
incr_bf_adr(o); // X B
vswap(); //B X
c ? vdup() : gv_dup(); // B V X
vrott(3); // X B V
if (bits)
vpushi(bits), gen_op(TOK_SHR);
if (bit_pos)
vpushi(bit_pos), gen_op(TOK_SHL);
n = 8 - bit_pos;
if (n > bit_size)
n = bit_size;
if (n < 8) {
m = ((1 << n) - 1) << bit_pos;
vpushi(m), gen_op('&'); // X B V1
vpushv(vtop-1); // X B V1 B
vpushi(m & 0x80 ? ~m & 0x7f : ~m);
gen_op('&'); // X B V1 B1
gen_op('|'); // X B V2
}
vdup(), vtop[-1] = vtop[-2]; // X B B V2
vstore(), vpop(); // X B
bits += n, bit_size -= n, bit_pos = 0, o = 1;
} while (bit_size);
vpop(), vpop();
}
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
static int adjust_bf(SValue *sv, int bit_pos, int bit_size)
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
{
int t;
if (0 == sv->type.ref)
return 0;
t = sv->type.ref->auxtype;
if (t != -1 && t != VT_STRUCT) {
sv->type.t = (sv->type.t & ~VT_BTYPE) | t;
sv->r = (sv->r & ~VT_LVAL_TYPE) | lvalue_type(sv->type.t);
}
return t;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* store vtop a register belonging to class 'rc'. lvalues are
converted to values. Cannot be used if cannot be converted to
register value (such as structures). */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC int gv(int rc)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
int r, bit_pos, bit_size, size, align, rc2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* NOTE: get_reg can modify vstack[] */
if (vtop->type.t & VT_BITFIELD) {
CType type;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
bit_pos = BIT_POS(vtop->type.t);
bit_size = BIT_SIZE(vtop->type.t);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* remove bit field info to avoid loops */
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
vtop->type.t &= ~VT_STRUCT_MASK;
type.ref = NULL;
type.t = vtop->type.t & VT_UNSIGNED;
if ((vtop->type.t & VT_BTYPE) == VT_BOOL)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type.t |= VT_UNSIGNED;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
r = adjust_bf(vtop, bit_pos, bit_size);
if ((vtop->type.t & VT_BTYPE) == VT_LLONG)
type.t |= VT_LLONG;
else
type.t |= VT_INT;
if (r == VT_STRUCT) {
load_packed_bf(&type, bit_pos, bit_size);
} else {
int bits = (type.t & VT_BTYPE) == VT_LLONG ? 64 : 32;
/* cast to int to propagate signedness in following ops */
gen_cast(&type);
/* generate shifts */
vpushi(bits - (bit_pos + bit_size));
gen_op(TOK_SHL);
vpushi(bits - bit_size);
/* NOTE: transformed to SHR if unsigned */
gen_op(TOK_SAR);
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
r = gv(rc);
} else {
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (is_float(vtop->type.t) &&
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
(vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
tccgen: nodata_wanted fix, default ONE_SOURCE, etc... tccgen.c: doubles need to be aligned, on ARM. The section_reserve() in init_putv does not do that. -D ONE_SOURCE: is now the default and not longer needed. Also, tcc.h now sets the default native target. These both make compiling tcc simple as "gcc tcc.c -o tcc -ldl" again. arm-asm.c: enable pseudo asm also for inline asm tests/tests2/Makefile: disable bitfield tests except on windows and x86_64 and don't generate-always tcc.c: fix a loop with -dt on errors configure: print compiler version (as recognized) tccpp.c: actually define symbols for tcc -dt clear static variables (needed for -dt or libtcc usage) 96_nodata_wanted.c: use __label__ instead of asm lib/files: use native symbols (__i386__ etc.) instead of TCC_TARGET_...
2017-07-24 03:24:11 +08:00
unsigned long offset;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* CPUs usually cannot use float constants, so we store them
generically in data segment */
size = type_size(&vtop->type, &align);
tccgen: nodata_wanted fix, default ONE_SOURCE, etc... tccgen.c: doubles need to be aligned, on ARM. The section_reserve() in init_putv does not do that. -D ONE_SOURCE: is now the default and not longer needed. Also, tcc.h now sets the default native target. These both make compiling tcc simple as "gcc tcc.c -o tcc -ldl" again. arm-asm.c: enable pseudo asm also for inline asm tests/tests2/Makefile: disable bitfield tests except on windows and x86_64 and don't generate-always tcc.c: fix a loop with -dt on errors configure: print compiler version (as recognized) tccpp.c: actually define symbols for tcc -dt clear static variables (needed for -dt or libtcc usage) 96_nodata_wanted.c: use __label__ instead of asm lib/files: use native symbols (__i386__ etc.) instead of TCC_TARGET_...
2017-07-24 03:24:11 +08:00
if (NODATA_WANTED)
size = 0, align = 1;
offset = section_add(data_section, size, align);
vpush_ref(&vtop->type, data_section, offset, size);
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
vswap();
tccgen: nodata_wanted fix, default ONE_SOURCE, etc... tccgen.c: doubles need to be aligned, on ARM. The section_reserve() in init_putv does not do that. -D ONE_SOURCE: is now the default and not longer needed. Also, tcc.h now sets the default native target. These both make compiling tcc simple as "gcc tcc.c -o tcc -ldl" again. arm-asm.c: enable pseudo asm also for inline asm tests/tests2/Makefile: disable bitfield tests except on windows and x86_64 and don't generate-always tcc.c: fix a loop with -dt on errors configure: print compiler version (as recognized) tccpp.c: actually define symbols for tcc -dt clear static variables (needed for -dt or libtcc usage) 96_nodata_wanted.c: use __label__ instead of asm lib/files: use native symbols (__i386__ etc.) instead of TCC_TARGET_...
2017-07-24 03:24:11 +08:00
init_putv(&vtop->type, data_section, offset);
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
vtop->r |= VT_LVAL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
#ifdef CONFIG_TCC_BCHECK
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (vtop->r & VT_MUSTBOUND)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gbound();
#endif
r = vtop->r & VT_VALMASK;
Improved x86-64 XMM register argument passing. Also made XMM0-7 available for use as temporary registers, since they are not used by the ABI. I'd like to do the same with RSI and RDI but that's trickier since they can be used by gv() as temporary registers and there isn't a way to disable that.
2013-04-20 05:05:49 +08:00
rc2 = (rc & RC_FLOAT) ? RC_FLOAT : RC_INT;
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#ifndef TCC_TARGET_ARM64
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (rc == RC_IRET)
rc2 = RC_LRET;
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
#ifdef TCC_TARGET_X86_64
else if (rc == RC_FRET)
rc2 = RC_QRET;
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#endif
Remove unused variables Remove unused local variables and declare them conditionally when they are used only on some architectures.
2011-05-16 20:15:32 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* need to reload if:
- constant
- lvalue (need to dereference pointer)
- already a register, but not in the right class */
x86-64: in gv(): ignore second register
2009-12-18 04:09:53 +08:00
if (r >= VT_CONST
|| (vtop->r & VT_LVAL)
|| !(reg_classes[r] & rc)
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
|| ((vtop->type.t & VT_BTYPE) == VT_QLONG && !(reg_classes[vtop->r2] & rc2))
|| ((vtop->type.t & VT_BTYPE) == VT_QFLOAT && !(reg_classes[vtop->r2] & rc2))
#else
x86-64: in gv(): ignore second register
2009-12-18 04:09:53 +08:00
|| ((vtop->type.t & VT_BTYPE) == VT_LLONG && !(reg_classes[vtop->r2] & rc2))
#endif
)
{
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
r = get_reg(rc);
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
if (((vtop->type.t & VT_BTYPE) == VT_QLONG) || ((vtop->type.t & VT_BTYPE) == VT_QFLOAT)) {
Fixed 64-bit integer bug introduced by x86-64 ABI work. Now I need to check that the x86-64 stuff still works.
2013-04-20 05:55:09 +08:00
int addr_type = VT_LLONG, load_size = 8, load_type = ((vtop->type.t & VT_BTYPE) == VT_QLONG) ? VT_LLONG : VT_DOUBLE;
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
#else
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
Fixed 64-bit integer bug introduced by x86-64 ABI work. Now I need to check that the x86-64 stuff still works.
2013-04-20 05:55:09 +08:00
int addr_type = VT_INT, load_size = 4, load_type = VT_INT;
Avoid warnings with gcc 4.8 + default CFLAGS
2013-09-24 21:36:04 +08:00
unsigned long long ll;
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
#endif
Fixed 64-bit integer bug introduced by x86-64 ABI work. Now I need to check that the x86-64 stuff still works.
2013-04-20 05:55:09 +08:00
int r2, original_type;
original_type = vtop->type.t;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* two register type load : expand to two words
temporarily */
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 4
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
/* load constant */
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
ll = vtop->c.i;
vtop->c.i = ll; /* first word */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
load(r, vtop);
vtop->r = r; /* save register value */
vpushi(ll >> 32); /* second word */
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
} else
#endif
tccgen: arm/i386: save_reg_upstack tccgen.c:gv() when loading long long from lvalue, before was saving all registers which caused problems in the arm function call register parameter preparation, as with void foo(long long y, int x); int main(void) { unsigned int *xx[1], x; unsigned long long *yy[1], y; foo(**yy, **xx); return 0; } Now only the modified register is saved if necessary, as in this case where it is used to store the result of the post-inc: long long *p, v, **pp; v = 1; p = &v; p[0]++; printf("another long long spill test : %lld\n", *p); i386-gen.c : - found a similar problem with TOK_UMULL caused by the vstack juggle in tccgen:gen_opl() (bug seen only when using EBX as 4th register)
2016-10-04 23:36:51 +08:00
if (vtop->r & VT_LVAL) {
Alternative fix for "Incorrect function call code on ARMv6" "make test" crashes without that "save_regs()". This partially reverts commit 49d3118621a68f6583228f123efd16f0f803d908. Found another solution: In a 2nd pass Just look if any of the argument registers has been saved again, and restore if so.
2016-10-03 18:27:50 +08:00
/* We do not want to modifier the long long
pointer here, so the safest (and less
efficient) is to save all the other registers
in the stack. XXX: totally inefficient. */
tccgen: arm/i386: save_reg_upstack tccgen.c:gv() when loading long long from lvalue, before was saving all registers which caused problems in the arm function call register parameter preparation, as with void foo(long long y, int x); int main(void) { unsigned int *xx[1], x; unsigned long long *yy[1], y; foo(**yy, **xx); return 0; } Now only the modified register is saved if necessary, as in this case where it is used to store the result of the post-inc: long long *p, v, **pp; v = 1; p = &v; p[0]++; printf("another long long spill test : %lld\n", *p); i386-gen.c : - found a similar problem with TOK_UMULL caused by the vstack juggle in tccgen:gen_opl() (bug seen only when using EBX as 4th register)
2016-10-04 23:36:51 +08:00
#if 0
Alternative fix for "Incorrect function call code on ARMv6" "make test" crashes without that "save_regs()". This partially reverts commit 49d3118621a68f6583228f123efd16f0f803d908. Found another solution: In a 2nd pass Just look if any of the argument registers has been saved again, and restore if so.
2016-10-03 18:27:50 +08:00
save_regs(1);
tccgen: arm/i386: save_reg_upstack tccgen.c:gv() when loading long long from lvalue, before was saving all registers which caused problems in the arm function call register parameter preparation, as with void foo(long long y, int x); int main(void) { unsigned int *xx[1], x; unsigned long long *yy[1], y; foo(**yy, **xx); return 0; } Now only the modified register is saved if necessary, as in this case where it is used to store the result of the post-inc: long long *p, v, **pp; v = 1; p = &v; p[0]++; printf("another long long spill test : %lld\n", *p); i386-gen.c : - found a similar problem with TOK_UMULL caused by the vstack juggle in tccgen:gen_opl() (bug seen only when using EBX as 4th register)
2016-10-04 23:36:51 +08:00
#else
/* lvalue_save: save only if used further down the stack */
save_reg_upstack(vtop->r, 1);
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* load from memory */
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
vtop->type.t = load_type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
load(r, vtop);
vdup();
vtop[-1].r = r; /* save register value */
/* increment pointer to get second word */
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
vtop->type.t = addr_type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gaddrof();
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
vpushi(load_size);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_op('+');
vtop->r |= VT_LVAL;
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
vtop->type.t = load_type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
/* move registers */
load(r, vtop);
vdup();
vtop[-1].r = r; /* save register value */
vtop->r = vtop[-1].r2;
}
get_reg(): try to free r2 for an SValue first To be able to load a long long value correctly on i386, gv() rely on the fact that when get_reg() look at an SValue it tries first to free the register in r2 and then r. More information about the context can be found at http://lists.nongnu.org/archive/html/tinycc-devel/2012-06/msg00017.html and later at http://lists.nongnu.org/archive/html/tinycc-devel/2012-07/msg00021.html
2012-07-12 05:39:05 +08:00
/* Allocate second register. Here we rely on the fact that
get_reg() tries first to free r2 of an SValue. */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
r2 = get_reg(rc2);
load(r2, vtop);
vpop();
/* write second register */
vtop->r2 = r2;
Fixed 64-bit integer bug introduced by x86-64 ABI work. Now I need to check that the x86-64 stuff still works.
2013-04-20 05:55:09 +08:00
vtop->type.t = original_type;
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
} else if ((vtop->r & VT_LVAL) && !is_float(vtop->type.t)) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
int t1, t;
/* lvalue of scalar type : need to use lvalue type
because of possible cast */
t = vtop->type.t;
t1 = t;
/* compute memory access type */
Remove VT_REF The canonical way to describe a local variable that actually holds the address of an lvalue is VT_LLOCAL. Remove the last user of VT_REF, and handling of it, thereby freeing a flag for SValue.r.
2017-02-20 06:50:13 +08:00
if (vtop->r & VT_LVAL_BYTE)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
t = VT_BYTE;
else if (vtop->r & VT_LVAL_SHORT)
t = VT_SHORT;
if (vtop->r & VT_LVAL_UNSIGNED)
t |= VT_UNSIGNED;
vtop->type.t = t;
load(r, vtop);
/* restore wanted type */
vtop->type.t = t1;
} else {
/* one register type load */
load(r, vtop);
}
}
vtop->r = r;
#ifdef TCC_TARGET_C67
/* uses register pairs for doubles */
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop->r2 = r+1;
#endif
}
return r;
}
/* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void gv2(int rc1, int rc2)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int v;
/* generate more generic register first. But VT_JMP or VT_CMP
values must be generated first in all cases to avoid possible
reload errors */
v = vtop[0].r & VT_VALMASK;
if (v != VT_CMP && (v & ~1) != VT_JMP && rc1 <= rc2) {
vswap();
gv(rc1);
vswap();
gv(rc2);
/* test if reload is needed for first register */
if ((vtop[-1].r & VT_VALMASK) >= VT_CONST) {
vswap();
gv(rc1);
vswap();
}
} else {
gv(rc2);
vswap();
gv(rc1);
vswap();
/* test if reload is needed for first register */
if ((vtop[0].r & VT_VALMASK) >= VT_CONST) {
gv(rc2);
}
}
}
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#ifndef TCC_TARGET_ARM64
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* wrapper around RC_FRET to return a register by type */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static int rc_fret(int t)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
#ifdef TCC_TARGET_X86_64
if (t == VT_LDOUBLE) {
return RC_ST0;
}
#endif
return RC_FRET;
}
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* wrapper around REG_FRET to return a register by type */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static int reg_fret(int t)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
#ifdef TCC_TARGET_X86_64
if (t == VT_LDOUBLE) {
return TREG_ST0;
}
#endif
return REG_FRET;
}
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 4
x86-64: Fix long long bug With the last improvements to lexpand it's now harmful to use on native 64bit platforms when not necessary. For gv_dup it's not necessary there. It can still be used with really transforming a 64bit value into two 32bit ones.
2016-10-17 06:57:16 +08:00
/* expand 64bit on stack in two ints */
Insert arm-xxx_FILES into Makefile to suport CROSS_TARGET and Remove duplicate function lexpand_nr
2019-01-09 02:06:26 +08:00
ST_FUNC void lexpand(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
i386: do not 'lexpand' into registers necessarily Previously, long longs were 'lexpand'ed into two registers always. Now, it expands - constants into two constants (lo-part, hi-part) - variables into two lvalues with offset+4 for the hi-part. This makes long long operations look a bit nicer. Also: don't apply i386 'inc/dec' optimization if carry generation is wanted.
2016-10-17 01:04:40 +08:00
int u, v;
Def signedness != signed != unsigned for char When checking for exact compatibility between types (such as in __builtin_types_compatible_p) consider the case of default signedness to be incompatible with both of the explicit signedness for char. That is, char is incompatible with signed char *and* unsigned char, no matter what the default signedness for char is.
2014-02-06 20:51:47 +08:00
u = vtop->type.t & (VT_DEFSIGN | VT_UNSIGNED);
i386: do not 'lexpand' into registers necessarily Previously, long longs were 'lexpand'ed into two registers always. Now, it expands - constants into two constants (lo-part, hi-part) - variables into two lvalues with offset+4 for the hi-part. This makes long long operations look a bit nicer. Also: don't apply i386 'inc/dec' optimization if carry generation is wanted.
2016-10-17 01:04:40 +08:00
v = vtop->r & (VT_VALMASK | VT_LVAL);
if (v == VT_CONST) {
vdup();
vtop[0].c.i >>= 32;
} else if (v == (VT_LVAL|VT_CONST) || v == (VT_LVAL|VT_LOCAL)) {
vdup();
vtop[0].c.i += 4;
} else {
gv(RC_INT);
vdup();
vtop[0].r = vtop[-1].r2;
vtop[0].r2 = vtop[-1].r2 = VT_CONST;
}
vtop[0].type.t = vtop[-1].type.t = VT_INT | u;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
arm64: Fix regression introduced by 6245db9.
2016-12-06 07:29:25 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 4
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* build a long long from two ints */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void lbuild(int t)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
gv2(RC_INT, RC_INT);
vtop[-1].r2 = vtop[0].r;
vtop[-1].type.t = t;
vpop();
}
x86-64: Fix long long bug With the last improvements to lexpand it's now harmful to use on native 64bit platforms when not necessary. For gv_dup it's not necessary there. It can still be used with really transforming a 64bit value into two 32bit ones.
2016-10-17 06:57:16 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* convert stack entry to register and duplicate its value in another
register */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void gv_dup(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int rc, t, r, r1;
SValue sv;
t = vtop->type.t;
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 4
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if ((t & VT_BTYPE) == VT_LLONG) {
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
if (t & VT_BITFIELD) {
gv(RC_INT);
t = vtop->type.t;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
lexpand();
gv_dup();
vswap();
vrotb(3);
gv_dup();
vrotb(4);
/* stack: H L L1 H1 */
lbuild(t);
vrotb(3);
vrotb(3);
vswap();
lbuild(t);
vswap();
x86-64: Fix long long bug With the last improvements to lexpand it's now harmful to use on native 64bit platforms when not necessary. For gv_dup it's not necessary there. It can still be used with really transforming a 64bit value into two 32bit ones.
2016-10-17 06:57:16 +08:00
} else
#endif
{
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* duplicate value */
rc = RC_INT;
sv.type.t = VT_INT;
if (is_float(t)) {
rc = RC_FLOAT;
#ifdef TCC_TARGET_X86_64
if ((t & VT_BTYPE) == VT_LDOUBLE) {
rc = RC_ST0;
}
#endif
sv.type.t = t;
}
r = gv(rc);
r1 = get_reg(rc);
sv.r = r;
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
sv.c.i = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
load(r1, &sv); /* move r to r1 */
vdup();
/* duplicates value */
trying to fix the bug of unclean FPU st(0) Date: Mon, 8 Jun 2009 19:06:56 +0800 From: Soloist Deng <soloist.deng-gmail-com> Subject: [Tinycc-devel] trying to fix the bug of unclean FPU st(0) Hi all: I am using tcc-0.9.25, and the FPU bug brought a big trouble to me. I read the source and tried to fix it. Below is my solution. There are two places where program(`o(0xd9dd)') will generates `fstp %st(1)': vpop() in tccgen.c:689 and save_reg() in tccgen.c:210. We should first change both of them to `o(0xd8dd) // fstp %st(0)'. But these changes are not enough. Let's check the following code. void foo() { double var = 2.7; var++; } Using the changed tcc will generate following machine code: .text:08000000 public foo .text:08000000 foo proc near .text:08000000 .text:08000000 var_18 = qword ptr -18h .text:08000000 var_10 = qword ptr -10h .text:08000000 var_8 = qword ptr -8 .text:08000000 .text:08000000 push ebp .text:08000001 mov ebp, esp .text:08000003 sub esp, 18h .text:08000009 nop .text:0800000A fld L_0 .text:08000010 fst [ebp+var_8] .text:08000013 fstp st(0) .text:08000015 fld [ebp+var_8] .text:08000018 fst [ebp+var_10] .text:0800001B fstp st(0) .text:0800001D fst [ebp+var_18] .text:08000020 fstp st(0) .text:08000022 fld L_1 .text:08000028 fadd [ebp+var_10] .text:0800002B fst [ebp+var_8] .text:0800002E fstp st(0) .text:08000030 leave .text:08000031 retn .text:08000031 foo endp .text:08000031 .text:08000031 _text ends -------------------------------------------------- .data:08000040 ; Segment type: Pure data .data:08000040 ; Segment permissions: Read/Write .data:08000040 ; Segment alignment '32byte' can not be represented in assembly .data:08000040 _data segment page public 'DATA' use32 .data:08000040 assume cs:_data .data:08000040 ;org 8000040h .data:08000040 L_0 dq 400599999999999Ah .data:08000048 L_1 dq 3FF0000000000000h .data:08000048 _data ends Please notice the code snippet from 0800000A to 08000020 // double var = 2.7; load constant to st(0) .text:0800000A fld L_0 // double var = 2.7; store st(0) to `var' .text:08000010 fst [ebp+var_8] // double var = 2.7; poping st(0) will empty the floating registers stack .text:08000013 fstp st(0) After that ,tcc will call `void inc(int post, int c)" in tccgen.c:2150, and produce 08000015 to 0800001B through the calling chain (inc ->gv_dup) // load from `var' to st(0) .text:08000015 fld [ebp+var_8] // store st(0) to a temporary location .text:08000018 fst [ebp+var_10] // poping st(0) will empty the floating registers stack .text:0800001B fstp st(0) And the calling chain (gen_op('+')->gen_opif('+')->gen_opf('+')->gv(rc=2)->get_reg(rc=2)->save_reg(r=3)) will produce 0800001D to 08000020 . // store st(0) to a temporary location, but floating stack is empty! .text:0800001D fst [ebp+var_18] // poping st(0) will empty the floating registers stack .text:08000020 fstp st(0) The `0800001D fst [ebp+var_18]' will store st(0) to a memory location, but st(0) is empty. That will cause FPU invalid operation exception(#IE). Why does tcc do that? Please read `gv_dup' called by `inc' carefully. Notice these lines: (1): r = gv(rc); (2): r1 = get_reg(rc); (3): sv.r = r; sv.c.ul = 0; (4) load(r1, &sv); /* move r to r1 */ (5) vdup(); /* duplicates value */ (6) vtop->r = r1; (1) let the vtop occupy TREG_ST0, and `r' will be TREG_ST0. (2) try to get a free floating register,but tcc assume there is only one, so it wil force vtop goto memory and assign `r1' with TREG_ST0. When executing (3), it will do nothing because `r' equals `r1'. (5) duplicates vtop. Then (6) let the new vtop occupy TREG_ST0, but this will cause problem because the old vtop has been moved to memory, so the new duplicated vtop does not reside in TREG_ST0 but also in memory after that. TREG_ST0 is not occupied but freely availabe now. `gen_op('+')' need at least one oprand in register, so it will incorrectly think TREG_ST0 is occupied by vtop and produce instructions(0800001D and 08000020) to store it to a temporary memory location. According program above, if `r' == `r1' it is impossible for the old vtop to still occupy the `r' register . And `load' will do nothing too at this condition. So the `gv_dup' can not promise the semantics that old vtop in one register and the new duplicated vtop in another register at the same time. I changed (6) to if (r != r1) { vtop->r = r1; } Then the new generated machine code will be : .text:08000000 push ebp .text:08000001 mov ebp, esp .text:08000003 sub esp, 10h .text:08000009 nop .text:0800000A fld L_0 .text:08000010 fst [ebp+var_8] .text:08000013 fstp st(0) .text:08000015 fld [ebp+var_8] .text:08000018 fst [ebp+var_10] .text:0800001B fstp st(0) .text:0800001D fld L_1 .text:08000023 fadd [ebp+var_10] .text:08000026 fst [ebp+var_8] .text:08000029 fstp st(0) .text:0800002B leave .text:0800002C retn It works well, and will clean the floating registers stack when return. Finally, I want to know there is any potential problem of this fixing ? soloist
2009-06-09 01:26:19 +08:00
if (r != r1)
vtop->r = r1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
Move logic for if (int value) to tccgen.c Move the logic to do a test of an integer value (ex if (0)) out of arch-specific code to tccgen.c to avoid code duplication. This also fixes test of long long value which was only testing the bottom half of such values on 32 bits architectures.
2013-12-31 23:51:20 +08:00
/* Generate value test
*
* Generate a test for any value (jump, comparison and integers) */
add missing prototypes
2014-04-10 17:53:54 +08:00
ST_FUNC int gvtst(int inv, int t)
Move logic for if (int value) to tccgen.c Move the logic to do a test of an integer value (ex if (0)) out of arch-specific code to tccgen.c to avoid code duplication. This also fixes test of long long value which was only testing the bottom half of such values on 32 bits architectures.
2013-12-31 23:51:20 +08:00
{
int v = vtop->r & VT_VALMASK;
if (v != VT_CMP && v != VT_JMP && v != VT_JMPI) {
vpushi(0);
gen_op(TOK_NE);
}
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
/* constant jmp optimization */
if ((vtop->c.i != 0) != inv)
t = gjmp(t);
vtop--;
return t;
}
return gtst(inv, t);
}
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 4
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* generate CPU independent (unsigned) long long operations */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void gen_opl(int op)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int t, a, b, op1, c, i;
int func;
unsigned short reg_iret = REG_IRET;
unsigned short reg_lret = REG_LRET;
SValue tmp;
switch(op) {
case '/':
case TOK_PDIV:
func = TOK___divdi3;
goto gen_func;
case TOK_UDIV:
func = TOK___udivdi3;
goto gen_func;
case '%':
func = TOK___moddi3;
goto gen_mod_func;
case TOK_UMOD:
func = TOK___umoddi3;
gen_mod_func:
#ifdef TCC_ARM_EABI
reg_iret = TREG_R2;
reg_lret = TREG_R3;
#endif
gen_func:
/* call generic long long function */
vpush_global_sym(&func_old_type, func);
vrott(3);
gfunc_call(2);
vpushi(0);
vtop->r = reg_iret;
vtop->r2 = reg_lret;
break;
case '^':
case '&':
case '|':
case '*':
case '+':
case '-':
tccgen: 32bits: fix PTR +/- long long Previously in order to perform a ll+ll operation tcc was trying to 'lexpand' PTR in gen_opl which did not work well. The case: 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; }
2016-10-14 01:21:43 +08:00
//pv("gen_opl A",0,2);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
t = vtop->type.t;
vswap();
lexpand();
vrotb(3);
lexpand();
/* stack: L1 H1 L2 H2 */
tmp = vtop[0];
vtop[0] = vtop[-3];
vtop[-3] = tmp;
tmp = vtop[-2];
vtop[-2] = vtop[-3];
vtop[-3] = tmp;
vswap();
/* stack: H1 H2 L1 L2 */
tccgen: 32bits: fix PTR +/- long long Previously in order to perform a ll+ll operation tcc was trying to 'lexpand' PTR in gen_opl which did not work well. The case: 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; }
2016-10-14 01:21:43 +08:00
//pv("gen_opl B",0,4);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (op == '*') {
vpushv(vtop - 1);
vpushv(vtop - 1);
gen_op(TOK_UMULL);
lexpand();
/* stack: H1 H2 L1 L2 ML MH */
for(i=0;i<4;i++)
vrotb(6);
/* stack: ML MH H1 H2 L1 L2 */
tmp = vtop[0];
vtop[0] = vtop[-2];
vtop[-2] = tmp;
/* stack: ML MH H1 L2 H2 L1 */
gen_op('*');
vrotb(3);
vrotb(3);
gen_op('*');
/* stack: ML MH M1 M2 */
gen_op('+');
gen_op('+');
} else if (op == '+' || op == '-') {
/* XXX: add non carry method too (for MIPS or alpha) */
if (op == '+')
op1 = TOK_ADDC1;
else
op1 = TOK_SUBC1;
gen_op(op1);
/* stack: H1 H2 (L1 op L2) */
vrotb(3);
vrotb(3);
gen_op(op1 + 1); /* TOK_xxxC2 */
} else {
gen_op(op);
/* stack: H1 H2 (L1 op L2) */
vrotb(3);
vrotb(3);
/* stack: (L1 op L2) H1 H2 */
gen_op(op);
/* stack: (L1 op L2) (H1 op H2) */
}
/* stack: L H */
lbuild(t);
break;
case TOK_SAR:
case TOK_SHR:
case TOK_SHL:
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
t = vtop[-1].type.t;
vswap();
lexpand();
vrotb(3);
/* stack: L H shift */
c = (int)vtop->c.i;
/* constant: simpler */
/* NOTE: all comments are for SHL. the other cases are
Spelling fixes in C comments only
2017-05-08 12:38:09 +08:00
done by swapping words */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vpop();
if (op != TOK_SHL)
vswap();
if (c >= 32) {
/* stack: L H */
vpop();
if (c > 32) {
vpushi(c - 32);
gen_op(op);
}
if (op != TOK_SAR) {
vpushi(0);
} else {
gv_dup();
vpushi(31);
gen_op(TOK_SAR);
}
vswap();
} else {
vswap();
gv_dup();
/* stack: H L L */
vpushi(c);
gen_op(op);
vswap();
vpushi(32 - c);
if (op == TOK_SHL)
gen_op(TOK_SHR);
else
gen_op(TOK_SHL);
vrotb(3);
/* stack: L L H */
vpushi(c);
if (op == TOK_SHL)
gen_op(TOK_SHL);
else
gen_op(TOK_SHR);
gen_op('|');
}
if (op != TOK_SHL)
vswap();
lbuild(t);
} else {
/* XXX: should provide a faster fallback on x86 ? */
switch(op) {
case TOK_SAR:
func = TOK___ashrdi3;
goto gen_func;
case TOK_SHR:
func = TOK___lshrdi3;
goto gen_func;
case TOK_SHL:
func = TOK___ashldi3;
goto gen_func;
}
}
break;
default:
/* compare operations */
t = vtop->type.t;
vswap();
lexpand();
vrotb(3);
lexpand();
/* stack: L1 H1 L2 H2 */
tmp = vtop[-1];
vtop[-1] = vtop[-2];
vtop[-2] = tmp;
/* stack: L1 L2 H1 H2 */
/* compare high */
op1 = op;
/* when values are equal, we need to compare low words. since
the jump is inverted, we invert the test too. */
if (op1 == TOK_LT)
op1 = TOK_LE;
else if (op1 == TOK_GT)
op1 = TOK_GE;
else if (op1 == TOK_ULT)
op1 = TOK_ULE;
else if (op1 == TOK_UGT)
op1 = TOK_UGE;
a = 0;
b = 0;
gen_op(op1);
fixes & cleanups - tccgen.c/tcc.h: allow function declaration after use: int f() { return g(); } int g() { return 1; } may be a warning but not an error see also 76cb1144ef91924c53c57ea71e6f67ce73ce1cc6 - tccgen.c: redundant code related to inline functions removed (functions used anywhere have sym->c set automatically) - tccgen.c: make 32bit llop non-equal test portable (probably not on C67) - dynarray_add: change prototype to possibly avoid aliasing problems or at least warnings - lib/alloca*.S: ".section .note.GNU-stack,"",%progbits" removed (has no effect) - tccpe: set SizeOfCode field (for correct upx decompression) - libtcc.c: fixed alternative -run invocation tcc "-run -lxxx ..." file.c (meant to load the library after file). Also supported now: tcc files ... options ... -run @ arguments ...
2017-02-14 01:23:43 +08:00
if (op == TOK_NE) {
b = gvtst(0, 0);
} else {
Move logic for if (int value) to tccgen.c Move the logic to do a test of an integer value (ex if (0)) out of arch-specific code to tccgen.c to avoid code duplication. This also fixes test of long long value which was only testing the bottom half of such values on 32 bits architectures.
2013-12-31 23:51:20 +08:00
a = gvtst(1, 0);
fixes & cleanups - tccgen.c/tcc.h: allow function declaration after use: int f() { return g(); } int g() { return 1; } may be a warning but not an error see also 76cb1144ef91924c53c57ea71e6f67ce73ce1cc6 - tccgen.c: redundant code related to inline functions removed (functions used anywhere have sym->c set automatically) - tccgen.c: make 32bit llop non-equal test portable (probably not on C67) - dynarray_add: change prototype to possibly avoid aliasing problems or at least warnings - lib/alloca*.S: ".section .note.GNU-stack,"",%progbits" removed (has no effect) - tccpe: set SizeOfCode field (for correct upx decompression) - libtcc.c: fixed alternative -run invocation tcc "-run -lxxx ..." file.c (meant to load the library after file). Also supported now: tcc files ... options ... -run @ arguments ...
2017-02-14 01:23:43 +08:00
if (op != TOK_EQ) {
/* generate non equal test */
vpushi(TOK_NE);
vtop->r = VT_CMP;
Move logic for if (int value) to tccgen.c Move the logic to do a test of an integer value (ex if (0)) out of arch-specific code to tccgen.c to avoid code duplication. This also fixes test of long long value which was only testing the bottom half of such values on 32 bits architectures.
2013-12-31 23:51:20 +08:00
b = gvtst(0, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
/* compare low. Always unsigned */
op1 = op;
if (op1 == TOK_LT)
op1 = TOK_ULT;
else if (op1 == TOK_LE)
op1 = TOK_ULE;
else if (op1 == TOK_GT)
op1 = TOK_UGT;
else if (op1 == TOK_GE)
op1 = TOK_UGE;
gen_op(op1);
Move logic for if (int value) to tccgen.c Move the logic to do a test of an integer value (ex if (0)) out of arch-specific code to tccgen.c to avoid code duplication. This also fixes test of long long value which was only testing the bottom half of such values on 32 bits architectures.
2013-12-31 23:51:20 +08:00
a = gvtst(1, a);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(b);
vseti(VT_JMPI, a);
break;
}
}
#endif
tccgen.c: Avoid undefined behaviour in constant propagation.
2015-11-18 03:34:31 +08:00
static uint64_t gen_opic_sdiv(uint64_t a, uint64_t b)
{
uint64_t x = (a >> 63 ? -a : a) / (b >> 63 ? -b : b);
return (a ^ b) >> 63 ? -x : x;
}
static int gen_opic_lt(uint64_t a, uint64_t b)
{
return (a ^ (uint64_t)1 << 63) < (b ^ (uint64_t)1 << 63);
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* handle integer constant optimizations and various machine
independent opt */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void gen_opic(int op)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
tccgen.c: Avoid undefined behaviour in constant propagation.
2015-11-18 03:34:31 +08:00
SValue *v1 = vtop - 1;
SValue *v2 = vtop;
int t1 = v1->type.t & VT_BTYPE;
int t2 = v2->type.t & VT_BTYPE;
int c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
int c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
uint64_t l1 = c1 ? v1->c.i : 0;
uint64_t l2 = c2 ? v2->c.i : 0;
int shm = (t1 == VT_LLONG) ? 63 : 31;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
Fix const folding of 64bit pointer constants See testcase.
2016-10-04 07:20:33 +08:00
if (t1 != VT_LLONG && (PTR_SIZE != 8 || t1 != VT_PTR))
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
l1 = ((uint32_t)l1 |
(v1->type.t & VT_UNSIGNED ? 0 : -(l1 & 0x80000000)));
Fix const folding of 64bit pointer constants See testcase.
2016-10-04 07:20:33 +08:00
if (t2 != VT_LLONG && (PTR_SIZE != 8 || t2 != VT_PTR))
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
l2 = ((uint32_t)l2 |
(v2->type.t & VT_UNSIGNED ? 0 : -(l2 & 0x80000000)));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (c1 && c2) {
switch(op) {
case '+': l1 += l2; break;
case '-': l1 -= l2; break;
case '&': l1 &= l2; break;
case '^': l1 ^= l2; break;
case '|': l1 |= l2; break;
case '*': l1 *= l2; break;
case TOK_PDIV:
case '/':
case '%':
case TOK_UDIV:
case TOK_UMOD:
/* if division by zero, generate explicit division */
if (l2 == 0) {
if (const_wanted)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("division by zero in constant");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
goto general_case;
}
switch(op) {
tccgen.c: Avoid undefined behaviour in constant propagation.
2015-11-18 03:34:31 +08:00
default: l1 = gen_opic_sdiv(l1, l2); break;
case '%': l1 = l1 - l2 * gen_opic_sdiv(l1, l2); break;
case TOK_UDIV: l1 = l1 / l2; break;
case TOK_UMOD: l1 = l1 % l2; break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
break;
tccgen.c: Avoid undefined behaviour in constant propagation.
2015-11-18 03:34:31 +08:00
case TOK_SHL: l1 <<= (l2 & shm); break;
case TOK_SHR: l1 >>= (l2 & shm); break;
case TOK_SAR:
l1 = (l1 >> 63) ? ~(~l1 >> (l2 & shm)) : l1 >> (l2 & shm);
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* tests */
tccgen.c: Avoid undefined behaviour in constant propagation.
2015-11-18 03:34:31 +08:00
case TOK_ULT: l1 = l1 < l2; break;
case TOK_UGE: l1 = l1 >= l2; break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_EQ: l1 = l1 == l2; break;
case TOK_NE: l1 = l1 != l2; break;
tccgen.c: Avoid undefined behaviour in constant propagation.
2015-11-18 03:34:31 +08:00
case TOK_ULE: l1 = l1 <= l2; break;
case TOK_UGT: l1 = l1 > l2; break;
case TOK_LT: l1 = gen_opic_lt(l1, l2); break;
case TOK_GE: l1 = !gen_opic_lt(l1, l2); break;
case TOK_LE: l1 = !gen_opic_lt(l2, l1); break;
case TOK_GT: l1 = gen_opic_lt(l2, l1); break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* logical */
case TOK_LAND: l1 = l1 && l2; break;
case TOK_LOR: l1 = l1 || l2; break;
default:
goto general_case;
}
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
if (t1 != VT_LLONG && (PTR_SIZE != 8 || t1 != VT_PTR))
l1 = ((uint32_t)l1 |
(v1->type.t & VT_UNSIGNED ? 0 : -(l1 & 0x80000000)));
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
v1->c.i = l1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop--;
} else {
/* if commutative ops, put c2 as constant */
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (c1 && (op == '+' || op == '&' || op == '^' ||
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
op == '|' || op == '*')) {
vswap();
c2 = c1; //c = c1, c1 = c2, c2 = c;
l2 = l1; //l = l1, l1 = l2, l2 = l;
}
tccgen.c: Optimise 0<<x, 0>>x, -1>>x, x&0, x*0, x|-1, x%1. More precisely, treat (0 << x) and so on as constant expressions, but not if const_wanted as we do not want to allow "case (x*0):", ... Do not optimise (0 / x) and (0 % x) here as x might be zero, though for an architecture that does not generate an exception for division by zero the back end might choose to optimise those.
2015-03-07 19:25:27 +08:00
if (!const_wanted &&
c1 && ((l1 == 0 &&
(op == TOK_SHL || op == TOK_SHR || op == TOK_SAR)) ||
(l1 == -1 && op == TOK_SAR))) {
/* treat (0 << x), (0 >> x) and (-1 >> x) as constant */
vtop--;
} else if (!const_wanted &&
c2 && ((l2 == 0 && (op == '&' || op == '*')) ||
unsorted adjustments - configure * use aarch64 instead of arm64 - Makefile * rename the custom include file to "config-extra.mak" * Also avoid "rm -r /*" if $(tccdir) is empty - pp/Makefile * fix .expect generation with gcc - tcc.h * cleanup #defines for _MSC_VER - tccgen.c: * fix const-propagation for &,| * fix anonymous named struct (ms-extension) and enable -fms-extension by default - i386-gen.c * clear VT_DEFSIGN - x86_64-gen.c/win64: * fix passing structs in registers * fix alloca (need to keep "func_scratch" below each alloca area on stack) (This allows to compile a working gnu-make on win64) - tccpp.c * alternative approach to 37999a4fbf3487b363fd0c2f9b7ab622401b202a This is to avoid some slowdown with ## token pasting. * get_tok_str() : return <eof> for TOK_EOF * -funsigned-char: apply to "string" literals as well - tccpe/tools.c: -impdef: support both 32 and 64 bit dlls anyway
2017-07-09 18:07:40 +08:00
(op == '|' &&
(l2 == -1 || (l2 == 0xFFFFFFFF && t2 != VT_LLONG))) ||
tccgen.c: Optimise 0<<x, 0>>x, -1>>x, x&0, x*0, x|-1, x%1. More precisely, treat (0 << x) and so on as constant expressions, but not if const_wanted as we do not want to allow "case (x*0):", ... Do not optimise (0 / x) and (0 % x) here as x might be zero, though for an architecture that does not generate an exception for division by zero the back end might choose to optimise those.
2015-03-07 19:25:27 +08:00
(l2 == 1 && (op == '%' || op == TOK_UMOD)))) {
/* treat (x & 0), (x * 0), (x | -1) and (x % 1) as constant */
if (l2 == 1)
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.i = 0;
tccgen.c: Optimise 0<<x, 0>>x, -1>>x, x&0, x*0, x|-1, x%1. More precisely, treat (0 << x) and so on as constant expressions, but not if const_wanted as we do not want to allow "case (x*0):", ... Do not optimise (0 / x) and (0 % x) here as x might be zero, though for an architecture that does not generate an exception for division by zero the back end might choose to optimise those.
2015-03-07 19:25:27 +08:00
vswap();
vtop--;
} else if (c2 && (((op == '*' || op == '/' || op == TOK_UDIV ||
op == TOK_PDIV) &&
l2 == 1) ||
((op == '+' || op == '-' || op == '|' || op == '^' ||
op == TOK_SHL || op == TOK_SHR || op == TOK_SAR) &&
l2 == 0) ||
(op == '&' &&
unsorted adjustments - configure * use aarch64 instead of arm64 - Makefile * rename the custom include file to "config-extra.mak" * Also avoid "rm -r /*" if $(tccdir) is empty - pp/Makefile * fix .expect generation with gcc - tcc.h * cleanup #defines for _MSC_VER - tccgen.c: * fix const-propagation for &,| * fix anonymous named struct (ms-extension) and enable -fms-extension by default - i386-gen.c * clear VT_DEFSIGN - x86_64-gen.c/win64: * fix passing structs in registers * fix alloca (need to keep "func_scratch" below each alloca area on stack) (This allows to compile a working gnu-make on win64) - tccpp.c * alternative approach to 37999a4fbf3487b363fd0c2f9b7ab622401b202a This is to avoid some slowdown with ## token pasting. * get_tok_str() : return <eof> for TOK_EOF * -funsigned-char: apply to "string" literals as well - tccpe/tools.c: -impdef: support both 32 and 64 bit dlls anyway
2017-07-09 18:07:40 +08:00
(l2 == -1 || (l2 == 0xFFFFFFFF && t2 != VT_LLONG))))) {
tccgen.c: Optimise 0<<x, 0>>x, -1>>x, x&0, x*0, x|-1, x%1. More precisely, treat (0 << x) and so on as constant expressions, but not if const_wanted as we do not want to allow "case (x*0):", ... Do not optimise (0 / x) and (0 % x) here as x might be zero, though for an architecture that does not generate an exception for division by zero the back end might choose to optimise those.
2015-03-07 19:25:27 +08:00
/* filter out NOP operations like x*1, x-0, x&-1... */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop--;
} else if (c2 && (op == '*' || op == TOK_PDIV || op == TOK_UDIV)) {
/* try to use shifts instead of muls or divs */
if (l2 > 0 && (l2 & (l2 - 1)) == 0) {
tccgen.c: Avoid undefined behaviour in constant propagation.
2015-11-18 03:34:31 +08:00
int n = -1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
while (l2) {
l2 >>= 1;
n++;
}
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.i = n;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (op == '*')
op = TOK_SHL;
else if (op == TOK_PDIV)
op = TOK_SAR;
else
op = TOK_SHR;
}
goto general_case;
} else if (c2 && (op == '+' || op == '-') &&
tccpe: improve dllimport/export and use for tcc_add_symbol
2010-01-15 03:55:51 +08:00
(((vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) == (VT_CONST | VT_SYM))
|| (vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_LOCAL)) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* symbol + constant case */
if (op == '-')
l2 = -l2;
64bit: Fix addends > 32 bits If a symbolic reference is offsetted by a constant > 32bit the backends can't deal with that, so don't construct such values.
2016-10-09 06:44:22 +08:00
l2 += vtop[-1].c.i;
/* The backends can't always deal with addends to symbols
larger than +-1<<31. Don't construct such. */
if ((int)l2 != l2)
goto general_case;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop--;
64bit: Fix addends > 32 bits If a symbolic reference is offsetted by a constant > 32bit the backends can't deal with that, so don't construct such values.
2016-10-09 06:44:22 +08:00
vtop->c.i = l2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
general_case:
/* call low level op generator */
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
if (t1 == VT_LLONG || t2 == VT_LLONG ||
(PTR_SIZE == 8 && (t1 == VT_PTR || t2 == VT_PTR)))
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_opl(op);
else
gen_opi(op);
}
}
}
/* generate a floating point operation with constant propagation */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void gen_opif(int op)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int c1, c2;
SValue *v1, *v2;
unsorted adjustments - configure * use aarch64 instead of arm64 - Makefile * rename the custom include file to "config-extra.mak" * Also avoid "rm -r /*" if $(tccdir) is empty - pp/Makefile * fix .expect generation with gcc - tcc.h * cleanup #defines for _MSC_VER - tccgen.c: * fix const-propagation for &,| * fix anonymous named struct (ms-extension) and enable -fms-extension by default - i386-gen.c * clear VT_DEFSIGN - x86_64-gen.c/win64: * fix passing structs in registers * fix alloca (need to keep "func_scratch" below each alloca area on stack) (This allows to compile a working gnu-make on win64) - tccpp.c * alternative approach to 37999a4fbf3487b363fd0c2f9b7ab622401b202a This is to avoid some slowdown with ## token pasting. * get_tok_str() : return <eof> for TOK_EOF * -funsigned-char: apply to "string" literals as well - tccpe/tools.c: -impdef: support both 32 and 64 bit dlls anyway
2017-07-09 18:07:40 +08:00
#if defined _MSC_VER && defined _AMD64_
/* avoid bad optimization with f1 -= f2 for f1:-0.0, f2:0.0 */
volatile
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
long double f1, f2;
v1 = vtop - 1;
v2 = vtop;
/* currently, we cannot do computations with forward symbols */
c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
if (c1 && c2) {
if (v1->type.t == VT_FLOAT) {
f1 = v1->c.f;
f2 = v2->c.f;
} else if (v1->type.t == VT_DOUBLE) {
f1 = v1->c.d;
f2 = v2->c.d;
} else {
f1 = v1->c.ld;
f2 = v2->c.ld;
}
/* NOTE: we only do constant propagation if finite number (not
NaN or infinity) (ANSI spec) */
if (!ieee_finite(f1) || !ieee_finite(f2))
goto general_case;
switch(op) {
case '+': f1 += f2; break;
case '-': f1 -= f2; break;
case '*': f1 *= f2; break;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
case '/':
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (f2 == 0.0) {
Accept more floating point constant expressions the rules for constant expressions in static initializers are more relaxed than for integer constant expressions. We need to accept 0.0/0.0 in static initializers (in non-static initializers the potential exceptions need to be raised though, so no translation-time calculation then).
2017-12-25 19:44:29 +08:00
/* If not in initializer we need to potentially generate
FP exceptions at runtime, otherwise we want to fold. */
if (!const_wanted)
goto general_case;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
f1 /= f2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
/* XXX: also handles tests ? */
default:
goto general_case;
}
/* XXX: overflow test ? */
if (v1->type.t == VT_FLOAT) {
v1->c.f = f1;
} else if (v1->type.t == VT_DOUBLE) {
v1->c.d = f1;
} else {
v1->c.ld = f1;
}
vtop--;
} else {
general_case:
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
gen_opf(op);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
static int pointed_size(CType *type)
{
int align;
return type_size(pointed_type(type), &align);
}
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
static void vla_runtime_pointed_size(CType *type)
{
int align;
vla_runtime_type_size(pointed_type(type), &align);
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
static inline int is_null_pointer(SValue *p)
{
if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
return 0;
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
return ((p->type.t & VT_BTYPE) == VT_INT && (uint32_t)p->c.i == 0) ||
((p->type.t & VT_BTYPE) == VT_LLONG && p->c.i == 0) ||
((p->type.t & VT_BTYPE) == VT_PTR &&
Fix ptr type combining inside the ternary operator Make it match http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 (or http://port70.net/~nsz/c/c11/n1570.html#6.5.15p6).
2018-11-28 17:22:37 +08:00
(PTR_SIZE == 4 ? (uint32_t)p->c.i == 0 : p->c.i == 0) &&
Fix type completion for array types as well like qualifier merging the array sizes are merged as well for the operands of ?:, and they must not statically influence the types of decls. Also fix some style problems, spaces aren't stinky :)
2018-12-01 06:43:30 +08:00
((pointed_type(&p->type)->t & VT_BTYPE) == VT_VOID) &&
0 == (pointed_type(&p->type)->t & (VT_CONSTANT | VT_VOLATILE))
Fix ptr type combining inside the ternary operator Make it match http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 (or http://port70.net/~nsz/c/c11/n1570.html#6.5.15p6).
2018-11-28 17:22:37 +08:00
);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
static inline int is_integer_btype(int bt)
{
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
return (bt == VT_BYTE || bt == VT_SHORT ||
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
bt == VT_INT || bt == VT_LLONG);
}
Corrected spelling mistakes in comments and strings
2014-04-07 19:31:00 +08:00
/* check types for comparison or subtraction of pointers */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
static void check_comparison_pointer_types(SValue *p1, SValue *p2, int op)
{
CType *type1, *type2, tmp_type1, tmp_type2;
int bt1, bt2;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* null pointers are accepted for all comparisons as gcc */
if (is_null_pointer(p1) || is_null_pointer(p2))
return;
type1 = &p1->type;
type2 = &p2->type;
bt1 = type1->t & VT_BTYPE;
bt2 = type2->t & VT_BTYPE;
/* accept comparison between pointer and integer with a warning */
if ((is_integer_btype(bt1) || is_integer_btype(bt2)) && op != '-') {
if (op != TOK_LOR && op != TOK_LAND )
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("comparison between pointer and integer");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
return;
}
/* both must be pointers or implicit function pointers */
if (bt1 == VT_PTR) {
type1 = pointed_type(type1);
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
} else if (bt1 != VT_FUNC)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
goto invalid_operands;
if (bt2 == VT_PTR) {
type2 = pointed_type(type2);
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
} else if (bt2 != VT_FUNC) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
invalid_operands:
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("invalid operands to binary %s", get_tok_str(op, NULL));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if ((type1->t & VT_BTYPE) == VT_VOID ||
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
(type2->t & VT_BTYPE) == VT_VOID)
return;
tmp_type1 = *type1;
tmp_type2 = *type2;
Def signedness != signed != unsigned for char When checking for exact compatibility between types (such as in __builtin_types_compatible_p) consider the case of default signedness to be incompatible with both of the explicit signedness for char. That is, char is incompatible with signed char *and* unsigned char, no matter what the default signedness for char is.
2014-02-06 20:51:47 +08:00
tmp_type1.t &= ~(VT_DEFSIGN | VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
tmp_type2.t &= ~(VT_DEFSIGN | VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (!is_compatible_types(&tmp_type1, &tmp_type2)) {
/* gcc-like error if '-' is used */
if (op == '-')
goto invalid_operands;
else
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("comparison of distinct pointer types lacks a cast");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
/* generic gen_op: handles types problems */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void gen_op(int op)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int u, t1, t2, bt1, bt2, t;
CType type1;
Fix function to pointer conversion This snippet is valid: void foo(void); ... foo + 42 ... the function designator is converted to pointer to function implicitely. gen_op didn't do that and bailed out.
2016-07-14 10:09:49 +08:00
redo:
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
t1 = vtop[-1].type.t;
t2 = vtop[0].type.t;
bt1 = t1 & VT_BTYPE;
bt2 = t2 & VT_BTYPE;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
Error out on operations on structs The check for structs was too late and on amd64 and aarch64 could lead to accepting and then asserting with code like: struct S {...} s; char *c = (char*)0x10 - s;
2016-05-12 07:12:04 +08:00
if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) {
tcc_error("operation on a struct");
Fix function to pointer conversion This snippet is valid: void foo(void); ... foo + 42 ... the function designator is converted to pointer to function implicitely. gen_op didn't do that and bailed out.
2016-07-14 10:09:49 +08:00
} else if (bt1 == VT_FUNC || bt2 == VT_FUNC) {
if (bt2 == VT_FUNC) {
mk_pointer(&vtop->type);
gaddrof();
}
if (bt1 == VT_FUNC) {
vswap();
mk_pointer(&vtop->type);
gaddrof();
vswap();
}
goto redo;
Error out on operations on structs The check for structs was too late and on amd64 and aarch64 could lead to accepting and then asserting with code like: struct S {...} s; char *c = (char*)0x10 - s;
2016-05-12 07:12:04 +08:00
} else if (bt1 == VT_PTR || bt2 == VT_PTR) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* at least one operand is a pointer */
Spelling fixes in C comments only
2017-05-08 12:38:09 +08:00
/* relational op: must be both pointers */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (op >= TOK_ULT && op <= TOK_LOR) {
check_comparison_pointer_types(vtop - 1, vtop, op);
/* pointers are handled are unsigned */
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
t = VT_LLONG | VT_UNSIGNED;
#else
t = VT_INT | VT_UNSIGNED;
#endif
goto std_op;
}
/* if both pointers, then it must be the '-' op */
if (bt1 == VT_PTR && bt2 == VT_PTR) {
if (op != '-')
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("cannot use pointers here");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
check_comparison_pointer_types(vtop - 1, vtop, op);
/* XXX: check that types are compatible */
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
if (vtop[-1].type.t & VT_VLA) {
vla_runtime_pointed_size(&vtop[-1].type);
} else {
simplify/rollback VLA pointer subtraction I don't know if it makes a difference to gen_op(TOK_PDIV) or not, but logically the ptr1_is_vla test in TP's VLA patch seems out of order, where the patch to fix it would be: ------------------------------------------------------------------ @@ -1581,15 +1581,15 @@ ST_FUNC void gen_op(int op) u = pointed_size(&vtop[-1].type); } gen_opic(op); + if (ptr1_is_vla) + vswap(); /* set to integer type */ #ifdef TCC_TARGET_X86_64 vtop->type.t = VT_LLONG; #else vtop->type.t = VT_INT; #endif - if (ptr1_is_vla) - vswap(); - else + if (!ptr1_is_vla) vpushi(u); gen_op(TOK_PDIV); } else { ------------------------------------------------------------------ Instead of that patch, which increases the complexity of the code, this one fixes the problem by just rolling back and retrying with a simpler approach.
2011-04-12 14:39:27 +08:00
vpushi(pointed_size(&vtop[-1].type));
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
}
simplify/rollback VLA pointer subtraction I don't know if it makes a difference to gen_op(TOK_PDIV) or not, but logically the ptr1_is_vla test in TP's VLA patch seems out of order, where the patch to fix it would be: ------------------------------------------------------------------ @@ -1581,15 +1581,15 @@ ST_FUNC void gen_op(int op) u = pointed_size(&vtop[-1].type); } gen_opic(op); + if (ptr1_is_vla) + vswap(); /* set to integer type */ #ifdef TCC_TARGET_X86_64 vtop->type.t = VT_LLONG; #else vtop->type.t = VT_INT; #endif - if (ptr1_is_vla) - vswap(); - else + if (!ptr1_is_vla) vpushi(u); gen_op(TOK_PDIV); } else { ------------------------------------------------------------------ Instead of that patch, which increases the complexity of the code, this one fixes the problem by just rolling back and retrying with a simpler approach.
2011-04-12 14:39:27 +08:00
vrott(3);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_opic(op);
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
vtop->type.t = ptrdiff_type.t;
simplify/rollback VLA pointer subtraction I don't know if it makes a difference to gen_op(TOK_PDIV) or not, but logically the ptr1_is_vla test in TP's VLA patch seems out of order, where the patch to fix it would be: ------------------------------------------------------------------ @@ -1581,15 +1581,15 @@ ST_FUNC void gen_op(int op) u = pointed_size(&vtop[-1].type); } gen_opic(op); + if (ptr1_is_vla) + vswap(); /* set to integer type */ #ifdef TCC_TARGET_X86_64 vtop->type.t = VT_LLONG; #else vtop->type.t = VT_INT; #endif - if (ptr1_is_vla) - vswap(); - else + if (!ptr1_is_vla) vpushi(u); gen_op(TOK_PDIV); } else { ------------------------------------------------------------------ Instead of that patch, which increases the complexity of the code, this one fixes the problem by just rolling back and retrying with a simpler approach.
2011-04-12 14:39:27 +08:00
vswap();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_op(TOK_PDIV);
} else {
/* exactly one pointer : must be '+' or '-'. */
if (op != '-' && op != '+')
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("cannot use pointers here");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* Put pointer as first operand */
if (bt2 == VT_PTR) {
vswap();
tccgen: factor out gfunc_return Also: - on windows i386 and x86-64, structures of size <= 8 are NOT returned in registers if size is not one of 1,2,4,8. - cleanup: put all tv-push/pop/swap/rot into one place
2017-02-09 02:45:31 +08:00
t = t1, t1 = t2, t2 = t;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen: 32bits: fix PTR +/- long long Previously in order to perform a ll+ll operation tcc was trying to 'lexpand' PTR in gen_opl which did not work well. The case: 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; }
2016-10-14 01:21:43 +08:00
#if PTR_SIZE == 4
if ((vtop[0].type.t & VT_BTYPE) == VT_LLONG)
/* XXX: truncate here because gen_opl can't handle ptr + long long */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
gen_cast_s(VT_INT);
tccgen: 32bits: fix PTR +/- long long Previously in order to perform a ll+ll operation tcc was trying to 'lexpand' PTR in gen_opl which did not work well. The case: 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; }
2016-10-14 01:21:43 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type1 = vtop[-1].type;
VLA fix [2/3]: removed VT_ARRAY from VT_VLA types A VLA is not really an array, it's a pointer-to-an-array. Making this explicit allows us to back out a few parts of the original VLA patch and paves the way for the next part of the fix, where a VLA will be stored on the runtime stack as a pointer-to-an-array, rather than on the compile- time stack as a Sym*.
2011-04-08 16:09:39 +08:00
type1.t &= ~VT_ARRAY;
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
if (vtop[-1].type.t & VT_VLA)
vla_runtime_pointed_size(&vtop[-1].type);
else {
u = pointed_size(&vtop[-1].type);
if (u < 0)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("unknown array element size");
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
vpushll(u);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#else
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
/* XXX: cast to int ? (long long case) */
vpushi(u);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#endif
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_op('*');
a bounds checking code for the ARCH=x86_64
2015-04-10 20:17:22 +08:00
#if 0
/* #ifdef CONFIG_TCC_BCHECK
The main reason to removing this code:
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
#include <stdio.h>
int main ()
{
int v[10];
int i = 10;
int j = 9;
fprintf(stderr, "v+i-j = %p\n", v+i-j);
fprintf(stderr, "v+(i-j) = %p\n", v+(i-j));
}
When this code is on. then the output looks like
v+i-j = 0xfffffffe
v+(i-j) = 0xbff84000
a bounds checking code for the ARCH=x86_64
2015-04-10 20:17:22 +08:00
*/
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* if evaluating constant expression, no code should be
generated, so no bound check */
move some global variables into TCCState
2009-05-12 00:45:44 +08:00
if (tcc_state->do_bounds_check && !const_wanted) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* if bounded pointers, we generate a special code to
test bounds */
if (op == '-') {
vpushi(0);
vswap();
gen_op('-');
}
gen_bounded_ptr_add();
} else
#endif
{
gen_opic(op);
}
/* put again type if gen_opic() swaped operands */
vtop->type = type1;
}
} else if (is_float(bt1) || is_float(bt2)) {
/* compute bigger type and do implicit casts */
if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
t = VT_LDOUBLE;
} else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
t = VT_DOUBLE;
} else {
t = VT_FLOAT;
}
/* floats can only be used for a few operations */
if (op != '+' && op != '-' && op != '*' && op != '/' &&
(op < TOK_ULT || op > TOK_GT))
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("invalid operands for binary operation");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
goto std_op;
Incorrect shift result type with 64-bit ABI On 2012-06-26 15:07:57 +0200, Vincent Lefevre wrote: > 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." I've written a patch (attached). Now the shift problems no longer occur with the testcase and with GNU MPFR's "make check". -- Vincent Lefèvre <vincent@vinc17.net> - Web: <http://www.vinc17.net/> 100% accessible validated (X)HTML - Blog: <http://www.vinc17.net/blog/> Work: CR INRIA - computer arithmetic / AriC project (LIP, ENS-Lyon)
2012-06-27 19:31:44 +08:00
} else if (op == TOK_SHR || op == TOK_SAR || op == TOK_SHL) {
Incorrect shift result type on unsigned short first argument. The code for shifts is now similar to code for binary arithmetic operations, except that only the first argument is considered, as required by the ISO C standard.
2012-07-06 20:22:37 +08:00
t = bt1 == VT_LLONG ? VT_LLONG : VT_INT;
bitfields: promote to signed int For integer promotion with for example arithmetics or expr_cond (x ? y : z), integral types need to be promoted to signed if they fit. According to latest standards, this also applies to bit-field types taking into account their specific width. In tcc, VT_BITFIELD set means width < original type width Field-widths between 33 and 63 are promoted to signed long long accordingly. struct { unsigned long long ullb:35; } s = { 1 }; #define X (s.ullb - 2) int main (void) { long long Y = X; printf("%d %016llx %016llx\n", X < 0, -X, -Y); return 0; } Results: GCC 4.7 : 0 0000000000000001 FFFFFFF800000001 MSVC : 1 0000000000000001 0000000000000001 TCC : 1 0000000000000001 0000000000000001 Also, gcc would promote long long bitfields of size < 32 to int as well. Example: struct { unsigned long long x:20; } t = { 123 }; /* with gcc: */ printf("%d %d\n", t.x, 456); /* with tcc: */ printf("%lld %d\n", t.x, 456);
2017-05-10 00:36:24 +08:00
if ((t1 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (t | VT_UNSIGNED))
Incorrect shift result type on unsigned short first argument. The code for shifts is now similar to code for binary arithmetic operations, except that only the first argument is considered, as required by the ISO C standard.
2012-07-06 20:22:37 +08:00
t |= VT_UNSIGNED;
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t |= (VT_LONG & t1);
Incorrect shift result type with 64-bit ABI On 2012-06-26 15:07:57 +0200, Vincent Lefevre wrote: > 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." I've written a patch (attached). Now the shift problems no longer occur with the testcase and with GNU MPFR's "make check". -- Vincent Lefèvre <vincent@vinc17.net> - Web: <http://www.vinc17.net/> 100% accessible validated (X)HTML - Blog: <http://www.vinc17.net/blog/> Work: CR INRIA - computer arithmetic / AriC project (LIP, ENS-Lyon)
2012-06-27 19:31:44 +08:00
goto std_op;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
/* cast to biggest op */
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t = VT_LLONG | VT_LONG;
if (bt1 == VT_LLONG)
t &= t1;
if (bt2 == VT_LLONG)
t &= t2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* convert to unsigned if it does not fit in a long long */
bitfields: promote to signed int For integer promotion with for example arithmetics or expr_cond (x ? y : z), integral types need to be promoted to signed if they fit. According to latest standards, this also applies to bit-field types taking into account their specific width. In tcc, VT_BITFIELD set means width < original type width Field-widths between 33 and 63 are promoted to signed long long accordingly. struct { unsigned long long ullb:35; } s = { 1 }; #define X (s.ullb - 2) int main (void) { long long Y = X; printf("%d %016llx %016llx\n", X < 0, -X, -Y); return 0; } Results: GCC 4.7 : 0 0000000000000001 FFFFFFF800000001 MSVC : 1 0000000000000001 0000000000000001 TCC : 1 0000000000000001 0000000000000001 Also, gcc would promote long long bitfields of size < 32 to int as well. Example: struct { unsigned long long x:20; } t = { 123 }; /* with gcc: */ printf("%d %d\n", t.x, 456); /* with tcc: */ printf("%lld %d\n", t.x, 456);
2017-05-10 00:36:24 +08:00
if ((t1 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_LLONG | VT_UNSIGNED) ||
(t2 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_LLONG | VT_UNSIGNED))
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
t |= VT_UNSIGNED;
goto std_op;
} else {
/* integer operations */
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t = VT_INT | (VT_LONG & (t1 | t2));
/* convert to unsigned if it does not fit in an integer */
bitfields: promote to signed int For integer promotion with for example arithmetics or expr_cond (x ? y : z), integral types need to be promoted to signed if they fit. According to latest standards, this also applies to bit-field types taking into account their specific width. In tcc, VT_BITFIELD set means width < original type width Field-widths between 33 and 63 are promoted to signed long long accordingly. struct { unsigned long long ullb:35; } s = { 1 }; #define X (s.ullb - 2) int main (void) { long long Y = X; printf("%d %016llx %016llx\n", X < 0, -X, -Y); return 0; } Results: GCC 4.7 : 0 0000000000000001 FFFFFFF800000001 MSVC : 1 0000000000000001 0000000000000001 TCC : 1 0000000000000001 0000000000000001 Also, gcc would promote long long bitfields of size < 32 to int as well. Example: struct { unsigned long long x:20; } t = { 123 }; /* with gcc: */ printf("%d %d\n", t.x, 456); /* with tcc: */ printf("%lld %d\n", t.x, 456);
2017-05-10 00:36:24 +08:00
if ((t1 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_INT | VT_UNSIGNED) ||
(t2 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_INT | VT_UNSIGNED))
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
t |= VT_UNSIGNED;
std_op:
/* XXX: currently, some unsigned operations are explicit, so
we modify them here */
if (t & VT_UNSIGNED) {
if (op == TOK_SAR)
op = TOK_SHR;
else if (op == '/')
op = TOK_UDIV;
else if (op == '%')
op = TOK_UMOD;
else if (op == TOK_LT)
op = TOK_ULT;
else if (op == TOK_GT)
op = TOK_UGT;
else if (op == TOK_LE)
op = TOK_ULE;
else if (op == TOK_GE)
op = TOK_UGE;
}
vswap();
type1.t = t;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
type1.ref = NULL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_cast(&type1);
vswap();
/* special case for shifts and long long: we keep the shift as
an integer */
if (op == TOK_SHR || op == TOK_SAR || op == TOK_SHL)
type1.t = VT_INT;
gen_cast(&type1);
if (is_float(t))
gen_opif(op);
else
gen_opic(op);
if (op >= TOK_ULT && op <= TOK_GT) {
Spelling fixes in C comments only
2017-05-08 12:38:09 +08:00
/* relational op: the result is an int */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop->type.t = VT_INT;
} else {
vtop->type.t = t;
}
}
tccgen.c: Make sure that gen_op always returns an rvalue. Either this fix, or an alternative one, is required for arm64.
2015-02-21 06:18:41 +08:00
// Make sure that we have converted to an rvalue:
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
if (vtop->r & VT_LVAL)
tccgen.c: Make sure that gen_op always returns an rvalue. Either this fix, or an alternative one, is required for arm64.
2015-02-21 06:18:41 +08:00
gv(is_float(vtop->type.t & VT_BTYPE) ? RC_FLOAT : RC_INT);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
#ifndef TCC_TARGET_ARM
/* generic itof for unsigned long long case */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void gen_cvt_itof1(int t)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#ifdef TCC_TARGET_ARM64
gen_cvt_itof(t);
#else
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
(VT_LLONG | VT_UNSIGNED)) {
if (t == VT_FLOAT)
vpush_global_sym(&func_old_type, TOK___floatundisf);
#if LDOUBLE_SIZE != 8
else if (t == VT_LDOUBLE)
vpush_global_sym(&func_old_type, TOK___floatundixf);
#endif
else
vpush_global_sym(&func_old_type, TOK___floatundidf);
vrott(2);
gfunc_call(1);
vpushi(0);
vtop->r = reg_fret(t);
} else {
gen_cvt_itof(t);
}
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
#endif
/* generic ftoi for unsigned long long case */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void gen_cvt_ftoi1(int t)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#ifdef TCC_TARGET_ARM64
gen_cvt_ftoi(t);
#else
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
int st;
if (t == (VT_LLONG | VT_UNSIGNED)) {
/* not handled natively */
st = vtop->type.t & VT_BTYPE;
if (st == VT_FLOAT)
vpush_global_sym(&func_old_type, TOK___fixunssfdi);
#if LDOUBLE_SIZE != 8
else if (st == VT_LDOUBLE)
vpush_global_sym(&func_old_type, TOK___fixunsxfdi);
#endif
else
vpush_global_sym(&func_old_type, TOK___fixunsdfdi);
vrott(2);
gfunc_call(1);
vpushi(0);
vtop->r = REG_IRET;
vtop->r2 = REG_LRET;
} else {
gen_cvt_ftoi(t);
}
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
/* force char or short cast */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
static void force_charshort_cast(int t)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int bits, dbt;
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
/* cannot cast static initializers */
if (STATIC_DATA_WANTED)
return;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
dbt = t & VT_BTYPE;
/* XXX: add optimization if lvalue : just change type and offset */
if (dbt == VT_BYTE)
bits = 8;
else
bits = 16;
if (t & VT_UNSIGNED) {
vpushi((1 << bits) - 1);
gen_op('&');
} else {
tccgen: fix long long -> char/short cast This was causing assembler bugs in a tcc compiled by itself at i386-asm.c:352 when ExprValue.v was changed to uint64_t: if (op->e.v == (int8_t)op->e.v) op->type |= OP_IM8S; A general test case: #include <stdio.h> int main(int argc, char **argv) { long long ll = 4000; int i = (char)ll; printf("%d\n", i); return 0; } Output was "4000", now "-96". Also: add "asmtest2" as asmtest with tcc compiled by itself
2016-10-02 07:38:22 +08:00
if ((vtop->type.t & VT_BTYPE) == VT_LLONG)
bits = 64 - bits;
else
bits = 32 - bits;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vpushi(bits);
gen_op(TOK_SHL);
/* result must be signed or the SAR is converted to an SHL
This was not the case when "t" was a signed short
and the last value on the stack was an unsigned int */
vtop->type.t &= ~VT_UNSIGNED;
vpushi(bits);
gen_op(TOK_SAR);
}
}
/* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
static void gen_cast_s(int t)
{
CType type;
type.t = t;
type.ref = NULL;
gen_cast(&type);
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
static void gen_cast(CType *type)
{
int sbt, dbt, sf, df, c, p;
/* special delayed cast for char/short */
/* XXX: in some cases (multiple cascaded casts), it may still
be incorrect */
if (vtop->r & VT_MUSTCAST) {
vtop->r &= ~VT_MUSTCAST;
force_charshort_cast(vtop->type.t);
}
/* bitfields first get cast to ints */
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
if (vtop->type.t & VT_BITFIELD) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gv(RC_INT);
}
dbt = type->t & (VT_BTYPE | VT_UNSIGNED);
sbt = vtop->type.t & (VT_BTYPE | VT_UNSIGNED);
if (sbt != dbt) {
sf = is_float(sbt);
df = is_float(dbt);
c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
p = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == (VT_CONST | VT_SYM);
various stuff win32/Makefile ("for cygwin") removed - On cygwin, the normal ./configure && make can be used with either cygwin's "GCC for Win32 Toolchain" ./configure --cross-prefix=i686-w64-mingw32- or with an existing tcc: ./configure --cc=<old-tccdir>/tcc.exe tcctest.c: - exclude test_high_clobbers() on _WIN64 (does not work) tests2/95_bitfield.c: - use 'signed char' for ARM (where default 'char' is unsigned) tests: - remove -I "expr" diff option to allow tests with busybox-diff. libtcc.c, tcc.c: - removed -iwithprefix option. It is supposed to be combined with -iprefix which we don't have either. tccgen.c: - fix assignments and return of 'void', as in void f() { void *p, *q; *p = *q: return *p; } This appears to be allowed but should do nothing. tcc.h, libtcc.c, tccpp.c: - Revert "Introduce VIP sysinclude paths which are always searched first" This reverts commit 1d5e386b0a78393ac6b670c209a185849ec798a1. The patch was giving tcc's system includes priority over -I which is not how it should be. tccelf.c: - add DT_TEXTREL tag only if text relocations are actually used (which is likely not the case on x86_64) - prepare_dynamic_rel(): avoid relocation of unresolved (weak) symbols tccrun.c: - for HAVE_SELINUX, use two mappings to the same (real) file. (it was so once except the RX mapping wasn't used at all). tccpe.c: - fix relocation constant used for x86_64 (by Andrei E. Warentin) - #ifndef _WIN32 do "chmod 755 ..." to get runnable exes on cygwin. tccasm.c: - keep forward asm labels static, otherwise they will endup in dynsym eventually. configure, Makefile: - mingw32: respect ./configure options --bindir --docdir --libdir - allow overriding tcc when building libtcc1.a and libtcc.def with make XTCC=<tcc program to use> - use $(wildcard ...) for install to allow installing just a cross compiler for example make cross-arm make install - use name <target>-libtcc1.a build-tcc.bat: - add options: -clean, -b bindir
2017-10-12 00:13:43 +08:00
#if !defined TCC_IS_NATIVE && !defined TCC_IS_NATIVE_387
c &= dbt != VT_LDOUBLE;
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (c) {
/* constant case: we can do it now */
/* XXX: in ISOC, cannot do it if error in convert */
if (sbt == VT_FLOAT)
vtop->c.ld = vtop->c.f;
else if (sbt == VT_DOUBLE)
vtop->c.ld = vtop->c.d;
if (df) {
if ((sbt & VT_BTYPE) == VT_LLONG) {
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
if ((sbt & VT_UNSIGNED) || !(vtop->c.i >> 63))
vtop->c.ld = vtop->c.i;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
else
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.ld = -(long double)-vtop->c.i;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if(!sf) {
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
if ((sbt & VT_UNSIGNED) || !(vtop->c.i >> 31))
vtop->c.ld = (uint32_t)vtop->c.i;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
else
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.ld = -(long double)-(uint32_t)vtop->c.i;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
if (dbt == VT_FLOAT)
vtop->c.f = (float)vtop->c.ld;
else if (dbt == VT_DOUBLE)
vtop->c.d = (double)vtop->c.ld;
} else if (sf && dbt == (VT_LLONG|VT_UNSIGNED)) {
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.i = vtop->c.ld;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (sf && dbt == VT_BOOL) {
vtop->c.i = (vtop->c.ld != 0);
} else {
if(sf)
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.i = vtop->c.ld;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
else if (sbt == (VT_LLONG|VT_UNSIGNED))
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
else if (sbt & VT_UNSIGNED)
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.i = (uint32_t)vtop->c.i;
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
x86-64: Fix Wrong comparisonbetweenpointerandlongcste main (int argc, char *argv[]) { char *p = (char *)0x12345678ABCD000F; int res; res = (p != (char *)0x12345678ABCD000F); return res; }
2009-12-16 00:45:15 +08:00
else if (sbt == VT_PTR)
;
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
else if (sbt != VT_LLONG)
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.i = ((uint32_t)vtop->c.i |
-(vtop->c.i & 0x80000000));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (dbt == (VT_LLONG|VT_UNSIGNED))
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
else if (dbt == VT_BOOL)
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.i = (vtop->c.i != 0);
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
Fix Fixes for PE x86_64 for fail in code Applying 64bit relocs assumes that the CVal is initialized to zero for the whole 64bit. Consolidate this a bit, at the same time zeroing the .ull member more consistently when needed. Fixes segfault on x86_64-linux using global vars in tcctest.c.
2014-01-12 06:42:58 +08:00
else if (dbt == VT_PTR)
;
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
else if (dbt != VT_LLONG) {
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
uint32_t m = ((dbt & VT_BTYPE) == VT_BYTE ? 0xff :
(dbt & VT_BTYPE) == VT_SHORT ? 0xffff :
0xffffffff);
vtop->c.i &= m;
if (!(dbt & VT_UNSIGNED))
vtop->c.i |= -(vtop->c.i & ((m >> 1) + 1));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
} else if (p && dbt == VT_BOOL) {
vtop->r = VT_CONST;
vtop->c.i = 1;
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
} else {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* non constant case: generate code */
if (sf && df) {
/* convert from fp to fp */
gen_cvt_ftof(dbt);
} else if (df) {
/* convert int to fp */
gen_cvt_itof1(dbt);
} else if (sf) {
/* convert fp to int */
if (dbt == VT_BOOL) {
vpushi(0);
gen_op(TOK_NE);
} else {
/* we handle char/short/etc... with generic code */
if (dbt != (VT_INT | VT_UNSIGNED) &&
dbt != (VT_LLONG | VT_UNSIGNED) &&
dbt != VT_LLONG)
dbt = VT_INT;
gen_cvt_ftoi1(dbt);
if (dbt == VT_INT && (type->t & (VT_BTYPE | VT_UNSIGNED)) != dbt) {
/* additional cast for char/short... */
vtop->type.t = dbt;
gen_cast(type);
}
}
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 4
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if ((dbt & VT_BTYPE) == VT_LLONG) {
tccgen/32bits: fix unsigned long long -> int cast gen_cast() failed to truncate long long's if they were unsigned, which was causing mess on the vstack. There was a similar bug here tccgen: 32bits: fix PTR +/- long long ed15cddacd145c74e4600af50f6616ba59ca0d8d Both were not visible until this patch tccgen: arm/i386: save_reg_upstack b691585785086024549cfb9ac65f3397263965aa I'd still assume that this patch is correct per se. Also: - remove 2x !nocode_wanted (we are already under a general "else if (!nocode_wanted)" clause above).
2016-10-16 17:03:57 +08:00
if ((sbt & VT_BTYPE) != VT_LLONG) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* scalar to long long */
/* machine independent conversion */
gv(RC_INT);
/* generate high word */
if (sbt == (VT_INT | VT_UNSIGNED)) {
vpushi(0);
gv(RC_INT);
} else {
if (sbt == VT_PTR) {
/* cast from pointer to int before we apply
shift operation, which pointers don't support*/
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
gen_cast_s(VT_INT);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
gv_dup();
vpushi(31);
gen_op(TOK_SAR);
}
/* patch second register */
vtop[-1].r2 = vtop->r;
vpop();
}
#else
} else if ((dbt & VT_BTYPE) == VT_LLONG ||
Fix casts from 32bit integer types to 64bit integer types. This bug was reported in http://lists.gnu.org/archive/html/tinycc-devel/2010-08/msg00050.html In this case, we should not emit any code when we cast from VT_FUNC to VT_PTR.
2010-08-31 07:35:31 +08:00
(dbt & VT_BTYPE) == VT_PTR ||
(dbt & VT_BTYPE) == VT_FUNC) {
if ((sbt & VT_BTYPE) != VT_LLONG &&
(sbt & VT_BTYPE) != VT_PTR &&
tccgen/32bits: fix unsigned long long -> int cast gen_cast() failed to truncate long long's if they were unsigned, which was causing mess on the vstack. There was a similar bug here tccgen: 32bits: fix PTR +/- long long ed15cddacd145c74e4600af50f6616ba59ca0d8d Both were not visible until this patch tccgen: arm/i386: save_reg_upstack b691585785086024549cfb9ac65f3397263965aa I'd still assume that this patch is correct per se. Also: - remove 2x !nocode_wanted (we are already under a general "else if (!nocode_wanted)" clause above).
2016-10-16 17:03:57 +08:00
(sbt & VT_BTYPE) != VT_FUNC) {
Fix casts from 32bit integer types to 64bit integer types. This bug was reported in http://lists.gnu.org/archive/html/tinycc-devel/2010-08/msg00050.html In this case, we should not emit any code when we cast from VT_FUNC to VT_PTR.
2010-08-31 07:35:31 +08:00
/* need to convert from 32bit to 64bit */
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
gv(RC_INT);
Fix casts from 32bit integer types to 64bit integer types. This bug was reported in http://lists.gnu.org/archive/html/tinycc-devel/2010-08/msg00050.html In this case, we should not emit any code when we cast from VT_FUNC to VT_PTR.
2010-08-31 07:35:31 +08:00
if (sbt != (VT_INT | VT_UNSIGNED)) {
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#if defined(TCC_TARGET_ARM64)
gen_cvt_sxtw();
#elif defined(TCC_TARGET_X86_64)
int r = gv(RC_INT);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* x86_64 specific: movslq */
o(0x6348);
o(0xc0 + (REG_VALUE(r) << 3) + REG_VALUE(r));
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#else
#error
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
#endif
} else if (dbt == VT_BOOL) {
/* scalar to bool */
vpushi(0);
gen_op(TOK_NE);
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
} else if ((dbt & VT_BTYPE) == VT_BYTE ||
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
(dbt & VT_BTYPE) == VT_SHORT) {
if (sbt == VT_PTR) {
vtop->type.t = VT_INT;
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("nonportable conversion from pointer to char/short");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
force_charshort_cast(dbt);
} else if ((dbt & VT_BTYPE) == VT_INT) {
/* scalar to int */
tccgen/32bits: fix unsigned long long -> int cast gen_cast() failed to truncate long long's if they were unsigned, which was causing mess on the vstack. There was a similar bug here tccgen: 32bits: fix PTR +/- long long ed15cddacd145c74e4600af50f6616ba59ca0d8d Both were not visible until this patch tccgen: arm/i386: save_reg_upstack b691585785086024549cfb9ac65f3397263965aa I'd still assume that this patch is correct per se. Also: - remove 2x !nocode_wanted (we are already under a general "else if (!nocode_wanted)" clause above).
2016-10-16 17:03:57 +08:00
if ((sbt & VT_BTYPE) == VT_LLONG) {
Fix shortening casts of long long see added testcase.
2018-04-01 03:52:20 +08:00
#if PTR_SIZE == 4
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* from long long: just take low order word */
lexpand();
vpop();
Fix shortening casts of long long see added testcase.
2018-04-01 03:52:20 +08:00
#else
vpushi(0xffffffff);
vtop->type.t |= VT_UNSIGNED;
gen_op('&');
#endif
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* if lvalue and single word type, nothing to do because
the lvalue already contains the real type size (see
VT_LVAL_xxx constants) */
}
}
} else if ((dbt & VT_BTYPE) == VT_PTR && !(vtop->r & VT_LVAL)) {
/* if we are casting between pointer types,
we must update the VT_LVAL_xxx size */
vtop->r = (vtop->r & ~VT_LVAL_TYPE)
| (lvalue_type(type->ref->type.t) & VT_LVAL_TYPE);
}
vtop->type = *type;
Make casts lose top-level qualifiers TODO: also make them lose lvalue status
2018-11-21 02:24:24 +08:00
vtop->type.t &= ~ ( VT_CONSTANT | VT_VOLATILE | VT_ARRAY );
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
/* return type size as known at compile time. Put alignment at 'a' */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC int type_size(CType *type, int *a)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Sym *s;
int bt;
bt = type->t & VT_BTYPE;
if (bt == VT_STRUCT) {
/* struct/union */
s = type->ref;
revert complicated & broken flexible array member handling
2011-03-19 08:47:35 +08:00
*a = s->r;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
return s->c;
} else if (bt == VT_PTR) {
VLA fix [2/3]: removed VT_ARRAY from VT_VLA types A VLA is not really an array, it's a pointer-to-an-array. Making this explicit allows us to back out a few parts of the original VLA patch and paves the way for the next part of the fix, where a VLA will be stored on the runtime stack as a pointer-to-an-array, rather than on the compile- time stack as a Sym*.
2011-04-08 16:09:39 +08:00
if (type->t & VT_ARRAY) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
int ts;
s = type->ref;
ts = type_size(&s->type, a);
if (ts < 0 && s->c < 0)
ts = -ts;
return ts * s->c;
} else {
*a = PTR_SIZE;
return PTR_SIZE;
}
Don't endlessly recurse on invalid nested typedefs see testcase.
2019-04-07 09:15:05 +08:00
} else if (IS_ENUM(type->t) && type->ref->c < 0) {
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
return -1; /* incomplete enum */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (bt == VT_LDOUBLE) {
*a = LDOUBLE_ALIGN;
return LDOUBLE_SIZE;
} else if (bt == VT_DOUBLE || bt == VT_LLONG) {
#ifdef TCC_TARGET_I386
#ifdef TCC_TARGET_PE
*a = 8;
#else
*a = 4;
#endif
#elif defined(TCC_TARGET_ARM)
#ifdef TCC_ARM_EABI
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
*a = 8;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#else
*a = 4;
#endif
#else
*a = 8;
#endif
return 8;
Fix type parsing the check on incomplete struct/union/enum types was too early, disallowing mixed specifiers and qualifiers. Simply rely on the size (->c) field for that. See testcases.
2016-03-24 22:44:01 +08:00
} else if (bt == VT_INT || bt == VT_FLOAT) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
*a = 4;
return 4;
} else if (bt == VT_SHORT) {
*a = 2;
return 2;
Got test1-3 working on x86-64. There are probably still issues on x86-64 I've missed. I've added a few new tests to abitest, which fail (2x long long and 2x double in a struct should be passed in registers).
2013-04-19 18:08:12 +08:00
} else if (bt == VT_QLONG || bt == VT_QFLOAT) {
*a = 8;
return 16;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
/* char, void, function, _Bool */
*a = 1;
return 1;
}
}
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
/* push type size as known at runtime time on top of value stack. Put
alignment at 'a' */
ST_FUNC void vla_runtime_type_size(CType *type, int *a)
{
if (type->t & VT_VLA) {
tccgen.c: make vla_runtime_type_size always return the alignment
2016-10-09 06:13:31 +08:00
type_size(&type->ref->type, a);
VLA fix [3/3]: store VLA sizeofs in anonymous runtime stack vars
2011-04-10 13:52:25 +08:00
vset(&int_type, VT_LOCAL|VT_LVAL, type->ref->c);
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
} else {
VLA fix [3/3]: store VLA sizeofs in anonymous runtime stack vars
2011-04-10 13:52:25 +08:00
vpushi(type_size(type, a));
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
}
}
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
static void vla_sp_restore(void) {
if (vlas_in_scope) {
gen_vla_sp_restore(vla_sp_loc);
Improved variable length array support. VLA storage is now freed when it goes out of scope. This makes it possible to use a VLA inside a loop without consuming an unlimited amount of memory. Combining VLAs with alloca() should work as in GCC - when a VLA is freed, memory allocated by alloca() after the VLA was created is also freed. There are some exceptions to this rule when using goto: if a VLA is in scope at the goto, jumping to a label will reset the stack pointer to where it was immediately after the last VLA was created prior to the label, or to what it was before the first VLA was created if the label is outside the scope of any VLA. This means that in some cases combining alloca() and VLAs will free alloca() memory where GCC would not.
2013-04-28 03:39:34 +08:00
}
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
}
static void vla_sp_restore_root(void) {
if (vlas_in_scope) {
gen_vla_sp_restore(vla_sp_root_loc);
Improved variable length array support. VLA storage is now freed when it goes out of scope. This makes it possible to use a VLA inside a loop without consuming an unlimited amount of memory. Combining VLAs with alloca() should work as in GCC - when a VLA is freed, memory allocated by alloca() after the VLA was created is also freed. There are some exceptions to this rule when using goto: if a VLA is in scope at the goto, jumping to a label will reset the stack pointer to where it was immediately after the last VLA was created prior to the label, or to what it was before the first VLA was created if the label is outside the scope of any VLA. This means that in some cases combining alloca() and VLAs will free alloca() memory where GCC would not.
2013-04-28 03:39:34 +08:00
}
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* return the pointed type of t */
static inline CType *pointed_type(CType *type)
{
return &type->ref->type;
}
/* modify type so that its it is a pointer to type. */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void mk_pointer(CType *type)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Sym *s;
s = sym_push(SYM_FIELD, type, 0, -1);
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
type->t = VT_PTR | (type->t & VT_STORAGE);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type->ref = s;
}
/* compare function types. OLD functions match any new functions */
static int is_compatible_func(CType *type1, CType *type2)
{
Sym *s1, *s2;
s1 = type1->ref;
s2 = type2->ref;
if (!is_compatible_types(&s1->type, &s2->type))
return 0;
/* check func_call */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (s1->f.func_call != s2->f.func_call)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
return 0;
/* XXX: not complete */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (s1->f.func_type == FUNC_OLD || s2->f.func_type == FUNC_OLD)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
return 1;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (s1->f.func_type != s2->f.func_type)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
return 0;
while (s1 != NULL) {
if (s2 == NULL)
return 0;
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
if (!is_compatible_unqualified_types(&s1->type, &s2->type))
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
return 0;
s1 = s1->next;
s2 = s2->next;
}
if (s2)
return 0;
return 1;
}
/* return true if type1 and type2 are the same. If unqualified is
true, qualifiers on the types are ignored.
*/
static int compare_types(CType *type1, CType *type2, int unqualified)
{
int bt1, t1, t2;
t1 = type1->t & VT_TYPE;
t2 = type2->t & VT_TYPE;
if (unqualified) {
/* strip qualifiers before comparing */
t1 &= ~(VT_CONSTANT | VT_VOLATILE);
t2 &= ~(VT_CONSTANT | VT_VOLATILE);
}
mutiples fix for _Generic * check that _Generic don't match unsigned char * with char * this case is usefull as with -funsigned-char, 'char *' are unsigned * change VT_LONG so it's now a qualifier VT_LONG are never use for code generation, but only durring parsing state, in _Generic we need to be able to make diference between 'long' and 'long long' So VT_LONG is now use as a type qualifier, it's old behaviour is still here, but we can keep trace of what was a long and what wasn't * add TOK_CLONG and TOK_CULONG tcc was directly converting value like '7171L' into TOK_CLLONG or TOK_CINT depending of the machine architecture. because of that, we was unable to make diference between a long and a long long, which doesn't work with _Generic. So now 7171L is a TOK_CLONG, and we can handle _Generic properly * check that _Generic can make diference between long and long long * uncomment "type match twice" as it should now pass tests on any platforms * add inside_generic global the point of this variable is to use VT_LONG in comparaison only when we are evaluating a _Generic. problem is with my lastest patchs tcc can now make the diference between a 'long long' and a 'long', but in 64 bit stddef.h typedef uint64_t as typedef signed long long int int64_t and stdint.h as unsigned long int, so tcc break when stdint.h and stddef.h are include together. Another solution woud be to modifie include/stddef.h so it define uint64_t as unsigned long int when processor is 64 bit, but this could break some legacy code, so for now, VT_LONG are use only inside generc. * check that _Generic parse first argument correctly * check that _Generic evaluate correctly exresion like "f() / 2"
2017-07-10 23:44:53 +08:00
Def signedness != signed != unsigned for char When checking for exact compatibility between types (such as in __builtin_types_compatible_p) consider the case of default signedness to be incompatible with both of the explicit signedness for char. That is, char is incompatible with signed char *and* unsigned char, no matter what the default signedness for char is.
2014-02-06 20:51:47 +08:00
/* Default Vs explicit signedness only matters for char */
if ((t1 & VT_BTYPE) != VT_BYTE) {
t1 &= ~VT_DEFSIGN;
t2 &= ~VT_DEFSIGN;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* XXX: bitfields ? */
if (t1 != t2)
return 0;
/* test more complicated cases */
Fix type completion for array types as well like qualifier merging the array sizes are merged as well for the operands of ?:, and they must not statically influence the types of decls. Also fix some style problems, spaces aren't stinky :)
2018-12-01 06:43:30 +08:00
bt1 = t1 & (VT_BTYPE | VT_ARRAY);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (bt1 == VT_PTR) {
type1 = pointed_type(type1);
type2 = pointed_type(type2);
return is_compatible_types(type1, type2);
Fix how _Generic treats pointers to arrays. _Generic should distinguish pointers to differently sized arrays such as `int(*)[2]` and `int(*)[4]`.
2018-11-13 00:19:15 +08:00
} else if (bt1 & VT_ARRAY) {
return type1->ref->c < 0 || type2->ref->c < 0
|| type1->ref->c == type2->ref->c;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (bt1 == VT_STRUCT) {
return (type1->ref == type2->ref);
} else if (bt1 == VT_FUNC) {
return is_compatible_func(type1, type2);
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
} else if (IS_ENUM(type1->t) || IS_ENUM(type2->t)) {
return type1->ref == type2->ref;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
return 1;
}
}
/* return true if type1 and type2 are exactly the same (including
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
qualifiers).
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
*/
static int is_compatible_types(CType *type1, CType *type2)
{
return compare_types(type1,type2,0);
}
/* return true if type1 and type2 are the same (ignoring qualifiers).
*/
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
static int is_compatible_unqualified_types(CType *type1, CType *type2)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
return compare_types(type1,type2,1);
}
/* print a type. If 'varstr' is not NULL, then the variable is also
printed in the type */
/* XXX: union */
/* XXX: add array and function pointers */
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
static void type_to_str(char *buf, int buf_size,
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
CType *type, const char *varstr)
{
int bt, v, t;
Sym *s, *sa;
char buf1[256];
const char *tstr;
Extend type_to_str to also print storage-class specifiers.
2017-03-06 10:26:21 +08:00
t = type->t;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
bt = t & VT_BTYPE;
buf[0] = '\0';
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
Extend type_to_str to also print storage-class specifiers.
2017-03-06 10:26:21 +08:00
if (t & VT_EXTERN)
pstrcat(buf, buf_size, "extern ");
if (t & VT_STATIC)
pstrcat(buf, buf_size, "static ");
if (t & VT_TYPEDEF)
pstrcat(buf, buf_size, "typedef ");
if (t & VT_INLINE)
pstrcat(buf, buf_size, "inline ");
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
if (t & VT_VOLATILE)
pstrcat(buf, buf_size, "volatile ");
if (t & VT_CONSTANT)
pstrcat(buf, buf_size, "const ");
if (((t & VT_DEFSIGN) && bt == VT_BYTE)
|| ((t & VT_UNSIGNED)
&& (bt == VT_SHORT || bt == VT_INT || bt == VT_LLONG)
&& !IS_ENUM(t)
))
pstrcat(buf, buf_size, (t & VT_UNSIGNED) ? "unsigned " : "signed ");
Extend type_to_str to also print storage-class specifiers.
2017-03-06 10:26:21 +08:00
buf_size -= strlen(buf);
buf += strlen(buf);
mutiples fix for _Generic * check that _Generic don't match unsigned char * with char * this case is usefull as with -funsigned-char, 'char *' are unsigned * change VT_LONG so it's now a qualifier VT_LONG are never use for code generation, but only durring parsing state, in _Generic we need to be able to make diference between 'long' and 'long long' So VT_LONG is now use as a type qualifier, it's old behaviour is still here, but we can keep trace of what was a long and what wasn't * add TOK_CLONG and TOK_CULONG tcc was directly converting value like '7171L' into TOK_CLLONG or TOK_CINT depending of the machine architecture. because of that, we was unable to make diference between a long and a long long, which doesn't work with _Generic. So now 7171L is a TOK_CLONG, and we can handle _Generic properly * check that _Generic can make diference between long and long long * uncomment "type match twice" as it should now pass tests on any platforms * add inside_generic global the point of this variable is to use VT_LONG in comparaison only when we are evaluating a _Generic. problem is with my lastest patchs tcc can now make the diference between a 'long long' and a 'long', but in 64 bit stddef.h typedef uint64_t as typedef signed long long int int64_t and stdint.h as unsigned long int, so tcc break when stdint.h and stddef.h are include together. Another solution woud be to modifie include/stddef.h so it define uint64_t as unsigned long int when processor is 64 bit, but this could break some legacy code, so for now, VT_LONG are use only inside generc. * check that _Generic parse first argument correctly * check that _Generic evaluate correctly exresion like "f() / 2"
2017-07-10 23:44:53 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
switch(bt) {
case VT_VOID:
tstr = "void";
goto add_tstr;
case VT_BOOL:
tstr = "_Bool";
goto add_tstr;
case VT_BYTE:
tstr = "char";
goto add_tstr;
case VT_SHORT:
tstr = "short";
goto add_tstr;
case VT_INT:
tstr = "int";
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
goto maybe_long;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case VT_LLONG:
tstr = "long long";
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
maybe_long:
if (t & VT_LONG)
tstr = "long";
if (!IS_ENUM(t))
goto add_tstr;
tstr = "enum ";
goto tstruct;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case VT_FLOAT:
tstr = "float";
goto add_tstr;
case VT_DOUBLE:
tstr = "double";
goto add_tstr;
case VT_LDOUBLE:
tstr = "long double";
add_tstr:
pstrcat(buf, buf_size, tstr);
break;
case VT_STRUCT:
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
tstr = "struct ";
if (IS_UNION(t))
tstr = "union ";
tstruct:
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
pstrcat(buf, buf_size, tstr);
v = type->ref->v & ~SYM_STRUCT;
if (v >= SYM_FIRST_ANOM)
pstrcat(buf, buf_size, "<anonymous>");
else
pstrcat(buf, buf_size, get_tok_str(v, NULL));
break;
case VT_FUNC:
s = type->ref;
patch type_to_str to handle complex function-ptr decls better Code like: #include <signal.h> int main() { _Generic(signal, int: 0); } should fail with error: type 'extern void (*(int, void (*)(int)))(int)' does not match any association not error: type 'extern void *(int)(int, void *(int))' does not match any association [matz: fix formatting, fix function-to-pointer decay for operands of _Generic, add testcase for this]
2018-03-16 07:26:16 +08:00
buf1[0]=0;
if (varstr && '*' == *varstr) {
pstrcat(buf1, sizeof(buf1), "(");
pstrcat(buf1, sizeof(buf1), varstr);
pstrcat(buf1, sizeof(buf1), ")");
}
pstrcat(buf1, buf_size, "(");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
sa = s->next;
while (sa != NULL) {
patch type_to_str to handle complex function-ptr decls better Code like: #include <signal.h> int main() { _Generic(signal, int: 0); } should fail with error: type 'extern void (*(int, void (*)(int)))(int)' does not match any association not error: type 'extern void *(int)(int, void *(int))' does not match any association [matz: fix formatting, fix function-to-pointer decay for operands of _Generic, add testcase for this]
2018-03-16 07:26:16 +08:00
char buf2[256];
type_to_str(buf2, sizeof(buf2), &sa->type, NULL);
pstrcat(buf1, sizeof(buf1), buf2);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
sa = sa->next;
if (sa)
patch type_to_str to handle complex function-ptr decls better Code like: #include <signal.h> int main() { _Generic(signal, int: 0); } should fail with error: type 'extern void (*(int, void (*)(int)))(int)' does not match any association not error: type 'extern void *(int)(int, void *(int))' does not match any association [matz: fix formatting, fix function-to-pointer decay for operands of _Generic, add testcase for this]
2018-03-16 07:26:16 +08:00
pstrcat(buf1, sizeof(buf1), ", ");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
patch type_to_str to handle complex function-ptr decls better Code like: #include <signal.h> int main() { _Generic(signal, int: 0); } should fail with error: type 'extern void (*(int, void (*)(int)))(int)' does not match any association not error: type 'extern void *(int)(int, void *(int))' does not match any association [matz: fix formatting, fix function-to-pointer decay for operands of _Generic, add testcase for this]
2018-03-16 07:26:16 +08:00
if (s->f.func_type == FUNC_ELLIPSIS)
pstrcat(buf1, sizeof(buf1), ", ...");
pstrcat(buf1, sizeof(buf1), ")");
type_to_str(buf, buf_size, &s->type, buf1);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
goto no_var;
case VT_PTR:
s = type->ref;
tccgen.c: Improvements to type_to_str (only used for error messages). 1. Handle array types. 2. Print the type qualifiers of pointers.
2015-11-20 07:35:36 +08:00
if (t & VT_ARRAY) {
Fix array pointer stringification. `int (*)[4];` should not be stringified as `int *[4];` Add stringification tests.
2018-11-13 00:11:24 +08:00
if (varstr && '*' == *varstr)
snprintf(buf1, sizeof(buf1), "(%s)[%d]", varstr, s->c);
else
snprintf(buf1, sizeof(buf1), "%s[%d]", varstr ? varstr : "", s->c);
tccgen.c: Improvements to type_to_str (only used for error messages). 1. Handle array types. 2. Print the type qualifiers of pointers.
2015-11-20 07:35:36 +08:00
type_to_str(buf, buf_size, &s->type, buf1);
goto no_var;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
pstrcpy(buf1, sizeof(buf1), "*");
tccgen.c: Improvements to type_to_str (only used for error messages). 1. Handle array types. 2. Print the type qualifiers of pointers.
2015-11-20 07:35:36 +08:00
if (t & VT_CONSTANT)
pstrcat(buf1, buf_size, "const ");
if (t & VT_VOLATILE)
pstrcat(buf1, buf_size, "volatile ");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (varstr)
pstrcat(buf1, sizeof(buf1), varstr);
type_to_str(buf, buf_size, &s->type, buf1);
goto no_var;
}
if (varstr) {
pstrcat(buf, buf_size, " ");
pstrcat(buf, buf_size, varstr);
}
no_var: ;
}
/* verify type compatibility to store vtop in 'dt' type, and generate
casts if needed. */
static void gen_assign_cast(CType *dt)
{
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
CType *st, *type1, *type2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
char buf1[256], buf2[256];
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
int dbt, sbt, qualwarn, lvl;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
st = &vtop->type; /* source type */
dbt = dt->t & VT_BTYPE;
sbt = st->t & VT_BTYPE;
a void to void cast. Allow tcc to compile the following program /////// void func1() {} void func2() { return func1(); } ////// gcc accepts this program
2015-03-03 20:39:57 +08:00
if (sbt == VT_VOID || dbt == VT_VOID) {
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (sbt == VT_VOID && dbt == VT_VOID)
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
; /* It is Ok if both are void */
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
else
tcc_error("cannot cast from/to void");
a void to void cast. Allow tcc to compile the following program /////// void func1() {} void func2() { return func1(); } ////// gcc accepts this program
2015-03-03 20:39:57 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (dt->t & VT_CONSTANT)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("assignment of read-only location");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
switch(dbt) {
case VT_PTR:
/* special cases for pointers */
/* '0' can also be a pointer */
if (is_null_pointer(vtop))
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
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* accept implicit pointer to integer cast with warning */
if (is_integer_btype(sbt)) {
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("assignment makes pointer from integer without a cast");
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
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
type1 = pointed_type(dt);
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
if (sbt == VT_PTR)
type2 = pointed_type(st);
else if (sbt == VT_FUNC)
type2 = st; /* a function is implicitly a function pointer */
else
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
goto error;
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
if (is_compatible_types(type1, type2))
break;
for (qualwarn = lvl = 0;; ++lvl) {
if (((type2->t & VT_CONSTANT) && !(type1->t & VT_CONSTANT)) ||
((type2->t & VT_VOLATILE) && !(type1->t & VT_VOLATILE)))
qualwarn = 1;
dbt = type1->t & (VT_BTYPE|VT_LONG);
sbt = type2->t & (VT_BTYPE|VT_LONG);
if (dbt != VT_PTR || sbt != VT_PTR)
break;
type1 = pointed_type(type1);
type2 = pointed_type(type2);
}
if (!is_compatible_unqualified_types(type1, type2)) {
if ((dbt == VT_VOID || sbt == VT_VOID) && lvl == 0) {
/* void * can match anything */
} else if (dbt == sbt
&& is_integer_btype(sbt & VT_BTYPE)
&& IS_ENUM(type1->t) + IS_ENUM(type2->t)
+ !!((type1->t ^ type2->t) & VT_UNSIGNED) < 2) {
enums and ints are compatible But like GCC do warn about changes in signedness. The latter leads to some changes in gen_assign_cast to not also warn about unsigned* = int* (where GCC warns, but only with extra warnings).
2016-08-07 08:15:34 +08:00
/* Like GCC don't warn by default for merely changes
in pointer target signedness. Do warn for different
base types, though, in particular for unsigned enums
and signed int targets. */
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
} else {
tcc_warning("assignment from incompatible pointer type");
break;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
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
if (qualwarn)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("assignment discards qualifiers from pointer target type");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
case VT_BYTE:
case VT_SHORT:
case VT_INT:
case VT_LLONG:
if (sbt == VT_PTR || sbt == VT_FUNC) {
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("assignment makes integer from pointer without a cast");
tccgen: gen_assign_cast(): cannot cast struct to scalar The case below previously was causing an assertion failure in the target specific generator. It probably is not incorrect not to allow this even if gcc does. struct S { long b; }; void f(struct S *x) { struct S y[1] = { *x }; }
2016-05-26 00:52:08 +08:00
} else if (sbt == VT_STRUCT) {
goto case_VT_STRUCT;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
/* XXX: more tests */
break;
case VT_STRUCT:
tccgen: gen_assign_cast(): cannot cast struct to scalar The case below previously was causing an assertion failure in the target specific generator. It probably is not incorrect not to allow this even if gcc does. struct S { long b; }; void f(struct S *x) { struct S y[1] = { *x }; }
2016-05-26 00:52:08 +08:00
case_VT_STRUCT:
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
if (!is_compatible_unqualified_types(dt, st)) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
error:
type_to_str(buf1, sizeof(buf1), st, NULL);
type_to_str(buf2, sizeof(buf2), dt, NULL);
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("cannot cast '%s' to '%s'", buf1, buf2);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
break;
}
gen_cast(dt);
}
/* store vtop in lvalue pushed on stack */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void vstore(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int sbt, dbt, ft, r, t, size, align, bit_size, bit_pos, rc, delayed_cast;
ft = vtop[-1].type.t;
sbt = vtop->type.t & VT_BTYPE;
dbt = ft & VT_BTYPE;
Fix bitfield loads into char/short. Removes a premature optimization of char/short loads rewriting the source type. It did so also for bitfield loads, thereby removing all the shifts/maskings.
2012-04-15 07:06:46 +08:00
if ((((sbt == VT_INT || sbt == VT_SHORT) && dbt == VT_BYTE) ||
(sbt == VT_INT && dbt == VT_SHORT))
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
&& !(vtop->type.t & VT_BITFIELD)) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* optimize char/short casts */
delayed_cast = VT_MUSTCAST;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
vtop->type.t = ft & VT_TYPE;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* XXX: factorize */
if (ft & VT_CONSTANT)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("assignment of read-only location");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
delayed_cast = 0;
if (!(ft & VT_BITFIELD))
gen_assign_cast(&vtop[-1].type);
}
if (sbt == VT_STRUCT) {
/* if structure, only generate pointer */
/* structure assignment : generate memcpy */
/* XXX: optimize if small size */
size = type_size(&vtop->type, &align);
avoid needless register save when storing structures When storing structs with a memcpy call in vstore(), so far a needless entry remaining on the vstack sometimes resulted in an useless store generated by save_regs() in gfunc_call() for the memcpy routine.
2009-12-01 02:33:44 +08:00
/* destination */
vswap();
vtop->type.t = VT_PTR;
gaddrof();
/* address of memcpy() */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#ifdef TCC_ARM_EABI
if(!(align & 7))
vpush_global_sym(&func_old_type, TOK_memcpy8);
else if(!(align & 3))
vpush_global_sym(&func_old_type, TOK_memcpy4);
else
#endif
tccgen.c: Use memmove for struct assignment: dest and src may be equal.
2015-11-05 04:23:17 +08:00
/* Use memmove, rather than memcpy, as dest and src may be same: */
vpush_global_sym(&func_old_type, TOK_memmove);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
avoid needless register save when storing structures When storing structs with a memcpy call in vstore(), so far a needless entry remaining on the vstack sometimes resulted in an useless store generated by save_regs() in gfunc_call() for the memcpy routine.
2009-12-01 02:33:44 +08:00
vswap();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* source */
vpushv(vtop - 2);
vtop->type.t = VT_PTR;
gaddrof();
/* type size */
vpushi(size);
gfunc_call(3);
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* leave source on stack */
} else if (ft & VT_BITFIELD) {
/* bitfield store handling */
tccgen: use lvalue as result from bitfield assignment test case: #include <stdio.h> int main(int argc, char **argv) { struct _s { unsigned a:9, b:5, c:7; } _s, *s = &_s; int n = 250; s->a = s->b = s->c = n + 4; printf("--> %d / %d / %d\n", s->a, s->b, s->c); return 0; } before: --> 254 / 30 / 126 now: --> 30 / 30 / 126
2014-09-23 18:30:08 +08:00
/* save lvalue as expression result (example: s.b = s.a = n;) */
vdup(), vtop[-1] = vtop[-2];
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
bit_pos = BIT_POS(ft);
bit_size = BIT_SIZE(ft);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* remove bit field info to avoid loops */
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
vtop[-1].type.t = ft & ~VT_STRUCT_MASK;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
if ((ft & VT_BTYPE) == VT_BOOL) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_cast(&vtop[-1].type);
vtop[-1].type.t = (vtop[-1].type.t & ~VT_BTYPE) | (VT_BYTE | VT_UNSIGNED);
}
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
r = adjust_bf(vtop - 1, bit_pos, bit_size);
if (r == VT_STRUCT) {
gen_cast_s((ft & VT_BTYPE) == VT_LLONG ? VT_LLONG : VT_INT);
store_packed_bf(bit_pos, bit_size);
} else {
unsigned long long mask = (1ULL << bit_size) - 1;
if ((ft & VT_BTYPE) != VT_BOOL) {
/* mask source */
if ((vtop[-1].type.t & VT_BTYPE) == VT_LLONG)
vpushll(mask);
else
vpushi((unsigned)mask);
gen_op('&');
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
/* shift source */
vpushi(bit_pos);
gen_op(TOK_SHL);
vswap();
/* duplicate destination */
vdup();
vrott(3);
/* load destination, mask and or with source */
if ((vtop->type.t & VT_BTYPE) == VT_LLONG)
vpushll(~(mask << bit_pos));
else
vpushi(~((unsigned)mask << bit_pos));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_op('&');
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
gen_op('|');
/* store result */
vstore();
/* ... and discard */
vpop();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
various stuff win32/Makefile ("for cygwin") removed - On cygwin, the normal ./configure && make can be used with either cygwin's "GCC for Win32 Toolchain" ./configure --cross-prefix=i686-w64-mingw32- or with an existing tcc: ./configure --cc=<old-tccdir>/tcc.exe tcctest.c: - exclude test_high_clobbers() on _WIN64 (does not work) tests2/95_bitfield.c: - use 'signed char' for ARM (where default 'char' is unsigned) tests: - remove -I "expr" diff option to allow tests with busybox-diff. libtcc.c, tcc.c: - removed -iwithprefix option. It is supposed to be combined with -iprefix which we don't have either. tccgen.c: - fix assignments and return of 'void', as in void f() { void *p, *q; *p = *q: return *p; } This appears to be allowed but should do nothing. tcc.h, libtcc.c, tccpp.c: - Revert "Introduce VIP sysinclude paths which are always searched first" This reverts commit 1d5e386b0a78393ac6b670c209a185849ec798a1. The patch was giving tcc's system includes priority over -I which is not how it should be. tccelf.c: - add DT_TEXTREL tag only if text relocations are actually used (which is likely not the case on x86_64) - prepare_dynamic_rel(): avoid relocation of unresolved (weak) symbols tccrun.c: - for HAVE_SELINUX, use two mappings to the same (real) file. (it was so once except the RX mapping wasn't used at all). tccpe.c: - fix relocation constant used for x86_64 (by Andrei E. Warentin) - #ifndef _WIN32 do "chmod 755 ..." to get runnable exes on cygwin. tccasm.c: - keep forward asm labels static, otherwise they will endup in dynsym eventually. configure, Makefile: - mingw32: respect ./configure options --bindir --docdir --libdir - allow overriding tcc when building libtcc1.a and libtcc.def with make XTCC=<tcc program to use> - use $(wildcard ...) for install to allow installing just a cross compiler for example make cross-arm make install - use name <target>-libtcc1.a build-tcc.bat: - add options: -clean, -b bindir
2017-10-12 00:13:43 +08:00
} else if (dbt == VT_VOID) {
--vtop;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
#ifdef CONFIG_TCC_BCHECK
Add some missing nocode_wanted guard int i = i++ causes a segfault because of missing guard. Looking recursively at all backend functions called from middle end several more guard appeared to be missing.
2015-03-10 23:23:00 +08:00
/* bound check case */
if (vtop[-1].r & VT_MUSTBOUND) {
vswap();
gbound();
vswap();
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#endif
rc = RC_INT;
if (is_float(ft)) {
rc = RC_FLOAT;
#ifdef TCC_TARGET_X86_64
if ((ft & VT_BTYPE) == VT_LDOUBLE) {
rc = RC_ST0;
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
} else if ((ft & VT_BTYPE) == VT_QFLOAT) {
rc = RC_FRET;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
#endif
}
r = gv(rc); /* generate value */
/* if lvalue was saved on stack, must read it */
if ((vtop[-1].r & VT_VALMASK) == VT_LLOCAL) {
SValue sv;
t = get_reg(RC_INT);
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
sv.type.t = VT_PTR;
#else
sv.type.t = VT_INT;
#endif
sv.r = VT_LOCAL | VT_LVAL;
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
sv.c.i = vtop[-1].c.i;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
load(t, &sv);
vtop[-1].r = t | VT_LVAL;
}
x86-64 ABI fixes. abitest now passes; however test1-3 fail in init_test. All other tests pass. I need to re-test Win32 and Linux-x86. I've added a dummy implementation of gfunc_sret to c67-gen.c so it should now compile, and I think it should behave as before I created gfunc_sret.
2013-04-19 07:40:48 +08:00
/* two word case handling : store second register at word + 4 (or +8 for x86-64) */
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
if (((ft & VT_BTYPE) == VT_QLONG) || ((ft & VT_BTYPE) == VT_QFLOAT)) {
int addr_type = VT_LLONG, load_size = 8, load_type = ((vtop->type.t & VT_BTYPE) == VT_QLONG) ? VT_LLONG : VT_DOUBLE;
x86-64 ABI fixes. abitest now passes; however test1-3 fail in init_test. All other tests pass. I need to re-test Win32 and Linux-x86. I've added a dummy implementation of gfunc_sret to c67-gen.c so it should now compile, and I think it should behave as before I created gfunc_sret.
2013-04-19 07:40:48 +08:00
#else
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if ((ft & VT_BTYPE) == VT_LLONG) {
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
int addr_type = VT_INT, load_size = 4, load_type = VT_INT;
x86-64 ABI fixes. abitest now passes; however test1-3 fail in init_test. All other tests pass. I need to re-test Win32 and Linux-x86. I've added a dummy implementation of gfunc_sret to c67-gen.c so it should now compile, and I think it should behave as before I created gfunc_sret.
2013-04-19 07:40:48 +08:00
#endif
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
vtop[-1].type.t = load_type;
store(r, vtop - 1);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vswap();
/* convert to int to increment easily */
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
vtop->type.t = addr_type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gaddrof();
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
vpushi(load_size);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_op('+');
vtop->r |= VT_LVAL;
vswap();
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
vtop[-1].type.t = load_type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* XXX: it works because r2 is spilled last ! */
store(vtop->r2, vtop - 1);
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
} else {
store(r, vtop - 1);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vswap();
vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
vtop->r |= delayed_cast;
}
}
/* post defines POST/PRE add. c is the token ++ or -- */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void inc(int post, int c)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
test_lvalue();
vdup(); /* save lvalue */
if (post) {
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
gv_dup(); /* duplicate value */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vrotb(3);
vrotb(3);
}
/* add constant */
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
vpushi(c - TOK_MID);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_op('+');
vstore(); /* store value */
if (post)
vpop(); /* if post op, return saved value */
}
inline asm: accept concatenated strings in constraints This really should be handled implicitly in the preprocessor, but for now this is enough.
2016-07-11 22:42:18 +08:00
ST_FUNC void parse_mult_str (CString *astr, const char *msg)
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
{
/* read the string */
if (tok != TOK_STR)
expect(msg);
cstr_new(astr);
while (tok == TOK_STR) {
/* XXX: add \0 handling too ? */
cstr_cat(astr, tokc.str.data, -1);
next();
}
cstr_ccat(astr, '\0');
}
Support large alignment requests The linux kernel has some structures that are page aligned, i.e. 4096. Instead of enlarging the bit fields to specify this, use the fact that alignment is always power of two, and store only the log2 minus 1 of it. The 5 bits are enough to specify an alignment of 1 << 30.
2016-10-09 08:41:34 +08:00
/* If I is >= 1 and a power of two, returns log2(i)+1.
If I is 0 returns 0. */
static int exact_log2p1(int i)
{
int ret;
if (!i)
return 0;
for (ret = 1; i >= 1 << 8; ret += 8)
i >>= 8;
if (i >= 1 << 4)
ret += 4, i >>= 4;
if (i >= 1 << 2)
ret += 2, i >>= 2;
if (i >= 1 << 1)
ret++;
return ret;
}
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
/* Parse __attribute__((...)) GNUC extension. */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
static void parse_attribute(AttributeDef *ad)
{
int t, n;
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
CString astr;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
redo:
if (tok != TOK_ATTRIBUTE1 && tok != TOK_ATTRIBUTE2)
return;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
skip('(');
skip('(');
while (tok != ')') {
if (tok < TOK_IDENT)
expect("attribute name");
t = tok;
next();
switch(t) {
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
case TOK_CLEANUP1:
case TOK_CLEANUP2:
{
Sym *s;
skip('(');
s = sym_find(tok);
if (!s) {
tcc_warning("implicit declaration of function '%s'",
get_tok_str(tok, &tokc));
Tidy some code the real difference is in decl0 where we can use external_sym just fine also for function definitions, we don't have to use external_global_sym. Setting VT_EXTERN in external_sym isn't necessary either (the type will have it set if necessary). The rest is tidying: removing unused arguments and moving some code around.
2019-04-18 09:36:39 +08:00
s = external_global_sym(tok, &func_old_type);
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
}
ad->cleanup_func = s;
next();
skip(')');
break;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_SECTION1:
case TOK_SECTION2:
skip('(');
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
parse_mult_str(&astr, "section name");
ad->section = find_section(tcc_state, (char *)astr.data);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(')');
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
cstr_free(&astr);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
tccgen: handle __attribute((alias("target")))
2011-03-03 17:58:45 +08:00
case TOK_ALIAS1:
case TOK_ALIAS2:
skip('(');
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
parse_mult_str(&astr, "alias(\"target\")");
tccgen: handle __attribute((alias("target")))
2011-03-03 17:58:45 +08:00
ad->alias_target = /* save string as token, for later */
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
tok_alloc((char*)astr.data, astr.size-1)->tok;
tccgen: handle __attribute((alias("target")))
2011-03-03 17:58:45 +08:00
skip(')');
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
cstr_free(&astr);
tccgen: handle __attribute((alias("target")))
2011-03-03 17:58:45 +08:00
break;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
case TOK_VISIBILITY1:
case TOK_VISIBILITY2:
Parse and emit hidden visibility This adds parsing of (GCC compatible) visibility attribute in order to mark selected global symbols as hidden. The generated .o files contain hidden symbols already, the TCC linker doesn't yet do the right thing.
2014-04-14 08:53:11 +08:00
skip('(');
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
parse_mult_str(&astr,
"visibility(\"default|hidden|internal|protected\")");
if (!strcmp (astr.data, "default"))
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
ad->a.visibility = STV_DEFAULT;
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
else if (!strcmp (astr.data, "hidden"))
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
ad->a.visibility = STV_HIDDEN;
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
else if (!strcmp (astr.data, "internal"))
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
ad->a.visibility = STV_INTERNAL;
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
else if (!strcmp (astr.data, "protected"))
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
ad->a.visibility = STV_PROTECTED;
else
Parse and emit hidden visibility This adds parsing of (GCC compatible) visibility attribute in order to mark selected global symbols as hidden. The generated .o files contain hidden symbols already, the TCC linker doesn't yet do the right thing.
2014-04-14 08:53:11 +08:00
expect("visibility(\"default|hidden|internal|protected\")");
skip(')');
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
cstr_free(&astr);
Parse and emit hidden visibility This adds parsing of (GCC compatible) visibility attribute in order to mark selected global symbols as hidden. The generated .o files contain hidden symbols already, the TCC linker doesn't yet do the right thing.
2014-04-14 08:53:11 +08:00
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_ALIGNED1:
case TOK_ALIGNED2:
if (tok == '(') {
next();
n = expr_const();
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (n <= 0 || (n & (n - 1)) != 0)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("alignment must be a positive power of two");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(')');
} else {
n = MAX_ALIGN;
}
Support large alignment requests The linux kernel has some structures that are page aligned, i.e. 4096. Instead of enlarging the bit fields to specify this, use the fact that alignment is always power of two, and store only the log2 minus 1 of it. The 5 bits are enough to specify an alignment of 1 << 30.
2016-10-09 08:41:34 +08:00
ad->a.aligned = exact_log2p1(n);
if (n != 1 << (ad->a.aligned - 1))
tcc_error("alignment of %d is larger than implemented", n);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
case TOK_PACKED1:
case TOK_PACKED2:
be stricter with aliasing Refactoring (no logical changes): - use memcpy in tccgen.c:ieee_finite(double d) - use union to store attribute flags in Sym Makefile: "CFLAGS+=-fno-strict-aliasing" basically not necessary anymore but I left it for now because gcc sometimes behaves unexpectedly without. Also: - configure: back to mode 100755 - tcc.h: remove unused variables tdata/tbss_section - x86_64-gen.c: adjust gfunc_sret for prototype
2014-01-07 21:57:07 +08:00
ad->a.packed = 1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
weak function symbols
2010-02-28 00:37:59 +08:00
case TOK_WEAK1:
case TOK_WEAK2:
be stricter with aliasing Refactoring (no logical changes): - use memcpy in tccgen.c:ieee_finite(double d) - use union to store attribute flags in Sym Makefile: "CFLAGS+=-fno-strict-aliasing" basically not necessary anymore but I left it for now because gcc sometimes behaves unexpectedly without. Also: - configure: back to mode 100755 - tcc.h: remove unused variables tdata/tbss_section - x86_64-gen.c: adjust gfunc_sret for prototype
2014-01-07 21:57:07 +08:00
ad->a.weak = 1;
weak function symbols
2010-02-28 00:37:59 +08:00
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_UNUSED1:
case TOK_UNUSED2:
/* currently, no need to handle it because tcc does not
track unused objects */
break;
case TOK_NORETURN1:
case TOK_NORETURN2:
/* currently, no need to handle it because tcc does not
track unused objects */
break;
case TOK_CDECL1:
case TOK_CDECL2:
case TOK_CDECL3:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->f.func_call = FUNC_CDECL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
case TOK_STDCALL1:
case TOK_STDCALL2:
case TOK_STDCALL3:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->f.func_call = FUNC_STDCALL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
#ifdef TCC_TARGET_I386
case TOK_REGPARM1:
case TOK_REGPARM2:
skip('(');
n = expr_const();
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (n > 3)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
n = 3;
else if (n < 0)
n = 0;
if (n > 0)
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->f.func_call = FUNC_FASTCALL1 + n - 1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(')');
break;
case TOK_FASTCALL1:
case TOK_FASTCALL2:
case TOK_FASTCALL3:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->f.func_call = FUNC_FASTCALLW;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#endif
Add support for the __mode__ attribute -- By by ... Detlef
2010-01-27 05:56:22 +08:00
case TOK_MODE:
skip('(');
switch(tok) {
case TOK_MODE_DI:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->attr_mode = VT_LLONG + 1;
Add support for the __mode__ attribute -- By by ... Detlef
2010-01-27 05:56:22 +08:00
break;
#define __GNUC__ = 2.1 __GNUC__ nowadays as macro seems to mean the "GNU C dialect" rather than the compiler itself. See also http://gcc.gnu.org/ml/gcc/2008-07/msg00026.html This patch will probably cause problems of various kinds but maybe we should try nonetheless.
2016-10-15 22:01:16 +08:00
case TOK_MODE_QI:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->attr_mode = VT_BYTE + 1;
#define __GNUC__ = 2.1 __GNUC__ nowadays as macro seems to mean the "GNU C dialect" rather than the compiler itself. See also http://gcc.gnu.org/ml/gcc/2008-07/msg00026.html This patch will probably cause problems of various kinds but maybe we should try nonetheless.
2016-10-15 22:01:16 +08:00
break;
Add support for the __mode__ attribute -- By by ... Detlef
2010-01-27 05:56:22 +08:00
case TOK_MODE_HI:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->attr_mode = VT_SHORT + 1;
Add support for the __mode__ attribute -- By by ... Detlef
2010-01-27 05:56:22 +08:00
break;
case TOK_MODE_SI:
#define __GNUC__ = 2.1 __GNUC__ nowadays as macro seems to mean the "GNU C dialect" rather than the compiler itself. See also http://gcc.gnu.org/ml/gcc/2008-07/msg00026.html This patch will probably cause problems of various kinds but maybe we should try nonetheless.
2016-10-15 22:01:16 +08:00
case TOK_MODE_word:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->attr_mode = VT_INT + 1;
Add support for the __mode__ attribute -- By by ... Detlef
2010-01-27 05:56:22 +08:00
break;
default:
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("__mode__(%s) not supported\n", get_tok_str(tok, NULL));
Add support for the __mode__ attribute -- By by ... Detlef
2010-01-27 05:56:22 +08:00
break;
}
next();
skip(')');
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_DLLEXPORT:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->a.dllexport = 1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
Implement __attribute__((nodecorate)) Prevent any decoration that would otherwise affect an exported PE function. For example, given the following: __declspec(dllexport) __stdcall int decorated(int arg) { return 0; } __declspec(dllexport) __stdcall __attribute__((nodecorate)) int undecorated(int arg) { return 0; } The following exported functions can now be seen in the DLL: _decorated@4 undecorated The attribute is recognised for all targets but only affects PE codegen. I'm not sure whether this would be useful for other targets; its intended use was to allow the creation of a DLL matching an existing set of signatures.
2018-07-22 07:54:01 +08:00
case TOK_NODECORATE:
ad->a.nodecorate = 1;
break;
win32: handle __declspec(dllimport)
2009-11-14 00:14:05 +08:00
case TOK_DLLIMPORT:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->a.dllimport = 1;
win32: handle __declspec(dllimport)
2009-11-14 00:14:05 +08:00
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
default:
if (tcc_state->warn_unsupported)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("'%s' attribute ignored", get_tok_str(t, NULL));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* skip parameters */
if (tok == '(') {
int parenthesis = 0;
do {
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (tok == '(')
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
parenthesis++;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
else if (tok == ')')
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
parenthesis--;
next();
} while (parenthesis && tok != -1);
}
break;
}
if (tok != ',')
break;
next();
}
skip(')');
skip(')');
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
goto redo;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Fix more struct inits anonymous struct members were somewhat broken as the testcase demonstrates. The reason is the jumping through hoops to fiddle with the offsets I once introduced to avoid having to track a cumulative offset. That's now not necessary anymore and actively harmful, doing the obvious thing is now better.
2019-04-11 06:30:41 +08:00
static Sym * find_field (CType *type, int v, int *cumofs)
struct-init: Correctly parse unnamed member initializers For union U { struct {int a,b}; int c; }; union U u = {{ 1, 2, }}; The unnamed first member of union U needs to actually exist in the structure so initializer parsing isn't confused about the double braces. That means also the a and b members must be part of _that_, not of union U directly. Which in turn means we need to do a bit more work for field lookup. See the testcase extension for more things that need to work.
2016-08-02 04:11:49 +08:00
{
Sym *s = type->ref;
v |= SYM_FIELD;
while ((s = s->next) != NULL) {
Fix struct layout some more Anonymous sub-sub-members weren't handled correctly. Bit-fields neither: this implements PCC layout for now. It temporarily disables MS-compatible bit-field layout.
2016-10-09 06:52:57 +08:00
if ((s->v & SYM_FIELD) &&
(s->type.t & VT_BTYPE) == VT_STRUCT &&
(s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM) {
Fix more struct inits anonymous struct members were somewhat broken as the testcase demonstrates. The reason is the jumping through hoops to fiddle with the offsets I once introduced to avoid having to track a cumulative offset. That's now not necessary anymore and actively harmful, doing the obvious thing is now better.
2019-04-11 06:30:41 +08:00
Sym *ret = find_field (&s->type, v, cumofs);
if (ret) {
*cumofs += s->c;
struct-init: Correctly parse unnamed member initializers For union U { struct {int a,b}; int c; }; union U u = {{ 1, 2, }}; The unnamed first member of union U needs to actually exist in the structure so initializer parsing isn't confused about the double braces. That means also the a and b members must be part of _that_, not of union U directly. Which in turn means we need to do a bit more work for field lookup. See the testcase extension for more things that need to work.
2016-08-02 04:11:49 +08:00
return ret;
Fix more struct inits anonymous struct members were somewhat broken as the testcase demonstrates. The reason is the jumping through hoops to fiddle with the offsets I once introduced to avoid having to track a cumulative offset. That's now not necessary anymore and actively harmful, doing the obvious thing is now better.
2019-04-11 06:30:41 +08:00
}
struct-init: Correctly parse unnamed member initializers For union U { struct {int a,b}; int c; }; union U u = {{ 1, 2, }}; The unnamed first member of union U needs to actually exist in the structure so initializer parsing isn't confused about the double braces. That means also the a and b members must be part of _that_, not of union U directly. Which in turn means we need to do a bit more work for field lookup. See the testcase extension for more things that need to work.
2016-08-02 04:11:49 +08:00
}
if (s->v == v)
break;
}
return s;
}
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
static void struct_layout(CType *type, AttributeDef *ad)
{
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
int size, align, maxalign, offset, c, bit_pos, bit_size;
int packed, a, bt, prevbt, prev_bit_size;
bitfields: fix PCC layout Fixes some corner cases in PCC layout. Testcases coming up.
2016-11-12 00:33:31 +08:00
int pcc = !tcc_state->ms_bitfields;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
int pragma_pack = *tcc_state->pack_stack_ptr;
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
Sym *f;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
maxalign = 1;
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
offset = 0;
c = 0;
Fix struct layout some more Anonymous sub-sub-members weren't handled correctly. Bit-fields neither: this implements PCC layout for now. It temporarily disables MS-compatible bit-field layout.
2016-10-09 06:52:57 +08:00
bit_pos = 0;
bitfields: Implement MS compatible layout Bit-fields are layed out differently in visual C, this implements a compatible mode. Checked against Visual C/C++ 2016. Unfortunately the GCC implementation of MS layout (behind -mms-bitfields) actually is different, and hence not compatible with MS in all cases :-/
2016-11-08 02:36:21 +08:00
prevbt = VT_STRUCT; /* make it never match */
bitfields: Fix MS layout some more Another corner case: struct foo6_1 { char x; short p:8; short :0; short :0; short p2:8; char y; }; In MS layout the second anon :0 bit-field does _not_ adjust size or alignment of the struct again. The first one does, though.
2016-11-29 03:27:42 +08:00
prev_bit_size = 0;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
//#define BF_DEBUG
bitfields: one more hack and a "-Wgcc-compat" switch bit_pos + bit_size > type_size * 8 must NEVER happen because the code generator can read/write only the basic integral types. Warn if tcc has to break GCC compatibility for that reason and if -Wgcc-compat is given. Example: struct __attribute__((packed)) _s { unsigned int x : 12; unsigned char y : 7; unsigned int z : 28; }; Expected (GCC) layout (sizeof struct = 6) .xxxxxxxx.xxxxyyyy.yyyzzzzz.zzzzzzzz.zzzzzzzz.zzzzzzz0. But we cannot read/write 'char y'from 2 bytes in memory. So we have to adjust: .xxxxxxxx.xxxx0000.yyyyyyyz.zzzzzzzz.zzzzzzzz.zzzzzzzz.zzz00000 Now 'int z' cannot be accessed from 5 bytes. So we arrive at this (sizeof struct = 7): .xxxxxxxx.xxxx0000.yyyyyyy0.zzzzzzzz.zzzzzzzz.zzzzzzzz.zzzz0000 Otherwise the bitfield load/store generator needs to be changed to allow byte-wise accesses. Also we may touch memory past the struct in some cases currently. The patch adds a warning for that too. 0: 55 push %ebp 1: 89 e5 mov %esp,%ebp 3: 81 ec 04 00 00 00 sub $0x4,%esp 9: 90 nop struct __attribute__((packed)) { unsigned x : 5; } b = {0} ; a: 8b 45 ff mov -0x1(%ebp),%eax d: 83 e0 e0 and $0xffffffe0,%eax 10: 89 45 ff mov %eax,-0x1(%ebp) This touches -0x1 ... +0x3(%ebp), hence 3 bytes beyond stack space. Since the data is not changed, nothing else happens here.
2017-05-10 00:10:02 +08:00
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
for (f = type->ref->next; f; f = f->next) {
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
if (f->type.t & VT_BITFIELD)
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
bit_size = BIT_SIZE(f->type.t);
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
else
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
bit_size = -1;
size = type_size(&f->type, &align);
a = f->a.aligned ? 1 << (f->a.aligned - 1) : 0;
packed = 0;
if (pcc && bit_size == 0) {
/* in pcc mode, packing does not affect zero-width bitfields */
} else {
/* in pcc mode, attribute packed overrides if set. */
if (pcc && (f->a.packed || ad->a.packed))
align = packed = 1;
/* pragma pack overrides align if lesser and packs bitfields always */
if (pragma_pack) {
packed = 1;
if (pragma_pack < align)
align = pragma_pack;
/* in pcc mode pragma pack also overrides individual align */
if (pcc && pragma_pack < a)
a = 0;
}
}
/* some individual align was specified */
if (a)
align = a;
if (type->ref->type.t == VT_UNION) {
struct-layout: cleanup code a bit
2016-11-29 03:54:59 +08:00
if (pcc && bit_size >= 0)
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
size = (bit_size + 7) >> 3;
struct-layout: cleanup code a bit
2016-11-29 03:54:59 +08:00
offset = 0;
if (size > c)
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
c = size;
struct-layout: cleanup code a bit
2016-11-29 03:54:59 +08:00
} else if (bit_size < 0) {
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
if (pcc)
c += (bit_pos + 7) >> 3;
c = (c + align - 1) & -align;
struct-layout: cleanup code a bit
2016-11-29 03:54:59 +08:00
offset = c;
if (size > 0)
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
c += size;
Fix struct layout some more Anonymous sub-sub-members weren't handled correctly. Bit-fields neither: this implements PCC layout for now. It temporarily disables MS-compatible bit-field layout.
2016-10-09 06:52:57 +08:00
bit_pos = 0;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
prevbt = VT_STRUCT;
prev_bit_size = 0;
Fix struct layout some more Anonymous sub-sub-members weren't handled correctly. Bit-fields neither: this implements PCC layout for now. It temporarily disables MS-compatible bit-field layout.
2016-10-09 06:52:57 +08:00
} else {
/* A bit-field. Layout is more complicated. There are two
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
options: PCC (GCC) compatible and MS compatible */
if (pcc) {
/* In PCC layout a bit-field is placed adjacent to the
preceding bit-fields, except if:
- it has zero-width
- an individual alignment was given
- it would overflow its base type container and
there is no packing */
if (bit_size == 0) {
new_field:
c = (c + ((bit_pos + 7) >> 3) + align - 1) & -align;
Fix struct layout some more Anonymous sub-sub-members weren't handled correctly. Bit-fields neither: this implements PCC layout for now. It temporarily disables MS-compatible bit-field layout.
2016-10-09 06:52:57 +08:00
bit_pos = 0;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
} else if (f->a.aligned) {
goto new_field;
} else if (!packed) {
int a8 = align * 8;
int ofs = ((c * 8 + bit_pos) % a8 + bit_size + a8 - 1) / a8;
if (ofs > size / align)
goto new_field;
}
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
/* in pcc mode, long long bitfields have type int if they fit */
if (size == 8 && bit_size <= 32)
f->type.t = (f->type.t & ~VT_BTYPE) | VT_INT, size = 4;
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
while (bit_pos >= align * 8)
c += align, bit_pos -= align * 8;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
offset = c;
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
Fix struct layout some more Anonymous sub-sub-members weren't handled correctly. Bit-fields neither: this implements PCC layout for now. It temporarily disables MS-compatible bit-field layout.
2016-10-09 06:52:57 +08:00
/* In PCC layout named bit-fields influence the alignment
of the containing struct using the base types alignment,
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
except for packed fields (which here have correct align). */
tccgen: nodata_wanted fix, default ONE_SOURCE, etc... tccgen.c: doubles need to be aligned, on ARM. The section_reserve() in init_putv does not do that. -D ONE_SOURCE: is now the default and not longer needed. Also, tcc.h now sets the default native target. These both make compiling tcc simple as "gcc tcc.c -o tcc -ldl" again. arm-asm.c: enable pseudo asm also for inline asm tests/tests2/Makefile: disable bitfield tests except on windows and x86_64 and don't generate-always tcc.c: fix a loop with -dt on errors configure: print compiler version (as recognized) tccpp.c: actually define symbols for tcc -dt clear static variables (needed for -dt or libtcc usage) 96_nodata_wanted.c: use __label__ instead of asm lib/files: use native symbols (__i386__ etc.) instead of TCC_TARGET_...
2017-07-24 03:24:11 +08:00
if (f->v & SYM_FIRST_ANOM
// && bit_size // ??? gcc on ARM/rpi does that
)
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
align = 1;
tccgen: nodata_wanted fix, default ONE_SOURCE, etc... tccgen.c: doubles need to be aligned, on ARM. The section_reserve() in init_putv does not do that. -D ONE_SOURCE: is now the default and not longer needed. Also, tcc.h now sets the default native target. These both make compiling tcc simple as "gcc tcc.c -o tcc -ldl" again. arm-asm.c: enable pseudo asm also for inline asm tests/tests2/Makefile: disable bitfield tests except on windows and x86_64 and don't generate-always tcc.c: fix a loop with -dt on errors configure: print compiler version (as recognized) tccpp.c: actually define symbols for tcc -dt clear static variables (needed for -dt or libtcc usage) 96_nodata_wanted.c: use __label__ instead of asm lib/files: use native symbols (__i386__ etc.) instead of TCC_TARGET_...
2017-07-24 03:24:11 +08:00
Fix struct layout some more Anonymous sub-sub-members weren't handled correctly. Bit-fields neither: this implements PCC layout for now. It temporarily disables MS-compatible bit-field layout.
2016-10-09 06:52:57 +08:00
} else {
bitfields: Implement MS compatible layout Bit-fields are layed out differently in visual C, this implements a compatible mode. Checked against Visual C/C++ 2016. Unfortunately the GCC implementation of MS layout (behind -mms-bitfields) actually is different, and hence not compatible with MS in all cases :-/
2016-11-08 02:36:21 +08:00
bt = f->type.t & VT_BTYPE;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
if ((bit_pos + bit_size > size * 8)
|| (bit_size > 0) == (bt != prevbt)
) {
c = (c + align - 1) & -align;
bitfields: Implement MS compatible layout Bit-fields are layed out differently in visual C, this implements a compatible mode. Checked against Visual C/C++ 2016. Unfortunately the GCC implementation of MS layout (behind -mms-bitfields) actually is different, and hence not compatible with MS in all cases :-/
2016-11-08 02:36:21 +08:00
offset = c;
bit_pos = 0;
/* In MS bitfield mode a bit-field run always uses
struct-layout: cleanup code a bit
2016-11-29 03:54:59 +08:00
at least as many bits as the underlying type.
To start a new run it's also required that this
or the last bit-field had non-zero width. */
bitfields: Fix MS layout some more Another corner case: struct foo6_1 { char x; short p:8; short :0; short :0; short p2:8; char y; }; In MS layout the second anon :0 bit-field does _not_ adjust size or alignment of the struct again. The first one does, though.
2016-11-29 03:27:42 +08:00
if (bit_size || prev_bit_size)
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
c += size;
bitfields: Implement MS compatible layout Bit-fields are layed out differently in visual C, this implements a compatible mode. Checked against Visual C/C++ 2016. Unfortunately the GCC implementation of MS layout (behind -mms-bitfields) actually is different, and hence not compatible with MS in all cases :-/
2016-11-08 02:36:21 +08:00
}
struct-layout: cleanup code a bit
2016-11-29 03:54:59 +08:00
/* In MS layout the records alignment is normally
influenced by the field, except for a zero-width
field at the start of a run (but by further zero-width
fields it is again). */
if (bit_size == 0 && prevbt != bt)
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
align = 1;
bitfields: Implement MS compatible layout Bit-fields are layed out differently in visual C, this implements a compatible mode. Checked against Visual C/C++ 2016. Unfortunately the GCC implementation of MS layout (behind -mms-bitfields) actually is different, and hence not compatible with MS in all cases :-/
2016-11-08 02:36:21 +08:00
prevbt = bt;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
prev_bit_size = bit_size;
Fix struct layout some more Anonymous sub-sub-members weren't handled correctly. Bit-fields neither: this implements PCC layout for now. It temporarily disables MS-compatible bit-field layout.
2016-10-09 06:52:57 +08:00
}
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
Fix struct layout some more Anonymous sub-sub-members weren't handled correctly. Bit-fields neither: this implements PCC layout for now. It temporarily disables MS-compatible bit-field layout.
2016-10-09 06:52:57 +08:00
f->type.t = (f->type.t & ~(0x3f << VT_STRUCT_SHIFT))
| (bit_pos << VT_STRUCT_SHIFT);
bit_pos += bit_size;
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
}
struct-layout: cleanup code a bit
2016-11-29 03:54:59 +08:00
if (align > maxalign)
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
maxalign = align;
#ifdef BF_DEBUG
printf("set field %s offset %-2d size %-2d align %-2d",
get_tok_str(f->v & ~SYM_FIELD, NULL), offset, size, align);
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
if (f->type.t & VT_BITFIELD) {
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
printf(" pos %-2d bits %-2d",
BIT_POS(f->type.t),
BIT_SIZE(f->type.t)
);
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
}
printf("\n");
#endif
Fix more struct inits anonymous struct members were somewhat broken as the testcase demonstrates. The reason is the jumping through hoops to fiddle with the offsets I once introduced to avoid having to track a cumulative offset. That's now not necessary anymore and actively harmful, doing the obvious thing is now better.
2019-04-11 06:30:41 +08:00
f->c = offset;
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
f->r = 0;
}
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
if (pcc)
c += (bit_pos + 7) >> 3;
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
/* store size and alignment */
a = bt = ad->a.aligned ? 1 << (ad->a.aligned - 1) : 1;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
if (a < maxalign)
a = maxalign;
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
type->ref->r = a;
tccgen: nodata_wanted fix, default ONE_SOURCE, etc... tccgen.c: doubles need to be aligned, on ARM. The section_reserve() in init_putv does not do that. -D ONE_SOURCE: is now the default and not longer needed. Also, tcc.h now sets the default native target. These both make compiling tcc simple as "gcc tcc.c -o tcc -ldl" again. arm-asm.c: enable pseudo asm also for inline asm tests/tests2/Makefile: disable bitfield tests except on windows and x86_64 and don't generate-always tcc.c: fix a loop with -dt on errors configure: print compiler version (as recognized) tccpp.c: actually define symbols for tcc -dt clear static variables (needed for -dt or libtcc usage) 96_nodata_wanted.c: use __label__ instead of asm lib/files: use native symbols (__i386__ etc.) instead of TCC_TARGET_...
2017-07-24 03:24:11 +08:00
if (pragma_pack && pragma_pack < maxalign && 0 == pcc) {
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
/* can happen if individual align for some member was given. In
this case MSVC ignores maxalign when aligning the size */
a = pragma_pack;
if (a < bt)
a = bt;
}
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
c = (c + a - 1) & -a;
type->ref->c = c;
#ifdef BF_DEBUG
printf("struct size %-2d align %-2d\n\n", c, a), fflush(stdout);
#endif
/* check whether we can access bitfields by their type */
for (f = type->ref->next; f; f = f->next) {
int s, px, cx, c0;
CType t;
if (0 == (f->type.t & VT_BITFIELD))
continue;
f->type.ref = f;
f->auxtype = -1;
bit_size = BIT_SIZE(f->type.t);
if (bit_size == 0)
continue;
bit_pos = BIT_POS(f->type.t);
size = type_size(&f->type, &align);
if (bit_pos + bit_size <= size * 8 && f->c + size <= c)
continue;
Spelling fixes Comments only, no change to functionality
2017-09-25 09:03:26 +08:00
/* try to access the field using a different type */
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
c0 = -1, s = align = 1;
for (;;) {
px = f->c * 8 + bit_pos;
cx = (px >> 3) & -align;
px = px - (cx << 3);
if (c0 == cx)
break;
s = (px + bit_size + 7) >> 3;
if (s > 4) {
t.t = VT_LLONG;
} else if (s > 2) {
t.t = VT_INT;
} else if (s > 1) {
t.t = VT_SHORT;
} else {
t.t = VT_BYTE;
}
s = type_size(&t, &align);
c0 = cx;
}
if (px + bit_size <= s * 8 && cx + s <= c) {
/* update offset and bit position */
f->c = cx;
bit_pos = px;
f->type.t = (f->type.t & ~(0x3f << VT_STRUCT_SHIFT))
| (bit_pos << VT_STRUCT_SHIFT);
if (s != size)
f->auxtype = t.t;
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
#ifdef BF_DEBUG
printf("FIX field %s offset %-2d size %-2d align %-2d "
"pos %-2d bits %-2d\n",
get_tok_str(f->v & ~SYM_FIELD, NULL),
cx, s, align, px, bit_size);
#endif
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
} else {
/* fall back to load/store single-byte wise */
f->auxtype = VT_STRUCT;
#ifdef BF_DEBUG
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
printf("FIX field %s : load byte-wise\n",
get_tok_str(f->v & ~SYM_FIELD, NULL));
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
#endif
#pragma comment(option,"-..."), bitfields test, etc... tccpp.c: * #pragma comment(option,"-some-option") to set commandline option from C code. May work only for some options. libtcc.c: * option "-d1..9": sets a 'g_debug' global variable. (for development) tests2/Makefile: * new make targets: tests2.37 / tests2.37+ run single test from tests2, optionally update .expect * new variable GEN-ALWAYS to always generate certain .expects * bitfields test tccgen.c: * bitfields: fix a bug and improve slightly more * _Generic: ignore "type match twice"
2017-07-15 01:26:01 +08:00
}
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
}
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
}
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
/* enum/struct/union declaration. u is VT_ENUM/VT_STRUCT/VT_UNION */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
static void struct_decl(CType *type, int u)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
int v, c, size, align, flexible;
struct-layout: cleanup code a bit
2016-11-29 03:54:59 +08:00
int bit_size, bsize, bt;
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
Sym *s, *ss, **ps;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
AttributeDef ad, ad1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
CType type1, btype;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
memset(&ad, 0, sizeof ad);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
parse_attribute(&ad);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok != '{') {
v = tok;
next();
/* struct already defined ? return it */
if (v < TOK_IDENT)
expect("struct/union/enum name");
s = struct_find(v);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (s && (s->sym_scope == local_scope || tok != '{')) {
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
if (u == s->type.t)
goto do_decl;
if (u == VT_ENUM && IS_ENUM(s->type.t))
goto do_decl;
tcc_error("redefinition of '%s'", get_tok_str(v, NULL));
Fix type parsing the check on incomplete struct/union/enum types was too early, disallowing mixed specifiers and qualifiers. Simply rely on the size (->c) field for that. See testcases.
2016-03-24 22:44:01 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
v = anon_sym++;
}
struct-init: Cleanup Remove dead code and variables. Properly check for unions when skipping fields in initializers. Make tests2/*.expect depend on the .c files so they are automatically rebuilt when the latter change.
2016-07-31 12:18:45 +08:00
/* Record the original enum/struct/union token. */
enums: Accept GNU extension See testcase. Happens e.g. in the linux kernel.
2017-07-11 04:20:34 +08:00
type1.t = u == VT_ENUM ? u | VT_INT | VT_UNSIGNED : u;
tccgen: fix crash with undeclared struct ... as in: #include<stdio.h> int main() { struct asdasd x; printf("%d\n", sizeof(x)); } This fixes commit 17571298f30bf204fafe9cf1aca5258d2d087d63
2013-07-24 23:06:13 +08:00
type1.ref = NULL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* we put an undefined size for struct/union */
s = sym_push(v | SYM_STRUCT, &type1, 0, -1);
s->r = 0; /* default alignment is zero as gcc */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
do_decl:
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
type->t = s->type.t;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type->ref = s;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok == '{') {
next();
if (s->c != -1)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("struct/union/enum already defined");
Don't endlessly recurse on invalid nested typedefs see testcase.
2019-04-07 09:15:05 +08:00
s->c = -2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* cannot be empty */
/* non empty enums are not allowed */
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
ps = &s->next;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (u == VT_ENUM) {
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
long long ll = 0, pl = 0, nl = 0;
CType t;
t.ref = s;
/* enum symbols have static storage */
t.t = VT_INT|VT_STATIC|VT_ENUM_VAL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
for(;;) {
v = tok;
if (v < TOK_UIDENT)
expect("identifier");
Report error when redefining enumerator Prevent the following code from compiling: enum color {RED, GREEN, BLUE}; enum rgb {RED, G, B};
2013-09-21 04:49:49 +08:00
ss = sym_find(v);
Allow local redefinition of enumerator
2014-03-31 22:58:17 +08:00
if (ss && !local_stack)
Report error when redefining enumerator Prevent the following code from compiling: enum color {RED, GREEN, BLUE}; enum rgb {RED, G, B};
2013-09-21 04:49:49 +08:00
tcc_error("redefinition of enumerator '%s'",
get_tok_str(v, NULL));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
if (tok == '=') {
next();
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
ll = expr_const64();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
ss = sym_push(v, &t, VT_CONST, 0);
ss->enum_val = ll;
*ps = ss, ps = &ss->next;
if (ll < nl)
nl = ll;
if (ll > pl)
pl = ll;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok != ',')
break;
next();
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
ll++;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* NOTE: we accept a trailing comma */
if (tok == '}')
break;
}
skip('}');
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
/* set integral type of the enum */
t.t = VT_INT;
enums: Accept GNU extension See testcase. Happens e.g. in the linux kernel.
2017-07-11 04:20:34 +08:00
if (nl >= 0) {
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
if (pl != (unsigned)pl)
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t.t = (LONG_SIZE==8 ? VT_LLONG|VT_LONG : VT_LLONG);
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
t.t |= VT_UNSIGNED;
} else if (pl != (int)pl || nl != (int)nl)
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t.t = (LONG_SIZE==8 ? VT_LLONG|VT_LONG : VT_LLONG);
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
s->type.t = type->t = t.t | VT_ENUM;
s->c = 0;
/* set type for enum members */
for (ss = s->next; ss; ss = ss->next) {
ll = ss->enum_val;
if (ll == (int)ll) /* default is int if it fits */
continue;
if (t.t & VT_UNSIGNED) {
ss->type.t |= VT_UNSIGNED;
if (ll == (unsigned)ll)
continue;
}
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
ss->type.t = (ss->type.t & ~VT_BTYPE)
| (LONG_SIZE==8 ? VT_LLONG|VT_LONG : VT_LLONG);
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
c = 0;
Detect usage of incomplete types inside struct/union Make sure the only exception is for a flexible array member as the last element of a structure
2013-10-06 20:43:16 +08:00
flexible = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
while (tok != '}') {
Accept empty struct member decls struct S { /*nothing*/; int a; }; is an acceptable struct declaration, there may be stray semicolons in the member list.
2016-06-28 21:09:40 +08:00
if (!parse_btype(&btype, &ad1)) {
skip(';');
continue;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
while (1) {
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (flexible)
tcc_error("flexible array member '%s' not at the end of struct",
Detect usage of incomplete types inside struct/union Make sure the only exception is for a flexible array member as the last element of a structure
2013-10-06 20:43:16 +08:00
get_tok_str(v, NULL));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
bit_size = -1;
v = 0;
type1 = btype;
if (tok != ':') {
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
if (tok != ';')
type_decl(&type1, &ad1, &v, TYPE_DIRECT);
fix the bug #31403: parser bug in structure - a warning: unnamed struct/union that defines no instances - allow a nested named struct declaration w/o identifier only when option -fms-extensions is used
2015-04-10 11:31:58 +08:00
if (v == 0) {
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if ((type1.t & VT_BTYPE) != VT_STRUCT)
expect("identifier");
else {
int v = btype.ref->v;
if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
if (tcc_state->ms_extensions == 0)
expect("identifier");
}
}
fix the bug #31403: parser bug in structure - a warning: unnamed struct/union that defines no instances - allow a nested named struct declaration w/o identifier only when option -fms-extensions is used
2015-04-10 11:31:58 +08:00
}
Detect usage of incomplete types inside struct/union Make sure the only exception is for a flexible array member as the last element of a structure
2013-10-06 20:43:16 +08:00
if (type_size(&type1, &align) < 0) {
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if ((u == VT_STRUCT) && (type1.t & VT_ARRAY) && c)
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
flexible = 1;
else
tcc_error("field '%s' has incomplete type",
get_tok_str(v, NULL));
Detect usage of incomplete types inside struct/union Make sure the only exception is for a flexible array member as the last element of a structure
2013-10-06 20:43:16 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if ((type1.t & VT_BTYPE) == VT_FUNC ||
Check for void type in top-level decls give an error message from the parser on things like "void x;" instead of relying on codegen erroring out.
2018-08-04 04:39:00 +08:00
(type1.t & VT_BTYPE) == VT_VOID ||
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
(type1.t & VT_STORAGE))
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
tcc_error("invalid type for '%s'",
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
get_tok_str(v, NULL));
}
if (tok == ':') {
next();
bit_size = expr_const();
/* XXX: handle v = 0 case for messages */
if (bit_size < 0)
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
tcc_error("negative width in bit-field '%s'",
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
get_tok_str(v, NULL));
if (v && bit_size == 0)
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
tcc_error("zero width for bit-field '%s'",
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
get_tok_str(v, NULL));
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
parse_attribute(&ad1);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
size = type_size(&type1, &align);
if (bit_size >= 0) {
bt = type1.t & VT_BTYPE;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (bt != VT_INT &&
bt != VT_BYTE &&
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
bt != VT_SHORT &&
bt != VT_BOOL &&
bt != VT_LLONG)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("bitfields must have scalar type");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
bsize = size * 8;
if (bit_size > bsize) {
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("width of '%s' exceeds its type",
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
get_tok_str(v, NULL));
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
} else if (bit_size == bsize
&& !ad.a.packed && !ad1.a.packed) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* no need for bit fields */
struct-layout: cleanup code a bit
2016-11-29 03:54:59 +08:00
;
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
} else if (bit_size == 64) {
tcc_error("field width 64 not implemented");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
type1.t = (type1.t & ~VT_STRUCT_MASK)
| VT_BITFIELD
| (bit_size << (VT_STRUCT_SHIFT + 6));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
if (v != 0 || (type1.t & VT_BTYPE) == VT_STRUCT) {
Split off record layouting Such struct decl: struct S { char a; int i;} __attribute__((packed)); should be accepted and cause S to be five bytes long (i.e. the packed attribute should matter). So we can't layout the members during parsing already. Split off the offset and alignment calculation for this.
2016-10-03 03:37:58 +08:00
/* Remember we've seen a real field to check
for placement of flexible array member. */
c = 1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
struct-layout: cleanup code a bit
2016-11-29 03:54:59 +08:00
/* If member is a struct or bit-field, enforce
placing into the struct (as anonymous). */
if (v == 0 &&
((type1.t & VT_BTYPE) == VT_STRUCT ||
bit_size >= 0)) {
struct-init: Correctly parse unnamed member initializers For union U { struct {int a,b}; int c; }; union U u = {{ 1, 2, }}; The unnamed first member of union U needs to actually exist in the structure so initializer parsing isn't confused about the double braces. That means also the a and b members must be part of _that_, not of union U directly. Which in turn means we need to do a bit more work for field lookup. See the testcase extension for more things that need to work.
2016-08-02 04:11:49 +08:00
v = anon_sym++;
}
if (v) {
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
ss = sym_push(v | SYM_FIELD, &type1, 0, 0);
ss->a = ad1.a;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
*ps = ss;
ps = &ss->next;
}
if (tok == ';' || tok == TOK_EOF)
break;
skip(',');
}
skip(';');
}
skip('}');
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
parse_attribute(&ad);
struct_layout(type, &ad);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
}
Fix function types various cases of function type uses were broken by recent attribute refactoring, this fixes and adds testcases for them.
2017-07-14 23:42:48 +08:00
static void sym_to_attr(AttributeDef *ad, Sym *s)
{
Fix more attribute placements when parsing the type in this cast: (int (__attribute__(X) *)(int))foo we ignored the attribute, which matters if it's e.g. a 'stdcall' attribute on the function pointer. Only this particular placement was misparsed. Putting the attribute after the '*' or outside the inner parens worked. This idiom seems to be used on SQLite, perhaps this fixes a compilation problem on win32 with that.
2019-01-01 05:00:31 +08:00
merge_symattr(&ad->a, &s->a);
merge_funcattr(&ad->f, &s->f);
Fix function types various cases of function type uses were broken by recent attribute refactoring, this fixes and adds testcases for them.
2017-07-14 23:42:48 +08:00
}
tccgen.c: In parse_btype, handle type qualifiers applied to arrays. Also add some test cases in tests/tests2/39_typedef.c.
2016-01-11 15:51:58 +08:00
/* Add type qualifiers to a type. If the type is an array then the qualifiers
are added to the element type, copied because it could be a typedef. */
static void parse_btype_qualify(CType *type, int qualifiers)
{
while (type->t & VT_ARRAY) {
type->ref = sym_push(SYM_FIELD, &type->ref->type, 0, type->ref->c);
type = &type->ref->type;
}
type->t |= qualifiers;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* return 0 if no type declaration. otherwise, return the basic type
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
and skip it.
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
*/
static int parse_btype(CType *type, AttributeDef *ad)
{
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
int t, u, bt, st, type_found, typespec_found, g;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
Sym *s;
CType type1;
memset(ad, 0, sizeof(AttributeDef));
type_found = 0;
typespec_found = 0;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
t = VT_INT;
bt = st = -1;
type->ref = NULL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
while(1) {
switch(tok) {
case TOK_EXTENSION:
/* currently, we really ignore extension */
next();
continue;
/* basic types */
case TOK_CHAR:
u = VT_BYTE;
basic_type:
next();
basic_type1:
Revert "simplify VT_LONG parsing" Too simple long parsion. Take me a long long long time to see my mistake, Sorry (long long long wasn't see as an error) This reverts commit a4cd2805f95e1369254762478883e91050f2cba1.
2017-07-26 04:04:24 +08:00
if (u == VT_SHORT || u == VT_LONG) {
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (st != -1 || (bt != -1 && bt != VT_INT))
tmbt: tcc_error("too many basic types");
st = u;
} else {
if (bt != -1 || (st != -1 && u != VT_INT))
goto tmbt;
bt = u;
}
if (u != VT_INT)
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t = (t & ~(VT_BTYPE|VT_LONG)) | u;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
typespec_found = 1;
break;
case TOK_VOID:
u = VT_VOID;
goto basic_type;
case TOK_SHORT:
u = VT_SHORT;
goto basic_type;
case TOK_INT:
Make parse_btype only accept one basic type This makes int char c; and struct {} int c; generate an error. Thanks Mobi Phil for reporting.
2014-03-24 23:28:56 +08:00
u = VT_INT;
goto basic_type;
C11 conformance: Add _Noreturn, stdnoreturn.h, and partial _Alignas support _Noreturn, just like __attribute__((noreturn)), is ignored. I also added stdnoreturn.h, in all its glorious uselessness. _Alignas only works for integer expressions right now. In order to comply, we need: - _Alignas(type) -> _Alignas(_Alignof(type)). - stdalign.h as soon as it is done. Note: DR 444 is supported; it works on struct members. Signed-off-by: Devin Hussey <husseydevin@gmail.com>
2019-03-21 03:03:27 +08:00
case TOK_ALIGNAS:
{ int n;
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
AttributeDef ad1;
next();
skip('(');
memset(&ad1, 0, sizeof(AttributeDef));
if (parse_btype(&type1, &ad1)) {
type_decl(&type1, &ad1, &n, TYPE_ABSTRACT);
if (ad1.a.aligned)
n = 1 << (ad1.a.aligned - 1);
else
type_size(&type1, &n);
} else {
n = expr_const();
if (n <= 0 || (n & (n - 1)) != 0)
C11 conformance: Add _Noreturn, stdnoreturn.h, and partial _Alignas support _Noreturn, just like __attribute__((noreturn)), is ignored. I also added stdnoreturn.h, in all its glorious uselessness. _Alignas only works for integer expressions right now. In order to comply, we need: - _Alignas(type) -> _Alignas(_Alignof(type)). - stdalign.h as soon as it is done. Note: DR 444 is supported; it works on struct members. Signed-off-by: Devin Hussey <husseydevin@gmail.com>
2019-03-21 03:03:27 +08:00
tcc_error("alignment must be a positive power of two");
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
}
skip(')');
ad->a.aligned = exact_log2p1(n);
C11 conformance: Add _Noreturn, stdnoreturn.h, and partial _Alignas support _Noreturn, just like __attribute__((noreturn)), is ignored. I also added stdnoreturn.h, in all its glorious uselessness. _Alignas only works for integer expressions right now. In order to comply, we need: - _Alignas(type) -> _Alignas(_Alignof(type)). - stdalign.h as soon as it is done. Note: DR 444 is supported; it works on struct members. Signed-off-by: Devin Hussey <husseydevin@gmail.com>
2019-03-21 03:03:27 +08:00
}
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
continue;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_LONG:
if ((t & VT_BTYPE) == VT_DOUBLE) {
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t = (t & ~(VT_BTYPE|VT_LONG)) | VT_LDOUBLE;
} else if ((t & (VT_BTYPE|VT_LONG)) == VT_LONG) {
t = (t & ~(VT_BTYPE|VT_LONG)) | VT_LLONG;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
Revert "simplify VT_LONG parsing" Too simple long parsion. Take me a long long long time to see my mistake, Sorry (long long long wasn't see as an error) This reverts commit a4cd2805f95e1369254762478883e91050f2cba1.
2017-07-26 04:04:24 +08:00
u = VT_LONG;
goto basic_type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
next();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#ifdef TCC_TARGET_ARM64
case TOK_UINT128:
/* GCC's __uint128_t appears in some Linux header files. Make it a
synonym for long double to get the size and alignment right. */
u = VT_LDOUBLE;
goto basic_type;
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_BOOL:
u = VT_BOOL;
goto basic_type;
case TOK_FLOAT:
u = VT_FLOAT;
goto basic_type;
case TOK_DOUBLE:
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
if ((t & (VT_BTYPE|VT_LONG)) == VT_LONG) {
t = (t & ~(VT_BTYPE|VT_LONG)) | VT_LDOUBLE;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
u = VT_DOUBLE;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
goto basic_type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
next();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
case TOK_ENUM:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
struct_decl(&type1, VT_ENUM);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
basic_type2:
u = type1.t;
type->ref = type1.ref;
goto basic_type1;
case TOK_STRUCT:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
struct_decl(&type1, VT_STRUCT);
goto basic_type2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_UNION:
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
struct_decl(&type1, VT_UNION);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
goto basic_type2;
/* type modifiers */
case TOK_CONST1:
case TOK_CONST2:
case TOK_CONST3:
tccgen.c: In parse_btype, handle type qualifiers applied to arrays. Also add some test cases in tests/tests2/39_typedef.c.
2016-01-11 15:51:58 +08:00
type->t = t;
parse_btype_qualify(type, VT_CONSTANT);
t = type->t;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
break;
case TOK_VOLATILE1:
case TOK_VOLATILE2:
case TOK_VOLATILE3:
tccgen.c: In parse_btype, handle type qualifiers applied to arrays. Also add some test cases in tests/tests2/39_typedef.c.
2016-01-11 15:51:58 +08:00
type->t = t;
parse_btype_qualify(type, VT_VOLATILE);
t = type->t;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
break;
case TOK_SIGNED1:
case TOK_SIGNED2:
case TOK_SIGNED3:
Def signedness != signed != unsigned for char When checking for exact compatibility between types (such as in __builtin_types_compatible_p) consider the case of default signedness to be incompatible with both of the explicit signedness for char. That is, char is incompatible with signed char *and* unsigned char, no matter what the default signedness for char is.
2014-02-06 20:51:47 +08:00
if ((t & (VT_DEFSIGN|VT_UNSIGNED)) == (VT_DEFSIGN|VT_UNSIGNED))
tcc_error("signed and unsigned modifier");
t |= VT_DEFSIGN;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
typespec_found = 1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
case TOK_REGISTER:
case TOK_AUTO:
case TOK_RESTRICT1:
case TOK_RESTRICT2:
case TOK_RESTRICT3:
next();
break;
case TOK_UNSIGNED:
Def signedness != signed != unsigned for char When checking for exact compatibility between types (such as in __builtin_types_compatible_p) consider the case of default signedness to be incompatible with both of the explicit signedness for char. That is, char is incompatible with signed char *and* unsigned char, no matter what the default signedness for char is.
2014-02-06 20:51:47 +08:00
if ((t & (VT_DEFSIGN|VT_UNSIGNED)) == VT_DEFSIGN)
tcc_error("signed and unsigned modifier");
t |= VT_DEFSIGN | VT_UNSIGNED;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
typespec_found = 1;
break;
/* storage */
case TOK_EXTERN:
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
g = VT_EXTERN;
goto storage;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_STATIC:
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
g = VT_STATIC;
goto storage;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_TYPEDEF:
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
g = VT_TYPEDEF;
goto storage;
storage:
if (t & (VT_EXTERN|VT_STATIC|VT_TYPEDEF) & ~g)
tcc_error("multiple storage classes");
t |= g;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
break;
case TOK_INLINE1:
case TOK_INLINE2:
case TOK_INLINE3:
t |= VT_INLINE;
next();
break;
C11 conformance: Add _Noreturn, stdnoreturn.h, and partial _Alignas support _Noreturn, just like __attribute__((noreturn)), is ignored. I also added stdnoreturn.h, in all its glorious uselessness. _Alignas only works for integer expressions right now. In order to comply, we need: - _Alignas(type) -> _Alignas(_Alignof(type)). - stdalign.h as soon as it is done. Note: DR 444 is supported; it works on struct members. Signed-off-by: Devin Hussey <husseydevin@gmail.com>
2019-03-21 03:03:27 +08:00
case TOK_NORETURN3:
/* currently, no need to handle it because tcc does not
track unused objects */
next();
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* GNUC attribute */
case TOK_ATTRIBUTE1:
case TOK_ATTRIBUTE2:
parse_attribute(ad);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (ad->attr_mode) {
u = ad->attr_mode -1;
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t = (t & ~(VT_BTYPE|VT_LONG)) | u;
Add support for the __mode__ attribute -- By by ... Detlef
2010-01-27 05:56:22 +08:00
}
Fix misparsed type in presence of attributes The type within the cast (int (__attribute__((foo)) *)(void)) was misparsed because of the presence of the attribute (parse_btype prematurely concluded that (__attribute__() *) is a type. Also see testcase. This construct is used in sqlite it seems.
2018-07-29 00:55:54 +08:00
continue;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* GNUC typeof */
case TOK_TYPEOF1:
case TOK_TYPEOF2:
case TOK_TYPEOF3:
next();
parse_expr_type(&type1);
__typeof(t) should not include storage modifiers of t
2011-03-07 14:32:35 +08:00
/* remove all storage modifiers except typedef */
type1.t &= ~(VT_STORAGE&~VT_TYPEDEF);
Fix function types various cases of function type uses were broken by recent attribute refactoring, this fixes and adds testcases for them.
2017-07-14 23:42:48 +08:00
if (type1.ref)
sym_to_attr(ad, type1.ref);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
goto basic_type2;
default:
Make parse_btype only accept one basic type This makes int char c; and struct {} int c; generate an error. Thanks Mobi Phil for reporting.
2014-03-24 23:28:56 +08:00
if (typespec_found)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
goto the_end;
s = sym_find(tok);
if (!s || !(s->type.t & VT_TYPEDEF))
goto the_end;
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t &= ~(VT_BTYPE|VT_LONG);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
u = t & ~(VT_CONSTANT | VT_VOLATILE), t ^= u;
type->t = (s->type.t & ~VT_TYPEDEF) | u;
tccgen.c: In parse_btype, handle type qualifiers applied to arrays. Also add some test cases in tests/tests2/39_typedef.c.
2016-01-11 15:51:58 +08:00
type->ref = s->type.ref;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (t)
parse_btype_qualify(type, t);
tccgen.c: In parse_btype, handle type qualifiers applied to arrays. Also add some test cases in tests/tests2/39_typedef.c.
2016-01-11 15:51:58 +08:00
t = type->t;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
/* get attributes from typedef */
Fix function types various cases of function type uses were broken by recent attribute refactoring, this fixes and adds testcases for them.
2017-07-14 23:42:48 +08:00
sym_to_attr(ad, s);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
typespec_found = 1;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
st = bt = -2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
}
type_found = 1;
}
the_end:
if (tcc_state->char_is_unsigned) {
Def signedness != signed != unsigned for char When checking for exact compatibility between types (such as in __builtin_types_compatible_p) consider the case of default signedness to be incompatible with both of the explicit signedness for char. That is, char is incompatible with signed char *and* unsigned char, no matter what the default signedness for char is.
2014-02-06 20:51:47 +08:00
if ((t & (VT_DEFSIGN|VT_BTYPE)) == VT_BYTE)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
t |= VT_UNSIGNED;
}
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
/* VT_LONG is used just as a modifier for VT_INT / VT_LLONG */
bt = t & (VT_BTYPE|VT_LONG);
if (bt == VT_LONG)
t |= LONG_SIZE == 8 ? VT_LLONG : VT_INT;
#ifdef TCC_TARGET_PE
if (bt == VT_LDOUBLE)
t = (t & ~(VT_BTYPE|VT_LONG)) | VT_DOUBLE;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#endif
type->t = t;
return type_found;
}
/* convert a function parameter type (array to pointer and function to
function pointer) */
static inline void convert_parameter_type(CType *pt)
{
/* remove const and volatile qualifiers (XXX: const could be used
to indicate a const function parameter */
pt->t &= ~(VT_CONSTANT | VT_VOLATILE);
/* array must be transformed to pointer according to ANSI C */
pt->t &= ~VT_ARRAY;
if ((pt->t & VT_BTYPE) == VT_FUNC) {
mk_pointer(pt);
}
}
Move asm label functions from tccasm.c to tccgen.c * Move functions parse_asm_str and asm_label_instr from tccasm.c to tccgen.c * Remove CONFIG_TCC_ASM_LABEL macro as asm label are available on all archs. See: http://lists.nongnu.org/archive/html/tinycc-devel/2010-09/msg00026.html for the rationale.
2010-09-15 01:17:39 +08:00
ST_FUNC void parse_asm_str(CString *astr)
{
skip('(');
Accept concatenated strings in attributes attribute(section("one" "two")) should be accepted (the section name being "onetwo"), it's normal string concatenation.
2016-06-28 02:10:53 +08:00
parse_mult_str(astr, "string constant");
Move asm label functions from tccasm.c to tccgen.c * Move functions parse_asm_str and asm_label_instr from tccasm.c to tccgen.c * Remove CONFIG_TCC_ASM_LABEL macro as asm label are available on all archs. See: http://lists.nongnu.org/archive/html/tinycc-devel/2010-09/msg00026.html for the rationale.
2010-09-15 01:17:39 +08:00
}
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
/* Parse an asm label and return the token */
static int asm_label_instr(void)
Move asm label functions from tccasm.c to tccgen.c * Move functions parse_asm_str and asm_label_instr from tccasm.c to tccgen.c * Remove CONFIG_TCC_ASM_LABEL macro as asm label are available on all archs. See: http://lists.nongnu.org/archive/html/tinycc-devel/2010-09/msg00026.html for the rationale.
2010-09-15 01:17:39 +08:00
{
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
int v;
CString astr;
Move asm label functions from tccasm.c to tccgen.c * Move functions parse_asm_str and asm_label_instr from tccasm.c to tccgen.c * Remove CONFIG_TCC_ASM_LABEL macro as asm label are available on all archs. See: http://lists.nongnu.org/archive/html/tinycc-devel/2010-09/msg00026.html for the rationale.
2010-09-15 01:17:39 +08:00
next();
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
parse_asm_str(&astr);
Move asm label functions from tccasm.c to tccgen.c * Move functions parse_asm_str and asm_label_instr from tccasm.c to tccgen.c * Remove CONFIG_TCC_ASM_LABEL macro as asm label are available on all archs. See: http://lists.nongnu.org/archive/html/tinycc-devel/2010-09/msg00026.html for the rationale.
2010-09-15 01:17:39 +08:00
skip(')');
#ifdef ASM_DEBUG
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
printf("asm_alias: \"%s\"\n", (char *)astr.data);
Move asm label functions from tccasm.c to tccgen.c * Move functions parse_asm_str and asm_label_instr from tccasm.c to tccgen.c * Remove CONFIG_TCC_ASM_LABEL macro as asm label are available on all archs. See: http://lists.nongnu.org/archive/html/tinycc-devel/2010-09/msg00026.html for the rationale.
2010-09-15 01:17:39 +08:00
#endif
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
v = tok_alloc(astr.data, astr.size - 1)->tok;
cstr_free(&astr);
return v;
Move asm label functions from tccasm.c to tccgen.c * Move functions parse_asm_str and asm_label_instr from tccasm.c to tccgen.c * Remove CONFIG_TCC_ASM_LABEL macro as asm label are available on all archs. See: http://lists.nongnu.org/archive/html/tinycc-devel/2010-09/msg00026.html for the rationale.
2010-09-15 01:17:39 +08:00
}
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
static int post_type(CType *type, AttributeDef *ad, int storage, int td)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int n, l, t1, arg_size, align;
Sym **plast, *s, *first;
AttributeDef ad1;
CType pt;
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
if (tok == '(') {
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
/* function type, or recursive declarator (return if so) */
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
next();
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
if (td && !(td & TYPE_ABSTRACT))
return 0;
if (tok == ')')
l = 0;
else if (parse_btype(&pt, &ad1))
l = FUNC_NEW;
Fix more attribute placements when parsing the type in this cast: (int (__attribute__(X) *)(int))foo we ignored the attribute, which matters if it's e.g. a 'stdcall' attribute on the function pointer. Only this particular placement was misparsed. Putting the attribute after the '*' or outside the inner parens worked. This idiom seems to be used on SQLite, perhaps this fixes a compilation problem on win32 with that.
2019-01-01 05:00:31 +08:00
else if (td) {
merge_attr (ad, &ad1);
return 0;
} else
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
l = FUNC_OLD;
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
first = NULL;
plast = &first;
arg_size = 0;
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
if (l) {
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
for(;;) {
/* read param name and compute offset */
if (l != FUNC_OLD) {
if ((pt.t & VT_BTYPE) == VT_VOID && tok == ')')
break;
type_decl(&pt, &ad1, &n, TYPE_DIRECT | TYPE_ABSTRACT);
if ((pt.t & VT_BTYPE) == VT_VOID)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("parameter declared as void");
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
} else {
n = tok;
if (n < TOK_UIDENT)
expect("identifier");
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
pt.t = VT_VOID; /* invalid type */
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
next();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
convert_parameter_type(&pt);
misc fixes misc fixes including: - tcc.c: fix "tcc -vv" for libtcc1.a on win32/PE - tccelf.c: fix a crash when GOT has no relocs (witn -nostdlib) - tccelf.c: fix stab linkage for zero n_strx - tccgen.c: fix stdcall decoration for array parameters int __stdcall func(char buf[10]) is _func@4 (was _func@12) - tccgen.c: fix static variables with nocode/nodata_wanted see tests2/96_nodata_wanted.c - tccrun.c: align sections using sh_addralign (for reliable function_alignment) - tests2/Makefile sort 100 after 99 - win32/include/sys/stat.h fix _stat and _wstat - x86_64-gen.c: win64/gfunc_call: fix a bug with xmmN register args previously overwrote valid other xmmN registers eventually
2018-06-01 05:51:51 +08:00
arg_size += (type_size(&pt, &align) + PTR_SIZE - 1) / PTR_SIZE;
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
s = sym_push(n | SYM_FIELD, &pt, 0, 0);
*plast = s;
plast = &s->next;
if (tok == ')')
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
skip(',');
if (l == FUNC_NEW && tok == TOK_DOTS) {
l = FUNC_ELLIPSIS;
next();
break;
}
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
if (l == FUNC_NEW && !parse_btype(&pt, &ad1))
tcc_error("invalid type");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
} else
/* if no parameters, then old type prototype */
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
l = FUNC_OLD;
skip(')');
/* NOTE: const is ignored in returned type as it has a special
meaning in gcc / C++ */
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
type->t &= ~VT_CONSTANT;
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
/* some ancient pre-K&R C allows a function to return an array
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
and the array brackets to be put after the arguments, such
clarify support for functions returning an array (try#2) fixes first attempt: http://repo.or.cz/w/tinycc.git/commitdiff/31fe1cc
2011-03-09 07:12:09 +08:00
that "int c()[]" means something like "int[] c()" */
if (tok == '[') {
next();
skip(']'); /* only handle simple "[]" */
Fix segfault with invalid function def This invalid function definition: int f()[] {} was tried to be handled but there was no testcase if it actually worked. This fixes it and adds a TCC only testcase.
2017-05-06 04:01:02 +08:00
mk_pointer(type);
clarify support for functions returning an array (try#2) fixes first attempt: http://repo.or.cz/w/tinycc.git/commitdiff/31fe1cc
2011-03-09 07:12:09 +08:00
}
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
/* we push a anonymous symbol which will contain the function prototype */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
ad->f.func_args = arg_size;
ad->f.func_type = l;
s = sym_push(SYM_FIELD, type, 0, 0);
be stricter with aliasing Refactoring (no logical changes): - use memcpy in tccgen.c:ieee_finite(double d) - use union to store attribute flags in Sym Makefile: "CFLAGS+=-fno-strict-aliasing" basically not necessary anymore but I left it for now because gcc sometimes behaves unexpectedly without. Also: - configure: back to mode 100755 - tcc.h: remove unused variables tdata/tbss_section - x86_64-gen.c: adjust gfunc_sret for prototype
2014-01-07 21:57:07 +08:00
s->a = ad->a;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
s->f = ad->f;
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
s->next = first;
clarify post_type() VT_STORAGE handling by moving it out
2011-04-07 03:08:50 +08:00
type->t = VT_FUNC;
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
type->ref = s;
} else if (tok == '[') {
Fix sizeof(char[a]) The sizes of VLAs need to be evaluated even inside sizeof, i.e. when nocode_wanted is set.
2016-09-04 05:55:54 +08:00
int saved_nocode_wanted = nocode_wanted;
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
/* array definition */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
Don't fail on const/restrict/static/* inside [] This patch makes tcc ignore them. Normally (as per the C standard), They should be only applicable inside parameter arrays and affect (const/restrict) the pointer the array gets converted to. [matz: fix formatting, add volatile handling, add testcase, add comment about above deficiency]
2018-03-23 20:19:58 +08:00
while (1) {
/* XXX The optional type-quals and static should only be accepted
in parameter decls. The '*' as well, and then even only
in prototypes (not function defs). */
switch (tok) {
case TOK_RESTRICT1: case TOK_RESTRICT2: case TOK_RESTRICT3:
case TOK_CONST1:
case TOK_VOLATILE1:
case TOK_STATIC:
case '*':
next();
continue;
default:
break;
}
break;
}
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
n = -1;
clarify post_type() VT_STORAGE handling by moving it out
2011-04-07 03:08:50 +08:00
t1 = 0;
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
if (tok != ']') {
Fix sizeof(char[a]) The sizes of VLAs need to be evaluated even inside sizeof, i.e. when nocode_wanted is set.
2016-09-04 05:55:54 +08:00
if (!local_stack || (storage & VT_STATIC))
vpushi(expr_const());
else {
/* VLAs (which can only happen with local_stack && !VT_STATIC)
length must always be evaluated, even under nocode_wanted,
so that its size slot is initialized (e.g. under sizeof
or typeof). */
nocode_wanted = 0;
gexpr();
}
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
n = vtop->c.i;
if (n < 0)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("invalid array size");
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
} else {
if (!is_integer_btype(vtop->type.t & VT_BTYPE))
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("size of variable length array should be an integer");
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
n = 0;
clarify post_type() VT_STORAGE handling by moving it out
2011-04-07 03:08:50 +08:00
t1 = VT_VLA;
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
}
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
}
skip(']');
/* parse next post type */
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
post_type(type, ad, storage, 0);
Forbid the use of array of functions Prevent the following code from compiling: int (*fct)[42](int x); Reported-by: Abdul Wadud Mohammad Mohibur Rashid <mohibur_rashid@yahoo.com>
2013-09-20 00:58:46 +08:00
if (type->t == VT_FUNC)
tcc_error("declaration of an array of functions");
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
t1 |= type->t & VT_VLA;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
VLA fix [3/3]: store VLA sizeofs in anonymous runtime stack vars
2011-04-10 13:52:25 +08:00
if (t1 & VT_VLA) {
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
if (n < 0)
tcc_error("need explicit inner array size in VLAs");
VLA fix [3/3]: store VLA sizeofs in anonymous runtime stack vars
2011-04-10 13:52:25 +08:00
loc -= type_size(&int_type, &align);
loc &= -align;
n = loc;
vla_runtime_type_size(type, &align);
gen_op('*');
VLA fix: save stack pointer right after modification This patch disables the optimization of saving stack pointers lazily, which didn't fully take into account that control flow might not reach the stack-saving instructions. I've decided to leave in the extra calls to vla_sp_save() in case anyone wants to restore this optimization. Tests added and enabled. There are two remaining bugs: VLA variables can be modified, and jumping into the scope of a declared VLA will cause a segfault rather than a compiler error. Both of these do not affect correct C code, but should be fixed at some point. Once VLA variables have been made properly immutable, we can share them with the saved stack pointer and save stack and instructions.
2015-04-28 17:23:29 +08:00
vset(&int_type, VT_LOCAL|VT_LVAL, n);
VLA fix [3/3]: store VLA sizeofs in anonymous runtime stack vars
2011-04-10 13:52:25 +08:00
vswap();
vstore();
}
if (n != -1)
vpop();
Fix sizeof(char[a]) The sizes of VLAs need to be evaluated even inside sizeof, i.e. when nocode_wanted is set.
2016-09-04 05:55:54 +08:00
nocode_wanted = saved_nocode_wanted;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
/* we push an anonymous symbol which will contain the array
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
element type */
s = sym_push(SYM_FIELD, type, 0, n);
VLA fix [2/3]: removed VT_ARRAY from VT_VLA types A VLA is not really an array, it's a pointer-to-an-array. Making this explicit allows us to back out a few parts of the original VLA patch and paves the way for the next part of the fix, where a VLA will be stored on the runtime stack as a pointer-to-an-array, rather than on the compile- time stack as a Sym*.
2011-04-08 16:09:39 +08:00
type->t = (t1 ? VT_VLA : VT_ARRAY) | VT_PTR;
revert last 3 commits. will find better way.
2011-03-09 04:56:13 +08:00
type->ref = s;
}
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
return 1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
/* Parse a type declarator (except basic type), and return the type
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
in 'type'. 'td' is a bitmask indicating which kind of type decl is
expected. 'type' should contain the basic type. 'ad' is the
attribute definition of the basic type. It can be modified by
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
type_decl(). If this (possibly abstract) declarator is a pointer chain
it returns the innermost pointed to type (equals *type, but is a different
pointer), otherwise returns type itself, that's used for recursive calls. */
static CType *type_decl(CType *type, AttributeDef *ad, int *v, int td)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
CType *post, *ret;
tccpp: alternative fix for #include_next infinite loop bug This replaces commit 3d409b08893873b917ccb8c34398bc41a4e84d7c - revert old fix in libtcc.c - #include_next: look up the file in the include stack to see if it is already included. Also: - streamline include code - remove 'type' from struct CachedInclude (obsolete because we check full filename anyway) - remove inc_type & inc_filename from struct Bufferedfile (obsolete) - fix bug with TOK_FLAG_ENDIF not being reset - unrelated: get rid of an 'variable potentially uninitialized' warning
2013-01-07 00:20:44 +08:00
int qualifiers, storage;
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
/* recursive type, remove storage bits first, apply them later again */
storage = type->t & VT_STORAGE;
type->t &= ~VT_STORAGE;
post = ret = type;
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
while (tok == '*') {
qualifiers = 0;
redo:
next();
switch(tok) {
case TOK_CONST1:
case TOK_CONST2:
case TOK_CONST3:
qualifiers |= VT_CONSTANT;
goto redo;
case TOK_VOLATILE1:
case TOK_VOLATILE2:
case TOK_VOLATILE3:
qualifiers |= VT_VOLATILE;
goto redo;
case TOK_RESTRICT1:
case TOK_RESTRICT2:
case TOK_RESTRICT3:
goto redo;
Support attribute between double pointer stars "int * __attribute__((something)) *" is supported by GCC.
2016-07-15 23:56:20 +08:00
/* XXX: clarify attribute handling */
case TOK_ATTRIBUTE1:
case TOK_ATTRIBUTE2:
parse_attribute(ad);
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
mk_pointer(type);
type->t |= qualifiers;
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
if (ret == type)
/* innermost pointed to type is the one for the first derivation */
ret = pointed_type(type);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok == '(') {
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
/* This is possibly a parameter type list for abstract declarators
('int ()'), use post_type for testing this. */
if (!post_type(type, ad, 0, td)) {
/* It's not, so it's a nested declarator, and the post operations
apply to the innermost pointed to type (if any). */
/* XXX: this is not correct to modify 'ad' at this point, but
the syntax is not clear */
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
parse_attribute(ad);
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
post = type_decl(type, ad, v, td);
skip(')');
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
} else
goto abstract;
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
} else if (tok >= TOK_IDENT && (td & TYPE_DIRECT)) {
/* type identifier */
*v = tok;
next();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
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
abstract:
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
if (!(td & TYPE_ABSTRACT))
expect("identifier");
*v = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
post_type(post, ad, storage, 0);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
parse_attribute(ad);
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
type->t |= storage;
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
return ret;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
/* compute the lvalue VT_LVAL_xxx needed to match type t. */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC int lvalue_type(int t)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int bt, r;
r = VT_LVAL;
bt = t & VT_BTYPE;
if (bt == VT_BYTE || bt == VT_BOOL)
r |= VT_LVAL_BYTE;
else if (bt == VT_SHORT)
r |= VT_LVAL_SHORT;
else
return r;
if (t & VT_UNSIGNED)
r |= VT_LVAL_UNSIGNED;
return r;
}
/* indirection with full error checking and bound check */
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void indir(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
if ((vtop->type.t & VT_BTYPE) != VT_PTR) {
if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
return;
expect("pointer");
}
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
if (vtop->r & VT_LVAL)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gv(RC_INT);
vtop->type = *pointed_type(&vtop->type);
/* Arrays and functions are never lvalues */
VLA fix [2/3]: removed VT_ARRAY from VT_VLA types A VLA is not really an array, it's a pointer-to-an-array. Making this explicit allows us to back out a few parts of the original VLA patch and paves the way for the next part of the fix, where a VLA will be stored on the runtime stack as a pointer-to-an-array, rather than on the compile- time stack as a Sym*.
2011-04-08 16:09:39 +08:00
if (!(vtop->type.t & VT_ARRAY) && !(vtop->type.t & VT_VLA)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
&& (vtop->type.t & VT_BTYPE) != VT_FUNC) {
vtop->r |= lvalue_type(vtop->type.t);
/* if bound checking, the referenced pointer must be checked */
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#ifdef CONFIG_TCC_BCHECK
move some global variables into TCCState
2009-05-12 00:45:44 +08:00
if (tcc_state->do_bounds_check)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop->r |= VT_MUSTBOUND;
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
/* pass a parameter to a function and do type checking and casting */
static void gfunc_param_typed(Sym *func, Sym *arg)
{
int func_type;
CType type;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
func_type = func->f.func_type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (func_type == FUNC_OLD ||
(func_type == FUNC_ELLIPSIS && arg == NULL)) {
/* default casting : only need to convert float to double */
if ((vtop->type.t & VT_BTYPE) == VT_FLOAT) {
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
gen_cast_s(VT_DOUBLE);
Fix parameter passing of long long bitfield
2014-02-04 20:54:28 +08:00
} else if (vtop->type.t & VT_BITFIELD) {
type.t = vtop->type.t & (VT_BTYPE | VT_UNSIGNED);
Fix enum bitfields passed to stdarg functions VT_ENUM types use the .ref member and can be VT_BITFIELD, so we need to copy it as well. Simply do it always.
2016-08-16 00:54:11 +08:00
type.ref = vtop->type.ref;
Fix parameter passing of long long bitfield
2014-02-04 20:54:28 +08:00
gen_cast(&type);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
} else if (arg == NULL) {
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("too many arguments to function");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
type = arg->type;
type.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
gen_assign_cast(&type);
}
}
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
/* parse an expression and return its type without any side effect. */
static void expr_type(CType *type, void (*expr_fn)(void))
Tidy typename parsing a bit
2017-02-27 10:34:33 +08:00
{
nocode_wanted++;
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
expr_fn();
Tidy typename parsing a bit
2017-02-27 10:34:33 +08:00
*type = vtop->type;
vpop();
nocode_wanted--;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* parse an expression of the form '(type)' or '(expr)' and return its
type */
static void parse_expr_type(CType *type)
{
int n;
AttributeDef ad;
skip('(');
if (parse_btype(type, &ad)) {
type_decl(type, &ad, &n, TYPE_ABSTRACT);
} else {
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
expr_type(type, gexpr);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
skip(')');
}
static void parse_type(CType *type)
{
AttributeDef ad;
int n;
if (!parse_btype(type, &ad)) {
expect("type");
}
type_decl(type, &ad, &n, TYPE_ABSTRACT);
}
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
static void parse_builtin_params(int nc, const char *args)
{
char c, sep = '(';
CType t;
if (nc)
nocode_wanted++;
next();
while ((c = *args++)) {
skip(sep);
sep = ',';
switch (c) {
case 'e': expr_eq(); continue;
case 't': parse_type(&t); vpush(&t); continue;
default: tcc_error("internal error"); break;
}
}
skip(')');
if (nc)
nocode_wanted--;
}
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
static void try_call_scope_cleanup(Sym *stop)
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
{
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
Sym *cls = current_cleanups;
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
for (; cls != stop; cls = cls->ncl) {
Sym *fs = cls->next;
Sym *vs = cls->prev_tok;
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
vpushsym(&fs->type, fs);
vset(&vs->type, vs->r, vs->c);
vtop->sym = vs;
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
mk_pointer(&vtop->type);
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
gaddrof();
gfunc_call(1);
}
}
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
static void try_call_cleanup_goto(Sym *cleanupstate)
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
{
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
Sym *oc, *cc;
int ocd, ccd;
remove C99 'for' loop initial declarations
2019-01-24 02:42:04 +08:00
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
if (!current_cleanups)
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
return;
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
/* search NCA of both cleanup chains given parents and initial depth */
ocd = cleanupstate ? cleanupstate->v & ~SYM_FIELD : 0;
for (ccd = ncleanups, oc = cleanupstate; ocd > ccd; --ocd, oc = oc->ncl)
;
for (cc = current_cleanups; ccd > ocd; --ccd, cc = cc->ncl)
;
for (; cc != oc; cc = cc->ncl, oc = oc->ncl, --ccd)
;
remove C99 'for' loop initial declarations
2019-01-24 02:42:04 +08:00
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
try_call_scope_cleanup(cc);
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
}
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void unary(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Correctly support all unary expression with sizeof Unary expression can start with a parenthesis. Thus, the current test to detect which sizeof form is being parsed is inaccurate. This patch makes tcc able to handle things like sizeof (x)[1] where x is declared as char x[5]; wich is a valid unary expression
2010-04-11 07:53:40 +08:00
int n, t, align, size, r, sizeof_caller;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
CType type;
Sym *s;
AttributeDef ad;
Correctly support all unary expression with sizeof Unary expression can start with a parenthesis. Thus, the current test to detect which sizeof form is being parsed is inaccurate. This patch makes tcc able to handle things like sizeof (x)[1] where x is declared as char x[5]; wich is a valid unary expression
2010-04-11 07:53:40 +08:00
sizeof_caller = in_sizeof;
in_sizeof = 0;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
type.ref = NULL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* XXX: GCC 2.95.3 does not generate a table although it should be
better here */
tok_next:
switch(tok) {
case TOK_EXTENSION:
next();
goto tok_next;
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
case TOK_LCHAR:
#ifdef TCC_TARGET_PE
t = VT_SHORT|VT_UNSIGNED;
goto push_tokc;
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_CINT:
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
case TOK_CCHAR:
Tidy unary() a bit factor code a bit for transforming tokens into SValues. This revealed a bug in TOK_GET (see testcase), which happened to be harmless before. So fix that as well.
2017-03-07 04:45:41 +08:00
t = VT_INT;
push_tokc:
type.t = t;
vsetc(&type, VT_CONST, &tokc);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
break;
case TOK_CUINT:
Tidy unary() a bit factor code a bit for transforming tokens into SValues. This revealed a bug in TOK_GET (see testcase), which happened to be harmless before. So fix that as well.
2017-03-07 04:45:41 +08:00
t = VT_INT | VT_UNSIGNED;
goto push_tokc;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_CLLONG:
Tidy unary() a bit factor code a bit for transforming tokens into SValues. This revealed a bug in TOK_GET (see testcase), which happened to be harmless before. So fix that as well.
2017-03-07 04:45:41 +08:00
t = VT_LLONG;
goto push_tokc;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_CULLONG:
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
t = VT_LLONG | VT_UNSIGNED;
Tidy unary() a bit factor code a bit for transforming tokens into SValues. This revealed a bug in TOK_GET (see testcase), which happened to be harmless before. So fix that as well.
2017-03-07 04:45:41 +08:00
goto push_tokc;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_CFLOAT:
Tidy unary() a bit factor code a bit for transforming tokens into SValues. This revealed a bug in TOK_GET (see testcase), which happened to be harmless before. So fix that as well.
2017-03-07 04:45:41 +08:00
t = VT_FLOAT;
goto push_tokc;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_CDOUBLE:
Tidy unary() a bit factor code a bit for transforming tokens into SValues. This revealed a bug in TOK_GET (see testcase), which happened to be harmless before. So fix that as well.
2017-03-07 04:45:41 +08:00
t = VT_DOUBLE;
goto push_tokc;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_CLDOUBLE:
Tidy unary() a bit factor code a bit for transforming tokens into SValues. This revealed a bug in TOK_GET (see testcase), which happened to be harmless before. So fix that as well.
2017-03-07 04:45:41 +08:00
t = VT_LDOUBLE;
goto push_tokc;
mutiples fix for _Generic * check that _Generic don't match unsigned char * with char * this case is usefull as with -funsigned-char, 'char *' are unsigned * change VT_LONG so it's now a qualifier VT_LONG are never use for code generation, but only durring parsing state, in _Generic we need to be able to make diference between 'long' and 'long long' So VT_LONG is now use as a type qualifier, it's old behaviour is still here, but we can keep trace of what was a long and what wasn't * add TOK_CLONG and TOK_CULONG tcc was directly converting value like '7171L' into TOK_CLLONG or TOK_CINT depending of the machine architecture. because of that, we was unable to make diference between a long and a long long, which doesn't work with _Generic. So now 7171L is a TOK_CLONG, and we can handle _Generic properly * check that _Generic can make diference between long and long long * uncomment "type match twice" as it should now pass tests on any platforms * add inside_generic global the point of this variable is to use VT_LONG in comparaison only when we are evaluating a _Generic. problem is with my lastest patchs tcc can now make the diference between a 'long long' and a 'long', but in 64 bit stddef.h typedef uint64_t as typedef signed long long int int64_t and stdint.h as unsigned long int, so tcc break when stdint.h and stddef.h are include together. Another solution woud be to modifie include/stddef.h so it define uint64_t as unsigned long int when processor is 64 bit, but this could break some legacy code, so for now, VT_LONG are use only inside generc. * check that _Generic parse first argument correctly * check that _Generic evaluate correctly exresion like "f() / 2"
2017-07-10 23:44:53 +08:00
case TOK_CLONG:
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t = (LONG_SIZE == 8 ? VT_LLONG : VT_INT) | VT_LONG;
goto push_tokc;
mutiples fix for _Generic * check that _Generic don't match unsigned char * with char * this case is usefull as with -funsigned-char, 'char *' are unsigned * change VT_LONG so it's now a qualifier VT_LONG are never use for code generation, but only durring parsing state, in _Generic we need to be able to make diference between 'long' and 'long long' So VT_LONG is now use as a type qualifier, it's old behaviour is still here, but we can keep trace of what was a long and what wasn't * add TOK_CLONG and TOK_CULONG tcc was directly converting value like '7171L' into TOK_CLLONG or TOK_CINT depending of the machine architecture. because of that, we was unable to make diference between a long and a long long, which doesn't work with _Generic. So now 7171L is a TOK_CLONG, and we can handle _Generic properly * check that _Generic can make diference between long and long long * uncomment "type match twice" as it should now pass tests on any platforms * add inside_generic global the point of this variable is to use VT_LONG in comparaison only when we are evaluating a _Generic. problem is with my lastest patchs tcc can now make the diference between a 'long long' and a 'long', but in 64 bit stddef.h typedef uint64_t as typedef signed long long int int64_t and stdint.h as unsigned long int, so tcc break when stdint.h and stddef.h are include together. Another solution woud be to modifie include/stddef.h so it define uint64_t as unsigned long int when processor is 64 bit, but this could break some legacy code, so for now, VT_LONG are use only inside generc. * check that _Generic parse first argument correctly * check that _Generic evaluate correctly exresion like "f() / 2"
2017-07-10 23:44:53 +08:00
case TOK_CULONG:
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
t = (LONG_SIZE == 8 ? VT_LLONG : VT_INT) | VT_LONG | VT_UNSIGNED;
mutiples fix for _Generic * check that _Generic don't match unsigned char * with char * this case is usefull as with -funsigned-char, 'char *' are unsigned * change VT_LONG so it's now a qualifier VT_LONG are never use for code generation, but only durring parsing state, in _Generic we need to be able to make diference between 'long' and 'long long' So VT_LONG is now use as a type qualifier, it's old behaviour is still here, but we can keep trace of what was a long and what wasn't * add TOK_CLONG and TOK_CULONG tcc was directly converting value like '7171L' into TOK_CLLONG or TOK_CINT depending of the machine architecture. because of that, we was unable to make diference between a long and a long long, which doesn't work with _Generic. So now 7171L is a TOK_CLONG, and we can handle _Generic properly * check that _Generic can make diference between long and long long * uncomment "type match twice" as it should now pass tests on any platforms * add inside_generic global the point of this variable is to use VT_LONG in comparaison only when we are evaluating a _Generic. problem is with my lastest patchs tcc can now make the diference between a 'long long' and a 'long', but in 64 bit stddef.h typedef uint64_t as typedef signed long long int int64_t and stdint.h as unsigned long int, so tcc break when stdint.h and stddef.h are include together. Another solution woud be to modifie include/stddef.h so it define uint64_t as unsigned long int when processor is 64 bit, but this could break some legacy code, so for now, VT_LONG are use only inside generc. * check that _Generic parse first argument correctly * check that _Generic evaluate correctly exresion like "f() / 2"
2017-07-10 23:44:53 +08:00
goto push_tokc;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK___FUNCTION__:
if (!gnu_ext)
goto tok_identifier;
/* fall thru */
case TOK___FUNC__:
{
void *ptr;
int len;
/* special function name identifier */
len = strlen(funcname) + 1;
/* generate char[len] type */
type.t = VT_BYTE;
mk_pointer(&type);
type.t |= VT_ARRAY;
type.ref->c = len;
vpush_ref(&type, data_section, data_section->data_offset, len);
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
if (!NODATA_WANTED) {
ptr = section_ptr_add(data_section, len);
memcpy(ptr, funcname, len);
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
}
break;
case TOK_LSTR:
#ifdef TCC_TARGET_PE
t = VT_SHORT | VT_UNSIGNED;
#else
t = VT_INT;
#endif
goto str_init;
case TOK_STR:
/* string parsing */
t = VT_BYTE;
unsorted adjustments - configure * use aarch64 instead of arm64 - Makefile * rename the custom include file to "config-extra.mak" * Also avoid "rm -r /*" if $(tccdir) is empty - pp/Makefile * fix .expect generation with gcc - tcc.h * cleanup #defines for _MSC_VER - tccgen.c: * fix const-propagation for &,| * fix anonymous named struct (ms-extension) and enable -fms-extension by default - i386-gen.c * clear VT_DEFSIGN - x86_64-gen.c/win64: * fix passing structs in registers * fix alloca (need to keep "func_scratch" below each alloca area on stack) (This allows to compile a working gnu-make on win64) - tccpp.c * alternative approach to 37999a4fbf3487b363fd0c2f9b7ab622401b202a This is to avoid some slowdown with ## token pasting. * get_tok_str() : return <eof> for TOK_EOF * -funsigned-char: apply to "string" literals as well - tccpe/tools.c: -impdef: support both 32 and 64 bit dlls anyway
2017-07-09 18:07:40 +08:00
if (tcc_state->char_is_unsigned)
t = VT_BYTE | VT_UNSIGNED;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
str_init:
Revert "String literals are always const" This reverts commit d4fe9aba3fc6f4b9cc97b100e86ffe7af5c29619. I was confused by the fact that string literals aren't writable. Nevertheless the type isn't const. As extension in GCC it's const with -Wwrite-string, which is exactly what we had before. GCC also wonders in a comment if it's really a good idea to change expression types based on warning flags (IMHO it's not), but let's be compatible. So restore the state from before.
2017-07-04 22:37:49 +08:00
if (tcc_state->warn_write_strings)
t |= VT_CONSTANT;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type.t = t;
mk_pointer(&type);
type.t |= VT_ARRAY;
memset(&ad, 0, sizeof(AttributeDef));
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
case '(':
next();
/* cast ? */
if (parse_btype(&type, &ad)) {
type_decl(&type, &ad, &n, TYPE_ABSTRACT);
skip(')');
/* check ISOC99 compound literal */
if (tok == '{') {
/* data is allocated locally by default */
if (global_expr)
r = VT_CONST;
else
r = VT_LOCAL;
/* all except arrays are lvalues */
if (!(type.t & VT_ARRAY))
r |= lvalue_type(type.t);
memset(&ad, 0, sizeof(AttributeDef));
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
decl_initializer_alloc(&type, &ad, r, 1, 0, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
Correctly support all unary expression with sizeof Unary expression can start with a parenthesis. Thus, the current test to detect which sizeof form is being parsed is inaccurate. This patch makes tcc able to handle things like sizeof (x)[1] where x is declared as char x[5]; wich is a valid unary expression
2010-04-11 07:53:40 +08:00
if (sizeof_caller) {
vpush(&type);
return;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
unary();
gen_cast(&type);
}
} else if (tok == '{') {
Fix some code suppression fallout Some more subtle issues with code suppression: - outputting asms but not their operand setup is broken - but global asms must always be output - statement expressions are transparent to code suppression - vtop can't be transformed from VT_CMP/VT_JMP when nocode_wanted Also remove .exe files from tests2 if they don't fail.
2016-12-20 11:49:22 +08:00
int saved_nocode_wanted = nocode_wanted;
tccgen.c: Give error if statement expression found when const wanted. Some test cases: #define SE ({ switch (0) { } 0; }) // Should give error: int x = SE; void f(void) { static int x = SE; } void f(void) { enum e { a = SE }; } void f(void) { switch (0) { case SE: break; } } // Correct: int f(void) { return SE; } int f(void) { return sizeof(SE); }
2015-11-26 20:24:34 +08:00
if (const_wanted)
tcc_error("expected constant");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* save all registers */
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
save_regs(0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* statement expression : we do not accept break/continue
Fix some code suppression fallout Some more subtle issues with code suppression: - outputting asms but not their operand setup is broken - but global asms must always be output - statement expressions are transparent to code suppression - vtop can't be transformed from VT_CMP/VT_JMP when nocode_wanted Also remove .exe files from tests2 if they don't fail.
2016-12-20 11:49:22 +08:00
inside as GCC does. We do retain the nocode_wanted state,
as statement expressions can't ever be entered from the
outside, so any reactivation of code emission (from labels
or loop heads) can be disabled again after the end of it. */
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
block(NULL, NULL, NULL, NULL, 1);
Fix some code suppression fallout Some more subtle issues with code suppression: - outputting asms but not their operand setup is broken - but global asms must always be output - statement expressions are transparent to code suppression - vtop can't be transformed from VT_CMP/VT_JMP when nocode_wanted Also remove .exe files from tests2 if they don't fail.
2016-12-20 11:49:22 +08:00
nocode_wanted = saved_nocode_wanted;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(')');
} else {
gexpr();
skip(')');
}
break;
case '*':
next();
unary();
indir();
break;
case '&':
next();
unary();
/* functions names must be treated as function pointers,
except for unary '&' and sizeof. Since we consider that
functions are not lvalues, we only have to handle it
there and in function calls. */
/* arrays can also be used although they are not lvalues */
if ((vtop->type.t & VT_BTYPE) != VT_FUNC &&
Fix bogus check for VT_LLOCAL types VT_LLOCAL is a flag on .r, not on type.t. Fixing this requires minor surgery for compound literals which accidentally happened to be subsumed by the bogus test.
2017-02-19 11:25:46 +08:00
!(vtop->type.t & VT_ARRAY))
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
test_lvalue();
mk_pointer(&vtop->type);
gaddrof();
break;
case '!':
next();
unary();
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
gen_cast_s(VT_BOOL);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop->c.i = !vtop->c.i;
} else if ((vtop->r & VT_VALMASK) == VT_CMP)
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.i ^= 1;
tccgen.c: Try to make sizeof(!x) work. tests/tests2/27_sizeof.*: Add test.
2015-11-22 08:00:36 +08:00
else {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
save_regs(1);
Move logic for if (int value) to tccgen.c Move the logic to do a test of an integer value (ex if (0)) out of arch-specific code to tccgen.c to avoid code duplication. This also fixes test of long long value which was only testing the bottom half of such values on 32 bits architectures.
2013-12-31 23:51:20 +08:00
vseti(VT_JMP, gvtst(1, 0));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
break;
case '~':
next();
unary();
vpushi(-1);
gen_op('^');
break;
case '+':
next();
unary();
if ((vtop->type.t & VT_BTYPE) == VT_PTR)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("pointer not accepted for unary plus");
Fix floating point unary minus and plus negate(x) is subtract(-0,x), not subtract(+0,x), which makes a difference with signed zeros. Also +x was expressed as x+0, in order for the integer promotions to happen, but also mangles signed zeros, so just don't do that with floating types.
2014-01-12 11:44:27 +08:00
/* In order to force cast, we add zero, except for floating point
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
where we really need an noop (otherwise -0.0 will be transformed
into +0.0). */
if (!is_float(vtop->type.t)) {
vpushi(0);
gen_op('+');
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
case TOK_SIZEOF:
case TOK_ALIGNOF1:
case TOK_ALIGNOF2:
Recognize C11' _Alignof
2018-12-13 02:53:58 +08:00
case TOK_ALIGNOF3:
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
t = tok;
next();
Correctly support all unary expression with sizeof Unary expression can start with a parenthesis. Thus, the current test to detect which sizeof form is being parsed is inaccurate. This patch makes tcc able to handle things like sizeof (x)[1] where x is declared as char x[5]; wich is a valid unary expression
2010-04-11 07:53:40 +08:00
in_sizeof++;
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
expr_type(&type, unary); /* Perform a in_sizeof = 0; */
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
s = vtop[1].sym; /* hack: accessing previous vtop */
VLA fix [2/3]: removed VT_ARRAY from VT_VLA types A VLA is not really an array, it's a pointer-to-an-array. Making this explicit allows us to back out a few parts of the original VLA patch and paves the way for the next part of the fix, where a VLA will be stored on the runtime stack as a pointer-to-an-array, rather than on the compile- time stack as a Sym*.
2011-04-08 16:09:39 +08:00
size = type_size(&type, &align);
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
if (s && s->a.aligned)
align = 1 << (s->a.aligned - 1);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (t == TOK_SIZEOF) {
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
if (!(type.t & VT_VLA)) {
if (size < 0)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("sizeof applied to an incomplete type");
Make sizeof() be of type size_t This matters when sizeof is directly used in arithmetic, ala "uintptr_t t; t &= -sizeof(long)" (for alignment). When sizeof isn't size_t (as it's specified to be) this masking will truncate the high bits of the uintptr_t object (if uintptr_t is larger than uint).
2012-04-16 07:13:25 +08:00
vpushs(size);
VLA fix [2/3]: removed VT_ARRAY from VT_VLA types A VLA is not really an array, it's a pointer-to-an-array. Making this explicit allows us to back out a few parts of the original VLA patch and paves the way for the next part of the fix, where a VLA will be stored on the runtime stack as a pointer-to-an-array, rather than on the compile- time stack as a Sym*.
2011-04-08 16:09:39 +08:00
} else {
vla_runtime_type_size(&type, &align);
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
Make sizeof() be of type size_t This matters when sizeof is directly used in arithmetic, ala "uintptr_t t; t &= -sizeof(long)" (for alignment). When sizeof isn't size_t (as it's specified to be) this masking will truncate the high bits of the uintptr_t object (if uintptr_t is larger than uint).
2012-04-16 07:13:25 +08:00
vpushs(align);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
vtop->type.t |= VT_UNSIGNED;
break;
__builtin_expect no-op Taken from David Mertens tcc branch on github https://github.com/run4flat/tinycc.git
2016-04-16 17:41:53 +08:00
case TOK_builtin_expect:
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
/* __builtin_expect is a no-op for now */
parse_builtin_params(0, "ee");
vpop();
__builtin_expect no-op Taken from David Mertens tcc branch on github https://github.com/run4flat/tinycc.git
2016-04-16 17:41:53 +08:00
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_builtin_types_compatible_p:
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
parse_builtin_params(0, "tt");
vtop[-1].type.t &= ~(VT_CONSTANT | VT_VOLATILE);
vtop[0].type.t &= ~(VT_CONSTANT | VT_VOLATILE);
n = is_compatible_types(&vtop[-1].type, &vtop[0].type);
vtop -= 2;
vpushi(n);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
Implement __builtin_choose_expr Follows GCC implementation.
2016-07-13 21:11:40 +08:00
case TOK_builtin_choose_expr:
{
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
int64_t c;
Implement __builtin_choose_expr Follows GCC implementation.
2016-07-13 21:11:40 +08:00
next();
skip('(');
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
c = expr_const64();
Implement __builtin_choose_expr Follows GCC implementation.
2016-07-13 21:11:40 +08:00
skip(',');
if (!c) {
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted++;
Implement __builtin_choose_expr Follows GCC implementation.
2016-07-13 21:11:40 +08:00
}
expr_eq();
if (!c) {
vpop();
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted--;
Implement __builtin_choose_expr Follows GCC implementation.
2016-07-13 21:11:40 +08:00
}
skip(',');
if (c) {
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted++;
Implement __builtin_choose_expr Follows GCC implementation.
2016-07-13 21:11:40 +08:00
}
expr_eq();
if (c) {
vpop();
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted--;
Implement __builtin_choose_expr Follows GCC implementation.
2016-07-13 21:11:40 +08:00
}
skip(')');
}
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_builtin_constant_p:
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
parse_builtin_params(1, "e");
n = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
vtop--;
vpushi(n);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
case TOK_builtin_frame_address:
Add __builtin_return_address. Implementation is mostly shared with __builtin_frame_address. It seems to work on arm64, i386 and x86_64. It may need to be adapted for other targets.
2015-03-07 05:01:14 +08:00
case TOK_builtin_return_address:
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Add __builtin_return_address. Implementation is mostly shared with __builtin_frame_address. It seems to work on arm64, i386 and x86_64. It may need to be adapted for other targets.
2015-03-07 05:01:14 +08:00
int tok1 = tok;
Add support for __builtin_frame_address(level) Continuing d6072d37 (Add __builtin_frame_address(0)) implement __builtin_frame_address for levels greater than zero, in order for tinycc to be able to compile its own lib/bcheck.c after cffb7af9 (lib/bcheck: Prevent __bound_local_new / __bound_local_delete from being miscompiled). I'm new to the internals, and used the most simple way to do it. Generated code is not very good for levels >= 2, compare gcc tcc level=0 mov %ebp,%eax lea 0x0(%ebp),%eax level=1 mov 0x0(%ebp),%eax mov 0x0(%ebp),%eax level=2 mov 0x0(%ebp),%eax mov 0x0(%ebp),%eax mov (%eax),%eax mov %eax,-0x10(%ebp) mov -0x10(%ebp),%eax mov (%eax),%eax level=3 mov 0x0(%ebp),%eax mov 0x0(%ebp),%eax mov (%eax),%eax mov (%eax),%ecx mov (%eax),%eax mov (%ecx),%eax But this is still an improvement and for bcheck we need level=1 for which the code is good. For the tests I had to force gcc use -O0 to not inline the functions. And -fno-omit-frame-pointer just in case. If someone knows how to improve the generated code - help is appreciated. Thanks, Kirill Cc: Michael Matz <matz@suse.de> Cc: Shinichiro Hamaji <shinichiro.hamaji@gmail.com>
2012-11-15 07:31:49 +08:00
int level;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
skip('(');
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
if (tok != TOK_CINT) {
Add __builtin_return_address. Implementation is mostly shared with __builtin_frame_address. It seems to work on arm64, i386 and x86_64. It may need to be adapted for other targets.
2015-03-07 05:01:14 +08:00
tcc_error("%s only takes positive integers",
tok1 == TOK_builtin_return_address ?
"__builtin_return_address" :
"__builtin_frame_address");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
level = (uint32_t)tokc.i;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
skip(')');
type.t = VT_VOID;
mk_pointer(&type);
Add support for __builtin_frame_address(level) Continuing d6072d37 (Add __builtin_frame_address(0)) implement __builtin_frame_address for levels greater than zero, in order for tinycc to be able to compile its own lib/bcheck.c after cffb7af9 (lib/bcheck: Prevent __bound_local_new / __bound_local_delete from being miscompiled). I'm new to the internals, and used the most simple way to do it. Generated code is not very good for levels >= 2, compare gcc tcc level=0 mov %ebp,%eax lea 0x0(%ebp),%eax level=1 mov 0x0(%ebp),%eax mov 0x0(%ebp),%eax level=2 mov 0x0(%ebp),%eax mov 0x0(%ebp),%eax mov (%eax),%eax mov %eax,-0x10(%ebp) mov -0x10(%ebp),%eax mov (%eax),%eax level=3 mov 0x0(%ebp),%eax mov 0x0(%ebp),%eax mov (%eax),%eax mov (%eax),%ecx mov (%eax),%eax mov (%ecx),%eax But this is still an improvement and for bcheck we need level=1 for which the code is good. For the tests I had to force gcc use -O0 to not inline the functions. And -fno-omit-frame-pointer just in case. If someone knows how to improve the generated code - help is appreciated. Thanks, Kirill Cc: Michael Matz <matz@suse.de> Cc: Shinichiro Hamaji <shinichiro.hamaji@gmail.com>
2012-11-15 07:31:49 +08:00
vset(&type, VT_LOCAL, 0); /* local frame */
while (level--) {
mk_pointer(&vtop->type);
indir(); /* -> parent frame */
}
Add __builtin_return_address. Implementation is mostly shared with __builtin_frame_address. It seems to work on arm64, i386 and x86_64. It may need to be adapted for other targets.
2015-03-07 05:01:14 +08:00
if (tok1 == TOK_builtin_return_address) {
// assume return address is just above frame pointer on stack
vpushi(PTR_SIZE);
gen_op('+');
mk_pointer(&vtop->type);
indir();
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
break;
64-bit tests now pass (well, nearly). tcctest1-3 fail, but this appears to be due to bugs in GCC rather than TCC (from manual inspection of the output).
2013-04-24 09:19:15 +08:00
#ifdef TCC_TARGET_X86_64
#ifdef TCC_TARGET_PE
case TOK_builtin_va_start:
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
parse_builtin_params(0, "ee");
more minor fixes * tccgen: re-allow long double constants for x87 cross sizeof (long double) may be 12 or 16 depending on host platform (i386/x86_64 on unix/windows). Except that it's 8 if the host is on windows and not gcc was used to compile tcc. * win64: fix builtin_va_start after VT_REF removal See also a8b83ce43a95fa519dacfe7690a3a0098af7909c * tcctest.c: remove outdated limitation for ll-bitfield test It always worked, there is no reason why it should not work in future. * libtcc1.c: exclude long double conversion on ARM * Makefile: remove CFLAGS from link recipes * lib/Makefile: use target DEFINES as passed from main Makefile * lib/armflush.c lib/va_list.c: factor out from libtcc1.c * arm-gen.c: disable "depreciated" warnings for now
2017-05-07 18:41:29 +08:00
r = vtop->r & VT_VALMASK;
if (r == VT_LLOCAL)
r = VT_LOCAL;
if (r != VT_LOCAL)
tcc_error("__builtin_va_start expects a local variable");
vtop->r = r;
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
vtop->type = char_pointer_type;
vtop->c.i += 8;
vstore();
64-bit tests now pass (well, nearly). tcctest1-3 fail, but this appears to be due to bugs in GCC rather than TCC (from manual inspection of the output).
2013-04-24 09:19:15 +08:00
break;
#else
Support struct arguments with stdarg.h - add __builtin_va_arg_types to check how arguments were passed - move most code of stdarg into libtcc1.c - remove __builtin_malloc and __builtin_free - add a test case based on the bug report (http://www.mail-archive.com/tinycc-devel@nongnu.org/msg03036.html)
2010-12-28 18:32:40 +08:00
case TOK_builtin_va_arg_types:
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
parse_builtin_params(0, "t");
vpushi(classify_x86_64_va_arg(&vtop->type));
vswap();
vpop();
Support struct arguments with stdarg.h - add __builtin_va_arg_types to check how arguments were passed - move most code of stdarg into libtcc1.c - remove __builtin_malloc and __builtin_free - add a test case based on the bug report (http://www.mail-archive.com/tinycc-devel@nongnu.org/msg03036.html)
2010-12-28 18:32:40 +08:00
break;
64-bit tests now pass (well, nearly). tcctest1-3 fail, but this appears to be due to bugs in GCC rather than TCC (from manual inspection of the output).
2013-04-24 09:19:15 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#endif
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#ifdef TCC_TARGET_ARM64
case TOK___va_start: {
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
parse_builtin_params(0, "ee");
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
//xx check types
gen_va_start();
vpushi(0);
vtop->type.t = VT_VOID;
break;
}
case TOK___va_arg: {
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
parse_builtin_params(0, "et");
type = vtop->type;
vpop();
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
//xx check types
gen_va_arg(&type);
vtop->type = type;
break;
}
arm64: Implement __clear_cache. __clear_cache is defined in lib-arm64.c with a single call to __arm64_clear_cache, which is the real built-in function and is turned into inline assembler by gen_clear_cache in arm64-gen.c
2015-03-08 08:10:44 +08:00
case TOK___arm64_clear_cache: {
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
parse_builtin_params(0, "ee");
arm64: Implement __clear_cache. __clear_cache is defined in lib-arm64.c with a single call to __arm64_clear_cache, which is the real built-in function and is turned into inline assembler by gen_clear_cache in arm64-gen.c
2015-03-08 08:10:44 +08:00
gen_clear_cache();
vpushi(0);
vtop->type.t = VT_VOID;
break;
}
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#endif
Add some missing nocode_wanted guard int i = i++ causes a segfault because of missing guard. Looking recursively at all backend functions called from middle end several more guard appeared to be missing.
2015-03-10 23:23:00 +08:00
/* pre operations */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
case TOK_INC:
case TOK_DEC:
t = tok;
next();
unary();
inc(0, t);
break;
case '-':
next();
unary();
Fix negation of 0.0 and -0.0
2014-01-04 12:56:14 +08:00
t = vtop->type.t & VT_BTYPE;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (is_float(t)) {
Fix floating point unary minus and plus negate(x) is subtract(-0,x), not subtract(+0,x), which makes a difference with signed zeros. Also +x was expressed as x+0, in order for the integer promotions to happen, but also mangles signed zeros, so just don't do that with floating types.
2014-01-12 11:44:27 +08:00
/* In IEEE negate(x) isn't subtract(0,x), but rather
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
subtract(-0, x). */
vpush(&vtop->type);
if (t == VT_FLOAT)
tccgen: factor out gfunc_return Also: - on windows i386 and x86-64, structures of size <= 8 are NOT returned in registers if size is not one of 1,2,4,8. - cleanup: put all tv-push/pop/swap/rot into one place
2017-02-09 02:45:31 +08:00
vtop->c.f = -1.0 * 0.0;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
else if (t == VT_DOUBLE)
tccgen: factor out gfunc_return Also: - on windows i386 and x86-64, structures of size <= 8 are NOT returned in registers if size is not one of 1,2,4,8. - cleanup: put all tv-push/pop/swap/rot into one place
2017-02-09 02:45:31 +08:00
vtop->c.d = -1.0 * 0.0;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
else
tccgen: factor out gfunc_return Also: - on windows i386 and x86-64, structures of size <= 8 are NOT returned in registers if size is not one of 1,2,4,8. - cleanup: put all tv-push/pop/swap/rot into one place
2017-02-09 02:45:31 +08:00
vtop->c.ld = -1.0 * 0.0;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
} else
vpushi(0);
vswap();
gen_op('-');
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
case TOK_LAND:
if (!gnu_ext)
goto tok_identifier;
next();
/* allow to take the address of a label */
if (tok < TOK_UIDENT)
expect("label identifier");
s = label_find(tok);
if (!s) {
s = label_push(&global_label_stack, tok, LABEL_FORWARD);
} else {
if (s->r == LABEL_DECLARED)
s->r = LABEL_FORWARD;
}
if (!s->type.t) {
s->type.t = VT_VOID;
mk_pointer(&s->type);
s->type.t |= VT_STATIC;
}
tccgen: x86_64: fix garbage in the SValue upper bits This was going wrong (case TOK_LAND in unary: computed labels) - vset(&s->type, VT_CONST | VT_SYM, 0); - vtop->sym = s; This does the right thing and is shorter: + vpushsym(&s->type, s); Test case was: int main(int argc, char **argv) { int x; static void *label_return = &&lbl_return; printf("label_return = %p\n", label_return); goto *label_return; //<<<<< here segfault on linux X86_64 without the memset on vset printf("unreachable\n"); lbl_return: return 0; } Also:: - Rename "void* CValue.ptr" to more usable "addr_t ptr_offset" and start to use it in obvious cases. - use __attribute__ ((noreturn)) only with gnu compiler - Revert CValue memsets ("After several days searching ...") commit 4bc83ac3933efa565ae3326b55fcd711b63c073d Doesn't mean that the vsetX/vpush thingy isn't brittle and there still might be bugs as to differences in how the CValue union was set and is then interpreted later on. However the big memset hammer was just too slow (-3% overall).
2014-04-05 02:18:39 +08:00
vpushsym(&s->type, s);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
break;
Tidy arg parsing for builtins Saves some lines of code.
2017-02-27 09:22:28 +08:00
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
case TOK_GENERIC:
{
CType controlling_type;
int has_default = 0;
int has_match = 0;
int learn = 0;
TokenString *str = NULL;
Always allow ({ }) in the ctrl-expr of _Generic tcc would reject e.g., void f(){ struct {_Bool x:_Generic(({0;}),default:1);} my_x; } with `expected constant`. This patch makes it accept it. (The patch also makes tcc's _Generic a little more "generic" than that of gcc and clang in that that tcc now also accepts `struct {_Bool x:_Generic(({0;}),default:1);} my_x;` in file scope while gcc and clang don't, but I think there's no harm in that and gcc and clang might as well accept it in filescope too, given that they have no problem with e.g., `/*filescope:*/int x=1, y=2, z=_Generic(x+y, int:3);`)
2018-11-13 19:51:16 +08:00
int saved_const_wanted = const_wanted;
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
next();
skip('(');
Always allow ({ }) in the ctrl-expr of _Generic tcc would reject e.g., void f(){ struct {_Bool x:_Generic(({0;}),default:1);} my_x; } with `expected constant`. This patch makes it accept it. (The patch also makes tcc's _Generic a little more "generic" than that of gcc and clang in that that tcc now also accepts `struct {_Bool x:_Generic(({0;}),default:1);} my_x;` in file scope while gcc and clang don't, but I think there's no harm in that and gcc and clang might as well accept it in filescope too, given that they have no problem with e.g., `/*filescope:*/int x=1, y=2, z=_Generic(x+y, int:3);`)
2018-11-13 19:51:16 +08:00
const_wanted = 0;
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
expr_type(&controlling_type, expr_eq);
mutiples fix for _Generic * check that _Generic don't match unsigned char * with char * this case is usefull as with -funsigned-char, 'char *' are unsigned * change VT_LONG so it's now a qualifier VT_LONG are never use for code generation, but only durring parsing state, in _Generic we need to be able to make diference between 'long' and 'long long' So VT_LONG is now use as a type qualifier, it's old behaviour is still here, but we can keep trace of what was a long and what wasn't * add TOK_CLONG and TOK_CULONG tcc was directly converting value like '7171L' into TOK_CLLONG or TOK_CINT depending of the machine architecture. because of that, we was unable to make diference between a long and a long long, which doesn't work with _Generic. So now 7171L is a TOK_CLONG, and we can handle _Generic properly * check that _Generic can make diference between long and long long * uncomment "type match twice" as it should now pass tests on any platforms * add inside_generic global the point of this variable is to use VT_LONG in comparaison only when we are evaluating a _Generic. problem is with my lastest patchs tcc can now make the diference between a 'long long' and a 'long', but in 64 bit stddef.h typedef uint64_t as typedef signed long long int int64_t and stdint.h as unsigned long int, so tcc break when stdint.h and stddef.h are include together. Another solution woud be to modifie include/stddef.h so it define uint64_t as unsigned long int when processor is 64 bit, but this could break some legacy code, so for now, VT_LONG are use only inside generc. * check that _Generic parse first argument correctly * check that _Generic evaluate correctly exresion like "f() / 2"
2017-07-10 23:44:53 +08:00
controlling_type.t &= ~(VT_CONSTANT | VT_VOLATILE | VT_ARRAY);
patch type_to_str to handle complex function-ptr decls better Code like: #include <signal.h> int main() { _Generic(signal, int: 0); } should fail with error: type 'extern void (*(int, void (*)(int)))(int)' does not match any association not error: type 'extern void *(int)(int, void *(int))' does not match any association [matz: fix formatting, fix function-to-pointer decay for operands of _Generic, add testcase for this]
2018-03-16 07:26:16 +08:00
if ((controlling_type.t & VT_BTYPE) == VT_FUNC)
mk_pointer(&controlling_type);
Always allow ({ }) in the ctrl-expr of _Generic tcc would reject e.g., void f(){ struct {_Bool x:_Generic(({0;}),default:1);} my_x; } with `expected constant`. This patch makes it accept it. (The patch also makes tcc's _Generic a little more "generic" than that of gcc and clang in that that tcc now also accepts `struct {_Bool x:_Generic(({0;}),default:1);} my_x;` in file scope while gcc and clang don't, but I think there's no harm in that and gcc and clang might as well accept it in filescope too, given that they have no problem with e.g., `/*filescope:*/int x=1, y=2, z=_Generic(x+y, int:3);`)
2018-11-13 19:51:16 +08:00
const_wanted = saved_const_wanted;
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
for (;;) {
learn = 0;
skip(',');
if (tok == TOK_DEFAULT) {
if (has_default)
tcc_error("too many 'default'");
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
has_default = 1;
if (!has_match)
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
learn = 1;
next();
} else {
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
AttributeDef ad_tmp;
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
int itmp;
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
CType cur_type;
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
parse_btype(&cur_type, &ad_tmp);
type_decl(&cur_type, &ad_tmp, &itmp, TYPE_ABSTRACT);
if (compare_types(&controlling_type, &cur_type, 0)) {
if (has_match) {
mutiples fix for _Generic * check that _Generic don't match unsigned char * with char * this case is usefull as with -funsigned-char, 'char *' are unsigned * change VT_LONG so it's now a qualifier VT_LONG are never use for code generation, but only durring parsing state, in _Generic we need to be able to make diference between 'long' and 'long long' So VT_LONG is now use as a type qualifier, it's old behaviour is still here, but we can keep trace of what was a long and what wasn't * add TOK_CLONG and TOK_CULONG tcc was directly converting value like '7171L' into TOK_CLLONG or TOK_CINT depending of the machine architecture. because of that, we was unable to make diference between a long and a long long, which doesn't work with _Generic. So now 7171L is a TOK_CLONG, and we can handle _Generic properly * check that _Generic can make diference between long and long long * uncomment "type match twice" as it should now pass tests on any platforms * add inside_generic global the point of this variable is to use VT_LONG in comparaison only when we are evaluating a _Generic. problem is with my lastest patchs tcc can now make the diference between a 'long long' and a 'long', but in 64 bit stddef.h typedef uint64_t as typedef signed long long int int64_t and stdint.h as unsigned long int, so tcc break when stdint.h and stddef.h are include together. Another solution woud be to modifie include/stddef.h so it define uint64_t as unsigned long int when processor is 64 bit, but this could break some legacy code, so for now, VT_LONG are use only inside generc. * check that _Generic parse first argument correctly * check that _Generic evaluate correctly exresion like "f() / 2"
2017-07-10 23:44:53 +08:00
tcc_error("type match twice");
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
}
has_match = 1;
learn = 1;
}
}
skip(':');
if (learn) {
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
if (str)
tok_str_free(str);
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
skip_or_save_block(&str);
} else {
skip_or_save_block(NULL);
}
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
if (tok == ')')
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
break;
}
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
if (!str) {
char buf[60];
type_to_str(buf, sizeof buf, &controlling_type, NULL);
tcc_error("type '%s' does not match any association", buf);
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
}
begin_macro(str, 1);
next();
expr_eq();
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
if (tok != TOK_EOF)
expect(",");
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
end_macro();
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
next();
add C11's _Generic Simple implementation, I'm not even sure to respect C standart here, but it should work with most use case. This add an case in unary(), and generate TokString depending of _Generic controlling exression, use begin_macro to "push" the generated TokString, then call unary() again before exiting the switch so the just add token are reevaluate again.
2016-12-09 18:42:41 +08:00
break;
}
Add nan, snan and inf float constants
2010-05-06 08:19:00 +08:00
// special qnan , snan and infinity values
case TOK___NAN__:
Make type of __nan__ __inf__ and __snan__ be float so that those builtins can be used directly for the C99 NAN and INFINITY math.h macros.
2017-12-24 20:16:09 +08:00
n = 0x7fc00000;
special_math_val:
vpushi(n);
vtop->type.t = VT_FLOAT;
Add nan, snan and inf float constants
2010-05-06 08:19:00 +08:00
next();
break;
case TOK___SNAN__:
Make type of __nan__ __inf__ and __snan__ be float so that those builtins can be used directly for the C99 NAN and INFINITY math.h macros.
2017-12-24 20:16:09 +08:00
n = 0x7f800001;
goto special_math_val;
Add nan, snan and inf float constants
2010-05-06 08:19:00 +08:00
case TOK___INF__:
Make type of __nan__ __inf__ and __snan__ be float so that those builtins can be used directly for the C99 NAN and INFINITY math.h macros.
2017-12-24 20:16:09 +08:00
n = 0x7f800000;
goto special_math_val;
Add nan, snan and inf float constants
2010-05-06 08:19:00 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
default:
tok_identifier:
t = tok;
next();
if (t < TOK_UIDENT)
expect("identifier");
s = sym_find(t);
tccasm: use global(_symbol)_stack * removed asm_label stack * removed asm_free_labels() post-processing * using "impossible C type" for asm labels (VT_ASM) * tccgen.c:update_storage(): use it to refresh symbol attributes * tccelf.c:find_elf_sym(): ignore STB_LOCAL symbols * tccgen.c:unary(): asm symbols are supposed to be undeclared in C
2017-11-30 22:15:22 +08:00
if (!s || IS_ASM_SYM(s)) {
win32: warn people about using undeclared WINAPI functions *** UNCONDITIONALLY *** Esp. sihce tinycc winapi headers are not as complete as people might expect this can otherwise lead to obscure problems that are difficult to debug. (Originally 'warn_implicit_function_declaration' was set to 1 always for windows but someone must have deleted that line)
2014-04-06 16:59:40 +08:00
const char *name = get_tok_str(t, NULL);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok != '(')
win32: warn people about using undeclared WINAPI functions *** UNCONDITIONALLY *** Esp. sihce tinycc winapi headers are not as complete as people might expect this can otherwise lead to obscure problems that are difficult to debug. (Originally 'warn_implicit_function_declaration' was set to 1 always for windows but someone must have deleted that line)
2014-04-06 16:59:40 +08:00
tcc_error("'%s' undeclared", name);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* for simple function calls, we tolerate undeclared
external reference to int() function */
win32: warn people about using undeclared WINAPI functions *** UNCONDITIONALLY *** Esp. sihce tinycc winapi headers are not as complete as people might expect this can otherwise lead to obscure problems that are difficult to debug. (Originally 'warn_implicit_function_declaration' was set to 1 always for windows but someone must have deleted that line)
2014-04-06 16:59:40 +08:00
if (tcc_state->warn_implicit_function_declaration
#ifdef TCC_TARGET_PE
/* people must be warned about using undeclared WINAPI functions
(which usually start with uppercase letter) */
|| (name[0] >= 'A' && name[0] <= 'Z')
#endif
)
tcc_warning("implicit declaration of function '%s'", name);
Tidy some code the real difference is in decl0 where we can use external_sym just fine also for function definitions, we don't have to use external_global_sym. Setting VT_EXTERN in external_sym isn't necessary either (the type will have it set if necessary). The rest is tidying: removing unused arguments and moving some code around.
2019-04-18 09:36:39 +08:00
s = external_global_sym(t, &func_old_type);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
fixes & cleanups - tccgen.c/tcc.h: allow function declaration after use: int f() { return g(); } int g() { return 1; } may be a warning but not an error see also 76cb1144ef91924c53c57ea71e6f67ce73ce1cc6 - tccgen.c: redundant code related to inline functions removed (functions used anywhere have sym->c set automatically) - tccgen.c: make 32bit llop non-equal test portable (probably not on C67) - dynarray_add: change prototype to possibly avoid aliasing problems or at least warnings - lib/alloca*.S: ".section .note.GNU-stack,"",%progbits" removed (has no effect) - tccpe: set SizeOfCode field (for correct upx decompression) - libtcc.c: fixed alternative -run invocation tcc "-run -lxxx ..." file.c (meant to load the library after file). Also supported now: tcc files ... options ... -run @ arguments ...
2017-02-14 01:23:43 +08:00
r = s->r;
/* A symbol that has a register is a local register variable,
which starts out as VT_LOCAL value. */
if ((r & VT_VALMASK) < VT_CONST)
r = (r & ~VT_VALMASK) | VT_LOCAL;
VLA fix [3/3]: store VLA sizeofs in anonymous runtime stack vars
2011-04-10 13:52:25 +08:00
vset(&s->type, r, s->c);
Support local register variables Similar to GCC a local asm register variable enforces the use of a specified register in asm operands (and doesn't otherwise matter). Works only if the variable is directly mentioned as operand. For that we now generally store a backpointer from an SValue to a Sym when the SValue was the result of unary() parsing a symbol identifier.
2016-10-06 10:05:30 +08:00
/* Point to s as backpointer (even without r&VT_SYM).
Will be used by at least the x86 inline asm parser for
regvars. */
vtop->sym = s;
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
if (r & VT_SYM) {
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
vtop->c.i = 0;
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
} else if (r == VT_CONST && IS_ENUM_VAL(s->type.t)) {
vtop->c.i = s->enum_val;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
break;
}
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* post operations */
while (1) {
if (tok == TOK_INC || tok == TOK_DEC) {
inc(1, tok);
next();
a number as a field name a test program: ======== typedef struct X { int len; } X; int main(void) { X myX; myX.10 = 10; return 0; } ======== Error message before a patch: error: ';' expected (got "(null)") After a patch: error: field name expected
2015-09-25 06:44:23 +08:00
} else if (tok == '.' || tok == TOK_ARROW || tok == TOK_CDOUBLE) {
Fix more struct inits anonymous struct members were somewhat broken as the testcase demonstrates. The reason is the jumping through hoops to fiddle with the offsets I once introduced to avoid having to track a cumulative offset. That's now not necessary anymore and actively harmful, doing the obvious thing is now better.
2019-04-11 06:30:41 +08:00
int qualifiers, cumofs = 0;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
/* field */
if (tok == TOK_ARROW)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
indir();
pass constness from structs to members
2009-06-16 04:26:44 +08:00
qualifiers = vtop->type.t & (VT_CONSTANT | VT_VOLATILE);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
test_lvalue();
gaddrof();
/* expect pointer on structure */
if ((vtop->type.t & VT_BTYPE) != VT_STRUCT)
expect("struct or union");
a number as a field name a test program: ======== typedef struct X { int len; } X; int main(void) { X myX; myX.10 = 10; return 0; } ======== Error message before a patch: error: ';' expected (got "(null)") After a patch: error: field name expected
2015-09-25 06:44:23 +08:00
if (tok == TOK_CDOUBLE)
expect("field name");
next();
a number as a field name (part 2) don't crash a test program: ================ typedef struct X { int len; } X; #define init(s,len) s.len = len; int main(void) { X myX; init(myX,10); return 0; } ================ After a patch: error: field name expected
2015-09-25 07:31:34 +08:00
if (tok == TOK_CINT || tok == TOK_CUINT)
expect("field name");
Fix more struct inits anonymous struct members were somewhat broken as the testcase demonstrates. The reason is the jumping through hoops to fiddle with the offsets I once introduced to avoid having to track a cumulative offset. That's now not necessary anymore and actively harmful, doing the obvious thing is now better.
2019-04-11 06:30:41 +08:00
s = find_field(&vtop->type, tok, &cumofs);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (!s)
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
tcc_error("field not found: %s", get_tok_str(tok & ~SYM_FIELD, &tokc));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* add field offset to pointer */
vtop->type = char_pointer_type; /* change type to 'char *' */
Fix more struct inits anonymous struct members were somewhat broken as the testcase demonstrates. The reason is the jumping through hoops to fiddle with the offsets I once introduced to avoid having to track a cumulative offset. That's now not necessary anymore and actively harmful, doing the obvious thing is now better.
2019-04-11 06:30:41 +08:00
vpushi(cumofs + s->c);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_op('+');
/* change type to field type, and set to lvalue */
vtop->type = s->type;
pass constness from structs to members
2009-06-16 04:26:44 +08:00
vtop->type.t |= qualifiers;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* an array is never an lvalue */
if (!(vtop->type.t & VT_ARRAY)) {
vtop->r |= lvalue_type(vtop->type.t);
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#ifdef CONFIG_TCC_BCHECK
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* if bound checking, the referenced pointer must be checked */
bcheck: access fields of local structs w/o bcheck Revert previous commit, this is probably a better fix.
2016-11-10 21:05:47 +08:00
if (tcc_state->do_bounds_check && (vtop->r & VT_VALMASK) != VT_LOCAL)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop->r |= VT_MUSTBOUND;
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
next();
} else if (tok == '[') {
next();
gexpr();
gen_op('+');
indir();
skip(']');
} else if (tok == '(') {
SValue ret;
Sym *sa;
Fix stack overwrite on structure return The common code to move a returned structure packed into registers into memory on the caller side didn't take the register size into account when allocating local storage, so sometimes that lead to stack overwrites (e.g. in 73_arm64.c), on x86_64. This fixes it by generally making gfunc_sret also return the register size.
2015-03-09 07:19:59 +08:00
int nb_args, ret_nregs, ret_align, regsize, variadic;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* function call */
if ((vtop->type.t & VT_BTYPE) != VT_FUNC) {
/* pointer test (no array accepted) */
if ((vtop->type.t & (VT_BTYPE | VT_ARRAY)) == VT_PTR) {
vtop->type = *pointed_type(&vtop->type);
if ((vtop->type.t & VT_BTYPE) != VT_FUNC)
goto error_func;
} else {
error_func:
expect("function pointer");
}
} else {
vtop->r &= ~VT_LVAL; /* no lvalue */
}
/* get return type */
s = vtop->type.ref;
next();
sa = s->next; /* first parameter */
fixes & cleanups - tccgen.c/tcc.h: allow function declaration after use: int f() { return g(); } int g() { return 1; } may be a warning but not an error see also 76cb1144ef91924c53c57ea71e6f67ce73ce1cc6 - tccgen.c: redundant code related to inline functions removed (functions used anywhere have sym->c set automatically) - tccgen.c: make 32bit llop non-equal test portable (probably not on C67) - dynarray_add: change prototype to possibly avoid aliasing problems or at least warnings - lib/alloca*.S: ".section .note.GNU-stack,"",%progbits" removed (has no effect) - tccpe: set SizeOfCode field (for correct upx decompression) - libtcc.c: fixed alternative -run invocation tcc "-run -lxxx ..." file.c (meant to load the library after file). Also supported now: tcc files ... options ... -run @ arguments ...
2017-02-14 01:23:43 +08:00
nb_args = regsize = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
ret.r2 = VT_CONST;
/* compute first implicit argument if a structure is returned */
if ((s->type.t & VT_BTYPE) == VT_STRUCT) {
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
variadic = (s->f.func_type == FUNC_ELLIPSIS);
Revert "fix-mixed-struct (patch by Pip Cet)" This reverts commit 4e04f67c94c97b4f28a4d73759a0ad38fb3a10f7. Requested by grischka.
2015-07-30 04:57:41 +08:00
ret_nregs = gfunc_sret(&s->type, variadic, &ret.type,
&ret_align, &regsize);
Fix "Add support for struct > 4B returned via registers" - avoid assumption "ret_align == register_size" which is false for non-arm targets - rename symbol "sret" to more descriptive "ret_nregs" This fixes commit dcec8673f21da86ae3dcf1ca3e9498127715b795 Also: - remove multiple definitions in win32/include/math.h
2013-12-16 22:38:10 +08:00
if (!ret_nregs) {
Tests in abitest.c now work on Win32. I expect that Linux-x86 is probably fine. All other architectures except ARM are definitely broken since I haven't yet implemented gfunc_sret for these, although replicating the current behaviour should be straightforward.
2013-04-19 00:27:34 +08:00
/* get some space for the returned structure */
size = type_size(&s->type, &align);
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#ifdef TCC_TARGET_ARM64
/* On arm64, a small struct is return in registers.
It is much easier to write it to memory if we know
that we are allowed to write some extra bytes, so
round the allocated space up to a power of 2: */
if (size < 16)
while (size & (size - 1))
size = (size | (size - 1)) + 1;
#endif
Tests in abitest.c now work on Win32. I expect that Linux-x86 is probably fine. All other architectures except ARM are definitely broken since I haven't yet implemented gfunc_sret for these, although replicating the current behaviour should be straightforward.
2013-04-19 00:27:34 +08:00
loc = (loc - size) & -align;
ret.type = s->type;
ret.r = VT_LOCAL | VT_LVAL;
/* pass it as 'int' to avoid structure arg passing
problems */
vseti(VT_LOCAL, loc);
ret.c = vtop->c;
nb_args++;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
Fix "Add support for struct > 4B returned via registers" - avoid assumption "ret_align == register_size" which is false for non-arm targets - rename symbol "sret" to more descriptive "ret_nregs" This fixes commit dcec8673f21da86ae3dcf1ca3e9498127715b795 Also: - remove multiple definitions in win32/include/math.h
2013-12-16 22:38:10 +08:00
ret_nregs = 1;
Tests in abitest.c now work on Win32. I expect that Linux-x86 is probably fine. All other architectures except ARM are definitely broken since I haven't yet implemented gfunc_sret for these, although replicating the current behaviour should be straightforward.
2013-04-19 00:27:34 +08:00
ret.type = s->type;
}
Fix "Add support for struct > 4B returned via registers" - avoid assumption "ret_align == register_size" which is false for non-arm targets - rename symbol "sret" to more descriptive "ret_nregs" This fixes commit dcec8673f21da86ae3dcf1ca3e9498127715b795 Also: - remove multiple definitions in win32/include/math.h
2013-12-16 22:38:10 +08:00
if (ret_nregs) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* return in register */
if (is_float(ret.type.t)) {
ret.r = reg_fret(ret.type.t);
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
#ifdef TCC_TARGET_X86_64
if ((ret.type.t & VT_BTYPE) == VT_QFLOAT)
ret.r2 = REG_QRET;
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#ifndef TCC_TARGET_ARM64
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
#ifdef TCC_TARGET_X86_64
if ((ret.type.t & VT_BTYPE) == VT_QLONG)
#else
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if ((ret.type.t & VT_BTYPE) == VT_LLONG)
Most x86-64 tests now work; only on error in test1-3. I've had to introduce the XMM1 register to get the calling convention to work properly, unfortunately this has broken a fair bit of code which assumes that only XMM0 is used.
2013-04-19 22:33:16 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
ret.r2 = REG_LRET;
Add arm64 (AArch64) as a target architecture.
2015-02-14 02:58:31 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
ret.r = REG_IRET;
}
ret.c.i = 0;
}
if (tok != ')') {
for(;;) {
expr_eq();
gfunc_param_typed(s, sa);
nb_args++;
if (sa)
sa = sa->next;
if (tok == ')')
break;
skip(',');
}
}
if (sa)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("too few arguments to function");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(')');
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
gfunc_call(nb_args);
Fix "Add support for struct > 4B returned via registers" - avoid assumption "ret_align == register_size" which is false for non-arm targets - rename symbol "sret" to more descriptive "ret_nregs" This fixes commit dcec8673f21da86ae3dcf1ca3e9498127715b795 Also: - remove multiple definitions in win32/include/math.h
2013-12-16 22:38:10 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* return value */
Fix "Add support for struct > 4B returned via registers" - avoid assumption "ret_align == register_size" which is false for non-arm targets - rename symbol "sret" to more descriptive "ret_nregs" This fixes commit dcec8673f21da86ae3dcf1ca3e9498127715b795 Also: - remove multiple definitions in win32/include/math.h
2013-12-16 22:38:10 +08:00
for (r = ret.r + ret_nregs + !ret_nregs; r-- > ret.r;) {
Add support for struct > 4B returned via registers On ARM with hardfloat calling convention, structure containing 4 fields or less of the same float type are returned via float registers. This means that a structure can be returned in up to 4 double registers in a structure is composed of 4 doubles. This commit adds support for return of structures in several registers.
2013-11-22 09:27:15 +08:00
vsetc(&ret.type, r, &ret.c);
vtop->r2 = ret.r2; /* Loop only happens when r2 is VT_CONST */
}
Fix "Add support for struct > 4B returned via registers" - avoid assumption "ret_align == register_size" which is false for non-arm targets - rename symbol "sret" to more descriptive "ret_nregs" This fixes commit dcec8673f21da86ae3dcf1ca3e9498127715b795 Also: - remove multiple definitions in win32/include/math.h
2013-12-16 22:38:10 +08:00
Tests in abitest.c now work on Win32. I expect that Linux-x86 is probably fine. All other architectures except ARM are definitely broken since I haven't yet implemented gfunc_sret for these, although replicating the current behaviour should be straightforward.
2013-04-19 00:27:34 +08:00
/* handle packed struct return */
Fix "Add support for struct > 4B returned via registers" - avoid assumption "ret_align == register_size" which is false for non-arm targets - rename symbol "sret" to more descriptive "ret_nregs" This fixes commit dcec8673f21da86ae3dcf1ca3e9498127715b795 Also: - remove multiple definitions in win32/include/math.h
2013-12-16 22:38:10 +08:00
if (((s->type.t & VT_BTYPE) == VT_STRUCT) && ret_nregs) {
Add support for struct > 4B returned via registers On ARM with hardfloat calling convention, structure containing 4 fields or less of the same float type are returned via float registers. This means that a structure can be returned in up to 4 double registers in a structure is composed of 4 doubles. This commit adds support for return of structures in several registers.
2013-11-22 09:27:15 +08:00
int addr, offset;
Tests in abitest.c now work on Win32. I expect that Linux-x86 is probably fine. All other architectures except ARM are definitely broken since I haven't yet implemented gfunc_sret for these, although replicating the current behaviour should be straightforward.
2013-04-19 00:27:34 +08:00
size = type_size(&s->type, &align);
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
/* We're writing whole regs often, make sure there's enough
space. Assume register size is power of 2. */
if (regsize > align)
align = regsize;
Tests in abitest.c now work on Win32. I expect that Linux-x86 is probably fine. All other architectures except ARM are definitely broken since I haven't yet implemented gfunc_sret for these, although replicating the current behaviour should be straightforward.
2013-04-19 00:27:34 +08:00
loc = (loc - size) & -align;
avoid "decl after statement" please for compiling tcc with msc
2013-04-30 06:33:34 +08:00
addr = loc;
Fix "Add support for struct > 4B returned via registers" - avoid assumption "ret_align == register_size" which is false for non-arm targets - rename symbol "sret" to more descriptive "ret_nregs" This fixes commit dcec8673f21da86ae3dcf1ca3e9498127715b795 Also: - remove multiple definitions in win32/include/math.h
2013-12-16 22:38:10 +08:00
offset = 0;
for (;;) {
Add support for struct > 4B returned via registers On ARM with hardfloat calling convention, structure containing 4 fields or less of the same float type are returned via float registers. This means that a structure can be returned in up to 4 double registers in a structure is composed of 4 doubles. This commit adds support for return of structures in several registers.
2013-11-22 09:27:15 +08:00
vset(&ret.type, VT_LOCAL | VT_LVAL, addr + offset);
vswap();
vstore();
vtop--;
Fix "Add support for struct > 4B returned via registers" - avoid assumption "ret_align == register_size" which is false for non-arm targets - rename symbol "sret" to more descriptive "ret_nregs" This fixes commit dcec8673f21da86ae3dcf1ca3e9498127715b795 Also: - remove multiple definitions in win32/include/math.h
2013-12-16 22:38:10 +08:00
if (--ret_nregs == 0)
break;
Fix stack overwrite on structure return The common code to move a returned structure packed into registers into memory on the caller side didn't take the register size into account when allocating local storage, so sometimes that lead to stack overwrites (e.g. in 73_arm64.c), on x86_64. This fixes it by generally making gfunc_sret also return the register size.
2015-03-09 07:19:59 +08:00
offset += regsize;
Add support for struct > 4B returned via registers On ARM with hardfloat calling convention, structure containing 4 fields or less of the same float type are returned via float registers. This means that a structure can be returned in up to 4 double registers in a structure is composed of 4 doubles. This commit adds support for return of structures in several registers.
2013-11-22 09:27:15 +08:00
}
Tests in abitest.c now work on Win32. I expect that Linux-x86 is probably fine. All other architectures except ARM are definitely broken since I haven't yet implemented gfunc_sret for these, although replicating the current behaviour should be straightforward.
2013-04-19 00:27:34 +08:00
vset(&s->type, VT_LOCAL | VT_LVAL, addr);
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
break;
}
}
}
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void expr_prod(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int t;
Fix binding of assignment expressions.
2010-10-25 22:40:30 +08:00
unary();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
while (tok == '*' || tok == '/' || tok == '%') {
t = tok;
next();
Fix binding of assignment expressions.
2010-10-25 22:40:30 +08:00
unary();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gen_op(t);
}
}
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void expr_sum(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int t;
expr_prod();
while (tok == '+' || tok == '-') {
t = tok;
next();
expr_prod();
gen_op(t);
}
}
static void expr_shift(void)
{
int t;
expr_sum();
while (tok == TOK_SHL || tok == TOK_SAR) {
t = tok;
next();
expr_sum();
gen_op(t);
}
}
static void expr_cmp(void)
{
int t;
expr_shift();
while ((tok >= TOK_ULE && tok <= TOK_GT) ||
tok == TOK_ULT || tok == TOK_UGE) {
t = tok;
next();
expr_shift();
gen_op(t);
}
}
static void expr_cmpeq(void)
{
int t;
expr_cmp();
while (tok == TOK_EQ || tok == TOK_NE) {
t = tok;
next();
expr_cmp();
gen_op(t);
}
}
static void expr_and(void)
{
expr_cmpeq();
while (tok == '&') {
next();
expr_cmpeq();
gen_op('&');
}
}
static void expr_xor(void)
{
expr_and();
while (tok == '^') {
next();
expr_and();
gen_op('^');
}
}
static void expr_or(void)
{
expr_xor();
while (tok == '|') {
next();
expr_xor();
gen_op('|');
}
}
static void expr_land(void)
{
expr_or();
if (tok == TOK_LAND) {
opt: constprop also 'cond && 0' We didn't handle constants in logical expressions when they weren't the first operand. Some reordering in the loop structure is enough to handle them.
2016-09-27 03:21:42 +08:00
int t = 0;
for(;;) {
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
gen_cast_s(VT_BOOL);
opt: constprop also 'cond && 0' We didn't handle constants in logical expressions when they weren't the first operand. Some reordering in the loop structure is enough to handle them.
2016-09-27 03:21:42 +08:00
if (vtop->c.i) {
vpop();
} else {
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted++;
opt: constprop also 'cond && 0' We didn't handle constants in logical expressions when they weren't the first operand. Some reordering in the loop structure is enough to handle them.
2016-09-27 03:21:42 +08:00
while (tok == TOK_LAND) {
next();
expr_or();
vpop();
}
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted--;
opt: constprop also 'cond && 0' We didn't handle constants in logical expressions when they weren't the first operand. Some reordering in the loop structure is enough to handle them.
2016-09-27 03:21:42 +08:00
if (t)
gsym(t);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
gen_cast_s(VT_INT);
opt: constprop also 'cond && 0' We didn't handle constants in logical expressions when they weren't the first operand. Some reordering in the loop structure is enough to handle them.
2016-09-27 03:21:42 +08:00
break;
}
} else {
if (!t)
save_regs(1);
t = gvtst(1, t);
}
if (tok != TOK_LAND) {
if (t)
vseti(VT_JMPI, t);
else
vpushi(1);
break;
}
next();
expr_or();
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
static void expr_lor(void)
{
expr_land();
if (tok == TOK_LOR) {
opt: constprop also 'cond && 0' We didn't handle constants in logical expressions when they weren't the first operand. Some reordering in the loop structure is enough to handle them.
2016-09-27 03:21:42 +08:00
int t = 0;
for(;;) {
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
gen_cast_s(VT_BOOL);
opt: constprop also 'cond && 0' We didn't handle constants in logical expressions when they weren't the first operand. Some reordering in the loop structure is enough to handle them.
2016-09-27 03:21:42 +08:00
if (!vtop->c.i) {
vpop();
} else {
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted++;
opt: constprop also 'cond && 0' We didn't handle constants in logical expressions when they weren't the first operand. Some reordering in the loop structure is enough to handle them.
2016-09-27 03:21:42 +08:00
while (tok == TOK_LOR) {
next();
expr_land();
vpop();
}
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted--;
opt: constprop also 'cond && 0' We didn't handle constants in logical expressions when they weren't the first operand. Some reordering in the loop structure is enough to handle them.
2016-09-27 03:21:42 +08:00
if (t)
gsym(t);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
gen_cast_s(VT_INT);
opt: constprop also 'cond && 0' We didn't handle constants in logical expressions when they weren't the first operand. Some reordering in the loop structure is enough to handle them.
2016-09-27 03:21:42 +08:00
break;
}
} else {
if (!t)
save_regs(1);
t = gvtst(0, t);
}
if (tok != TOK_LOR) {
if (t)
vseti(VT_JMP, t);
else
vpushi(0);
break;
}
next();
expr_land();
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
Factor out const condition detection Creating condition_3way for this.
2016-09-04 11:23:57 +08:00
/* Assuming vtop is a value used in a conditional context
(i.e. compared with zero) return 0 if it's false, 1 if
true and -1 if it can't be statically determined. */
static int condition_3way(void)
{
int c = -1;
if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST &&
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
(!(vtop->r & VT_SYM) || !vtop->sym->a.weak)) {
Factor out const condition detection Creating condition_3way for this.
2016-09-04 11:23:57 +08:00
vdup();
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
gen_cast_s(VT_BOOL);
Factor out const condition detection Creating condition_3way for this.
2016-09-04 11:23:57 +08:00
c = vtop->c.i;
vpop();
}
return c;
}
Fix binding of assignment expressions.
2010-10-25 22:40:30 +08:00
static void expr_cond(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
int tt, u, r1, r2, rc, t1, t2, bt1, bt2, islv, c, g;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
SValue sv;
CType type, type1, type2;
Improve constant propagation with "&&" and "||".
2015-11-21 07:33:49 +08:00
expr_lor();
tccgen.c: Recognise constant expressions with conditional operator. tests/tests2/78_vla_label.c: Check that int a[1 ? 1 : 1] is not a VLA.
2015-11-20 08:24:46 +08:00
if (tok == '?') {
next();
Factor out const condition detection Creating condition_3way for this.
2016-09-04 11:23:57 +08:00
c = condition_3way();
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
g = (tok == ':' && gnu_ext);
if (c < 0) {
/* needed to avoid having different registers saved in
each branch */
if (is_float(vtop->type.t)) {
rc = RC_FLOAT;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#ifdef TCC_TARGET_X86_64
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
rc = RC_ST0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
#endif
} else
rc = RC_INT;
gv(rc);
i386-gen: fix USE_EBX Restore ebx from *ebp because alloca might change esp. Also disable USE_EBX for upcoming release. Actually the benefit is less than one would expect, it appears that tcc can't do much with more than 3 registers except with extensive use of long longs where the disassembly looks much prettier (and shorter also). Also: tccgen/expr_cond() : fix wrong gv/save_regs order
2016-12-19 07:27:08 +08:00
save_regs(1);
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
if (g)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gv_dup();
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
tt = gvtst(1, 0);
} else {
if (!g)
vpop();
tt = 0;
}
if (1) {
if (c == 0)
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted++;
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
if (!g)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gexpr();
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
Fix type completion for array types as well like qualifier merging the array sizes are merged as well for the operands of ?:, and they must not statically influence the types of decls. Also fix some style problems, spaces aren't stinky :)
2018-12-01 06:43:30 +08:00
if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
Make fn designators in ?: decay to ptrs This _Generic((__typeof(1?f:f)*){0}, void (**)(void): (void)0); should compile like it does in gcc and clang.
2018-11-29 19:43:01 +08:00
mk_pointer(&vtop->type);
Fix type completion for array types as well like qualifier merging the array sizes are merged as well for the operands of ?:, and they must not statically influence the types of decls. Also fix some style problems, spaces aren't stinky :)
2018-12-01 06:43:30 +08:00
type1 = vtop->type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
sv = *vtop; /* save value to handle it later */
vtop--; /* no vpop so that FP stack is not flushed */
skip(':');
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
u = 0;
if (c < 0)
u = gjmp(0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(tt);
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
if (c == 0)
nocode_wanted--;
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
if (c == 1)
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted++;
Fix binding of assignment expressions.
2010-10-25 22:40:30 +08:00
expr_cond();
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
if (c == 1)
nocode_wanted--;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
Fix type completion for array types as well like qualifier merging the array sizes are merged as well for the operands of ?:, and they must not statically influence the types of decls. Also fix some style problems, spaces aren't stinky :)
2018-12-01 06:43:30 +08:00
if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
Make fn designators in ?: decay to ptrs This _Generic((__typeof(1?f:f)*){0}, void (**)(void): (void)0); should compile like it does in gcc and clang.
2018-11-29 19:43:01 +08:00
mk_pointer(&vtop->type);
Fix type completion for array types as well like qualifier merging the array sizes are merged as well for the operands of ?:, and they must not statically influence the types of decls. Also fix some style problems, spaces aren't stinky :)
2018-12-01 06:43:30 +08:00
type2=vtop->type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
t1 = type1.t;
bt1 = t1 & VT_BTYPE;
t2 = type2.t;
bt2 = t2 & VT_BTYPE;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
type.ref = NULL;
Fix ptr type combining inside the ternary operator Make it match http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 (or http://port70.net/~nsz/c/c11/n1570.html#6.5.15p6).
2018-11-28 17:22:37 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* cast operands to correct type according to ISOC rules */
Fix incorrect one-sided void handling in ?: Also make the case when one side in ?: is a ptr and the other is neither a ptr nor a null-ptr constant fail cleanly instead of segfaulting.
2018-11-29 20:40:48 +08:00
if (bt1 == VT_VOID || bt2 == VT_VOID) {
type.t = VT_VOID; /* NOTE: as an extension, we accept void on only one side */
Fix type completion for array types as well like qualifier merging the array sizes are merged as well for the operands of ?:, and they must not statically influence the types of decls. Also fix some style problems, spaces aren't stinky :)
2018-12-01 06:43:30 +08:00
} else if (is_float(bt1) || is_float(bt2)) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
type.t = VT_LDOUBLE;
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
type.t = VT_DOUBLE;
} else {
type.t = VT_FLOAT;
}
} else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
/* cast to biggest op */
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
type.t = VT_LLONG | VT_LONG;
if (bt1 == VT_LLONG)
type.t &= t1;
if (bt2 == VT_LLONG)
type.t &= t2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* convert to unsigned if it does not fit in a long long */
bitfields: promote to signed int For integer promotion with for example arithmetics or expr_cond (x ? y : z), integral types need to be promoted to signed if they fit. According to latest standards, this also applies to bit-field types taking into account their specific width. In tcc, VT_BITFIELD set means width < original type width Field-widths between 33 and 63 are promoted to signed long long accordingly. struct { unsigned long long ullb:35; } s = { 1 }; #define X (s.ullb - 2) int main (void) { long long Y = X; printf("%d %016llx %016llx\n", X < 0, -X, -Y); return 0; } Results: GCC 4.7 : 0 0000000000000001 FFFFFFF800000001 MSVC : 1 0000000000000001 0000000000000001 TCC : 1 0000000000000001 0000000000000001 Also, gcc would promote long long bitfields of size < 32 to int as well. Example: struct { unsigned long long x:20; } t = { 123 }; /* with gcc: */ printf("%d %d\n", t.x, 456); /* with tcc: */ printf("%lld %d\n", t.x, 456);
2017-05-10 00:36:24 +08:00
if ((t1 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_LLONG | VT_UNSIGNED) ||
(t2 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_LLONG | VT_UNSIGNED))
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type.t |= VT_UNSIGNED;
} else if (bt1 == VT_PTR || bt2 == VT_PTR) {
Fix ptr type combining inside the ternary operator Make it match http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 (or http://port70.net/~nsz/c/c11/n1570.html#6.5.15p6).
2018-11-28 17:22:37 +08:00
/* http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 */
/* If one is a null ptr constant the result type
is the other. */
if (is_null_pointer (vtop)) type = type1;
else if (is_null_pointer (&sv)) type = type2;
Fix type completion for array types as well like qualifier merging the array sizes are merged as well for the operands of ?:, and they must not statically influence the types of decls. Also fix some style problems, spaces aren't stinky :)
2018-12-01 06:43:30 +08:00
else if (bt1 != bt2)
tcc_error("incompatible types in conditional expressions");
else {
CType *pt1 = pointed_type(&type1);
CType *pt2 = pointed_type(&type2);
int pbt1 = pt1->t & VT_BTYPE;
int pbt2 = pt2->t & VT_BTYPE;
int newquals, copied = 0;
/* pointers to void get preferred, otherwise the
pointed to types minus qualifs should be compatible */
type = (pbt1 == VT_VOID) ? type1 : type2;
if (pbt1 != VT_VOID && pbt2 != VT_VOID) {
if(!compare_types(pt1, pt2, 1/*unqualif*/))
Fix ptr type combining inside the ternary operator Make it match http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 (or http://port70.net/~nsz/c/c11/n1570.html#6.5.15p6).
2018-11-28 17:22:37 +08:00
tcc_warning("pointer type mismatch in conditional expression\n");
}
Fix type completion for array types as well like qualifier merging the array sizes are merged as well for the operands of ?:, and they must not statically influence the types of decls. Also fix some style problems, spaces aren't stinky :)
2018-12-01 06:43:30 +08:00
/* combine qualifs */
newquals = ((pt1->t | pt2->t) & (VT_CONSTANT | VT_VOLATILE));
if ((~pointed_type(&type)->t & (VT_CONSTANT | VT_VOLATILE))
& newquals)
{
/* copy the pointer target symbol */
type.ref = sym_push(SYM_FIELD, &type.ref->type,
0, type.ref->c);
copied = 1;
pointed_type(&type)->t |= newquals;
}
/* pointers to incomplete arrays get converted to
pointers to completed ones if possible */
if (pt1->t & VT_ARRAY
&& pt2->t & VT_ARRAY
&& pointed_type(&type)->ref->c < 0
&& (pt1->ref->c > 0 || pt2->ref->c > 0))
{
if (!copied)
type.ref = sym_push(SYM_FIELD, &type.ref->type,
0, type.ref->c);
pointed_type(&type)->ref =
sym_push(SYM_FIELD, &pointed_type(&type)->ref->type,
0, pointed_type(&type)->ref->c);
Fix ptr type combining inside the ternary operator Make it match http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 (or http://port70.net/~nsz/c/c11/n1570.html#6.5.15p6).
2018-11-28 17:22:37 +08:00
pointed_type(&type)->ref->c =
Fix type completion for array types as well like qualifier merging the array sizes are merged as well for the operands of ?:, and they must not statically influence the types of decls. Also fix some style problems, spaces aren't stinky :)
2018-12-01 06:43:30 +08:00
0 < pt1->ref->c ? pt1->ref->c : pt2->ref->c;
}
Fix ptr type combining inside the ternary operator Make it match http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 (or http://port70.net/~nsz/c/c11/n1570.html#6.5.15p6).
2018-11-28 17:22:37 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) {
/* XXX: test structure compatibility */
Fix conversion in a?0:ptr. (cond ? 0 : ptr)->member wasn't handled correctly. If one arm is a null pointer constant (which also can be a pointer) the result type is that of the other arm.
2012-04-15 05:50:21 +08:00
type = bt1 == VT_STRUCT ? type1 : type2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
/* integer operations */
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
type.t = VT_INT | (VT_LONG & (t1 | t2));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* convert to unsigned if it does not fit in an integer */
bitfields: promote to signed int For integer promotion with for example arithmetics or expr_cond (x ? y : z), integral types need to be promoted to signed if they fit. According to latest standards, this also applies to bit-field types taking into account their specific width. In tcc, VT_BITFIELD set means width < original type width Field-widths between 33 and 63 are promoted to signed long long accordingly. struct { unsigned long long ullb:35; } s = { 1 }; #define X (s.ullb - 2) int main (void) { long long Y = X; printf("%d %016llx %016llx\n", X < 0, -X, -Y); return 0; } Results: GCC 4.7 : 0 0000000000000001 FFFFFFF800000001 MSVC : 1 0000000000000001 0000000000000001 TCC : 1 0000000000000001 0000000000000001 Also, gcc would promote long long bitfields of size < 32 to int as well. Example: struct { unsigned long long x:20; } t = { 123 }; /* with gcc: */ printf("%d %d\n", t.x, 456); /* with tcc: */ printf("%lld %d\n", t.x, 456);
2017-05-10 00:36:24 +08:00
if ((t1 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_INT | VT_UNSIGNED) ||
(t2 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_INT | VT_UNSIGNED))
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type.t |= VT_UNSIGNED;
}
Keep lvalue category on structs when evaluating ternary operator
2016-03-13 10:32:18 +08:00
/* keep structs lvalue by transforming `(expr ? a : b)` to `*(expr ? &a : &b)` so
that `(expr ? a : b).mem` does not error with "lvalue expected" */
islv = (vtop->r & VT_LVAL) && (sv.r & VT_LVAL) && VT_STRUCT == (type.t & VT_BTYPE);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* now we convert second operand */
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
if (c != 1) {
gen_cast(&type);
if (islv) {
mk_pointer(&vtop->type);
gaddrof();
} else if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
gaddrof();
Keep lvalue category on structs when evaluating ternary operator
2016-03-13 10:32:18 +08:00
}
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
rc = RC_INT;
if (is_float(type.t)) {
rc = RC_FLOAT;
#ifdef TCC_TARGET_X86_64
if ((type.t & VT_BTYPE) == VT_LDOUBLE) {
rc = RC_ST0;
}
#endif
} else if ((type.t & VT_BTYPE) == VT_LLONG) {
/* for long longs, we use fixed registers to avoid having
to handle a complicated move */
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
rc = RC_IRET;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
tt = r2 = 0;
if (c < 0) {
r2 = gv(rc);
tt = gjmp(0);
}
gsym(u);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* this is horrible, but we must also convert first
operand */
tests: add memory leak test Also ... tcctest.c: - exclude stuff that gcc doesn't compile on windows. libtcc.c/tccpp.c: - use unsigned for memory sizes to avoid printf format warnings - use "file:line: message" to make IDE error parsers happy. tccgen.c: fix typo
2016-12-19 05:05:42 +08:00
if (c != 0) {
*vtop = sv;
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
gen_cast(&type);
if (islv) {
mk_pointer(&vtop->type);
gaddrof();
} else if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
gaddrof();
}
Fix (Cexpr?struct1:struct2).member Tcc used to fail this with `lvalue expected` if the expression was a compile-time constant.
2018-11-29 04:12:38 +08:00
if (c < 0 || islv) {
tccgen: fix expr_cond for alt. nocode_wanted making shure that both the active and the passive branches do exacly the same thing.
2016-12-19 01:55:55 +08:00
r1 = gv(rc);
move_reg(r2, r1, type.t);
vtop->r = r2;
tests: add memory leak test Also ... tcctest.c: - exclude stuff that gcc doesn't compile on windows. libtcc.c/tccpp.c: - use unsigned for memory sizes to avoid printf format warnings - use "file:line: message" to make IDE error parsers happy. tccgen.c: fix typo
2016-12-19 05:05:42 +08:00
gsym(tt);
if (islv)
indir();
Keep lvalue category on structs when evaluating ternary operator
2016-03-13 10:32:18 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
}
Fix binding of assignment expressions.
2010-10-25 22:40:30 +08:00
static void expr_eq(void)
{
int t;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
Fix binding of assignment expressions.
2010-10-25 22:40:30 +08:00
expr_cond();
if (tok == '=' ||
(tok >= TOK_A_MOD && tok <= TOK_A_DIV) ||
tok == TOK_A_XOR || tok == TOK_A_OR ||
tok == TOK_A_SHL || tok == TOK_A_SAR) {
test_lvalue();
t = tok;
next();
if (t == '=') {
expr_eq();
} else {
vdup();
expr_eq();
gen_op(t & 0x7f);
}
vstore();
}
}
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
ST_FUNC void gexpr(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
while (1) {
expr_eq();
if (tok != ',')
break;
vpop();
next();
}
}
/* parse a constant expression and return value in vtop. */
static void expr_const1(void)
{
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
const_wanted++;
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
nocode_wanted++;
Fix binding of assignment expressions.
2010-10-25 22:40:30 +08:00
expr_cond();
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
nocode_wanted--;
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
const_wanted--;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
/* parse an integer constant and return its value. */
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
static inline int64_t expr_const64(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
int64_t c;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
expr_const1();
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
expect("constant expression");
c = vtop->c.i;
vpop();
return c;
}
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
/* parse an integer constant and return its value.
Complain if it doesn't fit 32bit (signed or unsigned). */
ST_FUNC int expr_const(void)
{
int c;
int64_t wc = expr_const64();
c = wc;
if (c != wc && (unsigned)c != wc)
tcc_error("constant exceeds 32 bit");
return c;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* return the label token if current token is a label, otherwise
return zero */
static int is_label(void)
{
int last_tok;
/* fast test first */
if (tok < TOK_UIDENT)
return 0;
/* no need to save tokc because tok is an identifier */
last_tok = tok;
next();
if (tok == ':') {
return last_tok;
} else {
unget_tok(last_tok);
return 0;
}
}
tccgen: factor out gfunc_return Also: - on windows i386 and x86-64, structures of size <= 8 are NOT returned in registers if size is not one of 1,2,4,8. - cleanup: put all tv-push/pop/swap/rot into one place
2017-02-09 02:45:31 +08:00
#ifndef TCC_TARGET_ARM64
static void gfunc_return(CType *func_type)
{
if ((func_type->t & VT_BTYPE) == VT_STRUCT) {
CType type, ret_type;
int ret_align, ret_nregs, regsize;
ret_nregs = gfunc_sret(func_type, func_var, &ret_type,
&ret_align, &regsize);
if (0 == ret_nregs) {
/* if returning structure, must copy it to implicit
first pointer arg location */
type = *func_type;
mk_pointer(&type);
vset(&type, VT_LOCAL | VT_LVAL, func_vc);
indir();
vswap();
/* copy structure value to pointer */
vstore();
} else {
/* returning structure packed into registers */
int r, size, addr, align;
size = type_size(func_type,&align);
if ((vtop->r != (VT_LOCAL | VT_LVAL) ||
(vtop->c.i & (ret_align-1)))
&& (align & (ret_align-1))) {
loc = (loc - size) & -ret_align;
addr = loc;
type = *func_type;
vset(&type, VT_LOCAL | VT_LVAL, addr);
vswap();
vstore();
vpop();
vset(&ret_type, VT_LOCAL | VT_LVAL, addr);
}
vtop->type = ret_type;
if (is_float(ret_type.t))
r = rc_fret(ret_type.t);
else
r = RC_IRET;
if (ret_nregs == 1)
gv(r);
else {
for (;;) {
vdup();
gv(r);
vpop();
if (--ret_nregs == 0)
break;
/* We assume that when a structure is returned in multiple
registers, their classes are consecutive values of the
suite s(n) = 2^n */
r <<= 1;
vtop->c.i += regsize;
}
}
}
} else if (is_float(func_type->t)) {
gv(rc_fret(func_type->t));
} else {
gv(RC_IRET);
}
vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
}
#endif
switch: fix label sorting
2016-10-03 15:40:37 +08:00
static int case_cmp(const void *pa, const void *pb)
{
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
int64_t a = (*(struct case_t**) pa)->v1;
int64_t b = (*(struct case_t**) pb)->v1;
switch: fix label sorting
2016-10-03 15:40:37 +08:00
return a < b ? -1 : a > b;
}
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
static void gcase(struct case_t **base, int len, int *bsym)
switch: binary search
2016-10-03 18:14:34 +08:00
{
struct case_t *p;
int e;
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
int ll = (vtop->type.t & VT_BTYPE) == VT_LLONG;
gv(RC_INT);
gcase() clean up remove tail recursion, simplify
2016-10-11 16:29:56 +08:00
while (len > 4) {
/* binary search */
switch: binary search
2016-10-03 18:14:34 +08:00
p = base[len/2];
Fix handling of case_reg in switch statement. The back end functions gen_op(comparison) and gtst() might allocate registers so case_reg should be left on the value stack while they are called and set again afterwards. This bug fix was first applied as ff3f9aa (20 Feb 2015), but the fix was reverted by fc0fc6a (21 Sep 2016, "switch: collect case ranges first, then generate code"). Here the fix is updated for the new code.
2016-10-11 03:15:20 +08:00
vdup();
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
if (ll)
vpushll(p->v2);
else
vpushi(p->v2);
switch: binary search
2016-10-03 18:14:34 +08:00
gen_op(TOK_LE);
e = gtst(1, 0);
Fix handling of case_reg in switch statement. The back end functions gen_op(comparison) and gtst() might allocate registers so case_reg should be left on the value stack while they are called and set again afterwards. This bug fix was first applied as ff3f9aa (20 Feb 2015), but the fix was reverted by fc0fc6a (21 Sep 2016, "switch: collect case ranges first, then generate code"). Here the fix is updated for the new code.
2016-10-11 03:15:20 +08:00
vdup();
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
if (ll)
vpushll(p->v1);
else
vpushi(p->v1);
switch: binary search
2016-10-03 18:14:34 +08:00
gen_op(TOK_GE);
gcase() clean up remove tail recursion, simplify
2016-10-11 16:29:56 +08:00
gtst_addr(0, p->sym); /* v1 <= x <= v2 */
/* x < v1 */
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
gcase(base, len/2, bsym);
switch: binary search
2016-10-03 18:14:34 +08:00
if (cur_switch->def_sym)
gjmp_addr(cur_switch->def_sym);
else
*bsym = gjmp(*bsym);
gcase() clean up remove tail recursion, simplify
2016-10-11 16:29:56 +08:00
/* x > v2 */
switch: binary search
2016-10-03 18:14:34 +08:00
gsym(e);
e = len/2 + 1;
gcase() clean up remove tail recursion, simplify
2016-10-11 16:29:56 +08:00
base += e; len -= e;
}
/* linear scan */
while (len--) {
p = *base++;
vdup();
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
if (ll)
vpushll(p->v2);
else
vpushi(p->v2);
gcase() clean up remove tail recursion, simplify
2016-10-11 16:29:56 +08:00
if (p->v1 == p->v2) {
gen_op(TOK_EQ);
gtst_addr(0, p->sym);
} else {
gen_op(TOK_LE);
e = gtst(1, 0);
vdup();
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
if (ll)
vpushll(p->v1);
else
vpushi(p->v1);
gcase() clean up remove tail recursion, simplify
2016-10-11 16:29:56 +08:00
gen_op(TOK_GE);
gtst_addr(0, p->sym);
gsym(e);
}
switch: binary search
2016-10-03 18:14:34 +08:00
}
}
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
static void block(int *bsym, Sym *bcl, int *csym, Sym *ccl, int is_expr)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
opt: Start optimizing dead code a bit If a condition is always zero/non-zero we can omit the then or else code. This is complicated a bit by having to deal with labels that might make such code reachable without us yet knowing during parsing.
2016-09-20 00:38:12 +08:00
int a, b, c, d, cond;
tccgen: scope levels for local symbols ... for fast redeclaration checks Also, check function parameters too: void foo(int a) { int a; ... } Also, try to fix struct/union/enum's on different scopes: { struct xxx { int x; }; { struct xxx { int y; }; ... }} and some (probably not all) combination with incomplete declarations "struct xxx;" Replaces 2bfedb18675228c3837c23fa523231f55e102c12 and 07d896c8e5d1b46bf4aebd403c78e5f7ffebe02a Fixes cf95ac399cbce1ea8a519f91dd36a5cfd4ea7943
2016-05-05 16:39:09 +08:00
Sym *s;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* generate line number info */
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
if (tcc_state->do_debug)
tcc_debug_line(tcc_state);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (is_expr) {
/* default return value is (void) */
vpushi(0);
vtop->type.t = VT_VOID;
}
if (tok == TOK_IF) {
/* if test */
opt: Start optimizing dead code a bit If a condition is always zero/non-zero we can omit the then or else code. This is complicated a bit by having to deal with labels that might make such code reachable without us yet knowing during parsing.
2016-09-20 00:38:12 +08:00
int saved_nocode_wanted = nocode_wanted;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
skip('(');
gexpr();
skip(')');
opt: Start optimizing dead code a bit If a condition is always zero/non-zero we can omit the then or else code. This is complicated a bit by having to deal with labels that might make such code reachable without us yet knowing during parsing.
2016-09-20 00:38:12 +08:00
cond = condition_3way();
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
if (cond == 1)
a = 0, vpop();
else
a = gvtst(1, 0);
if (cond == 0)
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted |= 0x20000000;
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
block(bsym, bcl, csym, ccl, 0);
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
if (cond != 1)
nocode_wanted = saved_nocode_wanted;
tidy code
2019-01-31 08:04:55 +08:00
if (tok == TOK_ELSE) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
d = gjmp(0);
gsym(a);
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
if (cond == 1)
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted |= 0x20000000;
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
block(bsym, bcl, csym, ccl, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(d); /* patch else jmp */
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
if (cond != 0)
nocode_wanted = saved_nocode_wanted;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else
gsym(a);
} else if (tok == TOK_WHILE) {
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
int saved_nocode_wanted;
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted &= ~0x20000000;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
d = ind;
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
vla_sp_restore();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip('(');
gexpr();
skip(')');
Move logic for if (int value) to tccgen.c Move the logic to do a test of an integer value (ex if (0)) out of arch-specific code to tccgen.c to avoid code duplication. This also fixes test of long long value which was only testing the bottom half of such values on 32 bits architectures.
2013-12-31 23:51:20 +08:00
a = gvtst(1, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
b = 0;
remove incr/decr_local_scope functions
2019-01-30 04:32:38 +08:00
++local_scope;
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
saved_nocode_wanted = nocode_wanted;
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
block(&a, current_cleanups, &b, current_cleanups, 0);
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
nocode_wanted = saved_nocode_wanted;
remove incr/decr_local_scope functions
2019-01-30 04:32:38 +08:00
--local_scope;
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
gjmp_addr(d);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(a);
gsym_addr(b, d);
} else if (tok == '{') {
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
Sym *llabel, *lcleanup;
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
int block_vla_sp_loc = vla_sp_loc, saved_vlas_in_scope = vlas_in_scope;
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
int lncleanups = ncleanups;
avoid "decl after statement" please for compiling tcc with msc
2013-04-30 06:33:34 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
/* record local declaration stack position */
s = local_stack;
llabel = local_label_stack;
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
lcleanup = current_cleanups;
remove incr/decr_local_scope functions
2019-01-30 04:32:38 +08:00
++local_scope;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* handle local labels declarations */
Support multiple __label__ declarations Support multiple __label__ declarations at the beginning of a block as long as they're contiguous. gcc and clang accept: { __label__ a,b; __label__ c; /*...*/ } . Tcc would fail it. This patch makes it accept it. The patch: - if (tok == TOK_LABEL) { + while (tok == TOK_LABEL) {
2019-01-10 01:20:15 +08:00
while (tok == TOK_LABEL) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
for(;;) {
if (tok < TOK_UIDENT)
expect("label identifier");
label_push(&local_label_stack, tok, LABEL_DECLARED);
next();
if (tok == ',') {
next();
} else {
skip(';');
break;
}
}
}
while (tok != '}') {
Remove label_or_decl The only use of this function can be rewritten in terms of is_label (if one other use of that one are a bit amended).
2017-04-16 02:05:39 +08:00
if ((a = is_label()))
unget_tok(a);
else
decl(VT_LOCAL);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok != '}') {
if (is_expr)
vpop();
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
block(bsym, bcl, csym, ccl, is_expr);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
if (current_cleanups != lcleanup) {
int jmp = 0;
Sym *g, **pg;
for (pg = &pending_gotos; (g = *pg) && g->c > lncleanups;)
if (g->prev_tok->r & LABEL_FORWARD) {
Sym *pcl = g->next;
if (!jmp)
jmp = gjmp(0);
gsym(pcl->jnext);
try_call_scope_cleanup(lcleanup);
pcl->jnext = gjmp(0);
if (!lncleanups)
goto remove_pending;
g->c = lncleanups;
pg = &g->prev;
} else {
remove_pending:
*pg = g->prev;
sym_free(g);
}
gsym(jmp);
if (!nocode_wanted) {
try_call_scope_cleanup(lcleanup);
}
}
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
current_cleanups = lcleanup;
ncleanups = lncleanups;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* pop locally defined labels */
Fix statement exprs returning a local label Like returned local variables also labels local to a statement expression can be returned, and so their symbols must not be immediately freed (though they need to be removed from the symbol table).
2017-07-11 04:25:11 +08:00
label_pop(&local_label_stack, llabel, is_expr);
move a comment to its correct location
2011-04-08 15:46:32 +08:00
/* pop locally defined symbols */
remove incr/decr_local_scope functions
2019-01-30 04:32:38 +08:00
--local_scope;
Fix access-after-free with statement expressions The return value of statement expressions might refer to local symbols, so those can't be popped. The old error message always was just a band-aid, and since disabling it for pointer types it wasn't effective anyway. It also never considered that also the vtop->sym member might have referred to such symbols (see the testcase with the local static, that used to segfault). For fixing this (can be seen better with valgrind and SYM_DEBUG) simply leave local symbols of stmt exprs on the stack.
2016-08-15 11:09:31 +08:00
/* In the is_expr case (a statement expression is finished here),
vtop might refer to symbols on the local_stack. Either via the
type or via vtop->sym. We can't pop those nor any that in turn
might be referred to. To make it easier we don't roll back
any symbols in that case; some upper level call to block() will
do that. We do have to remove such symbols from the lookup
tables, though. sym_pop will do that. */
sym_pop(&local_stack, s, is_expr);
Improved variable length array support. VLA storage is now freed when it goes out of scope. This makes it possible to use a VLA inside a loop without consuming an unlimited amount of memory. Combining VLAs with alloca() should work as in GCC - when a VLA is freed, memory allocated by alloca() after the VLA was created is also freed. There are some exceptions to this rule when using goto: if a VLA is in scope at the goto, jumping to a label will reset the stack pointer to where it was immediately after the last VLA was created prior to the label, or to what it was before the first VLA was created if the label is outside the scope of any VLA. This means that in some cases combining alloca() and VLAs will free alloca() memory where GCC would not.
2013-04-28 03:39:34 +08:00
/* Pop VLA frames and restore stack pointer if required */
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
if (vlas_in_scope > saved_vlas_in_scope) {
vla_sp_loc = saved_vlas_in_scope ? block_vla_sp_loc : vla_sp_root_loc;
vla_sp_restore();
Improved variable length array support. VLA storage is now freed when it goes out of scope. This makes it possible to use a VLA inside a loop without consuming an unlimited amount of memory. Combining VLAs with alloca() should work as in GCC - when a VLA is freed, memory allocated by alloca() after the VLA was created is also freed. There are some exceptions to this rule when using goto: if a VLA is in scope at the goto, jumping to a label will reset the stack pointer to where it was immediately after the last VLA was created prior to the label, or to what it was before the first VLA was created if the label is outside the scope of any VLA. This means that in some cases combining alloca() and VLAs will free alloca() memory where GCC would not.
2013-04-28 03:39:34 +08:00
}
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
vlas_in_scope = saved_vlas_in_scope;
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
} else if (tok == TOK_RETURN) {
next();
if (tok != ';') {
gexpr();
gen_assign_cast(&func_vt);
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
try_call_scope_cleanup(NULL);
various stuff win32/Makefile ("for cygwin") removed - On cygwin, the normal ./configure && make can be used with either cygwin's "GCC for Win32 Toolchain" ./configure --cross-prefix=i686-w64-mingw32- or with an existing tcc: ./configure --cc=<old-tccdir>/tcc.exe tcctest.c: - exclude test_high_clobbers() on _WIN64 (does not work) tests2/95_bitfield.c: - use 'signed char' for ARM (where default 'char' is unsigned) tests: - remove -I "expr" diff option to allow tests with busybox-diff. libtcc.c, tcc.c: - removed -iwithprefix option. It is supposed to be combined with -iprefix which we don't have either. tccgen.c: - fix assignments and return of 'void', as in void f() { void *p, *q; *p = *q: return *p; } This appears to be allowed but should do nothing. tcc.h, libtcc.c, tccpp.c: - Revert "Introduce VIP sysinclude paths which are always searched first" This reverts commit 1d5e386b0a78393ac6b670c209a185849ec798a1. The patch was giving tcc's system includes priority over -I which is not how it should be. tccelf.c: - add DT_TEXTREL tag only if text relocations are actually used (which is likely not the case on x86_64) - prepare_dynamic_rel(): avoid relocation of unresolved (weak) symbols tccrun.c: - for HAVE_SELINUX, use two mappings to the same (real) file. (it was so once except the RX mapping wasn't used at all). tccpe.c: - fix relocation constant used for x86_64 (by Andrei E. Warentin) - #ifndef _WIN32 do "chmod 755 ..." to get runnable exes on cygwin. tccasm.c: - keep forward asm labels static, otherwise they will endup in dynsym eventually. configure, Makefile: - mingw32: respect ./configure options --bindir --docdir --libdir - allow overriding tcc when building libtcc1.a and libtcc.def with make XTCC=<tcc program to use> - use $(wildcard ...) for install to allow installing just a cross compiler for example make cross-arm make install - use name <target>-libtcc1.a build-tcc.bat: - add options: -clean, -b bindir
2017-10-12 00:13:43 +08:00
if ((func_vt.t & VT_BTYPE) == VT_VOID)
vtop--;
else
gfunc_return(&func_vt);
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
} else {
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
try_call_scope_cleanup(NULL);
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(';');
tccgen: return: avoid jmp to retsym if possible When 'return' is the last statement of the top-level block (very common and often recommended case) jump is not needed.
2016-08-11 19:59:08 +08:00
/* jump unless last stmt in top-level block */
if (tok != '}' || local_scope != 1)
rsym = gjmp(rsym);
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted |= 0x20000000;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (tok == TOK_BREAK) {
/* compute jump */
if (!bsym)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("cannot break");
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
try_call_scope_cleanup(bcl);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
*bsym = gjmp(*bsym);
next();
skip(';');
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted |= 0x20000000;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (tok == TOK_CONTINUE) {
/* compute jump */
if (!csym)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("cannot continue");
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
try_call_scope_cleanup(ccl);
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
vla_sp_restore_root();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
*csym = gjmp(*csym);
next();
skip(';');
suppress code after continue as well fix an oversight in code suppression
2019-01-31 07:37:49 +08:00
nocode_wanted |= 0x20000000;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (tok == TOK_FOR) {
Revert "implemented C99 for loop with variable declaration" This reverts commit 433ecdfc9d1402ecf03e710de481e2063ad6de90. The patch breaks e.g. with for ((i = 10); --i;); In particular to check for a type decl. this is not sufficient: if (tok < TOK_UIDENT) { A future approach to c99 loop variables might instead use: if (parse_btype(...)) { plus refactor function decl() accordingly.
2010-08-21 19:39:12 +08:00
int e;
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
int saved_nocode_wanted;
fix cleanup with for loop initialisation Signed-off-by: matthias <uso.cosmo.ray@gmail.com>
2019-04-30 11:44:15 +08:00
Sym *lcleanup = current_cleanups;
int lncleanups = ncleanups;
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted &= ~0x20000000;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
skip('(');
fix c99 for-loop init decl scope (thanks: grischka) see http://lists.nongnu.org/archive/html/tinycc-devel/2011-03/msg00005.html
2011-03-09 07:19:54 +08:00
s = local_stack;
remove incr/decr_local_scope functions
2019-01-30 04:32:38 +08:00
++local_scope;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok != ';') {
support c99 for-loop init decls (2nd attempt)
2011-03-09 05:36:04 +08:00
/* c99 for-loop init decl? */
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
if (!decl0(VT_LOCAL, 1, NULL)) {
support c99 for-loop init decls (2nd attempt)
2011-03-09 05:36:04 +08:00
/* no, regular for-loop init expr */
gexpr();
vpop();
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Revert "implemented C99 for loop with variable declaration" This reverts commit 433ecdfc9d1402ecf03e710de481e2063ad6de90. The patch breaks e.g. with for ((i = 10); --i;); In particular to check for a type decl. this is not sufficient: if (tok < TOK_UIDENT) { A future approach to c99 loop variables might instead use: if (parse_btype(...)) { plus refactor function decl() accordingly.
2010-08-21 19:39:12 +08:00
skip(';');
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
d = ind;
c = ind;
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
vla_sp_restore();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
a = 0;
b = 0;
if (tok != ';') {
gexpr();
Move logic for if (int value) to tccgen.c Move the logic to do a test of an integer value (ex if (0)) out of arch-specific code to tccgen.c to avoid code duplication. This also fixes test of long long value which was only testing the bottom half of such values on 32 bits architectures.
2013-12-31 23:51:20 +08:00
a = gvtst(1, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
skip(';');
if (tok != ')') {
e = gjmp(0);
c = ind;
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
vla_sp_restore();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gexpr();
vpop();
gjmp_addr(d);
gsym(e);
}
skip(')');
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
saved_nocode_wanted = nocode_wanted;
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
block(&a, current_cleanups, &b, current_cleanups, 0);
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
nocode_wanted = saved_nocode_wanted;
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
gjmp_addr(c);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(a);
gsym_addr(b, c);
remove incr/decr_local_scope functions
2019-01-30 04:32:38 +08:00
--local_scope;
fix cleanup with for loop initialisation Signed-off-by: matthias <uso.cosmo.ray@gmail.com>
2019-04-30 11:44:15 +08:00
try_call_scope_cleanup(lcleanup);
ncleanups = lncleanups;
current_cleanups = lcleanup;
Fix access-after-free with statement expressions The return value of statement expressions might refer to local symbols, so those can't be popped. The old error message always was just a band-aid, and since disabling it for pointer types it wasn't effective anyway. It also never considered that also the vtop->sym member might have referred to such symbols (see the testcase with the local static, that used to segfault). For fixing this (can be seen better with valgrind and SYM_DEBUG) simply leave local symbols of stmt exprs on the stack.
2016-08-15 11:09:31 +08:00
sym_pop(&local_stack, s, 0);
tccgen: scope levels for local symbols ... for fast redeclaration checks Also, check function parameters too: void foo(int a) { int a; ... } Also, try to fix struct/union/enum's on different scopes: { struct xxx { int x; }; { struct xxx { int y; }; ... }} and some (probably not all) combination with incomplete declarations "struct xxx;" Replaces 2bfedb18675228c3837c23fa523231f55e102c12 and 07d896c8e5d1b46bf4aebd403c78e5f7ffebe02a Fixes cf95ac399cbce1ea8a519f91dd36a5cfd4ea7943
2016-05-05 16:39:09 +08:00
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
} else
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok == TOK_DO) {
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
int saved_nocode_wanted;
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted &= ~0x20000000;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
a = 0;
b = 0;
d = ind;
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
vla_sp_restore();
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
saved_nocode_wanted = nocode_wanted;
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
block(&a, current_cleanups, &b, current_cleanups, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(TOK_WHILE);
skip('(');
gsym(b);
Code suppression fixes See adjusted testcase, a lone break; in a do while loop was incorrectly disabling the exit test.
2017-11-14 22:38:40 +08:00
if (b)
nocode_wanted = saved_nocode_wanted;
arm64: Fix a case of dead code suppression 82_nocode_wanted.c:kb_wait_2_1 was miscompiled on arm64.
2016-12-14 00:23:02 +08:00
gexpr();
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
c = gvtst(0, 0);
gsym_addr(c, d);
arm64: Fix a case of dead code suppression 82_nocode_wanted.c:kb_wait_2_1 was miscompiled on arm64.
2016-12-14 00:23:02 +08:00
nocode_wanted = saved_nocode_wanted;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(')');
gsym(a);
skip(';');
} else
if (tok == TOK_SWITCH) {
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
struct switch_t *saved, sw;
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
int saved_nocode_wanted = nocode_wanted;
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
SValue switchval;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
skip('(');
gexpr();
skip(')');
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
switchval = *vtop--;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
a = 0;
b = gjmp(0); /* jump to first case */
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
sw.p = NULL; sw.n = 0; sw.def_sym = 0;
saved = cur_switch;
gcase() clean up remove tail recursion, simplify
2016-10-11 16:29:56 +08:00
cur_switch = &sw;
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
block(&a, current_cleanups, csym, ccl, 0);
opt: Make break and goto not fallthrough As we can optimize dead code a bit already it's fitting to disable code emission after break and goto.
2016-09-27 02:31:24 +08:00
nocode_wanted = saved_nocode_wanted;
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
a = gjmp(a); /* add implicit break */
switch: binary search
2016-10-03 18:14:34 +08:00
/* case lookup */
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
gsym(b);
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
qsort(sw.p, sw.n, sizeof(void*), case_cmp);
for (b = 1; b < sw.n; b++)
if (sw.p[b - 1]->v2 >= sw.p[b]->v1)
tcc_error("duplicate case value");
/* Our switch table sorting is signed, so the compared
value needs to be as well when it's 64bit. */
if ((switchval.type.t & VT_BTYPE) == VT_LLONG)
switchval.type.t &= ~VT_UNSIGNED;
vpushv(&switchval);
gcase(sw.p, sw.n, &a);
vpop();
if (sw.def_sym)
gjmp_addr(sw.def_sym);
Misc. fixes Makefile : - do not 'uninstall' peoples /usr/local/doc entirely libtcc.c : - MEM_DEBUG : IDE-friendly output "file:line: ..." - always ELF for objects tccgen.c : - fix memory leak in new switch code - move static 'in_sizeof' out of function profiling : - define 'static' to empty resolve_sym() : - replace by dlsym() win32/64: fix R_XXX_RELATIVE fixme - was fixed for i386 already in 8e4d64be2fc1d707c7800c5096f6e0ea22cbd - do not -Lsystemdir if compiling to .o
2016-10-06 00:34:17 +08:00
dynarray_reset(&sw.p, &sw.n);
switch: binary search
2016-10-03 18:14:34 +08:00
cur_switch = saved;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* break label */
gsym(a);
} else
if (tok == TOK_CASE) {
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
struct case_t *cr = tcc_malloc(sizeof(struct case_t));
if (!cur_switch)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
expect("switch");
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted &= ~0x20000000;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
cr->v1 = cr->v2 = expr_const64();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (gnu_ext && tok == TOK_DOTS) {
next();
Fix 64bit enums and switch cases See testcases. We now support 64bit case constants. At the same time also 64bit enum constants on L64 platforms (otherwise the Sym struct isn't large enough for now). The testcase also checks for various cases where sign/zero extension was confused.
2016-11-06 12:02:11 +08:00
cr->v2 = expr_const64();
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
if (cr->v2 < cr->v1)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("empty case range");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
cr->sym = ind;
fixes & cleanups - tccgen.c/tcc.h: allow function declaration after use: int f() { return g(); } int g() { return 1; } may be a warning but not an error see also 76cb1144ef91924c53c57ea71e6f67ce73ce1cc6 - tccgen.c: redundant code related to inline functions removed (functions used anywhere have sym->c set automatically) - tccgen.c: make 32bit llop non-equal test portable (probably not on C67) - dynarray_add: change prototype to possibly avoid aliasing problems or at least warnings - lib/alloca*.S: ".section .note.GNU-stack,"",%progbits" removed (has no effect) - tccpe: set SizeOfCode field (for correct upx decompression) - libtcc.c: fixed alternative -run invocation tcc "-run -lxxx ..." file.c (meant to load the library after file). Also supported now: tcc files ... options ... -run @ arguments ...
2017-02-14 01:23:43 +08:00
dynarray_add(&cur_switch->p, &cur_switch->n, cr);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(':');
is_expr = 0;
goto block_after_label;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
} else
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok == TOK_DEFAULT) {
next();
skip(':');
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
if (!cur_switch)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
expect("switch");
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
if (cur_switch->def_sym)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("too many 'default'");
switch: collect case ranges first, then generate code Collect cases first, then emit lookup code. Elliminates jumps to implement pass-through and jumps to link cases.
2016-09-21 23:35:29 +08:00
cur_switch->def_sym = ind;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
is_expr = 0;
goto block_after_label;
} else
if (tok == TOK_GOTO) {
next();
if (tok == '*' && gnu_ext) {
/* computed goto */
next();
gexpr();
if ((vtop->type.t & VT_BTYPE) != VT_PTR)
expect("pointer");
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
ggoto();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (tok >= TOK_UIDENT) {
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
s = label_find(tok);
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
/* put forward definition if needed */
if (!s)
s = label_push(&global_label_stack, tok, LABEL_FORWARD);
else if (s->r == LABEL_DECLARED)
s->r = LABEL_FORWARD;
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
vla_sp_restore_root();
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
if (s->r & LABEL_FORWARD) {
/* start new goto chain for cleanups, linked via label->next */
if (current_cleanups) {
sym_push2(&pending_gotos, SYM_FIELD, 0, ncleanups);
pending_gotos->prev_tok = s;
s = sym_push2(&s->next, SYM_FIELD, 0, 0);
pending_gotos->next = s;
}
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
s->jnext = gjmp(s->jnext);
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
} else {
try_call_cleanup_goto(s->cleanupstate);
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
gjmp_addr(s->jnext);
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
}
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
next();
} else {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
expect("label identifier");
}
skip(';');
} else if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) {
asm_instr();
} else {
b = is_label();
if (b) {
/* label case */
Remove label_or_decl The only use of this function can be rewritten in terms of is_label (if one other use of that one are a bit amended).
2017-04-16 02:05:39 +08:00
next();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
s = label_find(b);
if (s) {
if (s->r == LABEL_DEFINED)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("duplicate label '%s'", get_tok_str(s->v, NULL));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
s->r = LABEL_DEFINED;
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
if (s->next) {
Sym *pcl; /* pending cleanup goto */
for (pcl = s->next; pcl; pcl = pcl->prev)
gsym(pcl->jnext);
sym_pop(&s->next, NULL, 0);
} else
gsym(s->jnext);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
s = label_push(&global_label_stack, b, LABEL_DEFINED);
}
win64: fix pointer <-> unsigned long typecast issues
2009-07-19 04:05:58 +08:00
s->jnext = ind;
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
s->cleanupstate = current_cleanups;
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
vla_sp_restore();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* we accept this, but it is a mistake */
block_after_label:
tccgen: nocode_wanted++/-- uses 'nocode_wanted' as a level couter instead of 'saved_nocode_wanted' everywhere.
2016-12-19 01:58:33 +08:00
nocode_wanted &= ~0x20000000;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok == '}') {
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("deprecated use of label at end of compound statement");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
if (is_expr)
vpop();
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
block(bsym, bcl, csym, ccl, is_expr);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
} else {
/* expression case */
if (tok != ';') {
if (is_expr) {
vpop();
gexpr();
} else {
gexpr();
vpop();
}
}
skip(';');
}
}
}
Factor some code Three places that skip (and store) tokens in some fashion can be factored a bit.
2017-03-07 04:43:48 +08:00
/* This skips over a stream of tokens containing balanced {} and ()
Improve skip_or_save_block Stop at level 0 only for matching outer '}' (which is added). Otherwise stop only at stop tokens (which aren't added).
2017-07-04 00:13:15 +08:00
pairs, stopping at outer ',' ';' and '}' (or matching '}' if we started
with a '{'). If STR then allocates and stores the skipped tokens
in *STR. This doesn't check if () and {} are nested correctly,
i.e. "({)}" is accepted. */
Factor some code Three places that skip (and store) tokens in some fashion can be factored a bit.
2017-03-07 04:43:48 +08:00
static void skip_or_save_block(TokenString **str)
{
Improve skip_or_save_block Stop at level 0 only for matching outer '}' (which is added). Otherwise stop only at stop tokens (which aren't added).
2017-07-04 00:13:15 +08:00
int braces = tok == '{';
Factor some code Three places that skip (and store) tokens in some fashion can be factored a bit.
2017-03-07 04:43:48 +08:00
int level = 0;
if (str)
*str = tok_str_alloc();
Extend skip_or_save_block Make it stop also before outer level closing parens. This way we can now also skip/save the expression inside "foobar(42 + 41)".
2017-07-04 01:15:16 +08:00
while ((level > 0 || (tok != '}' && tok != ',' && tok != ';' && tok != ')'))) {
Factor some code Three places that skip (and store) tokens in some fashion can be factored a bit.
2017-03-07 04:43:48 +08:00
int t;
if (tok == TOK_EOF) {
if (str || level > 0)
tcc_error("unexpected end of file");
else
break;
}
if (str)
tok_str_add_tok(*str);
t = tok;
next();
if (t == '{' || t == '(') {
level++;
} else if (t == '}' || t == ')') {
level--;
Improve skip_or_save_block Stop at level 0 only for matching outer '}' (which is added). Otherwise stop only at stop tokens (which aren't added).
2017-07-04 00:13:15 +08:00
if (level == 0 && braces && t == '}')
Factor some code Three places that skip (and store) tokens in some fashion can be factored a bit.
2017-03-07 04:43:48 +08:00
break;
}
}
if (str) {
tok_str_add(*str, -1);
tok_str_add(*str, 0);
}
}
struct-init: Implement initializing subaggregates E.g. "struct { struct S s; int a;} = { others, 42 };" if 'others' is also a 'struct S'. Also when the value is a compound literal. See added testcases.
2016-07-31 11:43:17 +08:00
#define EXPR_CONST 1
#define EXPR_ANY 2
static void parse_init_elem(int expr_type)
{
int saved_global_expr;
switch(expr_type) {
case EXPR_CONST:
/* compound literals must be allocated globally in this case */
saved_global_expr = global_expr;
global_expr = 1;
expr_const1();
global_expr = saved_global_expr;
Fix bogus check for VT_LLOCAL types VT_LLOCAL is a flag on .r, not on type.t. Fixing this requires minor surgery for compound literals which accidentally happened to be subsumed by the bogus test.
2017-02-19 11:25:46 +08:00
/* NOTE: symbols are accepted, as well as lvalue for anon symbols
(compound literals). */
if (((vtop->r & (VT_VALMASK | VT_LVAL)) != VT_CONST
&& ((vtop->r & (VT_SYM|VT_LVAL)) != (VT_SYM|VT_LVAL)
|| vtop->sym->v < SYM_FIRST_ANOM))
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
#ifdef TCC_TARGET_PE
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
|| ((vtop->r & VT_SYM) && vtop->sym->a.dllimport)
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
#endif
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
)
struct-init: Implement initializing subaggregates E.g. "struct { struct S s; int a;} = { others, 42 };" if 'others' is also a 'struct S'. Also when the value is a compound literal. See added testcases.
2016-07-31 11:43:17 +08:00
tcc_error("initializer element is not constant");
break;
case EXPR_ANY:
expr_eq();
break;
}
}
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
/* put zeros for variable based init */
static void init_putz(Section *sec, unsigned long c, int size)
{
if (sec) {
/* nothing to do because globals are already set to zero */
} else {
vpush_global_sym(&func_old_type, TOK_memset);
vseti(VT_LOCAL, c);
#ifdef TCC_TARGET_ARM
vpushs(size);
vpushi(0);
#else
vpushi(0);
vpushs(size);
#endif
gfunc_call(3);
}
}
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
#define DIF_FIRST 1
#define DIF_SIZE_ONLY 2
#define DIF_HAVE_ELEM 4
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* t is the array or struct type. c is the array or struct
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
address. cur_field is the pointer to the current
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
field, for arrays the 'c' member contains the current start
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
index. 'flags' is as in decl_initializer.
'al' contains the already initialized length of the
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
current container (starting at c). This returns the new length of that. */
static int decl_designator(CType *type, Section *sec, unsigned long c,
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
Sym **cur_field, int flags, int al)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Sym *s, *f;
Tidy decl_designator Removing the need for the notfirst local variable, and tidy loop structure and error messaging a bit.
2017-04-16 02:07:26 +08:00
int index, index_last, align, l, nb_elems, elem_size;
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
unsigned long corig = c;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
elem_size = 0;
nb_elems = 1;
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
if (flags & DIF_HAVE_ELEM)
goto no_designator;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (gnu_ext && (l = is_label()) != 0)
goto struct_field;
Tidy decl_designator Removing the need for the notfirst local variable, and tidy loop structure and error messaging a bit.
2017-04-16 02:07:26 +08:00
/* NOTE: we only support ranges for last designator */
while (nb_elems == 1 && (tok == '[' || tok == '.')) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok == '[') {
if (!(type->t & VT_ARRAY))
expect("array type");
next();
Tidy decl_designator Removing the need for the notfirst local variable, and tidy loop structure and error messaging a bit.
2017-04-16 02:07:26 +08:00
index = index_last = expr_const();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok == TOK_DOTS && gnu_ext) {
next();
index_last = expr_const();
}
skip(']');
Tidy decl_designator Removing the need for the notfirst local variable, and tidy loop structure and error messaging a bit.
2017-04-16 02:07:26 +08:00
s = type->ref;
if (index < 0 || (s->c >= 0 && index_last >= s->c) ||
index_last < index)
tcc_error("invalid index");
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
if (cur_field)
(*cur_field)->c = index_last;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type = pointed_type(type);
elem_size = type_size(type, &align);
c += index * elem_size;
nb_elems = index_last - index + 1;
} else {
Fix more struct inits anonymous struct members were somewhat broken as the testcase demonstrates. The reason is the jumping through hoops to fiddle with the offsets I once introduced to avoid having to track a cumulative offset. That's now not necessary anymore and actively harmful, doing the obvious thing is now better.
2019-04-11 06:30:41 +08:00
int cumofs = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
l = tok;
struct_field:
Tidy decl_designator Removing the need for the notfirst local variable, and tidy loop structure and error messaging a bit.
2017-04-16 02:07:26 +08:00
next();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if ((type->t & VT_BTYPE) != VT_STRUCT)
expect("struct/union type");
Fix more struct inits anonymous struct members were somewhat broken as the testcase demonstrates. The reason is the jumping through hoops to fiddle with the offsets I once introduced to avoid having to track a cumulative offset. That's now not necessary anymore and actively harmful, doing the obvious thing is now better.
2019-04-11 06:30:41 +08:00
f = find_field(type, l, &cumofs);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (!f)
expect("field");
Tidy decl_designator Removing the need for the notfirst local variable, and tidy loop structure and error messaging a bit.
2017-04-16 02:07:26 +08:00
if (cur_field)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
*cur_field = f;
Tidy decl_designator The fixme therein is long solved.
2017-03-07 05:38:45 +08:00
type = &f->type;
Fix more struct inits anonymous struct members were somewhat broken as the testcase demonstrates. The reason is the jumping through hoops to fiddle with the offsets I once introduced to avoid having to track a cumulative offset. That's now not necessary anymore and actively harmful, doing the obvious thing is now better.
2019-04-11 06:30:41 +08:00
c += cumofs + f->c;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Tidy decl_designator Removing the need for the notfirst local variable, and tidy loop structure and error messaging a bit.
2017-04-16 02:07:26 +08:00
cur_field = NULL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Tidy decl_designator Removing the need for the notfirst local variable, and tidy loop structure and error messaging a bit.
2017-04-16 02:07:26 +08:00
if (!cur_field) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok == '=') {
next();
Tidy decl_designator Removing the need for the notfirst local variable, and tidy loop structure and error messaging a bit.
2017-04-16 02:07:26 +08:00
} else if (!gnu_ext) {
expect("=");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
} else {
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
no_designator:
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (type->t & VT_ARRAY) {
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
index = (*cur_field)->c;
if (type->ref->c >= 0 && index >= type->ref->c)
tcc_error("index too large");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type = pointed_type(type);
c += index * type_size(type, &align);
} else {
f = *cur_field;
Fix last change Skipping anonymous bit-fields is correct, but not other anonymous ones like unions or structs.
2017-05-01 12:04:19 +08:00
while (f && (f->v & SYM_FIRST_ANOM) && (f->type.t & VT_BITFIELD))
Remove a bit-field TODO Checked the lcc testsuite for bitfield stuff (in cq.c and fields.c), fixed one more error in initializing unnamed members (which have to be skipped), removed the TODO.
2017-04-30 04:09:10 +08:00
*cur_field = f = f->next;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (!f)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("too many field init");
Tidy decl_designator The fixme therein is long solved.
2017-03-07 05:38:45 +08:00
type = &f->type;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
c += f->c;
}
}
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
/* must put zero in holes (note that doing it that way
ensures that it even works with designators) */
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
if (!(flags & DIF_SIZE_ONLY) && c - corig > al)
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
init_putz(sec, corig + al, c - corig - al);
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
decl_initializer(type, sec, c, flags & ~DIF_FIRST);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* XXX: make it more general */
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
if (!(flags & DIF_SIZE_ONLY) && nb_elems > 1) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
unsigned long c_end;
uint8_t *src, *dst;
int i;
struct-init: Support range inits for local vars Implement missing support for range init for local variables.
2016-08-07 04:38:26 +08:00
if (!sec) {
vset(type, VT_LOCAL|VT_LVAL, c);
for (i = 1; i < nb_elems; i++) {
vset(type, VT_LOCAL|VT_LVAL, c + elem_size * i);
vswap();
vstore();
}
vpop();
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
} else if (!NODATA_WANTED) {
struct-init: Support range inits for local vars Implement missing support for range init for local variables.
2016-08-07 04:38:26 +08:00
c_end = c + nb_elems * elem_size;
if (c_end > sec->data_allocated)
section_realloc(sec, c_end);
src = sec->data + c;
dst = src;
for(i = 1; i < nb_elems; i++) {
dst += elem_size;
memcpy(dst, src, elem_size);
}
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
c += nb_elems * type_size(type, &align);
if (c - corig > al)
al = c - corig;
return al;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
/* store a value or an expression directly in global data or in local array */
struct-init: Cleanup Remove dead code and variables. Properly check for unions when skipping fields in initializers. Make tests2/*.expect depend on the .c files so they are automatically rebuilt when the latter change.
2016-07-31 12:18:45 +08:00
static void init_putv(CType *type, Section *sec, unsigned long c)
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
{
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
int bt;
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
void *ptr;
CType dtype;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
dtype = *type;
dtype.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
if (sec) {
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
int size, align;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* XXX: not portable */
/* XXX: generate error if incorrect relocation */
gen_assign_cast(&dtype);
bt = type->t & VT_BTYPE;
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
if ((vtop->r & VT_SYM)
&& bt != VT_PTR
&& bt != VT_FUNC
&& (bt != (PTR_SIZE == 8 ? VT_LLONG : VT_INT)
|| (type->t & VT_BITFIELD))
&& !((vtop->r & VT_CONST) && vtop->sym->v >= SYM_FIRST_ANOM)
)
tcc_error("initializer element is not computable at load time");
if (NODATA_WANTED) {
vtop--;
return;
}
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
size = type_size(type, &align);
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
section_reserve(sec, c + size);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
ptr = sec->data + c;
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* XXX: make code faster ? */
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
if ((vtop->r & (VT_SYM|VT_CONST)) == (VT_SYM|VT_CONST) &&
vtop->sym->v >= SYM_FIRST_ANOM &&
Spelling fixes in C comments only
2017-05-08 12:38:09 +08:00
/* XXX This rejects compound literals like
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
'(void *){ptr}'. The problem is that '&sym' is
represented the same way, which would be ruled out
by the SYM_FIRST_ANOM check above, but also '"string"'
in 'char *p = "string"' is represented the same
with the type being VT_PTR and the symbol being an
anonymous one. That is, there's no difference in vtop
between '(void *){x}' and '&(void *){x}'. Ignore
pointer typed entities here. Hopefully no real code
will every use compound literals with scalar type. */
(vtop->type.t & VT_BTYPE) != VT_PTR) {
/* These come from compound literals, memcpy stuff over. */
Section *ssec;
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
ElfSym *esym;
struct-init: Copy relocs for compound literals When copying the content of compound literals we must include relocations as well.
2016-10-04 01:21:10 +08:00
ElfW_Rel *rel;
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
esym = elfsym(vtop->sym);
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
ssec = tcc_state->sections[esym->st_shndx];
memmove (ptr, ssec->data + esym->st_value, size);
struct-init: Copy relocs for compound literals When copying the content of compound literals we must include relocations as well.
2016-10-04 01:21:10 +08:00
if (ssec->reloc) {
/* We need to copy over all memory contents, and that
includes relocations. Use the fact that relocs are
created it order, so look from the end of relocs
until we hit one before the copied region. */
int num_relocs = ssec->reloc->data_offset / sizeof(*rel);
rel = (ElfW_Rel*)(ssec->reloc->data + ssec->reloc->data_offset);
while (num_relocs--) {
rel--;
if (rel->r_offset >= esym->st_value + size)
continue;
if (rel->r_offset < esym->st_value)
break;
Fix initializing members multiple times When intializing members where the initializer needs relocations and the member is initialized multiple times we can't allow that to lead to multiple relocations to the same place. The last one must win.
2016-10-08 08:44:17 +08:00
/* Note: if the same fields are initialized multiple
times (possible with designators) then we possibly
add multiple relocations for the same offset here.
That would lead to wrong code, the last reloc needs
to win. We clean this up later after the whole
initializer is parsed. */
struct-init: Copy relocs for compound literals When copying the content of compound literals we must include relocations as well.
2016-10-04 01:21:10 +08:00
put_elf_reloca(symtab_section, sec,
c + rel->r_offset - esym->st_value,
ELFW(R_TYPE)(rel->r_info),
ELFW(R_SYM)(rel->r_info),
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
struct-init: Copy relocs for compound literals When copying the content of compound literals we must include relocations as well.
2016-10-04 01:21:10 +08:00
rel->r_addend
#else
0
#endif
);
}
}
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
} else {
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
if (type->t & VT_BITFIELD) {
int bit_pos, bit_size, bits, n;
unsigned char *p, v, m;
bit_pos = BIT_POS(vtop->type.t);
bit_size = BIT_SIZE(vtop->type.t);
p = (unsigned char*)ptr + (bit_pos >> 3);
bit_pos &= 7, bits = 0;
while (bit_size) {
n = 8 - bit_pos;
if (n > bit_size)
n = bit_size;
v = vtop->c.i >> bits << bit_pos;
m = ((1 << n) - 1) << bit_pos;
*p = (*p & ~m) | (v & m);
bits += n, bit_size -= n, bit_pos = 0, ++p;
}
} else
switch(bt) {
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
/* XXX: when cross-compiling we assume that each type has the
same representation on host and target, which is likely to
be wrong in the case of long double */
case VT_BOOL:
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
vtop->c.i = vtop->c.i != 0;
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
case VT_BYTE:
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
*(char *)ptr |= vtop->c.i;
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
break;
case VT_SHORT:
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
*(short *)ptr |= vtop->c.i;
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
break;
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
case VT_FLOAT:
*(float*)ptr = vtop->c.f;
break;
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
case VT_DOUBLE:
*(double *)ptr = vtop->c.d;
break;
case VT_LDOUBLE:
various stuff win32/Makefile ("for cygwin") removed - On cygwin, the normal ./configure && make can be used with either cygwin's "GCC for Win32 Toolchain" ./configure --cross-prefix=i686-w64-mingw32- or with an existing tcc: ./configure --cc=<old-tccdir>/tcc.exe tcctest.c: - exclude test_high_clobbers() on _WIN64 (does not work) tests2/95_bitfield.c: - use 'signed char' for ARM (where default 'char' is unsigned) tests: - remove -I "expr" diff option to allow tests with busybox-diff. libtcc.c, tcc.c: - removed -iwithprefix option. It is supposed to be combined with -iprefix which we don't have either. tccgen.c: - fix assignments and return of 'void', as in void f() { void *p, *q; *p = *q: return *p; } This appears to be allowed but should do nothing. tcc.h, libtcc.c, tccpp.c: - Revert "Introduce VIP sysinclude paths which are always searched first" This reverts commit 1d5e386b0a78393ac6b670c209a185849ec798a1. The patch was giving tcc's system includes priority over -I which is not how it should be. tccelf.c: - add DT_TEXTREL tag only if text relocations are actually used (which is likely not the case on x86_64) - prepare_dynamic_rel(): avoid relocation of unresolved (weak) symbols tccrun.c: - for HAVE_SELINUX, use two mappings to the same (real) file. (it was so once except the RX mapping wasn't used at all). tccpe.c: - fix relocation constant used for x86_64 (by Andrei E. Warentin) - #ifndef _WIN32 do "chmod 755 ..." to get runnable exes on cygwin. tccasm.c: - keep forward asm labels static, otherwise they will endup in dynsym eventually. configure, Makefile: - mingw32: respect ./configure options --bindir --docdir --libdir - allow overriding tcc when building libtcc1.a and libtcc.def with make XTCC=<tcc program to use> - use $(wildcard ...) for install to allow installing just a cross compiler for example make cross-arm make install - use name <target>-libtcc1.a build-tcc.bat: - add options: -clean, -b bindir
2017-10-12 00:13:43 +08:00
#if defined TCC_IS_NATIVE_387
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
if (sizeof (long double) >= 10) /* zero pad ten-byte LD */
memcpy(ptr, &vtop->c.ld, 10);
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#ifdef __TINYC__
else if (sizeof (long double) == sizeof (double))
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
__asm__("fldl %1\nfstpt %0\n" : "=m" (*ptr) : "m" (vtop->c.ld));
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#endif
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
else if (vtop->c.ld == 0.0)
;
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
else
more minor fixes * tccgen: re-allow long double constants for x87 cross sizeof (long double) may be 12 or 16 depending on host platform (i386/x86_64 on unix/windows). Except that it's 8 if the host is on windows and not gcc was used to compile tcc. * win64: fix builtin_va_start after VT_REF removal See also a8b83ce43a95fa519dacfe7690a3a0098af7909c * tcctest.c: remove outdated limitation for ll-bitfield test It always worked, there is no reason why it should not work in future. * libtcc1.c: exclude long double conversion on ARM * Makefile: remove CFLAGS from link recipes * lib/Makefile: use target DEFINES as passed from main Makefile * lib/armflush.c lib/va_list.c: factor out from libtcc1.c * arm-gen.c: disable "depreciated" warnings for now
2017-05-07 18:41:29 +08:00
#endif
'long' review add some features for more complete 'long' support tcc.h: - use LONG_SIZE=4/8 instead of TCC_LONG_ARE_64_BIT tccgen.c: - add ptrdiff_type, update size_type - support shift and ?: operations - support long enum types - display 'long' from type_to_str - nwchar_t is unsigned short on windows - unrelated: use memcpy in init_putv for long doubles to avoid random bytes in the image (if tcc was compiled by gcc) for diff purposes. tccpp.c: - make parse_number return correct types - improve multi-character-constants 'XX' 'abcd' Changelog: - update
2017-09-25 00:57:48 +08:00
if (sizeof(long double) == LDOUBLE_SIZE)
*(long double*)ptr = vtop->c.ld;
else if (sizeof(double) == LDOUBLE_SIZE)
*(double *)ptr = (double)vtop->c.ld;
else
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
tcc_error("can't cross compile long double constants");
break;
Accept symbols in initializers also on 64 bit Those should use long or long long type, and generate a 64bit reloc.
2016-07-11 22:26:36 +08:00
#if PTR_SIZE != 8
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
case VT_LLONG:
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
*(long long *)ptr |= vtop->c.i;
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
break;
Accept symbols in initializers also on 64 bit Those should use long or long long type, and generate a 64bit reloc.
2016-07-11 22:26:36 +08:00
#else
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
case VT_LLONG:
Accept symbols in initializers also on 64 bit Those should use long or long long type, and generate a 64bit reloc.
2016-07-11 22:26:36 +08:00
#endif
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
case VT_PTR:
{
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
addr_t val = vtop->c.i;
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
if (vtop->r & VT_SYM)
greloca(sec, vtop->sym, c, R_DATA_PTR, val);
else
*(addr_t *)ptr |= val;
Use RELA relocations properly for R_DATA_PTR on x86_64. libtcc.c: Add greloca, a generalisation of greloc that takes an addend. tcc.h: Add greloca and put_elf_reloca. tccelf.c: Add put_elf_reloca, a generalisation of put_elf_reloc. tccgen.c: On x86_64, use greloca instead of greloc in init_putv.
2015-02-22 05:29:03 +08:00
#else
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
if (vtop->r & VT_SYM)
greloc(sec, vtop->sym, c, R_DATA_PTR);
*(addr_t *)ptr |= val;
Use RELA relocations properly for R_DATA_PTR on x86_64. libtcc.c: Add greloca, a generalisation of greloc that takes an addend. tcc.h: Add greloca and put_elf_reloca. tccelf.c: Add put_elf_reloca, a generalisation of put_elf_reloc. tccgen.c: On x86_64, use greloca instead of greloc in init_putv.
2015-02-22 05:29:03 +08:00
#endif
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
break;
}
default:
{
refactor bitfields Use 2 level strategy to access packed bitfields cleanly: 1) Allow to override the original declaration type with an auxilary "access type". This solves cases such as struct { ... unsigned f1:1; }; by using VT_BYTE to access f1. 2) Allow byte-wise split accesses using two new functions load/store_packed_bf. This solves any cases, also ones such as struct __attribute((packed)) _s { unsigned x : 12; unsigned char y : 7; unsigned z : 28; unsigned a: 3; unsigned b: 3; unsigned c: 3; }; where for field 'z': - VT_INT access from offset 2 would be unaligned - VT_LLONG from offset 0 would go past the total struct size (7) and for field 'a' because it is in two bytes and aligned access with VT_SHORT/INT is not possible. Also, static bitfield initializers are stored byte-wise always. Also, cleanup the struct_layout function a bit.
2017-07-09 18:38:59 +08:00
int val = vtop->c.i;
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
#if PTR_SIZE == 8
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
if (vtop->r & VT_SYM)
greloca(sec, vtop->sym, c, R_DATA_PTR, val);
else
*(int *)ptr |= val;
Use RELA relocations properly for R_DATA_PTR on x86_64. libtcc.c: Add greloca, a generalisation of greloc that takes an addend. tcc.h: Add greloca and put_elf_reloca. tccelf.c: Add put_elf_reloca, a generalisation of put_elf_reloc. tccgen.c: On x86_64, use greloca instead of greloc in init_putv.
2015-02-22 05:29:03 +08:00
#else
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
if (vtop->r & VT_SYM)
greloc(sec, vtop->sym, c, R_DATA_PTR);
*(int *)ptr |= val;
Use RELA relocations properly for R_DATA_PTR on x86_64. libtcc.c: Add greloca, a generalisation of greloc that takes an addend. tcc.h: Add greloca and put_elf_reloca. tccelf.c: Add put_elf_reloca, a generalisation of put_elf_reloc. tccgen.c: On x86_64, use greloca instead of greloc in init_putv.
2015-02-22 05:29:03 +08:00
#endif
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
break;
}
}
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop--;
} else {
vset(&dtype, VT_LOCAL|VT_LVAL, c);
vswap();
vstore();
vpop();
}
}
/* 't' contains the type and storage info. 'c' is the offset of the
object in section 'sec'. If 'sec' is NULL, it means stack based
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
allocation. 'flags & DIF_FIRST' is true if array '{' must be read (multi
dimension implicit array init handling). 'flags & DIF_SIZE_ONLY' is true if
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
size only evaluation is wanted (only for arrays). */
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
static void decl_initializer(CType *type, Section *sec, unsigned long c,
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
int flags)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
int len, n, no_oblock, nb, i;
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
int size1, align1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
Sym *s, *f;
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
Sym indexsym;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
CType *t1;
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
if (!(flags & DIF_HAVE_ELEM) && tok != '{' &&
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
/* In case of strings we have special handling for arrays, so
don't consume them as initializer value (which would commit them
to some anonymous symbol). */
tok != TOK_LSTR && tok != TOK_STR &&
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
!(flags & DIF_SIZE_ONLY)) {
struct-init: Implement initializing subaggregates E.g. "struct { struct S s; int a;} = { others, 42 };" if 'others' is also a 'struct S'. Also when the value is a compound literal. See added testcases.
2016-07-31 11:43:17 +08:00
parse_init_elem(!sec ? EXPR_ANY : EXPR_CONST);
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
flags |= DIF_HAVE_ELEM;
struct-init: Implement initializing subaggregates E.g. "struct { struct S s; int a;} = { others, 42 };" if 'others' is also a 'struct S'. Also when the value is a compound literal. See added testcases.
2016-07-31 11:43:17 +08:00
}
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
if ((flags & DIF_HAVE_ELEM) &&
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
!(type->t & VT_ARRAY) &&
struct-init: Allow member initialization from qualified lvalues See testcase.
2016-08-02 04:55:07 +08:00
/* Use i_c_parameter_t, to strip toplevel qualifiers.
The source type might have VT_CONSTANT set, which is
struct-init: Support range inits for local vars Implement missing support for range init for local variables.
2016-08-07 04:38:26 +08:00
of course assignable to non-const elements. */
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
is_compatible_unqualified_types(type, &vtop->type)) {
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
init_putv(type, sec, c);
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
} else if (type->t & VT_ARRAY) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
s = type->ref;
n = s->c;
t1 = pointed_type(type);
size1 = type_size(t1, &align1);
no_oblock = 1;
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
if (((flags & DIF_FIRST) && tok != TOK_LSTR && tok != TOK_STR) ||
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
tok == '{') {
Error out on bad char array initialization Error out with an explicit message when trying to initialize a character array with something that's not a literal (optionally enclosed in braces) as per C99 6.7.8:14; thanks to Antti-Juhani Kaijanaho <ajk@debian.org> who did all the work.
2010-03-14 01:07:57 +08:00
if (tok != '{')
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("character array initializer must be a literal,"
Error out on bad char array initialization Error out with an explicit message when trying to initialize a character array with something that's not a literal (optionally enclosed in braces) as per C99 6.7.8:14; thanks to Antti-Juhani Kaijanaho <ajk@debian.org> who did all the work.
2010-03-14 01:07:57 +08:00
" optionally enclosed in braces");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip('{');
no_oblock = 0;
}
/* only parse strings here if correct type (otherwise: handle
them as ((w)char *) expressions */
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if ((tok == TOK_LSTR &&
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#ifdef TCC_TARGET_PE
(t1->t & VT_BTYPE) == VT_SHORT && (t1->t & VT_UNSIGNED)
#else
(t1->t & VT_BTYPE) == VT_INT
#endif
) || (tok == TOK_STR && (t1->t & VT_BTYPE) == VT_BYTE)) {
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
len = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
while (tok == TOK_STR || tok == TOK_LSTR) {
int cstr_len, ch;
/* compute maximum number of chars wanted */
if (tok == TOK_STR)
Change the way struct CStrings are handled. A CString used to be copied into a token string, which is an int array. On a 64-bit architecture the pointers were misaligned, so ASan gave lots of warnings. On a 64-bit architecture that required memory accesses to be correctly aligned it would not work at all. The CString is now included in CValue instead.
2015-11-21 19:23:53 +08:00
cstr_len = tokc.str.size;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
else
Change the way struct CStrings are handled. A CString used to be copied into a token string, which is an int array. On a 64-bit architecture the pointers were misaligned, so ASan gave lots of warnings. On a 64-bit architecture that required memory accesses to be correctly aligned it would not work at all. The CString is now included in CValue instead.
2015-11-21 19:23:53 +08:00
cstr_len = tokc.str.size / sizeof(nwchar_t);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
cstr_len--;
nb = cstr_len;
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
if (n >= 0 && nb > (n - len))
nb = n - len;
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
if (!(flags & DIF_SIZE_ONLY)) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (cstr_len > nb)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_warning("initializer-string for array is too long");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* in order to go faster for common case (char
string in global variable, we handle it
specifically */
if (sec && tok == TOK_STR && size1 == 1) {
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
if (!NODATA_WANTED)
memcpy(sec->data + c + len, tokc.str.data, nb);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
for(i=0;i<nb;i++) {
if (tok == TOK_STR)
Change the way struct CStrings are handled. A CString used to be copied into a token string, which is an int array. On a 64-bit architecture the pointers were misaligned, so ASan gave lots of warnings. On a 64-bit architecture that required memory accesses to be correctly aligned it would not work at all. The CString is now included in CValue instead.
2015-11-21 19:23:53 +08:00
ch = ((unsigned char *)tokc.str.data)[i];
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
else
Change the way struct CStrings are handled. A CString used to be copied into a token string, which is an int array. On a 64-bit architecture the pointers were misaligned, so ASan gave lots of warnings. On a 64-bit architecture that required memory accesses to be correctly aligned it would not work at all. The CString is now included in CValue instead.
2015-11-21 19:23:53 +08:00
ch = ((nwchar_t *)tokc.str.data)[i];
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
vpushi(ch);
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
init_putv(t1, sec, c + (len + i) * size1);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
}
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
len += nb;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
}
/* only add trailing zero if enough storage (no
warning in this case since it is standard) */
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
if (n < 0 || len < n) {
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
if (!(flags & DIF_SIZE_ONLY)) {
struct-init: Reimplement Start reimplementing the whole initializer handling to be conforming to ISO C. This patch just reimplements current functionality to prepare for further changes, all tests pass.
2016-07-24 06:43:49 +08:00
vpushi(0);
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
init_putv(t1, sec, c + (len * size1));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
len++;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
len *= size1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
indexsym.c = 0;
f = &indexsym;
do_init_list:
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
len = 0;
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
while (tok != '}' || (flags & DIF_HAVE_ELEM)) {
len = decl_designator(type, sec, c, &f, flags, len);
flags &= ~DIF_HAVE_ELEM;
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
if (type->t & VT_ARRAY) {
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
++indexsym.c;
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
/* special test for multi dimensional arrays (may not
be strictly correct if designators are used at the
same time) */
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
if (no_oblock && len >= n*size1)
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
break;
} else {
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (s->type.t == VT_UNION)
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
f = NULL;
else
f = f->next;
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
if (no_oblock && f == NULL)
break;
}
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
if (tok == '}')
break;
skip(',');
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
/* put zeros at the end */
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
if (!(flags & DIF_SIZE_ONLY) && len < n*size1)
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
init_putz(sec, c + len, n*size1 - len);
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
if (!no_oblock)
skip('}');
/* patch type size if needed, which happens only for array types */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (n < 0)
struct-init: Fix zero initialization with multi-level designators See the added testcase. When one used designators like .a.x to initialize sub-members of members, and didn't then initialize all of them the required zero-initialization of the other sub-members wasn't done. The fix also enables tiny code cleanups.
2017-05-06 11:28:13 +08:00
s->c = size1 == 1 ? len : ((len + size1 - 1)/size1);
struct-init: Cleanup Remove dead code and variables. Properly check for unions when skipping fields in initializers. Make tests2/*.expect depend on the .c files so they are automatically rebuilt when the latter change.
2016-07-31 12:18:45 +08:00
} else if ((type->t & VT_BTYPE) == VT_STRUCT) {
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
size1 = 1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
no_oblock = 1;
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
if ((flags & DIF_FIRST) || tok == '{') {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip('{');
no_oblock = 0;
}
s = type->ref;
Fix last commits: remove CRLF, chmod 644 tccgen.c
2010-06-15 23:02:09 +08:00
f = s->next;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
n = s->c;
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
goto do_init_list;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else if (tok == '{') {
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
if (flags & DIF_HAVE_ELEM)
skip(';');
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
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
decl_initializer(type, sec, c, flags & ~DIF_HAVE_ELEM);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip('}');
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
} else if ((flags & DIF_SIZE_ONLY)) {
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
/* If we supported only ISO C we wouldn't have to accept calling
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
this on anything than an array if DIF_SIZE_ONLY (and even then
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
only on the outermost level, so no recursion would be needed),
because initializing a flex array member isn't supported.
But GNU C supports it, so we need to recurse even into
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
subfields of structs and arrays when DIF_SIZE_ONLY is set. */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* just skip expression */
Improve skip_or_save_block Stop at level 0 only for matching outer '}' (which is added). Otherwise stop only at stop tokens (which aren't added).
2017-07-04 00:13:15 +08:00
skip_or_save_block(NULL);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
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
if (!(flags & DIF_HAVE_ELEM)) {
struct-init: Implement initializing subaggregates E.g. "struct { struct S s; int a;} = { others, 42 };" if 'others' is also a 'struct S'. Also when the value is a compound literal. See added testcases.
2016-07-31 11:43:17 +08:00
/* This should happen only when we haven't parsed
the init element above for fear of committing a
string constant to memory too early. */
if (tok != TOK_STR && tok != TOK_LSTR)
expect("string constant");
parse_init_elem(!sec ? EXPR_ANY : EXPR_CONST);
}
struct-init: Cleanup Remove dead code and variables. Properly check for unions when skipping fields in initializers. Make tests2/*.expect depend on the .c files so they are automatically rebuilt when the latter change.
2016-07-31 12:18:45 +08:00
init_putv(type, sec, c);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
/* parse an initializer for type 't' if 'has_init' is non zero, and
allocate space in local or global data space ('r' is either
VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
variable 'v' of scope 'scope' is declared before initializers
are parsed. If 'v' is zero, then a reference to the new object
is put in the value stack. If 'has_init' is 2, a special parsing
is done to handle string constants. */
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
int has_init, int v, int scope)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
int size, align, addr;
tccpp: cleanup - "utf8 in identifiers" from 936819a1b90f2618bb3f86730189cf2895948ba0 - CValue: remove member str.data_allocated - make tiny allocator private to tccpp - allocate macro_stack objects on heap because otherwise it could crash after error/setjmp in preprocess_delete():end_macro() - mov "TinyAlloc" defs to tccpp.c - define_push: take int* str again
2016-10-02 02:26:50 +08:00
TokenString *init_str = NULL;
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
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
Section *sec;
handle c99 flexible array members less hackily
2011-03-19 08:50:42 +08:00
Sym *flexible_array;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
Sym *sym = NULL;
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
int saved_nocode_wanted = nocode_wanted;
#ifdef CONFIG_TCC_BCHECK
misc fixes misc fixes including: - tcc.c: fix "tcc -vv" for libtcc1.a on win32/PE - tccelf.c: fix a crash when GOT has no relocs (witn -nostdlib) - tccelf.c: fix stab linkage for zero n_strx - tccgen.c: fix stdcall decoration for array parameters int __stdcall func(char buf[10]) is _func@4 (was _func@12) - tccgen.c: fix static variables with nocode/nodata_wanted see tests2/96_nodata_wanted.c - tccrun.c: align sections using sh_addralign (for reliable function_alignment) - tests2/Makefile sort 100 after 99 - win32/include/sys/stat.h fix _stat and _wstat - x86_64-gen.c: win64/gfunc_call: fix a bug with xmmN register args previously overwrote valid other xmmN registers eventually
2018-06-01 05:51:51 +08:00
int bcheck;
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
#endif
misc fixes misc fixes including: - tcc.c: fix "tcc -vv" for libtcc1.a on win32/PE - tccelf.c: fix a crash when GOT has no relocs (witn -nostdlib) - tccelf.c: fix stab linkage for zero n_strx - tccgen.c: fix stdcall decoration for array parameters int __stdcall func(char buf[10]) is _func@4 (was _func@12) - tccgen.c: fix static variables with nocode/nodata_wanted see tests2/96_nodata_wanted.c - tccrun.c: align sections using sh_addralign (for reliable function_alignment) - tests2/Makefile sort 100 after 99 - win32/include/sys/stat.h fix _stat and _wstat - x86_64-gen.c: win64/gfunc_call: fix a bug with xmmN register args previously overwrote valid other xmmN registers eventually
2018-06-01 05:51:51 +08:00
/* Always allocate static or global variables */
if (v && (r & VT_VALMASK) == VT_CONST)
nocode_wanted |= 0x80000000;
#ifdef CONFIG_TCC_BCHECK
bcheck = tcc_state->do_bounds_check && !NODATA_WANTED;
#endif
handle c99 flexible array members less hackily
2011-03-19 08:50:42 +08:00
flexible_array = NULL;
if ((type->t & VT_BTYPE) == VT_STRUCT) {
tccgen: fix crash with undeclared struct ... as in: #include<stdio.h> int main() { struct asdasd x; printf("%d\n", sizeof(x)); } This fixes commit 17571298f30bf204fafe9cf1aca5258d2d087d63
2013-07-24 23:06:13 +08:00
Sym *field = type->ref->next;
if (field) {
while (field->next)
field = field->next;
if (field->type.t & VT_ARRAY && field->type.ref->c < 0)
flexible_array = field;
}
handle c99 flexible array members less hackily
2011-03-19 08:50:42 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
size = type_size(type, &align);
/* If unknown size, we must evaluate it before
evaluating initializers because
initializers can generate global data too
(e.g. string pointers or ISOC99 compound
literals). It also simplifies local
initializers handling */
A reverse of the commit 14745bdeb because of the problems while compiling linux 2.4.26 A test program: /////////// typedef unsigned int __u32; static inline const __u32 __fswab32(__u32 x) { return ({ __u32 __tmp = (x) ; ___swab32(__tmp); }); } void func() { int aaa = 1; int snd_wnd = 2; int TCP_FLAG_ACK = 3; int pred_flags = (__builtin_constant_p((__u32) (((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd))) ? ({ __u32 __x = ((((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32((((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd)))); } //////////// error: ';' expected (got "(")
2015-03-03 20:44:29 +08:00
if (size < 0 || (flexible_array && has_init)) {
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (!has_init)
A reverse of the commit 14745bdeb because of the problems while compiling linux 2.4.26 A test program: /////////// typedef unsigned int __u32; static inline const __u32 __fswab32(__u32 x) { return ({ __u32 __tmp = (x) ; ___swab32(__tmp); }); } void func() { int aaa = 1; int snd_wnd = 2; int TCP_FLAG_ACK = 3; int pred_flags = (__builtin_constant_p((__u32) (((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd))) ? ({ __u32 __x = ((((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32((((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd)))); } //////////// error: ';' expected (got "(")
2015-03-03 20:44:29 +08:00
tcc_error("unknown type size");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* get all init string */
if (has_init == 2) {
Factor some code Three places that skip (and store) tokens in some fashion can be factored a bit.
2017-03-07 04:43:48 +08:00
init_str = tok_str_alloc();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* only get strings */
while (tok == TOK_STR || tok == TOK_LSTR) {
tccpp: cleanup - "utf8 in identifiers" from 936819a1b90f2618bb3f86730189cf2895948ba0 - CValue: remove member str.data_allocated - make tiny allocator private to tccpp - allocate macro_stack objects on heap because otherwise it could crash after error/setjmp in preprocess_delete():end_macro() - mov "TinyAlloc" defs to tccpp.c - define_push: take int* str again
2016-10-02 02:26:50 +08:00
tok_str_add_tok(init_str);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
}
Factor some code Three places that skip (and store) tokens in some fashion can be factored a bit.
2017-03-07 04:43:48 +08:00
tok_str_add(init_str, -1);
tok_str_add(init_str, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
Factor some code Three places that skip (and store) tokens in some fashion can be factored a bit.
2017-03-07 04:43:48 +08:00
skip_or_save_block(&init_str);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
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
unget_tok(0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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
/* compute size */
tccpp: cleanup - "utf8 in identifiers" from 936819a1b90f2618bb3f86730189cf2895948ba0 - CValue: remove member str.data_allocated - make tiny allocator private to tccpp - allocate macro_stack objects on heap because otherwise it could crash after error/setjmp in preprocess_delete():end_macro() - mov "TinyAlloc" defs to tccpp.c - define_push: take int* str again
2016-10-02 02:26:50 +08:00
begin_macro(init_str, 1);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
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
decl_initializer(type, NULL, 0, DIF_FIRST | DIF_SIZE_ONLY);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* prepare second initializer parsing */
tccpp: cleanup - "utf8 in identifiers" from 936819a1b90f2618bb3f86730189cf2895948ba0 - CValue: remove member str.data_allocated - make tiny allocator private to tccpp - allocate macro_stack objects on heap because otherwise it could crash after error/setjmp in preprocess_delete():end_macro() - mov "TinyAlloc" defs to tccpp.c - define_push: take int* str again
2016-10-02 02:26:50 +08:00
macro_ptr = init_str->str;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
A reverse of the commit 14745bdeb because of the problems while compiling linux 2.4.26 A test program: /////////// typedef unsigned int __u32; static inline const __u32 __fswab32(__u32 x) { return ({ __u32 __tmp = (x) ; ___swab32(__tmp); }); } void func() { int aaa = 1; int snd_wnd = 2; int TCP_FLAG_ACK = 3; int pred_flags = (__builtin_constant_p((__u32) (((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd))) ? ({ __u32 __x = ((((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32((((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd)))); } //////////// error: ';' expected (got "(")
2015-03-03 20:44:29 +08:00
/* if still unknown size, error */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
size = type_size(type, &align);
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if (size < 0)
A reverse of the commit 14745bdeb because of the problems while compiling linux 2.4.26 A test program: /////////// typedef unsigned int __u32; static inline const __u32 __fswab32(__u32 x) { return ({ __u32 __tmp = (x) ; ___swab32(__tmp); }); } void func() { int aaa = 1; int snd_wnd = 2; int TCP_FLAG_ACK = 3; int pred_flags = (__builtin_constant_p((__u32) (((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd))) ? ({ __u32 __x = ((((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32((((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd)))); } //////////// error: ';' expected (got "(")
2015-03-03 20:44:29 +08:00
tcc_error("unknown type size");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen.c: Fix flex array members some more Last fix didn't work for function f1int in the added testcase.
2016-03-12 05:35:44 +08:00
/* If there's a flex member and it was used in the initializer
adjust size. */
if (flexible_array &&
flexible_array->type.ref->c > 0)
size += flexible_array->type.ref->c
* pointed_size(&flexible_array->type);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* take into account specified alignment if bigger */
be stricter with aliasing Refactoring (no logical changes): - use memcpy in tccgen.c:ieee_finite(double d) - use union to store attribute flags in Sym Makefile: "CFLAGS+=-fno-strict-aliasing" basically not necessary anymore but I left it for now because gcc sometimes behaves unexpectedly without. Also: - configure: back to mode 100755 - tcc.h: remove unused variables tdata/tbss_section - x86_64-gen.c: adjust gfunc_sret for prototype
2014-01-07 21:57:07 +08:00
if (ad->a.aligned) {
Support large alignment requests The linux kernel has some structures that are page aligned, i.e. 4096. Instead of enlarging the bit fields to specify this, use the fact that alignment is always power of two, and store only the log2 minus 1 of it. The 5 bits are enough to specify an alignment of 1 << 30.
2016-10-09 08:41:34 +08:00
int speca = 1 << (ad->a.aligned - 1);
if (speca > align)
align = speca;
be stricter with aliasing Refactoring (no logical changes): - use memcpy in tccgen.c:ieee_finite(double d) - use union to store attribute flags in Sym Makefile: "CFLAGS+=-fno-strict-aliasing" basically not necessary anymore but I left it for now because gcc sometimes behaves unexpectedly without. Also: - configure: back to mode 100755 - tcc.h: remove unused variables tdata/tbss_section - x86_64-gen.c: adjust gfunc_sret for prototype
2014-01-07 21:57:07 +08:00
} else if (ad->a.packed) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
align = 1;
}
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
misc fixes misc fixes including: - tcc.c: fix "tcc -vv" for libtcc1.a on win32/PE - tccelf.c: fix a crash when GOT has no relocs (witn -nostdlib) - tccelf.c: fix stab linkage for zero n_strx - tccgen.c: fix stdcall decoration for array parameters int __stdcall func(char buf[10]) is _func@4 (was _func@12) - tccgen.c: fix static variables with nocode/nodata_wanted see tests2/96_nodata_wanted.c - tccrun.c: align sections using sh_addralign (for reliable function_alignment) - tests2/Makefile sort 100 after 99 - win32/include/sys/stat.h fix _stat and _wstat - x86_64-gen.c: win64/gfunc_call: fix a bug with xmmN register args previously overwrote valid other xmmN registers eventually
2018-06-01 05:51:51 +08:00
if (!v && NODATA_WANTED)
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
size = 0, align = 1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if ((r & VT_VALMASK) == VT_LOCAL) {
sec = NULL;
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#ifdef CONFIG_TCC_BCHECK
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
if (bcheck && (type->t & VT_ARRAY)) {
VLA fix [2/3]: removed VT_ARRAY from VT_VLA types A VLA is not really an array, it's a pointer-to-an-array. Making this explicit allows us to back out a few parts of the original VLA patch and paves the way for the next part of the fix, where a VLA will be stored on the runtime stack as a pointer-to-an-array, rather than on the compile- time stack as a Sym*.
2011-04-08 16:09:39 +08:00
loc--;
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
}
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
loc = (loc - size) & -align;
addr = loc;
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#ifdef CONFIG_TCC_BCHECK
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* handles bounds */
/* XXX: currently, since we do only one pass, we cannot track
'&' operators, so we add only arrays */
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
if (bcheck && (type->t & VT_ARRAY)) {
make a bound checking more compatible with Windows 64 On Linux 32: sizeof(long)=32 == sizeof(void *)=32 on Linux 64: sizeof(long)=64 == sizeof(void *)=64 on Windows 64: sizeof(long)=32 != sizeof(void *)=64
2015-03-26 12:47:45 +08:00
addr_t *bounds_ptr;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* add padding between regions */
loc--;
/* then add local bound info */
make a bound checking more compatible with Windows 64 On Linux 32: sizeof(long)=32 == sizeof(void *)=32 on Linux 64: sizeof(long)=64 == sizeof(void *)=64 on Windows 64: sizeof(long)=32 != sizeof(void *)=64
2015-03-26 12:47:45 +08:00
bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(addr_t));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
bounds_ptr[0] = addr;
bounds_ptr[1] = size;
}
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (v) {
/* local variable */
Support local register variables Similar to GCC a local asm register variable enforces the use of a specified register in asm operands (and doesn't otherwise matter). Works only if the variable is directly mentioned as operand. For that we now generally store a backpointer from an SValue to a Sym when the SValue was the result of unary() parsing a symbol identifier.
2016-10-06 10:05:30 +08:00
#ifdef CONFIG_TCC_ASM
if (ad->asm_label) {
int reg = asm_parse_regvar(ad->asm_label);
if (reg >= 0)
r = (r & ~VT_VALMASK) | reg;
}
#endif
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
sym = sym_push(v, type, r, addr);
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
if (ad->cleanup_func) {
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
Sym *cls = sym_push2(&all_cleanups, SYM_FIELD | ++ncleanups, 0, 0);
cls->prev_tok = sym;
cls->next = ad->cleanup_func;
cls->ncl = current_cleanups;
current_cleanups = cls;
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
}
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
sym->a = ad->a;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
/* push local reference */
vset(type, r, addr);
}
} else {
if (v && scope == VT_CONST) {
/* see if the symbol was already defined */
sym = sym_find(v);
if (sym) {
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
patch_storage(sym, ad, type);
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
/* we accept several definitions of the same global variable. */
if (!has_init && sym->c && elfsym(sym)->st_shndx != SHN_UNDEF)
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
goto no_alloc;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
/* allocate symbol in corresponding section */
sec = ad->section;
if (!sec) {
Revert "Add support for thread-local storage variables" TLS support in tinyCC is absolutely not ready: - segment register not select in load and store - no relocation added for computing offset of per-thread symbol - no support for TLS-specific relocations - no program header added as per Drepper document about TLS This reverts commit 1c4afd13501f07a673aed5f130166f2ee0f30927.
2013-11-03 18:55:54 +08:00
if (has_init)
sec = data_section;
else if (tcc_state->nocommon)
sec = bss_section;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (sec) {
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
addr = section_add(sec, size, align);
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#ifdef CONFIG_TCC_BCHECK
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* add padding if bound check */
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
if (bcheck)
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
section_add(sec, 1, 1);
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
addr = align; /* SHN_COMMON is special, symbol value is align */
sec = common_section;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
if (v) {
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
if (!sym) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
sym = sym_push(v, type, r | VT_SYM, 0);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
patch_storage(sym, ad, NULL);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccasm: Fix local statics referenced from asms The assembler uses the ->sym_scope member to walk up the symbols until finding a non-automatic symbol. Since reordering the members of Sym the sym_scope member contains a scope even for local statics. Formerly the use of asm_label for statics was implicitely clearing sym_scope, now we have to do that explicitely. Add a testcase for that, and one I encountered when moving the clearing of sym_scope too deep into the call chain (into put_extern_sym).
2017-07-11 04:29:28 +08:00
/* Local statics have a scope until now (for
warnings), remove it here. */
sym->sym_scope = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* update symbol definition */
Cleanups (float consts, sections, symbols) introduce common_section (SHN_COMMON), factorize some handling in decl_initializer_alloc, add section_add and use it to factorize some code that allocates stuff in sections (at the same time also fixing harmless bugs re section alignment), use init_putv to emit float consts into .data from gv() (fixing an XXX).
2017-03-12 12:25:09 +08:00
put_extern_sym(sym, sec, addr, size);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
/* push global reference */
Tidy some code the real difference is in decl0 where we can use external_sym just fine also for function definitions, we don't have to use external_global_sym. Setting VT_EXTERN in external_sym isn't necessary either (the type will have it set if necessary). The rest is tidying: removing unused arguments and moving some code around.
2019-04-18 09:36:39 +08:00
vpush_ref(type, sec, addr, size);
sym = vtop->sym;
Fix bogus check for VT_LLOCAL types VT_LLOCAL is a flag on .r, not on type.t. Fixing this requires minor surgery for compound literals which accidentally happened to be subsumed by the bogus test.
2017-02-19 11:25:46 +08:00
vtop->r |= r;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#ifdef CONFIG_TCC_BCHECK
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* handles bounds now because the symbol must be defined
before for the relocation */
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
if (bcheck) {
make a bound checking more compatible with Windows 64 On Linux 32: sizeof(long)=32 == sizeof(void *)=32 on Linux 64: sizeof(long)=64 == sizeof(void *)=64 on Windows 64: sizeof(long)=32 != sizeof(void *)=64
2015-03-26 12:47:45 +08:00
addr_t *bounds_ptr;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
configure: --config-musl/-uClibc switch & misc cleanups - configure: - add --config-uClibc,-musl switch and suggest to use it if uClibc/musl is detected - make warning options magic clang compatible - simplify (use $confvars instead of individual options) - Revert "Remove some unused-parameter lint" 7443db0d5f841b81a55e918bf8c228dd20f9ddb2 rather use -Wno-unused-parameter (or just not -Wextra) - #ifdef functions that are unused on some targets - tccgen.c: use PTR_SIZE==8 instead of (X86_64 || ARM64) - tccpe.c: fix some warnings - integrate dummy arm-asm better
2017-05-13 14:59:06 +08:00
greloca(bounds_section, sym, bounds_section->data_offset, R_DATA_PTR, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* then add global bound info */
make a bound checking more compatible with Windows 64 On Linux 32: sizeof(long)=32 == sizeof(void *)=32 on Linux 64: sizeof(long)=64 == sizeof(void *)=64 on Windows 64: sizeof(long)=32 != sizeof(void *)=64
2015-03-26 12:47:45 +08:00
bounds_ptr = section_ptr_add(bounds_section, 2 * sizeof(addr_t));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
bounds_ptr[0] = 0; /* relocated */
bounds_ptr[1] = size;
}
win32: enable bounds checker & exception handler exception handler borrowed from k1w1. Thanks.
2009-12-20 05:22:43 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
if (type->t & VT_VLA) {
int a;
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
if (NODATA_WANTED)
goto no_alloc;
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
/* save current stack pointer */
if (vlas_in_scope == 0) {
if (vla_sp_root_loc == -1)
vla_sp_root_loc = (loc -= PTR_SIZE);
gen_vla_sp_save(vla_sp_root_loc);
}
vla_runtime_type_size(type, &a);
gen_vla_alloc(type, a);
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
#if defined TCC_TARGET_PE && defined TCC_TARGET_X86_64
/* on _WIN64, because of the function args scratch area, the
result of alloca differs from RSP and is returned in RAX. */
gen_vla_result(addr), addr = (loc -= PTR_SIZE);
#endif
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
gen_vla_sp_save(addr);
vla_sp_loc = addr;
vlas_in_scope++;
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
} else if (has_init) {
Fix initializing members multiple times When intializing members where the initializer needs relocations and the member is initialized multiple times we can't allow that to lead to multiple relocations to the same place. The last one must win.
2016-10-08 08:44:17 +08:00
size_t oldreloc_offset = 0;
if (sec && sec->reloc)
oldreloc_offset = sec->reloc->data_offset;
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
decl_initializer(type, sec, addr, DIF_FIRST);
Fix initializing members multiple times When intializing members where the initializer needs relocations and the member is initialized multiple times we can't allow that to lead to multiple relocations to the same place. The last one must win.
2016-10-08 08:44:17 +08:00
if (sec && sec->reloc)
squeeze_multi_relocs(sec, oldreloc_offset);
handle c99 flexible array members less hackily
2011-03-19 08:50:42 +08:00
/* patch flexible array member size back to -1, */
/* for possible subsequent similar declarations */
if (flexible_array)
flexible_array->type.ref->c = -1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
no_alloc:
tccpp: cleanup - "utf8 in identifiers" from 936819a1b90f2618bb3f86730189cf2895948ba0 - CValue: remove member str.data_allocated - make tiny allocator private to tccpp - allocate macro_stack objects on heap because otherwise it could crash after error/setjmp in preprocess_delete():end_macro() - mov "TinyAlloc" defs to tccpp.c - define_push: take int* str again
2016-10-02 02:26:50 +08:00
/* restore parse state if needed */
if (init_str) {
end_macro();
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
next();
tccpp: cleanup - "utf8 in identifiers" from 936819a1b90f2618bb3f86730189cf2895948ba0 - CValue: remove member str.data_allocated - make tiny allocator private to tccpp - allocate macro_stack objects on heap because otherwise it could crash after error/setjmp in preprocess_delete():end_macro() - mov "TinyAlloc" defs to tccpp.c - define_push: take int* str again
2016-10-02 02:26:50 +08:00
}
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
nocode_wanted = saved_nocode_wanted;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
/* parse a function defined by symbol 'sym' and generate its code in
'cur_text_section' */
static void gen_function(Sym *sym)
{
A reverse of the commit 14745bdeb because of the problems while compiling linux 2.4.26 A test program: /////////// typedef unsigned int __u32; static inline const __u32 __fswab32(__u32 x) { return ({ __u32 __tmp = (x) ; ___swab32(__tmp); }); } void func() { int aaa = 1; int snd_wnd = 2; int TCP_FLAG_ACK = 3; int pred_flags = (__builtin_constant_p((__u32) (((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd))) ? ({ __u32 __x = ((((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32((((aaa << 26) | (__builtin_constant_p((__u32)((TCP_FLAG_ACK))) ? ({ __u32 __x = (((TCP_FLAG_ACK))); ((__u32)( (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); }) : __fswab32(((TCP_FLAG_ACK)))) | snd_wnd)))); } //////////// error: ';' expected (got "(")
2015-03-03 20:44:29 +08:00
nocode_wanted = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
ind = cur_text_section->data_offset;
Implement function alignment via attributes which requires being able to emit an arbitrary number of NOP instructions, which is also implemented here. For x86 we could emit other sequences but these are the easiest.
2018-04-07 05:01:45 +08:00
if (sym->a.aligned) {
size_t newoff = section_add(cur_text_section, 0,
1 << (sym->a.aligned - 1));
misc fixes misc fixes including: - tcc.c: fix "tcc -vv" for libtcc1.a on win32/PE - tccelf.c: fix a crash when GOT has no relocs (witn -nostdlib) - tccelf.c: fix stab linkage for zero n_strx - tccgen.c: fix stdcall decoration for array parameters int __stdcall func(char buf[10]) is _func@4 (was _func@12) - tccgen.c: fix static variables with nocode/nodata_wanted see tests2/96_nodata_wanted.c - tccrun.c: align sections using sh_addralign (for reliable function_alignment) - tests2/Makefile sort 100 after 99 - win32/include/sys/stat.h fix _stat and _wstat - x86_64-gen.c: win64/gfunc_call: fix a bug with xmmN register args previously overwrote valid other xmmN registers eventually
2018-06-01 05:51:51 +08:00
gen_fill_nops(newoff - ind);
Implement function alignment via attributes which requires being able to emit an arbitrary number of NOP instructions, which is also implemented here. For x86 we could emit other sequences but these are the easiest.
2018-04-07 05:01:45 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* NOTE: we patch the symbol size later */
put_extern_sym(sym, cur_text_section, ind, 0);
Fix fct asm label: only valid for declaration - Fix function assembly label mechanism introduced in commit 9b09fc376e8c212a767c875e71ca003e3b9a0d2e to only accept alternative name for function declaration. - merge the code with the one introduced in commit 264a103610e3ee86b27b8cbb0e4ec81cd654d980. - Don't memorize token for asm label but directly the asm label.
2011-02-08 05:42:38 +08:00
funcname = get_tok_str(sym->v, NULL);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
func_ind = ind;
Improved variable length array support. VLA storage is now freed when it goes out of scope. This makes it possible to use a VLA inside a loop without consuming an unlimited amount of memory. Combining VLAs with alloca() should work as in GCC - when a VLA is freed, memory allocated by alloca() after the VLA was created is also freed. There are some exceptions to this rule when using goto: if a VLA is in scope at the goto, jumping to a label will reset the stack pointer to where it was immediately after the last VLA was created prior to the label, or to what it was before the first VLA was created if the label is outside the scope of any VLA. This means that in some cases combining alloca() and VLAs will free alloca() memory where GCC would not.
2013-04-28 03:39:34 +08:00
/* Initialize VLA state */
a lot simpler VLA code Author: Philip <pipcet@gmail.com> Our VLA code can be made a lot simpler (simple enough for even me to understand it) by giving up on the optimization idea, which is very tempting. There's a patch to do that attached, feel free to test and commit it if you like. (It passes all the tests, at least
2015-05-04 09:09:05 +08:00
vla_sp_loc = -1;
vla_sp_root_loc = -1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* put debug symbol */
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
tcc_debug_funcstart(tcc_state, sym);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* push a dummy symbol to enable local sym storage */
sym_push2(&local_stack, SYM_FIELD, 0, 0);
tccgen: scope levels for local symbols ... for fast redeclaration checks Also, check function parameters too: void foo(int a) { int a; ... } Also, try to fix struct/union/enum's on different scopes: { struct xxx { int x; }; { struct xxx { int y; }; ... }} and some (probably not all) combination with incomplete declarations "struct xxx;" Replaces 2bfedb18675228c3837c23fa523231f55e102c12 and 07d896c8e5d1b46bf4aebd403c78e5f7ffebe02a Fixes cf95ac399cbce1ea8a519f91dd36a5cfd4ea7943
2016-05-05 16:39:09 +08:00
local_scope = 1; /* for function parameters */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gfunc_prolog(&sym->type);
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
reset_local_scope();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
rsym = 0;
optimize the generated code when save_reg is required Before this patch, save_reg can't reuse the temporary local variable created before to save register. It may consume a lot of stack memory. this patch make save_reg reuse the temporary local variable.
2019-01-10 03:32:23 +08:00
clear_temp_local_var_list();
fix cleanup with break and continue fix cleanup
2019-04-29 17:18:57 +08:00
block(NULL, NULL, NULL, NULL, 0);
Fix noreturn in main() ISO C requires 'main' falling through the end without explicit returns to implicitely return 0 (if declared as returning int).
2018-11-04 05:17:20 +08:00
if (!(nocode_wanted & 0x20000000)
&& ((func_vt.t & VT_BTYPE) == VT_INT)
&& !strcmp (funcname, "main"))
{
nocode_wanted = 0;
vpushi(0);
gen_assign_cast(&func_vt);
gfunc_return(&func_vt);
}
tccgen: nocode_wanted alternatively tccgen.c: remove any 'nocode_wanted' checks, except in - greloca(), disables output elf symbols and relocs - get_reg(), will return just the first suitable reg) - save_regs(), will do nothing Some minor adjustments were made where nocode_wanted is set. xxx-gen.c: disable code output directly where it happens in functions: - g(), output disabled - gjmp(), will do nothing - gtst(), dto.
2016-12-19 00:23:33 +08:00
nocode_wanted = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(rsym);
gfunc_epilog();
cur_text_section->data_offset = ind;
Fix statement exprs returning a local label Like returned local variables also labels local to a statement expression can be returned, and so their symbols must not be immediately freed (though they need to be removed from the symbol table).
2017-07-11 04:25:11 +08:00
label_pop(&global_label_stack, NULL, 0);
Error out in case of variable name clash Error out when two local variable with same name are defined in the same scope. This fixes bug #15597 in savannah's BTS.
2012-10-26 01:40:04 +08:00
/* reset local stack */
Add gcc attribute cleanup support The major difficulty was to handle cleanup when a goto happen to do so, I've had a "ScopeTracker" struct. I can't use local_scope because that would not work with code like below as local_scope would be at the same level: { char * __attribute__ ((cleanup(clean_function))) str = "hej"; goto next; } { next: }
2018-12-20 17:55:22 +08:00
reset_local_scope();
Fix access-after-free with statement expressions The return value of statement expressions might refer to local symbols, so those can't be popped. The old error message always was just a band-aid, and since disabling it for pointer types it wasn't effective anyway. It also never considered that also the vtop->sym member might have referred to such symbols (see the testcase with the local static, that used to segfault). For fixing this (can be seen better with valgrind and SYM_DEBUG) simply leave local symbols of stmt exprs on the stack.
2016-08-15 11:09:31 +08:00
sym_pop(&local_stack, NULL, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* end of function */
/* patch symbol size */
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
elfsym(sym)->st_size = ind - func_ind;
tcc: re-enable correct option -r support Forgot about it. It allows to compile several sources (and other .o's) to one single .o file; tcc -r -o all.o f1.c f2.c f3.S o4.o ... Also: - option -fold-struct-init-code removed, no effect anymore - (tcc_)set_environment() moved to tcc.c - win32/lib/(win)crt1 minor fix & add dependency - debug line output for asm (tcc -c -g xxx.S) enabled - configure/Makefiles: x86-64 -> x86_64 changes - README: cleanup
2017-02-21 01:58:08 +08:00
tcc_debug_funcend(tcc_state, ind - func_ind);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* It's better to crash than to generate wrong code */
cur_text_section = NULL;
funcname = ""; /* for safety */
func_vt.t = VT_VOID; /* for safety */
Fix struct ret in variadic fct with ARM hardfloat The procedure calling standard for ARM architecture mandate the use of the base standard for variadic function. Therefore, hgen float aggregate must be returned via stack when greater than 4 bytes and via core registers else in case of variadic function. This patch improve gfunc_sret() to take into account whether the function is variadic or not and make use of gfunc_sret() return value to determine whether to pass a structure via stack in gfunc_prolog(). It also take advantage of knowing if a function is variadic or not move float result value from VFP register to core register in gfunc_epilog().
2014-01-06 22:27:39 +08:00
func_var = 0; /* for safety */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
ind = 0; /* for safety */
tccgen: nodata_wanted The existing variable 'nocode_wanted' is now used to control output of static data too. So... (nocode_wanted == 0) code and data (normal within functions) (nocode_wanted < 0) means: no code, but data (global or static data) (nocode_wanted > 0) means: no code and no data (code and data suppressed) (nocode_wanted & 0xC0000000) means: we're in declaration of static data Also: new option '-dT' to be used with -run tcc -dT -run file.c This will look in file.c for certain comment-boundaries: /*-* test-xxx: ...some description */ and then for each test below run it from memory. This way various features and error messages can be tested with one single file. See 96_nodata_wanted.c for an example. Also: tccgen.c: one more bitfield fix
2017-07-16 18:10:00 +08:00
nocode_wanted = 0x80000000;
tccpp: fix issues, add tests * fix some macro expansion issues * add some pp tests in tests/pp * improved tcc -E output for better diff'ability * remove -dD feature (quirky code, exotic feature, didn't work well) Based partially on ideas / researches from PipCet Some issues remain with VA_ARGS macros (if used in a rather tricky way). Also, to keep it simple, the pp doesn't automtically add any extra spaces to separate tokens which otherwise would form wrong tokens if re-read from tcc -E output (such as '+' '=') GCC does that, other compilers don't. * cleanups - #line 01 "file" / # 01 "file" processing - #pragma comment(lib,"foo") - tcc -E: forward some pragmas to output (pack, comment(lib)) - fix macro parameter list parsing mess from a3fc54345949535524d01319e1ca6378b7c2c201 a715d7143d9d17da17e67fec6af1c01409a71a31 (some coffee might help, next time ;) - introduce TOK_PPSTR - to have character constants as written in the file (similar to TOK_PPNUM) - allow '\' appear in macros - new functions begin/end_macro to: - fix switching macro levels during expansion - allow unget_tok to unget more than one tok - slight speedup by using bitflags in isidnum_table Also: - x86_64.c : fix decl after statements - i386-gen,c : fix a vstack leak with VLA on windows - configure/Makefile : build on windows (MSYS) was broken - tcc_warning: fflush stderr to keep output order (win32)
2015-05-09 20:29:39 +08:00
check_vstack();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccpp_new/delete and other cleanups
2016-10-18 05:24:01 +08:00
static void gen_inline_functions(TCCState *s)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
Sym *sym;
tccpp: fix issues, add tests * fix some macro expansion issues * add some pp tests in tests/pp * improved tcc -E output for better diff'ability * remove -dD feature (quirky code, exotic feature, didn't work well) Based partially on ideas / researches from PipCet Some issues remain with VA_ARGS macros (if used in a rather tricky way). Also, to keep it simple, the pp doesn't automtically add any extra spaces to separate tokens which otherwise would form wrong tokens if re-read from tcc -E output (such as '+' '=') GCC does that, other compilers don't. * cleanups - #line 01 "file" / # 01 "file" processing - #pragma comment(lib,"foo") - tcc -E: forward some pragmas to output (pack, comment(lib)) - fix macro parameter list parsing mess from a3fc54345949535524d01319e1ca6378b7c2c201 a715d7143d9d17da17e67fec6af1c01409a71a31 (some coffee might help, next time ;) - introduce TOK_PPSTR - to have character constants as written in the file (similar to TOK_PPNUM) - allow '\' appear in macros - new functions begin/end_macro to: - fix switching macro levels during expansion - allow unget_tok to unget more than one tok - slight speedup by using bitflags in isidnum_table Also: - x86_64.c : fix decl after statements - i386-gen,c : fix a vstack leak with VLA on windows - configure/Makefile : build on windows (MSYS) was broken - tcc_warning: fflush stderr to keep output order (win32)
2015-05-09 20:29:39 +08:00
int inline_generated, i, ln;
cleanup: stop abuse of sym->r for inline functions
2009-06-30 03:14:53 +08:00
struct InlineFunc *fn;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
tccpp: fix issues, add tests * fix some macro expansion issues * add some pp tests in tests/pp * improved tcc -E output for better diff'ability * remove -dD feature (quirky code, exotic feature, didn't work well) Based partially on ideas / researches from PipCet Some issues remain with VA_ARGS macros (if used in a rather tricky way). Also, to keep it simple, the pp doesn't automtically add any extra spaces to separate tokens which otherwise would form wrong tokens if re-read from tcc -E output (such as '+' '=') GCC does that, other compilers don't. * cleanups - #line 01 "file" / # 01 "file" processing - #pragma comment(lib,"foo") - tcc -E: forward some pragmas to output (pack, comment(lib)) - fix macro parameter list parsing mess from a3fc54345949535524d01319e1ca6378b7c2c201 a715d7143d9d17da17e67fec6af1c01409a71a31 (some coffee might help, next time ;) - introduce TOK_PPSTR - to have character constants as written in the file (similar to TOK_PPNUM) - allow '\' appear in macros - new functions begin/end_macro to: - fix switching macro levels during expansion - allow unget_tok to unget more than one tok - slight speedup by using bitflags in isidnum_table Also: - x86_64.c : fix decl after statements - i386-gen,c : fix a vstack leak with VLA on windows - configure/Makefile : build on windows (MSYS) was broken - tcc_warning: fflush stderr to keep output order (win32)
2015-05-09 20:29:39 +08:00
ln = file->line_num;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* iterate while inline function are referenced */
Fix function types various cases of function type uses were broken by recent attribute refactoring, this fixes and adds testcases for them.
2017-07-14 23:42:48 +08:00
do {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
inline_generated = 0;
tccpp_new/delete and other cleanups
2016-10-18 05:24:01 +08:00
for (i = 0; i < s->nb_inline_fns; ++i) {
fn = s->inline_fns[i];
cleanup: stop abuse of sym->r for inline functions
2009-06-30 03:14:53 +08:00
sym = fn->sym;
Don't emit unreferenced static inlines there's no need to emit unreferenced static function, even if they are forced.
2019-06-18 01:28:51 +08:00
if (sym && (sym->c || !(sym->type.t & (VT_INLINE | VT_STATIC)) )) {
/* the function was used or forced (and then not internal):
generate its code and convert it to a normal function */
cleanup: stop abuse of sym->r for inline functions
2009-06-30 03:14:53 +08:00
fn->sym = NULL;
if (file)
safety: replace occurrences of strcpy by pstrcpy
2013-01-31 18:29:45 +08:00
pstrcpy(file->filename, sizeof file->filename, fn->filename);
tccgen: inline_functions double free fix Fix double free of the inline function token_string which could happen when an error/longjmp occurred while compiling the inline function.
2016-11-12 01:29:45 +08:00
begin_macro(fn->func_str, 1);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
cur_text_section = text_section;
gen_function(sym);
tccpp: fix issues, add tests * fix some macro expansion issues * add some pp tests in tests/pp * improved tcc -E output for better diff'ability * remove -dD feature (quirky code, exotic feature, didn't work well) Based partially on ideas / researches from PipCet Some issues remain with VA_ARGS macros (if used in a rather tricky way). Also, to keep it simple, the pp doesn't automtically add any extra spaces to separate tokens which otherwise would form wrong tokens if re-read from tcc -E output (such as '+' '=') GCC does that, other compilers don't. * cleanups - #line 01 "file" / # 01 "file" processing - #pragma comment(lib,"foo") - tcc -E: forward some pragmas to output (pack, comment(lib)) - fix macro parameter list parsing mess from a3fc54345949535524d01319e1ca6378b7c2c201 a715d7143d9d17da17e67fec6af1c01409a71a31 (some coffee might help, next time ;) - introduce TOK_PPSTR - to have character constants as written in the file (similar to TOK_PPNUM) - allow '\' appear in macros - new functions begin/end_macro to: - fix switching macro levels during expansion - allow unget_tok to unget more than one tok - slight speedup by using bitflags in isidnum_table Also: - x86_64.c : fix decl after statements - i386-gen,c : fix a vstack leak with VLA on windows - configure/Makefile : build on windows (MSYS) was broken - tcc_warning: fflush stderr to keep output order (win32)
2015-05-09 20:29:39 +08:00
end_macro();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
inline_generated = 1;
}
}
Fix function types various cases of function type uses were broken by recent attribute refactoring, this fixes and adds testcases for them.
2017-07-14 23:42:48 +08:00
} while (inline_generated);
tccpp: fix issues, add tests * fix some macro expansion issues * add some pp tests in tests/pp * improved tcc -E output for better diff'ability * remove -dD feature (quirky code, exotic feature, didn't work well) Based partially on ideas / researches from PipCet Some issues remain with VA_ARGS macros (if used in a rather tricky way). Also, to keep it simple, the pp doesn't automtically add any extra spaces to separate tokens which otherwise would form wrong tokens if re-read from tcc -E output (such as '+' '=') GCC does that, other compilers don't. * cleanups - #line 01 "file" / # 01 "file" processing - #pragma comment(lib,"foo") - tcc -E: forward some pragmas to output (pack, comment(lib)) - fix macro parameter list parsing mess from a3fc54345949535524d01319e1ca6378b7c2c201 a715d7143d9d17da17e67fec6af1c01409a71a31 (some coffee might help, next time ;) - introduce TOK_PPSTR - to have character constants as written in the file (similar to TOK_PPNUM) - allow '\' appear in macros - new functions begin/end_macro to: - fix switching macro levels during expansion - allow unget_tok to unget more than one tok - slight speedup by using bitflags in isidnum_table Also: - x86_64.c : fix decl after statements - i386-gen,c : fix a vstack leak with VLA on windows - configure/Makefile : build on windows (MSYS) was broken - tcc_warning: fflush stderr to keep output order (win32)
2015-05-09 20:29:39 +08:00
file->line_num = ln;
tccpp_new/delete and other cleanups
2016-10-18 05:24:01 +08:00
}
ST_FUNC void free_inline_functions(TCCState *s)
{
int i;
tccpp: fix issues, add tests * fix some macro expansion issues * add some pp tests in tests/pp * improved tcc -E output for better diff'ability * remove -dD feature (quirky code, exotic feature, didn't work well) Based partially on ideas / researches from PipCet Some issues remain with VA_ARGS macros (if used in a rather tricky way). Also, to keep it simple, the pp doesn't automtically add any extra spaces to separate tokens which otherwise would form wrong tokens if re-read from tcc -E output (such as '+' '=') GCC does that, other compilers don't. * cleanups - #line 01 "file" / # 01 "file" processing - #pragma comment(lib,"foo") - tcc -E: forward some pragmas to output (pack, comment(lib)) - fix macro parameter list parsing mess from a3fc54345949535524d01319e1ca6378b7c2c201 a715d7143d9d17da17e67fec6af1c01409a71a31 (some coffee might help, next time ;) - introduce TOK_PPSTR - to have character constants as written in the file (similar to TOK_PPNUM) - allow '\' appear in macros - new functions begin/end_macro to: - fix switching macro levels during expansion - allow unget_tok to unget more than one tok - slight speedup by using bitflags in isidnum_table Also: - x86_64.c : fix decl after statements - i386-gen,c : fix a vstack leak with VLA on windows - configure/Makefile : build on windows (MSYS) was broken - tcc_warning: fflush stderr to keep output order (win32)
2015-05-09 20:29:39 +08:00
/* free tokens of unused inline functions */
tccpp_new/delete and other cleanups
2016-10-18 05:24:01 +08:00
for (i = 0; i < s->nb_inline_fns; ++i) {
struct InlineFunc *fn = s->inline_fns[i];
tccgen: fix inline_functions double free fix
2016-11-12 03:25:13 +08:00
if (fn->sym)
tok_str_free(fn->func_str);
tccgen: free inline functions correctly
2009-07-14 10:46:35 +08:00
}
tccpp_new/delete and other cleanups
2016-10-18 05:24:01 +08:00
dynarray_reset(&s->inline_fns, &s->nb_inline_fns);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
/* 'l' is VT_LOCAL or VT_CONST to define default storage type, or VT_CMP
if parsing old style parameter decl list (and FUNC_SYM is set then) */
static int decl0(int l, int is_for_loop_init, Sym *func_sym)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
int v, has_init, r;
CType type, btype;
Sym *sym;
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
AttributeDef ad, adbase;
Error out in case of variable name clash Error out when two local variable with same name are defined in the same scope. This fixes bug #15597 in savannah's BTS.
2012-10-26 01:40:04 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
while (1) {
add C11 _Static_assert support
2019-04-28 07:07:01 +08:00
if (tok == TOK_STATIC_ASSERT) {
int c;
next();
skip('(');
c = expr_const();
skip(',');
if (c == 0)
tcc_error("%s", get_tok_str(tok, &tokc));
next();
skip(')');
_Static_assert must be followed by semicolon as per the C11 grammar.
2019-05-03 06:22:35 +08:00
skip(';');
add C11 _Static_assert support
2019-04-28 07:07:01 +08:00
continue;
}
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
if (!parse_btype(&btype, &adbase)) {
support c99 for-loop init decls (2nd attempt)
2011-03-09 05:36:04 +08:00
if (is_for_loop_init)
return 0;
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
/* skip redundant ';' if not in old parameter decl scope */
if (tok == ';' && l != VT_CMP) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
continue;
}
various stuff win32/Makefile ("for cygwin") removed - On cygwin, the normal ./configure && make can be used with either cygwin's "GCC for Win32 Toolchain" ./configure --cross-prefix=i686-w64-mingw32- or with an existing tcc: ./configure --cc=<old-tccdir>/tcc.exe tcctest.c: - exclude test_high_clobbers() on _WIN64 (does not work) tests2/95_bitfield.c: - use 'signed char' for ARM (where default 'char' is unsigned) tests: - remove -I "expr" diff option to allow tests with busybox-diff. libtcc.c, tcc.c: - removed -iwithprefix option. It is supposed to be combined with -iprefix which we don't have either. tccgen.c: - fix assignments and return of 'void', as in void f() { void *p, *q; *p = *q: return *p; } This appears to be allowed but should do nothing. tcc.h, libtcc.c, tccpp.c: - Revert "Introduce VIP sysinclude paths which are always searched first" This reverts commit 1d5e386b0a78393ac6b670c209a185849ec798a1. The patch was giving tcc's system includes priority over -I which is not how it should be. tccelf.c: - add DT_TEXTREL tag only if text relocations are actually used (which is likely not the case on x86_64) - prepare_dynamic_rel(): avoid relocation of unresolved (weak) symbols tccrun.c: - for HAVE_SELINUX, use two mappings to the same (real) file. (it was so once except the RX mapping wasn't used at all). tccpe.c: - fix relocation constant used for x86_64 (by Andrei E. Warentin) - #ifndef _WIN32 do "chmod 755 ..." to get runnable exes on cygwin. tccasm.c: - keep forward asm labels static, otherwise they will endup in dynsym eventually. configure, Makefile: - mingw32: respect ./configure options --bindir --docdir --libdir - allow overriding tcc when building libtcc1.a and libtcc.def with make XTCC=<tcc program to use> - use $(wildcard ...) for install to allow installing just a cross compiler for example make cross-arm make install - use name <target>-libtcc1.a build-tcc.bat: - add options: -clean, -b bindir
2017-10-12 00:13:43 +08:00
if (l != VT_CONST)
break;
if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* global asm block */
asm_global_instr();
continue;
}
various stuff win32/Makefile ("for cygwin") removed - On cygwin, the normal ./configure && make can be used with either cygwin's "GCC for Win32 Toolchain" ./configure --cross-prefix=i686-w64-mingw32- or with an existing tcc: ./configure --cc=<old-tccdir>/tcc.exe tcctest.c: - exclude test_high_clobbers() on _WIN64 (does not work) tests2/95_bitfield.c: - use 'signed char' for ARM (where default 'char' is unsigned) tests: - remove -I "expr" diff option to allow tests with busybox-diff. libtcc.c, tcc.c: - removed -iwithprefix option. It is supposed to be combined with -iprefix which we don't have either. tccgen.c: - fix assignments and return of 'void', as in void f() { void *p, *q; *p = *q: return *p; } This appears to be allowed but should do nothing. tcc.h, libtcc.c, tccpp.c: - Revert "Introduce VIP sysinclude paths which are always searched first" This reverts commit 1d5e386b0a78393ac6b670c209a185849ec798a1. The patch was giving tcc's system includes priority over -I which is not how it should be. tccelf.c: - add DT_TEXTREL tag only if text relocations are actually used (which is likely not the case on x86_64) - prepare_dynamic_rel(): avoid relocation of unresolved (weak) symbols tccrun.c: - for HAVE_SELINUX, use two mappings to the same (real) file. (it was so once except the RX mapping wasn't used at all). tccpe.c: - fix relocation constant used for x86_64 (by Andrei E. Warentin) - #ifndef _WIN32 do "chmod 755 ..." to get runnable exes on cygwin. tccasm.c: - keep forward asm labels static, otherwise they will endup in dynsym eventually. configure, Makefile: - mingw32: respect ./configure options --bindir --docdir --libdir - allow overriding tcc when building libtcc1.a and libtcc.def with make XTCC=<tcc program to use> - use $(wildcard ...) for install to allow installing just a cross compiler for example make cross-arm make install - use name <target>-libtcc1.a build-tcc.bat: - add options: -clean, -b bindir
2017-10-12 00:13:43 +08:00
if (tok >= TOK_UIDENT) {
/* special test for old K&R protos without explicit int
type. Only accepted when defining global data */
btype.t = VT_INT;
} else {
if (tok != TOK_EOF)
expect("declaration");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
break;
various stuff win32/Makefile ("for cygwin") removed - On cygwin, the normal ./configure && make can be used with either cygwin's "GCC for Win32 Toolchain" ./configure --cross-prefix=i686-w64-mingw32- or with an existing tcc: ./configure --cc=<old-tccdir>/tcc.exe tcctest.c: - exclude test_high_clobbers() on _WIN64 (does not work) tests2/95_bitfield.c: - use 'signed char' for ARM (where default 'char' is unsigned) tests: - remove -I "expr" diff option to allow tests with busybox-diff. libtcc.c, tcc.c: - removed -iwithprefix option. It is supposed to be combined with -iprefix which we don't have either. tccgen.c: - fix assignments and return of 'void', as in void f() { void *p, *q; *p = *q: return *p; } This appears to be allowed but should do nothing. tcc.h, libtcc.c, tccpp.c: - Revert "Introduce VIP sysinclude paths which are always searched first" This reverts commit 1d5e386b0a78393ac6b670c209a185849ec798a1. The patch was giving tcc's system includes priority over -I which is not how it should be. tccelf.c: - add DT_TEXTREL tag only if text relocations are actually used (which is likely not the case on x86_64) - prepare_dynamic_rel(): avoid relocation of unresolved (weak) symbols tccrun.c: - for HAVE_SELINUX, use two mappings to the same (real) file. (it was so once except the RX mapping wasn't used at all). tccpe.c: - fix relocation constant used for x86_64 (by Andrei E. Warentin) - #ifndef _WIN32 do "chmod 755 ..." to get runnable exes on cygwin. tccasm.c: - keep forward asm labels static, otherwise they will endup in dynsym eventually. configure, Makefile: - mingw32: respect ./configure options --bindir --docdir --libdir - allow overriding tcc when building libtcc1.a and libtcc.def with make XTCC=<tcc program to use> - use $(wildcard ...) for install to allow installing just a cross compiler for example make cross-arm make install - use name <target>-libtcc1.a build-tcc.bat: - add options: -clean, -b bindir
2017-10-12 00:13:43 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
if (tok == ';') {
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
if ((btype.t & VT_BTYPE) == VT_STRUCT) {
int v = btype.ref->v;
if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) >= SYM_FIRST_ANOM)
tcc_warning("unnamed struct/union that defines no instances");
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
next();
continue;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
}
refactor enums Eliminate VT_ENUM as a basic type. Instead use the integral types VT_InT/VT_LLONG with an additional flag to indicate that it is an enum.
2017-07-09 18:38:25 +08:00
if (IS_ENUM(btype.t)) {
next();
continue;
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
while (1) { /* iterate thru each declaration */
type = btype;
Fix parsing array typedefs of unknown size This must compile: typedef int arrtype1[]; arrtype1 sinit19 = {1}; arrtype1 sinit20 = {2,3}; and generate two arrays of one resp. two elements. Before the fix the determined size of the first array was encoded in the type directly, so sinit20 couldn't be parsed anymore (because arrtype1 was thought to be only one element long).
2016-07-13 23:39:15 +08:00
/* If the base type itself was an array type of unspecified
size (like in 'typedef int arr[]; arr x = {1};') then
we will overwrite the unknown size by the real one for
this decl. We need to unshare the ref symbol holding
that size. */
if ((type.t & VT_ARRAY) && type.ref->c < 0) {
type.ref = sym_push(SYM_FIELD, &type.ref->type, 0, type.ref->c);
}
Tidy new support for cleanups encode most things in Syms, do only as much work as necessary (e.g. pending cleanups), don't track scopes in a large structure (instead encode the scopes with cleanups directly in the cleanups tree). Removes ca. 120 lines of code.
2019-01-28 08:21:38 +08:00
ad = adbase;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
type_decl(&type, &ad, &v, TYPE_DIRECT);
#if 0
{
char buf[500];
Reorganize type parsing Various corner cases for declarator parsing were incorrect. This reorganizes and fixes it, and somewhat simplifies it as well.
2017-03-06 10:25:33 +08:00
type_to_str(buf, sizeof(buf), &type, get_tok_str(v, NULL));
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
printf("type = '%s'\n", buf);
}
#endif
if ((type.t & VT_BTYPE) == VT_FUNC) {
Fix incorrect use of basic type as bitflags. Fix incorrect use of basic types as bitflags and inefficiency in commit cf36410e30b3c18be6c556158b2d0d0938f5b77d
2011-02-08 06:46:20 +08:00
if ((type.t & VT_STATIC) && (l == VT_LOCAL)) {
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("function without file scope cannot be static");
Fix incorrect use of basic type as bitflags. Fix incorrect use of basic types as bitflags and inefficiency in commit cf36410e30b3c18be6c556158b2d0d0938f5b77d
2011-02-08 06:46:20 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* if old style function prototype, we accept a
declaration list */
sym = type.ref;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (sym->f.func_type == FUNC_OLD && l == VT_CONST)
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
decl0(VT_CMP, 0, sym);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
handle post-asm-label attributes on variables
2011-03-03 16:55:02 +08:00
if (gnu_ext && (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) {
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
ad.asm_label = asm_label_instr();
handle post-asm-label attributes on variables
2011-03-03 16:55:02 +08:00
/* parse one last attribute list, after asm label */
parse_attribute(&ad);
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
if (tok == '{')
expect(";");
handle post-asm-label attributes on variables
2011-03-03 16:55:02 +08:00
}
tccpe: improve dllimport/export and use for tcc_add_symbol
2010-01-15 03:55:51 +08:00
#ifdef TCC_TARGET_PE
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (ad.a.dllimport || ad.a.dllexport) {
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
if (type.t & (VT_STATIC|VT_TYPEDEF))
tcc_error("cannot have dll linkage with static or typedef");
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (ad.a.dllimport) {
if ((type.t & VT_BTYPE) == VT_FUNC)
ad.a.dllimport = 0;
else
type.t |= VT_EXTERN;
}
tccgen/win32: let __declspec(dllimport) imply extern Also, retain storage qualifiers in type_decl, in particular also for function pointers. This allows to get rid of this very early hack in decl() type.t |= (btype.t & VT_STATIC); /* Retain "static". */ which was to fix the case of int main() { static int (*foo)(); ... Also: - missing __declspec(dllimport) is an error now - except if the symbol is "_imp__symbol" - demonstrate export/import of data in the dll example (while 'extern' isn't strictly required with dllimport anymore) - new function 'patch_storage()' replaces 'weaken_symbol()' and 'apply_visibility()' - new function 'update_storage()' applies storage attributes to Elf symbols. - put_extern_sym/2 accepts new pseudo section SECTION_COMMON - add -Wl,-export-all-symbols as alias for -rdynamic - add -Wl,-subsystem=windows for mingw compatibility - redefinition of 'sym' error for initialized global data
2017-04-04 14:34:52 +08:00
}
tccpe: improve dllimport/export and use for tcc_add_symbol
2010-01-15 03:55:51 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok == '{') {
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
if (l != VT_CONST)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("cannot use local functions");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if ((type.t & VT_BTYPE) != VT_FUNC)
expect("function definition");
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
/* reject abstract declarators in function definition
standard conformant inline functions - add tests for standard conformant inline functions - implement it The old tinycc failed to provide a conforming implementation of non-static inlines. It would expose external symbols where it shouldn't and hide them where it should expose them. This commit provides a hopefully comprehensive test suite for how things should be done. The .expect file can be obtained by compiling the example c file (embedded in the test) with a conforming compiler such as gcc, clang or icc and then printing the exported symbols (e.g., with nm+awk+sort). (The implementation currently reserves two new VT_ flags. If anyone can provide an implementation without reserving two extra flags, please replace mine.)
2019-06-11 21:28:42 +08:00
make old style params without decl have int type */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
sym = type.ref;
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
while ((sym = sym->next) != NULL) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (!(sym->v & ~SYM_FIELD))
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
expect("identifier");
standard conformant inline functions - add tests for standard conformant inline functions - implement it The old tinycc failed to provide a conforming implementation of non-static inlines. It would expose external symbols where it shouldn't and hide them where it should expose them. This commit provides a hopefully comprehensive test suite for how things should be done. The .expect file can be obtained by compiling the example c file (embedded in the test) with a conforming compiler such as gcc, clang or icc and then printing the exported symbols (e.g., with nm+awk+sort). (The implementation currently reserves two new VT_ flags. If anyone can provide an implementation without reserving two extra flags, please replace mine.)
2019-06-11 21:28:42 +08:00
if (sym->type.t == VT_VOID)
sym->type = int_type;
}
fixes & cleanups - tccgen.c/tcc.h: allow function declaration after use: int f() { return g(); } int g() { return 1; } may be a warning but not an error see also 76cb1144ef91924c53c57ea71e6f67ce73ce1cc6 - tccgen.c: redundant code related to inline functions removed (functions used anywhere have sym->c set automatically) - tccgen.c: make 32bit llop non-equal test portable (probably not on C67) - dynarray_add: change prototype to possibly avoid aliasing problems or at least warnings - lib/alloca*.S: ".section .note.GNU-stack,"",%progbits" removed (has no effect) - tccpe: set SizeOfCode field (for correct upx decompression) - libtcc.c: fixed alternative -run invocation tcc "-run -lxxx ..." file.c (meant to load the library after file). Also supported now: tcc files ... options ... -run @ arguments ...
2017-02-14 01:23:43 +08:00
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
/* put function symbol */
Tidy some code the real difference is in decl0 where we can use external_sym just fine also for function definitions, we don't have to use external_global_sym. Setting VT_EXTERN in external_sym isn't necessary either (the type will have it set if necessary). The rest is tidying: removing unused arguments and moving some code around.
2019-04-18 09:36:39 +08:00
sym = external_sym(v, &type, 0, &ad);
Make mingw work again my last inline changes caused parameter names to be overwritten always (as VT_EXTERN now doesn't mark the current def anymore), leading to a compile error when including windows.h. Rework this. Also silence a warning that currently happens for mingw, which is written with gnu-inline behaviour in mind. Our work-arounds of using "static inline" actually create invalid C (which we warn about). Until we implement this properly, just silence the warning.
2019-06-18 00:28:56 +08:00
/* This is the def, so overwrite any other parameter names
we got from prototypes. */
sym->type.ref = type.ref;
TLC for C99 inline implementation there's no need for two new flags in type.t . We just can't use VT_EXTERN as marker if functions are defined or not (like we can for objects), and then can simply implement the rules of C99/C11 by not overwriting VT_STATIC/VT_EXTERN at all but rather only look at them. A function already on the inline list can be forced by removing the VT_INLINE flag, and then linkage follows from some combination of VT_STATIC, VT_EXTERN and VT_INLINE.
2019-06-17 09:34:03 +08:00
if (sym->c && elfsym(sym)->st_shndx != SHN_UNDEF
&& !(elfsym(sym)->st_other & ST_ASM_SET))
tcc_error("redefinition of '%s'", get_tok_str(sym->v, NULL));
fixes & cleanups - tccgen.c/tcc.h: allow function declaration after use: int f() { return g(); } int g() { return 1; } may be a warning but not an error see also 76cb1144ef91924c53c57ea71e6f67ce73ce1cc6 - tccgen.c: redundant code related to inline functions removed (functions used anywhere have sym->c set automatically) - tccgen.c: make 32bit llop non-equal test portable (probably not on C67) - dynarray_add: change prototype to possibly avoid aliasing problems or at least warnings - lib/alloca*.S: ".section .note.GNU-stack,"",%progbits" removed (has no effect) - tccpe: set SizeOfCode field (for correct upx decompression) - libtcc.c: fixed alternative -run invocation tcc "-run -lxxx ..." file.c (meant to load the library after file). Also supported now: tcc files ... options ... -run @ arguments ...
2017-02-14 01:23:43 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* static inline functions are just recorded as a kind
of macro. Their code will be emitted at the end of
the compilation unit only if they are used */
TLC for C99 inline implementation there's no need for two new flags in type.t . We just can't use VT_EXTERN as marker if functions are defined or not (like we can for objects), and then can simply implement the rules of C99/C11 by not overwriting VT_STATIC/VT_EXTERN at all but rather only look at them. A function already on the inline list can be forced by removing the VT_INLINE flag, and then linkage follows from some combination of VT_STATIC, VT_EXTERN and VT_INLINE.
2019-06-17 09:34:03 +08:00
if ((sym->type.t & (VT_INLINE | VT_EXTERN)) == VT_INLINE) {
cleanup: stop abuse of sym->r for inline functions
2009-06-30 03:14:53 +08:00
struct InlineFunc *fn;
const char *filename;
Revert all of my changes to directories & codingstyle.
2015-07-30 04:53:57 +08:00
tccpp: fix issues, add tests * fix some macro expansion issues * add some pp tests in tests/pp * improved tcc -E output for better diff'ability * remove -dD feature (quirky code, exotic feature, didn't work well) Based partially on ideas / researches from PipCet Some issues remain with VA_ARGS macros (if used in a rather tricky way). Also, to keep it simple, the pp doesn't automtically add any extra spaces to separate tokens which otherwise would form wrong tokens if re-read from tcc -E output (such as '+' '=') GCC does that, other compilers don't. * cleanups - #line 01 "file" / # 01 "file" processing - #pragma comment(lib,"foo") - tcc -E: forward some pragmas to output (pack, comment(lib)) - fix macro parameter list parsing mess from a3fc54345949535524d01319e1ca6378b7c2c201 a715d7143d9d17da17e67fec6af1c01409a71a31 (some coffee might help, next time ;) - introduce TOK_PPSTR - to have character constants as written in the file (similar to TOK_PPNUM) - allow '\' appear in macros - new functions begin/end_macro to: - fix switching macro levels during expansion - allow unget_tok to unget more than one tok - slight speedup by using bitflags in isidnum_table Also: - x86_64.c : fix decl after statements - i386-gen,c : fix a vstack leak with VLA on windows - configure/Makefile : build on windows (MSYS) was broken - tcc_warning: fflush stderr to keep output order (win32)
2015-05-09 20:29:39 +08:00
filename = file ? file->filename : "";
fn = tcc_malloc(sizeof *fn + strlen(filename));
strcpy(fn->filename, filename);
fn->sym = sym;
Factor some code Three places that skip (and store) tokens in some fashion can be factored a bit.
2017-03-07 04:43:48 +08:00
skip_or_save_block(&fn->func_str);
dynarray_add(&tcc_state->inline_fns,
&tcc_state->nb_inline_fns, fn);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
/* compute text section */
cur_text_section = ad.section;
if (!cur_text_section)
cur_text_section = text_section;
gen_function(sym);
}
break;
} else {
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
if (l == VT_CMP) {
/* find parameter in function parameter list */
for (sym = func_sym->next; sym; sym = sym->next)
if ((sym->v & ~SYM_FIELD) == v)
goto found;
tcc_error("declaration for parameter '%s' but no such parameter",
get_tok_str(v, NULL));
found:
if (type.t & VT_STORAGE) /* 'register' is okay */
tcc_error("storage class specified for '%s'",
get_tok_str(v, NULL));
if (sym->type.t != VT_VOID)
tcc_error("redefinition of parameter '%s'",
get_tok_str(v, NULL));
convert_parameter_type(&type);
sym->type = type;
} else if (type.t & VT_TYPEDEF) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* save typedefed type */
/* XXX: test storage specifiers ? */
tccgen: scopes levels for local symbols (update 2) allow typedef int xxx; typedef int xxx; in the same scope as long as it is the same type
2016-05-06 14:32:54 +08:00
sym = sym_find(v);
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
if (sym && sym->sym_scope == local_scope) {
tccgen: scopes levels for local symbols (update 2) allow typedef int xxx; typedef int xxx; in the same scope as long as it is the same type
2016-05-06 14:32:54 +08:00
if (!is_compatible_types(&sym->type, &type)
|| !(sym->type.t & VT_TYPEDEF))
tcc_error("incompatible redefinition of '%s'",
get_tok_str(v, NULL));
sym->type = type;
} else {
sym = sym_push(v, &type, 0, 0);
}
be stricter with aliasing Refactoring (no logical changes): - use memcpy in tccgen.c:ieee_finite(double d) - use union to store attribute flags in Sym Makefile: "CFLAGS+=-fno-strict-aliasing" basically not necessary anymore but I left it for now because gcc sometimes behaves unexpectedly without. Also: - configure: back to mode 100755 - tcc.h: remove unused variables tdata/tbss_section - x86_64-gen.c: adjust gfunc_sret for prototype
2014-01-07 21:57:07 +08:00
sym->a = ad.a;
Fix function types various cases of function type uses were broken by recent attribute refactoring, this fixes and adds testcases for them.
2017-07-14 23:42:48 +08:00
sym->f = ad.f;
Check for void type in top-level decls give an error message from the parser on things like "void x;" instead of relying on codegen erroring out.
2018-08-04 04:39:00 +08:00
} else if ((type.t & VT_BTYPE) == VT_VOID
&& !(type.t & VT_EXTERN)) {
tcc_error("declaration of void object");
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
r = 0;
collapse branch in decl(), making way for next patch
2011-03-03 17:07:36 +08:00
if ((type.t & VT_BTYPE) == VT_FUNC) {
/* external function definition */
/* specific case for func_call attribute */
Fix function types various cases of function type uses were broken by recent attribute refactoring, this fixes and adds testcases for them.
2017-07-14 23:42:48 +08:00
type.ref->f = ad.f;
collapse branch in decl(), making way for next patch
2011-03-03 17:07:36 +08:00
} else if (!(type.t & VT_ARRAY)) {
/* not lvalue if array */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
r |= lvalue_type(type.t);
collapse branch in decl(), making way for next patch
2011-03-03 17:07:36 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
has_init = (tok == '=');
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
if (has_init && (type.t & VT_VLA))
struct-init: Cleanup some more Some parameters aren't actually necessary. Also join the two parsing loops for the initializer list of arrays and structs.
2016-08-01 11:30:55 +08:00
tcc_error("variable length array cannot be initialized");
Accept extern initialized file-scope variables 'extern int i = 42;' at file scope (but not in function scope!) is allowed and is a proper definition, even though questionable style; some compilers warn about this.
2017-05-07 14:10:06 +08:00
if (((type.t & VT_EXTERN) && (!has_init || l != VT_CONST)) ||
((type.t & VT_BTYPE) == VT_FUNC) ||
VLA fix [2/3]: removed VT_ARRAY from VT_VLA types A VLA is not really an array, it's a pointer-to-an-array. Making this explicit allows us to back out a few parts of the original VLA patch and paves the way for the next part of the fix, where a VLA will be stored on the runtime stack as a pointer-to-an-array, rather than on the compile- time stack as a Sym*.
2011-04-08 16:09:39 +08:00
((type.t & VT_ARRAY) && (type.t & VT_STATIC) &&
!has_init && l == VT_CONST && type.ref->c < 0)) {
collapse branch in decl(), making way for next patch
2011-03-03 17:07:36 +08:00
/* external variable or function */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* NOTE: as GCC, uninitialized global static
arrays of null size are considered as
extern */
TLC for C99 inline implementation there's no need for two new flags in type.t . We just can't use VT_EXTERN as marker if functions are defined or not (like we can for objects), and then can simply implement the rules of C99/C11 by not overwriting VT_STATIC/VT_EXTERN at all but rather only look at them. A function already on the inline list can be forced by removing the VT_INLINE flag, and then linkage follows from some combination of VT_STATIC, VT_EXTERN and VT_INLINE.
2019-06-17 09:34:03 +08:00
if ((type.t & VT_BTYPE) != VT_FUNC)
type.t |= VT_EXTERN;
refactor sym & attributes tcc.h: * cleanup struct 'Sym' * include some 'Attributes' into 'Sym' * in turn get rid of VT_IM/EXPORT, VT_WEAK * re-number VT_XXX flags * replace some 'long' function args by 'int' tccgen.c: * refactor parse_btype()
2017-07-09 18:34:11 +08:00
sym = external_sym(v, &type, r, &ad);
tccgen: handle __attribute((alias("target")))
2011-03-03 17:58:45 +08:00
if (ad.alias_target) {
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
ElfSym *esym;
tccgen: handle __attribute((alias("target")))
2011-03-03 17:58:45 +08:00
Sym *alias_target;
alias_target = sym_find(ad.alias_target);
tccasm: Unify C and asm symbol table This makes the asm symbols use the same members as the C symbols for global decls, e.g. using the ELF symbol to hold offset and section. That allows us to use only one symbol table for C and asm symbols and to get rid of hacks to synch between them. We still need some special handling for symbols that come purely from asm sources.
2017-11-27 11:03:03 +08:00
esym = elfsym(alias_target);
if (!esym)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("unsupported forward __alias__ attribute");
tccasm: Fix local statics referenced from asms The assembler uses the ->sym_scope member to walk up the symbols until finding a non-automatic symbol. Since reordering the members of Sym the sym_scope member contains a scope even for local statics. Formerly the use of asm_label for statics was implicitely clearing sym_scope, now we have to do that explicitely. Add a testcase for that, and one I encountered when moving the clearing of sym_scope too deep into the call chain (into put_extern_sym).
2017-07-11 04:29:28 +08:00
/* Local statics have a scope until now (for
warnings), remove it here. */
sym->sym_scope = 0;
final update for 0.9.27 tccgen.c: - fix ldouble asm hack - fix a VLA problem on Win64 (also x86_64-gen.c) - patch_type(): make sure that no symbol ever changes from global to static tcc.c: - tcc -vv: print libtcc1.a path also on win32 tccpe.c, tcctools.c: - use unix LF mode to for .def output files (that is for creating reproducible output trees) Makefile: - suppress some warnings when makeinfo is missing - call 'which install' only on win32 tests/Makefile: - change PATH only on WINNT systems (i.e. not if cross-compiling on linux for win32) - asm-c-connect.test: slim output and do diff tccrun.c tccpe.c *-link.c: - integrate former 'pe_relocate_rva()' into normal relocation This also fixes linkage of the unwind data on WIN64 for -run (reported by Janus Lynggaard Thorborg) tccasm.c, tests/tcctest.c: - fix dot (sym_index of -1 crashed in put_elf_reloc) - massage .set a bit (see test) other: - #define SECTION_ABS removed - ST_DATA Section *strtab_section: removed - put_extern_sym2(): take int section number Conflicts: tccelf.c tccpe.c Conflicts: tccelf.c
2017-12-13 00:57:20 +08:00
put_extern_sym2(sym, esym->st_shndx, esym->st_value, esym->st_size, 0);
tccgen: handle __attribute((alias("target")))
2011-03-03 17:58:45 +08:00
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
if (type.t & VT_STATIC)
r |= VT_CONST;
else
r |= l;
if (has_init)
next();
TLC for C99 inline implementation there's no need for two new flags in type.t . We just can't use VT_EXTERN as marker if functions are defined or not (like we can for objects), and then can simply implement the rules of C99/C11 by not overwriting VT_STATIC/VT_EXTERN at all but rather only look at them. A function already on the inline list can be forced by removing the VT_INLINE flag, and then linkage follows from some combination of VT_STATIC, VT_EXTERN and VT_INLINE.
2019-06-17 09:34:03 +08:00
else if (l == VT_CONST
&& (type.t & VT_BTYPE) != VT_FUNC)
tccgen: unify type redefinition checks tccgen.c: - improved function patch_storage() and added new function patch_type() for more consistent type redefinition and instance redefinition checks.
2017-12-04 03:43:48 +08:00
/* uninitialized global variables may be overridden */
type.t |= VT_EXTERN;
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
decl_initializer_alloc(&type, &ad, r, has_init, v, l);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
if (tok != ',') {
tccgen: asm_label cleanup - avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute Also: fix some strange looking error messages
2015-11-20 18:22:56 +08:00
if (is_for_loop_init)
support c99 for-loop init decls (2nd attempt)
2011-03-09 05:36:04 +08:00
return 1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(';');
break;
}
next();
}
}
}
support c99 for-loop init decls (2nd attempt)
2011-03-09 05:36:04 +08:00
return 0;
}
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
static void decl(int l)
support c99 for-loop init decls (2nd attempt)
2011-03-09 05:36:04 +08:00
{
Merge func_decl_list into decl0 Removes some code duplication and also implements one feature: checking for duplicate decls for old style parameters.
2017-03-11 09:13:59 +08:00
decl0(l, 0, NULL);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
/* ------------------------------------------------------------------------- */
Reference in New Issue Copy Permalink