After several days searching why my code refactoring to remove globals was crashing, I found the problem it was because CValue stack variables have rubish as it inital values and assigning to a member that is smaller than the big union item and trying to recover it later as a different member gives bak garbage.

ST_FUNC void vset(TCCState* tcc_state, CType *type, int r, int v) { CValue cval; memset(&cval, 0, sizeof(CValue)); cval.i = v; //,<<<<<<<<<<< here is the main bug that mix with garbage vsetc(tcc_state, type, r, &cval); } /* store a value or an expression directly in global data or in local array */ static void init_putv(TCCState* tcc_state, CType *type, Section *sec, unsigned long c, int v, int expr_type) { ... case VT_PTR: if (tcc_state->tccgen_vtop->r & VT_SYM) { greloc(tcc_state, sec, tcc_state->tccgen_vtop->sym, c, R_DATA_PTR); } //<<< on the next line is where we try to get the assigned value to cvalue.i as cvalue.ull *(addr_t *)ptr |= (tcc_state->tccgen_vtop->c.ull & bit_mask) << bit_pos; break; Also this patch makes vla tests pass on linux 32 bits

mingodad committed 12 years ago

Commit 4bc83ac1 parent aa561d72 files · +20 −5Browse files

Unified · Split

2 files

tccgen.c +8 −1
tccpp.c +12 −4

tccgen.c+8−1

 void vpush(CType *type)
 {
     CValue cval;
+    memset(&cval, 0, sizeof(CValue));
     vsetc(type, VT_CONST, &cval);
 }
 ST_FUNC void vpushi(int v)
 {
     CValue cval;
+    memset(&cval, 0, sizeof(CValue));
     cval.i = v;
     vsetc(&int_type, VT_CONST, &cval);
 }
 static void vpushs(long long v)
 {
   CValue cval;
+  memset(&cval, 0, sizeof(CValue));
   if (PTR_SIZE == 4)
     cval.i = (int)v;
   else
 /* push arbitrary 64bit constant */
 void vpush64(int ty, unsigned long long v)
 {
-    CValue cval;
     CType ctype;
+    CValue cval;
+    memset(&cval, 0, sizeof(CValue));
     ctype.t = ty;
     ctype.ref = NULL;
     cval.ull = v;
 static inline void vpushsym(CType *type, Sym *sym)
 {
     CValue cval;
+    memset(&cval, 0, sizeof(CValue));
     cval.ull = 0;
     vsetc(type, VT_CONST | VT_SYM, &cval);
 ST_FUNC void vset(CType *type, int r, int v)
 {
     CValue cval;
+    memset(&cval, 0, sizeof(CValue));
     cval.i = v;
     vsetc(type, r, &cval);
             unsigned long offset;
 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
             CValue check;
+            memset(&check, 0, sizeof(CValue));
 #endif
             /* XXX: unify with initializers handling ? */

tccpp.c+12−4

 ST_FUNC void tok_str_add_tok(TokenString *s)
 {
     CValue cval;
+    memset(&cval, 0, sizeof(CValue));
     /* save line number info */
     if (file->line_num != s->last_line_num) {
 static int macro_is_equal(const int *a, const int *b)
 {
     char buf[STRING_MAX_SIZE + 1];
-    CValue cv;
     int t;
+    CValue cv;
+    memset(&cv, 0, sizeof(CValue));
     while (*a && *b) {
         TOK_GET(&t, &a, &cv);
         pstrcpy(buf, sizeof buf, get_tok_str(t, &cv));
 {
     int t;
     CValue cval;
+    memset(&cval, 0, sizeof(CValue));
     printf("<");
     while (1) {
     int last_tok, t, spc;
     const int *st;
     Sym *s;
-    CValue cval;
     TokenString str;
     CString cstr;
+    CValue cval;
+    memset(&cval, 0, sizeof(CValue));
     tok_str_new(&str);
     last_tok = 0;
     const int *p;
     TokenString str;
     char *cstrval;
-    CValue cval;
     CString cstr;
     char buf[32];
+    CValue cval;
+    memset(&cval, 0, sizeof(CValue));
     /* if symbol is a macro, prepare substitution */
     /* special macros */
     /* we search the first '##' */
     for(ptr = macro_str;;) {
         CValue cval;
+        memset(&cval, 0, sizeof(CValue));
         TOK_GET(&t, &ptr, &cval);
         if (t == TOK_TWOSHARPS)
             break;
                 t = *++ptr;
             if (t && t != TOK_TWOSHARPS) {
                 CValue cval;
+                memset(&cval, 0, sizeof(CValue));
                 TOK_GET(&t, &ptr, &cval);
                 /* We concatenate the two tokens */
                 cstr_new(&cstr);
     int *macro_str1;
     const int *ptr;
     int t, ret, spc;
-    CValue cval;
     struct macro_level ml;
     int force_blank;
+    CValue cval;
+    memset(&cval, 0, sizeof(CValue));
     /* first scan for '##' operator handling */
     ptr = macro_str;

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code