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
*common_section
;
31 ST_DATA Section
*cur_text_section
; /* current section where function code is generated */
33 ST_DATA Section
*last_text_section
; /* to handle .previous asm directive */
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 */
41 ST_DATA Section
*symtab_section
;
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
)
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,
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
,
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
);
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
;
99 put_stabs("", 0, 0, 0, 0);
102 static void free_section(Section
*s
)
107 ST_FUNC
void tccelf_delete(TCCState
*s1
)
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 */
122 for ( i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
123 DLLReference
*ref
= s1
->loaded_dlls
[i
];
126 FreeLibrary((HMODULE
)ref
->handle
);
128 dlclose(ref
->handle
);
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
)
143 for (i
= 1; i
< s1
->nb_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
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
));
192 ST_FUNC Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
)
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
;
207 sec
->sh_addralign
= 4;
210 sec
->sh_addralign
= 1;
213 sec
->sh_addralign
= PTR_SIZE
; /* gcc/pcc default alignment */
217 if (sh_flags
& SHF_PRIVATE
) {
218 dynarray_add(&s1
->priv_sections
, &s1
->nb_priv_sections
, sec
);
220 sec
->sh_num
= s1
->nb_sections
;
221 dynarray_add(&s1
->sections
, &s1
->nb_sections
, 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
);
244 hash
= new_section(s1
, hash_name
, SHT_HASH
, hash_sh_flags
);
245 hash
->sh_entsize
= sizeof(int);
249 ptr
= section_ptr_add(hash
, (2 + nb_buckets
+ 1) * sizeof(int));
252 memset(ptr
+ 2, 0, (nb_buckets
+ 1) * sizeof(int));
256 /* realloc section and set its content to zero */
257 ST_FUNC
void section_realloc(Section
*sec
, unsigned long new_size
)
262 size
= sec
->data_allocated
;
265 while (size
< new_size
)
267 data
= tcc_realloc(sec
->data
, size
);
268 memset(data
+ sec
->data_allocated
, 0, size
- sec
->data_allocated
);
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
;
289 /* reserve at least 'size' bytes in section 'sec' from
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
308 ST_FUNC Section
*find_section(TCCState
*s1
, const char *name
)
312 for(i
= 1; i
< s1
->nb_sections
; i
++) {
313 sec
= s1
->sections
[i
];
314 if (!strcmp(name
, sec
->name
))
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
)
328 len
= strlen(sym
) + 1;
329 offset
= s
->data_offset
;
330 ptr
= section_ptr_add(s
, len
);
331 memmove(ptr
, sym
, len
);
335 /* elf symbol hashing function */
336 static unsigned long elf_hash(const unsigned char *name
)
338 unsigned long h
= 0, g
;
341 h
= (h
<< 4) + *name
++;
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
)
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
));
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));
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
;
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
;
396 sym
= section_ptr_add(s
, sizeof(ElfW(Sym
)));
398 name_offset
= put_elf_str(s
->link
, name
);
401 /* XXX: endianness */
402 sym
->st_name
= name_offset
;
403 sym
->st_value
= value
;
406 sym
->st_other
= other
;
407 sym
->st_shndx
= shndx
;
408 sym_index
= sym
- (ElfW(Sym
) *)s
->data
;
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 */
418 h
= elf_hash((unsigned char *)s
->link
->data
+ name_offset
) % nbuckets
;
420 base
[2 + h
] = sym_index
;
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
);
435 ST_FUNC
int find_elf_sym(Section
*s
, const char *name
)
439 int nbuckets
, sym_index
, h
;
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
))
453 sym_index
= ((int *)hs
->data
)[2 + nbuckets
+ sym_index
];
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
)
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
) {
468 tcc_error("%s not defined", name
);
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);
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
)
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
);
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
)
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
) {
517 } else if (sym_vis
== STV_DEFAULT
) {
520 new_vis
= (esym_vis
< sym_vis
) ? esym_vis
: sym_vis
;
522 esym
->st_other
= (esym
->st_other
& ~ELFW(ST_VISIBILITY
)(-1))
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 */
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 */
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
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
);
556 tcc_error_noabort("'%s' defined twice", name
);
560 esym
->st_info
= ELFW(ST_INFO
)(sym_bind
, sym_type
);
561 esym
->st_shndx
= shndx
;
563 esym
->st_value
= value
;
564 esym
->st_size
= size
;
565 esym
->st_other
= other
;
569 sym_index
= put_elf_sym(s
, value
, size
,
570 ELFW(ST_INFO
)(sym_bind
, sym_type
), other
,
577 ST_FUNC
void put_elf_reloca(Section
*symtab
, Section
*s
, unsigned long offset
,
578 int type
, int symbol
, addr_t addend
)
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
590 sr
= new_section(tcc_state
, buf
, SHT_RELX
, symtab
->sh_flags
);
591 sr
->sh_entsize
= sizeof(ElfW_Rel
);
593 sr
->sh_info
= s
->sh_num
;
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
;
603 tcc_error("non-zero addend on REL architecture");
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
;
623 if (oldrelocoffset
+ sizeof(*r
) >= sr
->data_offset
)
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
);
642 for (; r
< (ElfW_Rel
*)(sr
->data
+ sr
->data_offset
); r
++) {
643 if (dest
->r_offset
!= r
->r_offset
)
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
,
657 sym
= section_ptr_add(stab_section
, sizeof(Stab_Sym
));
659 sym
->n_strx
= put_elf_str(stabstr_section
, str
);
664 sym
->n_other
= other
;
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
)
691 struct sym_attr
*tab
;
693 if (index
>= s1
->nb_sym_attrs
) {
695 return s1
->sym_attrs
;
696 /* find immediately bigger power of 2 and reallocate array */
700 tab
= tcc_realloc(s1
->sym_attrs
, n
* sizeof(*s1
->sym_attrs
));
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
;
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
;
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
;
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
;
757 /* we copy the new symbols to the old */
758 memcpy(s
->data
, new_syms
, nb_syms
* sizeof(ElfW(Sym
)));
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
)
782 int sym_bind
, sh_num
;
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) */
791 #if defined TCC_IS_NATIVE && !defined TCC_TARGET_PE
792 void *addr
= dlsym(RTLD_DEFAULT
, name
);
794 sym
->st_value
= (addr_t
) addr
;
796 printf ("relocate_sym: %s -> 0x%lx\n", name
, sym
->st_value
);
801 /* if dynamic symbol exist, it will be used in relocate_section */
802 } else if (s1
->dynsym
&& find_elf_sym(s1
->dynsym
, name
))
804 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
806 if (!strcmp(name
, "_fp_hw"))
808 /* only weak symbols are accepted to be undefined. Their
810 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
811 if (sym_bind
== STB_WEAK
)
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
;
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
;
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
);
842 #if SHT_RELX == SHT_RELA
843 tgt
+= rel
->r_addend
;
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
)
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
866 static int prepare_dynamic_rel(TCCState
*s1
, Section
*sr
)
872 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
873 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
874 int sym_index
= ELFW(R_SYM
)(rel
->r_info
);
876 type
= ELFW(R_TYPE
)(rel
->r_info
);
878 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
879 #if defined(TCC_TARGET_I386)
881 if (!get_sym_attr(s1
, sym_index
, 0)->dyn_index
882 && ((ElfW(Sym
)*)symtab_section
->data
+ sym_index
)->st_shndx
== SHN_UNDEF
) {
883 /* don't fixup unresolved (weak) symbols */
884 rel
->r_info
= ELFW(R_INFO
)(sym_index
, R_386_RELATIVE
);
887 #elif defined(TCC_TARGET_X86_64)
894 #if defined(TCC_TARGET_I386)
896 #elif defined(TCC_TARGET_X86_64)
899 if (get_sym_attr(s1
, sym_index
, 0)->dyn_index
)
908 /* allocate the section */
909 sr
->sh_flags
|= SHF_ALLOC
;
910 sr
->sh_size
= count
* sizeof(ElfW_Rel
);
915 static void build_got(TCCState
*s1
)
917 /* if no got, then create it */
918 s1
->got
= new_section(s1
, ".got", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
919 s1
->got
->sh_entsize
= 4;
920 set_elf_sym(symtab_section
, 0, 4, ELFW(ST_INFO
)(STB_GLOBAL
, STT_OBJECT
),
921 0, s1
->got
->sh_num
, "_GLOBAL_OFFSET_TABLE_");
922 /* keep space for _DYNAMIC pointer and two dummy got entries */
923 section_ptr_add(s1
->got
, 3 * PTR_SIZE
);
926 /* Create a GOT and (for function call) a PLT entry corresponding to a symbol
927 in s1->symtab. When creating the dynamic symbol table entry for the GOT
928 relocation, use 'size' and 'info' for the corresponding symbol metadata.
929 Returns the offset of the GOT or (if any) PLT entry. */
930 static struct sym_attr
* put_got_entry(TCCState
*s1
, int dyn_reloc_type
,
936 struct sym_attr
*attr
;
941 need_plt_entry
= (dyn_reloc_type
== R_JMP_SLOT
);
942 attr
= get_sym_attr(s1
, sym_index
, 1);
944 /* In case a function is both called and its address taken 2 GOT entries
945 are created, one for taking the address (GOT) and the other for the PLT
947 if (need_plt_entry
? attr
->plt_offset
: attr
->got_offset
)
950 /* create the GOT entry */
951 got_offset
= s1
->got
->data_offset
;
952 section_ptr_add(s1
->got
, PTR_SIZE
);
954 /* Create the GOT relocation that will insert the address of the object or
955 function of interest in the GOT entry. This is a static relocation for
956 memory output (dlsym will give us the address of symbols) and dynamic
957 relocation otherwise (executable and DLLs). The relocation should be
958 done lazily for GOT entry with *_JUMP_SLOT relocation type (the one
959 associated to a PLT entry) but is currently done at load time for an
962 sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
963 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
966 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_LOCAL
) {
967 /* Hack alarm. We don't want to emit dynamic symbols
968 and symbol based relocs for STB_LOCAL symbols, but rather
969 want to resolve them directly. At this point the symbol
970 values aren't final yet, so we must defer this. We will later
971 have to create a RELATIVE reloc anyway, so we misuse the
972 relocation slot to smuggle the symbol reference until
973 fill_local_got_entries. Not that the sym_index is
974 relative to symtab_section, not s1->dynsym! Nevertheless
975 we use s1->dyn_sym so that if this is the first call
976 that got->reloc is correctly created. Also note that
977 RELATIVE relocs are not normally created for the .got,
978 so the types serves as a marker for later (and is retained
979 also for the final output, which is okay because then the
980 got is just normal data). */
981 put_elf_reloc(s1
->dynsym
, s1
->got
, got_offset
, R_RELATIVE
,
984 if (0 == attr
->dyn_index
)
985 attr
->dyn_index
= set_elf_sym(s1
->dynsym
, sym
->st_value
,
986 sym
->st_size
, sym
->st_info
, 0,
987 sym
->st_shndx
, name
);
988 put_elf_reloc(s1
->dynsym
, s1
->got
, got_offset
, dyn_reloc_type
,
992 put_elf_reloc(symtab_section
, s1
->got
, got_offset
, dyn_reloc_type
,
996 if (need_plt_entry
) {
998 s1
->plt
= new_section(s1
, ".plt", SHT_PROGBITS
,
999 SHF_ALLOC
| SHF_EXECINSTR
);
1000 s1
->plt
->sh_entsize
= 4;
1003 attr
->plt_offset
= create_plt_entry(s1
, got_offset
, attr
);
1005 /* create a symbol 'sym@plt' for the PLT jump vector */
1007 if (len
> sizeof plt_name
- 5)
1008 len
= sizeof plt_name
- 5;
1009 memcpy(plt_name
, name
, len
);
1010 strcpy(plt_name
+ len
, "@plt");
1011 attr
->plt_sym
= put_elf_sym(s1
->symtab
, attr
->plt_offset
, sym
->st_size
,
1012 ELFW(ST_INFO
)(STB_GLOBAL
, STT_FUNC
), 0, s1
->plt
->sh_num
, plt_name
);
1015 attr
->got_offset
= got_offset
;
1021 /* build GOT and PLT entries */
1022 ST_FUNC
void build_got_entries(TCCState
*s1
)
1027 int i
, type
, gotplt_entry
, reloc_type
, sym_index
;
1028 struct sym_attr
*attr
;
1030 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1031 s
= s1
->sections
[i
];
1032 if (s
->sh_type
!= SHT_RELX
)
1034 /* no need to handle got relocations */
1035 if (s
->link
!= symtab_section
)
1037 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1038 type
= ELFW(R_TYPE
)(rel
->r_info
);
1039 gotplt_entry
= gotplt_entry_type(type
);
1040 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1041 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1043 if (gotplt_entry
== NO_GOTPLT_ENTRY
) {
1047 /* Automatically create PLT/GOT [entry] if it is an undefined
1048 reference (resolved at runtime), or the symbol is absolute,
1049 probably created by tcc_add_symbol, and thus on 64-bit
1050 targets might be too far from application code. */
1051 if (gotplt_entry
== AUTO_GOTPLT_ENTRY
) {
1052 if (sym
->st_shndx
== SHN_UNDEF
) {
1055 if (s1
->output_type
== TCC_OUTPUT_DLL
&& ! PCRELATIVE_DLLPLT
)
1057 /* Relocations for UNDEF symbols would normally need
1058 to be transferred into the executable or shared object.
1059 If that were done AUTO_GOTPLT_ENTRY wouldn't exist.
1060 But TCC doesn't do that (at least for exes), so we
1061 need to resolve all such relocs locally. And that
1062 means PLT slots for functions in DLLs and COPY relocs for
1063 data symbols. COPY relocs were generated in
1064 bind_exe_dynsyms (and the symbol adjusted to be defined),
1065 and for functions we were generated a dynamic symbol
1066 of function type. */
1068 /* dynsym isn't set for -run :-/ */
1069 dynindex
= get_sym_attr(s1
, sym_index
, 0)->dyn_index
;
1070 esym
= (ElfW(Sym
) *)s1
->dynsym
->data
+ dynindex
;
1072 && (ELFW(ST_TYPE
)(esym
->st_info
) == STT_FUNC
1073 || (ELFW(ST_TYPE
)(esym
->st_info
) == STT_NOTYPE
1074 && ELFW(ST_TYPE
)(sym
->st_info
) == STT_FUNC
)))
1077 } else if (!(sym
->st_shndx
== SHN_ABS
1078 #ifndef TCC_TARGET_ARM
1085 #ifdef TCC_TARGET_X86_64
1086 if ((type
== R_X86_64_PLT32
|| type
== R_X86_64_PC32
) &&
1087 sym
->st_shndx
!= SHN_UNDEF
&&
1088 (ELFW(ST_VISIBILITY
)(sym
->st_other
) != STV_DEFAULT
||
1089 ELFW(ST_BIND
)(sym
->st_info
) == STB_LOCAL
||
1090 s1
->output_type
== TCC_OUTPUT_EXE
)) {
1091 rel
->r_info
= ELFW(R_INFO
)(sym_index
, R_X86_64_PC32
);
1095 if (code_reloc(type
)) {
1097 reloc_type
= R_JMP_SLOT
;
1099 reloc_type
= R_GLOB_DAT
;
1104 if (gotplt_entry
== BUILD_GOT_ONLY
)
1107 attr
= put_got_entry(s1
, reloc_type
, sym_index
);
1109 if (reloc_type
== R_JMP_SLOT
)
1110 rel
->r_info
= ELFW(R_INFO
)(attr
->plt_sym
, type
);
1115 /* put dynamic tag */
1116 static void put_dt(Section
*dynamic
, int dt
, addr_t val
)
1119 dyn
= section_ptr_add(dynamic
, sizeof(ElfW(Dyn
)));
1121 dyn
->d_un
.d_val
= val
;
1124 #ifndef TCC_TARGET_PE
1125 static void add_init_array_defines(TCCState
*s1
, const char *section_name
)
1129 char sym_start
[1024];
1132 snprintf(sym_start
, sizeof(sym_start
), "__%s_start", section_name
+ 1);
1133 snprintf(sym_end
, sizeof(sym_end
), "__%s_end", section_name
+ 1);
1135 s
= find_section(s1
, section_name
);
1140 end_offset
= s
->data_offset
;
1143 set_elf_sym(symtab_section
,
1145 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1146 s
->sh_num
, sym_start
);
1147 set_elf_sym(symtab_section
,
1149 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1150 s
->sh_num
, sym_end
);
1153 static int tcc_add_support(TCCState
*s1
, const char *filename
)
1156 snprintf(buf
, sizeof(buf
), "%s/%s", s1
->tcc_lib_path
, filename
);
1157 return tcc_add_file(s1
, buf
);
1161 ST_FUNC
void tcc_add_bcheck(TCCState
*s1
)
1163 #ifdef CONFIG_TCC_BCHECK
1167 if (0 == s1
->do_bounds_check
)
1169 /* XXX: add an object file to do that */
1170 ptr
= section_ptr_add(bounds_section
, sizeof(*ptr
));
1172 set_elf_sym(symtab_section
, 0, 0,
1173 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1174 bounds_section
->sh_num
, "__bounds_start");
1175 /* pull bcheck.o from libtcc1.a */
1176 sym_index
= set_elf_sym(symtab_section
, 0, 0,
1177 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1178 SHN_UNDEF
, "__bound_init");
1179 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
) {
1180 /* add 'call __bound_init()' in .init section */
1181 Section
*init_section
= find_section(s1
, ".init");
1182 unsigned char *pinit
= section_ptr_add(init_section
, 5);
1184 write32le(pinit
+ 1, -4);
1185 put_elf_reloc(symtab_section
, init_section
,
1186 init_section
->data_offset
- 4, R_386_PC32
, sym_index
);
1187 /* R_386_PC32 = R_X86_64_PC32 = 2 */
1192 /* add tcc runtime libraries */
1193 ST_FUNC
void tcc_add_runtime(TCCState
*s1
)
1197 tcc_add_pragma_libs(s1
);
1198 #ifndef TCC_TARGET_PE
1200 if (!s1
->nostdlib
) {
1201 tcc_add_library_err(s1
, "c");
1203 if (!s1
->static_link
) {
1204 if (TCC_LIBGCC
[0] == '/')
1205 tcc_add_file(s1
, TCC_LIBGCC
);
1207 tcc_add_dll(s1
, TCC_LIBGCC
, 0);
1210 tcc_add_support(s1
, TCC_LIBTCC1
);
1211 /* add crt end if not memory output */
1212 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
)
1213 tcc_add_crt(s1
, "crtn.o");
1218 /* add various standard linker symbols (must be done after the
1219 sections are filled (for example after allocating common
1221 static void tcc_add_linker_symbols(TCCState
*s1
)
1227 set_elf_sym(symtab_section
,
1228 text_section
->data_offset
, 0,
1229 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1230 text_section
->sh_num
, "_etext");
1231 set_elf_sym(symtab_section
,
1232 data_section
->data_offset
, 0,
1233 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1234 data_section
->sh_num
, "_edata");
1235 set_elf_sym(symtab_section
,
1236 bss_section
->data_offset
, 0,
1237 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1238 bss_section
->sh_num
, "_end");
1239 #ifndef TCC_TARGET_PE
1240 /* horrible new standard ldscript defines */
1241 add_init_array_defines(s1
, ".preinit_array");
1242 add_init_array_defines(s1
, ".init_array");
1243 add_init_array_defines(s1
, ".fini_array");
1246 /* add start and stop symbols for sections whose name can be
1248 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1249 s
= s1
->sections
[i
];
1250 if (s
->sh_type
== SHT_PROGBITS
&&
1251 (s
->sh_flags
& SHF_ALLOC
)) {
1255 /* check if section name can be expressed in C */
1261 if (!isid(ch
) && !isnum(ch
))
1265 snprintf(buf
, sizeof(buf
), "__start_%s", s
->name
);
1266 set_elf_sym(symtab_section
,
1268 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1270 snprintf(buf
, sizeof(buf
), "__stop_%s", s
->name
);
1271 set_elf_sym(symtab_section
,
1273 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1280 ST_FUNC
void resolve_common_syms(TCCState
*s1
)
1284 /* Allocate common symbols in BSS. */
1285 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1286 if (sym
->st_shndx
== SHN_COMMON
) {
1287 /* symbol alignment is in st_value for SHN_COMMONs */
1288 sym
->st_value
= section_add(bss_section
, sym
->st_size
,
1290 sym
->st_shndx
= bss_section
->sh_num
;
1294 /* Now assign linker provided symbols their value. */
1295 tcc_add_linker_symbols(s1
);
1298 static void tcc_output_binary(TCCState
*s1
, FILE *f
,
1299 const int *sec_order
)
1302 int i
, offset
, size
;
1305 for(i
=1;i
<s1
->nb_sections
;i
++) {
1306 s
= s1
->sections
[sec_order
[i
]];
1307 if (s
->sh_type
!= SHT_NOBITS
&&
1308 (s
->sh_flags
& SHF_ALLOC
)) {
1309 while (offset
< s
->sh_offset
) {
1314 fwrite(s
->data
, 1, size
, f
);
1320 ST_FUNC
void fill_got_entry(TCCState
*s1
, ElfW_Rel
*rel
)
1322 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1323 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1324 struct sym_attr
*attr
= get_sym_attr(s1
, sym_index
, 0);
1325 unsigned offset
= attr
->got_offset
;
1329 section_reserve(s1
->got
, offset
+ PTR_SIZE
);
1330 #ifdef TCC_TARGET_X86_64
1331 write64le(s1
->got
->data
+ offset
, sym
->st_value
);
1333 write32le(s1
->got
->data
+ offset
, sym
->st_value
);
1337 /* Perform relocation to GOT or PLT entries */
1338 ST_FUNC
void fill_got(TCCState
*s1
)
1344 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1345 s
= s1
->sections
[i
];
1346 if (s
->sh_type
!= SHT_RELX
)
1348 /* no need to handle got relocations */
1349 if (s
->link
!= symtab_section
)
1351 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1352 switch (ELFW(R_TYPE
) (rel
->r_info
)) {
1353 case R_X86_64_GOT32
:
1354 case R_X86_64_GOTPCREL
:
1355 case R_X86_64_GOTPCRELX
:
1356 case R_X86_64_REX_GOTPCRELX
:
1357 case R_X86_64_PLT32
:
1358 fill_got_entry(s1
, rel
);
1365 /* See put_got_entry for a description. This is the second stage
1366 where GOT references to local defined symbols are rewritten. */
1367 static void fill_local_got_entries(TCCState
*s1
)
1370 if (!s1
->got
->reloc
)
1372 for_each_elem(s1
->got
->reloc
, 0, rel
, ElfW_Rel
) {
1373 if (ELFW(R_TYPE
)(rel
->r_info
) == R_RELATIVE
) {
1374 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1375 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1376 struct sym_attr
*attr
= get_sym_attr(s1
, sym_index
, 0);
1377 unsigned offset
= attr
->got_offset
;
1378 if (offset
!= rel
->r_offset
- s1
->got
->sh_addr
)
1379 tcc_error_noabort("huh");
1380 rel
->r_info
= ELFW(R_INFO
)(0, R_RELATIVE
);
1381 #if SHT_RELX == SHT_RELA
1382 rel
->r_addend
= sym
->st_value
;
1384 /* All our REL architectures also happen to be 32bit LE. */
1385 write32le(s1
->got
->data
+ offset
, sym
->st_value
);
1391 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1392 in shared libraries and export non local defined symbols to shared libraries
1393 if -rdynamic switch was given on command line */
1394 static void bind_exe_dynsyms(TCCState
*s1
)
1397 int sym_index
, index
;
1398 ElfW(Sym
) *sym
, *esym
;
1401 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1402 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1403 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1404 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1405 if (sym
->st_shndx
== SHN_UNDEF
) {
1406 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1407 sym_index
= find_elf_sym(s1
->dynsymtab_section
, name
);
1409 esym
= &((ElfW(Sym
) *)s1
->dynsymtab_section
->data
)[sym_index
];
1410 type
= ELFW(ST_TYPE
)(esym
->st_info
);
1411 if ((type
== STT_FUNC
) || (type
== STT_GNU_IFUNC
)) {
1412 /* Indirect functions shall have STT_FUNC type in executable
1413 * dynsym section. Indeed, a dlsym call following a lazy
1414 * resolution would pick the symbol value from the
1415 * executable dynsym entry which would contain the address
1416 * of the function wanted by the caller of dlsym instead of
1417 * the address of the function that would return that
1420 = put_elf_sym(s1
->dynsym
, 0, esym
->st_size
,
1421 ELFW(ST_INFO
)(STB_GLOBAL
,STT_FUNC
), 0, 0,
1423 int index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1424 get_sym_attr(s1
, index
, 1)->dyn_index
= dynindex
;
1425 } else if (type
== STT_OBJECT
) {
1426 unsigned long offset
;
1428 offset
= bss_section
->data_offset
;
1429 /* XXX: which alignment ? */
1430 offset
= (offset
+ 16 - 1) & -16;
1431 set_elf_sym (s1
->symtab
, offset
, esym
->st_size
,
1432 esym
->st_info
, 0, bss_section
->sh_num
, name
);
1433 index
= put_elf_sym(s1
->dynsym
, offset
, esym
->st_size
,
1434 esym
->st_info
, 0, bss_section
->sh_num
,
1437 /* Ensure R_COPY works for weak symbol aliases */
1438 if (ELFW(ST_BIND
)(esym
->st_info
) == STB_WEAK
) {
1439 for_each_elem(s1
->dynsymtab_section
, 1, dynsym
, ElfW(Sym
)) {
1440 if ((dynsym
->st_value
== esym
->st_value
)
1441 && (ELFW(ST_BIND
)(dynsym
->st_info
) == STB_GLOBAL
)) {
1442 char *dynname
= (char *) s1
->dynsymtab_section
->link
->data
1444 put_elf_sym(s1
->dynsym
, offset
, dynsym
->st_size
,
1446 bss_section
->sh_num
, dynname
);
1452 put_elf_reloc(s1
->dynsym
, bss_section
,
1453 offset
, R_COPY
, index
);
1454 offset
+= esym
->st_size
;
1455 bss_section
->data_offset
= offset
;
1458 /* STB_WEAK undefined symbols are accepted */
1459 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1460 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
||
1461 !strcmp(name
, "_fp_hw")) {
1463 tcc_error_noabort("undefined symbol '%s'", name
);
1466 } else if (s1
->rdynamic
&& ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1467 /* if -rdynamic option, then export all non local symbols */
1468 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1469 set_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1470 0, sym
->st_shndx
, name
);
1475 /* Bind symbols of libraries: export all non local symbols of executable that
1476 are referenced by shared libraries. The reason is that the dynamic loader
1477 search symbol first in executable and then in libraries. Therefore a
1478 reference to a symbol already defined by a library can still be resolved by
1479 a symbol in the executable. */
1480 static void bind_libs_dynsyms(TCCState
*s1
)
1484 ElfW(Sym
) *sym
, *esym
;
1486 for_each_elem(s1
->dynsymtab_section
, 1, esym
, ElfW(Sym
)) {
1487 name
= (char *) s1
->dynsymtab_section
->link
->data
+ esym
->st_name
;
1488 sym_index
= find_elf_sym(symtab_section
, name
);
1489 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1490 if (sym_index
&& sym
->st_shndx
!= SHN_UNDEF
1491 && ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1492 set_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1493 sym
->st_info
, 0, sym
->st_shndx
, name
);
1494 } else if (esym
->st_shndx
== SHN_UNDEF
) {
1495 /* weak symbols can stay undefined */
1496 if (ELFW(ST_BIND
)(esym
->st_info
) != STB_WEAK
)
1497 tcc_warning("undefined dynamic symbol '%s'", name
);
1502 /* Export all non local symbols. This is used by shared libraries so that the
1503 non local symbols they define can resolve a reference in another shared
1504 library or in the executable. Correspondingly, it allows undefined local
1505 symbols to be resolved by other shared libraries or by the executable. */
1506 static void export_global_syms(TCCState
*s1
)
1508 int dynindex
, index
;
1512 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1513 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1514 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1515 dynindex
= put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1516 sym
->st_info
, 0, sym
->st_shndx
, name
);
1517 index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1518 get_sym_attr(s1
, index
, 1)->dyn_index
= dynindex
;
1523 /* Allocate strings for section names and decide if an unallocated section
1525 NOTE: the strsec section comes last, so its size is also correct ! */
1526 static int alloc_sec_names(TCCState
*s1
, int file_type
, Section
*strsec
)
1532 /* Allocate strings for section names */
1533 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1534 s
= s1
->sections
[i
];
1535 /* when generating a DLL, we include relocations but we may
1537 if (file_type
== TCC_OUTPUT_DLL
&&
1538 s
->sh_type
== SHT_RELX
&&
1539 !(s
->sh_flags
& SHF_ALLOC
) &&
1540 (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_ALLOC
) &&
1541 prepare_dynamic_rel(s1
, s
)) {
1542 if (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_EXECINSTR
)
1544 } else if ((s1
->do_debug
&& s
->sh_type
!= SHT_RELX
) ||
1545 file_type
== TCC_OUTPUT_OBJ
||
1546 (s
->sh_flags
& SHF_ALLOC
) ||
1547 i
== (s1
->nb_sections
- 1)) {
1548 /* we output all sections if debug or object file */
1549 s
->sh_size
= s
->data_offset
;
1551 if (s
->sh_size
|| (s
->sh_flags
& SHF_ALLOC
))
1552 s
->sh_name
= put_elf_str(strsec
, s
->name
);
1554 strsec
->sh_size
= strsec
->data_offset
;
1558 /* Info to be copied in dynamic section */
1562 unsigned long data_offset
;
1565 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1571 /* Assign sections to segments and decide how are sections laid out when loaded
1572 in memory. This function also fills corresponding program headers. */
1573 static int layout_sections(TCCState
*s1
, ElfW(Phdr
) *phdr
, int phnum
,
1574 Section
*interp
, Section
* strsec
,
1575 struct dyn_inf
*dyninf
, int *sec_order
)
1577 int i
, j
, k
, file_type
, sh_order_index
, file_offset
;
1578 unsigned long s_align
;
1584 file_type
= s1
->output_type
;
1587 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
1588 file_offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1589 s_align
= ELF_PAGE_SIZE
;
1590 if (s1
->section_align
)
1591 s_align
= s1
->section_align
;
1594 if (s1
->has_text_addr
) {
1595 int a_offset
, p_offset
;
1596 addr
= s1
->text_addr
;
1597 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1599 a_offset
= (int) (addr
& (s_align
- 1));
1600 p_offset
= file_offset
& (s_align
- 1);
1601 if (a_offset
< p_offset
)
1602 a_offset
+= s_align
;
1603 file_offset
+= (a_offset
- p_offset
);
1605 if (file_type
== TCC_OUTPUT_DLL
)
1608 addr
= ELF_START_ADDR
;
1609 /* compute address after headers */
1610 addr
+= (file_offset
& (s_align
- 1));
1614 /* Leave one program headers for the program interpreter and one for
1615 the program header table itself if needed. These are done later as
1616 they require section layout to be done first. */
1620 /* dynamic relocation table information, for .dynamic section */
1621 dyninf
->rel_addr
= dyninf
->rel_size
= 0;
1622 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1623 dyninf
->bss_addr
= dyninf
->bss_size
= 0;
1626 for(j
= 0; j
< 2; j
++) {
1627 ph
->p_type
= PT_LOAD
;
1629 ph
->p_flags
= PF_R
| PF_X
;
1631 ph
->p_flags
= PF_R
| PF_W
;
1632 ph
->p_align
= s_align
;
1634 /* Decide the layout of sections loaded in memory. This must
1635 be done before program headers are filled since they contain
1636 info about the layout. We do the following ordering: interp,
1637 symbol tables, relocations, progbits, nobits */
1638 /* XXX: do faster and simpler sorting */
1639 for(k
= 0; k
< 5; k
++) {
1640 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1641 s
= s1
->sections
[i
];
1642 /* compute if section should be included */
1644 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1648 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1649 (SHF_ALLOC
| SHF_WRITE
))
1655 } else if (s
->sh_type
== SHT_DYNSYM
||
1656 s
->sh_type
== SHT_STRTAB
||
1657 s
->sh_type
== SHT_HASH
) {
1660 } else if (s
->sh_type
== SHT_RELX
) {
1663 } else if (s
->sh_type
== SHT_NOBITS
) {
1670 sec_order
[sh_order_index
++] = i
;
1672 /* section matches: we align it and add its size */
1674 addr
= (addr
+ s
->sh_addralign
- 1) &
1675 ~(s
->sh_addralign
- 1);
1676 file_offset
+= (int) ( addr
- tmp
);
1677 s
->sh_offset
= file_offset
;
1680 /* update program header infos */
1681 if (ph
->p_offset
== 0) {
1682 ph
->p_offset
= file_offset
;
1684 ph
->p_paddr
= ph
->p_vaddr
;
1686 /* update dynamic relocation infos */
1687 if (s
->sh_type
== SHT_RELX
) {
1688 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1689 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.got")) {
1690 dyninf
->rel_addr
= addr
;
1691 dyninf
->rel_size
+= s
->sh_size
; /* XXX only first rel. */
1693 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.bss")) {
1694 dyninf
->bss_addr
= addr
;
1695 dyninf
->bss_size
= s
->sh_size
; /* XXX only first rel. */
1698 if (dyninf
->rel_size
== 0)
1699 dyninf
->rel_addr
= addr
;
1700 dyninf
->rel_size
+= s
->sh_size
;
1704 if (s
->sh_type
!= SHT_NOBITS
)
1705 file_offset
+= s
->sh_size
;
1709 /* Make the first PT_LOAD segment include the program
1710 headers itself (and the ELF header as well), it'll
1711 come out with same memory use but will make various
1712 tools like binutils strip work better. */
1713 ph
->p_offset
&= ~(ph
->p_align
- 1);
1714 ph
->p_vaddr
&= ~(ph
->p_align
- 1);
1715 ph
->p_paddr
&= ~(ph
->p_align
- 1);
1717 ph
->p_filesz
= file_offset
- ph
->p_offset
;
1718 ph
->p_memsz
= addr
- ph
->p_vaddr
;
1721 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
) {
1722 /* if in the middle of a page, we duplicate the page in
1723 memory so that one copy is RX and the other is RW */
1724 if ((addr
& (s_align
- 1)) != 0)
1727 addr
= (addr
+ s_align
- 1) & ~(s_align
- 1);
1728 file_offset
= (file_offset
+ s_align
- 1) & ~(s_align
- 1);
1734 /* all other sections come after */
1735 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1736 s
= s1
->sections
[i
];
1737 if (phnum
> 0 && (s
->sh_flags
& SHF_ALLOC
))
1739 sec_order
[sh_order_index
++] = i
;
1741 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
1742 ~(s
->sh_addralign
- 1);
1743 s
->sh_offset
= file_offset
;
1744 if (s
->sh_type
!= SHT_NOBITS
)
1745 file_offset
+= s
->sh_size
;
1751 static void fill_unloadable_phdr(ElfW(Phdr
) *phdr
, int phnum
, Section
*interp
,
1756 /* if interpreter, then add corresponding program header */
1760 ph
->p_type
= PT_PHDR
;
1761 ph
->p_offset
= sizeof(ElfW(Ehdr
));
1762 ph
->p_filesz
= ph
->p_memsz
= phnum
* sizeof(ElfW(Phdr
));
1763 ph
->p_vaddr
= interp
->sh_addr
- ph
->p_filesz
;
1764 ph
->p_paddr
= ph
->p_vaddr
;
1765 ph
->p_flags
= PF_R
| PF_X
;
1766 ph
->p_align
= 4; /* interp->sh_addralign; */
1769 ph
->p_type
= PT_INTERP
;
1770 ph
->p_offset
= interp
->sh_offset
;
1771 ph
->p_vaddr
= interp
->sh_addr
;
1772 ph
->p_paddr
= ph
->p_vaddr
;
1773 ph
->p_filesz
= interp
->sh_size
;
1774 ph
->p_memsz
= interp
->sh_size
;
1776 ph
->p_align
= interp
->sh_addralign
;
1779 /* if dynamic section, then add corresponding program header */
1781 ph
= &phdr
[phnum
- 1];
1783 ph
->p_type
= PT_DYNAMIC
;
1784 ph
->p_offset
= dynamic
->sh_offset
;
1785 ph
->p_vaddr
= dynamic
->sh_addr
;
1786 ph
->p_paddr
= ph
->p_vaddr
;
1787 ph
->p_filesz
= dynamic
->sh_size
;
1788 ph
->p_memsz
= dynamic
->sh_size
;
1789 ph
->p_flags
= PF_R
| PF_W
;
1790 ph
->p_align
= dynamic
->sh_addralign
;
1794 /* Fill the dynamic section with tags describing the address and size of
1796 static void fill_dynamic(TCCState
*s1
, struct dyn_inf
*dyninf
)
1798 Section
*dynamic
= dyninf
->dynamic
;
1800 /* put dynamic section entries */
1801 put_dt(dynamic
, DT_HASH
, s1
->dynsym
->hash
->sh_addr
);
1802 put_dt(dynamic
, DT_STRTAB
, dyninf
->dynstr
->sh_addr
);
1803 put_dt(dynamic
, DT_SYMTAB
, s1
->dynsym
->sh_addr
);
1804 put_dt(dynamic
, DT_STRSZ
, dyninf
->dynstr
->data_offset
);
1805 put_dt(dynamic
, DT_SYMENT
, sizeof(ElfW(Sym
)));
1807 put_dt(dynamic
, DT_RELA
, dyninf
->rel_addr
);
1808 put_dt(dynamic
, DT_RELASZ
, dyninf
->rel_size
);
1809 put_dt(dynamic
, DT_RELAENT
, sizeof(ElfW_Rel
));
1811 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1812 put_dt(dynamic
, DT_PLTGOT
, s1
->got
->sh_addr
);
1813 put_dt(dynamic
, DT_PLTRELSZ
, dyninf
->rel_size
);
1814 put_dt(dynamic
, DT_JMPREL
, dyninf
->rel_addr
);
1815 put_dt(dynamic
, DT_PLTREL
, DT_REL
);
1816 put_dt(dynamic
, DT_REL
, dyninf
->bss_addr
);
1817 put_dt(dynamic
, DT_RELSZ
, dyninf
->bss_size
);
1819 put_dt(dynamic
, DT_REL
, dyninf
->rel_addr
);
1820 put_dt(dynamic
, DT_RELSZ
, dyninf
->rel_size
);
1821 put_dt(dynamic
, DT_RELENT
, sizeof(ElfW_Rel
));
1825 put_dt(dynamic
, DT_DEBUG
, 0);
1826 put_dt(dynamic
, DT_NULL
, 0);
1829 /* Relocate remaining sections and symbols (that is those not related to
1831 static int final_sections_reloc(TCCState
*s1
)
1836 relocate_syms(s1
, s1
->symtab
, 0);
1838 if (s1
->nb_errors
!= 0)
1841 /* relocate sections */
1842 /* XXX: ignore sections with allocated relocations ? */
1843 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1844 s
= s1
->sections
[i
];
1845 if (s
->reloc
&& (s
!= s1
->got
|| s1
->static_link
))
1846 relocate_section(s1
, s
);
1849 /* relocate relocation entries if the relocation tables are
1850 allocated in the executable */
1851 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1852 s
= s1
->sections
[i
];
1853 if ((s
->sh_flags
& SHF_ALLOC
) &&
1854 s
->sh_type
== SHT_RELX
) {
1855 relocate_rel(s1
, s
);
1861 /* Create an ELF file on disk.
1862 This function handle ELF specific layout requirements */
1863 static void tcc_output_elf(TCCState
*s1
, FILE *f
, int phnum
, ElfW(Phdr
) *phdr
,
1864 int file_offset
, int *sec_order
)
1866 int i
, shnum
, offset
, size
, file_type
;
1869 ElfW(Shdr
) shdr
, *sh
;
1871 file_type
= s1
->output_type
;
1872 shnum
= s1
->nb_sections
;
1874 memset(&ehdr
, 0, sizeof(ehdr
));
1877 ehdr
.e_phentsize
= sizeof(ElfW(Phdr
));
1878 ehdr
.e_phnum
= phnum
;
1879 ehdr
.e_phoff
= sizeof(ElfW(Ehdr
));
1883 file_offset
= (file_offset
+ 3) & -4;
1886 ehdr
.e_ident
[0] = ELFMAG0
;
1887 ehdr
.e_ident
[1] = ELFMAG1
;
1888 ehdr
.e_ident
[2] = ELFMAG2
;
1889 ehdr
.e_ident
[3] = ELFMAG3
;
1890 ehdr
.e_ident
[4] = ELFCLASSW
;
1891 ehdr
.e_ident
[5] = ELFDATA2LSB
;
1892 ehdr
.e_ident
[6] = EV_CURRENT
;
1893 #if !defined(TCC_TARGET_PE) && (defined(__FreeBSD__) || defined(__FreeBSD_kernel__))
1894 /* FIXME: should set only for freebsd _target_, but we exclude only PE target */
1895 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
1897 #ifdef TCC_TARGET_ARM
1899 ehdr
.e_ident
[EI_OSABI
] = 0;
1900 ehdr
.e_flags
= EF_ARM_EABI_VER4
;
1901 if (file_type
== TCC_OUTPUT_EXE
|| file_type
== TCC_OUTPUT_DLL
)
1902 ehdr
.e_flags
|= EF_ARM_HASENTRY
;
1903 if (s1
->float_abi
== ARM_HARD_FLOAT
)
1904 ehdr
.e_flags
|= EF_ARM_VFP_FLOAT
;
1906 ehdr
.e_flags
|= EF_ARM_SOFT_FLOAT
;
1908 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_ARM
;
1913 case TCC_OUTPUT_EXE
:
1914 ehdr
.e_type
= ET_EXEC
;
1915 ehdr
.e_entry
= get_elf_sym_addr(s1
, "_start", 1);
1917 case TCC_OUTPUT_DLL
:
1918 ehdr
.e_type
= ET_DYN
;
1919 ehdr
.e_entry
= text_section
->sh_addr
; /* XXX: is it correct ? */
1921 case TCC_OUTPUT_OBJ
:
1922 ehdr
.e_type
= ET_REL
;
1925 ehdr
.e_machine
= EM_TCC_TARGET
;
1926 ehdr
.e_version
= EV_CURRENT
;
1927 ehdr
.e_shoff
= file_offset
;
1928 ehdr
.e_ehsize
= sizeof(ElfW(Ehdr
));
1929 ehdr
.e_shentsize
= sizeof(ElfW(Shdr
));
1930 ehdr
.e_shnum
= shnum
;
1931 ehdr
.e_shstrndx
= shnum
- 1;
1933 fwrite(&ehdr
, 1, sizeof(ElfW(Ehdr
)), f
);
1934 fwrite(phdr
, 1, phnum
* sizeof(ElfW(Phdr
)), f
);
1935 offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1937 sort_syms(s1
, symtab_section
);
1938 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1939 s
= s1
->sections
[sec_order
[i
]];
1940 if (s
->sh_type
!= SHT_NOBITS
) {
1941 while (offset
< s
->sh_offset
) {
1947 fwrite(s
->data
, 1, size
, f
);
1952 /* output section headers */
1953 while (offset
< ehdr
.e_shoff
) {
1958 for(i
= 0; i
< s1
->nb_sections
; i
++) {
1960 memset(sh
, 0, sizeof(ElfW(Shdr
)));
1961 s
= s1
->sections
[i
];
1963 sh
->sh_name
= s
->sh_name
;
1964 sh
->sh_type
= s
->sh_type
;
1965 sh
->sh_flags
= s
->sh_flags
;
1966 sh
->sh_entsize
= s
->sh_entsize
;
1967 sh
->sh_info
= s
->sh_info
;
1969 sh
->sh_link
= s
->link
->sh_num
;
1970 sh
->sh_addralign
= s
->sh_addralign
;
1971 sh
->sh_addr
= s
->sh_addr
;
1972 sh
->sh_offset
= s
->sh_offset
;
1973 sh
->sh_size
= s
->sh_size
;
1975 fwrite(sh
, 1, sizeof(ElfW(Shdr
)), f
);
1979 /* Write an elf, coff or "binary" file */
1980 static int tcc_write_elf_file(TCCState
*s1
, const char *filename
, int phnum
,
1981 ElfW(Phdr
) *phdr
, int file_offset
, int *sec_order
)
1983 int fd
, mode
, file_type
;
1986 file_type
= s1
->output_type
;
1987 if (file_type
== TCC_OUTPUT_OBJ
)
1992 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, mode
);
1994 tcc_error_noabort("could not write '%s'", filename
);
1997 f
= fdopen(fd
, "wb");
1999 printf("<- %s\n", filename
);
2001 #ifdef TCC_TARGET_COFF
2002 if (s1
->output_format
== TCC_OUTPUT_FORMAT_COFF
)
2003 tcc_output_coff(s1
, f
);
2006 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
2007 tcc_output_elf(s1
, f
, phnum
, phdr
, file_offset
, sec_order
);
2009 tcc_output_binary(s1
, f
, sec_order
);
2015 /* Sort section headers by assigned sh_addr, remove sections
2016 that we aren't going to output. */
2017 static void tidy_section_headers(TCCState
*s1
, int *sec_order
)
2019 int i
, nnew
, l
, *backmap
;
2023 snew
= tcc_malloc(s1
->nb_sections
* sizeof(snew
[0]));
2024 backmap
= tcc_malloc(s1
->nb_sections
* sizeof(backmap
[0]));
2025 for (i
= 0, nnew
= 0, l
= s1
->nb_sections
; i
< s1
->nb_sections
; i
++) {
2026 s
= s1
->sections
[sec_order
[i
]];
2027 if (!i
|| s
->sh_name
) {
2028 backmap
[sec_order
[i
]] = nnew
;
2032 backmap
[sec_order
[i
]] = 0;
2036 for (i
= 0; i
< nnew
; i
++) {
2040 if (s
->sh_type
== SHT_RELX
)
2041 s
->sh_info
= backmap
[s
->sh_info
];
2045 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
))
2046 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
)
2047 sym
->st_shndx
= backmap
[sym
->st_shndx
];
2048 if( !s1
->static_link
) {
2049 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
))
2050 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
)
2051 sym
->st_shndx
= backmap
[sym
->st_shndx
];
2053 for (i
= 0; i
< s1
->nb_sections
; i
++)
2055 tcc_free(s1
->sections
);
2056 s1
->sections
= snew
;
2057 s1
->nb_sections
= nnew
;
2061 /* Output an elf, coff or binary file */
2062 /* XXX: suppress unneeded sections */
2063 static int elf_output_file(TCCState
*s1
, const char *filename
)
2065 int i
, ret
, phnum
, shnum
, file_type
, file_offset
, *sec_order
;
2066 struct dyn_inf dyninf
= {0};
2069 Section
*strsec
, *interp
, *dynamic
, *dynstr
;
2072 file_type
= s1
->output_type
;
2077 interp
= dynamic
= dynstr
= NULL
; /* avoid warning */
2080 if (file_type
!= TCC_OUTPUT_OBJ
) {
2081 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2082 tcc_add_runtime(s1
);
2083 resolve_common_syms(s1
);
2085 if (!s1
->static_link
) {
2086 if (file_type
== TCC_OUTPUT_EXE
) {
2088 /* allow override the dynamic loader */
2089 const char *elfint
= getenv("LD_SO");
2091 elfint
= DEFAULT_ELFINTERP(s1
);
2092 /* add interpreter section only if executable */
2093 interp
= new_section(s1
, ".interp", SHT_PROGBITS
, SHF_ALLOC
);
2094 interp
->sh_addralign
= 1;
2095 ptr
= section_ptr_add(interp
, 1 + strlen(elfint
));
2096 strcpy(ptr
, elfint
);
2099 /* add dynamic symbol table */
2100 s1
->dynsym
= new_symtab(s1
, ".dynsym", SHT_DYNSYM
, SHF_ALLOC
,
2102 ".hash", SHF_ALLOC
);
2103 dynstr
= s1
->dynsym
->link
;
2105 /* add dynamic section */
2106 dynamic
= new_section(s1
, ".dynamic", SHT_DYNAMIC
,
2107 SHF_ALLOC
| SHF_WRITE
);
2108 dynamic
->link
= dynstr
;
2109 dynamic
->sh_entsize
= sizeof(ElfW(Dyn
));
2113 if (file_type
== TCC_OUTPUT_EXE
) {
2114 bind_exe_dynsyms(s1
);
2117 bind_libs_dynsyms(s1
);
2119 /* shared library case: simply export all global symbols */
2120 export_global_syms(s1
);
2123 build_got_entries(s1
);
2126 /* we add a section for symbols */
2127 strsec
= new_section(s1
, ".shstrtab", SHT_STRTAB
, 0);
2128 put_elf_str(strsec
, "");
2130 /* Allocate strings for section names */
2131 textrel
= alloc_sec_names(s1
, file_type
, strsec
);
2134 /* add a list of needed dlls */
2135 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2136 DLLReference
*dllref
= s1
->loaded_dlls
[i
];
2137 if (dllref
->level
== 0)
2138 put_dt(dynamic
, DT_NEEDED
, put_elf_str(dynstr
, dllref
->name
));
2142 put_dt(dynamic
, s1
->enable_new_dtags
? DT_RUNPATH
: DT_RPATH
,
2143 put_elf_str(dynstr
, s1
->rpath
));
2145 if (file_type
== TCC_OUTPUT_DLL
) {
2147 put_dt(dynamic
, DT_SONAME
, put_elf_str(dynstr
, s1
->soname
));
2148 /* XXX: currently, since we do not handle PIC code, we
2149 must relocate the readonly segments */
2151 put_dt(dynamic
, DT_TEXTREL
, 0);
2155 put_dt(dynamic
, DT_SYMBOLIC
, 0);
2157 dyninf
.dynamic
= dynamic
;
2158 dyninf
.dynstr
= dynstr
;
2159 /* remember offset and reserve space for 2nd call below */
2160 dyninf
.data_offset
= dynamic
->data_offset
;
2161 fill_dynamic(s1
, &dyninf
);
2162 dynamic
->sh_size
= dynamic
->data_offset
;
2163 dynstr
->sh_size
= dynstr
->data_offset
;
2166 /* compute number of program headers */
2167 if (file_type
== TCC_OUTPUT_OBJ
)
2169 else if (file_type
== TCC_OUTPUT_DLL
)
2171 else if (s1
->static_link
)
2176 /* allocate program segment headers */
2177 phdr
= tcc_mallocz(phnum
* sizeof(ElfW(Phdr
)));
2179 /* compute number of sections */
2180 shnum
= s1
->nb_sections
;
2182 /* this array is used to reorder sections in the output file */
2183 sec_order
= tcc_malloc(sizeof(int) * shnum
);
2186 /* compute section to program header mapping */
2187 file_offset
= layout_sections(s1
, phdr
, phnum
, interp
, strsec
, &dyninf
,
2190 /* Fill remaining program header and finalize relocation related to dynamic
2192 if (file_type
!= TCC_OUTPUT_OBJ
) {
2193 fill_unloadable_phdr(phdr
, phnum
, interp
, dynamic
);
2195 dynamic
->data_offset
= dyninf
.data_offset
;
2196 fill_dynamic(s1
, &dyninf
);
2198 /* put in GOT the dynamic section address and relocate PLT */
2199 write32le(s1
->got
->data
, dynamic
->sh_addr
);
2200 if (file_type
== TCC_OUTPUT_EXE
2201 || (RELOCATE_DLLPLT
&& file_type
== TCC_OUTPUT_DLL
))
2204 /* relocate symbols in .dynsym now that final addresses are known */
2205 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
)) {
2206 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
) {
2207 /* do symbol relocation */
2208 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
2213 /* if building executable or DLL, then relocate each section
2214 except the GOT which is already relocated */
2215 ret
= final_sections_reloc(s1
);
2218 tidy_section_headers(s1
, sec_order
);
2220 /* Perform relocation to GOT or PLT entries */
2221 if (file_type
== TCC_OUTPUT_EXE
&& s1
->static_link
)
2224 fill_local_got_entries(s1
);
2227 /* Create the ELF file with name 'filename' */
2228 ret
= tcc_write_elf_file(s1
, filename
, phnum
, phdr
, file_offset
, sec_order
);
2229 s1
->nb_sections
= shnum
;
2231 tcc_free(sec_order
);
2236 LIBTCCAPI
int tcc_output_file(TCCState
*s
, const char *filename
)
2239 #ifdef TCC_TARGET_PE
2240 if (s
->output_type
!= TCC_OUTPUT_OBJ
) {
2241 ret
= pe_output_file(s
, filename
);
2244 ret
= elf_output_file(s
, filename
);
2248 ssize_t
full_read(int fd
, void *buf
, size_t count
) {
2252 ssize_t num
= read(fd
, cbuf
, count
-rnum
);
2253 if (num
< 0) return num
;
2254 if (num
== 0) return rnum
;
2260 static void *load_data(int fd
, unsigned long file_offset
, unsigned long size
)
2264 data
= tcc_malloc(size
);
2265 lseek(fd
, file_offset
, SEEK_SET
);
2266 full_read(fd
, data
, size
);
2270 typedef struct SectionMergeInfo
{
2271 Section
*s
; /* corresponding existing section */
2272 unsigned long offset
; /* offset of the new section in the existing section */
2273 uint8_t new_section
; /* true if section 's' was added */
2274 uint8_t link_once
; /* true if link once section */
2277 ST_FUNC
int tcc_object_type(int fd
, ElfW(Ehdr
) *h
)
2279 int size
= full_read(fd
, h
, sizeof *h
);
2280 if (size
== sizeof *h
&& 0 == memcmp(h
, ELFMAG
, 4)) {
2281 if (h
->e_type
== ET_REL
)
2282 return AFF_BINTYPE_REL
;
2283 if (h
->e_type
== ET_DYN
)
2284 return AFF_BINTYPE_DYN
;
2285 } else if (size
>= 8) {
2286 if (0 == memcmp(h
, ARMAG
, 8))
2287 return AFF_BINTYPE_AR
;
2288 #ifdef TCC_TARGET_COFF
2289 if (((struct filehdr
*)h
)->f_magic
== COFF_C67_MAGIC
)
2290 return AFF_BINTYPE_C67
;
2296 /* load an object file and merge it with current files */
2297 /* XXX: handle correctly stab (debug) info */
2298 ST_FUNC
int tcc_load_object_file(TCCState
*s1
,
2299 int fd
, unsigned long file_offset
)
2302 ElfW(Shdr
) *shdr
, *sh
;
2303 int size
, i
, j
, offset
, offseti
, nb_syms
, sym_index
, ret
, seencompressed
;
2304 char *strsec
, *strtab
;
2305 int *old_to_new_syms
;
2306 char *sh_name
, *name
;
2307 SectionMergeInfo
*sm_table
, *sm
;
2308 ElfW(Sym
) *sym
, *symtab
;
2315 stab_index
= stabstr_index
= 0;
2317 lseek(fd
, file_offset
, SEEK_SET
);
2318 if (tcc_object_type(fd
, &ehdr
) != AFF_BINTYPE_REL
)
2320 /* test CPU specific stuff */
2321 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2322 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2324 tcc_error_noabort("invalid object file");
2328 shdr
= load_data(fd
, file_offset
+ ehdr
.e_shoff
,
2329 sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2330 sm_table
= tcc_mallocz(sizeof(SectionMergeInfo
) * ehdr
.e_shnum
);
2332 /* load section names */
2333 sh
= &shdr
[ehdr
.e_shstrndx
];
2334 strsec
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2336 /* load symtab and strtab */
2337 old_to_new_syms
= NULL
;
2342 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2344 if (sh
->sh_type
== SHT_SYMTAB
) {
2346 tcc_error_noabort("object must contain only one symtab");
2351 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2352 symtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2353 sm_table
[i
].s
= symtab_section
;
2355 /* now load strtab */
2356 sh
= &shdr
[sh
->sh_link
];
2357 strtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2359 if (sh
->sh_flags
& SHF_COMPRESSED
)
2363 /* now examine each section and try to merge its content with the
2365 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2366 /* no need to examine section name strtab */
2367 if (i
== ehdr
.e_shstrndx
)
2370 if (sh
->sh_type
== SHT_RELX
)
2371 sh
= &shdr
[sh
->sh_info
];
2372 /* ignore sections types we do not handle (plus relocs to those) */
2373 if (sh
->sh_type
!= SHT_PROGBITS
&&
2375 sh
->sh_type
!= SHT_ARM_EXIDX
&&
2377 sh
->sh_type
!= SHT_NOBITS
&&
2378 sh
->sh_type
!= SHT_PREINIT_ARRAY
&&
2379 sh
->sh_type
!= SHT_INIT_ARRAY
&&
2380 sh
->sh_type
!= SHT_FINI_ARRAY
&&
2381 strcmp(strsec
+ sh
->sh_name
, ".stabstr")
2385 && !strncmp(strsec
+ sh
->sh_name
, ".debug_", sizeof(".debug_")-1))
2389 sh_name
= strsec
+ sh
->sh_name
;
2390 if (sh
->sh_addralign
< 1)
2391 sh
->sh_addralign
= 1;
2392 /* find corresponding section, if any */
2393 for(j
= 1; j
< s1
->nb_sections
;j
++) {
2394 s
= s1
->sections
[j
];
2395 if (!strcmp(s
->name
, sh_name
)) {
2396 if (!strncmp(sh_name
, ".gnu.linkonce",
2397 sizeof(".gnu.linkonce") - 1)) {
2398 /* if a 'linkonce' section is already present, we
2399 do not add it again. It is a little tricky as
2400 symbols can still be defined in
2402 sm_table
[i
].link_once
= 1;
2409 /* not found: create new section */
2410 s
= new_section(s1
, sh_name
, sh
->sh_type
, sh
->sh_flags
& ~SHF_GROUP
);
2411 /* take as much info as possible from the section. sh_link and
2412 sh_info will be updated later */
2413 s
->sh_addralign
= sh
->sh_addralign
;
2414 s
->sh_entsize
= sh
->sh_entsize
;
2415 sm_table
[i
].new_section
= 1;
2417 if (sh
->sh_type
!= s
->sh_type
) {
2418 tcc_error_noabort("invalid section type");
2422 /* align start of section */
2423 offset
= s
->data_offset
;
2425 if (0 == strcmp(sh_name
, ".stab")) {
2429 if (0 == strcmp(sh_name
, ".stabstr")) {
2434 size
= sh
->sh_addralign
- 1;
2435 offset
= (offset
+ size
) & ~size
;
2436 if (sh
->sh_addralign
> s
->sh_addralign
)
2437 s
->sh_addralign
= sh
->sh_addralign
;
2438 s
->data_offset
= offset
;
2440 sm_table
[i
].offset
= offset
;
2442 /* concatenate sections */
2444 if (sh
->sh_type
!= SHT_NOBITS
) {
2446 lseek(fd
, file_offset
+ sh
->sh_offset
, SEEK_SET
);
2447 ptr
= section_ptr_add(s
, size
);
2448 full_read(fd
, ptr
, size
);
2450 s
->data_offset
+= size
;
2455 /* gr relocate stab strings */
2456 if (stab_index
&& stabstr_index
) {
2459 s
= sm_table
[stab_index
].s
;
2460 a
= (Stab_Sym
*)(s
->data
+ sm_table
[stab_index
].offset
);
2461 b
= (Stab_Sym
*)(s
->data
+ s
->data_offset
);
2462 o
= sm_table
[stabstr_index
].offset
;
2470 /* second short pass to update sh_link and sh_info fields of new
2472 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2474 if (!s
|| !sm_table
[i
].new_section
)
2477 if (sh
->sh_link
> 0)
2478 s
->link
= sm_table
[sh
->sh_link
].s
;
2479 if (sh
->sh_type
== SHT_RELX
) {
2480 s
->sh_info
= sm_table
[sh
->sh_info
].s
->sh_num
;
2481 /* update backward link */
2482 s1
->sections
[s
->sh_info
]->reloc
= s
;
2487 /* resolve symbols */
2488 old_to_new_syms
= tcc_mallocz(nb_syms
* sizeof(int));
2491 for(i
= 1; i
< nb_syms
; i
++, sym
++) {
2492 if (sym
->st_shndx
!= SHN_UNDEF
&&
2493 sym
->st_shndx
< SHN_LORESERVE
) {
2494 sm
= &sm_table
[sym
->st_shndx
];
2495 if (sm
->link_once
) {
2496 /* if a symbol is in a link once section, we use the
2497 already defined symbol. It is very important to get
2498 correct relocations */
2499 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
2500 name
= strtab
+ sym
->st_name
;
2501 sym_index
= find_elf_sym(symtab_section
, name
);
2503 old_to_new_syms
[i
] = sym_index
;
2507 /* if no corresponding section added, no need to add symbol */
2510 /* convert section number */
2511 sym
->st_shndx
= sm
->s
->sh_num
;
2513 sym
->st_value
+= sm
->offset
;
2516 name
= strtab
+ sym
->st_name
;
2517 sym_index
= set_elf_sym(symtab_section
, sym
->st_value
, sym
->st_size
,
2518 sym
->st_info
, sym
->st_other
,
2519 sym
->st_shndx
, name
);
2520 old_to_new_syms
[i
] = sym_index
;
2523 /* third pass to patch relocation entries */
2524 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2529 offset
= sm_table
[i
].offset
;
2530 switch(s
->sh_type
) {
2532 /* take relocation offset information */
2533 offseti
= sm_table
[sh
->sh_info
].offset
;
2534 for_each_elem(s
, (offset
/ sizeof(*rel
)), rel
, ElfW_Rel
) {
2537 /* convert symbol index */
2538 type
= ELFW(R_TYPE
)(rel
->r_info
);
2539 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
2540 /* NOTE: only one symtab assumed */
2541 if (sym_index
>= nb_syms
)
2543 sym_index
= old_to_new_syms
[sym_index
];
2544 /* ignore link_once in rel section. */
2545 if (!sym_index
&& !sm
->link_once
2546 #ifdef TCC_TARGET_ARM
2547 && type
!= R_ARM_V4BX
2551 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2552 i
, strsec
+ sh
->sh_name
, rel
->r_offset
);
2555 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
2556 /* offset the relocation offset */
2557 rel
->r_offset
+= offseti
;
2558 #ifdef TCC_TARGET_ARM
2559 /* Jumps and branches from a Thumb code to a PLT entry need
2560 special handling since PLT entries are ARM code.
2561 Unconditional bl instructions referencing PLT entries are
2562 handled by converting these instructions into blx
2563 instructions. Other case of instructions referencing a PLT
2564 entry require to add a Thumb stub before the PLT entry to
2565 switch to ARM mode. We set bit plt_thumb_stub of the
2566 attribute of a symbol to indicate such a case. */
2567 if (type
== R_ARM_THM_JUMP24
)
2568 get_sym_attr(s1
, sym_index
, 1)->plt_thumb_stub
= 1;
2581 tcc_free(old_to_new_syms
);
2588 typedef struct ArchiveHeader
{
2589 char ar_name
[16]; /* name of this member */
2590 char ar_date
[12]; /* file mtime */
2591 char ar_uid
[6]; /* owner uid; printed as decimal */
2592 char ar_gid
[6]; /* owner gid; printed as decimal */
2593 char ar_mode
[8]; /* file mode, printed as octal */
2594 char ar_size
[10]; /* file size, printed as decimal */
2595 char ar_fmag
[2]; /* should contain ARFMAG */
2598 static int get_be32(const uint8_t *b
)
2600 return b
[3] | (b
[2] << 8) | (b
[1] << 16) | (b
[0] << 24);
2603 static long get_be64(const uint8_t *b
)
2605 long long ret
= get_be32(b
);
2606 ret
= (ret
<< 32) | (unsigned)get_be32(b
+4);
2610 /* load only the objects which resolve undefined symbols */
2611 static int tcc_load_alacarte(TCCState
*s1
, int fd
, int size
, int entrysize
)
2613 long i
, bound
, nsyms
, sym_index
, off
, ret
;
2615 const char *ar_names
, *p
;
2616 const uint8_t *ar_index
;
2619 data
= tcc_malloc(size
);
2620 if (full_read(fd
, data
, size
) != size
)
2622 nsyms
= entrysize
== 4 ? get_be32(data
) : get_be64(data
);
2623 ar_index
= data
+ entrysize
;
2624 ar_names
= (char *) ar_index
+ nsyms
* entrysize
;
2628 for(p
= ar_names
, i
= 0; i
< nsyms
; i
++, p
+= strlen(p
)+1) {
2629 sym_index
= find_elf_sym(symtab_section
, p
);
2631 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
2632 if(sym
->st_shndx
== SHN_UNDEF
) {
2633 off
= (entrysize
== 4
2634 ? get_be32(ar_index
+ i
* 4)
2635 : get_be64(ar_index
+ i
* 8))
2636 + sizeof(ArchiveHeader
);
2638 if(tcc_load_object_file(s1
, fd
, off
) < 0) {
2653 /* load a '.a' file */
2654 ST_FUNC
int tcc_load_archive(TCCState
*s1
, int fd
, int alacarte
)
2661 unsigned long file_offset
;
2663 /* skip magic which was already checked */
2664 full_read(fd
, magic
, sizeof(magic
));
2667 len
= full_read(fd
, &hdr
, sizeof(hdr
));
2670 if (len
!= sizeof(hdr
)) {
2671 tcc_error_noabort("invalid archive");
2674 memcpy(ar_size
, hdr
.ar_size
, sizeof(hdr
.ar_size
));
2675 ar_size
[sizeof(hdr
.ar_size
)] = '\0';
2676 size
= strtol(ar_size
, NULL
, 0);
2677 memcpy(ar_name
, hdr
.ar_name
, sizeof(hdr
.ar_name
));
2678 for(i
= sizeof(hdr
.ar_name
) - 1; i
>= 0; i
--) {
2679 if (ar_name
[i
] != ' ')
2682 ar_name
[i
+ 1] = '\0';
2683 file_offset
= lseek(fd
, 0, SEEK_CUR
);
2685 size
= (size
+ 1) & ~1;
2686 if (!strcmp(ar_name
, "/")) {
2687 /* coff symbol table : we handle it */
2689 return tcc_load_alacarte(s1
, fd
, size
, 4);
2690 } else if (!strcmp(ar_name
, "/SYM64/")) {
2692 return tcc_load_alacarte(s1
, fd
, size
, 8);
2695 if (tcc_object_type(fd
, &ehdr
) == AFF_BINTYPE_REL
) {
2696 if (tcc_load_object_file(s1
, fd
, file_offset
) < 0)
2700 lseek(fd
, file_offset
+ size
, SEEK_SET
);
2705 #ifndef TCC_TARGET_PE
2706 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2707 is referenced by the user (so it should be added as DT_NEEDED in
2708 the generated ELF file) */
2709 ST_FUNC
int tcc_load_dll(TCCState
*s1
, int fd
, const char *filename
, int level
)
2712 ElfW(Shdr
) *shdr
, *sh
, *sh1
;
2713 int i
, j
, nb_syms
, nb_dts
, sym_bind
, ret
;
2714 ElfW(Sym
) *sym
, *dynsym
;
2715 ElfW(Dyn
) *dt
, *dynamic
;
2716 unsigned char *dynstr
;
2717 const char *name
, *soname
;
2718 DLLReference
*dllref
;
2720 full_read(fd
, &ehdr
, sizeof(ehdr
));
2722 /* test CPU specific stuff */
2723 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2724 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2725 tcc_error_noabort("bad architecture");
2730 shdr
= load_data(fd
, ehdr
.e_shoff
, sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2732 /* load dynamic section and dynamic symbols */
2736 dynsym
= NULL
; /* avoid warning */
2737 dynstr
= NULL
; /* avoid warning */
2738 for(i
= 0, sh
= shdr
; i
< ehdr
.e_shnum
; i
++, sh
++) {
2739 switch(sh
->sh_type
) {
2741 nb_dts
= sh
->sh_size
/ sizeof(ElfW(Dyn
));
2742 dynamic
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2745 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2746 dynsym
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2747 sh1
= &shdr
[sh
->sh_link
];
2748 dynstr
= load_data(fd
, sh1
->sh_offset
, sh1
->sh_size
);
2755 /* compute the real library name */
2756 soname
= tcc_basename(filename
);
2758 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2759 if (dt
->d_tag
== DT_SONAME
) {
2760 soname
= (char *) dynstr
+ dt
->d_un
.d_val
;
2764 /* if the dll is already loaded, do not load it */
2765 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2766 dllref
= s1
->loaded_dlls
[i
];
2767 if (!strcmp(soname
, dllref
->name
)) {
2768 /* but update level if needed */
2769 if (level
< dllref
->level
)
2770 dllref
->level
= level
;
2776 /* add the dll and its level */
2777 dllref
= tcc_mallocz(sizeof(DLLReference
) + strlen(soname
));
2778 dllref
->level
= level
;
2779 strcpy(dllref
->name
, soname
);
2780 dynarray_add(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
, dllref
);
2782 /* add dynamic symbols in dynsym_section */
2783 for(i
= 1, sym
= dynsym
+ 1; i
< nb_syms
; i
++, sym
++) {
2784 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
2785 if (sym_bind
== STB_LOCAL
)
2787 name
= (char *) dynstr
+ sym
->st_name
;
2788 set_elf_sym(s1
->dynsymtab_section
, sym
->st_value
, sym
->st_size
,
2789 sym
->st_info
, sym
->st_other
, sym
->st_shndx
, name
);
2792 /* load all referenced DLLs */
2793 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2796 name
= (char *) dynstr
+ dt
->d_un
.d_val
;
2797 for(j
= 0; j
< s1
->nb_loaded_dlls
; j
++) {
2798 dllref
= s1
->loaded_dlls
[j
];
2799 if (!strcmp(name
, dllref
->name
))
2800 goto already_loaded
;
2802 if (tcc_add_dll(s1
, name
, AFF_REFERENCED_DLL
) < 0) {
2803 tcc_error_noabort("referenced dll '%s' not found", name
);
2820 #define LD_TOK_NAME 256
2821 #define LD_TOK_EOF (-1)
2823 /* return next ld script token */
2824 static int ld_next(TCCState
*s1
, char *name
, int name_size
)
2842 file
->buf_ptr
= parse_comment(file
->buf_ptr
);
2843 ch
= file
->buf_ptr
[0];
2856 /* case 'a' ... 'z': */
2883 /* case 'A' ... 'z': */
2917 if (!((ch
>= 'a' && ch
<= 'z') ||
2918 (ch
>= 'A' && ch
<= 'Z') ||
2919 (ch
>= '0' && ch
<= '9') ||
2920 strchr("/.-_+=$:\\,~", ch
)))
2922 if ((q
- name
) < name_size
- 1) {
2941 static int ld_add_file(TCCState
*s1
, const char filename
[])
2943 if (filename
[0] == '/') {
2944 if (CONFIG_SYSROOT
[0] == '\0'
2945 && tcc_add_file_internal(s1
, filename
, AFF_TYPE_BIN
) == 0)
2947 filename
= tcc_basename(filename
);
2949 return tcc_add_dll(s1
, filename
, 0);
2952 static inline int new_undef_syms(void)
2955 ret
= new_undef_sym
;
2960 static int ld_add_file_list(TCCState
*s1
, const char *cmd
, int as_needed
)
2962 char filename
[1024], libname
[1024];
2963 int t
, group
, nblibs
= 0, ret
= 0;
2966 group
= !strcmp(cmd
, "GROUP");
2969 t
= ld_next(s1
, filename
, sizeof(filename
));
2972 t
= ld_next(s1
, filename
, sizeof(filename
));
2975 if (t
== LD_TOK_EOF
) {
2976 tcc_error_noabort("unexpected end of file");
2978 goto lib_parse_error
;
2979 } else if (t
== ')') {
2981 } else if (t
== '-') {
2982 t
= ld_next(s1
, filename
, sizeof(filename
));
2983 if ((t
!= LD_TOK_NAME
) || (filename
[0] != 'l')) {
2984 tcc_error_noabort("library name expected");
2986 goto lib_parse_error
;
2988 pstrcpy(libname
, sizeof libname
, &filename
[1]);
2989 if (s1
->static_link
) {
2990 snprintf(filename
, sizeof filename
, "lib%s.a", libname
);
2992 snprintf(filename
, sizeof filename
, "lib%s.so", libname
);
2994 } else if (t
!= LD_TOK_NAME
) {
2995 tcc_error_noabort("filename expected");
2997 goto lib_parse_error
;
2999 if (!strcmp(filename
, "AS_NEEDED")) {
3000 ret
= ld_add_file_list(s1
, cmd
, 1);
3002 goto lib_parse_error
;
3004 /* TODO: Implement AS_NEEDED support. Ignore it for now */
3006 ret
= ld_add_file(s1
, filename
);
3008 goto lib_parse_error
;
3010 /* Add the filename *and* the libname to avoid future conversions */
3011 dynarray_add(&libs
, &nblibs
, tcc_strdup(filename
));
3012 if (libname
[0] != '\0')
3013 dynarray_add(&libs
, &nblibs
, tcc_strdup(libname
));
3017 t
= ld_next(s1
, filename
, sizeof(filename
));
3019 t
= ld_next(s1
, filename
, sizeof(filename
));
3022 if (group
&& !as_needed
) {
3023 while (new_undef_syms()) {
3026 for (i
= 0; i
< nblibs
; i
++)
3027 ld_add_file(s1
, libs
[i
]);
3031 dynarray_reset(&libs
, &nblibs
);
3035 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3037 ST_FUNC
int tcc_load_ldscript(TCCState
*s1
)
3040 char filename
[1024];
3045 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3046 if (t
== LD_TOK_EOF
)
3048 else if (t
!= LD_TOK_NAME
)
3050 if (!strcmp(cmd
, "INPUT") ||
3051 !strcmp(cmd
, "GROUP")) {
3052 ret
= ld_add_file_list(s1
, cmd
, 0);
3055 } else if (!strcmp(cmd
, "OUTPUT_FORMAT") ||
3056 !strcmp(cmd
, "TARGET")) {
3057 /* ignore some commands */
3058 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3062 t
= ld_next(s1
, filename
, sizeof(filename
));
3063 if (t
== LD_TOK_EOF
) {
3064 tcc_error_noabort("unexpected end of file");
3066 } else if (t
== ')') {
3076 #endif /* !TCC_TARGET_PE */