Implement function alignment via attributes
[tinycc.git] / tccelf.c
blobe979a4c1ce3f5504b5981a76b3c9d4488cfc8f52
1 /*
2 * ELF file handling for TCC
4 * Copyright (c) 2001-2004 Fabrice Bellard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include "tcc.h"
23 /* Define this to get some debug output during relocation processing. */
24 #undef DEBUG_RELOC
26 /********************************************************/
27 /* global variables */
29 ST_DATA Section *text_section, *data_section, *bss_section; /* predefined sections */
30 ST_DATA Section *common_section;
31 ST_DATA Section *cur_text_section; /* current section where function code is generated */
32 #ifdef CONFIG_TCC_ASM
33 ST_DATA Section *last_text_section; /* to handle .previous asm directive */
34 #endif
35 #ifdef CONFIG_TCC_BCHECK
36 /* bound check related sections */
37 ST_DATA Section *bounds_section; /* contains global data bound description */
38 ST_DATA Section *lbounds_section; /* contains local data bound description */
39 #endif
40 /* symbol sections */
41 ST_DATA Section *symtab_section;
42 /* debug sections */
43 ST_DATA Section *stab_section, *stabstr_section;
45 /* XXX: avoid static variable */
46 static int new_undef_sym = 0; /* Is there a new undefined sym since last new_undef_sym() */
48 /* special flag to indicate that the section should not be linked to the other ones */
49 #define SHF_PRIVATE 0x80000000
50 /* section is dynsymtab_section */
51 #define SHF_DYNSYM 0x40000000
53 /* ------------------------------------------------------------------------- */
55 ST_FUNC void tccelf_new(TCCState *s)
57 /* no section zero */
58 dynarray_add(&s->sections, &s->nb_sections, NULL);
60 /* create standard sections */
61 text_section = new_section(s, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
62 data_section = new_section(s, ".data", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
63 bss_section = new_section(s, ".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
64 common_section = new_section(s, ".common", SHT_NOBITS, SHF_PRIVATE);
65 common_section->sh_num = SHN_COMMON;
67 /* symbols are always generated for linking stage */
68 symtab_section = new_symtab(s, ".symtab", SHT_SYMTAB, 0,
69 ".strtab",
70 ".hashtab", SHF_PRIVATE);
71 s->symtab = symtab_section;
73 /* private symbol table for dynamic symbols */
74 s->dynsymtab_section = new_symtab(s, ".dynsymtab", SHT_SYMTAB, SHF_PRIVATE|SHF_DYNSYM,
75 ".dynstrtab",
76 ".dynhashtab", SHF_PRIVATE);
77 get_sym_attr(s, 0, 1);
80 #ifdef CONFIG_TCC_BCHECK
81 ST_FUNC void tccelf_bounds_new(TCCState *s)
83 /* create bounds sections */
84 bounds_section = new_section(s, ".bounds",
85 SHT_PROGBITS, SHF_ALLOC);
86 lbounds_section = new_section(s, ".lbounds",
87 SHT_PROGBITS, SHF_ALLOC);
89 #endif
91 ST_FUNC void tccelf_stab_new(TCCState *s)
93 stab_section = new_section(s, ".stab", SHT_PROGBITS, 0);
94 stab_section->sh_entsize = sizeof(Stab_Sym);
95 stabstr_section = new_section(s, ".stabstr", SHT_STRTAB, 0);
96 put_elf_str(stabstr_section, "");
97 stab_section->link = stabstr_section;
98 /* put first entry */
99 put_stabs("", 0, 0, 0, 0);
102 static void free_section(Section *s)
104 tcc_free(s->data);
107 ST_FUNC void tccelf_delete(TCCState *s1)
109 int i;
111 /* free all sections */
112 for(i = 1; i < s1->nb_sections; i++)
113 free_section(s1->sections[i]);
114 dynarray_reset(&s1->sections, &s1->nb_sections);
116 for(i = 0; i < s1->nb_priv_sections; i++)
117 free_section(s1->priv_sections[i]);
118 dynarray_reset(&s1->priv_sections, &s1->nb_priv_sections);
120 /* free any loaded DLLs */
121 #ifdef TCC_IS_NATIVE
122 for ( i = 0; i < s1->nb_loaded_dlls; i++) {
123 DLLReference *ref = s1->loaded_dlls[i];
124 if ( ref->handle )
125 # ifdef _WIN32
126 FreeLibrary((HMODULE)ref->handle);
127 # else
128 dlclose(ref->handle);
129 # endif
131 #endif
132 /* free loaded dlls array */
133 dynarray_reset(&s1->loaded_dlls, &s1->nb_loaded_dlls);
134 tcc_free(s1->sym_attrs);
136 symtab_section = NULL; /* for tccrun.c:rt_printline() */
139 /* save section data state */
140 ST_FUNC void tccelf_begin_file(TCCState *s1)
142 Section *s; int i;
143 for (i = 1; i < s1->nb_sections; i++) {
144 s = s1->sections[i];
145 s->sh_offset = s->data_offset;
147 /* disable symbol hashing during compilation */
148 s = s1->symtab, s->reloc = s->hash, s->hash = NULL;
149 #if defined TCC_TARGET_X86_64 && defined TCC_TARGET_PE
150 s1->uw_sym = 0;
151 #endif
154 /* At the end of compilation, convert any UNDEF syms to global, and merge
155 with previously existing symbols */
156 ST_FUNC void tccelf_end_file(TCCState *s1)
158 Section *s = s1->symtab;
159 int first_sym, nb_syms, *tr, i;
161 first_sym = s->sh_offset / sizeof (ElfSym);
162 nb_syms = s->data_offset / sizeof (ElfSym) - first_sym;
163 s->data_offset = s->sh_offset;
164 s->link->data_offset = s->link->sh_offset;
165 s->hash = s->reloc, s->reloc = NULL;
166 tr = tcc_mallocz(nb_syms * sizeof *tr);
168 for (i = 0; i < nb_syms; ++i) {
169 ElfSym *sym = (ElfSym*)s->data + first_sym + i;
170 if (sym->st_shndx == SHN_UNDEF
171 && ELFW(ST_BIND)(sym->st_info) == STB_LOCAL)
172 sym->st_info = ELFW(ST_INFO)(STB_GLOBAL, ELFW(ST_TYPE)(sym->st_info));
173 tr[i] = set_elf_sym(s, sym->st_value, sym->st_size, sym->st_info,
174 sym->st_other, sym->st_shndx, s->link->data + sym->st_name);
176 /* now update relocations */
177 for (i = 1; i < s1->nb_sections; i++) {
178 Section *sr = s1->sections[i];
179 if (sr->sh_type == SHT_RELX && sr->link == s) {
180 ElfW_Rel *rel = (ElfW_Rel*)(sr->data + sr->sh_offset);
181 ElfW_Rel *rel_end = (ElfW_Rel*)(sr->data + sr->data_offset);
182 for (; rel < rel_end; ++rel) {
183 int n = ELFW(R_SYM)(rel->r_info) - first_sym;
184 //if (n < 0) tcc_error("internal: invalid symbol index in relocation");
185 rel->r_info = ELFW(R_INFO)(tr[n], ELFW(R_TYPE)(rel->r_info));
189 tcc_free(tr);
192 ST_FUNC Section *new_section(TCCState *s1, const char *name, int sh_type, int sh_flags)
194 Section *sec;
196 sec = tcc_mallocz(sizeof(Section) + strlen(name));
197 strcpy(sec->name, name);
198 sec->sh_type = sh_type;
199 sec->sh_flags = sh_flags;
200 switch(sh_type) {
201 case SHT_HASH:
202 case SHT_REL:
203 case SHT_RELA:
204 case SHT_DYNSYM:
205 case SHT_SYMTAB:
206 case SHT_DYNAMIC:
207 sec->sh_addralign = 4;
208 break;
209 case SHT_STRTAB:
210 sec->sh_addralign = 1;
211 break;
212 default:
213 sec->sh_addralign = PTR_SIZE; /* gcc/pcc default alignment */
214 break;
217 if (sh_flags & SHF_PRIVATE) {
218 dynarray_add(&s1->priv_sections, &s1->nb_priv_sections, sec);
219 } else {
220 sec->sh_num = s1->nb_sections;
221 dynarray_add(&s1->sections, &s1->nb_sections, sec);
224 return sec;
227 ST_FUNC Section *new_symtab(TCCState *s1,
228 const char *symtab_name, int sh_type, int sh_flags,
229 const char *strtab_name,
230 const char *hash_name, int hash_sh_flags)
232 Section *symtab, *strtab, *hash;
233 int *ptr, nb_buckets;
235 symtab = new_section(s1, symtab_name, sh_type, sh_flags);
236 symtab->sh_entsize = sizeof(ElfW(Sym));
237 strtab = new_section(s1, strtab_name, SHT_STRTAB, sh_flags);
238 put_elf_str(strtab, "");
239 symtab->link = strtab;
240 put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL);
242 nb_buckets = 1;
244 hash = new_section(s1, hash_name, SHT_HASH, hash_sh_flags);
245 hash->sh_entsize = sizeof(int);
246 symtab->hash = hash;
247 hash->link = symtab;
249 ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int));
250 ptr[0] = nb_buckets;
251 ptr[1] = 1;
252 memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int));
253 return symtab;
256 /* realloc section and set its content to zero */
257 ST_FUNC void section_realloc(Section *sec, unsigned long new_size)
259 unsigned long size;
260 unsigned char *data;
262 size = sec->data_allocated;
263 if (size == 0)
264 size = 1;
265 while (size < new_size)
266 size = size * 2;
267 data = tcc_realloc(sec->data, size);
268 memset(data + sec->data_allocated, 0, size - sec->data_allocated);
269 sec->data = data;
270 sec->data_allocated = size;
273 /* reserve at least 'size' bytes aligned per 'align' in section
274 'sec' from current offset, and return the aligned offset */
275 ST_FUNC size_t section_add(Section *sec, addr_t size, int align)
277 size_t offset, offset1;
279 offset = (sec->data_offset + align - 1) & -align;
280 offset1 = offset + size;
281 if (sec->sh_type != SHT_NOBITS && offset1 > sec->data_allocated)
282 section_realloc(sec, offset1);
283 sec->data_offset = offset1;
284 if (align > sec->sh_addralign)
285 sec->sh_addralign = align;
286 return offset;
289 /* reserve at least 'size' bytes in section 'sec' from
290 sec->data_offset. */
291 ST_FUNC void *section_ptr_add(Section *sec, addr_t size)
293 size_t offset = section_add(sec, size, 1);
294 return sec->data + offset;
297 /* reserve at least 'size' bytes from section start */
298 ST_FUNC void section_reserve(Section *sec, unsigned long size)
300 if (size > sec->data_allocated)
301 section_realloc(sec, size);
302 if (size > sec->data_offset)
303 sec->data_offset = size;
306 /* return a reference to a section, and create it if it does not
307 exists */
308 ST_FUNC Section *find_section(TCCState *s1, const char *name)
310 Section *sec;
311 int i;
312 for(i = 1; i < s1->nb_sections; i++) {
313 sec = s1->sections[i];
314 if (!strcmp(name, sec->name))
315 return sec;
317 /* sections are created as PROGBITS */
318 return new_section(s1, name, SHT_PROGBITS, SHF_ALLOC);
321 /* ------------------------------------------------------------------------- */
323 ST_FUNC int put_elf_str(Section *s, const char *sym)
325 int offset, len;
326 char *ptr;
328 len = strlen(sym) + 1;
329 offset = s->data_offset;
330 ptr = section_ptr_add(s, len);
331 memmove(ptr, sym, len);
332 return offset;
335 /* elf symbol hashing function */
336 static unsigned long elf_hash(const unsigned char *name)
338 unsigned long h = 0, g;
340 while (*name) {
341 h = (h << 4) + *name++;
342 g = h & 0xf0000000;
343 if (g)
344 h ^= g >> 24;
345 h &= ~g;
347 return h;
350 /* rebuild hash table of section s */
351 /* NOTE: we do factorize the hash table code to go faster */
352 static void rebuild_hash(Section *s, unsigned int nb_buckets)
354 ElfW(Sym) *sym;
355 int *ptr, *hash, nb_syms, sym_index, h;
356 unsigned char *strtab;
358 strtab = s->link->data;
359 nb_syms = s->data_offset / sizeof(ElfW(Sym));
361 if (!nb_buckets)
362 nb_buckets = ((int*)s->hash->data)[0];
364 s->hash->data_offset = 0;
365 ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int));
366 ptr[0] = nb_buckets;
367 ptr[1] = nb_syms;
368 ptr += 2;
369 hash = ptr;
370 memset(hash, 0, (nb_buckets + 1) * sizeof(int));
371 ptr += nb_buckets + 1;
373 sym = (ElfW(Sym) *)s->data + 1;
374 for(sym_index = 1; sym_index < nb_syms; sym_index++) {
375 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
376 h = elf_hash(strtab + sym->st_name) % nb_buckets;
377 *ptr = hash[h];
378 hash[h] = sym_index;
379 } else {
380 *ptr = 0;
382 ptr++;
383 sym++;
387 /* return the symbol number */
388 ST_FUNC int put_elf_sym(Section *s, addr_t value, unsigned long size,
389 int info, int other, int shndx, const char *name)
391 int name_offset, sym_index;
392 int nbuckets, h;
393 ElfW(Sym) *sym;
394 Section *hs;
396 sym = section_ptr_add(s, sizeof(ElfW(Sym)));
397 if (name && name[0])
398 name_offset = put_elf_str(s->link, name);
399 else
400 name_offset = 0;
401 /* XXX: endianness */
402 sym->st_name = name_offset;
403 sym->st_value = value;
404 sym->st_size = size;
405 sym->st_info = info;
406 sym->st_other = other;
407 sym->st_shndx = shndx;
408 sym_index = sym - (ElfW(Sym) *)s->data;
409 hs = s->hash;
410 if (hs) {
411 int *ptr, *base;
412 ptr = section_ptr_add(hs, sizeof(int));
413 base = (int *)hs->data;
414 /* only add global or weak symbols. */
415 if (ELFW(ST_BIND)(info) != STB_LOCAL) {
416 /* add another hashing entry */
417 nbuckets = base[0];
418 h = elf_hash((unsigned char *)s->link->data + name_offset) % nbuckets;
419 *ptr = base[2 + h];
420 base[2 + h] = sym_index;
421 base[1]++;
422 /* we resize the hash table */
423 hs->nb_hashed_syms++;
424 if (hs->nb_hashed_syms > 2 * nbuckets) {
425 rebuild_hash(s, 2 * nbuckets);
427 } else {
428 *ptr = 0;
429 base[1]++;
432 return sym_index;
435 ST_FUNC int find_elf_sym(Section *s, const char *name)
437 ElfW(Sym) *sym;
438 Section *hs;
439 int nbuckets, sym_index, h;
440 const char *name1;
442 hs = s->hash;
443 if (!hs)
444 return 0;
445 nbuckets = ((int *)hs->data)[0];
446 h = elf_hash((unsigned char *) name) % nbuckets;
447 sym_index = ((int *)hs->data)[2 + h];
448 while (sym_index != 0) {
449 sym = &((ElfW(Sym) *)s->data)[sym_index];
450 name1 = (char *) s->link->data + sym->st_name;
451 if (!strcmp(name, name1))
452 return sym_index;
453 sym_index = ((int *)hs->data)[2 + nbuckets + sym_index];
455 return 0;
458 /* return elf symbol value, signal error if 'err' is nonzero */
459 ST_FUNC addr_t get_elf_sym_addr(TCCState *s, const char *name, int err)
461 int sym_index;
462 ElfW(Sym) *sym;
464 sym_index = find_elf_sym(s->symtab, name);
465 sym = &((ElfW(Sym) *)s->symtab->data)[sym_index];
466 if (!sym_index || sym->st_shndx == SHN_UNDEF) {
467 if (err)
468 tcc_error("%s not defined", name);
469 return 0;
471 return sym->st_value;
474 /* return elf symbol value */
475 LIBTCCAPI void *tcc_get_symbol(TCCState *s, const char *name)
477 return (void*)(uintptr_t)get_elf_sym_addr(s, name, 0);
480 #if defined TCC_IS_NATIVE || defined TCC_TARGET_PE
481 /* return elf symbol value or error */
482 ST_FUNC void* tcc_get_symbol_err(TCCState *s, const char *name)
484 return (void*)(uintptr_t)get_elf_sym_addr(s, name, 1);
486 #endif
488 /* add an elf symbol : check if it is already defined and patch
489 it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
490 ST_FUNC int set_elf_sym(Section *s, addr_t value, unsigned long size,
491 int info, int other, int shndx, const char *name)
493 ElfW(Sym) *esym;
494 int sym_bind, sym_index, sym_type, esym_bind;
495 unsigned char sym_vis, esym_vis, new_vis;
497 sym_bind = ELFW(ST_BIND)(info);
498 sym_type = ELFW(ST_TYPE)(info);
499 sym_vis = ELFW(ST_VISIBILITY)(other);
501 if (sym_bind != STB_LOCAL) {
502 /* we search global or weak symbols */
503 sym_index = find_elf_sym(s, name);
504 if (!sym_index)
505 goto do_def;
506 esym = &((ElfW(Sym) *)s->data)[sym_index];
507 if (esym->st_value == value && esym->st_size == size && esym->st_info == info
508 && esym->st_other == other && esym->st_shndx == shndx)
509 return sym_index;
510 if (esym->st_shndx != SHN_UNDEF) {
511 esym_bind = ELFW(ST_BIND)(esym->st_info);
512 /* propagate the most constraining visibility */
513 /* STV_DEFAULT(0)<STV_PROTECTED(3)<STV_HIDDEN(2)<STV_INTERNAL(1) */
514 esym_vis = ELFW(ST_VISIBILITY)(esym->st_other);
515 if (esym_vis == STV_DEFAULT) {
516 new_vis = sym_vis;
517 } else if (sym_vis == STV_DEFAULT) {
518 new_vis = esym_vis;
519 } else {
520 new_vis = (esym_vis < sym_vis) ? esym_vis : sym_vis;
522 esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
523 | new_vis;
524 other = esym->st_other; /* in case we have to patch esym */
525 if (shndx == SHN_UNDEF) {
526 /* ignore adding of undefined symbol if the
527 corresponding symbol is already defined */
528 } else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) {
529 /* global overrides weak, so patch */
530 goto do_patch;
531 } else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) {
532 /* weak is ignored if already global */
533 } else if (sym_bind == STB_WEAK && esym_bind == STB_WEAK) {
534 /* keep first-found weak definition, ignore subsequents */
535 } else if (sym_vis == STV_HIDDEN || sym_vis == STV_INTERNAL) {
536 /* ignore hidden symbols after */
537 } else if ((esym->st_shndx == SHN_COMMON
538 || esym->st_shndx == bss_section->sh_num)
539 && (shndx < SHN_LORESERVE
540 && shndx != bss_section->sh_num)) {
541 /* data symbol gets precedence over common/bss */
542 goto do_patch;
543 } else if (shndx == SHN_COMMON || shndx == bss_section->sh_num) {
544 /* data symbol keeps precedence over common/bss */
545 } else if (s->sh_flags & SHF_DYNSYM) {
546 /* we accept that two DLL define the same symbol */
547 } else if (esym->st_other & ST_ASM_SET) {
548 /* If the existing symbol came from an asm .set
549 we can override. */
550 goto do_patch;
551 } else {
552 #if 0
553 printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",
554 sym_bind, shndx, new_vis, esym_bind, esym->st_shndx, esym_vis);
555 #endif
556 tcc_error_noabort("'%s' defined twice", name);
558 } else {
559 do_patch:
560 esym->st_info = ELFW(ST_INFO)(sym_bind, sym_type);
561 esym->st_shndx = shndx;
562 new_undef_sym = 1;
563 esym->st_value = value;
564 esym->st_size = size;
565 esym->st_other = other;
567 } else {
568 do_def:
569 sym_index = put_elf_sym(s, value, size,
570 ELFW(ST_INFO)(sym_bind, sym_type), other,
571 shndx, name);
573 return sym_index;
576 /* put relocation */
577 ST_FUNC void put_elf_reloca(Section *symtab, Section *s, unsigned long offset,
578 int type, int symbol, addr_t addend)
580 char buf[256];
581 Section *sr;
582 ElfW_Rel *rel;
584 sr = s->reloc;
585 if (!sr) {
586 /* if no relocation section, create it */
587 snprintf(buf, sizeof(buf), REL_SECTION_FMT, s->name);
588 /* if the symtab is allocated, then we consider the relocation
589 are also */
590 sr = new_section(tcc_state, buf, SHT_RELX, symtab->sh_flags);
591 sr->sh_entsize = sizeof(ElfW_Rel);
592 sr->link = symtab;
593 sr->sh_info = s->sh_num;
594 s->reloc = sr;
596 rel = section_ptr_add(sr, sizeof(ElfW_Rel));
597 rel->r_offset = offset;
598 rel->r_info = ELFW(R_INFO)(symbol, type);
599 #if SHT_RELX == SHT_RELA
600 rel->r_addend = addend;
601 #else
602 if (addend)
603 tcc_error("non-zero addend on REL architecture");
604 #endif
607 ST_FUNC void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
608 int type, int symbol)
610 put_elf_reloca(symtab, s, offset, type, symbol, 0);
613 /* Remove relocations for section S->reloc starting at oldrelocoffset
614 that are to the same place, retaining the last of them. As side effect
615 the relocations are sorted. Possibly reduces the number of relocs. */
616 ST_FUNC void squeeze_multi_relocs(Section *s, size_t oldrelocoffset)
618 Section *sr = s->reloc;
619 ElfW_Rel *r, *dest;
620 ssize_t a;
621 ElfW(Addr) addr;
623 if (oldrelocoffset + sizeof(*r) >= sr->data_offset)
624 return;
625 /* The relocs we're dealing with are the result of initializer parsing.
626 So they will be mostly in order and there aren't many of them.
627 Secondly we need a stable sort (which qsort isn't). We use
628 a simple insertion sort. */
629 for (a = oldrelocoffset + sizeof(*r); a < sr->data_offset; a += sizeof(*r)) {
630 ssize_t i = a - sizeof(*r);
631 addr = ((ElfW_Rel*)(sr->data + a))->r_offset;
632 for (; i >= (ssize_t)oldrelocoffset &&
633 ((ElfW_Rel*)(sr->data + i))->r_offset > addr; i -= sizeof(*r)) {
634 ElfW_Rel tmp = *(ElfW_Rel*)(sr->data + a);
635 *(ElfW_Rel*)(sr->data + a) = *(ElfW_Rel*)(sr->data + i);
636 *(ElfW_Rel*)(sr->data + i) = tmp;
640 r = (ElfW_Rel*)(sr->data + oldrelocoffset);
641 dest = r;
642 for (; r < (ElfW_Rel*)(sr->data + sr->data_offset); r++) {
643 if (dest->r_offset != r->r_offset)
644 dest++;
645 *dest = *r;
647 sr->data_offset = (unsigned char*)dest - sr->data + sizeof(*r);
650 /* put stab debug information */
652 ST_FUNC void put_stabs(const char *str, int type, int other, int desc,
653 unsigned long value)
655 Stab_Sym *sym;
657 sym = section_ptr_add(stab_section, sizeof(Stab_Sym));
658 if (str) {
659 sym->n_strx = put_elf_str(stabstr_section, str);
660 } else {
661 sym->n_strx = 0;
663 sym->n_type = type;
664 sym->n_other = other;
665 sym->n_desc = desc;
666 sym->n_value = value;
669 ST_FUNC void put_stabs_r(const char *str, int type, int other, int desc,
670 unsigned long value, Section *sec, int sym_index)
672 put_stabs(str, type, other, desc, value);
673 put_elf_reloc(symtab_section, stab_section,
674 stab_section->data_offset - sizeof(unsigned int),
675 R_DATA_32, sym_index);
678 ST_FUNC void put_stabn(int type, int other, int desc, int value)
680 put_stabs(NULL, type, other, desc, value);
683 ST_FUNC void put_stabd(int type, int other, int desc)
685 put_stabs(NULL, type, other, desc, 0);
688 ST_FUNC struct sym_attr *get_sym_attr(TCCState *s1, int index, int alloc)
690 int n;
691 struct sym_attr *tab;
693 if (index >= s1->nb_sym_attrs) {
694 if (!alloc)
695 return s1->sym_attrs;
696 /* find immediately bigger power of 2 and reallocate array */
697 n = 1;
698 while (index >= n)
699 n *= 2;
700 tab = tcc_realloc(s1->sym_attrs, n * sizeof(*s1->sym_attrs));
701 s1->sym_attrs = tab;
702 memset(s1->sym_attrs + s1->nb_sym_attrs, 0,
703 (n - s1->nb_sym_attrs) * sizeof(*s1->sym_attrs));
704 s1->nb_sym_attrs = n;
706 return &s1->sym_attrs[index];
709 /* Browse each elem of type <type> in section <sec> starting at elem <startoff>
710 using variable <elem> */
711 #define for_each_elem(sec, startoff, elem, type) \
712 for (elem = (type *) sec->data + startoff; \
713 elem < (type *) (sec->data + sec->data_offset); elem++)
715 /* In an ELF file symbol table, the local symbols must appear below
716 the global and weak ones. Since TCC cannot sort it while generating
717 the code, we must do it after. All the relocation tables are also
718 modified to take into account the symbol table sorting */
719 static void sort_syms(TCCState *s1, Section *s)
721 int *old_to_new_syms;
722 ElfW(Sym) *new_syms;
723 int nb_syms, i;
724 ElfW(Sym) *p, *q;
725 ElfW_Rel *rel;
726 Section *sr;
727 int type, sym_index;
729 nb_syms = s->data_offset / sizeof(ElfW(Sym));
730 new_syms = tcc_malloc(nb_syms * sizeof(ElfW(Sym)));
731 old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
733 /* first pass for local symbols */
734 p = (ElfW(Sym) *)s->data;
735 q = new_syms;
736 for(i = 0; i < nb_syms; i++) {
737 if (ELFW(ST_BIND)(p->st_info) == STB_LOCAL) {
738 old_to_new_syms[i] = q - new_syms;
739 *q++ = *p;
741 p++;
743 /* save the number of local symbols in section header */
744 if( s->sh_size ) /* this 'if' makes IDA happy */
745 s->sh_info = q - new_syms;
747 /* then second pass for non local symbols */
748 p = (ElfW(Sym) *)s->data;
749 for(i = 0; i < nb_syms; i++) {
750 if (ELFW(ST_BIND)(p->st_info) != STB_LOCAL) {
751 old_to_new_syms[i] = q - new_syms;
752 *q++ = *p;
754 p++;
757 /* we copy the new symbols to the old */
758 memcpy(s->data, new_syms, nb_syms * sizeof(ElfW(Sym)));
759 tcc_free(new_syms);
761 /* now we modify all the relocations */
762 for(i = 1; i < s1->nb_sections; i++) {
763 sr = s1->sections[i];
764 if (sr->sh_type == SHT_RELX && sr->link == s) {
765 for_each_elem(sr, 0, rel, ElfW_Rel) {
766 sym_index = ELFW(R_SYM)(rel->r_info);
767 type = ELFW(R_TYPE)(rel->r_info);
768 sym_index = old_to_new_syms[sym_index];
769 rel->r_info = ELFW(R_INFO)(sym_index, type);
774 tcc_free(old_to_new_syms);
777 /* relocate symbol table, resolve undefined symbols if do_resolve is
778 true and output error if undefined symbol. */
779 ST_FUNC void relocate_syms(TCCState *s1, Section *symtab, int do_resolve)
781 ElfW(Sym) *sym;
782 int sym_bind, sh_num;
783 const char *name;
785 for_each_elem(symtab, 1, sym, ElfW(Sym)) {
786 sh_num = sym->st_shndx;
787 if (sh_num == SHN_UNDEF) {
788 name = (char *) s1->symtab->link->data + sym->st_name;
789 /* Use ld.so to resolve symbol for us (for tcc -run) */
790 if (do_resolve) {
791 #if defined TCC_IS_NATIVE && !defined TCC_TARGET_PE
792 void *addr = dlsym(RTLD_DEFAULT, name);
793 if (addr) {
794 sym->st_value = (addr_t) addr;
795 #ifdef DEBUG_RELOC
796 printf ("relocate_sym: %s -> 0x%lx\n", name, sym->st_value);
797 #endif
798 goto found;
800 #endif
801 /* if dynamic symbol exist, it will be used in relocate_section */
802 } else if (s1->dynsym && find_elf_sym(s1->dynsym, name))
803 goto found;
804 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
805 it */
806 if (!strcmp(name, "_fp_hw"))
807 goto found;
808 /* only weak symbols are accepted to be undefined. Their
809 value is zero */
810 sym_bind = ELFW(ST_BIND)(sym->st_info);
811 if (sym_bind == STB_WEAK)
812 sym->st_value = 0;
813 else
814 tcc_error_noabort("undefined symbol '%s'", name);
815 } else if (sh_num < SHN_LORESERVE) {
816 /* add section base */
817 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
819 found: ;
823 /* relocate a given section (CPU dependent) by applying the relocations
824 in the associated relocation section */
825 ST_FUNC void relocate_section(TCCState *s1, Section *s)
827 Section *sr = s->reloc;
828 ElfW_Rel *rel;
829 ElfW(Sym) *sym;
830 int type, sym_index;
831 unsigned char *ptr;
832 addr_t tgt, addr;
834 relocate_init(sr);
836 for_each_elem(sr, 0, rel, ElfW_Rel) {
837 ptr = s->data + rel->r_offset;
838 sym_index = ELFW(R_SYM)(rel->r_info);
839 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
840 type = ELFW(R_TYPE)(rel->r_info);
841 tgt = sym->st_value;
842 #if SHT_RELX == SHT_RELA
843 tgt += rel->r_addend;
844 #endif
845 addr = s->sh_addr + rel->r_offset;
846 relocate(s1, rel, type, ptr, addr, tgt);
848 /* if the relocation is allocated, we change its symbol table */
849 if (sr->sh_flags & SHF_ALLOC)
850 sr->link = s1->dynsym;
853 /* relocate relocation table in 'sr' */
854 static void relocate_rel(TCCState *s1, Section *sr)
856 Section *s;
857 ElfW_Rel *rel;
859 s = s1->sections[sr->sh_info];
860 for_each_elem(sr, 0, rel, ElfW_Rel)
861 rel->r_offset += s->sh_addr;
864 /* count the number of dynamic relocations so that we can reserve
865 their space */
866 static int prepare_dynamic_rel(TCCState *s1, Section *sr)
868 ElfW_Rel *rel;
869 int sym_index, type, count;
871 count = 0;
872 for_each_elem(sr, 0, rel, ElfW_Rel) {
873 sym_index = ELFW(R_SYM)(rel->r_info);
874 type = ELFW(R_TYPE)(rel->r_info);
875 switch(type) {
876 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
877 #if defined(TCC_TARGET_I386)
878 case R_386_32:
879 if (!get_sym_attr(s1, sym_index, 0)->dyn_index
880 && ((ElfW(Sym)*)symtab_section->data + sym_index)->st_shndx == SHN_UNDEF) {
881 /* don't fixup unresolved (weak) symbols */
882 rel->r_info = ELFW(R_INFO)(sym_index, R_386_RELATIVE);
883 break;
885 #elif defined(TCC_TARGET_X86_64)
886 case R_X86_64_32:
887 case R_X86_64_32S:
888 case R_X86_64_64:
889 #endif
890 count++;
891 break;
892 #if defined(TCC_TARGET_I386)
893 case R_386_PC32:
894 #elif defined(TCC_TARGET_X86_64)
895 case R_X86_64_PC32:
896 #endif
897 if (get_sym_attr(s1, sym_index, 0)->dyn_index)
898 count++;
899 break;
900 #endif
901 default:
902 break;
905 if (count) {
906 /* allocate the section */
907 sr->sh_flags |= SHF_ALLOC;
908 sr->sh_size = count * sizeof(ElfW_Rel);
910 return count;
913 static void build_got(TCCState *s1)
915 /* if no got, then create it */
916 s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
917 s1->got->sh_entsize = 4;
918 set_elf_sym(symtab_section, 0, 4, ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
919 0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
920 /* keep space for _DYNAMIC pointer and two dummy got entries */
921 section_ptr_add(s1->got, 3 * PTR_SIZE);
924 /* Create a GOT and (for function call) a PLT entry corresponding to a symbol
925 in s1->symtab. When creating the dynamic symbol table entry for the GOT
926 relocation, use 'size' and 'info' for the corresponding symbol metadata.
927 Returns the offset of the GOT or (if any) PLT entry. */
928 static struct sym_attr * put_got_entry(TCCState *s1, int dyn_reloc_type,
929 unsigned long size,
930 int info, int sym_index)
932 int need_plt_entry;
933 const char *name;
934 ElfW(Sym) *sym;
935 struct sym_attr *attr;
936 unsigned got_offset;
937 char plt_name[100];
938 int len;
940 need_plt_entry = (dyn_reloc_type == R_JMP_SLOT);
941 attr = get_sym_attr(s1, sym_index, 1);
943 /* In case a function is both called and its address taken 2 GOT entries
944 are created, one for taking the address (GOT) and the other for the PLT
945 entry (PLTGOT). */
946 if (need_plt_entry ? attr->plt_offset : attr->got_offset)
947 return attr;
949 /* create the GOT entry */
950 got_offset = s1->got->data_offset;
951 section_ptr_add(s1->got, PTR_SIZE);
953 /* Create the GOT relocation that will insert the address of the object or
954 function of interest in the GOT entry. This is a static relocation for
955 memory output (dlsym will give us the address of symbols) and dynamic
956 relocation otherwise (executable and DLLs). The relocation should be
957 done lazily for GOT entry with *_JUMP_SLOT relocation type (the one
958 associated to a PLT entry) but is currently done at load time for an
959 unknown reason. */
961 sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
962 name = (char *) symtab_section->link->data + sym->st_name;
964 if (s1->dynsym) {
965 if (ELFW(ST_BIND)(sym->st_info) == STB_LOCAL) {
966 /* Hack alarm. We don't want to emit dynamic symbols
967 and symbol based relocs for STB_LOCAL symbols, but rather
968 want to resolve them directly. At this point the symbol
969 values aren't final yet, so we must defer this. We will later
970 have to create a RELATIVE reloc anyway, so we misuse the
971 relocation slot to smuggle the symbol reference until
972 fill_local_got_entries. Not that the sym_index is
973 relative to symtab_section, not s1->dynsym! Nevertheless
974 we use s1->dyn_sym so that if this is the first call
975 that got->reloc is correctly created. Also note that
976 RELATIVE relocs are not normally created for the .got,
977 so the types serves as a marker for later (and is retained
978 also for the final output, which is okay because then the
979 got is just normal data). */
980 put_elf_reloc(s1->dynsym, s1->got, got_offset, R_RELATIVE,
981 sym_index);
982 } else {
983 if (0 == attr->dyn_index)
984 attr->dyn_index = set_elf_sym(s1->dynsym, sym->st_value, size,
985 info, 0, sym->st_shndx, name);
986 put_elf_reloc(s1->dynsym, s1->got, got_offset, dyn_reloc_type,
987 attr->dyn_index);
989 } else {
990 put_elf_reloc(symtab_section, s1->got, got_offset, dyn_reloc_type,
991 sym_index);
994 if (need_plt_entry) {
995 if (!s1->plt) {
996 s1->plt = new_section(s1, ".plt", SHT_PROGBITS,
997 SHF_ALLOC | SHF_EXECINSTR);
998 s1->plt->sh_entsize = 4;
1001 attr->plt_offset = create_plt_entry(s1, got_offset, attr);
1003 /* create a symbol 'sym@plt' for the PLT jump vector */
1004 len = strlen(name);
1005 if (len > sizeof plt_name - 5)
1006 len = sizeof plt_name - 5;
1007 memcpy(plt_name, name, len);
1008 strcpy(plt_name + len, "@plt");
1009 attr->plt_sym = put_elf_sym(s1->symtab, attr->plt_offset, sym->st_size,
1010 ELFW(ST_INFO)(STB_GLOBAL, STT_FUNC), 0, s1->plt->sh_num, plt_name);
1012 } else {
1013 attr->got_offset = got_offset;
1016 return attr;
1019 /* build GOT and PLT entries */
1020 ST_FUNC void build_got_entries(TCCState *s1)
1022 Section *s;
1023 ElfW_Rel *rel;
1024 ElfW(Sym) *sym;
1025 int i, type, gotplt_entry, reloc_type, sym_index;
1026 struct sym_attr *attr;
1028 for(i = 1; i < s1->nb_sections; i++) {
1029 s = s1->sections[i];
1030 if (s->sh_type != SHT_RELX)
1031 continue;
1032 /* no need to handle got relocations */
1033 if (s->link != symtab_section)
1034 continue;
1035 for_each_elem(s, 0, rel, ElfW_Rel) {
1036 type = ELFW(R_TYPE)(rel->r_info);
1037 gotplt_entry = gotplt_entry_type(type);
1038 sym_index = ELFW(R_SYM)(rel->r_info);
1039 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1041 if (gotplt_entry == NO_GOTPLT_ENTRY) {
1042 continue;
1045 /* Automatically create PLT/GOT [entry] if it is an undefined
1046 reference (resolved at runtime), or the symbol is absolute,
1047 probably created by tcc_add_symbol, and thus on 64-bit
1048 targets might be too far from application code. */
1049 if (gotplt_entry == AUTO_GOTPLT_ENTRY) {
1050 if (sym->st_shndx == SHN_UNDEF) {
1051 ElfW(Sym) *esym;
1052 int dynindex;
1053 if (s1->output_type == TCC_OUTPUT_DLL && ! PCRELATIVE_DLLPLT)
1054 continue;
1055 /* Relocations for UNDEF symbols would normally need
1056 to be transferred into the executable or shared object.
1057 If that were done AUTO_GOTPLT_ENTRY wouldn't exist.
1058 But TCC doesn't do that (at least for exes), so we
1059 need to resolve all such relocs locally. And that
1060 means PLT slots for functions in DLLs and COPY relocs for
1061 data symbols. COPY relocs were generated in
1062 bind_exe_dynsyms (and the symbol adjusted to be defined),
1063 and for functions we were generated a dynamic symbol
1064 of function type. */
1065 if (s1->dynsym) {
1066 /* dynsym isn't set for -run :-/ */
1067 dynindex = get_sym_attr(s1, sym_index, 0)->dyn_index;
1068 esym = (ElfW(Sym) *)s1->dynsym->data + dynindex;
1069 if (dynindex
1070 && (ELFW(ST_TYPE)(esym->st_info) == STT_FUNC
1071 || (ELFW(ST_TYPE)(esym->st_info) == STT_NOTYPE
1072 && ELFW(ST_TYPE)(sym->st_info) == STT_FUNC)))
1073 goto jmp_slot;
1075 } else if (!(sym->st_shndx == SHN_ABS
1076 #ifndef TCC_TARGET_ARM
1077 && PTR_SIZE == 8
1078 #endif
1080 continue;
1083 #ifdef TCC_TARGET_X86_64
1084 if ((type == R_X86_64_PLT32 || type == R_X86_64_PC32) &&
1085 (ELFW(ST_VISIBILITY)(sym->st_other) != STV_DEFAULT ||
1086 ELFW(ST_BIND)(sym->st_info) == STB_LOCAL)) {
1087 rel->r_info = ELFW(R_INFO)(sym_index, R_X86_64_PC32);
1088 continue;
1090 #endif
1091 if (code_reloc(type)) {
1092 jmp_slot:
1093 reloc_type = R_JMP_SLOT;
1094 } else
1095 reloc_type = R_GLOB_DAT;
1097 if (!s1->got)
1098 build_got(s1);
1100 if (gotplt_entry == BUILD_GOT_ONLY)
1101 continue;
1103 attr = put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
1104 sym_index);
1106 if (reloc_type == R_JMP_SLOT)
1107 rel->r_info = ELFW(R_INFO)(attr->plt_sym, type);
1112 /* put dynamic tag */
1113 static void put_dt(Section *dynamic, int dt, addr_t val)
1115 ElfW(Dyn) *dyn;
1116 dyn = section_ptr_add(dynamic, sizeof(ElfW(Dyn)));
1117 dyn->d_tag = dt;
1118 dyn->d_un.d_val = val;
1121 #ifndef TCC_TARGET_PE
1122 static void add_init_array_defines(TCCState *s1, const char *section_name)
1124 Section *s;
1125 long end_offset;
1126 char sym_start[1024];
1127 char sym_end[1024];
1129 snprintf(sym_start, sizeof(sym_start), "__%s_start", section_name + 1);
1130 snprintf(sym_end, sizeof(sym_end), "__%s_end", section_name + 1);
1132 s = find_section(s1, section_name);
1133 if (!s) {
1134 end_offset = 0;
1135 s = data_section;
1136 } else {
1137 end_offset = s->data_offset;
1140 set_elf_sym(symtab_section,
1141 0, 0,
1142 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1143 s->sh_num, sym_start);
1144 set_elf_sym(symtab_section,
1145 end_offset, 0,
1146 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1147 s->sh_num, sym_end);
1149 #endif
1151 static int tcc_add_support(TCCState *s1, const char *filename)
1153 char buf[1024];
1154 snprintf(buf, sizeof(buf), "%s/%s", s1->tcc_lib_path, filename);
1155 return tcc_add_file(s1, buf);
1158 ST_FUNC void tcc_add_bcheck(TCCState *s1)
1160 #ifdef CONFIG_TCC_BCHECK
1161 addr_t *ptr;
1162 int sym_index;
1164 if (0 == s1->do_bounds_check)
1165 return;
1166 /* XXX: add an object file to do that */
1167 ptr = section_ptr_add(bounds_section, sizeof(*ptr));
1168 *ptr = 0;
1169 set_elf_sym(symtab_section, 0, 0,
1170 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1171 bounds_section->sh_num, "__bounds_start");
1172 /* pull bcheck.o from libtcc1.a */
1173 sym_index = set_elf_sym(symtab_section, 0, 0,
1174 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1175 SHN_UNDEF, "__bound_init");
1176 if (s1->output_type != TCC_OUTPUT_MEMORY) {
1177 /* add 'call __bound_init()' in .init section */
1178 Section *init_section = find_section(s1, ".init");
1179 unsigned char *pinit = section_ptr_add(init_section, 5);
1180 pinit[0] = 0xe8;
1181 write32le(pinit + 1, -4);
1182 put_elf_reloc(symtab_section, init_section,
1183 init_section->data_offset - 4, R_386_PC32, sym_index);
1184 /* R_386_PC32 = R_X86_64_PC32 = 2 */
1186 #endif
1189 /* add tcc runtime libraries */
1190 ST_FUNC void tcc_add_runtime(TCCState *s1)
1192 tcc_add_bcheck(s1);
1193 tcc_add_pragma_libs(s1);
1194 /* add libc */
1195 if (!s1->nostdlib) {
1196 tcc_add_library_err(s1, "c");
1197 #ifdef TCC_LIBGCC
1198 if (!s1->static_link) {
1199 if (TCC_LIBGCC[0] == '/')
1200 tcc_add_file(s1, TCC_LIBGCC);
1201 else
1202 tcc_add_dll(s1, TCC_LIBGCC, 0);
1204 #endif
1205 tcc_add_support(s1, TCC_LIBTCC1);
1206 /* add crt end if not memory output */
1207 if (s1->output_type != TCC_OUTPUT_MEMORY)
1208 tcc_add_crt(s1, "crtn.o");
1212 /* add various standard linker symbols (must be done after the
1213 sections are filled (for example after allocating common
1214 symbols)) */
1215 static void tcc_add_linker_symbols(TCCState *s1)
1217 char buf[1024];
1218 int i;
1219 Section *s;
1221 set_elf_sym(symtab_section,
1222 text_section->data_offset, 0,
1223 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1224 text_section->sh_num, "_etext");
1225 set_elf_sym(symtab_section,
1226 data_section->data_offset, 0,
1227 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1228 data_section->sh_num, "_edata");
1229 set_elf_sym(symtab_section,
1230 bss_section->data_offset, 0,
1231 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1232 bss_section->sh_num, "_end");
1233 #ifndef TCC_TARGET_PE
1234 /* horrible new standard ldscript defines */
1235 add_init_array_defines(s1, ".preinit_array");
1236 add_init_array_defines(s1, ".init_array");
1237 add_init_array_defines(s1, ".fini_array");
1238 #endif
1240 /* add start and stop symbols for sections whose name can be
1241 expressed in C */
1242 for(i = 1; i < s1->nb_sections; i++) {
1243 s = s1->sections[i];
1244 if (s->sh_type == SHT_PROGBITS &&
1245 (s->sh_flags & SHF_ALLOC)) {
1246 const char *p;
1247 int ch;
1249 /* check if section name can be expressed in C */
1250 p = s->name;
1251 for(;;) {
1252 ch = *p;
1253 if (!ch)
1254 break;
1255 if (!isid(ch) && !isnum(ch))
1256 goto next_sec;
1257 p++;
1259 snprintf(buf, sizeof(buf), "__start_%s", s->name);
1260 set_elf_sym(symtab_section,
1261 0, 0,
1262 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1263 s->sh_num, buf);
1264 snprintf(buf, sizeof(buf), "__stop_%s", s->name);
1265 set_elf_sym(symtab_section,
1266 s->data_offset, 0,
1267 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1268 s->sh_num, buf);
1270 next_sec: ;
1274 ST_FUNC void resolve_common_syms(TCCState *s1)
1276 ElfW(Sym) *sym;
1278 /* Allocate common symbols in BSS. */
1279 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1280 if (sym->st_shndx == SHN_COMMON) {
1281 /* symbol alignment is in st_value for SHN_COMMONs */
1282 sym->st_value = section_add(bss_section, sym->st_size,
1283 sym->st_value);
1284 sym->st_shndx = bss_section->sh_num;
1288 /* Now assign linker provided symbols their value. */
1289 tcc_add_linker_symbols(s1);
1292 static void tcc_output_binary(TCCState *s1, FILE *f,
1293 const int *sec_order)
1295 Section *s;
1296 int i, offset, size;
1298 offset = 0;
1299 for(i=1;i<s1->nb_sections;i++) {
1300 s = s1->sections[sec_order[i]];
1301 if (s->sh_type != SHT_NOBITS &&
1302 (s->sh_flags & SHF_ALLOC)) {
1303 while (offset < s->sh_offset) {
1304 fputc(0, f);
1305 offset++;
1307 size = s->sh_size;
1308 fwrite(s->data, 1, size, f);
1309 offset += size;
1314 ST_FUNC void fill_got_entry(TCCState *s1, ElfW_Rel *rel)
1316 int sym_index = ELFW(R_SYM) (rel->r_info);
1317 ElfW(Sym) *sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
1318 struct sym_attr *attr = get_sym_attr(s1, sym_index, 0);
1319 unsigned offset = attr->got_offset;
1321 if (0 == offset)
1322 return;
1323 section_reserve(s1->got, offset + PTR_SIZE);
1324 #ifdef TCC_TARGET_X86_64
1325 write64le(s1->got->data + offset, sym->st_value);
1326 #else
1327 write32le(s1->got->data + offset, sym->st_value);
1328 #endif
1331 /* Perform relocation to GOT or PLT entries */
1332 ST_FUNC void fill_got(TCCState *s1)
1334 Section *s;
1335 ElfW_Rel *rel;
1336 int i;
1338 for(i = 1; i < s1->nb_sections; i++) {
1339 s = s1->sections[i];
1340 if (s->sh_type != SHT_RELX)
1341 continue;
1342 /* no need to handle got relocations */
1343 if (s->link != symtab_section)
1344 continue;
1345 for_each_elem(s, 0, rel, ElfW_Rel) {
1346 switch (ELFW(R_TYPE) (rel->r_info)) {
1347 case R_X86_64_GOT32:
1348 case R_X86_64_GOTPCREL:
1349 case R_X86_64_GOTPCRELX:
1350 case R_X86_64_REX_GOTPCRELX:
1351 case R_X86_64_PLT32:
1352 fill_got_entry(s1, rel);
1353 break;
1359 /* See put_got_entry for a description. This is the second stage
1360 where GOT references to local defined symbols are rewritten. */
1361 static void fill_local_got_entries(TCCState *s1)
1363 ElfW_Rel *rel;
1364 for_each_elem(s1->got->reloc, 0, rel, ElfW_Rel) {
1365 if (ELFW(R_TYPE)(rel->r_info) == R_RELATIVE) {
1366 int sym_index = ELFW(R_SYM) (rel->r_info);
1367 ElfW(Sym) *sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
1368 struct sym_attr *attr = get_sym_attr(s1, sym_index, 0);
1369 unsigned offset = attr->got_offset;
1370 if (offset != rel->r_offset - s1->got->sh_addr)
1371 tcc_error_noabort("huh");
1372 rel->r_info = ELFW(R_INFO)(0, R_RELATIVE);
1373 #if SHT_RELX == SHT_RELA
1374 rel->r_addend = sym->st_value;
1375 #else
1376 /* All our REL architectures also happen to be 32bit LE. */
1377 write32le(s1->got->data + offset, sym->st_value);
1378 #endif
1383 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1384 in shared libraries and export non local defined symbols to shared libraries
1385 if -rdynamic switch was given on command line */
1386 static void bind_exe_dynsyms(TCCState *s1)
1388 const char *name;
1389 int sym_index, index;
1390 ElfW(Sym) *sym, *esym;
1391 int type;
1393 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1394 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1395 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1396 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1397 if (sym->st_shndx == SHN_UNDEF) {
1398 name = (char *) symtab_section->link->data + sym->st_name;
1399 sym_index = find_elf_sym(s1->dynsymtab_section, name);
1400 if (sym_index) {
1401 esym = &((ElfW(Sym) *)s1->dynsymtab_section->data)[sym_index];
1402 type = ELFW(ST_TYPE)(esym->st_info);
1403 if ((type == STT_FUNC) || (type == STT_GNU_IFUNC)) {
1404 /* Indirect functions shall have STT_FUNC type in executable
1405 * dynsym section. Indeed, a dlsym call following a lazy
1406 * resolution would pick the symbol value from the
1407 * executable dynsym entry which would contain the address
1408 * of the function wanted by the caller of dlsym instead of
1409 * the address of the function that would return that
1410 * address */
1411 int dynindex
1412 = put_elf_sym(s1->dynsym, 0, esym->st_size,
1413 ELFW(ST_INFO)(STB_GLOBAL,STT_FUNC), 0, 0,
1414 name);
1415 int index = sym - (ElfW(Sym) *) symtab_section->data;
1416 get_sym_attr(s1, index, 1)->dyn_index = dynindex;
1417 } else if (type == STT_OBJECT) {
1418 unsigned long offset;
1419 ElfW(Sym) *dynsym;
1420 offset = bss_section->data_offset;
1421 /* XXX: which alignment ? */
1422 offset = (offset + 16 - 1) & -16;
1423 set_elf_sym (s1->symtab, offset, esym->st_size,
1424 esym->st_info, 0, bss_section->sh_num, name);
1425 index = put_elf_sym(s1->dynsym, offset, esym->st_size,
1426 esym->st_info, 0, bss_section->sh_num,
1427 name);
1429 /* Ensure R_COPY works for weak symbol aliases */
1430 if (ELFW(ST_BIND)(esym->st_info) == STB_WEAK) {
1431 for_each_elem(s1->dynsymtab_section, 1, dynsym, ElfW(Sym)) {
1432 if ((dynsym->st_value == esym->st_value)
1433 && (ELFW(ST_BIND)(dynsym->st_info) == STB_GLOBAL)) {
1434 char *dynname = (char *) s1->dynsymtab_section->link->data
1435 + dynsym->st_name;
1436 put_elf_sym(s1->dynsym, offset, dynsym->st_size,
1437 dynsym->st_info, 0,
1438 bss_section->sh_num, dynname);
1439 break;
1444 put_elf_reloc(s1->dynsym, bss_section,
1445 offset, R_COPY, index);
1446 offset += esym->st_size;
1447 bss_section->data_offset = offset;
1449 } else {
1450 /* STB_WEAK undefined symbols are accepted */
1451 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1452 if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK ||
1453 !strcmp(name, "_fp_hw")) {
1454 } else {
1455 tcc_error_noabort("undefined symbol '%s'", name);
1458 } else if (s1->rdynamic && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1459 /* if -rdynamic option, then export all non local symbols */
1460 name = (char *) symtab_section->link->data + sym->st_name;
1461 set_elf_sym(s1->dynsym, sym->st_value, sym->st_size, sym->st_info,
1462 0, sym->st_shndx, name);
1467 /* Bind symbols of libraries: export all non local symbols of executable that
1468 are referenced by shared libraries. The reason is that the dynamic loader
1469 search symbol first in executable and then in libraries. Therefore a
1470 reference to a symbol already defined by a library can still be resolved by
1471 a symbol in the executable. */
1472 static void bind_libs_dynsyms(TCCState *s1)
1474 const char *name;
1475 int sym_index;
1476 ElfW(Sym) *sym, *esym;
1478 for_each_elem(s1->dynsymtab_section, 1, esym, ElfW(Sym)) {
1479 name = (char *) s1->dynsymtab_section->link->data + esym->st_name;
1480 sym_index = find_elf_sym(symtab_section, name);
1481 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1482 if (sym_index && sym->st_shndx != SHN_UNDEF
1483 && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1484 set_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1485 sym->st_info, 0, sym->st_shndx, name);
1486 } else if (esym->st_shndx == SHN_UNDEF) {
1487 /* weak symbols can stay undefined */
1488 if (ELFW(ST_BIND)(esym->st_info) != STB_WEAK)
1489 tcc_warning("undefined dynamic symbol '%s'", name);
1494 /* Export all non local symbols. This is used by shared libraries so that the
1495 non local symbols they define can resolve a reference in another shared
1496 library or in the executable. Correspondingly, it allows undefined local
1497 symbols to be resolved by other shared libraries or by the executable. */
1498 static void export_global_syms(TCCState *s1)
1500 int dynindex, index;
1501 const char *name;
1502 ElfW(Sym) *sym;
1504 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1505 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1506 name = (char *) symtab_section->link->data + sym->st_name;
1507 dynindex = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1508 sym->st_info, 0, sym->st_shndx, name);
1509 index = sym - (ElfW(Sym) *) symtab_section->data;
1510 get_sym_attr(s1, index, 1)->dyn_index = dynindex;
1515 /* Allocate strings for section names and decide if an unallocated section
1516 should be output.
1517 NOTE: the strsec section comes last, so its size is also correct ! */
1518 static int alloc_sec_names(TCCState *s1, int file_type, Section *strsec)
1520 int i;
1521 Section *s;
1522 int textrel = 0;
1524 /* Allocate strings for section names */
1525 for(i = 1; i < s1->nb_sections; i++) {
1526 s = s1->sections[i];
1527 /* when generating a DLL, we include relocations but we may
1528 patch them */
1529 if (file_type == TCC_OUTPUT_DLL &&
1530 s->sh_type == SHT_RELX &&
1531 !(s->sh_flags & SHF_ALLOC) &&
1532 (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC) &&
1533 prepare_dynamic_rel(s1, s)) {
1534 if (s1->sections[s->sh_info]->sh_flags & SHF_EXECINSTR)
1535 textrel = 1;
1536 } else if ((s1->do_debug && s->sh_type != SHT_RELX) ||
1537 file_type == TCC_OUTPUT_OBJ ||
1538 (s->sh_flags & SHF_ALLOC) ||
1539 i == (s1->nb_sections - 1)) {
1540 /* we output all sections if debug or object file */
1541 s->sh_size = s->data_offset;
1543 if (s->sh_size || (s->sh_flags & SHF_ALLOC))
1544 s->sh_name = put_elf_str(strsec, s->name);
1546 strsec->sh_size = strsec->data_offset;
1547 return textrel;
1550 /* Info to be copied in dynamic section */
1551 struct dyn_inf {
1552 Section *dynamic;
1553 Section *dynstr;
1554 unsigned long data_offset;
1555 addr_t rel_addr;
1556 addr_t rel_size;
1557 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1558 addr_t bss_addr;
1559 addr_t bss_size;
1560 #endif
1563 /* Assign sections to segments and decide how are sections laid out when loaded
1564 in memory. This function also fills corresponding program headers. */
1565 static int layout_sections(TCCState *s1, ElfW(Phdr) *phdr, int phnum,
1566 Section *interp, Section* strsec,
1567 struct dyn_inf *dyninf, int *sec_order)
1569 int i, j, k, file_type, sh_order_index, file_offset;
1570 unsigned long s_align;
1571 long long tmp;
1572 addr_t addr;
1573 ElfW(Phdr) *ph;
1574 Section *s;
1576 file_type = s1->output_type;
1577 sh_order_index = 1;
1578 file_offset = 0;
1579 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
1580 file_offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1581 s_align = ELF_PAGE_SIZE;
1582 if (s1->section_align)
1583 s_align = s1->section_align;
1585 if (phnum > 0) {
1586 if (s1->has_text_addr) {
1587 int a_offset, p_offset;
1588 addr = s1->text_addr;
1589 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1590 ELF_PAGE_SIZE */
1591 a_offset = (int) (addr & (s_align - 1));
1592 p_offset = file_offset & (s_align - 1);
1593 if (a_offset < p_offset)
1594 a_offset += s_align;
1595 file_offset += (a_offset - p_offset);
1596 } else {
1597 if (file_type == TCC_OUTPUT_DLL)
1598 addr = 0;
1599 else
1600 addr = ELF_START_ADDR;
1601 /* compute address after headers */
1602 addr += (file_offset & (s_align - 1));
1605 ph = &phdr[0];
1606 /* Leave one program headers for the program interpreter and one for
1607 the program header table itself if needed. These are done later as
1608 they require section layout to be done first. */
1609 if (interp)
1610 ph += 2;
1612 /* dynamic relocation table information, for .dynamic section */
1613 dyninf->rel_addr = dyninf->rel_size = 0;
1614 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1615 dyninf->bss_addr = dyninf->bss_size = 0;
1616 #endif
1618 for(j = 0; j < 2; j++) {
1619 ph->p_type = PT_LOAD;
1620 if (j == 0)
1621 ph->p_flags = PF_R | PF_X;
1622 else
1623 ph->p_flags = PF_R | PF_W;
1624 ph->p_align = s_align;
1626 /* Decide the layout of sections loaded in memory. This must
1627 be done before program headers are filled since they contain
1628 info about the layout. We do the following ordering: interp,
1629 symbol tables, relocations, progbits, nobits */
1630 /* XXX: do faster and simpler sorting */
1631 for(k = 0; k < 5; k++) {
1632 for(i = 1; i < s1->nb_sections; i++) {
1633 s = s1->sections[i];
1634 /* compute if section should be included */
1635 if (j == 0) {
1636 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1637 SHF_ALLOC)
1638 continue;
1639 } else {
1640 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1641 (SHF_ALLOC | SHF_WRITE))
1642 continue;
1644 if (s == interp) {
1645 if (k != 0)
1646 continue;
1647 } else if (s->sh_type == SHT_DYNSYM ||
1648 s->sh_type == SHT_STRTAB ||
1649 s->sh_type == SHT_HASH) {
1650 if (k != 1)
1651 continue;
1652 } else if (s->sh_type == SHT_RELX) {
1653 if (k != 2)
1654 continue;
1655 } else if (s->sh_type == SHT_NOBITS) {
1656 if (k != 4)
1657 continue;
1658 } else {
1659 if (k != 3)
1660 continue;
1662 sec_order[sh_order_index++] = i;
1664 /* section matches: we align it and add its size */
1665 tmp = addr;
1666 addr = (addr + s->sh_addralign - 1) &
1667 ~(s->sh_addralign - 1);
1668 file_offset += (int) ( addr - tmp );
1669 s->sh_offset = file_offset;
1670 s->sh_addr = addr;
1672 /* update program header infos */
1673 if (ph->p_offset == 0) {
1674 ph->p_offset = file_offset;
1675 ph->p_vaddr = addr;
1676 ph->p_paddr = ph->p_vaddr;
1678 /* update dynamic relocation infos */
1679 if (s->sh_type == SHT_RELX) {
1680 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1681 if (!strcmp(strsec->data + s->sh_name, ".rel.got")) {
1682 dyninf->rel_addr = addr;
1683 dyninf->rel_size += s->sh_size; /* XXX only first rel. */
1685 if (!strcmp(strsec->data + s->sh_name, ".rel.bss")) {
1686 dyninf->bss_addr = addr;
1687 dyninf->bss_size = s->sh_size; /* XXX only first rel. */
1689 #else
1690 if (dyninf->rel_size == 0)
1691 dyninf->rel_addr = addr;
1692 dyninf->rel_size += s->sh_size;
1693 #endif
1695 addr += s->sh_size;
1696 if (s->sh_type != SHT_NOBITS)
1697 file_offset += s->sh_size;
1700 if (j == 0) {
1701 /* Make the first PT_LOAD segment include the program
1702 headers itself (and the ELF header as well), it'll
1703 come out with same memory use but will make various
1704 tools like binutils strip work better. */
1705 ph->p_offset &= ~(ph->p_align - 1);
1706 ph->p_vaddr &= ~(ph->p_align - 1);
1707 ph->p_paddr &= ~(ph->p_align - 1);
1709 ph->p_filesz = file_offset - ph->p_offset;
1710 ph->p_memsz = addr - ph->p_vaddr;
1711 ph++;
1712 if (j == 0) {
1713 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1714 /* if in the middle of a page, we duplicate the page in
1715 memory so that one copy is RX and the other is RW */
1716 if ((addr & (s_align - 1)) != 0)
1717 addr += s_align;
1718 } else {
1719 addr = (addr + s_align - 1) & ~(s_align - 1);
1720 file_offset = (file_offset + s_align - 1) & ~(s_align - 1);
1726 /* all other sections come after */
1727 for(i = 1; i < s1->nb_sections; i++) {
1728 s = s1->sections[i];
1729 if (phnum > 0 && (s->sh_flags & SHF_ALLOC))
1730 continue;
1731 sec_order[sh_order_index++] = i;
1733 file_offset = (file_offset + s->sh_addralign - 1) &
1734 ~(s->sh_addralign - 1);
1735 s->sh_offset = file_offset;
1736 if (s->sh_type != SHT_NOBITS)
1737 file_offset += s->sh_size;
1740 return file_offset;
1743 static void fill_unloadable_phdr(ElfW(Phdr) *phdr, int phnum, Section *interp,
1744 Section *dynamic)
1746 ElfW(Phdr) *ph;
1748 /* if interpreter, then add corresponding program header */
1749 if (interp) {
1750 ph = &phdr[0];
1752 ph->p_type = PT_PHDR;
1753 ph->p_offset = sizeof(ElfW(Ehdr));
1754 ph->p_filesz = ph->p_memsz = phnum * sizeof(ElfW(Phdr));
1755 ph->p_vaddr = interp->sh_addr - ph->p_filesz;
1756 ph->p_paddr = ph->p_vaddr;
1757 ph->p_flags = PF_R | PF_X;
1758 ph->p_align = 4; /* interp->sh_addralign; */
1759 ph++;
1761 ph->p_type = PT_INTERP;
1762 ph->p_offset = interp->sh_offset;
1763 ph->p_vaddr = interp->sh_addr;
1764 ph->p_paddr = ph->p_vaddr;
1765 ph->p_filesz = interp->sh_size;
1766 ph->p_memsz = interp->sh_size;
1767 ph->p_flags = PF_R;
1768 ph->p_align = interp->sh_addralign;
1771 /* if dynamic section, then add corresponding program header */
1772 if (dynamic) {
1773 ph = &phdr[phnum - 1];
1775 ph->p_type = PT_DYNAMIC;
1776 ph->p_offset = dynamic->sh_offset;
1777 ph->p_vaddr = dynamic->sh_addr;
1778 ph->p_paddr = ph->p_vaddr;
1779 ph->p_filesz = dynamic->sh_size;
1780 ph->p_memsz = dynamic->sh_size;
1781 ph->p_flags = PF_R | PF_W;
1782 ph->p_align = dynamic->sh_addralign;
1786 /* Fill the dynamic section with tags describing the address and size of
1787 sections */
1788 static void fill_dynamic(TCCState *s1, struct dyn_inf *dyninf)
1790 Section *dynamic = dyninf->dynamic;
1792 /* put dynamic section entries */
1793 put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
1794 put_dt(dynamic, DT_STRTAB, dyninf->dynstr->sh_addr);
1795 put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
1796 put_dt(dynamic, DT_STRSZ, dyninf->dynstr->data_offset);
1797 put_dt(dynamic, DT_SYMENT, sizeof(ElfW(Sym)));
1798 #if PTR_SIZE == 8
1799 put_dt(dynamic, DT_RELA, dyninf->rel_addr);
1800 put_dt(dynamic, DT_RELASZ, dyninf->rel_size);
1801 put_dt(dynamic, DT_RELAENT, sizeof(ElfW_Rel));
1802 #else
1803 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1804 put_dt(dynamic, DT_PLTGOT, s1->got->sh_addr);
1805 put_dt(dynamic, DT_PLTRELSZ, dyninf->rel_size);
1806 put_dt(dynamic, DT_JMPREL, dyninf->rel_addr);
1807 put_dt(dynamic, DT_PLTREL, DT_REL);
1808 put_dt(dynamic, DT_REL, dyninf->bss_addr);
1809 put_dt(dynamic, DT_RELSZ, dyninf->bss_size);
1810 #else
1811 put_dt(dynamic, DT_REL, dyninf->rel_addr);
1812 put_dt(dynamic, DT_RELSZ, dyninf->rel_size);
1813 put_dt(dynamic, DT_RELENT, sizeof(ElfW_Rel));
1814 #endif
1815 #endif
1816 if (s1->do_debug)
1817 put_dt(dynamic, DT_DEBUG, 0);
1818 put_dt(dynamic, DT_NULL, 0);
1821 /* Relocate remaining sections and symbols (that is those not related to
1822 dynamic linking) */
1823 static int final_sections_reloc(TCCState *s1)
1825 int i;
1826 Section *s;
1828 relocate_syms(s1, s1->symtab, 0);
1830 if (s1->nb_errors != 0)
1831 return -1;
1833 /* relocate sections */
1834 /* XXX: ignore sections with allocated relocations ? */
1835 for(i = 1; i < s1->nb_sections; i++) {
1836 s = s1->sections[i];
1837 if (s->reloc && s != s1->got)
1838 relocate_section(s1, s);
1841 /* relocate relocation entries if the relocation tables are
1842 allocated in the executable */
1843 for(i = 1; i < s1->nb_sections; i++) {
1844 s = s1->sections[i];
1845 if ((s->sh_flags & SHF_ALLOC) &&
1846 s->sh_type == SHT_RELX) {
1847 relocate_rel(s1, s);
1850 return 0;
1853 /* Create an ELF file on disk.
1854 This function handle ELF specific layout requirements */
1855 static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
1856 int file_offset, int *sec_order)
1858 int i, shnum, offset, size, file_type;
1859 Section *s;
1860 ElfW(Ehdr) ehdr;
1861 ElfW(Shdr) shdr, *sh;
1863 file_type = s1->output_type;
1864 shnum = s1->nb_sections;
1866 memset(&ehdr, 0, sizeof(ehdr));
1868 if (phnum > 0) {
1869 ehdr.e_phentsize = sizeof(ElfW(Phdr));
1870 ehdr.e_phnum = phnum;
1871 ehdr.e_phoff = sizeof(ElfW(Ehdr));
1874 /* align to 4 */
1875 file_offset = (file_offset + 3) & -4;
1877 /* fill header */
1878 ehdr.e_ident[0] = ELFMAG0;
1879 ehdr.e_ident[1] = ELFMAG1;
1880 ehdr.e_ident[2] = ELFMAG2;
1881 ehdr.e_ident[3] = ELFMAG3;
1882 ehdr.e_ident[4] = ELFCLASSW;
1883 ehdr.e_ident[5] = ELFDATA2LSB;
1884 ehdr.e_ident[6] = EV_CURRENT;
1885 #if !defined(TCC_TARGET_PE) && (defined(__FreeBSD__) || defined(__FreeBSD_kernel__))
1886 /* FIXME: should set only for freebsd _target_, but we exclude only PE target */
1887 ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
1888 #endif
1889 #ifdef TCC_TARGET_ARM
1890 #ifdef TCC_ARM_EABI
1891 ehdr.e_ident[EI_OSABI] = 0;
1892 ehdr.e_flags = EF_ARM_EABI_VER4;
1893 if (file_type == TCC_OUTPUT_EXE || file_type == TCC_OUTPUT_DLL)
1894 ehdr.e_flags |= EF_ARM_HASENTRY;
1895 if (s1->float_abi == ARM_HARD_FLOAT)
1896 ehdr.e_flags |= EF_ARM_VFP_FLOAT;
1897 else
1898 ehdr.e_flags |= EF_ARM_SOFT_FLOAT;
1899 #else
1900 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
1901 #endif
1902 #endif
1903 switch(file_type) {
1904 default:
1905 case TCC_OUTPUT_EXE:
1906 ehdr.e_type = ET_EXEC;
1907 ehdr.e_entry = get_elf_sym_addr(s1, "_start", 1);
1908 break;
1909 case TCC_OUTPUT_DLL:
1910 ehdr.e_type = ET_DYN;
1911 ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
1912 break;
1913 case TCC_OUTPUT_OBJ:
1914 ehdr.e_type = ET_REL;
1915 break;
1917 ehdr.e_machine = EM_TCC_TARGET;
1918 ehdr.e_version = EV_CURRENT;
1919 ehdr.e_shoff = file_offset;
1920 ehdr.e_ehsize = sizeof(ElfW(Ehdr));
1921 ehdr.e_shentsize = sizeof(ElfW(Shdr));
1922 ehdr.e_shnum = shnum;
1923 ehdr.e_shstrndx = shnum - 1;
1925 fwrite(&ehdr, 1, sizeof(ElfW(Ehdr)), f);
1926 fwrite(phdr, 1, phnum * sizeof(ElfW(Phdr)), f);
1927 offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1929 sort_syms(s1, symtab_section);
1930 for(i = 1; i < s1->nb_sections; i++) {
1931 s = s1->sections[sec_order[i]];
1932 if (s->sh_type != SHT_NOBITS) {
1933 while (offset < s->sh_offset) {
1934 fputc(0, f);
1935 offset++;
1937 size = s->sh_size;
1938 if (size)
1939 fwrite(s->data, 1, size, f);
1940 offset += size;
1944 /* output section headers */
1945 while (offset < ehdr.e_shoff) {
1946 fputc(0, f);
1947 offset++;
1950 for(i = 0; i < s1->nb_sections; i++) {
1951 sh = &shdr;
1952 memset(sh, 0, sizeof(ElfW(Shdr)));
1953 s = s1->sections[i];
1954 if (s) {
1955 sh->sh_name = s->sh_name;
1956 sh->sh_type = s->sh_type;
1957 sh->sh_flags = s->sh_flags;
1958 sh->sh_entsize = s->sh_entsize;
1959 sh->sh_info = s->sh_info;
1960 if (s->link)
1961 sh->sh_link = s->link->sh_num;
1962 sh->sh_addralign = s->sh_addralign;
1963 sh->sh_addr = s->sh_addr;
1964 sh->sh_offset = s->sh_offset;
1965 sh->sh_size = s->sh_size;
1967 fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
1971 /* Write an elf, coff or "binary" file */
1972 static int tcc_write_elf_file(TCCState *s1, const char *filename, int phnum,
1973 ElfW(Phdr) *phdr, int file_offset, int *sec_order)
1975 int fd, mode, file_type;
1976 FILE *f;
1978 file_type = s1->output_type;
1979 if (file_type == TCC_OUTPUT_OBJ)
1980 mode = 0666;
1981 else
1982 mode = 0777;
1983 unlink(filename);
1984 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
1985 if (fd < 0) {
1986 tcc_error_noabort("could not write '%s'", filename);
1987 return -1;
1989 f = fdopen(fd, "wb");
1990 if (s1->verbose)
1991 printf("<- %s\n", filename);
1993 #ifdef TCC_TARGET_COFF
1994 if (s1->output_format == TCC_OUTPUT_FORMAT_COFF)
1995 tcc_output_coff(s1, f);
1996 else
1997 #endif
1998 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
1999 tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
2000 else
2001 tcc_output_binary(s1, f, sec_order);
2002 fclose(f);
2004 return 0;
2007 /* Sort section headers by assigned sh_addr, remove sections
2008 that we aren't going to output. */
2009 static void tidy_section_headers(TCCState *s1, int *sec_order)
2011 int i, nnew, l, *backmap;
2012 Section **snew, *s;
2013 ElfW(Sym) *sym;
2015 snew = tcc_malloc(s1->nb_sections * sizeof(snew[0]));
2016 backmap = tcc_malloc(s1->nb_sections * sizeof(backmap[0]));
2017 for (i = 0, nnew = 0, l = s1->nb_sections; i < s1->nb_sections; i++) {
2018 s = s1->sections[sec_order[i]];
2019 if (!i || s->sh_name) {
2020 backmap[sec_order[i]] = nnew;
2021 snew[nnew] = s;
2022 ++nnew;
2023 } else {
2024 backmap[sec_order[i]] = 0;
2025 snew[--l] = s;
2028 for (i = 0; i < nnew; i++) {
2029 s = snew[i];
2030 if (s) {
2031 s->sh_num = i;
2032 if (s->sh_type == SHT_RELX)
2033 s->sh_info = backmap[s->sh_info];
2037 for_each_elem(symtab_section, 1, sym, ElfW(Sym))
2038 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE)
2039 sym->st_shndx = backmap[sym->st_shndx];
2040 if( !s1->static_link ) {
2041 for_each_elem(s1->dynsym, 1, sym, ElfW(Sym))
2042 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE)
2043 sym->st_shndx = backmap[sym->st_shndx];
2045 for (i = 0; i < s1->nb_sections; i++)
2046 sec_order[i] = i;
2047 tcc_free(s1->sections);
2048 s1->sections = snew;
2049 s1->nb_sections = nnew;
2050 tcc_free(backmap);
2053 /* Output an elf, coff or binary file */
2054 /* XXX: suppress unneeded sections */
2055 static int elf_output_file(TCCState *s1, const char *filename)
2057 int i, ret, phnum, shnum, file_type, file_offset, *sec_order;
2058 struct dyn_inf dyninf = {0};
2059 ElfW(Phdr) *phdr;
2060 ElfW(Sym) *sym;
2061 Section *strsec, *interp, *dynamic, *dynstr;
2062 int textrel;
2064 file_type = s1->output_type;
2065 s1->nb_errors = 0;
2066 ret = -1;
2067 phdr = NULL;
2068 sec_order = NULL;
2069 interp = dynamic = dynstr = NULL; /* avoid warning */
2070 textrel = 0;
2072 if (file_type != TCC_OUTPUT_OBJ) {
2073 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2074 tcc_add_runtime(s1);
2075 resolve_common_syms(s1);
2077 if (!s1->static_link) {
2078 if (file_type == TCC_OUTPUT_EXE) {
2079 char *ptr;
2080 /* allow override the dynamic loader */
2081 const char *elfint = getenv("LD_SO");
2082 if (elfint == NULL)
2083 elfint = DEFAULT_ELFINTERP(s1);
2084 /* add interpreter section only if executable */
2085 interp = new_section(s1, ".interp", SHT_PROGBITS, SHF_ALLOC);
2086 interp->sh_addralign = 1;
2087 ptr = section_ptr_add(interp, 1 + strlen(elfint));
2088 strcpy(ptr, elfint);
2091 /* add dynamic symbol table */
2092 s1->dynsym = new_symtab(s1, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
2093 ".dynstr",
2094 ".hash", SHF_ALLOC);
2095 dynstr = s1->dynsym->link;
2097 /* add dynamic section */
2098 dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC,
2099 SHF_ALLOC | SHF_WRITE);
2100 dynamic->link = dynstr;
2101 dynamic->sh_entsize = sizeof(ElfW(Dyn));
2103 build_got(s1);
2105 if (file_type == TCC_OUTPUT_EXE) {
2106 bind_exe_dynsyms(s1);
2107 if (s1->nb_errors)
2108 goto the_end;
2109 bind_libs_dynsyms(s1);
2110 } else {
2111 /* shared library case: simply export all global symbols */
2112 export_global_syms(s1);
2115 build_got_entries(s1);
2118 /* we add a section for symbols */
2119 strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0);
2120 put_elf_str(strsec, "");
2122 /* Allocate strings for section names */
2123 textrel = alloc_sec_names(s1, file_type, strsec);
2125 if (dynamic) {
2126 /* add a list of needed dlls */
2127 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2128 DLLReference *dllref = s1->loaded_dlls[i];
2129 if (dllref->level == 0)
2130 put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name));
2133 if (s1->rpath)
2134 put_dt(dynamic, s1->enable_new_dtags ? DT_RUNPATH : DT_RPATH,
2135 put_elf_str(dynstr, s1->rpath));
2137 if (file_type == TCC_OUTPUT_DLL) {
2138 if (s1->soname)
2139 put_dt(dynamic, DT_SONAME, put_elf_str(dynstr, s1->soname));
2140 /* XXX: currently, since we do not handle PIC code, we
2141 must relocate the readonly segments */
2142 if (textrel)
2143 put_dt(dynamic, DT_TEXTREL, 0);
2146 if (s1->symbolic)
2147 put_dt(dynamic, DT_SYMBOLIC, 0);
2149 dyninf.dynamic = dynamic;
2150 dyninf.dynstr = dynstr;
2151 /* remember offset and reserve space for 2nd call below */
2152 dyninf.data_offset = dynamic->data_offset;
2153 fill_dynamic(s1, &dyninf);
2154 dynamic->sh_size = dynamic->data_offset;
2155 dynstr->sh_size = dynstr->data_offset;
2158 /* compute number of program headers */
2159 if (file_type == TCC_OUTPUT_OBJ)
2160 phnum = 0;
2161 else if (file_type == TCC_OUTPUT_DLL)
2162 phnum = 3;
2163 else if (s1->static_link)
2164 phnum = 2;
2165 else
2166 phnum = 5;
2168 /* allocate program segment headers */
2169 phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
2171 /* compute number of sections */
2172 shnum = s1->nb_sections;
2174 /* this array is used to reorder sections in the output file */
2175 sec_order = tcc_malloc(sizeof(int) * shnum);
2176 sec_order[0] = 0;
2178 /* compute section to program header mapping */
2179 file_offset = layout_sections(s1, phdr, phnum, interp, strsec, &dyninf,
2180 sec_order);
2182 /* Fill remaining program header and finalize relocation related to dynamic
2183 linking. */
2184 if (file_type != TCC_OUTPUT_OBJ) {
2185 fill_unloadable_phdr(phdr, phnum, interp, dynamic);
2186 if (dynamic) {
2187 dynamic->data_offset = dyninf.data_offset;
2188 fill_dynamic(s1, &dyninf);
2190 /* put in GOT the dynamic section address and relocate PLT */
2191 write32le(s1->got->data, dynamic->sh_addr);
2192 if (file_type == TCC_OUTPUT_EXE
2193 || (RELOCATE_DLLPLT && file_type == TCC_OUTPUT_DLL))
2194 relocate_plt(s1);
2196 /* relocate symbols in .dynsym now that final addresses are known */
2197 for_each_elem(s1->dynsym, 1, sym, ElfW(Sym)) {
2198 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE) {
2199 /* do symbol relocation */
2200 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
2205 /* if building executable or DLL, then relocate each section
2206 except the GOT which is already relocated */
2207 ret = final_sections_reloc(s1);
2208 if (ret)
2209 goto the_end;
2210 tidy_section_headers(s1, sec_order);
2212 /* Perform relocation to GOT or PLT entries */
2213 if (file_type == TCC_OUTPUT_EXE && s1->static_link)
2214 fill_got(s1);
2215 else if (s1->got)
2216 fill_local_got_entries(s1);
2219 /* Create the ELF file with name 'filename' */
2220 ret = tcc_write_elf_file(s1, filename, phnum, phdr, file_offset, sec_order);
2221 s1->nb_sections = shnum;
2222 the_end:
2223 tcc_free(sec_order);
2224 tcc_free(phdr);
2225 return ret;
2228 LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename)
2230 int ret;
2231 #ifdef TCC_TARGET_PE
2232 if (s->output_type != TCC_OUTPUT_OBJ) {
2233 ret = pe_output_file(s, filename);
2234 } else
2235 #endif
2236 ret = elf_output_file(s, filename);
2237 return ret;
2240 static void *load_data(int fd, unsigned long file_offset, unsigned long size)
2242 void *data;
2244 data = tcc_malloc(size);
2245 lseek(fd, file_offset, SEEK_SET);
2246 read(fd, data, size);
2247 return data;
2250 typedef struct SectionMergeInfo {
2251 Section *s; /* corresponding existing section */
2252 unsigned long offset; /* offset of the new section in the existing section */
2253 uint8_t new_section; /* true if section 's' was added */
2254 uint8_t link_once; /* true if link once section */
2255 } SectionMergeInfo;
2257 ST_FUNC int tcc_object_type(int fd, ElfW(Ehdr) *h)
2259 int size = read(fd, h, sizeof *h);
2260 if (size == sizeof *h && 0 == memcmp(h, ELFMAG, 4)) {
2261 if (h->e_type == ET_REL)
2262 return AFF_BINTYPE_REL;
2263 if (h->e_type == ET_DYN)
2264 return AFF_BINTYPE_DYN;
2265 } else if (size >= 8) {
2266 if (0 == memcmp(h, ARMAG, 8))
2267 return AFF_BINTYPE_AR;
2268 #ifdef TCC_TARGET_COFF
2269 if (((struct filehdr*)h)->f_magic == COFF_C67_MAGIC)
2270 return AFF_BINTYPE_C67;
2271 #endif
2273 return 0;
2276 /* load an object file and merge it with current files */
2277 /* XXX: handle correctly stab (debug) info */
2278 ST_FUNC int tcc_load_object_file(TCCState *s1,
2279 int fd, unsigned long file_offset)
2281 ElfW(Ehdr) ehdr;
2282 ElfW(Shdr) *shdr, *sh;
2283 int size, i, j, offset, offseti, nb_syms, sym_index, ret, seencompressed;
2284 unsigned char *strsec, *strtab;
2285 int *old_to_new_syms;
2286 char *sh_name, *name;
2287 SectionMergeInfo *sm_table, *sm;
2288 ElfW(Sym) *sym, *symtab;
2289 ElfW_Rel *rel;
2290 Section *s;
2292 int stab_index;
2293 int stabstr_index;
2295 stab_index = stabstr_index = 0;
2297 lseek(fd, file_offset, SEEK_SET);
2298 if (tcc_object_type(fd, &ehdr) != AFF_BINTYPE_REL)
2299 goto fail1;
2300 /* test CPU specific stuff */
2301 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2302 ehdr.e_machine != EM_TCC_TARGET) {
2303 fail1:
2304 tcc_error_noabort("invalid object file");
2305 return -1;
2307 /* read sections */
2308 shdr = load_data(fd, file_offset + ehdr.e_shoff,
2309 sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2310 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
2312 /* load section names */
2313 sh = &shdr[ehdr.e_shstrndx];
2314 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2316 /* load symtab and strtab */
2317 old_to_new_syms = NULL;
2318 symtab = NULL;
2319 strtab = NULL;
2320 nb_syms = 0;
2321 seencompressed = 0;
2322 for(i = 1; i < ehdr.e_shnum; i++) {
2323 sh = &shdr[i];
2324 if (sh->sh_type == SHT_SYMTAB) {
2325 if (symtab) {
2326 tcc_error_noabort("object must contain only one symtab");
2327 fail:
2328 ret = -1;
2329 goto the_end;
2331 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2332 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2333 sm_table[i].s = symtab_section;
2335 /* now load strtab */
2336 sh = &shdr[sh->sh_link];
2337 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2339 if (sh->sh_flags & SHF_COMPRESSED)
2340 seencompressed = 1;
2343 /* now examine each section and try to merge its content with the
2344 ones in memory */
2345 for(i = 1; i < ehdr.e_shnum; i++) {
2346 /* no need to examine section name strtab */
2347 if (i == ehdr.e_shstrndx)
2348 continue;
2349 sh = &shdr[i];
2350 sh_name = (char *) strsec + sh->sh_name;
2351 /* ignore sections types we do not handle */
2352 if (sh->sh_type != SHT_PROGBITS &&
2353 sh->sh_type != SHT_RELX &&
2354 #ifdef TCC_ARM_EABI
2355 sh->sh_type != SHT_ARM_EXIDX &&
2356 #endif
2357 sh->sh_type != SHT_NOBITS &&
2358 sh->sh_type != SHT_PREINIT_ARRAY &&
2359 sh->sh_type != SHT_INIT_ARRAY &&
2360 sh->sh_type != SHT_FINI_ARRAY &&
2361 strcmp(sh_name, ".stabstr")
2363 continue;
2364 if (seencompressed
2365 && (!strncmp(sh_name, ".debug_", sizeof(".debug_")-1)
2366 || (sh->sh_type == SHT_RELX
2367 && !strncmp((char*)strsec + shdr[sh->sh_info].sh_name,
2368 ".debug_", sizeof(".debug_")-1))))
2369 continue;
2370 if (sh->sh_addralign < 1)
2371 sh->sh_addralign = 1;
2372 /* find corresponding section, if any */
2373 for(j = 1; j < s1->nb_sections;j++) {
2374 s = s1->sections[j];
2375 if (!strcmp(s->name, sh_name)) {
2376 if (!strncmp(sh_name, ".gnu.linkonce",
2377 sizeof(".gnu.linkonce") - 1)) {
2378 /* if a 'linkonce' section is already present, we
2379 do not add it again. It is a little tricky as
2380 symbols can still be defined in
2381 it. */
2382 sm_table[i].link_once = 1;
2383 goto next;
2384 } else {
2385 goto found;
2389 /* not found: create new section */
2390 s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags & ~SHF_GROUP);
2391 /* take as much info as possible from the section. sh_link and
2392 sh_info will be updated later */
2393 s->sh_addralign = sh->sh_addralign;
2394 s->sh_entsize = sh->sh_entsize;
2395 sm_table[i].new_section = 1;
2396 found:
2397 if (sh->sh_type != s->sh_type) {
2398 tcc_error_noabort("invalid section type");
2399 goto fail;
2402 /* align start of section */
2403 offset = s->data_offset;
2405 if (0 == strcmp(sh_name, ".stab")) {
2406 stab_index = i;
2407 goto no_align;
2409 if (0 == strcmp(sh_name, ".stabstr")) {
2410 stabstr_index = i;
2411 goto no_align;
2414 size = sh->sh_addralign - 1;
2415 offset = (offset + size) & ~size;
2416 if (sh->sh_addralign > s->sh_addralign)
2417 s->sh_addralign = sh->sh_addralign;
2418 s->data_offset = offset;
2419 no_align:
2420 sm_table[i].offset = offset;
2421 sm_table[i].s = s;
2422 /* concatenate sections */
2423 size = sh->sh_size;
2424 if (sh->sh_type != SHT_NOBITS) {
2425 unsigned char *ptr;
2426 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
2427 ptr = section_ptr_add(s, size);
2428 read(fd, ptr, size);
2429 } else {
2430 s->data_offset += size;
2432 next: ;
2435 /* gr relocate stab strings */
2436 if (stab_index && stabstr_index) {
2437 Stab_Sym *a, *b;
2438 unsigned o;
2439 s = sm_table[stab_index].s;
2440 a = (Stab_Sym *)(s->data + sm_table[stab_index].offset);
2441 b = (Stab_Sym *)(s->data + s->data_offset);
2442 o = sm_table[stabstr_index].offset;
2443 while (a < b)
2444 a->n_strx += o, a++;
2447 /* second short pass to update sh_link and sh_info fields of new
2448 sections */
2449 for(i = 1; i < ehdr.e_shnum; i++) {
2450 s = sm_table[i].s;
2451 if (!s || !sm_table[i].new_section)
2452 continue;
2453 sh = &shdr[i];
2454 if (sh->sh_link > 0)
2455 s->link = sm_table[sh->sh_link].s;
2456 if (sh->sh_type == SHT_RELX) {
2457 s->sh_info = sm_table[sh->sh_info].s->sh_num;
2458 /* update backward link */
2459 s1->sections[s->sh_info]->reloc = s;
2462 sm = sm_table;
2464 /* resolve symbols */
2465 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
2467 sym = symtab + 1;
2468 for(i = 1; i < nb_syms; i++, sym++) {
2469 if (sym->st_shndx != SHN_UNDEF &&
2470 sym->st_shndx < SHN_LORESERVE) {
2471 sm = &sm_table[sym->st_shndx];
2472 if (sm->link_once) {
2473 /* if a symbol is in a link once section, we use the
2474 already defined symbol. It is very important to get
2475 correct relocations */
2476 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
2477 name = (char *) strtab + sym->st_name;
2478 sym_index = find_elf_sym(symtab_section, name);
2479 if (sym_index)
2480 old_to_new_syms[i] = sym_index;
2482 continue;
2484 /* if no corresponding section added, no need to add symbol */
2485 if (!sm->s)
2486 continue;
2487 /* convert section number */
2488 sym->st_shndx = sm->s->sh_num;
2489 /* offset value */
2490 sym->st_value += sm->offset;
2492 /* add symbol */
2493 name = (char *) strtab + sym->st_name;
2494 sym_index = set_elf_sym(symtab_section, sym->st_value, sym->st_size,
2495 sym->st_info, sym->st_other,
2496 sym->st_shndx, name);
2497 old_to_new_syms[i] = sym_index;
2500 /* third pass to patch relocation entries */
2501 for(i = 1; i < ehdr.e_shnum; i++) {
2502 s = sm_table[i].s;
2503 if (!s)
2504 continue;
2505 sh = &shdr[i];
2506 offset = sm_table[i].offset;
2507 switch(s->sh_type) {
2508 case SHT_RELX:
2509 /* take relocation offset information */
2510 offseti = sm_table[sh->sh_info].offset;
2511 for_each_elem(s, (offset / sizeof(*rel)), rel, ElfW_Rel) {
2512 int type;
2513 unsigned sym_index;
2514 /* convert symbol index */
2515 type = ELFW(R_TYPE)(rel->r_info);
2516 sym_index = ELFW(R_SYM)(rel->r_info);
2517 /* NOTE: only one symtab assumed */
2518 if (sym_index >= nb_syms)
2519 goto invalid_reloc;
2520 sym_index = old_to_new_syms[sym_index];
2521 /* ignore link_once in rel section. */
2522 if (!sym_index && !sm->link_once
2523 #ifdef TCC_TARGET_ARM
2524 && type != R_ARM_V4BX
2525 #endif
2527 invalid_reloc:
2528 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2529 i, strsec + sh->sh_name, rel->r_offset);
2530 goto fail;
2532 rel->r_info = ELFW(R_INFO)(sym_index, type);
2533 /* offset the relocation offset */
2534 rel->r_offset += offseti;
2535 #ifdef TCC_TARGET_ARM
2536 /* Jumps and branches from a Thumb code to a PLT entry need
2537 special handling since PLT entries are ARM code.
2538 Unconditional bl instructions referencing PLT entries are
2539 handled by converting these instructions into blx
2540 instructions. Other case of instructions referencing a PLT
2541 entry require to add a Thumb stub before the PLT entry to
2542 switch to ARM mode. We set bit plt_thumb_stub of the
2543 attribute of a symbol to indicate such a case. */
2544 if (type == R_ARM_THM_JUMP24)
2545 get_sym_attr(s1, sym_index, 1)->plt_thumb_stub = 1;
2546 #endif
2548 break;
2549 default:
2550 break;
2554 ret = 0;
2555 the_end:
2556 tcc_free(symtab);
2557 tcc_free(strtab);
2558 tcc_free(old_to_new_syms);
2559 tcc_free(sm_table);
2560 tcc_free(strsec);
2561 tcc_free(shdr);
2562 return ret;
2565 typedef struct ArchiveHeader {
2566 char ar_name[16]; /* name of this member */
2567 char ar_date[12]; /* file mtime */
2568 char ar_uid[6]; /* owner uid; printed as decimal */
2569 char ar_gid[6]; /* owner gid; printed as decimal */
2570 char ar_mode[8]; /* file mode, printed as octal */
2571 char ar_size[10]; /* file size, printed as decimal */
2572 char ar_fmag[2]; /* should contain ARFMAG */
2573 } ArchiveHeader;
2575 static int get_be32(const uint8_t *b)
2577 return b[3] | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
2580 static long get_be64(const uint8_t *b)
2582 long long ret = get_be32(b);
2583 ret = (ret << 32) | (unsigned)get_be32(b+4);
2584 return (long)ret;
2587 /* load only the objects which resolve undefined symbols */
2588 static int tcc_load_alacarte(TCCState *s1, int fd, int size, int entrysize)
2590 long i, bound, nsyms, sym_index, off, ret;
2591 uint8_t *data;
2592 const char *ar_names, *p;
2593 const uint8_t *ar_index;
2594 ElfW(Sym) *sym;
2596 data = tcc_malloc(size);
2597 if (read(fd, data, size) != size)
2598 goto fail;
2599 nsyms = entrysize == 4 ? get_be32(data) : get_be64(data);
2600 ar_index = data + entrysize;
2601 ar_names = (char *) ar_index + nsyms * entrysize;
2603 do {
2604 bound = 0;
2605 for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2606 sym_index = find_elf_sym(symtab_section, p);
2607 if(sym_index) {
2608 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
2609 if(sym->st_shndx == SHN_UNDEF) {
2610 off = (entrysize == 4
2611 ? get_be32(ar_index + i * 4)
2612 : get_be64(ar_index + i * 8))
2613 + sizeof(ArchiveHeader);
2614 ++bound;
2615 if(tcc_load_object_file(s1, fd, off) < 0) {
2616 fail:
2617 ret = -1;
2618 goto the_end;
2623 } while(bound);
2624 ret = 0;
2625 the_end:
2626 tcc_free(data);
2627 return ret;
2630 /* load a '.a' file */
2631 ST_FUNC int tcc_load_archive(TCCState *s1, int fd)
2633 ArchiveHeader hdr;
2634 char ar_size[11];
2635 char ar_name[17];
2636 char magic[8];
2637 int size, len, i;
2638 unsigned long file_offset;
2640 /* skip magic which was already checked */
2641 read(fd, magic, sizeof(magic));
2643 for(;;) {
2644 len = read(fd, &hdr, sizeof(hdr));
2645 if (len == 0)
2646 break;
2647 if (len != sizeof(hdr)) {
2648 tcc_error_noabort("invalid archive");
2649 return -1;
2651 memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
2652 ar_size[sizeof(hdr.ar_size)] = '\0';
2653 size = strtol(ar_size, NULL, 0);
2654 memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
2655 for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
2656 if (ar_name[i] != ' ')
2657 break;
2659 ar_name[i + 1] = '\0';
2660 file_offset = lseek(fd, 0, SEEK_CUR);
2661 /* align to even */
2662 size = (size + 1) & ~1;
2663 if (!strcmp(ar_name, "/")) {
2664 /* coff symbol table : we handle it */
2665 if(s1->alacarte_link)
2666 return tcc_load_alacarte(s1, fd, size, 4);
2667 } else if (!strcmp(ar_name, "/SYM64/")) {
2668 if(s1->alacarte_link)
2669 return tcc_load_alacarte(s1, fd, size, 8);
2670 } else {
2671 ElfW(Ehdr) ehdr;
2672 if (tcc_object_type(fd, &ehdr) == AFF_BINTYPE_REL) {
2673 if (tcc_load_object_file(s1, fd, file_offset) < 0)
2674 return -1;
2677 lseek(fd, file_offset + size, SEEK_SET);
2679 return 0;
2682 #ifndef TCC_TARGET_PE
2683 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2684 is referenced by the user (so it should be added as DT_NEEDED in
2685 the generated ELF file) */
2686 ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
2688 ElfW(Ehdr) ehdr;
2689 ElfW(Shdr) *shdr, *sh, *sh1;
2690 int i, j, nb_syms, nb_dts, sym_bind, ret;
2691 ElfW(Sym) *sym, *dynsym;
2692 ElfW(Dyn) *dt, *dynamic;
2693 unsigned char *dynstr;
2694 const char *name, *soname;
2695 DLLReference *dllref;
2697 read(fd, &ehdr, sizeof(ehdr));
2699 /* test CPU specific stuff */
2700 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2701 ehdr.e_machine != EM_TCC_TARGET) {
2702 tcc_error_noabort("bad architecture");
2703 return -1;
2706 /* read sections */
2707 shdr = load_data(fd, ehdr.e_shoff, sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2709 /* load dynamic section and dynamic symbols */
2710 nb_syms = 0;
2711 nb_dts = 0;
2712 dynamic = NULL;
2713 dynsym = NULL; /* avoid warning */
2714 dynstr = NULL; /* avoid warning */
2715 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
2716 switch(sh->sh_type) {
2717 case SHT_DYNAMIC:
2718 nb_dts = sh->sh_size / sizeof(ElfW(Dyn));
2719 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
2720 break;
2721 case SHT_DYNSYM:
2722 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2723 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
2724 sh1 = &shdr[sh->sh_link];
2725 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
2726 break;
2727 default:
2728 break;
2732 /* compute the real library name */
2733 soname = tcc_basename(filename);
2735 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2736 if (dt->d_tag == DT_SONAME) {
2737 soname = (char *) dynstr + dt->d_un.d_val;
2741 /* if the dll is already loaded, do not load it */
2742 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2743 dllref = s1->loaded_dlls[i];
2744 if (!strcmp(soname, dllref->name)) {
2745 /* but update level if needed */
2746 if (level < dllref->level)
2747 dllref->level = level;
2748 ret = 0;
2749 goto the_end;
2753 /* add the dll and its level */
2754 dllref = tcc_mallocz(sizeof(DLLReference) + strlen(soname));
2755 dllref->level = level;
2756 strcpy(dllref->name, soname);
2757 dynarray_add(&s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
2759 /* add dynamic symbols in dynsym_section */
2760 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
2761 sym_bind = ELFW(ST_BIND)(sym->st_info);
2762 if (sym_bind == STB_LOCAL)
2763 continue;
2764 name = (char *) dynstr + sym->st_name;
2765 set_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
2766 sym->st_info, sym->st_other, sym->st_shndx, name);
2769 /* load all referenced DLLs */
2770 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2771 switch(dt->d_tag) {
2772 case DT_NEEDED:
2773 name = (char *) dynstr + dt->d_un.d_val;
2774 for(j = 0; j < s1->nb_loaded_dlls; j++) {
2775 dllref = s1->loaded_dlls[j];
2776 if (!strcmp(name, dllref->name))
2777 goto already_loaded;
2779 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
2780 tcc_error_noabort("referenced dll '%s' not found", name);
2781 ret = -1;
2782 goto the_end;
2784 already_loaded:
2785 break;
2788 ret = 0;
2789 the_end:
2790 tcc_free(dynstr);
2791 tcc_free(dynsym);
2792 tcc_free(dynamic);
2793 tcc_free(shdr);
2794 return ret;
2797 #define LD_TOK_NAME 256
2798 #define LD_TOK_EOF (-1)
2800 /* return next ld script token */
2801 static int ld_next(TCCState *s1, char *name, int name_size)
2803 int c;
2804 char *q;
2806 redo:
2807 switch(ch) {
2808 case ' ':
2809 case '\t':
2810 case '\f':
2811 case '\v':
2812 case '\r':
2813 case '\n':
2814 inp();
2815 goto redo;
2816 case '/':
2817 minp();
2818 if (ch == '*') {
2819 file->buf_ptr = parse_comment(file->buf_ptr);
2820 ch = file->buf_ptr[0];
2821 goto redo;
2822 } else {
2823 q = name;
2824 *q++ = '/';
2825 goto parse_name;
2827 break;
2828 case '\\':
2829 ch = handle_eob();
2830 if (ch != '\\')
2831 goto redo;
2832 /* fall through */
2833 /* case 'a' ... 'z': */
2834 case 'a':
2835 case 'b':
2836 case 'c':
2837 case 'd':
2838 case 'e':
2839 case 'f':
2840 case 'g':
2841 case 'h':
2842 case 'i':
2843 case 'j':
2844 case 'k':
2845 case 'l':
2846 case 'm':
2847 case 'n':
2848 case 'o':
2849 case 'p':
2850 case 'q':
2851 case 'r':
2852 case 's':
2853 case 't':
2854 case 'u':
2855 case 'v':
2856 case 'w':
2857 case 'x':
2858 case 'y':
2859 case 'z':
2860 /* case 'A' ... 'z': */
2861 case 'A':
2862 case 'B':
2863 case 'C':
2864 case 'D':
2865 case 'E':
2866 case 'F':
2867 case 'G':
2868 case 'H':
2869 case 'I':
2870 case 'J':
2871 case 'K':
2872 case 'L':
2873 case 'M':
2874 case 'N':
2875 case 'O':
2876 case 'P':
2877 case 'Q':
2878 case 'R':
2879 case 'S':
2880 case 'T':
2881 case 'U':
2882 case 'V':
2883 case 'W':
2884 case 'X':
2885 case 'Y':
2886 case 'Z':
2887 case '_':
2888 case '.':
2889 case '$':
2890 case '~':
2891 q = name;
2892 parse_name:
2893 for(;;) {
2894 if (!((ch >= 'a' && ch <= 'z') ||
2895 (ch >= 'A' && ch <= 'Z') ||
2896 (ch >= '0' && ch <= '9') ||
2897 strchr("/.-_+=$:\\,~", ch)))
2898 break;
2899 if ((q - name) < name_size - 1) {
2900 *q++ = ch;
2902 minp();
2904 *q = '\0';
2905 c = LD_TOK_NAME;
2906 break;
2907 case CH_EOF:
2908 c = LD_TOK_EOF;
2909 break;
2910 default:
2911 c = ch;
2912 inp();
2913 break;
2915 return c;
2918 static int ld_add_file(TCCState *s1, const char filename[])
2920 if (filename[0] == '/') {
2921 if (CONFIG_SYSROOT[0] == '\0'
2922 && tcc_add_file_internal(s1, filename, AFF_TYPE_BIN) == 0)
2923 return 0;
2924 filename = tcc_basename(filename);
2926 return tcc_add_dll(s1, filename, 0);
2929 static inline int new_undef_syms(void)
2931 int ret = 0;
2932 ret = new_undef_sym;
2933 new_undef_sym = 0;
2934 return ret;
2937 static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
2939 char filename[1024], libname[1024];
2940 int t, group, nblibs = 0, ret = 0;
2941 char **libs = NULL;
2943 group = !strcmp(cmd, "GROUP");
2944 if (!as_needed)
2945 new_undef_syms();
2946 t = ld_next(s1, filename, sizeof(filename));
2947 if (t != '(')
2948 expect("(");
2949 t = ld_next(s1, filename, sizeof(filename));
2950 for(;;) {
2951 libname[0] = '\0';
2952 if (t == LD_TOK_EOF) {
2953 tcc_error_noabort("unexpected end of file");
2954 ret = -1;
2955 goto lib_parse_error;
2956 } else if (t == ')') {
2957 break;
2958 } else if (t == '-') {
2959 t = ld_next(s1, filename, sizeof(filename));
2960 if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
2961 tcc_error_noabort("library name expected");
2962 ret = -1;
2963 goto lib_parse_error;
2965 pstrcpy(libname, sizeof libname, &filename[1]);
2966 if (s1->static_link) {
2967 snprintf(filename, sizeof filename, "lib%s.a", libname);
2968 } else {
2969 snprintf(filename, sizeof filename, "lib%s.so", libname);
2971 } else if (t != LD_TOK_NAME) {
2972 tcc_error_noabort("filename expected");
2973 ret = -1;
2974 goto lib_parse_error;
2976 if (!strcmp(filename, "AS_NEEDED")) {
2977 ret = ld_add_file_list(s1, cmd, 1);
2978 if (ret)
2979 goto lib_parse_error;
2980 } else {
2981 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2982 if (!as_needed) {
2983 ret = ld_add_file(s1, filename);
2984 if (ret)
2985 goto lib_parse_error;
2986 if (group) {
2987 /* Add the filename *and* the libname to avoid future conversions */
2988 dynarray_add(&libs, &nblibs, tcc_strdup(filename));
2989 if (libname[0] != '\0')
2990 dynarray_add(&libs, &nblibs, tcc_strdup(libname));
2994 t = ld_next(s1, filename, sizeof(filename));
2995 if (t == ',') {
2996 t = ld_next(s1, filename, sizeof(filename));
2999 if (group && !as_needed) {
3000 while (new_undef_syms()) {
3001 int i;
3003 for (i = 0; i < nblibs; i ++)
3004 ld_add_file(s1, libs[i]);
3007 lib_parse_error:
3008 dynarray_reset(&libs, &nblibs);
3009 return ret;
3012 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3013 files */
3014 ST_FUNC int tcc_load_ldscript(TCCState *s1)
3016 char cmd[64];
3017 char filename[1024];
3018 int t, ret;
3020 ch = handle_eob();
3021 for(;;) {
3022 t = ld_next(s1, cmd, sizeof(cmd));
3023 if (t == LD_TOK_EOF)
3024 return 0;
3025 else if (t != LD_TOK_NAME)
3026 return -1;
3027 if (!strcmp(cmd, "INPUT") ||
3028 !strcmp(cmd, "GROUP")) {
3029 ret = ld_add_file_list(s1, cmd, 0);
3030 if (ret)
3031 return ret;
3032 } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
3033 !strcmp(cmd, "TARGET")) {
3034 /* ignore some commands */
3035 t = ld_next(s1, cmd, sizeof(cmd));
3036 if (t != '(')
3037 expect("(");
3038 for(;;) {
3039 t = ld_next(s1, filename, sizeof(filename));
3040 if (t == LD_TOK_EOF) {
3041 tcc_error_noabort("unexpected end of file");
3042 return -1;
3043 } else if (t == ')') {
3044 break;
3047 } else {
3048 return -1;
3051 return 0;
3053 #endif /* !TCC_TARGET_PE */