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
23 /* Define this to get some debug output during relocation processing. */
26 /********************************************************/
27 /* global variables */
29 ST_DATA Section
*text_section
, *data_section
, *bss_section
; /* predefined sections */
30 ST_DATA Section
*cur_text_section
; /* current section where function code is generated */
32 ST_DATA Section
*last_text_section
; /* to handle .previous asm directive */
34 #ifdef CONFIG_TCC_BCHECK
35 /* bound check related sections */
36 ST_DATA Section
*bounds_section
; /* contains global data bound description */
37 ST_DATA Section
*lbounds_section
; /* contains local data bound description */
40 ST_DATA Section
*symtab_section
, *strtab_section
;
42 ST_DATA Section
*stab_section
, *stabstr_section
;
44 /* XXX: avoid static variable */
45 static int new_undef_sym
= 0; /* Is there a new undefined sym since last new_undef_sym() */
47 /* ------------------------------------------------------------------------- */
49 ST_FUNC
void tccelf_new(TCCState
*s
)
52 dynarray_add(&s
->sections
, &s
->nb_sections
, NULL
);
54 /* create standard sections */
55 text_section
= new_section(s
, ".text", SHT_PROGBITS
, SHF_ALLOC
| SHF_EXECINSTR
);
56 data_section
= new_section(s
, ".data", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
57 bss_section
= new_section(s
, ".bss", SHT_NOBITS
, SHF_ALLOC
| SHF_WRITE
);
59 /* symbols are always generated for linking stage */
60 symtab_section
= new_symtab(s
, ".symtab", SHT_SYMTAB
, 0,
62 ".hashtab", SHF_PRIVATE
);
63 strtab_section
= symtab_section
->link
;
64 s
->symtab
= symtab_section
;
66 /* private symbol table for dynamic symbols */
67 s
->dynsymtab_section
= new_symtab(s
, ".dynsymtab", SHT_SYMTAB
, SHF_PRIVATE
,
69 ".dynhashtab", SHF_PRIVATE
);
70 get_sym_attr(s
, 0, 1);
73 #ifdef CONFIG_TCC_BCHECK
74 ST_FUNC
void tccelf_bounds_new(TCCState
*s
)
76 /* create bounds sections */
77 bounds_section
= new_section(s
, ".bounds",
78 SHT_PROGBITS
, SHF_ALLOC
);
79 lbounds_section
= new_section(s
, ".lbounds",
80 SHT_PROGBITS
, SHF_ALLOC
);
84 ST_FUNC
void tccelf_stab_new(TCCState
*s
)
86 stab_section
= new_section(s
, ".stab", SHT_PROGBITS
, 0);
87 stab_section
->sh_entsize
= sizeof(Stab_Sym
);
88 stabstr_section
= new_section(s
, ".stabstr", SHT_STRTAB
, 0);
89 put_elf_str(stabstr_section
, "");
90 stab_section
->link
= stabstr_section
;
92 put_stabs("", 0, 0, 0, 0);
95 static void free_section(Section
*s
)
100 ST_FUNC
void tccelf_delete(TCCState
*s1
)
104 /* free all sections */
105 for(i
= 1; i
< s1
->nb_sections
; i
++)
106 free_section(s1
->sections
[i
]);
107 dynarray_reset(&s1
->sections
, &s1
->nb_sections
);
109 for(i
= 0; i
< s1
->nb_priv_sections
; i
++)
110 free_section(s1
->priv_sections
[i
]);
111 dynarray_reset(&s1
->priv_sections
, &s1
->nb_priv_sections
);
113 /* free any loaded DLLs */
115 for ( i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
116 DLLReference
*ref
= s1
->loaded_dlls
[i
];
119 FreeLibrary((HMODULE
)ref
->handle
);
121 dlclose(ref
->handle
);
125 /* free loaded dlls array */
126 dynarray_reset(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
);
127 tcc_free(s1
->sym_attrs
);
130 ST_FUNC Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
)
134 sec
= tcc_mallocz(sizeof(Section
) + strlen(name
));
135 strcpy(sec
->name
, name
);
136 sec
->sh_type
= sh_type
;
137 sec
->sh_flags
= sh_flags
;
145 sec
->sh_addralign
= 4;
148 sec
->sh_addralign
= 1;
151 sec
->sh_addralign
= PTR_SIZE
; /* gcc/pcc default aligment */
155 if (sh_flags
& SHF_PRIVATE
) {
156 dynarray_add(&s1
->priv_sections
, &s1
->nb_priv_sections
, sec
);
158 sec
->sh_num
= s1
->nb_sections
;
159 dynarray_add(&s1
->sections
, &s1
->nb_sections
, sec
);
165 ST_FUNC Section
*new_symtab(TCCState
*s1
,
166 const char *symtab_name
, int sh_type
, int sh_flags
,
167 const char *strtab_name
,
168 const char *hash_name
, int hash_sh_flags
)
170 Section
*symtab
, *strtab
, *hash
;
171 int *ptr
, nb_buckets
;
173 symtab
= new_section(s1
, symtab_name
, sh_type
, sh_flags
);
174 symtab
->sh_entsize
= sizeof(ElfW(Sym
));
175 strtab
= new_section(s1
, strtab_name
, SHT_STRTAB
, sh_flags
);
176 put_elf_str(strtab
, "");
177 symtab
->link
= strtab
;
178 put_elf_sym(symtab
, 0, 0, 0, 0, 0, NULL
);
182 hash
= new_section(s1
, hash_name
, SHT_HASH
, hash_sh_flags
);
183 hash
->sh_entsize
= sizeof(int);
187 ptr
= section_ptr_add(hash
, (2 + nb_buckets
+ 1) * sizeof(int));
190 memset(ptr
+ 2, 0, (nb_buckets
+ 1) * sizeof(int));
194 /* realloc section and set its content to zero */
195 ST_FUNC
void section_realloc(Section
*sec
, unsigned long new_size
)
200 size
= sec
->data_allocated
;
203 while (size
< new_size
)
205 data
= tcc_realloc(sec
->data
, size
);
206 memset(data
+ sec
->data_allocated
, 0, size
- sec
->data_allocated
);
208 sec
->data_allocated
= size
;
211 /* reserve at least 'size' bytes in section 'sec' from
213 ST_FUNC
void *section_ptr_add(Section
*sec
, addr_t size
)
215 size_t offset
, offset1
;
217 offset
= sec
->data_offset
;
218 offset1
= offset
+ size
;
219 if (offset1
> sec
->data_allocated
)
220 section_realloc(sec
, offset1
);
221 sec
->data_offset
= offset1
;
222 return sec
->data
+ offset
;
225 /* reserve at least 'size' bytes from section start */
226 ST_FUNC
void section_reserve(Section
*sec
, unsigned long size
)
228 if (size
> sec
->data_allocated
)
229 section_realloc(sec
, size
);
230 if (size
> sec
->data_offset
)
231 sec
->data_offset
= size
;
234 /* return a reference to a section, and create it if it does not
236 ST_FUNC Section
*find_section(TCCState
*s1
, const char *name
)
240 for(i
= 1; i
< s1
->nb_sections
; i
++) {
241 sec
= s1
->sections
[i
];
242 if (!strcmp(name
, sec
->name
))
245 /* sections are created as PROGBITS */
246 return new_section(s1
, name
, SHT_PROGBITS
, SHF_ALLOC
);
249 /* ------------------------------------------------------------------------- */
251 ST_FUNC
int put_elf_str(Section
*s
, const char *sym
)
256 len
= strlen(sym
) + 1;
257 offset
= s
->data_offset
;
258 ptr
= section_ptr_add(s
, len
);
259 memcpy(ptr
, sym
, len
);
263 /* elf symbol hashing function */
264 static unsigned long elf_hash(const unsigned char *name
)
266 unsigned long h
= 0, g
;
269 h
= (h
<< 4) + *name
++;
278 /* rebuild hash table of section s */
279 /* NOTE: we do factorize the hash table code to go faster */
280 static void rebuild_hash(Section
*s
, unsigned int nb_buckets
)
283 int *ptr
, *hash
, nb_syms
, sym_index
, h
;
284 unsigned char *strtab
;
286 strtab
= s
->link
->data
;
287 nb_syms
= s
->data_offset
/ sizeof(ElfW(Sym
));
289 s
->hash
->data_offset
= 0;
290 ptr
= section_ptr_add(s
->hash
, (2 + nb_buckets
+ nb_syms
) * sizeof(int));
295 memset(hash
, 0, (nb_buckets
+ 1) * sizeof(int));
296 ptr
+= nb_buckets
+ 1;
298 sym
= (ElfW(Sym
) *)s
->data
+ 1;
299 for(sym_index
= 1; sym_index
< nb_syms
; sym_index
++) {
300 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
301 h
= elf_hash(strtab
+ sym
->st_name
) % nb_buckets
;
312 /* return the symbol number */
313 ST_FUNC
int put_elf_sym(Section
*s
, addr_t value
, unsigned long size
,
314 int info
, int other
, int shndx
, const char *name
)
316 int name_offset
, sym_index
;
321 sym
= section_ptr_add(s
, sizeof(ElfW(Sym
)));
323 name_offset
= put_elf_str(s
->link
, name
);
326 /* XXX: endianness */
327 sym
->st_name
= name_offset
;
328 sym
->st_value
= value
;
331 sym
->st_other
= other
;
332 sym
->st_shndx
= shndx
;
333 sym_index
= sym
- (ElfW(Sym
) *)s
->data
;
337 ptr
= section_ptr_add(hs
, sizeof(int));
338 base
= (int *)hs
->data
;
339 /* only add global or weak symbols */
340 if (ELFW(ST_BIND
)(info
) != STB_LOCAL
) {
341 /* add another hashing entry */
343 h
= elf_hash((unsigned char *) name
) % nbuckets
;
345 base
[2 + h
] = sym_index
;
347 /* we resize the hash table */
348 hs
->nb_hashed_syms
++;
349 if (hs
->nb_hashed_syms
> 2 * nbuckets
) {
350 rebuild_hash(s
, 2 * nbuckets
);
360 /* find global ELF symbol 'name' and return its index. Return 0 if not
362 ST_FUNC
int find_elf_sym(Section
*s
, const char *name
)
366 int nbuckets
, sym_index
, h
;
372 nbuckets
= ((int *)hs
->data
)[0];
373 h
= elf_hash((unsigned char *) name
) % nbuckets
;
374 sym_index
= ((int *)hs
->data
)[2 + h
];
375 while (sym_index
!= 0) {
376 sym
= &((ElfW(Sym
) *)s
->data
)[sym_index
];
377 name1
= (char *) s
->link
->data
+ sym
->st_name
;
378 if (!strcmp(name
, name1
))
380 sym_index
= ((int *)hs
->data
)[2 + nbuckets
+ sym_index
];
385 /* return elf symbol value, signal error if 'err' is nonzero */
386 ST_FUNC addr_t
get_elf_sym_addr(TCCState
*s
, const char *name
, int err
)
391 sym_index
= find_elf_sym(s
->symtab
, name
);
392 sym
= &((ElfW(Sym
) *)s
->symtab
->data
)[sym_index
];
393 if (!sym_index
|| sym
->st_shndx
== SHN_UNDEF
) {
395 tcc_error("%s not defined", name
);
398 return sym
->st_value
;
401 /* return elf symbol value */
402 LIBTCCAPI
void *tcc_get_symbol(TCCState
*s
, const char *name
)
404 return (void*)(uintptr_t)get_elf_sym_addr(s
, name
, 0);
407 #if defined TCC_IS_NATIVE || defined TCC_TARGET_PE
408 /* return elf symbol value or error */
409 ST_FUNC
void* tcc_get_symbol_err(TCCState
*s
, const char *name
)
411 return (void*)(uintptr_t)get_elf_sym_addr(s
, name
, 1);
415 /* add an elf symbol : check if it is already defined and patch
416 it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
417 ST_FUNC
int set_elf_sym(Section
*s
, addr_t value
, unsigned long size
,
418 int info
, int other
, int shndx
, const char *name
)
421 int sym_bind
, sym_index
, sym_type
, esym_bind
;
422 unsigned char sym_vis
, esym_vis
, new_vis
;
424 sym_bind
= ELFW(ST_BIND
)(info
);
425 sym_type
= ELFW(ST_TYPE
)(info
);
426 sym_vis
= ELFW(ST_VISIBILITY
)(other
);
428 sym_index
= find_elf_sym(s
, name
);
429 esym
= &((ElfW(Sym
) *)s
->data
)[sym_index
];
430 if (sym_index
&& esym
->st_value
== value
&& esym
->st_size
== size
431 && esym
->st_info
== info
&& esym
->st_other
== other
432 && esym
->st_shndx
== shndx
)
435 if (sym_bind
!= STB_LOCAL
) {
436 /* we search global or weak symbols */
439 if (esym
->st_shndx
!= SHN_UNDEF
) {
440 esym_bind
= ELFW(ST_BIND
)(esym
->st_info
);
441 /* propagate the most constraining visibility */
442 /* STV_DEFAULT(0)<STV_PROTECTED(3)<STV_HIDDEN(2)<STV_INTERNAL(1) */
443 esym_vis
= ELFW(ST_VISIBILITY
)(esym
->st_other
);
444 if (esym_vis
== STV_DEFAULT
) {
446 } else if (sym_vis
== STV_DEFAULT
) {
449 new_vis
= (esym_vis
< sym_vis
) ? esym_vis
: sym_vis
;
451 esym
->st_other
= (esym
->st_other
& ~ELFW(ST_VISIBILITY
)(-1))
453 other
= esym
->st_other
; /* in case we have to patch esym */
454 if (shndx
== SHN_UNDEF
) {
455 /* ignore adding of undefined symbol if the
456 corresponding symbol is already defined */
457 } else if (sym_bind
== STB_GLOBAL
&& esym_bind
== STB_WEAK
) {
458 /* global overrides weak, so patch */
460 } else if (sym_bind
== STB_WEAK
&& esym_bind
== STB_GLOBAL
) {
461 /* weak is ignored if already global */
462 } else if (sym_bind
== STB_WEAK
&& esym_bind
== STB_WEAK
) {
463 /* keep first-found weak definition, ignore subsequents */
464 } else if (sym_vis
== STV_HIDDEN
|| sym_vis
== STV_INTERNAL
) {
465 /* ignore hidden symbols after */
466 } else if ((esym
->st_shndx
== SHN_COMMON
467 || esym
->st_shndx
== bss_section
->sh_num
)
468 && (shndx
< SHN_LORESERVE
469 && shndx
!= bss_section
->sh_num
)) {
470 /* data symbol gets precedence over common/bss */
472 } else if (shndx
== SHN_COMMON
|| shndx
== bss_section
->sh_num
) {
473 /* data symbol keeps precedence over common/bss */
474 } else if (s
== tcc_state
->dynsymtab_section
) {
475 /* we accept that two DLL define the same symbol */
478 printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",
479 sym_bind
, shndx
, new_vis
, esym_bind
, esym
->st_shndx
, esym_vis
);
481 tcc_error_noabort("'%s' defined twice", name
);
485 esym
->st_info
= ELFW(ST_INFO
)(sym_bind
, sym_type
);
486 esym
->st_shndx
= shndx
;
488 esym
->st_value
= value
;
489 esym
->st_size
= size
;
490 esym
->st_other
= other
;
494 sym_index
= put_elf_sym(s
, value
, size
,
495 ELFW(ST_INFO
)(sym_bind
, sym_type
), other
,
502 ST_FUNC
void put_elf_reloca(Section
*symtab
, Section
*s
, unsigned long offset
,
503 int type
, int symbol
, addr_t addend
)
511 /* if no relocation section, create it */
512 snprintf(buf
, sizeof(buf
), REL_SECTION_FMT
, s
->name
);
513 /* if the symtab is allocated, then we consider the relocation
515 sr
= new_section(tcc_state
, buf
, SHT_RELX
, symtab
->sh_flags
);
516 sr
->sh_entsize
= sizeof(ElfW_Rel
);
518 sr
->sh_info
= s
->sh_num
;
521 rel
= section_ptr_add(sr
, sizeof(ElfW_Rel
));
522 rel
->r_offset
= offset
;
523 rel
->r_info
= ELFW(R_INFO
)(symbol
, type
);
524 #if SHT_RELX == SHT_RELA
525 rel
->r_addend
= addend
;
528 tcc_error("non-zero addend on REL architecture");
532 ST_FUNC
void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
533 int type
, int symbol
)
535 put_elf_reloca(symtab
, s
, offset
, type
, symbol
, 0);
538 /* Remove relocations for section S->reloc starting at oldrelocoffset
539 that are to the same place, retaining the last of them. As side effect
540 the relocations are sorted. Possibly reduces the number of relocs. */
541 ST_FUNC
void squeeze_multi_relocs(Section
*s
, size_t oldrelocoffset
)
543 Section
*sr
= s
->reloc
;
548 if (oldrelocoffset
+ sizeof(*r
) >= sr
->data_offset
)
550 /* The relocs we're dealing with are the result of initializer parsing.
551 So they will be mostly in order and there aren't many of them.
552 Secondly we need a stable sort (which qsort isn't). We use
553 a simple insertion sort. */
554 for (a
= oldrelocoffset
+ sizeof(*r
); a
< sr
->data_offset
; a
+= sizeof(*r
)) {
555 ssize_t i
= a
- sizeof(*r
);
556 addr
= ((ElfW_Rel
*)(sr
->data
+ a
))->r_offset
;
557 for (; i
>= (ssize_t
)oldrelocoffset
&&
558 ((ElfW_Rel
*)(sr
->data
+ i
))->r_offset
> addr
; i
-= sizeof(*r
)) {
559 ElfW_Rel tmp
= *(ElfW_Rel
*)(sr
->data
+ a
);
560 *(ElfW_Rel
*)(sr
->data
+ a
) = *(ElfW_Rel
*)(sr
->data
+ i
);
561 *(ElfW_Rel
*)(sr
->data
+ i
) = tmp
;
565 r
= (ElfW_Rel
*)(sr
->data
+ oldrelocoffset
);
567 for (; r
< (ElfW_Rel
*)(sr
->data
+ sr
->data_offset
); r
++) {
568 if (dest
->r_offset
!= r
->r_offset
)
572 sr
->data_offset
= (unsigned char*)dest
- sr
->data
+ sizeof(*r
);
575 /* put stab debug information */
577 ST_FUNC
void put_stabs(const char *str
, int type
, int other
, int desc
,
582 sym
= section_ptr_add(stab_section
, sizeof(Stab_Sym
));
584 sym
->n_strx
= put_elf_str(stabstr_section
, str
);
589 sym
->n_other
= other
;
591 sym
->n_value
= value
;
594 ST_FUNC
void put_stabs_r(const char *str
, int type
, int other
, int desc
,
595 unsigned long value
, Section
*sec
, int sym_index
)
597 put_stabs(str
, type
, other
, desc
, value
);
598 put_elf_reloc(symtab_section
, stab_section
,
599 stab_section
->data_offset
- sizeof(unsigned int),
600 R_DATA_32
, sym_index
);
603 ST_FUNC
void put_stabn(int type
, int other
, int desc
, int value
)
605 put_stabs(NULL
, type
, other
, desc
, value
);
608 ST_FUNC
void put_stabd(int type
, int other
, int desc
)
610 put_stabs(NULL
, type
, other
, desc
, 0);
613 ST_FUNC
struct sym_attr
*get_sym_attr(TCCState
*s1
, int index
, int alloc
)
616 struct sym_attr
*tab
;
618 if (index
>= s1
->nb_sym_attrs
) {
620 return s1
->sym_attrs
;
621 /* find immediately bigger power of 2 and reallocate array */
625 tab
= tcc_realloc(s1
->sym_attrs
, n
* sizeof(*s1
->sym_attrs
));
627 memset(s1
->sym_attrs
+ s1
->nb_sym_attrs
, 0,
628 (n
- s1
->nb_sym_attrs
) * sizeof(*s1
->sym_attrs
));
629 s1
->nb_sym_attrs
= n
;
631 return &s1
->sym_attrs
[index
];
634 /* Browse each elem of type <type> in section <sec> starting at elem <startoff>
635 using variable <elem> */
636 #define for_each_elem(sec, startoff, elem, type) \
637 for (elem = (type *) sec->data + startoff; \
638 elem < (type *) (sec->data + sec->data_offset); elem++)
640 /* In an ELF file symbol table, the local symbols must appear below
641 the global and weak ones. Since TCC cannot sort it while generating
642 the code, we must do it after. All the relocation tables are also
643 modified to take into account the symbol table sorting */
644 static void sort_syms(TCCState
*s1
, Section
*s
)
646 int *old_to_new_syms
;
654 nb_syms
= s
->data_offset
/ sizeof(ElfW(Sym
));
655 new_syms
= tcc_malloc(nb_syms
* sizeof(ElfW(Sym
)));
656 old_to_new_syms
= tcc_malloc(nb_syms
* sizeof(int));
658 /* first pass for local symbols */
659 p
= (ElfW(Sym
) *)s
->data
;
661 for(i
= 0; i
< nb_syms
; i
++) {
662 if (ELFW(ST_BIND
)(p
->st_info
) == STB_LOCAL
) {
663 old_to_new_syms
[i
] = q
- new_syms
;
668 /* save the number of local symbols in section header */
669 s
->sh_info
= q
- new_syms
;
671 /* then second pass for non local symbols */
672 p
= (ElfW(Sym
) *)s
->data
;
673 for(i
= 0; i
< nb_syms
; i
++) {
674 if (ELFW(ST_BIND
)(p
->st_info
) != STB_LOCAL
) {
675 old_to_new_syms
[i
] = q
- new_syms
;
681 /* we copy the new symbols to the old */
682 memcpy(s
->data
, new_syms
, nb_syms
* sizeof(ElfW(Sym
)));
685 /* now we modify all the relocations */
686 for(i
= 1; i
< s1
->nb_sections
; i
++) {
687 sr
= s1
->sections
[i
];
688 if (sr
->sh_type
== SHT_RELX
&& sr
->link
== s
) {
689 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
690 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
691 type
= ELFW(R_TYPE
)(rel
->r_info
);
692 sym_index
= old_to_new_syms
[sym_index
];
693 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
698 tcc_free(old_to_new_syms
);
701 /* relocate common symbols in the .bss section */
702 ST_FUNC
void relocate_common_syms(void)
705 unsigned long offset
, align
;
707 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
708 if (sym
->st_shndx
== SHN_COMMON
) {
710 align
= sym
->st_value
;
711 offset
= bss_section
->data_offset
;
712 offset
= (offset
+ align
- 1) & -align
;
713 sym
->st_value
= offset
;
714 sym
->st_shndx
= bss_section
->sh_num
;
715 offset
+= sym
->st_size
;
716 bss_section
->data_offset
= offset
;
721 /* relocate symbol table, resolve undefined symbols if do_resolve is
722 true and output error if undefined symbol. */
723 ST_FUNC
void relocate_syms(TCCState
*s1
, Section
*symtab
, int do_resolve
)
726 int sym_bind
, sh_num
;
729 for_each_elem(symtab
, 1, sym
, ElfW(Sym
)) {
730 sh_num
= sym
->st_shndx
;
731 if (sh_num
== SHN_UNDEF
) {
732 name
= (char *) strtab_section
->data
+ sym
->st_name
;
733 /* Use ld.so to resolve symbol for us (for tcc -run) */
735 #if defined TCC_IS_NATIVE && !defined TCC_TARGET_PE
736 void *addr
= dlsym(RTLD_DEFAULT
, name
);
738 sym
->st_value
= (addr_t
) addr
;
740 printf ("relocate_sym: %s -> 0x%lx\n", name
, sym
->st_value
);
745 /* if dynamic symbol exist, it will be used in relocate_section */
746 } else if (s1
->dynsym
&& find_elf_sym(s1
->dynsym
, name
))
748 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
750 if (!strcmp(name
, "_fp_hw"))
752 /* only weak symbols are accepted to be undefined. Their
754 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
755 if (sym_bind
== STB_WEAK
)
758 tcc_error_noabort("undefined symbol '%s'", name
);
759 } else if (sh_num
< SHN_LORESERVE
) {
760 /* add section base */
761 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
767 /* relocate a given section (CPU dependent) by applying the relocations
768 in the associated relocation section */
769 ST_FUNC
void relocate_section(TCCState
*s1
, Section
*s
)
771 Section
*sr
= s
->reloc
;
780 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
781 ptr
= s
->data
+ rel
->r_offset
;
782 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
783 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
784 type
= ELFW(R_TYPE
)(rel
->r_info
);
786 #if SHT_RELX == SHT_RELA
787 tgt
+= rel
->r_addend
;
789 addr
= s
->sh_addr
+ rel
->r_offset
;
790 relocate(s1
, rel
, type
, ptr
, addr
, tgt
);
792 /* if the relocation is allocated, we change its symbol table */
793 if (sr
->sh_flags
& SHF_ALLOC
)
794 sr
->link
= s1
->dynsym
;
797 /* relocate relocation table in 'sr' */
798 static void relocate_rel(TCCState
*s1
, Section
*sr
)
803 s
= s1
->sections
[sr
->sh_info
];
804 for_each_elem(sr
, 0, rel
, ElfW_Rel
)
805 rel
->r_offset
+= s
->sh_addr
;
808 /* count the number of dynamic relocations so that we can reserve
810 static int prepare_dynamic_rel(TCCState
*s1
, Section
*sr
)
813 int sym_index
, type
, count
;
816 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
817 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
818 type
= ELFW(R_TYPE
)(rel
->r_info
);
820 #if defined(TCC_TARGET_I386)
822 #elif defined(TCC_TARGET_X86_64)
829 #if defined(TCC_TARGET_I386)
831 #elif defined(TCC_TARGET_X86_64)
834 if (get_sym_attr(s1
, sym_index
, 0)->dyn_index
)
842 /* allocate the section */
843 sr
->sh_flags
|= SHF_ALLOC
;
844 sr
->sh_size
= count
* sizeof(ElfW_Rel
);
849 static void build_got(TCCState
*s1
)
851 /* if no got, then create it */
852 s1
->got
= new_section(s1
, ".got", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
853 s1
->got
->sh_entsize
= 4;
854 set_elf_sym(symtab_section
, 0, 4, ELFW(ST_INFO
)(STB_GLOBAL
, STT_OBJECT
),
855 0, s1
->got
->sh_num
, "_GLOBAL_OFFSET_TABLE_");
856 /* keep space for _DYNAMIC pointer and two dummy got entries */
857 section_ptr_add(s1
->got
, 3 * PTR_SIZE
);
860 /* Create a GOT and (for function call) a PLT entry corresponding to a symbol
861 in s1->symtab. When creating the dynamic symbol table entry for the GOT
862 relocation, use 'size' and 'info' for the corresponding symbol metadata.
863 Returns the offset of the GOT or (if any) PLT entry. */
864 static struct sym_attr
* put_got_entry(TCCState
*s1
, int dyn_reloc_type
,
865 int reloc_type
, unsigned long size
,
866 int info
, int sym_index
)
871 struct sym_attr
*attr
;
876 need_plt_entry
= (dyn_reloc_type
== R_JMP_SLOT
);
877 attr
= get_sym_attr(s1
, sym_index
, 1);
879 /* In case a function is both called and its address taken 2 GOT entries
880 are created, one for taking the address (GOT) and the other for the PLT
882 if (need_plt_entry
? attr
->plt_offset
: attr
->got_offset
)
885 /* create the GOT entry */
886 got_offset
= s1
->got
->data_offset
;
887 section_ptr_add(s1
->got
, PTR_SIZE
);
889 /* Create the GOT relocation that will insert the address of the object or
890 function of interest in the GOT entry. This is a static relocation for
891 memory output (dlsym will give us the address of symbols) and dynamic
892 relocation otherwise (executable and DLLs). The relocation should be
893 done lazily for GOT entry with *_JUMP_SLOT relocation type (the one
894 associated to a PLT entry) but is currently done at load time for an
897 sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
898 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
901 if (0 == attr
->dyn_index
)
902 attr
->dyn_index
= set_elf_sym(s1
->dynsym
, sym
->st_value
, size
,
903 info
, 0, sym
->st_shndx
, name
);
904 put_elf_reloc(s1
->dynsym
, s1
->got
, got_offset
, dyn_reloc_type
,
907 put_elf_reloc(symtab_section
, s1
->got
, got_offset
, dyn_reloc_type
,
911 if (need_plt_entry
) {
913 s1
->plt
= new_section(s1
, ".plt", SHT_PROGBITS
,
914 SHF_ALLOC
| SHF_EXECINSTR
);
915 s1
->plt
->sh_entsize
= 4;
918 attr
->plt_offset
= create_plt_entry(s1
, got_offset
, attr
);
920 /* create a symbol 'sym@plt' for the PLT jump vector */
922 if (len
> sizeof plt_name
- 5)
923 len
= sizeof plt_name
- 5;
924 memcpy(plt_name
, name
, len
);
925 strcpy(plt_name
+ len
, "@plt");
926 attr
->plt_sym
= put_elf_sym(s1
->symtab
, attr
->plt_offset
, sym
->st_size
,
927 ELFW(ST_INFO
)(STB_GLOBAL
, STT_FUNC
), 0, s1
->plt
->sh_num
, plt_name
);
930 attr
->got_offset
= got_offset
;
936 /* build GOT and PLT entries */
937 ST_FUNC
void build_got_entries(TCCState
*s1
)
942 int i
, type
, gotplt_entry
, reloc_type
, sym_index
;
943 struct sym_attr
*attr
;
945 for(i
= 1; i
< s1
->nb_sections
; i
++) {
947 if (s
->sh_type
!= SHT_RELX
)
949 /* no need to handle got relocations */
950 if (s
->link
!= symtab_section
)
952 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
953 type
= ELFW(R_TYPE
)(rel
->r_info
);
954 gotplt_entry
= gotplt_entry_type(type
);
955 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
956 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
958 if (gotplt_entry
== NO_GOTPLT_ENTRY
) {
962 /* Automatically create PLT/GOT [entry] if it is an undefined
963 reference (resolved at runtime), or the symbol is absolute,
964 probably created by tcc_add_symbol, and thus on 64-bit
965 targets might be too far from application code. */
966 if (gotplt_entry
== AUTO_GOTPLT_ENTRY
) {
967 if (sym
->st_shndx
== SHN_UNDEF
) {
970 if (s1
->output_type
== TCC_OUTPUT_DLL
&& ! PCRELATIVE_DLLPLT
)
972 /* Relocations for UNDEF symbols would normally need
973 to be transferred into the executable or shared object.
974 If that were done AUTO_GOTPLT_ENTRY wouldn't exist.
975 But TCC doesn't do that (at least for exes), so we
976 need to resolve all such relocs locally. And that
977 means PLT slots for functions in DLLs and COPY relocs for
978 data symbols. COPY relocs were generated in
979 bind_exe_dynsyms (and the symbol adjusted to be defined),
980 and for functions we were generated a dynamic symbol
983 /* dynsym isn't set for -run :-/ */
984 dynindex
= get_sym_attr(s1
, sym_index
, 0)->dyn_index
;
985 esym
= (ElfW(Sym
) *)s1
->dynsym
->data
+ dynindex
;
987 && (ELFW(ST_TYPE
)(esym
->st_info
) == STT_FUNC
988 || (ELFW(ST_TYPE
)(esym
->st_info
) == STT_NOTYPE
989 && ELFW(ST_TYPE
)(sym
->st_info
) == STT_FUNC
)))
992 } else if (!(sym
->st_shndx
== SHN_ABS
&& PTR_SIZE
== 8))
996 #ifdef TCC_TARGET_X86_64
997 if (type
== R_X86_64_PLT32
&&
998 ELFW(ST_VISIBILITY
)(sym
->st_other
) != STV_DEFAULT
) {
999 rel
->r_info
= ELFW(R_INFO
)(sym_index
, R_X86_64_PC32
);
1003 if (code_reloc(type
)) {
1005 reloc_type
= R_JMP_SLOT
;
1007 reloc_type
= R_GLOB_DAT
;
1012 if (gotplt_entry
== BUILD_GOT_ONLY
)
1015 attr
= put_got_entry(s1
, reloc_type
, type
, sym
->st_size
, sym
->st_info
,
1018 if (reloc_type
== R_JMP_SLOT
)
1019 rel
->r_info
= ELFW(R_INFO
)(attr
->plt_sym
, type
);
1024 /* put dynamic tag */
1025 static void put_dt(Section
*dynamic
, int dt
, addr_t val
)
1028 dyn
= section_ptr_add(dynamic
, sizeof(ElfW(Dyn
)));
1030 dyn
->d_un
.d_val
= val
;
1033 #ifndef TCC_TARGET_PE
1034 static void add_init_array_defines(TCCState
*s1
, const char *section_name
)
1038 char sym_start
[1024];
1041 snprintf(sym_start
, sizeof(sym_start
), "__%s_start", section_name
+ 1);
1042 snprintf(sym_end
, sizeof(sym_end
), "__%s_end", section_name
+ 1);
1044 s
= find_section(s1
, section_name
);
1049 end_offset
= s
->data_offset
;
1052 set_elf_sym(symtab_section
,
1054 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1055 s
->sh_num
, sym_start
);
1056 set_elf_sym(symtab_section
,
1058 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1059 s
->sh_num
, sym_end
);
1063 static int tcc_add_support(TCCState
*s1
, const char *filename
)
1066 snprintf(buf
, sizeof(buf
), "%s/%s", s1
->tcc_lib_path
, filename
);
1067 return tcc_add_file(s1
, buf
);
1070 ST_FUNC
void tcc_add_bcheck(TCCState
*s1
)
1072 #ifdef CONFIG_TCC_BCHECK
1076 if (0 == s1
->do_bounds_check
)
1078 /* XXX: add an object file to do that */
1079 ptr
= section_ptr_add(bounds_section
, sizeof(*ptr
));
1081 set_elf_sym(symtab_section
, 0, 0,
1082 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1083 bounds_section
->sh_num
, "__bounds_start");
1084 /* pull bcheck.o from libtcc1.a */
1085 sym_index
= set_elf_sym(symtab_section
, 0, 0,
1086 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1087 SHN_UNDEF
, "__bound_init");
1088 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
) {
1089 /* add 'call __bound_init()' in .init section */
1090 Section
*init_section
= find_section(s1
, ".init");
1091 unsigned char *pinit
= section_ptr_add(init_section
, 5);
1093 write32le(pinit
+ 1, -4);
1094 put_elf_reloc(symtab_section
, init_section
,
1095 init_section
->data_offset
- 4, R_386_PC32
, sym_index
);
1096 /* R_386_PC32 = R_X86_64_PC32 = 2 */
1101 /* add tcc runtime libraries */
1102 ST_FUNC
void tcc_add_runtime(TCCState
*s1
)
1105 tcc_add_pragma_libs(s1
);
1107 if (!s1
->nostdlib
) {
1108 tcc_add_library_err(s1
, "c");
1110 if (!s1
->static_link
) {
1111 if (TCC_LIBGCC
[0] == '/')
1112 tcc_add_file(s1
, TCC_LIBGCC
);
1114 tcc_add_dll(s1
, TCC_LIBGCC
, 0);
1117 tcc_add_support(s1
, TCC_LIBTCC1
);
1118 /* add crt end if not memory output */
1119 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
)
1120 tcc_add_crt(s1
, "crtn.o");
1124 /* add various standard linker symbols (must be done after the
1125 sections are filled (for example after allocating common
1127 ST_FUNC
void tcc_add_linker_symbols(TCCState
*s1
)
1133 set_elf_sym(symtab_section
,
1134 text_section
->data_offset
, 0,
1135 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1136 text_section
->sh_num
, "_etext");
1137 set_elf_sym(symtab_section
,
1138 data_section
->data_offset
, 0,
1139 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1140 data_section
->sh_num
, "_edata");
1141 set_elf_sym(symtab_section
,
1142 bss_section
->data_offset
, 0,
1143 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1144 bss_section
->sh_num
, "_end");
1145 #ifndef TCC_TARGET_PE
1146 /* horrible new standard ldscript defines */
1147 add_init_array_defines(s1
, ".preinit_array");
1148 add_init_array_defines(s1
, ".init_array");
1149 add_init_array_defines(s1
, ".fini_array");
1152 /* add start and stop symbols for sections whose name can be
1154 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1155 s
= s1
->sections
[i
];
1156 if (s
->sh_type
== SHT_PROGBITS
&&
1157 (s
->sh_flags
& SHF_ALLOC
)) {
1161 /* check if section name can be expressed in C */
1167 if (!isid(ch
) && !isnum(ch
))
1171 snprintf(buf
, sizeof(buf
), "__start_%s", s
->name
);
1172 set_elf_sym(symtab_section
,
1174 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1176 snprintf(buf
, sizeof(buf
), "__stop_%s", s
->name
);
1177 set_elf_sym(symtab_section
,
1179 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1186 static void tcc_output_binary(TCCState
*s1
, FILE *f
,
1187 const int *sec_order
)
1190 int i
, offset
, size
;
1193 for(i
=1;i
<s1
->nb_sections
;i
++) {
1194 s
= s1
->sections
[sec_order
[i
]];
1195 if (s
->sh_type
!= SHT_NOBITS
&&
1196 (s
->sh_flags
& SHF_ALLOC
)) {
1197 while (offset
< s
->sh_offset
) {
1202 fwrite(s
->data
, 1, size
, f
);
1208 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1210 #define EXTRA_RELITEMS 14
1213 #define EXTRA_RELITEMS 9
1216 ST_FUNC
void fill_got_entry(TCCState
*s1
, ElfW_Rel
*rel
)
1218 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1219 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1220 struct sym_attr
*attr
= get_sym_attr(s1
, sym_index
, 0);
1221 unsigned offset
= attr
->got_offset
;
1225 section_reserve(s1
->got
, offset
+ PTR_SIZE
);
1226 #ifdef TCC_TARGET_X86_64
1227 write64le(s1
->got
->data
+ offset
, sym
->st_value
);
1229 write32le(s1
->got
->data
+ offset
, sym
->st_value
);
1233 /* Perform relocation to GOT or PLT entries */
1234 ST_FUNC
void fill_got(TCCState
*s1
)
1240 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1241 s
= s1
->sections
[i
];
1242 if (s
->sh_type
!= SHT_RELX
)
1244 /* no need to handle got relocations */
1245 if (s
->link
!= symtab_section
)
1247 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1248 switch (ELFW(R_TYPE
) (rel
->r_info
)) {
1249 case R_X86_64_GOT32
:
1250 case R_X86_64_GOTPCREL
:
1251 case R_X86_64_GOTPCRELX
:
1252 case R_X86_64_REX_GOTPCRELX
:
1253 case R_X86_64_PLT32
:
1254 fill_got_entry(s1
, rel
);
1261 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1262 in shared libraries and export non local defined symbols to shared libraries
1263 if -rdynamic switch was given on command line */
1264 static void bind_exe_dynsyms(TCCState
*s1
)
1267 int sym_index
, index
;
1268 ElfW(Sym
) *sym
, *esym
;
1271 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1272 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1273 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1274 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1275 if (sym
->st_shndx
== SHN_UNDEF
) {
1276 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1277 sym_index
= find_elf_sym(s1
->dynsymtab_section
, name
);
1279 esym
= &((ElfW(Sym
) *)s1
->dynsymtab_section
->data
)[sym_index
];
1280 type
= ELFW(ST_TYPE
)(esym
->st_info
);
1281 if ((type
== STT_FUNC
) || (type
== STT_GNU_IFUNC
)) {
1282 /* Indirect functions shall have STT_FUNC type in executable
1283 * dynsym section. Indeed, a dlsym call following a lazy
1284 * resolution would pick the symbol value from the
1285 * executable dynsym entry which would contain the address
1286 * of the function wanted by the caller of dlsym instead of
1287 * the address of the function that would return that
1290 = put_elf_sym(s1
->dynsym
, 0, esym
->st_size
,
1291 ELFW(ST_INFO
)(STB_GLOBAL
,STT_FUNC
), 0, 0,
1293 int index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1294 get_sym_attr(s1
, index
, 1)->dyn_index
= dynindex
;
1295 } else if (type
== STT_OBJECT
) {
1296 unsigned long offset
;
1298 offset
= bss_section
->data_offset
;
1299 /* XXX: which alignment ? */
1300 offset
= (offset
+ 16 - 1) & -16;
1301 set_elf_sym (s1
->symtab
, offset
, esym
->st_size
,
1302 esym
->st_info
, 0, bss_section
->sh_num
, name
);
1303 index
= put_elf_sym(s1
->dynsym
, offset
, esym
->st_size
,
1304 esym
->st_info
, 0, bss_section
->sh_num
,
1307 /* Ensure R_COPY works for weak symbol aliases */
1308 if (ELFW(ST_BIND
)(esym
->st_info
) == STB_WEAK
) {
1309 for_each_elem(s1
->dynsymtab_section
, 1, dynsym
, ElfW(Sym
)) {
1310 if ((dynsym
->st_value
== esym
->st_value
)
1311 && (ELFW(ST_BIND
)(dynsym
->st_info
) == STB_GLOBAL
)) {
1312 char *dynname
= (char *) s1
->dynsymtab_section
->link
->data
1314 put_elf_sym(s1
->dynsym
, offset
, dynsym
->st_size
,
1316 bss_section
->sh_num
, dynname
);
1322 put_elf_reloc(s1
->dynsym
, bss_section
,
1323 offset
, R_COPY
, index
);
1324 offset
+= esym
->st_size
;
1325 bss_section
->data_offset
= offset
;
1328 /* STB_WEAK undefined symbols are accepted */
1329 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1330 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
||
1331 !strcmp(name
, "_fp_hw")) {
1333 tcc_error_noabort("undefined symbol '%s'", name
);
1336 } else if (s1
->rdynamic
&& ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1337 /* if -rdynamic option, then export all non local symbols */
1338 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1339 set_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1340 0, sym
->st_shndx
, name
);
1345 /* Bind symbols of libraries: export all non local symbols of executable that
1346 are referenced by shared libraries. The reason is that the dynamic loader
1347 search symbol first in executable and then in libraries. Therefore a
1348 reference to a symbol already defined by a library can still be resolved by
1349 a symbol in the executable. */
1350 static void bind_libs_dynsyms(TCCState
*s1
)
1354 ElfW(Sym
) *sym
, *esym
;
1356 for_each_elem(s1
->dynsymtab_section
, 1, esym
, ElfW(Sym
)) {
1357 name
= (char *) s1
->dynsymtab_section
->link
->data
+ esym
->st_name
;
1358 sym_index
= find_elf_sym(symtab_section
, name
);
1359 /* XXX: avoid adding a symbol if already present because of
1361 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1362 if (sym_index
&& sym
->st_shndx
!= SHN_UNDEF
)
1363 set_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1364 0, sym
->st_shndx
, name
);
1365 else if (esym
->st_shndx
== SHN_UNDEF
) {
1366 /* weak symbols can stay undefined */
1367 if (ELFW(ST_BIND
)(esym
->st_info
) != STB_WEAK
)
1368 tcc_warning("undefined dynamic symbol '%s'", name
);
1373 /* Export all non local symbols. This is used by shared libraries so that the
1374 non local symbols they define can resolve a reference in another shared
1375 library or in the executable. Correspondingly, it allows undefined local
1376 symbols to be resolved by other shared libraries or by the executable. */
1377 static void export_global_syms(TCCState
*s1
)
1379 int dynindex
, index
;
1383 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1384 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1385 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1386 dynindex
= put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1387 sym
->st_info
, 0, sym
->st_shndx
, name
);
1388 index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1389 get_sym_attr(s1
, index
, 1)->dyn_index
= dynindex
;
1394 /* Allocate strings for section names and decide if an unallocated section
1396 NOTE: the strsec section comes last, so its size is also correct ! */
1397 static void alloc_sec_names(TCCState
*s1
, int file_type
, Section
*strsec
)
1402 /* Allocate strings for section names */
1403 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1404 s
= s1
->sections
[i
];
1405 s
->sh_name
= put_elf_str(strsec
, s
->name
);
1406 /* when generating a DLL, we include relocations but we may
1408 if (file_type
== TCC_OUTPUT_DLL
&&
1409 s
->sh_type
== SHT_RELX
&&
1410 !(s
->sh_flags
& SHF_ALLOC
)) {
1411 /* gr: avoid bogus relocs for empty (debug) sections */
1412 if (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_ALLOC
)
1413 prepare_dynamic_rel(s1
, s
);
1414 else if (s1
->do_debug
)
1415 s
->sh_size
= s
->data_offset
;
1416 } else if (s1
->do_debug
||
1417 file_type
== TCC_OUTPUT_OBJ
||
1418 (s
->sh_flags
& SHF_ALLOC
) ||
1419 i
== (s1
->nb_sections
- 1)) {
1420 /* we output all sections if debug or object file */
1421 s
->sh_size
= s
->data_offset
;
1426 /* Info to be copied in dynamic section */
1430 unsigned long dyn_rel_off
;
1433 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1439 /* Assign sections to segments and decide how are sections laid out when loaded
1440 in memory. This function also fills corresponding program headers. */
1441 static int layout_sections(TCCState
*s1
, ElfW(Phdr
) *phdr
, int phnum
,
1442 Section
*interp
, Section
* strsec
,
1443 struct dyn_inf
*dyninf
, int *sec_order
)
1445 int i
, j
, k
, file_type
, sh_order_index
, file_offset
;
1446 unsigned long s_align
;
1452 file_type
= s1
->output_type
;
1455 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
1456 file_offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1457 s_align
= ELF_PAGE_SIZE
;
1458 if (s1
->section_align
)
1459 s_align
= s1
->section_align
;
1462 if (s1
->has_text_addr
) {
1463 int a_offset
, p_offset
;
1464 addr
= s1
->text_addr
;
1465 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1467 a_offset
= (int) (addr
& (s_align
- 1));
1468 p_offset
= file_offset
& (s_align
- 1);
1469 if (a_offset
< p_offset
)
1470 a_offset
+= s_align
;
1471 file_offset
+= (a_offset
- p_offset
);
1473 if (file_type
== TCC_OUTPUT_DLL
)
1476 addr
= ELF_START_ADDR
;
1477 /* compute address after headers */
1478 addr
+= (file_offset
& (s_align
- 1));
1482 /* Leave one program headers for the program interpreter and one for
1483 the program header table itself if needed. These are done later as
1484 they require section layout to be done first. */
1486 ph
+= 1 + HAVE_PHDR
;
1488 /* dynamic relocation table information, for .dynamic section */
1489 dyninf
->rel_addr
= dyninf
->rel_size
= 0;
1490 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1491 dyninf
->bss_addr
= dyninf
->bss_size
= 0;
1494 for(j
= 0; j
< 2; j
++) {
1495 ph
->p_type
= PT_LOAD
;
1497 ph
->p_flags
= PF_R
| PF_X
;
1499 ph
->p_flags
= PF_R
| PF_W
;
1500 ph
->p_align
= s_align
;
1502 /* Decide the layout of sections loaded in memory. This must
1503 be done before program headers are filled since they contain
1504 info about the layout. We do the following ordering: interp,
1505 symbol tables, relocations, progbits, nobits */
1506 /* XXX: do faster and simpler sorting */
1507 for(k
= 0; k
< 5; k
++) {
1508 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1509 s
= s1
->sections
[i
];
1510 /* compute if section should be included */
1512 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1516 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1517 (SHF_ALLOC
| SHF_WRITE
))
1523 } else if (s
->sh_type
== SHT_DYNSYM
||
1524 s
->sh_type
== SHT_STRTAB
||
1525 s
->sh_type
== SHT_HASH
) {
1528 } else if (s
->sh_type
== SHT_RELX
) {
1531 } else if (s
->sh_type
== SHT_NOBITS
) {
1538 sec_order
[sh_order_index
++] = i
;
1540 /* section matches: we align it and add its size */
1542 addr
= (addr
+ s
->sh_addralign
- 1) &
1543 ~(s
->sh_addralign
- 1);
1544 file_offset
+= (int) ( addr
- tmp
);
1545 s
->sh_offset
= file_offset
;
1548 /* update program header infos */
1549 if (ph
->p_offset
== 0) {
1550 ph
->p_offset
= file_offset
;
1552 ph
->p_paddr
= ph
->p_vaddr
;
1554 /* update dynamic relocation infos */
1555 if (s
->sh_type
== SHT_RELX
) {
1556 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1557 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.got")) {
1558 dyninf
->rel_addr
= addr
;
1559 dyninf
->rel_size
+= s
->sh_size
; /* XXX only first rel. */
1561 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.bss")) {
1562 dyninf
->bss_addr
= addr
;
1563 dyninf
->bss_size
= s
->sh_size
; /* XXX only first rel. */
1566 if (dyninf
->rel_size
== 0)
1567 dyninf
->rel_addr
= addr
;
1568 dyninf
->rel_size
+= s
->sh_size
;
1572 if (s
->sh_type
!= SHT_NOBITS
)
1573 file_offset
+= s
->sh_size
;
1577 /* Make the first PT_LOAD segment include the program
1578 headers itself (and the ELF header as well), it'll
1579 come out with same memory use but will make various
1580 tools like binutils strip work better. */
1581 ph
->p_offset
&= ~(ph
->p_align
- 1);
1582 ph
->p_vaddr
&= ~(ph
->p_align
- 1);
1583 ph
->p_paddr
&= ~(ph
->p_align
- 1);
1585 ph
->p_filesz
= file_offset
- ph
->p_offset
;
1586 ph
->p_memsz
= addr
- ph
->p_vaddr
;
1589 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
) {
1590 /* if in the middle of a page, we duplicate the page in
1591 memory so that one copy is RX and the other is RW */
1592 if ((addr
& (s_align
- 1)) != 0)
1595 addr
= (addr
+ s_align
- 1) & ~(s_align
- 1);
1596 file_offset
= (file_offset
+ s_align
- 1) & ~(s_align
- 1);
1602 /* all other sections come after */
1603 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1604 s
= s1
->sections
[i
];
1605 if (phnum
> 0 && (s
->sh_flags
& SHF_ALLOC
))
1607 sec_order
[sh_order_index
++] = i
;
1609 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
1610 ~(s
->sh_addralign
- 1);
1611 s
->sh_offset
= file_offset
;
1612 if (s
->sh_type
!= SHT_NOBITS
)
1613 file_offset
+= s
->sh_size
;
1619 static void fill_unloadable_phdr(ElfW(Phdr
) *phdr
, int phnum
, Section
*interp
,
1624 /* if interpreter, then add corresponding program header */
1630 int len
= phnum
* sizeof(ElfW(Phdr
));
1632 ph
->p_type
= PT_PHDR
;
1633 ph
->p_offset
= sizeof(ElfW(Ehdr
));
1634 ph
->p_vaddr
= interp
->sh_addr
- len
;
1635 ph
->p_paddr
= ph
->p_vaddr
;
1636 ph
->p_filesz
= ph
->p_memsz
= len
;
1637 ph
->p_flags
= PF_R
| PF_X
;
1638 ph
->p_align
= 4; /* interp->sh_addralign; */
1642 ph
->p_type
= PT_INTERP
;
1643 ph
->p_offset
= interp
->sh_offset
;
1644 ph
->p_vaddr
= interp
->sh_addr
;
1645 ph
->p_paddr
= ph
->p_vaddr
;
1646 ph
->p_filesz
= interp
->sh_size
;
1647 ph
->p_memsz
= interp
->sh_size
;
1649 ph
->p_align
= interp
->sh_addralign
;
1652 /* if dynamic section, then add corresponding program header */
1654 ph
= &phdr
[phnum
- 1];
1656 ph
->p_type
= PT_DYNAMIC
;
1657 ph
->p_offset
= dynamic
->sh_offset
;
1658 ph
->p_vaddr
= dynamic
->sh_addr
;
1659 ph
->p_paddr
= ph
->p_vaddr
;
1660 ph
->p_filesz
= dynamic
->sh_size
;
1661 ph
->p_memsz
= dynamic
->sh_size
;
1662 ph
->p_flags
= PF_R
| PF_W
;
1663 ph
->p_align
= dynamic
->sh_addralign
;
1667 /* Fill the dynamic section with tags describing the address and size of
1669 static void fill_dynamic(TCCState
*s1
, struct dyn_inf
*dyninf
)
1673 dynamic
= dyninf
->dynamic
;
1675 /* put dynamic section entries */
1676 dynamic
->data_offset
= dyninf
->dyn_rel_off
;
1677 put_dt(dynamic
, DT_HASH
, s1
->dynsym
->hash
->sh_addr
);
1678 put_dt(dynamic
, DT_STRTAB
, dyninf
->dynstr
->sh_addr
);
1679 put_dt(dynamic
, DT_SYMTAB
, s1
->dynsym
->sh_addr
);
1680 put_dt(dynamic
, DT_STRSZ
, dyninf
->dynstr
->data_offset
);
1681 put_dt(dynamic
, DT_SYMENT
, sizeof(ElfW(Sym
)));
1682 #if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
1683 put_dt(dynamic
, DT_RELA
, dyninf
->rel_addr
);
1684 put_dt(dynamic
, DT_RELASZ
, dyninf
->rel_size
);
1685 put_dt(dynamic
, DT_RELAENT
, sizeof(ElfW_Rel
));
1687 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1688 put_dt(dynamic
, DT_PLTGOT
, s1
->got
->sh_addr
);
1689 put_dt(dynamic
, DT_PLTRELSZ
, dyninf
->rel_size
);
1690 put_dt(dynamic
, DT_JMPREL
, dyninf
->rel_addr
);
1691 put_dt(dynamic
, DT_PLTREL
, DT_REL
);
1692 put_dt(dynamic
, DT_REL
, dyninf
->bss_addr
);
1693 put_dt(dynamic
, DT_RELSZ
, dyninf
->bss_size
);
1695 put_dt(dynamic
, DT_REL
, dyninf
->rel_addr
);
1696 put_dt(dynamic
, DT_RELSZ
, dyninf
->rel_size
);
1697 put_dt(dynamic
, DT_RELENT
, sizeof(ElfW_Rel
));
1701 put_dt(dynamic
, DT_DEBUG
, 0);
1702 put_dt(dynamic
, DT_NULL
, 0);
1705 /* Relocate remaining sections and symbols (that is those not related to
1707 static int final_sections_reloc(TCCState
*s1
)
1712 relocate_syms(s1
, s1
->symtab
, 0);
1714 if (s1
->nb_errors
!= 0)
1717 /* relocate sections */
1718 /* XXX: ignore sections with allocated relocations ? */
1719 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1720 s
= s1
->sections
[i
];
1721 #if defined(TCC_TARGET_I386) || defined(TCC_MUSL)
1722 if (s
->reloc
&& s
!= s1
->got
&& (s
->sh_flags
& SHF_ALLOC
)) //gr
1723 /* On X86 gdb 7.3 works in any case but gdb 6.6 will crash if SHF_ALLOC
1724 checking is removed */
1726 if (s
->reloc
&& s
!= s1
->got
)
1727 /* On X86_64 gdb 7.3 will crash if SHF_ALLOC checking is present */
1729 relocate_section(s1
, s
);
1732 /* relocate relocation entries if the relocation tables are
1733 allocated in the executable */
1734 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1735 s
= s1
->sections
[i
];
1736 if ((s
->sh_flags
& SHF_ALLOC
) &&
1737 s
->sh_type
== SHT_RELX
) {
1738 relocate_rel(s1
, s
);
1744 /* Create an ELF file on disk.
1745 This function handle ELF specific layout requirements */
1746 static void tcc_output_elf(TCCState
*s1
, FILE *f
, int phnum
, ElfW(Phdr
) *phdr
,
1747 int file_offset
, int *sec_order
)
1749 int i
, shnum
, offset
, size
, file_type
;
1752 ElfW(Shdr
) shdr
, *sh
;
1754 file_type
= s1
->output_type
;
1755 shnum
= s1
->nb_sections
;
1757 memset(&ehdr
, 0, sizeof(ehdr
));
1760 ehdr
.e_phentsize
= sizeof(ElfW(Phdr
));
1761 ehdr
.e_phnum
= phnum
;
1762 ehdr
.e_phoff
= sizeof(ElfW(Ehdr
));
1766 file_offset
= (file_offset
+ 3) & -4;
1769 ehdr
.e_ident
[0] = ELFMAG0
;
1770 ehdr
.e_ident
[1] = ELFMAG1
;
1771 ehdr
.e_ident
[2] = ELFMAG2
;
1772 ehdr
.e_ident
[3] = ELFMAG3
;
1773 ehdr
.e_ident
[4] = ELFCLASSW
;
1774 ehdr
.e_ident
[5] = ELFDATA2LSB
;
1775 ehdr
.e_ident
[6] = EV_CURRENT
;
1776 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1777 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
1779 #ifdef TCC_TARGET_ARM
1781 ehdr
.e_ident
[EI_OSABI
] = 0;
1782 ehdr
.e_flags
= EF_ARM_EABI_VER4
;
1783 if (file_type
== TCC_OUTPUT_EXE
|| file_type
== TCC_OUTPUT_DLL
)
1784 ehdr
.e_flags
|= EF_ARM_HASENTRY
;
1785 if (s1
->float_abi
== ARM_HARD_FLOAT
)
1786 ehdr
.e_flags
|= EF_ARM_VFP_FLOAT
;
1788 ehdr
.e_flags
|= EF_ARM_SOFT_FLOAT
;
1790 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_ARM
;
1795 case TCC_OUTPUT_EXE
:
1796 ehdr
.e_type
= ET_EXEC
;
1797 ehdr
.e_entry
= get_elf_sym_addr(s1
, "_start", 1);
1799 case TCC_OUTPUT_DLL
:
1800 ehdr
.e_type
= ET_DYN
;
1801 ehdr
.e_entry
= text_section
->sh_addr
; /* XXX: is it correct ? */
1803 case TCC_OUTPUT_OBJ
:
1804 ehdr
.e_type
= ET_REL
;
1807 ehdr
.e_machine
= EM_TCC_TARGET
;
1808 ehdr
.e_version
= EV_CURRENT
;
1809 ehdr
.e_shoff
= file_offset
;
1810 ehdr
.e_ehsize
= sizeof(ElfW(Ehdr
));
1811 ehdr
.e_shentsize
= sizeof(ElfW(Shdr
));
1812 ehdr
.e_shnum
= shnum
;
1813 ehdr
.e_shstrndx
= shnum
- 1;
1815 fwrite(&ehdr
, 1, sizeof(ElfW(Ehdr
)), f
);
1816 fwrite(phdr
, 1, phnum
* sizeof(ElfW(Phdr
)), f
);
1817 offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1819 sort_syms(s1
, symtab_section
);
1820 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1821 s
= s1
->sections
[sec_order
[i
]];
1822 if (s
->sh_type
!= SHT_NOBITS
) {
1823 while (offset
< s
->sh_offset
) {
1829 fwrite(s
->data
, 1, size
, f
);
1834 /* output section headers */
1835 while (offset
< ehdr
.e_shoff
) {
1840 for(i
= 0; i
< s1
->nb_sections
; i
++) {
1842 memset(sh
, 0, sizeof(ElfW(Shdr
)));
1843 s
= s1
->sections
[i
];
1845 sh
->sh_name
= s
->sh_name
;
1846 sh
->sh_type
= s
->sh_type
;
1847 sh
->sh_flags
= s
->sh_flags
;
1848 sh
->sh_entsize
= s
->sh_entsize
;
1849 sh
->sh_info
= s
->sh_info
;
1851 sh
->sh_link
= s
->link
->sh_num
;
1852 sh
->sh_addralign
= s
->sh_addralign
;
1853 sh
->sh_addr
= s
->sh_addr
;
1854 sh
->sh_offset
= s
->sh_offset
;
1855 sh
->sh_size
= s
->sh_size
;
1857 fwrite(sh
, 1, sizeof(ElfW(Shdr
)), f
);
1861 /* Write an elf, coff or "binary" file */
1862 static int tcc_write_elf_file(TCCState
*s1
, const char *filename
, int phnum
,
1863 ElfW(Phdr
) *phdr
, int file_offset
, int *sec_order
)
1865 int fd
, mode
, file_type
;
1868 file_type
= s1
->output_type
;
1869 if (file_type
== TCC_OUTPUT_OBJ
)
1874 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, mode
);
1876 tcc_error_noabort("could not write '%s'", filename
);
1879 f
= fdopen(fd
, "wb");
1881 printf("<- %s\n", filename
);
1883 #ifdef TCC_TARGET_COFF
1884 if (s1
->output_format
== TCC_OUTPUT_FORMAT_COFF
)
1885 tcc_output_coff(s1
, f
);
1888 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
1889 tcc_output_elf(s1
, f
, phnum
, phdr
, file_offset
, sec_order
);
1891 tcc_output_binary(s1
, f
, sec_order
);
1897 /* Output an elf, coff or binary file */
1898 /* XXX: suppress unneeded sections */
1899 static int elf_output_file(TCCState
*s1
, const char *filename
)
1901 int i
, ret
, phnum
, shnum
, file_type
, file_offset
, *sec_order
;
1902 struct dyn_inf dyninf
= {0};
1905 Section
*strsec
, *interp
, *dynamic
, *dynstr
;
1907 file_type
= s1
->output_type
;
1910 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
1911 if (file_type
!= TCC_OUTPUT_OBJ
) {
1912 tcc_add_runtime(s1
);
1917 interp
= dynamic
= dynstr
= NULL
; /* avoid warning */
1919 if (file_type
!= TCC_OUTPUT_OBJ
) {
1920 relocate_common_syms();
1922 tcc_add_linker_symbols(s1
);
1924 if (!s1
->static_link
) {
1925 if (file_type
== TCC_OUTPUT_EXE
) {
1927 /* allow override the dynamic loader */
1928 const char *elfint
= getenv("LD_SO");
1930 elfint
= DEFAULT_ELFINTERP(s1
);
1931 /* add interpreter section only if executable */
1932 interp
= new_section(s1
, ".interp", SHT_PROGBITS
, SHF_ALLOC
);
1933 interp
->sh_addralign
= 1;
1934 ptr
= section_ptr_add(interp
, 1 + strlen(elfint
));
1935 strcpy(ptr
, elfint
);
1938 /* add dynamic symbol table */
1939 s1
->dynsym
= new_symtab(s1
, ".dynsym", SHT_DYNSYM
, SHF_ALLOC
,
1941 ".hash", SHF_ALLOC
);
1942 dynstr
= s1
->dynsym
->link
;
1944 /* add dynamic section */
1945 dynamic
= new_section(s1
, ".dynamic", SHT_DYNAMIC
,
1946 SHF_ALLOC
| SHF_WRITE
);
1947 dynamic
->link
= dynstr
;
1948 dynamic
->sh_entsize
= sizeof(ElfW(Dyn
));
1952 if (file_type
== TCC_OUTPUT_EXE
) {
1953 bind_exe_dynsyms(s1
);
1955 if (s1
->nb_errors
) {
1960 bind_libs_dynsyms(s1
);
1961 } else /* shared library case: simply export all global symbols */
1962 export_global_syms(s1
);
1964 build_got_entries(s1
);
1966 /* add a list of needed dlls */
1967 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
1968 DLLReference
*dllref
= s1
->loaded_dlls
[i
];
1969 if (dllref
->level
== 0)
1970 put_dt(dynamic
, DT_NEEDED
, put_elf_str(dynstr
, dllref
->name
));
1974 put_dt(dynamic
, s1
->enable_new_dtags
? DT_RUNPATH
: DT_RPATH
,
1975 put_elf_str(dynstr
, s1
->rpath
));
1977 /* XXX: currently, since we do not handle PIC code, we
1978 must relocate the readonly segments */
1979 if (file_type
== TCC_OUTPUT_DLL
) {
1981 put_dt(dynamic
, DT_SONAME
, put_elf_str(dynstr
, s1
->soname
));
1982 put_dt(dynamic
, DT_TEXTREL
, 0);
1986 put_dt(dynamic
, DT_SYMBOLIC
, 0);
1988 /* add necessary space for other entries */
1989 dyninf
.dyn_rel_off
= dynamic
->data_offset
;
1990 dynamic
->data_offset
+= sizeof(ElfW(Dyn
)) * EXTRA_RELITEMS
;
1992 /* still need to build got entries in case of static link */
1993 build_got_entries(s1
);
1997 /* we add a section for symbols */
1998 strsec
= new_section(s1
, ".shstrtab", SHT_STRTAB
, 0);
1999 put_elf_str(strsec
, "");
2001 /* compute number of sections */
2002 shnum
= s1
->nb_sections
;
2004 /* this array is used to reorder sections in the output file */
2005 sec_order
= tcc_malloc(sizeof(int) * shnum
);
2008 /* compute number of program headers */
2011 case TCC_OUTPUT_OBJ
:
2014 case TCC_OUTPUT_EXE
:
2015 if (!s1
->static_link
)
2016 phnum
= 4 + HAVE_PHDR
;
2020 case TCC_OUTPUT_DLL
:
2025 /* Allocate strings for section names */
2026 alloc_sec_names(s1
, file_type
, strsec
);
2028 /* allocate program segment headers */
2029 phdr
= tcc_mallocz(phnum
* sizeof(ElfW(Phdr
)));
2031 /* compute section to program header mapping */
2032 file_offset
= layout_sections(s1
, phdr
, phnum
, interp
, strsec
, &dyninf
,
2035 /* Fill remaining program header and finalize relocation related to dynamic
2038 fill_unloadable_phdr(phdr
, phnum
, interp
, dynamic
);
2040 dyninf
.dynamic
= dynamic
;
2041 dyninf
.dynstr
= dynstr
;
2043 fill_dynamic(s1
, &dyninf
);
2045 /* put in GOT the dynamic section address and relocate PLT */
2046 write32le(s1
->got
->data
, dynamic
->sh_addr
);
2047 if (file_type
== TCC_OUTPUT_EXE
2048 || (RELOCATE_DLLPLT
&& file_type
== TCC_OUTPUT_DLL
))
2051 /* relocate symbols in .dynsym now that final addresses are known */
2052 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
)) {
2053 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
) {
2054 /* do symbol relocation */
2055 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
2061 /* if building executable or DLL, then relocate each section
2062 except the GOT which is already relocated */
2063 if (file_type
!= TCC_OUTPUT_OBJ
) {
2064 ret
= final_sections_reloc(s1
);
2069 /* Perform relocation to GOT or PLT entries */
2070 if (file_type
== TCC_OUTPUT_EXE
&& s1
->static_link
)
2073 /* Create the ELF file with name 'filename' */
2074 ret
= tcc_write_elf_file(s1
, filename
, phnum
, phdr
, file_offset
, sec_order
);
2076 tcc_free(sec_order
);
2081 LIBTCCAPI
int tcc_output_file(TCCState
*s
, const char *filename
)
2084 #ifdef TCC_TARGET_PE
2085 if (s
->output_type
!= TCC_OUTPUT_OBJ
) {
2086 ret
= pe_output_file(s
, filename
);
2089 ret
= elf_output_file(s
, filename
);
2093 static void *load_data(int fd
, unsigned long file_offset
, unsigned long size
)
2097 data
= tcc_malloc(size
);
2098 lseek(fd
, file_offset
, SEEK_SET
);
2099 read(fd
, data
, size
);
2103 typedef struct SectionMergeInfo
{
2104 Section
*s
; /* corresponding existing section */
2105 unsigned long offset
; /* offset of the new section in the existing section */
2106 uint8_t new_section
; /* true if section 's' was added */
2107 uint8_t link_once
; /* true if link once section */
2110 ST_FUNC
int tcc_object_type(int fd
, ElfW(Ehdr
) *h
)
2112 int size
= read(fd
, h
, sizeof *h
);
2113 if (size
== sizeof *h
&& 0 == memcmp(h
, ELFMAG
, 4)) {
2114 if (h
->e_type
== ET_REL
)
2115 return AFF_BINTYPE_REL
;
2116 if (h
->e_type
== ET_DYN
)
2117 return AFF_BINTYPE_DYN
;
2118 } else if (size
>= 8) {
2119 if (0 == memcmp(h
, ARMAG
, 8))
2120 return AFF_BINTYPE_AR
;
2121 #ifdef TCC_TARGET_COFF
2122 if (((struct filehdr
*)h
)->f_magic
== COFF_C67_MAGIC
)
2123 return AFF_BINTYPE_C67
;
2129 /* load an object file and merge it with current files */
2130 /* XXX: handle correctly stab (debug) info */
2131 ST_FUNC
int tcc_load_object_file(TCCState
*s1
,
2132 int fd
, unsigned long file_offset
)
2135 ElfW(Shdr
) *shdr
, *sh
;
2136 int size
, i
, j
, offset
, offseti
, nb_syms
, sym_index
, ret
;
2137 unsigned char *strsec
, *strtab
;
2138 int *old_to_new_syms
;
2139 char *sh_name
, *name
;
2140 SectionMergeInfo
*sm_table
, *sm
;
2141 ElfW(Sym
) *sym
, *symtab
;
2148 stab_index
= stabstr_index
= 0;
2150 lseek(fd
, file_offset
, SEEK_SET
);
2151 if (tcc_object_type(fd
, &ehdr
) != AFF_BINTYPE_REL
)
2153 /* test CPU specific stuff */
2154 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2155 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2157 tcc_error_noabort("invalid object file");
2161 shdr
= load_data(fd
, file_offset
+ ehdr
.e_shoff
,
2162 sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2163 sm_table
= tcc_mallocz(sizeof(SectionMergeInfo
) * ehdr
.e_shnum
);
2165 /* load section names */
2166 sh
= &shdr
[ehdr
.e_shstrndx
];
2167 strsec
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2169 /* load symtab and strtab */
2170 old_to_new_syms
= NULL
;
2174 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2176 if (sh
->sh_type
== SHT_SYMTAB
) {
2178 tcc_error_noabort("object must contain only one symtab");
2183 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2184 symtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2185 sm_table
[i
].s
= symtab_section
;
2187 /* now load strtab */
2188 sh
= &shdr
[sh
->sh_link
];
2189 strtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2193 /* now examine each section and try to merge its content with the
2195 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2196 /* no need to examine section name strtab */
2197 if (i
== ehdr
.e_shstrndx
)
2200 sh_name
= (char *) strsec
+ sh
->sh_name
;
2201 /* ignore sections types we do not handle */
2202 if (sh
->sh_type
!= SHT_PROGBITS
&&
2203 sh
->sh_type
!= SHT_RELX
&&
2205 sh
->sh_type
!= SHT_ARM_EXIDX
&&
2207 sh
->sh_type
!= SHT_NOBITS
&&
2208 sh
->sh_type
!= SHT_PREINIT_ARRAY
&&
2209 sh
->sh_type
!= SHT_INIT_ARRAY
&&
2210 sh
->sh_type
!= SHT_FINI_ARRAY
&&
2211 strcmp(sh_name
, ".stabstr")
2214 if (sh
->sh_addralign
< 1)
2215 sh
->sh_addralign
= 1;
2216 /* find corresponding section, if any */
2217 for(j
= 1; j
< s1
->nb_sections
;j
++) {
2218 s
= s1
->sections
[j
];
2219 if (!strcmp(s
->name
, sh_name
)) {
2220 if (!strncmp(sh_name
, ".gnu.linkonce",
2221 sizeof(".gnu.linkonce") - 1)) {
2222 /* if a 'linkonce' section is already present, we
2223 do not add it again. It is a little tricky as
2224 symbols can still be defined in
2226 sm_table
[i
].link_once
= 1;
2233 /* not found: create new section */
2234 s
= new_section(s1
, sh_name
, sh
->sh_type
, sh
->sh_flags
& ~SHF_GROUP
);
2235 /* take as much info as possible from the section. sh_link and
2236 sh_info will be updated later */
2237 s
->sh_addralign
= sh
->sh_addralign
;
2238 s
->sh_entsize
= sh
->sh_entsize
;
2239 sm_table
[i
].new_section
= 1;
2241 if (sh
->sh_type
!= s
->sh_type
) {
2242 tcc_error_noabort("invalid section type");
2246 /* align start of section */
2247 offset
= s
->data_offset
;
2249 if (0 == strcmp(sh_name
, ".stab")) {
2253 if (0 == strcmp(sh_name
, ".stabstr")) {
2258 size
= sh
->sh_addralign
- 1;
2259 offset
= (offset
+ size
) & ~size
;
2260 if (sh
->sh_addralign
> s
->sh_addralign
)
2261 s
->sh_addralign
= sh
->sh_addralign
;
2262 s
->data_offset
= offset
;
2264 sm_table
[i
].offset
= offset
;
2266 /* concatenate sections */
2268 if (sh
->sh_type
!= SHT_NOBITS
) {
2270 lseek(fd
, file_offset
+ sh
->sh_offset
, SEEK_SET
);
2271 ptr
= section_ptr_add(s
, size
);
2272 read(fd
, ptr
, size
);
2274 s
->data_offset
+= size
;
2279 /* gr relocate stab strings */
2280 if (stab_index
&& stabstr_index
) {
2283 s
= sm_table
[stab_index
].s
;
2284 a
= (Stab_Sym
*)(s
->data
+ sm_table
[stab_index
].offset
);
2285 b
= (Stab_Sym
*)(s
->data
+ s
->data_offset
);
2286 o
= sm_table
[stabstr_index
].offset
;
2288 a
->n_strx
+= o
, a
++;
2291 /* second short pass to update sh_link and sh_info fields of new
2293 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2295 if (!s
|| !sm_table
[i
].new_section
)
2298 if (sh
->sh_link
> 0)
2299 s
->link
= sm_table
[sh
->sh_link
].s
;
2300 if (sh
->sh_type
== SHT_RELX
) {
2301 s
->sh_info
= sm_table
[sh
->sh_info
].s
->sh_num
;
2302 /* update backward link */
2303 s1
->sections
[s
->sh_info
]->reloc
= s
;
2308 /* resolve symbols */
2309 old_to_new_syms
= tcc_mallocz(nb_syms
* sizeof(int));
2312 for(i
= 1; i
< nb_syms
; i
++, sym
++) {
2313 if (sym
->st_shndx
!= SHN_UNDEF
&&
2314 sym
->st_shndx
< SHN_LORESERVE
) {
2315 sm
= &sm_table
[sym
->st_shndx
];
2316 if (sm
->link_once
) {
2317 /* if a symbol is in a link once section, we use the
2318 already defined symbol. It is very important to get
2319 correct relocations */
2320 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
2321 name
= (char *) strtab
+ sym
->st_name
;
2322 sym_index
= find_elf_sym(symtab_section
, name
);
2324 old_to_new_syms
[i
] = sym_index
;
2328 /* if no corresponding section added, no need to add symbol */
2331 /* convert section number */
2332 sym
->st_shndx
= sm
->s
->sh_num
;
2334 sym
->st_value
+= sm
->offset
;
2337 name
= (char *) strtab
+ sym
->st_name
;
2338 sym_index
= set_elf_sym(symtab_section
, sym
->st_value
, sym
->st_size
,
2339 sym
->st_info
, sym
->st_other
,
2340 sym
->st_shndx
, name
);
2341 old_to_new_syms
[i
] = sym_index
;
2344 /* third pass to patch relocation entries */
2345 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2350 offset
= sm_table
[i
].offset
;
2351 switch(s
->sh_type
) {
2353 /* take relocation offset information */
2354 offseti
= sm_table
[sh
->sh_info
].offset
;
2355 for_each_elem(s
, (offset
/ sizeof(*rel
)), rel
, ElfW_Rel
) {
2358 /* convert symbol index */
2359 type
= ELFW(R_TYPE
)(rel
->r_info
);
2360 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
2361 /* NOTE: only one symtab assumed */
2362 if (sym_index
>= nb_syms
)
2364 sym_index
= old_to_new_syms
[sym_index
];
2365 /* ignore link_once in rel section. */
2366 if (!sym_index
&& !sm
->link_once
2367 #ifdef TCC_TARGET_ARM
2368 && type
!= R_ARM_V4BX
2372 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2373 i
, strsec
+ sh
->sh_name
, rel
->r_offset
);
2376 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
2377 /* offset the relocation offset */
2378 rel
->r_offset
+= offseti
;
2379 #ifdef TCC_TARGET_ARM
2380 /* Jumps and branches from a Thumb code to a PLT entry need
2381 special handling since PLT entries are ARM code.
2382 Unconditional bl instructions referencing PLT entries are
2383 handled by converting these instructions into blx
2384 instructions. Other case of instructions referencing a PLT
2385 entry require to add a Thumb stub before the PLT entry to
2386 switch to ARM mode. We set bit plt_thumb_stub of the
2387 attribute of a symbol to indicate such a case. */
2388 if (type
== R_ARM_THM_JUMP24
)
2389 get_sym_attr(s1
, sym_index
, 1)->plt_thumb_stub
= 1;
2402 tcc_free(old_to_new_syms
);
2409 typedef struct ArchiveHeader
{
2410 char ar_name
[16]; /* name of this member */
2411 char ar_date
[12]; /* file mtime */
2412 char ar_uid
[6]; /* owner uid; printed as decimal */
2413 char ar_gid
[6]; /* owner gid; printed as decimal */
2414 char ar_mode
[8]; /* file mode, printed as octal */
2415 char ar_size
[10]; /* file size, printed as decimal */
2416 char ar_fmag
[2]; /* should contain ARFMAG */
2419 static int get_be32(const uint8_t *b
)
2421 return b
[3] | (b
[2] << 8) | (b
[1] << 16) | (b
[0] << 24);
2424 static long get_be64(const uint8_t *b
)
2426 long long ret
= get_be32(b
);
2427 ret
= (ret
<< 32) | (unsigned)get_be32(b
+4);
2431 /* load only the objects which resolve undefined symbols */
2432 static int tcc_load_alacarte(TCCState
*s1
, int fd
, int size
, int entrysize
)
2434 long i
, bound
, nsyms
, sym_index
, off
, ret
;
2436 const char *ar_names
, *p
;
2437 const uint8_t *ar_index
;
2440 data
= tcc_malloc(size
);
2441 if (read(fd
, data
, size
) != size
)
2443 nsyms
= entrysize
== 4 ? get_be32(data
) : get_be64(data
);
2444 ar_index
= data
+ entrysize
;
2445 ar_names
= (char *) ar_index
+ nsyms
* entrysize
;
2449 for(p
= ar_names
, i
= 0; i
< nsyms
; i
++, p
+= strlen(p
)+1) {
2450 sym_index
= find_elf_sym(symtab_section
, p
);
2452 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
2453 if(sym
->st_shndx
== SHN_UNDEF
) {
2454 off
= (entrysize
== 4
2455 ? get_be32(ar_index
+ i
* 4)
2456 : get_be64(ar_index
+ i
* 8))
2457 + sizeof(ArchiveHeader
);
2459 if(tcc_load_object_file(s1
, fd
, off
) < 0) {
2474 /* load a '.a' file */
2475 ST_FUNC
int tcc_load_archive(TCCState
*s1
, int fd
)
2482 unsigned long file_offset
;
2484 /* skip magic which was already checked */
2485 read(fd
, magic
, sizeof(magic
));
2488 len
= read(fd
, &hdr
, sizeof(hdr
));
2491 if (len
!= sizeof(hdr
)) {
2492 tcc_error_noabort("invalid archive");
2495 memcpy(ar_size
, hdr
.ar_size
, sizeof(hdr
.ar_size
));
2496 ar_size
[sizeof(hdr
.ar_size
)] = '\0';
2497 size
= strtol(ar_size
, NULL
, 0);
2498 memcpy(ar_name
, hdr
.ar_name
, sizeof(hdr
.ar_name
));
2499 for(i
= sizeof(hdr
.ar_name
) - 1; i
>= 0; i
--) {
2500 if (ar_name
[i
] != ' ')
2503 ar_name
[i
+ 1] = '\0';
2504 file_offset
= lseek(fd
, 0, SEEK_CUR
);
2506 size
= (size
+ 1) & ~1;
2507 if (!strcmp(ar_name
, "/")) {
2508 /* coff symbol table : we handle it */
2509 if(s1
->alacarte_link
)
2510 return tcc_load_alacarte(s1
, fd
, size
, 4);
2511 } else if (!strcmp(ar_name
, "/SYM64/")) {
2512 if(s1
->alacarte_link
)
2513 return tcc_load_alacarte(s1
, fd
, size
, 8);
2516 if (tcc_object_type(fd
, &ehdr
) == AFF_BINTYPE_REL
) {
2517 if (tcc_load_object_file(s1
, fd
, file_offset
) < 0)
2521 lseek(fd
, file_offset
+ size
, SEEK_SET
);
2526 #ifndef TCC_TARGET_PE
2527 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2528 is referenced by the user (so it should be added as DT_NEEDED in
2529 the generated ELF file) */
2530 ST_FUNC
int tcc_load_dll(TCCState
*s1
, int fd
, const char *filename
, int level
)
2533 ElfW(Shdr
) *shdr
, *sh
, *sh1
;
2534 int i
, j
, nb_syms
, nb_dts
, sym_bind
, ret
;
2535 ElfW(Sym
) *sym
, *dynsym
;
2536 ElfW(Dyn
) *dt
, *dynamic
;
2537 unsigned char *dynstr
;
2538 const char *name
, *soname
;
2539 DLLReference
*dllref
;
2541 read(fd
, &ehdr
, sizeof(ehdr
));
2543 /* test CPU specific stuff */
2544 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2545 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2546 tcc_error_noabort("bad architecture");
2551 shdr
= load_data(fd
, ehdr
.e_shoff
, sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2553 /* load dynamic section and dynamic symbols */
2557 dynsym
= NULL
; /* avoid warning */
2558 dynstr
= NULL
; /* avoid warning */
2559 for(i
= 0, sh
= shdr
; i
< ehdr
.e_shnum
; i
++, sh
++) {
2560 switch(sh
->sh_type
) {
2562 nb_dts
= sh
->sh_size
/ sizeof(ElfW(Dyn
));
2563 dynamic
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2566 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2567 dynsym
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2568 sh1
= &shdr
[sh
->sh_link
];
2569 dynstr
= load_data(fd
, sh1
->sh_offset
, sh1
->sh_size
);
2576 /* compute the real library name */
2577 soname
= tcc_basename(filename
);
2579 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2580 if (dt
->d_tag
== DT_SONAME
) {
2581 soname
= (char *) dynstr
+ dt
->d_un
.d_val
;
2585 /* if the dll is already loaded, do not load it */
2586 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2587 dllref
= s1
->loaded_dlls
[i
];
2588 if (!strcmp(soname
, dllref
->name
)) {
2589 /* but update level if needed */
2590 if (level
< dllref
->level
)
2591 dllref
->level
= level
;
2597 /* add the dll and its level */
2598 dllref
= tcc_mallocz(sizeof(DLLReference
) + strlen(soname
));
2599 dllref
->level
= level
;
2600 strcpy(dllref
->name
, soname
);
2601 dynarray_add(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
, dllref
);
2603 /* add dynamic symbols in dynsym_section */
2604 for(i
= 1, sym
= dynsym
+ 1; i
< nb_syms
; i
++, sym
++) {
2605 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
2606 if (sym_bind
== STB_LOCAL
)
2608 name
= (char *) dynstr
+ sym
->st_name
;
2609 set_elf_sym(s1
->dynsymtab_section
, sym
->st_value
, sym
->st_size
,
2610 sym
->st_info
, sym
->st_other
, sym
->st_shndx
, name
);
2613 /* load all referenced DLLs */
2614 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2617 name
= (char *) dynstr
+ dt
->d_un
.d_val
;
2618 for(j
= 0; j
< s1
->nb_loaded_dlls
; j
++) {
2619 dllref
= s1
->loaded_dlls
[j
];
2620 if (!strcmp(name
, dllref
->name
))
2621 goto already_loaded
;
2623 if (tcc_add_dll(s1
, name
, AFF_REFERENCED_DLL
) < 0) {
2624 tcc_error_noabort("referenced dll '%s' not found", name
);
2641 #define LD_TOK_NAME 256
2642 #define LD_TOK_EOF (-1)
2644 /* return next ld script token */
2645 static int ld_next(TCCState
*s1
, char *name
, int name_size
)
2663 file
->buf_ptr
= parse_comment(file
->buf_ptr
);
2664 ch
= file
->buf_ptr
[0];
2677 /* case 'a' ... 'z': */
2704 /* case 'A' ... 'z': */
2738 if (!((ch
>= 'a' && ch
<= 'z') ||
2739 (ch
>= 'A' && ch
<= 'Z') ||
2740 (ch
>= '0' && ch
<= '9') ||
2741 strchr("/.-_+=$:\\,~", ch
)))
2743 if ((q
- name
) < name_size
- 1) {
2762 static int ld_add_file(TCCState
*s1
, const char filename
[])
2764 if (filename
[0] == '/') {
2765 if (CONFIG_SYSROOT
[0] == '\0'
2766 && tcc_add_file_internal(s1
, filename
, AFF_TYPE_BIN
) == 0)
2768 filename
= tcc_basename(filename
);
2770 return tcc_add_dll(s1
, filename
, 0);
2773 static inline int new_undef_syms(void)
2776 ret
= new_undef_sym
;
2781 static int ld_add_file_list(TCCState
*s1
, const char *cmd
, int as_needed
)
2783 char filename
[1024], libname
[1024];
2784 int t
, group
, nblibs
= 0, ret
= 0;
2787 group
= !strcmp(cmd
, "GROUP");
2790 t
= ld_next(s1
, filename
, sizeof(filename
));
2793 t
= ld_next(s1
, filename
, sizeof(filename
));
2796 if (t
== LD_TOK_EOF
) {
2797 tcc_error_noabort("unexpected end of file");
2799 goto lib_parse_error
;
2800 } else if (t
== ')') {
2802 } else if (t
== '-') {
2803 t
= ld_next(s1
, filename
, sizeof(filename
));
2804 if ((t
!= LD_TOK_NAME
) || (filename
[0] != 'l')) {
2805 tcc_error_noabort("library name expected");
2807 goto lib_parse_error
;
2809 pstrcpy(libname
, sizeof libname
, &filename
[1]);
2810 if (s1
->static_link
) {
2811 snprintf(filename
, sizeof filename
, "lib%s.a", libname
);
2813 snprintf(filename
, sizeof filename
, "lib%s.so", libname
);
2815 } else if (t
!= LD_TOK_NAME
) {
2816 tcc_error_noabort("filename expected");
2818 goto lib_parse_error
;
2820 if (!strcmp(filename
, "AS_NEEDED")) {
2821 ret
= ld_add_file_list(s1
, cmd
, 1);
2823 goto lib_parse_error
;
2825 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2827 ret
= ld_add_file(s1
, filename
);
2829 goto lib_parse_error
;
2831 /* Add the filename *and* the libname to avoid future conversions */
2832 dynarray_add(&libs
, &nblibs
, tcc_strdup(filename
));
2833 if (libname
[0] != '\0')
2834 dynarray_add(&libs
, &nblibs
, tcc_strdup(libname
));
2838 t
= ld_next(s1
, filename
, sizeof(filename
));
2840 t
= ld_next(s1
, filename
, sizeof(filename
));
2843 if (group
&& !as_needed
) {
2844 while (new_undef_syms()) {
2847 for (i
= 0; i
< nblibs
; i
++)
2848 ld_add_file(s1
, libs
[i
]);
2852 dynarray_reset(&libs
, &nblibs
);
2856 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
2858 ST_FUNC
int tcc_load_ldscript(TCCState
*s1
)
2861 char filename
[1024];
2866 t
= ld_next(s1
, cmd
, sizeof(cmd
));
2867 if (t
== LD_TOK_EOF
)
2869 else if (t
!= LD_TOK_NAME
)
2871 if (!strcmp(cmd
, "INPUT") ||
2872 !strcmp(cmd
, "GROUP")) {
2873 ret
= ld_add_file_list(s1
, cmd
, 0);
2876 } else if (!strcmp(cmd
, "OUTPUT_FORMAT") ||
2877 !strcmp(cmd
, "TARGET")) {
2878 /* ignore some commands */
2879 t
= ld_next(s1
, cmd
, sizeof(cmd
));
2883 t
= ld_next(s1
, filename
, sizeof(filename
));
2884 if (t
== LD_TOK_EOF
) {
2885 tcc_error_noabort("unexpected end of file");
2887 } else if (t
== ')') {
2897 #endif /* !TCC_TARGET_PE */