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
)
869 int sym_index
, type
, count
;
872 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
873 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
874 type
= ELFW(R_TYPE
)(rel
->r_info
);
876 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
877 #if defined(TCC_TARGET_I386)
879 if (!get_sym_attr(s1
, sym_index
, 0)->dyn_index
880 && ((ElfW(Sym
)*)symtab_section
->data
+ sym_index
)->st_shndx
== SHN_UNDEF
) {
881 /* don't fixup unresolved (weak) symbols */
882 rel
->r_info
= ELFW(R_INFO
)(sym_index
, R_386_RELATIVE
);
885 #elif defined(TCC_TARGET_X86_64)
892 #if defined(TCC_TARGET_I386)
894 #elif defined(TCC_TARGET_X86_64)
897 if (get_sym_attr(s1
, sym_index
, 0)->dyn_index
)
906 /* allocate the section */
907 sr
->sh_flags
|= SHF_ALLOC
;
908 sr
->sh_size
= count
* sizeof(ElfW_Rel
);
913 static void build_got(TCCState
*s1
)
915 /* if no got, then create it */
916 s1
->got
= new_section(s1
, ".got", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
917 s1
->got
->sh_entsize
= 4;
918 set_elf_sym(symtab_section
, 0, 4, ELFW(ST_INFO
)(STB_GLOBAL
, STT_OBJECT
),
919 0, s1
->got
->sh_num
, "_GLOBAL_OFFSET_TABLE_");
920 /* keep space for _DYNAMIC pointer and two dummy got entries */
921 section_ptr_add(s1
->got
, 3 * PTR_SIZE
);
924 /* Create a GOT and (for function call) a PLT entry corresponding to a symbol
925 in s1->symtab. When creating the dynamic symbol table entry for the GOT
926 relocation, use 'size' and 'info' for the corresponding symbol metadata.
927 Returns the offset of the GOT or (if any) PLT entry. */
928 static struct sym_attr
* put_got_entry(TCCState
*s1
, int dyn_reloc_type
,
930 int info
, int sym_index
)
935 struct sym_attr
*attr
;
940 need_plt_entry
= (dyn_reloc_type
== R_JMP_SLOT
);
941 attr
= get_sym_attr(s1
, sym_index
, 1);
943 /* In case a function is both called and its address taken 2 GOT entries
944 are created, one for taking the address (GOT) and the other for the PLT
946 if (need_plt_entry
? attr
->plt_offset
: attr
->got_offset
)
949 /* create the GOT entry */
950 got_offset
= s1
->got
->data_offset
;
951 section_ptr_add(s1
->got
, PTR_SIZE
);
953 /* Create the GOT relocation that will insert the address of the object or
954 function of interest in the GOT entry. This is a static relocation for
955 memory output (dlsym will give us the address of symbols) and dynamic
956 relocation otherwise (executable and DLLs). The relocation should be
957 done lazily for GOT entry with *_JUMP_SLOT relocation type (the one
958 associated to a PLT entry) but is currently done at load time for an
961 sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
962 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
965 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_LOCAL
) {
966 /* Hack alarm. We don't want to emit dynamic symbols
967 and symbol based relocs for STB_LOCAL symbols, but rather
968 want to resolve them directly. At this point the symbol
969 values aren't final yet, so we must defer this. We will later
970 have to create a RELATIVE reloc anyway, so we misuse the
971 relocation slot to smuggle the symbol reference until
972 fill_local_got_entries. Not that the sym_index is
973 relative to symtab_section, not s1->dynsym! Nevertheless
974 we use s1->dyn_sym so that if this is the first call
975 that got->reloc is correctly created. Also note that
976 RELATIVE relocs are not normally created for the .got,
977 so the types serves as a marker for later (and is retained
978 also for the final output, which is okay because then the
979 got is just normal data). */
980 put_elf_reloc(s1
->dynsym
, s1
->got
, got_offset
, R_RELATIVE
,
983 if (0 == attr
->dyn_index
)
984 attr
->dyn_index
= set_elf_sym(s1
->dynsym
, sym
->st_value
, size
,
985 info
, 0, sym
->st_shndx
, name
);
986 put_elf_reloc(s1
->dynsym
, s1
->got
, got_offset
, dyn_reloc_type
,
990 put_elf_reloc(symtab_section
, s1
->got
, got_offset
, dyn_reloc_type
,
994 if (need_plt_entry
) {
996 s1
->plt
= new_section(s1
, ".plt", SHT_PROGBITS
,
997 SHF_ALLOC
| SHF_EXECINSTR
);
998 s1
->plt
->sh_entsize
= 4;
1001 attr
->plt_offset
= create_plt_entry(s1
, got_offset
, attr
);
1003 /* create a symbol 'sym@plt' for the PLT jump vector */
1005 if (len
> sizeof plt_name
- 5)
1006 len
= sizeof plt_name
- 5;
1007 memcpy(plt_name
, name
, len
);
1008 strcpy(plt_name
+ len
, "@plt");
1009 attr
->plt_sym
= put_elf_sym(s1
->symtab
, attr
->plt_offset
, sym
->st_size
,
1010 ELFW(ST_INFO
)(STB_GLOBAL
, STT_FUNC
), 0, s1
->plt
->sh_num
, plt_name
);
1013 attr
->got_offset
= got_offset
;
1019 /* build GOT and PLT entries */
1020 ST_FUNC
void build_got_entries(TCCState
*s1
)
1025 int i
, type
, gotplt_entry
, reloc_type
, sym_index
;
1026 struct sym_attr
*attr
;
1028 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1029 s
= s1
->sections
[i
];
1030 if (s
->sh_type
!= SHT_RELX
)
1032 /* no need to handle got relocations */
1033 if (s
->link
!= symtab_section
)
1035 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1036 type
= ELFW(R_TYPE
)(rel
->r_info
);
1037 gotplt_entry
= gotplt_entry_type(type
);
1038 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1039 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1041 if (gotplt_entry
== NO_GOTPLT_ENTRY
) {
1045 /* Automatically create PLT/GOT [entry] if it is an undefined
1046 reference (resolved at runtime), or the symbol is absolute,
1047 probably created by tcc_add_symbol, and thus on 64-bit
1048 targets might be too far from application code. */
1049 if (gotplt_entry
== AUTO_GOTPLT_ENTRY
) {
1050 if (sym
->st_shndx
== SHN_UNDEF
) {
1053 if (s1
->output_type
== TCC_OUTPUT_DLL
&& ! PCRELATIVE_DLLPLT
)
1055 /* Relocations for UNDEF symbols would normally need
1056 to be transferred into the executable or shared object.
1057 If that were done AUTO_GOTPLT_ENTRY wouldn't exist.
1058 But TCC doesn't do that (at least for exes), so we
1059 need to resolve all such relocs locally. And that
1060 means PLT slots for functions in DLLs and COPY relocs for
1061 data symbols. COPY relocs were generated in
1062 bind_exe_dynsyms (and the symbol adjusted to be defined),
1063 and for functions we were generated a dynamic symbol
1064 of function type. */
1066 /* dynsym isn't set for -run :-/ */
1067 dynindex
= get_sym_attr(s1
, sym_index
, 0)->dyn_index
;
1068 esym
= (ElfW(Sym
) *)s1
->dynsym
->data
+ dynindex
;
1070 && (ELFW(ST_TYPE
)(esym
->st_info
) == STT_FUNC
1071 || (ELFW(ST_TYPE
)(esym
->st_info
) == STT_NOTYPE
1072 && ELFW(ST_TYPE
)(sym
->st_info
) == STT_FUNC
)))
1075 } else if (!(sym
->st_shndx
== SHN_ABS
1076 #ifndef TCC_TARGET_ARM
1083 #ifdef TCC_TARGET_X86_64
1084 if ((type
== R_X86_64_PLT32
|| type
== R_X86_64_PC32
) &&
1085 (ELFW(ST_VISIBILITY
)(sym
->st_other
) != STV_DEFAULT
||
1086 ELFW(ST_BIND
)(sym
->st_info
) == STB_LOCAL
)) {
1087 rel
->r_info
= ELFW(R_INFO
)(sym_index
, R_X86_64_PC32
);
1091 if (code_reloc(type
)) {
1093 reloc_type
= R_JMP_SLOT
;
1095 reloc_type
= R_GLOB_DAT
;
1100 if (gotplt_entry
== BUILD_GOT_ONLY
)
1103 attr
= put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
1106 if (reloc_type
== R_JMP_SLOT
)
1107 rel
->r_info
= ELFW(R_INFO
)(attr
->plt_sym
, type
);
1112 /* put dynamic tag */
1113 static void put_dt(Section
*dynamic
, int dt
, addr_t val
)
1116 dyn
= section_ptr_add(dynamic
, sizeof(ElfW(Dyn
)));
1118 dyn
->d_un
.d_val
= val
;
1121 #ifndef TCC_TARGET_PE
1122 static void add_init_array_defines(TCCState
*s1
, const char *section_name
)
1126 char sym_start
[1024];
1129 snprintf(sym_start
, sizeof(sym_start
), "__%s_start", section_name
+ 1);
1130 snprintf(sym_end
, sizeof(sym_end
), "__%s_end", section_name
+ 1);
1132 s
= find_section(s1
, section_name
);
1137 end_offset
= s
->data_offset
;
1140 set_elf_sym(symtab_section
,
1142 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1143 s
->sh_num
, sym_start
);
1144 set_elf_sym(symtab_section
,
1146 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1147 s
->sh_num
, sym_end
);
1150 static int tcc_add_support(TCCState
*s1
, const char *filename
)
1153 snprintf(buf
, sizeof(buf
), "%s/%s", s1
->tcc_lib_path
, filename
);
1154 return tcc_add_file(s1
, buf
);
1158 ST_FUNC
void tcc_add_bcheck(TCCState
*s1
)
1160 #ifdef CONFIG_TCC_BCHECK
1164 if (0 == s1
->do_bounds_check
)
1166 /* XXX: add an object file to do that */
1167 ptr
= section_ptr_add(bounds_section
, sizeof(*ptr
));
1169 set_elf_sym(symtab_section
, 0, 0,
1170 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1171 bounds_section
->sh_num
, "__bounds_start");
1172 /* pull bcheck.o from libtcc1.a */
1173 sym_index
= set_elf_sym(symtab_section
, 0, 0,
1174 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1175 SHN_UNDEF
, "__bound_init");
1176 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
) {
1177 /* add 'call __bound_init()' in .init section */
1178 Section
*init_section
= find_section(s1
, ".init");
1179 unsigned char *pinit
= section_ptr_add(init_section
, 5);
1181 write32le(pinit
+ 1, -4);
1182 put_elf_reloc(symtab_section
, init_section
,
1183 init_section
->data_offset
- 4, R_386_PC32
, sym_index
);
1184 /* R_386_PC32 = R_X86_64_PC32 = 2 */
1189 /* add tcc runtime libraries */
1190 ST_FUNC
void tcc_add_runtime(TCCState
*s1
)
1194 tcc_add_pragma_libs(s1
);
1195 #ifndef TCC_TARGET_PE
1197 if (!s1
->nostdlib
) {
1198 tcc_add_library_err(s1
, "c");
1200 if (!s1
->static_link
) {
1201 if (TCC_LIBGCC
[0] == '/')
1202 tcc_add_file(s1
, TCC_LIBGCC
);
1204 tcc_add_dll(s1
, TCC_LIBGCC
, 0);
1207 tcc_add_support(s1
, TCC_LIBTCC1
);
1208 /* add crt end if not memory output */
1209 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
)
1210 tcc_add_crt(s1
, "crtn.o");
1215 /* add various standard linker symbols (must be done after the
1216 sections are filled (for example after allocating common
1218 static void tcc_add_linker_symbols(TCCState
*s1
)
1224 set_elf_sym(symtab_section
,
1225 text_section
->data_offset
, 0,
1226 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1227 text_section
->sh_num
, "_etext");
1228 set_elf_sym(symtab_section
,
1229 data_section
->data_offset
, 0,
1230 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1231 data_section
->sh_num
, "_edata");
1232 set_elf_sym(symtab_section
,
1233 bss_section
->data_offset
, 0,
1234 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1235 bss_section
->sh_num
, "_end");
1236 #ifndef TCC_TARGET_PE
1237 /* horrible new standard ldscript defines */
1238 add_init_array_defines(s1
, ".preinit_array");
1239 add_init_array_defines(s1
, ".init_array");
1240 add_init_array_defines(s1
, ".fini_array");
1243 /* add start and stop symbols for sections whose name can be
1245 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1246 s
= s1
->sections
[i
];
1247 if (s
->sh_type
== SHT_PROGBITS
&&
1248 (s
->sh_flags
& SHF_ALLOC
)) {
1252 /* check if section name can be expressed in C */
1258 if (!isid(ch
) && !isnum(ch
))
1262 snprintf(buf
, sizeof(buf
), "__start_%s", s
->name
);
1263 set_elf_sym(symtab_section
,
1265 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1267 snprintf(buf
, sizeof(buf
), "__stop_%s", s
->name
);
1268 set_elf_sym(symtab_section
,
1270 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1277 ST_FUNC
void resolve_common_syms(TCCState
*s1
)
1281 /* Allocate common symbols in BSS. */
1282 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1283 if (sym
->st_shndx
== SHN_COMMON
) {
1284 /* symbol alignment is in st_value for SHN_COMMONs */
1285 sym
->st_value
= section_add(bss_section
, sym
->st_size
,
1287 sym
->st_shndx
= bss_section
->sh_num
;
1291 /* Now assign linker provided symbols their value. */
1292 tcc_add_linker_symbols(s1
);
1295 static void tcc_output_binary(TCCState
*s1
, FILE *f
,
1296 const int *sec_order
)
1299 int i
, offset
, size
;
1302 for(i
=1;i
<s1
->nb_sections
;i
++) {
1303 s
= s1
->sections
[sec_order
[i
]];
1304 if (s
->sh_type
!= SHT_NOBITS
&&
1305 (s
->sh_flags
& SHF_ALLOC
)) {
1306 while (offset
< s
->sh_offset
) {
1311 fwrite(s
->data
, 1, size
, f
);
1317 ST_FUNC
void fill_got_entry(TCCState
*s1
, ElfW_Rel
*rel
)
1319 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1320 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1321 struct sym_attr
*attr
= get_sym_attr(s1
, sym_index
, 0);
1322 unsigned offset
= attr
->got_offset
;
1326 section_reserve(s1
->got
, offset
+ PTR_SIZE
);
1327 #ifdef TCC_TARGET_X86_64
1328 write64le(s1
->got
->data
+ offset
, sym
->st_value
);
1330 write32le(s1
->got
->data
+ offset
, sym
->st_value
);
1334 /* Perform relocation to GOT or PLT entries */
1335 ST_FUNC
void fill_got(TCCState
*s1
)
1341 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1342 s
= s1
->sections
[i
];
1343 if (s
->sh_type
!= SHT_RELX
)
1345 /* no need to handle got relocations */
1346 if (s
->link
!= symtab_section
)
1348 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1349 switch (ELFW(R_TYPE
) (rel
->r_info
)) {
1350 case R_X86_64_GOT32
:
1351 case R_X86_64_GOTPCREL
:
1352 case R_X86_64_GOTPCRELX
:
1353 case R_X86_64_REX_GOTPCRELX
:
1354 case R_X86_64_PLT32
:
1355 fill_got_entry(s1
, rel
);
1362 /* See put_got_entry for a description. This is the second stage
1363 where GOT references to local defined symbols are rewritten. */
1364 static void fill_local_got_entries(TCCState
*s1
)
1367 for_each_elem(s1
->got
->reloc
, 0, rel
, ElfW_Rel
) {
1368 if (ELFW(R_TYPE
)(rel
->r_info
) == R_RELATIVE
) {
1369 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1370 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1371 struct sym_attr
*attr
= get_sym_attr(s1
, sym_index
, 0);
1372 unsigned offset
= attr
->got_offset
;
1373 if (offset
!= rel
->r_offset
- s1
->got
->sh_addr
)
1374 tcc_error_noabort("huh");
1375 rel
->r_info
= ELFW(R_INFO
)(0, R_RELATIVE
);
1376 #if SHT_RELX == SHT_RELA
1377 rel
->r_addend
= sym
->st_value
;
1379 /* All our REL architectures also happen to be 32bit LE. */
1380 write32le(s1
->got
->data
+ offset
, sym
->st_value
);
1386 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1387 in shared libraries and export non local defined symbols to shared libraries
1388 if -rdynamic switch was given on command line */
1389 static void bind_exe_dynsyms(TCCState
*s1
)
1392 int sym_index
, index
;
1393 ElfW(Sym
) *sym
, *esym
;
1396 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1397 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1398 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1399 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1400 if (sym
->st_shndx
== SHN_UNDEF
) {
1401 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1402 sym_index
= find_elf_sym(s1
->dynsymtab_section
, name
);
1404 esym
= &((ElfW(Sym
) *)s1
->dynsymtab_section
->data
)[sym_index
];
1405 type
= ELFW(ST_TYPE
)(esym
->st_info
);
1406 if ((type
== STT_FUNC
) || (type
== STT_GNU_IFUNC
)) {
1407 /* Indirect functions shall have STT_FUNC type in executable
1408 * dynsym section. Indeed, a dlsym call following a lazy
1409 * resolution would pick the symbol value from the
1410 * executable dynsym entry which would contain the address
1411 * of the function wanted by the caller of dlsym instead of
1412 * the address of the function that would return that
1415 = put_elf_sym(s1
->dynsym
, 0, esym
->st_size
,
1416 ELFW(ST_INFO
)(STB_GLOBAL
,STT_FUNC
), 0, 0,
1418 int index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1419 get_sym_attr(s1
, index
, 1)->dyn_index
= dynindex
;
1420 } else if (type
== STT_OBJECT
) {
1421 unsigned long offset
;
1423 offset
= bss_section
->data_offset
;
1424 /* XXX: which alignment ? */
1425 offset
= (offset
+ 16 - 1) & -16;
1426 set_elf_sym (s1
->symtab
, offset
, esym
->st_size
,
1427 esym
->st_info
, 0, bss_section
->sh_num
, name
);
1428 index
= put_elf_sym(s1
->dynsym
, offset
, esym
->st_size
,
1429 esym
->st_info
, 0, bss_section
->sh_num
,
1432 /* Ensure R_COPY works for weak symbol aliases */
1433 if (ELFW(ST_BIND
)(esym
->st_info
) == STB_WEAK
) {
1434 for_each_elem(s1
->dynsymtab_section
, 1, dynsym
, ElfW(Sym
)) {
1435 if ((dynsym
->st_value
== esym
->st_value
)
1436 && (ELFW(ST_BIND
)(dynsym
->st_info
) == STB_GLOBAL
)) {
1437 char *dynname
= (char *) s1
->dynsymtab_section
->link
->data
1439 put_elf_sym(s1
->dynsym
, offset
, dynsym
->st_size
,
1441 bss_section
->sh_num
, dynname
);
1447 put_elf_reloc(s1
->dynsym
, bss_section
,
1448 offset
, R_COPY
, index
);
1449 offset
+= esym
->st_size
;
1450 bss_section
->data_offset
= offset
;
1453 /* STB_WEAK undefined symbols are accepted */
1454 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1455 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
||
1456 !strcmp(name
, "_fp_hw")) {
1458 tcc_error_noabort("undefined symbol '%s'", name
);
1461 } else if (s1
->rdynamic
&& ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1462 /* if -rdynamic option, then export all non local symbols */
1463 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1464 set_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1465 0, sym
->st_shndx
, name
);
1470 /* Bind symbols of libraries: export all non local symbols of executable that
1471 are referenced by shared libraries. The reason is that the dynamic loader
1472 search symbol first in executable and then in libraries. Therefore a
1473 reference to a symbol already defined by a library can still be resolved by
1474 a symbol in the executable. */
1475 static void bind_libs_dynsyms(TCCState
*s1
)
1479 ElfW(Sym
) *sym
, *esym
;
1481 for_each_elem(s1
->dynsymtab_section
, 1, esym
, ElfW(Sym
)) {
1482 name
= (char *) s1
->dynsymtab_section
->link
->data
+ esym
->st_name
;
1483 sym_index
= find_elf_sym(symtab_section
, name
);
1484 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1485 if (sym_index
&& sym
->st_shndx
!= SHN_UNDEF
1486 && ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1487 set_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1488 sym
->st_info
, 0, sym
->st_shndx
, name
);
1489 } else if (esym
->st_shndx
== SHN_UNDEF
) {
1490 /* weak symbols can stay undefined */
1491 if (ELFW(ST_BIND
)(esym
->st_info
) != STB_WEAK
)
1492 tcc_warning("undefined dynamic symbol '%s'", name
);
1497 /* Export all non local symbols. This is used by shared libraries so that the
1498 non local symbols they define can resolve a reference in another shared
1499 library or in the executable. Correspondingly, it allows undefined local
1500 symbols to be resolved by other shared libraries or by the executable. */
1501 static void export_global_syms(TCCState
*s1
)
1503 int dynindex
, index
;
1507 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1508 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1509 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1510 dynindex
= put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1511 sym
->st_info
, 0, sym
->st_shndx
, name
);
1512 index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1513 get_sym_attr(s1
, index
, 1)->dyn_index
= dynindex
;
1518 /* Allocate strings for section names and decide if an unallocated section
1520 NOTE: the strsec section comes last, so its size is also correct ! */
1521 static int alloc_sec_names(TCCState
*s1
, int file_type
, Section
*strsec
)
1527 /* Allocate strings for section names */
1528 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1529 s
= s1
->sections
[i
];
1530 /* when generating a DLL, we include relocations but we may
1532 if (file_type
== TCC_OUTPUT_DLL
&&
1533 s
->sh_type
== SHT_RELX
&&
1534 !(s
->sh_flags
& SHF_ALLOC
) &&
1535 (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_ALLOC
) &&
1536 prepare_dynamic_rel(s1
, s
)) {
1537 if (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_EXECINSTR
)
1539 } else if ((s1
->do_debug
&& s
->sh_type
!= SHT_RELX
) ||
1540 file_type
== TCC_OUTPUT_OBJ
||
1541 (s
->sh_flags
& SHF_ALLOC
) ||
1542 i
== (s1
->nb_sections
- 1)) {
1543 /* we output all sections if debug or object file */
1544 s
->sh_size
= s
->data_offset
;
1546 if (s
->sh_size
|| (s
->sh_flags
& SHF_ALLOC
))
1547 s
->sh_name
= put_elf_str(strsec
, s
->name
);
1549 strsec
->sh_size
= strsec
->data_offset
;
1553 /* Info to be copied in dynamic section */
1557 unsigned long data_offset
;
1560 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1566 /* Assign sections to segments and decide how are sections laid out when loaded
1567 in memory. This function also fills corresponding program headers. */
1568 static int layout_sections(TCCState
*s1
, ElfW(Phdr
) *phdr
, int phnum
,
1569 Section
*interp
, Section
* strsec
,
1570 struct dyn_inf
*dyninf
, int *sec_order
)
1572 int i
, j
, k
, file_type
, sh_order_index
, file_offset
;
1573 unsigned long s_align
;
1579 file_type
= s1
->output_type
;
1582 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
1583 file_offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1584 s_align
= ELF_PAGE_SIZE
;
1585 if (s1
->section_align
)
1586 s_align
= s1
->section_align
;
1589 if (s1
->has_text_addr
) {
1590 int a_offset
, p_offset
;
1591 addr
= s1
->text_addr
;
1592 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1594 a_offset
= (int) (addr
& (s_align
- 1));
1595 p_offset
= file_offset
& (s_align
- 1);
1596 if (a_offset
< p_offset
)
1597 a_offset
+= s_align
;
1598 file_offset
+= (a_offset
- p_offset
);
1600 if (file_type
== TCC_OUTPUT_DLL
)
1603 addr
= ELF_START_ADDR
;
1604 /* compute address after headers */
1605 addr
+= (file_offset
& (s_align
- 1));
1609 /* Leave one program headers for the program interpreter and one for
1610 the program header table itself if needed. These are done later as
1611 they require section layout to be done first. */
1615 /* dynamic relocation table information, for .dynamic section */
1616 dyninf
->rel_addr
= dyninf
->rel_size
= 0;
1617 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1618 dyninf
->bss_addr
= dyninf
->bss_size
= 0;
1621 for(j
= 0; j
< 2; j
++) {
1622 ph
->p_type
= PT_LOAD
;
1624 ph
->p_flags
= PF_R
| PF_X
;
1626 ph
->p_flags
= PF_R
| PF_W
;
1627 ph
->p_align
= s_align
;
1629 /* Decide the layout of sections loaded in memory. This must
1630 be done before program headers are filled since they contain
1631 info about the layout. We do the following ordering: interp,
1632 symbol tables, relocations, progbits, nobits */
1633 /* XXX: do faster and simpler sorting */
1634 for(k
= 0; k
< 5; k
++) {
1635 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1636 s
= s1
->sections
[i
];
1637 /* compute if section should be included */
1639 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1643 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1644 (SHF_ALLOC
| SHF_WRITE
))
1650 } else if (s
->sh_type
== SHT_DYNSYM
||
1651 s
->sh_type
== SHT_STRTAB
||
1652 s
->sh_type
== SHT_HASH
) {
1655 } else if (s
->sh_type
== SHT_RELX
) {
1658 } else if (s
->sh_type
== SHT_NOBITS
) {
1665 sec_order
[sh_order_index
++] = i
;
1667 /* section matches: we align it and add its size */
1669 addr
= (addr
+ s
->sh_addralign
- 1) &
1670 ~(s
->sh_addralign
- 1);
1671 file_offset
+= (int) ( addr
- tmp
);
1672 s
->sh_offset
= file_offset
;
1675 /* update program header infos */
1676 if (ph
->p_offset
== 0) {
1677 ph
->p_offset
= file_offset
;
1679 ph
->p_paddr
= ph
->p_vaddr
;
1681 /* update dynamic relocation infos */
1682 if (s
->sh_type
== SHT_RELX
) {
1683 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1684 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.got")) {
1685 dyninf
->rel_addr
= addr
;
1686 dyninf
->rel_size
+= s
->sh_size
; /* XXX only first rel. */
1688 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.bss")) {
1689 dyninf
->bss_addr
= addr
;
1690 dyninf
->bss_size
= s
->sh_size
; /* XXX only first rel. */
1693 if (dyninf
->rel_size
== 0)
1694 dyninf
->rel_addr
= addr
;
1695 dyninf
->rel_size
+= s
->sh_size
;
1699 if (s
->sh_type
!= SHT_NOBITS
)
1700 file_offset
+= s
->sh_size
;
1704 /* Make the first PT_LOAD segment include the program
1705 headers itself (and the ELF header as well), it'll
1706 come out with same memory use but will make various
1707 tools like binutils strip work better. */
1708 ph
->p_offset
&= ~(ph
->p_align
- 1);
1709 ph
->p_vaddr
&= ~(ph
->p_align
- 1);
1710 ph
->p_paddr
&= ~(ph
->p_align
- 1);
1712 ph
->p_filesz
= file_offset
- ph
->p_offset
;
1713 ph
->p_memsz
= addr
- ph
->p_vaddr
;
1716 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
) {
1717 /* if in the middle of a page, we duplicate the page in
1718 memory so that one copy is RX and the other is RW */
1719 if ((addr
& (s_align
- 1)) != 0)
1722 addr
= (addr
+ s_align
- 1) & ~(s_align
- 1);
1723 file_offset
= (file_offset
+ s_align
- 1) & ~(s_align
- 1);
1729 /* all other sections come after */
1730 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1731 s
= s1
->sections
[i
];
1732 if (phnum
> 0 && (s
->sh_flags
& SHF_ALLOC
))
1734 sec_order
[sh_order_index
++] = i
;
1736 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
1737 ~(s
->sh_addralign
- 1);
1738 s
->sh_offset
= file_offset
;
1739 if (s
->sh_type
!= SHT_NOBITS
)
1740 file_offset
+= s
->sh_size
;
1746 static void fill_unloadable_phdr(ElfW(Phdr
) *phdr
, int phnum
, Section
*interp
,
1751 /* if interpreter, then add corresponding program header */
1755 ph
->p_type
= PT_PHDR
;
1756 ph
->p_offset
= sizeof(ElfW(Ehdr
));
1757 ph
->p_filesz
= ph
->p_memsz
= phnum
* sizeof(ElfW(Phdr
));
1758 ph
->p_vaddr
= interp
->sh_addr
- ph
->p_filesz
;
1759 ph
->p_paddr
= ph
->p_vaddr
;
1760 ph
->p_flags
= PF_R
| PF_X
;
1761 ph
->p_align
= 4; /* interp->sh_addralign; */
1764 ph
->p_type
= PT_INTERP
;
1765 ph
->p_offset
= interp
->sh_offset
;
1766 ph
->p_vaddr
= interp
->sh_addr
;
1767 ph
->p_paddr
= ph
->p_vaddr
;
1768 ph
->p_filesz
= interp
->sh_size
;
1769 ph
->p_memsz
= interp
->sh_size
;
1771 ph
->p_align
= interp
->sh_addralign
;
1774 /* if dynamic section, then add corresponding program header */
1776 ph
= &phdr
[phnum
- 1];
1778 ph
->p_type
= PT_DYNAMIC
;
1779 ph
->p_offset
= dynamic
->sh_offset
;
1780 ph
->p_vaddr
= dynamic
->sh_addr
;
1781 ph
->p_paddr
= ph
->p_vaddr
;
1782 ph
->p_filesz
= dynamic
->sh_size
;
1783 ph
->p_memsz
= dynamic
->sh_size
;
1784 ph
->p_flags
= PF_R
| PF_W
;
1785 ph
->p_align
= dynamic
->sh_addralign
;
1789 /* Fill the dynamic section with tags describing the address and size of
1791 static void fill_dynamic(TCCState
*s1
, struct dyn_inf
*dyninf
)
1793 Section
*dynamic
= dyninf
->dynamic
;
1795 /* put dynamic section entries */
1796 put_dt(dynamic
, DT_HASH
, s1
->dynsym
->hash
->sh_addr
);
1797 put_dt(dynamic
, DT_STRTAB
, dyninf
->dynstr
->sh_addr
);
1798 put_dt(dynamic
, DT_SYMTAB
, s1
->dynsym
->sh_addr
);
1799 put_dt(dynamic
, DT_STRSZ
, dyninf
->dynstr
->data_offset
);
1800 put_dt(dynamic
, DT_SYMENT
, sizeof(ElfW(Sym
)));
1802 put_dt(dynamic
, DT_RELA
, dyninf
->rel_addr
);
1803 put_dt(dynamic
, DT_RELASZ
, dyninf
->rel_size
);
1804 put_dt(dynamic
, DT_RELAENT
, sizeof(ElfW_Rel
));
1806 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1807 put_dt(dynamic
, DT_PLTGOT
, s1
->got
->sh_addr
);
1808 put_dt(dynamic
, DT_PLTRELSZ
, dyninf
->rel_size
);
1809 put_dt(dynamic
, DT_JMPREL
, dyninf
->rel_addr
);
1810 put_dt(dynamic
, DT_PLTREL
, DT_REL
);
1811 put_dt(dynamic
, DT_REL
, dyninf
->bss_addr
);
1812 put_dt(dynamic
, DT_RELSZ
, dyninf
->bss_size
);
1814 put_dt(dynamic
, DT_REL
, dyninf
->rel_addr
);
1815 put_dt(dynamic
, DT_RELSZ
, dyninf
->rel_size
);
1816 put_dt(dynamic
, DT_RELENT
, sizeof(ElfW_Rel
));
1820 put_dt(dynamic
, DT_DEBUG
, 0);
1821 put_dt(dynamic
, DT_NULL
, 0);
1824 /* Relocate remaining sections and symbols (that is those not related to
1826 static int final_sections_reloc(TCCState
*s1
)
1831 relocate_syms(s1
, s1
->symtab
, 0);
1833 if (s1
->nb_errors
!= 0)
1836 /* relocate sections */
1837 /* XXX: ignore sections with allocated relocations ? */
1838 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1839 s
= s1
->sections
[i
];
1840 if (s
->reloc
&& s
!= s1
->got
)
1841 relocate_section(s1
, s
);
1844 /* relocate relocation entries if the relocation tables are
1845 allocated in the executable */
1846 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1847 s
= s1
->sections
[i
];
1848 if ((s
->sh_flags
& SHF_ALLOC
) &&
1849 s
->sh_type
== SHT_RELX
) {
1850 relocate_rel(s1
, s
);
1856 /* Create an ELF file on disk.
1857 This function handle ELF specific layout requirements */
1858 static void tcc_output_elf(TCCState
*s1
, FILE *f
, int phnum
, ElfW(Phdr
) *phdr
,
1859 int file_offset
, int *sec_order
)
1861 int i
, shnum
, offset
, size
, file_type
;
1864 ElfW(Shdr
) shdr
, *sh
;
1866 file_type
= s1
->output_type
;
1867 shnum
= s1
->nb_sections
;
1869 memset(&ehdr
, 0, sizeof(ehdr
));
1872 ehdr
.e_phentsize
= sizeof(ElfW(Phdr
));
1873 ehdr
.e_phnum
= phnum
;
1874 ehdr
.e_phoff
= sizeof(ElfW(Ehdr
));
1878 file_offset
= (file_offset
+ 3) & -4;
1881 ehdr
.e_ident
[0] = ELFMAG0
;
1882 ehdr
.e_ident
[1] = ELFMAG1
;
1883 ehdr
.e_ident
[2] = ELFMAG2
;
1884 ehdr
.e_ident
[3] = ELFMAG3
;
1885 ehdr
.e_ident
[4] = ELFCLASSW
;
1886 ehdr
.e_ident
[5] = ELFDATA2LSB
;
1887 ehdr
.e_ident
[6] = EV_CURRENT
;
1888 #if !defined(TCC_TARGET_PE) && (defined(__FreeBSD__) || defined(__FreeBSD_kernel__))
1889 /* FIXME: should set only for freebsd _target_, but we exclude only PE target */
1890 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
1892 #ifdef TCC_TARGET_ARM
1894 ehdr
.e_ident
[EI_OSABI
] = 0;
1895 ehdr
.e_flags
= EF_ARM_EABI_VER4
;
1896 if (file_type
== TCC_OUTPUT_EXE
|| file_type
== TCC_OUTPUT_DLL
)
1897 ehdr
.e_flags
|= EF_ARM_HASENTRY
;
1898 if (s1
->float_abi
== ARM_HARD_FLOAT
)
1899 ehdr
.e_flags
|= EF_ARM_VFP_FLOAT
;
1901 ehdr
.e_flags
|= EF_ARM_SOFT_FLOAT
;
1903 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_ARM
;
1908 case TCC_OUTPUT_EXE
:
1909 ehdr
.e_type
= ET_EXEC
;
1910 ehdr
.e_entry
= get_elf_sym_addr(s1
, "_start", 1);
1912 case TCC_OUTPUT_DLL
:
1913 ehdr
.e_type
= ET_DYN
;
1914 ehdr
.e_entry
= text_section
->sh_addr
; /* XXX: is it correct ? */
1916 case TCC_OUTPUT_OBJ
:
1917 ehdr
.e_type
= ET_REL
;
1920 ehdr
.e_machine
= EM_TCC_TARGET
;
1921 ehdr
.e_version
= EV_CURRENT
;
1922 ehdr
.e_shoff
= file_offset
;
1923 ehdr
.e_ehsize
= sizeof(ElfW(Ehdr
));
1924 ehdr
.e_shentsize
= sizeof(ElfW(Shdr
));
1925 ehdr
.e_shnum
= shnum
;
1926 ehdr
.e_shstrndx
= shnum
- 1;
1928 fwrite(&ehdr
, 1, sizeof(ElfW(Ehdr
)), f
);
1929 fwrite(phdr
, 1, phnum
* sizeof(ElfW(Phdr
)), f
);
1930 offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1932 sort_syms(s1
, symtab_section
);
1933 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1934 s
= s1
->sections
[sec_order
[i
]];
1935 if (s
->sh_type
!= SHT_NOBITS
) {
1936 while (offset
< s
->sh_offset
) {
1942 fwrite(s
->data
, 1, size
, f
);
1947 /* output section headers */
1948 while (offset
< ehdr
.e_shoff
) {
1953 for(i
= 0; i
< s1
->nb_sections
; i
++) {
1955 memset(sh
, 0, sizeof(ElfW(Shdr
)));
1956 s
= s1
->sections
[i
];
1958 sh
->sh_name
= s
->sh_name
;
1959 sh
->sh_type
= s
->sh_type
;
1960 sh
->sh_flags
= s
->sh_flags
;
1961 sh
->sh_entsize
= s
->sh_entsize
;
1962 sh
->sh_info
= s
->sh_info
;
1964 sh
->sh_link
= s
->link
->sh_num
;
1965 sh
->sh_addralign
= s
->sh_addralign
;
1966 sh
->sh_addr
= s
->sh_addr
;
1967 sh
->sh_offset
= s
->sh_offset
;
1968 sh
->sh_size
= s
->sh_size
;
1970 fwrite(sh
, 1, sizeof(ElfW(Shdr
)), f
);
1974 /* Write an elf, coff or "binary" file */
1975 static int tcc_write_elf_file(TCCState
*s1
, const char *filename
, int phnum
,
1976 ElfW(Phdr
) *phdr
, int file_offset
, int *sec_order
)
1978 int fd
, mode
, file_type
;
1981 file_type
= s1
->output_type
;
1982 if (file_type
== TCC_OUTPUT_OBJ
)
1987 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, mode
);
1989 tcc_error_noabort("could not write '%s'", filename
);
1992 f
= fdopen(fd
, "wb");
1994 printf("<- %s\n", filename
);
1996 #ifdef TCC_TARGET_COFF
1997 if (s1
->output_format
== TCC_OUTPUT_FORMAT_COFF
)
1998 tcc_output_coff(s1
, f
);
2001 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
2002 tcc_output_elf(s1
, f
, phnum
, phdr
, file_offset
, sec_order
);
2004 tcc_output_binary(s1
, f
, sec_order
);
2010 /* Sort section headers by assigned sh_addr, remove sections
2011 that we aren't going to output. */
2012 static void tidy_section_headers(TCCState
*s1
, int *sec_order
)
2014 int i
, nnew
, l
, *backmap
;
2018 snew
= tcc_malloc(s1
->nb_sections
* sizeof(snew
[0]));
2019 backmap
= tcc_malloc(s1
->nb_sections
* sizeof(backmap
[0]));
2020 for (i
= 0, nnew
= 0, l
= s1
->nb_sections
; i
< s1
->nb_sections
; i
++) {
2021 s
= s1
->sections
[sec_order
[i
]];
2022 if (!i
|| s
->sh_name
) {
2023 backmap
[sec_order
[i
]] = nnew
;
2027 backmap
[sec_order
[i
]] = 0;
2031 for (i
= 0; i
< nnew
; i
++) {
2035 if (s
->sh_type
== SHT_RELX
)
2036 s
->sh_info
= backmap
[s
->sh_info
];
2040 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
))
2041 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
)
2042 sym
->st_shndx
= backmap
[sym
->st_shndx
];
2043 if( !s1
->static_link
) {
2044 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
))
2045 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
)
2046 sym
->st_shndx
= backmap
[sym
->st_shndx
];
2048 for (i
= 0; i
< s1
->nb_sections
; i
++)
2050 tcc_free(s1
->sections
);
2051 s1
->sections
= snew
;
2052 s1
->nb_sections
= nnew
;
2056 /* Output an elf, coff or binary file */
2057 /* XXX: suppress unneeded sections */
2058 static int elf_output_file(TCCState
*s1
, const char *filename
)
2060 int i
, ret
, phnum
, shnum
, file_type
, file_offset
, *sec_order
;
2061 struct dyn_inf dyninf
= {0};
2064 Section
*strsec
, *interp
, *dynamic
, *dynstr
;
2067 file_type
= s1
->output_type
;
2072 interp
= dynamic
= dynstr
= NULL
; /* avoid warning */
2075 if (file_type
!= TCC_OUTPUT_OBJ
) {
2076 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2077 tcc_add_runtime(s1
);
2078 resolve_common_syms(s1
);
2080 if (!s1
->static_link
) {
2081 if (file_type
== TCC_OUTPUT_EXE
) {
2083 /* allow override the dynamic loader */
2084 const char *elfint
= getenv("LD_SO");
2086 elfint
= DEFAULT_ELFINTERP(s1
);
2087 /* add interpreter section only if executable */
2088 interp
= new_section(s1
, ".interp", SHT_PROGBITS
, SHF_ALLOC
);
2089 interp
->sh_addralign
= 1;
2090 ptr
= section_ptr_add(interp
, 1 + strlen(elfint
));
2091 strcpy(ptr
, elfint
);
2094 /* add dynamic symbol table */
2095 s1
->dynsym
= new_symtab(s1
, ".dynsym", SHT_DYNSYM
, SHF_ALLOC
,
2097 ".hash", SHF_ALLOC
);
2098 dynstr
= s1
->dynsym
->link
;
2100 /* add dynamic section */
2101 dynamic
= new_section(s1
, ".dynamic", SHT_DYNAMIC
,
2102 SHF_ALLOC
| SHF_WRITE
);
2103 dynamic
->link
= dynstr
;
2104 dynamic
->sh_entsize
= sizeof(ElfW(Dyn
));
2108 if (file_type
== TCC_OUTPUT_EXE
) {
2109 bind_exe_dynsyms(s1
);
2112 bind_libs_dynsyms(s1
);
2114 /* shared library case: simply export all global symbols */
2115 export_global_syms(s1
);
2118 build_got_entries(s1
);
2121 /* we add a section for symbols */
2122 strsec
= new_section(s1
, ".shstrtab", SHT_STRTAB
, 0);
2123 put_elf_str(strsec
, "");
2125 /* Allocate strings for section names */
2126 textrel
= alloc_sec_names(s1
, file_type
, strsec
);
2129 /* add a list of needed dlls */
2130 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2131 DLLReference
*dllref
= s1
->loaded_dlls
[i
];
2132 if (dllref
->level
== 0)
2133 put_dt(dynamic
, DT_NEEDED
, put_elf_str(dynstr
, dllref
->name
));
2137 put_dt(dynamic
, s1
->enable_new_dtags
? DT_RUNPATH
: DT_RPATH
,
2138 put_elf_str(dynstr
, s1
->rpath
));
2140 if (file_type
== TCC_OUTPUT_DLL
) {
2142 put_dt(dynamic
, DT_SONAME
, put_elf_str(dynstr
, s1
->soname
));
2143 /* XXX: currently, since we do not handle PIC code, we
2144 must relocate the readonly segments */
2146 put_dt(dynamic
, DT_TEXTREL
, 0);
2150 put_dt(dynamic
, DT_SYMBOLIC
, 0);
2152 dyninf
.dynamic
= dynamic
;
2153 dyninf
.dynstr
= dynstr
;
2154 /* remember offset and reserve space for 2nd call below */
2155 dyninf
.data_offset
= dynamic
->data_offset
;
2156 fill_dynamic(s1
, &dyninf
);
2157 dynamic
->sh_size
= dynamic
->data_offset
;
2158 dynstr
->sh_size
= dynstr
->data_offset
;
2161 /* compute number of program headers */
2162 if (file_type
== TCC_OUTPUT_OBJ
)
2164 else if (file_type
== TCC_OUTPUT_DLL
)
2166 else if (s1
->static_link
)
2171 /* allocate program segment headers */
2172 phdr
= tcc_mallocz(phnum
* sizeof(ElfW(Phdr
)));
2174 /* compute number of sections */
2175 shnum
= s1
->nb_sections
;
2177 /* this array is used to reorder sections in the output file */
2178 sec_order
= tcc_malloc(sizeof(int) * shnum
);
2181 /* compute section to program header mapping */
2182 file_offset
= layout_sections(s1
, phdr
, phnum
, interp
, strsec
, &dyninf
,
2185 /* Fill remaining program header and finalize relocation related to dynamic
2187 if (file_type
!= TCC_OUTPUT_OBJ
) {
2188 fill_unloadable_phdr(phdr
, phnum
, interp
, dynamic
);
2190 dynamic
->data_offset
= dyninf
.data_offset
;
2191 fill_dynamic(s1
, &dyninf
);
2193 /* put in GOT the dynamic section address and relocate PLT */
2194 write32le(s1
->got
->data
, dynamic
->sh_addr
);
2195 if (file_type
== TCC_OUTPUT_EXE
2196 || (RELOCATE_DLLPLT
&& file_type
== TCC_OUTPUT_DLL
))
2199 /* relocate symbols in .dynsym now that final addresses are known */
2200 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
)) {
2201 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
) {
2202 /* do symbol relocation */
2203 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
2208 /* if building executable or DLL, then relocate each section
2209 except the GOT which is already relocated */
2210 ret
= final_sections_reloc(s1
);
2213 tidy_section_headers(s1
, sec_order
);
2215 /* Perform relocation to GOT or PLT entries */
2216 if (file_type
== TCC_OUTPUT_EXE
&& s1
->static_link
)
2219 fill_local_got_entries(s1
);
2222 /* Create the ELF file with name 'filename' */
2223 ret
= tcc_write_elf_file(s1
, filename
, phnum
, phdr
, file_offset
, sec_order
);
2224 s1
->nb_sections
= shnum
;
2226 tcc_free(sec_order
);
2231 LIBTCCAPI
int tcc_output_file(TCCState
*s
, const char *filename
)
2234 #ifdef TCC_TARGET_PE
2235 if (s
->output_type
!= TCC_OUTPUT_OBJ
) {
2236 ret
= pe_output_file(s
, filename
);
2239 ret
= elf_output_file(s
, filename
);
2243 static void *load_data(int fd
, unsigned long file_offset
, unsigned long size
)
2247 data
= tcc_malloc(size
);
2248 lseek(fd
, file_offset
, SEEK_SET
);
2249 read(fd
, data
, size
);
2253 typedef struct SectionMergeInfo
{
2254 Section
*s
; /* corresponding existing section */
2255 unsigned long offset
; /* offset of the new section in the existing section */
2256 uint8_t new_section
; /* true if section 's' was added */
2257 uint8_t link_once
; /* true if link once section */
2260 ST_FUNC
int tcc_object_type(int fd
, ElfW(Ehdr
) *h
)
2262 int size
= read(fd
, h
, sizeof *h
);
2263 if (size
== sizeof *h
&& 0 == memcmp(h
, ELFMAG
, 4)) {
2264 if (h
->e_type
== ET_REL
)
2265 return AFF_BINTYPE_REL
;
2266 if (h
->e_type
== ET_DYN
)
2267 return AFF_BINTYPE_DYN
;
2268 } else if (size
>= 8) {
2269 if (0 == memcmp(h
, ARMAG
, 8))
2270 return AFF_BINTYPE_AR
;
2271 #ifdef TCC_TARGET_COFF
2272 if (((struct filehdr
*)h
)->f_magic
== COFF_C67_MAGIC
)
2273 return AFF_BINTYPE_C67
;
2279 /* load an object file and merge it with current files */
2280 /* XXX: handle correctly stab (debug) info */
2281 ST_FUNC
int tcc_load_object_file(TCCState
*s1
,
2282 int fd
, unsigned long file_offset
)
2285 ElfW(Shdr
) *shdr
, *sh
;
2286 int size
, i
, j
, offset
, offseti
, nb_syms
, sym_index
, ret
, seencompressed
;
2287 unsigned char *strsec
, *strtab
;
2288 int *old_to_new_syms
;
2289 char *sh_name
, *name
;
2290 SectionMergeInfo
*sm_table
, *sm
;
2291 ElfW(Sym
) *sym
, *symtab
;
2298 stab_index
= stabstr_index
= 0;
2300 lseek(fd
, file_offset
, SEEK_SET
);
2301 if (tcc_object_type(fd
, &ehdr
) != AFF_BINTYPE_REL
)
2303 /* test CPU specific stuff */
2304 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2305 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2307 tcc_error_noabort("invalid object file");
2311 shdr
= load_data(fd
, file_offset
+ ehdr
.e_shoff
,
2312 sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2313 sm_table
= tcc_mallocz(sizeof(SectionMergeInfo
) * ehdr
.e_shnum
);
2315 /* load section names */
2316 sh
= &shdr
[ehdr
.e_shstrndx
];
2317 strsec
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2319 /* load symtab and strtab */
2320 old_to_new_syms
= NULL
;
2325 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2327 if (sh
->sh_type
== SHT_SYMTAB
) {
2329 tcc_error_noabort("object must contain only one symtab");
2334 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2335 symtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2336 sm_table
[i
].s
= symtab_section
;
2338 /* now load strtab */
2339 sh
= &shdr
[sh
->sh_link
];
2340 strtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2342 if (sh
->sh_flags
& SHF_COMPRESSED
)
2346 /* now examine each section and try to merge its content with the
2348 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2349 /* no need to examine section name strtab */
2350 if (i
== ehdr
.e_shstrndx
)
2353 sh_name
= (char *) strsec
+ sh
->sh_name
;
2354 /* ignore sections types we do not handle */
2355 if (sh
->sh_type
!= SHT_PROGBITS
&&
2356 sh
->sh_type
!= SHT_RELX
&&
2358 sh
->sh_type
!= SHT_ARM_EXIDX
&&
2360 sh
->sh_type
!= SHT_NOBITS
&&
2361 sh
->sh_type
!= SHT_PREINIT_ARRAY
&&
2362 sh
->sh_type
!= SHT_INIT_ARRAY
&&
2363 sh
->sh_type
!= SHT_FINI_ARRAY
&&
2364 strcmp(sh_name
, ".stabstr")
2368 && (!strncmp(sh_name
, ".debug_", sizeof(".debug_")-1)
2369 || (sh
->sh_type
== SHT_RELX
2370 && !strncmp((char*)strsec
+ shdr
[sh
->sh_info
].sh_name
,
2371 ".debug_", sizeof(".debug_")-1))))
2373 if (sh
->sh_addralign
< 1)
2374 sh
->sh_addralign
= 1;
2375 /* find corresponding section, if any */
2376 for(j
= 1; j
< s1
->nb_sections
;j
++) {
2377 s
= s1
->sections
[j
];
2378 if (!strcmp(s
->name
, sh_name
)) {
2379 if (!strncmp(sh_name
, ".gnu.linkonce",
2380 sizeof(".gnu.linkonce") - 1)) {
2381 /* if a 'linkonce' section is already present, we
2382 do not add it again. It is a little tricky as
2383 symbols can still be defined in
2385 sm_table
[i
].link_once
= 1;
2392 /* not found: create new section */
2393 s
= new_section(s1
, sh_name
, sh
->sh_type
, sh
->sh_flags
& ~SHF_GROUP
);
2394 /* take as much info as possible from the section. sh_link and
2395 sh_info will be updated later */
2396 s
->sh_addralign
= sh
->sh_addralign
;
2397 s
->sh_entsize
= sh
->sh_entsize
;
2398 sm_table
[i
].new_section
= 1;
2400 if (sh
->sh_type
!= s
->sh_type
) {
2401 tcc_error_noabort("invalid section type");
2405 /* align start of section */
2406 offset
= s
->data_offset
;
2408 if (0 == strcmp(sh_name
, ".stab")) {
2412 if (0 == strcmp(sh_name
, ".stabstr")) {
2417 size
= sh
->sh_addralign
- 1;
2418 offset
= (offset
+ size
) & ~size
;
2419 if (sh
->sh_addralign
> s
->sh_addralign
)
2420 s
->sh_addralign
= sh
->sh_addralign
;
2421 s
->data_offset
= offset
;
2423 sm_table
[i
].offset
= offset
;
2425 /* concatenate sections */
2427 if (sh
->sh_type
!= SHT_NOBITS
) {
2429 lseek(fd
, file_offset
+ sh
->sh_offset
, SEEK_SET
);
2430 ptr
= section_ptr_add(s
, size
);
2431 read(fd
, ptr
, size
);
2433 s
->data_offset
+= size
;
2438 /* gr relocate stab strings */
2439 if (stab_index
&& stabstr_index
) {
2442 s
= sm_table
[stab_index
].s
;
2443 a
= (Stab_Sym
*)(s
->data
+ sm_table
[stab_index
].offset
);
2444 b
= (Stab_Sym
*)(s
->data
+ s
->data_offset
);
2445 o
= sm_table
[stabstr_index
].offset
;
2447 a
->n_strx
+= o
, a
++;
2450 /* second short pass to update sh_link and sh_info fields of new
2452 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2454 if (!s
|| !sm_table
[i
].new_section
)
2457 if (sh
->sh_link
> 0)
2458 s
->link
= sm_table
[sh
->sh_link
].s
;
2459 if (sh
->sh_type
== SHT_RELX
) {
2460 s
->sh_info
= sm_table
[sh
->sh_info
].s
->sh_num
;
2461 /* update backward link */
2462 s1
->sections
[s
->sh_info
]->reloc
= s
;
2467 /* resolve symbols */
2468 old_to_new_syms
= tcc_mallocz(nb_syms
* sizeof(int));
2471 for(i
= 1; i
< nb_syms
; i
++, sym
++) {
2472 if (sym
->st_shndx
!= SHN_UNDEF
&&
2473 sym
->st_shndx
< SHN_LORESERVE
) {
2474 sm
= &sm_table
[sym
->st_shndx
];
2475 if (sm
->link_once
) {
2476 /* if a symbol is in a link once section, we use the
2477 already defined symbol. It is very important to get
2478 correct relocations */
2479 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
2480 name
= (char *) strtab
+ sym
->st_name
;
2481 sym_index
= find_elf_sym(symtab_section
, name
);
2483 old_to_new_syms
[i
] = sym_index
;
2487 /* if no corresponding section added, no need to add symbol */
2490 /* convert section number */
2491 sym
->st_shndx
= sm
->s
->sh_num
;
2493 sym
->st_value
+= sm
->offset
;
2496 name
= (char *) strtab
+ sym
->st_name
;
2497 sym_index
= set_elf_sym(symtab_section
, sym
->st_value
, sym
->st_size
,
2498 sym
->st_info
, sym
->st_other
,
2499 sym
->st_shndx
, name
);
2500 old_to_new_syms
[i
] = sym_index
;
2503 /* third pass to patch relocation entries */
2504 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2509 offset
= sm_table
[i
].offset
;
2510 switch(s
->sh_type
) {
2512 /* take relocation offset information */
2513 offseti
= sm_table
[sh
->sh_info
].offset
;
2514 for_each_elem(s
, (offset
/ sizeof(*rel
)), rel
, ElfW_Rel
) {
2517 /* convert symbol index */
2518 type
= ELFW(R_TYPE
)(rel
->r_info
);
2519 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
2520 /* NOTE: only one symtab assumed */
2521 if (sym_index
>= nb_syms
)
2523 sym_index
= old_to_new_syms
[sym_index
];
2524 /* ignore link_once in rel section. */
2525 if (!sym_index
&& !sm
->link_once
2526 #ifdef TCC_TARGET_ARM
2527 && type
!= R_ARM_V4BX
2531 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2532 i
, strsec
+ sh
->sh_name
, rel
->r_offset
);
2535 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
2536 /* offset the relocation offset */
2537 rel
->r_offset
+= offseti
;
2538 #ifdef TCC_TARGET_ARM
2539 /* Jumps and branches from a Thumb code to a PLT entry need
2540 special handling since PLT entries are ARM code.
2541 Unconditional bl instructions referencing PLT entries are
2542 handled by converting these instructions into blx
2543 instructions. Other case of instructions referencing a PLT
2544 entry require to add a Thumb stub before the PLT entry to
2545 switch to ARM mode. We set bit plt_thumb_stub of the
2546 attribute of a symbol to indicate such a case. */
2547 if (type
== R_ARM_THM_JUMP24
)
2548 get_sym_attr(s1
, sym_index
, 1)->plt_thumb_stub
= 1;
2561 tcc_free(old_to_new_syms
);
2568 typedef struct ArchiveHeader
{
2569 char ar_name
[16]; /* name of this member */
2570 char ar_date
[12]; /* file mtime */
2571 char ar_uid
[6]; /* owner uid; printed as decimal */
2572 char ar_gid
[6]; /* owner gid; printed as decimal */
2573 char ar_mode
[8]; /* file mode, printed as octal */
2574 char ar_size
[10]; /* file size, printed as decimal */
2575 char ar_fmag
[2]; /* should contain ARFMAG */
2578 static int get_be32(const uint8_t *b
)
2580 return b
[3] | (b
[2] << 8) | (b
[1] << 16) | (b
[0] << 24);
2583 static long get_be64(const uint8_t *b
)
2585 long long ret
= get_be32(b
);
2586 ret
= (ret
<< 32) | (unsigned)get_be32(b
+4);
2590 /* load only the objects which resolve undefined symbols */
2591 static int tcc_load_alacarte(TCCState
*s1
, int fd
, int size
, int entrysize
)
2593 long i
, bound
, nsyms
, sym_index
, off
, ret
;
2595 const char *ar_names
, *p
;
2596 const uint8_t *ar_index
;
2599 data
= tcc_malloc(size
);
2600 if (read(fd
, data
, size
) != size
)
2602 nsyms
= entrysize
== 4 ? get_be32(data
) : get_be64(data
);
2603 ar_index
= data
+ entrysize
;
2604 ar_names
= (char *) ar_index
+ nsyms
* entrysize
;
2608 for(p
= ar_names
, i
= 0; i
< nsyms
; i
++, p
+= strlen(p
)+1) {
2609 sym_index
= find_elf_sym(symtab_section
, p
);
2611 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
2612 if(sym
->st_shndx
== SHN_UNDEF
) {
2613 off
= (entrysize
== 4
2614 ? get_be32(ar_index
+ i
* 4)
2615 : get_be64(ar_index
+ i
* 8))
2616 + sizeof(ArchiveHeader
);
2618 if(tcc_load_object_file(s1
, fd
, off
) < 0) {
2633 /* load a '.a' file */
2634 ST_FUNC
int tcc_load_archive(TCCState
*s1
, int fd
, int alacarte
)
2641 unsigned long file_offset
;
2643 /* skip magic which was already checked */
2644 read(fd
, magic
, sizeof(magic
));
2647 len
= read(fd
, &hdr
, sizeof(hdr
));
2650 if (len
!= sizeof(hdr
)) {
2651 tcc_error_noabort("invalid archive");
2654 memcpy(ar_size
, hdr
.ar_size
, sizeof(hdr
.ar_size
));
2655 ar_size
[sizeof(hdr
.ar_size
)] = '\0';
2656 size
= strtol(ar_size
, NULL
, 0);
2657 memcpy(ar_name
, hdr
.ar_name
, sizeof(hdr
.ar_name
));
2658 for(i
= sizeof(hdr
.ar_name
) - 1; i
>= 0; i
--) {
2659 if (ar_name
[i
] != ' ')
2662 ar_name
[i
+ 1] = '\0';
2663 file_offset
= lseek(fd
, 0, SEEK_CUR
);
2665 size
= (size
+ 1) & ~1;
2666 if (!strcmp(ar_name
, "/")) {
2667 /* coff symbol table : we handle it */
2669 return tcc_load_alacarte(s1
, fd
, size
, 4);
2670 } else if (!strcmp(ar_name
, "/SYM64/")) {
2672 return tcc_load_alacarte(s1
, fd
, size
, 8);
2675 if (tcc_object_type(fd
, &ehdr
) == AFF_BINTYPE_REL
) {
2676 if (tcc_load_object_file(s1
, fd
, file_offset
) < 0)
2680 lseek(fd
, file_offset
+ size
, SEEK_SET
);
2685 #ifndef TCC_TARGET_PE
2686 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2687 is referenced by the user (so it should be added as DT_NEEDED in
2688 the generated ELF file) */
2689 ST_FUNC
int tcc_load_dll(TCCState
*s1
, int fd
, const char *filename
, int level
)
2692 ElfW(Shdr
) *shdr
, *sh
, *sh1
;
2693 int i
, j
, nb_syms
, nb_dts
, sym_bind
, ret
;
2694 ElfW(Sym
) *sym
, *dynsym
;
2695 ElfW(Dyn
) *dt
, *dynamic
;
2696 unsigned char *dynstr
;
2697 const char *name
, *soname
;
2698 DLLReference
*dllref
;
2700 read(fd
, &ehdr
, sizeof(ehdr
));
2702 /* test CPU specific stuff */
2703 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2704 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2705 tcc_error_noabort("bad architecture");
2710 shdr
= load_data(fd
, ehdr
.e_shoff
, sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2712 /* load dynamic section and dynamic symbols */
2716 dynsym
= NULL
; /* avoid warning */
2717 dynstr
= NULL
; /* avoid warning */
2718 for(i
= 0, sh
= shdr
; i
< ehdr
.e_shnum
; i
++, sh
++) {
2719 switch(sh
->sh_type
) {
2721 nb_dts
= sh
->sh_size
/ sizeof(ElfW(Dyn
));
2722 dynamic
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2725 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2726 dynsym
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2727 sh1
= &shdr
[sh
->sh_link
];
2728 dynstr
= load_data(fd
, sh1
->sh_offset
, sh1
->sh_size
);
2735 /* compute the real library name */
2736 soname
= tcc_basename(filename
);
2738 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2739 if (dt
->d_tag
== DT_SONAME
) {
2740 soname
= (char *) dynstr
+ dt
->d_un
.d_val
;
2744 /* if the dll is already loaded, do not load it */
2745 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2746 dllref
= s1
->loaded_dlls
[i
];
2747 if (!strcmp(soname
, dllref
->name
)) {
2748 /* but update level if needed */
2749 if (level
< dllref
->level
)
2750 dllref
->level
= level
;
2756 /* add the dll and its level */
2757 dllref
= tcc_mallocz(sizeof(DLLReference
) + strlen(soname
));
2758 dllref
->level
= level
;
2759 strcpy(dllref
->name
, soname
);
2760 dynarray_add(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
, dllref
);
2762 /* add dynamic symbols in dynsym_section */
2763 for(i
= 1, sym
= dynsym
+ 1; i
< nb_syms
; i
++, sym
++) {
2764 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
2765 if (sym_bind
== STB_LOCAL
)
2767 name
= (char *) dynstr
+ sym
->st_name
;
2768 set_elf_sym(s1
->dynsymtab_section
, sym
->st_value
, sym
->st_size
,
2769 sym
->st_info
, sym
->st_other
, sym
->st_shndx
, name
);
2772 /* load all referenced DLLs */
2773 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2776 name
= (char *) dynstr
+ dt
->d_un
.d_val
;
2777 for(j
= 0; j
< s1
->nb_loaded_dlls
; j
++) {
2778 dllref
= s1
->loaded_dlls
[j
];
2779 if (!strcmp(name
, dllref
->name
))
2780 goto already_loaded
;
2782 if (tcc_add_dll(s1
, name
, AFF_REFERENCED_DLL
) < 0) {
2783 tcc_error_noabort("referenced dll '%s' not found", name
);
2800 #define LD_TOK_NAME 256
2801 #define LD_TOK_EOF (-1)
2803 /* return next ld script token */
2804 static int ld_next(TCCState
*s1
, char *name
, int name_size
)
2822 file
->buf_ptr
= parse_comment(file
->buf_ptr
);
2823 ch
= file
->buf_ptr
[0];
2836 /* case 'a' ... 'z': */
2863 /* case 'A' ... 'z': */
2897 if (!((ch
>= 'a' && ch
<= 'z') ||
2898 (ch
>= 'A' && ch
<= 'Z') ||
2899 (ch
>= '0' && ch
<= '9') ||
2900 strchr("/.-_+=$:\\,~", ch
)))
2902 if ((q
- name
) < name_size
- 1) {
2921 static int ld_add_file(TCCState
*s1
, const char filename
[])
2923 if (filename
[0] == '/') {
2924 if (CONFIG_SYSROOT
[0] == '\0'
2925 && tcc_add_file_internal(s1
, filename
, AFF_TYPE_BIN
) == 0)
2927 filename
= tcc_basename(filename
);
2929 return tcc_add_dll(s1
, filename
, 0);
2932 static inline int new_undef_syms(void)
2935 ret
= new_undef_sym
;
2940 static int ld_add_file_list(TCCState
*s1
, const char *cmd
, int as_needed
)
2942 char filename
[1024], libname
[1024];
2943 int t
, group
, nblibs
= 0, ret
= 0;
2946 group
= !strcmp(cmd
, "GROUP");
2949 t
= ld_next(s1
, filename
, sizeof(filename
));
2952 t
= ld_next(s1
, filename
, sizeof(filename
));
2955 if (t
== LD_TOK_EOF
) {
2956 tcc_error_noabort("unexpected end of file");
2958 goto lib_parse_error
;
2959 } else if (t
== ')') {
2961 } else if (t
== '-') {
2962 t
= ld_next(s1
, filename
, sizeof(filename
));
2963 if ((t
!= LD_TOK_NAME
) || (filename
[0] != 'l')) {
2964 tcc_error_noabort("library name expected");
2966 goto lib_parse_error
;
2968 pstrcpy(libname
, sizeof libname
, &filename
[1]);
2969 if (s1
->static_link
) {
2970 snprintf(filename
, sizeof filename
, "lib%s.a", libname
);
2972 snprintf(filename
, sizeof filename
, "lib%s.so", libname
);
2974 } else if (t
!= LD_TOK_NAME
) {
2975 tcc_error_noabort("filename expected");
2977 goto lib_parse_error
;
2979 if (!strcmp(filename
, "AS_NEEDED")) {
2980 ret
= ld_add_file_list(s1
, cmd
, 1);
2982 goto lib_parse_error
;
2984 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2986 ret
= ld_add_file(s1
, filename
);
2988 goto lib_parse_error
;
2990 /* Add the filename *and* the libname to avoid future conversions */
2991 dynarray_add(&libs
, &nblibs
, tcc_strdup(filename
));
2992 if (libname
[0] != '\0')
2993 dynarray_add(&libs
, &nblibs
, tcc_strdup(libname
));
2997 t
= ld_next(s1
, filename
, sizeof(filename
));
2999 t
= ld_next(s1
, filename
, sizeof(filename
));
3002 if (group
&& !as_needed
) {
3003 while (new_undef_syms()) {
3006 for (i
= 0; i
< nblibs
; i
++)
3007 ld_add_file(s1
, libs
[i
]);
3011 dynarray_reset(&libs
, &nblibs
);
3015 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3017 ST_FUNC
int tcc_load_ldscript(TCCState
*s1
)
3020 char filename
[1024];
3025 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3026 if (t
== LD_TOK_EOF
)
3028 else if (t
!= LD_TOK_NAME
)
3030 if (!strcmp(cmd
, "INPUT") ||
3031 !strcmp(cmd
, "GROUP")) {
3032 ret
= ld_add_file_list(s1
, cmd
, 0);
3035 } else if (!strcmp(cmd
, "OUTPUT_FORMAT") ||
3036 !strcmp(cmd
, "TARGET")) {
3037 /* ignore some commands */
3038 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3042 t
= ld_next(s1
, filename
, sizeof(filename
));
3043 if (t
== LD_TOK_EOF
) {
3044 tcc_error_noabort("unexpected end of file");
3046 } else if (t
== ')') {
3056 #endif /* !TCC_TARGET_PE */