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.

Michael Matz committed 7 years ago

Commit c07e81b1 parent f2461095 files · +20 −26Browse files

Unified · Split

5 files

i386-gen.c +2 −2
tcc.h +1 −1
tccasm.c +1 −3
tccgen.c +13 −17
x86_64-gen.c +3 −3

i386-gen.c+2−2

@@ -341,7 +341,7 @@ static void gen_static_call(int v) · 340 unmodified lines
341	{	341	{
342	Sym *sym;	342	Sym *sym;
343		343
344	sym = external_global_sym(v, &func_old_type, 0);	344	sym = external_global_sym(v, &func_old_type);
345	oad(0xe8, -4);	345	oad(0xe8, -4);
346	greloc(cur_text_section, sym, ind-4, R_386_PC32);	346	greloc(cur_text_section, sym, ind-4, R_386_PC32);
347	}	347	}
@@ -1125,7 +1125,7 @@ ST_FUNC void gen_bounded_ptr_deref(void) · 777 unmodified lines
1125	/* patch relocation */	1125	/* patch relocation */
1126	/* XXX: find a better solution ? */	1126	/* XXX: find a better solution ? */
1127	rel = (Elf32_Rel *)(cur_text_section->reloc->data + vtop->c.i);	1127	rel = (Elf32_Rel *)(cur_text_section->reloc->data + vtop->c.i);
1128	sym = external_global_sym(func, &func_old_type, 0);	1128	sym = external_global_sym(func, &func_old_type);
1129	if (!sym->c)	1129	if (!sym->c)
1130	put_extern_sym(sym, NULL, 0, 0);	1130	put_extern_sym(sym, NULL, 0, 0);
1131	rel->r_info = ELF32_R_INFO(sym->c, ELF32_R_TYPE(rel->r_info));	1131	rel->r_info = ELF32_R_INFO(sym->c, ELF32_R_TYPE(rel->r_info));

tcc.h+1−1

@@ -1318,7 +1318,7 @@ ST_FUNC void test_lvalue(void); · 1317 unmodified lines
1318	ST_FUNC void vpushi(int v);	1318	ST_FUNC void vpushi(int v);
1319	ST_FUNC ElfSym elfsym(Sym );	1319	ST_FUNC ElfSym elfsym(Sym );
1320	ST_FUNC void update_storage(Sym *sym);	1320	ST_FUNC void update_storage(Sym *sym);
1321	ST_FUNC Sym external_global_sym(int v, CType type, int r);	1321	ST_FUNC Sym external_global_sym(int v, CType type);
1322	ST_FUNC void vset(CType *type, int r, int v);	1322	ST_FUNC void vset(CType *type, int r, int v);
1323	ST_FUNC void vswap(void);	1323	ST_FUNC void vswap(void);
1324	ST_FUNC void vpush_global_sym(CType *type, int v);	1324	ST_FUNC void vpush_global_sym(CType *type, int v);

tccasm.c+1−3

     /* We always add VT_EXTERN, for sym definition that's tentative
        (for .set, removed for real defs), for mere references it's correct
        as is.  */
-    Sym *sym = global_identifier_push(v, VT_ASM | VT_EXTERN | VT_STATIC, 0);
+    return global_identifier_push(v, VT_ASM | VT_EXTERN | VT_STATIC, 0);
-    sym->r = VT_CONST | VT_SYM;
-    return sym;
 }
 /* Return a symbol we can use inside the assembler, having name NAME.

tccgen.c+13−17

 {
     Sym *s, **ps;
     s = sym_push2(&global_stack, v, t, c);
+    s->r = VT_CONST | VT_SYM;
     /* don't record anonymous symbol */
     if (v < SYM_FIRST_ANOM) {
         ps = &table_ident[v - TOK_IDENT]->sym_identifier;
-        /* modify the top most local identifier, so that
+        /* modify the top most local identifier, so that sym_identifier will
-           sym_identifier will point to 's' when popped */
+           point to 's' when popped; happens when called from inline asm */
         while (*ps != NULL && (*ps)->sym_scope)
             ps = &(*ps)->prev_tok;
         s->prev_tok = *ps;
     Sym *sym;
     v = anon_sym++;
-    sym = global_identifier_push(v, type->t | VT_STATIC, 0);
+    sym = sym_push(v, type, VT_CONST | VT_SYM, 0);
-    sym->type.ref = type->ref;
+    sym->type.t |= VT_STATIC;
-    sym->r = VT_CONST | VT_SYM;
     put_extern_sym(sym, sec, offset, size);
     return sym;
 }
 }
 /* define a new external reference to a symbol 'v' of type 'u' */
-ST_FUNC Sym *external_global_sym(int v, CType *type, int r)
+ST_FUNC Sym *external_global_sym(int v, CType *type)
 {
     Sym *s;
         /* push forward reference */
         s = global_identifier_push(v, type->t | VT_EXTERN, 0);
         s->type.ref = type->ref;
-        s->r = r | VT_CONST | VT_SYM;
     } else if (IS_ASM_SYM(s)) {
         s->type.t = type->t | (s->type.t & VT_EXTERN);
         s->type.ref = type->ref;
             tcc_error("conflicting types for '%s'", get_tok_str(s->v, NULL));
         /* push forward reference */
         s = sym_push(v, type, r | VT_CONST | VT_SYM, 0);
-        s->type.t |= VT_EXTERN;
         s->a = ad->a;
         s->sym_scope = 0;
     } else {
 /* push a reference to global symbol v */
 ST_FUNC void vpush_global_sym(CType *type, int v)
 {
-    vpushsym(type, external_global_sym(v, type, 0));
+    vpushsym(type, external_global_sym(v, type));
 }
 /* save registers up to (vtop - n) stack entry */
 	    if (!s) {
 	      tcc_warning("implicit declaration of function '%s'",
 			  get_tok_str(tok, &tokc));
-	      s = external_global_sym(tok, &func_old_type, 0);
+	      s = external_global_sym(tok, &func_old_type);
 	    }
 	    ad->cleanup_func = s;
 	    next();
 #endif
             )
                 tcc_warning("implicit declaration of function '%s'", name);
-            s = external_global_sym(t, &func_old_type, 0);
+            s = external_global_sym(t, &func_old_type);
         }
         r = s->r;
 	    put_extern_sym(sym, sec, addr, size);
         } else {
             /* push global reference */
-            sym = get_sym_ref(type, sec, addr, size);
+            vpush_ref(type, sec, addr, size);
-	    vpushsym(type, sym);
+            sym = vtop->sym;
 	    vtop->r |= r;
         }
                     type.t = (type.t & ~VT_EXTERN) | VT_STATIC;
                 /* put function symbol */
-                sym = external_global_sym(v, &type, 0);
+                sym = external_sym(v, &type, 0, &ad);
-                type.t &= ~VT_EXTERN;
-                patch_storage(sym, &ad, &type);
                 /* 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 */
                 if ((type.t & (VT_INLINE | VT_STATIC)) ==
                     (VT_INLINE | VT_STATIC)) {
                     struct InlineFunc *fn;
                     const char *filename;

x86_64-gen.c+3−3

@@ -649,7 +649,7 @@ static unsigned long func_bound_ind; · 648 unmodified lines
649		649
650	static void gen_static_call(int v)	650	static void gen_static_call(int v)
651	{	651	{
652	Sym *sym = external_global_sym(v, &func_old_type, 0);	652	Sym *sym = external_global_sym(v, &func_old_type);
653	oad(0xe8, 0);	653	oad(0xe8, 0);
654	greloca(cur_text_section, sym, ind-4, R_X86_64_PC32, -4);	654	greloca(cur_text_section, sym, ind-4, R_X86_64_PC32, -4);
655	}	655	}
@@ -713,7 +713,7 @@ ST_FUNC void gen_bounded_ptr_deref(void) · 57 unmodified lines
713	break;	713	break;
714	}	714	}
715		715
716	sym = external_global_sym(func, &func_old_type, 0);	716	sym = external_global_sym(func, &func_old_type);
717	if (!sym->c)	717	if (!sym->c)
718	put_extern_sym(sym, NULL, 0, 0);	718	put_extern_sym(sym, NULL, 0, 0);
719		719
@@ -1031,7 +1031,7 @@ void gfunc_epilog(void) · 311 unmodified lines
1031	v = (func_scratch + -loc + 15) & -16;	1031	v = (func_scratch + -loc + 15) & -16;
1032		1032
1033	if (v >= 4096) {	1033	if (v >= 4096) {
1034	Sym *sym = external_global_sym(TOK___chkstk, &func_old_type, 0);	1034	Sym *sym = external_global_sym(TOK___chkstk, &func_old_type);
1035	oad(0xb8, v); /* mov stacksize, %eax */	1035	oad(0xb8, v); /* mov stacksize, %eax */
1036	oad(0xe8, 0); /* call __chkstk, (does the stackframe too) */	1036	oad(0xe8, 0); /* call __chkstk, (does the stackframe too) */
1037	greloca(cur_text_section, sym, ind-4, R_X86_64_PC32, -4);	1037	greloca(cur_text_section, sym, ind-4, R_X86_64_PC32, -4);

Tidy some code

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code