final update for 0.9.27
[tinycc.git] / tccelf.c
blob70d47e1513e5be27307065b96e069f8c3f7456d7
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)
877 case R_386_32:
878 if (!get_sym_attr(s1, sym_index, 0)->dyn_index
879 && ((ElfW(Sym)*)symtab_section->data + sym_index)->st_shndx == SHN_UNDEF) {
880 /* don't fixup unresolved (weak) symbols */
881 rel->r_info = ELFW(R_INFO)(sym_index, R_386_RELATIVE);
882 break;
884 #elif defined(TCC_TARGET_X86_64)
885 case R_X86_64_32:
886 case R_X86_64_32S:
887 case R_X86_64_64:
888 #endif
889 count++;
890 break;
891 #if defined(TCC_TARGET_I386)
892 case R_386_PC32:
893 #elif defined(TCC_TARGET_X86_64)
894 case R_X86_64_PC32:
895 #endif
896 if (get_sym_attr(s1, sym_index, 0)->dyn_index)
897 count++;
898 break;
899 default:
900 break;
903 if (count) {
904 /* allocate the section */
905 sr->sh_flags |= SHF_ALLOC;
906 sr->sh_size = count * sizeof(ElfW_Rel);
908 return count;
911 static void build_got(TCCState *s1)
913 /* if no got, then create it */
914 s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
915 s1->got->sh_entsize = 4;
916 set_elf_sym(symtab_section, 0, 4, ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
917 0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
918 /* keep space for _DYNAMIC pointer and two dummy got entries */
919 section_ptr_add(s1->got, 3 * PTR_SIZE);
922 /* Create a GOT and (for function call) a PLT entry corresponding to a symbol
923 in s1->symtab. When creating the dynamic symbol table entry for the GOT
924 relocation, use 'size' and 'info' for the corresponding symbol metadata.
925 Returns the offset of the GOT or (if any) PLT entry. */
926 static struct sym_attr * put_got_entry(TCCState *s1, int dyn_reloc_type,
927 unsigned long size,
928 int info, int sym_index)
930 int need_plt_entry;
931 const char *name;
932 ElfW(Sym) *sym;
933 struct sym_attr *attr;
934 unsigned got_offset;
935 char plt_name[100];
936 int len;
938 need_plt_entry = (dyn_reloc_type == R_JMP_SLOT);
939 attr = get_sym_attr(s1, sym_index, 1);
941 /* In case a function is both called and its address taken 2 GOT entries
942 are created, one for taking the address (GOT) and the other for the PLT
943 entry (PLTGOT). */
944 if (need_plt_entry ? attr->plt_offset : attr->got_offset)
945 return attr;
947 /* create the GOT entry */
948 got_offset = s1->got->data_offset;
949 section_ptr_add(s1->got, PTR_SIZE);
951 /* Create the GOT relocation that will insert the address of the object or
952 function of interest in the GOT entry. This is a static relocation for
953 memory output (dlsym will give us the address of symbols) and dynamic
954 relocation otherwise (executable and DLLs). The relocation should be
955 done lazily for GOT entry with *_JUMP_SLOT relocation type (the one
956 associated to a PLT entry) but is currently done at load time for an
957 unknown reason. */
959 sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
960 name = (char *) symtab_section->link->data + sym->st_name;
962 if (s1->dynsym) {
963 if (ELFW(ST_BIND)(sym->st_info) == STB_LOCAL) {
964 /* Hack alarm. We don't want to emit dynamic symbols
965 and symbol based relocs for STB_LOCAL symbols, but rather
966 want to resolve them directly. At this point the symbol
967 values aren't final yet, so we must defer this. We will later
968 have to create a RELATIVE reloc anyway, so we misuse the
969 relocation slot to smuggle the symbol reference until
970 fill_local_got_entries. Not that the sym_index is
971 relative to symtab_section, not s1->dynsym! Nevertheless
972 we use s1->dyn_sym so that if this is the first call
973 that got->reloc is correctly created. Also note that
974 RELATIVE relocs are not normally created for the .got,
975 so the types serves as a marker for later (and is retained
976 also for the final output, which is okay because then the
977 got is just normal data). */
978 put_elf_reloc(s1->dynsym, s1->got, got_offset, R_RELATIVE,
979 sym_index);
980 } else {
981 if (0 == attr->dyn_index)
982 attr->dyn_index = set_elf_sym(s1->dynsym, sym->st_value, size,
983 info, 0, sym->st_shndx, name);
984 put_elf_reloc(s1->dynsym, s1->got, got_offset, dyn_reloc_type,
985 attr->dyn_index);
987 } else {
988 put_elf_reloc(symtab_section, s1->got, got_offset, dyn_reloc_type,
989 sym_index);
992 if (need_plt_entry) {
993 if (!s1->plt) {
994 s1->plt = new_section(s1, ".plt", SHT_PROGBITS,
995 SHF_ALLOC | SHF_EXECINSTR);
996 s1->plt->sh_entsize = 4;
999 attr->plt_offset = create_plt_entry(s1, got_offset, attr);
1001 /* create a symbol 'sym@plt' for the PLT jump vector */
1002 len = strlen(name);
1003 if (len > sizeof plt_name - 5)
1004 len = sizeof plt_name - 5;
1005 memcpy(plt_name, name, len);
1006 strcpy(plt_name + len, "@plt");
1007 attr->plt_sym = put_elf_sym(s1->symtab, attr->plt_offset, sym->st_size,
1008 ELFW(ST_INFO)(STB_GLOBAL, STT_FUNC), 0, s1->plt->sh_num, plt_name);
1010 } else {
1011 attr->got_offset = got_offset;
1014 return attr;
1017 /* build GOT and PLT entries */
1018 ST_FUNC void build_got_entries(TCCState *s1)
1020 Section *s;
1021 ElfW_Rel *rel;
1022 ElfW(Sym) *sym;
1023 int i, type, gotplt_entry, reloc_type, sym_index;
1024 struct sym_attr *attr;
1026 for(i = 1; i < s1->nb_sections; i++) {
1027 s = s1->sections[i];
1028 if (s->sh_type != SHT_RELX)
1029 continue;
1030 /* no need to handle got relocations */
1031 if (s->link != symtab_section)
1032 continue;
1033 for_each_elem(s, 0, rel, ElfW_Rel) {
1034 type = ELFW(R_TYPE)(rel->r_info);
1035 gotplt_entry = gotplt_entry_type(type);
1036 sym_index = ELFW(R_SYM)(rel->r_info);
1037 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1039 if (gotplt_entry == NO_GOTPLT_ENTRY) {
1040 continue;
1043 /* Automatically create PLT/GOT [entry] if it is an undefined
1044 reference (resolved at runtime), or the symbol is absolute,
1045 probably created by tcc_add_symbol, and thus on 64-bit
1046 targets might be too far from application code. */
1047 if (gotplt_entry == AUTO_GOTPLT_ENTRY) {
1048 if (sym->st_shndx == SHN_UNDEF) {
1049 ElfW(Sym) *esym;
1050 int dynindex;
1051 if (s1->output_type == TCC_OUTPUT_DLL && ! PCRELATIVE_DLLPLT)
1052 continue;
1053 /* Relocations for UNDEF symbols would normally need
1054 to be transferred into the executable or shared object.
1055 If that were done AUTO_GOTPLT_ENTRY wouldn't exist.
1056 But TCC doesn't do that (at least for exes), so we
1057 need to resolve all such relocs locally. And that
1058 means PLT slots for functions in DLLs and COPY relocs for
1059 data symbols. COPY relocs were generated in
1060 bind_exe_dynsyms (and the symbol adjusted to be defined),
1061 and for functions we were generated a dynamic symbol
1062 of function type. */
1063 if (s1->dynsym) {
1064 /* dynsym isn't set for -run :-/ */
1065 dynindex = get_sym_attr(s1, sym_index, 0)->dyn_index;
1066 esym = (ElfW(Sym) *)s1->dynsym->data + dynindex;
1067 if (dynindex
1068 && (ELFW(ST_TYPE)(esym->st_info) == STT_FUNC
1069 || (ELFW(ST_TYPE)(esym->st_info) == STT_NOTYPE
1070 && ELFW(ST_TYPE)(sym->st_info) == STT_FUNC)))
1071 goto jmp_slot;
1073 } else if (!(sym->st_shndx == SHN_ABS
1074 #ifndef TCC_TARGET_ARM
1075 && PTR_SIZE == 8
1076 #endif
1078 continue;
1081 #ifdef TCC_TARGET_X86_64
1082 if ((type == R_X86_64_PLT32 || type == R_X86_64_PC32) &&
1083 (ELFW(ST_VISIBILITY)(sym->st_other) != STV_DEFAULT ||
1084 ELFW(ST_BIND)(sym->st_info) == STB_LOCAL)) {
1085 rel->r_info = ELFW(R_INFO)(sym_index, R_X86_64_PC32);
1086 continue;
1088 #endif
1089 if (code_reloc(type)) {
1090 jmp_slot:
1091 reloc_type = R_JMP_SLOT;
1092 } else
1093 reloc_type = R_GLOB_DAT;
1095 if (!s1->got)
1096 build_got(s1);
1098 if (gotplt_entry == BUILD_GOT_ONLY)
1099 continue;
1101 attr = put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
1102 sym_index);
1104 if (reloc_type == R_JMP_SLOT)
1105 rel->r_info = ELFW(R_INFO)(attr->plt_sym, type);
1110 /* put dynamic tag */
1111 static void put_dt(Section *dynamic, int dt, addr_t val)
1113 ElfW(Dyn) *dyn;
1114 dyn = section_ptr_add(dynamic, sizeof(ElfW(Dyn)));
1115 dyn->d_tag = dt;
1116 dyn->d_un.d_val = val;
1119 #ifndef TCC_TARGET_PE
1120 static void add_init_array_defines(TCCState *s1, const char *section_name)
1122 Section *s;
1123 long end_offset;
1124 char sym_start[1024];
1125 char sym_end[1024];
1127 snprintf(sym_start, sizeof(sym_start), "__%s_start", section_name + 1);
1128 snprintf(sym_end, sizeof(sym_end), "__%s_end", section_name + 1);
1130 s = find_section(s1, section_name);
1131 if (!s) {
1132 end_offset = 0;
1133 s = data_section;
1134 } else {
1135 end_offset = s->data_offset;
1138 set_elf_sym(symtab_section,
1139 0, 0,
1140 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1141 s->sh_num, sym_start);
1142 set_elf_sym(symtab_section,
1143 end_offset, 0,
1144 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1145 s->sh_num, sym_end);
1147 #endif
1149 static int tcc_add_support(TCCState *s1, const char *filename)
1151 char buf[1024];
1152 snprintf(buf, sizeof(buf), "%s/%s", s1->tcc_lib_path, filename);
1153 return tcc_add_file(s1, buf);
1156 ST_FUNC void tcc_add_bcheck(TCCState *s1)
1158 #ifdef CONFIG_TCC_BCHECK
1159 addr_t *ptr;
1160 int sym_index;
1162 if (0 == s1->do_bounds_check)
1163 return;
1164 /* XXX: add an object file to do that */
1165 ptr = section_ptr_add(bounds_section, sizeof(*ptr));
1166 *ptr = 0;
1167 set_elf_sym(symtab_section, 0, 0,
1168 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1169 bounds_section->sh_num, "__bounds_start");
1170 /* pull bcheck.o from libtcc1.a */
1171 sym_index = set_elf_sym(symtab_section, 0, 0,
1172 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1173 SHN_UNDEF, "__bound_init");
1174 if (s1->output_type != TCC_OUTPUT_MEMORY) {
1175 /* add 'call __bound_init()' in .init section */
1176 Section *init_section = find_section(s1, ".init");
1177 unsigned char *pinit = section_ptr_add(init_section, 5);
1178 pinit[0] = 0xe8;
1179 write32le(pinit + 1, -4);
1180 put_elf_reloc(symtab_section, init_section,
1181 init_section->data_offset - 4, R_386_PC32, sym_index);
1182 /* R_386_PC32 = R_X86_64_PC32 = 2 */
1184 #endif
1187 /* add tcc runtime libraries */
1188 ST_FUNC void tcc_add_runtime(TCCState *s1)
1190 tcc_add_bcheck(s1);
1191 tcc_add_pragma_libs(s1);
1192 /* add libc */
1193 if (!s1->nostdlib) {
1194 tcc_add_library_err(s1, "c");
1195 #ifdef TCC_LIBGCC
1196 if (!s1->static_link) {
1197 if (TCC_LIBGCC[0] == '/')
1198 tcc_add_file(s1, TCC_LIBGCC);
1199 else
1200 tcc_add_dll(s1, TCC_LIBGCC, 0);
1202 #endif
1203 tcc_add_support(s1, TCC_LIBTCC1);
1204 /* add crt end if not memory output */
1205 if (s1->output_type != TCC_OUTPUT_MEMORY)
1206 tcc_add_crt(s1, "crtn.o");
1210 /* add various standard linker symbols (must be done after the
1211 sections are filled (for example after allocating common
1212 symbols)) */
1213 static void tcc_add_linker_symbols(TCCState *s1)
1215 char buf[1024];
1216 int i;
1217 Section *s;
1219 set_elf_sym(symtab_section,
1220 text_section->data_offset, 0,
1221 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1222 text_section->sh_num, "_etext");
1223 set_elf_sym(symtab_section,
1224 data_section->data_offset, 0,
1225 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1226 data_section->sh_num, "_edata");
1227 set_elf_sym(symtab_section,
1228 bss_section->data_offset, 0,
1229 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1230 bss_section->sh_num, "_end");
1231 #ifndef TCC_TARGET_PE
1232 /* horrible new standard ldscript defines */
1233 add_init_array_defines(s1, ".preinit_array");
1234 add_init_array_defines(s1, ".init_array");
1235 add_init_array_defines(s1, ".fini_array");
1236 #endif
1238 /* add start and stop symbols for sections whose name can be
1239 expressed in C */
1240 for(i = 1; i < s1->nb_sections; i++) {
1241 s = s1->sections[i];
1242 if (s->sh_type == SHT_PROGBITS &&
1243 (s->sh_flags & SHF_ALLOC)) {
1244 const char *p;
1245 int ch;
1247 /* check if section name can be expressed in C */
1248 p = s->name;
1249 for(;;) {
1250 ch = *p;
1251 if (!ch)
1252 break;
1253 if (!isid(ch) && !isnum(ch))
1254 goto next_sec;
1255 p++;
1257 snprintf(buf, sizeof(buf), "__start_%s", s->name);
1258 set_elf_sym(symtab_section,
1259 0, 0,
1260 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1261 s->sh_num, buf);
1262 snprintf(buf, sizeof(buf), "__stop_%s", s->name);
1263 set_elf_sym(symtab_section,
1264 s->data_offset, 0,
1265 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1266 s->sh_num, buf);
1268 next_sec: ;
1272 ST_FUNC void resolve_common_syms(TCCState *s1)
1274 ElfW(Sym) *sym;
1276 /* Allocate common symbols in BSS. */
1277 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1278 if (sym->st_shndx == SHN_COMMON) {
1279 /* symbol alignment is in st_value for SHN_COMMONs */
1280 sym->st_value = section_add(bss_section, sym->st_size,
1281 sym->st_value);
1282 sym->st_shndx = bss_section->sh_num;
1286 /* Now assign linker provided symbols their value. */
1287 tcc_add_linker_symbols(s1);
1290 static void tcc_output_binary(TCCState *s1, FILE *f,
1291 const int *sec_order)
1293 Section *s;
1294 int i, offset, size;
1296 offset = 0;
1297 for(i=1;i<s1->nb_sections;i++) {
1298 s = s1->sections[sec_order[i]];
1299 if (s->sh_type != SHT_NOBITS &&
1300 (s->sh_flags & SHF_ALLOC)) {
1301 while (offset < s->sh_offset) {
1302 fputc(0, f);
1303 offset++;
1305 size = s->sh_size;
1306 fwrite(s->data, 1, size, f);
1307 offset += size;
1312 ST_FUNC void fill_got_entry(TCCState *s1, ElfW_Rel *rel)
1314 int sym_index = ELFW(R_SYM) (rel->r_info);
1315 ElfW(Sym) *sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
1316 struct sym_attr *attr = get_sym_attr(s1, sym_index, 0);
1317 unsigned offset = attr->got_offset;
1319 if (0 == offset)
1320 return;
1321 section_reserve(s1->got, offset + PTR_SIZE);
1322 #ifdef TCC_TARGET_X86_64
1323 write64le(s1->got->data + offset, sym->st_value);
1324 #else
1325 write32le(s1->got->data + offset, sym->st_value);
1326 #endif
1329 /* Perform relocation to GOT or PLT entries */
1330 ST_FUNC void fill_got(TCCState *s1)
1332 Section *s;
1333 ElfW_Rel *rel;
1334 int i;
1336 for(i = 1; i < s1->nb_sections; i++) {
1337 s = s1->sections[i];
1338 if (s->sh_type != SHT_RELX)
1339 continue;
1340 /* no need to handle got relocations */
1341 if (s->link != symtab_section)
1342 continue;
1343 for_each_elem(s, 0, rel, ElfW_Rel) {
1344 switch (ELFW(R_TYPE) (rel->r_info)) {
1345 case R_X86_64_GOT32:
1346 case R_X86_64_GOTPCREL:
1347 case R_X86_64_GOTPCRELX:
1348 case R_X86_64_REX_GOTPCRELX:
1349 case R_X86_64_PLT32:
1350 fill_got_entry(s1, rel);
1351 break;
1357 /* See put_got_entry for a description. This is the second stage
1358 where GOT references to local defined symbols are rewritten. */
1359 static void fill_local_got_entries(TCCState *s1)
1361 ElfW_Rel *rel;
1362 for_each_elem(s1->got->reloc, 0, rel, ElfW_Rel) {
1363 if (ELFW(R_TYPE)(rel->r_info) == R_RELATIVE) {
1364 int sym_index = ELFW(R_SYM) (rel->r_info);
1365 ElfW(Sym) *sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
1366 struct sym_attr *attr = get_sym_attr(s1, sym_index, 0);
1367 unsigned offset = attr->got_offset;
1368 if (offset != rel->r_offset - s1->got->sh_addr)
1369 tcc_error_noabort("huh");
1370 rel->r_info = ELFW(R_INFO)(0, R_RELATIVE);
1371 #if SHT_RELX == SHT_RELA
1372 rel->r_addend = sym->st_value;
1373 #else
1374 /* All our REL architectures also happen to be 32bit LE. */
1375 write32le(s1->got->data + offset, sym->st_value);
1376 #endif
1381 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1382 in shared libraries and export non local defined symbols to shared libraries
1383 if -rdynamic switch was given on command line */
1384 static void bind_exe_dynsyms(TCCState *s1)
1386 const char *name;
1387 int sym_index, index;
1388 ElfW(Sym) *sym, *esym;
1389 int type;
1391 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1392 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1393 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1394 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1395 if (sym->st_shndx == SHN_UNDEF) {
1396 name = (char *) symtab_section->link->data + sym->st_name;
1397 sym_index = find_elf_sym(s1->dynsymtab_section, name);
1398 if (sym_index) {
1399 esym = &((ElfW(Sym) *)s1->dynsymtab_section->data)[sym_index];
1400 type = ELFW(ST_TYPE)(esym->st_info);
1401 if ((type == STT_FUNC) || (type == STT_GNU_IFUNC)) {
1402 /* Indirect functions shall have STT_FUNC type in executable
1403 * dynsym section. Indeed, a dlsym call following a lazy
1404 * resolution would pick the symbol value from the
1405 * executable dynsym entry which would contain the address
1406 * of the function wanted by the caller of dlsym instead of
1407 * the address of the function that would return that
1408 * address */
1409 int dynindex
1410 = put_elf_sym(s1->dynsym, 0, esym->st_size,
1411 ELFW(ST_INFO)(STB_GLOBAL,STT_FUNC), 0, 0,
1412 name);
1413 int index = sym - (ElfW(Sym) *) symtab_section->data;
1414 get_sym_attr(s1, index, 1)->dyn_index = dynindex;
1415 } else if (type == STT_OBJECT) {
1416 unsigned long offset;
1417 ElfW(Sym) *dynsym;
1418 offset = bss_section->data_offset;
1419 /* XXX: which alignment ? */
1420 offset = (offset + 16 - 1) & -16;
1421 set_elf_sym (s1->symtab, offset, esym->st_size,
1422 esym->st_info, 0, bss_section->sh_num, name);
1423 index = put_elf_sym(s1->dynsym, offset, esym->st_size,
1424 esym->st_info, 0, bss_section->sh_num,
1425 name);
1427 /* Ensure R_COPY works for weak symbol aliases */
1428 if (ELFW(ST_BIND)(esym->st_info) == STB_WEAK) {
1429 for_each_elem(s1->dynsymtab_section, 1, dynsym, ElfW(Sym)) {
1430 if ((dynsym->st_value == esym->st_value)
1431 && (ELFW(ST_BIND)(dynsym->st_info) == STB_GLOBAL)) {
1432 char *dynname = (char *) s1->dynsymtab_section->link->data
1433 + dynsym->st_name;
1434 put_elf_sym(s1->dynsym, offset, dynsym->st_size,
1435 dynsym->st_info, 0,
1436 bss_section->sh_num, dynname);
1437 break;
1442 put_elf_reloc(s1->dynsym, bss_section,
1443 offset, R_COPY, index);
1444 offset += esym->st_size;
1445 bss_section->data_offset = offset;
1447 } else {
1448 /* STB_WEAK undefined symbols are accepted */
1449 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1450 if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK ||
1451 !strcmp(name, "_fp_hw")) {
1452 } else {
1453 tcc_error_noabort("undefined symbol '%s'", name);
1456 } else if (s1->rdynamic && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1457 /* if -rdynamic option, then export all non local symbols */
1458 name = (char *) symtab_section->link->data + sym->st_name;
1459 set_elf_sym(s1->dynsym, sym->st_value, sym->st_size, sym->st_info,
1460 0, sym->st_shndx, name);
1465 /* Bind symbols of libraries: export all non local symbols of executable that
1466 are referenced by shared libraries. The reason is that the dynamic loader
1467 search symbol first in executable and then in libraries. Therefore a
1468 reference to a symbol already defined by a library can still be resolved by
1469 a symbol in the executable. */
1470 static void bind_libs_dynsyms(TCCState *s1)
1472 const char *name;
1473 int sym_index;
1474 ElfW(Sym) *sym, *esym;
1476 for_each_elem(s1->dynsymtab_section, 1, esym, ElfW(Sym)) {
1477 name = (char *) s1->dynsymtab_section->link->data + esym->st_name;
1478 sym_index = find_elf_sym(symtab_section, name);
1479 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1480 if (sym_index && sym->st_shndx != SHN_UNDEF
1481 && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1482 set_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1483 sym->st_info, 0, sym->st_shndx, name);
1484 } else if (esym->st_shndx == SHN_UNDEF) {
1485 /* weak symbols can stay undefined */
1486 if (ELFW(ST_BIND)(esym->st_info) != STB_WEAK)
1487 tcc_warning("undefined dynamic symbol '%s'", name);
1492 /* Export all non local symbols. This is used by shared libraries so that the
1493 non local symbols they define can resolve a reference in another shared
1494 library or in the executable. Correspondingly, it allows undefined local
1495 symbols to be resolved by other shared libraries or by the executable. */
1496 static void export_global_syms(TCCState *s1)
1498 int dynindex, index;
1499 const char *name;
1500 ElfW(Sym) *sym;
1502 for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
1503 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1504 name = (char *) symtab_section->link->data + sym->st_name;
1505 dynindex = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1506 sym->st_info, 0, sym->st_shndx, name);
1507 index = sym - (ElfW(Sym) *) symtab_section->data;
1508 get_sym_attr(s1, index, 1)->dyn_index = dynindex;
1513 /* Allocate strings for section names and decide if an unallocated section
1514 should be output.
1515 NOTE: the strsec section comes last, so its size is also correct ! */
1516 static int alloc_sec_names(TCCState *s1, int file_type, Section *strsec)
1518 int i;
1519 Section *s;
1520 int textrel = 0;
1522 /* Allocate strings for section names */
1523 for(i = 1; i < s1->nb_sections; i++) {
1524 s = s1->sections[i];
1525 /* when generating a DLL, we include relocations but we may
1526 patch them */
1527 if (file_type == TCC_OUTPUT_DLL &&
1528 s->sh_type == SHT_RELX &&
1529 !(s->sh_flags & SHF_ALLOC) &&
1530 (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC) &&
1531 prepare_dynamic_rel(s1, s)) {
1532 if (s1->sections[s->sh_info]->sh_flags & SHF_EXECINSTR)
1533 textrel = 1;
1534 } else if (s1->do_debug ||
1535 file_type == TCC_OUTPUT_OBJ ||
1536 (s->sh_flags & SHF_ALLOC) ||
1537 i == (s1->nb_sections - 1)) {
1538 /* we output all sections if debug or object file */
1539 s->sh_size = s->data_offset;
1541 if (s->sh_size || (s->sh_flags & SHF_ALLOC))
1542 s->sh_name = put_elf_str(strsec, s->name);
1544 strsec->sh_size = strsec->data_offset;
1545 return textrel;
1548 /* Info to be copied in dynamic section */
1549 struct dyn_inf {
1550 Section *dynamic;
1551 Section *dynstr;
1552 unsigned long data_offset;
1553 addr_t rel_addr;
1554 addr_t rel_size;
1555 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1556 addr_t bss_addr;
1557 addr_t bss_size;
1558 #endif
1561 /* Assign sections to segments and decide how are sections laid out when loaded
1562 in memory. This function also fills corresponding program headers. */
1563 static int layout_sections(TCCState *s1, ElfW(Phdr) *phdr, int phnum,
1564 Section *interp, Section* strsec,
1565 struct dyn_inf *dyninf, int *sec_order)
1567 int i, j, k, file_type, sh_order_index, file_offset;
1568 unsigned long s_align;
1569 long long tmp;
1570 addr_t addr;
1571 ElfW(Phdr) *ph;
1572 Section *s;
1574 file_type = s1->output_type;
1575 sh_order_index = 1;
1576 file_offset = 0;
1577 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
1578 file_offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1579 s_align = ELF_PAGE_SIZE;
1580 if (s1->section_align)
1581 s_align = s1->section_align;
1583 if (phnum > 0) {
1584 if (s1->has_text_addr) {
1585 int a_offset, p_offset;
1586 addr = s1->text_addr;
1587 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1588 ELF_PAGE_SIZE */
1589 a_offset = (int) (addr & (s_align - 1));
1590 p_offset = file_offset & (s_align - 1);
1591 if (a_offset < p_offset)
1592 a_offset += s_align;
1593 file_offset += (a_offset - p_offset);
1594 } else {
1595 if (file_type == TCC_OUTPUT_DLL)
1596 addr = 0;
1597 else
1598 addr = ELF_START_ADDR;
1599 /* compute address after headers */
1600 addr += (file_offset & (s_align - 1));
1603 ph = &phdr[0];
1604 /* Leave one program headers for the program interpreter and one for
1605 the program header table itself if needed. These are done later as
1606 they require section layout to be done first. */
1607 if (interp)
1608 ph += 2;
1610 /* dynamic relocation table information, for .dynamic section */
1611 dyninf->rel_addr = dyninf->rel_size = 0;
1612 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1613 dyninf->bss_addr = dyninf->bss_size = 0;
1614 #endif
1616 for(j = 0; j < 2; j++) {
1617 ph->p_type = PT_LOAD;
1618 if (j == 0)
1619 ph->p_flags = PF_R | PF_X;
1620 else
1621 ph->p_flags = PF_R | PF_W;
1622 ph->p_align = s_align;
1624 /* Decide the layout of sections loaded in memory. This must
1625 be done before program headers are filled since they contain
1626 info about the layout. We do the following ordering: interp,
1627 symbol tables, relocations, progbits, nobits */
1628 /* XXX: do faster and simpler sorting */
1629 for(k = 0; k < 5; k++) {
1630 for(i = 1; i < s1->nb_sections; i++) {
1631 s = s1->sections[i];
1632 /* compute if section should be included */
1633 if (j == 0) {
1634 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1635 SHF_ALLOC)
1636 continue;
1637 } else {
1638 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1639 (SHF_ALLOC | SHF_WRITE))
1640 continue;
1642 if (s == interp) {
1643 if (k != 0)
1644 continue;
1645 } else if (s->sh_type == SHT_DYNSYM ||
1646 s->sh_type == SHT_STRTAB ||
1647 s->sh_type == SHT_HASH) {
1648 if (k != 1)
1649 continue;
1650 } else if (s->sh_type == SHT_RELX) {
1651 if (k != 2)
1652 continue;
1653 } else if (s->sh_type == SHT_NOBITS) {
1654 if (k != 4)
1655 continue;
1656 } else {
1657 if (k != 3)
1658 continue;
1660 sec_order[sh_order_index++] = i;
1662 /* section matches: we align it and add its size */
1663 tmp = addr;
1664 addr = (addr + s->sh_addralign - 1) &
1665 ~(s->sh_addralign - 1);
1666 file_offset += (int) ( addr - tmp );
1667 s->sh_offset = file_offset;
1668 s->sh_addr = addr;
1670 /* update program header infos */
1671 if (ph->p_offset == 0) {
1672 ph->p_offset = file_offset;
1673 ph->p_vaddr = addr;
1674 ph->p_paddr = ph->p_vaddr;
1676 /* update dynamic relocation infos */
1677 if (s->sh_type == SHT_RELX) {
1678 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1679 if (!strcmp(strsec->data + s->sh_name, ".rel.got")) {
1680 dyninf->rel_addr = addr;
1681 dyninf->rel_size += s->sh_size; /* XXX only first rel. */
1683 if (!strcmp(strsec->data + s->sh_name, ".rel.bss")) {
1684 dyninf->bss_addr = addr;
1685 dyninf->bss_size = s->sh_size; /* XXX only first rel. */
1687 #else
1688 if (dyninf->rel_size == 0)
1689 dyninf->rel_addr = addr;
1690 dyninf->rel_size += s->sh_size;
1691 #endif
1693 addr += s->sh_size;
1694 if (s->sh_type != SHT_NOBITS)
1695 file_offset += s->sh_size;
1698 if (j == 0) {
1699 /* Make the first PT_LOAD segment include the program
1700 headers itself (and the ELF header as well), it'll
1701 come out with same memory use but will make various
1702 tools like binutils strip work better. */
1703 ph->p_offset &= ~(ph->p_align - 1);
1704 ph->p_vaddr &= ~(ph->p_align - 1);
1705 ph->p_paddr &= ~(ph->p_align - 1);
1707 ph->p_filesz = file_offset - ph->p_offset;
1708 ph->p_memsz = addr - ph->p_vaddr;
1709 ph++;
1710 if (j == 0) {
1711 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1712 /* if in the middle of a page, we duplicate the page in
1713 memory so that one copy is RX and the other is RW */
1714 if ((addr & (s_align - 1)) != 0)
1715 addr += s_align;
1716 } else {
1717 addr = (addr + s_align - 1) & ~(s_align - 1);
1718 file_offset = (file_offset + s_align - 1) & ~(s_align - 1);
1724 /* all other sections come after */
1725 for(i = 1; i < s1->nb_sections; i++) {
1726 s = s1->sections[i];
1727 if (phnum > 0 && (s->sh_flags & SHF_ALLOC))
1728 continue;
1729 sec_order[sh_order_index++] = i;
1731 file_offset = (file_offset + s->sh_addralign - 1) &
1732 ~(s->sh_addralign - 1);
1733 s->sh_offset = file_offset;
1734 if (s->sh_type != SHT_NOBITS)
1735 file_offset += s->sh_size;
1738 return file_offset;
1741 static void fill_unloadable_phdr(ElfW(Phdr) *phdr, int phnum, Section *interp,
1742 Section *dynamic)
1744 ElfW(Phdr) *ph;
1746 /* if interpreter, then add corresponding program header */
1747 if (interp) {
1748 ph = &phdr[0];
1750 ph->p_type = PT_PHDR;
1751 ph->p_offset = sizeof(ElfW(Ehdr));
1752 ph->p_filesz = ph->p_memsz = phnum * sizeof(ElfW(Phdr));
1753 ph->p_vaddr = interp->sh_addr - ph->p_filesz;
1754 ph->p_paddr = ph->p_vaddr;
1755 ph->p_flags = PF_R | PF_X;
1756 ph->p_align = 4; /* interp->sh_addralign; */
1757 ph++;
1759 ph->p_type = PT_INTERP;
1760 ph->p_offset = interp->sh_offset;
1761 ph->p_vaddr = interp->sh_addr;
1762 ph->p_paddr = ph->p_vaddr;
1763 ph->p_filesz = interp->sh_size;
1764 ph->p_memsz = interp->sh_size;
1765 ph->p_flags = PF_R;
1766 ph->p_align = interp->sh_addralign;
1769 /* if dynamic section, then add corresponding program header */
1770 if (dynamic) {
1771 ph = &phdr[phnum - 1];
1773 ph->p_type = PT_DYNAMIC;
1774 ph->p_offset = dynamic->sh_offset;
1775 ph->p_vaddr = dynamic->sh_addr;
1776 ph->p_paddr = ph->p_vaddr;
1777 ph->p_filesz = dynamic->sh_size;
1778 ph->p_memsz = dynamic->sh_size;
1779 ph->p_flags = PF_R | PF_W;
1780 ph->p_align = dynamic->sh_addralign;
1784 /* Fill the dynamic section with tags describing the address and size of
1785 sections */
1786 static void fill_dynamic(TCCState *s1, struct dyn_inf *dyninf)
1788 Section *dynamic = dyninf->dynamic;
1790 /* put dynamic section entries */
1791 put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
1792 put_dt(dynamic, DT_STRTAB, dyninf->dynstr->sh_addr);
1793 put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
1794 put_dt(dynamic, DT_STRSZ, dyninf->dynstr->data_offset);
1795 put_dt(dynamic, DT_SYMENT, sizeof(ElfW(Sym)));
1796 #if PTR_SIZE == 8
1797 put_dt(dynamic, DT_RELA, dyninf->rel_addr);
1798 put_dt(dynamic, DT_RELASZ, dyninf->rel_size);
1799 put_dt(dynamic, DT_RELAENT, sizeof(ElfW_Rel));
1800 #else
1801 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1802 put_dt(dynamic, DT_PLTGOT, s1->got->sh_addr);
1803 put_dt(dynamic, DT_PLTRELSZ, dyninf->rel_size);
1804 put_dt(dynamic, DT_JMPREL, dyninf->rel_addr);
1805 put_dt(dynamic, DT_PLTREL, DT_REL);
1806 put_dt(dynamic, DT_REL, dyninf->bss_addr);
1807 put_dt(dynamic, DT_RELSZ, dyninf->bss_size);
1808 #else
1809 put_dt(dynamic, DT_REL, dyninf->rel_addr);
1810 put_dt(dynamic, DT_RELSZ, dyninf->rel_size);
1811 put_dt(dynamic, DT_RELENT, sizeof(ElfW_Rel));
1812 #endif
1813 #endif
1814 if (s1->do_debug)
1815 put_dt(dynamic, DT_DEBUG, 0);
1816 put_dt(dynamic, DT_NULL, 0);
1819 /* Relocate remaining sections and symbols (that is those not related to
1820 dynamic linking) */
1821 static int final_sections_reloc(TCCState *s1)
1823 int i;
1824 Section *s;
1826 relocate_syms(s1, s1->symtab, 0);
1828 if (s1->nb_errors != 0)
1829 return -1;
1831 /* relocate sections */
1832 /* XXX: ignore sections with allocated relocations ? */
1833 for(i = 1; i < s1->nb_sections; i++) {
1834 s = s1->sections[i];
1835 #if defined(TCC_TARGET_I386) || defined(TCC_MUSL)
1836 if (s->reloc && s != s1->got && (s->sh_flags & SHF_ALLOC)) //gr
1837 /* On X86 gdb 7.3 works in any case but gdb 6.6 will crash if SHF_ALLOC
1838 checking is removed */
1839 #else
1840 if (s->reloc && s != s1->got)
1841 /* On X86_64 gdb 7.3 will crash if SHF_ALLOC checking is present */
1842 #endif
1843 relocate_section(s1, s);
1846 /* relocate relocation entries if the relocation tables are
1847 allocated in the executable */
1848 for(i = 1; i < s1->nb_sections; i++) {
1849 s = s1->sections[i];
1850 if ((s->sh_flags & SHF_ALLOC) &&
1851 s->sh_type == SHT_RELX) {
1852 relocate_rel(s1, s);
1855 return 0;
1858 /* Create an ELF file on disk.
1859 This function handle ELF specific layout requirements */
1860 static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
1861 int file_offset, int *sec_order)
1863 int i, shnum, offset, size, file_type;
1864 Section *s;
1865 ElfW(Ehdr) ehdr;
1866 ElfW(Shdr) shdr, *sh;
1868 file_type = s1->output_type;
1869 shnum = s1->nb_sections;
1871 memset(&ehdr, 0, sizeof(ehdr));
1873 if (phnum > 0) {
1874 ehdr.e_phentsize = sizeof(ElfW(Phdr));
1875 ehdr.e_phnum = phnum;
1876 ehdr.e_phoff = sizeof(ElfW(Ehdr));
1879 /* align to 4 */
1880 file_offset = (file_offset + 3) & -4;
1882 /* fill header */
1883 ehdr.e_ident[0] = ELFMAG0;
1884 ehdr.e_ident[1] = ELFMAG1;
1885 ehdr.e_ident[2] = ELFMAG2;
1886 ehdr.e_ident[3] = ELFMAG3;
1887 ehdr.e_ident[4] = ELFCLASSW;
1888 ehdr.e_ident[5] = ELFDATA2LSB;
1889 ehdr.e_ident[6] = EV_CURRENT;
1890 #if !defined(TCC_TARGET_PE) && (defined(__FreeBSD__) || defined(__FreeBSD_kernel__))
1891 /* FIXME: should set only for freebsd _target_, but we exclude only PE target */
1892 ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
1893 #endif
1894 #ifdef TCC_TARGET_ARM
1895 #ifdef TCC_ARM_EABI
1896 ehdr.e_ident[EI_OSABI] = 0;
1897 ehdr.e_flags = EF_ARM_EABI_VER4;
1898 if (file_type == TCC_OUTPUT_EXE || file_type == TCC_OUTPUT_DLL)
1899 ehdr.e_flags |= EF_ARM_HASENTRY;
1900 if (s1->float_abi == ARM_HARD_FLOAT)
1901 ehdr.e_flags |= EF_ARM_VFP_FLOAT;
1902 else
1903 ehdr.e_flags |= EF_ARM_SOFT_FLOAT;
1904 #else
1905 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
1906 #endif
1907 #endif
1908 switch(file_type) {
1909 default:
1910 case TCC_OUTPUT_EXE:
1911 ehdr.e_type = ET_EXEC;
1912 ehdr.e_entry = get_elf_sym_addr(s1, "_start", 1);
1913 break;
1914 case TCC_OUTPUT_DLL:
1915 ehdr.e_type = ET_DYN;
1916 ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
1917 break;
1918 case TCC_OUTPUT_OBJ:
1919 ehdr.e_type = ET_REL;
1920 break;
1922 ehdr.e_machine = EM_TCC_TARGET;
1923 ehdr.e_version = EV_CURRENT;
1924 ehdr.e_shoff = file_offset;
1925 ehdr.e_ehsize = sizeof(ElfW(Ehdr));
1926 ehdr.e_shentsize = sizeof(ElfW(Shdr));
1927 ehdr.e_shnum = shnum;
1928 ehdr.e_shstrndx = shnum - 1;
1930 fwrite(&ehdr, 1, sizeof(ElfW(Ehdr)), f);
1931 fwrite(phdr, 1, phnum * sizeof(ElfW(Phdr)), f);
1932 offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1934 sort_syms(s1, symtab_section);
1935 for(i = 1; i < s1->nb_sections; i++) {
1936 s = s1->sections[sec_order[i]];
1937 if (s->sh_type != SHT_NOBITS) {
1938 while (offset < s->sh_offset) {
1939 fputc(0, f);
1940 offset++;
1942 size = s->sh_size;
1943 if (size)
1944 fwrite(s->data, 1, size, f);
1945 offset += size;
1949 /* output section headers */
1950 while (offset < ehdr.e_shoff) {
1951 fputc(0, f);
1952 offset++;
1955 for(i = 0; i < s1->nb_sections; i++) {
1956 sh = &shdr;
1957 memset(sh, 0, sizeof(ElfW(Shdr)));
1958 s = s1->sections[i];
1959 if (s) {
1960 sh->sh_name = s->sh_name;
1961 sh->sh_type = s->sh_type;
1962 sh->sh_flags = s->sh_flags;
1963 sh->sh_entsize = s->sh_entsize;
1964 sh->sh_info = s->sh_info;
1965 if (s->link)
1966 sh->sh_link = s->link->sh_num;
1967 sh->sh_addralign = s->sh_addralign;
1968 sh->sh_addr = s->sh_addr;
1969 sh->sh_offset = s->sh_offset;
1970 sh->sh_size = s->sh_size;
1972 fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
1976 /* Write an elf, coff or "binary" file */
1977 static int tcc_write_elf_file(TCCState *s1, const char *filename, int phnum,
1978 ElfW(Phdr) *phdr, int file_offset, int *sec_order)
1980 int fd, mode, file_type;
1981 FILE *f;
1983 file_type = s1->output_type;
1984 if (file_type == TCC_OUTPUT_OBJ)
1985 mode = 0666;
1986 else
1987 mode = 0777;
1988 unlink(filename);
1989 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
1990 if (fd < 0) {
1991 tcc_error_noabort("could not write '%s'", filename);
1992 return -1;
1994 f = fdopen(fd, "wb");
1995 if (s1->verbose)
1996 printf("<- %s\n", filename);
1998 #ifdef TCC_TARGET_COFF
1999 if (s1->output_format == TCC_OUTPUT_FORMAT_COFF)
2000 tcc_output_coff(s1, f);
2001 else
2002 #endif
2003 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
2004 tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
2005 else
2006 tcc_output_binary(s1, f, sec_order);
2007 fclose(f);
2009 return 0;
2012 /* Sort section headers by assigned sh_addr, remove sections
2013 that we aren't going to output. */
2014 static void tidy_section_headers(TCCState *s1, int *sec_order)
2016 int i, nnew, l, *backmap;
2017 Section **snew, *s;
2018 ElfW(Sym) *sym;
2020 snew = tcc_malloc(s1->nb_sections * sizeof(snew[0]));
2021 backmap = tcc_malloc(s1->nb_sections * sizeof(backmap[0]));
2022 for (i = 0, nnew = 0, l = s1->nb_sections; i < s1->nb_sections; i++) {
2023 s = s1->sections[sec_order[i]];
2024 if (!i || s->sh_name) {
2025 backmap[sec_order[i]] = nnew;
2026 snew[nnew] = s;
2027 ++nnew;
2028 } else {
2029 backmap[sec_order[i]] = 0;
2030 snew[--l] = s;
2033 for (i = 0; i < nnew; i++) {
2034 s = snew[i];
2035 if (s) {
2036 s->sh_num = i;
2037 if (s->sh_type == SHT_RELX)
2038 s->sh_info = backmap[s->sh_info];
2042 for_each_elem(symtab_section, 1, sym, ElfW(Sym))
2043 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE)
2044 sym->st_shndx = backmap[sym->st_shndx];
2045 if( !s1->static_link ) {
2046 for_each_elem(s1->dynsym, 1, sym, ElfW(Sym))
2047 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE)
2048 sym->st_shndx = backmap[sym->st_shndx];
2050 for (i = 0; i < s1->nb_sections; i++)
2051 sec_order[i] = i;
2052 tcc_free(s1->sections);
2053 s1->sections = snew;
2054 s1->nb_sections = nnew;
2055 tcc_free(backmap);
2058 /* Output an elf, coff or binary file */
2059 /* XXX: suppress unneeded sections */
2060 static int elf_output_file(TCCState *s1, const char *filename)
2062 int i, ret, phnum, shnum, file_type, file_offset, *sec_order;
2063 struct dyn_inf dyninf = {0};
2064 ElfW(Phdr) *phdr;
2065 ElfW(Sym) *sym;
2066 Section *strsec, *interp, *dynamic, *dynstr;
2067 int textrel;
2069 file_type = s1->output_type;
2070 s1->nb_errors = 0;
2071 ret = -1;
2072 phdr = NULL;
2073 sec_order = NULL;
2074 interp = dynamic = dynstr = NULL; /* avoid warning */
2075 textrel = 0;
2077 if (file_type != TCC_OUTPUT_OBJ) {
2078 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2079 tcc_add_runtime(s1);
2080 resolve_common_syms(s1);
2082 if (!s1->static_link) {
2083 if (file_type == TCC_OUTPUT_EXE) {
2084 char *ptr;
2085 /* allow override the dynamic loader */
2086 const char *elfint = getenv("LD_SO");
2087 if (elfint == NULL)
2088 elfint = DEFAULT_ELFINTERP(s1);
2089 /* add interpreter section only if executable */
2090 interp = new_section(s1, ".interp", SHT_PROGBITS, SHF_ALLOC);
2091 interp->sh_addralign = 1;
2092 ptr = section_ptr_add(interp, 1 + strlen(elfint));
2093 strcpy(ptr, elfint);
2096 /* add dynamic symbol table */
2097 s1->dynsym = new_symtab(s1, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
2098 ".dynstr",
2099 ".hash", SHF_ALLOC);
2100 dynstr = s1->dynsym->link;
2102 /* add dynamic section */
2103 dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC,
2104 SHF_ALLOC | SHF_WRITE);
2105 dynamic->link = dynstr;
2106 dynamic->sh_entsize = sizeof(ElfW(Dyn));
2108 build_got(s1);
2110 if (file_type == TCC_OUTPUT_EXE) {
2111 bind_exe_dynsyms(s1);
2112 if (s1->nb_errors)
2113 goto the_end;
2114 bind_libs_dynsyms(s1);
2115 } else {
2116 /* shared library case: simply export all global symbols */
2117 export_global_syms(s1);
2120 build_got_entries(s1);
2123 /* we add a section for symbols */
2124 strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0);
2125 put_elf_str(strsec, "");
2127 /* Allocate strings for section names */
2128 textrel = alloc_sec_names(s1, file_type, strsec);
2130 if (dynamic) {
2131 /* add a list of needed dlls */
2132 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2133 DLLReference *dllref = s1->loaded_dlls[i];
2134 if (dllref->level == 0)
2135 put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name));
2138 if (s1->rpath)
2139 put_dt(dynamic, s1->enable_new_dtags ? DT_RUNPATH : DT_RPATH,
2140 put_elf_str(dynstr, s1->rpath));
2142 if (file_type == TCC_OUTPUT_DLL) {
2143 if (s1->soname)
2144 put_dt(dynamic, DT_SONAME, put_elf_str(dynstr, s1->soname));
2145 /* XXX: currently, since we do not handle PIC code, we
2146 must relocate the readonly segments */
2147 if (textrel)
2148 put_dt(dynamic, DT_TEXTREL, 0);
2151 if (s1->symbolic)
2152 put_dt(dynamic, DT_SYMBOLIC, 0);
2154 dyninf.dynamic = dynamic;
2155 dyninf.dynstr = dynstr;
2156 /* remember offset and reserve space for 2nd call below */
2157 dyninf.data_offset = dynamic->data_offset;
2158 fill_dynamic(s1, &dyninf);
2159 dynamic->sh_size = dynamic->data_offset;
2160 dynstr->sh_size = dynstr->data_offset;
2163 /* compute number of program headers */
2164 if (file_type == TCC_OUTPUT_OBJ)
2165 phnum = 0;
2166 else if (file_type == TCC_OUTPUT_DLL)
2167 phnum = 3;
2168 else if (s1->static_link)
2169 phnum = 2;
2170 else
2171 phnum = 5;
2173 /* allocate program segment headers */
2174 phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
2176 /* compute number of sections */
2177 shnum = s1->nb_sections;
2179 /* this array is used to reorder sections in the output file */
2180 sec_order = tcc_malloc(sizeof(int) * shnum);
2181 sec_order[0] = 0;
2183 /* compute section to program header mapping */
2184 file_offset = layout_sections(s1, phdr, phnum, interp, strsec, &dyninf,
2185 sec_order);
2187 /* Fill remaining program header and finalize relocation related to dynamic
2188 linking. */
2189 if (file_type != TCC_OUTPUT_OBJ) {
2190 fill_unloadable_phdr(phdr, phnum, interp, dynamic);
2191 if (dynamic) {
2192 dynamic->data_offset = dyninf.data_offset;
2193 fill_dynamic(s1, &dyninf);
2195 /* put in GOT the dynamic section address and relocate PLT */
2196 write32le(s1->got->data, dynamic->sh_addr);
2197 if (file_type == TCC_OUTPUT_EXE
2198 || (RELOCATE_DLLPLT && file_type == TCC_OUTPUT_DLL))
2199 relocate_plt(s1);
2201 /* relocate symbols in .dynsym now that final addresses are known */
2202 for_each_elem(s1->dynsym, 1, sym, ElfW(Sym)) {
2203 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE) {
2204 /* do symbol relocation */
2205 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
2210 /* if building executable or DLL, then relocate each section
2211 except the GOT which is already relocated */
2212 ret = final_sections_reloc(s1);
2213 if (ret)
2214 goto the_end;
2215 tidy_section_headers(s1, sec_order);
2217 /* Perform relocation to GOT or PLT entries */
2218 if (file_type == TCC_OUTPUT_EXE && s1->static_link)
2219 fill_got(s1);
2220 else if (s1->got)
2221 fill_local_got_entries(s1);
2224 /* Create the ELF file with name 'filename' */
2225 ret = tcc_write_elf_file(s1, filename, phnum, phdr, file_offset, sec_order);
2226 s1->nb_sections = shnum;
2227 the_end:
2228 tcc_free(sec_order);
2229 tcc_free(phdr);
2230 return ret;
2233 LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename)
2235 int ret;
2236 #ifdef TCC_TARGET_PE
2237 if (s->output_type != TCC_OUTPUT_OBJ) {
2238 ret = pe_output_file(s, filename);
2239 } else
2240 #endif
2241 ret = elf_output_file(s, filename);
2242 return ret;
2245 static void *load_data(int fd, unsigned long file_offset, unsigned long size)
2247 void *data;
2249 data = tcc_malloc(size);
2250 lseek(fd, file_offset, SEEK_SET);
2251 read(fd, data, size);
2252 return data;
2255 typedef struct SectionMergeInfo {
2256 Section *s; /* corresponding existing section */
2257 unsigned long offset; /* offset of the new section in the existing section */
2258 uint8_t new_section; /* true if section 's' was added */
2259 uint8_t link_once; /* true if link once section */
2260 } SectionMergeInfo;
2262 ST_FUNC int tcc_object_type(int fd, ElfW(Ehdr) *h)
2264 int size = read(fd, h, sizeof *h);
2265 if (size == sizeof *h && 0 == memcmp(h, ELFMAG, 4)) {
2266 if (h->e_type == ET_REL)
2267 return AFF_BINTYPE_REL;
2268 if (h->e_type == ET_DYN)
2269 return AFF_BINTYPE_DYN;
2270 } else if (size >= 8) {
2271 if (0 == memcmp(h, ARMAG, 8))
2272 return AFF_BINTYPE_AR;
2273 #ifdef TCC_TARGET_COFF
2274 if (((struct filehdr*)h)->f_magic == COFF_C67_MAGIC)
2275 return AFF_BINTYPE_C67;
2276 #endif
2278 return 0;
2281 /* load an object file and merge it with current files */
2282 /* XXX: handle correctly stab (debug) info */
2283 ST_FUNC int tcc_load_object_file(TCCState *s1,
2284 int fd, unsigned long file_offset)
2286 ElfW(Ehdr) ehdr;
2287 ElfW(Shdr) *shdr, *sh;
2288 int size, i, j, offset, offseti, nb_syms, sym_index, ret, seencompressed;
2289 unsigned char *strsec, *strtab;
2290 int *old_to_new_syms;
2291 char *sh_name, *name;
2292 SectionMergeInfo *sm_table, *sm;
2293 ElfW(Sym) *sym, *symtab;
2294 ElfW_Rel *rel;
2295 Section *s;
2297 int stab_index;
2298 int stabstr_index;
2300 stab_index = stabstr_index = 0;
2302 lseek(fd, file_offset, SEEK_SET);
2303 if (tcc_object_type(fd, &ehdr) != AFF_BINTYPE_REL)
2304 goto fail1;
2305 /* test CPU specific stuff */
2306 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2307 ehdr.e_machine != EM_TCC_TARGET) {
2308 fail1:
2309 tcc_error_noabort("invalid object file");
2310 return -1;
2312 /* read sections */
2313 shdr = load_data(fd, file_offset + ehdr.e_shoff,
2314 sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2315 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
2317 /* load section names */
2318 sh = &shdr[ehdr.e_shstrndx];
2319 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2321 /* load symtab and strtab */
2322 old_to_new_syms = NULL;
2323 symtab = NULL;
2324 strtab = NULL;
2325 nb_syms = 0;
2326 seencompressed = 0;
2327 for(i = 1; i < ehdr.e_shnum; i++) {
2328 sh = &shdr[i];
2329 if (sh->sh_type == SHT_SYMTAB) {
2330 if (symtab) {
2331 tcc_error_noabort("object must contain only one symtab");
2332 fail:
2333 ret = -1;
2334 goto the_end;
2336 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2337 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2338 sm_table[i].s = symtab_section;
2340 /* now load strtab */
2341 sh = &shdr[sh->sh_link];
2342 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2344 if (sh->sh_flags & SHF_COMPRESSED)
2345 seencompressed = 1;
2348 /* now examine each section and try to merge its content with the
2349 ones in memory */
2350 for(i = 1; i < ehdr.e_shnum; i++) {
2351 /* no need to examine section name strtab */
2352 if (i == ehdr.e_shstrndx)
2353 continue;
2354 sh = &shdr[i];
2355 sh_name = (char *) strsec + sh->sh_name;
2356 /* ignore sections types we do not handle */
2357 if (sh->sh_type != SHT_PROGBITS &&
2358 sh->sh_type != SHT_RELX &&
2359 #ifdef TCC_ARM_EABI
2360 sh->sh_type != SHT_ARM_EXIDX &&
2361 #endif
2362 sh->sh_type != SHT_NOBITS &&
2363 sh->sh_type != SHT_PREINIT_ARRAY &&
2364 sh->sh_type != SHT_INIT_ARRAY &&
2365 sh->sh_type != SHT_FINI_ARRAY &&
2366 strcmp(sh_name, ".stabstr")
2368 continue;
2369 if (seencompressed
2370 && (!strncmp(sh_name, ".debug_", sizeof(".debug_")-1)
2371 || (sh->sh_type == SHT_RELX
2372 && !strncmp((char*)strsec + shdr[sh->sh_info].sh_name,
2373 ".debug_", sizeof(".debug_")-1))))
2374 continue;
2375 if (sh->sh_addralign < 1)
2376 sh->sh_addralign = 1;
2377 /* find corresponding section, if any */
2378 for(j = 1; j < s1->nb_sections;j++) {
2379 s = s1->sections[j];
2380 if (!strcmp(s->name, sh_name)) {
2381 if (!strncmp(sh_name, ".gnu.linkonce",
2382 sizeof(".gnu.linkonce") - 1)) {
2383 /* if a 'linkonce' section is already present, we
2384 do not add it again. It is a little tricky as
2385 symbols can still be defined in
2386 it. */
2387 sm_table[i].link_once = 1;
2388 goto next;
2389 } else {
2390 goto found;
2394 /* not found: create new section */
2395 s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags & ~SHF_GROUP);
2396 /* take as much info as possible from the section. sh_link and
2397 sh_info will be updated later */
2398 s->sh_addralign = sh->sh_addralign;
2399 s->sh_entsize = sh->sh_entsize;
2400 sm_table[i].new_section = 1;
2401 found:
2402 if (sh->sh_type != s->sh_type) {
2403 tcc_error_noabort("invalid section type");
2404 goto fail;
2407 /* align start of section */
2408 offset = s->data_offset;
2410 if (0 == strcmp(sh_name, ".stab")) {
2411 stab_index = i;
2412 goto no_align;
2414 if (0 == strcmp(sh_name, ".stabstr")) {
2415 stabstr_index = i;
2416 goto no_align;
2419 size = sh->sh_addralign - 1;
2420 offset = (offset + size) & ~size;
2421 if (sh->sh_addralign > s->sh_addralign)
2422 s->sh_addralign = sh->sh_addralign;
2423 s->data_offset = offset;
2424 no_align:
2425 sm_table[i].offset = offset;
2426 sm_table[i].s = s;
2427 /* concatenate sections */
2428 size = sh->sh_size;
2429 if (sh->sh_type != SHT_NOBITS) {
2430 unsigned char *ptr;
2431 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
2432 ptr = section_ptr_add(s, size);
2433 read(fd, ptr, size);
2434 } else {
2435 s->data_offset += size;
2437 next: ;
2440 /* gr relocate stab strings */
2441 if (stab_index && stabstr_index) {
2442 Stab_Sym *a, *b;
2443 unsigned o;
2444 s = sm_table[stab_index].s;
2445 a = (Stab_Sym *)(s->data + sm_table[stab_index].offset);
2446 b = (Stab_Sym *)(s->data + s->data_offset);
2447 o = sm_table[stabstr_index].offset;
2448 while (a < b)
2449 a->n_strx += o, a++;
2452 /* second short pass to update sh_link and sh_info fields of new
2453 sections */
2454 for(i = 1; i < ehdr.e_shnum; i++) {
2455 s = sm_table[i].s;
2456 if (!s || !sm_table[i].new_section)
2457 continue;
2458 sh = &shdr[i];
2459 if (sh->sh_link > 0)
2460 s->link = sm_table[sh->sh_link].s;
2461 if (sh->sh_type == SHT_RELX) {
2462 s->sh_info = sm_table[sh->sh_info].s->sh_num;
2463 /* update backward link */
2464 s1->sections[s->sh_info]->reloc = s;
2467 sm = sm_table;
2469 /* resolve symbols */
2470 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
2472 sym = symtab + 1;
2473 for(i = 1; i < nb_syms; i++, sym++) {
2474 if (sym->st_shndx != SHN_UNDEF &&
2475 sym->st_shndx < SHN_LORESERVE) {
2476 sm = &sm_table[sym->st_shndx];
2477 if (sm->link_once) {
2478 /* if a symbol is in a link once section, we use the
2479 already defined symbol. It is very important to get
2480 correct relocations */
2481 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
2482 name = (char *) strtab + sym->st_name;
2483 sym_index = find_elf_sym(symtab_section, name);
2484 if (sym_index)
2485 old_to_new_syms[i] = sym_index;
2487 continue;
2489 /* if no corresponding section added, no need to add symbol */
2490 if (!sm->s)
2491 continue;
2492 /* convert section number */
2493 sym->st_shndx = sm->s->sh_num;
2494 /* offset value */
2495 sym->st_value += sm->offset;
2497 /* add symbol */
2498 name = (char *) strtab + sym->st_name;
2499 sym_index = set_elf_sym(symtab_section, sym->st_value, sym->st_size,
2500 sym->st_info, sym->st_other,
2501 sym->st_shndx, name);
2502 old_to_new_syms[i] = sym_index;
2505 /* third pass to patch relocation entries */
2506 for(i = 1; i < ehdr.e_shnum; i++) {
2507 s = sm_table[i].s;
2508 if (!s)
2509 continue;
2510 sh = &shdr[i];
2511 offset = sm_table[i].offset;
2512 switch(s->sh_type) {
2513 case SHT_RELX:
2514 /* take relocation offset information */
2515 offseti = sm_table[sh->sh_info].offset;
2516 for_each_elem(s, (offset / sizeof(*rel)), rel, ElfW_Rel) {
2517 int type;
2518 unsigned sym_index;
2519 /* convert symbol index */
2520 type = ELFW(R_TYPE)(rel->r_info);
2521 sym_index = ELFW(R_SYM)(rel->r_info);
2522 /* NOTE: only one symtab assumed */
2523 if (sym_index >= nb_syms)
2524 goto invalid_reloc;
2525 sym_index = old_to_new_syms[sym_index];
2526 /* ignore link_once in rel section. */
2527 if (!sym_index && !sm->link_once
2528 #ifdef TCC_TARGET_ARM
2529 && type != R_ARM_V4BX
2530 #endif
2532 invalid_reloc:
2533 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2534 i, strsec + sh->sh_name, rel->r_offset);
2535 goto fail;
2537 rel->r_info = ELFW(R_INFO)(sym_index, type);
2538 /* offset the relocation offset */
2539 rel->r_offset += offseti;
2540 #ifdef TCC_TARGET_ARM
2541 /* Jumps and branches from a Thumb code to a PLT entry need
2542 special handling since PLT entries are ARM code.
2543 Unconditional bl instructions referencing PLT entries are
2544 handled by converting these instructions into blx
2545 instructions. Other case of instructions referencing a PLT
2546 entry require to add a Thumb stub before the PLT entry to
2547 switch to ARM mode. We set bit plt_thumb_stub of the
2548 attribute of a symbol to indicate such a case. */
2549 if (type == R_ARM_THM_JUMP24)
2550 get_sym_attr(s1, sym_index, 1)->plt_thumb_stub = 1;
2551 #endif
2553 break;
2554 default:
2555 break;
2559 ret = 0;
2560 the_end:
2561 tcc_free(symtab);
2562 tcc_free(strtab);
2563 tcc_free(old_to_new_syms);
2564 tcc_free(sm_table);
2565 tcc_free(strsec);
2566 tcc_free(shdr);
2567 return ret;
2570 typedef struct ArchiveHeader {
2571 char ar_name[16]; /* name of this member */
2572 char ar_date[12]; /* file mtime */
2573 char ar_uid[6]; /* owner uid; printed as decimal */
2574 char ar_gid[6]; /* owner gid; printed as decimal */
2575 char ar_mode[8]; /* file mode, printed as octal */
2576 char ar_size[10]; /* file size, printed as decimal */
2577 char ar_fmag[2]; /* should contain ARFMAG */
2578 } ArchiveHeader;
2580 static int get_be32(const uint8_t *b)
2582 return b[3] | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
2585 static long get_be64(const uint8_t *b)
2587 long long ret = get_be32(b);
2588 ret = (ret << 32) | (unsigned)get_be32(b+4);
2589 return (long)ret;
2592 /* load only the objects which resolve undefined symbols */
2593 static int tcc_load_alacarte(TCCState *s1, int fd, int size, int entrysize)
2595 long i, bound, nsyms, sym_index, off, ret;
2596 uint8_t *data;
2597 const char *ar_names, *p;
2598 const uint8_t *ar_index;
2599 ElfW(Sym) *sym;
2601 data = tcc_malloc(size);
2602 if (read(fd, data, size) != size)
2603 goto fail;
2604 nsyms = entrysize == 4 ? get_be32(data) : get_be64(data);
2605 ar_index = data + entrysize;
2606 ar_names = (char *) ar_index + nsyms * entrysize;
2608 do {
2609 bound = 0;
2610 for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2611 sym_index = find_elf_sym(symtab_section, p);
2612 if(sym_index) {
2613 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
2614 if(sym->st_shndx == SHN_UNDEF) {
2615 off = (entrysize == 4
2616 ? get_be32(ar_index + i * 4)
2617 : get_be64(ar_index + i * 8))
2618 + sizeof(ArchiveHeader);
2619 ++bound;
2620 if(tcc_load_object_file(s1, fd, off) < 0) {
2621 fail:
2622 ret = -1;
2623 goto the_end;
2628 } while(bound);
2629 ret = 0;
2630 the_end:
2631 tcc_free(data);
2632 return ret;
2635 /* load a '.a' file */
2636 ST_FUNC int tcc_load_archive(TCCState *s1, int fd)
2638 ArchiveHeader hdr;
2639 char ar_size[11];
2640 char ar_name[17];
2641 char magic[8];
2642 int size, len, i;
2643 unsigned long file_offset;
2645 /* skip magic which was already checked */
2646 read(fd, magic, sizeof(magic));
2648 for(;;) {
2649 len = read(fd, &hdr, sizeof(hdr));
2650 if (len == 0)
2651 break;
2652 if (len != sizeof(hdr)) {
2653 tcc_error_noabort("invalid archive");
2654 return -1;
2656 memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
2657 ar_size[sizeof(hdr.ar_size)] = '\0';
2658 size = strtol(ar_size, NULL, 0);
2659 memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
2660 for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
2661 if (ar_name[i] != ' ')
2662 break;
2664 ar_name[i + 1] = '\0';
2665 file_offset = lseek(fd, 0, SEEK_CUR);
2666 /* align to even */
2667 size = (size + 1) & ~1;
2668 if (!strcmp(ar_name, "/")) {
2669 /* coff symbol table : we handle it */
2670 if(s1->alacarte_link)
2671 return tcc_load_alacarte(s1, fd, size, 4);
2672 } else if (!strcmp(ar_name, "/SYM64/")) {
2673 if(s1->alacarte_link)
2674 return tcc_load_alacarte(s1, fd, size, 8);
2675 } else {
2676 ElfW(Ehdr) ehdr;
2677 if (tcc_object_type(fd, &ehdr) == AFF_BINTYPE_REL) {
2678 if (tcc_load_object_file(s1, fd, file_offset) < 0)
2679 return -1;
2682 lseek(fd, file_offset + size, SEEK_SET);
2684 return 0;
2687 #ifndef TCC_TARGET_PE
2688 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2689 is referenced by the user (so it should be added as DT_NEEDED in
2690 the generated ELF file) */
2691 ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
2693 ElfW(Ehdr) ehdr;
2694 ElfW(Shdr) *shdr, *sh, *sh1;
2695 int i, j, nb_syms, nb_dts, sym_bind, ret;
2696 ElfW(Sym) *sym, *dynsym;
2697 ElfW(Dyn) *dt, *dynamic;
2698 unsigned char *dynstr;
2699 const char *name, *soname;
2700 DLLReference *dllref;
2702 read(fd, &ehdr, sizeof(ehdr));
2704 /* test CPU specific stuff */
2705 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2706 ehdr.e_machine != EM_TCC_TARGET) {
2707 tcc_error_noabort("bad architecture");
2708 return -1;
2711 /* read sections */
2712 shdr = load_data(fd, ehdr.e_shoff, sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2714 /* load dynamic section and dynamic symbols */
2715 nb_syms = 0;
2716 nb_dts = 0;
2717 dynamic = NULL;
2718 dynsym = NULL; /* avoid warning */
2719 dynstr = NULL; /* avoid warning */
2720 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
2721 switch(sh->sh_type) {
2722 case SHT_DYNAMIC:
2723 nb_dts = sh->sh_size / sizeof(ElfW(Dyn));
2724 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
2725 break;
2726 case SHT_DYNSYM:
2727 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2728 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
2729 sh1 = &shdr[sh->sh_link];
2730 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
2731 break;
2732 default:
2733 break;
2737 /* compute the real library name */
2738 soname = tcc_basename(filename);
2740 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2741 if (dt->d_tag == DT_SONAME) {
2742 soname = (char *) dynstr + dt->d_un.d_val;
2746 /* if the dll is already loaded, do not load it */
2747 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2748 dllref = s1->loaded_dlls[i];
2749 if (!strcmp(soname, dllref->name)) {
2750 /* but update level if needed */
2751 if (level < dllref->level)
2752 dllref->level = level;
2753 ret = 0;
2754 goto the_end;
2758 /* add the dll and its level */
2759 dllref = tcc_mallocz(sizeof(DLLReference) + strlen(soname));
2760 dllref->level = level;
2761 strcpy(dllref->name, soname);
2762 dynarray_add(&s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
2764 /* add dynamic symbols in dynsym_section */
2765 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
2766 sym_bind = ELFW(ST_BIND)(sym->st_info);
2767 if (sym_bind == STB_LOCAL)
2768 continue;
2769 name = (char *) dynstr + sym->st_name;
2770 set_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
2771 sym->st_info, sym->st_other, sym->st_shndx, name);
2774 /* load all referenced DLLs */
2775 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2776 switch(dt->d_tag) {
2777 case DT_NEEDED:
2778 name = (char *) dynstr + dt->d_un.d_val;
2779 for(j = 0; j < s1->nb_loaded_dlls; j++) {
2780 dllref = s1->loaded_dlls[j];
2781 if (!strcmp(name, dllref->name))
2782 goto already_loaded;
2784 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
2785 tcc_error_noabort("referenced dll '%s' not found", name);
2786 ret = -1;
2787 goto the_end;
2789 already_loaded:
2790 break;
2793 ret = 0;
2794 the_end:
2795 tcc_free(dynstr);
2796 tcc_free(dynsym);
2797 tcc_free(dynamic);
2798 tcc_free(shdr);
2799 return ret;
2802 #define LD_TOK_NAME 256
2803 #define LD_TOK_EOF (-1)
2805 /* return next ld script token */
2806 static int ld_next(TCCState *s1, char *name, int name_size)
2808 int c;
2809 char *q;
2811 redo:
2812 switch(ch) {
2813 case ' ':
2814 case '\t':
2815 case '\f':
2816 case '\v':
2817 case '\r':
2818 case '\n':
2819 inp();
2820 goto redo;
2821 case '/':
2822 minp();
2823 if (ch == '*') {
2824 file->buf_ptr = parse_comment(file->buf_ptr);
2825 ch = file->buf_ptr[0];
2826 goto redo;
2827 } else {
2828 q = name;
2829 *q++ = '/';
2830 goto parse_name;
2832 break;
2833 case '\\':
2834 ch = handle_eob();
2835 if (ch != '\\')
2836 goto redo;
2837 /* fall through */
2838 /* case 'a' ... 'z': */
2839 case 'a':
2840 case 'b':
2841 case 'c':
2842 case 'd':
2843 case 'e':
2844 case 'f':
2845 case 'g':
2846 case 'h':
2847 case 'i':
2848 case 'j':
2849 case 'k':
2850 case 'l':
2851 case 'm':
2852 case 'n':
2853 case 'o':
2854 case 'p':
2855 case 'q':
2856 case 'r':
2857 case 's':
2858 case 't':
2859 case 'u':
2860 case 'v':
2861 case 'w':
2862 case 'x':
2863 case 'y':
2864 case 'z':
2865 /* case 'A' ... 'z': */
2866 case 'A':
2867 case 'B':
2868 case 'C':
2869 case 'D':
2870 case 'E':
2871 case 'F':
2872 case 'G':
2873 case 'H':
2874 case 'I':
2875 case 'J':
2876 case 'K':
2877 case 'L':
2878 case 'M':
2879 case 'N':
2880 case 'O':
2881 case 'P':
2882 case 'Q':
2883 case 'R':
2884 case 'S':
2885 case 'T':
2886 case 'U':
2887 case 'V':
2888 case 'W':
2889 case 'X':
2890 case 'Y':
2891 case 'Z':
2892 case '_':
2893 case '.':
2894 case '$':
2895 case '~':
2896 q = name;
2897 parse_name:
2898 for(;;) {
2899 if (!((ch >= 'a' && ch <= 'z') ||
2900 (ch >= 'A' && ch <= 'Z') ||
2901 (ch >= '0' && ch <= '9') ||
2902 strchr("/.-_+=$:\\,~", ch)))
2903 break;
2904 if ((q - name) < name_size - 1) {
2905 *q++ = ch;
2907 minp();
2909 *q = '\0';
2910 c = LD_TOK_NAME;
2911 break;
2912 case CH_EOF:
2913 c = LD_TOK_EOF;
2914 break;
2915 default:
2916 c = ch;
2917 inp();
2918 break;
2920 return c;
2923 static int ld_add_file(TCCState *s1, const char filename[])
2925 if (filename[0] == '/') {
2926 if (CONFIG_SYSROOT[0] == '\0'
2927 && tcc_add_file_internal(s1, filename, AFF_TYPE_BIN) == 0)
2928 return 0;
2929 filename = tcc_basename(filename);
2931 return tcc_add_dll(s1, filename, 0);
2934 static inline int new_undef_syms(void)
2936 int ret = 0;
2937 ret = new_undef_sym;
2938 new_undef_sym = 0;
2939 return ret;
2942 static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
2944 char filename[1024], libname[1024];
2945 int t, group, nblibs = 0, ret = 0;
2946 char **libs = NULL;
2948 group = !strcmp(cmd, "GROUP");
2949 if (!as_needed)
2950 new_undef_syms();
2951 t = ld_next(s1, filename, sizeof(filename));
2952 if (t != '(')
2953 expect("(");
2954 t = ld_next(s1, filename, sizeof(filename));
2955 for(;;) {
2956 libname[0] = '\0';
2957 if (t == LD_TOK_EOF) {
2958 tcc_error_noabort("unexpected end of file");
2959 ret = -1;
2960 goto lib_parse_error;
2961 } else if (t == ')') {
2962 break;
2963 } else if (t == '-') {
2964 t = ld_next(s1, filename, sizeof(filename));
2965 if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
2966 tcc_error_noabort("library name expected");
2967 ret = -1;
2968 goto lib_parse_error;
2970 pstrcpy(libname, sizeof libname, &filename[1]);
2971 if (s1->static_link) {
2972 snprintf(filename, sizeof filename, "lib%s.a", libname);
2973 } else {
2974 snprintf(filename, sizeof filename, "lib%s.so", libname);
2976 } else if (t != LD_TOK_NAME) {
2977 tcc_error_noabort("filename expected");
2978 ret = -1;
2979 goto lib_parse_error;
2981 if (!strcmp(filename, "AS_NEEDED")) {
2982 ret = ld_add_file_list(s1, cmd, 1);
2983 if (ret)
2984 goto lib_parse_error;
2985 } else {
2986 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2987 if (!as_needed) {
2988 ret = ld_add_file(s1, filename);
2989 if (ret)
2990 goto lib_parse_error;
2991 if (group) {
2992 /* Add the filename *and* the libname to avoid future conversions */
2993 dynarray_add(&libs, &nblibs, tcc_strdup(filename));
2994 if (libname[0] != '\0')
2995 dynarray_add(&libs, &nblibs, tcc_strdup(libname));
2999 t = ld_next(s1, filename, sizeof(filename));
3000 if (t == ',') {
3001 t = ld_next(s1, filename, sizeof(filename));
3004 if (group && !as_needed) {
3005 while (new_undef_syms()) {
3006 int i;
3008 for (i = 0; i < nblibs; i ++)
3009 ld_add_file(s1, libs[i]);
3012 lib_parse_error:
3013 dynarray_reset(&libs, &nblibs);
3014 return ret;
3017 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3018 files */
3019 ST_FUNC int tcc_load_ldscript(TCCState *s1)
3021 char cmd[64];
3022 char filename[1024];
3023 int t, ret;
3025 ch = handle_eob();
3026 for(;;) {
3027 t = ld_next(s1, cmd, sizeof(cmd));
3028 if (t == LD_TOK_EOF)
3029 return 0;
3030 else if (t != LD_TOK_NAME)
3031 return -1;
3032 if (!strcmp(cmd, "INPUT") ||
3033 !strcmp(cmd, "GROUP")) {
3034 ret = ld_add_file_list(s1, cmd, 0);
3035 if (ret)
3036 return ret;
3037 } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
3038 !strcmp(cmd, "TARGET")) {
3039 /* ignore some commands */
3040 t = ld_next(s1, cmd, sizeof(cmd));
3041 if (t != '(')
3042 expect("(");
3043 for(;;) {
3044 t = ld_next(s1, filename, sizeof(filename));
3045 if (t == LD_TOK_EOF) {
3046 tcc_error_noabort("unexpected end of file");
3047 return -1;
3048 } else if (t == ')') {
3049 break;
3052 } else {
3053 return -1;
3056 return 0;
3058 #endif /* !TCC_TARGET_PE */