SECTION_ALIGNMENT -> RUN_SECTION_ALIGNMENT, and tweaks
[tinycc.git] / tccelf.c
blobe2ba5a4224dbd8489d22d94a33c240b93487de76
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((void ***)&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((void ***)&s1->priv_sections, &s1->nb_priv_sections, sec);
157 } else {
158 sec->sh_num = s1->nb_sections;
159 dynarray_add((void ***)&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/"TCC_ARCH_DIR"%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 CONFIG_USE_LIBGCC
1110 if (!s1->static_link) {
1111 tcc_add_file(s1, TCC_LIBGCC);
1113 #endif
1114 tcc_add_support(s1, "libtcc1.a");
1115 /* add crt end if not memory output */
1116 if (s1->output_type != TCC_OUTPUT_MEMORY)
1117 tcc_add_crt(s1, "crtn.o");
1121 /* add various standard linker symbols (must be done after the
1122 sections are filled (for example after allocating common
1123 symbols)) */
1124 ST_FUNC void tcc_add_linker_symbols(TCCState *s1)
1126 char buf[1024];
1127 int i;
1128 Section *s;
1130 set_elf_sym(symtab_section,
1131 text_section->data_offset, 0,
1132 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1133 text_section->sh_num, "_etext");
1134 set_elf_sym(symtab_section,
1135 data_section->data_offset, 0,
1136 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1137 data_section->sh_num, "_edata");
1138 set_elf_sym(symtab_section,
1139 bss_section->data_offset, 0,
1140 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1141 bss_section->sh_num, "_end");
1142 #ifndef TCC_TARGET_PE
1143 /* horrible new standard ldscript defines */
1144 add_init_array_defines(s1, ".preinit_array");
1145 add_init_array_defines(s1, ".init_array");
1146 add_init_array_defines(s1, ".fini_array");
1147 #endif
1149 /* add start and stop symbols for sections whose name can be
1150 expressed in C */
1151 for(i = 1; i < s1->nb_sections; i++) {
1152 s = s1->sections[i];
1153 if (s->sh_type == SHT_PROGBITS &&
1154 (s->sh_flags & SHF_ALLOC)) {
1155 const char *p;
1156 int ch;
1158 /* check if section name can be expressed in C */
1159 p = s->name;
1160 for(;;) {
1161 ch = *p;
1162 if (!ch)
1163 break;
1164 if (!isid(ch) && !isnum(ch))
1165 goto next_sec;
1166 p++;
1168 snprintf(buf, sizeof(buf), "__start_%s", s->name);
1169 set_elf_sym(symtab_section,
1170 0, 0,
1171 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1172 s->sh_num, buf);
1173 snprintf(buf, sizeof(buf), "__stop_%s", s->name);
1174 set_elf_sym(symtab_section,
1175 s->data_offset, 0,
1176 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1177 s->sh_num, buf);
1179 next_sec: ;
1183 static void tcc_output_binary(TCCState *s1, FILE *f,
1184 const int *sec_order)
1186 Section *s;
1187 int i, offset, size;
1189 offset = 0;
1190 for(i=1;i<s1->nb_sections;i++) {
1191 s = s1->sections[sec_order[i]];
1192 if (s->sh_type != SHT_NOBITS &&
1193 (s->sh_flags & SHF_ALLOC)) {
1194 while (offset < s->sh_offset) {
1195 fputc(0, f);
1196 offset++;
1198 size = s->sh_size;
1199 fwrite(s->data, 1, size, f);
1200 offset += size;
1205 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1206 #define HAVE_PHDR 1
1207 #define EXTRA_RELITEMS 14
1208 #else
1209 #define HAVE_PHDR 1
1210 #define EXTRA_RELITEMS 9
1211 #endif
1213 ST_FUNC void fill_got_entry(TCCState *s1, ElfW_Rel *rel)
1215 int sym_index = ELFW(R_SYM) (rel->r_info);
1216 ElfW(Sym) *sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
1217 struct sym_attr *attr = get_sym_attr(s1, sym_index, 0);
1218 unsigned offset = attr->got_offset;
1220 if (0 == offset)
1221 return;
1222 section_reserve(s1->got, offset + PTR_SIZE);
1223 #ifdef TCC_TARGET_X86_64
1224 write64le(s1->got->data + offset, sym->st_value);
1225 #else
1226 write32le(s1->got->data + offset, sym->st_value);
1227 #endif
1230 /* Perform relocation to GOT or PLT entries */
1231 ST_FUNC void fill_got(TCCState *s1)
1233 Section *s;
1234 ElfW_Rel *rel;
1235 int i;
1237 for(i = 1; i < s1->nb_sections; i++) {
1238 s = s1->sections[i];
1239 if (s->sh_type != SHT_RELX)
1240 continue;
1241 /* no need to handle got relocations */
1242 if (s->link != symtab_section)
1243 continue;
1244 for_each_elem(s, 0, rel, ElfW_Rel) {
1245 switch (ELFW(R_TYPE) (rel->r_info)) {
1246 case R_X86_64_GOT32:
1247 case R_X86_64_GOTPCREL:
1248 case R_X86_64_GOTPCRELX:
1249 case R_X86_64_REX_GOTPCRELX:
1250 case R_X86_64_PLT32:
1251 fill_got_entry(s1, rel);
1252 break;
1258 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1259 in shared libraries and export non local defined symbols to shared libraries
1260 if -rdynamic switch was given on command line */
1261 static void bind_exe_dynsyms(TCCState *s1)
1263 const char *name;
1264 int sym_index, index;
1265 ElfW(Sym) *sym, *esym;
1266 int type;
1268 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1269 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1270 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1271 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1272 if (sym->st_shndx == SHN_UNDEF) {
1273 name = (char *) symtab_section->link->data + sym->st_name;
1274 sym_index = find_elf_sym(s1->dynsymtab_section, name);
1275 if (sym_index) {
1276 esym = &((ElfW(Sym) *)s1->dynsymtab_section->data)[sym_index];
1277 type = ELFW(ST_TYPE)(esym->st_info);
1278 if ((type == STT_FUNC) || (type == STT_GNU_IFUNC)) {
1279 /* Indirect functions shall have STT_FUNC type in executable
1280 * dynsym section. Indeed, a dlsym call following a lazy
1281 * resolution would pick the symbol value from the
1282 * executable dynsym entry which would contain the address
1283 * of the function wanted by the caller of dlsym instead of
1284 * the address of the function that would return that
1285 * address */
1286 int dynindex
1287 = put_elf_sym(s1->dynsym, 0, esym->st_size,
1288 ELFW(ST_INFO)(STB_GLOBAL,STT_FUNC), 0, 0,
1289 name);
1290 int index = sym - (ElfW(Sym) *) symtab_section->data;
1291 get_sym_attr(s1, index, 1)->dyn_index = dynindex;
1292 } else if (type == STT_OBJECT) {
1293 unsigned long offset;
1294 ElfW(Sym) *dynsym;
1295 offset = bss_section->data_offset;
1296 /* XXX: which alignment ? */
1297 offset = (offset + 16 - 1) & -16;
1298 set_elf_sym (s1->symtab, offset, esym->st_size,
1299 esym->st_info, 0, bss_section->sh_num, name);
1300 index = put_elf_sym(s1->dynsym, offset, esym->st_size,
1301 esym->st_info, 0, bss_section->sh_num,
1302 name);
1304 /* Ensure R_COPY works for weak symbol aliases */
1305 if (ELFW(ST_BIND)(esym->st_info) == STB_WEAK) {
1306 for_each_elem(s1->dynsymtab_section, 1, dynsym, ElfW(Sym)) {
1307 if ((dynsym->st_value == esym->st_value)
1308 && (ELFW(ST_BIND)(dynsym->st_info) == STB_GLOBAL)) {
1309 char *dynname = (char *) s1->dynsymtab_section->link->data
1310 + dynsym->st_name;
1311 put_elf_sym(s1->dynsym, offset, dynsym->st_size,
1312 dynsym->st_info, 0,
1313 bss_section->sh_num, dynname);
1314 break;
1319 put_elf_reloc(s1->dynsym, bss_section,
1320 offset, R_COPY, index);
1321 offset += esym->st_size;
1322 bss_section->data_offset = offset;
1324 } else {
1325 /* STB_WEAK undefined symbols are accepted */
1326 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1327 if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK ||
1328 !strcmp(name, "_fp_hw")) {
1329 } else {
1330 tcc_error_noabort("undefined symbol '%s'", name);
1333 } else if (s1->rdynamic && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1334 /* if -rdynamic option, then export all non local symbols */
1335 name = (char *) symtab_section->link->data + sym->st_name;
1336 set_elf_sym(s1->dynsym, sym->st_value, sym->st_size, sym->st_info,
1337 0, sym->st_shndx, name);
1342 /* Bind symbols of libraries: export all non local symbols of executable that
1343 are referenced by shared libraries. The reason is that the dynamic loader
1344 search symbol first in executable and then in libraries. Therefore a
1345 reference to a symbol already defined by a library can still be resolved by
1346 a symbol in the executable. */
1347 static void bind_libs_dynsyms(TCCState *s1)
1349 const char *name;
1350 int sym_index;
1351 ElfW(Sym) *sym, *esym;
1353 for_each_elem(s1->dynsymtab_section, 1, esym, ElfW(Sym)) {
1354 name = (char *) s1->dynsymtab_section->link->data + esym->st_name;
1355 sym_index = find_elf_sym(symtab_section, name);
1356 /* XXX: avoid adding a symbol if already present because of
1357 -rdynamic ? */
1358 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1359 if (sym_index && sym->st_shndx != SHN_UNDEF)
1360 set_elf_sym(s1->dynsym, sym->st_value, sym->st_size, sym->st_info,
1361 0, sym->st_shndx, name);
1362 else if (esym->st_shndx == SHN_UNDEF) {
1363 /* weak symbols can stay undefined */
1364 if (ELFW(ST_BIND)(esym->st_info) != STB_WEAK)
1365 tcc_warning("undefined dynamic symbol '%s'", name);
1370 /* Export all non local symbols. This is used by shared libraries so that the
1371 non local symbols they define can resolve a reference in another shared
1372 library or in the executable. Correspondingly, it allows undefined local
1373 symbols to be resolved by other shared libraries or by the executable. */
1374 static void export_global_syms(TCCState *s1)
1376 int dynindex, index;
1377 const char *name;
1378 ElfW(Sym) *sym;
1380 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1381 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1382 name = (char *) symtab_section->link->data + sym->st_name;
1383 dynindex = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1384 sym->st_info, 0, sym->st_shndx, name);
1385 index = sym - (ElfW(Sym) *) symtab_section->data;
1386 get_sym_attr(s1, index, 1)->dyn_index = dynindex;
1391 /* Allocate strings for section names and decide if an unallocated section
1392 should be output.
1393 NOTE: the strsec section comes last, so its size is also correct ! */
1394 static void alloc_sec_names(TCCState *s1, int file_type, Section *strsec)
1396 int i;
1397 Section *s;
1399 /* Allocate strings for section names */
1400 for(i = 1; i < s1->nb_sections; i++) {
1401 s = s1->sections[i];
1402 s->sh_name = put_elf_str(strsec, s->name);
1403 /* when generating a DLL, we include relocations but we may
1404 patch them */
1405 if (file_type == TCC_OUTPUT_DLL &&
1406 s->sh_type == SHT_RELX &&
1407 !(s->sh_flags & SHF_ALLOC)) {
1408 /* gr: avoid bogus relocs for empty (debug) sections */
1409 if (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC)
1410 prepare_dynamic_rel(s1, s);
1411 else if (s1->do_debug)
1412 s->sh_size = s->data_offset;
1413 } else if (s1->do_debug ||
1414 file_type == TCC_OUTPUT_OBJ ||
1415 (s->sh_flags & SHF_ALLOC) ||
1416 i == (s1->nb_sections - 1)) {
1417 /* we output all sections if debug or object file */
1418 s->sh_size = s->data_offset;
1423 /* Info to be copied in dynamic section */
1424 struct dyn_inf {
1425 Section *dynamic;
1426 Section *dynstr;
1427 unsigned long dyn_rel_off;
1428 addr_t rel_addr;
1429 addr_t rel_size;
1430 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1431 addr_t bss_addr;
1432 addr_t bss_size;
1433 #endif
1436 /* Assign sections to segments and decide how are sections laid out when loaded
1437 in memory. This function also fills corresponding program headers. */
1438 static int layout_sections(TCCState *s1, ElfW(Phdr) *phdr, int phnum,
1439 Section *interp, Section* strsec,
1440 struct dyn_inf *dyninf, int *sec_order)
1442 int i, j, k, file_type, sh_order_index, file_offset;
1443 unsigned long s_align;
1444 long long tmp;
1445 addr_t addr;
1446 ElfW(Phdr) *ph;
1447 Section *s;
1449 file_type = s1->output_type;
1450 sh_order_index = 1;
1451 file_offset = 0;
1452 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
1453 file_offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1454 s_align = ELF_PAGE_SIZE;
1455 if (s1->section_align)
1456 s_align = s1->section_align;
1458 if (phnum > 0) {
1459 if (s1->has_text_addr) {
1460 int a_offset, p_offset;
1461 addr = s1->text_addr;
1462 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1463 ELF_PAGE_SIZE */
1464 a_offset = (int) (addr & (s_align - 1));
1465 p_offset = file_offset & (s_align - 1);
1466 if (a_offset < p_offset)
1467 a_offset += s_align;
1468 file_offset += (a_offset - p_offset);
1469 } else {
1470 if (file_type == TCC_OUTPUT_DLL)
1471 addr = 0;
1472 else
1473 addr = ELF_START_ADDR;
1474 /* compute address after headers */
1475 addr += (file_offset & (s_align - 1));
1478 ph = &phdr[0];
1479 /* Leave one program headers for the program interpreter and one for
1480 the program header table itself if needed. These are done later as
1481 they require section layout to be done first. */
1482 if (interp)
1483 ph += 1 + HAVE_PHDR;
1485 /* dynamic relocation table information, for .dynamic section */
1486 dyninf->rel_addr = dyninf->rel_size = 0;
1487 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1488 dyninf->bss_addr = dyninf->bss_size = 0;
1489 #endif
1491 for(j = 0; j < 2; j++) {
1492 ph->p_type = PT_LOAD;
1493 if (j == 0)
1494 ph->p_flags = PF_R | PF_X;
1495 else
1496 ph->p_flags = PF_R | PF_W;
1497 ph->p_align = s_align;
1499 /* Decide the layout of sections loaded in memory. This must
1500 be done before program headers are filled since they contain
1501 info about the layout. We do the following ordering: interp,
1502 symbol tables, relocations, progbits, nobits */
1503 /* XXX: do faster and simpler sorting */
1504 for(k = 0; k < 5; k++) {
1505 for(i = 1; i < s1->nb_sections; i++) {
1506 s = s1->sections[i];
1507 /* compute if section should be included */
1508 if (j == 0) {
1509 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1510 SHF_ALLOC)
1511 continue;
1512 } else {
1513 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1514 (SHF_ALLOC | SHF_WRITE))
1515 continue;
1517 if (s == interp) {
1518 if (k != 0)
1519 continue;
1520 } else if (s->sh_type == SHT_DYNSYM ||
1521 s->sh_type == SHT_STRTAB ||
1522 s->sh_type == SHT_HASH) {
1523 if (k != 1)
1524 continue;
1525 } else if (s->sh_type == SHT_RELX) {
1526 if (k != 2)
1527 continue;
1528 } else if (s->sh_type == SHT_NOBITS) {
1529 if (k != 4)
1530 continue;
1531 } else {
1532 if (k != 3)
1533 continue;
1535 sec_order[sh_order_index++] = i;
1537 /* section matches: we align it and add its size */
1538 tmp = addr;
1539 addr = (addr + s->sh_addralign - 1) &
1540 ~(s->sh_addralign - 1);
1541 file_offset += (int) ( addr - tmp );
1542 s->sh_offset = file_offset;
1543 s->sh_addr = addr;
1545 /* update program header infos */
1546 if (ph->p_offset == 0) {
1547 ph->p_offset = file_offset;
1548 ph->p_vaddr = addr;
1549 ph->p_paddr = ph->p_vaddr;
1551 /* update dynamic relocation infos */
1552 if (s->sh_type == SHT_RELX) {
1553 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1554 if (!strcmp(strsec->data + s->sh_name, ".rel.got")) {
1555 dyninf->rel_addr = addr;
1556 dyninf->rel_size += s->sh_size; /* XXX only first rel. */
1558 if (!strcmp(strsec->data + s->sh_name, ".rel.bss")) {
1559 dyninf->bss_addr = addr;
1560 dyninf->bss_size = s->sh_size; /* XXX only first rel. */
1562 #else
1563 if (dyninf->rel_size == 0)
1564 dyninf->rel_addr = addr;
1565 dyninf->rel_size += s->sh_size;
1566 #endif
1568 addr += s->sh_size;
1569 if (s->sh_type != SHT_NOBITS)
1570 file_offset += s->sh_size;
1573 if (j == 0) {
1574 /* Make the first PT_LOAD segment include the program
1575 headers itself (and the ELF header as well), it'll
1576 come out with same memory use but will make various
1577 tools like binutils strip work better. */
1578 ph->p_offset &= ~(ph->p_align - 1);
1579 ph->p_vaddr &= ~(ph->p_align - 1);
1580 ph->p_paddr &= ~(ph->p_align - 1);
1582 ph->p_filesz = file_offset - ph->p_offset;
1583 ph->p_memsz = addr - ph->p_vaddr;
1584 ph++;
1585 if (j == 0) {
1586 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1587 /* if in the middle of a page, we duplicate the page in
1588 memory so that one copy is RX and the other is RW */
1589 if ((addr & (s_align - 1)) != 0)
1590 addr += s_align;
1591 } else {
1592 addr = (addr + s_align - 1) & ~(s_align - 1);
1593 file_offset = (file_offset + s_align - 1) & ~(s_align - 1);
1599 /* all other sections come after */
1600 for(i = 1; i < s1->nb_sections; i++) {
1601 s = s1->sections[i];
1602 if (phnum > 0 && (s->sh_flags & SHF_ALLOC))
1603 continue;
1604 sec_order[sh_order_index++] = i;
1606 file_offset = (file_offset + s->sh_addralign - 1) &
1607 ~(s->sh_addralign - 1);
1608 s->sh_offset = file_offset;
1609 if (s->sh_type != SHT_NOBITS)
1610 file_offset += s->sh_size;
1613 return file_offset;
1616 static void fill_unloadable_phdr(ElfW(Phdr) *phdr, int phnum, Section *interp,
1617 Section *dynamic)
1619 ElfW(Phdr) *ph;
1621 /* if interpreter, then add corresponding program header */
1622 if (interp) {
1623 ph = &phdr[0];
1625 if (HAVE_PHDR)
1627 int len = phnum * sizeof(ElfW(Phdr));
1629 ph->p_type = PT_PHDR;
1630 ph->p_offset = sizeof(ElfW(Ehdr));
1631 ph->p_vaddr = interp->sh_addr - len;
1632 ph->p_paddr = ph->p_vaddr;
1633 ph->p_filesz = ph->p_memsz = len;
1634 ph->p_flags = PF_R | PF_X;
1635 ph->p_align = 4; /* interp->sh_addralign; */
1636 ph++;
1639 ph->p_type = PT_INTERP;
1640 ph->p_offset = interp->sh_offset;
1641 ph->p_vaddr = interp->sh_addr;
1642 ph->p_paddr = ph->p_vaddr;
1643 ph->p_filesz = interp->sh_size;
1644 ph->p_memsz = interp->sh_size;
1645 ph->p_flags = PF_R;
1646 ph->p_align = interp->sh_addralign;
1649 /* if dynamic section, then add corresponding program header */
1650 if (dynamic) {
1651 ph = &phdr[phnum - 1];
1653 ph->p_type = PT_DYNAMIC;
1654 ph->p_offset = dynamic->sh_offset;
1655 ph->p_vaddr = dynamic->sh_addr;
1656 ph->p_paddr = ph->p_vaddr;
1657 ph->p_filesz = dynamic->sh_size;
1658 ph->p_memsz = dynamic->sh_size;
1659 ph->p_flags = PF_R | PF_W;
1660 ph->p_align = dynamic->sh_addralign;
1664 /* Fill the dynamic section with tags describing the address and size of
1665 sections */
1666 static void fill_dynamic(TCCState *s1, struct dyn_inf *dyninf)
1668 Section *dynamic;
1670 dynamic = dyninf->dynamic;
1672 /* put dynamic section entries */
1673 dynamic->data_offset = dyninf->dyn_rel_off;
1674 put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
1675 put_dt(dynamic, DT_STRTAB, dyninf->dynstr->sh_addr);
1676 put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
1677 put_dt(dynamic, DT_STRSZ, dyninf->dynstr->data_offset);
1678 put_dt(dynamic, DT_SYMENT, sizeof(ElfW(Sym)));
1679 #if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
1680 put_dt(dynamic, DT_RELA, dyninf->rel_addr);
1681 put_dt(dynamic, DT_RELASZ, dyninf->rel_size);
1682 put_dt(dynamic, DT_RELAENT, sizeof(ElfW_Rel));
1683 #else
1684 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1685 put_dt(dynamic, DT_PLTGOT, s1->got->sh_addr);
1686 put_dt(dynamic, DT_PLTRELSZ, dyninf->rel_size);
1687 put_dt(dynamic, DT_JMPREL, dyninf->rel_addr);
1688 put_dt(dynamic, DT_PLTREL, DT_REL);
1689 put_dt(dynamic, DT_REL, dyninf->bss_addr);
1690 put_dt(dynamic, DT_RELSZ, dyninf->bss_size);
1691 #else
1692 put_dt(dynamic, DT_REL, dyninf->rel_addr);
1693 put_dt(dynamic, DT_RELSZ, dyninf->rel_size);
1694 put_dt(dynamic, DT_RELENT, sizeof(ElfW_Rel));
1695 #endif
1696 #endif
1697 if (s1->do_debug)
1698 put_dt(dynamic, DT_DEBUG, 0);
1699 put_dt(dynamic, DT_NULL, 0);
1702 /* Relocate remaining sections and symbols (that is those not related to
1703 dynamic linking) */
1704 static int final_sections_reloc(TCCState *s1)
1706 int i;
1707 Section *s;
1709 relocate_syms(s1, s1->symtab, 0);
1711 if (s1->nb_errors != 0)
1712 return -1;
1714 /* relocate sections */
1715 /* XXX: ignore sections with allocated relocations ? */
1716 for(i = 1; i < s1->nb_sections; i++) {
1717 s = s1->sections[i];
1718 #ifdef TCC_TARGET_I386
1719 if (s->reloc && s != s1->got && (s->sh_flags & SHF_ALLOC)) //gr
1720 /* On X86 gdb 7.3 works in any case but gdb 6.6 will crash if SHF_ALLOC
1721 checking is removed */
1722 #else
1723 if (s->reloc && s != s1->got)
1724 /* On X86_64 gdb 7.3 will crash if SHF_ALLOC checking is present */
1725 #endif
1726 relocate_section(s1, s);
1729 /* relocate relocation entries if the relocation tables are
1730 allocated in the executable */
1731 for(i = 1; i < s1->nb_sections; i++) {
1732 s = s1->sections[i];
1733 if ((s->sh_flags & SHF_ALLOC) &&
1734 s->sh_type == SHT_RELX) {
1735 relocate_rel(s1, s);
1738 return 0;
1741 /* Create an ELF file on disk.
1742 This function handle ELF specific layout requirements */
1743 static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
1744 int file_offset, int *sec_order)
1746 int i, shnum, offset, size, file_type;
1747 Section *s;
1748 ElfW(Ehdr) ehdr;
1749 ElfW(Shdr) shdr, *sh;
1751 file_type = s1->output_type;
1752 shnum = s1->nb_sections;
1754 memset(&ehdr, 0, sizeof(ehdr));
1756 if (phnum > 0) {
1757 ehdr.e_phentsize = sizeof(ElfW(Phdr));
1758 ehdr.e_phnum = phnum;
1759 ehdr.e_phoff = sizeof(ElfW(Ehdr));
1762 /* align to 4 */
1763 file_offset = (file_offset + 3) & -4;
1765 /* fill header */
1766 ehdr.e_ident[0] = ELFMAG0;
1767 ehdr.e_ident[1] = ELFMAG1;
1768 ehdr.e_ident[2] = ELFMAG2;
1769 ehdr.e_ident[3] = ELFMAG3;
1770 ehdr.e_ident[4] = ELFCLASSW;
1771 ehdr.e_ident[5] = ELFDATA2LSB;
1772 ehdr.e_ident[6] = EV_CURRENT;
1773 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1774 ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
1775 #endif
1776 #ifdef TCC_TARGET_ARM
1777 #ifdef TCC_ARM_EABI
1778 ehdr.e_ident[EI_OSABI] = 0;
1779 ehdr.e_flags = EF_ARM_EABI_VER4;
1780 if (file_type == TCC_OUTPUT_EXE || file_type == TCC_OUTPUT_DLL)
1781 ehdr.e_flags |= EF_ARM_HASENTRY;
1782 if (s1->float_abi == ARM_HARD_FLOAT)
1783 ehdr.e_flags |= EF_ARM_VFP_FLOAT;
1784 else
1785 ehdr.e_flags |= EF_ARM_SOFT_FLOAT;
1786 #else
1787 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
1788 #endif
1789 #endif
1790 switch(file_type) {
1791 default:
1792 case TCC_OUTPUT_EXE:
1793 ehdr.e_type = ET_EXEC;
1794 ehdr.e_entry = get_elf_sym_addr(s1, "_start", 1);
1795 break;
1796 case TCC_OUTPUT_DLL:
1797 ehdr.e_type = ET_DYN;
1798 ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
1799 break;
1800 case TCC_OUTPUT_OBJ:
1801 ehdr.e_type = ET_REL;
1802 break;
1804 ehdr.e_machine = EM_TCC_TARGET;
1805 ehdr.e_version = EV_CURRENT;
1806 ehdr.e_shoff = file_offset;
1807 ehdr.e_ehsize = sizeof(ElfW(Ehdr));
1808 ehdr.e_shentsize = sizeof(ElfW(Shdr));
1809 ehdr.e_shnum = shnum;
1810 ehdr.e_shstrndx = shnum - 1;
1812 fwrite(&ehdr, 1, sizeof(ElfW(Ehdr)), f);
1813 fwrite(phdr, 1, phnum * sizeof(ElfW(Phdr)), f);
1814 offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1816 sort_syms(s1, symtab_section);
1817 for(i = 1; i < s1->nb_sections; i++) {
1818 s = s1->sections[sec_order[i]];
1819 if (s->sh_type != SHT_NOBITS) {
1820 while (offset < s->sh_offset) {
1821 fputc(0, f);
1822 offset++;
1824 size = s->sh_size;
1825 if (size)
1826 fwrite(s->data, 1, size, f);
1827 offset += size;
1831 /* output section headers */
1832 while (offset < ehdr.e_shoff) {
1833 fputc(0, f);
1834 offset++;
1837 for(i = 0; i < s1->nb_sections; i++) {
1838 sh = &shdr;
1839 memset(sh, 0, sizeof(ElfW(Shdr)));
1840 s = s1->sections[i];
1841 if (s) {
1842 sh->sh_name = s->sh_name;
1843 sh->sh_type = s->sh_type;
1844 sh->sh_flags = s->sh_flags;
1845 sh->sh_entsize = s->sh_entsize;
1846 sh->sh_info = s->sh_info;
1847 if (s->link)
1848 sh->sh_link = s->link->sh_num;
1849 sh->sh_addralign = s->sh_addralign;
1850 sh->sh_addr = s->sh_addr;
1851 sh->sh_offset = s->sh_offset;
1852 sh->sh_size = s->sh_size;
1854 fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
1858 /* Write an elf, coff or "binary" file */
1859 static int tcc_write_elf_file(TCCState *s1, const char *filename, int phnum,
1860 ElfW(Phdr) *phdr, int file_offset, int *sec_order)
1862 int fd, mode, file_type;
1863 FILE *f;
1865 file_type = s1->output_type;
1866 if (file_type == TCC_OUTPUT_OBJ)
1867 mode = 0666;
1868 else
1869 mode = 0777;
1870 unlink(filename);
1871 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
1872 if (fd < 0) {
1873 tcc_error_noabort("could not write '%s'", filename);
1874 return -1;
1876 f = fdopen(fd, "wb");
1877 if (s1->verbose)
1878 printf("<- %s\n", filename);
1880 #ifdef TCC_TARGET_COFF
1881 if (s1->output_format == TCC_OUTPUT_FORMAT_COFF)
1882 tcc_output_coff(s1, f);
1883 else
1884 #endif
1885 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
1886 tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
1887 else
1888 tcc_output_binary(s1, f, sec_order);
1889 fclose(f);
1891 return 0;
1894 /* Output an elf, coff or binary file */
1895 /* XXX: suppress unneeded sections */
1896 static int elf_output_file(TCCState *s1, const char *filename)
1898 int i, ret, phnum, shnum, file_type, file_offset, *sec_order;
1899 struct dyn_inf dyninf;
1900 ElfW(Phdr) *phdr;
1901 ElfW(Sym) *sym;
1902 Section *strsec, *interp, *dynamic, *dynstr;
1904 file_type = s1->output_type;
1905 s1->nb_errors = 0;
1907 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
1908 if (file_type != TCC_OUTPUT_OBJ) {
1909 tcc_add_runtime(s1);
1912 phdr = NULL;
1913 sec_order = NULL;
1914 interp = dynamic = dynstr = NULL; /* avoid warning */
1915 dyninf.dyn_rel_off = 0; /* avoid warning */
1917 if (file_type != TCC_OUTPUT_OBJ) {
1918 relocate_common_syms();
1920 tcc_add_linker_symbols(s1);
1922 if (!s1->static_link) {
1923 if (file_type == TCC_OUTPUT_EXE) {
1924 char *ptr;
1925 /* allow override the dynamic loader */
1926 const char *elfint = getenv("LD_SO");
1927 if (elfint == NULL)
1928 elfint = DEFAULT_ELFINTERP(s1);
1929 /* add interpreter section only if executable */
1930 interp = new_section(s1, ".interp", SHT_PROGBITS, SHF_ALLOC);
1931 interp->sh_addralign = 1;
1932 ptr = section_ptr_add(interp, 1 + strlen(elfint));
1933 strcpy(ptr, elfint);
1936 /* add dynamic symbol table */
1937 s1->dynsym = new_symtab(s1, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
1938 ".dynstr",
1939 ".hash", SHF_ALLOC);
1940 dynstr = s1->dynsym->link;
1942 /* add dynamic section */
1943 dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC,
1944 SHF_ALLOC | SHF_WRITE);
1945 dynamic->link = dynstr;
1946 dynamic->sh_entsize = sizeof(ElfW(Dyn));
1948 build_got(s1);
1950 if (file_type == TCC_OUTPUT_EXE) {
1951 bind_exe_dynsyms(s1);
1953 if (s1->nb_errors) {
1954 ret = -1;
1955 goto the_end;
1958 bind_libs_dynsyms(s1);
1959 } else /* shared library case: simply export all global symbols */
1960 export_global_syms(s1);
1962 build_got_entries(s1);
1964 /* add a list of needed dlls */
1965 for(i = 0; i < s1->nb_loaded_dlls; i++) {
1966 DLLReference *dllref = s1->loaded_dlls[i];
1967 if (dllref->level == 0)
1968 put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name));
1971 if (s1->rpath)
1972 put_dt(dynamic, DT_RPATH, put_elf_str(dynstr, s1->rpath));
1974 /* XXX: currently, since we do not handle PIC code, we
1975 must relocate the readonly segments */
1976 if (file_type == TCC_OUTPUT_DLL) {
1977 if (s1->soname)
1978 put_dt(dynamic, DT_SONAME, put_elf_str(dynstr, s1->soname));
1979 put_dt(dynamic, DT_TEXTREL, 0);
1982 if (s1->symbolic)
1983 put_dt(dynamic, DT_SYMBOLIC, 0);
1985 /* add necessary space for other entries */
1986 dyninf.dyn_rel_off = dynamic->data_offset;
1987 dynamic->data_offset += sizeof(ElfW(Dyn)) * EXTRA_RELITEMS;
1988 } else {
1989 /* still need to build got entries in case of static link */
1990 build_got_entries(s1);
1994 /* we add a section for symbols */
1995 strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0);
1996 put_elf_str(strsec, "");
1998 /* compute number of sections */
1999 shnum = s1->nb_sections;
2001 /* this array is used to reorder sections in the output file */
2002 sec_order = tcc_malloc(sizeof(int) * shnum);
2003 sec_order[0] = 0;
2005 /* compute number of program headers */
2006 switch(file_type) {
2007 default:
2008 case TCC_OUTPUT_OBJ:
2009 phnum = 0;
2010 break;
2011 case TCC_OUTPUT_EXE:
2012 if (!s1->static_link)
2013 phnum = 4 + HAVE_PHDR;
2014 else
2015 phnum = 2;
2016 break;
2017 case TCC_OUTPUT_DLL:
2018 phnum = 3;
2019 break;
2022 /* Allocate strings for section names */
2023 alloc_sec_names(s1, file_type, strsec);
2025 /* allocate program segment headers */
2026 phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
2028 /* compute section to program header mapping */
2029 file_offset = layout_sections(s1, phdr, phnum, interp, strsec, &dyninf,
2030 sec_order);
2032 /* Fill remaining program header and finalize relocation related to dynamic
2033 linking. */
2034 if (phnum > 0) {
2035 fill_unloadable_phdr(phdr, phnum, interp, dynamic);
2036 if (dynamic) {
2037 dyninf.dynamic = dynamic;
2038 dyninf.dynstr = dynstr;
2040 fill_dynamic(s1, &dyninf);
2042 /* put in GOT the dynamic section address and relocate PLT */
2043 write32le(s1->got->data, dynamic->sh_addr);
2044 if (file_type == TCC_OUTPUT_EXE
2045 || (RELOCATE_DLLPLT && file_type == TCC_OUTPUT_DLL))
2046 relocate_plt(s1);
2048 /* relocate symbols in .dynsym now that final addresses are known */
2049 for_each_elem(s1->dynsym, 1, sym, ElfW(Sym)) {
2050 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE) {
2051 /* do symbol relocation */
2052 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
2058 /* if building executable or DLL, then relocate each section
2059 except the GOT which is already relocated */
2060 if (file_type != TCC_OUTPUT_OBJ) {
2061 ret = final_sections_reloc(s1);
2062 if (ret)
2063 goto the_end;
2066 /* Perform relocation to GOT or PLT entries */
2067 if (file_type == TCC_OUTPUT_EXE && s1->static_link)
2068 fill_got(s1);
2070 /* Create the ELF file with name 'filename' */
2071 ret = tcc_write_elf_file(s1, filename, phnum, phdr, file_offset, sec_order);
2072 the_end:
2073 tcc_free(sec_order);
2074 tcc_free(phdr);
2075 return ret;
2078 LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename)
2080 int ret;
2081 #ifdef TCC_TARGET_PE
2082 if (s->output_type != TCC_OUTPUT_OBJ) {
2083 ret = pe_output_file(s, filename);
2084 } else
2085 #endif
2086 ret = elf_output_file(s, filename);
2087 return ret;
2090 static void *load_data(int fd, unsigned long file_offset, unsigned long size)
2092 void *data;
2094 data = tcc_malloc(size);
2095 lseek(fd, file_offset, SEEK_SET);
2096 read(fd, data, size);
2097 return data;
2100 typedef struct SectionMergeInfo {
2101 Section *s; /* corresponding existing section */
2102 unsigned long offset; /* offset of the new section in the existing section */
2103 uint8_t new_section; /* true if section 's' was added */
2104 uint8_t link_once; /* true if link once section */
2105 } SectionMergeInfo;
2107 ST_FUNC int tcc_object_type(int fd, ElfW(Ehdr) *h)
2109 int size = read(fd, h, sizeof *h);
2110 if (size == sizeof *h && 0 == memcmp(h, ELFMAG, 4)) {
2111 if (h->e_type == ET_REL)
2112 return AFF_BINTYPE_REL;
2113 if (h->e_type == ET_DYN)
2114 return AFF_BINTYPE_DYN;
2115 } else if (size >= 8) {
2116 if (0 == memcmp(h, ARMAG, 8))
2117 return AFF_BINTYPE_AR;
2118 #ifdef TCC_TARGET_COFF
2119 if (((struct filehdr*)h)->f_magic == COFF_C67_MAGIC)
2120 return AFF_BINTYPE_C67;
2121 #endif
2123 return 0;
2126 /* load an object file and merge it with current files */
2127 /* XXX: handle correctly stab (debug) info */
2128 ST_FUNC int tcc_load_object_file(TCCState *s1,
2129 int fd, unsigned long file_offset)
2131 ElfW(Ehdr) ehdr;
2132 ElfW(Shdr) *shdr, *sh;
2133 int size, i, j, offset, offseti, nb_syms, sym_index, ret;
2134 unsigned char *strsec, *strtab;
2135 int *old_to_new_syms;
2136 char *sh_name, *name;
2137 SectionMergeInfo *sm_table, *sm;
2138 ElfW(Sym) *sym, *symtab;
2139 ElfW_Rel *rel;
2140 Section *s;
2142 int stab_index;
2143 int stabstr_index;
2145 stab_index = stabstr_index = 0;
2147 lseek(fd, file_offset, SEEK_SET);
2148 if (tcc_object_type(fd, &ehdr) != AFF_BINTYPE_REL)
2149 goto fail1;
2150 /* test CPU specific stuff */
2151 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2152 ehdr.e_machine != EM_TCC_TARGET) {
2153 fail1:
2154 tcc_error_noabort("invalid object file");
2155 return -1;
2157 /* read sections */
2158 shdr = load_data(fd, file_offset + ehdr.e_shoff,
2159 sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2160 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
2162 /* load section names */
2163 sh = &shdr[ehdr.e_shstrndx];
2164 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2166 /* load symtab and strtab */
2167 old_to_new_syms = NULL;
2168 symtab = NULL;
2169 strtab = NULL;
2170 nb_syms = 0;
2171 for(i = 1; i < ehdr.e_shnum; i++) {
2172 sh = &shdr[i];
2173 if (sh->sh_type == SHT_SYMTAB) {
2174 if (symtab) {
2175 tcc_error_noabort("object must contain only one symtab");
2176 fail:
2177 ret = -1;
2178 goto the_end;
2180 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2181 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2182 sm_table[i].s = symtab_section;
2184 /* now load strtab */
2185 sh = &shdr[sh->sh_link];
2186 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2190 /* now examine each section and try to merge its content with the
2191 ones in memory */
2192 for(i = 1; i < ehdr.e_shnum; i++) {
2193 /* no need to examine section name strtab */
2194 if (i == ehdr.e_shstrndx)
2195 continue;
2196 sh = &shdr[i];
2197 sh_name = (char *) strsec + sh->sh_name;
2198 /* ignore sections types we do not handle */
2199 if (sh->sh_type != SHT_PROGBITS &&
2200 sh->sh_type != SHT_RELX &&
2201 #ifdef TCC_ARM_EABI
2202 sh->sh_type != SHT_ARM_EXIDX &&
2203 #endif
2204 sh->sh_type != SHT_NOBITS &&
2205 sh->sh_type != SHT_PREINIT_ARRAY &&
2206 sh->sh_type != SHT_INIT_ARRAY &&
2207 sh->sh_type != SHT_FINI_ARRAY &&
2208 strcmp(sh_name, ".stabstr")
2210 continue;
2211 if (sh->sh_addralign < 1)
2212 sh->sh_addralign = 1;
2213 /* find corresponding section, if any */
2214 for(j = 1; j < s1->nb_sections;j++) {
2215 s = s1->sections[j];
2216 if (!strcmp(s->name, sh_name)) {
2217 if (!strncmp(sh_name, ".gnu.linkonce",
2218 sizeof(".gnu.linkonce") - 1)) {
2219 /* if a 'linkonce' section is already present, we
2220 do not add it again. It is a little tricky as
2221 symbols can still be defined in
2222 it. */
2223 sm_table[i].link_once = 1;
2224 goto next;
2225 } else {
2226 goto found;
2230 /* not found: create new section */
2231 s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags & ~SHF_GROUP);
2232 /* take as much info as possible from the section. sh_link and
2233 sh_info will be updated later */
2234 s->sh_addralign = sh->sh_addralign;
2235 s->sh_entsize = sh->sh_entsize;
2236 sm_table[i].new_section = 1;
2237 found:
2238 if (sh->sh_type != s->sh_type) {
2239 tcc_error_noabort("invalid section type");
2240 goto fail;
2243 /* align start of section */
2244 offset = s->data_offset;
2246 if (0 == strcmp(sh_name, ".stab")) {
2247 stab_index = i;
2248 goto no_align;
2250 if (0 == strcmp(sh_name, ".stabstr")) {
2251 stabstr_index = i;
2252 goto no_align;
2255 size = sh->sh_addralign - 1;
2256 offset = (offset + size) & ~size;
2257 if (sh->sh_addralign > s->sh_addralign)
2258 s->sh_addralign = sh->sh_addralign;
2259 s->data_offset = offset;
2260 no_align:
2261 sm_table[i].offset = offset;
2262 sm_table[i].s = s;
2263 /* concatenate sections */
2264 size = sh->sh_size;
2265 if (sh->sh_type != SHT_NOBITS) {
2266 unsigned char *ptr;
2267 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
2268 ptr = section_ptr_add(s, size);
2269 read(fd, ptr, size);
2270 } else {
2271 s->data_offset += size;
2273 next: ;
2276 /* gr relocate stab strings */
2277 if (stab_index && stabstr_index) {
2278 Stab_Sym *a, *b;
2279 unsigned o;
2280 s = sm_table[stab_index].s;
2281 a = (Stab_Sym *)(s->data + sm_table[stab_index].offset);
2282 b = (Stab_Sym *)(s->data + s->data_offset);
2283 o = sm_table[stabstr_index].offset;
2284 while (a < b)
2285 a->n_strx += o, a++;
2288 /* second short pass to update sh_link and sh_info fields of new
2289 sections */
2290 for(i = 1; i < ehdr.e_shnum; i++) {
2291 s = sm_table[i].s;
2292 if (!s || !sm_table[i].new_section)
2293 continue;
2294 sh = &shdr[i];
2295 if (sh->sh_link > 0)
2296 s->link = sm_table[sh->sh_link].s;
2297 if (sh->sh_type == SHT_RELX) {
2298 s->sh_info = sm_table[sh->sh_info].s->sh_num;
2299 /* update backward link */
2300 s1->sections[s->sh_info]->reloc = s;
2303 sm = sm_table;
2305 /* resolve symbols */
2306 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
2308 sym = symtab + 1;
2309 for(i = 1; i < nb_syms; i++, sym++) {
2310 if (sym->st_shndx != SHN_UNDEF &&
2311 sym->st_shndx < SHN_LORESERVE) {
2312 sm = &sm_table[sym->st_shndx];
2313 if (sm->link_once) {
2314 /* if a symbol is in a link once section, we use the
2315 already defined symbol. It is very important to get
2316 correct relocations */
2317 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
2318 name = (char *) strtab + sym->st_name;
2319 sym_index = find_elf_sym(symtab_section, name);
2320 if (sym_index)
2321 old_to_new_syms[i] = sym_index;
2323 continue;
2325 /* if no corresponding section added, no need to add symbol */
2326 if (!sm->s)
2327 continue;
2328 /* convert section number */
2329 sym->st_shndx = sm->s->sh_num;
2330 /* offset value */
2331 sym->st_value += sm->offset;
2333 /* add symbol */
2334 name = (char *) strtab + sym->st_name;
2335 sym_index = set_elf_sym(symtab_section, sym->st_value, sym->st_size,
2336 sym->st_info, sym->st_other,
2337 sym->st_shndx, name);
2338 old_to_new_syms[i] = sym_index;
2341 /* third pass to patch relocation entries */
2342 for(i = 1; i < ehdr.e_shnum; i++) {
2343 s = sm_table[i].s;
2344 if (!s)
2345 continue;
2346 sh = &shdr[i];
2347 offset = sm_table[i].offset;
2348 switch(s->sh_type) {
2349 case SHT_RELX:
2350 /* take relocation offset information */
2351 offseti = sm_table[sh->sh_info].offset;
2352 for_each_elem(s, (offset / sizeof(*rel)), rel, ElfW_Rel) {
2353 int type;
2354 unsigned sym_index;
2355 /* convert symbol index */
2356 type = ELFW(R_TYPE)(rel->r_info);
2357 sym_index = ELFW(R_SYM)(rel->r_info);
2358 /* NOTE: only one symtab assumed */
2359 if (sym_index >= nb_syms)
2360 goto invalid_reloc;
2361 sym_index = old_to_new_syms[sym_index];
2362 /* ignore link_once in rel section. */
2363 if (!sym_index && !sm->link_once
2364 #ifdef TCC_TARGET_ARM
2365 && type != R_ARM_V4BX
2366 #endif
2368 invalid_reloc:
2369 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2370 i, strsec + sh->sh_name, rel->r_offset);
2371 goto fail;
2373 rel->r_info = ELFW(R_INFO)(sym_index, type);
2374 /* offset the relocation offset */
2375 rel->r_offset += offseti;
2376 #ifdef TCC_TARGET_ARM
2377 /* Jumps and branches from a Thumb code to a PLT entry need
2378 special handling since PLT entries are ARM code.
2379 Unconditional bl instructions referencing PLT entries are
2380 handled by converting these instructions into blx
2381 instructions. Other case of instructions referencing a PLT
2382 entry require to add a Thumb stub before the PLT entry to
2383 switch to ARM mode. We set bit plt_thumb_stub of the
2384 attribute of a symbol to indicate such a case. */
2385 if (type == R_ARM_THM_JUMP24)
2386 get_sym_attr(s1, sym_index, 1)->plt_thumb_stub = 1;
2387 #endif
2389 break;
2390 default:
2391 break;
2395 ret = 0;
2396 the_end:
2397 tcc_free(symtab);
2398 tcc_free(strtab);
2399 tcc_free(old_to_new_syms);
2400 tcc_free(sm_table);
2401 tcc_free(strsec);
2402 tcc_free(shdr);
2403 return ret;
2406 typedef struct ArchiveHeader {
2407 char ar_name[16]; /* name of this member */
2408 char ar_date[12]; /* file mtime */
2409 char ar_uid[6]; /* owner uid; printed as decimal */
2410 char ar_gid[6]; /* owner gid; printed as decimal */
2411 char ar_mode[8]; /* file mode, printed as octal */
2412 char ar_size[10]; /* file size, printed as decimal */
2413 char ar_fmag[2]; /* should contain ARFMAG */
2414 } ArchiveHeader;
2416 static int get_be32(const uint8_t *b)
2418 return b[3] | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
2421 static long get_be64(const uint8_t *b)
2423 long long ret = get_be32(b);
2424 ret = (ret << 32) | (unsigned)get_be32(b+4);
2425 return (long)ret;
2428 /* load only the objects which resolve undefined symbols */
2429 static int tcc_load_alacarte(TCCState *s1, int fd, int size, int entrysize)
2431 long i, bound, nsyms, sym_index, off, ret;
2432 uint8_t *data;
2433 const char *ar_names, *p;
2434 const uint8_t *ar_index;
2435 ElfW(Sym) *sym;
2437 data = tcc_malloc(size);
2438 if (read(fd, data, size) != size)
2439 goto fail;
2440 nsyms = entrysize == 4 ? get_be32(data) : get_be64(data);
2441 ar_index = data + entrysize;
2442 ar_names = (char *) ar_index + nsyms * entrysize;
2444 do {
2445 bound = 0;
2446 for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2447 sym_index = find_elf_sym(symtab_section, p);
2448 if(sym_index) {
2449 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
2450 if(sym->st_shndx == SHN_UNDEF) {
2451 off = (entrysize == 4
2452 ? get_be32(ar_index + i * 4)
2453 : get_be64(ar_index + i * 8))
2454 + sizeof(ArchiveHeader);
2455 ++bound;
2456 if(tcc_load_object_file(s1, fd, off) < 0) {
2457 fail:
2458 ret = -1;
2459 goto the_end;
2464 } while(bound);
2465 ret = 0;
2466 the_end:
2467 tcc_free(data);
2468 return ret;
2471 /* load a '.a' file */
2472 ST_FUNC int tcc_load_archive(TCCState *s1, int fd)
2474 ArchiveHeader hdr;
2475 char ar_size[11];
2476 char ar_name[17];
2477 char magic[8];
2478 int size, len, i;
2479 unsigned long file_offset;
2481 /* skip magic which was already checked */
2482 read(fd, magic, sizeof(magic));
2484 for(;;) {
2485 len = read(fd, &hdr, sizeof(hdr));
2486 if (len == 0)
2487 break;
2488 if (len != sizeof(hdr)) {
2489 tcc_error_noabort("invalid archive");
2490 return -1;
2492 memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
2493 ar_size[sizeof(hdr.ar_size)] = '\0';
2494 size = strtol(ar_size, NULL, 0);
2495 memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
2496 for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
2497 if (ar_name[i] != ' ')
2498 break;
2500 ar_name[i + 1] = '\0';
2501 file_offset = lseek(fd, 0, SEEK_CUR);
2502 /* align to even */
2503 size = (size + 1) & ~1;
2504 if (!strcmp(ar_name, "/")) {
2505 /* coff symbol table : we handle it */
2506 if(s1->alacarte_link)
2507 return tcc_load_alacarte(s1, fd, size, 4);
2508 } else if (!strcmp(ar_name, "/SYM64/")) {
2509 if(s1->alacarte_link)
2510 return tcc_load_alacarte(s1, fd, size, 8);
2511 } else {
2512 ElfW(Ehdr) ehdr;
2513 if (tcc_object_type(fd, &ehdr) == AFF_BINTYPE_REL) {
2514 if (tcc_load_object_file(s1, fd, file_offset) < 0)
2515 return -1;
2518 lseek(fd, file_offset + size, SEEK_SET);
2520 return 0;
2523 #ifndef TCC_TARGET_PE
2524 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2525 is referenced by the user (so it should be added as DT_NEEDED in
2526 the generated ELF file) */
2527 ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
2529 ElfW(Ehdr) ehdr;
2530 ElfW(Shdr) *shdr, *sh, *sh1;
2531 int i, j, nb_syms, nb_dts, sym_bind, ret;
2532 ElfW(Sym) *sym, *dynsym;
2533 ElfW(Dyn) *dt, *dynamic;
2534 unsigned char *dynstr;
2535 const char *name, *soname;
2536 DLLReference *dllref;
2538 read(fd, &ehdr, sizeof(ehdr));
2540 /* test CPU specific stuff */
2541 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2542 ehdr.e_machine != EM_TCC_TARGET) {
2543 tcc_error_noabort("bad architecture");
2544 return -1;
2547 /* read sections */
2548 shdr = load_data(fd, ehdr.e_shoff, sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2550 /* load dynamic section and dynamic symbols */
2551 nb_syms = 0;
2552 nb_dts = 0;
2553 dynamic = NULL;
2554 dynsym = NULL; /* avoid warning */
2555 dynstr = NULL; /* avoid warning */
2556 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
2557 switch(sh->sh_type) {
2558 case SHT_DYNAMIC:
2559 nb_dts = sh->sh_size / sizeof(ElfW(Dyn));
2560 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
2561 break;
2562 case SHT_DYNSYM:
2563 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2564 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
2565 sh1 = &shdr[sh->sh_link];
2566 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
2567 break;
2568 default:
2569 break;
2573 /* compute the real library name */
2574 soname = tcc_basename(filename);
2576 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2577 if (dt->d_tag == DT_SONAME) {
2578 soname = (char *) dynstr + dt->d_un.d_val;
2582 /* if the dll is already loaded, do not load it */
2583 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2584 dllref = s1->loaded_dlls[i];
2585 if (!strcmp(soname, dllref->name)) {
2586 /* but update level if needed */
2587 if (level < dllref->level)
2588 dllref->level = level;
2589 ret = 0;
2590 goto the_end;
2594 /* add the dll and its level */
2595 dllref = tcc_mallocz(sizeof(DLLReference) + strlen(soname));
2596 dllref->level = level;
2597 strcpy(dllref->name, soname);
2598 dynarray_add((void ***)&s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
2600 /* add dynamic symbols in dynsym_section */
2601 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
2602 sym_bind = ELFW(ST_BIND)(sym->st_info);
2603 if (sym_bind == STB_LOCAL)
2604 continue;
2605 name = (char *) dynstr + sym->st_name;
2606 set_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
2607 sym->st_info, sym->st_other, sym->st_shndx, name);
2610 /* load all referenced DLLs */
2611 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2612 switch(dt->d_tag) {
2613 case DT_NEEDED:
2614 name = (char *) dynstr + dt->d_un.d_val;
2615 for(j = 0; j < s1->nb_loaded_dlls; j++) {
2616 dllref = s1->loaded_dlls[j];
2617 if (!strcmp(name, dllref->name))
2618 goto already_loaded;
2620 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
2621 tcc_error_noabort("referenced dll '%s' not found", name);
2622 ret = -1;
2623 goto the_end;
2625 already_loaded:
2626 break;
2629 ret = 0;
2630 the_end:
2631 tcc_free(dynstr);
2632 tcc_free(dynsym);
2633 tcc_free(dynamic);
2634 tcc_free(shdr);
2635 return ret;
2638 #define LD_TOK_NAME 256
2639 #define LD_TOK_EOF (-1)
2641 /* return next ld script token */
2642 static int ld_next(TCCState *s1, char *name, int name_size)
2644 int c;
2645 char *q;
2647 redo:
2648 switch(ch) {
2649 case ' ':
2650 case '\t':
2651 case '\f':
2652 case '\v':
2653 case '\r':
2654 case '\n':
2655 inp();
2656 goto redo;
2657 case '/':
2658 minp();
2659 if (ch == '*') {
2660 file->buf_ptr = parse_comment(file->buf_ptr);
2661 ch = file->buf_ptr[0];
2662 goto redo;
2663 } else {
2664 q = name;
2665 *q++ = '/';
2666 goto parse_name;
2668 break;
2669 case '\\':
2670 ch = handle_eob();
2671 if (ch != '\\')
2672 goto redo;
2673 /* fall through */
2674 /* case 'a' ... 'z': */
2675 case 'a':
2676 case 'b':
2677 case 'c':
2678 case 'd':
2679 case 'e':
2680 case 'f':
2681 case 'g':
2682 case 'h':
2683 case 'i':
2684 case 'j':
2685 case 'k':
2686 case 'l':
2687 case 'm':
2688 case 'n':
2689 case 'o':
2690 case 'p':
2691 case 'q':
2692 case 'r':
2693 case 's':
2694 case 't':
2695 case 'u':
2696 case 'v':
2697 case 'w':
2698 case 'x':
2699 case 'y':
2700 case 'z':
2701 /* case 'A' ... 'z': */
2702 case 'A':
2703 case 'B':
2704 case 'C':
2705 case 'D':
2706 case 'E':
2707 case 'F':
2708 case 'G':
2709 case 'H':
2710 case 'I':
2711 case 'J':
2712 case 'K':
2713 case 'L':
2714 case 'M':
2715 case 'N':
2716 case 'O':
2717 case 'P':
2718 case 'Q':
2719 case 'R':
2720 case 'S':
2721 case 'T':
2722 case 'U':
2723 case 'V':
2724 case 'W':
2725 case 'X':
2726 case 'Y':
2727 case 'Z':
2728 case '_':
2729 case '.':
2730 case '$':
2731 case '~':
2732 q = name;
2733 parse_name:
2734 for(;;) {
2735 if (!((ch >= 'a' && ch <= 'z') ||
2736 (ch >= 'A' && ch <= 'Z') ||
2737 (ch >= '0' && ch <= '9') ||
2738 strchr("/.-_+=$:\\,~", ch)))
2739 break;
2740 if ((q - name) < name_size - 1) {
2741 *q++ = ch;
2743 minp();
2745 *q = '\0';
2746 c = LD_TOK_NAME;
2747 break;
2748 case CH_EOF:
2749 c = LD_TOK_EOF;
2750 break;
2751 default:
2752 c = ch;
2753 inp();
2754 break;
2756 return c;
2759 static int ld_add_file(TCCState *s1, const char filename[])
2761 int ret;
2763 ret = tcc_add_file_internal(s1, filename, AFF_TYPE_BIN);
2764 if (ret)
2765 ret = tcc_add_dll(s1, filename, 0);
2766 return ret;
2769 static inline int new_undef_syms(void)
2771 int ret = 0;
2772 ret = new_undef_sym;
2773 new_undef_sym = 0;
2774 return ret;
2777 static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
2779 char filename[1024], libname[1024];
2780 int t, group, nblibs = 0, ret = 0;
2781 char **libs = NULL;
2783 group = !strcmp(cmd, "GROUP");
2784 if (!as_needed)
2785 new_undef_syms();
2786 t = ld_next(s1, filename, sizeof(filename));
2787 if (t != '(')
2788 expect("(");
2789 t = ld_next(s1, filename, sizeof(filename));
2790 for(;;) {
2791 libname[0] = '\0';
2792 if (t == LD_TOK_EOF) {
2793 tcc_error_noabort("unexpected end of file");
2794 ret = -1;
2795 goto lib_parse_error;
2796 } else if (t == ')') {
2797 break;
2798 } else if (t == '-') {
2799 t = ld_next(s1, filename, sizeof(filename));
2800 if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
2801 tcc_error_noabort("library name expected");
2802 ret = -1;
2803 goto lib_parse_error;
2805 pstrcpy(libname, sizeof libname, &filename[1]);
2806 if (s1->static_link) {
2807 snprintf(filename, sizeof filename, "lib%s.a", libname);
2808 } else {
2809 snprintf(filename, sizeof filename, "lib%s.so", libname);
2811 } else if (t != LD_TOK_NAME) {
2812 tcc_error_noabort("filename expected");
2813 ret = -1;
2814 goto lib_parse_error;
2816 if (!strcmp(filename, "AS_NEEDED")) {
2817 ret = ld_add_file_list(s1, cmd, 1);
2818 if (ret)
2819 goto lib_parse_error;
2820 } else {
2821 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2822 if (!as_needed) {
2823 ret = ld_add_file(s1, filename);
2824 if (ret)
2825 goto lib_parse_error;
2826 if (group) {
2827 /* Add the filename *and* the libname to avoid future conversions */
2828 dynarray_add((void ***) &libs, &nblibs, tcc_strdup(filename));
2829 if (libname[0] != '\0')
2830 dynarray_add((void ***) &libs, &nblibs, tcc_strdup(libname));
2834 t = ld_next(s1, filename, sizeof(filename));
2835 if (t == ',') {
2836 t = ld_next(s1, filename, sizeof(filename));
2839 if (group && !as_needed) {
2840 while (new_undef_syms()) {
2841 int i;
2843 for (i = 0; i < nblibs; i ++)
2844 ld_add_file(s1, libs[i]);
2847 lib_parse_error:
2848 dynarray_reset(&libs, &nblibs);
2849 return ret;
2852 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
2853 files */
2854 ST_FUNC int tcc_load_ldscript(TCCState *s1)
2856 char cmd[64];
2857 char filename[1024];
2858 int t, ret;
2860 ch = handle_eob();
2861 for(;;) {
2862 t = ld_next(s1, cmd, sizeof(cmd));
2863 if (t == LD_TOK_EOF)
2864 return 0;
2865 else if (t != LD_TOK_NAME)
2866 return -1;
2867 if (!strcmp(cmd, "INPUT") ||
2868 !strcmp(cmd, "GROUP")) {
2869 ret = ld_add_file_list(s1, cmd, 0);
2870 if (ret)
2871 return ret;
2872 } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
2873 !strcmp(cmd, "TARGET")) {
2874 /* ignore some commands */
2875 t = ld_next(s1, cmd, sizeof(cmd));
2876 if (t != '(')
2877 expect("(");
2878 for(;;) {
2879 t = ld_next(s1, filename, sizeof(filename));
2880 if (t == LD_TOK_EOF) {
2881 tcc_error_noabort("unexpected end of file");
2882 return -1;
2883 } else if (t == ')') {
2884 break;
2887 } else {
2888 return -1;
2891 return 0;
2893 #endif /* !TCC_TARGET_PE */