Linux was incorrectly identified in banner when compiled on macOS Darwin
[tinycc.git] / tccelf.c
blob5208545003ba122f7089fc3c3876d3bde1b0fc2a
1 /*
2 * ELF file handling for TCC
4 * Copyright (c) 2001-2004 Fabrice Bellard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include "tcc.h"
23 /* Define this to get some debug output during relocation processing. */
24 #undef DEBUG_RELOC
26 /********************************************************/
27 /* global variables */
29 ST_DATA Section *text_section, *data_section, *bss_section; /* predefined sections */
30 ST_DATA Section *cur_text_section; /* current section where function code is generated */
31 #ifdef CONFIG_TCC_ASM
32 ST_DATA Section *last_text_section; /* to handle .previous asm directive */
33 #endif
34 #ifdef CONFIG_TCC_BCHECK
35 /* bound check related sections */
36 ST_DATA Section *bounds_section; /* contains global data bound description */
37 ST_DATA Section *lbounds_section; /* contains local data bound description */
38 #endif
39 /* symbol sections */
40 ST_DATA Section *symtab_section, *strtab_section;
41 /* debug sections */
42 ST_DATA Section *stab_section, *stabstr_section;
44 /* XXX: avoid static variable */
45 static int new_undef_sym = 0; /* Is there a new undefined sym since last new_undef_sym() */
47 /* ------------------------------------------------------------------------- */
49 ST_FUNC void tccelf_new(TCCState *s)
51 /* no section zero */
52 dynarray_add(&s->sections, &s->nb_sections, NULL);
54 /* create standard sections */
55 text_section = new_section(s, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
56 data_section = new_section(s, ".data", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
57 bss_section = new_section(s, ".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
59 /* symbols are always generated for linking stage */
60 symtab_section = new_symtab(s, ".symtab", SHT_SYMTAB, 0,
61 ".strtab",
62 ".hashtab", SHF_PRIVATE);
63 strtab_section = symtab_section->link;
64 s->symtab = symtab_section;
66 /* private symbol table for dynamic symbols */
67 s->dynsymtab_section = new_symtab(s, ".dynsymtab", SHT_SYMTAB, SHF_PRIVATE,
68 ".dynstrtab",
69 ".dynhashtab", SHF_PRIVATE);
70 get_sym_attr(s, 0, 1);
73 #ifdef CONFIG_TCC_BCHECK
74 ST_FUNC void tccelf_bounds_new(TCCState *s)
76 /* create bounds sections */
77 bounds_section = new_section(s, ".bounds",
78 SHT_PROGBITS, SHF_ALLOC);
79 lbounds_section = new_section(s, ".lbounds",
80 SHT_PROGBITS, SHF_ALLOC);
82 #endif
84 ST_FUNC void tccelf_stab_new(TCCState *s)
86 stab_section = new_section(s, ".stab", SHT_PROGBITS, 0);
87 stab_section->sh_entsize = sizeof(Stab_Sym);
88 stabstr_section = new_section(s, ".stabstr", SHT_STRTAB, 0);
89 put_elf_str(stabstr_section, "");
90 stab_section->link = stabstr_section;
91 /* put first entry */
92 put_stabs("", 0, 0, 0, 0);
95 static void free_section(Section *s)
97 tcc_free(s->data);
100 ST_FUNC void tccelf_delete(TCCState *s1)
102 int i;
104 /* free all sections */
105 for(i = 1; i < s1->nb_sections; i++)
106 free_section(s1->sections[i]);
107 dynarray_reset(&s1->sections, &s1->nb_sections);
109 for(i = 0; i < s1->nb_priv_sections; i++)
110 free_section(s1->priv_sections[i]);
111 dynarray_reset(&s1->priv_sections, &s1->nb_priv_sections);
113 /* free any loaded DLLs */
114 #ifdef TCC_IS_NATIVE
115 for ( i = 0; i < s1->nb_loaded_dlls; i++) {
116 DLLReference *ref = s1->loaded_dlls[i];
117 if ( ref->handle )
118 # ifdef _WIN32
119 FreeLibrary((HMODULE)ref->handle);
120 # else
121 dlclose(ref->handle);
122 # endif
124 #endif
125 /* free loaded dlls array */
126 dynarray_reset(&s1->loaded_dlls, &s1->nb_loaded_dlls);
127 tcc_free(s1->sym_attrs);
130 ST_FUNC Section *new_section(TCCState *s1, const char *name, int sh_type, int sh_flags)
132 Section *sec;
134 sec = tcc_mallocz(sizeof(Section) + strlen(name));
135 strcpy(sec->name, name);
136 sec->sh_type = sh_type;
137 sec->sh_flags = sh_flags;
138 switch(sh_type) {
139 case SHT_HASH:
140 case SHT_REL:
141 case SHT_RELA:
142 case SHT_DYNSYM:
143 case SHT_SYMTAB:
144 case SHT_DYNAMIC:
145 sec->sh_addralign = 4;
146 break;
147 case SHT_STRTAB:
148 sec->sh_addralign = 1;
149 break;
150 default:
151 sec->sh_addralign = PTR_SIZE; /* gcc/pcc default aligment */
152 break;
155 if (sh_flags & SHF_PRIVATE) {
156 dynarray_add(&s1->priv_sections, &s1->nb_priv_sections, sec);
157 } else {
158 sec->sh_num = s1->nb_sections;
159 dynarray_add(&s1->sections, &s1->nb_sections, sec);
162 return sec;
165 ST_FUNC Section *new_symtab(TCCState *s1,
166 const char *symtab_name, int sh_type, int sh_flags,
167 const char *strtab_name,
168 const char *hash_name, int hash_sh_flags)
170 Section *symtab, *strtab, *hash;
171 int *ptr, nb_buckets;
173 symtab = new_section(s1, symtab_name, sh_type, sh_flags);
174 symtab->sh_entsize = sizeof(ElfW(Sym));
175 strtab = new_section(s1, strtab_name, SHT_STRTAB, sh_flags);
176 put_elf_str(strtab, "");
177 symtab->link = strtab;
178 put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL);
180 nb_buckets = 1;
182 hash = new_section(s1, hash_name, SHT_HASH, hash_sh_flags);
183 hash->sh_entsize = sizeof(int);
184 symtab->hash = hash;
185 hash->link = symtab;
187 ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int));
188 ptr[0] = nb_buckets;
189 ptr[1] = 1;
190 memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int));
191 return symtab;
194 /* realloc section and set its content to zero */
195 ST_FUNC void section_realloc(Section *sec, unsigned long new_size)
197 unsigned long size;
198 unsigned char *data;
200 size = sec->data_allocated;
201 if (size == 0)
202 size = 1;
203 while (size < new_size)
204 size = size * 2;
205 data = tcc_realloc(sec->data, size);
206 memset(data + sec->data_allocated, 0, size - sec->data_allocated);
207 sec->data = data;
208 sec->data_allocated = size;
211 /* reserve at least 'size' bytes in section 'sec' from
212 sec->data_offset. */
213 ST_FUNC void *section_ptr_add(Section *sec, addr_t size)
215 size_t offset, offset1;
217 offset = sec->data_offset;
218 offset1 = offset + size;
219 if (offset1 > sec->data_allocated)
220 section_realloc(sec, offset1);
221 sec->data_offset = offset1;
222 return sec->data + offset;
225 /* reserve at least 'size' bytes from section start */
226 ST_FUNC void section_reserve(Section *sec, unsigned long size)
228 if (size > sec->data_allocated)
229 section_realloc(sec, size);
230 if (size > sec->data_offset)
231 sec->data_offset = size;
234 /* return a reference to a section, and create it if it does not
235 exists */
236 ST_FUNC Section *find_section(TCCState *s1, const char *name)
238 Section *sec;
239 int i;
240 for(i = 1; i < s1->nb_sections; i++) {
241 sec = s1->sections[i];
242 if (!strcmp(name, sec->name))
243 return sec;
245 /* sections are created as PROGBITS */
246 return new_section(s1, name, SHT_PROGBITS, SHF_ALLOC);
249 /* ------------------------------------------------------------------------- */
251 ST_FUNC int put_elf_str(Section *s, const char *sym)
253 int offset, len;
254 char *ptr;
256 len = strlen(sym) + 1;
257 offset = s->data_offset;
258 ptr = section_ptr_add(s, len);
259 memcpy(ptr, sym, len);
260 return offset;
263 /* elf symbol hashing function */
264 static unsigned long elf_hash(const unsigned char *name)
266 unsigned long h = 0, g;
268 while (*name) {
269 h = (h << 4) + *name++;
270 g = h & 0xf0000000;
271 if (g)
272 h ^= g >> 24;
273 h &= ~g;
275 return h;
278 /* rebuild hash table of section s */
279 /* NOTE: we do factorize the hash table code to go faster */
280 static void rebuild_hash(Section *s, unsigned int nb_buckets)
282 ElfW(Sym) *sym;
283 int *ptr, *hash, nb_syms, sym_index, h;
284 unsigned char *strtab;
286 strtab = s->link->data;
287 nb_syms = s->data_offset / sizeof(ElfW(Sym));
289 s->hash->data_offset = 0;
290 ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int));
291 ptr[0] = nb_buckets;
292 ptr[1] = nb_syms;
293 ptr += 2;
294 hash = ptr;
295 memset(hash, 0, (nb_buckets + 1) * sizeof(int));
296 ptr += nb_buckets + 1;
298 sym = (ElfW(Sym) *)s->data + 1;
299 for(sym_index = 1; sym_index < nb_syms; sym_index++) {
300 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
301 h = elf_hash(strtab + sym->st_name) % nb_buckets;
302 *ptr = hash[h];
303 hash[h] = sym_index;
304 } else {
305 *ptr = 0;
307 ptr++;
308 sym++;
312 /* return the symbol number */
313 ST_FUNC int put_elf_sym(Section *s, addr_t value, unsigned long size,
314 int info, int other, int shndx, const char *name)
316 int name_offset, sym_index;
317 int nbuckets, h;
318 ElfW(Sym) *sym;
319 Section *hs;
321 sym = section_ptr_add(s, sizeof(ElfW(Sym)));
322 if (name)
323 name_offset = put_elf_str(s->link, name);
324 else
325 name_offset = 0;
326 /* XXX: endianness */
327 sym->st_name = name_offset;
328 sym->st_value = value;
329 sym->st_size = size;
330 sym->st_info = info;
331 sym->st_other = other;
332 sym->st_shndx = shndx;
333 sym_index = sym - (ElfW(Sym) *)s->data;
334 hs = s->hash;
335 if (hs) {
336 int *ptr, *base;
337 ptr = section_ptr_add(hs, sizeof(int));
338 base = (int *)hs->data;
339 /* only add global or weak symbols */
340 if (ELFW(ST_BIND)(info) != STB_LOCAL) {
341 /* add another hashing entry */
342 nbuckets = base[0];
343 h = elf_hash((unsigned char *) name) % nbuckets;
344 *ptr = base[2 + h];
345 base[2 + h] = sym_index;
346 base[1]++;
347 /* we resize the hash table */
348 hs->nb_hashed_syms++;
349 if (hs->nb_hashed_syms > 2 * nbuckets) {
350 rebuild_hash(s, 2 * nbuckets);
352 } else {
353 *ptr = 0;
354 base[1]++;
357 return sym_index;
360 /* find global ELF symbol 'name' and return its index. Return 0 if not
361 found. */
362 ST_FUNC int find_elf_sym(Section *s, const char *name)
364 ElfW(Sym) *sym;
365 Section *hs;
366 int nbuckets, sym_index, h;
367 const char *name1;
369 hs = s->hash;
370 if (!hs)
371 return 0;
372 nbuckets = ((int *)hs->data)[0];
373 h = elf_hash((unsigned char *) name) % nbuckets;
374 sym_index = ((int *)hs->data)[2 + h];
375 while (sym_index != 0) {
376 sym = &((ElfW(Sym) *)s->data)[sym_index];
377 name1 = (char *) s->link->data + sym->st_name;
378 if (!strcmp(name, name1))
379 return sym_index;
380 sym_index = ((int *)hs->data)[2 + nbuckets + sym_index];
382 return 0;
385 /* return elf symbol value, signal error if 'err' is nonzero */
386 ST_FUNC addr_t get_elf_sym_addr(TCCState *s, const char *name, int err)
388 int sym_index;
389 ElfW(Sym) *sym;
391 sym_index = find_elf_sym(s->symtab, name);
392 sym = &((ElfW(Sym) *)s->symtab->data)[sym_index];
393 if (!sym_index || sym->st_shndx == SHN_UNDEF) {
394 if (err)
395 tcc_error("%s not defined", name);
396 return 0;
398 return sym->st_value;
401 /* return elf symbol value */
402 LIBTCCAPI void *tcc_get_symbol(TCCState *s, const char *name)
404 return (void*)(uintptr_t)get_elf_sym_addr(s, name, 0);
407 #if defined TCC_IS_NATIVE || defined TCC_TARGET_PE
408 /* return elf symbol value or error */
409 ST_FUNC void* tcc_get_symbol_err(TCCState *s, const char *name)
411 return (void*)(uintptr_t)get_elf_sym_addr(s, name, 1);
413 #endif
415 /* add an elf symbol : check if it is already defined and patch
416 it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
417 ST_FUNC int set_elf_sym(Section *s, addr_t value, unsigned long size,
418 int info, int other, int shndx, const char *name)
420 ElfW(Sym) *esym;
421 int sym_bind, sym_index, sym_type, esym_bind;
422 unsigned char sym_vis, esym_vis, new_vis;
424 sym_bind = ELFW(ST_BIND)(info);
425 sym_type = ELFW(ST_TYPE)(info);
426 sym_vis = ELFW(ST_VISIBILITY)(other);
428 sym_index = find_elf_sym(s, name);
429 esym = &((ElfW(Sym) *)s->data)[sym_index];
430 if (sym_index && esym->st_value == value && esym->st_size == size
431 && esym->st_info == info && esym->st_other == other
432 && esym->st_shndx == shndx)
433 return sym_index;
435 if (sym_bind != STB_LOCAL) {
436 /* we search global or weak symbols */
437 if (!sym_index)
438 goto do_def;
439 if (esym->st_shndx != SHN_UNDEF) {
440 esym_bind = ELFW(ST_BIND)(esym->st_info);
441 /* propagate the most constraining visibility */
442 /* STV_DEFAULT(0)<STV_PROTECTED(3)<STV_HIDDEN(2)<STV_INTERNAL(1) */
443 esym_vis = ELFW(ST_VISIBILITY)(esym->st_other);
444 if (esym_vis == STV_DEFAULT) {
445 new_vis = sym_vis;
446 } else if (sym_vis == STV_DEFAULT) {
447 new_vis = esym_vis;
448 } else {
449 new_vis = (esym_vis < sym_vis) ? esym_vis : sym_vis;
451 esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
452 | new_vis;
453 other = esym->st_other; /* in case we have to patch esym */
454 if (shndx == SHN_UNDEF) {
455 /* ignore adding of undefined symbol if the
456 corresponding symbol is already defined */
457 } else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) {
458 /* global overrides weak, so patch */
459 goto do_patch;
460 } else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) {
461 /* weak is ignored if already global */
462 } else if (sym_bind == STB_WEAK && esym_bind == STB_WEAK) {
463 /* keep first-found weak definition, ignore subsequents */
464 } else if (sym_vis == STV_HIDDEN || sym_vis == STV_INTERNAL) {
465 /* ignore hidden symbols after */
466 } else if ((esym->st_shndx == SHN_COMMON
467 || esym->st_shndx == bss_section->sh_num)
468 && (shndx < SHN_LORESERVE
469 && shndx != bss_section->sh_num)) {
470 /* data symbol gets precedence over common/bss */
471 goto do_patch;
472 } else if (shndx == SHN_COMMON || shndx == bss_section->sh_num) {
473 /* data symbol keeps precedence over common/bss */
474 } else if (s == tcc_state->dynsymtab_section) {
475 /* we accept that two DLL define the same symbol */
476 } else {
477 #if 0
478 printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",
479 sym_bind, shndx, new_vis, esym_bind, esym->st_shndx, esym_vis);
480 #endif
481 tcc_error_noabort("'%s' defined twice", name);
483 } else {
484 do_patch:
485 esym->st_info = ELFW(ST_INFO)(sym_bind, sym_type);
486 esym->st_shndx = shndx;
487 new_undef_sym = 1;
488 esym->st_value = value;
489 esym->st_size = size;
490 esym->st_other = other;
492 } else {
493 do_def:
494 sym_index = put_elf_sym(s, value, size,
495 ELFW(ST_INFO)(sym_bind, sym_type), other,
496 shndx, name);
498 return sym_index;
501 /* put relocation */
502 ST_FUNC void put_elf_reloca(Section *symtab, Section *s, unsigned long offset,
503 int type, int symbol, addr_t addend)
505 char buf[256];
506 Section *sr;
507 ElfW_Rel *rel;
509 sr = s->reloc;
510 if (!sr) {
511 /* if no relocation section, create it */
512 snprintf(buf, sizeof(buf), REL_SECTION_FMT, s->name);
513 /* if the symtab is allocated, then we consider the relocation
514 are also */
515 sr = new_section(tcc_state, buf, SHT_RELX, symtab->sh_flags);
516 sr->sh_entsize = sizeof(ElfW_Rel);
517 sr->link = symtab;
518 sr->sh_info = s->sh_num;
519 s->reloc = sr;
521 rel = section_ptr_add(sr, sizeof(ElfW_Rel));
522 rel->r_offset = offset;
523 rel->r_info = ELFW(R_INFO)(symbol, type);
524 #if SHT_RELX == SHT_RELA
525 rel->r_addend = addend;
526 #else
527 if (addend)
528 tcc_error("non-zero addend on REL architecture");
529 #endif
532 ST_FUNC void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
533 int type, int symbol)
535 put_elf_reloca(symtab, s, offset, type, symbol, 0);
538 /* Remove relocations for section S->reloc starting at oldrelocoffset
539 that are to the same place, retaining the last of them. As side effect
540 the relocations are sorted. Possibly reduces the number of relocs. */
541 ST_FUNC void squeeze_multi_relocs(Section *s, size_t oldrelocoffset)
543 Section *sr = s->reloc;
544 ElfW_Rel *r, *dest;
545 ssize_t a;
546 ElfW(Addr) addr;
548 if (oldrelocoffset + sizeof(*r) >= sr->data_offset)
549 return;
550 /* The relocs we're dealing with are the result of initializer parsing.
551 So they will be mostly in order and there aren't many of them.
552 Secondly we need a stable sort (which qsort isn't). We use
553 a simple insertion sort. */
554 for (a = oldrelocoffset + sizeof(*r); a < sr->data_offset; a += sizeof(*r)) {
555 ssize_t i = a - sizeof(*r);
556 addr = ((ElfW_Rel*)(sr->data + a))->r_offset;
557 for (; i >= (ssize_t)oldrelocoffset &&
558 ((ElfW_Rel*)(sr->data + i))->r_offset > addr; i -= sizeof(*r)) {
559 ElfW_Rel tmp = *(ElfW_Rel*)(sr->data + a);
560 *(ElfW_Rel*)(sr->data + a) = *(ElfW_Rel*)(sr->data + i);
561 *(ElfW_Rel*)(sr->data + i) = tmp;
565 r = (ElfW_Rel*)(sr->data + oldrelocoffset);
566 dest = r;
567 for (; r < (ElfW_Rel*)(sr->data + sr->data_offset); r++) {
568 if (dest->r_offset != r->r_offset)
569 dest++;
570 *dest = *r;
572 sr->data_offset = (unsigned char*)dest - sr->data + sizeof(*r);
575 /* put stab debug information */
577 ST_FUNC void put_stabs(const char *str, int type, int other, int desc,
578 unsigned long value)
580 Stab_Sym *sym;
582 sym = section_ptr_add(stab_section, sizeof(Stab_Sym));
583 if (str) {
584 sym->n_strx = put_elf_str(stabstr_section, str);
585 } else {
586 sym->n_strx = 0;
588 sym->n_type = type;
589 sym->n_other = other;
590 sym->n_desc = desc;
591 sym->n_value = value;
594 ST_FUNC void put_stabs_r(const char *str, int type, int other, int desc,
595 unsigned long value, Section *sec, int sym_index)
597 put_stabs(str, type, other, desc, value);
598 put_elf_reloc(symtab_section, stab_section,
599 stab_section->data_offset - sizeof(unsigned int),
600 R_DATA_32, sym_index);
603 ST_FUNC void put_stabn(int type, int other, int desc, int value)
605 put_stabs(NULL, type, other, desc, value);
608 ST_FUNC void put_stabd(int type, int other, int desc)
610 put_stabs(NULL, type, other, desc, 0);
613 ST_FUNC struct sym_attr *get_sym_attr(TCCState *s1, int index, int alloc)
615 int n;
616 struct sym_attr *tab;
618 if (index >= s1->nb_sym_attrs) {
619 if (!alloc)
620 return s1->sym_attrs;
621 /* find immediately bigger power of 2 and reallocate array */
622 n = 1;
623 while (index >= n)
624 n *= 2;
625 tab = tcc_realloc(s1->sym_attrs, n * sizeof(*s1->sym_attrs));
626 s1->sym_attrs = tab;
627 memset(s1->sym_attrs + s1->nb_sym_attrs, 0,
628 (n - s1->nb_sym_attrs) * sizeof(*s1->sym_attrs));
629 s1->nb_sym_attrs = n;
631 return &s1->sym_attrs[index];
634 /* Browse each elem of type <type> in section <sec> starting at elem <startoff>
635 using variable <elem> */
636 #define for_each_elem(sec, startoff, elem, type) \
637 for (elem = (type *) sec->data + startoff; \
638 elem < (type *) (sec->data + sec->data_offset); elem++)
640 /* In an ELF file symbol table, the local symbols must appear below
641 the global and weak ones. Since TCC cannot sort it while generating
642 the code, we must do it after. All the relocation tables are also
643 modified to take into account the symbol table sorting */
644 static void sort_syms(TCCState *s1, Section *s)
646 int *old_to_new_syms;
647 ElfW(Sym) *new_syms;
648 int nb_syms, i;
649 ElfW(Sym) *p, *q;
650 ElfW_Rel *rel;
651 Section *sr;
652 int type, sym_index;
654 nb_syms = s->data_offset / sizeof(ElfW(Sym));
655 new_syms = tcc_malloc(nb_syms * sizeof(ElfW(Sym)));
656 old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
658 /* first pass for local symbols */
659 p = (ElfW(Sym) *)s->data;
660 q = new_syms;
661 for(i = 0; i < nb_syms; i++) {
662 if (ELFW(ST_BIND)(p->st_info) == STB_LOCAL) {
663 old_to_new_syms[i] = q - new_syms;
664 *q++ = *p;
666 p++;
668 /* save the number of local symbols in section header */
669 s->sh_info = q - new_syms;
671 /* then second pass for non local symbols */
672 p = (ElfW(Sym) *)s->data;
673 for(i = 0; i < nb_syms; i++) {
674 if (ELFW(ST_BIND)(p->st_info) != STB_LOCAL) {
675 old_to_new_syms[i] = q - new_syms;
676 *q++ = *p;
678 p++;
681 /* we copy the new symbols to the old */
682 memcpy(s->data, new_syms, nb_syms * sizeof(ElfW(Sym)));
683 tcc_free(new_syms);
685 /* now we modify all the relocations */
686 for(i = 1; i < s1->nb_sections; i++) {
687 sr = s1->sections[i];
688 if (sr->sh_type == SHT_RELX && sr->link == s) {
689 for_each_elem(sr, 0, rel, ElfW_Rel) {
690 sym_index = ELFW(R_SYM)(rel->r_info);
691 type = ELFW(R_TYPE)(rel->r_info);
692 sym_index = old_to_new_syms[sym_index];
693 rel->r_info = ELFW(R_INFO)(sym_index, type);
698 tcc_free(old_to_new_syms);
701 /* relocate common symbols in the .bss section */
702 ST_FUNC void relocate_common_syms(void)
704 ElfW(Sym) *sym;
705 unsigned long offset, align;
707 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
708 if (sym->st_shndx == SHN_COMMON) {
709 /* align symbol */
710 align = sym->st_value;
711 offset = bss_section->data_offset;
712 offset = (offset + align - 1) & -align;
713 sym->st_value = offset;
714 sym->st_shndx = bss_section->sh_num;
715 offset += sym->st_size;
716 bss_section->data_offset = offset;
721 /* relocate symbol table, resolve undefined symbols if do_resolve is
722 true and output error if undefined symbol. */
723 ST_FUNC void relocate_syms(TCCState *s1, Section *symtab, int do_resolve)
725 ElfW(Sym) *sym;
726 int sym_bind, sh_num;
727 const char *name;
729 for_each_elem(symtab, 1, sym, ElfW(Sym)) {
730 sh_num = sym->st_shndx;
731 if (sh_num == SHN_UNDEF) {
732 name = (char *) strtab_section->data + sym->st_name;
733 /* Use ld.so to resolve symbol for us (for tcc -run) */
734 if (do_resolve) {
735 #if defined TCC_IS_NATIVE && !defined TCC_TARGET_PE
736 void *addr = dlsym(RTLD_DEFAULT, name);
737 if (addr) {
738 sym->st_value = (addr_t) addr;
739 #ifdef DEBUG_RELOC
740 printf ("relocate_sym: %s -> 0x%lx\n", name, sym->st_value);
741 #endif
742 goto found;
744 #endif
745 /* if dynamic symbol exist, it will be used in relocate_section */
746 } else if (s1->dynsym && find_elf_sym(s1->dynsym, name))
747 goto found;
748 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
749 it */
750 if (!strcmp(name, "_fp_hw"))
751 goto found;
752 /* only weak symbols are accepted to be undefined. Their
753 value is zero */
754 sym_bind = ELFW(ST_BIND)(sym->st_info);
755 if (sym_bind == STB_WEAK)
756 sym->st_value = 0;
757 else
758 tcc_error_noabort("undefined symbol '%s'", name);
759 } else if (sh_num < SHN_LORESERVE) {
760 /* add section base */
761 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
763 found: ;
767 /* relocate a given section (CPU dependent) by applying the relocations
768 in the associated relocation section */
769 ST_FUNC void relocate_section(TCCState *s1, Section *s)
771 Section *sr = s->reloc;
772 ElfW_Rel *rel;
773 ElfW(Sym) *sym;
774 int type, sym_index;
775 unsigned char *ptr;
776 addr_t tgt, addr;
778 relocate_init(sr);
780 for_each_elem(sr, 0, rel, ElfW_Rel) {
781 ptr = s->data + rel->r_offset;
782 sym_index = ELFW(R_SYM)(rel->r_info);
783 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
784 type = ELFW(R_TYPE)(rel->r_info);
785 tgt = sym->st_value;
786 #if SHT_RELX == SHT_RELA
787 tgt += rel->r_addend;
788 #endif
789 addr = s->sh_addr + rel->r_offset;
790 relocate(s1, rel, type, ptr, addr, tgt);
792 /* if the relocation is allocated, we change its symbol table */
793 if (sr->sh_flags & SHF_ALLOC)
794 sr->link = s1->dynsym;
797 /* relocate relocation table in 'sr' */
798 static void relocate_rel(TCCState *s1, Section *sr)
800 Section *s;
801 ElfW_Rel *rel;
803 s = s1->sections[sr->sh_info];
804 for_each_elem(sr, 0, rel, ElfW_Rel)
805 rel->r_offset += s->sh_addr;
808 /* count the number of dynamic relocations so that we can reserve
809 their space */
810 static int prepare_dynamic_rel(TCCState *s1, Section *sr)
812 ElfW_Rel *rel;
813 int sym_index, type, count;
815 count = 0;
816 for_each_elem(sr, 0, rel, ElfW_Rel) {
817 sym_index = ELFW(R_SYM)(rel->r_info);
818 type = ELFW(R_TYPE)(rel->r_info);
819 switch(type) {
820 #if defined(TCC_TARGET_I386)
821 case R_386_32:
822 #elif defined(TCC_TARGET_X86_64)
823 case R_X86_64_32:
824 case R_X86_64_32S:
825 case R_X86_64_64:
826 #endif
827 count++;
828 break;
829 #if defined(TCC_TARGET_I386)
830 case R_386_PC32:
831 #elif defined(TCC_TARGET_X86_64)
832 case R_X86_64_PC32:
833 #endif
834 if (get_sym_attr(s1, sym_index, 0)->dyn_index)
835 count++;
836 break;
837 default:
838 break;
841 if (count) {
842 /* allocate the section */
843 sr->sh_flags |= SHF_ALLOC;
844 sr->sh_size = count * sizeof(ElfW_Rel);
846 return count;
849 static void build_got(TCCState *s1)
851 /* if no got, then create it */
852 s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
853 s1->got->sh_entsize = 4;
854 set_elf_sym(symtab_section, 0, 4, ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
855 0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
856 /* keep space for _DYNAMIC pointer and two dummy got entries */
857 section_ptr_add(s1->got, 3 * PTR_SIZE);
860 /* Create a GOT and (for function call) a PLT entry corresponding to a symbol
861 in s1->symtab. When creating the dynamic symbol table entry for the GOT
862 relocation, use 'size' and 'info' for the corresponding symbol metadata.
863 Returns the offset of the GOT or (if any) PLT entry. */
864 static struct sym_attr * put_got_entry(TCCState *s1, int dyn_reloc_type,
865 int reloc_type, unsigned long size,
866 int info, int sym_index)
868 int need_plt_entry;
869 const char *name;
870 ElfW(Sym) *sym;
871 struct sym_attr *attr;
872 unsigned got_offset;
873 char plt_name[100];
874 int len;
876 need_plt_entry = (dyn_reloc_type == R_JMP_SLOT);
877 attr = get_sym_attr(s1, sym_index, 1);
879 /* In case a function is both called and its address taken 2 GOT entries
880 are created, one for taking the address (GOT) and the other for the PLT
881 entry (PLTGOT). */
882 if (need_plt_entry ? attr->plt_offset : attr->got_offset)
883 return attr;
885 /* create the GOT entry */
886 got_offset = s1->got->data_offset;
887 section_ptr_add(s1->got, PTR_SIZE);
889 /* Create the GOT relocation that will insert the address of the object or
890 function of interest in the GOT entry. This is a static relocation for
891 memory output (dlsym will give us the address of symbols) and dynamic
892 relocation otherwise (executable and DLLs). The relocation should be
893 done lazily for GOT entry with *_JUMP_SLOT relocation type (the one
894 associated to a PLT entry) but is currently done at load time for an
895 unknown reason. */
897 sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
898 name = (char *) symtab_section->link->data + sym->st_name;
900 if (s1->dynsym) {
901 if (0 == attr->dyn_index)
902 attr->dyn_index = set_elf_sym(s1->dynsym, sym->st_value, size,
903 info, 0, sym->st_shndx, name);
904 put_elf_reloc(s1->dynsym, s1->got, got_offset, dyn_reloc_type,
905 attr->dyn_index);
906 } else {
907 put_elf_reloc(symtab_section, s1->got, got_offset, dyn_reloc_type,
908 sym_index);
911 if (need_plt_entry) {
912 if (!s1->plt) {
913 s1->plt = new_section(s1, ".plt", SHT_PROGBITS,
914 SHF_ALLOC | SHF_EXECINSTR);
915 s1->plt->sh_entsize = 4;
918 attr->plt_offset = create_plt_entry(s1, got_offset, attr);
920 /* create a symbol 'sym@plt' for the PLT jump vector */
921 len = strlen(name);
922 if (len > sizeof plt_name - 5)
923 len = sizeof plt_name - 5;
924 memcpy(plt_name, name, len);
925 strcpy(plt_name + len, "@plt");
926 attr->plt_sym = put_elf_sym(s1->symtab, attr->plt_offset, sym->st_size,
927 ELFW(ST_INFO)(STB_GLOBAL, STT_FUNC), 0, s1->plt->sh_num, plt_name);
929 } else {
930 attr->got_offset = got_offset;
933 return attr;
936 /* build GOT and PLT entries */
937 ST_FUNC void build_got_entries(TCCState *s1)
939 Section *s;
940 ElfW_Rel *rel;
941 ElfW(Sym) *sym;
942 int i, type, gotplt_entry, reloc_type, sym_index;
943 struct sym_attr *attr;
945 for(i = 1; i < s1->nb_sections; i++) {
946 s = s1->sections[i];
947 if (s->sh_type != SHT_RELX)
948 continue;
949 /* no need to handle got relocations */
950 if (s->link != symtab_section)
951 continue;
952 for_each_elem(s, 0, rel, ElfW_Rel) {
953 type = ELFW(R_TYPE)(rel->r_info);
954 gotplt_entry = gotplt_entry_type(type);
955 sym_index = ELFW(R_SYM)(rel->r_info);
956 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
958 if (gotplt_entry == NO_GOTPLT_ENTRY) {
959 continue;
962 /* Automatically create PLT/GOT [entry] if it is an undefined
963 reference (resolved at runtime), or the symbol is absolute,
964 probably created by tcc_add_symbol, and thus on 64-bit
965 targets might be too far from application code. */
966 if (gotplt_entry == AUTO_GOTPLT_ENTRY) {
967 if (sym->st_shndx == SHN_UNDEF) {
968 ElfW(Sym) *esym;
969 int dynindex;
970 if (s1->output_type == TCC_OUTPUT_DLL && ! PCRELATIVE_DLLPLT)
971 continue;
972 /* Relocations for UNDEF symbols would normally need
973 to be transferred into the executable or shared object.
974 If that were done AUTO_GOTPLT_ENTRY wouldn't exist.
975 But TCC doesn't do that (at least for exes), so we
976 need to resolve all such relocs locally. And that
977 means PLT slots for functions in DLLs and COPY relocs for
978 data symbols. COPY relocs were generated in
979 bind_exe_dynsyms (and the symbol adjusted to be defined),
980 and for functions we were generated a dynamic symbol
981 of function type. */
982 if (s1->dynsym) {
983 /* dynsym isn't set for -run :-/ */
984 dynindex = get_sym_attr(s1, sym_index, 0)->dyn_index;
985 esym = (ElfW(Sym) *)s1->dynsym->data + dynindex;
986 if (dynindex
987 && (ELFW(ST_TYPE)(esym->st_info) == STT_FUNC
988 || (ELFW(ST_TYPE)(esym->st_info) == STT_NOTYPE
989 && ELFW(ST_TYPE)(sym->st_info) == STT_FUNC)))
990 goto jmp_slot;
992 } else if (!(sym->st_shndx == SHN_ABS && PTR_SIZE == 8))
993 continue;
996 #ifdef TCC_TARGET_X86_64
997 if (type == R_X86_64_PLT32 &&
998 ELFW(ST_VISIBILITY)(sym->st_other) != STV_DEFAULT) {
999 rel->r_info = ELFW(R_INFO)(sym_index, R_X86_64_PC32);
1000 continue;
1002 #endif
1003 if (code_reloc(type)) {
1004 jmp_slot:
1005 reloc_type = R_JMP_SLOT;
1006 } else
1007 reloc_type = R_GLOB_DAT;
1009 if (!s1->got)
1010 build_got(s1);
1012 if (gotplt_entry == BUILD_GOT_ONLY)
1013 continue;
1015 attr = put_got_entry(s1, reloc_type, type, sym->st_size, sym->st_info,
1016 sym_index);
1018 if (reloc_type == R_JMP_SLOT)
1019 rel->r_info = ELFW(R_INFO)(attr->plt_sym, type);
1024 /* put dynamic tag */
1025 static void put_dt(Section *dynamic, int dt, addr_t val)
1027 ElfW(Dyn) *dyn;
1028 dyn = section_ptr_add(dynamic, sizeof(ElfW(Dyn)));
1029 dyn->d_tag = dt;
1030 dyn->d_un.d_val = val;
1033 #ifndef TCC_TARGET_PE
1034 static void add_init_array_defines(TCCState *s1, const char *section_name)
1036 Section *s;
1037 long end_offset;
1038 char sym_start[1024];
1039 char sym_end[1024];
1041 snprintf(sym_start, sizeof(sym_start), "__%s_start", section_name + 1);
1042 snprintf(sym_end, sizeof(sym_end), "__%s_end", section_name + 1);
1044 s = find_section(s1, section_name);
1045 if (!s) {
1046 end_offset = 0;
1047 s = data_section;
1048 } else {
1049 end_offset = s->data_offset;
1052 set_elf_sym(symtab_section,
1053 0, 0,
1054 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1055 s->sh_num, sym_start);
1056 set_elf_sym(symtab_section,
1057 end_offset, 0,
1058 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1059 s->sh_num, sym_end);
1061 #endif
1063 static int tcc_add_support(TCCState *s1, const char *filename)
1065 char buf[1024];
1066 snprintf(buf, sizeof(buf), "%s/%s", s1->tcc_lib_path, filename);
1067 return tcc_add_file(s1, buf);
1070 ST_FUNC void tcc_add_bcheck(TCCState *s1)
1072 #ifdef CONFIG_TCC_BCHECK
1073 addr_t *ptr;
1074 int sym_index;
1076 if (0 == s1->do_bounds_check)
1077 return;
1078 /* XXX: add an object file to do that */
1079 ptr = section_ptr_add(bounds_section, sizeof(*ptr));
1080 *ptr = 0;
1081 set_elf_sym(symtab_section, 0, 0,
1082 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1083 bounds_section->sh_num, "__bounds_start");
1084 /* pull bcheck.o from libtcc1.a */
1085 sym_index = set_elf_sym(symtab_section, 0, 0,
1086 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1087 SHN_UNDEF, "__bound_init");
1088 if (s1->output_type != TCC_OUTPUT_MEMORY) {
1089 /* add 'call __bound_init()' in .init section */
1090 Section *init_section = find_section(s1, ".init");
1091 unsigned char *pinit = section_ptr_add(init_section, 5);
1092 pinit[0] = 0xe8;
1093 write32le(pinit + 1, -4);
1094 put_elf_reloc(symtab_section, init_section,
1095 init_section->data_offset - 4, R_386_PC32, sym_index);
1096 /* R_386_PC32 = R_X86_64_PC32 = 2 */
1098 #endif
1101 /* add tcc runtime libraries */
1102 ST_FUNC void tcc_add_runtime(TCCState *s1)
1104 tcc_add_bcheck(s1);
1105 tcc_add_pragma_libs(s1);
1106 /* add libc */
1107 if (!s1->nostdlib) {
1108 tcc_add_library_err(s1, "c");
1109 #ifdef TCC_LIBGCC
1110 if (!s1->static_link) {
1111 if (TCC_LIBGCC[0] == '/')
1112 tcc_add_file(s1, TCC_LIBGCC);
1113 else
1114 tcc_add_dll(s1, TCC_LIBGCC, 0);
1116 #endif
1117 tcc_add_support(s1, TCC_LIBTCC1);
1118 /* add crt end if not memory output */
1119 if (s1->output_type != TCC_OUTPUT_MEMORY)
1120 tcc_add_crt(s1, "crtn.o");
1124 /* add various standard linker symbols (must be done after the
1125 sections are filled (for example after allocating common
1126 symbols)) */
1127 ST_FUNC void tcc_add_linker_symbols(TCCState *s1)
1129 char buf[1024];
1130 int i;
1131 Section *s;
1133 set_elf_sym(symtab_section,
1134 text_section->data_offset, 0,
1135 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1136 text_section->sh_num, "_etext");
1137 set_elf_sym(symtab_section,
1138 data_section->data_offset, 0,
1139 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1140 data_section->sh_num, "_edata");
1141 set_elf_sym(symtab_section,
1142 bss_section->data_offset, 0,
1143 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1144 bss_section->sh_num, "_end");
1145 #ifndef TCC_TARGET_PE
1146 /* horrible new standard ldscript defines */
1147 add_init_array_defines(s1, ".preinit_array");
1148 add_init_array_defines(s1, ".init_array");
1149 add_init_array_defines(s1, ".fini_array");
1150 #endif
1152 /* add start and stop symbols for sections whose name can be
1153 expressed in C */
1154 for(i = 1; i < s1->nb_sections; i++) {
1155 s = s1->sections[i];
1156 if (s->sh_type == SHT_PROGBITS &&
1157 (s->sh_flags & SHF_ALLOC)) {
1158 const char *p;
1159 int ch;
1161 /* check if section name can be expressed in C */
1162 p = s->name;
1163 for(;;) {
1164 ch = *p;
1165 if (!ch)
1166 break;
1167 if (!isid(ch) && !isnum(ch))
1168 goto next_sec;
1169 p++;
1171 snprintf(buf, sizeof(buf), "__start_%s", s->name);
1172 set_elf_sym(symtab_section,
1173 0, 0,
1174 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1175 s->sh_num, buf);
1176 snprintf(buf, sizeof(buf), "__stop_%s", s->name);
1177 set_elf_sym(symtab_section,
1178 s->data_offset, 0,
1179 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1180 s->sh_num, buf);
1182 next_sec: ;
1186 static void tcc_output_binary(TCCState *s1, FILE *f,
1187 const int *sec_order)
1189 Section *s;
1190 int i, offset, size;
1192 offset = 0;
1193 for(i=1;i<s1->nb_sections;i++) {
1194 s = s1->sections[sec_order[i]];
1195 if (s->sh_type != SHT_NOBITS &&
1196 (s->sh_flags & SHF_ALLOC)) {
1197 while (offset < s->sh_offset) {
1198 fputc(0, f);
1199 offset++;
1201 size = s->sh_size;
1202 fwrite(s->data, 1, size, f);
1203 offset += size;
1208 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1209 #define HAVE_PHDR 1
1210 #define EXTRA_RELITEMS 14
1211 #else
1212 #define HAVE_PHDR 1
1213 #define EXTRA_RELITEMS 9
1214 #endif
1216 ST_FUNC void fill_got_entry(TCCState *s1, ElfW_Rel *rel)
1218 int sym_index = ELFW(R_SYM) (rel->r_info);
1219 ElfW(Sym) *sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
1220 struct sym_attr *attr = get_sym_attr(s1, sym_index, 0);
1221 unsigned offset = attr->got_offset;
1223 if (0 == offset)
1224 return;
1225 section_reserve(s1->got, offset + PTR_SIZE);
1226 #ifdef TCC_TARGET_X86_64
1227 write64le(s1->got->data + offset, sym->st_value);
1228 #else
1229 write32le(s1->got->data + offset, sym->st_value);
1230 #endif
1233 /* Perform relocation to GOT or PLT entries */
1234 ST_FUNC void fill_got(TCCState *s1)
1236 Section *s;
1237 ElfW_Rel *rel;
1238 int i;
1240 for(i = 1; i < s1->nb_sections; i++) {
1241 s = s1->sections[i];
1242 if (s->sh_type != SHT_RELX)
1243 continue;
1244 /* no need to handle got relocations */
1245 if (s->link != symtab_section)
1246 continue;
1247 for_each_elem(s, 0, rel, ElfW_Rel) {
1248 switch (ELFW(R_TYPE) (rel->r_info)) {
1249 case R_X86_64_GOT32:
1250 case R_X86_64_GOTPCREL:
1251 case R_X86_64_GOTPCRELX:
1252 case R_X86_64_REX_GOTPCRELX:
1253 case R_X86_64_PLT32:
1254 fill_got_entry(s1, rel);
1255 break;
1261 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1262 in shared libraries and export non local defined symbols to shared libraries
1263 if -rdynamic switch was given on command line */
1264 static void bind_exe_dynsyms(TCCState *s1)
1266 const char *name;
1267 int sym_index, index;
1268 ElfW(Sym) *sym, *esym;
1269 int type;
1271 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1272 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1273 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1274 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1275 if (sym->st_shndx == SHN_UNDEF) {
1276 name = (char *) symtab_section->link->data + sym->st_name;
1277 sym_index = find_elf_sym(s1->dynsymtab_section, name);
1278 if (sym_index) {
1279 esym = &((ElfW(Sym) *)s1->dynsymtab_section->data)[sym_index];
1280 type = ELFW(ST_TYPE)(esym->st_info);
1281 if ((type == STT_FUNC) || (type == STT_GNU_IFUNC)) {
1282 /* Indirect functions shall have STT_FUNC type in executable
1283 * dynsym section. Indeed, a dlsym call following a lazy
1284 * resolution would pick the symbol value from the
1285 * executable dynsym entry which would contain the address
1286 * of the function wanted by the caller of dlsym instead of
1287 * the address of the function that would return that
1288 * address */
1289 int dynindex
1290 = put_elf_sym(s1->dynsym, 0, esym->st_size,
1291 ELFW(ST_INFO)(STB_GLOBAL,STT_FUNC), 0, 0,
1292 name);
1293 int index = sym - (ElfW(Sym) *) symtab_section->data;
1294 get_sym_attr(s1, index, 1)->dyn_index = dynindex;
1295 } else if (type == STT_OBJECT) {
1296 unsigned long offset;
1297 ElfW(Sym) *dynsym;
1298 offset = bss_section->data_offset;
1299 /* XXX: which alignment ? */
1300 offset = (offset + 16 - 1) & -16;
1301 set_elf_sym (s1->symtab, offset, esym->st_size,
1302 esym->st_info, 0, bss_section->sh_num, name);
1303 index = put_elf_sym(s1->dynsym, offset, esym->st_size,
1304 esym->st_info, 0, bss_section->sh_num,
1305 name);
1307 /* Ensure R_COPY works for weak symbol aliases */
1308 if (ELFW(ST_BIND)(esym->st_info) == STB_WEAK) {
1309 for_each_elem(s1->dynsymtab_section, 1, dynsym, ElfW(Sym)) {
1310 if ((dynsym->st_value == esym->st_value)
1311 && (ELFW(ST_BIND)(dynsym->st_info) == STB_GLOBAL)) {
1312 char *dynname = (char *) s1->dynsymtab_section->link->data
1313 + dynsym->st_name;
1314 put_elf_sym(s1->dynsym, offset, dynsym->st_size,
1315 dynsym->st_info, 0,
1316 bss_section->sh_num, dynname);
1317 break;
1322 put_elf_reloc(s1->dynsym, bss_section,
1323 offset, R_COPY, index);
1324 offset += esym->st_size;
1325 bss_section->data_offset = offset;
1327 } else {
1328 /* STB_WEAK undefined symbols are accepted */
1329 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1330 if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK ||
1331 !strcmp(name, "_fp_hw")) {
1332 } else {
1333 tcc_error_noabort("undefined symbol '%s'", name);
1336 } else if (s1->rdynamic && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1337 /* if -rdynamic option, then export all non local symbols */
1338 name = (char *) symtab_section->link->data + sym->st_name;
1339 set_elf_sym(s1->dynsym, sym->st_value, sym->st_size, sym->st_info,
1340 0, sym->st_shndx, name);
1345 /* Bind symbols of libraries: export all non local symbols of executable that
1346 are referenced by shared libraries. The reason is that the dynamic loader
1347 search symbol first in executable and then in libraries. Therefore a
1348 reference to a symbol already defined by a library can still be resolved by
1349 a symbol in the executable. */
1350 static void bind_libs_dynsyms(TCCState *s1)
1352 const char *name;
1353 int sym_index;
1354 ElfW(Sym) *sym, *esym;
1356 for_each_elem(s1->dynsymtab_section, 1, esym, ElfW(Sym)) {
1357 name = (char *) s1->dynsymtab_section->link->data + esym->st_name;
1358 sym_index = find_elf_sym(symtab_section, name);
1359 /* XXX: avoid adding a symbol if already present because of
1360 -rdynamic ? */
1361 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1362 if (sym_index && sym->st_shndx != SHN_UNDEF)
1363 set_elf_sym(s1->dynsym, sym->st_value, sym->st_size, sym->st_info,
1364 0, sym->st_shndx, name);
1365 else if (esym->st_shndx == SHN_UNDEF) {
1366 /* weak symbols can stay undefined */
1367 if (ELFW(ST_BIND)(esym->st_info) != STB_WEAK)
1368 tcc_warning("undefined dynamic symbol '%s'", name);
1373 /* Export all non local symbols. This is used by shared libraries so that the
1374 non local symbols they define can resolve a reference in another shared
1375 library or in the executable. Correspondingly, it allows undefined local
1376 symbols to be resolved by other shared libraries or by the executable. */
1377 static void export_global_syms(TCCState *s1)
1379 int dynindex, index;
1380 const char *name;
1381 ElfW(Sym) *sym;
1383 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1384 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1385 name = (char *) symtab_section->link->data + sym->st_name;
1386 dynindex = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1387 sym->st_info, 0, sym->st_shndx, name);
1388 index = sym - (ElfW(Sym) *) symtab_section->data;
1389 get_sym_attr(s1, index, 1)->dyn_index = dynindex;
1394 /* Allocate strings for section names and decide if an unallocated section
1395 should be output.
1396 NOTE: the strsec section comes last, so its size is also correct ! */
1397 static void alloc_sec_names(TCCState *s1, int file_type, Section *strsec)
1399 int i;
1400 Section *s;
1402 /* Allocate strings for section names */
1403 for(i = 1; i < s1->nb_sections; i++) {
1404 s = s1->sections[i];
1405 s->sh_name = put_elf_str(strsec, s->name);
1406 /* when generating a DLL, we include relocations but we may
1407 patch them */
1408 if (file_type == TCC_OUTPUT_DLL &&
1409 s->sh_type == SHT_RELX &&
1410 !(s->sh_flags & SHF_ALLOC)) {
1411 /* gr: avoid bogus relocs for empty (debug) sections */
1412 if (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC)
1413 prepare_dynamic_rel(s1, s);
1414 else if (s1->do_debug)
1415 s->sh_size = s->data_offset;
1416 } else if (s1->do_debug ||
1417 file_type == TCC_OUTPUT_OBJ ||
1418 (s->sh_flags & SHF_ALLOC) ||
1419 i == (s1->nb_sections - 1)) {
1420 /* we output all sections if debug or object file */
1421 s->sh_size = s->data_offset;
1426 /* Info to be copied in dynamic section */
1427 struct dyn_inf {
1428 Section *dynamic;
1429 Section *dynstr;
1430 unsigned long dyn_rel_off;
1431 addr_t rel_addr;
1432 addr_t rel_size;
1433 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1434 addr_t bss_addr;
1435 addr_t bss_size;
1436 #endif
1439 /* Assign sections to segments and decide how are sections laid out when loaded
1440 in memory. This function also fills corresponding program headers. */
1441 static int layout_sections(TCCState *s1, ElfW(Phdr) *phdr, int phnum,
1442 Section *interp, Section* strsec,
1443 struct dyn_inf *dyninf, int *sec_order)
1445 int i, j, k, file_type, sh_order_index, file_offset;
1446 unsigned long s_align;
1447 long long tmp;
1448 addr_t addr;
1449 ElfW(Phdr) *ph;
1450 Section *s;
1452 file_type = s1->output_type;
1453 sh_order_index = 1;
1454 file_offset = 0;
1455 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
1456 file_offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1457 s_align = ELF_PAGE_SIZE;
1458 if (s1->section_align)
1459 s_align = s1->section_align;
1461 if (phnum > 0) {
1462 if (s1->has_text_addr) {
1463 int a_offset, p_offset;
1464 addr = s1->text_addr;
1465 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1466 ELF_PAGE_SIZE */
1467 a_offset = (int) (addr & (s_align - 1));
1468 p_offset = file_offset & (s_align - 1);
1469 if (a_offset < p_offset)
1470 a_offset += s_align;
1471 file_offset += (a_offset - p_offset);
1472 } else {
1473 if (file_type == TCC_OUTPUT_DLL)
1474 addr = 0;
1475 else
1476 addr = ELF_START_ADDR;
1477 /* compute address after headers */
1478 addr += (file_offset & (s_align - 1));
1481 ph = &phdr[0];
1482 /* Leave one program headers for the program interpreter and one for
1483 the program header table itself if needed. These are done later as
1484 they require section layout to be done first. */
1485 if (interp)
1486 ph += 1 + HAVE_PHDR;
1488 /* dynamic relocation table information, for .dynamic section */
1489 dyninf->rel_addr = dyninf->rel_size = 0;
1490 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1491 dyninf->bss_addr = dyninf->bss_size = 0;
1492 #endif
1494 for(j = 0; j < 2; j++) {
1495 ph->p_type = PT_LOAD;
1496 if (j == 0)
1497 ph->p_flags = PF_R | PF_X;
1498 else
1499 ph->p_flags = PF_R | PF_W;
1500 ph->p_align = s_align;
1502 /* Decide the layout of sections loaded in memory. This must
1503 be done before program headers are filled since they contain
1504 info about the layout. We do the following ordering: interp,
1505 symbol tables, relocations, progbits, nobits */
1506 /* XXX: do faster and simpler sorting */
1507 for(k = 0; k < 5; k++) {
1508 for(i = 1; i < s1->nb_sections; i++) {
1509 s = s1->sections[i];
1510 /* compute if section should be included */
1511 if (j == 0) {
1512 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1513 SHF_ALLOC)
1514 continue;
1515 } else {
1516 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1517 (SHF_ALLOC | SHF_WRITE))
1518 continue;
1520 if (s == interp) {
1521 if (k != 0)
1522 continue;
1523 } else if (s->sh_type == SHT_DYNSYM ||
1524 s->sh_type == SHT_STRTAB ||
1525 s->sh_type == SHT_HASH) {
1526 if (k != 1)
1527 continue;
1528 } else if (s->sh_type == SHT_RELX) {
1529 if (k != 2)
1530 continue;
1531 } else if (s->sh_type == SHT_NOBITS) {
1532 if (k != 4)
1533 continue;
1534 } else {
1535 if (k != 3)
1536 continue;
1538 sec_order[sh_order_index++] = i;
1540 /* section matches: we align it and add its size */
1541 tmp = addr;
1542 addr = (addr + s->sh_addralign - 1) &
1543 ~(s->sh_addralign - 1);
1544 file_offset += (int) ( addr - tmp );
1545 s->sh_offset = file_offset;
1546 s->sh_addr = addr;
1548 /* update program header infos */
1549 if (ph->p_offset == 0) {
1550 ph->p_offset = file_offset;
1551 ph->p_vaddr = addr;
1552 ph->p_paddr = ph->p_vaddr;
1554 /* update dynamic relocation infos */
1555 if (s->sh_type == SHT_RELX) {
1556 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1557 if (!strcmp(strsec->data + s->sh_name, ".rel.got")) {
1558 dyninf->rel_addr = addr;
1559 dyninf->rel_size += s->sh_size; /* XXX only first rel. */
1561 if (!strcmp(strsec->data + s->sh_name, ".rel.bss")) {
1562 dyninf->bss_addr = addr;
1563 dyninf->bss_size = s->sh_size; /* XXX only first rel. */
1565 #else
1566 if (dyninf->rel_size == 0)
1567 dyninf->rel_addr = addr;
1568 dyninf->rel_size += s->sh_size;
1569 #endif
1571 addr += s->sh_size;
1572 if (s->sh_type != SHT_NOBITS)
1573 file_offset += s->sh_size;
1576 if (j == 0) {
1577 /* Make the first PT_LOAD segment include the program
1578 headers itself (and the ELF header as well), it'll
1579 come out with same memory use but will make various
1580 tools like binutils strip work better. */
1581 ph->p_offset &= ~(ph->p_align - 1);
1582 ph->p_vaddr &= ~(ph->p_align - 1);
1583 ph->p_paddr &= ~(ph->p_align - 1);
1585 ph->p_filesz = file_offset - ph->p_offset;
1586 ph->p_memsz = addr - ph->p_vaddr;
1587 ph++;
1588 if (j == 0) {
1589 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1590 /* if in the middle of a page, we duplicate the page in
1591 memory so that one copy is RX and the other is RW */
1592 if ((addr & (s_align - 1)) != 0)
1593 addr += s_align;
1594 } else {
1595 addr = (addr + s_align - 1) & ~(s_align - 1);
1596 file_offset = (file_offset + s_align - 1) & ~(s_align - 1);
1602 /* all other sections come after */
1603 for(i = 1; i < s1->nb_sections; i++) {
1604 s = s1->sections[i];
1605 if (phnum > 0 && (s->sh_flags & SHF_ALLOC))
1606 continue;
1607 sec_order[sh_order_index++] = i;
1609 file_offset = (file_offset + s->sh_addralign - 1) &
1610 ~(s->sh_addralign - 1);
1611 s->sh_offset = file_offset;
1612 if (s->sh_type != SHT_NOBITS)
1613 file_offset += s->sh_size;
1616 return file_offset;
1619 static void fill_unloadable_phdr(ElfW(Phdr) *phdr, int phnum, Section *interp,
1620 Section *dynamic)
1622 ElfW(Phdr) *ph;
1624 /* if interpreter, then add corresponding program header */
1625 if (interp) {
1626 ph = &phdr[0];
1628 if (HAVE_PHDR)
1630 int len = phnum * sizeof(ElfW(Phdr));
1632 ph->p_type = PT_PHDR;
1633 ph->p_offset = sizeof(ElfW(Ehdr));
1634 ph->p_vaddr = interp->sh_addr - len;
1635 ph->p_paddr = ph->p_vaddr;
1636 ph->p_filesz = ph->p_memsz = len;
1637 ph->p_flags = PF_R | PF_X;
1638 ph->p_align = 4; /* interp->sh_addralign; */
1639 ph++;
1642 ph->p_type = PT_INTERP;
1643 ph->p_offset = interp->sh_offset;
1644 ph->p_vaddr = interp->sh_addr;
1645 ph->p_paddr = ph->p_vaddr;
1646 ph->p_filesz = interp->sh_size;
1647 ph->p_memsz = interp->sh_size;
1648 ph->p_flags = PF_R;
1649 ph->p_align = interp->sh_addralign;
1652 /* if dynamic section, then add corresponding program header */
1653 if (dynamic) {
1654 ph = &phdr[phnum - 1];
1656 ph->p_type = PT_DYNAMIC;
1657 ph->p_offset = dynamic->sh_offset;
1658 ph->p_vaddr = dynamic->sh_addr;
1659 ph->p_paddr = ph->p_vaddr;
1660 ph->p_filesz = dynamic->sh_size;
1661 ph->p_memsz = dynamic->sh_size;
1662 ph->p_flags = PF_R | PF_W;
1663 ph->p_align = dynamic->sh_addralign;
1667 /* Fill the dynamic section with tags describing the address and size of
1668 sections */
1669 static void fill_dynamic(TCCState *s1, struct dyn_inf *dyninf)
1671 Section *dynamic;
1673 dynamic = dyninf->dynamic;
1675 /* put dynamic section entries */
1676 dynamic->data_offset = dyninf->dyn_rel_off;
1677 put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
1678 put_dt(dynamic, DT_STRTAB, dyninf->dynstr->sh_addr);
1679 put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
1680 put_dt(dynamic, DT_STRSZ, dyninf->dynstr->data_offset);
1681 put_dt(dynamic, DT_SYMENT, sizeof(ElfW(Sym)));
1682 #if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
1683 put_dt(dynamic, DT_RELA, dyninf->rel_addr);
1684 put_dt(dynamic, DT_RELASZ, dyninf->rel_size);
1685 put_dt(dynamic, DT_RELAENT, sizeof(ElfW_Rel));
1686 #else
1687 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1688 put_dt(dynamic, DT_PLTGOT, s1->got->sh_addr);
1689 put_dt(dynamic, DT_PLTRELSZ, dyninf->rel_size);
1690 put_dt(dynamic, DT_JMPREL, dyninf->rel_addr);
1691 put_dt(dynamic, DT_PLTREL, DT_REL);
1692 put_dt(dynamic, DT_REL, dyninf->bss_addr);
1693 put_dt(dynamic, DT_RELSZ, dyninf->bss_size);
1694 #else
1695 put_dt(dynamic, DT_REL, dyninf->rel_addr);
1696 put_dt(dynamic, DT_RELSZ, dyninf->rel_size);
1697 put_dt(dynamic, DT_RELENT, sizeof(ElfW_Rel));
1698 #endif
1699 #endif
1700 if (s1->do_debug)
1701 put_dt(dynamic, DT_DEBUG, 0);
1702 put_dt(dynamic, DT_NULL, 0);
1705 /* Relocate remaining sections and symbols (that is those not related to
1706 dynamic linking) */
1707 static int final_sections_reloc(TCCState *s1)
1709 int i;
1710 Section *s;
1712 relocate_syms(s1, s1->symtab, 0);
1714 if (s1->nb_errors != 0)
1715 return -1;
1717 /* relocate sections */
1718 /* XXX: ignore sections with allocated relocations ? */
1719 for(i = 1; i < s1->nb_sections; i++) {
1720 s = s1->sections[i];
1721 #ifdef TCC_TARGET_I386
1722 if (s->reloc && s != s1->got && (s->sh_flags & SHF_ALLOC)) //gr
1723 /* On X86 gdb 7.3 works in any case but gdb 6.6 will crash if SHF_ALLOC
1724 checking is removed */
1725 #else
1726 if (s->reloc && s != s1->got)
1727 /* On X86_64 gdb 7.3 will crash if SHF_ALLOC checking is present */
1728 #endif
1729 relocate_section(s1, s);
1732 /* relocate relocation entries if the relocation tables are
1733 allocated in the executable */
1734 for(i = 1; i < s1->nb_sections; i++) {
1735 s = s1->sections[i];
1736 if ((s->sh_flags & SHF_ALLOC) &&
1737 s->sh_type == SHT_RELX) {
1738 relocate_rel(s1, s);
1741 return 0;
1744 /* Create an ELF file on disk.
1745 This function handle ELF specific layout requirements */
1746 static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
1747 int file_offset, int *sec_order)
1749 int i, shnum, offset, size, file_type;
1750 Section *s;
1751 ElfW(Ehdr) ehdr;
1752 ElfW(Shdr) shdr, *sh;
1754 file_type = s1->output_type;
1755 shnum = s1->nb_sections;
1757 memset(&ehdr, 0, sizeof(ehdr));
1759 if (phnum > 0) {
1760 ehdr.e_phentsize = sizeof(ElfW(Phdr));
1761 ehdr.e_phnum = phnum;
1762 ehdr.e_phoff = sizeof(ElfW(Ehdr));
1765 /* align to 4 */
1766 file_offset = (file_offset + 3) & -4;
1768 /* fill header */
1769 ehdr.e_ident[0] = ELFMAG0;
1770 ehdr.e_ident[1] = ELFMAG1;
1771 ehdr.e_ident[2] = ELFMAG2;
1772 ehdr.e_ident[3] = ELFMAG3;
1773 ehdr.e_ident[4] = ELFCLASSW;
1774 ehdr.e_ident[5] = ELFDATA2LSB;
1775 ehdr.e_ident[6] = EV_CURRENT;
1776 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1777 ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
1778 #endif
1779 #ifdef TCC_TARGET_ARM
1780 #ifdef TCC_ARM_EABI
1781 ehdr.e_ident[EI_OSABI] = 0;
1782 ehdr.e_flags = EF_ARM_EABI_VER4;
1783 if (file_type == TCC_OUTPUT_EXE || file_type == TCC_OUTPUT_DLL)
1784 ehdr.e_flags |= EF_ARM_HASENTRY;
1785 if (s1->float_abi == ARM_HARD_FLOAT)
1786 ehdr.e_flags |= EF_ARM_VFP_FLOAT;
1787 else
1788 ehdr.e_flags |= EF_ARM_SOFT_FLOAT;
1789 #else
1790 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
1791 #endif
1792 #endif
1793 switch(file_type) {
1794 default:
1795 case TCC_OUTPUT_EXE:
1796 ehdr.e_type = ET_EXEC;
1797 ehdr.e_entry = get_elf_sym_addr(s1, "_start", 1);
1798 break;
1799 case TCC_OUTPUT_DLL:
1800 ehdr.e_type = ET_DYN;
1801 ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
1802 break;
1803 case TCC_OUTPUT_OBJ:
1804 ehdr.e_type = ET_REL;
1805 break;
1807 ehdr.e_machine = EM_TCC_TARGET;
1808 ehdr.e_version = EV_CURRENT;
1809 ehdr.e_shoff = file_offset;
1810 ehdr.e_ehsize = sizeof(ElfW(Ehdr));
1811 ehdr.e_shentsize = sizeof(ElfW(Shdr));
1812 ehdr.e_shnum = shnum;
1813 ehdr.e_shstrndx = shnum - 1;
1815 fwrite(&ehdr, 1, sizeof(ElfW(Ehdr)), f);
1816 fwrite(phdr, 1, phnum * sizeof(ElfW(Phdr)), f);
1817 offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1819 sort_syms(s1, symtab_section);
1820 for(i = 1; i < s1->nb_sections; i++) {
1821 s = s1->sections[sec_order[i]];
1822 if (s->sh_type != SHT_NOBITS) {
1823 while (offset < s->sh_offset) {
1824 fputc(0, f);
1825 offset++;
1827 size = s->sh_size;
1828 if (size)
1829 fwrite(s->data, 1, size, f);
1830 offset += size;
1834 /* output section headers */
1835 while (offset < ehdr.e_shoff) {
1836 fputc(0, f);
1837 offset++;
1840 for(i = 0; i < s1->nb_sections; i++) {
1841 sh = &shdr;
1842 memset(sh, 0, sizeof(ElfW(Shdr)));
1843 s = s1->sections[i];
1844 if (s) {
1845 sh->sh_name = s->sh_name;
1846 sh->sh_type = s->sh_type;
1847 sh->sh_flags = s->sh_flags;
1848 sh->sh_entsize = s->sh_entsize;
1849 sh->sh_info = s->sh_info;
1850 if (s->link)
1851 sh->sh_link = s->link->sh_num;
1852 sh->sh_addralign = s->sh_addralign;
1853 sh->sh_addr = s->sh_addr;
1854 sh->sh_offset = s->sh_offset;
1855 sh->sh_size = s->sh_size;
1857 fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
1861 /* Write an elf, coff or "binary" file */
1862 static int tcc_write_elf_file(TCCState *s1, const char *filename, int phnum,
1863 ElfW(Phdr) *phdr, int file_offset, int *sec_order)
1865 int fd, mode, file_type;
1866 FILE *f;
1868 file_type = s1->output_type;
1869 if (file_type == TCC_OUTPUT_OBJ)
1870 mode = 0666;
1871 else
1872 mode = 0777;
1873 unlink(filename);
1874 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
1875 if (fd < 0) {
1876 tcc_error_noabort("could not write '%s'", filename);
1877 return -1;
1879 f = fdopen(fd, "wb");
1880 if (s1->verbose)
1881 printf("<- %s\n", filename);
1883 #ifdef TCC_TARGET_COFF
1884 if (s1->output_format == TCC_OUTPUT_FORMAT_COFF)
1885 tcc_output_coff(s1, f);
1886 else
1887 #endif
1888 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
1889 tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
1890 else
1891 tcc_output_binary(s1, f, sec_order);
1892 fclose(f);
1894 return 0;
1897 /* Output an elf, coff or binary file */
1898 /* XXX: suppress unneeded sections */
1899 static int elf_output_file(TCCState *s1, const char *filename)
1901 int i, ret, phnum, shnum, file_type, file_offset, *sec_order;
1902 struct dyn_inf dyninf = {0};
1903 ElfW(Phdr) *phdr;
1904 ElfW(Sym) *sym;
1905 Section *strsec, *interp, *dynamic, *dynstr;
1907 file_type = s1->output_type;
1908 s1->nb_errors = 0;
1910 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
1911 if (file_type != TCC_OUTPUT_OBJ) {
1912 tcc_add_runtime(s1);
1915 phdr = NULL;
1916 sec_order = NULL;
1917 interp = dynamic = dynstr = NULL; /* avoid warning */
1919 if (file_type != TCC_OUTPUT_OBJ) {
1920 relocate_common_syms();
1922 tcc_add_linker_symbols(s1);
1924 if (!s1->static_link) {
1925 if (file_type == TCC_OUTPUT_EXE) {
1926 char *ptr;
1927 /* allow override the dynamic loader */
1928 const char *elfint = getenv("LD_SO");
1929 if (elfint == NULL)
1930 elfint = DEFAULT_ELFINTERP(s1);
1931 /* add interpreter section only if executable */
1932 interp = new_section(s1, ".interp", SHT_PROGBITS, SHF_ALLOC);
1933 interp->sh_addralign = 1;
1934 ptr = section_ptr_add(interp, 1 + strlen(elfint));
1935 strcpy(ptr, elfint);
1938 /* add dynamic symbol table */
1939 s1->dynsym = new_symtab(s1, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
1940 ".dynstr",
1941 ".hash", SHF_ALLOC);
1942 dynstr = s1->dynsym->link;
1944 /* add dynamic section */
1945 dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC,
1946 SHF_ALLOC | SHF_WRITE);
1947 dynamic->link = dynstr;
1948 dynamic->sh_entsize = sizeof(ElfW(Dyn));
1950 build_got(s1);
1952 if (file_type == TCC_OUTPUT_EXE) {
1953 bind_exe_dynsyms(s1);
1955 if (s1->nb_errors) {
1956 ret = -1;
1957 goto the_end;
1960 bind_libs_dynsyms(s1);
1961 } else /* shared library case: simply export all global symbols */
1962 export_global_syms(s1);
1964 build_got_entries(s1);
1966 /* add a list of needed dlls */
1967 for(i = 0; i < s1->nb_loaded_dlls; i++) {
1968 DLLReference *dllref = s1->loaded_dlls[i];
1969 if (dllref->level == 0)
1970 put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name));
1973 if (s1->rpath)
1974 put_dt(dynamic, s1->enable_new_dtags ? DT_RUNPATH : DT_RPATH,
1975 put_elf_str(dynstr, s1->rpath));
1977 /* XXX: currently, since we do not handle PIC code, we
1978 must relocate the readonly segments */
1979 if (file_type == TCC_OUTPUT_DLL) {
1980 if (s1->soname)
1981 put_dt(dynamic, DT_SONAME, put_elf_str(dynstr, s1->soname));
1982 put_dt(dynamic, DT_TEXTREL, 0);
1985 if (s1->symbolic)
1986 put_dt(dynamic, DT_SYMBOLIC, 0);
1988 /* add necessary space for other entries */
1989 dyninf.dyn_rel_off = dynamic->data_offset;
1990 dynamic->data_offset += sizeof(ElfW(Dyn)) * EXTRA_RELITEMS;
1991 } else {
1992 /* still need to build got entries in case of static link */
1993 build_got_entries(s1);
1997 /* we add a section for symbols */
1998 strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0);
1999 put_elf_str(strsec, "");
2001 /* compute number of sections */
2002 shnum = s1->nb_sections;
2004 /* this array is used to reorder sections in the output file */
2005 sec_order = tcc_malloc(sizeof(int) * shnum);
2006 sec_order[0] = 0;
2008 /* compute number of program headers */
2009 switch(file_type) {
2010 default:
2011 case TCC_OUTPUT_OBJ:
2012 phnum = 0;
2013 break;
2014 case TCC_OUTPUT_EXE:
2015 if (!s1->static_link)
2016 phnum = 4 + HAVE_PHDR;
2017 else
2018 phnum = 2;
2019 break;
2020 case TCC_OUTPUT_DLL:
2021 phnum = 3;
2022 break;
2025 /* Allocate strings for section names */
2026 alloc_sec_names(s1, file_type, strsec);
2028 /* allocate program segment headers */
2029 phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
2031 /* compute section to program header mapping */
2032 file_offset = layout_sections(s1, phdr, phnum, interp, strsec, &dyninf,
2033 sec_order);
2035 /* Fill remaining program header and finalize relocation related to dynamic
2036 linking. */
2037 if (phnum > 0) {
2038 fill_unloadable_phdr(phdr, phnum, interp, dynamic);
2039 if (dynamic) {
2040 dyninf.dynamic = dynamic;
2041 dyninf.dynstr = dynstr;
2043 fill_dynamic(s1, &dyninf);
2045 /* put in GOT the dynamic section address and relocate PLT */
2046 write32le(s1->got->data, dynamic->sh_addr);
2047 if (file_type == TCC_OUTPUT_EXE
2048 || (RELOCATE_DLLPLT && file_type == TCC_OUTPUT_DLL))
2049 relocate_plt(s1);
2051 /* relocate symbols in .dynsym now that final addresses are known */
2052 for_each_elem(s1->dynsym, 1, sym, ElfW(Sym)) {
2053 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE) {
2054 /* do symbol relocation */
2055 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
2061 /* if building executable or DLL, then relocate each section
2062 except the GOT which is already relocated */
2063 if (file_type != TCC_OUTPUT_OBJ) {
2064 ret = final_sections_reloc(s1);
2065 if (ret)
2066 goto the_end;
2069 /* Perform relocation to GOT or PLT entries */
2070 if (file_type == TCC_OUTPUT_EXE && s1->static_link)
2071 fill_got(s1);
2073 /* Create the ELF file with name 'filename' */
2074 ret = tcc_write_elf_file(s1, filename, phnum, phdr, file_offset, sec_order);
2075 the_end:
2076 tcc_free(sec_order);
2077 tcc_free(phdr);
2078 return ret;
2081 LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename)
2083 int ret;
2084 #ifdef TCC_TARGET_PE
2085 if (s->output_type != TCC_OUTPUT_OBJ) {
2086 ret = pe_output_file(s, filename);
2087 } else
2088 #endif
2089 ret = elf_output_file(s, filename);
2090 return ret;
2093 static void *load_data(int fd, unsigned long file_offset, unsigned long size)
2095 void *data;
2097 data = tcc_malloc(size);
2098 lseek(fd, file_offset, SEEK_SET);
2099 read(fd, data, size);
2100 return data;
2103 typedef struct SectionMergeInfo {
2104 Section *s; /* corresponding existing section */
2105 unsigned long offset; /* offset of the new section in the existing section */
2106 uint8_t new_section; /* true if section 's' was added */
2107 uint8_t link_once; /* true if link once section */
2108 } SectionMergeInfo;
2110 ST_FUNC int tcc_object_type(int fd, ElfW(Ehdr) *h)
2112 int size = read(fd, h, sizeof *h);
2113 if (size == sizeof *h && 0 == memcmp(h, ELFMAG, 4)) {
2114 if (h->e_type == ET_REL)
2115 return AFF_BINTYPE_REL;
2116 if (h->e_type == ET_DYN)
2117 return AFF_BINTYPE_DYN;
2118 } else if (size >= 8) {
2119 if (0 == memcmp(h, ARMAG, 8))
2120 return AFF_BINTYPE_AR;
2121 #ifdef TCC_TARGET_COFF
2122 if (((struct filehdr*)h)->f_magic == COFF_C67_MAGIC)
2123 return AFF_BINTYPE_C67;
2124 #endif
2126 return 0;
2129 /* load an object file and merge it with current files */
2130 /* XXX: handle correctly stab (debug) info */
2131 ST_FUNC int tcc_load_object_file(TCCState *s1,
2132 int fd, unsigned long file_offset)
2134 ElfW(Ehdr) ehdr;
2135 ElfW(Shdr) *shdr, *sh;
2136 int size, i, j, offset, offseti, nb_syms, sym_index, ret;
2137 unsigned char *strsec, *strtab;
2138 int *old_to_new_syms;
2139 char *sh_name, *name;
2140 SectionMergeInfo *sm_table, *sm;
2141 ElfW(Sym) *sym, *symtab;
2142 ElfW_Rel *rel;
2143 Section *s;
2145 int stab_index;
2146 int stabstr_index;
2148 stab_index = stabstr_index = 0;
2150 lseek(fd, file_offset, SEEK_SET);
2151 if (tcc_object_type(fd, &ehdr) != AFF_BINTYPE_REL)
2152 goto fail1;
2153 /* test CPU specific stuff */
2154 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2155 ehdr.e_machine != EM_TCC_TARGET) {
2156 fail1:
2157 tcc_error_noabort("invalid object file");
2158 return -1;
2160 /* read sections */
2161 shdr = load_data(fd, file_offset + ehdr.e_shoff,
2162 sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2163 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
2165 /* load section names */
2166 sh = &shdr[ehdr.e_shstrndx];
2167 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2169 /* load symtab and strtab */
2170 old_to_new_syms = NULL;
2171 symtab = NULL;
2172 strtab = NULL;
2173 nb_syms = 0;
2174 for(i = 1; i < ehdr.e_shnum; i++) {
2175 sh = &shdr[i];
2176 if (sh->sh_type == SHT_SYMTAB) {
2177 if (symtab) {
2178 tcc_error_noabort("object must contain only one symtab");
2179 fail:
2180 ret = -1;
2181 goto the_end;
2183 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2184 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2185 sm_table[i].s = symtab_section;
2187 /* now load strtab */
2188 sh = &shdr[sh->sh_link];
2189 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2193 /* now examine each section and try to merge its content with the
2194 ones in memory */
2195 for(i = 1; i < ehdr.e_shnum; i++) {
2196 /* no need to examine section name strtab */
2197 if (i == ehdr.e_shstrndx)
2198 continue;
2199 sh = &shdr[i];
2200 sh_name = (char *) strsec + sh->sh_name;
2201 /* ignore sections types we do not handle */
2202 if (sh->sh_type != SHT_PROGBITS &&
2203 sh->sh_type != SHT_RELX &&
2204 #ifdef TCC_ARM_EABI
2205 sh->sh_type != SHT_ARM_EXIDX &&
2206 #endif
2207 sh->sh_type != SHT_NOBITS &&
2208 sh->sh_type != SHT_PREINIT_ARRAY &&
2209 sh->sh_type != SHT_INIT_ARRAY &&
2210 sh->sh_type != SHT_FINI_ARRAY &&
2211 strcmp(sh_name, ".stabstr")
2213 continue;
2214 if (sh->sh_addralign < 1)
2215 sh->sh_addralign = 1;
2216 /* find corresponding section, if any */
2217 for(j = 1; j < s1->nb_sections;j++) {
2218 s = s1->sections[j];
2219 if (!strcmp(s->name, sh_name)) {
2220 if (!strncmp(sh_name, ".gnu.linkonce",
2221 sizeof(".gnu.linkonce") - 1)) {
2222 /* if a 'linkonce' section is already present, we
2223 do not add it again. It is a little tricky as
2224 symbols can still be defined in
2225 it. */
2226 sm_table[i].link_once = 1;
2227 goto next;
2228 } else {
2229 goto found;
2233 /* not found: create new section */
2234 s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags & ~SHF_GROUP);
2235 /* take as much info as possible from the section. sh_link and
2236 sh_info will be updated later */
2237 s->sh_addralign = sh->sh_addralign;
2238 s->sh_entsize = sh->sh_entsize;
2239 sm_table[i].new_section = 1;
2240 found:
2241 if (sh->sh_type != s->sh_type) {
2242 tcc_error_noabort("invalid section type");
2243 goto fail;
2246 /* align start of section */
2247 offset = s->data_offset;
2249 if (0 == strcmp(sh_name, ".stab")) {
2250 stab_index = i;
2251 goto no_align;
2253 if (0 == strcmp(sh_name, ".stabstr")) {
2254 stabstr_index = i;
2255 goto no_align;
2258 size = sh->sh_addralign - 1;
2259 offset = (offset + size) & ~size;
2260 if (sh->sh_addralign > s->sh_addralign)
2261 s->sh_addralign = sh->sh_addralign;
2262 s->data_offset = offset;
2263 no_align:
2264 sm_table[i].offset = offset;
2265 sm_table[i].s = s;
2266 /* concatenate sections */
2267 size = sh->sh_size;
2268 if (sh->sh_type != SHT_NOBITS) {
2269 unsigned char *ptr;
2270 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
2271 ptr = section_ptr_add(s, size);
2272 read(fd, ptr, size);
2273 } else {
2274 s->data_offset += size;
2276 next: ;
2279 /* gr relocate stab strings */
2280 if (stab_index && stabstr_index) {
2281 Stab_Sym *a, *b;
2282 unsigned o;
2283 s = sm_table[stab_index].s;
2284 a = (Stab_Sym *)(s->data + sm_table[stab_index].offset);
2285 b = (Stab_Sym *)(s->data + s->data_offset);
2286 o = sm_table[stabstr_index].offset;
2287 while (a < b)
2288 a->n_strx += o, a++;
2291 /* second short pass to update sh_link and sh_info fields of new
2292 sections */
2293 for(i = 1; i < ehdr.e_shnum; i++) {
2294 s = sm_table[i].s;
2295 if (!s || !sm_table[i].new_section)
2296 continue;
2297 sh = &shdr[i];
2298 if (sh->sh_link > 0)
2299 s->link = sm_table[sh->sh_link].s;
2300 if (sh->sh_type == SHT_RELX) {
2301 s->sh_info = sm_table[sh->sh_info].s->sh_num;
2302 /* update backward link */
2303 s1->sections[s->sh_info]->reloc = s;
2306 sm = sm_table;
2308 /* resolve symbols */
2309 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
2311 sym = symtab + 1;
2312 for(i = 1; i < nb_syms; i++, sym++) {
2313 if (sym->st_shndx != SHN_UNDEF &&
2314 sym->st_shndx < SHN_LORESERVE) {
2315 sm = &sm_table[sym->st_shndx];
2316 if (sm->link_once) {
2317 /* if a symbol is in a link once section, we use the
2318 already defined symbol. It is very important to get
2319 correct relocations */
2320 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
2321 name = (char *) strtab + sym->st_name;
2322 sym_index = find_elf_sym(symtab_section, name);
2323 if (sym_index)
2324 old_to_new_syms[i] = sym_index;
2326 continue;
2328 /* if no corresponding section added, no need to add symbol */
2329 if (!sm->s)
2330 continue;
2331 /* convert section number */
2332 sym->st_shndx = sm->s->sh_num;
2333 /* offset value */
2334 sym->st_value += sm->offset;
2336 /* add symbol */
2337 name = (char *) strtab + sym->st_name;
2338 sym_index = set_elf_sym(symtab_section, sym->st_value, sym->st_size,
2339 sym->st_info, sym->st_other,
2340 sym->st_shndx, name);
2341 old_to_new_syms[i] = sym_index;
2344 /* third pass to patch relocation entries */
2345 for(i = 1; i < ehdr.e_shnum; i++) {
2346 s = sm_table[i].s;
2347 if (!s)
2348 continue;
2349 sh = &shdr[i];
2350 offset = sm_table[i].offset;
2351 switch(s->sh_type) {
2352 case SHT_RELX:
2353 /* take relocation offset information */
2354 offseti = sm_table[sh->sh_info].offset;
2355 for_each_elem(s, (offset / sizeof(*rel)), rel, ElfW_Rel) {
2356 int type;
2357 unsigned sym_index;
2358 /* convert symbol index */
2359 type = ELFW(R_TYPE)(rel->r_info);
2360 sym_index = ELFW(R_SYM)(rel->r_info);
2361 /* NOTE: only one symtab assumed */
2362 if (sym_index >= nb_syms)
2363 goto invalid_reloc;
2364 sym_index = old_to_new_syms[sym_index];
2365 /* ignore link_once in rel section. */
2366 if (!sym_index && !sm->link_once
2367 #ifdef TCC_TARGET_ARM
2368 && type != R_ARM_V4BX
2369 #endif
2371 invalid_reloc:
2372 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2373 i, strsec + sh->sh_name, rel->r_offset);
2374 goto fail;
2376 rel->r_info = ELFW(R_INFO)(sym_index, type);
2377 /* offset the relocation offset */
2378 rel->r_offset += offseti;
2379 #ifdef TCC_TARGET_ARM
2380 /* Jumps and branches from a Thumb code to a PLT entry need
2381 special handling since PLT entries are ARM code.
2382 Unconditional bl instructions referencing PLT entries are
2383 handled by converting these instructions into blx
2384 instructions. Other case of instructions referencing a PLT
2385 entry require to add a Thumb stub before the PLT entry to
2386 switch to ARM mode. We set bit plt_thumb_stub of the
2387 attribute of a symbol to indicate such a case. */
2388 if (type == R_ARM_THM_JUMP24)
2389 get_sym_attr(s1, sym_index, 1)->plt_thumb_stub = 1;
2390 #endif
2392 break;
2393 default:
2394 break;
2398 ret = 0;
2399 the_end:
2400 tcc_free(symtab);
2401 tcc_free(strtab);
2402 tcc_free(old_to_new_syms);
2403 tcc_free(sm_table);
2404 tcc_free(strsec);
2405 tcc_free(shdr);
2406 return ret;
2409 typedef struct ArchiveHeader {
2410 char ar_name[16]; /* name of this member */
2411 char ar_date[12]; /* file mtime */
2412 char ar_uid[6]; /* owner uid; printed as decimal */
2413 char ar_gid[6]; /* owner gid; printed as decimal */
2414 char ar_mode[8]; /* file mode, printed as octal */
2415 char ar_size[10]; /* file size, printed as decimal */
2416 char ar_fmag[2]; /* should contain ARFMAG */
2417 } ArchiveHeader;
2419 static int get_be32(const uint8_t *b)
2421 return b[3] | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
2424 static long get_be64(const uint8_t *b)
2426 long long ret = get_be32(b);
2427 ret = (ret << 32) | (unsigned)get_be32(b+4);
2428 return (long)ret;
2431 /* load only the objects which resolve undefined symbols */
2432 static int tcc_load_alacarte(TCCState *s1, int fd, int size, int entrysize)
2434 long i, bound, nsyms, sym_index, off, ret;
2435 uint8_t *data;
2436 const char *ar_names, *p;
2437 const uint8_t *ar_index;
2438 ElfW(Sym) *sym;
2440 data = tcc_malloc(size);
2441 if (read(fd, data, size) != size)
2442 goto fail;
2443 nsyms = entrysize == 4 ? get_be32(data) : get_be64(data);
2444 ar_index = data + entrysize;
2445 ar_names = (char *) ar_index + nsyms * entrysize;
2447 do {
2448 bound = 0;
2449 for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2450 sym_index = find_elf_sym(symtab_section, p);
2451 if(sym_index) {
2452 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
2453 if(sym->st_shndx == SHN_UNDEF) {
2454 off = (entrysize == 4
2455 ? get_be32(ar_index + i * 4)
2456 : get_be64(ar_index + i * 8))
2457 + sizeof(ArchiveHeader);
2458 ++bound;
2459 if(tcc_load_object_file(s1, fd, off) < 0) {
2460 fail:
2461 ret = -1;
2462 goto the_end;
2467 } while(bound);
2468 ret = 0;
2469 the_end:
2470 tcc_free(data);
2471 return ret;
2474 /* load a '.a' file */
2475 ST_FUNC int tcc_load_archive(TCCState *s1, int fd)
2477 ArchiveHeader hdr;
2478 char ar_size[11];
2479 char ar_name[17];
2480 char magic[8];
2481 int size, len, i;
2482 unsigned long file_offset;
2484 /* skip magic which was already checked */
2485 read(fd, magic, sizeof(magic));
2487 for(;;) {
2488 len = read(fd, &hdr, sizeof(hdr));
2489 if (len == 0)
2490 break;
2491 if (len != sizeof(hdr)) {
2492 tcc_error_noabort("invalid archive");
2493 return -1;
2495 memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
2496 ar_size[sizeof(hdr.ar_size)] = '\0';
2497 size = strtol(ar_size, NULL, 0);
2498 memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
2499 for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
2500 if (ar_name[i] != ' ')
2501 break;
2503 ar_name[i + 1] = '\0';
2504 file_offset = lseek(fd, 0, SEEK_CUR);
2505 /* align to even */
2506 size = (size + 1) & ~1;
2507 if (!strcmp(ar_name, "/")) {
2508 /* coff symbol table : we handle it */
2509 if(s1->alacarte_link)
2510 return tcc_load_alacarte(s1, fd, size, 4);
2511 } else if (!strcmp(ar_name, "/SYM64/")) {
2512 if(s1->alacarte_link)
2513 return tcc_load_alacarte(s1, fd, size, 8);
2514 } else {
2515 ElfW(Ehdr) ehdr;
2516 if (tcc_object_type(fd, &ehdr) == AFF_BINTYPE_REL) {
2517 if (tcc_load_object_file(s1, fd, file_offset) < 0)
2518 return -1;
2521 lseek(fd, file_offset + size, SEEK_SET);
2523 return 0;
2526 #ifndef TCC_TARGET_PE
2527 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2528 is referenced by the user (so it should be added as DT_NEEDED in
2529 the generated ELF file) */
2530 ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
2532 ElfW(Ehdr) ehdr;
2533 ElfW(Shdr) *shdr, *sh, *sh1;
2534 int i, j, nb_syms, nb_dts, sym_bind, ret;
2535 ElfW(Sym) *sym, *dynsym;
2536 ElfW(Dyn) *dt, *dynamic;
2537 unsigned char *dynstr;
2538 const char *name, *soname;
2539 DLLReference *dllref;
2541 read(fd, &ehdr, sizeof(ehdr));
2543 /* test CPU specific stuff */
2544 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2545 ehdr.e_machine != EM_TCC_TARGET) {
2546 tcc_error_noabort("bad architecture");
2547 return -1;
2550 /* read sections */
2551 shdr = load_data(fd, ehdr.e_shoff, sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2553 /* load dynamic section and dynamic symbols */
2554 nb_syms = 0;
2555 nb_dts = 0;
2556 dynamic = NULL;
2557 dynsym = NULL; /* avoid warning */
2558 dynstr = NULL; /* avoid warning */
2559 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
2560 switch(sh->sh_type) {
2561 case SHT_DYNAMIC:
2562 nb_dts = sh->sh_size / sizeof(ElfW(Dyn));
2563 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
2564 break;
2565 case SHT_DYNSYM:
2566 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2567 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
2568 sh1 = &shdr[sh->sh_link];
2569 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
2570 break;
2571 default:
2572 break;
2576 /* compute the real library name */
2577 soname = tcc_basename(filename);
2579 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2580 if (dt->d_tag == DT_SONAME) {
2581 soname = (char *) dynstr + dt->d_un.d_val;
2585 /* if the dll is already loaded, do not load it */
2586 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2587 dllref = s1->loaded_dlls[i];
2588 if (!strcmp(soname, dllref->name)) {
2589 /* but update level if needed */
2590 if (level < dllref->level)
2591 dllref->level = level;
2592 ret = 0;
2593 goto the_end;
2597 /* add the dll and its level */
2598 dllref = tcc_mallocz(sizeof(DLLReference) + strlen(soname));
2599 dllref->level = level;
2600 strcpy(dllref->name, soname);
2601 dynarray_add(&s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
2603 /* add dynamic symbols in dynsym_section */
2604 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
2605 sym_bind = ELFW(ST_BIND)(sym->st_info);
2606 if (sym_bind == STB_LOCAL)
2607 continue;
2608 name = (char *) dynstr + sym->st_name;
2609 set_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
2610 sym->st_info, sym->st_other, sym->st_shndx, name);
2613 /* load all referenced DLLs */
2614 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2615 switch(dt->d_tag) {
2616 case DT_NEEDED:
2617 name = (char *) dynstr + dt->d_un.d_val;
2618 for(j = 0; j < s1->nb_loaded_dlls; j++) {
2619 dllref = s1->loaded_dlls[j];
2620 if (!strcmp(name, dllref->name))
2621 goto already_loaded;
2623 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
2624 tcc_error_noabort("referenced dll '%s' not found", name);
2625 ret = -1;
2626 goto the_end;
2628 already_loaded:
2629 break;
2632 ret = 0;
2633 the_end:
2634 tcc_free(dynstr);
2635 tcc_free(dynsym);
2636 tcc_free(dynamic);
2637 tcc_free(shdr);
2638 return ret;
2641 #define LD_TOK_NAME 256
2642 #define LD_TOK_EOF (-1)
2644 /* return next ld script token */
2645 static int ld_next(TCCState *s1, char *name, int name_size)
2647 int c;
2648 char *q;
2650 redo:
2651 switch(ch) {
2652 case ' ':
2653 case '\t':
2654 case '\f':
2655 case '\v':
2656 case '\r':
2657 case '\n':
2658 inp();
2659 goto redo;
2660 case '/':
2661 minp();
2662 if (ch == '*') {
2663 file->buf_ptr = parse_comment(file->buf_ptr);
2664 ch = file->buf_ptr[0];
2665 goto redo;
2666 } else {
2667 q = name;
2668 *q++ = '/';
2669 goto parse_name;
2671 break;
2672 case '\\':
2673 ch = handle_eob();
2674 if (ch != '\\')
2675 goto redo;
2676 /* fall through */
2677 /* case 'a' ... 'z': */
2678 case 'a':
2679 case 'b':
2680 case 'c':
2681 case 'd':
2682 case 'e':
2683 case 'f':
2684 case 'g':
2685 case 'h':
2686 case 'i':
2687 case 'j':
2688 case 'k':
2689 case 'l':
2690 case 'm':
2691 case 'n':
2692 case 'o':
2693 case 'p':
2694 case 'q':
2695 case 'r':
2696 case 's':
2697 case 't':
2698 case 'u':
2699 case 'v':
2700 case 'w':
2701 case 'x':
2702 case 'y':
2703 case 'z':
2704 /* case 'A' ... 'z': */
2705 case 'A':
2706 case 'B':
2707 case 'C':
2708 case 'D':
2709 case 'E':
2710 case 'F':
2711 case 'G':
2712 case 'H':
2713 case 'I':
2714 case 'J':
2715 case 'K':
2716 case 'L':
2717 case 'M':
2718 case 'N':
2719 case 'O':
2720 case 'P':
2721 case 'Q':
2722 case 'R':
2723 case 'S':
2724 case 'T':
2725 case 'U':
2726 case 'V':
2727 case 'W':
2728 case 'X':
2729 case 'Y':
2730 case 'Z':
2731 case '_':
2732 case '.':
2733 case '$':
2734 case '~':
2735 q = name;
2736 parse_name:
2737 for(;;) {
2738 if (!((ch >= 'a' && ch <= 'z') ||
2739 (ch >= 'A' && ch <= 'Z') ||
2740 (ch >= '0' && ch <= '9') ||
2741 strchr("/.-_+=$:\\,~", ch)))
2742 break;
2743 if ((q - name) < name_size - 1) {
2744 *q++ = ch;
2746 minp();
2748 *q = '\0';
2749 c = LD_TOK_NAME;
2750 break;
2751 case CH_EOF:
2752 c = LD_TOK_EOF;
2753 break;
2754 default:
2755 c = ch;
2756 inp();
2757 break;
2759 return c;
2762 static int ld_add_file(TCCState *s1, const char filename[])
2764 if (filename[0] == '/') {
2765 if (CONFIG_SYSROOT[0] == '\0'
2766 && tcc_add_file_internal(s1, filename, AFF_TYPE_BIN) == 0)
2767 return 0;
2768 filename = tcc_basename(filename);
2770 return tcc_add_dll(s1, filename, 0);
2773 static inline int new_undef_syms(void)
2775 int ret = 0;
2776 ret = new_undef_sym;
2777 new_undef_sym = 0;
2778 return ret;
2781 static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
2783 char filename[1024], libname[1024];
2784 int t, group, nblibs = 0, ret = 0;
2785 char **libs = NULL;
2787 group = !strcmp(cmd, "GROUP");
2788 if (!as_needed)
2789 new_undef_syms();
2790 t = ld_next(s1, filename, sizeof(filename));
2791 if (t != '(')
2792 expect("(");
2793 t = ld_next(s1, filename, sizeof(filename));
2794 for(;;) {
2795 libname[0] = '\0';
2796 if (t == LD_TOK_EOF) {
2797 tcc_error_noabort("unexpected end of file");
2798 ret = -1;
2799 goto lib_parse_error;
2800 } else if (t == ')') {
2801 break;
2802 } else if (t == '-') {
2803 t = ld_next(s1, filename, sizeof(filename));
2804 if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
2805 tcc_error_noabort("library name expected");
2806 ret = -1;
2807 goto lib_parse_error;
2809 pstrcpy(libname, sizeof libname, &filename[1]);
2810 if (s1->static_link) {
2811 snprintf(filename, sizeof filename, "lib%s.a", libname);
2812 } else {
2813 snprintf(filename, sizeof filename, "lib%s.so", libname);
2815 } else if (t != LD_TOK_NAME) {
2816 tcc_error_noabort("filename expected");
2817 ret = -1;
2818 goto lib_parse_error;
2820 if (!strcmp(filename, "AS_NEEDED")) {
2821 ret = ld_add_file_list(s1, cmd, 1);
2822 if (ret)
2823 goto lib_parse_error;
2824 } else {
2825 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2826 if (!as_needed) {
2827 ret = ld_add_file(s1, filename);
2828 if (ret)
2829 goto lib_parse_error;
2830 if (group) {
2831 /* Add the filename *and* the libname to avoid future conversions */
2832 dynarray_add(&libs, &nblibs, tcc_strdup(filename));
2833 if (libname[0] != '\0')
2834 dynarray_add(&libs, &nblibs, tcc_strdup(libname));
2838 t = ld_next(s1, filename, sizeof(filename));
2839 if (t == ',') {
2840 t = ld_next(s1, filename, sizeof(filename));
2843 if (group && !as_needed) {
2844 while (new_undef_syms()) {
2845 int i;
2847 for (i = 0; i < nblibs; i ++)
2848 ld_add_file(s1, libs[i]);
2851 lib_parse_error:
2852 dynarray_reset(&libs, &nblibs);
2853 return ret;
2856 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
2857 files */
2858 ST_FUNC int tcc_load_ldscript(TCCState *s1)
2860 char cmd[64];
2861 char filename[1024];
2862 int t, ret;
2864 ch = handle_eob();
2865 for(;;) {
2866 t = ld_next(s1, cmd, sizeof(cmd));
2867 if (t == LD_TOK_EOF)
2868 return 0;
2869 else if (t != LD_TOK_NAME)
2870 return -1;
2871 if (!strcmp(cmd, "INPUT") ||
2872 !strcmp(cmd, "GROUP")) {
2873 ret = ld_add_file_list(s1, cmd, 0);
2874 if (ret)
2875 return ret;
2876 } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
2877 !strcmp(cmd, "TARGET")) {
2878 /* ignore some commands */
2879 t = ld_next(s1, cmd, sizeof(cmd));
2880 if (t != '(')
2881 expect("(");
2882 for(;;) {
2883 t = ld_next(s1, filename, sizeof(filename));
2884 if (t == LD_TOK_EOF) {
2885 tcc_error_noabort("unexpected end of file");
2886 return -1;
2887 } else if (t == ')') {
2888 break;
2891 } else {
2892 return -1;
2895 return 0;
2897 #endif /* !TCC_TARGET_PE */