tccgen: asm_label cleanup

- avoid memory allocation by using its (int) token number - avoid additional function parameter by using Attribute

grischka committed 10 years ago

Commit 54cf57a1 parent 992cbda4 files · +42 −42Browse files

Unified · Split

4 files

libtcc.c +1 −1
tcc.h +2 −1
tccgen.c +30 −39
tccpp.c +9 −1

@@ -680,7 +680,7 @@ ST_FUNC void put_extern_sym2(Sym sym, Section section, · 679 unmodified lines
680	name = buf1;	680	name = buf1;
681	}	681	}
682	if (sym->asm_label) {	682	if (sym->asm_label) {
683	name = sym->asm_label;	683	name = get_tok_str(sym->asm_label, NULL);
684	}	684	}
685	info = ELFW(ST_INFO)(sym_bind, sym_type);	685	info = ELFW(ST_INFO)(sym_bind, sym_type);
686	sym->c = add_elf_sym(symtab_section, value, size, info, other, sh_num, name);	686	sym->c = add_elf_sym(symtab_section, value, size, info, other, sh_num, name);

tcc.h+2−1

     struct Attribute a;
     struct Section *section;
     int alias_target;    /* token */
+    int asm_label;    /* associated asm label */
 } AttributeDef;
 /* symbol management */
 typedef struct Sym {
     int v;    /* symbol token */
-    char *asm_label;    /* associated asm label */
+    int asm_label;    /* associated asm label */
     union {
         long r;    /* associated register */
         struct Attribute a;

tccgen.c+30−39

 static void parse_expr_type(CType *type);
 static void decl_initializer(CType *type, Section *sec, unsigned long c, int first, int size_only);
 static void block(int *bsym, int *csym, int *case_sym, int *def_sym, int case_reg, int is_expr);
-static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, int has_init, int v, char *asm_label, int scope);
+static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, int has_init, int v, int scope);
 static int decl0(int l, int is_for_loop_init);
 static void expr_eq(void);
 static void unary_type(CType *type);
 ST_INLN void sym_free(Sym *sym)
 {
     sym->next = sym_free_first;
-    tcc_free(sym->asm_label);
     sym_free_first = sym;
 }
                           get_tok_str(v, NULL));
     }
     s = sym_malloc();
-    s->asm_label = NULL;
+    s->asm_label = 0;
     s->v = v;
     s->type.t = t;
     s->type.ref = NULL;
     return s;
 }
-/* define a new external reference to a symbol 'v' with alternate asm
+/* define a new external reference to a symbol 'v' */
-   name 'asm_label' of type 'u'. 'asm_label' is equal to NULL if there
+static Sym *external_sym(int v, CType *type, int r)
-   is no alternate name (most cases) */
-static Sym *external_sym(int v, CType *type, int r, char *asm_label)
 {
     Sym *s;
     if (!s) {
         /* push forward reference */
         s = sym_push(v, type, r | VT_CONST | VT_SYM, 0);
-        s->asm_label = asm_label ? tcc_strdup(asm_label) : 0;
         s->type.t |= VT_EXTERN;
     } else if (s->type.ref == func_old_type.ref) {
         s->type.ref = type->ref;
     cstr_ccat(astr, '\0');
 }
-/* Parse an asm label and return the label
+/* Parse an asm label and return the token */
- * Don't forget to free the CString in the caller! */
+static int asm_label_instr(void)
-static void asm_label_instr(CString *astr)
 {
+    int v;
+    CString astr;
     next();
-    parse_asm_str(astr);
+    parse_asm_str(&astr);
     skip(')');
 #ifdef ASM_DEBUG
-    printf("asm_alias: \"%s\"\n", (char *)astr->data);
+    printf("asm_alias: \"%s\"\n", (char *)astr.data);
 #endif
+    v = tok_alloc(astr.data, astr.size - 1)->tok;
+    cstr_free(&astr);
+    return v;
 }
 static void post_type(CType *type, AttributeDef *ad)
         mk_pointer(&type);
         type.t |= VT_ARRAY;
         memset(&ad, 0, sizeof(AttributeDef));
-        decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, NULL, 0);
+        decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0);
         break;
     case '(':
         next();
                 if (!(type.t & VT_ARRAY))
                     r |= lvalue_type(type.t);
                 memset(&ad, 0, sizeof(AttributeDef));
-                decl_initializer_alloc(&type, &ad, r, 1, 0, NULL, 0);
+                decl_initializer_alloc(&type, &ad, r, 1, 0, 0);
             } else {
                 if (sizeof_caller) {
                     vpush(&type);
                     break;
             }
             if (!s)
-                tcc_error("field not found: %s",  get_tok_str(tok & ~SYM_FIELD, NULL));
+                tcc_error("field not found: %s",  get_tok_str(tok & ~SYM_FIELD, &tokc));
             /* add field offset to pointer */
             vtop->type = char_pointer_type; /* change type to 'char *' */
             vpushi(s->c);
 /* 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
-   variable 'v' with an associated name represented by 'asm_label' of
+   variable 'v' of scope 'scope' is declared before initializers
-   scope 'scope' is declared before initializers are parsed. If 'v' is
+   are parsed. If 'v' is zero, then a reference to the new object
-   zero, then a reference to the new object is put in the value stack.
+   is put in the value stack. If 'has_init' is 2, a special parsing
-   If 'has_init' is 2, a special parsing is done to handle string
+   is done to handle string constants. */
-   constants. */
 static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
-                                   int has_init, int v, char *asm_label,
+                                   int has_init, int v, int scope)
-                                   int scope)
 {
     int size, align, addr, data_offset;
     int level;
         if (v) {
             if (scope != VT_CONST || !sym) {
                 sym = sym_push(v, type, r | VT_SYM, 0);
-                sym->asm_label = asm_label ? tcc_strdup(asm_label) : 0;
+                sym->asm_label = ad->asm_label;
             }
             /* update symbol definition */
             if (sec) {
     CType type, btype;
     Sym *sym;
     AttributeDef ad;
-    char *asm_label = 0; // associated asm label
     while (1) {
         if (!parse_btype(&btype, &ad)) {
                     func_decl_list(sym);
             }
-            tcc_free(asm_label);
-            asm_label = 0;
             if (gnu_ext && (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) {
-                CString astr;
+                ad.asm_label = asm_label_instr();
-                asm_label_instr(&astr);
-                asm_label = tcc_strdup(astr.data);
-                cstr_free(&astr);
                 /* parse one last attribute list, after asm label */
                 parse_attribute(&ad);
+                if (tok == '{')
+                    expect(";");
             }
             if (ad.a.weak)
                         /* NOTE: as GCC, uninitialized global static
                            arrays of null size are considered as
                            extern */
-                        sym = external_sym(v, &type, r, asm_label);
+                        sym = external_sym(v, &type, r);
+                        sym->asm_label = ad.asm_label;
                         if (ad.alias_target) {
                             Section tsec;
                             r |= l;
                         if (has_init)
                             next();
-                        decl_initializer_alloc(&type, &ad, r, has_init, v, asm_label, l);
+                        decl_initializer_alloc(&type, &ad, r, has_init, v, l);
                     }
                 }
                 if (tok != ',') {
-                    if (is_for_loop_init) {
+                    if (is_for_loop_init)
-                        tcc_free(asm_label);
                         return 1;
-                    }
                     skip(';');
                     break;
                 }
             ad.a.aligned = 0;
         }
     }
-    tcc_free(asm_label);
     return 0;
 }

tccpp.c+9−1

         break;
     case TOK_CFLOAT:
+        cstr_cat(&cstr_buf, "<float>");
+        break;
     case TOK_CDOUBLE:
+	cstr_cat(&cstr_buf, "<double>");
+	break;
     case TOK_CLDOUBLE:
+	cstr_cat(&cstr_buf, "<long double>");
+	break;
     case TOK_LINENUM:
-        return NULL; /* should not happen */
+	cstr_cat(&cstr_buf, "<linenumber>");
+	break;
+        //return NULL; /* should not happen */
     /* above tokens have value, the ones below don't */

tccgen: asm_label cleanup

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code