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.

Michael Matz committed 8 years ago

Commit 9e0d23c1 parent 3494e5d8 files · +165 −189Browse files

Unified · Split

8 files

i386-asm.c +7 −8
tcc.h +7 −4
tccasm.c +90 −152
tccelf.c +9 −3
tccgen.c +42 −21
tccpp.c +0 −1
tests/asm-c-connect-1.c +7 −0
tests/asm-c-connect-2.c +3 −0

i386-asm.c+7−8

 static void gen_disp32(ExprValue *pe)
 {
     Sym *sym = pe->sym;
-    if (sym && sym->r == cur_text_section->sh_num) {
+    ElfSym *esym = elfsym(sym);
+    if (esym && esym->st_shndx == cur_text_section->sh_num) {
         /* same section: we can output an absolute value. Note
            that the TCC compiler behaves differently here because
            it always outputs a relocation to ease (future) code
            elimination in the linker */
-        gen_le32(pe->v + sym->jnext - ind - 4);
+        gen_le32(pe->v + esym->st_value - ind - 4);
     } else {
         if (sym && sym->type.t == VT_VOID) {
             sym->type.t = VT_FUNC;
     if (pa->instr_type & OPC_B)
         v += s >= 1;
     if (nb_ops == 1 && pa->op_type[0] == OPT_DISP8) {
-        Sym *sym;
+	ElfSym *esym;
         int jmp_disp;
         /* see if we can really generate the jump with a byte offset */
-        sym = ops[0].e.sym;
+	esym = elfsym(ops[0].e.sym);
-        if (!sym)
+        if (!esym || esym->st_shndx != cur_text_section->sh_num)
             goto no_short_jump;
-        if (sym->r != cur_text_section->sh_num)
+        jmp_disp = ops[0].e.v + esym->st_value - ind - 2 - (v >= 0xff);
-            goto no_short_jump;
-        jmp_disp = ops[0].e.v + sym->jnext - ind - 2 - (v >= 0xff);
         if (jmp_disp == (int8_t)jmp_disp) {
             /* OK to generate jump */
 	    ops[0].e.sym = 0;

tcc.h+7−4

 #endif
 /* target address type */
 #define addr_t ElfW(Addr)
+#define ElfSym ElfW(Sym)
 #if PTR_SIZE == 8 && !defined TCC_TARGET_PE
 # define LONG_SIZE 8
     struct Sym *sym_label; /* direct pointer to label */
     struct Sym *sym_struct; /* direct pointer to structure */
     struct Sym *sym_identifier; /* direct pointer to identifier */
-    struct Sym *sym_asm_label; /* direct pointer to asm label */
     int tok; /* token number */
     int len;
     char str[1];
     visibility  : 2,
     dllexport   : 1,
     dllimport   : 1,
-    asmcsym     : 1,
     asmexport   : 1,
-    unused      : 3;
+    unused      : 4;
 };
 /* function attributes or temporary attributes for parsing */
     int nb_sym_attrs;
     /* tiny assembler state */
     Sym *asm_labels;
+    ElfSym esym_dot;
 #ifdef TCC_TARGET_PE
     /* PE info */
 ST_FUNC void sym_pop(Sym **ptop, Sym *b, int keep);
 ST_INLN Sym *struct_find(int v);
 ST_INLN Sym *sym_find(int v);
-ST_FUNC Sym *global_identifier_push(int v, int t, int c);
+ST_FUNC Sym *global_identifier_push_1(Sym **, int v, int t, int c);
 ST_FUNC void tcc_open_bf(TCCState *s1, const char *filename, int initlen);
 ST_FUNC int tcc_open(TCCState *s1, const char *filename);
 ST_FUNC int ieee_finite(double d);
 ST_FUNC void test_lvalue(void);
 ST_FUNC void vpushi(int v);
+ST_FUNC ElfSym *elfsym(Sym *);
 ST_FUNC Sym *external_global_sym(int v, CType *type, int r);
 ST_FUNC void vset(CType *type, int r, int v);
 ST_FUNC void vswap(void);
 # define ST_PE_IMPORT 0x20
 # define ST_PE_STDCALL 0x40
 #endif
+#define ST_ASM_SET 0x04
 /* ------------ tccrun.c ----------------- */
 #ifdef TCC_IS_NATIVE
 #ifdef CONFIG_TCC_STATIC

tccasm.c+90−152

@@ -36,64 +36,40 @@ static Sym sym_dot; · 35 unmodified lines
36		36
37	static Sym *asm_label_find(int v)	37	static Sym *asm_label_find(int v)
38	{	38	{
39	v -= TOK_IDENT;	39	Sym *sym = sym_find(v);
40	if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))	40	while (sym && sym->sym_scope)
41	return NULL;	41	sym = sym->prev_tok;
42	return table_ident[v]->sym_asm_label;	42	return sym;
43	}	43	}
44		44
45	static Sym asm_label_push(Sym *ptop, int v)	45	static Sym *asm_label_push(int v, int t)
46	{	46	{
47	Sym s, *ps;	47	Sym *sym = global_identifier_push_1(&tcc_state->asm_labels, v, t, 0);
48	s = sym_push2(ptop, v, 0, 0);	48	/* We always add VT_EXTERN, for sym definition that's tentative
49	ps = &table_ident[v - TOK_IDENT]->sym_asm_label;	49	(for .set, removed for real defs), for mere references it's correct
50	s->prev_tok = *ps;	50	as is. */
51	*ps = s;	51	sym->type.t \|= VT_VOID \| VT_EXTERN;
52	return s;	52	sym->r = VT_CONST \| VT_SYM;
		53	return sym;
53	}	54	}
54		55
55	/* Return a symbol we can use inside the assembler, having name NAME.	56	/* Return a symbol we can use inside the assembler, having name NAME.
56	The assembler symbol table is different from the C symbol table	57	Symbols from asm and C source share a namespace. If we generate
57	(and the Sym members are used differently). But we must be able	58	an asm symbol it's also a (file-global) C symbol, but it's
58	to look up file-global C symbols from inside the assembler, e.g.	59	either not accessible by name (like "L.123"), or its type information
59	for global asm blocks to be able to refer to defined C symbols.	60	is such that it's not usable without a proper C declaration.
60		61
61	This routine gives back either an existing asm-internal	62	Sometimes we need symbols accessible by name from asm, which
62	symbol, or a new one. In the latter case the new asm-internal	63	are anonymous in C, in this case CSYM can be used to transfer
63	symbol is initialized with info from the C symbol table.	64	all information from that symbol to the (possibly newly created)
64		65	asm symbol. */
65	If CSYM is non-null we take symbol info from it, otherwise
66	we look up NAME in the C symbol table and use that. */
67	ST_FUNC Sym* get_asm_sym(int name, Sym *csym)	66	ST_FUNC Sym* get_asm_sym(int name, Sym *csym)
68	{	67	{
69	Sym *sym = asm_label_find(name);	68	Sym *sym = asm_label_find(name);
70	if (!sym) {	69	if (!sym) {
71	sym = asm_label_push(&tcc_state->asm_labels, name);	70	sym = asm_label_push(name, 0);
72	sym->type.t = VT_VOID \| VT_EXTERN;	71	if (csym)
73	if (!csym) {	72	sym->c = csym->c;
74	csym = sym_find(name);
75	/* We might be called for an asm block from inside a C routine
76	and so might have local decls on the identifier stack. Search
77	for the first global one. */
78	while (csym && csym->sym_scope)
79	csym = csym->prev_tok;
80	}
81	/* Now, if we have a defined global symbol copy over
82	section and offset. */
83	if (csym &&
84	((csym->r & (VT_SYM\|VT_CONST)) == (VT_SYM\|VT_CONST)) &&
85	csym->c) {
86	ElfW(Sym) *esym;
87	esym = &((ElfW(Sym) *)symtab_section->data)[csym->c];
88	sym->c = csym->c;
89	sym->r = esym->st_shndx;
90	sym->jnext = esym->st_value;
91	/* XXX can't yet store st_size anywhere. */
92	sym->type.t = VT_VOID \| (csym->type.t & VT_STATIC);
93	/* Mark that this asm symbol doesn't need to be fed back. */
94	sym->a.asmcsym = 1;
95	sym->a.asmexport = !(csym->type.t & VT_STATIC);
96	}
97	}	73	}
98	return sym;	74	return sym;
99	}	75	}
@@ -118,16 +94,15 @@ static void asm_expr_unary(TCCState s1, ExprValue pe) · 18 unmodified lines
118	sym = asm_label_find(label);	94	sym = asm_label_find(label);
119	if (*p == 'b') {	95	if (*p == 'b') {
120	/* backward : find the last corresponding defined label */	96	/* backward : find the last corresponding defined label */
121	if (sym && sym->r == 0)	97	if (sym && (!sym->c \|\| elfsym(sym)->st_shndx == SHN_UNDEF))
122	sym = sym->prev_tok;	98	sym = sym->prev_tok;
123	if (!sym)	99	if (!sym)
124	tcc_error("local label '%d' not found backward", n);	100	tcc_error("local label '%d' not found backward", n);
125	} else {	101	} else {
126	/* forward */	102	/* forward */
127	if (!sym \|\| sym->r) {	103	if (!sym \|\| (sym->c && elfsym(sym)->st_shndx != SHN_UNDEF)) {
128	/* if the last label is defined, then define a new one */	104	/* if the last label is defined, then define a new one */
129	sym = asm_label_push(&s1->asm_labels, label);	105	sym = asm_label_push(label, VT_STATIC);
130	sym->type.t = VT_STATIC \| VT_VOID \| VT_EXTERN;
131	}	106	}
132	}	107	}
133	pe->v = 0;	108	pe->v = 0;
@@ -175,17 +150,20 @@ static void asm_expr_unary(TCCState s1, ExprValue pe) · 41 unmodified lines
175	pe->sym = &sym_dot;	150	pe->sym = &sym_dot;
176	pe->pcrel = 0;	151	pe->pcrel = 0;
177	sym_dot.type.t = VT_VOID \| VT_STATIC;	152	sym_dot.type.t = VT_VOID \| VT_STATIC;
178	sym_dot.r = cur_text_section->sh_num;	153	sym_dot.c = -1;
179	sym_dot.jnext = ind;	154	tcc_state->esym_dot.st_shndx = cur_text_section->sh_num;
		155	tcc_state->esym_dot.st_value = ind;
180	next();	156	next();
181	break;	157	break;
182	default:	158	default:
183	if (tok >= TOK_IDENT) {	159	if (tok >= TOK_IDENT) {
		160	ElfSym *esym;
184	/* label case : if the label was not found, add one */	161	/* label case : if the label was not found, add one */
185	sym = get_asm_sym(tok, NULL);	162	sym = get_asm_sym(tok, NULL);
186	if (sym->r == SHN_ABS) {	163	esym = elfsym(sym);
		164	if (esym && esym->st_shndx == SHN_ABS) {
187	/* if absolute symbol, no need to put a symbol value */	165	/* if absolute symbol, no need to put a symbol value */
188	pe->v = sym->jnext;	166	pe->v = esym->st_value;
189	pe->sym = NULL;	167	pe->sym = NULL;
190	pe->pcrel = 0;	168	pe->pcrel = 0;
191	} else {	169	} else {
@@ -299,20 +277,26 @@ static inline void asm_expr_sum(TCCState s1, ExprValue pe) · 107 unmodified lines
299	} else if (pe->sym == e2.sym) {	277	} else if (pe->sym == e2.sym) {
300	/* OK */	278	/* OK */
301	pe->sym = NULL; /* same symbols can be subtracted to NULL */	279	pe->sym = NULL; /* same symbols can be subtracted to NULL */
302	} else if (pe->sym && pe->sym->r == e2.sym->r && pe->sym->r != 0) {	280	} else {
303	/* we also accept defined symbols in the same section */	281	ElfSym esym1, esym2;
304	pe->v += pe->sym->jnext - e2.sym->jnext;	282	esym1 = elfsym(pe->sym);
305	pe->sym = NULL;	283	esym2 = elfsym(e2.sym);
306	} else if (e2.sym->r == cur_text_section->sh_num) {	284	if (esym1 && esym1->st_shndx == esym2->st_shndx
307	/* When subtracting a defined symbol in current section	285	&& esym1->st_shndx != SHN_UNDEF) {
308	this actually makes the value PC-relative. */	286	/* we also accept defined symbols in the same section */
309	pe->v -= e2.sym->jnext - ind - 4;	287	pe->v += esym1->st_value - esym2->st_value;
310	pe->pcrel = 1;	288	pe->sym = NULL;
311	e2.sym = NULL;	289	} else if (esym2->st_shndx == cur_text_section->sh_num) {
312	} else {	290	/* When subtracting a defined symbol in current section
313	cannot_relocate:	291	this actually makes the value PC-relative. */
314	tcc_error("invalid operation with label");	292	pe->v -= esym2->st_value - ind - 4;
315	}	293	pe->pcrel = 1;
		294	e2.sym = NULL;
		295	} else {
		296	cannot_relocate:
		297	tcc_error("invalid operation with label");
		298	}
		299	}
316	}	300	}
317	}	301	}
318	}	302	}
@@ -377,13 +361,15 @@ static Sym* asm_new_label1(TCCState *s1, int label, int is_local, · 58 unmodified lines
377	int sh_num, int value)	361	int sh_num, int value)
378	{	362	{
379	Sym *sym;	363	Sym *sym;
		364	ElfSym *esym;
380		365
381	sym = asm_label_find(label);	366	sym = asm_label_find(label);
382	if (sym) {	367	if (sym) {
		368	esym = elfsym(sym);
383	/* A VT_EXTERN symbol, even if it has a section is considered	369	/* A VT_EXTERN symbol, even if it has a section is considered
384	overridable. This is how we "define" .set targets. Real	370	overridable. This is how we "define" .set targets. Real
385	definitions won't have VT_EXTERN set. */	371	definitions won't have VT_EXTERN set. */
386	if (sym->r && !(sym->type.t & VT_EXTERN)) {	372	if (esym && esym->st_shndx != SHN_UNDEF && !(sym->type.t & VT_EXTERN)) {
387	/* the label is already defined */	373	/* the label is already defined */
388	if (!is_local) {	374	if (!is_local) {
389	tcc_error("assembler label '%s' already defined",	375	tcc_error("assembler label '%s' already defined",
@@ -395,14 +381,13 @@ static Sym* asm_new_label1(TCCState *s1, int label, int is_local, · 5 unmodified lines
395	}	381	}
396	} else {	382	} else {
397	new_label:	383	new_label:
398	sym = asm_label_push(&s1->asm_labels, label);	384	sym = asm_label_push(label, is_local ? VT_STATIC : 0);
399	/* If we need a symbol to hold a value, mark it as
400	tentative only (for .set). If this is for a real label
401	we'll remove VT_EXTERN. */
402	sym->type.t = VT_VOID \| (is_local ? VT_STATIC : 0) \| VT_EXTERN;
403	}	385	}
404	sym->r = sh_num;	386	if (!sym->c)
405	sym->jnext = value;	387	put_extern_sym2(sym, NULL, 0, 0, 0);
		388	esym = elfsym(sym);
		389	esym->st_shndx = sh_num;
		390	esym->st_value = value;
406	return sym;	391	return sym;
407	}	392	}
408		393
@@ -417,79 +402,41 @@ static Sym* set_symbol(TCCState *s1, int label) · 8 unmodified lines
417	{	402	{
418	long n;	403	long n;
419	ExprValue e;	404	ExprValue e;
		405	Sym *sym;
		406	ElfSym *esym;
420	next();	407	next();
421	asm_expr(s1, &e);	408	asm_expr(s1, &e);
422	n = e.v;	409	n = e.v;
423	if (e.sym)	410	esym = elfsym(e.sym);
424	n += e.sym->jnext;	411	if (esym)
425	return asm_new_label1(s1, label, 0, e.sym ? e.sym->r : SHN_ABS, n);	412	n += esym->st_value;
426	}	413	sym = asm_new_label1(s1, label, 0, esym ? esym->st_shndx : SHN_ABS, n);
427		414	elfsym(sym)->st_other \|= ST_ASM_SET;
428	/* Patch ELF symbol associated with SYM based on the assemblers	415	return sym;
429	understanding. */
430	static void patch_binding(Sym *sym)
431	{
432	ElfW(Sym) *esym;
433	if (0 == sym->c)
434	return;
435	esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
436	if (sym->a.visibility)
437	esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
438	\| sym->a.visibility;
439
440	esym->st_info = ELFW(ST_INFO)(sym->a.weak ? STB_WEAK
441	: (sym->type.t & VT_STATIC) ? STB_LOCAL
442	: STB_GLOBAL,
443	ELFW(ST_TYPE)(esym->st_info));
444	}	416	}
445		417
446	ST_FUNC void asm_free_labels(TCCState *st)	418	ST_FUNC void asm_free_labels(TCCState *st)
447	{	419	{
448	Sym s, s1;	420	Sym s, s1;
449	Section *sec;
450		421
451	for(s = st->asm_labels; s != NULL; s = s1) {	422	for(s = st->asm_labels; s != NULL; s = s1) {
452	int was_ext = s->type.t & VT_EXTERN;	423	ElfSym *esym = elfsym(s);
453	s1 = s->prev;	424	s1 = s->prev;
454	/* define symbol value in object file and care for updating	425	/* Possibly update binding and visibility from asm directives. */
455	the C and asm symbols */
456	s->type.t &= ~VT_EXTERN;	426	s->type.t &= ~VT_EXTERN;
457	if (!s->a.asmcsym) {	427	if (esym) {
458	Sym *csym = sym_find(s->v);	428	if (!s->a.asmexport && esym->st_shndx != SHN_UNDEF)
459	ElfW(Sym) *esym = NULL;	429	s->type.t \|= VT_STATIC;
460	if (csym) {	430	if (s->a.visibility)
461	s->a.asmexport \|= !(csym->type.t & VT_STATIC);	431	esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
462	if (csym->c) {	432	\| s->a.visibility;
463	esym = &((ElfW(Sym) *)symtab_section->data)[csym->c];	433	esym->st_info = ELFW(ST_INFO)(s->a.weak ? STB_WEAK
464	if (s->c) {	434	: (s->type.t & VT_STATIC) ? STB_LOCAL
465	/* We have generated code and possibly relocs	435	: STB_GLOBAL,
466	referencing the symtab entry s->c (the asm	436	ELFW(ST_TYPE)(esym->st_info));
467	ELF symbol). If that's undefined but the C
468	symbol is defined, copy over the info. */
469	ElfW(Sym) asm_esym = &((ElfW(Sym) )symtab_section->data)[s->c];
470	if (asm_esym->st_shndx == SHN_UNDEF) {
471	asm_esym = esym;
472	}
473	}
474	}
475	}
476	if (!s->a.asmexport)
477	s->type.t \|= VT_STATIC;
478	if (s->r) {
479	if (s->r == SHN_ABS)
480	sec = SECTION_ABS;
481	else
482	sec = st->sections[s->r];
483	/* !was_ext so that we run into an multi-def error if
484	we defined it in C and in asm (non-tentatively) */
485	if (!esym \|\| esym->st_shndx == SHN_UNDEF \|\| !was_ext)
486	put_extern_sym2(s, sec, s->jnext, 0, 0);
487	} else /* undefined symbols are global */
488	s->type.t &= ~VT_STATIC, s->a.asmexport = 1;
489	patch_binding(s);
490	}	437	}
491	/* remove label */	438	/* remove label */
492	table_ident[s->v - TOK_IDENT]->sym_asm_label = NULL;	439	table_ident[s->v - TOK_IDENT]->sym_identifier = s->prev_tok;
493	sym_free(s);	440	sym_free(s);
494	}	441	}
495	st->asm_labels = NULL;	442	st->asm_labels = NULL;
@@ -715,13 +662,15 @@ static void asm_parse_directive(TCCState *s1, int global) · 219 unmodified lines
715	{	662	{
716	unsigned long n;	663	unsigned long n;
717	ExprValue e;	664	ExprValue e;
		665	ElfSym *esym;
718	next();	666	next();
719	asm_expr(s1, &e);	667	asm_expr(s1, &e);
720	n = e.v;	668	n = e.v;
721	if (e.sym) {	669	esym = elfsym(e.sym);
722	if (e.sym->r != cur_text_section->sh_num)	670	if (esym) {
		671	if (esym->st_shndx != cur_text_section->sh_num)
723	expect("constant or same-section symbol");	672	expect("constant or same-section symbol");
724	n += e.sym->jnext;	673	n += esym->st_value;
725	}	674	}
726	if (n < ind)	675	if (n < ind)
727	tcc_error("attempt to .org backwards");	676	tcc_error("attempt to .org backwards");
@@ -978,7 +927,6 @@ static int tcc_assemble_internal(TCCState *s1, int do_preprocess, int global) · 250 unmodified lines
978	int opcode;	927	int opcode;
979	int saved_parse_flags = parse_flags;	928	int saved_parse_flags = parse_flags;
980		929
981	/* XXX: undefine C labels */
982	parse_flags = PARSE_FLAG_ASM_FILE \| PARSE_FLAG_TOK_STR;	930	parse_flags = PARSE_FLAG_ASM_FILE \| PARSE_FLAG_TOK_STR;
983	if (do_preprocess)	931	if (do_preprocess)
984	parse_flags \|= PARSE_FLAG_PREPROCESS;	932	parse_flags \|= PARSE_FLAG_PREPROCESS;
@@ -1017,18 +965,8 @@ static int tcc_assemble_internal(TCCState *s1, int do_preprocess, int global) · 32 unmodified lines
1017	opcode = tok;	965	opcode = tok;
1018	next();	966	next();
1019	if (tok == ':') {	967	if (tok == ':') {
1020	/* handle "extern void vide(void); __asm__("vide: ret");" as
1021	"__asm__("globl vide\nvide: ret");" */
1022	Sym *sym = sym_find(opcode);
1023	if (sym && (sym->type.t & VT_EXTERN) && global) {
1024	sym = asm_label_find(opcode);
1025	if (!sym) {
1026	sym = asm_label_push(&s1->asm_labels, opcode);
1027	sym->type.t = VT_VOID \| VT_EXTERN;
1028	}
1029	}
1030	/* new label */	968	/* new label */
1031	sym = asm_new_label(s1, opcode, 0);	969	Sym *sym = asm_new_label(s1, opcode, 0);
1032	sym->type.t &= ~VT_EXTERN;	970	sym->type.t &= ~VT_EXTERN;
1033	next();	971	next();
1034	goto redo;	972	goto redo;

tccelf.c+9−3

     sym = (ElfW(Sym) *)s->data + 1;
     for(sym_index = 1; sym_index < nb_syms; sym_index++) {
-        if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
+        if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL
+	    || sym->st_shndx == SHN_UNDEF) {
             h = elf_hash(strtab + sym->st_name) % nb_buckets;
             *ptr = hash[h];
             hash[h] = sym_index;
         int *ptr, *base;
         ptr = section_ptr_add(hs, sizeof(int));
         base = (int *)hs->data;
-        /* only add global or weak symbols */
+        /* only add global, weak or undef symbols.  The latter might
-        if (ELFW(ST_BIND)(info) != STB_LOCAL) {
+	   become global late (from asm references).  */
+        if (ELFW(ST_BIND)(info) != STB_LOCAL || shndx == SHN_UNDEF) {
             /* add another hashing entry */
             nbuckets = base[0];
             h = elf_hash((unsigned char *) name) % nbuckets;
                 /* data symbol keeps precedence over common/bss */
             } else if (s == tcc_state->dynsymtab_section) {
                 /* we accept that two DLL define the same symbol */
+	    } else if (esym->st_other & ST_ASM_SET) {
+		/* If the existing symbol came from an asm .set
+		   we can override.  */
+		goto do_patch;
             } else {
 #if 0
                 printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",

tccgen.c+42−21

 }
 /* ------------------------------------------------------------------------- */
+ST_FUNC ElfSym *elfsym(Sym *s)
+{
+  if (!s || !s->c)
+    return NULL;
+  if (s->c == -1)
+    return &tcc_state->esym_dot;
+  else
+    return &((ElfSym *)symtab_section->data)[s->c];
+}
 /* apply storage attributes to Elf symbol */
 static void update_storage(Sym *sym)
 {
-    ElfW(Sym) *esym;
+    ElfSym *esym = elfsym(sym);
-    if (0 == sym->c)
+    if (!esym)
         return;
-    esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
     if (sym->a.visibility)
         esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
             | sym->a.visibility;
                             int can_add_underscore)
 {
     int sym_type, sym_bind, sh_num, info, other, t;
-    ElfW(Sym) *esym;
+    ElfSym *esym;
     const char *name;
     char buf1[256];
 #ifdef CONFIG_TCC_BCHECK
         info = ELFW(ST_INFO)(sym_bind, sym_type);
         sym->c = set_elf_sym(symtab_section, value, size, info, other, sh_num, name);
     } else {
-        esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
+        esym = elfsym(sym);
         esym->st_value = value;
         esym->st_size = size;
         esym->st_shndx = sh_num;
 }
 /* push a global identifier */
-ST_FUNC Sym *global_identifier_push(int v, int t, int c)
+ST_FUNC Sym *global_identifier_push_1(Sym **ptop, int v, int t, int c)
 {
     Sym *s, **ps;
-    s = sym_push2(&global_stack, v, t, c);
+    s = sym_push2(ptop, v, t, c);
     /* 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
            sym_identifier will point to 's' when popped */
-        while (*ps != NULL)
+        while (*ps != NULL && (*ps)->sym_scope)
             ps = &(*ps)->prev_tok;
-        s->prev_tok = NULL;
+        s->prev_tok = *ps;
         *ps = s;
     }
     return s;
 }
+static Sym *global_identifier_push(int v, int t, int c)
+{
+    return global_identifier_push_1(&global_stack, v, t, c);
+}
 /* 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)
 /* Merge some storage attributes.  */
 static void patch_storage(Sym *sym, AttributeDef *ad, CType *type)
 {
-    if (type && !is_compatible_types(&sym->type, type))
+    if (type) {
-        tcc_error("incompatible types for redefinition of '%s'",
+	if ((sym->type.t & VT_BTYPE) == VT_VOID) /* from asm */
-            get_tok_str(sym->v, NULL));
+	    sym->type = *type;
+	else if (!is_compatible_types(&sym->type, type))
+	    tcc_error("incompatible types for redefinition of '%s'",
+                      get_tok_str(sym->v, NULL));
+    }
 #ifdef TCC_TARGET_PE
     if (sym->a.dllimport != ad->a.dllimport)
         tcc_error("incompatible dll linkage for redefinition of '%s'",
 	    (vtop->type.t & VT_BTYPE) != VT_PTR) {
 	    /* These come from compound literals, memcpy stuff over.  */
 	    Section *ssec;
-	    ElfW(Sym) *esym;
+	    ElfSym *esym;
 	    ElfW_Rel *rel;
-	    esym = &((ElfW(Sym) *)symtab_section->data)[vtop->sym->c];
+	    esym = elfsym(vtop->sym);
 	    ssec = tcc_state->sections[esym->st_shndx];
 	    memmove (ptr, ssec->data + esym->st_value, size);
 	    if (ssec->reloc) {
                     /* no init data, we won't add more to the symbol */
                     goto no_alloc;
                 } else if (sym->c) {
-                    ElfW(Sym) *esym;
+                    ElfSym *esym = elfsym(sym);
-                    esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
                     if (esym->st_shndx == data_section->sh_num)
                         tcc_error("redefinition of '%s'", get_tok_str(v, NULL));
                 }
     sym_pop(&local_stack, NULL, 0);
     /* end of function */
     /* patch symbol size */
-    ((ElfW(Sym) *)symtab_section->data)[sym->c].st_size =
+    elfsym(sym)->st_size = ind - func_ind;
-        ind - func_ind;
     tcc_debug_funcend(tcc_state, ind - func_ind);
     /* It's better to crash than to generate wrong code */
     cur_text_section = NULL;
                 sym = sym_find(v);
                 if (sym) {
                     Sym *ref;
+		    /* If type is VT_VOID the symbol was created by tccasm
+		       first, and we see the first reference from C now. */
+		    if ((sym->type.t & VT_BTYPE) == VT_VOID)
+		        sym->type = type;
                     if ((sym->type.t & VT_BTYPE) != VT_FUNC)
                         goto func_error1;
                         sym = external_sym(v, &type, r, &ad);
                         if (ad.alias_target) {
                             Section tsec;
-                            ElfW(Sym) *esym;
+                            ElfSym *esym;
                             Sym *alias_target;
                             alias_target = sym_find(ad.alias_target);
-                            if (!alias_target || !alias_target->c)
+                            esym = elfsym(alias_target);
+                            if (!esym)
                                 tcc_error("unsupported forward __alias__ attribute");
-                            esym = &((ElfW(Sym) *)symtab_section->data)[alias_target->c];
                             tsec.sh_num = esym->st_shndx;
                             /* Local statics have a scope until now (for
                                warnings), remove it here.  */

tccpp.c+0−1

@@ -432,7 +432,6 @@ static TokenSym tok_alloc_new(TokenSym pts, const char str, int len) · 431 unmodified lines
432	ts->sym_label = NULL;	432	ts->sym_label = NULL;
433	ts->sym_struct = NULL;	433	ts->sym_struct = NULL;
434	ts->sym_identifier = NULL;	434	ts->sym_identifier = NULL;
435	ts->sym_asm_label = NULL;
436	ts->len = len;	435	ts->len = len;
437	ts->hash_next = NULL;	436	ts->hash_next = NULL;
438	memcpy(ts->str, str, len);	437	memcpy(ts->str, str, len);

tests/asm-c-connect-1.c+7−0

 asm(".text;"_"x1: call "_"x1_c; ret");
+void callx4(void);
 int main(int argc, char *argv[])
 {
     asm("call "_"x1");
     asm("call "_"x2");
     asm("call "_"x3");
+    callx4();
     return 0;
 }
 }
 extern int x3(void);
+void x4(void)
+{
+    printf("x4\n");
+}

tests/asm-c-connect-2.c+3−0

@@ -5,3 +5,6 @@ int x3(void) · 4 unmodified lines
5	printf("x3\n");	5	printf("x3\n");
6	return 3;	6	return 3;
7	}	7	}
		8
		9	void callx4(void);
		10	__asm__("callx4: call x4; ret");

tccasm: Unify C and asm symbol table

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code