Add make testspp.all/testspp.20
[tinycc.git] / tccelf.c
blobc0cbe429371dc2a7fc55b9db03bd0f1b583a0197
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 && s->sh_type != SHT_RELX) ||
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 (s->reloc && s != s1->got)
1836 relocate_section(s1, s);
1839 /* relocate relocation entries if the relocation tables are
1840 allocated in the executable */
1841 for(i = 1; i < s1->nb_sections; i++) {
1842 s = s1->sections[i];
1843 if ((s->sh_flags & SHF_ALLOC) &&
1844 s->sh_type == SHT_RELX) {
1845 relocate_rel(s1, s);
1848 return 0;
1851 /* Create an ELF file on disk.
1852 This function handle ELF specific layout requirements */
1853 static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
1854 int file_offset, int *sec_order)
1856 int i, shnum, offset, size, file_type;
1857 Section *s;
1858 ElfW(Ehdr) ehdr;
1859 ElfW(Shdr) shdr, *sh;
1861 file_type = s1->output_type;
1862 shnum = s1->nb_sections;
1864 memset(&ehdr, 0, sizeof(ehdr));
1866 if (phnum > 0) {
1867 ehdr.e_phentsize = sizeof(ElfW(Phdr));
1868 ehdr.e_phnum = phnum;
1869 ehdr.e_phoff = sizeof(ElfW(Ehdr));
1872 /* align to 4 */
1873 file_offset = (file_offset + 3) & -4;
1875 /* fill header */
1876 ehdr.e_ident[0] = ELFMAG0;
1877 ehdr.e_ident[1] = ELFMAG1;
1878 ehdr.e_ident[2] = ELFMAG2;
1879 ehdr.e_ident[3] = ELFMAG3;
1880 ehdr.e_ident[4] = ELFCLASSW;
1881 ehdr.e_ident[5] = ELFDATA2LSB;
1882 ehdr.e_ident[6] = EV_CURRENT;
1883 #if !defined(TCC_TARGET_PE) && (defined(__FreeBSD__) || defined(__FreeBSD_kernel__))
1884 /* FIXME: should set only for freebsd _target_, but we exclude only PE target */
1885 ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
1886 #endif
1887 #ifdef TCC_TARGET_ARM
1888 #ifdef TCC_ARM_EABI
1889 ehdr.e_ident[EI_OSABI] = 0;
1890 ehdr.e_flags = EF_ARM_EABI_VER4;
1891 if (file_type == TCC_OUTPUT_EXE || file_type == TCC_OUTPUT_DLL)
1892 ehdr.e_flags |= EF_ARM_HASENTRY;
1893 if (s1->float_abi == ARM_HARD_FLOAT)
1894 ehdr.e_flags |= EF_ARM_VFP_FLOAT;
1895 else
1896 ehdr.e_flags |= EF_ARM_SOFT_FLOAT;
1897 #else
1898 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
1899 #endif
1900 #endif
1901 switch(file_type) {
1902 default:
1903 case TCC_OUTPUT_EXE:
1904 ehdr.e_type = ET_EXEC;
1905 ehdr.e_entry = get_elf_sym_addr(s1, "_start", 1);
1906 break;
1907 case TCC_OUTPUT_DLL:
1908 ehdr.e_type = ET_DYN;
1909 ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
1910 break;
1911 case TCC_OUTPUT_OBJ:
1912 ehdr.e_type = ET_REL;
1913 break;
1915 ehdr.e_machine = EM_TCC_TARGET;
1916 ehdr.e_version = EV_CURRENT;
1917 ehdr.e_shoff = file_offset;
1918 ehdr.e_ehsize = sizeof(ElfW(Ehdr));
1919 ehdr.e_shentsize = sizeof(ElfW(Shdr));
1920 ehdr.e_shnum = shnum;
1921 ehdr.e_shstrndx = shnum - 1;
1923 fwrite(&ehdr, 1, sizeof(ElfW(Ehdr)), f);
1924 fwrite(phdr, 1, phnum * sizeof(ElfW(Phdr)), f);
1925 offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1927 sort_syms(s1, symtab_section);
1928 for(i = 1; i < s1->nb_sections; i++) {
1929 s = s1->sections[sec_order[i]];
1930 if (s->sh_type != SHT_NOBITS) {
1931 while (offset < s->sh_offset) {
1932 fputc(0, f);
1933 offset++;
1935 size = s->sh_size;
1936 if (size)
1937 fwrite(s->data, 1, size, f);
1938 offset += size;
1942 /* output section headers */
1943 while (offset < ehdr.e_shoff) {
1944 fputc(0, f);
1945 offset++;
1948 for(i = 0; i < s1->nb_sections; i++) {
1949 sh = &shdr;
1950 memset(sh, 0, sizeof(ElfW(Shdr)));
1951 s = s1->sections[i];
1952 if (s) {
1953 sh->sh_name = s->sh_name;
1954 sh->sh_type = s->sh_type;
1955 sh->sh_flags = s->sh_flags;
1956 sh->sh_entsize = s->sh_entsize;
1957 sh->sh_info = s->sh_info;
1958 if (s->link)
1959 sh->sh_link = s->link->sh_num;
1960 sh->sh_addralign = s->sh_addralign;
1961 sh->sh_addr = s->sh_addr;
1962 sh->sh_offset = s->sh_offset;
1963 sh->sh_size = s->sh_size;
1965 fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
1969 /* Write an elf, coff or "binary" file */
1970 static int tcc_write_elf_file(TCCState *s1, const char *filename, int phnum,
1971 ElfW(Phdr) *phdr, int file_offset, int *sec_order)
1973 int fd, mode, file_type;
1974 FILE *f;
1976 file_type = s1->output_type;
1977 if (file_type == TCC_OUTPUT_OBJ)
1978 mode = 0666;
1979 else
1980 mode = 0777;
1981 unlink(filename);
1982 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
1983 if (fd < 0) {
1984 tcc_error_noabort("could not write '%s'", filename);
1985 return -1;
1987 f = fdopen(fd, "wb");
1988 if (s1->verbose)
1989 printf("<- %s\n", filename);
1991 #ifdef TCC_TARGET_COFF
1992 if (s1->output_format == TCC_OUTPUT_FORMAT_COFF)
1993 tcc_output_coff(s1, f);
1994 else
1995 #endif
1996 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
1997 tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
1998 else
1999 tcc_output_binary(s1, f, sec_order);
2000 fclose(f);
2002 return 0;
2005 /* Sort section headers by assigned sh_addr, remove sections
2006 that we aren't going to output. */
2007 static void tidy_section_headers(TCCState *s1, int *sec_order)
2009 int i, nnew, l, *backmap;
2010 Section **snew, *s;
2011 ElfW(Sym) *sym;
2013 snew = tcc_malloc(s1->nb_sections * sizeof(snew[0]));
2014 backmap = tcc_malloc(s1->nb_sections * sizeof(backmap[0]));
2015 for (i = 0, nnew = 0, l = s1->nb_sections; i < s1->nb_sections; i++) {
2016 s = s1->sections[sec_order[i]];
2017 if (!i || s->sh_name) {
2018 backmap[sec_order[i]] = nnew;
2019 snew[nnew] = s;
2020 ++nnew;
2021 } else {
2022 backmap[sec_order[i]] = 0;
2023 snew[--l] = s;
2026 for (i = 0; i < nnew; i++) {
2027 s = snew[i];
2028 if (s) {
2029 s->sh_num = i;
2030 if (s->sh_type == SHT_RELX)
2031 s->sh_info = backmap[s->sh_info];
2035 for_each_elem(symtab_section, 1, sym, ElfW(Sym))
2036 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE)
2037 sym->st_shndx = backmap[sym->st_shndx];
2038 if( !s1->static_link ) {
2039 for_each_elem(s1->dynsym, 1, sym, ElfW(Sym))
2040 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE)
2041 sym->st_shndx = backmap[sym->st_shndx];
2043 for (i = 0; i < s1->nb_sections; i++)
2044 sec_order[i] = i;
2045 tcc_free(s1->sections);
2046 s1->sections = snew;
2047 s1->nb_sections = nnew;
2048 tcc_free(backmap);
2051 /* Output an elf, coff or binary file */
2052 /* XXX: suppress unneeded sections */
2053 static int elf_output_file(TCCState *s1, const char *filename)
2055 int i, ret, phnum, shnum, file_type, file_offset, *sec_order;
2056 struct dyn_inf dyninf = {0};
2057 ElfW(Phdr) *phdr;
2058 ElfW(Sym) *sym;
2059 Section *strsec, *interp, *dynamic, *dynstr;
2060 int textrel;
2062 file_type = s1->output_type;
2063 s1->nb_errors = 0;
2064 ret = -1;
2065 phdr = NULL;
2066 sec_order = NULL;
2067 interp = dynamic = dynstr = NULL; /* avoid warning */
2068 textrel = 0;
2070 if (file_type != TCC_OUTPUT_OBJ) {
2071 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2072 tcc_add_runtime(s1);
2073 resolve_common_syms(s1);
2075 if (!s1->static_link) {
2076 if (file_type == TCC_OUTPUT_EXE) {
2077 char *ptr;
2078 /* allow override the dynamic loader */
2079 const char *elfint = getenv("LD_SO");
2080 if (elfint == NULL)
2081 elfint = DEFAULT_ELFINTERP(s1);
2082 /* add interpreter section only if executable */
2083 interp = new_section(s1, ".interp", SHT_PROGBITS, SHF_ALLOC);
2084 interp->sh_addralign = 1;
2085 ptr = section_ptr_add(interp, 1 + strlen(elfint));
2086 strcpy(ptr, elfint);
2089 /* add dynamic symbol table */
2090 s1->dynsym = new_symtab(s1, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
2091 ".dynstr",
2092 ".hash", SHF_ALLOC);
2093 dynstr = s1->dynsym->link;
2095 /* add dynamic section */
2096 dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC,
2097 SHF_ALLOC | SHF_WRITE);
2098 dynamic->link = dynstr;
2099 dynamic->sh_entsize = sizeof(ElfW(Dyn));
2101 build_got(s1);
2103 if (file_type == TCC_OUTPUT_EXE) {
2104 bind_exe_dynsyms(s1);
2105 if (s1->nb_errors)
2106 goto the_end;
2107 bind_libs_dynsyms(s1);
2108 } else {
2109 /* shared library case: simply export all global symbols */
2110 export_global_syms(s1);
2113 build_got_entries(s1);
2116 /* we add a section for symbols */
2117 strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0);
2118 put_elf_str(strsec, "");
2120 /* Allocate strings for section names */
2121 textrel = alloc_sec_names(s1, file_type, strsec);
2123 if (dynamic) {
2124 /* add a list of needed dlls */
2125 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2126 DLLReference *dllref = s1->loaded_dlls[i];
2127 if (dllref->level == 0)
2128 put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name));
2131 if (s1->rpath)
2132 put_dt(dynamic, s1->enable_new_dtags ? DT_RUNPATH : DT_RPATH,
2133 put_elf_str(dynstr, s1->rpath));
2135 if (file_type == TCC_OUTPUT_DLL) {
2136 if (s1->soname)
2137 put_dt(dynamic, DT_SONAME, put_elf_str(dynstr, s1->soname));
2138 /* XXX: currently, since we do not handle PIC code, we
2139 must relocate the readonly segments */
2140 if (textrel)
2141 put_dt(dynamic, DT_TEXTREL, 0);
2144 if (s1->symbolic)
2145 put_dt(dynamic, DT_SYMBOLIC, 0);
2147 dyninf.dynamic = dynamic;
2148 dyninf.dynstr = dynstr;
2149 /* remember offset and reserve space for 2nd call below */
2150 dyninf.data_offset = dynamic->data_offset;
2151 fill_dynamic(s1, &dyninf);
2152 dynamic->sh_size = dynamic->data_offset;
2153 dynstr->sh_size = dynstr->data_offset;
2156 /* compute number of program headers */
2157 if (file_type == TCC_OUTPUT_OBJ)
2158 phnum = 0;
2159 else if (file_type == TCC_OUTPUT_DLL)
2160 phnum = 3;
2161 else if (s1->static_link)
2162 phnum = 2;
2163 else
2164 phnum = 5;
2166 /* allocate program segment headers */
2167 phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
2169 /* compute number of sections */
2170 shnum = s1->nb_sections;
2172 /* this array is used to reorder sections in the output file */
2173 sec_order = tcc_malloc(sizeof(int) * shnum);
2174 sec_order[0] = 0;
2176 /* compute section to program header mapping */
2177 file_offset = layout_sections(s1, phdr, phnum, interp, strsec, &dyninf,
2178 sec_order);
2180 /* Fill remaining program header and finalize relocation related to dynamic
2181 linking. */
2182 if (file_type != TCC_OUTPUT_OBJ) {
2183 fill_unloadable_phdr(phdr, phnum, interp, dynamic);
2184 if (dynamic) {
2185 dynamic->data_offset = dyninf.data_offset;
2186 fill_dynamic(s1, &dyninf);
2188 /* put in GOT the dynamic section address and relocate PLT */
2189 write32le(s1->got->data, dynamic->sh_addr);
2190 if (file_type == TCC_OUTPUT_EXE
2191 || (RELOCATE_DLLPLT && file_type == TCC_OUTPUT_DLL))
2192 relocate_plt(s1);
2194 /* relocate symbols in .dynsym now that final addresses are known */
2195 for_each_elem(s1->dynsym, 1, sym, ElfW(Sym)) {
2196 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE) {
2197 /* do symbol relocation */
2198 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
2203 /* if building executable or DLL, then relocate each section
2204 except the GOT which is already relocated */
2205 ret = final_sections_reloc(s1);
2206 if (ret)
2207 goto the_end;
2208 tidy_section_headers(s1, sec_order);
2210 /* Perform relocation to GOT or PLT entries */
2211 if (file_type == TCC_OUTPUT_EXE && s1->static_link)
2212 fill_got(s1);
2213 else if (s1->got)
2214 fill_local_got_entries(s1);
2217 /* Create the ELF file with name 'filename' */
2218 ret = tcc_write_elf_file(s1, filename, phnum, phdr, file_offset, sec_order);
2219 s1->nb_sections = shnum;
2220 the_end:
2221 tcc_free(sec_order);
2222 tcc_free(phdr);
2223 return ret;
2226 LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename)
2228 int ret;
2229 #ifdef TCC_TARGET_PE
2230 if (s->output_type != TCC_OUTPUT_OBJ) {
2231 ret = pe_output_file(s, filename);
2232 } else
2233 #endif
2234 ret = elf_output_file(s, filename);
2235 return ret;
2238 static void *load_data(int fd, unsigned long file_offset, unsigned long size)
2240 void *data;
2242 data = tcc_malloc(size);
2243 lseek(fd, file_offset, SEEK_SET);
2244 read(fd, data, size);
2245 return data;
2248 typedef struct SectionMergeInfo {
2249 Section *s; /* corresponding existing section */
2250 unsigned long offset; /* offset of the new section in the existing section */
2251 uint8_t new_section; /* true if section 's' was added */
2252 uint8_t link_once; /* true if link once section */
2253 } SectionMergeInfo;
2255 ST_FUNC int tcc_object_type(int fd, ElfW(Ehdr) *h)
2257 int size = read(fd, h, sizeof *h);
2258 if (size == sizeof *h && 0 == memcmp(h, ELFMAG, 4)) {
2259 if (h->e_type == ET_REL)
2260 return AFF_BINTYPE_REL;
2261 if (h->e_type == ET_DYN)
2262 return AFF_BINTYPE_DYN;
2263 } else if (size >= 8) {
2264 if (0 == memcmp(h, ARMAG, 8))
2265 return AFF_BINTYPE_AR;
2266 #ifdef TCC_TARGET_COFF
2267 if (((struct filehdr*)h)->f_magic == COFF_C67_MAGIC)
2268 return AFF_BINTYPE_C67;
2269 #endif
2271 return 0;
2274 /* load an object file and merge it with current files */
2275 /* XXX: handle correctly stab (debug) info */
2276 ST_FUNC int tcc_load_object_file(TCCState *s1,
2277 int fd, unsigned long file_offset)
2279 ElfW(Ehdr) ehdr;
2280 ElfW(Shdr) *shdr, *sh;
2281 int size, i, j, offset, offseti, nb_syms, sym_index, ret, seencompressed;
2282 unsigned char *strsec, *strtab;
2283 int *old_to_new_syms;
2284 char *sh_name, *name;
2285 SectionMergeInfo *sm_table, *sm;
2286 ElfW(Sym) *sym, *symtab;
2287 ElfW_Rel *rel;
2288 Section *s;
2290 int stab_index;
2291 int stabstr_index;
2293 stab_index = stabstr_index = 0;
2295 lseek(fd, file_offset, SEEK_SET);
2296 if (tcc_object_type(fd, &ehdr) != AFF_BINTYPE_REL)
2297 goto fail1;
2298 /* test CPU specific stuff */
2299 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2300 ehdr.e_machine != EM_TCC_TARGET) {
2301 fail1:
2302 tcc_error_noabort("invalid object file");
2303 return -1;
2305 /* read sections */
2306 shdr = load_data(fd, file_offset + ehdr.e_shoff,
2307 sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2308 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
2310 /* load section names */
2311 sh = &shdr[ehdr.e_shstrndx];
2312 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2314 /* load symtab and strtab */
2315 old_to_new_syms = NULL;
2316 symtab = NULL;
2317 strtab = NULL;
2318 nb_syms = 0;
2319 seencompressed = 0;
2320 for(i = 1; i < ehdr.e_shnum; i++) {
2321 sh = &shdr[i];
2322 if (sh->sh_type == SHT_SYMTAB) {
2323 if (symtab) {
2324 tcc_error_noabort("object must contain only one symtab");
2325 fail:
2326 ret = -1;
2327 goto the_end;
2329 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2330 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2331 sm_table[i].s = symtab_section;
2333 /* now load strtab */
2334 sh = &shdr[sh->sh_link];
2335 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2337 if (sh->sh_flags & SHF_COMPRESSED)
2338 seencompressed = 1;
2341 /* now examine each section and try to merge its content with the
2342 ones in memory */
2343 for(i = 1; i < ehdr.e_shnum; i++) {
2344 /* no need to examine section name strtab */
2345 if (i == ehdr.e_shstrndx)
2346 continue;
2347 sh = &shdr[i];
2348 sh_name = (char *) strsec + sh->sh_name;
2349 /* ignore sections types we do not handle */
2350 if (sh->sh_type != SHT_PROGBITS &&
2351 sh->sh_type != SHT_RELX &&
2352 #ifdef TCC_ARM_EABI
2353 sh->sh_type != SHT_ARM_EXIDX &&
2354 #endif
2355 sh->sh_type != SHT_NOBITS &&
2356 sh->sh_type != SHT_PREINIT_ARRAY &&
2357 sh->sh_type != SHT_INIT_ARRAY &&
2358 sh->sh_type != SHT_FINI_ARRAY &&
2359 strcmp(sh_name, ".stabstr")
2361 continue;
2362 if (seencompressed
2363 && (!strncmp(sh_name, ".debug_", sizeof(".debug_")-1)
2364 || (sh->sh_type == SHT_RELX
2365 && !strncmp((char*)strsec + shdr[sh->sh_info].sh_name,
2366 ".debug_", sizeof(".debug_")-1))))
2367 continue;
2368 if (sh->sh_addralign < 1)
2369 sh->sh_addralign = 1;
2370 /* find corresponding section, if any */
2371 for(j = 1; j < s1->nb_sections;j++) {
2372 s = s1->sections[j];
2373 if (!strcmp(s->name, sh_name)) {
2374 if (!strncmp(sh_name, ".gnu.linkonce",
2375 sizeof(".gnu.linkonce") - 1)) {
2376 /* if a 'linkonce' section is already present, we
2377 do not add it again. It is a little tricky as
2378 symbols can still be defined in
2379 it. */
2380 sm_table[i].link_once = 1;
2381 goto next;
2382 } else {
2383 goto found;
2387 /* not found: create new section */
2388 s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags & ~SHF_GROUP);
2389 /* take as much info as possible from the section. sh_link and
2390 sh_info will be updated later */
2391 s->sh_addralign = sh->sh_addralign;
2392 s->sh_entsize = sh->sh_entsize;
2393 sm_table[i].new_section = 1;
2394 found:
2395 if (sh->sh_type != s->sh_type) {
2396 tcc_error_noabort("invalid section type");
2397 goto fail;
2400 /* align start of section */
2401 offset = s->data_offset;
2403 if (0 == strcmp(sh_name, ".stab")) {
2404 stab_index = i;
2405 goto no_align;
2407 if (0 == strcmp(sh_name, ".stabstr")) {
2408 stabstr_index = i;
2409 goto no_align;
2412 size = sh->sh_addralign - 1;
2413 offset = (offset + size) & ~size;
2414 if (sh->sh_addralign > s->sh_addralign)
2415 s->sh_addralign = sh->sh_addralign;
2416 s->data_offset = offset;
2417 no_align:
2418 sm_table[i].offset = offset;
2419 sm_table[i].s = s;
2420 /* concatenate sections */
2421 size = sh->sh_size;
2422 if (sh->sh_type != SHT_NOBITS) {
2423 unsigned char *ptr;
2424 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
2425 ptr = section_ptr_add(s, size);
2426 read(fd, ptr, size);
2427 } else {
2428 s->data_offset += size;
2430 next: ;
2433 /* gr relocate stab strings */
2434 if (stab_index && stabstr_index) {
2435 Stab_Sym *a, *b;
2436 unsigned o;
2437 s = sm_table[stab_index].s;
2438 a = (Stab_Sym *)(s->data + sm_table[stab_index].offset);
2439 b = (Stab_Sym *)(s->data + s->data_offset);
2440 o = sm_table[stabstr_index].offset;
2441 while (a < b)
2442 a->n_strx += o, a++;
2445 /* second short pass to update sh_link and sh_info fields of new
2446 sections */
2447 for(i = 1; i < ehdr.e_shnum; i++) {
2448 s = sm_table[i].s;
2449 if (!s || !sm_table[i].new_section)
2450 continue;
2451 sh = &shdr[i];
2452 if (sh->sh_link > 0)
2453 s->link = sm_table[sh->sh_link].s;
2454 if (sh->sh_type == SHT_RELX) {
2455 s->sh_info = sm_table[sh->sh_info].s->sh_num;
2456 /* update backward link */
2457 s1->sections[s->sh_info]->reloc = s;
2460 sm = sm_table;
2462 /* resolve symbols */
2463 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
2465 sym = symtab + 1;
2466 for(i = 1; i < nb_syms; i++, sym++) {
2467 if (sym->st_shndx != SHN_UNDEF &&
2468 sym->st_shndx < SHN_LORESERVE) {
2469 sm = &sm_table[sym->st_shndx];
2470 if (sm->link_once) {
2471 /* if a symbol is in a link once section, we use the
2472 already defined symbol. It is very important to get
2473 correct relocations */
2474 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
2475 name = (char *) strtab + sym->st_name;
2476 sym_index = find_elf_sym(symtab_section, name);
2477 if (sym_index)
2478 old_to_new_syms[i] = sym_index;
2480 continue;
2482 /* if no corresponding section added, no need to add symbol */
2483 if (!sm->s)
2484 continue;
2485 /* convert section number */
2486 sym->st_shndx = sm->s->sh_num;
2487 /* offset value */
2488 sym->st_value += sm->offset;
2490 /* add symbol */
2491 name = (char *) strtab + sym->st_name;
2492 sym_index = set_elf_sym(symtab_section, sym->st_value, sym->st_size,
2493 sym->st_info, sym->st_other,
2494 sym->st_shndx, name);
2495 old_to_new_syms[i] = sym_index;
2498 /* third pass to patch relocation entries */
2499 for(i = 1; i < ehdr.e_shnum; i++) {
2500 s = sm_table[i].s;
2501 if (!s)
2502 continue;
2503 sh = &shdr[i];
2504 offset = sm_table[i].offset;
2505 switch(s->sh_type) {
2506 case SHT_RELX:
2507 /* take relocation offset information */
2508 offseti = sm_table[sh->sh_info].offset;
2509 for_each_elem(s, (offset / sizeof(*rel)), rel, ElfW_Rel) {
2510 int type;
2511 unsigned sym_index;
2512 /* convert symbol index */
2513 type = ELFW(R_TYPE)(rel->r_info);
2514 sym_index = ELFW(R_SYM)(rel->r_info);
2515 /* NOTE: only one symtab assumed */
2516 if (sym_index >= nb_syms)
2517 goto invalid_reloc;
2518 sym_index = old_to_new_syms[sym_index];
2519 /* ignore link_once in rel section. */
2520 if (!sym_index && !sm->link_once
2521 #ifdef TCC_TARGET_ARM
2522 && type != R_ARM_V4BX
2523 #endif
2525 invalid_reloc:
2526 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2527 i, strsec + sh->sh_name, rel->r_offset);
2528 goto fail;
2530 rel->r_info = ELFW(R_INFO)(sym_index, type);
2531 /* offset the relocation offset */
2532 rel->r_offset += offseti;
2533 #ifdef TCC_TARGET_ARM
2534 /* Jumps and branches from a Thumb code to a PLT entry need
2535 special handling since PLT entries are ARM code.
2536 Unconditional bl instructions referencing PLT entries are
2537 handled by converting these instructions into blx
2538 instructions. Other case of instructions referencing a PLT
2539 entry require to add a Thumb stub before the PLT entry to
2540 switch to ARM mode. We set bit plt_thumb_stub of the
2541 attribute of a symbol to indicate such a case. */
2542 if (type == R_ARM_THM_JUMP24)
2543 get_sym_attr(s1, sym_index, 1)->plt_thumb_stub = 1;
2544 #endif
2546 break;
2547 default:
2548 break;
2552 ret = 0;
2553 the_end:
2554 tcc_free(symtab);
2555 tcc_free(strtab);
2556 tcc_free(old_to_new_syms);
2557 tcc_free(sm_table);
2558 tcc_free(strsec);
2559 tcc_free(shdr);
2560 return ret;
2563 typedef struct ArchiveHeader {
2564 char ar_name[16]; /* name of this member */
2565 char ar_date[12]; /* file mtime */
2566 char ar_uid[6]; /* owner uid; printed as decimal */
2567 char ar_gid[6]; /* owner gid; printed as decimal */
2568 char ar_mode[8]; /* file mode, printed as octal */
2569 char ar_size[10]; /* file size, printed as decimal */
2570 char ar_fmag[2]; /* should contain ARFMAG */
2571 } ArchiveHeader;
2573 static int get_be32(const uint8_t *b)
2575 return b[3] | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
2578 static long get_be64(const uint8_t *b)
2580 long long ret = get_be32(b);
2581 ret = (ret << 32) | (unsigned)get_be32(b+4);
2582 return (long)ret;
2585 /* load only the objects which resolve undefined symbols */
2586 static int tcc_load_alacarte(TCCState *s1, int fd, int size, int entrysize)
2588 long i, bound, nsyms, sym_index, off, ret;
2589 uint8_t *data;
2590 const char *ar_names, *p;
2591 const uint8_t *ar_index;
2592 ElfW(Sym) *sym;
2594 data = tcc_malloc(size);
2595 if (read(fd, data, size) != size)
2596 goto fail;
2597 nsyms = entrysize == 4 ? get_be32(data) : get_be64(data);
2598 ar_index = data + entrysize;
2599 ar_names = (char *) ar_index + nsyms * entrysize;
2601 do {
2602 bound = 0;
2603 for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2604 sym_index = find_elf_sym(symtab_section, p);
2605 if(sym_index) {
2606 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
2607 if(sym->st_shndx == SHN_UNDEF) {
2608 off = (entrysize == 4
2609 ? get_be32(ar_index + i * 4)
2610 : get_be64(ar_index + i * 8))
2611 + sizeof(ArchiveHeader);
2612 ++bound;
2613 if(tcc_load_object_file(s1, fd, off) < 0) {
2614 fail:
2615 ret = -1;
2616 goto the_end;
2621 } while(bound);
2622 ret = 0;
2623 the_end:
2624 tcc_free(data);
2625 return ret;
2628 /* load a '.a' file */
2629 ST_FUNC int tcc_load_archive(TCCState *s1, int fd)
2631 ArchiveHeader hdr;
2632 char ar_size[11];
2633 char ar_name[17];
2634 char magic[8];
2635 int size, len, i;
2636 unsigned long file_offset;
2638 /* skip magic which was already checked */
2639 read(fd, magic, sizeof(magic));
2641 for(;;) {
2642 len = read(fd, &hdr, sizeof(hdr));
2643 if (len == 0)
2644 break;
2645 if (len != sizeof(hdr)) {
2646 tcc_error_noabort("invalid archive");
2647 return -1;
2649 memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
2650 ar_size[sizeof(hdr.ar_size)] = '\0';
2651 size = strtol(ar_size, NULL, 0);
2652 memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
2653 for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
2654 if (ar_name[i] != ' ')
2655 break;
2657 ar_name[i + 1] = '\0';
2658 file_offset = lseek(fd, 0, SEEK_CUR);
2659 /* align to even */
2660 size = (size + 1) & ~1;
2661 if (!strcmp(ar_name, "/")) {
2662 /* coff symbol table : we handle it */
2663 if(s1->alacarte_link)
2664 return tcc_load_alacarte(s1, fd, size, 4);
2665 } else if (!strcmp(ar_name, "/SYM64/")) {
2666 if(s1->alacarte_link)
2667 return tcc_load_alacarte(s1, fd, size, 8);
2668 } else {
2669 ElfW(Ehdr) ehdr;
2670 if (tcc_object_type(fd, &ehdr) == AFF_BINTYPE_REL) {
2671 if (tcc_load_object_file(s1, fd, file_offset) < 0)
2672 return -1;
2675 lseek(fd, file_offset + size, SEEK_SET);
2677 return 0;
2680 #ifndef TCC_TARGET_PE
2681 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2682 is referenced by the user (so it should be added as DT_NEEDED in
2683 the generated ELF file) */
2684 ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
2686 ElfW(Ehdr) ehdr;
2687 ElfW(Shdr) *shdr, *sh, *sh1;
2688 int i, j, nb_syms, nb_dts, sym_bind, ret;
2689 ElfW(Sym) *sym, *dynsym;
2690 ElfW(Dyn) *dt, *dynamic;
2691 unsigned char *dynstr;
2692 const char *name, *soname;
2693 DLLReference *dllref;
2695 read(fd, &ehdr, sizeof(ehdr));
2697 /* test CPU specific stuff */
2698 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2699 ehdr.e_machine != EM_TCC_TARGET) {
2700 tcc_error_noabort("bad architecture");
2701 return -1;
2704 /* read sections */
2705 shdr = load_data(fd, ehdr.e_shoff, sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2707 /* load dynamic section and dynamic symbols */
2708 nb_syms = 0;
2709 nb_dts = 0;
2710 dynamic = NULL;
2711 dynsym = NULL; /* avoid warning */
2712 dynstr = NULL; /* avoid warning */
2713 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
2714 switch(sh->sh_type) {
2715 case SHT_DYNAMIC:
2716 nb_dts = sh->sh_size / sizeof(ElfW(Dyn));
2717 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
2718 break;
2719 case SHT_DYNSYM:
2720 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2721 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
2722 sh1 = &shdr[sh->sh_link];
2723 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
2724 break;
2725 default:
2726 break;
2730 /* compute the real library name */
2731 soname = tcc_basename(filename);
2733 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2734 if (dt->d_tag == DT_SONAME) {
2735 soname = (char *) dynstr + dt->d_un.d_val;
2739 /* if the dll is already loaded, do not load it */
2740 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2741 dllref = s1->loaded_dlls[i];
2742 if (!strcmp(soname, dllref->name)) {
2743 /* but update level if needed */
2744 if (level < dllref->level)
2745 dllref->level = level;
2746 ret = 0;
2747 goto the_end;
2751 /* add the dll and its level */
2752 dllref = tcc_mallocz(sizeof(DLLReference) + strlen(soname));
2753 dllref->level = level;
2754 strcpy(dllref->name, soname);
2755 dynarray_add(&s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
2757 /* add dynamic symbols in dynsym_section */
2758 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
2759 sym_bind = ELFW(ST_BIND)(sym->st_info);
2760 if (sym_bind == STB_LOCAL)
2761 continue;
2762 name = (char *) dynstr + sym->st_name;
2763 set_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
2764 sym->st_info, sym->st_other, sym->st_shndx, name);
2767 /* load all referenced DLLs */
2768 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2769 switch(dt->d_tag) {
2770 case DT_NEEDED:
2771 name = (char *) dynstr + dt->d_un.d_val;
2772 for(j = 0; j < s1->nb_loaded_dlls; j++) {
2773 dllref = s1->loaded_dlls[j];
2774 if (!strcmp(name, dllref->name))
2775 goto already_loaded;
2777 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
2778 tcc_error_noabort("referenced dll '%s' not found", name);
2779 ret = -1;
2780 goto the_end;
2782 already_loaded:
2783 break;
2786 ret = 0;
2787 the_end:
2788 tcc_free(dynstr);
2789 tcc_free(dynsym);
2790 tcc_free(dynamic);
2791 tcc_free(shdr);
2792 return ret;
2795 #define LD_TOK_NAME 256
2796 #define LD_TOK_EOF (-1)
2798 /* return next ld script token */
2799 static int ld_next(TCCState *s1, char *name, int name_size)
2801 int c;
2802 char *q;
2804 redo:
2805 switch(ch) {
2806 case ' ':
2807 case '\t':
2808 case '\f':
2809 case '\v':
2810 case '\r':
2811 case '\n':
2812 inp();
2813 goto redo;
2814 case '/':
2815 minp();
2816 if (ch == '*') {
2817 file->buf_ptr = parse_comment(file->buf_ptr);
2818 ch = file->buf_ptr[0];
2819 goto redo;
2820 } else {
2821 q = name;
2822 *q++ = '/';
2823 goto parse_name;
2825 break;
2826 case '\\':
2827 ch = handle_eob();
2828 if (ch != '\\')
2829 goto redo;
2830 /* fall through */
2831 /* case 'a' ... 'z': */
2832 case 'a':
2833 case 'b':
2834 case 'c':
2835 case 'd':
2836 case 'e':
2837 case 'f':
2838 case 'g':
2839 case 'h':
2840 case 'i':
2841 case 'j':
2842 case 'k':
2843 case 'l':
2844 case 'm':
2845 case 'n':
2846 case 'o':
2847 case 'p':
2848 case 'q':
2849 case 'r':
2850 case 's':
2851 case 't':
2852 case 'u':
2853 case 'v':
2854 case 'w':
2855 case 'x':
2856 case 'y':
2857 case 'z':
2858 /* case 'A' ... 'z': */
2859 case 'A':
2860 case 'B':
2861 case 'C':
2862 case 'D':
2863 case 'E':
2864 case 'F':
2865 case 'G':
2866 case 'H':
2867 case 'I':
2868 case 'J':
2869 case 'K':
2870 case 'L':
2871 case 'M':
2872 case 'N':
2873 case 'O':
2874 case 'P':
2875 case 'Q':
2876 case 'R':
2877 case 'S':
2878 case 'T':
2879 case 'U':
2880 case 'V':
2881 case 'W':
2882 case 'X':
2883 case 'Y':
2884 case 'Z':
2885 case '_':
2886 case '.':
2887 case '$':
2888 case '~':
2889 q = name;
2890 parse_name:
2891 for(;;) {
2892 if (!((ch >= 'a' && ch <= 'z') ||
2893 (ch >= 'A' && ch <= 'Z') ||
2894 (ch >= '0' && ch <= '9') ||
2895 strchr("/.-_+=$:\\,~", ch)))
2896 break;
2897 if ((q - name) < name_size - 1) {
2898 *q++ = ch;
2900 minp();
2902 *q = '\0';
2903 c = LD_TOK_NAME;
2904 break;
2905 case CH_EOF:
2906 c = LD_TOK_EOF;
2907 break;
2908 default:
2909 c = ch;
2910 inp();
2911 break;
2913 return c;
2916 static int ld_add_file(TCCState *s1, const char filename[])
2918 if (filename[0] == '/') {
2919 if (CONFIG_SYSROOT[0] == '\0'
2920 && tcc_add_file_internal(s1, filename, AFF_TYPE_BIN) == 0)
2921 return 0;
2922 filename = tcc_basename(filename);
2924 return tcc_add_dll(s1, filename, 0);
2927 static inline int new_undef_syms(void)
2929 int ret = 0;
2930 ret = new_undef_sym;
2931 new_undef_sym = 0;
2932 return ret;
2935 static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
2937 char filename[1024], libname[1024];
2938 int t, group, nblibs = 0, ret = 0;
2939 char **libs = NULL;
2941 group = !strcmp(cmd, "GROUP");
2942 if (!as_needed)
2943 new_undef_syms();
2944 t = ld_next(s1, filename, sizeof(filename));
2945 if (t != '(')
2946 expect("(");
2947 t = ld_next(s1, filename, sizeof(filename));
2948 for(;;) {
2949 libname[0] = '\0';
2950 if (t == LD_TOK_EOF) {
2951 tcc_error_noabort("unexpected end of file");
2952 ret = -1;
2953 goto lib_parse_error;
2954 } else if (t == ')') {
2955 break;
2956 } else if (t == '-') {
2957 t = ld_next(s1, filename, sizeof(filename));
2958 if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
2959 tcc_error_noabort("library name expected");
2960 ret = -1;
2961 goto lib_parse_error;
2963 pstrcpy(libname, sizeof libname, &filename[1]);
2964 if (s1->static_link) {
2965 snprintf(filename, sizeof filename, "lib%s.a", libname);
2966 } else {
2967 snprintf(filename, sizeof filename, "lib%s.so", libname);
2969 } else if (t != LD_TOK_NAME) {
2970 tcc_error_noabort("filename expected");
2971 ret = -1;
2972 goto lib_parse_error;
2974 if (!strcmp(filename, "AS_NEEDED")) {
2975 ret = ld_add_file_list(s1, cmd, 1);
2976 if (ret)
2977 goto lib_parse_error;
2978 } else {
2979 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2980 if (!as_needed) {
2981 ret = ld_add_file(s1, filename);
2982 if (ret)
2983 goto lib_parse_error;
2984 if (group) {
2985 /* Add the filename *and* the libname to avoid future conversions */
2986 dynarray_add(&libs, &nblibs, tcc_strdup(filename));
2987 if (libname[0] != '\0')
2988 dynarray_add(&libs, &nblibs, tcc_strdup(libname));
2992 t = ld_next(s1, filename, sizeof(filename));
2993 if (t == ',') {
2994 t = ld_next(s1, filename, sizeof(filename));
2997 if (group && !as_needed) {
2998 while (new_undef_syms()) {
2999 int i;
3001 for (i = 0; i < nblibs; i ++)
3002 ld_add_file(s1, libs[i]);
3005 lib_parse_error:
3006 dynarray_reset(&libs, &nblibs);
3007 return ret;
3010 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3011 files */
3012 ST_FUNC int tcc_load_ldscript(TCCState *s1)
3014 char cmd[64];
3015 char filename[1024];
3016 int t, ret;
3018 ch = handle_eob();
3019 for(;;) {
3020 t = ld_next(s1, cmd, sizeof(cmd));
3021 if (t == LD_TOK_EOF)
3022 return 0;
3023 else if (t != LD_TOK_NAME)
3024 return -1;
3025 if (!strcmp(cmd, "INPUT") ||
3026 !strcmp(cmd, "GROUP")) {
3027 ret = ld_add_file_list(s1, cmd, 0);
3028 if (ret)
3029 return ret;
3030 } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
3031 !strcmp(cmd, "TARGET")) {
3032 /* ignore some commands */
3033 t = ld_next(s1, cmd, sizeof(cmd));
3034 if (t != '(')
3035 expect("(");
3036 for(;;) {
3037 t = ld_next(s1, filename, sizeof(filename));
3038 if (t == LD_TOK_EOF) {
3039 tcc_error_noabort("unexpected end of file");
3040 return -1;
3041 } else if (t == ')') {
3042 break;
3045 } else {
3046 return -1;
3049 return 0;
3051 #endif /* !TCC_TARGET_PE */