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
, *strtab_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 /* ------------------------------------------------------------------------- */
50 ST_FUNC
void tccelf_new(TCCState
*s
)
53 dynarray_add(&s
->sections
, &s
->nb_sections
, NULL
);
55 /* create standard sections */
56 text_section
= new_section(s
, ".text", SHT_PROGBITS
, SHF_ALLOC
| SHF_EXECINSTR
);
57 data_section
= new_section(s
, ".data", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
58 bss_section
= new_section(s
, ".bss", SHT_NOBITS
, SHF_ALLOC
| SHF_WRITE
);
59 common_section
= new_section(s
, ".common", SHT_NOBITS
, SHF_PRIVATE
);
60 common_section
->sh_num
= SHN_COMMON
;
62 /* symbols are always generated for linking stage */
63 symtab_section
= new_symtab(s
, ".symtab", SHT_SYMTAB
, 0,
65 ".hashtab", SHF_PRIVATE
);
66 strtab_section
= symtab_section
->link
;
67 s
->symtab
= symtab_section
;
69 /* private symbol table for dynamic symbols */
70 s
->dynsymtab_section
= new_symtab(s
, ".dynsymtab", SHT_SYMTAB
, SHF_PRIVATE
,
72 ".dynhashtab", SHF_PRIVATE
);
73 get_sym_attr(s
, 0, 1);
76 #ifdef CONFIG_TCC_BCHECK
77 ST_FUNC
void tccelf_bounds_new(TCCState
*s
)
79 /* create bounds sections */
80 bounds_section
= new_section(s
, ".bounds",
81 SHT_PROGBITS
, SHF_ALLOC
);
82 lbounds_section
= new_section(s
, ".lbounds",
83 SHT_PROGBITS
, SHF_ALLOC
);
87 ST_FUNC
void tccelf_stab_new(TCCState
*s
)
89 stab_section
= new_section(s
, ".stab", SHT_PROGBITS
, 0);
90 stab_section
->sh_entsize
= sizeof(Stab_Sym
);
91 stabstr_section
= new_section(s
, ".stabstr", SHT_STRTAB
, 0);
92 put_elf_str(stabstr_section
, "");
93 stab_section
->link
= stabstr_section
;
95 put_stabs("", 0, 0, 0, 0);
98 static void free_section(Section
*s
)
103 ST_FUNC
void tccelf_delete(TCCState
*s1
)
107 /* free all sections */
108 for(i
= 1; i
< s1
->nb_sections
; i
++)
109 free_section(s1
->sections
[i
]);
110 dynarray_reset(&s1
->sections
, &s1
->nb_sections
);
112 for(i
= 0; i
< s1
->nb_priv_sections
; i
++)
113 free_section(s1
->priv_sections
[i
]);
114 dynarray_reset(&s1
->priv_sections
, &s1
->nb_priv_sections
);
116 /* free any loaded DLLs */
118 for ( i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
119 DLLReference
*ref
= s1
->loaded_dlls
[i
];
122 FreeLibrary((HMODULE
)ref
->handle
);
124 dlclose(ref
->handle
);
128 /* free loaded dlls array */
129 dynarray_reset(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
);
130 tcc_free(s1
->sym_attrs
);
133 ST_FUNC Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
)
137 sec
= tcc_mallocz(sizeof(Section
) + strlen(name
));
138 strcpy(sec
->name
, name
);
139 sec
->sh_type
= sh_type
;
140 sec
->sh_flags
= sh_flags
;
148 sec
->sh_addralign
= 4;
151 sec
->sh_addralign
= 1;
154 sec
->sh_addralign
= PTR_SIZE
; /* gcc/pcc default alignment */
158 if (sh_flags
& SHF_PRIVATE
) {
159 dynarray_add(&s1
->priv_sections
, &s1
->nb_priv_sections
, sec
);
161 sec
->sh_num
= s1
->nb_sections
;
162 dynarray_add(&s1
->sections
, &s1
->nb_sections
, sec
);
168 ST_FUNC Section
*new_symtab(TCCState
*s1
,
169 const char *symtab_name
, int sh_type
, int sh_flags
,
170 const char *strtab_name
,
171 const char *hash_name
, int hash_sh_flags
)
173 Section
*symtab
, *strtab
, *hash
;
174 int *ptr
, nb_buckets
;
176 symtab
= new_section(s1
, symtab_name
, sh_type
, sh_flags
);
177 symtab
->sh_entsize
= sizeof(ElfW(Sym
));
178 strtab
= new_section(s1
, strtab_name
, SHT_STRTAB
, sh_flags
);
179 put_elf_str(strtab
, "");
180 symtab
->link
= strtab
;
181 put_elf_sym(symtab
, 0, 0, 0, 0, 0, NULL
);
185 hash
= new_section(s1
, hash_name
, SHT_HASH
, hash_sh_flags
);
186 hash
->sh_entsize
= sizeof(int);
190 ptr
= section_ptr_add(hash
, (2 + nb_buckets
+ 1) * sizeof(int));
193 memset(ptr
+ 2, 0, (nb_buckets
+ 1) * sizeof(int));
197 /* realloc section and set its content to zero */
198 ST_FUNC
void section_realloc(Section
*sec
, unsigned long new_size
)
203 size
= sec
->data_allocated
;
206 while (size
< new_size
)
208 data
= tcc_realloc(sec
->data
, size
);
209 memset(data
+ sec
->data_allocated
, 0, size
- sec
->data_allocated
);
211 sec
->data_allocated
= size
;
214 /* reserve at least 'size' bytes aligned per 'align' in section
215 'sec' from current offset, and return the aligned offset */
216 ST_FUNC
size_t section_add(Section
*sec
, addr_t size
, int align
)
218 size_t offset
, offset1
;
220 offset
= (sec
->data_offset
+ align
- 1) & -align
;
221 offset1
= offset
+ size
;
222 if (sec
->sh_type
!= SHT_NOBITS
&& offset1
> sec
->data_allocated
)
223 section_realloc(sec
, offset1
);
224 sec
->data_offset
= offset1
;
225 if (align
> sec
->sh_addralign
)
226 sec
->sh_addralign
= align
;
230 /* reserve at least 'size' bytes in section 'sec' from
232 ST_FUNC
void *section_ptr_add(Section
*sec
, addr_t size
)
234 size_t offset
= section_add(sec
, size
, 1);
235 return sec
->data
+ offset
;
238 /* reserve at least 'size' bytes from section start */
239 ST_FUNC
void section_reserve(Section
*sec
, unsigned long size
)
241 if (size
> sec
->data_allocated
)
242 section_realloc(sec
, size
);
243 if (size
> sec
->data_offset
)
244 sec
->data_offset
= size
;
247 /* return a reference to a section, and create it if it does not
249 ST_FUNC Section
*find_section(TCCState
*s1
, const char *name
)
253 for(i
= 1; i
< s1
->nb_sections
; i
++) {
254 sec
= s1
->sections
[i
];
255 if (!strcmp(name
, sec
->name
))
258 /* sections are created as PROGBITS */
259 return new_section(s1
, name
, SHT_PROGBITS
, SHF_ALLOC
);
262 /* ------------------------------------------------------------------------- */
264 ST_FUNC
int put_elf_str(Section
*s
, const char *sym
)
269 len
= strlen(sym
) + 1;
270 offset
= s
->data_offset
;
271 ptr
= section_ptr_add(s
, len
);
272 memcpy(ptr
, sym
, len
);
276 /* elf symbol hashing function */
277 static unsigned long elf_hash(const unsigned char *name
)
279 unsigned long h
= 0, g
;
282 h
= (h
<< 4) + *name
++;
291 /* rebuild hash table of section s */
292 /* NOTE: we do factorize the hash table code to go faster */
293 static void rebuild_hash(Section
*s
, unsigned int nb_buckets
)
296 int *ptr
, *hash
, nb_syms
, sym_index
, h
;
297 unsigned char *strtab
;
299 strtab
= s
->link
->data
;
300 nb_syms
= s
->data_offset
/ sizeof(ElfW(Sym
));
302 s
->hash
->data_offset
= 0;
303 ptr
= section_ptr_add(s
->hash
, (2 + nb_buckets
+ nb_syms
) * sizeof(int));
308 memset(hash
, 0, (nb_buckets
+ 1) * sizeof(int));
309 ptr
+= nb_buckets
+ 1;
311 sym
= (ElfW(Sym
) *)s
->data
+ 1;
312 for(sym_index
= 1; sym_index
< nb_syms
; sym_index
++) {
313 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
314 h
= elf_hash(strtab
+ sym
->st_name
) % nb_buckets
;
325 /* return the symbol number */
326 ST_FUNC
int put_elf_sym(Section
*s
, addr_t value
, unsigned long size
,
327 int info
, int other
, int shndx
, const char *name
)
329 int name_offset
, sym_index
;
334 sym
= section_ptr_add(s
, sizeof(ElfW(Sym
)));
336 name_offset
= put_elf_str(s
->link
, name
);
339 /* XXX: endianness */
340 sym
->st_name
= name_offset
;
341 sym
->st_value
= value
;
344 sym
->st_other
= other
;
345 sym
->st_shndx
= shndx
;
346 sym_index
= sym
- (ElfW(Sym
) *)s
->data
;
350 ptr
= section_ptr_add(hs
, sizeof(int));
351 base
= (int *)hs
->data
;
352 /* only add global or weak symbols */
353 if (ELFW(ST_BIND
)(info
) != STB_LOCAL
) {
354 /* add another hashing entry */
356 h
= elf_hash((unsigned char *) name
) % nbuckets
;
358 base
[2 + h
] = sym_index
;
360 /* we resize the hash table */
361 hs
->nb_hashed_syms
++;
362 if (hs
->nb_hashed_syms
> 2 * nbuckets
) {
363 rebuild_hash(s
, 2 * nbuckets
);
373 /* find global ELF symbol 'name' and return its index. Return 0 if not
375 ST_FUNC
int find_elf_sym(Section
*s
, const char *name
)
379 int nbuckets
, sym_index
, h
;
385 nbuckets
= ((int *)hs
->data
)[0];
386 h
= elf_hash((unsigned char *) name
) % nbuckets
;
387 sym_index
= ((int *)hs
->data
)[2 + h
];
388 while (sym_index
!= 0) {
389 sym
= &((ElfW(Sym
) *)s
->data
)[sym_index
];
390 name1
= (char *) s
->link
->data
+ sym
->st_name
;
391 if (!strcmp(name
, name1
))
393 sym_index
= ((int *)hs
->data
)[2 + nbuckets
+ sym_index
];
398 /* return elf symbol value, signal error if 'err' is nonzero */
399 ST_FUNC addr_t
get_elf_sym_addr(TCCState
*s
, const char *name
, int err
)
404 sym_index
= find_elf_sym(s
->symtab
, name
);
405 sym
= &((ElfW(Sym
) *)s
->symtab
->data
)[sym_index
];
406 if (!sym_index
|| sym
->st_shndx
== SHN_UNDEF
) {
408 tcc_error("%s not defined", name
);
411 return sym
->st_value
;
414 /* return elf symbol value */
415 LIBTCCAPI
void *tcc_get_symbol(TCCState
*s
, const char *name
)
417 return (void*)(uintptr_t)get_elf_sym_addr(s
, name
, 0);
420 #if defined TCC_IS_NATIVE || defined TCC_TARGET_PE
421 /* return elf symbol value or error */
422 ST_FUNC
void* tcc_get_symbol_err(TCCState
*s
, const char *name
)
424 return (void*)(uintptr_t)get_elf_sym_addr(s
, name
, 1);
428 /* add an elf symbol : check if it is already defined and patch
429 it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
430 ST_FUNC
int set_elf_sym(Section
*s
, addr_t value
, unsigned long size
,
431 int info
, int other
, int shndx
, const char *name
)
434 int sym_bind
, sym_index
, sym_type
, esym_bind
;
435 unsigned char sym_vis
, esym_vis
, new_vis
;
437 sym_bind
= ELFW(ST_BIND
)(info
);
438 sym_type
= ELFW(ST_TYPE
)(info
);
439 sym_vis
= ELFW(ST_VISIBILITY
)(other
);
441 sym_index
= find_elf_sym(s
, name
);
442 esym
= &((ElfW(Sym
) *)s
->data
)[sym_index
];
443 if (sym_index
&& esym
->st_value
== value
&& esym
->st_size
== size
444 && esym
->st_info
== info
&& esym
->st_other
== other
445 && esym
->st_shndx
== shndx
)
448 if (sym_bind
!= STB_LOCAL
) {
449 /* we search global or weak symbols */
452 if (esym
->st_shndx
!= SHN_UNDEF
) {
453 esym_bind
= ELFW(ST_BIND
)(esym
->st_info
);
454 /* propagate the most constraining visibility */
455 /* STV_DEFAULT(0)<STV_PROTECTED(3)<STV_HIDDEN(2)<STV_INTERNAL(1) */
456 esym_vis
= ELFW(ST_VISIBILITY
)(esym
->st_other
);
457 if (esym_vis
== STV_DEFAULT
) {
459 } else if (sym_vis
== STV_DEFAULT
) {
462 new_vis
= (esym_vis
< sym_vis
) ? esym_vis
: sym_vis
;
464 esym
->st_other
= (esym
->st_other
& ~ELFW(ST_VISIBILITY
)(-1))
466 other
= esym
->st_other
; /* in case we have to patch esym */
467 if (shndx
== SHN_UNDEF
) {
468 /* ignore adding of undefined symbol if the
469 corresponding symbol is already defined */
470 } else if (sym_bind
== STB_GLOBAL
&& esym_bind
== STB_WEAK
) {
471 /* global overrides weak, so patch */
473 } else if (sym_bind
== STB_WEAK
&& esym_bind
== STB_GLOBAL
) {
474 /* weak is ignored if already global */
475 } else if (sym_bind
== STB_WEAK
&& esym_bind
== STB_WEAK
) {
476 /* keep first-found weak definition, ignore subsequents */
477 } else if (sym_vis
== STV_HIDDEN
|| sym_vis
== STV_INTERNAL
) {
478 /* ignore hidden symbols after */
479 } else if ((esym
->st_shndx
== SHN_COMMON
480 || esym
->st_shndx
== bss_section
->sh_num
)
481 && (shndx
< SHN_LORESERVE
482 && shndx
!= bss_section
->sh_num
)) {
483 /* data symbol gets precedence over common/bss */
485 } else if (shndx
== SHN_COMMON
|| shndx
== bss_section
->sh_num
) {
486 /* data symbol keeps precedence over common/bss */
487 } else if (s
== tcc_state
->dynsymtab_section
) {
488 /* we accept that two DLL define the same symbol */
491 printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",
492 sym_bind
, shndx
, new_vis
, esym_bind
, esym
->st_shndx
, esym_vis
);
494 tcc_error_noabort("'%s' defined twice", name
);
498 esym
->st_info
= ELFW(ST_INFO
)(sym_bind
, sym_type
);
499 esym
->st_shndx
= shndx
;
501 esym
->st_value
= value
;
502 esym
->st_size
= size
;
503 esym
->st_other
= other
;
507 sym_index
= put_elf_sym(s
, value
, size
,
508 ELFW(ST_INFO
)(sym_bind
, sym_type
), other
,
515 ST_FUNC
void put_elf_reloca(Section
*symtab
, Section
*s
, unsigned long offset
,
516 int type
, int symbol
, addr_t addend
)
524 /* if no relocation section, create it */
525 snprintf(buf
, sizeof(buf
), REL_SECTION_FMT
, s
->name
);
526 /* if the symtab is allocated, then we consider the relocation
528 sr
= new_section(tcc_state
, buf
, SHT_RELX
, symtab
->sh_flags
);
529 sr
->sh_entsize
= sizeof(ElfW_Rel
);
531 sr
->sh_info
= s
->sh_num
;
534 rel
= section_ptr_add(sr
, sizeof(ElfW_Rel
));
535 rel
->r_offset
= offset
;
536 rel
->r_info
= ELFW(R_INFO
)(symbol
, type
);
537 #if SHT_RELX == SHT_RELA
538 rel
->r_addend
= addend
;
541 tcc_error("non-zero addend on REL architecture");
545 ST_FUNC
void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
546 int type
, int symbol
)
548 put_elf_reloca(symtab
, s
, offset
, type
, symbol
, 0);
551 /* Remove relocations for section S->reloc starting at oldrelocoffset
552 that are to the same place, retaining the last of them. As side effect
553 the relocations are sorted. Possibly reduces the number of relocs. */
554 ST_FUNC
void squeeze_multi_relocs(Section
*s
, size_t oldrelocoffset
)
556 Section
*sr
= s
->reloc
;
561 if (oldrelocoffset
+ sizeof(*r
) >= sr
->data_offset
)
563 /* The relocs we're dealing with are the result of initializer parsing.
564 So they will be mostly in order and there aren't many of them.
565 Secondly we need a stable sort (which qsort isn't). We use
566 a simple insertion sort. */
567 for (a
= oldrelocoffset
+ sizeof(*r
); a
< sr
->data_offset
; a
+= sizeof(*r
)) {
568 ssize_t i
= a
- sizeof(*r
);
569 addr
= ((ElfW_Rel
*)(sr
->data
+ a
))->r_offset
;
570 for (; i
>= (ssize_t
)oldrelocoffset
&&
571 ((ElfW_Rel
*)(sr
->data
+ i
))->r_offset
> addr
; i
-= sizeof(*r
)) {
572 ElfW_Rel tmp
= *(ElfW_Rel
*)(sr
->data
+ a
);
573 *(ElfW_Rel
*)(sr
->data
+ a
) = *(ElfW_Rel
*)(sr
->data
+ i
);
574 *(ElfW_Rel
*)(sr
->data
+ i
) = tmp
;
578 r
= (ElfW_Rel
*)(sr
->data
+ oldrelocoffset
);
580 for (; r
< (ElfW_Rel
*)(sr
->data
+ sr
->data_offset
); r
++) {
581 if (dest
->r_offset
!= r
->r_offset
)
585 sr
->data_offset
= (unsigned char*)dest
- sr
->data
+ sizeof(*r
);
588 /* put stab debug information */
590 ST_FUNC
void put_stabs(const char *str
, int type
, int other
, int desc
,
595 sym
= section_ptr_add(stab_section
, sizeof(Stab_Sym
));
597 sym
->n_strx
= put_elf_str(stabstr_section
, str
);
602 sym
->n_other
= other
;
604 sym
->n_value
= value
;
607 ST_FUNC
void put_stabs_r(const char *str
, int type
, int other
, int desc
,
608 unsigned long value
, Section
*sec
, int sym_index
)
610 put_stabs(str
, type
, other
, desc
, value
);
611 put_elf_reloc(symtab_section
, stab_section
,
612 stab_section
->data_offset
- sizeof(unsigned int),
613 R_DATA_32
, sym_index
);
616 ST_FUNC
void put_stabn(int type
, int other
, int desc
, int value
)
618 put_stabs(NULL
, type
, other
, desc
, value
);
621 ST_FUNC
void put_stabd(int type
, int other
, int desc
)
623 put_stabs(NULL
, type
, other
, desc
, 0);
626 ST_FUNC
struct sym_attr
*get_sym_attr(TCCState
*s1
, int index
, int alloc
)
629 struct sym_attr
*tab
;
631 if (index
>= s1
->nb_sym_attrs
) {
633 return s1
->sym_attrs
;
634 /* find immediately bigger power of 2 and reallocate array */
638 tab
= tcc_realloc(s1
->sym_attrs
, n
* sizeof(*s1
->sym_attrs
));
640 memset(s1
->sym_attrs
+ s1
->nb_sym_attrs
, 0,
641 (n
- s1
->nb_sym_attrs
) * sizeof(*s1
->sym_attrs
));
642 s1
->nb_sym_attrs
= n
;
644 return &s1
->sym_attrs
[index
];
647 /* Browse each elem of type <type> in section <sec> starting at elem <startoff>
648 using variable <elem> */
649 #define for_each_elem(sec, startoff, elem, type) \
650 for (elem = (type *) sec->data + startoff; \
651 elem < (type *) (sec->data + sec->data_offset); elem++)
653 /* In an ELF file symbol table, the local symbols must appear below
654 the global and weak ones. Since TCC cannot sort it while generating
655 the code, we must do it after. All the relocation tables are also
656 modified to take into account the symbol table sorting */
657 static void sort_syms(TCCState
*s1
, Section
*s
)
659 int *old_to_new_syms
;
667 nb_syms
= s
->data_offset
/ sizeof(ElfW(Sym
));
668 new_syms
= tcc_malloc(nb_syms
* sizeof(ElfW(Sym
)));
669 old_to_new_syms
= tcc_malloc(nb_syms
* sizeof(int));
671 /* first pass for local symbols */
672 p
= (ElfW(Sym
) *)s
->data
;
674 for(i
= 0; i
< nb_syms
; i
++) {
675 if (ELFW(ST_BIND
)(p
->st_info
) == STB_LOCAL
) {
676 old_to_new_syms
[i
] = q
- new_syms
;
681 /* save the number of local symbols in section header */
682 if( s
->sh_size
) /* this 'if' makes IDA happy */
683 s
->sh_info
= q
- new_syms
;
685 /* then second pass for non local symbols */
686 p
= (ElfW(Sym
) *)s
->data
;
687 for(i
= 0; i
< nb_syms
; i
++) {
688 if (ELFW(ST_BIND
)(p
->st_info
) != STB_LOCAL
) {
689 old_to_new_syms
[i
] = q
- new_syms
;
695 /* we copy the new symbols to the old */
696 memcpy(s
->data
, new_syms
, nb_syms
* sizeof(ElfW(Sym
)));
699 /* now we modify all the relocations */
700 for(i
= 1; i
< s1
->nb_sections
; i
++) {
701 sr
= s1
->sections
[i
];
702 if (sr
->sh_type
== SHT_RELX
&& sr
->link
== s
) {
703 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
704 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
705 type
= ELFW(R_TYPE
)(rel
->r_info
);
706 sym_index
= old_to_new_syms
[sym_index
];
707 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
712 tcc_free(old_to_new_syms
);
715 /* relocate common symbols in the .bss section */
716 ST_FUNC
void relocate_common_syms(void)
720 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
721 if (sym
->st_shndx
== SHN_COMMON
) {
722 /* symbol alignment is in st_value for SHN_COMMONs */
723 sym
->st_value
= section_add(bss_section
, sym
->st_size
,
725 sym
->st_shndx
= bss_section
->sh_num
;
730 /* relocate symbol table, resolve undefined symbols if do_resolve is
731 true and output error if undefined symbol. */
732 ST_FUNC
void relocate_syms(TCCState
*s1
, Section
*symtab
, int do_resolve
)
735 int sym_bind
, sh_num
;
738 for_each_elem(symtab
, 1, sym
, ElfW(Sym
)) {
739 sh_num
= sym
->st_shndx
;
740 if (sh_num
== SHN_UNDEF
) {
741 name
= (char *) strtab_section
->data
+ sym
->st_name
;
742 /* Use ld.so to resolve symbol for us (for tcc -run) */
744 #if defined TCC_IS_NATIVE && !defined TCC_TARGET_PE
745 void *addr
= dlsym(RTLD_DEFAULT
, name
);
747 sym
->st_value
= (addr_t
) addr
;
749 printf ("relocate_sym: %s -> 0x%lx\n", name
, sym
->st_value
);
754 /* if dynamic symbol exist, it will be used in relocate_section */
755 } else if (s1
->dynsym
&& find_elf_sym(s1
->dynsym
, name
))
757 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
759 if (!strcmp(name
, "_fp_hw"))
761 /* only weak symbols are accepted to be undefined. Their
763 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
764 if (sym_bind
== STB_WEAK
)
767 tcc_error_noabort("undefined symbol '%s'", name
);
768 } else if (sh_num
< SHN_LORESERVE
) {
769 /* add section base */
770 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
776 /* relocate a given section (CPU dependent) by applying the relocations
777 in the associated relocation section */
778 ST_FUNC
void relocate_section(TCCState
*s1
, Section
*s
)
780 Section
*sr
= s
->reloc
;
789 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
790 ptr
= s
->data
+ rel
->r_offset
;
791 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
792 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
793 type
= ELFW(R_TYPE
)(rel
->r_info
);
795 #if SHT_RELX == SHT_RELA
796 tgt
+= rel
->r_addend
;
798 addr
= s
->sh_addr
+ rel
->r_offset
;
799 relocate(s1
, rel
, type
, ptr
, addr
, tgt
);
801 /* if the relocation is allocated, we change its symbol table */
802 if (sr
->sh_flags
& SHF_ALLOC
)
803 sr
->link
= s1
->dynsym
;
806 /* relocate relocation table in 'sr' */
807 static void relocate_rel(TCCState
*s1
, Section
*sr
)
812 s
= s1
->sections
[sr
->sh_info
];
813 for_each_elem(sr
, 0, rel
, ElfW_Rel
)
814 rel
->r_offset
+= s
->sh_addr
;
817 /* count the number of dynamic relocations so that we can reserve
819 static int prepare_dynamic_rel(TCCState
*s1
, Section
*sr
)
822 int sym_index
, type
, count
;
825 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
826 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
827 type
= ELFW(R_TYPE
)(rel
->r_info
);
829 #if defined(TCC_TARGET_I386)
831 #elif defined(TCC_TARGET_X86_64)
838 #if defined(TCC_TARGET_I386)
840 #elif defined(TCC_TARGET_X86_64)
843 if (get_sym_attr(s1
, sym_index
, 0)->dyn_index
)
851 /* allocate the section */
852 sr
->sh_flags
|= SHF_ALLOC
;
853 sr
->sh_size
= count
* sizeof(ElfW_Rel
);
858 static void build_got(TCCState
*s1
)
860 /* if no got, then create it */
861 s1
->got
= new_section(s1
, ".got", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
862 s1
->got
->sh_entsize
= 4;
863 set_elf_sym(symtab_section
, 0, 4, ELFW(ST_INFO
)(STB_GLOBAL
, STT_OBJECT
),
864 0, s1
->got
->sh_num
, "_GLOBAL_OFFSET_TABLE_");
865 /* keep space for _DYNAMIC pointer and two dummy got entries */
866 section_ptr_add(s1
->got
, 3 * PTR_SIZE
);
869 /* Create a GOT and (for function call) a PLT entry corresponding to a symbol
870 in s1->symtab. When creating the dynamic symbol table entry for the GOT
871 relocation, use 'size' and 'info' for the corresponding symbol metadata.
872 Returns the offset of the GOT or (if any) PLT entry. */
873 static struct sym_attr
* put_got_entry(TCCState
*s1
, int dyn_reloc_type
,
875 int info
, int sym_index
)
880 struct sym_attr
*attr
;
885 need_plt_entry
= (dyn_reloc_type
== R_JMP_SLOT
);
886 attr
= get_sym_attr(s1
, sym_index
, 1);
888 /* In case a function is both called and its address taken 2 GOT entries
889 are created, one for taking the address (GOT) and the other for the PLT
891 if (need_plt_entry
? attr
->plt_offset
: attr
->got_offset
)
894 /* create the GOT entry */
895 got_offset
= s1
->got
->data_offset
;
896 section_ptr_add(s1
->got
, PTR_SIZE
);
898 /* Create the GOT relocation that will insert the address of the object or
899 function of interest in the GOT entry. This is a static relocation for
900 memory output (dlsym will give us the address of symbols) and dynamic
901 relocation otherwise (executable and DLLs). The relocation should be
902 done lazily for GOT entry with *_JUMP_SLOT relocation type (the one
903 associated to a PLT entry) but is currently done at load time for an
906 sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
907 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
910 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_LOCAL
) {
911 /* Hack alarm. We don't want to emit dynamic symbols
912 and symbol based relocs for STB_LOCAL symbols, but rather
913 want to resolve them directly. At this point the symbol
914 values aren't final yet, so we must defer this. We will later
915 have to create a RELATIVE reloc anyway, so we misuse the
916 relocation slot to smuggle the symbol reference until
917 fill_local_got_entries. Not that the sym_index is
918 relative to symtab_section, not s1->dynsym! Nevertheless
919 we use s1->dyn_sym so that if this is the first call
920 that got->reloc is correctly created. Also note that
921 RELATIVE relocs are not normally created for the .got,
922 so the types serves as a marker for later (and is retained
923 also for the final output, which is okay because then the
924 got is just normal data). */
925 put_elf_reloc(s1
->dynsym
, s1
->got
, got_offset
, R_RELATIVE
,
928 if (0 == attr
->dyn_index
)
929 attr
->dyn_index
= set_elf_sym(s1
->dynsym
, sym
->st_value
, size
,
930 info
, 0, sym
->st_shndx
, name
);
931 put_elf_reloc(s1
->dynsym
, s1
->got
, got_offset
, dyn_reloc_type
,
935 put_elf_reloc(symtab_section
, s1
->got
, got_offset
, dyn_reloc_type
,
939 if (need_plt_entry
) {
941 s1
->plt
= new_section(s1
, ".plt", SHT_PROGBITS
,
942 SHF_ALLOC
| SHF_EXECINSTR
);
943 s1
->plt
->sh_entsize
= 4;
946 attr
->plt_offset
= create_plt_entry(s1
, got_offset
, attr
);
948 /* create a symbol 'sym@plt' for the PLT jump vector */
950 if (len
> sizeof plt_name
- 5)
951 len
= sizeof plt_name
- 5;
952 memcpy(plt_name
, name
, len
);
953 strcpy(plt_name
+ len
, "@plt");
954 attr
->plt_sym
= put_elf_sym(s1
->symtab
, attr
->plt_offset
, sym
->st_size
,
955 ELFW(ST_INFO
)(STB_GLOBAL
, STT_FUNC
), 0, s1
->plt
->sh_num
, plt_name
);
958 attr
->got_offset
= got_offset
;
964 /* build GOT and PLT entries */
965 ST_FUNC
void build_got_entries(TCCState
*s1
)
970 int i
, type
, gotplt_entry
, reloc_type
, sym_index
;
971 struct sym_attr
*attr
;
973 for(i
= 1; i
< s1
->nb_sections
; i
++) {
975 if (s
->sh_type
!= SHT_RELX
)
977 /* no need to handle got relocations */
978 if (s
->link
!= symtab_section
)
980 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
981 type
= ELFW(R_TYPE
)(rel
->r_info
);
982 gotplt_entry
= gotplt_entry_type(type
);
983 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
984 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
986 if (gotplt_entry
== NO_GOTPLT_ENTRY
) {
990 /* Automatically create PLT/GOT [entry] if it is an undefined
991 reference (resolved at runtime), or the symbol is absolute,
992 probably created by tcc_add_symbol, and thus on 64-bit
993 targets might be too far from application code. */
994 if (gotplt_entry
== AUTO_GOTPLT_ENTRY
) {
995 if (sym
->st_shndx
== SHN_UNDEF
) {
998 if (s1
->output_type
== TCC_OUTPUT_DLL
&& ! PCRELATIVE_DLLPLT
)
1000 /* Relocations for UNDEF symbols would normally need
1001 to be transferred into the executable or shared object.
1002 If that were done AUTO_GOTPLT_ENTRY wouldn't exist.
1003 But TCC doesn't do that (at least for exes), so we
1004 need to resolve all such relocs locally. And that
1005 means PLT slots for functions in DLLs and COPY relocs for
1006 data symbols. COPY relocs were generated in
1007 bind_exe_dynsyms (and the symbol adjusted to be defined),
1008 and for functions we were generated a dynamic symbol
1009 of function type. */
1011 /* dynsym isn't set for -run :-/ */
1012 dynindex
= get_sym_attr(s1
, sym_index
, 0)->dyn_index
;
1013 esym
= (ElfW(Sym
) *)s1
->dynsym
->data
+ dynindex
;
1015 && (ELFW(ST_TYPE
)(esym
->st_info
) == STT_FUNC
1016 || (ELFW(ST_TYPE
)(esym
->st_info
) == STT_NOTYPE
1017 && ELFW(ST_TYPE
)(sym
->st_info
) == STT_FUNC
)))
1020 } else if (!(sym
->st_shndx
== SHN_ABS
1021 #ifndef TCC_TARGET_ARM
1028 #ifdef TCC_TARGET_X86_64
1029 if ((type
== R_X86_64_PLT32
|| type
== R_X86_64_PC32
) &&
1030 (ELFW(ST_VISIBILITY
)(sym
->st_other
) != STV_DEFAULT
||
1031 ELFW(ST_BIND
)(sym
->st_info
) == STB_LOCAL
)) {
1032 rel
->r_info
= ELFW(R_INFO
)(sym_index
, R_X86_64_PC32
);
1036 if (code_reloc(type
)) {
1038 reloc_type
= R_JMP_SLOT
;
1040 reloc_type
= R_GLOB_DAT
;
1045 if (gotplt_entry
== BUILD_GOT_ONLY
)
1048 attr
= put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
1051 if (reloc_type
== R_JMP_SLOT
)
1052 rel
->r_info
= ELFW(R_INFO
)(attr
->plt_sym
, type
);
1057 /* put dynamic tag */
1058 static void put_dt(Section
*dynamic
, int dt
, addr_t val
)
1061 dyn
= section_ptr_add(dynamic
, sizeof(ElfW(Dyn
)));
1063 dyn
->d_un
.d_val
= val
;
1066 #ifndef TCC_TARGET_PE
1067 static void add_init_array_defines(TCCState
*s1
, const char *section_name
)
1071 char sym_start
[1024];
1074 snprintf(sym_start
, sizeof(sym_start
), "__%s_start", section_name
+ 1);
1075 snprintf(sym_end
, sizeof(sym_end
), "__%s_end", section_name
+ 1);
1077 s
= find_section(s1
, section_name
);
1082 end_offset
= s
->data_offset
;
1085 set_elf_sym(symtab_section
,
1087 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1088 s
->sh_num
, sym_start
);
1089 set_elf_sym(symtab_section
,
1091 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1092 s
->sh_num
, sym_end
);
1096 static int tcc_add_support(TCCState
*s1
, const char *filename
)
1099 snprintf(buf
, sizeof(buf
), "%s/%s", s1
->tcc_lib_path
, filename
);
1100 return tcc_add_file(s1
, buf
);
1103 ST_FUNC
void tcc_add_bcheck(TCCState
*s1
)
1105 #ifdef CONFIG_TCC_BCHECK
1109 if (0 == s1
->do_bounds_check
)
1111 /* XXX: add an object file to do that */
1112 ptr
= section_ptr_add(bounds_section
, sizeof(*ptr
));
1114 set_elf_sym(symtab_section
, 0, 0,
1115 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1116 bounds_section
->sh_num
, "__bounds_start");
1117 /* pull bcheck.o from libtcc1.a */
1118 sym_index
= set_elf_sym(symtab_section
, 0, 0,
1119 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1120 SHN_UNDEF
, "__bound_init");
1121 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
) {
1122 /* add 'call __bound_init()' in .init section */
1123 Section
*init_section
= find_section(s1
, ".init");
1124 unsigned char *pinit
= section_ptr_add(init_section
, 5);
1126 write32le(pinit
+ 1, -4);
1127 put_elf_reloc(symtab_section
, init_section
,
1128 init_section
->data_offset
- 4, R_386_PC32
, sym_index
);
1129 /* R_386_PC32 = R_X86_64_PC32 = 2 */
1134 /* add tcc runtime libraries */
1135 ST_FUNC
void tcc_add_runtime(TCCState
*s1
)
1138 tcc_add_pragma_libs(s1
);
1140 if (!s1
->nostdlib
) {
1141 tcc_add_library_err(s1
, "c");
1143 if (!s1
->static_link
) {
1144 if (TCC_LIBGCC
[0] == '/')
1145 tcc_add_file(s1
, TCC_LIBGCC
);
1147 tcc_add_dll(s1
, TCC_LIBGCC
, 0);
1150 tcc_add_support(s1
, TCC_LIBTCC1
);
1151 /* add crt end if not memory output */
1152 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
)
1153 tcc_add_crt(s1
, "crtn.o");
1157 /* add various standard linker symbols (must be done after the
1158 sections are filled (for example after allocating common
1160 ST_FUNC
void tcc_add_linker_symbols(TCCState
*s1
)
1166 set_elf_sym(symtab_section
,
1167 text_section
->data_offset
, 0,
1168 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1169 text_section
->sh_num
, "_etext");
1170 set_elf_sym(symtab_section
,
1171 data_section
->data_offset
, 0,
1172 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1173 data_section
->sh_num
, "_edata");
1174 set_elf_sym(symtab_section
,
1175 bss_section
->data_offset
, 0,
1176 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1177 bss_section
->sh_num
, "_end");
1178 #ifndef TCC_TARGET_PE
1179 /* horrible new standard ldscript defines */
1180 add_init_array_defines(s1
, ".preinit_array");
1181 add_init_array_defines(s1
, ".init_array");
1182 add_init_array_defines(s1
, ".fini_array");
1185 /* add start and stop symbols for sections whose name can be
1187 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1188 s
= s1
->sections
[i
];
1189 if (s
->sh_type
== SHT_PROGBITS
&&
1190 (s
->sh_flags
& SHF_ALLOC
)) {
1194 /* check if section name can be expressed in C */
1200 if (!isid(ch
) && !isnum(ch
))
1204 snprintf(buf
, sizeof(buf
), "__start_%s", s
->name
);
1205 set_elf_sym(symtab_section
,
1207 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1209 snprintf(buf
, sizeof(buf
), "__stop_%s", s
->name
);
1210 set_elf_sym(symtab_section
,
1212 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1219 static void tcc_output_binary(TCCState
*s1
, FILE *f
,
1220 const int *sec_order
)
1223 int i
, offset
, size
;
1226 for(i
=1;i
<s1
->nb_sections
;i
++) {
1227 s
= s1
->sections
[sec_order
[i
]];
1228 if (s
->sh_type
!= SHT_NOBITS
&&
1229 (s
->sh_flags
& SHF_ALLOC
)) {
1230 while (offset
< s
->sh_offset
) {
1235 fwrite(s
->data
, 1, size
, f
);
1241 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1243 #define EXTRA_RELITEMS 14
1246 #define EXTRA_RELITEMS 9
1249 ST_FUNC
void fill_got_entry(TCCState
*s1
, ElfW_Rel
*rel
)
1251 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1252 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1253 struct sym_attr
*attr
= get_sym_attr(s1
, sym_index
, 0);
1254 unsigned offset
= attr
->got_offset
;
1258 section_reserve(s1
->got
, offset
+ PTR_SIZE
);
1259 #ifdef TCC_TARGET_X86_64
1260 write64le(s1
->got
->data
+ offset
, sym
->st_value
);
1262 write32le(s1
->got
->data
+ offset
, sym
->st_value
);
1266 /* Perform relocation to GOT or PLT entries */
1267 ST_FUNC
void fill_got(TCCState
*s1
)
1273 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1274 s
= s1
->sections
[i
];
1275 if (s
->sh_type
!= SHT_RELX
)
1277 /* no need to handle got relocations */
1278 if (s
->link
!= symtab_section
)
1280 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1281 switch (ELFW(R_TYPE
) (rel
->r_info
)) {
1282 case R_X86_64_GOT32
:
1283 case R_X86_64_GOTPCREL
:
1284 case R_X86_64_GOTPCRELX
:
1285 case R_X86_64_REX_GOTPCRELX
:
1286 case R_X86_64_PLT32
:
1287 fill_got_entry(s1
, rel
);
1294 /* See put_got_entry for a description. This is the second stage
1295 where GOT references to local defined symbols are rewritten. */
1296 static void fill_local_got_entries(TCCState
*s1
)
1299 for_each_elem(s1
->got
->reloc
, 0, rel
, ElfW_Rel
) {
1300 if (ELFW(R_TYPE
)(rel
->r_info
) == R_RELATIVE
) {
1301 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1302 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1303 struct sym_attr
*attr
= get_sym_attr(s1
, sym_index
, 0);
1304 unsigned offset
= attr
->got_offset
;
1305 if (offset
!= rel
->r_offset
- s1
->got
->sh_addr
)
1306 tcc_error_noabort("huh");
1307 rel
->r_info
= ELFW(R_INFO
)(0, R_RELATIVE
);
1308 #if SHT_RELX == SHT_RELA
1309 rel
->r_addend
= sym
->st_value
;
1311 /* All our REL architectures also happen to be 32bit LE. */
1312 write32le(s1
->got
->data
+ offset
, sym
->st_value
);
1318 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1319 in shared libraries and export non local defined symbols to shared libraries
1320 if -rdynamic switch was given on command line */
1321 static void bind_exe_dynsyms(TCCState
*s1
)
1324 int sym_index
, index
;
1325 ElfW(Sym
) *sym
, *esym
;
1328 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1329 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1330 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1331 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1332 if (sym
->st_shndx
== SHN_UNDEF
) {
1333 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1334 sym_index
= find_elf_sym(s1
->dynsymtab_section
, name
);
1336 esym
= &((ElfW(Sym
) *)s1
->dynsymtab_section
->data
)[sym_index
];
1337 type
= ELFW(ST_TYPE
)(esym
->st_info
);
1338 if ((type
== STT_FUNC
) || (type
== STT_GNU_IFUNC
)) {
1339 /* Indirect functions shall have STT_FUNC type in executable
1340 * dynsym section. Indeed, a dlsym call following a lazy
1341 * resolution would pick the symbol value from the
1342 * executable dynsym entry which would contain the address
1343 * of the function wanted by the caller of dlsym instead of
1344 * the address of the function that would return that
1347 = put_elf_sym(s1
->dynsym
, 0, esym
->st_size
,
1348 ELFW(ST_INFO
)(STB_GLOBAL
,STT_FUNC
), 0, 0,
1350 int index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1351 get_sym_attr(s1
, index
, 1)->dyn_index
= dynindex
;
1352 } else if (type
== STT_OBJECT
) {
1353 unsigned long offset
;
1355 offset
= bss_section
->data_offset
;
1356 /* XXX: which alignment ? */
1357 offset
= (offset
+ 16 - 1) & -16;
1358 set_elf_sym (s1
->symtab
, offset
, esym
->st_size
,
1359 esym
->st_info
, 0, bss_section
->sh_num
, name
);
1360 index
= put_elf_sym(s1
->dynsym
, offset
, esym
->st_size
,
1361 esym
->st_info
, 0, bss_section
->sh_num
,
1364 /* Ensure R_COPY works for weak symbol aliases */
1365 if (ELFW(ST_BIND
)(esym
->st_info
) == STB_WEAK
) {
1366 for_each_elem(s1
->dynsymtab_section
, 1, dynsym
, ElfW(Sym
)) {
1367 if ((dynsym
->st_value
== esym
->st_value
)
1368 && (ELFW(ST_BIND
)(dynsym
->st_info
) == STB_GLOBAL
)) {
1369 char *dynname
= (char *) s1
->dynsymtab_section
->link
->data
1371 put_elf_sym(s1
->dynsym
, offset
, dynsym
->st_size
,
1373 bss_section
->sh_num
, dynname
);
1379 put_elf_reloc(s1
->dynsym
, bss_section
,
1380 offset
, R_COPY
, index
);
1381 offset
+= esym
->st_size
;
1382 bss_section
->data_offset
= offset
;
1385 /* STB_WEAK undefined symbols are accepted */
1386 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1387 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
||
1388 !strcmp(name
, "_fp_hw")) {
1390 tcc_error_noabort("undefined symbol '%s'", name
);
1393 } else if (s1
->rdynamic
&& ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1394 /* if -rdynamic option, then export all non local symbols */
1395 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1396 set_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1397 0, sym
->st_shndx
, name
);
1402 /* Bind symbols of libraries: export all non local symbols of executable that
1403 are referenced by shared libraries. The reason is that the dynamic loader
1404 search symbol first in executable and then in libraries. Therefore a
1405 reference to a symbol already defined by a library can still be resolved by
1406 a symbol in the executable. */
1407 static void bind_libs_dynsyms(TCCState
*s1
)
1411 ElfW(Sym
) *sym
, *esym
;
1413 for_each_elem(s1
->dynsymtab_section
, 1, esym
, ElfW(Sym
)) {
1414 name
= (char *) s1
->dynsymtab_section
->link
->data
+ esym
->st_name
;
1415 sym_index
= find_elf_sym(symtab_section
, name
);
1416 /* XXX: avoid adding a symbol if already present because of
1418 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1419 if (sym_index
&& sym
->st_shndx
!= SHN_UNDEF
)
1420 set_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1421 0, sym
->st_shndx
, name
);
1422 else if (esym
->st_shndx
== SHN_UNDEF
) {
1423 /* weak symbols can stay undefined */
1424 if (ELFW(ST_BIND
)(esym
->st_info
) != STB_WEAK
)
1425 tcc_warning("undefined dynamic symbol '%s'", name
);
1430 /* Export all non local symbols. This is used by shared libraries so that the
1431 non local symbols they define can resolve a reference in another shared
1432 library or in the executable. Correspondingly, it allows undefined local
1433 symbols to be resolved by other shared libraries or by the executable. */
1434 static void export_global_syms(TCCState
*s1
)
1436 int dynindex
, index
;
1440 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1441 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1442 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1443 dynindex
= put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1444 sym
->st_info
, 0, sym
->st_shndx
, name
);
1445 index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1446 get_sym_attr(s1
, index
, 1)->dyn_index
= dynindex
;
1451 /* Allocate strings for section names and decide if an unallocated section
1453 NOTE: the strsec section comes last, so its size is also correct ! */
1454 static void alloc_sec_names(TCCState
*s1
, int file_type
, Section
*strsec
)
1459 /* Allocate strings for section names */
1460 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1461 s
= s1
->sections
[i
];
1462 /* when generating a DLL, we include relocations but we may
1464 if (file_type
== TCC_OUTPUT_DLL
&&
1465 s
->sh_type
== SHT_RELX
&&
1466 !(s
->sh_flags
& SHF_ALLOC
)) {
1467 /* gr: avoid bogus relocs for empty (debug) sections */
1468 if (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_ALLOC
)
1469 prepare_dynamic_rel(s1
, s
);
1470 else if (s1
->do_debug
)
1471 s
->sh_size
= s
->data_offset
;
1472 } else if (s1
->do_debug
||
1473 file_type
== TCC_OUTPUT_OBJ
||
1474 (s
->sh_flags
& SHF_ALLOC
) ||
1475 i
== (s1
->nb_sections
- 1)) {
1476 /* we output all sections if debug or object file */
1477 s
->sh_size
= s
->data_offset
;
1479 if (s
->sh_size
|| (s
->sh_flags
& SHF_ALLOC
))
1480 s
->sh_name
= put_elf_str(strsec
, s
->name
);
1482 strsec
->sh_size
= strsec
->data_offset
;
1485 /* Info to be copied in dynamic section */
1489 unsigned long dyn_rel_off
;
1492 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1498 /* Assign sections to segments and decide how are sections laid out when loaded
1499 in memory. This function also fills corresponding program headers. */
1500 static int layout_sections(TCCState
*s1
, ElfW(Phdr
) *phdr
, int phnum
,
1501 Section
*interp
, Section
* strsec
,
1502 struct dyn_inf
*dyninf
, int *sec_order
)
1504 int i
, j
, k
, file_type
, sh_order_index
, file_offset
;
1505 unsigned long s_align
;
1511 file_type
= s1
->output_type
;
1514 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
1515 file_offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1516 s_align
= ELF_PAGE_SIZE
;
1517 if (s1
->section_align
)
1518 s_align
= s1
->section_align
;
1521 if (s1
->has_text_addr
) {
1522 int a_offset
, p_offset
;
1523 addr
= s1
->text_addr
;
1524 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1526 a_offset
= (int) (addr
& (s_align
- 1));
1527 p_offset
= file_offset
& (s_align
- 1);
1528 if (a_offset
< p_offset
)
1529 a_offset
+= s_align
;
1530 file_offset
+= (a_offset
- p_offset
);
1532 if (file_type
== TCC_OUTPUT_DLL
)
1535 addr
= ELF_START_ADDR
;
1536 /* compute address after headers */
1537 addr
+= (file_offset
& (s_align
- 1));
1541 /* Leave one program headers for the program interpreter and one for
1542 the program header table itself if needed. These are done later as
1543 they require section layout to be done first. */
1545 ph
+= 1 + HAVE_PHDR
;
1547 /* dynamic relocation table information, for .dynamic section */
1548 dyninf
->rel_addr
= dyninf
->rel_size
= 0;
1549 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1550 dyninf
->bss_addr
= dyninf
->bss_size
= 0;
1553 for(j
= 0; j
< 2; j
++) {
1554 ph
->p_type
= PT_LOAD
;
1556 ph
->p_flags
= PF_R
| PF_X
;
1558 ph
->p_flags
= PF_R
| PF_W
;
1559 ph
->p_align
= s_align
;
1561 /* Decide the layout of sections loaded in memory. This must
1562 be done before program headers are filled since they contain
1563 info about the layout. We do the following ordering: interp,
1564 symbol tables, relocations, progbits, nobits */
1565 /* XXX: do faster and simpler sorting */
1566 for(k
= 0; k
< 5; k
++) {
1567 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1568 s
= s1
->sections
[i
];
1569 /* compute if section should be included */
1571 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1575 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1576 (SHF_ALLOC
| SHF_WRITE
))
1582 } else if (s
->sh_type
== SHT_DYNSYM
||
1583 s
->sh_type
== SHT_STRTAB
||
1584 s
->sh_type
== SHT_HASH
) {
1587 } else if (s
->sh_type
== SHT_RELX
) {
1590 } else if (s
->sh_type
== SHT_NOBITS
) {
1597 sec_order
[sh_order_index
++] = i
;
1599 /* section matches: we align it and add its size */
1601 addr
= (addr
+ s
->sh_addralign
- 1) &
1602 ~(s
->sh_addralign
- 1);
1603 file_offset
+= (int) ( addr
- tmp
);
1604 s
->sh_offset
= file_offset
;
1607 /* update program header infos */
1608 if (ph
->p_offset
== 0) {
1609 ph
->p_offset
= file_offset
;
1611 ph
->p_paddr
= ph
->p_vaddr
;
1613 /* update dynamic relocation infos */
1614 if (s
->sh_type
== SHT_RELX
) {
1615 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1616 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.got")) {
1617 dyninf
->rel_addr
= addr
;
1618 dyninf
->rel_size
+= s
->sh_size
; /* XXX only first rel. */
1620 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.bss")) {
1621 dyninf
->bss_addr
= addr
;
1622 dyninf
->bss_size
= s
->sh_size
; /* XXX only first rel. */
1625 if (dyninf
->rel_size
== 0)
1626 dyninf
->rel_addr
= addr
;
1627 dyninf
->rel_size
+= s
->sh_size
;
1631 if (s
->sh_type
!= SHT_NOBITS
)
1632 file_offset
+= s
->sh_size
;
1636 /* Make the first PT_LOAD segment include the program
1637 headers itself (and the ELF header as well), it'll
1638 come out with same memory use but will make various
1639 tools like binutils strip work better. */
1640 ph
->p_offset
&= ~(ph
->p_align
- 1);
1641 ph
->p_vaddr
&= ~(ph
->p_align
- 1);
1642 ph
->p_paddr
&= ~(ph
->p_align
- 1);
1644 ph
->p_filesz
= file_offset
- ph
->p_offset
;
1645 ph
->p_memsz
= addr
- ph
->p_vaddr
;
1648 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
) {
1649 /* if in the middle of a page, we duplicate the page in
1650 memory so that one copy is RX and the other is RW */
1651 if ((addr
& (s_align
- 1)) != 0)
1654 addr
= (addr
+ s_align
- 1) & ~(s_align
- 1);
1655 file_offset
= (file_offset
+ s_align
- 1) & ~(s_align
- 1);
1661 /* all other sections come after */
1662 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1663 s
= s1
->sections
[i
];
1664 if (phnum
> 0 && (s
->sh_flags
& SHF_ALLOC
))
1666 sec_order
[sh_order_index
++] = i
;
1668 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
1669 ~(s
->sh_addralign
- 1);
1670 s
->sh_offset
= file_offset
;
1671 if (s
->sh_type
!= SHT_NOBITS
)
1672 file_offset
+= s
->sh_size
;
1678 static void fill_unloadable_phdr(ElfW(Phdr
) *phdr
, int phnum
, Section
*interp
,
1683 /* if interpreter, then add corresponding program header */
1689 int len
= phnum
* sizeof(ElfW(Phdr
));
1691 ph
->p_type
= PT_PHDR
;
1692 ph
->p_offset
= sizeof(ElfW(Ehdr
));
1693 ph
->p_vaddr
= interp
->sh_addr
- len
;
1694 ph
->p_paddr
= ph
->p_vaddr
;
1695 ph
->p_filesz
= ph
->p_memsz
= len
;
1696 ph
->p_flags
= PF_R
| PF_X
;
1697 ph
->p_align
= 4; /* interp->sh_addralign; */
1701 ph
->p_type
= PT_INTERP
;
1702 ph
->p_offset
= interp
->sh_offset
;
1703 ph
->p_vaddr
= interp
->sh_addr
;
1704 ph
->p_paddr
= ph
->p_vaddr
;
1705 ph
->p_filesz
= interp
->sh_size
;
1706 ph
->p_memsz
= interp
->sh_size
;
1708 ph
->p_align
= interp
->sh_addralign
;
1711 /* if dynamic section, then add corresponding program header */
1713 ph
= &phdr
[phnum
- 1];
1715 ph
->p_type
= PT_DYNAMIC
;
1716 ph
->p_offset
= dynamic
->sh_offset
;
1717 ph
->p_vaddr
= dynamic
->sh_addr
;
1718 ph
->p_paddr
= ph
->p_vaddr
;
1719 ph
->p_filesz
= dynamic
->sh_size
;
1720 ph
->p_memsz
= dynamic
->sh_size
;
1721 ph
->p_flags
= PF_R
| PF_W
;
1722 ph
->p_align
= dynamic
->sh_addralign
;
1726 /* Fill the dynamic section with tags describing the address and size of
1728 static void fill_dynamic(TCCState
*s1
, struct dyn_inf
*dyninf
)
1732 dynamic
= dyninf
->dynamic
;
1734 /* put dynamic section entries */
1735 dynamic
->data_offset
= dyninf
->dyn_rel_off
;
1736 put_dt(dynamic
, DT_HASH
, s1
->dynsym
->hash
->sh_addr
);
1737 put_dt(dynamic
, DT_STRTAB
, dyninf
->dynstr
->sh_addr
);
1738 put_dt(dynamic
, DT_SYMTAB
, s1
->dynsym
->sh_addr
);
1739 put_dt(dynamic
, DT_STRSZ
, dyninf
->dynstr
->data_offset
);
1740 put_dt(dynamic
, DT_SYMENT
, sizeof(ElfW(Sym
)));
1742 put_dt(dynamic
, DT_RELA
, dyninf
->rel_addr
);
1743 put_dt(dynamic
, DT_RELASZ
, dyninf
->rel_size
);
1744 put_dt(dynamic
, DT_RELAENT
, sizeof(ElfW_Rel
));
1746 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1747 put_dt(dynamic
, DT_PLTGOT
, s1
->got
->sh_addr
);
1748 put_dt(dynamic
, DT_PLTRELSZ
, dyninf
->rel_size
);
1749 put_dt(dynamic
, DT_JMPREL
, dyninf
->rel_addr
);
1750 put_dt(dynamic
, DT_PLTREL
, DT_REL
);
1751 put_dt(dynamic
, DT_REL
, dyninf
->bss_addr
);
1752 put_dt(dynamic
, DT_RELSZ
, dyninf
->bss_size
);
1754 put_dt(dynamic
, DT_REL
, dyninf
->rel_addr
);
1755 put_dt(dynamic
, DT_RELSZ
, dyninf
->rel_size
);
1756 put_dt(dynamic
, DT_RELENT
, sizeof(ElfW_Rel
));
1760 put_dt(dynamic
, DT_DEBUG
, 0);
1761 put_dt(dynamic
, DT_NULL
, 0);
1764 /* Relocate remaining sections and symbols (that is those not related to
1766 static int final_sections_reloc(TCCState
*s1
)
1771 relocate_syms(s1
, s1
->symtab
, 0);
1773 if (s1
->nb_errors
!= 0)
1776 /* relocate sections */
1777 /* XXX: ignore sections with allocated relocations ? */
1778 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1779 s
= s1
->sections
[i
];
1780 #if defined(TCC_TARGET_I386) || defined(TCC_MUSL)
1781 if (s
->reloc
&& s
!= s1
->got
&& (s
->sh_flags
& SHF_ALLOC
)) //gr
1782 /* On X86 gdb 7.3 works in any case but gdb 6.6 will crash if SHF_ALLOC
1783 checking is removed */
1785 if (s
->reloc
&& s
!= s1
->got
)
1786 /* On X86_64 gdb 7.3 will crash if SHF_ALLOC checking is present */
1788 relocate_section(s1
, s
);
1791 /* relocate relocation entries if the relocation tables are
1792 allocated in the executable */
1793 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1794 s
= s1
->sections
[i
];
1795 if ((s
->sh_flags
& SHF_ALLOC
) &&
1796 s
->sh_type
== SHT_RELX
) {
1797 relocate_rel(s1
, s
);
1803 /* Create an ELF file on disk.
1804 This function handle ELF specific layout requirements */
1805 static void tcc_output_elf(TCCState
*s1
, FILE *f
, int phnum
, ElfW(Phdr
) *phdr
,
1806 int file_offset
, int *sec_order
)
1808 int i
, shnum
, offset
, size
, file_type
;
1811 ElfW(Shdr
) shdr
, *sh
;
1813 file_type
= s1
->output_type
;
1814 shnum
= s1
->nb_sections
;
1816 memset(&ehdr
, 0, sizeof(ehdr
));
1819 ehdr
.e_phentsize
= sizeof(ElfW(Phdr
));
1820 ehdr
.e_phnum
= phnum
;
1821 ehdr
.e_phoff
= sizeof(ElfW(Ehdr
));
1825 file_offset
= (file_offset
+ 3) & -4;
1828 ehdr
.e_ident
[0] = ELFMAG0
;
1829 ehdr
.e_ident
[1] = ELFMAG1
;
1830 ehdr
.e_ident
[2] = ELFMAG2
;
1831 ehdr
.e_ident
[3] = ELFMAG3
;
1832 ehdr
.e_ident
[4] = ELFCLASSW
;
1833 ehdr
.e_ident
[5] = ELFDATA2LSB
;
1834 ehdr
.e_ident
[6] = EV_CURRENT
;
1835 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1836 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
1838 #ifdef TCC_TARGET_ARM
1840 ehdr
.e_ident
[EI_OSABI
] = 0;
1841 ehdr
.e_flags
= EF_ARM_EABI_VER4
;
1842 if (file_type
== TCC_OUTPUT_EXE
|| file_type
== TCC_OUTPUT_DLL
)
1843 ehdr
.e_flags
|= EF_ARM_HASENTRY
;
1844 if (s1
->float_abi
== ARM_HARD_FLOAT
)
1845 ehdr
.e_flags
|= EF_ARM_VFP_FLOAT
;
1847 ehdr
.e_flags
|= EF_ARM_SOFT_FLOAT
;
1849 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_ARM
;
1854 case TCC_OUTPUT_EXE
:
1855 ehdr
.e_type
= ET_EXEC
;
1856 ehdr
.e_entry
= get_elf_sym_addr(s1
, "_start", 1);
1858 case TCC_OUTPUT_DLL
:
1859 ehdr
.e_type
= ET_DYN
;
1860 ehdr
.e_entry
= text_section
->sh_addr
; /* XXX: is it correct ? */
1862 case TCC_OUTPUT_OBJ
:
1863 ehdr
.e_type
= ET_REL
;
1866 ehdr
.e_machine
= EM_TCC_TARGET
;
1867 ehdr
.e_version
= EV_CURRENT
;
1868 ehdr
.e_shoff
= file_offset
;
1869 ehdr
.e_ehsize
= sizeof(ElfW(Ehdr
));
1870 ehdr
.e_shentsize
= sizeof(ElfW(Shdr
));
1871 ehdr
.e_shnum
= shnum
;
1872 ehdr
.e_shstrndx
= shnum
- 1;
1874 fwrite(&ehdr
, 1, sizeof(ElfW(Ehdr
)), f
);
1875 fwrite(phdr
, 1, phnum
* sizeof(ElfW(Phdr
)), f
);
1876 offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1878 sort_syms(s1
, symtab_section
);
1879 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1880 s
= s1
->sections
[sec_order
[i
]];
1881 if (s
->sh_type
!= SHT_NOBITS
) {
1882 while (offset
< s
->sh_offset
) {
1888 fwrite(s
->data
, 1, size
, f
);
1893 /* output section headers */
1894 while (offset
< ehdr
.e_shoff
) {
1899 for(i
= 0; i
< s1
->nb_sections
; i
++) {
1901 memset(sh
, 0, sizeof(ElfW(Shdr
)));
1902 s
= s1
->sections
[i
];
1904 sh
->sh_name
= s
->sh_name
;
1905 sh
->sh_type
= s
->sh_type
;
1906 sh
->sh_flags
= s
->sh_flags
;
1907 sh
->sh_entsize
= s
->sh_entsize
;
1908 sh
->sh_info
= s
->sh_info
;
1910 sh
->sh_link
= s
->link
->sh_num
;
1911 sh
->sh_addralign
= s
->sh_addralign
;
1912 sh
->sh_addr
= s
->sh_addr
;
1913 sh
->sh_offset
= s
->sh_offset
;
1914 sh
->sh_size
= s
->sh_size
;
1916 fwrite(sh
, 1, sizeof(ElfW(Shdr
)), f
);
1920 /* Write an elf, coff or "binary" file */
1921 static int tcc_write_elf_file(TCCState
*s1
, const char *filename
, int phnum
,
1922 ElfW(Phdr
) *phdr
, int file_offset
, int *sec_order
)
1924 int fd
, mode
, file_type
;
1927 file_type
= s1
->output_type
;
1928 if (file_type
== TCC_OUTPUT_OBJ
)
1933 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, mode
);
1935 tcc_error_noabort("could not write '%s'", filename
);
1938 f
= fdopen(fd
, "wb");
1940 printf("<- %s\n", filename
);
1942 #ifdef TCC_TARGET_COFF
1943 if (s1
->output_format
== TCC_OUTPUT_FORMAT_COFF
)
1944 tcc_output_coff(s1
, f
);
1947 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
1948 tcc_output_elf(s1
, f
, phnum
, phdr
, file_offset
, sec_order
);
1950 tcc_output_binary(s1
, f
, sec_order
);
1956 /* Sort section headers by assigned sh_addr, remove sections
1957 that we aren't going to output. */
1958 static void tidy_section_headers(TCCState
*s1
, int *sec_order
)
1960 int i
, nnew
, l
, *backmap
;
1964 snew
= tcc_malloc(s1
->nb_sections
* sizeof(snew
[0]));
1965 backmap
= tcc_malloc(s1
->nb_sections
* sizeof(backmap
[0]));
1966 for (i
= 0, nnew
= 0, l
= s1
->nb_sections
; i
< s1
->nb_sections
; i
++) {
1967 s
= s1
->sections
[sec_order
[i
]];
1968 if (!i
|| s
->sh_name
) {
1969 backmap
[sec_order
[i
]] = nnew
;
1973 backmap
[sec_order
[i
]] = 0;
1977 for (i
= 0; i
< nnew
; i
++) {
1981 if (s
->sh_type
== SHT_RELX
)
1982 s
->sh_info
= backmap
[s
->sh_info
];
1986 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
))
1987 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
)
1988 sym
->st_shndx
= backmap
[sym
->st_shndx
];
1989 if( !s1
->static_link
) {
1990 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
))
1991 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
)
1992 sym
->st_shndx
= backmap
[sym
->st_shndx
];
1994 for (i
= 0; i
< s1
->nb_sections
; i
++)
1996 tcc_free(s1
->sections
);
1997 s1
->sections
= snew
;
1998 s1
->nb_sections
= nnew
;
2002 /* Output an elf, coff or binary file */
2003 /* XXX: suppress unneeded sections */
2004 static int elf_output_file(TCCState
*s1
, const char *filename
)
2006 int i
, ret
, phnum
, shnum
, file_type
, file_offset
, *sec_order
;
2007 struct dyn_inf dyninf
= {0};
2010 Section
*strsec
, *interp
, *dynamic
, *dynstr
;
2012 file_type
= s1
->output_type
;
2015 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2016 if (file_type
!= TCC_OUTPUT_OBJ
) {
2017 tcc_add_runtime(s1
);
2022 interp
= dynamic
= dynstr
= NULL
; /* avoid warning */
2024 if (file_type
!= TCC_OUTPUT_OBJ
) {
2025 relocate_common_syms();
2027 tcc_add_linker_symbols(s1
);
2029 if (!s1
->static_link
) {
2030 if (file_type
== TCC_OUTPUT_EXE
) {
2032 /* allow override the dynamic loader */
2033 const char *elfint
= getenv("LD_SO");
2035 elfint
= DEFAULT_ELFINTERP(s1
);
2036 /* add interpreter section only if executable */
2037 interp
= new_section(s1
, ".interp", SHT_PROGBITS
, SHF_ALLOC
);
2038 interp
->sh_addralign
= 1;
2039 ptr
= section_ptr_add(interp
, 1 + strlen(elfint
));
2040 strcpy(ptr
, elfint
);
2043 /* add dynamic symbol table */
2044 s1
->dynsym
= new_symtab(s1
, ".dynsym", SHT_DYNSYM
, SHF_ALLOC
,
2046 ".hash", SHF_ALLOC
);
2047 dynstr
= s1
->dynsym
->link
;
2049 /* add dynamic section */
2050 dynamic
= new_section(s1
, ".dynamic", SHT_DYNAMIC
,
2051 SHF_ALLOC
| SHF_WRITE
);
2052 dynamic
->link
= dynstr
;
2053 dynamic
->sh_entsize
= sizeof(ElfW(Dyn
));
2057 if (file_type
== TCC_OUTPUT_EXE
) {
2058 bind_exe_dynsyms(s1
);
2060 if (s1
->nb_errors
) {
2065 bind_libs_dynsyms(s1
);
2066 } else /* shared library case: simply export all global symbols */
2067 export_global_syms(s1
);
2069 build_got_entries(s1
);
2071 /* add a list of needed dlls */
2072 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2073 DLLReference
*dllref
= s1
->loaded_dlls
[i
];
2074 if (dllref
->level
== 0)
2075 put_dt(dynamic
, DT_NEEDED
, put_elf_str(dynstr
, dllref
->name
));
2079 put_dt(dynamic
, s1
->enable_new_dtags
? DT_RUNPATH
: DT_RPATH
,
2080 put_elf_str(dynstr
, s1
->rpath
));
2082 /* XXX: currently, since we do not handle PIC code, we
2083 must relocate the readonly segments */
2084 if (file_type
== TCC_OUTPUT_DLL
) {
2086 put_dt(dynamic
, DT_SONAME
, put_elf_str(dynstr
, s1
->soname
));
2087 put_dt(dynamic
, DT_TEXTREL
, 0);
2091 put_dt(dynamic
, DT_SYMBOLIC
, 0);
2093 /* add necessary space for other entries */
2094 dyninf
.dyn_rel_off
= dynamic
->data_offset
;
2095 dynamic
->data_offset
+= sizeof(ElfW(Dyn
)) * EXTRA_RELITEMS
;
2097 /* still need to build got entries in case of static link */
2098 build_got_entries(s1
);
2102 /* we add a section for symbols */
2103 strsec
= new_section(s1
, ".shstrtab", SHT_STRTAB
, 0);
2104 put_elf_str(strsec
, "");
2106 /* compute number of sections */
2107 shnum
= s1
->nb_sections
;
2109 /* this array is used to reorder sections in the output file */
2110 sec_order
= tcc_malloc(sizeof(int) * shnum
);
2113 /* compute number of program headers */
2116 case TCC_OUTPUT_OBJ
:
2119 case TCC_OUTPUT_EXE
:
2120 if (!s1
->static_link
)
2121 phnum
= 4 + HAVE_PHDR
;
2125 case TCC_OUTPUT_DLL
:
2130 /* Allocate strings for section names */
2131 alloc_sec_names(s1
, file_type
, strsec
);
2133 /* allocate program segment headers */
2134 phdr
= tcc_mallocz(phnum
* sizeof(ElfW(Phdr
)));
2136 /* compute section to program header mapping */
2137 file_offset
= layout_sections(s1
, phdr
, phnum
, interp
, strsec
, &dyninf
,
2140 /* Fill remaining program header and finalize relocation related to dynamic
2143 fill_unloadable_phdr(phdr
, phnum
, interp
, dynamic
);
2145 dyninf
.dynamic
= dynamic
;
2146 dyninf
.dynstr
= dynstr
;
2148 fill_dynamic(s1
, &dyninf
);
2150 /* put in GOT the dynamic section address and relocate PLT */
2151 write32le(s1
->got
->data
, dynamic
->sh_addr
);
2152 if (file_type
== TCC_OUTPUT_EXE
2153 || (RELOCATE_DLLPLT
&& file_type
== TCC_OUTPUT_DLL
))
2156 /* relocate symbols in .dynsym now that final addresses are known */
2157 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
)) {
2158 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
) {
2159 /* do symbol relocation */
2160 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
2166 /* if building executable or DLL, then relocate each section
2167 except the GOT which is already relocated */
2168 if (file_type
!= TCC_OUTPUT_OBJ
) {
2169 ret
= final_sections_reloc(s1
);
2172 tidy_section_headers(s1
, sec_order
);
2175 /* Perform relocation to GOT or PLT entries */
2176 if (file_type
== TCC_OUTPUT_EXE
&& s1
->static_link
)
2179 fill_local_got_entries(s1
);
2181 /* Create the ELF file with name 'filename' */
2182 ret
= tcc_write_elf_file(s1
, filename
, phnum
, phdr
, file_offset
, sec_order
);
2183 s1
->nb_sections
= shnum
;
2185 tcc_free(sec_order
);
2190 LIBTCCAPI
int tcc_output_file(TCCState
*s
, const char *filename
)
2193 #ifdef TCC_TARGET_PE
2194 if (s
->output_type
!= TCC_OUTPUT_OBJ
) {
2195 ret
= pe_output_file(s
, filename
);
2198 ret
= elf_output_file(s
, filename
);
2202 static void *load_data(int fd
, unsigned long file_offset
, unsigned long size
)
2206 data
= tcc_malloc(size
);
2207 lseek(fd
, file_offset
, SEEK_SET
);
2208 read(fd
, data
, size
);
2212 typedef struct SectionMergeInfo
{
2213 Section
*s
; /* corresponding existing section */
2214 unsigned long offset
; /* offset of the new section in the existing section */
2215 uint8_t new_section
; /* true if section 's' was added */
2216 uint8_t link_once
; /* true if link once section */
2219 ST_FUNC
int tcc_object_type(int fd
, ElfW(Ehdr
) *h
)
2221 int size
= read(fd
, h
, sizeof *h
);
2222 if (size
== sizeof *h
&& 0 == memcmp(h
, ELFMAG
, 4)) {
2223 if (h
->e_type
== ET_REL
)
2224 return AFF_BINTYPE_REL
;
2225 if (h
->e_type
== ET_DYN
)
2226 return AFF_BINTYPE_DYN
;
2227 } else if (size
>= 8) {
2228 if (0 == memcmp(h
, ARMAG
, 8))
2229 return AFF_BINTYPE_AR
;
2230 #ifdef TCC_TARGET_COFF
2231 if (((struct filehdr
*)h
)->f_magic
== COFF_C67_MAGIC
)
2232 return AFF_BINTYPE_C67
;
2238 /* load an object file and merge it with current files */
2239 /* XXX: handle correctly stab (debug) info */
2240 ST_FUNC
int tcc_load_object_file(TCCState
*s1
,
2241 int fd
, unsigned long file_offset
)
2244 ElfW(Shdr
) *shdr
, *sh
;
2245 int size
, i
, j
, offset
, offseti
, nb_syms
, sym_index
, ret
, seencompressed
;
2246 unsigned char *strsec
, *strtab
;
2247 int *old_to_new_syms
;
2248 char *sh_name
, *name
;
2249 SectionMergeInfo
*sm_table
, *sm
;
2250 ElfW(Sym
) *sym
, *symtab
;
2257 stab_index
= stabstr_index
= 0;
2259 lseek(fd
, file_offset
, SEEK_SET
);
2260 if (tcc_object_type(fd
, &ehdr
) != AFF_BINTYPE_REL
)
2262 /* test CPU specific stuff */
2263 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2264 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2266 tcc_error_noabort("invalid object file");
2270 shdr
= load_data(fd
, file_offset
+ ehdr
.e_shoff
,
2271 sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2272 sm_table
= tcc_mallocz(sizeof(SectionMergeInfo
) * ehdr
.e_shnum
);
2274 /* load section names */
2275 sh
= &shdr
[ehdr
.e_shstrndx
];
2276 strsec
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2278 /* load symtab and strtab */
2279 old_to_new_syms
= NULL
;
2284 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2286 if (sh
->sh_type
== SHT_SYMTAB
) {
2288 tcc_error_noabort("object must contain only one symtab");
2293 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2294 symtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2295 sm_table
[i
].s
= symtab_section
;
2297 /* now load strtab */
2298 sh
= &shdr
[sh
->sh_link
];
2299 strtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2301 if (sh
->sh_flags
& SHF_COMPRESSED
)
2305 /* now examine each section and try to merge its content with the
2307 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2308 /* no need to examine section name strtab */
2309 if (i
== ehdr
.e_shstrndx
)
2312 sh_name
= (char *) strsec
+ sh
->sh_name
;
2313 /* ignore sections types we do not handle */
2314 if (sh
->sh_type
!= SHT_PROGBITS
&&
2315 sh
->sh_type
!= SHT_RELX
&&
2317 sh
->sh_type
!= SHT_ARM_EXIDX
&&
2319 sh
->sh_type
!= SHT_NOBITS
&&
2320 sh
->sh_type
!= SHT_PREINIT_ARRAY
&&
2321 sh
->sh_type
!= SHT_INIT_ARRAY
&&
2322 sh
->sh_type
!= SHT_FINI_ARRAY
&&
2323 strcmp(sh_name
, ".stabstr")
2327 && (!strncmp(sh_name
, ".debug_", sizeof(".debug_")-1)
2328 || (sh
->sh_type
== SHT_RELX
2329 && !strncmp((char*)strsec
+ shdr
[sh
->sh_info
].sh_name
,
2330 ".debug_", sizeof(".debug_")-1))))
2332 if (sh
->sh_addralign
< 1)
2333 sh
->sh_addralign
= 1;
2334 /* find corresponding section, if any */
2335 for(j
= 1; j
< s1
->nb_sections
;j
++) {
2336 s
= s1
->sections
[j
];
2337 if (!strcmp(s
->name
, sh_name
)) {
2338 if (!strncmp(sh_name
, ".gnu.linkonce",
2339 sizeof(".gnu.linkonce") - 1)) {
2340 /* if a 'linkonce' section is already present, we
2341 do not add it again. It is a little tricky as
2342 symbols can still be defined in
2344 sm_table
[i
].link_once
= 1;
2351 /* not found: create new section */
2352 s
= new_section(s1
, sh_name
, sh
->sh_type
, sh
->sh_flags
& ~SHF_GROUP
);
2353 /* take as much info as possible from the section. sh_link and
2354 sh_info will be updated later */
2355 s
->sh_addralign
= sh
->sh_addralign
;
2356 s
->sh_entsize
= sh
->sh_entsize
;
2357 sm_table
[i
].new_section
= 1;
2359 if (sh
->sh_type
!= s
->sh_type
) {
2360 tcc_error_noabort("invalid section type");
2364 /* align start of section */
2365 offset
= s
->data_offset
;
2367 if (0 == strcmp(sh_name
, ".stab")) {
2371 if (0 == strcmp(sh_name
, ".stabstr")) {
2376 size
= sh
->sh_addralign
- 1;
2377 offset
= (offset
+ size
) & ~size
;
2378 if (sh
->sh_addralign
> s
->sh_addralign
)
2379 s
->sh_addralign
= sh
->sh_addralign
;
2380 s
->data_offset
= offset
;
2382 sm_table
[i
].offset
= offset
;
2384 /* concatenate sections */
2386 if (sh
->sh_type
!= SHT_NOBITS
) {
2388 lseek(fd
, file_offset
+ sh
->sh_offset
, SEEK_SET
);
2389 ptr
= section_ptr_add(s
, size
);
2390 read(fd
, ptr
, size
);
2392 s
->data_offset
+= size
;
2397 /* gr relocate stab strings */
2398 if (stab_index
&& stabstr_index
) {
2401 s
= sm_table
[stab_index
].s
;
2402 a
= (Stab_Sym
*)(s
->data
+ sm_table
[stab_index
].offset
);
2403 b
= (Stab_Sym
*)(s
->data
+ s
->data_offset
);
2404 o
= sm_table
[stabstr_index
].offset
;
2406 a
->n_strx
+= o
, a
++;
2409 /* second short pass to update sh_link and sh_info fields of new
2411 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2413 if (!s
|| !sm_table
[i
].new_section
)
2416 if (sh
->sh_link
> 0)
2417 s
->link
= sm_table
[sh
->sh_link
].s
;
2418 if (sh
->sh_type
== SHT_RELX
) {
2419 s
->sh_info
= sm_table
[sh
->sh_info
].s
->sh_num
;
2420 /* update backward link */
2421 s1
->sections
[s
->sh_info
]->reloc
= s
;
2426 /* resolve symbols */
2427 old_to_new_syms
= tcc_mallocz(nb_syms
* sizeof(int));
2430 for(i
= 1; i
< nb_syms
; i
++, sym
++) {
2431 if (sym
->st_shndx
!= SHN_UNDEF
&&
2432 sym
->st_shndx
< SHN_LORESERVE
) {
2433 sm
= &sm_table
[sym
->st_shndx
];
2434 if (sm
->link_once
) {
2435 /* if a symbol is in a link once section, we use the
2436 already defined symbol. It is very important to get
2437 correct relocations */
2438 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
2439 name
= (char *) strtab
+ sym
->st_name
;
2440 sym_index
= find_elf_sym(symtab_section
, name
);
2442 old_to_new_syms
[i
] = sym_index
;
2446 /* if no corresponding section added, no need to add symbol */
2449 /* convert section number */
2450 sym
->st_shndx
= sm
->s
->sh_num
;
2452 sym
->st_value
+= sm
->offset
;
2455 name
= (char *) strtab
+ sym
->st_name
;
2456 sym_index
= set_elf_sym(symtab_section
, sym
->st_value
, sym
->st_size
,
2457 sym
->st_info
, sym
->st_other
,
2458 sym
->st_shndx
, name
);
2459 old_to_new_syms
[i
] = sym_index
;
2462 /* third pass to patch relocation entries */
2463 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2468 offset
= sm_table
[i
].offset
;
2469 switch(s
->sh_type
) {
2471 /* take relocation offset information */
2472 offseti
= sm_table
[sh
->sh_info
].offset
;
2473 for_each_elem(s
, (offset
/ sizeof(*rel
)), rel
, ElfW_Rel
) {
2476 /* convert symbol index */
2477 type
= ELFW(R_TYPE
)(rel
->r_info
);
2478 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
2479 /* NOTE: only one symtab assumed */
2480 if (sym_index
>= nb_syms
)
2482 sym_index
= old_to_new_syms
[sym_index
];
2483 /* ignore link_once in rel section. */
2484 if (!sym_index
&& !sm
->link_once
2485 #ifdef TCC_TARGET_ARM
2486 && type
!= R_ARM_V4BX
2490 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2491 i
, strsec
+ sh
->sh_name
, rel
->r_offset
);
2494 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
2495 /* offset the relocation offset */
2496 rel
->r_offset
+= offseti
;
2497 #ifdef TCC_TARGET_ARM
2498 /* Jumps and branches from a Thumb code to a PLT entry need
2499 special handling since PLT entries are ARM code.
2500 Unconditional bl instructions referencing PLT entries are
2501 handled by converting these instructions into blx
2502 instructions. Other case of instructions referencing a PLT
2503 entry require to add a Thumb stub before the PLT entry to
2504 switch to ARM mode. We set bit plt_thumb_stub of the
2505 attribute of a symbol to indicate such a case. */
2506 if (type
== R_ARM_THM_JUMP24
)
2507 get_sym_attr(s1
, sym_index
, 1)->plt_thumb_stub
= 1;
2520 tcc_free(old_to_new_syms
);
2527 typedef struct ArchiveHeader
{
2528 char ar_name
[16]; /* name of this member */
2529 char ar_date
[12]; /* file mtime */
2530 char ar_uid
[6]; /* owner uid; printed as decimal */
2531 char ar_gid
[6]; /* owner gid; printed as decimal */
2532 char ar_mode
[8]; /* file mode, printed as octal */
2533 char ar_size
[10]; /* file size, printed as decimal */
2534 char ar_fmag
[2]; /* should contain ARFMAG */
2537 static int get_be32(const uint8_t *b
)
2539 return b
[3] | (b
[2] << 8) | (b
[1] << 16) | (b
[0] << 24);
2542 static long get_be64(const uint8_t *b
)
2544 long long ret
= get_be32(b
);
2545 ret
= (ret
<< 32) | (unsigned)get_be32(b
+4);
2549 /* load only the objects which resolve undefined symbols */
2550 static int tcc_load_alacarte(TCCState
*s1
, int fd
, int size
, int entrysize
)
2552 long i
, bound
, nsyms
, sym_index
, off
, ret
;
2554 const char *ar_names
, *p
;
2555 const uint8_t *ar_index
;
2558 data
= tcc_malloc(size
);
2559 if (read(fd
, data
, size
) != size
)
2561 nsyms
= entrysize
== 4 ? get_be32(data
) : get_be64(data
);
2562 ar_index
= data
+ entrysize
;
2563 ar_names
= (char *) ar_index
+ nsyms
* entrysize
;
2567 for(p
= ar_names
, i
= 0; i
< nsyms
; i
++, p
+= strlen(p
)+1) {
2568 sym_index
= find_elf_sym(symtab_section
, p
);
2570 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
2571 if(sym
->st_shndx
== SHN_UNDEF
) {
2572 off
= (entrysize
== 4
2573 ? get_be32(ar_index
+ i
* 4)
2574 : get_be64(ar_index
+ i
* 8))
2575 + sizeof(ArchiveHeader
);
2577 if(tcc_load_object_file(s1
, fd
, off
) < 0) {
2592 /* load a '.a' file */
2593 ST_FUNC
int tcc_load_archive(TCCState
*s1
, int fd
)
2600 unsigned long file_offset
;
2602 /* skip magic which was already checked */
2603 read(fd
, magic
, sizeof(magic
));
2606 len
= read(fd
, &hdr
, sizeof(hdr
));
2609 if (len
!= sizeof(hdr
)) {
2610 tcc_error_noabort("invalid archive");
2613 memcpy(ar_size
, hdr
.ar_size
, sizeof(hdr
.ar_size
));
2614 ar_size
[sizeof(hdr
.ar_size
)] = '\0';
2615 size
= strtol(ar_size
, NULL
, 0);
2616 memcpy(ar_name
, hdr
.ar_name
, sizeof(hdr
.ar_name
));
2617 for(i
= sizeof(hdr
.ar_name
) - 1; i
>= 0; i
--) {
2618 if (ar_name
[i
] != ' ')
2621 ar_name
[i
+ 1] = '\0';
2622 file_offset
= lseek(fd
, 0, SEEK_CUR
);
2624 size
= (size
+ 1) & ~1;
2625 if (!strcmp(ar_name
, "/")) {
2626 /* coff symbol table : we handle it */
2627 if(s1
->alacarte_link
)
2628 return tcc_load_alacarte(s1
, fd
, size
, 4);
2629 } else if (!strcmp(ar_name
, "/SYM64/")) {
2630 if(s1
->alacarte_link
)
2631 return tcc_load_alacarte(s1
, fd
, size
, 8);
2634 if (tcc_object_type(fd
, &ehdr
) == AFF_BINTYPE_REL
) {
2635 if (tcc_load_object_file(s1
, fd
, file_offset
) < 0)
2639 lseek(fd
, file_offset
+ size
, SEEK_SET
);
2644 #ifndef TCC_TARGET_PE
2645 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2646 is referenced by the user (so it should be added as DT_NEEDED in
2647 the generated ELF file) */
2648 ST_FUNC
int tcc_load_dll(TCCState
*s1
, int fd
, const char *filename
, int level
)
2651 ElfW(Shdr
) *shdr
, *sh
, *sh1
;
2652 int i
, j
, nb_syms
, nb_dts
, sym_bind
, ret
;
2653 ElfW(Sym
) *sym
, *dynsym
;
2654 ElfW(Dyn
) *dt
, *dynamic
;
2655 unsigned char *dynstr
;
2656 const char *name
, *soname
;
2657 DLLReference
*dllref
;
2659 read(fd
, &ehdr
, sizeof(ehdr
));
2661 /* test CPU specific stuff */
2662 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2663 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2664 tcc_error_noabort("bad architecture");
2669 shdr
= load_data(fd
, ehdr
.e_shoff
, sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2671 /* load dynamic section and dynamic symbols */
2675 dynsym
= NULL
; /* avoid warning */
2676 dynstr
= NULL
; /* avoid warning */
2677 for(i
= 0, sh
= shdr
; i
< ehdr
.e_shnum
; i
++, sh
++) {
2678 switch(sh
->sh_type
) {
2680 nb_dts
= sh
->sh_size
/ sizeof(ElfW(Dyn
));
2681 dynamic
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2684 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2685 dynsym
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2686 sh1
= &shdr
[sh
->sh_link
];
2687 dynstr
= load_data(fd
, sh1
->sh_offset
, sh1
->sh_size
);
2694 /* compute the real library name */
2695 soname
= tcc_basename(filename
);
2697 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2698 if (dt
->d_tag
== DT_SONAME
) {
2699 soname
= (char *) dynstr
+ dt
->d_un
.d_val
;
2703 /* if the dll is already loaded, do not load it */
2704 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2705 dllref
= s1
->loaded_dlls
[i
];
2706 if (!strcmp(soname
, dllref
->name
)) {
2707 /* but update level if needed */
2708 if (level
< dllref
->level
)
2709 dllref
->level
= level
;
2715 /* add the dll and its level */
2716 dllref
= tcc_mallocz(sizeof(DLLReference
) + strlen(soname
));
2717 dllref
->level
= level
;
2718 strcpy(dllref
->name
, soname
);
2719 dynarray_add(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
, dllref
);
2721 /* add dynamic symbols in dynsym_section */
2722 for(i
= 1, sym
= dynsym
+ 1; i
< nb_syms
; i
++, sym
++) {
2723 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
2724 if (sym_bind
== STB_LOCAL
)
2726 name
= (char *) dynstr
+ sym
->st_name
;
2727 set_elf_sym(s1
->dynsymtab_section
, sym
->st_value
, sym
->st_size
,
2728 sym
->st_info
, sym
->st_other
, sym
->st_shndx
, name
);
2731 /* load all referenced DLLs */
2732 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2735 name
= (char *) dynstr
+ dt
->d_un
.d_val
;
2736 for(j
= 0; j
< s1
->nb_loaded_dlls
; j
++) {
2737 dllref
= s1
->loaded_dlls
[j
];
2738 if (!strcmp(name
, dllref
->name
))
2739 goto already_loaded
;
2741 if (tcc_add_dll(s1
, name
, AFF_REFERENCED_DLL
) < 0) {
2742 tcc_error_noabort("referenced dll '%s' not found", name
);
2759 #define LD_TOK_NAME 256
2760 #define LD_TOK_EOF (-1)
2762 /* return next ld script token */
2763 static int ld_next(TCCState
*s1
, char *name
, int name_size
)
2781 file
->buf_ptr
= parse_comment(file
->buf_ptr
);
2782 ch
= file
->buf_ptr
[0];
2795 /* case 'a' ... 'z': */
2822 /* case 'A' ... 'z': */
2856 if (!((ch
>= 'a' && ch
<= 'z') ||
2857 (ch
>= 'A' && ch
<= 'Z') ||
2858 (ch
>= '0' && ch
<= '9') ||
2859 strchr("/.-_+=$:\\,~", ch
)))
2861 if ((q
- name
) < name_size
- 1) {
2880 static int ld_add_file(TCCState
*s1
, const char filename
[])
2882 if (filename
[0] == '/') {
2883 if (CONFIG_SYSROOT
[0] == '\0'
2884 && tcc_add_file_internal(s1
, filename
, AFF_TYPE_BIN
) == 0)
2886 filename
= tcc_basename(filename
);
2888 return tcc_add_dll(s1
, filename
, 0);
2891 static inline int new_undef_syms(void)
2894 ret
= new_undef_sym
;
2899 static int ld_add_file_list(TCCState
*s1
, const char *cmd
, int as_needed
)
2901 char filename
[1024], libname
[1024];
2902 int t
, group
, nblibs
= 0, ret
= 0;
2905 group
= !strcmp(cmd
, "GROUP");
2908 t
= ld_next(s1
, filename
, sizeof(filename
));
2911 t
= ld_next(s1
, filename
, sizeof(filename
));
2914 if (t
== LD_TOK_EOF
) {
2915 tcc_error_noabort("unexpected end of file");
2917 goto lib_parse_error
;
2918 } else if (t
== ')') {
2920 } else if (t
== '-') {
2921 t
= ld_next(s1
, filename
, sizeof(filename
));
2922 if ((t
!= LD_TOK_NAME
) || (filename
[0] != 'l')) {
2923 tcc_error_noabort("library name expected");
2925 goto lib_parse_error
;
2927 pstrcpy(libname
, sizeof libname
, &filename
[1]);
2928 if (s1
->static_link
) {
2929 snprintf(filename
, sizeof filename
, "lib%s.a", libname
);
2931 snprintf(filename
, sizeof filename
, "lib%s.so", libname
);
2933 } else if (t
!= LD_TOK_NAME
) {
2934 tcc_error_noabort("filename expected");
2936 goto lib_parse_error
;
2938 if (!strcmp(filename
, "AS_NEEDED")) {
2939 ret
= ld_add_file_list(s1
, cmd
, 1);
2941 goto lib_parse_error
;
2943 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2945 ret
= ld_add_file(s1
, filename
);
2947 goto lib_parse_error
;
2949 /* Add the filename *and* the libname to avoid future conversions */
2950 dynarray_add(&libs
, &nblibs
, tcc_strdup(filename
));
2951 if (libname
[0] != '\0')
2952 dynarray_add(&libs
, &nblibs
, tcc_strdup(libname
));
2956 t
= ld_next(s1
, filename
, sizeof(filename
));
2958 t
= ld_next(s1
, filename
, sizeof(filename
));
2961 if (group
&& !as_needed
) {
2962 while (new_undef_syms()) {
2965 for (i
= 0; i
< nblibs
; i
++)
2966 ld_add_file(s1
, libs
[i
]);
2970 dynarray_reset(&libs
, &nblibs
);
2974 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
2976 ST_FUNC
int tcc_load_ldscript(TCCState
*s1
)
2979 char filename
[1024];
2984 t
= ld_next(s1
, cmd
, sizeof(cmd
));
2985 if (t
== LD_TOK_EOF
)
2987 else if (t
!= LD_TOK_NAME
)
2989 if (!strcmp(cmd
, "INPUT") ||
2990 !strcmp(cmd
, "GROUP")) {
2991 ret
= ld_add_file_list(s1
, cmd
, 0);
2994 } else if (!strcmp(cmd
, "OUTPUT_FORMAT") ||
2995 !strcmp(cmd
, "TARGET")) {
2996 /* ignore some commands */
2997 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3001 t
= ld_next(s1
, filename
, sizeof(filename
));
3002 if (t
== LD_TOK_EOF
) {
3003 tcc_error_noabort("unexpected end of file");
3005 } else if (t
== ')') {
3015 #endif /* !TCC_TARGET_PE */