github-repos/tinycc
1
0
Fork 0
mirror of https://github.com/mirror/tinycc.git synced 2024-12-26 03:50:07 +08:00
Code Issues Packages Projects Releases Wiki Activity
2d17e5a6c4
tinycc/tccgen.c

7963 lines
230 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 libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +08:00
#define USING_GLOBALS
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"
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +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
/********************************************************/
/* 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 *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
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +08:00
static Sym *sym_free_first;
static void **sym_pools;
static int nb_sym_pools;
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
static Sym *all_cleanups, *pending_gotos;
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;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
static int in_generic;
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
-bench fix Put total_lines etc. into TCCState. Also, initialize the predefined compiler types for the preprocessor too. tccpe.c: fix BaseOfCode if .init section present (with tcc -b)
2019-12-14 19:31:03 +08:00
ST_DATA SValue *vtop;
static SValue _vstack[1 + VSTACK_SIZE];
#define vstack (_vstack + 1)
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 */
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
/* Automagical code suppression ----> */
#define CODE_OFF() (nocode_wanted |= 0x20000000)
#define CODE_ON() (nocode_wanted &= ~0x20000000)
/* Clear 'nocode_wanted' at label if it was used */
ST_FUNC void gsym(int t) { if (t) { gsym_addr(t, ind); CODE_ON(); }}
static int gind(void) { CODE_ON(); return ind; }
/* Set 'nocode_wanted' after unconditional jumps */
static void gjmp_addr_acs(int t) { gjmp_addr(t); CODE_OFF(); }
static int gjmp_acs(int t) { t = gjmp(t); CODE_OFF(); return t; }
/* These are #undef'd at the end of this file */
#define gjmp_addr gjmp_addr_acs
#define gjmp gjmp_acs
/* <---- */
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;
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
static int last_line_num, new_file, func_ind; /* debug info control */
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;
update gen_cast
2019-12-17 01:51:28 +08:00
ST_DATA CType int_type, func_old_type, char_pointer_type;
allow tcc be build from separate objects If you want that, run: make NOTALLINONE=1
2009-12-20 08:53:49 +08:00
update gen_cast
2019-12-17 01:51:28 +08:00
#if PTR_SIZE == 4
#define VT_SIZE_T (VT_INT | VT_UNSIGNED)
#define VT_PTRDIFF_T VT_INT
#elif LONG_SIZE == 4
#define VT_SIZE_T (VT_LLONG | VT_UNSIGNED)
#define VT_PTRDIFF_T VT_LLONG
#else
#define VT_SIZE_T (VT_LONG | VT_LLONG | VT_UNSIGNED)
#define VT_PTRDIFF_T (VT_LONG | VT_LLONG)
#endif
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 */
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
int *bsym;
struct scope *scope;
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; /* 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
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
static struct scope {
struct scope *prev;
struct { int loc, num; } vla;
struct { Sym *s; int n; } cl;
int *bsym, *csym;
Sym *lstk, *llstk;
} *cur_scope, *loop_scope, *root_scope;
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +08:00
/********************************************************/
#ifndef CONFIG_TCC_ASM
ST_FUNC void asm_instr(void)
{
tcc_error("inline asm() not supported");
}
ST_FUNC void asm_global_instr(void)
{
tcc_error("inline asm() not supported");
}
#endif
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);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
static void block(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);
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);
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +08:00
static void free_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();
update gen_cast
2019-12-17 01:51:28 +08:00
static void cast_error(CType *st, CType *dt);
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)
{
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
int bt = t & VT_BTYPE;
return bt == VT_LDOUBLE
|| bt == VT_DOUBLE
|| bt == VT_FLOAT
|| bt == VT_QFLOAT;
}
static inline int is_integer_btype(int bt)
{
return bt == VT_BYTE
update gen_cast
2019-12-17 01:51:28 +08:00
|| bt == VT_BOOL
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
|| bt == VT_SHORT
|| bt == VT_INT
|| bt == VT_LLONG;
}
static int btype_size(int bt)
{
return bt == VT_BYTE || bt == VT_BOOL ? 1 :
bt == VT_SHORT ? 2 :
bt == VT_INT ? 4 :
bt == VT_LLONG ? 8 :
bt == VT_PTR ? PTR_SIZE : 0;
}
/* returns function return register from type */
static int R_RET(int t)
{
if (!is_float(t))
return REG_IRET;
#ifdef TCC_TARGET_X86_64
if ((t & VT_BTYPE) == VT_LDOUBLE)
return TREG_ST0;
#elif defined TCC_TARGET_RISCV64
if ((t & VT_BTYPE) == VT_LDOUBLE)
return REG_IRET;
#endif
return REG_FRET;
}
/* returns 2nd function return register, if any */
static int R2_RET(int t)
{
t &= VT_BTYPE;
#if PTR_SIZE == 4
if (t == VT_LLONG)
return REG_IRE2;
#elif defined TCC_TARGET_X86_64
if (t == VT_QLONG)
return REG_IRE2;
if (t == VT_QFLOAT)
return REG_FRE2;
#elif defined TCC_TARGET_RISCV64
if (t == VT_LDOUBLE)
return REG_IRE2;
#endif
return VT_CONST;
}
/* returns true for two-word types */
#define USING_TWO_WORDS(t) (R2_RET(t) != VT_CONST)
/* put function return registers to stack value */
static void PUT_R_RET(SValue *sv, int t)
{
sv->r = R_RET(t), sv->r2 = R2_RET(t);
}
/* returns function return register class for type t */
static int RC_RET(int t)
{
return reg_classes[R_RET(t)] & ~(RC_FLOAT | RC_INT);
}
/* returns generic register class for type t */
static int RC_TYPE(int t)
{
if (!is_float(t))
return RC_INT;
#ifdef TCC_TARGET_X86_64
if ((t & VT_BTYPE) == VT_LDOUBLE)
return RC_ST0;
if ((t & VT_BTYPE) == VT_QFLOAT)
return RC_FRET;
#elif defined TCC_TARGET_RISCV64
if ((t & VT_BTYPE) == VT_LDOUBLE)
return RC_INT;
#endif
return RC_FLOAT;
}
/* returns 2nd register class corresponding to t and rc */
static int RC2_TYPE(int t, int rc)
{
if (!USING_TWO_WORDS(t))
return 0;
#ifdef RC_IRE2
if (rc == RC_IRET)
return RC_IRE2;
#endif
#ifdef RC_FRE2
if (rc == RC_FRET)
return RC_FRE2;
#endif
if (rc & RC_FLOAT)
return RC_FLOAT;
return RC_INT;
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)
{
-bench fix Put total_lines etc. into TCCState. Also, initialize the predefined compiler types for the preprocessor too. tccpe.c: fix BaseOfCode if .init section present (with tcc -b)
2019-12-14 19:31:03 +08:00
if (vtop != vstack - 1)
tcc_error("internal compiler error: vstack leak (%d)", vtop - vstack + 1);
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
}
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), "/");
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +08:00
put_stabs_r(s1, buf, N_SO, 0, 0,
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
text_section->data_offset, text_section, section_sym);
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +08:00
put_stabs_r(s1, file->prev->filename, N_SO, 0, 0,
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
text_section->data_offset, text_section, section_sym);
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
new_file = last_line_num = 0;
func_ind = -1;
/* we're currently 'including' the <command line> */
tcc_debug_bincl(s1);
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;
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +08:00
put_stabs_r(s1, NULL, N_SO, 0, 0,
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
text_section->data_offset, text_section, section_sym);
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +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
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
static BufferedFile* put_new_file(TCCState *s1)
{
BufferedFile *f = file;
/* use upper file if from inline ":asm:" */
if (f->filename[0] == ':')
f = f->prev;
if (f && new_file) {
put_stabs_r(s1, f->filename, N_SOL, 0, 0, ind, text_section, section_sym);
new_file = last_line_num = 0;
}
return f;
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
}
/* generate line number info */
ST_FUNC void tcc_debug_line(TCCState *s1)
{
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
BufferedFile *f;
if (!s1->do_debug || !(f = put_new_file(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
return;
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
if (last_line_num == f->line_num)
return;
if (text_section != cur_text_section)
return;
if (func_ind != -1) {
put_stabn(s1, N_SLINE, 0, f->line_num, ind - func_ind);
} else {
/* from tcc_assemble */
put_stabs_r(s1, NULL, N_SLINE, 0, f->line_num, ind, 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
}
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
last_line_num = f->line_num;
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 function symbol */
ST_FUNC void tcc_debug_funcstart(TCCState *s1, Sym *sym)
{
char buf[512];
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
BufferedFile *f;
if (!s1->do_debug || !(f = put_new_file(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
return;
/* XXX: we put here a dummy type */
snprintf(buf, sizeof(buf), "%s:%c1",
funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
put_stabs_r(s1, buf, N_FUN, 0, f->line_num, 0, cur_text_section, sym->c);
tcc_debug_line(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
}
/* put function size */
ST_FUNC void tcc_debug_funcend(TCCState *s1, int size)
{
if (!s1->do_debug)
return;
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
#if 0 // this seems to confuse gnu tools
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +08:00
put_stabn(s1, N_FUN, 0, 0, size);
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
#endif
}
/* put alternative filename */
ST_FUNC void tcc_debug_putfile(TCCState *s1, const char *filename)
{
if (0 == strcmp(file->filename, filename))
return;
pstrcpy(file->filename, sizeof(file->filename), filename);
new_file = 1;
}
/* begin of #include */
ST_FUNC void tcc_debug_bincl(TCCState *s1)
{
if (!s1->do_debug)
return;
put_stabs(s1, file->filename, N_BINCL, 0, 0, 0);
new_file = 1;
}
/* end of #include */
ST_FUNC void tcc_debug_eincl(TCCState *s1)
{
if (!s1->do_debug)
return;
put_stabn(s1, N_EINCL, 0, 0, 0);
new_file = 1;
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
}
/* ------------------------------------------------------------------------- */
-bench fix Put total_lines etc. into TCCState. Also, initialize the predefined compiler types for the preprocessor too. tccpe.c: fix BaseOfCode if .init section present (with tcc -b)
2019-12-14 19:31:03 +08:00
/* initialize vstack and types. This must be done also for tcc -E */
ST_FUNC void tccgen_init(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
{
-bench fix Put total_lines etc. into TCCState. Also, initialize the predefined compiler types for the preprocessor too. tccpe.c: fix BaseOfCode if .init section present (with tcc -b)
2019-12-14 19:31:03 +08:00
vtop = vstack - 1;
memset(vtop, 0, sizeof *vtop);
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);
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;
-bench fix Put total_lines etc. into TCCState. Also, initialize the predefined compiler types for the preprocessor too. tccpe.c: fix BaseOfCode if .init section present (with tcc -b)
2019-12-14 19:31:03 +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
-bench fix Put total_lines etc. into TCCState. Also, initialize the predefined compiler types for the preprocessor too. tccpe.c: fix BaseOfCode if .init section present (with tcc -b)
2019-12-14 19:31:03 +08:00
ST_FUNC int tccgen_compile(TCCState *s1)
{
cur_text_section = NULL;
funcname = "";
anon_sym = SYM_FIRST_ANOM;
section_sym = 0;
const_wanted = 0;
nocode_wanted = 0x80000000;
local_scope = 0;
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
-bench fix Put total_lines etc. into TCCState. Also, initialize the predefined compiler types for the preprocessor too. tccpe.c: fix BaseOfCode if .init section present (with tcc -b)
2019-12-14 19:31:03 +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
}
-bench fix Put total_lines etc. into TCCState. Also, initialize the predefined compiler types for the preprocessor too. tccpe.c: fix BaseOfCode if .init section present (with tcc -b)
2019-12-14 19:31:03 +08:00
ST_FUNC void tccgen_finish(TCCState *s1)
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +08:00
{
-bench fix Put total_lines etc. into TCCState. Also, initialize the predefined compiler types for the preprocessor too. tccpe.c: fix BaseOfCode if .init section present (with tcc -b)
2019-12-14 19:31:03 +08:00
free_inline_functions(s1);
sym_pop(&global_stack, NULL, 0);
sym_pop(&local_stack, NULL, 0);
/* free preprocessor macros */
free_defines(NULL);
/* free sym_pools */
dynarray_reset(&sym_pools, &nb_sym_pools);
sym_free_first = NULL;
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +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
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
if (sym->type.t & (VT_STATIC | 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:
Add new bounds checking functions. The following functions are now also bounds checked: memcmp, strncpy, strcmp, strncmp, strcat, strchr, strdup. Add statistics code for bounds checking functions. The statistics can be printed by settings environment variable "TCC_BOUNDS_PRINT_STATISTIC". Enabled more tests in test/Makefile.
2019-12-13 03:49:35 +08:00
case TOK_memcmp:
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
case TOK_strlen:
case TOK_strcpy:
Add new bounds checking functions. The following functions are now also bounds checked: memcmp, strncpy, strcmp, strncmp, strcat, strchr, strdup. Add statistics code for bounds checking functions. The statistics can be printed by settings environment variable "TCC_BOUNDS_PRINT_STATISTIC". Enabled more tests in test/Makefile.
2019-12-13 03:49:35 +08:00
case TOK_strncpy:
case TOK_strcmp:
case TOK_strncmp:
case TOK_strcat:
case TOK_strchr:
case TOK_strdup:
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
case TOK_alloca:
Fix bounds checking for linux/windows
2019-12-10 15:07:25 +08:00
case TOK_mmap:
case TOK_munmap:
tccgen/tccelf: move code from libtcc.c
2016-10-15 21:55:31 +08:00
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;
}
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
if (t & (VT_STATIC | 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
}
/* ------------------------------------------------------------------------- */
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
static void vcheck_cmp(void)
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
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
when code is unsuppressed again. */
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
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
if (vtop->r == VT_CMP && !nocode_wanted)
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
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
static void vsetc(CType *type, int r, CValue *vc)
{
if (vtop >= vstack + (VSTACK_SIZE - 1))
tcc_error("memory full (vstack)");
vcheck_cmp();
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;
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
vcheck_cmp();
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
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
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
if (v == VT_CMP) {
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
/* need to put correct jump if && or || without test */
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
gsym(vtop->jtrue);
gsym(vtop->jfalse);
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--;
}
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 */
update gen_cast
2019-12-17 01:51:28 +08:00
static 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
}
update gen_cast
2019-12-17 01:51:28 +08:00
/* push arbitrary 64bit constant */
static void vpush64(int ty, unsigned long long v)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
CValue cval;
update gen_cast
2019-12-17 01:51:28 +08:00
CType ctype;
ctype.t = ty;
ctype.ref = NULL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
cval.i = v;
update gen_cast
2019-12-17 01:51:28 +08:00
vsetc(&ctype, VT_CONST, &cval);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
update gen_cast
2019-12-17 01:51:28 +08:00
/* push integer constant */
ST_FUNC void vpushi(int 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
{
update gen_cast
2019-12-17 01:51:28 +08:00
vpush64(VT_INT, 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
}
update gen_cast
2019-12-17 01:51:28 +08:00
/* push a pointer sized constant */
static void vpushs(addr_t v)
Add nan, snan and inf float constants
2010-05-06 08:19:00 +08:00
{
update gen_cast
2019-12-17 01:51:28 +08:00
vpush64(VT_SIZE_T, v);
Add nan, snan and inf float constants
2010-05-06 08:19:00 +08:00
}
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;
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
vcheck_cmp();
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
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;
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
vcheck_cmp();
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
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);
}
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
/* ------------------------------------------------------------------------- */
/* vtop->r = VT_CMP means CPU-flags have been set from comparison or test. */
/* called from generators to set the result from relational ops */
ST_FUNC void vset_VT_CMP(int op)
{
vtop->r = VT_CMP;
vtop->cmp_op = op;
vtop->jfalse = 0;
vtop->jtrue = 0;
}
/* called once before asking generators to load VT_CMP to a register */
static void vset_VT_JMP(void)
{
int op = vtop->cmp_op;
if (vtop->jtrue || vtop->jfalse) {
/* we need to jump to 'mov $0,%R' or 'mov $1,%R' */
int inv = op & (op < 2); /* small optimization */
vseti(VT_JMP+inv, gvtst(inv, 0));
} else {
/* otherwise convert flags (rsp. 0/1) to register */
vtop->c.i = op;
if (op < 2) /* doesn't seem to happen */
vtop->r = VT_CONST;
}
}
/* Set CPU Flags, doesn't yet jump */
static void gvtst_set(int inv, int t)
{
int *p;
if (vtop->r != VT_CMP) {
vpushi(0);
gen_op(TOK_NE);
riscv: Add more ops and fixes * implement compares, gtst and gsym/gjmp and add * implement stores (simple cases) * fix arg passing with more than one register arg, fix loads to not always use 8byte loads * add some predefined macros: __riscv, __riscv_xlen, __SIZEOF_POINTER__ (needed by glibc header) The first 5 tests of tests2 run now.
2019-06-24 08:34:46 +08:00
if (vtop->r == VT_CMP) /* must be VT_CONST otherwise */
;
else if (vtop->r == VT_CONST)
vset_VT_CMP(vtop->c.i != 0);
else
tcc_error("ICE");
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
}
p = inv ? &vtop->jfalse : &vtop->jtrue;
*p = gjmp_append(*p, t);
}
/* Generate value test
*
* Generate a test for any value (jump, comparison and integers) */
static int gvtst(int inv, int t)
{
int op, u, x;
gvtst_set(inv, t);
t = vtop->jtrue, u = vtop->jfalse;
if (inv)
x = u, u = t, t = x;
op = vtop->cmp_op;
/* jump to the wanted target */
if (op > 1)
t = gjmp_cond(op ^ inv, t);
else if (op != inv)
t = gjmp(t);
/* resolve complementary jumps to here */
gsym(u);
vtop--;
return t;
}
update gen_cast
2019-12-17 01:51:28 +08:00
/* generate a zero or nozero test */
static void gen_test_zero(int op)
{
if (vtop->r == VT_CMP) {
int j;
if (op == TOK_EQ) {
j = vtop->jfalse;
vtop->jfalse = vtop->jtrue;
vtop->jtrue = j;
vtop->cmp_op ^= 1;
}
} else {
vpushi(0);
gen_op(op);
}
}
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
/* ------------------------------------------------------------------------- */
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)
{
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
if (!(type->t & VT_EXTERN) || IS_ENUM_VAL(sym->type.t)) {
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));
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
/* set 'inline' if both agree or if one has static */
if ((type->t | sym->type.t) & VT_INLINE) {
if (!((type->t ^ sym->type.t) & VT_INLINE)
|| ((type->t | sym->type.t) & VT_STATIC))
static_proto |= VT_INLINE;
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
}
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
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)) {
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
/* put complete type, use static from prototype */
sym->type.t = (type->t & ~(VT_STATIC|VT_INLINE)) | static_proto;
sym->type.ref = type->ref;
} else {
sym->type.t &= ~VT_INLINE | static_proto;
}
if (sym->type.ref->f.func_type == FUNC_OLD
&& type->ref->f.func_type != FUNC_OLD) {
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
}
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
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 */
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
sym->type.ref->c = type->ref->c;
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->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
}
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
/* copy sym to other stack */
static Sym *sym_copy(Sym *s0, Sym **ps)
{
Sym *s;
s = sym_malloc(), *s = *s0;
s->prev = *ps, *ps = s;
if (s->v < SYM_FIRST_ANOM) {
ps = &table_ident[s->v - TOK_IDENT]->sym_identifier;
s->prev_tok = *ps, *ps = s;
}
return s;
}
tccgen.c: local extern decls: copy s->ref for VT_PTR too This fixes the issue int main() { extern char *x; } void main1() { extern char *x; } t2.c:5: error: incompatible types for redefinition of 'x' (reported by Giovanni Mascellani 2019/07/16)
2019-07-16 23:30:04 +08:00
/* copy s->type.ref to stack 'ps' for VT_FUNC and VT_PTR */
static void sym_copy_ref(Sym *s, Sym **ps)
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
{
tccgen.c: local extern decls: copy s->ref for VT_PTR too This fixes the issue int main() { extern char *x; } void main1() { extern char *x; } t2.c:5: error: incompatible types for redefinition of 'x' (reported by Giovanni Mascellani 2019/07/16)
2019-07-16 23:30:04 +08:00
int bt = s->type.t & VT_BTYPE;
if (bt == VT_FUNC || bt == VT_PTR) {
Sym **sp = &s->type.ref;
for (s = *sp, *sp = NULL; s; s = s->next) {
Sym *s2 = sym_copy(s, ps);
sp = &(*sp = s2)->next;
sym_copy_ref(s2, ps);
}
}
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
}
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
{
tccgen.c: local extern decls: copy s->ref for VT_PTR too This fixes the issue int main() { extern char *x; } void main1() { extern char *x; } t2.c:5: error: incompatible types for redefinition of 'x' (reported by Giovanni Mascellani 2019/07/16)
2019-07-16 23:30:04 +08:00
Sym *s;
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
/* look for global symbol */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
s = sym_find(v);
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
while (s && s->sym_scope)
s = s->prev_tok;
if (!s) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* push forward reference */
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
s = global_identifier_push(v, type->t, 0);
s->r |= r;
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;
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
s->type.ref = type->ref;
tccgen.c: local extern decls: copy s->ref for VT_PTR too This fixes the issue int main() { extern char *x; } void main1() { extern char *x; } t2.c:5: error: incompatible types for redefinition of 'x' (reported by Giovanni Mascellani 2019/07/16)
2019-07-16 23:30:04 +08:00
/* copy type to the global stack */
if (local_stack)
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
sym_copy_ref(s, &global_stack);
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 {
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
}
tccgen.c: local extern decls: copy s->ref for VT_PTR too This fixes the issue int main() { extern char *x; } void main1() { extern char *x; } t2.c:5: error: incompatible types for redefinition of 'x' (reported by Giovanni Mascellani 2019/07/16)
2019-07-16 23:30:04 +08:00
/* push variables on local_stack if any */
if (local_stack && (s->type.t & VT_BTYPE) != VT_FUNC)
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
s = sym_copy(s, &local_stack);
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
{
update gen_cast
2019-12-17 01:51:28 +08:00
int l, size, align, bt;
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
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;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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++) {
update gen_cast
2019-12-17 01:51:28 +08:00
if ((p->r & VT_VALMASK) == r || p->r2 == r) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* must save value on stack if not already done */
update gen_cast
2019-12-17 01:51:28 +08:00
if (!l) {
bt = p->type.t & VT_BTYPE;
if (bt == VT_VOID)
continue;
if ((p->r & VT_LVAL) || bt == VT_FUNC)
bt = VT_PTR;
sv.type.t = bt;
size = type_size(&sv.type, &align);
bcheck cleanup - revert Makefiles to state before last bcheck additions Instead, just load bcheck.o explicitly if that is what is wanted. - move tcc_add_bcheck() to the <target>-link.c files and remove revently added arguments. This function is to support tccelf.c with linking, not for tccgen.c to support compilation. - remove -ba option: It said: "-ba Enable better address checking with bounds checker" Okay, if it is better then to have it is not an option. - remove va_copy. It is C99 and we try to stay C89 in tinycc when possible. For example, MS compilers do not have va_copy. - win64: revert any 'fixes' to alloca It was correct as it was before, except for bound_checking where it was not implemented. This should now work too. - remove parasitic filename:linenum features Such feature is already present with rt_printline in tccrun.c. If it doesn't work it can be fixed. - revert changes to gen_bounded_ptr_add() gen_bounded_ptr_add() was working as it should before (mostly). For the sake of simplicity I switched it to CDECL. Anyway, FASTCALL means SLOWCALL with tinycc. In exchange you get one addition which is required for bounds_cnecking function arguments. The important thing is to check them *BEFORE* they are loaded into registers. New function gbound_args() does that. In any case, code instrumentation with the bounds-check functions as such now seems to work flawlessly again, which means when they are inserted as NOPs, any code that tcc can compile, seems to behave just the same as without them. What these functions then do when fully enabled, is a differnt story. I did not touch this.
2019-12-12 22:45:45 +08:00
#ifdef CONFIG_TCC_BCHECK
if (tcc_state->do_bounds_check)
l = loc = (loc - size) & -align;
else
#endif
update gen_cast
2019-12-17 01:51:28 +08:00
l = get_temp_local_var(size,align);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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;
update gen_cast
2019-12-17 01:51:28 +08:00
store(p->r & VT_VALMASK, &sv);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#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
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
/* special long long case */
update gen_cast
2019-12-17 01:51:28 +08:00
if (p->r2 < VT_CONST && USING_TWO_WORDS(bt)) {
riscv: some work on large function arguments like long double (16 bytes) and structs. Not completely correct, but 73_arm64 somewhat works now (when the stdarg part is disabled), though with some errors. What's definitely incorrect is arguments of a mixed int/float struct. I'm using VT_LDOUBLE (which conveniently has to be placed in a int-reg-pair) to load/store structure arguments of size > 8 and <= 16, and that can lead to overreads.
2019-07-18 10:51:52 +08:00
sv.c.i += PTR_SIZE;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
store(p->r2, &sv);
}
}
/* 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 {
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
p->r = VT_LVAL | VT_LOCAL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
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 ||
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
p->r2 == r)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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 ||
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
p->r2 == r)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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) */
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
r = p->r2;
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)
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
vtop->r = (vtop->r & ~VT_VALMASK) | VT_LOCAL | VT_LVAL;
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
{
CType type1;
vtop->r &= ~VT_MUSTBOUND;
/* if lvalue, then use checking code before dereferencing */
bcheck cleanup - revert Makefiles to state before last bcheck additions Instead, just load bcheck.o explicitly if that is what is wanted. - move tcc_add_bcheck() to the <target>-link.c files and remove revently added arguments. This function is to support tccelf.c with linking, not for tccgen.c to support compilation. - remove -ba option: It said: "-ba Enable better address checking with bounds checker" Okay, if it is better then to have it is not an option. - remove va_copy. It is C99 and we try to stay C89 in tinycc when possible. For example, MS compilers do not have va_copy. - win64: revert any 'fixes' to alloca It was correct as it was before, except for bound_checking where it was not implemented. This should now work too. - remove parasitic filename:linenum features Such feature is already present with rt_printline in tccrun.c. If it doesn't work it can be fixed. - revert changes to gen_bounded_ptr_add() gen_bounded_ptr_add() was working as it should before (mostly). For the sake of simplicity I switched it to CDECL. Anyway, FASTCALL means SLOWCALL with tinycc. In exchange you get one addition which is required for bounds_cnecking function arguments. The important thing is to check them *BEFORE* they are loaded into registers. New function gbound_args() does that. In any case, code instrumentation with the bounds-check functions as such now seems to work flawlessly again, which means when they are inserted as NOPs, any code that tcc can compile, seems to behave just the same as without them. What these functions then do when fully enabled, is a differnt story. I did not touch this.
2019-12-12 22:45:45 +08:00
if (vtop->r & VT_LVAL) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* if not VT_BOUNDED value, then make one */
if (!(vtop->r & VT_BOUNDED)) {
/* 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();
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
vtop->r |= VT_LVAL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop->type = type1;
}
/* then check for dereferencing */
gen_bounded_ptr_deref();
}
}
bcheck cleanup - revert Makefiles to state before last bcheck additions Instead, just load bcheck.o explicitly if that is what is wanted. - move tcc_add_bcheck() to the <target>-link.c files and remove revently added arguments. This function is to support tccelf.c with linking, not for tccgen.c to support compilation. - remove -ba option: It said: "-ba Enable better address checking with bounds checker" Okay, if it is better then to have it is not an option. - remove va_copy. It is C99 and we try to stay C89 in tinycc when possible. For example, MS compilers do not have va_copy. - win64: revert any 'fixes' to alloca It was correct as it was before, except for bound_checking where it was not implemented. This should now work too. - remove parasitic filename:linenum features Such feature is already present with rt_printline in tccrun.c. If it doesn't work it can be fixed. - revert changes to gen_bounded_ptr_add() gen_bounded_ptr_add() was working as it should before (mostly). For the sake of simplicity I switched it to CDECL. Anyway, FASTCALL means SLOWCALL with tinycc. In exchange you get one addition which is required for bounds_cnecking function arguments. The important thing is to check them *BEFORE* they are loaded into registers. New function gbound_args() does that. In any case, code instrumentation with the bounds-check functions as such now seems to work flawlessly again, which means when they are inserted as NOPs, any code that tcc can compile, seems to behave just the same as without them. What these functions then do when fully enabled, is a differnt story. I did not touch this.
2019-12-12 22:45:45 +08:00
/* we need to call __bound_ptr_add before we start to load function
args into registers */
ST_FUNC void gbound_args(int nb_args)
{
int i;
for (i = 1; i <= nb_args; ++i)
if (vtop[1 - i].r & VT_MUSTBOUND) {
vrotb(i);
gbound();
vrott(i);
}
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#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();
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
vpushs(o);
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('+');
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
vtop->type.t = VT_BYTE | VT_UNSIGNED;
vtop->r |= VT_LVAL;
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
}
/* 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;
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
sv->r |= VT_LVAL;
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
}
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
{
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
int r, r2, r_ok, r2_ok, rc2, bt;
int bit_pos, bit_size, size, align;
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
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
bt = vtop->type.t & VT_BTYPE;
riscv: some long double support long double on risc-v is 128bit, but there are no registers for that type (without the Q ISA extension). They are passed like two 64bit integers values (with an exception for varargs, where it's an aligned register pair). This all requires some hacks in generic code as otherwise RC_FLOAT regs are tried for holding values of long double type, but we need a RC_INT register pair. This really could all use some cleanup for all archs. This doesn't implement any conversions of operations for long double, but it's enough to get 70_floating_point_literals working.
2019-07-14 11:48:15 +08:00
#ifdef TCC_TARGET_RISCV64
/* XXX mega hack */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
if (bt == VT_LDOUBLE && rc == RC_FLOAT)
riscv: some long double support long double on risc-v is 128bit, but there are no registers for that type (without the Q ISA extension). They are passed like two 64bit integers values (with an exception for varargs, where it's an aligned register pair). This all requires some hacks in generic code as otherwise RC_FLOAT regs are tried for holding values of long double type, but we need a RC_INT register pair. This really could all use some cleanup for all archs. This doesn't implement any conversions of operations for long double, but it's enough to get 70_floating_point_literals working.
2019-07-14 11:48:15 +08:00
rc = RC_INT;
#endif
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
rc2 = RC2_TYPE(bt, rc);
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 */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
r = vtop->r & VT_VALMASK;
r_ok = !(vtop->r & VT_LVAL) && (r < VT_CONST) && (reg_classes[r] & rc);
r2_ok = !rc2 || ((vtop->r2 < VT_CONST) && (reg_classes[vtop->r2] & rc2));
if (!r_ok || !r2_ok) {
if (!r_ok)
r = get_reg(rc);
if (rc2) {
update gen_cast
2019-12-17 01:51:28 +08:00
int load_type = (bt == VT_QFLOAT) ? VT_DOUBLE : VT_PTRDIFF_T;
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
int original_type = vtop->type.t;
/* two register type load :
expand to two words temporarily */
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 */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
unsigned long long ll = vtop->c.i;
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
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 */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
} else if (vtop->r & VT_LVAL) {
/* We do not want to modifier the long long pointer here.
So we save any other instances down the stack */
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(vtop->r, 1);
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 */
update gen_cast
2019-12-17 01:51:28 +08:00
vtop->type.t = VT_PTRDIFF_T;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gaddrof();
update gen_cast
2019-12-17 01:51:28 +08:00
vpushs(PTR_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 */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
if (!r_ok)
load(r, vtop);
if (r2_ok && vtop->r2 < VT_CONST)
goto done;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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;
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
done:
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;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
if (vtop->r == VT_CMP)
vset_VT_JMP();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* one register type load */
load(r, vtop);
}
}
vtop->r = r;
#ifdef TCC_TARGET_C67
/* uses register pairs for doubles */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
if (bt == 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
{
/* generate more generic register first. But VT_JMP or VT_CMP
values must be generated first in all cases to avoid possible
reload errors */
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
if (vtop->r != VT_CMP && rc1 <= rc2) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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);
}
}
}
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
{
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
int t, rc, r;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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();
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
return;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
#endif
/* duplicate value */
rc = RC_TYPE(t);
gv(rc);
r = get_reg(rc);
vdup();
load(r, vtop);
vtop->r = r;
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
/* 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;
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
unsigned short reg_lret = REG_IRE2;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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 */
some smaller fixes - libtcc.c/tccpp.c: fix -U option for multiple input files - libtcc: remove decl of tcc_add_crt() for PE - tcc.h: define __i386__ and __x86_64__ for msvc - tcc.h: undef __attribute__ for __TINYC__ on gnu/linux platforms - tccelf.c: disable prepare_dynamic_rel unless x86/x64 - tccpe.c: construct rather than predefine PE section flags - tccpp.c: (alt.) fix access of dead stack variable after error/longjmp - x86_64-gen.c: fix func_alloca chain for nocode_wanted - tccpp.c/tccgen.c: improve file:line info for inline functions - winapi/winnt.h: correct position for DECLSPEC_ALIGN attribute - win32/lib/crt: simplify top exception handler (needed for signal) - arm64-gen.c: remove dprintf left from VT_CMP commit - tccgen.c: limit binary scan with gcase to > 8 (= smaller code) - tccgen.c: call save_regs(4) in gen_opl for cmp-ops (see test in tcctest.c)
2018-06-08 21:31:40 +08:00
save_regs(4);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* 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 */
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
vpushi(0);
vset_VT_CMP(TOK_NE);
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);
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
#if 0//def TCC_TARGET_I386
if (op == TOK_NE) { gsym(b); break; }
if (op == TOK_EQ) { gsym(a); break; }
#endif
gvtst_set(1, a);
gvtst_set(0, b);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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 == '^' ||
riscv: Add special cases for const operands RISC-V supports small immediates for some operations, let's use them.
2019-08-13 09:21:58 +08:00
op == '|' || op == '*' || op == TOK_EQ || op == TOK_NE)) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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;
some smaller fixes - libtcc.c/tccpp.c: fix -U option for multiple input files - libtcc: remove decl of tcc_add_crt() for PE - tcc.h: define __i386__ and __x86_64__ for msvc - tcc.h: undef __attribute__ for __TINYC__ on gnu/linux platforms - tccelf.c: disable prepare_dynamic_rel unless x86/x64 - tccpe.c: construct rather than predefine PE section flags - tccpp.c: (alt.) fix access of dead stack variable after error/longjmp - x86_64-gen.c: fix func_alloca chain for nocode_wanted - tccpp.c/tccgen.c: improve file:line info for inline functions - winapi/winnt.h: correct position for DECLSPEC_ALIGN attribute - win32/lib/crt: simplify top exception handler (needed for signal) - arm64-gen.c: remove dprintf left from VT_CMP commit - tccgen.c: limit binary scan with gcase to > 8 (= smaller code) - tccgen.c: call save_regs(4) in gen_opl for cmp-ops (see test in tcctest.c)
2018-06-08 21:31:40 +08:00
#if defined _MSC_VER && defined __x86_64__
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
/* 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
}
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);
update gen_cast
2019-12-17 01:51:28 +08:00
vtop->type.t = VT_PTRDIFF_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('*');
Update bounds checking. The bounds checking code has now enabled gen_bounded_ptr_add tests. This makes the code slower but finds more errors. I had to correct some things in tcc to make it work. - Fixed off by one in lib/bcheck.c - Corrected tccelf.c sym_versions. - Disabled USE_TAL when using bounds checking. - Fixed cstr_printf va_start. - Fixed tests/tests2/46_grep.c off by one error. - Updated gen_bounded_ptr_add in x86_64-gen.c - Fixed x86_64-link.c pointer diff. For gen_vla_alloc now always use alloca call when bounds checking. Added line/filename in %rax before bound calls to find location of error.
2019-12-12 19:56:06 +08:00
#ifdef CONFIG_TCC_BCHECK
bcheck cleanup - revert Makefiles to state before last bcheck additions Instead, just load bcheck.o explicitly if that is what is wanted. - move tcc_add_bcheck() to the <target>-link.c files and remove revently added arguments. This function is to support tccelf.c with linking, not for tccgen.c to support compilation. - remove -ba option: It said: "-ba Enable better address checking with bounds checker" Okay, if it is better then to have it is not an option. - remove va_copy. It is C99 and we try to stay C89 in tinycc when possible. For example, MS compilers do not have va_copy. - win64: revert any 'fixes' to alloca It was correct as it was before, except for bound_checking where it was not implemented. This should now work too. - remove parasitic filename:linenum features Such feature is already present with rt_printline in tccrun.c. If it doesn't work it can be fixed. - revert changes to gen_bounded_ptr_add() gen_bounded_ptr_add() was working as it should before (mostly). For the sake of simplicity I switched it to CDECL. Anyway, FASTCALL means SLOWCALL with tinycc. In exchange you get one addition which is required for bounds_cnecking function arguments. The important thing is to check them *BEFORE* they are loaded into registers. New function gbound_args() does that. In any case, code instrumentation with the bounds-check functions as such now seems to work flawlessly again, which means when they are inserted as NOPs, any code that tcc can compile, seems to behave just the same as without them. What these functions then do when fully enabled, is a differnt story. I did not touch this.
2019-12-12 22:45:45 +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('-');
}
bcheck cleanup - revert Makefiles to state before last bcheck additions Instead, just load bcheck.o explicitly if that is what is wanted. - move tcc_add_bcheck() to the <target>-link.c files and remove revently added arguments. This function is to support tccelf.c with linking, not for tccgen.c to support compilation. - remove -ba option: It said: "-ba Enable better address checking with bounds checker" Okay, if it is better then to have it is not an option. - remove va_copy. It is C99 and we try to stay C89 in tinycc when possible. For example, MS compilers do not have va_copy. - win64: revert any 'fixes' to alloca It was correct as it was before, except for bound_checking where it was not implemented. This should now work too. - remove parasitic filename:linenum features Such feature is already present with rt_printline in tccrun.c. If it doesn't work it can be fixed. - revert changes to gen_bounded_ptr_add() gen_bounded_ptr_add() was working as it should before (mostly). For the sake of simplicity I switched it to CDECL. Anyway, FASTCALL means SLOWCALL with tinycc. In exchange you get one addition which is required for bounds_cnecking function arguments. The important thing is to check them *BEFORE* they are loaded into registers. New function gbound_args() does that. In any case, code instrumentation with the bounds-check functions as such now seems to work flawlessly again, which means when they are inserted as NOPs, any code that tcc can compile, seems to behave just the same as without them. What these functions then do when fully enabled, is a differnt story. I did not touch this.
2019-12-12 22:45:45 +08:00
vtop[-1].r &= ~VT_MUSTBOUND;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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
}
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
#if defined TCC_TARGET_ARM64 || defined TCC_TARGET_RISCV64 || defined TCC_TARGET_ARM
#define gen_cvt_itof1 gen_cvt_itof
#else
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* 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
{
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);
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
PUT_R_RET(vtop, t);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
gen_cvt_itof(t);
}
}
#endif
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
#if defined TCC_TARGET_ARM64 || defined TCC_TARGET_RISCV64
#define gen_cvt_ftoi1 gen_cvt_ftoi
#else
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* 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
{
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);
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
PUT_R_RET(vtop, t);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
gen_cvt_ftoi(t);
}
}
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
#endif
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
update gen_cast
2019-12-17 01:51:28 +08:00
/* special delayed cast for char/short */
static void force_charshort_cast(void)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
update gen_cast
2019-12-17 01:51:28 +08:00
int sbt = BFGET(vtop->r, VT_MUSTCAST) == 2 ? VT_LLONG : VT_INT;
int dbt = vtop->type.t;
vtop->r &= ~VT_MUSTCAST;
vtop->type.t = sbt;
gen_cast_s(dbt == VT_BOOL ? VT_BYTE|VT_UNSIGNED : dbt);
vtop->type.t = dbt;
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
static void gen_cast_s(int t)
{
CType type;
type.t = t;
type.ref = NULL;
gen_cast(&type);
}
update gen_cast
2019-12-17 01:51:28 +08:00
/* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
static void gen_cast(CType *type)
{
update gen_cast
2019-12-17 01:51:28 +08:00
int sbt, dbt, sf, df, c;
int dbt_bt, sbt_bt, ds, ss, bits, trunc;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* special delayed cast for char/short */
update gen_cast
2019-12-17 01:51:28 +08:00
if (vtop->r & VT_MUSTCAST)
force_charshort_cast();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* bitfields first get cast to ints */
update gen_cast
2019-12-17 01:51:28 +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);
update gen_cast
2019-12-17 01:51:28 +08:00
if (sbt == VT_FUNC)
sbt = VT_PTR;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
update gen_cast
2019-12-17 01:51:28 +08:00
again:
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (sbt != dbt) {
sf = is_float(sbt);
df = is_float(dbt);
update gen_cast
2019-12-17 01:51:28 +08:00
dbt_bt = dbt & VT_BTYPE;
sbt_bt = sbt & VT_BTYPE;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
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
riscv: some work on large function arguments like long double (16 bytes) and structs. Not completely correct, but 73_arm64 somewhat works now (when the stdarg part is disabled), though with some errors. What's definitely incorrect is arguments of a mixed int/float struct. I'm using VT_LDOUBLE (which conveniently has to be placed in a int-reg-pair) to load/store structure arguments of size > 8 and <= 16, and that can lead to overreads.
2019-07-18 10:51:52 +08:00
c &= (dbt != VT_LDOUBLE) | !!nocode_wanted;
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
#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) {
update gen_cast
2019-12-17 01:51:28 +08:00
if (sbt_bt == 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_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;
update gen_cast
2019-12-17 01:51:28 +08:00
else if (sbt_bt == VT_LLONG || (PTR_SIZE == 8 && sbt == VT_PTR))
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;
update gen_cast
2019-12-17 01:51:28 +08:00
else
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
update gen_cast
2019-12-17 01:51:28 +08:00
if (dbt_bt == VT_LLONG || (PTR_SIZE == 8 && dbt == VT_PTR))
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);
update gen_cast
2019-12-17 01:51:28 +08:00
else {
uint32_t m = dbt_bt == VT_BYTE ? 0xff :
dbt_bt == VT_SHORT ? 0xffff :
0xffffffff;
Merge the integer members of union CValue into "uint64_t i".
2015-11-18 03:09:35 +08:00
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
}
}
update gen_cast
2019-12-17 01:51:28 +08:00
goto done;
} else if (dbt == VT_BOOL
&& (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM))
== (VT_CONST | VT_SYM)) {
/* addresses are considered non-zero (see tcctest.c:sinit23) */
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vtop->r = VT_CONST;
vtop->c.i = 1;
update gen_cast
2019-12-17 01:51:28 +08:00
goto done;
}
/* cannot generate code for global or static initializers */
if (STATIC_DATA_WANTED)
goto done;
/* non constant case: generate code */
if (dbt == VT_BOOL) {
gen_test_zero(TOK_NE);
goto done;
}
if (sf || df) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (sf && df) {
/* convert from fp to fp */
gen_cvt_ftof(dbt);
} else if (df) {
/* convert int to fp */
gen_cvt_itof1(dbt);
update gen_cast
2019-12-17 01:51:28 +08:00
} else {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* convert fp to int */
update gen_cast
2019-12-17 01:51:28 +08:00
sbt = dbt;
if (dbt_bt != VT_LLONG && dbt_bt != VT_INT)
sbt = VT_INT;
gen_cvt_ftoi1(sbt);
goto again; /* may need char/short cast */
}
goto done;
}
ds = btype_size(dbt_bt);
ss = btype_size(sbt_bt);
if (ds == 0 || ss == 0) {
if (dbt_bt == VT_VOID)
goto done;
cast_error(&vtop->type, type);
}
if (IS_ENUM(type->t) && type->ref->c < 0)
tcc_error("cast to incomplete type");
/* same size and no sign conversion needed */
if (ds == ss && ds >= 4)
goto done;
if (dbt_bt == VT_PTR || sbt_bt == VT_PTR) {
tcc_warning("cast between pointer and integer of different size");
if (sbt_bt == VT_PTR) {
/* put integer type to allow logical operations below */
vtop->type.t = (PTR_SIZE == 8 ? VT_LLONG : VT_INT);
}
}
/* processor allows { int a = 0, b = *(char*)&a; }
That means that if we cast to less width, we can just
change the type and read it still later. */
#define ALLOW_SUBTYPE_ACCESS 1
if (ALLOW_SUBTYPE_ACCESS && (vtop->r & VT_LVAL)) {
/* value still in memory */
if (ds <= ss)
goto done;
/* ss <= 4 here */
if (ds <= 4) {
gv(RC_INT);
goto done; /* no 64bit envolved */
}
}
gv(RC_INT);
trunc = 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 == 4
update gen_cast
2019-12-17 01:51:28 +08:00
if (ds == 8) {
/* generate high word */
if (sbt & VT_UNSIGNED) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
vpushi(0);
update gen_cast
2019-12-17 01:51:28 +08:00
gv(RC_INT);
} else {
gv_dup();
vpushi(31);
gen_op(TOK_SAR);
}
lbuild(dbt);
} else if (ss == 8) {
/* from long long: just take low order word */
lexpand();
vpop();
}
ss = 4;
#elif PTR_SIZE == 8
if (ds == 8) {
/* need to convert from 32bit to 64bit */
if (sbt & VT_UNSIGNED) {
#if defined(TCC_TARGET_RISCV64)
/* RISC-V keeps 32bit vals in registers sign-extended.
So here we need a zero-extension. */
trunc = 32;
Fix shortening casts of long long see added testcase.
2018-04-01 03:52:20 +08:00
#else
update gen_cast
2019-12-17 01:51:28 +08:00
goto done;
Fix shortening casts of long long see added testcase.
2018-04-01 03:52:20 +08:00
#endif
update gen_cast
2019-12-17 01:51:28 +08:00
} else {
gen_cvt_sxtw();
goto done;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
update gen_cast
2019-12-17 01:51:28 +08:00
ss = ds, ds = 4, dbt = sbt;
} else if (ss == 8) {
/* XXX some architectures (e.g. risc-v) would like it
better for this merely being a 32-to-64 sign or zero-
extension. */
trunc = 32; /* zero upper 32 bits */
} else {
ss = 4;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
update gen_cast
2019-12-17 01:51:28 +08:00
#endif
if (ds >= ss)
goto done;
#if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64 || defined TCC_TARGET_ARM64
if (ss == 4) {
gen_cvt_csti(dbt);
goto done;
}
#endif
bits = (ss - ds) * 8;
/* for unsigned, gen_op will convert SAR to SHR */
vtop->type.t = (ss == 8 ? VT_LLONG : VT_INT) | (dbt & VT_UNSIGNED);
vpushi(bits);
gen_op(TOK_SHL);
vpushi(bits - trunc);
gen_op(TOK_SAR);
vpushi(trunc);
gen_op(TOK_SHR);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
update gen_cast
2019-12-17 01:51:28 +08:00
done:
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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
}
}
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;
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;
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
if (s1->f.func_type != s2->f.func_type
&& 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 0;
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
/* we should check the function return type for FUNC_OLD too
but that causes problems with the internally used support
functions such as TOK_memmove */
if (s1->f.func_type == FUNC_OLD && !s1->next)
return 1;
if (s2->f.func_type == FUNC_OLD && !s2->next)
return 1;
for (;;) {
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;
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
if (!s1)
return !s2;
if (!s2)
return 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
/* 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;
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
if ((t1 & VT_ARRAY)
&& !(type1->ref->c < 0
|| type2->ref->c < 0
|| type1->ref->c == type2->ref->c))
return 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* test more complicated cases */
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
bt1 = t1 & VT_BTYPE;
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);
} 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: ;
}
update gen_cast
2019-12-17 01:51:28 +08:00
static void cast_error(CType *st, CType *dt)
{
char buf1[256], buf2[256];
type_to_str(buf1, sizeof(buf1), st, NULL);
type_to_str(buf2, sizeof(buf2), dt, NULL);
tcc_error("cannot convert '%s' to '%s'", buf1, buf2);
}
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
/* verify type compatibility to store vtop in 'dt' type */
static void verify_assign_cast(CType *dt)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +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
CType *st, *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
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;
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) {
update gen_cast
2019-12-17 01:51:28 +08:00
case VT_VOID:
if (sbt != dbt)
tcc_error("assignment to void expression");
break;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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)) {
update gen_cast
2019-12-17 01:51:28 +08:00
error:
cast_error(st, dt);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
break;
}
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
}
static void gen_assign_cast(CType *dt)
{
verify_assign_cast(dt);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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
{
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
int sbt, dbt, ft, r, size, align, bit_size, bit_pos, delayed_cast;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
ft = vtop[-1].type.t;
sbt = vtop->type.t & VT_BTYPE;
dbt = ft & VT_BTYPE;
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
verify_assign_cast(&vtop[-1].type);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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);
/* leave source on stack */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} 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
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
if (dbt == 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);
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
if (dbt != VT_BOOL) {
gen_cast(&vtop[-1].type);
dbt = vtop[-1].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 (r == VT_STRUCT) {
store_packed_bf(bit_pos, bit_size);
} else {
unsigned long long mask = (1ULL << bit_size) - 1;
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
if (dbt != 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
/* mask source */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
if (dbt == 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
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 */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
if (dbt == 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
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 {
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
/* optimize char/short casts */
delayed_cast = 0;
if ((dbt == VT_BYTE || dbt == VT_SHORT)
&& is_integer_btype(sbt)
) {
if ((vtop->r & VT_MUSTCAST)
&& btype_size(dbt) > btype_size(sbt)
)
update gen_cast
2019-12-17 01:51:28 +08:00
force_charshort_cast();
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
delayed_cast = 1;
} else {
gen_cast(&vtop[-1].type);
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
#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
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
gv(RC_TYPE(dbt)); /* generate value */
if (delayed_cast) {
update gen_cast
2019-12-17 01:51:28 +08:00
vtop->r |= BFVAL(VT_MUSTCAST, (sbt == VT_LLONG) + 1);
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
//tcc_warning("deley cast %x -> %x", sbt, dbt);
vtop->type.t = ft & VT_TYPE;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* if lvalue was saved on stack, must read it */
if ((vtop[-1].r & VT_VALMASK) == VT_LLOCAL) {
SValue sv;
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
r = get_reg(RC_INT);
update gen_cast
2019-12-17 01:51:28 +08:00
sv.type.t = VT_PTRDIFF_T;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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;
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
load(r, &sv);
vtop[-1].r = r | VT_LVAL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
r = vtop->r & VT_VALMASK;
/* two word case handling :
store second register at word + 4 (or +8 for x86-64) */
if (USING_TWO_WORDS(dbt)) {
update gen_cast
2019-12-17 01:51:28 +08:00
int load_type = (dbt == VT_QFLOAT) ? VT_DOUBLE : VT_PTRDIFF_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
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 */
update gen_cast
2019-12-17 01:51:28 +08:00
vtop->type.t = VT_PTRDIFF_T;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gaddrof();
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
vpushs(PTR_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 {
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
/* single 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
store(r, vtop - 1);
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 */
}
}
/* 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;
}
Add constructor/destructor support
2019-10-29 14:02:58 +08:00
case TOK_CONSTRUCTOR1:
case TOK_CONSTRUCTOR2:
ad->a.constructor = 1;
break;
case TOK_DESTRUCTOR1:
case TOK_DESTRUCTOR2:
ad->a.destructor = 1;
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:
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
ad->f.func_noreturn = 1;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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)
{
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
int t, u, bt, st, type_found, typespec_found, g, n;
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:
next();
fix _Noreturn keyword
2019-09-08 23:35:15 +08:00
ad->f.func_noreturn = 1;
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
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;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
n = tok, next();
if (tok == ':' && !in_generic) {
/* ignore if it's a label */
unget_tok(n);
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
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
{
reject invalid arrays in post_type()
2019-06-24 16:28:36 +08:00
int n, l, t1, arg_size, align, unused_align;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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 */
some smaller fixes - libtcc.c/tccpp.c: fix -U option for multiple input files - libtcc: remove decl of tcc_add_crt() for PE - tcc.h: define __i386__ and __x86_64__ for msvc - tcc.h: undef __attribute__ for __TINYC__ on gnu/linux platforms - tccelf.c: disable prepare_dynamic_rel unless x86/x64 - tccpe.c: construct rather than predefine PE section flags - tccpp.c: (alt.) fix access of dead stack variable after error/longjmp - x86_64-gen.c: fix func_alloca chain for nocode_wanted - tccpp.c/tccgen.c: improve file:line info for inline functions - winapi/winnt.h: correct position for DECLSPEC_ALIGN attribute - win32/lib/crt: simplify top exception handler (needed for signal) - arm64-gen.c: remove dprintf left from VT_CMP commit - tccgen.c: limit binary scan with gcase to > 8 (= smaller code) - tccgen.c: call save_regs(4) in gen_opl for cmp-ops (see test in tcctest.c)
2018-06-08 21:31:40 +08:00
pt.ref = NULL;
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);
reject invalid arrays in post_type()
2019-06-24 16:28:36 +08:00
if ((type->t & VT_BTYPE) == VT_FUNC)
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
tcc_error("declaration of an array of functions");
reject invalid arrays in post_type()
2019-06-24 16:28:36 +08:00
if ((type->t & VT_BTYPE) == VT_VOID
|| type_size(type, &unused_align) < 0)
tcc_error("declaration of an array of incomplete type elements");
re-apply VLA by Thomas Preud'homme
2011-04-07 00:17:03 +08:00
t1 |= type->t & VT_VLA;
reject invalid arrays in post_type()
2019-06-24 16:28:36 +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
}
/* 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 */
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
if (!(vtop->type.t & (VT_ARRAY | VT_VLA))
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
&& (vtop->type.t & VT_BTYPE) != VT_FUNC) {
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
vtop->r |= VT_LVAL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* 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);
update gen_cast
2019-12-17 01:51:28 +08:00
} else if (vtop->r & VT_MUSTCAST) {
force_charshort_cast();
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--;
}
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))
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
r |= VT_LVAL;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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. */
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
block(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();
update gen_cast
2019-12-17 01:51:28 +08:00
gen_test_zero(TOK_EQ);
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; */
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
s = NULL;
if (vtop[1].r & VT_SYM)
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;
riscv: implement stdarg functions this also fixes passing of params > 16 bytes. In riscv they aren't passed by value on stack, but via reference (and because callees are allowed to modify by-ref params the caller must allocate an own copy per call). This fixes the stdarg parts of 73_arm.c.
2019-07-21 09:25:12 +08:00
#ifdef TCC_TARGET_RISCV64
case TOK_builtin_va_start:
parse_builtin_params(0, "ee");
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");
riscv: Fix stdarg_many_test if named params are passed on stack, the va_arg area begins after that, not at sp+0. Fixes abitest:stdarg_many_test.
2019-07-23 02:37:42 +08:00
gen_va_start();
riscv: implement stdarg functions this also fixes passing of params > 16 bytes. In riscv they aren't passed by value on stack, but via reference (and because callees are allowed to modify by-ref params the caller must allocate an own copy per call). This fixes the stdarg parts of 73_arm.c.
2019-07-21 09:25:12 +08:00
vstore();
break;
#endif
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;
riscv: fix more sign/zero-extension problems see the testcase. For the signed case this problably does the wrong thing, and it should break other archs. Rework once there are testcases for this.
2019-07-22 12:45:03 +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;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
in_generic++;
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);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
in_generic--;
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
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)) {
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
vtop->r |= VT_LVAL;
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
Fix bounds checking for linux/windows
2019-12-10 15:07:25 +08:00
#ifdef CONFIG_TCC_BCHECK
if (tcc_state->do_bounds_check && (vtop->r & VT_SYM) && vtop->sym->v == TOK_alloca) {
addr_t *bounds_ptr;
bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(addr_t));
bounds_ptr[0] = 1; /* marks alloca/vla used */
bounds_ptr[1] = 0;
}
#endif
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);
riscv: rewrite parameter passing this fixes the ret_mixed_test of abitest.c, now everything of the testsuite works. The generic code for returns is good enough for our use, except in the specific case of a mixed int/float structures returned in registers, so instead of duplicating the whole generic gfunc_return function, add another modus for gfunc_sret: returning -1 makes the actual register transfer by a new backend function.
2019-08-11 03:21:43 +08:00
if (ret_nregs <= 0) {
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;
riscv: rewrite parameter passing this fixes the ret_mixed_test of abitest.c, now everything of the testsuite works. The generic code for returns is good enough for our use, except in the specific case of a mixed int/float structures returned in registers, so instead of duplicating the whole generic gfunc_return function, add another modus for gfunc_sret: returning -1 makes the actual register transfer by a new backend function.
2019-08-11 03:21:43 +08:00
if (ret_nregs < 0)
vtop--;
else
nb_args++;
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
}
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;
}
riscv: rewrite parameter passing this fixes the ret_mixed_test of abitest.c, now everything of the testsuite works. The generic code for returns is good enough for our use, except in the specific case of a mixed int/float structures returned in registers, so instead of duplicating the whole generic gfunc_return function, add another modus for gfunc_sret: returning -1 makes the actual register transfer by a new backend function.
2019-08-11 03:21:43 +08:00
if (ret_nregs > 0) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* return in register */
ret.c.i = 0;
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
PUT_R_RET(&ret, ret.type.t);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
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
riscv: rewrite parameter passing this fixes the ret_mixed_test of abitest.c, now everything of the testsuite works. The generic code for returns is good enough for our use, except in the specific case of a mixed int/float structures returned in registers, so instead of duplicating the whole generic gfunc_return function, add another modus for gfunc_sret: returning -1 makes the actual register transfer by a new backend function.
2019-08-11 03:21:43 +08:00
if (ret_nregs < 0) {
vsetc(&ret.type, ret.r, &ret.c);
#ifdef TCC_TARGET_RISCV64
arch_transfer_ret_regs(1);
#endif
} else {
/* return value */
for (r = ret.r + ret_nregs + !ret_nregs; r-- > ret.r;) {
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
riscv: rewrite parameter passing this fixes the ret_mixed_test of abitest.c, now everything of the testsuite works. The generic code for returns is good enough for our use, except in the specific case of a mixed int/float structures returned in registers, so instead of duplicating the whole generic gfunc_return function, add another modus for gfunc_sret: returning -1 makes the actual register transfer by a new backend function.
2019-08-11 03:21:43 +08:00
/* handle packed struct return */
if (((s->type.t & VT_BTYPE) == VT_STRUCT) && ret_nregs) {
int addr, offset;
size = type_size(&s->type, &align);
/* We're writing whole regs often, make sure there's enough
space. Assume register size is power of 2. */
if (regsize > align)
align = regsize;
loc = (loc - size) & -align;
addr = loc;
offset = 0;
for (;;) {
vset(&ret.type, VT_LOCAL | VT_LVAL, addr + offset);
vswap();
vstore();
vtop--;
if (--ret_nregs == 0)
break;
offset += regsize;
}
vset(&s->type, VT_LOCAL | VT_LVAL, addr);
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
}
tccgen.c: generic char/short promotion for function return values
2019-09-23 23:45:39 +08:00
/* Promote char/short return values. This is matters only
for calling function that were not compiled by TCC */
t = s->type.t & VT_BTYPE;
if (t == VT_BYTE || t == VT_SHORT || t == VT_BOOL)
vtop->r |= BFVAL(VT_MUSTCAST, 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
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
if (s->f.func_noreturn)
CODE_OFF();
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('|');
}
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
static int condition_3way(void);
static void expr_landor(void(*e_fn)(void), int e_op, int i)
{
int t = 0, cc = 1, f = 0, c;
for(;;) {
c = f ? i : condition_3way();
if (c < 0) {
save_regs(1), cc = 0;
} else if (c != i) {
nocode_wanted++, f = 1;
}
if (tok != e_op) {
if (cc || f) {
vpop();
vpushi(i ^ f);
gsym(t);
nocode_wanted -= f;
} else {
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
gvtst_set(i, t);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
}
break;
}
if (c < 0)
t = gvtst(i, t);
else
vpop();
next();
e_fn();
}
}
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
static void expr_land(void)
{
expr_or();
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
if (tok == TOK_LAND)
expr_landor(expr_or, TOK_LAND, 1);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
static void expr_lor(void)
{
expr_land();
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
if (tok == TOK_LOR)
expr_landor(expr_land, TOK_LOR, 0);
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;
}
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
static int is_cond_bool(SValue *sv)
{
if ((sv->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST
&& (sv->type.t & VT_BTYPE) == VT_INT)
return (unsigned)sv->c.i < 2;
if (sv->r == VT_CMP)
return 1;
return 0;
}
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;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
int ncw_prev;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
tt = 0;
if (!g) {
if (c < 0) {
save_regs(1);
tt = gvtst(1, 0);
} else {
vpop();
}
} else if (c < 0) {
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
/* needed to avoid having different registers saved in
each branch */
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);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
gv_dup();
tt = gvtst(0, 0);
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
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
ncw_prev = 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 (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
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
if (c < 0 && vtop->r == VT_CMP) {
t1 = gvtst(0, 0);
vpushi(0);
gvtst_set(0, t1);
}
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 */
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
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
if (g) {
u = tt;
} else if (c < 0) {
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 = gjmp(0);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
gsym(tt);
} else
u = 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, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
nocode_wanted = ncw_prev;
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++;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
skip(':');
Fix binding of assignment expressions.
2010-10-25 22:40:30 +08:00
expr_cond();
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
if (c < 0 && is_cond_bool(vtop) && is_cond_bool(&sv)) {
if (sv.r == VT_CMP) {
t1 = sv.jtrue;
t2 = u;
} else {
t1 = gvtst(0, 0);
t2 = gjmp(0);
gsym(u);
vpushv(&sv);
}
gvtst_set(0, t1);
gvtst_set(1, t2);
nocode_wanted = ncw_prev;
// tcc_warning("two conditions expr_cond");
return;
}
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;
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
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
rc = RC_TYPE(type.t);
/* for long longs, we use fixed registers to avoid having
to handle a complicated move */
if (USING_TWO_WORDS(type.t))
rc = RC_RET(type.t);
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);
Applying grischka proposed patch fixes error reported on 93_integer_promotion test as found on Debian buster / gcc 8.3 for ARM plateform
2019-06-26 11:26:20 +08:00
nocode_wanted = ncw_prev;
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
/* 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();
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
if (c < 0) {
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);
riscv: implement stdarg functions this also fixes passing of params > 16 bytes. In riscv they aren't passed by value on stack, but via reference (and because callees are allowed to modify by-ref params the caller must allocate an own copy per call). This fixes the stdarg parts of 73_arm.c.
2019-07-21 09:25:12 +08:00
move_reg(r2, r1, islv ? VT_PTR : type.t);
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
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);
Keep lvalue category on structs when evaluating ternary operator
2016-03-13 10:32:18 +08:00
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
if (islv)
indir();
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;
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
/* ------------------------------------------------------------------------- */
/* return from function */
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
#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);
riscv: rewrite parameter passing this fixes the ret_mixed_test of abitest.c, now everything of the testsuite works. The generic code for returns is good enough for our use, except in the specific case of a mixed int/float structures returned in registers, so instead of duplicating the whole generic gfunc_return function, add another modus for gfunc_sret: returning -1 makes the actual register transfer by a new backend function.
2019-08-11 03:21:43 +08:00
if (ret_nregs < 0) {
#ifdef TCC_TARGET_RISCV64
arch_transfer_ret_regs(0);
#endif
} else if (0 == ret_nregs) {
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
/* 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 */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
int size, addr, align, rc;
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
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;
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
rc = RC_RET(ret_type.t);
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
if (ret_nregs == 1)
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
gv(rc);
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
else {
for (;;) {
vdup();
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
gv(rc);
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
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 */
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
rc <<= 1;
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.i += regsize;
}
}
}
} else {
tccgen.c: cleanup reg classes wrap some copy&paste code into functions
2019-12-17 01:44:35 +08:00
gv(RC_RET(func_type->t));
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--; /* NOT vpop() because on x86 it would flush the fp stack */
}
#endif
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
static void check_func_return(void)
{
if ((func_vt.t & VT_BTYPE) == VT_VOID)
return;
if (!strcmp (funcname, "main")
&& (func_vt.t & VT_BTYPE) == VT_INT) {
/* main returns 0 by default */
vpushi(0);
gen_assign_cast(&func_vt);
gfunc_return(&func_vt);
} else {
tcc_warning("function might return no value: '%s'", funcname);
}
}
/* ------------------------------------------------------------------------- */
/* switch/case */
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
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
static void gtst_addr(int t, int a)
{
gsym_addr(gvtst(0, t), a);
}
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;
some smaller fixes - libtcc.c/tccpp.c: fix -U option for multiple input files - libtcc: remove decl of tcc_add_crt() for PE - tcc.h: define __i386__ and __x86_64__ for msvc - tcc.h: undef __attribute__ for __TINYC__ on gnu/linux platforms - tccelf.c: disable prepare_dynamic_rel unless x86/x64 - tccpe.c: construct rather than predefine PE section flags - tccpp.c: (alt.) fix access of dead stack variable after error/longjmp - x86_64-gen.c: fix func_alloca chain for nocode_wanted - tccpp.c/tccgen.c: improve file:line info for inline functions - winapi/winnt.h: correct position for DECLSPEC_ALIGN attribute - win32/lib/crt: simplify top exception handler (needed for signal) - arm64-gen.c: remove dprintf left from VT_CMP commit - tccgen.c: limit binary scan with gcase to > 8 (= smaller code) - tccgen.c: call save_regs(4) in gen_opl for cmp-ops (see test in tcctest.c)
2018-06-08 21:31:40 +08:00
while (len > 8) {
gcase() clean up remove tail recursion, simplify
2016-10-11 16:29:56 +08:00
/* 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);
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
e = gvtst(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);
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);
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
e = gvtst(1, 0);
gcase() clean up remove tail recursion, simplify
2016-10-11 16:29:56 +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);
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
}
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
*bsym = gjmp(*bsym);
switch: binary search
2016-10-03 18:14:34 +08:00
}
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
/* ------------------------------------------------------------------------- */
/* __attribute__((cleanup(fn))) */
static void try_call_scope_cleanup(Sym *stop)
{
Sym *cls = cur_scope->cl.s;
for (; cls != stop; cls = cls->ncl) {
Sym *fs = cls->next;
Sym *vs = cls->prev_tok;
vpushsym(&fs->type, fs);
vset(&vs->type, vs->r, vs->c);
vtop->sym = vs;
mk_pointer(&vtop->type);
gaddrof();
gfunc_call(1);
}
}
static void try_call_cleanup_goto(Sym *cleanupstate)
{
Sym *oc, *cc;
int ocd, ccd;
if (!cur_scope->cl.s)
return;
/* search NCA of both cleanup chains given parents and initial depth */
ocd = cleanupstate ? cleanupstate->v & ~SYM_FIELD : 0;
for (ccd = cur_scope->cl.n, oc = cleanupstate; ocd > ccd; --ocd, oc = oc->ncl)
;
for (cc = cur_scope->cl.s; ccd > ocd; --ccd, cc = cc->ncl)
;
for (; cc != oc; cc = cc->ncl, oc = oc->ncl, --ccd)
;
try_call_scope_cleanup(cc);
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
/* call 'func' for each __attribute__((cleanup(func))) */
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
static void block_cleanup(struct scope *o)
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
{
int jmp = 0;
Sym *g, **pg;
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
for (pg = &pending_gotos; (g = *pg) && g->c > o->cl.n;) {
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
if (g->prev_tok->r & LABEL_FORWARD) {
Sym *pcl = g->next;
if (!jmp)
jmp = gjmp(0);
gsym(pcl->jnext);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
try_call_scope_cleanup(o->cl.s);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
pcl->jnext = gjmp(0);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
if (!o->cl.n)
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
goto remove_pending;
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
g->c = o->cl.n;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
pg = &g->prev;
} else {
remove_pending:
*pg = g->prev;
sym_free(g);
}
}
gsym(jmp);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
try_call_scope_cleanup(o->cl.s);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
}
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
/* ------------------------------------------------------------------------- */
/* VLA */
static void vla_restore(int loc)
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
{
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
if (loc)
gen_vla_sp_restore(loc);
}
static void vla_leave(struct scope *o)
{
if (o->vla.num < cur_scope->vla.num)
vla_restore(o->vla.loc);
}
/* ------------------------------------------------------------------------- */
/* local scopes */
void new_scope(struct scope *o)
{
/* copy and link previous scope */
*o = *cur_scope;
o->prev = cur_scope;
cur_scope = o;
/* record local declaration stack position */
o->lstk = local_stack;
o->llstk = local_label_stack;
++local_scope;
}
void prev_scope(struct scope *o, int is_expr)
{
vla_leave(o->prev);
if (o->cl.s != o->prev->cl.s)
block_cleanup(o->prev);
/* pop locally defined labels */
label_pop(&local_label_stack, o->llstk, is_expr);
/* 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. */
/* pop locally defined symbols */
sym_pop(&local_stack, o->lstk, is_expr);
cur_scope = o->prev;
--local_scope;
}
/* leave a scope via break/continue(/goto) */
void leave_scope(struct scope *o)
{
if (!o)
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
return;
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
try_call_scope_cleanup(o->cl.s);
vla_leave(o);
}
/* ------------------------------------------------------------------------- */
/* call block from 'for do while' loops */
static void lblock(int *bsym, int *csym)
{
struct scope *lo = loop_scope, *co = cur_scope;
int *b = co->bsym, *c = co->csym;
if (csym) {
co->csym = csym;
loop_scope = co;
}
co->bsym = bsym;
block(0);
co->bsym = b;
if (csym) {
co->csym = c;
loop_scope = lo;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
}
}
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
static void block(int is_expr)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
int a, b, c, d, e, t;
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
if (is_expr) {
/* default return value is (void) */
vpushi(0);
vtop->type.t = VT_VOID;
}
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
again:
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
t = tok, next();
if (t == TOK_IF) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip('(');
gexpr();
skip(')');
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
a = gvtst(1, 0);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
block(0);
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
d = gjmp(0);
gsym(a);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
next();
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
block(0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(d); /* patch else jmp */
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(a);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
}
} else if (t == TOK_WHILE) {
d = gind();
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;
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
lblock(&a, &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
gjmp_addr(d);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym_addr(b, d);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
gsym(a);
} else if (t == '{') {
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
struct scope o;
new_scope(&o);
remove incr/decr_local_scope functions
2019-01-30 04:32:38 +08:00
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) {
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
do {
next();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok < TOK_UIDENT)
expect("label identifier");
label_push(&local_label_stack, tok, LABEL_DECLARED);
next();
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} while (tok == ',');
skip(';');
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
while (tok != '}') {
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
decl(VT_LOCAL);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (tok != '}') {
if (is_expr)
vpop();
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
block(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
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
prev_scope(&o, is_expr);
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
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
if (0 == local_scope && !nocode_wanted)
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
check_func_return();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
next();
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else if (t == TOK_RETURN) {
b = (func_vt.t & VT_BTYPE) != VT_VOID;
update gen_cast
2019-12-17 01:51:28 +08:00
if (tok != ';') {
gexpr();
if (b) {
gen_assign_cast(&func_vt);
} else {
if (vtop->type.t != VT_VOID)
tcc_warning("void function returns a value");
vtop--;
}
} else if (b) {
tcc_warning("'return' with no value");
b = 0;
}
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
leave_scope(root_scope);
update gen_cast
2019-12-17 01:51:28 +08:00
if (b)
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
gfunc_return(&func_vt);
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);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
CODE_OFF();
} else if (t == TOK_BREAK) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* compute jump */
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
if (!cur_scope->bsym)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("cannot break");
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
if (!cur_switch || cur_scope->bsym != cur_switch->bsym)
leave_scope(loop_scope);
else
leave_scope(cur_switch->scope);
*cur_scope->bsym = gjmp(*cur_scope->bsym);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(';');
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else if (t == TOK_CONTINUE) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* compute jump */
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
if (!cur_scope->csym)
rename error/warning -> tcc_(error/warning)
2011-08-11 23:07:56 +08:00
tcc_error("cannot continue");
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
leave_scope(loop_scope);
*cur_scope->csym = gjmp(*cur_scope->csym);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(';');
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else if (t == TOK_FOR) {
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
struct scope o;
new_scope(&o);
fix cleanup with for loop initialisation Signed-off-by: matthias <uso.cosmo.ray@gmail.com>
2019-04-30 11:44:15 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip('(');
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(';');
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
a = b = 0;
c = d = gind();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
d = gind();
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gexpr();
vpop();
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
gjmp_addr(c);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(e);
}
skip(')');
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
lblock(&a, &b);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
gjmp_addr(d);
gsym_addr(b, d);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(a);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
prev_scope(&o, 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
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else if (t == TOK_DO) {
a = b = 0;
d = gind();
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
lblock(&a, &b);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
gsym(b);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
skip(TOK_WHILE);
skip('(');
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();
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
skip(')');
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
c = gvtst(0, 0);
gsym_addr(c, d);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(a);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else if (t == 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;
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;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
sw.p = NULL;
sw.n = 0;
sw.def_sym = 0;
sw.bsym = &a;
sw.scope = cur_scope;
saved = cur_switch;
cur_switch = &sw;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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--;
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
a = 0;
b = gjmp(0); /* jump to first case */
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
lblock(&a, NULL);
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);
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +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
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");
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +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
/* 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);
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
gv(RC_INT);
d = 0, gcase(sw.p, sw.n, &d);
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
vpop();
if (sw.def_sym)
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
gsym_addr(d, sw.def_sym);
else
gsym(d);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* break label */
gsym(a);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
jump optimizations This unifies VT_CMP with VT_JMP(i) by using mostly VT_CMP with both a positive and a negative jump target list. Such we can delay putting the non-inverted or inverted jump until we can see which one is nore suitable (in most cases). example: if (a && b || c && d) e = 0; before this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 11 00 00 00 je 27 <main+0x27> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 84 05 00 00 00 je 27 <main+0x27> 22: e9 22 00 00 00 jmp 49 <main+0x49> 27: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 2a: 83 f8 00 cmp $0x0,%eax 2d: 0f 84 11 00 00 00 je 44 <main+0x44> 33: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 36: 83 f8 00 cmp $0x0,%eax 39: 0f 84 05 00 00 00 je 44 <main+0x44> 3f: e9 05 00 00 00 jmp 49 <main+0x49> 44: e9 08 00 00 00 jmp 51 <main+0x51> 49: b8 00 00 00 00 mov $0x0,%eax 4e: 89 45 ec mov %eax,0xffffffec(%ebp) 51: ... with this patch: a: 8b 45 fc mov 0xfffffffc(%ebp),%eax d: 83 f8 00 cmp $0x0,%eax 10: 0f 84 0c 00 00 00 je 22 <main+0x22> 16: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 19: 83 f8 00 cmp $0x0,%eax 1c: 0f 85 18 00 00 00 jne 3a <main+0x3a> 22: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 25: 83 f8 00 cmp $0x0,%eax 28: 0f 84 14 00 00 00 je 42 <main+0x42> 2e: 8b 45 f0 mov 0xfffffff0(%ebp),%eax 31: 83 f8 00 cmp $0x0,%eax 34: 0f 84 08 00 00 00 je 42 <main+0x42> 3a: b8 00 00 00 00 mov $0x0,%eax 3f: 89 45 ec mov %eax,0xffffffec(%ebp) 42: ...
2019-06-22 17:45:35 +08:00
dynarray_reset(&sw.p, &sw.n);
cur_switch = saved;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else if (t == 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");
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
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
cr->sym = gind();
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;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else if (t == TOK_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
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'");
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
cur_switch->def_sym = gind();
skip(':');
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
is_expr = 0;
goto block_after_label;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else if (t == TOK_GOTO) {
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
vla_restore(root_scope->vla.loc);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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();
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
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
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 */
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
if (cur_scope->cl.s && !nocode_wanted) {
sym_push2(&pending_gotos, SYM_FIELD, 0, cur_scope->cl.n);
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
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();
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
expect("label identifier");
}
skip(';');
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
} else if (t == TOK_ASM1 || t == TOK_ASM2 || t == TOK_ASM3) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
asm_instr();
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
if (tok == ':' && t >= TOK_UIDENT) {
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* 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();
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
s = label_find(t);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
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 {
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
s = label_push(&global_label_stack, t, LABEL_DEFINED);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
s->jnext = gind();
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
s->cleanupstate = cur_scope->cl.s;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
block_after_label:
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
vla_restore(cur_scope->vla.loc);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* we accept this, but it is a mistake */
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 {
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
goto again;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
} else {
/* expression case */
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
if (t != ';') {
unget_tok(t);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
if (is_expr) {
vpop();
gexpr();
} else {
gexpr();
vpop();
}
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
skip(';');
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
}
}
}
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;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +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)
goto no_designator;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
if (gnu_ext && tok >= TOK_UIDENT) {
l = tok, next();
if (tok == ':')
goto struct_field;
unget_tok(l);
}
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 invalid size with GNU designated initializers the uninitialized cumofs was leading to random sizes for the memset when initializing local structures, potentially leading to segfaults from it. Only a problem with GNU designated initializers, which we didn't test very well. See testcase.
2019-07-22 03:14:58 +08:00
int cumofs;
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 invalid size with GNU designated initializers the uninitialized cumofs was leading to random sizes for the memset when initializing local structures, potentially leading to segfaults from it. Only a problem with GNU designated initializers, which we didn't test very well. See testcase.
2019-07-22 03:14:58 +08:00
cumofs = 0;
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
Fix bounds checking for linux/windows
2019-12-10 15:07:25 +08:00
if (bcheck && ((type->t & VT_ARRAY) ||
(type->t & VT_BTYPE) == VT_STRUCT)) {
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
Fix bounds checking for linux/windows
2019-12-10 15:07:25 +08:00
'&' operators, so we add only arrays/structs/unions */
if (bcheck && ((type->t & VT_ARRAY) ||
(type->t & VT_BTYPE) == VT_STRUCT)) {
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) {
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
Sym *cls = sym_push2(&all_cleanups,
SYM_FIELD | ++cur_scope->cl.n, 0, 0);
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
cls->prev_tok = sym;
cls->next = ad->cleanup_func;
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
cls->ncl = cur_scope->cl.s;
cur_scope->cl.s = 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
}
/* 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 */
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
if (root_scope->vla.loc == 0) {
struct scope *v = cur_scope;
gen_vla_sp_save(loc -= PTR_SIZE);
do v->vla.loc = loc; while ((v = v->prev));
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
}
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);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
cur_scope->vla.loc = addr;
cur_scope->vla.num++;
Fix bounds checking for linux/windows
2019-12-10 15:07:25 +08:00
#ifdef CONFIG_TCC_BCHECK
if (bcheck) {
addr_t *bounds_ptr;
bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(addr_t));
bounds_ptr[0] = 1; /* marks alloca/vla used */
bounds_ptr[1] = 0;
}
#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
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' */
Add constructor/destructor support
2019-10-29 14:02:58 +08:00
static void gen_function(Sym *sym, AttributeDef *ad)
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
{
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
/* Initialize VLA state */
struct scope f = { 0 };
cur_scope = root_scope = &f;
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);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
Add constructor/destructor support
2019-10-29 14:02:58 +08:00
if (ad && ad->a.constructor) {
add_init_array (tcc_state, sym);
}
if (ad && ad->a.destructor) {
add_fini_array (tcc_state, sym);
}
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;
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
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 */
Fix bounds checking for linux/windows
2019-12-10 15:07:25 +08:00
gfunc_prolog(sym);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
local_scope = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
rsym = 0;
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
clear_temp_local_var_list();
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
block(0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gsym(rsym);
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
nocode_wanted = 0;
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
gfunc_epilog();
cur_text_section->data_offset = ind;
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 */
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);
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
local_scope = 0;
label_pop(&global_label_stack, NULL, 0);
sym_pop(&all_cleanups, NULL, 0);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
/* 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;
introduce scopes for VLA & attribute cleanup
2019-06-22 19:18:54 +08:00
/* end of function */
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;
some smaller fixes - libtcc.c/tccpp.c: fix -U option for multiple input files - libtcc: remove decl of tcc_add_crt() for PE - tcc.h: define __i386__ and __x86_64__ for msvc - tcc.h: undef __attribute__ for __TINYC__ on gnu/linux platforms - tccelf.c: disable prepare_dynamic_rel unless x86/x64 - tccpe.c: construct rather than predefine PE section flags - tccpp.c: (alt.) fix access of dead stack variable after error/longjmp - x86_64-gen.c: fix func_alloca chain for nocode_wanted - tccpp.c/tccgen.c: improve file:line info for inline functions - winapi/winnt.h: correct position for DECLSPEC_ALIGN attribute - win32/lib/crt: simplify top exception handler (needed for signal) - arm64-gen.c: remove dprintf left from VT_CMP commit - tccgen.c: limit binary scan with gcase to > 8 (= smaller code) - tccgen.c: call save_regs(4) in gen_opl for cmp-ops (see test in tcctest.c)
2018-06-08 21:31:40 +08:00
int inline_generated, i;
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
some smaller fixes - libtcc.c/tccpp.c: fix -U option for multiple input files - libtcc: remove decl of tcc_add_crt() for PE - tcc.h: define __i386__ and __x86_64__ for msvc - tcc.h: undef __attribute__ for __TINYC__ on gnu/linux platforms - tccelf.c: disable prepare_dynamic_rel unless x86/x64 - tccpe.c: construct rather than predefine PE section flags - tccpp.c: (alt.) fix access of dead stack variable after error/longjmp - x86_64-gen.c: fix func_alloca chain for nocode_wanted - tccpp.c/tccgen.c: improve file:line info for inline functions - winapi/winnt.h: correct position for DECLSPEC_ALIGN attribute - win32/lib/crt: simplify top exception handler (needed for signal) - arm64-gen.c: remove dprintf left from VT_CMP commit - tccgen.c: limit binary scan with gcase to > 8 (= smaller code) - tccgen.c: call save_regs(4) in gen_opl for cmp-ops (see test in tcctest.c)
2018-06-08 21:31:40 +08:00
tcc_open_bf(s, ":inline:", 0);
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;
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
if (sym && (sym->c || !(sym->type.t & VT_INLINE))) {
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
/* 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;
tccrun.c: better stab debug support * a major revision of the rt_printline() feature in tccrun.c to report file:linenumber more correctly. * minor changes to the stab info produced by the compiler in tccgen.c However stab addresses are limited to 32 bits. I added a work around: if (sizeof pc == 8) pc |= wanted_pc & 0xffffffff00000000ULL; However GDB has problems with that too.
2019-12-14 19:36:12 +08:00
tcc_debug_putfile(s, 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;
Add constructor/destructor support
2019-10-29 14:02:58 +08:00
gen_function(sym, NULL);
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);
some smaller fixes - libtcc.c/tccpp.c: fix -U option for multiple input files - libtcc: remove decl of tcc_add_crt() for PE - tcc.h: define __i386__ and __x86_64__ for msvc - tcc.h: undef __attribute__ for __TINYC__ on gnu/linux platforms - tccelf.c: disable prepare_dynamic_rel unless x86/x64 - tccpe.c: construct rather than predefine PE section flags - tccpp.c: (alt.) fix access of dead stack variable after error/longjmp - x86_64-gen.c: fix func_alloca chain for nocode_wanted - tccpp.c/tccgen.c: improve file:line info for inline functions - winapi/winnt.h: correct position for DECLSPEC_ALIGN attribute - win32/lib/crt: simplify top exception handler (needed for signal) - arm64-gen.c: remove dprintf left from VT_CMP commit - tccgen.c: limit binary scan with gcase to > 8 (= smaller code) - tccgen.c: call save_regs(4) in gen_opl for cmp-ops (see test in tcctest.c)
2018-06-08 21:31:40 +08:00
tcc_close();
tccpp_new/delete and other cleanups
2016-10-18 05:24:01 +08:00
}
allow libtcc states to be used concurrently This allows creation of TCCStates and operation with API calls independently from each other, even from threads. Frontend (option parsing/libtcc.c) and backend (linker/tccelf.c) now depend only on the TCCState (s1) argument. Compilation per se (tccpp.c, tccgen.c) is still using globals for convenience. There is only one entry point to this section which is tcc_compile() which is protected by a semaphore. There are some hacks involved to avoid too many changes, as well as some changes in order to avoid too many hacks ;) The test libtcc_test_mt.c shows the feature. Except this new file the patch adds 87 lines overall.
2019-12-11 07:37:18 +08:00
static void free_inline_functions(TCCState *s)
tccpp_new/delete and other cleanups
2016-10-18 05:24:01 +08:00
{
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) {
Readd lost error on local static function decls see testcase: block scope decls for functions can't use static (allowed is only extern or none). This got lost in commit 85690480.
2019-12-16 13:54:18 +08:00
if ((type.t & VT_STATIC) && (l == VT_LOCAL))
tcc_error("function without file scope cannot be static");
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);
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
/* always compile 'extern inline' */
if (type.t & VT_EXTERN)
type.t &= ~VT_INLINE;
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);
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
#if 0
/* gcc does not allow __asm__("label") with function definition,
but why not ... */
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(";");
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
#endif
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) {
win: ignore dllimport/dllexport for typedef with warning instead of error Keep the same as gcc and clang. The usage exists in MinGW-w64 headers.
2019-06-29 09:42:25 +08:00
if (type.t & VT_STATIC)
tcc_error("cannot have dll linkage with static");
if (type.t & VT_TYPEDEF) {
tcc_warning("'%s' attribute ignored for typedef",
ad.a.dllimport ? (ad.a.dllimport = 0, "dllimport") :
(ad.a.dllexport = 0, "dllexport"));
} else if (ad.a.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
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 */
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
type.t &= ~VT_EXTERN;
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);
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 */
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
if (sym->type.t & 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;
Add constructor/destructor support
2019-10-29 14:02:58 +08:00
gen_function(sym, &ad);
move parser/generator to tccgen.c
2009-05-06 02:18:10 +08:00
}
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 */
remove VT_LVAL_BYTE etc. For some reason there was no point for that anymore.
2019-12-17 01:48:31 +08:00
r |= VT_LVAL;
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");
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
if (((type.t & VT_EXTERN) && (!has_init || l != VT_CONST))
|| (type.t & VT_BTYPE) == VT_FUNC
/* as with GCC, uninitialized global arrays with no size
are considered extern: */
|| ((type.t & VT_ARRAY) && !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 */
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
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");
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();
work on local extern declarations Example: int a = 1; void f(void) { int a = 2; { extern int a; // = 1 !! .... To get this (more) correctly there is a new function to copy syms between local to global stacks. Also, this patch changes the meaning of VT_EXTERN back to the simpler and IMO more useful notion of DECLARED but not (yet) DEFINED. and that for both variables and functions. That is, VT_EXTERN in tcc doesn't have to do with the keyword 'extern' necessarily. Also this patch does allow int x[]; as alias for extern int x[]; (as do gcc and msvc)
2019-06-22 10:00:52 +08:00
else if (l == VT_CONST)
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
/* ------------------------------------------------------------------------- */
nocode, noreturn A more automatic approach to code suppression (aka. nocode_wanted) The simple rules are: - Clear 'nocode_wanted' at (im/explicit) label IF it was used - Set 'nocode_wanted' after unconditional jumps Also in order to test this then I did add the "function might return no value" warning, and then to make that work again I did add the __attribute__((noreturn)). Also moved the look ahead label check into the type parser to gain a little speed.
2019-04-29 19:53:07 +08:00
#undef gjmp_addr
#undef gjmp
/* ------------------------------------------------------------------------- */
Reference in New Issue Copy Permalink