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 aligment */
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 s
->sh_info
= q
- new_syms
;
684 /* then second pass for non local symbols */
685 p
= (ElfW(Sym
) *)s
->data
;
686 for(i
= 0; i
< nb_syms
; i
++) {
687 if (ELFW(ST_BIND
)(p
->st_info
) != STB_LOCAL
) {
688 old_to_new_syms
[i
] = q
- new_syms
;
694 /* we copy the new symbols to the old */
695 memcpy(s
->data
, new_syms
, nb_syms
* sizeof(ElfW(Sym
)));
698 /* now we modify all the relocations */
699 for(i
= 1; i
< s1
->nb_sections
; i
++) {
700 sr
= s1
->sections
[i
];
701 if (sr
->sh_type
== SHT_RELX
&& sr
->link
== s
) {
702 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
703 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
704 type
= ELFW(R_TYPE
)(rel
->r_info
);
705 sym_index
= old_to_new_syms
[sym_index
];
706 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
711 tcc_free(old_to_new_syms
);
714 /* relocate common symbols in the .bss section */
715 ST_FUNC
void relocate_common_syms(void)
719 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
720 if (sym
->st_shndx
== SHN_COMMON
) {
721 /* symbol alignment is in st_value for SHN_COMMONs */
722 sym
->st_value
= section_add(bss_section
, sym
->st_size
,
724 sym
->st_shndx
= bss_section
->sh_num
;
729 /* relocate symbol table, resolve undefined symbols if do_resolve is
730 true and output error if undefined symbol. */
731 ST_FUNC
void relocate_syms(TCCState
*s1
, Section
*symtab
, int do_resolve
)
734 int sym_bind
, sh_num
;
737 for_each_elem(symtab
, 1, sym
, ElfW(Sym
)) {
738 sh_num
= sym
->st_shndx
;
739 if (sh_num
== SHN_UNDEF
) {
740 name
= (char *) strtab_section
->data
+ sym
->st_name
;
741 /* Use ld.so to resolve symbol for us (for tcc -run) */
743 #if defined TCC_IS_NATIVE && !defined TCC_TARGET_PE
744 void *addr
= dlsym(RTLD_DEFAULT
, name
);
746 sym
->st_value
= (addr_t
) addr
;
748 printf ("relocate_sym: %s -> 0x%lx\n", name
, sym
->st_value
);
753 /* if dynamic symbol exist, it will be used in relocate_section */
754 } else if (s1
->dynsym
&& find_elf_sym(s1
->dynsym
, name
))
756 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
758 if (!strcmp(name
, "_fp_hw"))
760 /* only weak symbols are accepted to be undefined. Their
762 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
763 if (sym_bind
== STB_WEAK
)
766 tcc_error_noabort("undefined symbol '%s'", name
);
767 } else if (sh_num
< SHN_LORESERVE
) {
768 /* add section base */
769 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
775 /* relocate a given section (CPU dependent) by applying the relocations
776 in the associated relocation section */
777 ST_FUNC
void relocate_section(TCCState
*s1
, Section
*s
)
779 Section
*sr
= s
->reloc
;
788 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
789 ptr
= s
->data
+ rel
->r_offset
;
790 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
791 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
792 type
= ELFW(R_TYPE
)(rel
->r_info
);
794 #if SHT_RELX == SHT_RELA
795 tgt
+= rel
->r_addend
;
797 addr
= s
->sh_addr
+ rel
->r_offset
;
798 relocate(s1
, rel
, type
, ptr
, addr
, tgt
);
800 /* if the relocation is allocated, we change its symbol table */
801 if (sr
->sh_flags
& SHF_ALLOC
)
802 sr
->link
= s1
->dynsym
;
805 /* relocate relocation table in 'sr' */
806 static void relocate_rel(TCCState
*s1
, Section
*sr
)
811 s
= s1
->sections
[sr
->sh_info
];
812 for_each_elem(sr
, 0, rel
, ElfW_Rel
)
813 rel
->r_offset
+= s
->sh_addr
;
816 /* count the number of dynamic relocations so that we can reserve
818 static int prepare_dynamic_rel(TCCState
*s1
, Section
*sr
)
821 int sym_index
, type
, count
;
824 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
825 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
826 type
= ELFW(R_TYPE
)(rel
->r_info
);
828 #if defined(TCC_TARGET_I386)
830 #elif defined(TCC_TARGET_X86_64)
837 #if defined(TCC_TARGET_I386)
839 #elif defined(TCC_TARGET_X86_64)
842 if (get_sym_attr(s1
, sym_index
, 0)->dyn_index
)
850 /* allocate the section */
851 sr
->sh_flags
|= SHF_ALLOC
;
852 sr
->sh_size
= count
* sizeof(ElfW_Rel
);
857 static void build_got(TCCState
*s1
)
859 /* if no got, then create it */
860 s1
->got
= new_section(s1
, ".got", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
861 s1
->got
->sh_entsize
= 4;
862 set_elf_sym(symtab_section
, 0, 4, ELFW(ST_INFO
)(STB_GLOBAL
, STT_OBJECT
),
863 0, s1
->got
->sh_num
, "_GLOBAL_OFFSET_TABLE_");
864 /* keep space for _DYNAMIC pointer and two dummy got entries */
865 section_ptr_add(s1
->got
, 3 * PTR_SIZE
);
868 /* Create a GOT and (for function call) a PLT entry corresponding to a symbol
869 in s1->symtab. When creating the dynamic symbol table entry for the GOT
870 relocation, use 'size' and 'info' for the corresponding symbol metadata.
871 Returns the offset of the GOT or (if any) PLT entry. */
872 static struct sym_attr
* put_got_entry(TCCState
*s1
, int dyn_reloc_type
,
873 int reloc_type
, unsigned long size
,
874 int info
, int sym_index
)
879 struct sym_attr
*attr
;
884 need_plt_entry
= (dyn_reloc_type
== R_JMP_SLOT
);
885 attr
= get_sym_attr(s1
, sym_index
, 1);
887 /* In case a function is both called and its address taken 2 GOT entries
888 are created, one for taking the address (GOT) and the other for the PLT
890 if (need_plt_entry
? attr
->plt_offset
: attr
->got_offset
)
893 /* create the GOT entry */
894 got_offset
= s1
->got
->data_offset
;
895 section_ptr_add(s1
->got
, PTR_SIZE
);
897 /* Create the GOT relocation that will insert the address of the object or
898 function of interest in the GOT entry. This is a static relocation for
899 memory output (dlsym will give us the address of symbols) and dynamic
900 relocation otherwise (executable and DLLs). The relocation should be
901 done lazily for GOT entry with *_JUMP_SLOT relocation type (the one
902 associated to a PLT entry) but is currently done at load time for an
905 sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
906 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
909 if (0 == attr
->dyn_index
)
910 attr
->dyn_index
= set_elf_sym(s1
->dynsym
, sym
->st_value
, size
,
911 info
, 0, sym
->st_shndx
, name
);
912 put_elf_reloc(s1
->dynsym
, s1
->got
, got_offset
, dyn_reloc_type
,
915 put_elf_reloc(symtab_section
, s1
->got
, got_offset
, dyn_reloc_type
,
919 if (need_plt_entry
) {
921 s1
->plt
= new_section(s1
, ".plt", SHT_PROGBITS
,
922 SHF_ALLOC
| SHF_EXECINSTR
);
923 s1
->plt
->sh_entsize
= 4;
926 attr
->plt_offset
= create_plt_entry(s1
, got_offset
, attr
);
928 /* create a symbol 'sym@plt' for the PLT jump vector */
930 if (len
> sizeof plt_name
- 5)
931 len
= sizeof plt_name
- 5;
932 memcpy(plt_name
, name
, len
);
933 strcpy(plt_name
+ len
, "@plt");
934 attr
->plt_sym
= put_elf_sym(s1
->symtab
, attr
->plt_offset
, sym
->st_size
,
935 ELFW(ST_INFO
)(STB_GLOBAL
, STT_FUNC
), 0, s1
->plt
->sh_num
, plt_name
);
938 attr
->got_offset
= got_offset
;
944 /* build GOT and PLT entries */
945 ST_FUNC
void build_got_entries(TCCState
*s1
)
950 int i
, type
, gotplt_entry
, reloc_type
, sym_index
;
951 struct sym_attr
*attr
;
953 for(i
= 1; i
< s1
->nb_sections
; i
++) {
955 if (s
->sh_type
!= SHT_RELX
)
957 /* no need to handle got relocations */
958 if (s
->link
!= symtab_section
)
960 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
961 type
= ELFW(R_TYPE
)(rel
->r_info
);
962 gotplt_entry
= gotplt_entry_type(type
);
963 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
964 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
966 if (gotplt_entry
== NO_GOTPLT_ENTRY
) {
970 /* Automatically create PLT/GOT [entry] if it is an undefined
971 reference (resolved at runtime), or the symbol is absolute,
972 probably created by tcc_add_symbol, and thus on 64-bit
973 targets might be too far from application code. */
974 if (gotplt_entry
== AUTO_GOTPLT_ENTRY
) {
975 if (sym
->st_shndx
== SHN_UNDEF
) {
978 if (s1
->output_type
== TCC_OUTPUT_DLL
&& ! PCRELATIVE_DLLPLT
)
980 /* Relocations for UNDEF symbols would normally need
981 to be transferred into the executable or shared object.
982 If that were done AUTO_GOTPLT_ENTRY wouldn't exist.
983 But TCC doesn't do that (at least for exes), so we
984 need to resolve all such relocs locally. And that
985 means PLT slots for functions in DLLs and COPY relocs for
986 data symbols. COPY relocs were generated in
987 bind_exe_dynsyms (and the symbol adjusted to be defined),
988 and for functions we were generated a dynamic symbol
991 /* dynsym isn't set for -run :-/ */
992 dynindex
= get_sym_attr(s1
, sym_index
, 0)->dyn_index
;
993 esym
= (ElfW(Sym
) *)s1
->dynsym
->data
+ dynindex
;
995 && (ELFW(ST_TYPE
)(esym
->st_info
) == STT_FUNC
996 || (ELFW(ST_TYPE
)(esym
->st_info
) == STT_NOTYPE
997 && ELFW(ST_TYPE
)(sym
->st_info
) == STT_FUNC
)))
1000 } else if (!(sym
->st_shndx
== SHN_ABS
1001 #ifndef TCC_TARGET_ARM
1008 #ifdef TCC_TARGET_X86_64
1009 if (type
== R_X86_64_PLT32
&&
1010 ELFW(ST_VISIBILITY
)(sym
->st_other
) != STV_DEFAULT
) {
1011 rel
->r_info
= ELFW(R_INFO
)(sym_index
, R_X86_64_PC32
);
1015 if (code_reloc(type
)) {
1017 reloc_type
= R_JMP_SLOT
;
1019 reloc_type
= R_GLOB_DAT
;
1024 if (gotplt_entry
== BUILD_GOT_ONLY
)
1027 attr
= put_got_entry(s1
, reloc_type
, type
, sym
->st_size
, sym
->st_info
,
1030 if (reloc_type
== R_JMP_SLOT
)
1031 rel
->r_info
= ELFW(R_INFO
)(attr
->plt_sym
, type
);
1036 /* put dynamic tag */
1037 static void put_dt(Section
*dynamic
, int dt
, addr_t val
)
1040 dyn
= section_ptr_add(dynamic
, sizeof(ElfW(Dyn
)));
1042 dyn
->d_un
.d_val
= val
;
1045 #ifndef TCC_TARGET_PE
1046 static void add_init_array_defines(TCCState
*s1
, const char *section_name
)
1050 char sym_start
[1024];
1053 snprintf(sym_start
, sizeof(sym_start
), "__%s_start", section_name
+ 1);
1054 snprintf(sym_end
, sizeof(sym_end
), "__%s_end", section_name
+ 1);
1056 s
= find_section(s1
, section_name
);
1061 end_offset
= s
->data_offset
;
1064 set_elf_sym(symtab_section
,
1066 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1067 s
->sh_num
, sym_start
);
1068 set_elf_sym(symtab_section
,
1070 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1071 s
->sh_num
, sym_end
);
1075 static int tcc_add_support(TCCState
*s1
, const char *filename
)
1078 snprintf(buf
, sizeof(buf
), "%s/%s", s1
->tcc_lib_path
, filename
);
1079 return tcc_add_file(s1
, buf
);
1082 ST_FUNC
void tcc_add_bcheck(TCCState
*s1
)
1084 #ifdef CONFIG_TCC_BCHECK
1088 if (0 == s1
->do_bounds_check
)
1090 /* XXX: add an object file to do that */
1091 ptr
= section_ptr_add(bounds_section
, sizeof(*ptr
));
1093 set_elf_sym(symtab_section
, 0, 0,
1094 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1095 bounds_section
->sh_num
, "__bounds_start");
1096 /* pull bcheck.o from libtcc1.a */
1097 sym_index
= set_elf_sym(symtab_section
, 0, 0,
1098 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1099 SHN_UNDEF
, "__bound_init");
1100 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
) {
1101 /* add 'call __bound_init()' in .init section */
1102 Section
*init_section
= find_section(s1
, ".init");
1103 unsigned char *pinit
= section_ptr_add(init_section
, 5);
1105 write32le(pinit
+ 1, -4);
1106 put_elf_reloc(symtab_section
, init_section
,
1107 init_section
->data_offset
- 4, R_386_PC32
, sym_index
);
1108 /* R_386_PC32 = R_X86_64_PC32 = 2 */
1113 /* add tcc runtime libraries */
1114 ST_FUNC
void tcc_add_runtime(TCCState
*s1
)
1117 tcc_add_pragma_libs(s1
);
1119 if (!s1
->nostdlib
) {
1120 tcc_add_library_err(s1
, "c");
1122 if (!s1
->static_link
) {
1123 if (TCC_LIBGCC
[0] == '/')
1124 tcc_add_file(s1
, TCC_LIBGCC
);
1126 tcc_add_dll(s1
, TCC_LIBGCC
, 0);
1129 tcc_add_support(s1
, TCC_LIBTCC1
);
1130 /* add crt end if not memory output */
1131 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
)
1132 tcc_add_crt(s1
, "crtn.o");
1136 /* add various standard linker symbols (must be done after the
1137 sections are filled (for example after allocating common
1139 ST_FUNC
void tcc_add_linker_symbols(TCCState
*s1
)
1145 set_elf_sym(symtab_section
,
1146 text_section
->data_offset
, 0,
1147 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1148 text_section
->sh_num
, "_etext");
1149 set_elf_sym(symtab_section
,
1150 data_section
->data_offset
, 0,
1151 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1152 data_section
->sh_num
, "_edata");
1153 set_elf_sym(symtab_section
,
1154 bss_section
->data_offset
, 0,
1155 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1156 bss_section
->sh_num
, "_end");
1157 #ifndef TCC_TARGET_PE
1158 /* horrible new standard ldscript defines */
1159 add_init_array_defines(s1
, ".preinit_array");
1160 add_init_array_defines(s1
, ".init_array");
1161 add_init_array_defines(s1
, ".fini_array");
1164 /* add start and stop symbols for sections whose name can be
1166 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1167 s
= s1
->sections
[i
];
1168 if (s
->sh_type
== SHT_PROGBITS
&&
1169 (s
->sh_flags
& SHF_ALLOC
)) {
1173 /* check if section name can be expressed in C */
1179 if (!isid(ch
) && !isnum(ch
))
1183 snprintf(buf
, sizeof(buf
), "__start_%s", s
->name
);
1184 set_elf_sym(symtab_section
,
1186 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1188 snprintf(buf
, sizeof(buf
), "__stop_%s", s
->name
);
1189 set_elf_sym(symtab_section
,
1191 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1198 static void tcc_output_binary(TCCState
*s1
, FILE *f
,
1199 const int *sec_order
)
1202 int i
, offset
, size
;
1205 for(i
=1;i
<s1
->nb_sections
;i
++) {
1206 s
= s1
->sections
[sec_order
[i
]];
1207 if (s
->sh_type
!= SHT_NOBITS
&&
1208 (s
->sh_flags
& SHF_ALLOC
)) {
1209 while (offset
< s
->sh_offset
) {
1214 fwrite(s
->data
, 1, size
, f
);
1220 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1222 #define EXTRA_RELITEMS 14
1225 #define EXTRA_RELITEMS 9
1228 ST_FUNC
void fill_got_entry(TCCState
*s1
, ElfW_Rel
*rel
)
1230 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1231 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1232 struct sym_attr
*attr
= get_sym_attr(s1
, sym_index
, 0);
1233 unsigned offset
= attr
->got_offset
;
1237 section_reserve(s1
->got
, offset
+ PTR_SIZE
);
1238 #ifdef TCC_TARGET_X86_64
1239 write64le(s1
->got
->data
+ offset
, sym
->st_value
);
1241 write32le(s1
->got
->data
+ offset
, sym
->st_value
);
1245 /* Perform relocation to GOT or PLT entries */
1246 ST_FUNC
void fill_got(TCCState
*s1
)
1252 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1253 s
= s1
->sections
[i
];
1254 if (s
->sh_type
!= SHT_RELX
)
1256 /* no need to handle got relocations */
1257 if (s
->link
!= symtab_section
)
1259 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1260 switch (ELFW(R_TYPE
) (rel
->r_info
)) {
1261 case R_X86_64_GOT32
:
1262 case R_X86_64_GOTPCREL
:
1263 case R_X86_64_GOTPCRELX
:
1264 case R_X86_64_REX_GOTPCRELX
:
1265 case R_X86_64_PLT32
:
1266 fill_got_entry(s1
, rel
);
1273 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1274 in shared libraries and export non local defined symbols to shared libraries
1275 if -rdynamic switch was given on command line */
1276 static void bind_exe_dynsyms(TCCState
*s1
)
1279 int sym_index
, index
;
1280 ElfW(Sym
) *sym
, *esym
;
1283 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1284 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1285 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1286 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1287 if (sym
->st_shndx
== SHN_UNDEF
) {
1288 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1289 sym_index
= find_elf_sym(s1
->dynsymtab_section
, name
);
1291 esym
= &((ElfW(Sym
) *)s1
->dynsymtab_section
->data
)[sym_index
];
1292 type
= ELFW(ST_TYPE
)(esym
->st_info
);
1293 if ((type
== STT_FUNC
) || (type
== STT_GNU_IFUNC
)) {
1294 /* Indirect functions shall have STT_FUNC type in executable
1295 * dynsym section. Indeed, a dlsym call following a lazy
1296 * resolution would pick the symbol value from the
1297 * executable dynsym entry which would contain the address
1298 * of the function wanted by the caller of dlsym instead of
1299 * the address of the function that would return that
1302 = put_elf_sym(s1
->dynsym
, 0, esym
->st_size
,
1303 ELFW(ST_INFO
)(STB_GLOBAL
,STT_FUNC
), 0, 0,
1305 int index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1306 get_sym_attr(s1
, index
, 1)->dyn_index
= dynindex
;
1307 } else if (type
== STT_OBJECT
) {
1308 unsigned long offset
;
1310 offset
= bss_section
->data_offset
;
1311 /* XXX: which alignment ? */
1312 offset
= (offset
+ 16 - 1) & -16;
1313 set_elf_sym (s1
->symtab
, offset
, esym
->st_size
,
1314 esym
->st_info
, 0, bss_section
->sh_num
, name
);
1315 index
= put_elf_sym(s1
->dynsym
, offset
, esym
->st_size
,
1316 esym
->st_info
, 0, bss_section
->sh_num
,
1319 /* Ensure R_COPY works for weak symbol aliases */
1320 if (ELFW(ST_BIND
)(esym
->st_info
) == STB_WEAK
) {
1321 for_each_elem(s1
->dynsymtab_section
, 1, dynsym
, ElfW(Sym
)) {
1322 if ((dynsym
->st_value
== esym
->st_value
)
1323 && (ELFW(ST_BIND
)(dynsym
->st_info
) == STB_GLOBAL
)) {
1324 char *dynname
= (char *) s1
->dynsymtab_section
->link
->data
1326 put_elf_sym(s1
->dynsym
, offset
, dynsym
->st_size
,
1328 bss_section
->sh_num
, dynname
);
1334 put_elf_reloc(s1
->dynsym
, bss_section
,
1335 offset
, R_COPY
, index
);
1336 offset
+= esym
->st_size
;
1337 bss_section
->data_offset
= offset
;
1340 /* STB_WEAK undefined symbols are accepted */
1341 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1342 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
||
1343 !strcmp(name
, "_fp_hw")) {
1345 tcc_error_noabort("undefined symbol '%s'", name
);
1348 } else if (s1
->rdynamic
&& ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1349 /* if -rdynamic option, then export all non local symbols */
1350 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1351 set_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1352 0, sym
->st_shndx
, name
);
1357 /* Bind symbols of libraries: export all non local symbols of executable that
1358 are referenced by shared libraries. The reason is that the dynamic loader
1359 search symbol first in executable and then in libraries. Therefore a
1360 reference to a symbol already defined by a library can still be resolved by
1361 a symbol in the executable. */
1362 static void bind_libs_dynsyms(TCCState
*s1
)
1366 ElfW(Sym
) *sym
, *esym
;
1368 for_each_elem(s1
->dynsymtab_section
, 1, esym
, ElfW(Sym
)) {
1369 name
= (char *) s1
->dynsymtab_section
->link
->data
+ esym
->st_name
;
1370 sym_index
= find_elf_sym(symtab_section
, name
);
1371 /* XXX: avoid adding a symbol if already present because of
1373 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1374 if (sym_index
&& sym
->st_shndx
!= SHN_UNDEF
)
1375 set_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1376 0, sym
->st_shndx
, name
);
1377 else if (esym
->st_shndx
== SHN_UNDEF
) {
1378 /* weak symbols can stay undefined */
1379 if (ELFW(ST_BIND
)(esym
->st_info
) != STB_WEAK
)
1380 tcc_warning("undefined dynamic symbol '%s'", name
);
1385 /* Export all non local symbols. This is used by shared libraries so that the
1386 non local symbols they define can resolve a reference in another shared
1387 library or in the executable. Correspondingly, it allows undefined local
1388 symbols to be resolved by other shared libraries or by the executable. */
1389 static void export_global_syms(TCCState
*s1
)
1391 int dynindex
, index
;
1395 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1396 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1397 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1398 dynindex
= put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1399 sym
->st_info
, 0, sym
->st_shndx
, name
);
1400 index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1401 get_sym_attr(s1
, index
, 1)->dyn_index
= dynindex
;
1406 /* Allocate strings for section names and decide if an unallocated section
1408 NOTE: the strsec section comes last, so its size is also correct ! */
1409 static void alloc_sec_names(TCCState
*s1
, int file_type
, Section
*strsec
)
1414 /* Allocate strings for section names */
1415 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1416 s
= s1
->sections
[i
];
1417 /* when generating a DLL, we include relocations but we may
1419 if (file_type
== TCC_OUTPUT_DLL
&&
1420 s
->sh_type
== SHT_RELX
&&
1421 !(s
->sh_flags
& SHF_ALLOC
)) {
1422 /* gr: avoid bogus relocs for empty (debug) sections */
1423 if (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_ALLOC
)
1424 prepare_dynamic_rel(s1
, s
);
1425 else if (s1
->do_debug
)
1426 s
->sh_size
= s
->data_offset
;
1427 } else if (s1
->do_debug
||
1428 file_type
== TCC_OUTPUT_OBJ
||
1429 (s
->sh_flags
& SHF_ALLOC
) ||
1430 i
== (s1
->nb_sections
- 1)) {
1431 /* we output all sections if debug or object file */
1432 s
->sh_size
= s
->data_offset
;
1434 if (s
->sh_size
|| (s
->sh_flags
& SHF_ALLOC
))
1435 s
->sh_name
= put_elf_str(strsec
, s
->name
);
1437 strsec
->sh_size
= strsec
->data_offset
;
1440 /* Info to be copied in dynamic section */
1444 unsigned long dyn_rel_off
;
1447 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1453 /* Assign sections to segments and decide how are sections laid out when loaded
1454 in memory. This function also fills corresponding program headers. */
1455 static int layout_sections(TCCState
*s1
, ElfW(Phdr
) *phdr
, int phnum
,
1456 Section
*interp
, Section
* strsec
,
1457 struct dyn_inf
*dyninf
, int *sec_order
)
1459 int i
, j
, k
, file_type
, sh_order_index
, file_offset
;
1460 unsigned long s_align
;
1466 file_type
= s1
->output_type
;
1469 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
1470 file_offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1471 s_align
= ELF_PAGE_SIZE
;
1472 if (s1
->section_align
)
1473 s_align
= s1
->section_align
;
1476 if (s1
->has_text_addr
) {
1477 int a_offset
, p_offset
;
1478 addr
= s1
->text_addr
;
1479 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1481 a_offset
= (int) (addr
& (s_align
- 1));
1482 p_offset
= file_offset
& (s_align
- 1);
1483 if (a_offset
< p_offset
)
1484 a_offset
+= s_align
;
1485 file_offset
+= (a_offset
- p_offset
);
1487 if (file_type
== TCC_OUTPUT_DLL
)
1490 addr
= ELF_START_ADDR
;
1491 /* compute address after headers */
1492 addr
+= (file_offset
& (s_align
- 1));
1496 /* Leave one program headers for the program interpreter and one for
1497 the program header table itself if needed. These are done later as
1498 they require section layout to be done first. */
1500 ph
+= 1 + HAVE_PHDR
;
1502 /* dynamic relocation table information, for .dynamic section */
1503 dyninf
->rel_addr
= dyninf
->rel_size
= 0;
1504 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1505 dyninf
->bss_addr
= dyninf
->bss_size
= 0;
1508 for(j
= 0; j
< 2; j
++) {
1509 ph
->p_type
= PT_LOAD
;
1511 ph
->p_flags
= PF_R
| PF_X
;
1513 ph
->p_flags
= PF_R
| PF_W
;
1514 ph
->p_align
= s_align
;
1516 /* Decide the layout of sections loaded in memory. This must
1517 be done before program headers are filled since they contain
1518 info about the layout. We do the following ordering: interp,
1519 symbol tables, relocations, progbits, nobits */
1520 /* XXX: do faster and simpler sorting */
1521 for(k
= 0; k
< 5; k
++) {
1522 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1523 s
= s1
->sections
[i
];
1524 /* compute if section should be included */
1526 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1530 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1531 (SHF_ALLOC
| SHF_WRITE
))
1537 } else if (s
->sh_type
== SHT_DYNSYM
||
1538 s
->sh_type
== SHT_STRTAB
||
1539 s
->sh_type
== SHT_HASH
) {
1542 } else if (s
->sh_type
== SHT_RELX
) {
1545 } else if (s
->sh_type
== SHT_NOBITS
) {
1552 sec_order
[sh_order_index
++] = i
;
1554 /* section matches: we align it and add its size */
1556 addr
= (addr
+ s
->sh_addralign
- 1) &
1557 ~(s
->sh_addralign
- 1);
1558 file_offset
+= (int) ( addr
- tmp
);
1559 s
->sh_offset
= file_offset
;
1562 /* update program header infos */
1563 if (ph
->p_offset
== 0) {
1564 ph
->p_offset
= file_offset
;
1566 ph
->p_paddr
= ph
->p_vaddr
;
1568 /* update dynamic relocation infos */
1569 if (s
->sh_type
== SHT_RELX
) {
1570 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1571 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.got")) {
1572 dyninf
->rel_addr
= addr
;
1573 dyninf
->rel_size
+= s
->sh_size
; /* XXX only first rel. */
1575 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.bss")) {
1576 dyninf
->bss_addr
= addr
;
1577 dyninf
->bss_size
= s
->sh_size
; /* XXX only first rel. */
1580 if (dyninf
->rel_size
== 0)
1581 dyninf
->rel_addr
= addr
;
1582 dyninf
->rel_size
+= s
->sh_size
;
1586 if (s
->sh_type
!= SHT_NOBITS
)
1587 file_offset
+= s
->sh_size
;
1591 /* Make the first PT_LOAD segment include the program
1592 headers itself (and the ELF header as well), it'll
1593 come out with same memory use but will make various
1594 tools like binutils strip work better. */
1595 ph
->p_offset
&= ~(ph
->p_align
- 1);
1596 ph
->p_vaddr
&= ~(ph
->p_align
- 1);
1597 ph
->p_paddr
&= ~(ph
->p_align
- 1);
1599 ph
->p_filesz
= file_offset
- ph
->p_offset
;
1600 ph
->p_memsz
= addr
- ph
->p_vaddr
;
1603 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
) {
1604 /* if in the middle of a page, we duplicate the page in
1605 memory so that one copy is RX and the other is RW */
1606 if ((addr
& (s_align
- 1)) != 0)
1609 addr
= (addr
+ s_align
- 1) & ~(s_align
- 1);
1610 file_offset
= (file_offset
+ s_align
- 1) & ~(s_align
- 1);
1616 /* all other sections come after */
1617 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1618 s
= s1
->sections
[i
];
1619 if (phnum
> 0 && (s
->sh_flags
& SHF_ALLOC
))
1621 sec_order
[sh_order_index
++] = i
;
1623 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
1624 ~(s
->sh_addralign
- 1);
1625 s
->sh_offset
= file_offset
;
1626 if (s
->sh_type
!= SHT_NOBITS
)
1627 file_offset
+= s
->sh_size
;
1633 static void fill_unloadable_phdr(ElfW(Phdr
) *phdr
, int phnum
, Section
*interp
,
1638 /* if interpreter, then add corresponding program header */
1644 int len
= phnum
* sizeof(ElfW(Phdr
));
1646 ph
->p_type
= PT_PHDR
;
1647 ph
->p_offset
= sizeof(ElfW(Ehdr
));
1648 ph
->p_vaddr
= interp
->sh_addr
- len
;
1649 ph
->p_paddr
= ph
->p_vaddr
;
1650 ph
->p_filesz
= ph
->p_memsz
= len
;
1651 ph
->p_flags
= PF_R
| PF_X
;
1652 ph
->p_align
= 4; /* interp->sh_addralign; */
1656 ph
->p_type
= PT_INTERP
;
1657 ph
->p_offset
= interp
->sh_offset
;
1658 ph
->p_vaddr
= interp
->sh_addr
;
1659 ph
->p_paddr
= ph
->p_vaddr
;
1660 ph
->p_filesz
= interp
->sh_size
;
1661 ph
->p_memsz
= interp
->sh_size
;
1663 ph
->p_align
= interp
->sh_addralign
;
1666 /* if dynamic section, then add corresponding program header */
1668 ph
= &phdr
[phnum
- 1];
1670 ph
->p_type
= PT_DYNAMIC
;
1671 ph
->p_offset
= dynamic
->sh_offset
;
1672 ph
->p_vaddr
= dynamic
->sh_addr
;
1673 ph
->p_paddr
= ph
->p_vaddr
;
1674 ph
->p_filesz
= dynamic
->sh_size
;
1675 ph
->p_memsz
= dynamic
->sh_size
;
1676 ph
->p_flags
= PF_R
| PF_W
;
1677 ph
->p_align
= dynamic
->sh_addralign
;
1681 /* Fill the dynamic section with tags describing the address and size of
1683 static void fill_dynamic(TCCState
*s1
, struct dyn_inf
*dyninf
)
1687 dynamic
= dyninf
->dynamic
;
1689 /* put dynamic section entries */
1690 dynamic
->data_offset
= dyninf
->dyn_rel_off
;
1691 put_dt(dynamic
, DT_HASH
, s1
->dynsym
->hash
->sh_addr
);
1692 put_dt(dynamic
, DT_STRTAB
, dyninf
->dynstr
->sh_addr
);
1693 put_dt(dynamic
, DT_SYMTAB
, s1
->dynsym
->sh_addr
);
1694 put_dt(dynamic
, DT_STRSZ
, dyninf
->dynstr
->data_offset
);
1695 put_dt(dynamic
, DT_SYMENT
, sizeof(ElfW(Sym
)));
1696 #if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
1697 put_dt(dynamic
, DT_RELA
, dyninf
->rel_addr
);
1698 put_dt(dynamic
, DT_RELASZ
, dyninf
->rel_size
);
1699 put_dt(dynamic
, DT_RELAENT
, sizeof(ElfW_Rel
));
1701 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1702 put_dt(dynamic
, DT_PLTGOT
, s1
->got
->sh_addr
);
1703 put_dt(dynamic
, DT_PLTRELSZ
, dyninf
->rel_size
);
1704 put_dt(dynamic
, DT_JMPREL
, dyninf
->rel_addr
);
1705 put_dt(dynamic
, DT_PLTREL
, DT_REL
);
1706 put_dt(dynamic
, DT_REL
, dyninf
->bss_addr
);
1707 put_dt(dynamic
, DT_RELSZ
, dyninf
->bss_size
);
1709 put_dt(dynamic
, DT_REL
, dyninf
->rel_addr
);
1710 put_dt(dynamic
, DT_RELSZ
, dyninf
->rel_size
);
1711 put_dt(dynamic
, DT_RELENT
, sizeof(ElfW_Rel
));
1715 put_dt(dynamic
, DT_DEBUG
, 0);
1716 put_dt(dynamic
, DT_NULL
, 0);
1719 /* Relocate remaining sections and symbols (that is those not related to
1721 static int final_sections_reloc(TCCState
*s1
)
1726 relocate_syms(s1
, s1
->symtab
, 0);
1728 if (s1
->nb_errors
!= 0)
1731 /* relocate sections */
1732 /* XXX: ignore sections with allocated relocations ? */
1733 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1734 s
= s1
->sections
[i
];
1735 #if defined(TCC_TARGET_I386) || defined(TCC_MUSL)
1736 if (s
->reloc
&& s
!= s1
->got
&& (s
->sh_flags
& SHF_ALLOC
)) //gr
1737 /* On X86 gdb 7.3 works in any case but gdb 6.6 will crash if SHF_ALLOC
1738 checking is removed */
1740 if (s
->reloc
&& s
!= s1
->got
)
1741 /* On X86_64 gdb 7.3 will crash if SHF_ALLOC checking is present */
1743 relocate_section(s1
, s
);
1746 /* relocate relocation entries if the relocation tables are
1747 allocated in the executable */
1748 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1749 s
= s1
->sections
[i
];
1750 if ((s
->sh_flags
& SHF_ALLOC
) &&
1751 s
->sh_type
== SHT_RELX
) {
1752 relocate_rel(s1
, s
);
1758 /* Create an ELF file on disk.
1759 This function handle ELF specific layout requirements */
1760 static void tcc_output_elf(TCCState
*s1
, FILE *f
, int phnum
, ElfW(Phdr
) *phdr
,
1761 int file_offset
, int *sec_order
)
1763 int i
, shnum
, offset
, size
, file_type
;
1766 ElfW(Shdr
) shdr
, *sh
;
1768 file_type
= s1
->output_type
;
1769 shnum
= s1
->nb_sections
;
1771 memset(&ehdr
, 0, sizeof(ehdr
));
1774 ehdr
.e_phentsize
= sizeof(ElfW(Phdr
));
1775 ehdr
.e_phnum
= phnum
;
1776 ehdr
.e_phoff
= sizeof(ElfW(Ehdr
));
1780 file_offset
= (file_offset
+ 3) & -4;
1783 ehdr
.e_ident
[0] = ELFMAG0
;
1784 ehdr
.e_ident
[1] = ELFMAG1
;
1785 ehdr
.e_ident
[2] = ELFMAG2
;
1786 ehdr
.e_ident
[3] = ELFMAG3
;
1787 ehdr
.e_ident
[4] = ELFCLASSW
;
1788 ehdr
.e_ident
[5] = ELFDATA2LSB
;
1789 ehdr
.e_ident
[6] = EV_CURRENT
;
1790 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1791 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
1793 #ifdef TCC_TARGET_ARM
1795 ehdr
.e_ident
[EI_OSABI
] = 0;
1796 ehdr
.e_flags
= EF_ARM_EABI_VER4
;
1797 if (file_type
== TCC_OUTPUT_EXE
|| file_type
== TCC_OUTPUT_DLL
)
1798 ehdr
.e_flags
|= EF_ARM_HASENTRY
;
1799 if (s1
->float_abi
== ARM_HARD_FLOAT
)
1800 ehdr
.e_flags
|= EF_ARM_VFP_FLOAT
;
1802 ehdr
.e_flags
|= EF_ARM_SOFT_FLOAT
;
1804 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_ARM
;
1809 case TCC_OUTPUT_EXE
:
1810 ehdr
.e_type
= ET_EXEC
;
1811 ehdr
.e_entry
= get_elf_sym_addr(s1
, "_start", 1);
1813 case TCC_OUTPUT_DLL
:
1814 ehdr
.e_type
= ET_DYN
;
1815 ehdr
.e_entry
= text_section
->sh_addr
; /* XXX: is it correct ? */
1817 case TCC_OUTPUT_OBJ
:
1818 ehdr
.e_type
= ET_REL
;
1821 ehdr
.e_machine
= EM_TCC_TARGET
;
1822 ehdr
.e_version
= EV_CURRENT
;
1823 ehdr
.e_shoff
= file_offset
;
1824 ehdr
.e_ehsize
= sizeof(ElfW(Ehdr
));
1825 ehdr
.e_shentsize
= sizeof(ElfW(Shdr
));
1826 ehdr
.e_shnum
= shnum
;
1827 ehdr
.e_shstrndx
= shnum
- 1;
1829 fwrite(&ehdr
, 1, sizeof(ElfW(Ehdr
)), f
);
1830 fwrite(phdr
, 1, phnum
* sizeof(ElfW(Phdr
)), f
);
1831 offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1833 sort_syms(s1
, symtab_section
);
1834 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1835 s
= s1
->sections
[sec_order
[i
]];
1836 if (s
->sh_type
!= SHT_NOBITS
) {
1837 while (offset
< s
->sh_offset
) {
1843 fwrite(s
->data
, 1, size
, f
);
1848 /* output section headers */
1849 while (offset
< ehdr
.e_shoff
) {
1854 for(i
= 0; i
< s1
->nb_sections
; i
++) {
1856 memset(sh
, 0, sizeof(ElfW(Shdr
)));
1857 s
= s1
->sections
[i
];
1859 sh
->sh_name
= s
->sh_name
;
1860 sh
->sh_type
= s
->sh_type
;
1861 sh
->sh_flags
= s
->sh_flags
;
1862 sh
->sh_entsize
= s
->sh_entsize
;
1863 sh
->sh_info
= s
->sh_info
;
1865 sh
->sh_link
= s
->link
->sh_num
;
1866 sh
->sh_addralign
= s
->sh_addralign
;
1867 sh
->sh_addr
= s
->sh_addr
;
1868 sh
->sh_offset
= s
->sh_offset
;
1869 sh
->sh_size
= s
->sh_size
;
1871 fwrite(sh
, 1, sizeof(ElfW(Shdr
)), f
);
1875 /* Write an elf, coff or "binary" file */
1876 static int tcc_write_elf_file(TCCState
*s1
, const char *filename
, int phnum
,
1877 ElfW(Phdr
) *phdr
, int file_offset
, int *sec_order
)
1879 int fd
, mode
, file_type
;
1882 file_type
= s1
->output_type
;
1883 if (file_type
== TCC_OUTPUT_OBJ
)
1888 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, mode
);
1890 tcc_error_noabort("could not write '%s'", filename
);
1893 f
= fdopen(fd
, "wb");
1895 printf("<- %s\n", filename
);
1897 #ifdef TCC_TARGET_COFF
1898 if (s1
->output_format
== TCC_OUTPUT_FORMAT_COFF
)
1899 tcc_output_coff(s1
, f
);
1902 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
1903 tcc_output_elf(s1
, f
, phnum
, phdr
, file_offset
, sec_order
);
1905 tcc_output_binary(s1
, f
, sec_order
);
1911 /* Sort section headers by assigned sh_addr, remove sections
1912 that we aren't going to output. */
1913 static void tidy_section_headers(TCCState
*s1
, int *sec_order
)
1915 int i
, nnew
, l
, *backmap
;
1919 snew
= tcc_malloc(s1
->nb_sections
* sizeof(snew
[0]));
1920 backmap
= tcc_malloc(s1
->nb_sections
* sizeof(backmap
[0]));
1921 for (i
= 0, nnew
= 0, l
= s1
->nb_sections
; i
< s1
->nb_sections
; i
++) {
1922 s
= s1
->sections
[sec_order
[i
]];
1923 if (!i
|| s
->sh_name
) {
1924 backmap
[sec_order
[i
]] = nnew
;
1928 backmap
[sec_order
[i
]] = 0;
1932 for (i
= 0; i
< nnew
; i
++) {
1936 if (s
->sh_type
== SHT_RELX
)
1937 s
->sh_info
= backmap
[s
->sh_info
];
1941 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
))
1942 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
)
1943 sym
->st_shndx
= backmap
[sym
->st_shndx
];
1944 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
))
1945 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
)
1946 sym
->st_shndx
= backmap
[sym
->st_shndx
];
1948 for (i
= 0; i
< s1
->nb_sections
; i
++)
1950 tcc_free(s1
->sections
);
1951 s1
->sections
= snew
;
1952 s1
->nb_sections
= nnew
;
1956 /* Output an elf, coff or binary file */
1957 /* XXX: suppress unneeded sections */
1958 static int elf_output_file(TCCState
*s1
, const char *filename
)
1960 int i
, ret
, phnum
, shnum
, file_type
, file_offset
, *sec_order
;
1961 struct dyn_inf dyninf
= {0};
1964 Section
*strsec
, *interp
, *dynamic
, *dynstr
;
1966 file_type
= s1
->output_type
;
1969 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
1970 if (file_type
!= TCC_OUTPUT_OBJ
) {
1971 tcc_add_runtime(s1
);
1976 interp
= dynamic
= dynstr
= NULL
; /* avoid warning */
1978 if (file_type
!= TCC_OUTPUT_OBJ
) {
1979 relocate_common_syms();
1981 tcc_add_linker_symbols(s1
);
1983 if (!s1
->static_link
) {
1984 if (file_type
== TCC_OUTPUT_EXE
) {
1986 /* allow override the dynamic loader */
1987 const char *elfint
= getenv("LD_SO");
1989 elfint
= DEFAULT_ELFINTERP(s1
);
1990 /* add interpreter section only if executable */
1991 interp
= new_section(s1
, ".interp", SHT_PROGBITS
, SHF_ALLOC
);
1992 interp
->sh_addralign
= 1;
1993 ptr
= section_ptr_add(interp
, 1 + strlen(elfint
));
1994 strcpy(ptr
, elfint
);
1997 /* add dynamic symbol table */
1998 s1
->dynsym
= new_symtab(s1
, ".dynsym", SHT_DYNSYM
, SHF_ALLOC
,
2000 ".hash", SHF_ALLOC
);
2001 dynstr
= s1
->dynsym
->link
;
2003 /* add dynamic section */
2004 dynamic
= new_section(s1
, ".dynamic", SHT_DYNAMIC
,
2005 SHF_ALLOC
| SHF_WRITE
);
2006 dynamic
->link
= dynstr
;
2007 dynamic
->sh_entsize
= sizeof(ElfW(Dyn
));
2011 if (file_type
== TCC_OUTPUT_EXE
) {
2012 bind_exe_dynsyms(s1
);
2014 if (s1
->nb_errors
) {
2019 bind_libs_dynsyms(s1
);
2020 } else /* shared library case: simply export all global symbols */
2021 export_global_syms(s1
);
2023 build_got_entries(s1
);
2025 /* add a list of needed dlls */
2026 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2027 DLLReference
*dllref
= s1
->loaded_dlls
[i
];
2028 if (dllref
->level
== 0)
2029 put_dt(dynamic
, DT_NEEDED
, put_elf_str(dynstr
, dllref
->name
));
2033 put_dt(dynamic
, s1
->enable_new_dtags
? DT_RUNPATH
: DT_RPATH
,
2034 put_elf_str(dynstr
, s1
->rpath
));
2036 /* XXX: currently, since we do not handle PIC code, we
2037 must relocate the readonly segments */
2038 if (file_type
== TCC_OUTPUT_DLL
) {
2040 put_dt(dynamic
, DT_SONAME
, put_elf_str(dynstr
, s1
->soname
));
2041 put_dt(dynamic
, DT_TEXTREL
, 0);
2045 put_dt(dynamic
, DT_SYMBOLIC
, 0);
2047 /* add necessary space for other entries */
2048 dyninf
.dyn_rel_off
= dynamic
->data_offset
;
2049 dynamic
->data_offset
+= sizeof(ElfW(Dyn
)) * EXTRA_RELITEMS
;
2051 /* still need to build got entries in case of static link */
2052 build_got_entries(s1
);
2056 /* we add a section for symbols */
2057 strsec
= new_section(s1
, ".shstrtab", SHT_STRTAB
, 0);
2058 put_elf_str(strsec
, "");
2060 /* compute number of sections */
2061 shnum
= s1
->nb_sections
;
2063 /* this array is used to reorder sections in the output file */
2064 sec_order
= tcc_malloc(sizeof(int) * shnum
);
2067 /* compute number of program headers */
2070 case TCC_OUTPUT_OBJ
:
2073 case TCC_OUTPUT_EXE
:
2074 if (!s1
->static_link
)
2075 phnum
= 4 + HAVE_PHDR
;
2079 case TCC_OUTPUT_DLL
:
2084 /* Allocate strings for section names */
2085 alloc_sec_names(s1
, file_type
, strsec
);
2087 /* allocate program segment headers */
2088 phdr
= tcc_mallocz(phnum
* sizeof(ElfW(Phdr
)));
2090 /* compute section to program header mapping */
2091 file_offset
= layout_sections(s1
, phdr
, phnum
, interp
, strsec
, &dyninf
,
2094 /* Fill remaining program header and finalize relocation related to dynamic
2097 fill_unloadable_phdr(phdr
, phnum
, interp
, dynamic
);
2099 dyninf
.dynamic
= dynamic
;
2100 dyninf
.dynstr
= dynstr
;
2102 fill_dynamic(s1
, &dyninf
);
2104 /* put in GOT the dynamic section address and relocate PLT */
2105 write32le(s1
->got
->data
, dynamic
->sh_addr
);
2106 if (file_type
== TCC_OUTPUT_EXE
2107 || (RELOCATE_DLLPLT
&& file_type
== TCC_OUTPUT_DLL
))
2110 /* relocate symbols in .dynsym now that final addresses are known */
2111 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
)) {
2112 if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
< SHN_LORESERVE
) {
2113 /* do symbol relocation */
2114 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
2120 /* if building executable or DLL, then relocate each section
2121 except the GOT which is already relocated */
2122 if (file_type
!= TCC_OUTPUT_OBJ
) {
2123 ret
= final_sections_reloc(s1
);
2126 tidy_section_headers(s1
, sec_order
);
2129 /* Perform relocation to GOT or PLT entries */
2130 if (file_type
== TCC_OUTPUT_EXE
&& s1
->static_link
)
2133 /* Create the ELF file with name 'filename' */
2134 ret
= tcc_write_elf_file(s1
, filename
, phnum
, phdr
, file_offset
, sec_order
);
2135 s1
->nb_sections
= shnum
;
2137 tcc_free(sec_order
);
2142 LIBTCCAPI
int tcc_output_file(TCCState
*s
, const char *filename
)
2145 #ifdef TCC_TARGET_PE
2146 if (s
->output_type
!= TCC_OUTPUT_OBJ
) {
2147 ret
= pe_output_file(s
, filename
);
2150 ret
= elf_output_file(s
, filename
);
2154 static void *load_data(int fd
, unsigned long file_offset
, unsigned long size
)
2158 data
= tcc_malloc(size
);
2159 lseek(fd
, file_offset
, SEEK_SET
);
2160 read(fd
, data
, size
);
2164 typedef struct SectionMergeInfo
{
2165 Section
*s
; /* corresponding existing section */
2166 unsigned long offset
; /* offset of the new section in the existing section */
2167 uint8_t new_section
; /* true if section 's' was added */
2168 uint8_t link_once
; /* true if link once section */
2171 ST_FUNC
int tcc_object_type(int fd
, ElfW(Ehdr
) *h
)
2173 int size
= read(fd
, h
, sizeof *h
);
2174 if (size
== sizeof *h
&& 0 == memcmp(h
, ELFMAG
, 4)) {
2175 if (h
->e_type
== ET_REL
)
2176 return AFF_BINTYPE_REL
;
2177 if (h
->e_type
== ET_DYN
)
2178 return AFF_BINTYPE_DYN
;
2179 } else if (size
>= 8) {
2180 if (0 == memcmp(h
, ARMAG
, 8))
2181 return AFF_BINTYPE_AR
;
2182 #ifdef TCC_TARGET_COFF
2183 if (((struct filehdr
*)h
)->f_magic
== COFF_C67_MAGIC
)
2184 return AFF_BINTYPE_C67
;
2190 /* load an object file and merge it with current files */
2191 /* XXX: handle correctly stab (debug) info */
2192 ST_FUNC
int tcc_load_object_file(TCCState
*s1
,
2193 int fd
, unsigned long file_offset
)
2196 ElfW(Shdr
) *shdr
, *sh
;
2197 int size
, i
, j
, offset
, offseti
, nb_syms
, sym_index
, ret
;
2198 unsigned char *strsec
, *strtab
;
2199 int *old_to_new_syms
;
2200 char *sh_name
, *name
;
2201 SectionMergeInfo
*sm_table
, *sm
;
2202 ElfW(Sym
) *sym
, *symtab
;
2209 stab_index
= stabstr_index
= 0;
2211 lseek(fd
, file_offset
, SEEK_SET
);
2212 if (tcc_object_type(fd
, &ehdr
) != AFF_BINTYPE_REL
)
2214 /* test CPU specific stuff */
2215 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2216 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2218 tcc_error_noabort("invalid object file");
2222 shdr
= load_data(fd
, file_offset
+ ehdr
.e_shoff
,
2223 sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2224 sm_table
= tcc_mallocz(sizeof(SectionMergeInfo
) * ehdr
.e_shnum
);
2226 /* load section names */
2227 sh
= &shdr
[ehdr
.e_shstrndx
];
2228 strsec
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2230 /* load symtab and strtab */
2231 old_to_new_syms
= NULL
;
2235 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2237 if (sh
->sh_type
== SHT_SYMTAB
) {
2239 tcc_error_noabort("object must contain only one symtab");
2244 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2245 symtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2246 sm_table
[i
].s
= symtab_section
;
2248 /* now load strtab */
2249 sh
= &shdr
[sh
->sh_link
];
2250 strtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2254 /* now examine each section and try to merge its content with the
2256 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2257 /* no need to examine section name strtab */
2258 if (i
== ehdr
.e_shstrndx
)
2261 sh_name
= (char *) strsec
+ sh
->sh_name
;
2262 /* ignore sections types we do not handle */
2263 if (sh
->sh_type
!= SHT_PROGBITS
&&
2264 sh
->sh_type
!= SHT_RELX
&&
2266 sh
->sh_type
!= SHT_ARM_EXIDX
&&
2268 sh
->sh_type
!= SHT_NOBITS
&&
2269 sh
->sh_type
!= SHT_PREINIT_ARRAY
&&
2270 sh
->sh_type
!= SHT_INIT_ARRAY
&&
2271 sh
->sh_type
!= SHT_FINI_ARRAY
&&
2272 strcmp(sh_name
, ".stabstr")
2275 if (sh
->sh_addralign
< 1)
2276 sh
->sh_addralign
= 1;
2277 /* find corresponding section, if any */
2278 for(j
= 1; j
< s1
->nb_sections
;j
++) {
2279 s
= s1
->sections
[j
];
2280 if (!strcmp(s
->name
, sh_name
)) {
2281 if (!strncmp(sh_name
, ".gnu.linkonce",
2282 sizeof(".gnu.linkonce") - 1)) {
2283 /* if a 'linkonce' section is already present, we
2284 do not add it again. It is a little tricky as
2285 symbols can still be defined in
2287 sm_table
[i
].link_once
= 1;
2294 /* not found: create new section */
2295 s
= new_section(s1
, sh_name
, sh
->sh_type
, sh
->sh_flags
& ~SHF_GROUP
);
2296 /* take as much info as possible from the section. sh_link and
2297 sh_info will be updated later */
2298 s
->sh_addralign
= sh
->sh_addralign
;
2299 s
->sh_entsize
= sh
->sh_entsize
;
2300 sm_table
[i
].new_section
= 1;
2302 if (sh
->sh_type
!= s
->sh_type
) {
2303 tcc_error_noabort("invalid section type");
2307 /* align start of section */
2308 offset
= s
->data_offset
;
2310 if (0 == strcmp(sh_name
, ".stab")) {
2314 if (0 == strcmp(sh_name
, ".stabstr")) {
2319 size
= sh
->sh_addralign
- 1;
2320 offset
= (offset
+ size
) & ~size
;
2321 if (sh
->sh_addralign
> s
->sh_addralign
)
2322 s
->sh_addralign
= sh
->sh_addralign
;
2323 s
->data_offset
= offset
;
2325 sm_table
[i
].offset
= offset
;
2327 /* concatenate sections */
2329 if (sh
->sh_type
!= SHT_NOBITS
) {
2331 lseek(fd
, file_offset
+ sh
->sh_offset
, SEEK_SET
);
2332 ptr
= section_ptr_add(s
, size
);
2333 read(fd
, ptr
, size
);
2335 s
->data_offset
+= size
;
2340 /* gr relocate stab strings */
2341 if (stab_index
&& stabstr_index
) {
2344 s
= sm_table
[stab_index
].s
;
2345 a
= (Stab_Sym
*)(s
->data
+ sm_table
[stab_index
].offset
);
2346 b
= (Stab_Sym
*)(s
->data
+ s
->data_offset
);
2347 o
= sm_table
[stabstr_index
].offset
;
2349 a
->n_strx
+= o
, a
++;
2352 /* second short pass to update sh_link and sh_info fields of new
2354 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2356 if (!s
|| !sm_table
[i
].new_section
)
2359 if (sh
->sh_link
> 0)
2360 s
->link
= sm_table
[sh
->sh_link
].s
;
2361 if (sh
->sh_type
== SHT_RELX
) {
2362 s
->sh_info
= sm_table
[sh
->sh_info
].s
->sh_num
;
2363 /* update backward link */
2364 s1
->sections
[s
->sh_info
]->reloc
= s
;
2369 /* resolve symbols */
2370 old_to_new_syms
= tcc_mallocz(nb_syms
* sizeof(int));
2373 for(i
= 1; i
< nb_syms
; i
++, sym
++) {
2374 if (sym
->st_shndx
!= SHN_UNDEF
&&
2375 sym
->st_shndx
< SHN_LORESERVE
) {
2376 sm
= &sm_table
[sym
->st_shndx
];
2377 if (sm
->link_once
) {
2378 /* if a symbol is in a link once section, we use the
2379 already defined symbol. It is very important to get
2380 correct relocations */
2381 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
2382 name
= (char *) strtab
+ sym
->st_name
;
2383 sym_index
= find_elf_sym(symtab_section
, name
);
2385 old_to_new_syms
[i
] = sym_index
;
2389 /* if no corresponding section added, no need to add symbol */
2392 /* convert section number */
2393 sym
->st_shndx
= sm
->s
->sh_num
;
2395 sym
->st_value
+= sm
->offset
;
2398 name
= (char *) strtab
+ sym
->st_name
;
2399 sym_index
= set_elf_sym(symtab_section
, sym
->st_value
, sym
->st_size
,
2400 sym
->st_info
, sym
->st_other
,
2401 sym
->st_shndx
, name
);
2402 old_to_new_syms
[i
] = sym_index
;
2405 /* third pass to patch relocation entries */
2406 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2411 offset
= sm_table
[i
].offset
;
2412 switch(s
->sh_type
) {
2414 /* take relocation offset information */
2415 offseti
= sm_table
[sh
->sh_info
].offset
;
2416 for_each_elem(s
, (offset
/ sizeof(*rel
)), rel
, ElfW_Rel
) {
2419 /* convert symbol index */
2420 type
= ELFW(R_TYPE
)(rel
->r_info
);
2421 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
2422 /* NOTE: only one symtab assumed */
2423 if (sym_index
>= nb_syms
)
2425 sym_index
= old_to_new_syms
[sym_index
];
2426 /* ignore link_once in rel section. */
2427 if (!sym_index
&& !sm
->link_once
2428 #ifdef TCC_TARGET_ARM
2429 && type
!= R_ARM_V4BX
2433 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2434 i
, strsec
+ sh
->sh_name
, rel
->r_offset
);
2437 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
2438 /* offset the relocation offset */
2439 rel
->r_offset
+= offseti
;
2440 #ifdef TCC_TARGET_ARM
2441 /* Jumps and branches from a Thumb code to a PLT entry need
2442 special handling since PLT entries are ARM code.
2443 Unconditional bl instructions referencing PLT entries are
2444 handled by converting these instructions into blx
2445 instructions. Other case of instructions referencing a PLT
2446 entry require to add a Thumb stub before the PLT entry to
2447 switch to ARM mode. We set bit plt_thumb_stub of the
2448 attribute of a symbol to indicate such a case. */
2449 if (type
== R_ARM_THM_JUMP24
)
2450 get_sym_attr(s1
, sym_index
, 1)->plt_thumb_stub
= 1;
2463 tcc_free(old_to_new_syms
);
2470 typedef struct ArchiveHeader
{
2471 char ar_name
[16]; /* name of this member */
2472 char ar_date
[12]; /* file mtime */
2473 char ar_uid
[6]; /* owner uid; printed as decimal */
2474 char ar_gid
[6]; /* owner gid; printed as decimal */
2475 char ar_mode
[8]; /* file mode, printed as octal */
2476 char ar_size
[10]; /* file size, printed as decimal */
2477 char ar_fmag
[2]; /* should contain ARFMAG */
2480 static int get_be32(const uint8_t *b
)
2482 return b
[3] | (b
[2] << 8) | (b
[1] << 16) | (b
[0] << 24);
2485 static long get_be64(const uint8_t *b
)
2487 long long ret
= get_be32(b
);
2488 ret
= (ret
<< 32) | (unsigned)get_be32(b
+4);
2492 /* load only the objects which resolve undefined symbols */
2493 static int tcc_load_alacarte(TCCState
*s1
, int fd
, int size
, int entrysize
)
2495 long i
, bound
, nsyms
, sym_index
, off
, ret
;
2497 const char *ar_names
, *p
;
2498 const uint8_t *ar_index
;
2501 data
= tcc_malloc(size
);
2502 if (read(fd
, data
, size
) != size
)
2504 nsyms
= entrysize
== 4 ? get_be32(data
) : get_be64(data
);
2505 ar_index
= data
+ entrysize
;
2506 ar_names
= (char *) ar_index
+ nsyms
* entrysize
;
2510 for(p
= ar_names
, i
= 0; i
< nsyms
; i
++, p
+= strlen(p
)+1) {
2511 sym_index
= find_elf_sym(symtab_section
, p
);
2513 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
2514 if(sym
->st_shndx
== SHN_UNDEF
) {
2515 off
= (entrysize
== 4
2516 ? get_be32(ar_index
+ i
* 4)
2517 : get_be64(ar_index
+ i
* 8))
2518 + sizeof(ArchiveHeader
);
2520 if(tcc_load_object_file(s1
, fd
, off
) < 0) {
2535 /* load a '.a' file */
2536 ST_FUNC
int tcc_load_archive(TCCState
*s1
, int fd
)
2543 unsigned long file_offset
;
2545 /* skip magic which was already checked */
2546 read(fd
, magic
, sizeof(magic
));
2549 len
= read(fd
, &hdr
, sizeof(hdr
));
2552 if (len
!= sizeof(hdr
)) {
2553 tcc_error_noabort("invalid archive");
2556 memcpy(ar_size
, hdr
.ar_size
, sizeof(hdr
.ar_size
));
2557 ar_size
[sizeof(hdr
.ar_size
)] = '\0';
2558 size
= strtol(ar_size
, NULL
, 0);
2559 memcpy(ar_name
, hdr
.ar_name
, sizeof(hdr
.ar_name
));
2560 for(i
= sizeof(hdr
.ar_name
) - 1; i
>= 0; i
--) {
2561 if (ar_name
[i
] != ' ')
2564 ar_name
[i
+ 1] = '\0';
2565 file_offset
= lseek(fd
, 0, SEEK_CUR
);
2567 size
= (size
+ 1) & ~1;
2568 if (!strcmp(ar_name
, "/")) {
2569 /* coff symbol table : we handle it */
2570 if(s1
->alacarte_link
)
2571 return tcc_load_alacarte(s1
, fd
, size
, 4);
2572 } else if (!strcmp(ar_name
, "/SYM64/")) {
2573 if(s1
->alacarte_link
)
2574 return tcc_load_alacarte(s1
, fd
, size
, 8);
2577 if (tcc_object_type(fd
, &ehdr
) == AFF_BINTYPE_REL
) {
2578 if (tcc_load_object_file(s1
, fd
, file_offset
) < 0)
2582 lseek(fd
, file_offset
+ size
, SEEK_SET
);
2587 #ifndef TCC_TARGET_PE
2588 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2589 is referenced by the user (so it should be added as DT_NEEDED in
2590 the generated ELF file) */
2591 ST_FUNC
int tcc_load_dll(TCCState
*s1
, int fd
, const char *filename
, int level
)
2594 ElfW(Shdr
) *shdr
, *sh
, *sh1
;
2595 int i
, j
, nb_syms
, nb_dts
, sym_bind
, ret
;
2596 ElfW(Sym
) *sym
, *dynsym
;
2597 ElfW(Dyn
) *dt
, *dynamic
;
2598 unsigned char *dynstr
;
2599 const char *name
, *soname
;
2600 DLLReference
*dllref
;
2602 read(fd
, &ehdr
, sizeof(ehdr
));
2604 /* test CPU specific stuff */
2605 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2606 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2607 tcc_error_noabort("bad architecture");
2612 shdr
= load_data(fd
, ehdr
.e_shoff
, sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2614 /* load dynamic section and dynamic symbols */
2618 dynsym
= NULL
; /* avoid warning */
2619 dynstr
= NULL
; /* avoid warning */
2620 for(i
= 0, sh
= shdr
; i
< ehdr
.e_shnum
; i
++, sh
++) {
2621 switch(sh
->sh_type
) {
2623 nb_dts
= sh
->sh_size
/ sizeof(ElfW(Dyn
));
2624 dynamic
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2627 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2628 dynsym
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2629 sh1
= &shdr
[sh
->sh_link
];
2630 dynstr
= load_data(fd
, sh1
->sh_offset
, sh1
->sh_size
);
2637 /* compute the real library name */
2638 soname
= tcc_basename(filename
);
2640 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2641 if (dt
->d_tag
== DT_SONAME
) {
2642 soname
= (char *) dynstr
+ dt
->d_un
.d_val
;
2646 /* if the dll is already loaded, do not load it */
2647 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2648 dllref
= s1
->loaded_dlls
[i
];
2649 if (!strcmp(soname
, dllref
->name
)) {
2650 /* but update level if needed */
2651 if (level
< dllref
->level
)
2652 dllref
->level
= level
;
2658 /* add the dll and its level */
2659 dllref
= tcc_mallocz(sizeof(DLLReference
) + strlen(soname
));
2660 dllref
->level
= level
;
2661 strcpy(dllref
->name
, soname
);
2662 dynarray_add(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
, dllref
);
2664 /* add dynamic symbols in dynsym_section */
2665 for(i
= 1, sym
= dynsym
+ 1; i
< nb_syms
; i
++, sym
++) {
2666 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
2667 if (sym_bind
== STB_LOCAL
)
2669 name
= (char *) dynstr
+ sym
->st_name
;
2670 set_elf_sym(s1
->dynsymtab_section
, sym
->st_value
, sym
->st_size
,
2671 sym
->st_info
, sym
->st_other
, sym
->st_shndx
, name
);
2674 /* load all referenced DLLs */
2675 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2678 name
= (char *) dynstr
+ dt
->d_un
.d_val
;
2679 for(j
= 0; j
< s1
->nb_loaded_dlls
; j
++) {
2680 dllref
= s1
->loaded_dlls
[j
];
2681 if (!strcmp(name
, dllref
->name
))
2682 goto already_loaded
;
2684 if (tcc_add_dll(s1
, name
, AFF_REFERENCED_DLL
) < 0) {
2685 tcc_error_noabort("referenced dll '%s' not found", name
);
2702 #define LD_TOK_NAME 256
2703 #define LD_TOK_EOF (-1)
2705 /* return next ld script token */
2706 static int ld_next(TCCState
*s1
, char *name
, int name_size
)
2724 file
->buf_ptr
= parse_comment(file
->buf_ptr
);
2725 ch
= file
->buf_ptr
[0];
2738 /* case 'a' ... 'z': */
2765 /* case 'A' ... 'z': */
2799 if (!((ch
>= 'a' && ch
<= 'z') ||
2800 (ch
>= 'A' && ch
<= 'Z') ||
2801 (ch
>= '0' && ch
<= '9') ||
2802 strchr("/.-_+=$:\\,~", ch
)))
2804 if ((q
- name
) < name_size
- 1) {
2823 static int ld_add_file(TCCState
*s1
, const char filename
[])
2825 if (filename
[0] == '/') {
2826 if (CONFIG_SYSROOT
[0] == '\0'
2827 && tcc_add_file_internal(s1
, filename
, AFF_TYPE_BIN
) == 0)
2829 filename
= tcc_basename(filename
);
2831 return tcc_add_dll(s1
, filename
, 0);
2834 static inline int new_undef_syms(void)
2837 ret
= new_undef_sym
;
2842 static int ld_add_file_list(TCCState
*s1
, const char *cmd
, int as_needed
)
2844 char filename
[1024], libname
[1024];
2845 int t
, group
, nblibs
= 0, ret
= 0;
2848 group
= !strcmp(cmd
, "GROUP");
2851 t
= ld_next(s1
, filename
, sizeof(filename
));
2854 t
= ld_next(s1
, filename
, sizeof(filename
));
2857 if (t
== LD_TOK_EOF
) {
2858 tcc_error_noabort("unexpected end of file");
2860 goto lib_parse_error
;
2861 } else if (t
== ')') {
2863 } else if (t
== '-') {
2864 t
= ld_next(s1
, filename
, sizeof(filename
));
2865 if ((t
!= LD_TOK_NAME
) || (filename
[0] != 'l')) {
2866 tcc_error_noabort("library name expected");
2868 goto lib_parse_error
;
2870 pstrcpy(libname
, sizeof libname
, &filename
[1]);
2871 if (s1
->static_link
) {
2872 snprintf(filename
, sizeof filename
, "lib%s.a", libname
);
2874 snprintf(filename
, sizeof filename
, "lib%s.so", libname
);
2876 } else if (t
!= LD_TOK_NAME
) {
2877 tcc_error_noabort("filename expected");
2879 goto lib_parse_error
;
2881 if (!strcmp(filename
, "AS_NEEDED")) {
2882 ret
= ld_add_file_list(s1
, cmd
, 1);
2884 goto lib_parse_error
;
2886 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2888 ret
= ld_add_file(s1
, filename
);
2890 goto lib_parse_error
;
2892 /* Add the filename *and* the libname to avoid future conversions */
2893 dynarray_add(&libs
, &nblibs
, tcc_strdup(filename
));
2894 if (libname
[0] != '\0')
2895 dynarray_add(&libs
, &nblibs
, tcc_strdup(libname
));
2899 t
= ld_next(s1
, filename
, sizeof(filename
));
2901 t
= ld_next(s1
, filename
, sizeof(filename
));
2904 if (group
&& !as_needed
) {
2905 while (new_undef_syms()) {
2908 for (i
= 0; i
< nblibs
; i
++)
2909 ld_add_file(s1
, libs
[i
]);
2913 dynarray_reset(&libs
, &nblibs
);
2917 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
2919 ST_FUNC
int tcc_load_ldscript(TCCState
*s1
)
2922 char filename
[1024];
2927 t
= ld_next(s1
, cmd
, sizeof(cmd
));
2928 if (t
== LD_TOK_EOF
)
2930 else if (t
!= LD_TOK_NAME
)
2932 if (!strcmp(cmd
, "INPUT") ||
2933 !strcmp(cmd
, "GROUP")) {
2934 ret
= ld_add_file_list(s1
, cmd
, 0);
2937 } else if (!strcmp(cmd
, "OUTPUT_FORMAT") ||
2938 !strcmp(cmd
, "TARGET")) {
2939 /* ignore some commands */
2940 t
= ld_next(s1
, cmd
, sizeof(cmd
));
2944 t
= ld_next(s1
, filename
, sizeof(filename
));
2945 if (t
== LD_TOK_EOF
) {
2946 tcc_error_noabort("unexpected end of file");
2948 } else if (t
== ')') {
2958 #endif /* !TCC_TARGET_PE */