Use unsigned int to count sizes for -bench (YARPgen) (part 2)
[tinycc.git] / tccelf.c
blob15ed168cdab0863ee49e378c3556e830c4aaeb4b
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 /* elf version information */
30 struct sym_version {
31 char *lib;
32 char *version;
33 int out_index;
34 int prev_same_lib;
37 #define nb_sym_versions s1->nb_sym_versions
38 #define sym_versions s1->sym_versions
39 #define nb_sym_to_version s1->nb_sym_to_version
40 #define sym_to_version s1->sym_to_version
41 #define dt_verneednum s1->dt_verneednum
42 #define versym_section s1->versym_section
43 #define verneed_section s1->verneed_section
45 /* special flag to indicate that the section should not be linked to the other ones */
46 #define SHF_PRIVATE 0x80000000
47 /* section is dynsymtab_section */
48 #define SHF_DYNSYM 0x40000000
50 #ifdef TCC_TARGET_PE
51 static const int shf_RELRO = SHF_ALLOC;
52 static const char rdata[] = ".rdata";
53 #else
54 static const int shf_RELRO = SHF_ALLOC | SHF_WRITE;
55 static const char rdata[] = ".data.ro";
56 #endif
58 /* ------------------------------------------------------------------------- */
60 ST_FUNC void tccelf_new(TCCState *s)
62 TCCState *s1 = s;
63 /* no section zero */
64 dynarray_add(&s->sections, &s->nb_sections, NULL);
66 /* create standard sections */
67 text_section = new_section(s, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
68 data_section = new_section(s, ".data", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
69 /* create ro data section (make ro after relocation done with GNU_RELRO) */
70 rodata_section = new_section(s, rdata, SHT_PROGBITS, shf_RELRO);
71 bss_section = new_section(s, ".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
72 common_section = new_section(s, ".common", SHT_NOBITS, SHF_PRIVATE);
73 common_section->sh_num = SHN_COMMON;
75 /* symbols are always generated for linking stage */
76 symtab_section = new_symtab(s, ".symtab", SHT_SYMTAB, 0,
77 ".strtab",
78 ".hashtab", SHF_PRIVATE);
79 s->symtab = symtab_section;
81 /* private symbol table for dynamic symbols */
82 s->dynsymtab_section = new_symtab(s, ".dynsymtab", SHT_SYMTAB, SHF_PRIVATE|SHF_DYNSYM,
83 ".dynstrtab",
84 ".dynhashtab", SHF_PRIVATE);
85 get_sym_attr(s, 0, 1);
88 #ifdef CONFIG_TCC_BCHECK
89 ST_FUNC void tccelf_bounds_new(TCCState *s)
91 TCCState *s1 = s;
92 /* create bounds sections (make ro after relocation done with GNU_RELRO) */
93 bounds_section = new_section(s, ".bounds", SHT_PROGBITS, shf_RELRO);
94 lbounds_section = new_section(s, ".lbounds", SHT_PROGBITS, shf_RELRO);
96 #endif
98 static void free_section(Section *s)
100 tcc_free(s->data);
103 ST_FUNC void tccelf_delete(TCCState *s1)
105 int i;
107 #ifndef ELF_OBJ_ONLY
108 /* free symbol versions */
109 for (i = 0; i < nb_sym_versions; i++) {
110 tcc_free(sym_versions[i].version);
111 tcc_free(sym_versions[i].lib);
113 tcc_free(sym_versions);
114 tcc_free(sym_to_version);
115 #endif
117 /* free all sections */
118 for(i = 1; i < s1->nb_sections; i++)
119 free_section(s1->sections[i]);
120 dynarray_reset(&s1->sections, &s1->nb_sections);
122 for(i = 0; i < s1->nb_priv_sections; i++)
123 free_section(s1->priv_sections[i]);
124 dynarray_reset(&s1->priv_sections, &s1->nb_priv_sections);
126 /* free any loaded DLLs */
127 #ifdef TCC_IS_NATIVE
128 for ( i = 0; i < s1->nb_loaded_dlls; i++) {
129 DLLReference *ref = s1->loaded_dlls[i];
130 if ( ref->handle )
131 # ifdef _WIN32
132 FreeLibrary((HMODULE)ref->handle);
133 # else
134 dlclose(ref->handle);
135 # endif
137 #endif
138 /* free loaded dlls array */
139 dynarray_reset(&s1->loaded_dlls, &s1->nb_loaded_dlls);
140 tcc_free(s1->sym_attrs);
142 symtab_section = NULL; /* for tccrun.c:rt_printline() */
145 /* save section data state */
146 ST_FUNC void tccelf_begin_file(TCCState *s1)
148 Section *s; int i;
149 for (i = 1; i < s1->nb_sections; i++) {
150 s = s1->sections[i];
151 s->sh_offset = s->data_offset;
153 /* disable symbol hashing during compilation */
154 s = s1->symtab, s->reloc = s->hash, s->hash = NULL;
155 #if defined TCC_TARGET_X86_64 && defined TCC_TARGET_PE
156 s1->uw_sym = 0;
157 #endif
160 /* At the end of compilation, convert any UNDEF syms to global, and merge
161 with previously existing symbols */
162 ST_FUNC void tccelf_end_file(TCCState *s1)
164 Section *s = s1->symtab;
165 int first_sym, nb_syms, *tr, i;
167 first_sym = s->sh_offset / sizeof (ElfSym);
168 nb_syms = s->data_offset / sizeof (ElfSym) - first_sym;
169 s->data_offset = s->sh_offset;
170 s->link->data_offset = s->link->sh_offset;
171 s->hash = s->reloc, s->reloc = NULL;
172 tr = tcc_mallocz(nb_syms * sizeof *tr);
174 for (i = 0; i < nb_syms; ++i) {
175 ElfSym *sym = (ElfSym*)s->data + first_sym + i;
176 if (sym->st_shndx == SHN_UNDEF
177 && ELFW(ST_BIND)(sym->st_info) == STB_LOCAL)
178 sym->st_info = ELFW(ST_INFO)(STB_GLOBAL, ELFW(ST_TYPE)(sym->st_info));
179 tr[i] = set_elf_sym(s, sym->st_value, sym->st_size, sym->st_info,
180 sym->st_other, sym->st_shndx, (char*)s->link->data + sym->st_name);
182 /* now update relocations */
183 for (i = 1; i < s1->nb_sections; i++) {
184 Section *sr = s1->sections[i];
185 if (sr->sh_type == SHT_RELX && sr->link == s) {
186 ElfW_Rel *rel = (ElfW_Rel*)(sr->data + sr->sh_offset);
187 ElfW_Rel *rel_end = (ElfW_Rel*)(sr->data + sr->data_offset);
188 for (; rel < rel_end; ++rel) {
189 int n = ELFW(R_SYM)(rel->r_info) - first_sym;
190 if (n < 0) /* zero sym_index in reloc (can happen with asm) */
191 continue;
192 rel->r_info = ELFW(R_INFO)(tr[n], ELFW(R_TYPE)(rel->r_info));
196 tcc_free(tr);
198 /* record text/data/bss output for -bench info */
199 for (i = 0; i < 4; ++i) {
200 s = s1->sections[i + 1];
201 s1->total_output[i] += s->data_offset - s->sh_offset;
205 ST_FUNC Section *new_section(TCCState *s1, const char *name, int sh_type, int sh_flags)
207 Section *sec;
209 sec = tcc_mallocz(sizeof(Section) + strlen(name));
210 sec->s1 = s1;
211 strcpy(sec->name, name);
212 sec->sh_type = sh_type;
213 sec->sh_flags = sh_flags;
214 switch(sh_type) {
215 case SHT_GNU_versym:
216 sec->sh_addralign = 2;
217 break;
218 case SHT_HASH:
219 case SHT_GNU_HASH:
220 case SHT_REL:
221 case SHT_RELA:
222 case SHT_DYNSYM:
223 case SHT_SYMTAB:
224 case SHT_DYNAMIC:
225 case SHT_GNU_verneed:
226 case SHT_GNU_verdef:
227 sec->sh_addralign = PTR_SIZE;
228 break;
229 case SHT_STRTAB:
230 sec->sh_addralign = 1;
231 break;
232 default:
233 sec->sh_addralign = PTR_SIZE; /* gcc/pcc default alignment */
234 break;
237 if (sh_flags & SHF_PRIVATE) {
238 dynarray_add(&s1->priv_sections, &s1->nb_priv_sections, sec);
239 } else {
240 sec->sh_num = s1->nb_sections;
241 dynarray_add(&s1->sections, &s1->nb_sections, sec);
244 return sec;
247 ST_FUNC Section *new_symtab(TCCState *s1,
248 const char *symtab_name, int sh_type, int sh_flags,
249 const char *strtab_name,
250 const char *hash_name, int hash_sh_flags)
252 Section *symtab, *strtab, *hash;
253 int *ptr, nb_buckets;
255 symtab = new_section(s1, symtab_name, sh_type, sh_flags);
256 symtab->sh_entsize = sizeof(ElfW(Sym));
257 strtab = new_section(s1, strtab_name, SHT_STRTAB, sh_flags);
258 put_elf_str(strtab, "");
259 symtab->link = strtab;
260 put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL);
262 nb_buckets = 1;
264 hash = new_section(s1, hash_name, SHT_HASH, hash_sh_flags);
265 hash->sh_entsize = sizeof(int);
266 symtab->hash = hash;
267 hash->link = symtab;
269 ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int));
270 ptr[0] = nb_buckets;
271 ptr[1] = 1;
272 memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int));
273 return symtab;
276 /* realloc section and set its content to zero */
277 ST_FUNC void section_realloc(Section *sec, unsigned long new_size)
279 unsigned long size;
280 unsigned char *data;
282 size = sec->data_allocated;
283 if (size == 0)
284 size = 1;
285 while (size < new_size)
286 size = size * 2;
287 data = tcc_realloc(sec->data, size);
288 memset(data + sec->data_allocated, 0, size - sec->data_allocated);
289 sec->data = data;
290 sec->data_allocated = size;
293 /* reserve at least 'size' bytes aligned per 'align' in section
294 'sec' from current offset, and return the aligned offset */
295 ST_FUNC size_t section_add(Section *sec, addr_t size, int align)
297 size_t offset, offset1;
299 offset = (sec->data_offset + align - 1) & -align;
300 offset1 = offset + size;
301 if (sec->sh_type != SHT_NOBITS && offset1 > sec->data_allocated)
302 section_realloc(sec, offset1);
303 sec->data_offset = offset1;
304 if (align > sec->sh_addralign)
305 sec->sh_addralign = align;
306 return offset;
309 /* reserve at least 'size' bytes in section 'sec' from
310 sec->data_offset. */
311 ST_FUNC void *section_ptr_add(Section *sec, addr_t size)
313 size_t offset = section_add(sec, size, 1);
314 return sec->data + offset;
317 #ifndef ELF_OBJ_ONLY
318 /* reserve at least 'size' bytes from section start */
319 static void section_reserve(Section *sec, unsigned long size)
321 if (size > sec->data_allocated)
322 section_realloc(sec, size);
323 if (size > sec->data_offset)
324 sec->data_offset = size;
326 #endif
328 static Section *have_section(TCCState *s1, const char *name)
330 Section *sec;
331 int i;
332 for(i = 1; i < s1->nb_sections; i++) {
333 sec = s1->sections[i];
334 if (!strcmp(name, sec->name))
335 return sec;
337 return NULL;
340 /* return a reference to a section, and create it if it does not
341 exists */
342 ST_FUNC Section *find_section(TCCState *s1, const char *name)
344 Section *sec = have_section(s1, name);
345 if (sec)
346 return sec;
347 /* sections are created as PROGBITS */
348 return new_section(s1, name, SHT_PROGBITS, SHF_ALLOC);
351 /* ------------------------------------------------------------------------- */
353 ST_FUNC int put_elf_str(Section *s, const char *sym)
355 int offset, len;
356 char *ptr;
358 len = strlen(sym) + 1;
359 offset = s->data_offset;
360 ptr = section_ptr_add(s, len);
361 memmove(ptr, sym, len);
362 return offset;
365 /* elf symbol hashing function */
366 static ElfW(Word) elf_hash(const unsigned char *name)
368 ElfW(Word) h = 0, g;
370 while (*name) {
371 h = (h << 4) + *name++;
372 g = h & 0xf0000000;
373 if (g)
374 h ^= g >> 24;
375 h &= ~g;
377 return h;
380 /* rebuild hash table of section s */
381 /* NOTE: we do factorize the hash table code to go faster */
382 static void rebuild_hash(Section *s, unsigned int nb_buckets)
384 ElfW(Sym) *sym;
385 int *ptr, *hash, nb_syms, sym_index, h;
386 unsigned char *strtab;
388 strtab = s->link->data;
389 nb_syms = s->data_offset / sizeof(ElfW(Sym));
391 if (!nb_buckets)
392 nb_buckets = ((int*)s->hash->data)[0];
394 s->hash->data_offset = 0;
395 ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int));
396 ptr[0] = nb_buckets;
397 ptr[1] = nb_syms;
398 ptr += 2;
399 hash = ptr;
400 memset(hash, 0, (nb_buckets + 1) * sizeof(int));
401 ptr += nb_buckets + 1;
403 sym = (ElfW(Sym) *)s->data + 1;
404 for(sym_index = 1; sym_index < nb_syms; sym_index++) {
405 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
406 h = elf_hash(strtab + sym->st_name) % nb_buckets;
407 *ptr = hash[h];
408 hash[h] = sym_index;
409 } else {
410 *ptr = 0;
412 ptr++;
413 sym++;
417 /* return the symbol number */
418 ST_FUNC int put_elf_sym(Section *s, addr_t value, unsigned long size,
419 int info, int other, int shndx, const char *name)
421 int name_offset, sym_index;
422 int nbuckets, h;
423 ElfW(Sym) *sym;
424 Section *hs;
426 sym = section_ptr_add(s, sizeof(ElfW(Sym)));
427 if (name && name[0])
428 name_offset = put_elf_str(s->link, name);
429 else
430 name_offset = 0;
431 /* XXX: endianness */
432 sym->st_name = name_offset;
433 sym->st_value = value;
434 sym->st_size = size;
435 sym->st_info = info;
436 sym->st_other = other;
437 sym->st_shndx = shndx;
438 sym_index = sym - (ElfW(Sym) *)s->data;
439 hs = s->hash;
440 if (hs) {
441 int *ptr, *base;
442 ptr = section_ptr_add(hs, sizeof(int));
443 base = (int *)hs->data;
444 /* only add global or weak symbols. */
445 if (ELFW(ST_BIND)(info) != STB_LOCAL) {
446 /* add another hashing entry */
447 nbuckets = base[0];
448 h = elf_hash((unsigned char *)s->link->data + name_offset) % nbuckets;
449 *ptr = base[2 + h];
450 base[2 + h] = sym_index;
451 base[1]++;
452 /* we resize the hash table */
453 hs->nb_hashed_syms++;
454 if (hs->nb_hashed_syms > 2 * nbuckets) {
455 rebuild_hash(s, 2 * nbuckets);
457 } else {
458 *ptr = 0;
459 base[1]++;
462 return sym_index;
465 ST_FUNC int find_elf_sym(Section *s, const char *name)
467 ElfW(Sym) *sym;
468 Section *hs;
469 int nbuckets, sym_index, h;
470 const char *name1;
472 hs = s->hash;
473 if (!hs)
474 return 0;
475 nbuckets = ((int *)hs->data)[0];
476 h = elf_hash((unsigned char *) name) % nbuckets;
477 sym_index = ((int *)hs->data)[2 + h];
478 while (sym_index != 0) {
479 sym = &((ElfW(Sym) *)s->data)[sym_index];
480 name1 = (char *) s->link->data + sym->st_name;
481 if (!strcmp(name, name1))
482 return sym_index;
483 sym_index = ((int *)hs->data)[2 + nbuckets + sym_index];
485 return 0;
488 /* return elf symbol value, signal error if 'err' is nonzero, decorate
489 name if FORC */
490 ST_FUNC addr_t get_sym_addr(TCCState *s1, const char *name, int err, int forc)
492 int sym_index;
493 ElfW(Sym) *sym;
494 char buf[256];
495 if (forc && s1->leading_underscore
496 #ifdef TCC_TARGET_PE
497 /* win32-32bit stdcall symbols always have _ already */
498 && !strchr(name, '@')
499 #endif
501 buf[0] = '_';
502 pstrcpy(buf + 1, sizeof(buf) - 1, name);
503 name = buf;
505 sym_index = find_elf_sym(s1->symtab, name);
506 sym = &((ElfW(Sym) *)s1->symtab->data)[sym_index];
507 if (!sym_index || sym->st_shndx == SHN_UNDEF) {
508 if (err)
509 tcc_error("%s not defined", name);
510 return (addr_t)-1;
512 return sym->st_value;
515 /* return elf symbol value */
516 LIBTCCAPI void *tcc_get_symbol(TCCState *s, const char *name)
518 addr_t addr = get_sym_addr(s, name, 0, 1);
519 return addr == -1 ? NULL : (void*)(uintptr_t)addr;
522 /* list elf symbol names and values */
523 ST_FUNC void list_elf_symbols(TCCState *s, void *ctx,
524 void (*symbol_cb)(void *ctx, const char *name, const void *val))
526 ElfW(Sym) *sym;
527 Section *symtab;
528 int sym_index, end_sym;
529 const char *name;
530 unsigned char sym_vis, sym_bind;
532 symtab = s->symtab;
533 end_sym = symtab->data_offset / sizeof (ElfSym);
534 for (sym_index = 0; sym_index < end_sym; ++sym_index) {
535 sym = &((ElfW(Sym) *)symtab->data)[sym_index];
536 if (sym->st_value) {
537 name = (char *) symtab->link->data + sym->st_name;
538 sym_bind = ELFW(ST_BIND)(sym->st_info);
539 sym_vis = ELFW(ST_VISIBILITY)(sym->st_other);
540 if (sym_bind == STB_GLOBAL && sym_vis == STV_DEFAULT)
541 symbol_cb(ctx, name, (void*)(uintptr_t)sym->st_value);
546 /* list elf symbol names and values */
547 LIBTCCAPI void tcc_list_symbols(TCCState *s, void *ctx,
548 void (*symbol_cb)(void *ctx, const char *name, const void *val))
550 list_elf_symbols(s, ctx, symbol_cb);
553 #ifndef ELF_OBJ_ONLY
554 static void
555 version_add (TCCState *s1)
557 int i;
558 ElfW(Sym) *sym;
559 ElfW(Verneed) *vn = NULL;
560 Section *symtab;
561 int sym_index, end_sym, nb_versions = 2, nb_entries = 0;
562 ElfW(Half) *versym;
563 const char *name;
565 if (0 == nb_sym_versions)
566 return;
567 versym_section = new_section(s1, ".gnu.version", SHT_GNU_versym, SHF_ALLOC);
568 versym_section->sh_entsize = sizeof(ElfW(Half));
569 versym_section->link = s1->dynsym;
571 /* add needed symbols */
572 symtab = s1->dynsym;
573 end_sym = symtab->data_offset / sizeof (ElfSym);
574 versym = section_ptr_add(versym_section, end_sym * sizeof(ElfW(Half)));
575 for (sym_index = 1; sym_index < end_sym; ++sym_index) {
576 int dllindex, verndx;
577 sym = &((ElfW(Sym) *)symtab->data)[sym_index];
578 if (sym->st_shndx != SHN_UNDEF)
579 continue; /* defined symbol doesn't need library version */
580 name = (char *) symtab->link->data + sym->st_name;
581 dllindex = find_elf_sym(s1->dynsymtab_section, name);
582 verndx = (dllindex && dllindex < nb_sym_to_version)
583 ? sym_to_version[dllindex] : -1;
584 if (verndx >= 0) {
585 if (!sym_versions[verndx].out_index)
586 sym_versions[verndx].out_index = nb_versions++;
587 versym[sym_index] = sym_versions[verndx].out_index;
590 /* generate verneed section, but not when it will be empty. Some
591 dynamic linkers look at their contents even when DTVERNEEDNUM and
592 section size is zero. */
593 if (nb_versions > 2) {
594 verneed_section = new_section(s1, ".gnu.version_r",
595 SHT_GNU_verneed, SHF_ALLOC);
596 verneed_section->link = s1->dynsym->link;
597 for (i = nb_sym_versions; i-- > 0;) {
598 struct sym_version *sv = &sym_versions[i];
599 int n_same_libs = 0, prev;
600 size_t vnofs;
601 ElfW(Vernaux) *vna = 0;
602 if (sv->out_index < 1)
603 continue;
605 /* make sure that a DT_NEEDED tag is put */
606 /* abitest-tcc fails on older i386-linux with "ld-linux.so.2" DT_NEEDED
607 ret_int_test... Inconsistency detected by ld.so: dl-minimal.c: 148:
608 realloc: Assertion `ptr == alloc_last_block' failed! */
609 if (strcmp(sv->lib, "ld-linux.so.2"))
610 tcc_add_dllref(s1, sv->lib, 0);
612 vnofs = section_add(verneed_section, sizeof(*vn), 1);
613 vn = (ElfW(Verneed)*)(verneed_section->data + vnofs);
614 vn->vn_version = 1;
615 vn->vn_file = put_elf_str(verneed_section->link, sv->lib);
616 vn->vn_aux = sizeof (*vn);
617 do {
618 prev = sv->prev_same_lib;
619 if (sv->out_index > 0) {
620 vna = section_ptr_add(verneed_section, sizeof(*vna));
621 vna->vna_hash = elf_hash ((const unsigned char *)sv->version);
622 vna->vna_flags = 0;
623 vna->vna_other = sv->out_index;
624 sv->out_index = -2;
625 vna->vna_name = put_elf_str(verneed_section->link, sv->version);
626 vna->vna_next = sizeof (*vna);
627 n_same_libs++;
629 if (prev >= 0)
630 sv = &sym_versions[prev];
631 } while(prev >= 0);
632 vna->vna_next = 0;
633 vn = (ElfW(Verneed)*)(verneed_section->data + vnofs);
634 vn->vn_cnt = n_same_libs;
635 vn->vn_next = sizeof(*vn) + n_same_libs * sizeof(*vna);
636 nb_entries++;
638 if (vn)
639 vn->vn_next = 0;
640 verneed_section->sh_info = nb_entries;
642 dt_verneednum = nb_entries;
644 #endif /* ndef ELF_OBJ_ONLY */
646 /* add an elf symbol : check if it is already defined and patch
647 it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
648 ST_FUNC int set_elf_sym(Section *s, addr_t value, unsigned long size,
649 int info, int other, int shndx, const char *name)
651 TCCState *s1 = s->s1;
652 ElfW(Sym) *esym;
653 int sym_bind, sym_index, sym_type, esym_bind;
654 unsigned char sym_vis, esym_vis, new_vis;
656 sym_bind = ELFW(ST_BIND)(info);
657 sym_type = ELFW(ST_TYPE)(info);
658 sym_vis = ELFW(ST_VISIBILITY)(other);
660 if (sym_bind != STB_LOCAL) {
661 /* we search global or weak symbols */
662 sym_index = find_elf_sym(s, name);
663 if (!sym_index)
664 goto do_def;
665 esym = &((ElfW(Sym) *)s->data)[sym_index];
666 if (esym->st_value == value && esym->st_size == size && esym->st_info == info
667 && esym->st_other == other && esym->st_shndx == shndx)
668 return sym_index;
669 if (esym->st_shndx != SHN_UNDEF) {
670 esym_bind = ELFW(ST_BIND)(esym->st_info);
671 /* propagate the most constraining visibility */
672 /* STV_DEFAULT(0)<STV_PROTECTED(3)<STV_HIDDEN(2)<STV_INTERNAL(1) */
673 esym_vis = ELFW(ST_VISIBILITY)(esym->st_other);
674 if (esym_vis == STV_DEFAULT) {
675 new_vis = sym_vis;
676 } else if (sym_vis == STV_DEFAULT) {
677 new_vis = esym_vis;
678 } else {
679 new_vis = (esym_vis < sym_vis) ? esym_vis : sym_vis;
681 esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
682 | new_vis;
683 if (shndx == SHN_UNDEF) {
684 /* ignore adding of undefined symbol if the
685 corresponding symbol is already defined */
686 } else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) {
687 /* global overrides weak, so patch */
688 goto do_patch;
689 } else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) {
690 /* weak is ignored if already global */
691 } else if (sym_bind == STB_WEAK && esym_bind == STB_WEAK) {
692 /* keep first-found weak definition, ignore subsequents */
693 } else if (sym_vis == STV_HIDDEN || sym_vis == STV_INTERNAL) {
694 /* ignore hidden symbols after */
695 } else if ((esym->st_shndx == SHN_COMMON
696 || esym->st_shndx == bss_section->sh_num)
697 && (shndx < SHN_LORESERVE
698 && shndx != bss_section->sh_num)) {
699 /* data symbol gets precedence over common/bss */
700 goto do_patch;
701 } else if (shndx == SHN_COMMON || shndx == bss_section->sh_num) {
702 /* data symbol keeps precedence over common/bss */
703 } else if (s->sh_flags & SHF_DYNSYM) {
704 /* we accept that two DLL define the same symbol */
705 } else if (esym->st_other & ST_ASM_SET) {
706 /* If the existing symbol came from an asm .set
707 we can override. */
708 goto do_patch;
709 } else {
710 #if 0
711 printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",
712 sym_bind, shndx, new_vis, esym_bind, esym->st_shndx, esym_vis);
713 #endif
714 tcc_error_noabort("'%s' defined twice", name);
716 } else {
717 esym->st_other = other;
718 do_patch:
719 esym->st_info = ELFW(ST_INFO)(sym_bind, sym_type);
720 esym->st_shndx = shndx;
721 s1->new_undef_sym = 1;
722 esym->st_value = value;
723 esym->st_size = size;
725 } else {
726 do_def:
727 sym_index = put_elf_sym(s, value, size,
728 ELFW(ST_INFO)(sym_bind, sym_type), other,
729 shndx, name);
731 return sym_index;
734 /* put relocation */
735 ST_FUNC void put_elf_reloca(Section *symtab, Section *s, unsigned long offset,
736 int type, int symbol, addr_t addend)
738 TCCState *s1 = s->s1;
739 char buf[256];
740 Section *sr;
741 ElfW_Rel *rel;
743 sr = s->reloc;
744 if (!sr) {
745 /* if no relocation section, create it */
746 snprintf(buf, sizeof(buf), REL_SECTION_FMT, s->name);
747 /* if the symtab is allocated, then we consider the relocation
748 are also */
749 sr = new_section(s->s1, buf, SHT_RELX, symtab->sh_flags);
750 sr->sh_entsize = sizeof(ElfW_Rel);
751 sr->link = symtab;
752 sr->sh_info = s->sh_num;
753 s->reloc = sr;
755 rel = section_ptr_add(sr, sizeof(ElfW_Rel));
756 rel->r_offset = offset;
757 rel->r_info = ELFW(R_INFO)(symbol, type);
758 #if SHT_RELX == SHT_RELA
759 rel->r_addend = addend;
760 #endif
761 if (SHT_RELX != SHT_RELA && addend)
762 tcc_error("non-zero addend on REL architecture");
765 ST_FUNC void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
766 int type, int symbol)
768 put_elf_reloca(symtab, s, offset, type, symbol, 0);
771 ST_FUNC struct sym_attr *get_sym_attr(TCCState *s1, int index, int alloc)
773 int n;
774 struct sym_attr *tab;
776 if (index >= s1->nb_sym_attrs) {
777 if (!alloc)
778 return s1->sym_attrs;
779 /* find immediately bigger power of 2 and reallocate array */
780 n = 1;
781 while (index >= n)
782 n *= 2;
783 tab = tcc_realloc(s1->sym_attrs, n * sizeof(*s1->sym_attrs));
784 s1->sym_attrs = tab;
785 memset(s1->sym_attrs + s1->nb_sym_attrs, 0,
786 (n - s1->nb_sym_attrs) * sizeof(*s1->sym_attrs));
787 s1->nb_sym_attrs = n;
789 return &s1->sym_attrs[index];
792 static void modify_reloctions_old_to_new(TCCState *s1, Section *s, int *old_to_new_syms)
794 int i, type, sym_index;
795 Section *sr;
796 ElfW_Rel *rel;
798 for(i = 1; i < s1->nb_sections; i++) {
799 sr = s1->sections[i];
800 if (sr->sh_type == SHT_RELX && sr->link == s) {
801 for_each_elem(sr, 0, rel, ElfW_Rel) {
802 sym_index = ELFW(R_SYM)(rel->r_info);
803 type = ELFW(R_TYPE)(rel->r_info);
804 sym_index = old_to_new_syms[sym_index];
805 rel->r_info = ELFW(R_INFO)(sym_index, type);
811 /* In an ELF file symbol table, the local symbols must appear below
812 the global and weak ones. Since TCC cannot sort it while generating
813 the code, we must do it after. All the relocation tables are also
814 modified to take into account the symbol table sorting */
815 static void sort_syms(TCCState *s1, Section *s)
817 int *old_to_new_syms;
818 ElfW(Sym) *new_syms;
819 int nb_syms, i;
820 ElfW(Sym) *p, *q;
822 nb_syms = s->data_offset / sizeof(ElfW(Sym));
823 new_syms = tcc_malloc(nb_syms * sizeof(ElfW(Sym)));
824 old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
826 /* first pass for local symbols */
827 p = (ElfW(Sym) *)s->data;
828 q = new_syms;
829 for(i = 0; i < nb_syms; i++) {
830 if (ELFW(ST_BIND)(p->st_info) == STB_LOCAL) {
831 old_to_new_syms[i] = q - new_syms;
832 *q++ = *p;
834 p++;
836 /* save the number of local symbols in section header */
837 if( s->sh_size ) /* this 'if' makes IDA happy */
838 s->sh_info = q - new_syms;
840 /* then second pass for non local symbols */
841 p = (ElfW(Sym) *)s->data;
842 for(i = 0; i < nb_syms; i++) {
843 if (ELFW(ST_BIND)(p->st_info) != STB_LOCAL) {
844 old_to_new_syms[i] = q - new_syms;
845 *q++ = *p;
847 p++;
850 /* we copy the new symbols to the old */
851 memcpy(s->data, new_syms, nb_syms * sizeof(ElfW(Sym)));
852 tcc_free(new_syms);
854 modify_reloctions_old_to_new(s1, s, old_to_new_syms);
856 tcc_free(old_to_new_syms);
859 #ifndef ELF_OBJ_ONLY
860 /* See: https://flapenguin.me/elf-dt-gnu-hash */
861 #define ELFCLASS_BITS (PTR_SIZE * 8)
863 static Section *create_gnu_hash(TCCState *s1)
865 int nb_syms, i, ndef, nbuckets, symoffset, bloom_size, bloom_shift;
866 ElfW(Sym) *p;
867 Section *gnu_hash;
868 Section *dynsym = s1->dynsym;
869 Elf32_Word *ptr;
871 gnu_hash = new_section(s1, ".gnu.hash", SHT_GNU_HASH, SHF_ALLOC);
872 gnu_hash->link = dynsym->hash->link;
874 nb_syms = dynsym->data_offset / sizeof(ElfW(Sym));
876 /* count def symbols */
877 ndef = 0;
878 p = (ElfW(Sym) *)dynsym->data;
879 for(i = 0; i < nb_syms; i++, p++)
880 ndef += p->st_shndx != SHN_UNDEF;
882 /* calculate gnu hash sizes and fill header */
883 nbuckets = ndef / 4 + 1;
884 symoffset = nb_syms - ndef;
885 bloom_shift = PTR_SIZE == 8 ? 6 : 5;
886 bloom_size = 1; /* must be power of two */
887 while (ndef >= bloom_size * (1 << (bloom_shift - 3)))
888 bloom_size *= 2;
889 ptr = section_ptr_add(gnu_hash, 4 * 4 +
890 PTR_SIZE * bloom_size +
891 nbuckets * 4 +
892 ndef * 4);
893 ptr[0] = nbuckets;
894 ptr[1] = symoffset;
895 ptr[2] = bloom_size;
896 ptr[3] = bloom_shift;
897 return gnu_hash;
900 static Elf32_Word elf_gnu_hash (const unsigned char *name)
902 Elf32_Word h = 5381;
903 unsigned char c;
905 while ((c = *name++))
906 h = h * 33 + c;
907 return h;
910 static void update_gnu_hash(TCCState *s1, Section *gnu_hash)
912 int *old_to_new_syms;
913 ElfW(Sym) *new_syms;
914 int nb_syms, i, nbuckets, bloom_size, bloom_shift;
915 ElfW(Sym) *p, *q;
916 Section *vs;
917 Section *dynsym = s1->dynsym;
918 Elf32_Word *ptr, *buckets, *chain, *hash;
919 unsigned int *nextbuck;
920 addr_t *bloom;
921 unsigned char *strtab;
922 struct { int first, last; } *buck;
924 strtab = dynsym->link->data;
925 nb_syms = dynsym->data_offset / sizeof(ElfW(Sym));
926 new_syms = tcc_malloc(nb_syms * sizeof(ElfW(Sym)));
927 old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
928 hash = tcc_malloc(nb_syms * sizeof(Elf32_Word));
929 nextbuck = tcc_malloc(nb_syms * sizeof(int));
931 /* calculate hashes and copy undefs */
932 p = (ElfW(Sym) *)dynsym->data;
933 q = new_syms;
934 for(i = 0; i < nb_syms; i++, p++) {
935 if (p->st_shndx == SHN_UNDEF) {
936 old_to_new_syms[i] = q - new_syms;
937 *q++ = *p;
939 else
940 hash[i] = elf_gnu_hash(strtab + p->st_name);
943 ptr = (Elf32_Word *) gnu_hash->data;
944 nbuckets = ptr[0];
945 bloom_size = ptr[2];
946 bloom_shift = ptr[3];
947 bloom = (addr_t *) (void *) &ptr[4];
948 buckets = (Elf32_Word*) (void *) &bloom[bloom_size];
949 chain = &buckets[nbuckets];
950 buck = tcc_malloc(nbuckets * sizeof(*buck));
952 if (gnu_hash->data_offset != 4 * 4 +
953 PTR_SIZE * bloom_size +
954 nbuckets * 4 +
955 (nb_syms - (q - new_syms)) * 4)
956 tcc_error ("gnu_hash size incorrect");
958 /* find buckets */
959 for(i = 0; i < nbuckets; i++)
960 buck[i].first = -1;
962 p = (ElfW(Sym) *)dynsym->data;
963 for(i = 0; i < nb_syms; i++, p++)
964 if (p->st_shndx != SHN_UNDEF) {
965 int bucket = hash[i] % nbuckets;
967 if (buck[bucket].first == -1)
968 buck[bucket].first = buck[bucket].last = i;
969 else {
970 nextbuck[buck[bucket].last] = i;
971 buck[bucket].last = i;
975 /* fill buckets/chains/bloom and sort symbols */
976 p = (ElfW(Sym) *)dynsym->data;
977 for(i = 0; i < nbuckets; i++) {
978 int cur = buck[i].first;
980 if (cur != -1) {
981 buckets[i] = q - new_syms;
982 for (;;) {
983 old_to_new_syms[cur] = q - new_syms;
984 *q++ = p[cur];
985 *chain++ = hash[cur] & ~1;
986 bloom[(hash[cur] / ELFCLASS_BITS) % bloom_size] |=
987 (addr_t)1 << (hash[cur] % ELFCLASS_BITS) |
988 (addr_t)1 << ((hash[cur] >> bloom_shift) % ELFCLASS_BITS);
989 if (cur == buck[i].last)
990 break;
991 cur = nextbuck[cur];
993 chain[-1] |= 1;
997 memcpy(dynsym->data, new_syms, nb_syms * sizeof(ElfW(Sym)));
998 tcc_free(new_syms);
999 tcc_free(hash);
1000 tcc_free(buck);
1001 tcc_free(nextbuck);
1003 modify_reloctions_old_to_new(s1, dynsym, old_to_new_syms);
1005 /* modify the versions */
1006 vs = versym_section;
1007 if (vs) {
1008 ElfW(Half) *newver, *versym = (ElfW(Half) *)vs->data;
1010 if (1/*versym*/) {
1011 newver = tcc_malloc(nb_syms * sizeof(*newver));
1012 for (i = 0; i < nb_syms; i++)
1013 newver[old_to_new_syms[i]] = versym[i];
1014 memcpy(vs->data, newver, nb_syms * sizeof(*newver));
1015 tcc_free(newver);
1019 tcc_free(old_to_new_syms);
1021 /* rebuild hash */
1022 ptr = (Elf32_Word *) dynsym->hash->data;
1023 rebuild_hash(dynsym, ptr[0]);
1025 #endif /* ELF_OBJ_ONLY */
1027 /* relocate symbol table, resolve undefined symbols if do_resolve is
1028 true and output error if undefined symbol. */
1029 ST_FUNC void relocate_syms(TCCState *s1, Section *symtab, int do_resolve)
1031 ElfW(Sym) *sym;
1032 int sym_bind, sh_num;
1033 const char *name;
1035 for_each_elem(symtab, 1, sym, ElfW(Sym)) {
1036 sh_num = sym->st_shndx;
1037 if (sh_num == SHN_UNDEF) {
1038 if (do_resolve == 2) /* relocating dynsym */
1039 continue;
1040 name = (char *) s1->symtab->link->data + sym->st_name;
1041 /* Use ld.so to resolve symbol for us (for tcc -run) */
1042 if (do_resolve) {
1043 #if defined TCC_IS_NATIVE && !defined TCC_TARGET_PE
1044 /* dlsym() needs the undecorated name. */
1045 void *addr = dlsym(RTLD_DEFAULT, &name[s1->leading_underscore]);
1046 #if TARGETOS_OpenBSD || TARGETOS_FreeBSD || TARGETOS_NetBSD || TARGETOS_ANDROID
1047 if (addr == NULL) {
1048 int i;
1049 for (i = 0; i < s1->nb_loaded_dlls; i++)
1050 if ((addr = dlsym(s1->loaded_dlls[i]->handle, name)))
1051 break;
1053 #endif
1054 if (addr) {
1055 sym->st_value = (addr_t) addr;
1056 #ifdef DEBUG_RELOC
1057 printf ("relocate_sym: %s -> 0x%lx\n", name, sym->st_value);
1058 #endif
1059 goto found;
1061 #endif
1062 /* if dynamic symbol exist, it will be used in relocate_section */
1063 } else if (s1->dynsym && find_elf_sym(s1->dynsym, name))
1064 goto found;
1065 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
1066 it */
1067 if (!strcmp(name, "_fp_hw"))
1068 goto found;
1069 /* only weak symbols are accepted to be undefined. Their
1070 value is zero */
1071 sym_bind = ELFW(ST_BIND)(sym->st_info);
1072 if (sym_bind == STB_WEAK)
1073 sym->st_value = 0;
1074 else
1075 tcc_error_noabort("undefined symbol '%s'", name);
1077 } else if (sh_num < SHN_LORESERVE) {
1078 /* add section base */
1079 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
1081 found: ;
1085 /* relocate a given section (CPU dependent) by applying the relocations
1086 in the associated relocation section */
1087 static void relocate_section(TCCState *s1, Section *s, Section *sr)
1089 ElfW_Rel *rel;
1090 ElfW(Sym) *sym;
1091 int type, sym_index;
1092 unsigned char *ptr;
1093 addr_t tgt, addr;
1094 int is_dwarf = s->sh_num >= s1->dwlo && s->sh_num < s1->dwhi;
1096 qrel = (ElfW_Rel *)sr->data;
1097 for_each_elem(sr, 0, rel, ElfW_Rel) {
1098 ptr = s->data + rel->r_offset;
1099 sym_index = ELFW(R_SYM)(rel->r_info);
1100 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1101 type = ELFW(R_TYPE)(rel->r_info);
1102 tgt = sym->st_value;
1103 #if SHT_RELX == SHT_RELA
1104 tgt += rel->r_addend;
1105 #endif
1106 if (is_dwarf && type == R_DATA_32DW
1107 && sym->st_shndx >= s1->dwlo && sym->st_shndx < s1->dwhi) {
1108 /* dwarf section relocation to each other */
1109 add32le(ptr, tgt - s1->sections[sym->st_shndx]->sh_addr);
1110 continue;
1112 addr = s->sh_addr + rel->r_offset;
1113 relocate(s1, rel, type, ptr, addr, tgt);
1115 #ifndef ELF_OBJ_ONLY
1116 /* if the relocation is allocated, we change its symbol table */
1117 if (sr->sh_flags & SHF_ALLOC) {
1118 sr->link = s1->dynsym;
1119 if (s1->output_type & TCC_OUTPUT_DYN) {
1120 size_t r = (uint8_t*)qrel - sr->data;
1121 if (sizeof ((Stab_Sym*)0)->n_value < PTR_SIZE
1122 && 0 == strcmp(s->name, ".stab"))
1123 r = 0; /* cannot apply 64bit relocation to 32bit value */
1124 sr->data_offset = sr->sh_size = r;
1125 #ifdef CONFIG_TCC_PIE
1126 if (r && 0 == (s->sh_flags & SHF_WRITE))
1127 tcc_warning("%d relocations to ro-section %s", (unsigned)(r / sizeof *qrel), s->name);
1128 #endif
1131 #endif
1134 /* relocate all sections */
1135 ST_FUNC void relocate_sections(TCCState *s1)
1137 int i;
1138 Section *s, *sr;
1140 for (i = 1; i < s1->nb_sections; ++i) {
1141 sr = s1->sections[i];
1142 if (sr->sh_type != SHT_RELX)
1143 continue;
1144 s = s1->sections[sr->sh_info];
1145 #ifndef TCC_TARGET_MACHO
1146 if (s != s1->got
1147 || s1->static_link
1148 || s1->output_type == TCC_OUTPUT_MEMORY)
1149 #endif
1151 relocate_section(s1, s, sr);
1153 #ifndef ELF_OBJ_ONLY
1154 if (sr->sh_flags & SHF_ALLOC) {
1155 ElfW_Rel *rel;
1156 /* relocate relocation table in 'sr' */
1157 for_each_elem(sr, 0, rel, ElfW_Rel)
1158 rel->r_offset += s->sh_addr;
1160 #endif
1164 #ifndef ELF_OBJ_ONLY
1165 /* count the number of dynamic relocations so that we can reserve
1166 their space */
1167 static int prepare_dynamic_rel(TCCState *s1, Section *sr)
1169 int count = 0;
1170 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64) || \
1171 defined(TCC_TARGET_ARM) || defined(TCC_TARGET_ARM64) || \
1172 defined(TCC_TARGET_RISCV64)
1173 ElfW_Rel *rel;
1174 for_each_elem(sr, 0, rel, ElfW_Rel) {
1175 int sym_index = ELFW(R_SYM)(rel->r_info);
1176 int type = ELFW(R_TYPE)(rel->r_info);
1177 switch(type) {
1178 #if defined(TCC_TARGET_I386)
1179 case R_386_32:
1180 if (!get_sym_attr(s1, sym_index, 0)->dyn_index
1181 && ((ElfW(Sym)*)symtab_section->data + sym_index)->st_shndx == SHN_UNDEF) {
1182 /* don't fixup unresolved (weak) symbols */
1183 rel->r_info = ELFW(R_INFO)(sym_index, R_386_RELATIVE);
1184 break;
1186 #elif defined(TCC_TARGET_X86_64)
1187 case R_X86_64_32:
1188 case R_X86_64_32S:
1189 case R_X86_64_64:
1190 #elif defined(TCC_TARGET_ARM)
1191 case R_ARM_ABS32:
1192 case R_ARM_TARGET1:
1193 #elif defined(TCC_TARGET_ARM64)
1194 case R_AARCH64_ABS32:
1195 case R_AARCH64_ABS64:
1196 #elif defined(TCC_TARGET_RISCV64)
1197 case R_RISCV_32:
1198 case R_RISCV_64:
1199 #endif
1200 count++;
1201 break;
1202 #if defined(TCC_TARGET_I386)
1203 case R_386_PC32:
1204 #elif defined(TCC_TARGET_X86_64)
1205 case R_X86_64_PC32:
1207 ElfW(Sym) *sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1208 /* Hidden defined symbols can and must be resolved locally.
1209 We're misusing a PLT32 reloc for this, as that's always
1210 resolved to its address even in shared libs. */
1211 if (sym->st_shndx != SHN_UNDEF &&
1212 ELFW(ST_VISIBILITY)(sym->st_other) == STV_HIDDEN) {
1213 rel->r_info = ELFW(R_INFO)(sym_index, R_X86_64_PLT32);
1214 break;
1217 #elif defined(TCC_TARGET_ARM64)
1218 case R_AARCH64_PREL32:
1219 #endif
1220 if (s1->output_type != TCC_OUTPUT_DLL)
1221 break;
1222 if (get_sym_attr(s1, sym_index, 0)->dyn_index)
1223 count++;
1224 break;
1225 default:
1226 break;
1229 #endif
1230 return count;
1232 #endif
1234 #ifdef NEED_BUILD_GOT
1235 static int build_got(TCCState *s1)
1237 /* if no got, then create it */
1238 s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
1239 s1->got->sh_entsize = 4;
1240 /* keep space for _DYNAMIC pointer and two dummy got entries */
1241 section_ptr_add(s1->got, 3 * PTR_SIZE);
1242 return set_elf_sym(symtab_section, 0, 0, ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
1243 0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
1246 /* Create a GOT and (for function call) a PLT entry corresponding to a symbol
1247 in s1->symtab. When creating the dynamic symbol table entry for the GOT
1248 relocation, use 'size' and 'info' for the corresponding symbol metadata.
1249 Returns the offset of the GOT or (if any) PLT entry. */
1250 static struct sym_attr * put_got_entry(TCCState *s1, int dyn_reloc_type,
1251 int sym_index)
1253 int need_plt_entry;
1254 const char *name;
1255 ElfW(Sym) *sym;
1256 struct sym_attr *attr;
1257 unsigned got_offset;
1258 char plt_name[200];
1259 int len;
1260 Section *s_rel;
1262 need_plt_entry = (dyn_reloc_type == R_JMP_SLOT);
1263 attr = get_sym_attr(s1, sym_index, 1);
1265 /* In case a function is both called and its address taken 2 GOT entries
1266 are created, one for taking the address (GOT) and the other for the PLT
1267 entry (PLTGOT). */
1268 if (need_plt_entry ? attr->plt_offset : attr->got_offset)
1269 return attr;
1271 s_rel = s1->got;
1272 if (need_plt_entry) {
1273 if (!s1->plt) {
1274 s1->plt = new_section(s1, ".plt", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
1275 s1->plt->sh_entsize = 4;
1277 s_rel = s1->plt;
1280 /* create the GOT entry */
1281 got_offset = s1->got->data_offset;
1282 section_ptr_add(s1->got, PTR_SIZE);
1284 /* Create the GOT relocation that will insert the address of the object or
1285 function of interest in the GOT entry. This is a static relocation for
1286 memory output (dlsym will give us the address of symbols) and dynamic
1287 relocation otherwise (executable and DLLs). The relocation should be
1288 done lazily for GOT entry with *_JUMP_SLOT relocation type (the one
1289 associated to a PLT entry) but is currently done at load time for an
1290 unknown reason. */
1292 sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
1293 name = (char *) symtab_section->link->data + sym->st_name;
1294 //printf("sym %d %s\n", need_plt_entry, name);
1296 if (s1->dynsym) {
1297 if (ELFW(ST_BIND)(sym->st_info) == STB_LOCAL) {
1298 /* Hack alarm. We don't want to emit dynamic symbols
1299 and symbol based relocs for STB_LOCAL symbols, but rather
1300 want to resolve them directly. At this point the symbol
1301 values aren't final yet, so we must defer this. We will later
1302 have to create a RELATIVE reloc anyway, so we misuse the
1303 relocation slot to smuggle the symbol reference until
1304 fill_local_got_entries. Not that the sym_index is
1305 relative to symtab_section, not s1->dynsym! Nevertheless
1306 we use s1->dyn_sym so that if this is the first call
1307 that got->reloc is correctly created. Also note that
1308 RELATIVE relocs are not normally created for the .got,
1309 so the types serves as a marker for later (and is retained
1310 also for the final output, which is okay because then the
1311 got is just normal data). */
1312 put_elf_reloc(s1->dynsym, s1->got, got_offset, R_RELATIVE,
1313 sym_index);
1314 } else {
1315 if (0 == attr->dyn_index)
1316 attr->dyn_index = set_elf_sym(s1->dynsym, sym->st_value,
1317 sym->st_size, sym->st_info, 0,
1318 sym->st_shndx, name);
1319 put_elf_reloc(s1->dynsym, s_rel, got_offset, dyn_reloc_type,
1320 attr->dyn_index);
1322 } else {
1323 put_elf_reloc(symtab_section, s1->got, got_offset, dyn_reloc_type,
1324 sym_index);
1327 if (need_plt_entry) {
1328 attr->plt_offset = create_plt_entry(s1, got_offset, attr);
1330 /* create a symbol 'sym@plt' for the PLT jump vector */
1331 len = strlen(name);
1332 if (len > sizeof plt_name - 5)
1333 len = sizeof plt_name - 5;
1334 memcpy(plt_name, name, len);
1335 strcpy(plt_name + len, "@plt");
1336 attr->plt_sym = put_elf_sym(s1->symtab, attr->plt_offset, 0,
1337 ELFW(ST_INFO)(STB_GLOBAL, STT_FUNC), 0, s1->plt->sh_num, plt_name);
1338 } else {
1339 attr->got_offset = got_offset;
1342 return attr;
1345 /* build GOT and PLT entries */
1346 /* Two passes because R_JMP_SLOT should become first. Some targets
1347 (arm, arm64) do not allow mixing R_JMP_SLOT and R_GLOB_DAT. */
1348 ST_FUNC void build_got_entries(TCCState *s1, int got_sym)
1350 Section *s;
1351 ElfW_Rel *rel;
1352 ElfW(Sym) *sym;
1353 int i, type, gotplt_entry, reloc_type, sym_index;
1354 struct sym_attr *attr;
1355 int pass = 0;
1356 redo:
1357 for(i = 1; i < s1->nb_sections; i++) {
1358 s = s1->sections[i];
1359 if (s->sh_type != SHT_RELX)
1360 continue;
1361 /* no need to handle got relocations */
1362 if (s->link != symtab_section)
1363 continue;
1364 for_each_elem(s, 0, rel, ElfW_Rel) {
1365 type = ELFW(R_TYPE)(rel->r_info);
1366 gotplt_entry = gotplt_entry_type(type);
1367 if (gotplt_entry == -1)
1368 tcc_error ("Unknown relocation type for got: %d", type);
1369 sym_index = ELFW(R_SYM)(rel->r_info);
1370 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1372 if (gotplt_entry == NO_GOTPLT_ENTRY) {
1373 continue;
1376 /* Automatically create PLT/GOT [entry] if it is an undefined
1377 reference (resolved at runtime), or the symbol is absolute,
1378 probably created by tcc_add_symbol, and thus on 64-bit
1379 targets might be too far from application code. */
1380 if (gotplt_entry == AUTO_GOTPLT_ENTRY) {
1381 if (sym->st_shndx == SHN_UNDEF) {
1382 ElfW(Sym) *esym;
1383 int dynindex;
1384 if (!PCRELATIVE_DLLPLT
1385 && (s1->output_type & TCC_OUTPUT_DYN))
1386 continue;
1387 /* Relocations for UNDEF symbols would normally need
1388 to be transferred into the executable or shared object.
1389 If that were done AUTO_GOTPLT_ENTRY wouldn't exist.
1390 But TCC doesn't do that (at least for exes), so we
1391 need to resolve all such relocs locally. And that
1392 means PLT slots for functions in DLLs and COPY relocs for
1393 data symbols. COPY relocs were generated in
1394 bind_exe_dynsyms (and the symbol adjusted to be defined),
1395 and for functions we were generated a dynamic symbol
1396 of function type. */
1397 if (s1->dynsym) {
1398 /* dynsym isn't set for -run :-/ */
1399 dynindex = get_sym_attr(s1, sym_index, 0)->dyn_index;
1400 esym = (ElfW(Sym) *)s1->dynsym->data + dynindex;
1401 if (dynindex
1402 && (ELFW(ST_TYPE)(esym->st_info) == STT_FUNC
1403 || (ELFW(ST_TYPE)(esym->st_info) == STT_NOTYPE
1404 && ELFW(ST_TYPE)(sym->st_info) == STT_FUNC)))
1405 goto jmp_slot;
1407 } else if (sym->st_shndx == SHN_ABS) {
1408 if (sym->st_value == 0) /* from tcc_add_btstub() */
1409 continue;
1410 #ifndef TCC_TARGET_ARM
1411 if (PTR_SIZE != 8)
1412 continue;
1413 #endif
1414 /* from tcc_add_symbol(): on 64 bit platforms these
1415 need to go through .got */
1416 } else
1417 continue;
1420 #ifdef TCC_TARGET_X86_64
1421 if ((type == R_X86_64_PLT32 || type == R_X86_64_PC32) &&
1422 sym->st_shndx != SHN_UNDEF &&
1423 (ELFW(ST_VISIBILITY)(sym->st_other) != STV_DEFAULT ||
1424 ELFW(ST_BIND)(sym->st_info) == STB_LOCAL ||
1425 s1->output_type & TCC_OUTPUT_EXE)) {
1426 if (pass != 0)
1427 continue;
1428 rel->r_info = ELFW(R_INFO)(sym_index, R_X86_64_PC32);
1429 continue;
1431 #endif
1432 reloc_type = code_reloc(type);
1433 if (reloc_type == -1)
1434 tcc_error ("Unknown relocation type: %d", type);
1436 if (reloc_type != 0) {
1437 jmp_slot:
1438 if (pass != 0)
1439 continue;
1440 reloc_type = R_JMP_SLOT;
1441 } else {
1442 if (pass != 1)
1443 continue;
1444 reloc_type = R_GLOB_DAT;
1447 if (!s1->got)
1448 got_sym = build_got(s1);
1450 if (gotplt_entry == BUILD_GOT_ONLY)
1451 continue;
1453 attr = put_got_entry(s1, reloc_type, sym_index);
1455 if (reloc_type == R_JMP_SLOT)
1456 rel->r_info = ELFW(R_INFO)(attr->plt_sym, type);
1459 if (++pass < 2)
1460 goto redo;
1461 /* .rel.plt refers to .got actually */
1462 if (s1->plt && s1->plt->reloc)
1463 s1->plt->reloc->sh_info = s1->got->sh_num;
1464 if (got_sym) /* set size */
1465 ((ElfW(Sym)*)symtab_section->data)[got_sym].st_size = s1->got->data_offset;
1467 #endif /* def NEED_BUILD_GOT */
1469 ST_FUNC int set_global_sym(TCCState *s1, const char *name, Section *sec, addr_t offs)
1471 int shn = sec ? sec->sh_num : offs || !name ? SHN_ABS : SHN_UNDEF;
1472 if (sec && offs == -1)
1473 offs = sec->data_offset;
1474 return set_elf_sym(symtab_section, offs, 0,
1475 ELFW(ST_INFO)(name ? STB_GLOBAL : STB_LOCAL, STT_NOTYPE), 0, shn, name);
1478 static void add_init_array_defines(TCCState *s1, const char *section_name)
1480 Section *s;
1481 addr_t end_offset;
1482 char buf[1024];
1483 s = have_section(s1, section_name);
1484 if (!s || !(s->sh_flags & SHF_ALLOC)) {
1485 end_offset = 0;
1486 s = data_section;
1487 } else {
1488 end_offset = s->data_offset;
1490 snprintf(buf, sizeof(buf), "__%s_start", section_name + 1);
1491 set_global_sym(s1, buf, s, 0);
1492 snprintf(buf, sizeof(buf), "__%s_end", section_name + 1);
1493 set_global_sym(s1, buf, s, end_offset);
1496 ST_FUNC void add_array (TCCState *s1, const char *sec, int c)
1498 Section *s;
1499 s = find_section(s1, sec);
1500 s->sh_flags = shf_RELRO;
1501 s->sh_type = sec[1] == 'i' ? SHT_INIT_ARRAY : SHT_FINI_ARRAY;
1502 put_elf_reloc (s1->symtab, s, s->data_offset, R_DATA_PTR, c);
1503 section_ptr_add(s, PTR_SIZE);
1506 #ifdef CONFIG_TCC_BCHECK
1507 ST_FUNC void tcc_add_bcheck(TCCState *s1)
1509 if (0 == s1->do_bounds_check)
1510 return;
1511 section_ptr_add(bounds_section, sizeof(addr_t));
1513 #endif
1515 /* set symbol to STB_LOCAL and resolve. The point is to not export it as
1516 a dynamic symbol to allow so's to have one each with a different value. */
1517 static void set_local_sym(TCCState *s1, const char *name, Section *s, int offset)
1519 int c = find_elf_sym(s1->symtab, name);
1520 if (c) {
1521 ElfW(Sym) *esym = (ElfW(Sym)*)s1->symtab->data + c;
1522 esym->st_info = ELFW(ST_INFO)(STB_LOCAL, STT_NOTYPE);
1523 esym->st_value = offset;
1524 esym->st_shndx = s->sh_num;
1528 /* avoid generating debug/test_coverage code for stub functions */
1529 static void tcc_compile_string_no_debug(TCCState *s, const char *str)
1531 int save_do_debug = s->do_debug;
1532 int save_test_coverage = s->test_coverage;
1534 s->do_debug = 0;
1535 s->test_coverage = 0;
1536 tcc_compile_string(s, str);
1537 s->do_debug = save_do_debug;
1538 s->test_coverage = save_test_coverage;
1541 #ifdef CONFIG_TCC_BACKTRACE
1542 static void put_ptr(TCCState *s1, Section *s, int offs)
1544 int c;
1545 c = set_global_sym(s1, NULL, s, offs);
1546 s = data_section;
1547 put_elf_reloc (s1->symtab, s, s->data_offset, R_DATA_PTR, c);
1548 section_ptr_add(s, PTR_SIZE);
1551 ST_FUNC void tcc_add_btstub(TCCState *s1)
1553 Section *s;
1554 int n, o;
1555 CString cstr;
1557 s = data_section;
1558 /* Align to PTR_SIZE */
1559 section_ptr_add(s, -s->data_offset & (PTR_SIZE - 1));
1560 o = s->data_offset;
1561 /* create (part of) a struct rt_context (see tccrun.c) */
1562 if (s1->dwarf) {
1563 put_ptr(s1, dwarf_line_section, 0);
1564 put_ptr(s1, dwarf_line_section, -1);
1565 if (s1->dwarf >= 5)
1566 put_ptr(s1, dwarf_line_str_section, 0);
1567 else
1568 put_ptr(s1, dwarf_str_section, 0);
1570 else
1572 put_ptr(s1, stab_section, 0);
1573 put_ptr(s1, stab_section, -1);
1574 put_ptr(s1, stab_section->link, 0);
1576 *(addr_t *)section_ptr_add(s, PTR_SIZE) = s1->dwarf;
1577 /* skip esym_start/esym_end/elf_str (not loaded) */
1578 section_ptr_add(s, 3 * PTR_SIZE);
1579 /* prog_base : local nameless symbol with offset 0 at SHN_ABS */
1580 put_ptr(s1, NULL, 0);
1581 #if defined TCC_TARGET_MACHO
1582 /* adjust for __PAGEZERO */
1583 if (s1->dwarf == 0 && s1->output_type == TCC_OUTPUT_EXE)
1584 write64le(data_section->data + data_section->data_offset - PTR_SIZE,
1585 (uint64_t)1 << 32);
1586 #endif
1587 n = 2 * PTR_SIZE;
1588 #ifdef CONFIG_TCC_BCHECK
1589 if (s1->do_bounds_check) {
1590 put_ptr(s1, bounds_section, 0);
1591 n -= PTR_SIZE;
1593 #endif
1594 section_ptr_add(s, n);
1595 cstr_new(&cstr);
1596 cstr_printf(&cstr,
1597 "extern void __bt_init(),__bt_exit(),__bt_init_dll();"
1598 "static void *__rt_info[];"
1599 "__attribute__((constructor)) static void __bt_init_rt(){");
1600 #ifdef TCC_TARGET_PE
1601 if (s1->output_type == TCC_OUTPUT_DLL)
1602 #ifdef CONFIG_TCC_BCHECK
1603 cstr_printf(&cstr, "__bt_init_dll(%d);", s1->do_bounds_check);
1604 #else
1605 cstr_printf(&cstr, "__bt_init_dll(0);");
1606 #endif
1607 #endif
1608 cstr_printf(&cstr, "__bt_init(__rt_info,%d);}",
1609 s1->output_type == TCC_OUTPUT_DLL ? 0 : s1->rt_num_callers + 1);
1610 /* In case dlcose is called by application */
1611 cstr_printf(&cstr,
1612 "__attribute__((destructor)) static void __bt_exit_rt(){"
1613 "__bt_exit(__rt_info);}");
1614 tcc_compile_string_no_debug(s1, cstr.data);
1615 cstr_free(&cstr);
1616 set_local_sym(s1, &"___rt_info"[!s1->leading_underscore], s, o);
1618 #endif /* def CONFIG_TCC_BACKTRACE */
1620 static void tcc_tcov_add_file(TCCState *s1, const char *filename)
1622 CString cstr;
1623 void *ptr;
1624 char wd[1024];
1626 if (tcov_section == NULL)
1627 return;
1628 section_ptr_add(tcov_section, 1);
1629 write32le (tcov_section->data, tcov_section->data_offset);
1631 cstr_new (&cstr);
1632 if (filename[0] == '/')
1633 cstr_printf (&cstr, "%s.tcov", filename);
1634 else {
1635 getcwd (wd, sizeof(wd));
1636 cstr_printf (&cstr, "%s/%s.tcov", wd, filename);
1638 ptr = section_ptr_add(tcov_section, cstr.size + 1);
1639 strcpy((char *)ptr, cstr.data);
1640 unlink((char *)ptr);
1641 #ifdef _WIN32
1642 normalize_slashes((char *)ptr);
1643 #endif
1644 cstr_free (&cstr);
1646 cstr_new(&cstr);
1647 cstr_printf(&cstr,
1648 "extern char *__tcov_data[];"
1649 "extern void __store_test_coverage ();"
1650 "__attribute__((destructor)) static void __tcov_exit() {"
1651 "__store_test_coverage(__tcov_data);"
1652 "}");
1653 tcc_compile_string_no_debug(s1, cstr.data);
1654 cstr_free(&cstr);
1655 set_local_sym(s1, &"___tcov_data"[!s1->leading_underscore], tcov_section, 0);
1658 #ifndef TCC_TARGET_PE
1659 /* add tcc runtime libraries */
1660 ST_FUNC void tcc_add_runtime(TCCState *s1)
1662 s1->filetype = 0;
1664 #ifdef CONFIG_TCC_BCHECK
1665 tcc_add_bcheck(s1);
1666 #endif
1667 tcc_add_pragma_libs(s1);
1669 /* add libc */
1670 if (!s1->nostdlib) {
1671 int lpthread = s1->option_pthread;
1673 #ifdef CONFIG_TCC_BCHECK
1674 if (s1->do_bounds_check && s1->output_type != TCC_OUTPUT_DLL) {
1675 tcc_add_support(s1, "bcheck.o");
1676 # if !(TARGETOS_OpenBSD || TARGETOS_NetBSD)
1677 tcc_add_library_err(s1, "dl");
1678 # endif
1679 lpthread = 1;
1681 #endif
1682 #ifdef CONFIG_TCC_BACKTRACE
1683 if (s1->do_backtrace) {
1684 if (s1->output_type & TCC_OUTPUT_EXE)
1685 tcc_add_support(s1, "bt-exe.o");
1686 if (s1->output_type != TCC_OUTPUT_DLL)
1687 tcc_add_support(s1, "bt-log.o");
1688 if (s1->output_type != TCC_OUTPUT_MEMORY)
1689 tcc_add_btstub(s1);
1691 #endif
1692 if (lpthread)
1693 tcc_add_library_err(s1, "pthread");
1694 tcc_add_library_err(s1, "c");
1695 #ifdef TCC_LIBGCC
1696 if (!s1->static_link) {
1697 if (TCC_LIBGCC[0] == '/')
1698 tcc_add_file(s1, TCC_LIBGCC);
1699 else
1700 tcc_add_dll(s1, TCC_LIBGCC, 0);
1702 #endif
1703 #if defined TCC_TARGET_ARM && TARGETOS_FreeBSD
1704 tcc_add_library_err(s1, "gcc_s"); // unwind code
1705 #endif
1706 if (TCC_LIBTCC1[0])
1707 tcc_add_support(s1, TCC_LIBTCC1);
1709 /* add crt end if not memory output */
1710 if (s1->output_type != TCC_OUTPUT_MEMORY) {
1711 #if defined TCC_TARGET_MACHO
1712 /* nothing to do */
1713 #elif TARGETOS_FreeBSD || TARGETOS_NetBSD
1714 if (s1->output_type & TCC_OUTPUT_DYN)
1715 tcc_add_crt(s1, "crtendS.o");
1716 else
1717 tcc_add_crt(s1, "crtend.o");
1718 tcc_add_crt(s1, "crtn.o");
1719 #elif TARGETOS_OpenBSD
1720 if (s1->output_type == TCC_OUTPUT_DLL)
1721 tcc_add_crt(s1, "crtendS.o");
1722 else
1723 tcc_add_crt(s1, "crtend.o");
1724 #elif TARGETOS_ANDROID
1725 if (s1->output_type == TCC_OUTPUT_DLL)
1726 tcc_add_crt(s1, "crtend_so.o");
1727 else
1728 tcc_add_crt(s1, "crtend_android.o");
1729 #else
1730 tcc_add_crt(s1, "crtn.o");
1731 #endif
1735 #endif /* ndef TCC_TARGET_PE */
1737 /* add various standard linker symbols (must be done after the
1738 sections are filled (for example after allocating common
1739 symbols)) */
1740 static void tcc_add_linker_symbols(TCCState *s1)
1742 char buf[1024];
1743 int i;
1744 Section *s;
1746 set_global_sym(s1, "_etext", text_section, -1);
1747 set_global_sym(s1, "_edata", data_section, -1);
1748 set_global_sym(s1, "_end", bss_section, -1);
1749 #if TARGETOS_OpenBSD
1750 set_global_sym(s1, "__executable_start", NULL, ELF_START_ADDR);
1751 #endif
1752 #ifdef TCC_TARGET_RISCV64
1753 /* XXX should be .sdata+0x800, not .data+0x800 */
1754 set_global_sym(s1, "__global_pointer$", data_section, 0x800);
1755 #endif
1756 /* horrible new standard ldscript defines */
1757 add_init_array_defines(s1, ".preinit_array");
1758 add_init_array_defines(s1, ".init_array");
1759 add_init_array_defines(s1, ".fini_array");
1760 /* add start and stop symbols for sections whose name can be
1761 expressed in C */
1762 for(i = 1; i < s1->nb_sections; i++) {
1763 s = s1->sections[i];
1764 if ((s->sh_flags & SHF_ALLOC)
1765 && (s->sh_type == SHT_PROGBITS
1766 || s->sh_type == SHT_STRTAB)) {
1767 const char *p;
1768 /* check if section name can be expressed in C */
1769 p = s->name;
1770 for(;;) {
1771 int c = *p;
1772 if (!c)
1773 break;
1774 if (!isid(c) && !isnum(c))
1775 goto next_sec;
1776 p++;
1778 snprintf(buf, sizeof(buf), "__start_%s", s->name);
1779 set_global_sym(s1, buf, s, 0);
1780 snprintf(buf, sizeof(buf), "__stop_%s", s->name);
1781 set_global_sym(s1, buf, s, -1);
1783 next_sec: ;
1787 ST_FUNC void resolve_common_syms(TCCState *s1)
1789 ElfW(Sym) *sym;
1791 /* Allocate common symbols in BSS. */
1792 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1793 if (sym->st_shndx == SHN_COMMON) {
1794 /* symbol alignment is in st_value for SHN_COMMONs */
1795 sym->st_value = section_add(bss_section, sym->st_size,
1796 sym->st_value);
1797 sym->st_shndx = bss_section->sh_num;
1801 /* Now assign linker provided symbols their value. */
1802 tcc_add_linker_symbols(s1);
1805 #ifndef ELF_OBJ_ONLY
1806 ST_FUNC void fill_got_entry(TCCState *s1, ElfW_Rel *rel)
1808 int sym_index = ELFW(R_SYM) (rel->r_info);
1809 ElfW(Sym) *sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
1810 struct sym_attr *attr = get_sym_attr(s1, sym_index, 0);
1811 unsigned offset = attr->got_offset;
1813 if (0 == offset)
1814 return;
1815 section_reserve(s1->got, offset + PTR_SIZE);
1816 #if PTR_SIZE == 8
1817 write64le(s1->got->data + offset, sym->st_value);
1818 #else
1819 write32le(s1->got->data + offset, sym->st_value);
1820 #endif
1823 /* Perform relocation to GOT or PLT entries */
1824 ST_FUNC void fill_got(TCCState *s1)
1826 Section *s;
1827 ElfW_Rel *rel;
1828 int i;
1830 for(i = 1; i < s1->nb_sections; i++) {
1831 s = s1->sections[i];
1832 if (s->sh_type != SHT_RELX)
1833 continue;
1834 /* no need to handle got relocations */
1835 if (s->link != symtab_section)
1836 continue;
1837 for_each_elem(s, 0, rel, ElfW_Rel) {
1838 switch (ELFW(R_TYPE) (rel->r_info)) {
1839 case R_X86_64_GOT32:
1840 case R_X86_64_GOTPCREL:
1841 case R_X86_64_GOTPCRELX:
1842 case R_X86_64_REX_GOTPCRELX:
1843 case R_X86_64_PLT32:
1844 fill_got_entry(s1, rel);
1845 break;
1851 /* See put_got_entry for a description. This is the second stage
1852 where GOT references to local defined symbols are rewritten. */
1853 static void fill_local_got_entries(TCCState *s1)
1855 ElfW_Rel *rel;
1856 if (!s1->got->reloc)
1857 return;
1858 for_each_elem(s1->got->reloc, 0, rel, ElfW_Rel) {
1859 if (ELFW(R_TYPE)(rel->r_info) == R_RELATIVE) {
1860 int sym_index = ELFW(R_SYM) (rel->r_info);
1861 ElfW(Sym) *sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
1862 struct sym_attr *attr = get_sym_attr(s1, sym_index, 0);
1863 unsigned offset = attr->got_offset;
1864 if (offset != rel->r_offset - s1->got->sh_addr)
1865 tcc_error_noabort("huh");
1866 rel->r_info = ELFW(R_INFO)(0, R_RELATIVE);
1867 #if SHT_RELX == SHT_RELA
1868 rel->r_addend = sym->st_value;
1869 #else
1870 /* All our REL architectures also happen to be 32bit LE. */
1871 write32le(s1->got->data + offset, sym->st_value);
1872 #endif
1877 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1878 in shared libraries */
1879 static void bind_exe_dynsyms(TCCState *s1)
1881 const char *name;
1882 int sym_index, index;
1883 ElfW(Sym) *sym, *esym;
1884 int type;
1886 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1887 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1888 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1889 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1890 if (sym->st_shndx == SHN_UNDEF) {
1891 name = (char *) symtab_section->link->data + sym->st_name;
1892 sym_index = find_elf_sym(s1->dynsymtab_section, name);
1893 if (sym_index) {
1894 esym = &((ElfW(Sym) *)s1->dynsymtab_section->data)[sym_index];
1895 type = ELFW(ST_TYPE)(esym->st_info);
1896 if ((type == STT_FUNC) || (type == STT_GNU_IFUNC)) {
1897 /* Indirect functions shall have STT_FUNC type in executable
1898 * dynsym section. Indeed, a dlsym call following a lazy
1899 * resolution would pick the symbol value from the
1900 * executable dynsym entry which would contain the address
1901 * of the function wanted by the caller of dlsym instead of
1902 * the address of the function that would return that
1903 * address */
1904 int dynindex
1905 = put_elf_sym(s1->dynsym, 0, esym->st_size,
1906 ELFW(ST_INFO)(STB_GLOBAL,STT_FUNC), 0, 0,
1907 name);
1908 int index = sym - (ElfW(Sym) *) symtab_section->data;
1909 get_sym_attr(s1, index, 1)->dyn_index = dynindex;
1910 } else if (type == STT_OBJECT) {
1911 unsigned long offset;
1912 ElfW(Sym) *dynsym;
1913 offset = bss_section->data_offset;
1914 /* XXX: which alignment ? */
1915 offset = (offset + 16 - 1) & -16;
1916 set_elf_sym (s1->symtab, offset, esym->st_size,
1917 esym->st_info, 0, bss_section->sh_num, name);
1918 index = put_elf_sym(s1->dynsym, offset, esym->st_size,
1919 esym->st_info, 0, bss_section->sh_num,
1920 name);
1922 /* Ensure R_COPY works for weak symbol aliases */
1923 if (ELFW(ST_BIND)(esym->st_info) == STB_WEAK) {
1924 for_each_elem(s1->dynsymtab_section, 1, dynsym, ElfW(Sym)) {
1925 if ((dynsym->st_value == esym->st_value)
1926 && (ELFW(ST_BIND)(dynsym->st_info) == STB_GLOBAL)) {
1927 char *dynname = (char *) s1->dynsymtab_section->link->data
1928 + dynsym->st_name;
1929 put_elf_sym(s1->dynsym, offset, dynsym->st_size,
1930 dynsym->st_info, 0,
1931 bss_section->sh_num, dynname);
1932 break;
1937 put_elf_reloc(s1->dynsym, bss_section,
1938 offset, R_COPY, index);
1939 offset += esym->st_size;
1940 bss_section->data_offset = offset;
1942 } else {
1943 /* STB_WEAK undefined symbols are accepted */
1944 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1945 if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK ||
1946 !strcmp(name, "_fp_hw")) {
1947 } else {
1948 tcc_error_noabort("undefined symbol '%s'", name);
1955 /* Bind symbols of libraries: export all non local symbols of executable that
1956 are referenced by shared libraries. The reason is that the dynamic loader
1957 search symbol first in executable and then in libraries. Therefore a
1958 reference to a symbol already defined by a library can still be resolved by
1959 a symbol in the executable. With -rdynamic, export all defined symbols */
1960 static void bind_libs_dynsyms(TCCState *s1)
1962 const char *name;
1963 int dynsym_index;
1964 ElfW(Sym) *sym, *esym;
1966 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1967 name = (char *)symtab_section->link->data + sym->st_name;
1968 dynsym_index = find_elf_sym(s1->dynsymtab_section, name);
1969 if (sym->st_shndx != SHN_UNDEF
1970 && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1971 if (dynsym_index || s1->rdynamic)
1972 set_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1973 sym->st_info, 0, sym->st_shndx, name);
1974 } else if (dynsym_index) {
1975 esym = (ElfW(Sym) *)s1->dynsymtab_section->data + dynsym_index;
1976 if (esym->st_shndx == SHN_UNDEF) {
1977 /* weak symbols can stay undefined */
1978 if (ELFW(ST_BIND)(esym->st_info) != STB_WEAK)
1979 tcc_warning("undefined dynamic symbol '%s'", name);
1985 /* Export all non local symbols. This is used by shared libraries so that the
1986 non local symbols they define can resolve a reference in another shared
1987 library or in the executable. Correspondingly, it allows undefined local
1988 symbols to be resolved by other shared libraries or by the executable. */
1989 static void export_global_syms(TCCState *s1)
1991 int dynindex, index;
1992 const char *name;
1993 ElfW(Sym) *sym;
1994 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1995 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1996 name = (char *) symtab_section->link->data + sym->st_name;
1997 dynindex = set_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1998 sym->st_info, 0, sym->st_shndx, name);
1999 index = sym - (ElfW(Sym) *) symtab_section->data;
2000 get_sym_attr(s1, index, 1)->dyn_index = dynindex;
2005 /* decide if an unallocated section should be output. */
2006 static int set_sec_sizes(TCCState *s1)
2008 int i;
2009 Section *s;
2010 int textrel = 0;
2011 int file_type = s1->output_type;
2013 /* Allocate strings for section names */
2014 for(i = 1; i < s1->nb_sections; i++) {
2015 s = s1->sections[i];
2016 if (s->sh_type == SHT_RELX && !(s->sh_flags & SHF_ALLOC)) {
2017 /* when generating a DLL, we include relocations but
2018 we may patch them */
2019 if ((file_type & TCC_OUTPUT_DYN)
2020 && (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC)) {
2021 int count = prepare_dynamic_rel(s1, s);
2022 if (count) {
2023 /* allocate the section */
2024 s->sh_flags |= SHF_ALLOC;
2025 s->sh_size = count * sizeof(ElfW_Rel);
2026 if (!(s1->sections[s->sh_info]->sh_flags & SHF_WRITE))
2027 textrel += count;
2030 } else if ((s->sh_flags & SHF_ALLOC)
2031 #ifdef TCC_TARGET_ARM
2032 || s->sh_type == SHT_ARM_ATTRIBUTES
2033 #endif
2034 || s1->do_debug) {
2035 s->sh_size = s->data_offset;
2038 #ifdef TCC_TARGET_ARM
2039 /* XXX: Suppress stack unwinding section. */
2040 if (s->sh_type == SHT_ARM_EXIDX) {
2041 s->sh_flags = 0;
2042 s->sh_size = 0;
2044 #endif
2047 return textrel;
2050 /* various data used under elf_output_file() */
2051 struct dyn_inf {
2052 Section *dynamic;
2053 Section *dynstr;
2054 struct {
2055 /* Info to be copied in dynamic section */
2056 unsigned long data_offset;
2057 addr_t rel_addr;
2058 addr_t rel_size;
2061 ElfW(Phdr) *phdr;
2062 int phnum;
2063 Section *interp;
2064 Section *note;
2065 Section *gnu_hash;
2067 /* read only segment mapping for GNU_RELRO */
2068 Section _roinf, *roinf;
2071 /* Decide the layout of sections loaded in memory. This must be done before
2072 program headers are filled since they contain info about the layout.
2073 We do the following ordering: interp, symbol tables, relocations, progbits,
2074 nobits */
2075 static int sort_sections(TCCState *s1, int *sec_order, Section *interp)
2077 Section *s;
2078 int i, j, k, f, f0, n;
2079 int nb_sections = s1->nb_sections;
2080 int *sec_cls = sec_order + nb_sections;
2082 for (i = 1; i < nb_sections; i++) {
2083 s = s1->sections[i];
2084 if (s->sh_flags & SHF_ALLOC) {
2085 j = 0x100;
2086 if (s->sh_flags & SHF_WRITE)
2087 j = 0x200;
2088 if (s->sh_flags & SHF_TLS)
2089 j += 0x200;
2090 } else if (s->sh_name) {
2091 j = 0x700;
2092 } else {
2093 j = 0x900; /* no sh_name: won't go to file */
2095 if (s->sh_type == SHT_SYMTAB || s->sh_type == SHT_DYNSYM) {
2096 k = 0x10;
2097 } else if (s->sh_type == SHT_STRTAB && strcmp(s->name, ".stabstr")) {
2098 k = 0x11;
2099 if (i == nb_sections - 1) /* ".shstrtab" assumed to remain last */
2100 k = 0xff;
2101 } else if (s->sh_type == SHT_HASH || s->sh_type == SHT_GNU_HASH) {
2102 k = 0x12;
2103 } else if (s->sh_type == SHT_RELX) {
2104 k = 0x20;
2105 if (s1->plt && s == s1->plt->reloc)
2106 k = 0x21;
2107 } else if (s->sh_type == SHT_PREINIT_ARRAY) {
2108 k = 0x41;
2109 } else if (s->sh_type == SHT_INIT_ARRAY) {
2110 k = 0x42;
2111 } else if (s->sh_type == SHT_FINI_ARRAY) {
2112 k = 0x43;
2113 #ifdef CONFIG_TCC_BCHECK
2114 } else if (s == bounds_section || s == lbounds_section) {
2115 k = 0x44;
2116 #endif
2117 } else if (s == rodata_section || 0 == strcmp(s->name, ".data.rel.ro")) {
2118 k = 0x45;
2119 } else if (s->sh_type == SHT_DYNAMIC) {
2120 k = 0x46;
2121 } else if (s == s1->got) {
2122 k = 0x47; /* .got as RELRO needs BIND_NOW in DT_FLAGS */
2123 } else {
2124 k = 0x50;
2125 if (s->sh_type == SHT_NOTE)
2126 k = 0x60;
2127 if (s->sh_flags & SHF_EXECINSTR)
2128 k = 0x70;
2129 if (s->sh_type == SHT_NOBITS)
2130 k = 0x80;
2131 if (s == interp)
2132 k = 0x00;
2134 k += j;
2136 for (n = i; n > 1 && k < (f = sec_cls[n - 1]); --n)
2137 sec_cls[n] = f, sec_order[n] = sec_order[n - 1];
2138 sec_cls[n] = k, sec_order[n] = i;
2140 sec_order[0] = 0;
2142 /* count PT_LOAD headers needed */
2143 n = f0 = 0;
2144 for (i = 1; i < nb_sections; i++) {
2145 s = s1->sections[sec_order[i]];
2146 k = sec_cls[i];
2147 f = 0;
2148 if (k < 0x700) {
2149 f = s->sh_flags & (SHF_ALLOC|SHF_WRITE|SHF_EXECINSTR|SHF_TLS);
2150 #if TARGETOS_NetBSD
2151 /* NetBSD only supports 2 PT_LOAD sections.
2152 See: https://blog.netbsd.org/tnf/entry/the_first_report_on_lld */
2153 if ((f & SHF_WRITE) == 0) f |= SHF_EXECINSTR;
2154 #else
2155 if ((k & 0xfff0) == 0x240) /* RELRO sections */
2156 f |= 1<<4;
2157 #endif
2158 if (f != f0) /* start new header when flags changed or relro */
2159 f0 = f, ++n, f |= 1<<8;
2161 sec_cls[i] = f;
2162 //printf("ph %d sec %02d : %3X %3X %8.2X %04X %s\n", !!f * n, i, f, k, s->sh_type, s->sh_size, s->name);
2164 return n;
2167 static ElfW(Phdr) *fill_phdr(ElfW(Phdr) *ph, int type, Section *s)
2169 if (s) {
2170 ph->p_offset = s->sh_offset;
2171 ph->p_vaddr = s->sh_addr;
2172 ph->p_filesz = s->sh_size;
2173 ph->p_align = s->sh_addralign;
2175 ph->p_type = type;
2176 ph->p_flags = PF_R;
2177 ph->p_paddr = ph->p_vaddr;
2178 ph->p_memsz = ph->p_filesz;
2179 return ph;
2182 /* Assign sections to segments and decide how are sections laid out when loaded
2183 in memory. This function also fills corresponding program headers. */
2184 static int layout_sections(TCCState *s1, int *sec_order, struct dyn_inf *d)
2186 Section *s;
2187 addr_t addr, tmp, align, s_align, base;
2188 ElfW(Phdr) *ph = NULL;
2189 int i, f, n, phnum, phfill;
2190 int file_offset;
2192 /* compute number of program headers */
2193 phnum = sort_sections(s1, sec_order, d->interp);
2194 phfill = 0; /* set to 1 to have dll's with a PT_PHDR */
2195 if (d->interp)
2196 phfill = 2;
2197 phnum += phfill;
2198 if (d->note)
2199 ++phnum;
2200 if (d->dynamic)
2201 ++phnum;
2202 if (d->roinf)
2203 ++phnum;
2204 d->phnum = phnum;
2205 d->phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
2207 file_offset = 0;
2208 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
2209 file_offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
2211 s_align = ELF_PAGE_SIZE;
2212 if (s1->section_align)
2213 s_align = s1->section_align;
2215 addr = ELF_START_ADDR;
2216 if (s1->output_type & TCC_OUTPUT_DYN)
2217 addr = 0;
2219 if (s1->has_text_addr) {
2220 addr = s1->text_addr;
2221 if (0) {
2222 int a_offset, p_offset;
2223 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
2224 ELF_PAGE_SIZE */
2225 a_offset = (int) (addr & (s_align - 1));
2226 p_offset = file_offset & (s_align - 1);
2227 if (a_offset < p_offset)
2228 a_offset += s_align;
2229 file_offset += (a_offset - p_offset);
2232 base = addr;
2233 /* compute address after headers */
2234 addr = addr + (file_offset & (s_align - 1));
2236 n = 0;
2237 for(i = 1; i < s1->nb_sections; i++) {
2238 s = s1->sections[sec_order[i]];
2239 f = sec_order[i + s1->nb_sections];
2240 align = s->sh_addralign - 1;
2242 if (f == 0) { /* no alloc */
2243 file_offset = (file_offset + align) & ~align;
2244 s->sh_offset = file_offset;
2245 if (s->sh_type != SHT_NOBITS)
2246 file_offset += s->sh_size;
2247 continue;
2250 if ((f & 1<<8) && n) {
2251 /* different rwx section flags */
2252 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
2253 /* if in the middle of a page, w e duplicate the page in
2254 memory so that one copy is RX and the other is RW */
2255 if ((addr & (s_align - 1)) != 0)
2256 addr += s_align;
2257 } else {
2258 align = s_align - 1;
2262 tmp = addr;
2263 addr = (addr + align) & ~align;
2264 file_offset += (int)(addr - tmp);
2265 s->sh_offset = file_offset;
2266 s->sh_addr = addr;
2268 if (f & 1<<8) {
2269 /* set new program header */
2270 ph = &d->phdr[phfill + n];
2271 ph->p_type = PT_LOAD;
2272 ph->p_align = s_align;
2273 ph->p_flags = PF_R;
2274 if (f & SHF_WRITE)
2275 ph->p_flags |= PF_W;
2276 if (f & SHF_EXECINSTR)
2277 ph->p_flags |= PF_X;
2278 if (f & SHF_TLS) {
2279 ph->p_type = PT_TLS;
2280 ph->p_align = 4;
2282 ph->p_offset = file_offset;
2283 ph->p_vaddr = addr;
2284 if (n == 0) {
2285 /* Make the first PT_LOAD segment include the program
2286 headers itself (and the ELF header as well), it'll
2287 come out with same memory use but will make various
2288 tools like binutils strip work better. */
2289 ph->p_offset = 0;
2290 ph->p_vaddr = base;
2292 ph->p_paddr = ph->p_vaddr;
2293 ++n;
2296 if (f & 1<<4) {
2297 Section *roinf = &d->_roinf;
2298 if (roinf->sh_size == 0) {
2299 roinf->sh_offset = s->sh_offset;
2300 roinf->sh_addr = s->sh_addr;
2301 roinf->sh_addralign = 1;
2303 roinf->sh_size = (addr - roinf->sh_addr) + s->sh_size;
2306 addr += s->sh_size;
2307 if (s->sh_type != SHT_NOBITS)
2308 file_offset += s->sh_size;
2310 ph->p_filesz = file_offset - ph->p_offset;
2311 ph->p_memsz = addr - ph->p_vaddr;
2314 /* Fill other headers */
2315 if (d->note)
2316 fill_phdr(++ph, PT_NOTE, d->note);
2317 if (d->dynamic)
2318 fill_phdr(++ph, PT_DYNAMIC, d->dynamic)->p_flags |= PF_W;
2319 if (d->roinf)
2320 fill_phdr(++ph, PT_GNU_RELRO, d->roinf)->p_flags |= PF_W;
2321 if (d->interp)
2322 fill_phdr(&d->phdr[1], PT_INTERP, d->interp);
2323 if (phfill) {
2324 ph = &d->phdr[0];
2325 ph->p_offset = sizeof(ElfW(Ehdr));
2326 ph->p_vaddr = base + ph->p_offset;
2327 ph->p_filesz = phnum * sizeof(ElfW(Phdr));
2328 ph->p_align = 4;
2329 fill_phdr(ph, PT_PHDR, NULL);
2331 return file_offset;
2334 /* put dynamic tag */
2335 static void put_dt(Section *dynamic, int dt, addr_t val)
2337 ElfW(Dyn) *dyn;
2338 dyn = section_ptr_add(dynamic, sizeof(ElfW(Dyn)));
2339 dyn->d_tag = dt;
2340 dyn->d_un.d_val = val;
2343 /* Fill the dynamic section with tags describing the address and size of
2344 sections */
2345 static void fill_dynamic(TCCState *s1, struct dyn_inf *dyninf)
2347 Section *dynamic = dyninf->dynamic;
2348 Section *s;
2350 /* put dynamic section entries */
2351 put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
2352 put_dt(dynamic, DT_GNU_HASH, dyninf->gnu_hash->sh_addr);
2353 put_dt(dynamic, DT_STRTAB, dyninf->dynstr->sh_addr);
2354 put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
2355 put_dt(dynamic, DT_STRSZ, dyninf->dynstr->data_offset);
2356 put_dt(dynamic, DT_SYMENT, sizeof(ElfW(Sym)));
2357 #if PTR_SIZE == 8
2358 put_dt(dynamic, DT_RELA, dyninf->rel_addr);
2359 put_dt(dynamic, DT_RELASZ, dyninf->rel_size);
2360 put_dt(dynamic, DT_RELAENT, sizeof(ElfW_Rel));
2361 if (s1->plt && s1->plt->reloc) {
2362 put_dt(dynamic, DT_PLTGOT, s1->got->sh_addr);
2363 put_dt(dynamic, DT_PLTRELSZ, s1->plt->reloc->data_offset);
2364 put_dt(dynamic, DT_JMPREL, s1->plt->reloc->sh_addr);
2365 put_dt(dynamic, DT_PLTREL, DT_RELA);
2367 put_dt(dynamic, DT_RELACOUNT, 0);
2368 #else
2369 put_dt(dynamic, DT_REL, dyninf->rel_addr);
2370 put_dt(dynamic, DT_RELSZ, dyninf->rel_size);
2371 put_dt(dynamic, DT_RELENT, sizeof(ElfW_Rel));
2372 if (s1->plt && s1->plt->reloc) {
2373 put_dt(dynamic, DT_PLTGOT, s1->got->sh_addr);
2374 put_dt(dynamic, DT_PLTRELSZ, s1->plt->reloc->data_offset);
2375 put_dt(dynamic, DT_JMPREL, s1->plt->reloc->sh_addr);
2376 put_dt(dynamic, DT_PLTREL, DT_REL);
2378 put_dt(dynamic, DT_RELCOUNT, 0);
2379 #endif
2380 if (versym_section && verneed_section) {
2381 /* The dynamic linker can not handle VERSYM without VERNEED */
2382 put_dt(dynamic, DT_VERSYM, versym_section->sh_addr);
2383 put_dt(dynamic, DT_VERNEED, verneed_section->sh_addr);
2384 put_dt(dynamic, DT_VERNEEDNUM, dt_verneednum);
2386 s = have_section(s1, ".preinit_array");
2387 if (s && s->data_offset) {
2388 put_dt(dynamic, DT_PREINIT_ARRAY, s->sh_addr);
2389 put_dt(dynamic, DT_PREINIT_ARRAYSZ, s->data_offset);
2391 s = have_section(s1, ".init_array");
2392 if (s && s->data_offset) {
2393 put_dt(dynamic, DT_INIT_ARRAY, s->sh_addr);
2394 put_dt(dynamic, DT_INIT_ARRAYSZ, s->data_offset);
2396 s = have_section(s1, ".fini_array");
2397 if (s && s->data_offset) {
2398 put_dt(dynamic, DT_FINI_ARRAY, s->sh_addr);
2399 put_dt(dynamic, DT_FINI_ARRAYSZ, s->data_offset);
2401 s = have_section(s1, ".init");
2402 if (s && s->data_offset) {
2403 put_dt(dynamic, DT_INIT, s->sh_addr);
2405 s = have_section(s1, ".fini");
2406 if (s && s->data_offset) {
2407 put_dt(dynamic, DT_FINI, s->sh_addr);
2409 if (s1->do_debug)
2410 put_dt(dynamic, DT_DEBUG, 0);
2411 put_dt(dynamic, DT_NULL, 0);
2414 /* Remove gaps between RELX sections.
2415 These gaps are a result of final_sections_reloc. Here some relocs are removed.
2416 The gaps are then filled with 0 in tcc_output_elf. The 0 is intepreted as
2417 R_...NONE reloc. This does work on most targets but on OpenBSD/arm64 this
2418 is illegal. OpenBSD/arm64 does not support R_...NONE reloc. */
2419 static void update_reloc_sections(TCCState *s1, struct dyn_inf *dyninf)
2421 int i;
2422 unsigned long file_offset = 0;
2423 Section *s;
2424 Section *relocplt = s1->plt ? s1->plt->reloc : NULL;
2426 /* dynamic relocation table information, for .dynamic section */
2427 dyninf->rel_addr = dyninf->rel_size = 0;
2429 for(i = 1; i < s1->nb_sections; i++) {
2430 s = s1->sections[i];
2431 if (s->sh_type == SHT_RELX && s != relocplt) {
2432 if (dyninf->rel_size == 0) {
2433 dyninf->rel_addr = s->sh_addr;
2434 file_offset = s->sh_offset;
2436 else {
2437 s->sh_addr = dyninf->rel_addr + dyninf->rel_size;
2438 s->sh_offset = file_offset + dyninf->rel_size;
2440 dyninf->rel_size += s->sh_size;
2445 static int tidy_section_headers(TCCState *s1, int *sec_order);
2446 #endif /* ndef ELF_OBJ_ONLY */
2448 /* Create an ELF file on disk.
2449 This function handle ELF specific layout requirements */
2450 static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
2451 int file_offset, int *sec_order)
2453 int i, shnum, offset, size, file_type;
2454 Section *s;
2455 ElfW(Ehdr) ehdr;
2456 ElfW(Shdr) shdr, *sh;
2458 file_type = s1->output_type;
2459 shnum = s1->nb_sections;
2461 memset(&ehdr, 0, sizeof(ehdr));
2463 if (phnum > 0) {
2464 ehdr.e_phentsize = sizeof(ElfW(Phdr));
2465 ehdr.e_phnum = phnum;
2466 ehdr.e_phoff = sizeof(ElfW(Ehdr));
2467 #ifndef ELF_OBJ_ONLY
2468 shnum = tidy_section_headers(s1, sec_order);
2469 #endif
2472 /* align to 4 */
2473 file_offset = (file_offset + 3) & -4;
2475 /* fill header */
2476 ehdr.e_ident[0] = ELFMAG0;
2477 ehdr.e_ident[1] = ELFMAG1;
2478 ehdr.e_ident[2] = ELFMAG2;
2479 ehdr.e_ident[3] = ELFMAG3;
2480 ehdr.e_ident[4] = ELFCLASSW;
2481 ehdr.e_ident[5] = ELFDATA2LSB;
2482 ehdr.e_ident[6] = EV_CURRENT;
2484 #if TARGETOS_FreeBSD || TARGETOS_FreeBSD_kernel
2485 ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
2486 #elif defined TCC_TARGET_ARM && defined TCC_ARM_EABI
2487 ehdr.e_flags = EF_ARM_EABI_VER5;
2488 ehdr.e_flags |= s1->float_abi == ARM_HARD_FLOAT
2489 ? EF_ARM_VFP_FLOAT : EF_ARM_SOFT_FLOAT;
2490 #elif defined TCC_TARGET_ARM
2491 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
2492 #elif defined TCC_TARGET_RISCV64
2493 ehdr.e_flags = EF_RISCV_FLOAT_ABI_DOUBLE;
2494 #endif
2496 if (file_type == TCC_OUTPUT_OBJ) {
2497 ehdr.e_type = ET_REL;
2498 } else {
2499 if (file_type & TCC_OUTPUT_DYN)
2500 ehdr.e_type = ET_DYN;
2501 else
2502 ehdr.e_type = ET_EXEC;
2503 if (s1->elf_entryname)
2504 ehdr.e_entry = get_sym_addr(s1, s1->elf_entryname, 1, 0);
2505 else
2506 ehdr.e_entry = get_sym_addr(s1, "_start", !!(file_type & TCC_OUTPUT_EXE), 0);
2507 if (ehdr.e_entry == (addr_t)-1)
2508 ehdr.e_entry = text_section->sh_addr;
2511 ehdr.e_machine = EM_TCC_TARGET;
2512 ehdr.e_version = EV_CURRENT;
2513 ehdr.e_shoff = file_offset;
2514 ehdr.e_ehsize = sizeof(ElfW(Ehdr));
2515 ehdr.e_shentsize = sizeof(ElfW(Shdr));
2516 ehdr.e_shnum = shnum;
2517 ehdr.e_shstrndx = shnum - 1;
2519 fwrite(&ehdr, 1, sizeof(ElfW(Ehdr)), f);
2520 if (phdr)
2521 fwrite(phdr, 1, phnum * sizeof(ElfW(Phdr)), f);
2522 offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
2524 sort_syms(s1, symtab_section);
2526 for(i = 1; i < shnum; i++) {
2527 s = s1->sections[sec_order ? sec_order[i] : i];
2528 if (s->sh_type != SHT_NOBITS) {
2529 while (offset < s->sh_offset) {
2530 fputc(0, f);
2531 offset++;
2533 size = s->sh_size;
2534 if (size)
2535 fwrite(s->data, 1, size, f);
2536 offset += size;
2540 /* output section headers */
2541 while (offset < ehdr.e_shoff) {
2542 fputc(0, f);
2543 offset++;
2546 for(i = 0; i < shnum; i++) {
2547 sh = &shdr;
2548 memset(sh, 0, sizeof(ElfW(Shdr)));
2549 s = s1->sections[i];
2550 if (s) {
2551 sh->sh_name = s->sh_name;
2552 sh->sh_type = s->sh_type;
2553 sh->sh_flags = s->sh_flags;
2554 sh->sh_entsize = s->sh_entsize;
2555 sh->sh_info = s->sh_info;
2556 if (s->link)
2557 sh->sh_link = s->link->sh_num;
2558 sh->sh_addralign = s->sh_addralign;
2559 sh->sh_addr = s->sh_addr;
2560 sh->sh_offset = s->sh_offset;
2561 sh->sh_size = s->sh_size;
2563 fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
2567 static void tcc_output_binary(TCCState *s1, FILE *f,
2568 const int *sec_order)
2570 Section *s;
2571 int i, offset, size;
2573 offset = 0;
2574 for(i=1;i<s1->nb_sections;i++) {
2575 s = s1->sections[sec_order[i]];
2576 if (s->sh_type != SHT_NOBITS &&
2577 (s->sh_flags & SHF_ALLOC)) {
2578 while (offset < s->sh_offset) {
2579 fputc(0, f);
2580 offset++;
2582 size = s->sh_size;
2583 fwrite(s->data, 1, size, f);
2584 offset += size;
2589 /* Write an elf, coff or "binary" file */
2590 static int tcc_write_elf_file(TCCState *s1, const char *filename, int phnum,
2591 ElfW(Phdr) *phdr, int file_offset, int *sec_order)
2593 int fd, mode, file_type;
2594 FILE *f;
2596 file_type = s1->output_type;
2597 if (file_type == TCC_OUTPUT_OBJ)
2598 mode = 0666;
2599 else
2600 mode = 0777;
2601 unlink(filename);
2602 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
2603 if (fd < 0 || (f = fdopen(fd, "wb")) == NULL) {
2604 tcc_error_noabort("could not write '%s: %s'", filename, strerror(errno));
2605 return -1;
2607 if (s1->verbose)
2608 printf("<- %s\n", filename);
2610 #ifdef TCC_TARGET_COFF
2611 if (s1->output_format == TCC_OUTPUT_FORMAT_COFF)
2612 tcc_output_coff(s1, f);
2613 else
2614 #endif
2615 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
2616 tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
2617 else
2618 tcc_output_binary(s1, f, sec_order);
2619 fclose(f);
2621 return 0;
2624 #ifndef ELF_OBJ_ONLY
2625 /* Sort section headers by assigned sh_addr, remove sections
2626 that we aren't going to output. */
2627 static int tidy_section_headers(TCCState *s1, int *sec_order)
2629 int i, nnew, l, *backmap;
2630 Section **snew, *s;
2631 ElfW(Sym) *sym;
2633 snew = tcc_malloc(s1->nb_sections * sizeof(snew[0]));
2634 backmap = tcc_malloc(s1->nb_sections * sizeof(backmap[0]));
2635 for (i = 0, nnew = 0, l = s1->nb_sections; i < s1->nb_sections; i++) {
2636 s = s1->sections[sec_order[i]];
2637 if (!i || s->sh_name) {
2638 backmap[sec_order[i]] = nnew;
2639 snew[nnew] = s;
2640 ++nnew;
2641 } else {
2642 backmap[sec_order[i]] = 0;
2643 snew[--l] = s;
2646 for (i = 0; i < nnew; i++) {
2647 s = snew[i];
2648 if (s) {
2649 s->sh_num = i;
2650 if (s->sh_type == SHT_RELX)
2651 s->sh_info = backmap[s->sh_info];
2655 for_each_elem(symtab_section, 1, sym, ElfW(Sym))
2656 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE)
2657 sym->st_shndx = backmap[sym->st_shndx];
2658 if ( !s1->static_link ) {
2659 for_each_elem(s1->dynsym, 1, sym, ElfW(Sym))
2660 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE)
2661 sym->st_shndx = backmap[sym->st_shndx];
2663 for (i = 0; i < s1->nb_sections; i++)
2664 sec_order[i] = i;
2665 tcc_free(s1->sections);
2666 s1->sections = snew;
2667 tcc_free(backmap);
2668 return nnew;
2671 #ifdef TCC_TARGET_ARM
2672 static void create_arm_attribute_section(TCCState *s1)
2674 // Needed for DLL support.
2675 static const unsigned char arm_attr[] = {
2676 0x41, // 'A'
2677 0x2c, 0x00, 0x00, 0x00, // size 0x2c
2678 'a', 'e', 'a', 'b', 'i', 0x00, // "aeabi"
2679 0x01, 0x22, 0x00, 0x00, 0x00, // 'File Attributes', size 0x22
2680 0x05, 0x36, 0x00, // 'CPU_name', "6"
2681 0x06, 0x06, // 'CPU_arch', 'v6'
2682 0x08, 0x01, // 'ARM_ISA_use', 'Yes'
2683 0x09, 0x01, // 'THUMB_ISA_use', 'Thumb-1'
2684 0x0a, 0x02, // 'FP_arch', 'VFPv2'
2685 0x12, 0x04, // 'ABI_PCS_wchar_t', 4
2686 0x14, 0x01, // 'ABI_FP_denormal', 'Needed'
2687 0x15, 0x01, // 'ABI_FP_exceptions', 'Needed'
2688 0x17, 0x03, // 'ABI_FP_number_model', 'IEEE 754'
2689 0x18, 0x01, // 'ABI_align_needed', '8-byte'
2690 0x19, 0x01, // 'ABI_align_preserved', '8-byte, except leaf SP'
2691 0x1a, 0x02, // 'ABI_enum_size', 'int'
2692 0x1c, 0x01, // 'ABI_VFP_args', 'VFP registers'
2693 0x22, 0x01 // 'CPU_unaligned_access', 'v6'
2695 Section *attr = new_section(s1, ".ARM.attributes", SHT_ARM_ATTRIBUTES, 0);
2696 unsigned char *ptr = section_ptr_add(attr, sizeof(arm_attr));
2697 attr->sh_addralign = 1;
2698 memcpy(ptr, arm_attr, sizeof(arm_attr));
2699 if (s1->float_abi != ARM_HARD_FLOAT) {
2700 ptr[26] = 0x00; // 'FP_arch', 'No'
2701 ptr[41] = 0x1e; // 'ABI_optimization_goals'
2702 ptr[42] = 0x06; // 'Aggressive Debug'
2705 #endif
2707 #if TARGETOS_OpenBSD || TARGETOS_NetBSD
2708 static Section *create_bsd_note_section(TCCState *s1,
2709 const char *name,
2710 const char *value)
2712 Section *s = find_section (s1, name);
2714 if (s->data_offset == 0) {
2715 char *ptr = section_ptr_add(s, sizeof(ElfW(Nhdr)) + 8 + 4);
2716 ElfW(Nhdr) *note = (ElfW(Nhdr) *) ptr;
2718 s->sh_type = SHT_NOTE;
2719 note->n_namesz = 8;
2720 note->n_descsz = 4;
2721 note->n_type = ELF_NOTE_OS_GNU;
2722 strcpy (ptr + sizeof(ElfW(Nhdr)), value);
2724 return s;
2726 #endif
2728 static void alloc_sec_names(TCCState *s1, int is_obj);
2730 /* Output an elf, coff or binary file */
2731 /* XXX: suppress unneeded sections */
2732 static int elf_output_file(TCCState *s1, const char *filename)
2734 int i, ret, file_type, file_offset, *sec_order;
2735 struct dyn_inf dyninf = {0};
2736 Section *interp, *dynstr, *dynamic;
2737 int textrel, got_sym, dt_flags_1;
2739 file_type = s1->output_type;
2740 s1->nb_errors = 0;
2741 ret = -1;
2742 interp = dynstr = dynamic = NULL;
2743 sec_order = NULL;
2744 dyninf.roinf = &dyninf._roinf;
2746 #ifdef TCC_TARGET_ARM
2747 create_arm_attribute_section (s1);
2748 #endif
2750 #if TARGETOS_OpenBSD
2751 dyninf.note = create_bsd_note_section (s1, ".note.openbsd.ident", "OpenBSD");
2752 #endif
2754 #if TARGETOS_NetBSD
2755 dyninf.note = create_bsd_note_section (s1, ".note.netbsd.ident", "NetBSD");
2756 #endif
2758 #if TARGETOS_FreeBSD || TARGETOS_NetBSD
2759 dyninf.roinf = NULL;
2760 #endif
2761 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2762 tcc_add_runtime(s1);
2763 resolve_common_syms(s1);
2765 if (!s1->static_link) {
2766 if (file_type & TCC_OUTPUT_EXE) {
2767 char *ptr;
2768 /* allow override the dynamic loader */
2769 const char *elfint = getenv("LD_SO");
2770 if (elfint == NULL)
2771 elfint = DEFAULT_ELFINTERP(s1);
2772 /* add interpreter section only if executable */
2773 interp = new_section(s1, ".interp", SHT_PROGBITS, SHF_ALLOC);
2774 interp->sh_addralign = 1;
2775 ptr = section_ptr_add(interp, 1 + strlen(elfint));
2776 strcpy(ptr, elfint);
2777 dyninf.interp = interp;
2780 /* add dynamic symbol table */
2781 s1->dynsym = new_symtab(s1, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
2782 ".dynstr",
2783 ".hash", SHF_ALLOC);
2784 /* Number of local symbols (readelf complains if not set) */
2785 s1->dynsym->sh_info = 1;
2786 dynstr = s1->dynsym->link;
2787 /* add dynamic section */
2788 dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC,
2789 SHF_ALLOC | SHF_WRITE);
2790 dynamic->link = dynstr;
2791 dynamic->sh_entsize = sizeof(ElfW(Dyn));
2793 got_sym = build_got(s1);
2794 if (file_type == TCC_OUTPUT_EXE) {
2795 bind_exe_dynsyms(s1);
2796 if (s1->nb_errors)
2797 goto the_end;
2799 build_got_entries(s1, got_sym);
2800 if (file_type & TCC_OUTPUT_EXE) {
2801 bind_libs_dynsyms(s1);
2802 } else {
2803 /* shared library case: simply export all global symbols */
2804 export_global_syms(s1);
2806 dyninf.gnu_hash = create_gnu_hash(s1);
2807 } else {
2808 build_got_entries(s1, 0);
2810 version_add (s1);
2812 textrel = set_sec_sizes(s1);
2813 alloc_sec_names(s1, 0);
2815 if (!s1->static_link) {
2816 /* add a list of needed dlls */
2817 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2818 DLLReference *dllref = s1->loaded_dlls[i];
2819 if (dllref->level == 0)
2820 put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name));
2823 if (s1->rpath)
2824 put_dt(dynamic, s1->enable_new_dtags ? DT_RUNPATH : DT_RPATH,
2825 put_elf_str(dynstr, s1->rpath));
2827 dt_flags_1 = DF_1_NOW;
2828 if (file_type & TCC_OUTPUT_DYN) {
2829 if (s1->soname)
2830 put_dt(dynamic, DT_SONAME, put_elf_str(dynstr, s1->soname));
2831 /* XXX: currently, since we do not handle PIC code, we
2832 must relocate the readonly segments */
2833 if (textrel)
2834 put_dt(dynamic, DT_TEXTREL, 0);
2835 if (file_type & TCC_OUTPUT_EXE)
2836 dt_flags_1 = DF_1_NOW | DF_1_PIE;
2838 put_dt(dynamic, DT_FLAGS, DF_BIND_NOW);
2839 put_dt(dynamic, DT_FLAGS_1, dt_flags_1);
2840 if (s1->symbolic)
2841 put_dt(dynamic, DT_SYMBOLIC, 0);
2843 dyninf.dynamic = dynamic;
2844 dyninf.dynstr = dynstr;
2845 /* remember offset and reserve space for 2nd call below */
2846 dyninf.data_offset = dynamic->data_offset;
2847 fill_dynamic(s1, &dyninf);
2848 dynamic->sh_size = dynamic->data_offset;
2849 dynstr->sh_size = dynstr->data_offset;
2852 /* this array is used to reorder sections in the output file */
2853 sec_order = tcc_malloc(sizeof(int) * 2 * s1->nb_sections);
2854 /* compute section to program header mapping */
2855 file_offset = layout_sections(s1, sec_order, &dyninf);
2857 if (dynamic) {
2858 /* put in GOT the dynamic section address and relocate PLT */
2859 write32le(s1->got->data, dynamic->sh_addr);
2860 if (file_type == TCC_OUTPUT_EXE
2861 || (RELOCATE_DLLPLT && (file_type & TCC_OUTPUT_DYN)))
2862 relocate_plt(s1);
2863 /* relocate symbols in .dynsym now that final addresses are known */
2864 relocate_syms(s1, s1->dynsym, 2);
2867 /* if building executable or DLL, then relocate each section
2868 except the GOT which is already relocated */
2869 relocate_syms(s1, s1->symtab, 0);
2870 if (s1->nb_errors != 0)
2871 goto the_end;
2872 relocate_sections(s1);
2873 if (dynamic) {
2874 update_reloc_sections (s1, &dyninf);
2875 dynamic->data_offset = dyninf.data_offset;
2876 fill_dynamic(s1, &dyninf);
2878 /* Perform relocation to GOT or PLT entries */
2879 if (file_type == TCC_OUTPUT_EXE && s1->static_link)
2880 fill_got(s1);
2881 else if (s1->got)
2882 fill_local_got_entries(s1);
2884 if (dyninf.gnu_hash)
2885 update_gnu_hash(s1, dyninf.gnu_hash);
2887 /* Create the ELF file with name 'filename' */
2888 ret = tcc_write_elf_file(s1, filename, dyninf.phnum, dyninf.phdr, file_offset, sec_order);
2889 the_end:
2890 tcc_free(sec_order);
2891 tcc_free(dyninf.phdr);
2892 return ret;
2894 #endif /* ndef ELF_OBJ_ONLY */
2896 /* Allocate strings for section names */
2897 static void alloc_sec_names(TCCState *s1, int is_obj)
2899 int i;
2900 Section *s, *strsec;
2902 strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0);
2903 put_elf_str(strsec, "");
2904 for(i = 1; i < s1->nb_sections; i++) {
2905 s = s1->sections[i];
2906 if (is_obj)
2907 s->sh_size = s->data_offset;
2908 if (s == strsec || s->sh_size || (s->sh_flags & SHF_ALLOC))
2909 s->sh_name = put_elf_str(strsec, s->name);
2911 strsec->sh_size = strsec->data_offset;
2914 /* Output an elf .o file */
2915 static int elf_output_obj(TCCState *s1, const char *filename)
2917 Section *s;
2918 int i, ret, file_offset;
2919 s1->nb_errors = 0;
2920 /* Allocate strings for section names */
2921 alloc_sec_names(s1, 1);
2922 file_offset = sizeof (ElfW(Ehdr));
2923 for(i = 1; i < s1->nb_sections; i++) {
2924 s = s1->sections[i];
2925 file_offset = (file_offset + 15) & -16;
2926 s->sh_offset = file_offset;
2927 if (s->sh_type != SHT_NOBITS)
2928 file_offset += s->sh_size;
2930 /* Create the ELF file with name 'filename' */
2931 ret = tcc_write_elf_file(s1, filename, 0, NULL, file_offset, NULL);
2932 return ret;
2935 LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename)
2937 if (s->test_coverage)
2938 tcc_tcov_add_file(s, filename);
2939 if (s->output_type == TCC_OUTPUT_OBJ)
2940 return elf_output_obj(s, filename);
2941 #ifdef TCC_TARGET_PE
2942 return pe_output_file(s, filename);
2943 #elif TCC_TARGET_MACHO
2944 return macho_output_file(s, filename);
2945 #else
2946 return elf_output_file(s, filename);
2947 #endif
2950 ST_FUNC ssize_t full_read(int fd, void *buf, size_t count) {
2951 char *cbuf = buf;
2952 size_t rnum = 0;
2953 while (1) {
2954 ssize_t num = read(fd, cbuf, count-rnum);
2955 if (num < 0) return num;
2956 if (num == 0) return rnum;
2957 rnum += num;
2958 cbuf += num;
2962 ST_FUNC void *load_data(int fd, unsigned long file_offset, unsigned long size)
2964 void *data;
2966 data = tcc_malloc(size);
2967 lseek(fd, file_offset, SEEK_SET);
2968 full_read(fd, data, size);
2969 return data;
2972 typedef struct SectionMergeInfo {
2973 Section *s; /* corresponding existing section */
2974 unsigned long offset; /* offset of the new section in the existing section */
2975 uint8_t new_section; /* true if section 's' was added */
2976 uint8_t link_once; /* true if link once section */
2977 } SectionMergeInfo;
2979 ST_FUNC int tcc_object_type(int fd, ElfW(Ehdr) *h)
2981 int size = full_read(fd, h, sizeof *h);
2982 if (size == sizeof *h && 0 == memcmp(h, ELFMAG, 4)) {
2983 if (h->e_type == ET_REL)
2984 return AFF_BINTYPE_REL;
2985 if (h->e_type == ET_DYN)
2986 return AFF_BINTYPE_DYN;
2987 } else if (size >= 8) {
2988 if (0 == memcmp(h, ARMAG, 8))
2989 return AFF_BINTYPE_AR;
2990 #ifdef TCC_TARGET_COFF
2991 if (((struct filehdr*)h)->f_magic == COFF_C67_MAGIC)
2992 return AFF_BINTYPE_C67;
2993 #endif
2995 return 0;
2998 /* load an object file and merge it with current files */
2999 /* XXX: handle correctly stab (debug) info */
3000 ST_FUNC int tcc_load_object_file(TCCState *s1,
3001 int fd, unsigned long file_offset)
3003 ElfW(Ehdr) ehdr;
3004 ElfW(Shdr) *shdr, *sh;
3005 unsigned long size, offset, offseti;
3006 int i, j, nb_syms, sym_index, ret, seencompressed;
3007 char *strsec, *strtab;
3008 int stab_index, stabstr_index;
3009 int *old_to_new_syms;
3010 char *sh_name, *name;
3011 SectionMergeInfo *sm_table, *sm;
3012 ElfW(Sym) *sym, *symtab;
3013 ElfW_Rel *rel;
3014 Section *s;
3016 lseek(fd, file_offset, SEEK_SET);
3017 if (tcc_object_type(fd, &ehdr) != AFF_BINTYPE_REL)
3018 goto fail1;
3019 /* test CPU specific stuff */
3020 if (ehdr.e_ident[5] != ELFDATA2LSB ||
3021 ehdr.e_machine != EM_TCC_TARGET) {
3022 fail1:
3023 tcc_error_noabort("invalid object file");
3024 return -1;
3026 /* read sections */
3027 shdr = load_data(fd, file_offset + ehdr.e_shoff,
3028 sizeof(ElfW(Shdr)) * ehdr.e_shnum);
3029 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
3031 /* load section names */
3032 sh = &shdr[ehdr.e_shstrndx];
3033 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
3035 /* load symtab and strtab */
3036 old_to_new_syms = NULL;
3037 symtab = NULL;
3038 strtab = NULL;
3039 nb_syms = 0;
3040 seencompressed = 0;
3041 stab_index = stabstr_index = 0;
3043 for(i = 1; i < ehdr.e_shnum; i++) {
3044 sh = &shdr[i];
3045 if (sh->sh_type == SHT_SYMTAB) {
3046 if (symtab) {
3047 tcc_error_noabort("object must contain only one symtab");
3048 fail:
3049 ret = -1;
3050 goto the_end;
3052 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
3053 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
3054 sm_table[i].s = symtab_section;
3056 /* now load strtab */
3057 sh = &shdr[sh->sh_link];
3058 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
3060 if (sh->sh_flags & SHF_COMPRESSED)
3061 seencompressed = 1;
3064 /* now examine each section and try to merge its content with the
3065 ones in memory */
3066 for(i = 1; i < ehdr.e_shnum; i++) {
3067 /* no need to examine section name strtab */
3068 if (i == ehdr.e_shstrndx)
3069 continue;
3070 sh = &shdr[i];
3071 if (sh->sh_type == SHT_RELX)
3072 sh = &shdr[sh->sh_info];
3073 /* ignore sections types we do not handle (plus relocs to those) */
3074 if (sh->sh_type != SHT_PROGBITS &&
3075 #ifdef TCC_ARM_EABI
3076 sh->sh_type != SHT_ARM_EXIDX &&
3077 #endif
3078 #if TARGETOS_OpenBSD || TARGETOS_FreeBSD || TARGETOS_NetBSD
3079 sh->sh_type != SHT_X86_64_UNWIND &&
3080 #endif
3081 sh->sh_type != SHT_NOTE &&
3082 sh->sh_type != SHT_NOBITS &&
3083 sh->sh_type != SHT_PREINIT_ARRAY &&
3084 sh->sh_type != SHT_INIT_ARRAY &&
3085 sh->sh_type != SHT_FINI_ARRAY &&
3086 strcmp(strsec + sh->sh_name, ".stabstr")
3088 continue;
3089 if (seencompressed && 0 == strncmp(strsec + sh->sh_name, ".debug_", 7))
3090 continue;
3092 sh = &shdr[i];
3093 sh_name = strsec + sh->sh_name;
3094 if (sh->sh_addralign < 1)
3095 sh->sh_addralign = 1;
3096 /* find corresponding section, if any */
3097 for(j = 1; j < s1->nb_sections;j++) {
3098 s = s1->sections[j];
3099 if (!strcmp(s->name, sh_name)) {
3100 if (!strncmp(sh_name, ".gnu.linkonce",
3101 sizeof(".gnu.linkonce") - 1)) {
3102 /* if a 'linkonce' section is already present, we
3103 do not add it again. It is a little tricky as
3104 symbols can still be defined in
3105 it. */
3106 sm_table[i].link_once = 1;
3107 goto next;
3109 if (stab_section) {
3110 if (s == stab_section)
3111 stab_index = i;
3112 if (s == stab_section->link)
3113 stabstr_index = i;
3115 goto found;
3118 /* not found: create new section */
3119 s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags & ~SHF_GROUP);
3120 /* take as much info as possible from the section. sh_link and
3121 sh_info will be updated later */
3122 s->sh_addralign = sh->sh_addralign;
3123 s->sh_entsize = sh->sh_entsize;
3124 sm_table[i].new_section = 1;
3125 found:
3126 if (sh->sh_type != s->sh_type) {
3127 #if TARGETOS_OpenBSD || TARGETOS_FreeBSD || TARGETOS_NetBSD
3128 if (strcmp (s->name, ".eh_frame"))
3129 #endif
3131 tcc_error_noabort("invalid section type");
3132 goto fail;
3135 /* align start of section */
3136 s->data_offset += -s->data_offset & (sh->sh_addralign - 1);
3137 if (sh->sh_addralign > s->sh_addralign)
3138 s->sh_addralign = sh->sh_addralign;
3139 sm_table[i].offset = s->data_offset;
3140 sm_table[i].s = s;
3141 /* concatenate sections */
3142 size = sh->sh_size;
3143 if (sh->sh_type != SHT_NOBITS) {
3144 unsigned char *ptr;
3145 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
3146 ptr = section_ptr_add(s, size);
3147 full_read(fd, ptr, size);
3148 } else {
3149 s->data_offset += size;
3151 next: ;
3154 /* gr relocate stab strings */
3155 if (stab_index && stabstr_index) {
3156 Stab_Sym *a, *b;
3157 unsigned o;
3158 s = sm_table[stab_index].s;
3159 a = (Stab_Sym *)(s->data + sm_table[stab_index].offset);
3160 b = (Stab_Sym *)(s->data + s->data_offset);
3161 o = sm_table[stabstr_index].offset;
3162 while (a < b) {
3163 if (a->n_strx)
3164 a->n_strx += o;
3165 a++;
3169 /* second short pass to update sh_link and sh_info fields of new
3170 sections */
3171 for(i = 1; i < ehdr.e_shnum; i++) {
3172 s = sm_table[i].s;
3173 if (!s || !sm_table[i].new_section)
3174 continue;
3175 sh = &shdr[i];
3176 if (sh->sh_link > 0)
3177 s->link = sm_table[sh->sh_link].s;
3178 if (sh->sh_type == SHT_RELX) {
3179 s->sh_info = sm_table[sh->sh_info].s->sh_num;
3180 /* update backward link */
3181 s1->sections[s->sh_info]->reloc = s;
3185 /* resolve symbols */
3186 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
3188 sym = symtab + 1;
3189 for(i = 1; i < nb_syms; i++, sym++) {
3190 if (sym->st_shndx != SHN_UNDEF &&
3191 sym->st_shndx < SHN_LORESERVE) {
3192 sm = &sm_table[sym->st_shndx];
3193 if (sm->link_once) {
3194 /* if a symbol is in a link once section, we use the
3195 already defined symbol. It is very important to get
3196 correct relocations */
3197 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
3198 name = strtab + sym->st_name;
3199 sym_index = find_elf_sym(symtab_section, name);
3200 if (sym_index)
3201 old_to_new_syms[i] = sym_index;
3203 continue;
3205 /* if no corresponding section added, no need to add symbol */
3206 if (!sm->s)
3207 continue;
3208 /* convert section number */
3209 sym->st_shndx = sm->s->sh_num;
3210 /* offset value */
3211 sym->st_value += sm->offset;
3213 /* add symbol */
3214 name = strtab + sym->st_name;
3215 sym_index = set_elf_sym(symtab_section, sym->st_value, sym->st_size,
3216 sym->st_info, sym->st_other,
3217 sym->st_shndx, name);
3218 old_to_new_syms[i] = sym_index;
3221 /* third pass to patch relocation entries */
3222 for(i = 1; i < ehdr.e_shnum; i++) {
3223 s = sm_table[i].s;
3224 if (!s)
3225 continue;
3226 sh = &shdr[i];
3227 offset = sm_table[i].offset;
3228 size = sh->sh_size;
3229 switch(s->sh_type) {
3230 case SHT_RELX:
3231 /* take relocation offset information */
3232 offseti = sm_table[sh->sh_info].offset;
3233 for (rel = (ElfW_Rel *) s->data + (offset / sizeof(*rel));
3234 rel < (ElfW_Rel *) s->data + ((offset + size) / sizeof(*rel));
3235 rel++) {
3236 int type;
3237 unsigned sym_index;
3238 /* convert symbol index */
3239 type = ELFW(R_TYPE)(rel->r_info);
3240 sym_index = ELFW(R_SYM)(rel->r_info);
3241 /* NOTE: only one symtab assumed */
3242 if (sym_index >= nb_syms)
3243 goto invalid_reloc;
3244 sym_index = old_to_new_syms[sym_index];
3245 /* ignore link_once in rel section. */
3246 if (!sym_index && !sm_table[sh->sh_info].link_once
3247 #ifdef TCC_TARGET_ARM
3248 && type != R_ARM_V4BX
3249 #elif defined TCC_TARGET_RISCV64
3250 && type != R_RISCV_ALIGN
3251 && type != R_RISCV_RELAX
3252 #endif
3254 invalid_reloc:
3255 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
3256 i, strsec + sh->sh_name, (int)rel->r_offset);
3257 goto fail;
3259 rel->r_info = ELFW(R_INFO)(sym_index, type);
3260 /* offset the relocation offset */
3261 rel->r_offset += offseti;
3262 #ifdef TCC_TARGET_ARM
3263 /* Jumps and branches from a Thumb code to a PLT entry need
3264 special handling since PLT entries are ARM code.
3265 Unconditional bl instructions referencing PLT entries are
3266 handled by converting these instructions into blx
3267 instructions. Other case of instructions referencing a PLT
3268 entry require to add a Thumb stub before the PLT entry to
3269 switch to ARM mode. We set bit plt_thumb_stub of the
3270 attribute of a symbol to indicate such a case. */
3271 if (type == R_ARM_THM_JUMP24)
3272 get_sym_attr(s1, sym_index, 1)->plt_thumb_stub = 1;
3273 #endif
3275 break;
3276 default:
3277 break;
3281 ret = 0;
3282 the_end:
3283 tcc_free(symtab);
3284 tcc_free(strtab);
3285 tcc_free(old_to_new_syms);
3286 tcc_free(sm_table);
3287 tcc_free(strsec);
3288 tcc_free(shdr);
3289 return ret;
3292 typedef struct ArchiveHeader {
3293 char ar_name[16]; /* name of this member */
3294 char ar_date[12]; /* file mtime */
3295 char ar_uid[6]; /* owner uid; printed as decimal */
3296 char ar_gid[6]; /* owner gid; printed as decimal */
3297 char ar_mode[8]; /* file mode, printed as octal */
3298 char ar_size[10]; /* file size, printed as decimal */
3299 char ar_fmag[2]; /* should contain ARFMAG */
3300 } ArchiveHeader;
3302 #define ARFMAG "`\n"
3304 static unsigned long long get_be(const uint8_t *b, int n)
3306 unsigned long long ret = 0;
3307 while (n)
3308 ret = (ret << 8) | *b++, --n;
3309 return ret;
3312 static int read_ar_header(int fd, int offset, ArchiveHeader *hdr)
3314 char *p, *e;
3315 int len;
3316 lseek(fd, offset, SEEK_SET);
3317 len = full_read(fd, hdr, sizeof(ArchiveHeader));
3318 if (len != sizeof(ArchiveHeader))
3319 return len ? -1 : 0;
3320 p = hdr->ar_name;
3321 for (e = p + sizeof hdr->ar_name; e > p && e[-1] == ' ';)
3322 --e;
3323 *e = '\0';
3324 hdr->ar_size[sizeof hdr->ar_size-1] = 0;
3325 return len;
3328 /* load only the objects which resolve undefined symbols */
3329 static int tcc_load_alacarte(TCCState *s1, int fd, int size, int entrysize)
3331 int i, bound, nsyms, sym_index, len, ret = -1;
3332 unsigned long long off;
3333 uint8_t *data;
3334 const char *ar_names, *p;
3335 const uint8_t *ar_index;
3336 ElfW(Sym) *sym;
3337 ArchiveHeader hdr;
3339 data = tcc_malloc(size);
3340 if (full_read(fd, data, size) != size)
3341 goto the_end;
3342 nsyms = get_be(data, entrysize);
3343 ar_index = data + entrysize;
3344 ar_names = (char *) ar_index + nsyms * entrysize;
3346 do {
3347 bound = 0;
3348 for (p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
3349 Section *s = symtab_section;
3350 sym_index = find_elf_sym(s, p);
3351 if (!sym_index)
3352 continue;
3353 sym = &((ElfW(Sym) *)s->data)[sym_index];
3354 if(sym->st_shndx != SHN_UNDEF)
3355 continue;
3356 off = get_be(ar_index + i * entrysize, entrysize);
3357 len = read_ar_header(fd, off, &hdr);
3358 if (len <= 0 || memcmp(hdr.ar_fmag, ARFMAG, 2)) {
3359 tcc_error_noabort("invalid archive");
3360 goto the_end;
3362 off += len;
3363 if (s1->verbose == 2)
3364 printf(" -> %s\n", hdr.ar_name);
3365 if (tcc_load_object_file(s1, fd, off) < 0)
3366 goto the_end;
3367 ++bound;
3369 } while(bound);
3370 ret = 0;
3371 the_end:
3372 tcc_free(data);
3373 return ret;
3376 /* load a '.a' file */
3377 ST_FUNC int tcc_load_archive(TCCState *s1, int fd, int alacarte)
3379 ArchiveHeader hdr;
3380 /* char magic[8]; */
3381 int size, len;
3382 unsigned long file_offset;
3383 ElfW(Ehdr) ehdr;
3385 /* skip magic which was already checked */
3386 /* full_read(fd, magic, sizeof(magic)); */
3387 file_offset = sizeof ARMAG - 1;
3389 for(;;) {
3390 len = read_ar_header(fd, file_offset, &hdr);
3391 if (len == 0)
3392 return 0;
3393 if (len < 0) {
3394 tcc_error_noabort("invalid archive");
3395 return -1;
3397 file_offset += len;
3398 size = strtol(hdr.ar_size, NULL, 0);
3399 /* align to even */
3400 size = (size + 1) & ~1;
3401 if (alacarte) {
3402 /* coff symbol table : we handle it */
3403 if (!strcmp(hdr.ar_name, "/"))
3404 return tcc_load_alacarte(s1, fd, size, 4);
3405 if (!strcmp(hdr.ar_name, "/SYM64/"))
3406 return tcc_load_alacarte(s1, fd, size, 8);
3407 } else if (tcc_object_type(fd, &ehdr) == AFF_BINTYPE_REL) {
3408 if (s1->verbose == 2)
3409 printf(" -> %s\n", hdr.ar_name);
3410 if (tcc_load_object_file(s1, fd, file_offset) < 0)
3411 return -1;
3413 file_offset += size;
3417 #ifndef ELF_OBJ_ONLY
3418 /* Set LV[I] to the global index of sym-version (LIB,VERSION). Maybe resizes
3419 LV, maybe create a new entry for (LIB,VERSION). */
3420 static void set_ver_to_ver(TCCState *s1, int *n, int **lv, int i, char *lib, char *version)
3422 while (i >= *n) {
3423 *lv = tcc_realloc(*lv, (*n + 1) * sizeof(**lv));
3424 (*lv)[(*n)++] = -1;
3426 if ((*lv)[i] == -1) {
3427 int v, prev_same_lib = -1;
3428 for (v = 0; v < nb_sym_versions; v++) {
3429 if (strcmp(sym_versions[v].lib, lib))
3430 continue;
3431 prev_same_lib = v;
3432 if (!strcmp(sym_versions[v].version, version))
3433 break;
3435 if (v == nb_sym_versions) {
3436 sym_versions = tcc_realloc (sym_versions,
3437 (v + 1) * sizeof(*sym_versions));
3438 sym_versions[v].lib = tcc_strdup(lib);
3439 sym_versions[v].version = tcc_strdup(version);
3440 sym_versions[v].out_index = 0;
3441 sym_versions[v].prev_same_lib = prev_same_lib;
3442 nb_sym_versions++;
3444 (*lv)[i] = v;
3448 /* Associates symbol SYM_INDEX (in dynsymtab) with sym-version index
3449 VERNDX. */
3450 static void
3451 set_sym_version(TCCState *s1, int sym_index, int verndx)
3453 if (sym_index >= nb_sym_to_version) {
3454 int newelems = sym_index ? sym_index * 2 : 1;
3455 sym_to_version = tcc_realloc(sym_to_version,
3456 newelems * sizeof(*sym_to_version));
3457 memset(sym_to_version + nb_sym_to_version, -1,
3458 (newelems - nb_sym_to_version) * sizeof(*sym_to_version));
3459 nb_sym_to_version = newelems;
3461 if (sym_to_version[sym_index] < 0)
3462 sym_to_version[sym_index] = verndx;
3465 struct versym_info {
3466 int nb_versyms;
3467 ElfW(Verdef) *verdef;
3468 ElfW(Verneed) *verneed;
3469 ElfW(Half) *versym;
3470 int nb_local_ver, *local_ver;
3474 static void store_version(TCCState *s1, struct versym_info *v, char *dynstr)
3476 char *lib, *version;
3477 uint32_t next;
3478 int i;
3480 #define DEBUG_VERSION 0
3482 if (v->versym && v->verdef) {
3483 ElfW(Verdef) *vdef = v->verdef;
3484 lib = NULL;
3485 do {
3486 ElfW(Verdaux) *verdaux =
3487 (ElfW(Verdaux) *) (((char *) vdef) + vdef->vd_aux);
3489 #if DEBUG_VERSION
3490 printf ("verdef: version:%u flags:%u index:%u, hash:%u\n",
3491 vdef->vd_version, vdef->vd_flags, vdef->vd_ndx,
3492 vdef->vd_hash);
3493 #endif
3494 if (vdef->vd_cnt) {
3495 version = dynstr + verdaux->vda_name;
3497 if (lib == NULL)
3498 lib = version;
3499 else
3500 set_ver_to_ver(s1, &v->nb_local_ver, &v->local_ver, vdef->vd_ndx,
3501 lib, version);
3502 #if DEBUG_VERSION
3503 printf (" verdaux(%u): %s\n", vdef->vd_ndx, version);
3504 #endif
3506 next = vdef->vd_next;
3507 vdef = (ElfW(Verdef) *) (((char *) vdef) + next);
3508 } while (next);
3510 if (v->versym && v->verneed) {
3511 ElfW(Verneed) *vneed = v->verneed;
3512 do {
3513 ElfW(Vernaux) *vernaux =
3514 (ElfW(Vernaux) *) (((char *) vneed) + vneed->vn_aux);
3516 lib = dynstr + vneed->vn_file;
3517 #if DEBUG_VERSION
3518 printf ("verneed: %u %s\n", vneed->vn_version, lib);
3519 #endif
3520 for (i = 0; i < vneed->vn_cnt; i++) {
3521 if ((vernaux->vna_other & 0x8000) == 0) { /* hidden */
3522 version = dynstr + vernaux->vna_name;
3523 set_ver_to_ver(s1, &v->nb_local_ver, &v->local_ver, vernaux->vna_other,
3524 lib, version);
3525 #if DEBUG_VERSION
3526 printf (" vernaux(%u): %u %u %s\n",
3527 vernaux->vna_other, vernaux->vna_hash,
3528 vernaux->vna_flags, version);
3529 #endif
3531 vernaux = (ElfW(Vernaux) *) (((char *) vernaux) + vernaux->vna_next);
3533 next = vneed->vn_next;
3534 vneed = (ElfW(Verneed) *) (((char *) vneed) + next);
3535 } while (next);
3538 #if DEBUG_VERSION
3539 for (i = 0; i < v->nb_local_ver; i++) {
3540 if (v->local_ver[i] > 0) {
3541 printf ("%d: lib: %s, version %s\n",
3542 i, sym_versions[v->local_ver[i]].lib,
3543 sym_versions[v->local_ver[i]].version);
3546 #endif
3549 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
3550 is referenced by the user (so it should be added as DT_NEEDED in
3551 the generated ELF file) */
3552 ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
3554 ElfW(Ehdr) ehdr;
3555 ElfW(Shdr) *shdr, *sh, *sh1;
3556 int i, nb_syms, nb_dts, sym_bind, ret = -1;
3557 ElfW(Sym) *sym, *dynsym;
3558 ElfW(Dyn) *dt, *dynamic;
3560 char *dynstr;
3561 int sym_index;
3562 const char *name, *soname;
3563 struct versym_info v;
3565 full_read(fd, &ehdr, sizeof(ehdr));
3567 /* test CPU specific stuff */
3568 if (ehdr.e_ident[5] != ELFDATA2LSB ||
3569 ehdr.e_machine != EM_TCC_TARGET) {
3570 tcc_error_noabort("bad architecture");
3571 return -1;
3574 /* read sections */
3575 shdr = load_data(fd, ehdr.e_shoff, sizeof(ElfW(Shdr)) * ehdr.e_shnum);
3577 /* load dynamic section and dynamic symbols */
3578 nb_syms = 0;
3579 nb_dts = 0;
3580 dynamic = NULL;
3581 dynsym = NULL; /* avoid warning */
3582 dynstr = NULL; /* avoid warning */
3583 memset(&v, 0, sizeof v);
3585 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
3586 switch(sh->sh_type) {
3587 case SHT_DYNAMIC:
3588 nb_dts = sh->sh_size / sizeof(ElfW(Dyn));
3589 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
3590 break;
3591 case SHT_DYNSYM:
3592 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
3593 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
3594 sh1 = &shdr[sh->sh_link];
3595 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
3596 break;
3597 case SHT_GNU_verdef:
3598 v.verdef = load_data(fd, sh->sh_offset, sh->sh_size);
3599 break;
3600 case SHT_GNU_verneed:
3601 v.verneed = load_data(fd, sh->sh_offset, sh->sh_size);
3602 break;
3603 case SHT_GNU_versym:
3604 v.nb_versyms = sh->sh_size / sizeof(ElfW(Half));
3605 v.versym = load_data(fd, sh->sh_offset, sh->sh_size);
3606 break;
3607 default:
3608 break;
3612 if (!dynamic)
3613 goto the_end;
3615 /* compute the real library name */
3616 soname = tcc_basename(filename);
3617 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++)
3618 if (dt->d_tag == DT_SONAME)
3619 soname = dynstr + dt->d_un.d_val;
3621 /* if the dll is already loaded, do not load it */
3622 if (tcc_add_dllref(s1, soname, level)->found)
3623 goto ret_success;
3625 if (v.nb_versyms != nb_syms)
3626 tcc_free (v.versym), v.versym = NULL;
3627 else
3628 store_version(s1, &v, dynstr);
3630 /* add dynamic symbols in dynsym_section */
3631 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
3632 sym_bind = ELFW(ST_BIND)(sym->st_info);
3633 if (sym_bind == STB_LOCAL)
3634 continue;
3635 name = dynstr + sym->st_name;
3636 sym_index = set_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
3637 sym->st_info, sym->st_other, sym->st_shndx, name);
3638 if (v.versym) {
3639 ElfW(Half) vsym = v.versym[i];
3640 if ((vsym & 0x8000) == 0 && vsym > 0 && vsym < v.nb_local_ver)
3641 set_sym_version(s1, sym_index, v.local_ver[vsym]);
3645 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++)
3646 if (dt->d_tag == DT_RPATH)
3647 tcc_add_library_path(s1, dynstr + dt->d_un.d_val);
3649 /* load all referenced DLLs */
3650 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
3651 switch(dt->d_tag) {
3652 case DT_NEEDED:
3653 name = dynstr + dt->d_un.d_val;
3654 if (tcc_add_dllref(s1, name, -1))
3655 continue;
3656 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
3657 tcc_error_noabort("referenced dll '%s' not found", name);
3658 goto the_end;
3663 ret_success:
3664 ret = 0;
3665 the_end:
3666 tcc_free(dynstr);
3667 tcc_free(dynsym);
3668 tcc_free(dynamic);
3669 tcc_free(shdr);
3670 tcc_free(v.local_ver);
3671 tcc_free(v.verdef);
3672 tcc_free(v.verneed);
3673 tcc_free(v.versym);
3674 return ret;
3677 #define LD_TOK_NAME 256
3678 #define LD_TOK_EOF (-1)
3680 static int ld_inp(TCCState *s1)
3682 char b;
3683 if (s1->cc != -1) {
3684 int c = s1->cc;
3685 s1->cc = -1;
3686 return c;
3688 if (1 == read(s1->fd, &b, 1))
3689 return b;
3690 return CH_EOF;
3693 /* return next ld script token */
3694 static int ld_next(TCCState *s1, char *name, int name_size)
3696 int c, d, ch;
3697 char *q;
3699 redo:
3700 ch = ld_inp(s1);
3701 switch(ch) {
3702 case ' ':
3703 case '\t':
3704 case '\f':
3705 case '\v':
3706 case '\r':
3707 case '\n':
3708 goto redo;
3709 case '/':
3710 ch = ld_inp(s1);
3711 if (ch == '*') { /* comment */
3712 for (d = 0;; d = ch) {
3713 ch = ld_inp(s1);
3714 if (ch == CH_EOF || (ch == '/' && d == '*'))
3715 break;
3717 goto redo;
3718 } else {
3719 q = name;
3720 *q++ = '/';
3721 goto parse_name;
3723 break;
3724 case '\\':
3725 /* case 'a' ... 'z': */
3726 case 'a':
3727 case 'b':
3728 case 'c':
3729 case 'd':
3730 case 'e':
3731 case 'f':
3732 case 'g':
3733 case 'h':
3734 case 'i':
3735 case 'j':
3736 case 'k':
3737 case 'l':
3738 case 'm':
3739 case 'n':
3740 case 'o':
3741 case 'p':
3742 case 'q':
3743 case 'r':
3744 case 's':
3745 case 't':
3746 case 'u':
3747 case 'v':
3748 case 'w':
3749 case 'x':
3750 case 'y':
3751 case 'z':
3752 /* case 'A' ... 'z': */
3753 case 'A':
3754 case 'B':
3755 case 'C':
3756 case 'D':
3757 case 'E':
3758 case 'F':
3759 case 'G':
3760 case 'H':
3761 case 'I':
3762 case 'J':
3763 case 'K':
3764 case 'L':
3765 case 'M':
3766 case 'N':
3767 case 'O':
3768 case 'P':
3769 case 'Q':
3770 case 'R':
3771 case 'S':
3772 case 'T':
3773 case 'U':
3774 case 'V':
3775 case 'W':
3776 case 'X':
3777 case 'Y':
3778 case 'Z':
3779 case '_':
3780 case '.':
3781 case '$':
3782 case '~':
3783 q = name;
3784 parse_name:
3785 for(;;) {
3786 if (!((ch >= 'a' && ch <= 'z') ||
3787 (ch >= 'A' && ch <= 'Z') ||
3788 (ch >= '0' && ch <= '9') ||
3789 strchr("/.-_+=$:\\,~", ch)))
3790 break;
3791 if ((q - name) < name_size - 1) {
3792 *q++ = ch;
3794 ch = ld_inp(s1);
3796 s1->cc = ch;
3797 *q = '\0';
3798 c = LD_TOK_NAME;
3799 break;
3800 case CH_EOF:
3801 c = LD_TOK_EOF;
3802 break;
3803 default:
3804 c = ch;
3805 break;
3807 return c;
3810 static int ld_add_file(TCCState *s1, const char filename[])
3812 if (filename[0] == '/') {
3813 if (CONFIG_SYSROOT[0] == '\0'
3814 && tcc_add_file_internal(s1, filename, AFF_TYPE_BIN) == 0)
3815 return 0;
3816 filename = tcc_basename(filename);
3818 return tcc_add_dll(s1, filename, 0);
3821 static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
3823 char filename[1024], libname[1024];
3824 int t, group, nblibs = 0, ret = 0;
3825 char **libs = NULL;
3827 group = !strcmp(cmd, "GROUP");
3828 if (!as_needed)
3829 s1->new_undef_sym = 0;
3830 t = ld_next(s1, filename, sizeof(filename));
3831 if (t != '(') {
3832 tcc_error_noabort("( expected");
3833 ret = -1;
3834 goto lib_parse_error;
3836 t = ld_next(s1, filename, sizeof(filename));
3837 for(;;) {
3838 libname[0] = '\0';
3839 if (t == LD_TOK_EOF) {
3840 tcc_error_noabort("unexpected end of file");
3841 ret = -1;
3842 goto lib_parse_error;
3843 } else if (t == ')') {
3844 break;
3845 } else if (t == '-') {
3846 t = ld_next(s1, filename, sizeof(filename));
3847 if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
3848 tcc_error_noabort("library name expected");
3849 ret = -1;
3850 goto lib_parse_error;
3852 pstrcpy(libname, sizeof libname, &filename[1]);
3853 if (s1->static_link) {
3854 snprintf(filename, sizeof filename, "lib%s.a", libname);
3855 } else {
3856 snprintf(filename, sizeof filename, "lib%s.so", libname);
3858 } else if (t != LD_TOK_NAME) {
3859 tcc_error_noabort("filename expected");
3860 ret = -1;
3861 goto lib_parse_error;
3863 if (!strcmp(filename, "AS_NEEDED")) {
3864 ret = ld_add_file_list(s1, cmd, 1);
3865 if (ret)
3866 goto lib_parse_error;
3867 } else {
3868 /* TODO: Implement AS_NEEDED support. Ignore it for now */
3869 if (!as_needed) {
3870 ret = ld_add_file(s1, filename);
3871 if (ret)
3872 goto lib_parse_error;
3873 if (group) {
3874 /* Add the filename *and* the libname to avoid future conversions */
3875 dynarray_add(&libs, &nblibs, tcc_strdup(filename));
3876 if (libname[0] != '\0')
3877 dynarray_add(&libs, &nblibs, tcc_strdup(libname));
3881 t = ld_next(s1, filename, sizeof(filename));
3882 if (t == ',') {
3883 t = ld_next(s1, filename, sizeof(filename));
3886 if (group && !as_needed) {
3887 while (s1->new_undef_sym) {
3888 int i;
3889 s1->new_undef_sym = 0;
3890 for (i = 0; i < nblibs; i ++)
3891 ld_add_file(s1, libs[i]);
3894 lib_parse_error:
3895 dynarray_reset(&libs, &nblibs);
3896 return ret;
3899 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3900 files */
3901 ST_FUNC int tcc_load_ldscript(TCCState *s1, int fd)
3903 char cmd[64];
3904 char filename[1024];
3905 int t, ret;
3907 s1->fd = fd;
3908 s1->cc = -1;
3909 for(;;) {
3910 t = ld_next(s1, cmd, sizeof(cmd));
3911 if (t == LD_TOK_EOF)
3912 return 0;
3913 else if (t != LD_TOK_NAME)
3914 return -1;
3915 if (!strcmp(cmd, "INPUT") ||
3916 !strcmp(cmd, "GROUP")) {
3917 ret = ld_add_file_list(s1, cmd, 0);
3918 if (ret)
3919 return ret;
3920 } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
3921 !strcmp(cmd, "TARGET")) {
3922 /* ignore some commands */
3923 t = ld_next(s1, cmd, sizeof(cmd));
3924 if (t != '(') {
3925 tcc_error_noabort("( expected");
3926 return -1;
3928 for(;;) {
3929 t = ld_next(s1, filename, sizeof(filename));
3930 if (t == LD_TOK_EOF) {
3931 tcc_error_noabort("unexpected end of file");
3932 return -1;
3933 } else if (t == ')') {
3934 break;
3937 } else {
3938 return -1;
3941 return 0;
3943 #endif /* !ELF_OBJ_ONLY */