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 /* XXX: avoid static variable */
24 static int new_undef_sym
= 0; /* Is there a new undefined sym since last new_undef_sym() */
26 ST_FUNC
int put_elf_str(Section
*s
, const char *sym
)
31 len
= strlen(sym
) + 1;
32 offset
= s
->data_offset
;
33 ptr
= section_ptr_add(s
, len
);
34 memcpy(ptr
, sym
, len
);
38 /* elf symbol hashing function */
39 static unsigned long elf_hash(const unsigned char *name
)
41 unsigned long h
= 0, g
;
44 h
= (h
<< 4) + *name
++;
53 /* rebuild hash table of section s */
54 /* NOTE: we do factorize the hash table code to go faster */
55 static void rebuild_hash(Section
*s
, unsigned int nb_buckets
)
58 int *ptr
, *hash
, nb_syms
, sym_index
, h
;
59 unsigned char *strtab
;
61 strtab
= s
->link
->data
;
62 nb_syms
= s
->data_offset
/ sizeof(ElfW(Sym
));
64 s
->hash
->data_offset
= 0;
65 ptr
= section_ptr_add(s
->hash
, (2 + nb_buckets
+ nb_syms
) * sizeof(int));
70 memset(hash
, 0, (nb_buckets
+ 1) * sizeof(int));
71 ptr
+= nb_buckets
+ 1;
73 sym
= (ElfW(Sym
) *)s
->data
+ 1;
74 for(sym_index
= 1; sym_index
< nb_syms
; sym_index
++) {
75 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
76 h
= elf_hash(strtab
+ sym
->st_name
) % nb_buckets
;
87 /* return the symbol number */
88 ST_FUNC
int put_elf_sym(Section
*s
, addr_t value
, unsigned long size
,
89 int info
, int other
, int shndx
, const char *name
)
91 int name_offset
, sym_index
;
96 sym
= section_ptr_add(s
, sizeof(ElfW(Sym
)));
98 name_offset
= put_elf_str(s
->link
, name
);
101 /* XXX: endianness */
102 sym
->st_name
= name_offset
;
103 sym
->st_value
= value
;
106 sym
->st_other
= other
;
107 sym
->st_shndx
= shndx
;
108 sym_index
= sym
- (ElfW(Sym
) *)s
->data
;
112 ptr
= section_ptr_add(hs
, sizeof(int));
113 base
= (int *)hs
->data
;
114 /* only add global or weak symbols */
115 if (ELFW(ST_BIND
)(info
) != STB_LOCAL
) {
116 /* add another hashing entry */
118 h
= elf_hash((unsigned char *) name
) % nbuckets
;
120 base
[2 + h
] = sym_index
;
122 /* we resize the hash table */
123 hs
->nb_hashed_syms
++;
124 if (hs
->nb_hashed_syms
> 2 * nbuckets
) {
125 rebuild_hash(s
, 2 * nbuckets
);
135 /* find global ELF symbol 'name' and return its index. Return 0 if not
137 ST_FUNC
int find_elf_sym(Section
*s
, const char *name
)
141 int nbuckets
, sym_index
, h
;
147 nbuckets
= ((int *)hs
->data
)[0];
148 h
= elf_hash((unsigned char *) name
) % nbuckets
;
149 sym_index
= ((int *)hs
->data
)[2 + h
];
150 while (sym_index
!= 0) {
151 sym
= &((ElfW(Sym
) *)s
->data
)[sym_index
];
152 name1
= (char *) s
->link
->data
+ sym
->st_name
;
153 if (!strcmp(name
, name1
))
155 sym_index
= ((int *)hs
->data
)[2 + nbuckets
+ sym_index
];
160 /* return elf symbol value, signal error if 'err' is nonzero */
161 ST_FUNC addr_t
get_elf_sym_addr(TCCState
*s
, const char *name
, int err
)
166 sym_index
= find_elf_sym(s
->symtab
, name
);
167 sym
= &((ElfW(Sym
) *)s
->symtab
->data
)[sym_index
];
168 if (!sym_index
|| sym
->st_shndx
== SHN_UNDEF
) {
170 tcc_error("%s not defined", name
);
173 return sym
->st_value
;
176 /* return elf symbol value */
177 LIBTCCAPI
void *tcc_get_symbol(TCCState
*s
, const char *name
)
179 return (void*)(uintptr_t)get_elf_sym_addr(s
, name
, 0);
182 #if defined TCC_IS_NATIVE || defined TCC_TARGET_PE
183 /* return elf symbol value or error */
184 ST_FUNC
void* tcc_get_symbol_err(TCCState
*s
, const char *name
)
186 return (void*)(uintptr_t)get_elf_sym_addr(s
, name
, 1);
190 /* add an elf symbol : check if it is already defined and patch
191 it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
192 ST_FUNC
int add_elf_sym(Section
*s
, addr_t value
, unsigned long size
,
193 int info
, int other
, int sh_num
, const char *name
)
196 int sym_bind
, sym_index
, sym_type
, esym_bind
;
197 unsigned char sym_vis
, esym_vis
, new_vis
;
199 sym_bind
= ELFW(ST_BIND
)(info
);
200 sym_type
= ELFW(ST_TYPE
)(info
);
201 sym_vis
= ELFW(ST_VISIBILITY
)(other
);
203 if (sym_bind
!= STB_LOCAL
) {
204 /* we search global or weak symbols */
205 sym_index
= find_elf_sym(s
, name
);
208 esym
= &((ElfW(Sym
) *)s
->data
)[sym_index
];
209 if (esym
->st_shndx
!= SHN_UNDEF
) {
210 esym_bind
= ELFW(ST_BIND
)(esym
->st_info
);
211 /* propagate the most constraining visibility */
212 /* STV_DEFAULT(0)<STV_PROTECTED(3)<STV_HIDDEN(2)<STV_INTERNAL(1) */
213 esym_vis
= ELFW(ST_VISIBILITY
)(esym
->st_other
);
214 if (esym_vis
== STV_DEFAULT
) {
216 } else if (sym_vis
== STV_DEFAULT
) {
219 new_vis
= (esym_vis
< sym_vis
) ? esym_vis
: sym_vis
;
221 esym
->st_other
= (esym
->st_other
& ~ELFW(ST_VISIBILITY
)(-1))
223 other
= esym
->st_other
; /* in case we have to patch esym */
224 if (sh_num
== SHN_UNDEF
) {
225 /* ignore adding of undefined symbol if the
226 corresponding symbol is already defined */
227 } else if (sym_bind
== STB_GLOBAL
&& esym_bind
== STB_WEAK
) {
228 /* global overrides weak, so patch */
230 } else if (sym_bind
== STB_WEAK
&& esym_bind
== STB_GLOBAL
) {
231 /* weak is ignored if already global */
232 } else if (sym_bind
== STB_WEAK
&& esym_bind
== STB_WEAK
) {
233 /* keep first-found weak definition, ignore subsequents */
234 } else if (sym_vis
== STV_HIDDEN
|| sym_vis
== STV_INTERNAL
) {
235 /* ignore hidden symbols after */
236 } else if (esym
->st_shndx
== SHN_COMMON
237 && (sh_num
< SHN_LORESERVE
|| sh_num
== SHN_COMMON
)) {
238 /* gr: Happens with 'tcc ... -static tcctest.c' on e.g. Ubuntu 6.01
239 No idea if this is the correct solution ... */
241 } else if (s
== tcc_state
->dynsymtab_section
) {
242 /* we accept that two DLL define the same symbol */
245 printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",
246 sym_bind
, sh_num
, new_vis
, esym_bind
, esym
->st_shndx
, esym_vis
);
248 tcc_error_noabort("'%s' defined twice", name
);
252 esym
->st_info
= ELFW(ST_INFO
)(sym_bind
, sym_type
);
253 esym
->st_shndx
= sh_num
;
255 esym
->st_value
= value
;
256 esym
->st_size
= size
;
257 esym
->st_other
= other
;
261 sym_index
= put_elf_sym(s
, value
, size
,
262 ELFW(ST_INFO
)(sym_bind
, sym_type
), other
,
269 ST_FUNC
void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
270 int type
, int symbol
)
278 /* if no relocation section, create it */
279 snprintf(buf
, sizeof(buf
), REL_SECTION_FMT
, s
->name
);
280 /* if the symtab is allocated, then we consider the relocation
282 sr
= new_section(tcc_state
, buf
, SHT_RELX
, symtab
->sh_flags
);
283 sr
->sh_entsize
= sizeof(ElfW_Rel
);
285 sr
->sh_info
= s
->sh_num
;
288 rel
= section_ptr_add(sr
, sizeof(ElfW_Rel
));
289 rel
->r_offset
= offset
;
290 rel
->r_info
= ELFW(R_INFO
)(symbol
, type
);
291 #ifdef TCC_TARGET_X86_64
296 /* put stab debug information */
298 ST_FUNC
void put_stabs(const char *str
, int type
, int other
, int desc
,
303 sym
= section_ptr_add(stab_section
, sizeof(Stab_Sym
));
305 sym
->n_strx
= put_elf_str(stabstr_section
, str
);
310 sym
->n_other
= other
;
312 sym
->n_value
= value
;
315 ST_FUNC
void put_stabs_r(const char *str
, int type
, int other
, int desc
,
316 unsigned long value
, Section
*sec
, int sym_index
)
318 put_stabs(str
, type
, other
, desc
, value
);
319 put_elf_reloc(symtab_section
, stab_section
,
320 stab_section
->data_offset
- sizeof(unsigned int),
321 R_DATA_32
, sym_index
);
324 ST_FUNC
void put_stabn(int type
, int other
, int desc
, int value
)
326 put_stabs(NULL
, type
, other
, desc
, value
);
329 ST_FUNC
void put_stabd(int type
, int other
, int desc
)
331 put_stabs(NULL
, type
, other
, desc
, 0);
334 /* Browse each elem of type <type> in section <sec> starting at elem <startoff>
335 using variable <elem> */
336 #define for_each_elem(sec, startoff, elem, type) \
337 for (elem = (type *) sec->data + startoff; \
338 elem < (type *) (sec->data + sec->data_offset); elem++)
340 /* In an ELF file symbol table, the local symbols must appear below
341 the global and weak ones. Since TCC cannot sort it while generating
342 the code, we must do it after. All the relocation tables are also
343 modified to take into account the symbol table sorting */
344 static void sort_syms(TCCState
*s1
, Section
*s
)
346 int *old_to_new_syms
;
354 nb_syms
= s
->data_offset
/ sizeof(ElfW(Sym
));
355 new_syms
= tcc_malloc(nb_syms
* sizeof(ElfW(Sym
)));
356 old_to_new_syms
= tcc_malloc(nb_syms
* sizeof(int));
358 /* first pass for local symbols */
359 p
= (ElfW(Sym
) *)s
->data
;
361 for(i
= 0; i
< nb_syms
; i
++) {
362 if (ELFW(ST_BIND
)(p
->st_info
) == STB_LOCAL
) {
363 old_to_new_syms
[i
] = q
- new_syms
;
368 /* save the number of local symbols in section header */
369 s
->sh_info
= q
- new_syms
;
371 /* then second pass for non local symbols */
372 p
= (ElfW(Sym
) *)s
->data
;
373 for(i
= 0; i
< nb_syms
; i
++) {
374 if (ELFW(ST_BIND
)(p
->st_info
) != STB_LOCAL
) {
375 old_to_new_syms
[i
] = q
- new_syms
;
381 /* we copy the new symbols to the old */
382 memcpy(s
->data
, new_syms
, nb_syms
* sizeof(ElfW(Sym
)));
385 /* now we modify all the relocations */
386 for(i
= 1; i
< s1
->nb_sections
; i
++) {
387 sr
= s1
->sections
[i
];
388 if (sr
->sh_type
== SHT_RELX
&& sr
->link
== s
) {
389 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
390 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
391 type
= ELFW(R_TYPE
)(rel
->r_info
);
392 sym_index
= old_to_new_syms
[sym_index
];
393 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
398 tcc_free(old_to_new_syms
);
401 /* relocate common symbols in the .bss section */
402 ST_FUNC
void relocate_common_syms(void)
405 unsigned long offset
, align
;
407 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
408 if (sym
->st_shndx
== SHN_COMMON
) {
410 align
= sym
->st_value
;
411 offset
= bss_section
->data_offset
;
412 offset
= (offset
+ align
- 1) & -align
;
413 sym
->st_value
= offset
;
414 sym
->st_shndx
= bss_section
->sh_num
;
415 offset
+= sym
->st_size
;
416 bss_section
->data_offset
= offset
;
421 /* relocate symbol table, resolve undefined symbols if do_resolve is
422 true and output error if undefined symbol. */
423 ST_FUNC
void relocate_syms(TCCState
*s1
, int do_resolve
)
425 ElfW(Sym
) *sym
, *esym
;
426 int sym_bind
, sh_num
, sym_index
;
429 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
430 sh_num
= sym
->st_shndx
;
431 if (sh_num
== SHN_UNDEF
) {
432 name
= (char *) strtab_section
->data
+ sym
->st_name
;
433 /* Use ld.so to resolve symbol for us (for tcc -run) */
435 #if defined TCC_IS_NATIVE && !defined _WIN32
437 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
438 addr
= resolve_sym(s1
, name
);
440 sym
->st_value
= (addr_t
)addr
;
444 } else if (s1
->dynsym
) {
445 /* if dynamic symbol exist, then use it */
446 sym_index
= find_elf_sym(s1
->dynsym
, name
);
448 esym
= &((ElfW(Sym
) *)s1
->dynsym
->data
)[sym_index
];
449 sym
->st_value
= esym
->st_value
;
453 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
455 if (!strcmp(name
, "_fp_hw"))
457 /* only weak symbols are accepted to be undefined. Their
459 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
460 if (sym_bind
== STB_WEAK
) {
463 tcc_error_noabort("undefined symbol '%s'", name
);
465 } else if (sh_num
< SHN_LORESERVE
) {
466 /* add section base */
467 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
473 #ifdef TCC_HAS_RUNTIME_PLTGOT
474 #ifdef TCC_TARGET_X86_64
475 #define JMP_TABLE_ENTRY_SIZE 14
476 static addr_t
add_jmp_table(TCCState
*s1
, addr_t val
)
478 char *p
= s1
->runtime_plt_and_got
+ s1
->runtime_plt_and_got_offset
;
479 s1
->runtime_plt_and_got_offset
+= JMP_TABLE_ENTRY_SIZE
;
484 *(addr_t
*)(p
+ 6) = val
;
488 static addr_t
add_got_table(TCCState
*s1
, addr_t val
)
490 addr_t
*p
= (addr_t
*)(s1
->runtime_plt_and_got
+ s1
->runtime_plt_and_got_offset
);
491 s1
->runtime_plt_and_got_offset
+= sizeof(addr_t
);
495 #elif defined TCC_TARGET_ARM
496 #define JMP_TABLE_ENTRY_SIZE 8
497 static addr_t
add_jmp_table(TCCState
*s1
, int val
)
499 uint32_t *p
= (uint32_t *)(s1
->runtime_plt_and_got
+ s1
->runtime_plt_and_got_offset
);
500 s1
->runtime_plt_and_got_offset
+= JMP_TABLE_ENTRY_SIZE
;
501 /* ldr pc, [pc, #-4] */
507 #endif /* def TCC_HAS_RUNTIME_PLTGOT */
509 /* relocate a given section (CPU dependent) by applying the relocations
510 in the associated relocation section */
511 ST_FUNC
void relocate_section(TCCState
*s1
, Section
*s
)
513 Section
*sr
= s
->reloc
;
519 #if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
520 ElfW_Rel
*qrel
= (ElfW_Rel
*) sr
->data
; /* ptr to next reloc entry reused */
524 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
525 ptr
= s
->data
+ rel
->r_offset
;
527 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
528 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
530 #ifdef TCC_TARGET_X86_64
531 val
+= rel
->r_addend
;
533 type
= ELFW(R_TYPE
)(rel
->r_info
);
534 addr
= s
->sh_addr
+ rel
->r_offset
;
538 #if defined(TCC_TARGET_I386)
540 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
541 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
542 qrel
->r_offset
= rel
->r_offset
;
544 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_386_32
);
548 qrel
->r_info
= ELFW(R_INFO
)(0, R_386_RELATIVE
);
555 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
557 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
559 qrel
->r_offset
= rel
->r_offset
;
560 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_386_PC32
);
565 *(int *)ptr
+= val
- addr
;
568 *(int *)ptr
+= val
- addr
;
575 *(int *)ptr
+= s1
->got
->sh_addr
- addr
;
578 *(int *)ptr
+= val
- s1
->got
->sh_addr
;
581 /* we load the got offset */
582 *(int *)ptr
+= s1
->sym_attrs
[sym_index
].got_offset
;
585 if (s1
->output_format
!= TCC_OUTPUT_FORMAT_BINARY
) {
587 tcc_error("can only produce 16-bit binary files");
589 *(short *)ptr
+= val
;
592 if (s1
->output_format
!= TCC_OUTPUT_FORMAT_BINARY
)
594 *(short *)ptr
+= val
- addr
;
596 #elif defined(TCC_TARGET_ARM)
602 int x
, is_thumb
, is_call
, h
, blx_avail
, is_bl
, th_ko
;
603 x
= (*(int *) ptr
) & 0xffffff;
604 (*(int *)ptr
) &= 0xff000000;
608 blx_avail
= (TCC_ARM_VERSION
>= 5);
610 is_bl
= (*(unsigned *) ptr
) >> 24 == 0xeb;
611 is_call
= (type
== R_ARM_CALL
|| (type
== R_ARM_PC24
&& is_bl
));
614 th_ko
= (x
& 3) && (!blx_avail
|| !is_call
);
615 #ifdef TCC_HAS_RUNTIME_PLTGOT
616 if (s1
->output_type
== TCC_OUTPUT_MEMORY
) {
617 if (th_ko
|| x
>= 0x2000000 || x
< -0x2000000) {
618 x
+= add_jmp_table(s1
, val
) - val
; /* add veneer */
619 th_ko
= (x
& 3) && (!blx_avail
|| !is_call
);
620 is_thumb
= 0; /* Veneer uses ARM instructions */
624 if (th_ko
|| x
>= 0x2000000 || x
< -0x2000000)
625 tcc_error("can't relocate value at %x",addr
);
628 /* Only reached if blx is avail and it is a call */
631 (*(int *)ptr
) = 0xfa << 24; /* bl -> blx */
636 /* Since these relocations only concern Thumb-2 and blx instruction was
637 introduced before Thumb-2, we can assume blx is available and not
640 case R_ARM_THM_JUMP24
:
642 int x
, hi
, lo
, s
, j1
, j2
, i1
, i2
, imm10
, imm11
;
643 int to_thumb
, is_call
, to_plt
, blx_bit
= 1 << 12;
647 if (sym
->st_shndx
== SHN_UNDEF
&&
648 ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
)
651 /* Get initial offset */
652 hi
= (*(uint16_t *)ptr
);
653 lo
= (*(uint16_t *)(ptr
+2));
661 x
= (s
<< 24) | (i1
<< 23) | (i2
<< 22) |
662 (imm10
<< 12) | (imm11
<< 1);
666 /* Relocation infos */
669 to_plt
= (val
>= plt
->sh_addr
) &&
670 (val
< plt
->sh_addr
+ plt
->data_offset
);
671 is_call
= (type
== R_ARM_THM_PC22
);
673 /* Compute final offset */
674 if (to_plt
&& !is_call
) /* Point to 1st instr of Thumb stub */
677 if (!to_thumb
&& is_call
) {
678 blx_bit
= 0; /* bl -> blx */
679 x
= (x
+ 3) & -4; /* Compute offset from aligned PC */
682 /* Check that relocation is possible
683 * offset must not be out of range
684 * if target is to be entered in arm mode:
686 - instruction must be a call (bl) or a jump to PLT */
687 if (!to_thumb
|| x
>= 0x1000000 || x
< -0x1000000)
688 if (to_thumb
|| (val
& 2) || (!is_call
&& !to_plt
))
689 tcc_error("can't relocate value at %x",addr
);
691 /* Compute and store final offset */
697 imm10
= (x
>> 12) & 0x3ff;
698 imm11
= (x
>> 1) & 0x7ff;
699 (*(uint16_t *)ptr
) = (uint16_t) ((hi
& 0xf800) |
701 (*(uint16_t *)(ptr
+2)) = (uint16_t) ((lo
& 0xc000) |
702 (j1
<< 13) | blx_bit
| (j2
<< 11) |
707 case R_ARM_MOVW_ABS_NC
:
710 if (type
== R_ARM_MOVT_ABS
)
713 imm4
= (val
>> 12) & 0xf;
714 x
= (imm4
<< 16) | imm12
;
715 if (type
== R_ARM_THM_MOVT_ABS
)
721 case R_ARM_THM_MOVT_ABS
:
722 case R_ARM_THM_MOVW_ABS_NC
:
724 int x
, i
, imm4
, imm3
, imm8
;
725 if (type
== R_ARM_THM_MOVT_ABS
)
728 imm3
= (val
>> 8) & 0x7;
730 imm4
= (val
>> 12) & 0xf;
731 x
= (imm3
<< 28) | (imm8
<< 16) | (i
<< 10) | imm4
;
732 if (type
== R_ARM_THM_MOVT_ABS
)
741 x
= (*(int *)ptr
) & 0x7fffffff;
742 (*(int *)ptr
) &= 0x80000000;
745 if((x
^(x
>>1))&0x40000000)
746 tcc_error("can't relocate value at %x",addr
);
747 (*(int *)ptr
) |= x
& 0x7fffffff;
753 *(int *)ptr
+= val
- addr
;
756 *(int *)ptr
+= s1
->got
->sh_addr
- addr
;
759 *(int *)ptr
+= val
- s1
->got
->sh_addr
;
762 /* we load the got offset */
763 *(int *)ptr
+= s1
->sym_attrs
[sym_index
].got_offset
;
768 /* trade Thumb support for ARMv4 support */
769 if ((0x0ffffff0 & *(int*)ptr
) == 0x012FFF10)
770 *(int*)ptr
^= 0xE12FFF10 ^ 0xE1A0F000; /* BX Rm -> MOV PC, Rm */
773 /* Nothing to do. Normally used to indicate a dependency
774 on a certain symbol (like for exception handling under EABI). */
777 fprintf(stderr
,"FIXME: handle reloc type %x at %x [%p] to %x\n",
778 type
, (unsigned)addr
, ptr
, (unsigned)val
);
780 #elif defined(TCC_TARGET_C67)
788 /* put the low 16 bits of the absolute address
789 add to what is already there */
791 orig
= ((*(int *)(ptr
)) >> 7) & 0xffff;
792 orig
|= (((*(int *)(ptr
+4)) >> 7) & 0xffff) << 16;
794 /* patch both at once - assumes always in pairs Low - High */
796 *(int *) ptr
= (*(int *) ptr
& (~(0xffff << 7)) ) | (((val
+orig
) & 0xffff) << 7);
797 *(int *)(ptr
+4) = (*(int *)(ptr
+4) & (~(0xffff << 7)) ) | ((((val
+orig
)>>16) & 0xffff) << 7);
803 fprintf(stderr
,"FIXME: handle reloc type %x at %x [%p] to %x\n",
804 type
, (unsigned)addr
, ptr
, (unsigned)val
);
806 #elif defined(TCC_TARGET_X86_64)
808 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
809 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
810 qrel
->r_offset
= rel
->r_offset
;
812 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_X86_64_64
);
813 qrel
->r_addend
= rel
->r_addend
;
817 qrel
->r_info
= ELFW(R_INFO
)(0, R_X86_64_RELATIVE
);
818 qrel
->r_addend
= *(long long *)ptr
+ val
;
822 *(long long *)ptr
+= val
;
826 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
827 /* XXX: this logic may depend on TCC's codegen
828 now TCC uses R_X86_64_32 even for a 64bit pointer */
829 qrel
->r_info
= ELFW(R_INFO
)(0, R_X86_64_RELATIVE
);
830 qrel
->r_addend
= *(int *)ptr
+ val
;
837 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
839 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
841 qrel
->r_offset
= rel
->r_offset
;
842 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_X86_64_PC32
);
843 qrel
->r_addend
= *(int *)ptr
;
851 /* We've put the PLT slot offset into r_addend when generating
852 it, and that's what we must use as relocation value (adjusted
853 by section offset of course). */
854 val
= s1
->plt
->sh_addr
+ rel
->r_addend
;
860 diff
= (long long)val
- addr
;
861 if (diff
<= -2147483647 || diff
> 2147483647) {
862 #ifdef TCC_HAS_RUNTIME_PLTGOT
863 /* XXX: naive support for over 32bit jump */
864 if (s1
->output_type
== TCC_OUTPUT_MEMORY
) {
865 val
= (add_jmp_table(s1
, val
- rel
->r_addend
) +
870 if (diff
<= -2147483647 || diff
> 2147483647) {
871 tcc_error("internal error: relocation failed");
877 case R_X86_64_GLOB_DAT
:
878 case R_X86_64_JUMP_SLOT
:
879 /* They don't need addend */
880 *(addr_t
*)ptr
= val
- rel
->r_addend
;
882 case R_X86_64_GOTPCREL
:
883 #ifdef TCC_HAS_RUNTIME_PLTGOT
884 if (s1
->output_type
== TCC_OUTPUT_MEMORY
) {
885 val
= add_got_table(s1
, val
- rel
->r_addend
) + rel
->r_addend
;
886 *(int *)ptr
+= val
- addr
;
890 *(int *)ptr
+= (s1
->got
->sh_addr
- addr
+
891 s1
->sym_attrs
[sym_index
].got_offset
- 4);
893 case R_X86_64_GOTTPOFF
:
894 *(int *)ptr
+= val
- s1
->got
->sh_addr
;
897 /* we load the got offset */
898 *(int *)ptr
+= s1
->sym_attrs
[sym_index
].got_offset
;
901 #error unsupported processor
905 /* if the relocation is allocated, we change its symbol table */
906 if (sr
->sh_flags
& SHF_ALLOC
)
907 sr
->link
= s1
->dynsym
;
910 /* relocate relocation table in 'sr' */
911 static void relocate_rel(TCCState
*s1
, Section
*sr
)
916 s
= s1
->sections
[sr
->sh_info
];
917 for_each_elem(sr
, 0, rel
, ElfW_Rel
)
918 rel
->r_offset
+= s
->sh_addr
;
921 /* count the number of dynamic relocations so that we can reserve
923 static int prepare_dynamic_rel(TCCState
*s1
, Section
*sr
)
926 int sym_index
, esym_index
, type
, count
;
929 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
930 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
931 type
= ELFW(R_TYPE
)(rel
->r_info
);
933 #if defined(TCC_TARGET_I386)
935 #elif defined(TCC_TARGET_X86_64)
942 #if defined(TCC_TARGET_I386)
944 #elif defined(TCC_TARGET_X86_64)
947 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
956 /* allocate the section */
957 sr
->sh_flags
|= SHF_ALLOC
;
958 sr
->sh_size
= count
* sizeof(ElfW_Rel
);
963 static struct sym_attr
*alloc_sym_attr(TCCState
*s1
, int index
)
966 struct sym_attr
*tab
;
968 if (index
>= s1
->nb_sym_attrs
) {
969 /* find immediately bigger power of 2 and reallocate array */
973 tab
= tcc_realloc(s1
->sym_attrs
, n
* sizeof(*s1
->sym_attrs
));
975 memset(s1
->sym_attrs
+ s1
->nb_sym_attrs
, 0,
976 (n
- s1
->nb_sym_attrs
) * sizeof(*s1
->sym_attrs
));
977 s1
->nb_sym_attrs
= n
;
979 return &s1
->sym_attrs
[index
];
982 /* XXX: suppress that */
983 static void put32(unsigned char *p
, uint32_t val
)
991 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_ARM) || \
992 defined(TCC_TARGET_X86_64)
993 static uint32_t get32(unsigned char *p
)
995 return p
[0] | (p
[1] << 8) | (p
[2] << 16) | (p
[3] << 24);
999 static void build_got(TCCState
*s1
)
1003 /* if no got, then create it */
1004 s1
->got
= new_section(s1
, ".got", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
1005 s1
->got
->sh_entsize
= 4;
1006 add_elf_sym(symtab_section
, 0, 4, ELFW(ST_INFO
)(STB_GLOBAL
, STT_OBJECT
),
1007 0, s1
->got
->sh_num
, "_GLOBAL_OFFSET_TABLE_");
1008 ptr
= section_ptr_add(s1
->got
, 3 * PTR_SIZE
);
1010 /* keep space for _DYNAMIC pointer, if present */
1012 /* two dummy got entries */
1016 /* keep space for _DYNAMIC pointer, if present */
1019 /* two dummy got entries */
1027 /* put a got or plt entry corresponding to a symbol in symtab_section. 'size'
1028 and 'info' can be modifed if more precise info comes from the DLL.
1029 Returns offset of GOT or PLT slot. */
1030 static unsigned long put_got_entry(TCCState
*s1
,
1031 int reloc_type
, unsigned long size
, int info
,
1034 int index
, need_plt_entry
;
1037 unsigned long offset
;
1039 struct sym_attr
*symattr
;
1045 #ifdef TCC_TARGET_X86_64
1046 (reloc_type
== R_X86_64_JUMP_SLOT
);
1047 #elif defined(TCC_TARGET_I386)
1048 (reloc_type
== R_386_JMP_SLOT
);
1049 #elif defined(TCC_TARGET_ARM)
1050 (reloc_type
== R_ARM_JUMP_SLOT
);
1055 if (need_plt_entry
&& !s1
->plt
) {
1057 s1
->plt
= new_section(s1
, ".plt", SHT_PROGBITS
,
1058 SHF_ALLOC
| SHF_EXECINSTR
);
1059 s1
->plt
->sh_entsize
= 4;
1062 /* If a got/plt entry already exists for that symbol, no need to add one */
1063 if (sym_index
< s1
->nb_sym_attrs
) {
1064 if (need_plt_entry
&& s1
->sym_attrs
[sym_index
].plt_offset
)
1065 return s1
->sym_attrs
[sym_index
].plt_offset
;
1066 else if (!need_plt_entry
&& s1
->sym_attrs
[sym_index
].got_offset
)
1067 return s1
->sym_attrs
[sym_index
].got_offset
;
1070 symattr
= alloc_sym_attr(s1
, sym_index
);
1072 /* Only store the GOT offset if it's not generated for the PLT entry. */
1073 if (!need_plt_entry
)
1074 symattr
->got_offset
= s1
->got
->data_offset
;
1076 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1077 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1078 offset
= sym
->st_value
;
1079 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
1080 if (need_plt_entry
) {
1084 unsigned long relofs
;
1086 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
1089 /* if we build a DLL, we add a %ebx offset */
1090 if (s1
->output_type
== TCC_OUTPUT_DLL
)
1096 /* add a PLT entry */
1098 if (plt
->data_offset
== 0) {
1099 /* first plt entry */
1100 p
= section_ptr_add(plt
, 16);
1101 p
[0] = 0xff; /* pushl got + PTR_SIZE */
1102 p
[1] = modrm
+ 0x10;
1103 put32(p
+ 2, PTR_SIZE
);
1104 p
[6] = 0xff; /* jmp *(got + PTR_SIZE * 2) */
1106 put32(p
+ 8, PTR_SIZE
* 2);
1109 /* The PLT slot refers to the relocation entry it needs
1110 via offset. The reloc entry is created below, so its
1111 offset is the current data_offset. */
1112 relofs
= s1
->got
->reloc
? s1
->got
->reloc
->data_offset
: 0;
1113 symattr
->plt_offset
= plt
->data_offset
;
1114 p
= section_ptr_add(plt
, 16);
1115 p
[0] = 0xff; /* jmp *(got + x) */
1117 put32(p
+ 2, s1
->got
->data_offset
);
1118 p
[6] = 0x68; /* push $xxx */
1119 #ifdef TCC_TARGET_X86_64
1120 /* On x86-64, the relocation is referred to by _index_. */
1121 put32(p
+ 7, relofs
/ sizeof (ElfW_Rel
));
1123 put32(p
+ 7, relofs
);
1125 p
[11] = 0xe9; /* jmp plt_start */
1126 put32(p
+ 12, -(plt
->data_offset
));
1128 /* If this was an UNDEF symbol set the offset in the
1129 dynsymtab to the PLT slot, so that PC32 relocs to it
1131 if (sym
->st_shndx
== SHN_UNDEF
)
1132 offset
= plt
->data_offset
- 16;
1134 #elif defined(TCC_TARGET_ARM)
1135 if (need_plt_entry
) {
1139 /* if we build a DLL, we add a %ebx offset */
1140 if (s1
->output_type
== TCC_OUTPUT_DLL
)
1141 tcc_error("DLLs unimplemented!");
1143 /* add a PLT entry */
1145 if (plt
->data_offset
== 0) {
1146 /* first plt entry */
1147 p
= section_ptr_add(plt
, 16);
1148 put32(p
, 0xe52de004); /* push {lr} */
1149 put32(p
+4, 0xe59fe010); /* ldr lr, [pc, #16] */
1150 put32(p
+8, 0xe08fe00e); /* add lr, pc, lr */
1151 put32(p
+12, 0xe5bef008); /* ldr pc, [lr, #8]! */
1154 symattr
->plt_offset
= plt
->data_offset
;
1155 if (symattr
->plt_thumb_stub
) {
1156 p
= section_ptr_add(plt
, 20);
1157 put32(p
, 0x4778); /* bx pc */
1158 put32(p
+2, 0x46c0); /* nop */
1161 p
= section_ptr_add(plt
, 16);
1162 put32(p
, 0xe59fc004); /* ldr ip, [pc, #4] ; GOT entry offset */
1163 put32(p
+4, 0xe08fc00c); /* add ip, pc, ip ; addr of GOT entry */
1164 put32(p
+8, 0xe59cf000); /* ldr pc, [ip] ; jump to GOT entry */
1165 put32(p
+12, s1
->got
->data_offset
); /* GOT entry off once patched */
1167 /* the symbol is modified so that it will be relocated to
1169 if (s1
->output_type
== TCC_OUTPUT_EXE
)
1170 offset
= plt
->data_offset
- 16;
1172 #elif defined(TCC_TARGET_C67)
1174 tcc_error("C67 got not implemented");
1177 #error unsupported CPU
1180 /* XXX This might generate multiple syms for name. */
1181 index
= put_elf_sym(s1
->dynsym
, offset
,
1182 size
, info
, 0, sym
->st_shndx
, name
);
1183 /* Create the relocation (it's against the GOT for PLT
1185 put_elf_reloc(s1
->dynsym
, s1
->got
,
1186 s1
->got
->data_offset
,
1189 /* Without .dynsym (i.e. static link or memory output) we
1190 still need relocs against the generated got, so as to fill
1191 the entries with the symbol values (determined later). */
1192 put_elf_reloc(symtab_section
, s1
->got
,
1193 s1
->got
->data_offset
,
1194 reloc_type
, sym_index
);
1196 /* And now create the GOT slot itself. */
1197 ptr
= section_ptr_add(s1
->got
, PTR_SIZE
);
1200 return symattr
->plt_offset
;
1202 return symattr
->got_offset
;
1205 /* build GOT and PLT entries */
1206 ST_FUNC
void build_got_entries(TCCState
*s1
)
1211 int i
, type
, reloc_type
, sym_index
;
1213 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1214 s
= s1
->sections
[i
];
1215 if (s
->sh_type
!= SHT_RELX
)
1217 /* no need to handle got relocations */
1218 if (s
->link
!= symtab_section
)
1220 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1221 type
= ELFW(R_TYPE
)(rel
->r_info
);
1223 #if defined(TCC_TARGET_I386)
1230 if (type
== R_386_GOT32
|| type
== R_386_PLT32
) {
1231 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1232 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1233 /* look at the symbol got offset. If none, then add one */
1234 if (type
== R_386_GOT32
)
1235 reloc_type
= R_386_GLOB_DAT
;
1237 reloc_type
= R_386_JMP_SLOT
;
1238 put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
1242 #elif defined(TCC_TARGET_ARM)
1249 if (type
== R_ARM_GOT32
|| type
== R_ARM_PLT32
) {
1250 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1251 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1252 /* look at the symbol got offset. If none, then add one */
1253 if (type
== R_ARM_GOT32
)
1254 reloc_type
= R_ARM_GLOB_DAT
;
1256 reloc_type
= R_ARM_JUMP_SLOT
;
1257 put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
1261 case R_ARM_THM_JUMP24
:
1262 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1263 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1264 /* We are relocating a jump from thumb code to arm code */
1265 if (sym
->st_shndx
!= SHN_UNDEF
&& !(sym
->st_value
& 1)) {
1268 char *name
, buf
[1024];
1269 Section
*text_section
;
1271 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1272 text_section
= s1
->sections
[sym
->st_shndx
];
1273 /* Modify reloc to target a thumb stub to switch to ARM */
1274 snprintf(buf
, sizeof(buf
), "%s_from_thumb", name
);
1275 index
= put_elf_sym(symtab_section
,
1276 text_section
->data_offset
+ 1,
1277 sym
->st_size
, sym
->st_info
, 0,
1278 sym
->st_shndx
, buf
);
1279 rel
->r_info
= ELFW(R_INFO
)(index
, type
);
1280 /* Create a thumb stub fonction to switch to ARM mode */
1281 put_elf_reloc(symtab_section
, text_section
,
1282 text_section
->data_offset
+ 4, R_ARM_JUMP24
,
1284 p
= section_ptr_add(text_section
, 8);
1285 put32(p
, 0x4778); /* bx pc */
1286 put32(p
+2, 0x46c0); /* nop */
1287 put32(p
+4, 0xeafffffe); /* b $sym */
1289 #elif defined(TCC_TARGET_C67)
1296 if (type
== R_C60_GOT32
|| type
== R_C60_PLT32
) {
1297 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1298 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1299 /* look at the symbol got offset. If none, then add one */
1300 if (type
== R_C60_GOT32
)
1301 reloc_type
= R_C60_GLOB_DAT
;
1303 reloc_type
= R_C60_JMP_SLOT
;
1304 put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
1308 #elif defined(TCC_TARGET_X86_64)
1309 case R_X86_64_GOT32
:
1310 case R_X86_64_GOTTPOFF
:
1311 case R_X86_64_GOTPCREL
:
1312 case R_X86_64_PLT32
:
1315 if (type
== R_X86_64_GOT32
|| type
== R_X86_64_GOTPCREL
||
1316 type
== R_X86_64_PLT32
) {
1318 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1319 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1320 /* look at the symbol got offset. If none, then add one */
1321 if (type
== R_X86_64_GOT32
|| type
== R_X86_64_GOTPCREL
)
1322 reloc_type
= R_X86_64_GLOB_DAT
;
1324 reloc_type
= R_X86_64_JUMP_SLOT
;
1325 ofs
= put_got_entry(s1
, reloc_type
, sym
->st_size
,
1326 sym
->st_info
, sym_index
);
1327 if (type
== R_X86_64_PLT32
)
1328 /* We store the place of the generated PLT slot
1330 rel
->r_addend
+= ofs
;
1334 #error unsupported CPU
1343 ST_FUNC Section
*new_symtab(TCCState
*s1
,
1344 const char *symtab_name
, int sh_type
, int sh_flags
,
1345 const char *strtab_name
,
1346 const char *hash_name
, int hash_sh_flags
)
1348 Section
*symtab
, *strtab
, *hash
;
1349 int *ptr
, nb_buckets
;
1351 symtab
= new_section(s1
, symtab_name
, sh_type
, sh_flags
);
1352 symtab
->sh_entsize
= sizeof(ElfW(Sym
));
1353 strtab
= new_section(s1
, strtab_name
, SHT_STRTAB
, sh_flags
);
1354 put_elf_str(strtab
, "");
1355 symtab
->link
= strtab
;
1356 put_elf_sym(symtab
, 0, 0, 0, 0, 0, NULL
);
1360 hash
= new_section(s1
, hash_name
, SHT_HASH
, hash_sh_flags
);
1361 hash
->sh_entsize
= sizeof(int);
1362 symtab
->hash
= hash
;
1363 hash
->link
= symtab
;
1365 ptr
= section_ptr_add(hash
, (2 + nb_buckets
+ 1) * sizeof(int));
1366 ptr
[0] = nb_buckets
;
1368 memset(ptr
+ 2, 0, (nb_buckets
+ 1) * sizeof(int));
1372 /* put dynamic tag */
1373 static void put_dt(Section
*dynamic
, int dt
, addr_t val
)
1376 dyn
= section_ptr_add(dynamic
, sizeof(ElfW(Dyn
)));
1378 dyn
->d_un
.d_val
= val
;
1381 static void add_init_array_defines(TCCState
*s1
, const char *section_name
)
1385 char sym_start
[1024];
1388 snprintf(sym_start
, sizeof(sym_start
), "__%s_start", section_name
+ 1);
1389 snprintf(sym_end
, sizeof(sym_end
), "__%s_end", section_name
+ 1);
1391 s
= find_section(s1
, section_name
);
1396 end_offset
= s
->data_offset
;
1399 add_elf_sym(symtab_section
,
1401 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1402 s
->sh_num
, sym_start
);
1403 add_elf_sym(symtab_section
,
1405 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1406 s
->sh_num
, sym_end
);
1409 ST_FUNC
void tcc_add_bcheck(TCCState
*s1
)
1411 #ifdef CONFIG_TCC_BCHECK
1413 Section
*init_section
;
1414 unsigned char *pinit
;
1417 if (0 == s1
->do_bounds_check
)
1420 /* XXX: add an object file to do that */
1421 ptr
= section_ptr_add(bounds_section
, sizeof(unsigned long));
1423 add_elf_sym(symtab_section
, 0, 0,
1424 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1425 bounds_section
->sh_num
, "__bounds_start");
1426 #ifdef TCC_TARGET_I386
1427 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
) {
1428 /* add 'call __bound_init()' in .init section */
1429 init_section
= find_section(s1
, ".init");
1430 pinit
= section_ptr_add(init_section
, 5);
1432 put32(pinit
+ 1, -4);
1433 sym_index
= find_elf_sym(symtab_section
, "__bound_init");
1434 put_elf_reloc(symtab_section
, init_section
,
1435 init_section
->data_offset
- 4, R_386_PC32
, sym_index
);
1441 static inline int tcc_add_support(TCCState
*s1
, const char *filename
)
1444 snprintf(buf
, sizeof(buf
), "%s/%s", s1
->tcc_lib_path
, filename
);
1445 return tcc_add_file(s1
, buf
);
1448 /* add tcc runtime libraries */
1449 ST_FUNC
void tcc_add_runtime(TCCState
*s1
)
1452 if (!s1
->nostdlib
) {
1453 tcc_add_library(s1
, "c");
1454 #ifdef CONFIG_USE_LIBGCC
1455 if (!s1
->static_link
) {
1456 tcc_add_file(s1
, TCC_LIBGCC
);
1457 tcc_add_support(s1
, "libtcc1.a");
1459 tcc_add_support(s1
, "libtcc1.a");
1461 tcc_add_support(s1
, "libtcc1.a");
1465 /* tcc_add_bcheck tries to relocate a call to __bound_init in _init so
1466 libtcc1.a must be loaded before for __bound_init to be defined and
1467 crtn.o must be loaded after to not finalize _init too early. */
1470 if (!s1
->nostdlib
) {
1471 /* add crt end if not memory output */
1472 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
)
1473 tcc_add_crt(s1
, "crtn.o");
1477 /* add various standard linker symbols (must be done after the
1478 sections are filled (for example after allocating common
1480 ST_FUNC
void tcc_add_linker_symbols(TCCState
*s1
)
1486 add_elf_sym(symtab_section
,
1487 text_section
->data_offset
, 0,
1488 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1489 text_section
->sh_num
, "_etext");
1490 add_elf_sym(symtab_section
,
1491 data_section
->data_offset
, 0,
1492 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1493 data_section
->sh_num
, "_edata");
1494 add_elf_sym(symtab_section
,
1495 bss_section
->data_offset
, 0,
1496 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1497 bss_section
->sh_num
, "_end");
1498 /* horrible new standard ldscript defines */
1499 add_init_array_defines(s1
, ".preinit_array");
1500 add_init_array_defines(s1
, ".init_array");
1501 add_init_array_defines(s1
, ".fini_array");
1503 /* add start and stop symbols for sections whose name can be
1505 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1506 s
= s1
->sections
[i
];
1507 if (s
->sh_type
== SHT_PROGBITS
&&
1508 (s
->sh_flags
& SHF_ALLOC
)) {
1512 /* check if section name can be expressed in C */
1518 if (!isid(ch
) && !isnum(ch
))
1522 snprintf(buf
, sizeof(buf
), "__start_%s", s
->name
);
1523 add_elf_sym(symtab_section
,
1525 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1527 snprintf(buf
, sizeof(buf
), "__stop_%s", s
->name
);
1528 add_elf_sym(symtab_section
,
1530 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1537 static void tcc_output_binary(TCCState
*s1
, FILE *f
,
1538 const int *sec_order
)
1541 int i
, offset
, size
;
1544 for(i
=1;i
<s1
->nb_sections
;i
++) {
1545 s
= s1
->sections
[sec_order
[i
]];
1546 if (s
->sh_type
!= SHT_NOBITS
&&
1547 (s
->sh_flags
& SHF_ALLOC
)) {
1548 while (offset
< s
->sh_offset
) {
1553 fwrite(s
->data
, 1, size
, f
);
1559 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1561 #define EXTRA_RELITEMS 14
1563 /* move the relocation value from .dynsym to .got */
1564 void patch_dynsym_undef(TCCState
*s1
, Section
*s
)
1566 uint32_t *gotd
= (void *)s1
->got
->data
;
1569 gotd
+= 3; /* dummy entries in .got */
1570 /* relocate symbols in .dynsym */
1571 for_each_elem(s
, 1, sym
, ElfW(Sym
)) {
1572 if (sym
->st_shndx
== SHN_UNDEF
) {
1573 *gotd
++ = sym
->st_value
+ 6; /* XXX 6 is magic ? */
1580 #define EXTRA_RELITEMS 9
1582 /* zero plt offsets of weak symbols in .dynsym */
1583 void patch_dynsym_undef(TCCState
*s1
, Section
*s
)
1587 for_each_elem(s
, 1, sym
, ElfW(Sym
))
1588 if (sym
->st_shndx
== SHN_UNDEF
&& ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
)
1593 ST_FUNC
void fill_got_entry(TCCState
*s1
, ElfW_Rel
*rel
)
1595 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1596 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1597 unsigned long offset
;
1599 if (sym_index
>= s1
->nb_sym_attrs
)
1601 offset
= s1
->sym_attrs
[sym_index
].got_offset
;
1602 section_reserve(s1
->got
, offset
+ PTR_SIZE
);
1603 #ifdef TCC_TARGET_X86_64
1604 /* only works for x86-64 */
1605 put32(s1
->got
->data
+ offset
+ 4, sym
->st_value
>> 32);
1607 put32(s1
->got
->data
+ offset
, sym
->st_value
& 0xffffffff);
1610 /* Perform relocation to GOT or PLTÂ entries */
1611 ST_FUNC
void fill_got(TCCState
*s1
)
1617 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1618 s
= s1
->sections
[i
];
1619 if (s
->sh_type
!= SHT_RELX
)
1621 /* no need to handle got relocations */
1622 if (s
->link
!= symtab_section
)
1624 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1625 switch (ELFW(R_TYPE
) (rel
->r_info
)) {
1626 case R_X86_64_GOT32
:
1627 case R_X86_64_GOTPCREL
:
1628 case R_X86_64_PLT32
:
1629 fill_got_entry(s1
, rel
);
1636 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1637 in shared libraries and export non local defined symbols to shared libraries
1638 if -rdynamic switch was given on command line */
1639 static void bind_exe_dynsyms(TCCState
*s1
)
1642 int sym_index
, index
;
1643 ElfW(Sym
) *sym
, *esym
;
1646 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1647 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1648 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1649 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1650 if (sym
->st_shndx
== SHN_UNDEF
) {
1651 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1652 sym_index
= find_elf_sym(s1
->dynsymtab_section
, name
);
1654 esym
= &((ElfW(Sym
) *)s1
->dynsymtab_section
->data
)[sym_index
];
1655 type
= ELFW(ST_TYPE
)(esym
->st_info
);
1656 if ((type
== STT_FUNC
) || (type
== STT_GNU_IFUNC
)) {
1657 /* Indirect functions shall have STT_FUNC type in executable
1658 * dynsym section. Indeed, a dlsym call following a lazy
1659 * resolution would pick the symbol value from the
1660 * executable dynsym entry which would contain the address
1661 * of the function wanted by the caller of dlsym instead of
1662 * the address of the function that would return that
1664 put_got_entry(s1
, R_JMP_SLOT
, esym
->st_size
,
1665 ELFW(ST_INFO
)(STB_GLOBAL
,STT_FUNC
),
1666 sym
- (ElfW(Sym
) *)symtab_section
->data
);
1667 } else if (type
== STT_OBJECT
) {
1668 unsigned long offset
;
1670 offset
= bss_section
->data_offset
;
1671 /* XXX: which alignment ? */
1672 offset
= (offset
+ 16 - 1) & -16;
1673 index
= put_elf_sym(s1
->dynsym
, offset
, esym
->st_size
,
1674 esym
->st_info
, 0, bss_section
->sh_num
,
1676 /* Ensure R_COPY works for weak symbol aliases */
1677 if (ELFW(ST_BIND
)(esym
->st_info
) == STB_WEAK
) {
1678 for_each_elem(s1
->dynsymtab_section
, 1, dynsym
, ElfW(Sym
)) {
1679 if ((dynsym
->st_value
== esym
->st_value
)
1680 && (ELFW(ST_BIND
)(dynsym
->st_info
) == STB_GLOBAL
)) {
1681 char *dynname
= (char *) s1
->dynsymtab_section
->link
->data
1683 put_elf_sym(s1
->dynsym
, offset
, dynsym
->st_size
,
1685 bss_section
->sh_num
, dynname
);
1690 put_elf_reloc(s1
->dynsym
, bss_section
,
1691 offset
, R_COPY
, index
);
1692 offset
+= esym
->st_size
;
1693 bss_section
->data_offset
= offset
;
1696 /* STB_WEAK undefined symbols are accepted */
1697 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1698 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
||
1699 !strcmp(name
, "_fp_hw")) {
1701 tcc_error_noabort("undefined symbol '%s'", name
);
1704 } else if (s1
->rdynamic
&& ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1705 /* if -rdynamic option, then export all non local symbols */
1706 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1707 put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1708 0, sym
->st_shndx
, name
);
1713 /* Bind symbols of libraries: export non local symbols of executable that
1714 resolve undefined symbols of shared libraries */
1715 static void bind_libs_dynsyms(TCCState
*s1
)
1719 ElfW(Sym
) *sym
, *esym
;
1721 /* now look at unresolved dynamic symbols and export
1722 corresponding symbol */
1723 for_each_elem(s1
->dynsymtab_section
, 1, esym
, ElfW(Sym
)) {
1724 if (esym
->st_shndx
== SHN_UNDEF
) {
1725 name
= (char *) s1
->dynsymtab_section
->link
->data
+ esym
->st_name
;
1726 sym_index
= find_elf_sym(symtab_section
, name
);
1728 /* XXX: avoid adding a symbol if already present because of
1730 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1731 put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1732 sym
->st_info
, 0, sym
->st_shndx
, name
);
1734 /* weak symbols can stay undefined */
1735 if (ELFW(ST_BIND
)(esym
->st_info
) != STB_WEAK
)
1736 tcc_warning("undefined dynamic symbol '%s'", name
);
1742 /* Export all non local symbols (for shared libraries) */
1743 static void export_global_syms(TCCState
*s1
)
1745 int nb_syms
, dynindex
, index
;
1749 nb_syms
= symtab_section
->data_offset
/ sizeof(ElfW(Sym
));
1750 s1
->symtab_to_dynsym
= tcc_mallocz(sizeof(int) * nb_syms
);
1751 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1752 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1753 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1754 dynindex
= put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1755 sym
->st_info
, 0, sym
->st_shndx
, name
);
1756 index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1757 s1
->symtab_to_dynsym
[index
] = dynindex
;
1762 /* relocate the PLT: compute addresses and offsets in the PLT now that final
1763 address for PLT and GOT are known (see fill_program_header) */
1764 ST_FUNC
void relocate_plt(TCCState
*s1
)
1772 p_end
= p
+ s1
->plt
->data_offset
;
1774 #if defined(TCC_TARGET_I386)
1775 put32(p
+ 2, get32(p
+ 2) + s1
->got
->sh_addr
);
1776 put32(p
+ 8, get32(p
+ 8) + s1
->got
->sh_addr
);
1779 put32(p
+ 2, get32(p
+ 2) + s1
->got
->sh_addr
);
1782 #elif defined(TCC_TARGET_X86_64)
1783 int x
= s1
->got
->sh_addr
- s1
->plt
->sh_addr
- 6;
1784 put32(p
+ 2, get32(p
+ 2) + x
);
1785 put32(p
+ 8, get32(p
+ 8) + x
- 6);
1788 put32(p
+ 2, get32(p
+ 2) + x
+ s1
->plt
->data
- p
);
1791 #elif defined(TCC_TARGET_ARM)
1793 x
=s1
->got
->sh_addr
- s1
->plt
->sh_addr
- 12;
1796 if (get32(p
) == 0x46c04778) /* PLT Thumb stub present */
1798 put32(p
+ 12, x
+ get32(p
+ 12) + s1
->plt
->data
- p
);
1801 #elif defined(TCC_TARGET_C67)
1804 #error unsupported CPU
1809 /* Allocate strings for section names and decide if an unallocated section
1812 NOTE: the strsec section comes last, so its size is also correct ! */
1813 static void alloc_sec_names(TCCState
*s1
, int file_type
, Section
*strsec
)
1818 /* Allocate strings for section names */
1819 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1820 s
= s1
->sections
[i
];
1821 s
->sh_name
= put_elf_str(strsec
, s
->name
);
1822 /* when generating a DLL, we include relocations but we may
1824 if (file_type
== TCC_OUTPUT_DLL
&&
1825 s
->sh_type
== SHT_RELX
&&
1826 !(s
->sh_flags
& SHF_ALLOC
)) {
1827 /* gr: avoid bogus relocs for empty (debug) sections */
1828 if (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_ALLOC
)
1829 prepare_dynamic_rel(s1
, s
);
1830 else if (s1
->do_debug
)
1831 s
->sh_size
= s
->data_offset
;
1832 } else if (s1
->do_debug
||
1833 file_type
== TCC_OUTPUT_OBJ
||
1834 (s
->sh_flags
& SHF_ALLOC
) ||
1835 i
== (s1
->nb_sections
- 1)) {
1836 /* we output all sections if debug or object file */
1837 s
->sh_size
= s
->data_offset
;
1842 /* Info to be copied in dynamic section */
1846 unsigned long dyn_rel_off
;
1849 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1855 /* Assign sections to segments and decide how are sections laid out when loaded
1856 in memory. This function also fills corresponding program headers. */
1857 static int layout_sections(TCCState
*s1
, ElfW(Phdr
) *phdr
, int phnum
,
1858 Section
*interp
, struct dyn_inf
*dyninf
,
1861 int i
, j
, k
, file_type
, sh_order_index
, file_offset
;
1867 file_type
= s1
->output_type
;
1869 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
1870 file_offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1875 if (s1
->has_text_addr
) {
1876 int a_offset
, p_offset
;
1877 addr
= s1
->text_addr
;
1878 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1880 a_offset
= (int) (addr
& (s1
->section_align
- 1));
1881 p_offset
= file_offset
& (s1
->section_align
- 1);
1882 if (a_offset
< p_offset
)
1883 a_offset
+= s1
->section_align
;
1884 file_offset
+= (a_offset
- p_offset
);
1886 if (file_type
== TCC_OUTPUT_DLL
)
1889 addr
= ELF_START_ADDR
;
1890 /* compute address after headers */
1891 addr
+= (file_offset
& (s1
->section_align
- 1));
1895 /* Leave one program headers for the program interpreter and one for
1896 the program header table itself if needed. These are done later as
1897 they require section layout to be done first. */
1899 ph
+= 1 + HAVE_PHDR
;
1901 /* dynamic relocation table information, for .dynamic section */
1902 dyninf
->rel_addr
= dyninf
->rel_size
= 0;
1903 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1904 dyninf
->bss_addr
= dyninf
->bss_size
= 0;
1907 for(j
= 0; j
< 2; j
++) {
1908 ph
->p_type
= PT_LOAD
;
1910 ph
->p_flags
= PF_R
| PF_X
;
1912 ph
->p_flags
= PF_R
| PF_W
;
1913 ph
->p_align
= s1
->section_align
;
1915 /* Decide the layout of sections loaded in memory. This must
1916 be done before program headers are filled since they contain
1917 info about the layout. We do the following ordering: interp,
1918 symbol tables, relocations, progbits, nobits */
1919 /* XXX: do faster and simpler sorting */
1920 for(k
= 0; k
< 5; k
++) {
1921 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1922 s
= s1
->sections
[i
];
1923 /* compute if section should be included */
1925 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1929 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1930 (SHF_ALLOC
| SHF_WRITE
))
1936 } else if (s
->sh_type
== SHT_DYNSYM
||
1937 s
->sh_type
== SHT_STRTAB
||
1938 s
->sh_type
== SHT_HASH
) {
1941 } else if (s
->sh_type
== SHT_RELX
) {
1944 } else if (s
->sh_type
== SHT_NOBITS
) {
1951 sec_order
[sh_order_index
++] = i
;
1953 /* section matches: we align it and add its size */
1955 addr
= (addr
+ s
->sh_addralign
- 1) &
1956 ~(s
->sh_addralign
- 1);
1957 file_offset
+= (int) ( addr
- tmp
);
1958 s
->sh_offset
= file_offset
;
1961 /* update program header infos */
1962 if (ph
->p_offset
== 0) {
1963 ph
->p_offset
= file_offset
;
1965 ph
->p_paddr
= ph
->p_vaddr
;
1967 /* update dynamic relocation infos */
1968 if (s
->sh_type
== SHT_RELX
) {
1969 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1970 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.got")) {
1971 dyninf
->rel_addr
= addr
;
1972 dyninf
->rel_size
+= s
->sh_size
; /* XXX only first rel. */
1974 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.bss")) {
1975 dyninf
->bss_addr
= addr
;
1976 dyninf
->bss_size
= s
->sh_size
; /* XXX only first rel. */
1979 if (dyninf
->rel_size
== 0)
1980 dyninf
->rel_addr
= addr
;
1981 dyninf
->rel_size
+= s
->sh_size
;
1985 if (s
->sh_type
!= SHT_NOBITS
)
1986 file_offset
+= s
->sh_size
;
1990 /* Make the first PT_LOAD segment include the program
1991 headers itself (and the ELF header as well), it'll
1992 come out with same memory use but will make various
1993 tools like binutils strip work better. */
1994 ph
->p_offset
&= ~(ph
->p_align
- 1);
1995 ph
->p_vaddr
&= ~(ph
->p_align
- 1);
1996 ph
->p_paddr
&= ~(ph
->p_align
- 1);
1998 ph
->p_filesz
= file_offset
- ph
->p_offset
;
1999 ph
->p_memsz
= addr
- ph
->p_vaddr
;
2002 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
) {
2003 /* if in the middle of a page, we duplicate the page in
2004 memory so that one copy is RX and the other is RW */
2005 if ((addr
& (s1
->section_align
- 1)) != 0)
2006 addr
+= s1
->section_align
;
2008 addr
= (addr
+ s1
->section_align
- 1) & ~(s1
->section_align
- 1);
2009 file_offset
= (file_offset
+ s1
->section_align
- 1) &
2010 ~(s1
->section_align
- 1);
2016 /* all other sections come after */
2017 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2018 s
= s1
->sections
[i
];
2019 if (phnum
> 0 && (s
->sh_flags
& SHF_ALLOC
))
2021 sec_order
[sh_order_index
++] = i
;
2023 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
2024 ~(s
->sh_addralign
- 1);
2025 s
->sh_offset
= file_offset
;
2026 if (s
->sh_type
!= SHT_NOBITS
)
2027 file_offset
+= s
->sh_size
;
2033 static void fill_unloadable_phdr(ElfW(Phdr
) *phdr
, int phnum
, Section
*interp
,
2038 /* if interpreter, then add corresponding program header */
2044 int len
= phnum
* sizeof(ElfW(Phdr
));
2046 ph
->p_type
= PT_PHDR
;
2047 ph
->p_offset
= sizeof(ElfW(Ehdr
));
2048 ph
->p_vaddr
= interp
->sh_addr
- len
;
2049 ph
->p_paddr
= ph
->p_vaddr
;
2050 ph
->p_filesz
= ph
->p_memsz
= len
;
2051 ph
->p_flags
= PF_R
| PF_X
;
2052 ph
->p_align
= 4; /* interp->sh_addralign; */
2056 ph
->p_type
= PT_INTERP
;
2057 ph
->p_offset
= interp
->sh_offset
;
2058 ph
->p_vaddr
= interp
->sh_addr
;
2059 ph
->p_paddr
= ph
->p_vaddr
;
2060 ph
->p_filesz
= interp
->sh_size
;
2061 ph
->p_memsz
= interp
->sh_size
;
2063 ph
->p_align
= interp
->sh_addralign
;
2066 /* if dynamic section, then add corresponding program header */
2068 ph
= &phdr
[phnum
- 1];
2070 ph
->p_type
= PT_DYNAMIC
;
2071 ph
->p_offset
= dynamic
->sh_offset
;
2072 ph
->p_vaddr
= dynamic
->sh_addr
;
2073 ph
->p_paddr
= ph
->p_vaddr
;
2074 ph
->p_filesz
= dynamic
->sh_size
;
2075 ph
->p_memsz
= dynamic
->sh_size
;
2076 ph
->p_flags
= PF_R
| PF_W
;
2077 ph
->p_align
= dynamic
->sh_addralign
;
2081 /* Fill the dynamic section with tags describing the address and size of
2083 static void fill_dynamic(TCCState
*s1
, struct dyn_inf
*dyninf
)
2087 dynamic
= dyninf
->dynamic
;
2089 /* put dynamic section entries */
2090 dynamic
->data_offset
= dyninf
->dyn_rel_off
;
2091 put_dt(dynamic
, DT_HASH
, s1
->dynsym
->hash
->sh_addr
);
2092 put_dt(dynamic
, DT_STRTAB
, dyninf
->dynstr
->sh_addr
);
2093 put_dt(dynamic
, DT_SYMTAB
, s1
->dynsym
->sh_addr
);
2094 put_dt(dynamic
, DT_STRSZ
, dyninf
->dynstr
->data_offset
);
2095 put_dt(dynamic
, DT_SYMENT
, sizeof(ElfW(Sym
)));
2096 #ifdef TCC_TARGET_X86_64
2097 put_dt(dynamic
, DT_RELA
, dyninf
->rel_addr
);
2098 put_dt(dynamic
, DT_RELASZ
, dyninf
->rel_size
);
2099 put_dt(dynamic
, DT_RELAENT
, sizeof(ElfW_Rel
));
2101 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2102 put_dt(dynamic
, DT_PLTGOT
, s1
->got
->sh_addr
);
2103 put_dt(dynamic
, DT_PLTRELSZ
, dyninf
->rel_size
);
2104 put_dt(dynamic
, DT_JMPREL
, dyninf
->rel_addr
);
2105 put_dt(dynamic
, DT_PLTREL
, DT_REL
);
2106 put_dt(dynamic
, DT_REL
, dyninf
->bss_addr
);
2107 put_dt(dynamic
, DT_RELSZ
, dyninf
->bss_size
);
2109 put_dt(dynamic
, DT_REL
, dyninf
->rel_addr
);
2110 put_dt(dynamic
, DT_RELSZ
, dyninf
->rel_size
);
2111 put_dt(dynamic
, DT_RELENT
, sizeof(ElfW_Rel
));
2115 put_dt(dynamic
, DT_DEBUG
, 0);
2116 put_dt(dynamic
, DT_NULL
, 0);
2119 /* Relocate remaining sections and symbols (that is those not related to
2121 static int final_sections_reloc(TCCState
*s1
)
2126 relocate_syms(s1
, 0);
2128 if (s1
->nb_errors
!= 0)
2131 /* relocate sections */
2132 /* XXX: ignore sections with allocated relocations ? */
2133 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2134 s
= s1
->sections
[i
];
2135 if (s
->reloc
&& s
!= s1
->got
)
2136 relocate_section(s1
, s
);
2139 /* relocate relocation entries if the relocation tables are
2140 allocated in the executable */
2141 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2142 s
= s1
->sections
[i
];
2143 if ((s
->sh_flags
& SHF_ALLOC
) &&
2144 s
->sh_type
== SHT_RELX
) {
2145 relocate_rel(s1
, s
);
2151 /* Create an ELF file on disk.
2152 This function handle ELF specific layout requirements */
2153 static void tcc_output_elf(TCCState
*s1
, FILE *f
, int phnum
, ElfW(Phdr
) *phdr
,
2154 int file_offset
, int *sec_order
)
2156 int i
, shnum
, offset
, size
, file_type
;
2159 ElfW(Shdr
) shdr
, *sh
;
2161 file_type
= s1
->output_type
;
2162 shnum
= s1
->nb_sections
;
2164 memset(&ehdr
, 0, sizeof(ehdr
));
2167 ehdr
.e_phentsize
= sizeof(ElfW(Phdr
));
2168 ehdr
.e_phnum
= phnum
;
2169 ehdr
.e_phoff
= sizeof(ElfW(Ehdr
));
2173 file_offset
= (file_offset
+ 3) & -4;
2176 ehdr
.e_ident
[0] = ELFMAG0
;
2177 ehdr
.e_ident
[1] = ELFMAG1
;
2178 ehdr
.e_ident
[2] = ELFMAG2
;
2179 ehdr
.e_ident
[3] = ELFMAG3
;
2180 ehdr
.e_ident
[4] = ELFCLASSW
;
2181 ehdr
.e_ident
[5] = ELFDATA2LSB
;
2182 ehdr
.e_ident
[6] = EV_CURRENT
;
2183 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2184 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
2186 #ifdef TCC_TARGET_ARM
2188 ehdr
.e_ident
[EI_OSABI
] = 0;
2189 ehdr
.e_flags
= EF_ARM_EABI_VER4
;
2190 if (file_type
== TCC_OUTPUT_EXE
|| file_type
== TCC_OUTPUT_DLL
)
2191 ehdr
.e_flags
|= EF_ARM_HASENTRY
;
2192 if (s1
->float_abi
== ARM_HARD_FLOAT
)
2193 ehdr
.e_flags
|= EF_ARM_VFP_FLOAT
;
2195 ehdr
.e_flags
|= EF_ARM_SOFT_FLOAT
;
2197 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_ARM
;
2202 case TCC_OUTPUT_EXE
:
2203 ehdr
.e_type
= ET_EXEC
;
2204 ehdr
.e_entry
= get_elf_sym_addr(s1
, "_start", 1);
2206 case TCC_OUTPUT_DLL
:
2207 ehdr
.e_type
= ET_DYN
;
2208 ehdr
.e_entry
= text_section
->sh_addr
; /* XXX: is it correct ? */
2210 case TCC_OUTPUT_OBJ
:
2211 ehdr
.e_type
= ET_REL
;
2214 ehdr
.e_machine
= EM_TCC_TARGET
;
2215 ehdr
.e_version
= EV_CURRENT
;
2216 ehdr
.e_shoff
= file_offset
;
2217 ehdr
.e_ehsize
= sizeof(ElfW(Ehdr
));
2218 ehdr
.e_shentsize
= sizeof(ElfW(Shdr
));
2219 ehdr
.e_shnum
= shnum
;
2220 ehdr
.e_shstrndx
= shnum
- 1;
2222 fwrite(&ehdr
, 1, sizeof(ElfW(Ehdr
)), f
);
2223 fwrite(phdr
, 1, phnum
* sizeof(ElfW(Phdr
)), f
);
2224 offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
2226 sort_syms(s1
, symtab_section
);
2227 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2228 s
= s1
->sections
[sec_order
[i
]];
2229 if (s
->sh_type
!= SHT_NOBITS
) {
2230 if (s
->sh_type
== SHT_DYNSYM
)
2231 patch_dynsym_undef(s1
, s
);
2232 while (offset
< s
->sh_offset
) {
2237 fwrite(s
->data
, 1, size
, f
);
2242 /* output section headers */
2243 while (offset
< ehdr
.e_shoff
) {
2248 for(i
= 0; i
< s1
->nb_sections
; i
++) {
2250 memset(sh
, 0, sizeof(ElfW(Shdr
)));
2251 s
= s1
->sections
[i
];
2253 sh
->sh_name
= s
->sh_name
;
2254 sh
->sh_type
= s
->sh_type
;
2255 sh
->sh_flags
= s
->sh_flags
;
2256 sh
->sh_entsize
= s
->sh_entsize
;
2257 sh
->sh_info
= s
->sh_info
;
2259 sh
->sh_link
= s
->link
->sh_num
;
2260 sh
->sh_addralign
= s
->sh_addralign
;
2261 sh
->sh_addr
= s
->sh_addr
;
2262 sh
->sh_offset
= s
->sh_offset
;
2263 sh
->sh_size
= s
->sh_size
;
2265 fwrite(sh
, 1, sizeof(ElfW(Shdr
)), f
);
2269 /* Write an elf, coff or "binary" file */
2270 static int tcc_write_elf_file(TCCState
*s1
, const char *filename
, int phnum
,
2271 ElfW(Phdr
) *phdr
, int file_offset
, int *sec_order
)
2273 int fd
, mode
, file_type
;
2276 file_type
= s1
->output_type
;
2277 if (file_type
== TCC_OUTPUT_OBJ
)
2282 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, mode
);
2284 tcc_error_noabort("could not write '%s'", filename
);
2287 f
= fdopen(fd
, "wb");
2289 printf("<- %s\n", filename
);
2291 #ifdef TCC_TARGET_COFF
2292 if (s1
->output_format
== TCC_OUTPUT_FORMAT_COFF
)
2293 tcc_output_coff(s1
, f
);
2296 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
2297 tcc_output_elf(s1
, f
, phnum
, phdr
, file_offset
, sec_order
);
2299 tcc_output_binary(s1
, f
, sec_order
);
2305 /* Output an elf, coff or binary file */
2306 /* XXX: suppress unneeded sections */
2307 static int elf_output_file(TCCState
*s1
, const char *filename
)
2309 int i
, ret
, phnum
, shnum
, file_type
, file_offset
, *sec_order
;
2310 struct dyn_inf dyninf
;
2313 Section
*strsec
, *interp
, *dynamic
, *dynstr
;
2315 file_type
= s1
->output_type
;
2318 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2319 if (file_type
!= TCC_OUTPUT_OBJ
) {
2320 tcc_add_runtime(s1
);
2325 interp
= dynamic
= dynstr
= NULL
; /* avoid warning */
2326 dyninf
.dyn_rel_off
= 0; /* avoid warning */
2328 if (file_type
!= TCC_OUTPUT_OBJ
) {
2329 relocate_common_syms();
2331 tcc_add_linker_symbols(s1
);
2333 if (!s1
->static_link
) {
2334 if (file_type
== TCC_OUTPUT_EXE
) {
2336 /* allow override the dynamic loader */
2337 const char *elfint
= getenv("LD_SO");
2339 elfint
= DEFAULT_ELFINTERP(s1
);
2340 /* add interpreter section only if executable */
2341 interp
= new_section(s1
, ".interp", SHT_PROGBITS
, SHF_ALLOC
);
2342 interp
->sh_addralign
= 1;
2343 ptr
= section_ptr_add(interp
, 1 + strlen(elfint
));
2344 strcpy(ptr
, elfint
);
2347 /* add dynamic symbol table */
2348 s1
->dynsym
= new_symtab(s1
, ".dynsym", SHT_DYNSYM
, SHF_ALLOC
,
2350 ".hash", SHF_ALLOC
);
2351 dynstr
= s1
->dynsym
->link
;
2353 /* add dynamic section */
2354 dynamic
= new_section(s1
, ".dynamic", SHT_DYNAMIC
,
2355 SHF_ALLOC
| SHF_WRITE
);
2356 dynamic
->link
= dynstr
;
2357 dynamic
->sh_entsize
= sizeof(ElfW(Dyn
));
2361 if (file_type
== TCC_OUTPUT_EXE
) {
2362 bind_exe_dynsyms(s1
);
2364 if (s1
->nb_errors
) {
2369 bind_libs_dynsyms(s1
);
2370 } else /* shared library case: simply export all global symbols */
2371 export_global_syms(s1
);
2373 build_got_entries(s1
);
2375 /* add a list of needed dlls */
2376 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2377 DLLReference
*dllref
= s1
->loaded_dlls
[i
];
2378 if (dllref
->level
== 0)
2379 put_dt(dynamic
, DT_NEEDED
, put_elf_str(dynstr
, dllref
->name
));
2383 put_dt(dynamic
, DT_RPATH
, put_elf_str(dynstr
, s1
->rpath
));
2385 /* XXX: currently, since we do not handle PIC code, we
2386 must relocate the readonly segments */
2387 if (file_type
== TCC_OUTPUT_DLL
) {
2389 put_dt(dynamic
, DT_SONAME
, put_elf_str(dynstr
, s1
->soname
));
2390 put_dt(dynamic
, DT_TEXTREL
, 0);
2394 put_dt(dynamic
, DT_SYMBOLIC
, 0);
2396 /* add necessary space for other entries */
2397 dyninf
.dyn_rel_off
= dynamic
->data_offset
;
2398 dynamic
->data_offset
+= sizeof(ElfW(Dyn
)) * EXTRA_RELITEMS
;
2400 /* still need to build got entries in case of static link */
2401 build_got_entries(s1
);
2405 /* we add a section for symbols */
2406 strsec
= new_section(s1
, ".shstrtab", SHT_STRTAB
, 0);
2407 put_elf_str(strsec
, "");
2409 /* compute number of sections */
2410 shnum
= s1
->nb_sections
;
2412 /* this array is used to reorder sections in the output file */
2413 sec_order
= tcc_malloc(sizeof(int) * shnum
);
2416 /* compute number of program headers */
2419 case TCC_OUTPUT_OBJ
:
2422 case TCC_OUTPUT_EXE
:
2423 if (!s1
->static_link
)
2424 phnum
= 4 + HAVE_PHDR
;
2428 case TCC_OUTPUT_DLL
:
2433 /* Allocate strings for section names */
2434 alloc_sec_names(s1
, file_type
, strsec
);
2436 /* allocate program segment headers */
2437 phdr
= tcc_mallocz(phnum
* sizeof(ElfW(Phdr
)));
2439 /* compute section to program header mapping */
2440 file_offset
= layout_sections(s1
, phdr
, phnum
, interp
, &dyninf
, sec_order
);
2442 /* Fill remaining program header and finalize relocation related to dynamic
2445 fill_unloadable_phdr(phdr
, phnum
, interp
, dynamic
);
2447 dyninf
.dynamic
= dynamic
;
2448 dyninf
.dynstr
= dynstr
;
2450 fill_dynamic(s1
, &dyninf
);
2452 /* put in GOT the dynamic section address and relocate PLT */
2453 put32(s1
->got
->data
, dynamic
->sh_addr
);
2454 if (file_type
== TCC_OUTPUT_EXE
2455 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
2456 || file_type
== TCC_OUTPUT_DLL
2461 /* relocate symbols in .dynsym now that final addresses are known */
2462 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
)) {
2463 /* relocate to PLT if symbol corresponds to a PLT entry */
2464 if (sym
->st_shndx
== SHN_UNDEF
) {
2466 sym
->st_value
+= s1
->plt
->sh_addr
;
2467 } else if (sym
->st_shndx
< SHN_LORESERVE
) {
2468 /* do symbol relocation */
2469 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
2475 /* if building executable or DLL, then relocate each section
2476 except the GOT which is already relocated */
2477 if (file_type
!= TCC_OUTPUT_OBJ
) {
2478 ret
= final_sections_reloc(s1
);
2483 /* Perform relocation to GOT or PLTÂ entries */
2484 if (file_type
== TCC_OUTPUT_EXE
&& s1
->static_link
)
2487 /* Create the ELF file with name 'filename' */
2488 ret
= tcc_write_elf_file(s1
, filename
, phnum
, phdr
, file_offset
, sec_order
);
2490 tcc_free(s1
->symtab_to_dynsym
);
2491 tcc_free(sec_order
);
2493 tcc_free(s1
->sym_attrs
);
2494 s1
->sym_attrs
= NULL
;
2498 LIBTCCAPI
int tcc_output_file(TCCState
*s
, const char *filename
)
2501 #ifdef TCC_TARGET_PE
2502 if (s
->output_type
!= TCC_OUTPUT_OBJ
) {
2503 ret
= pe_output_file(s
, filename
);
2506 ret
= elf_output_file(s
, filename
);
2510 static void *load_data(int fd
, unsigned long file_offset
, unsigned long size
)
2514 data
= tcc_malloc(size
);
2515 lseek(fd
, file_offset
, SEEK_SET
);
2516 read(fd
, data
, size
);
2520 typedef struct SectionMergeInfo
{
2521 Section
*s
; /* corresponding existing section */
2522 unsigned long offset
; /* offset of the new section in the existing section */
2523 uint8_t new_section
; /* true if section 's' was added */
2524 uint8_t link_once
; /* true if link once section */
2527 /* load an object file and merge it with current files */
2528 /* XXX: handle correctly stab (debug) info */
2529 ST_FUNC
int tcc_load_object_file(TCCState
*s1
,
2530 int fd
, unsigned long file_offset
)
2533 ElfW(Shdr
) *shdr
, *sh
;
2534 int size
, i
, j
, offset
, offseti
, nb_syms
, sym_index
, ret
;
2535 unsigned char *strsec
, *strtab
;
2536 int *old_to_new_syms
;
2537 char *sh_name
, *name
;
2538 SectionMergeInfo
*sm_table
, *sm
;
2539 ElfW(Sym
) *sym
, *symtab
;
2546 stab_index
= stabstr_index
= 0;
2548 if (read(fd
, &ehdr
, sizeof(ehdr
)) != sizeof(ehdr
))
2550 if (ehdr
.e_ident
[0] != ELFMAG0
||
2551 ehdr
.e_ident
[1] != ELFMAG1
||
2552 ehdr
.e_ident
[2] != ELFMAG2
||
2553 ehdr
.e_ident
[3] != ELFMAG3
)
2555 /* test if object file */
2556 if (ehdr
.e_type
!= ET_REL
)
2558 /* test CPU specific stuff */
2559 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2560 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2562 tcc_error_noabort("invalid object file");
2566 shdr
= load_data(fd
, file_offset
+ ehdr
.e_shoff
,
2567 sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2568 sm_table
= tcc_mallocz(sizeof(SectionMergeInfo
) * ehdr
.e_shnum
);
2570 /* load section names */
2571 sh
= &shdr
[ehdr
.e_shstrndx
];
2572 strsec
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2574 /* load symtab and strtab */
2575 old_to_new_syms
= NULL
;
2579 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2581 if (sh
->sh_type
== SHT_SYMTAB
) {
2583 tcc_error_noabort("object must contain only one symtab");
2588 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2589 symtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2590 sm_table
[i
].s
= symtab_section
;
2592 /* now load strtab */
2593 sh
= &shdr
[sh
->sh_link
];
2594 strtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2598 /* now examine each section and try to merge its content with the
2600 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2601 /* no need to examine section name strtab */
2602 if (i
== ehdr
.e_shstrndx
)
2605 sh_name
= (char *) strsec
+ sh
->sh_name
;
2606 /* ignore sections types we do not handle */
2607 if (sh
->sh_type
!= SHT_PROGBITS
&&
2608 sh
->sh_type
!= SHT_RELX
&&
2610 sh
->sh_type
!= SHT_ARM_EXIDX
&&
2612 sh
->sh_type
!= SHT_NOBITS
&&
2613 sh
->sh_type
!= SHT_PREINIT_ARRAY
&&
2614 sh
->sh_type
!= SHT_INIT_ARRAY
&&
2615 sh
->sh_type
!= SHT_FINI_ARRAY
&&
2616 strcmp(sh_name
, ".stabstr")
2619 if (sh
->sh_addralign
< 1)
2620 sh
->sh_addralign
= 1;
2621 /* find corresponding section, if any */
2622 for(j
= 1; j
< s1
->nb_sections
;j
++) {
2623 s
= s1
->sections
[j
];
2624 if (!strcmp(s
->name
, sh_name
)) {
2625 if (!strncmp(sh_name
, ".gnu.linkonce",
2626 sizeof(".gnu.linkonce") - 1)) {
2627 /* if a 'linkonce' section is already present, we
2628 do not add it again. It is a little tricky as
2629 symbols can still be defined in
2631 sm_table
[i
].link_once
= 1;
2638 /* not found: create new section */
2639 s
= new_section(s1
, sh_name
, sh
->sh_type
, sh
->sh_flags
);
2640 /* take as much info as possible from the section. sh_link and
2641 sh_info will be updated later */
2642 s
->sh_addralign
= sh
->sh_addralign
;
2643 s
->sh_entsize
= sh
->sh_entsize
;
2644 sm_table
[i
].new_section
= 1;
2646 if (sh
->sh_type
!= s
->sh_type
) {
2647 tcc_error_noabort("invalid section type");
2651 /* align start of section */
2652 offset
= s
->data_offset
;
2654 if (0 == strcmp(sh_name
, ".stab")) {
2658 if (0 == strcmp(sh_name
, ".stabstr")) {
2663 size
= sh
->sh_addralign
- 1;
2664 offset
= (offset
+ size
) & ~size
;
2665 if (sh
->sh_addralign
> s
->sh_addralign
)
2666 s
->sh_addralign
= sh
->sh_addralign
;
2667 s
->data_offset
= offset
;
2669 sm_table
[i
].offset
= offset
;
2671 /* concatenate sections */
2673 if (sh
->sh_type
!= SHT_NOBITS
) {
2675 lseek(fd
, file_offset
+ sh
->sh_offset
, SEEK_SET
);
2676 ptr
= section_ptr_add(s
, size
);
2677 read(fd
, ptr
, size
);
2679 s
->data_offset
+= size
;
2684 /* gr relocate stab strings */
2685 if (stab_index
&& stabstr_index
) {
2688 s
= sm_table
[stab_index
].s
;
2689 a
= (Stab_Sym
*)(s
->data
+ sm_table
[stab_index
].offset
);
2690 b
= (Stab_Sym
*)(s
->data
+ s
->data_offset
);
2691 o
= sm_table
[stabstr_index
].offset
;
2693 a
->n_strx
+= o
, a
++;
2696 /* second short pass to update sh_link and sh_info fields of new
2698 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2700 if (!s
|| !sm_table
[i
].new_section
)
2703 if (sh
->sh_link
> 0)
2704 s
->link
= sm_table
[sh
->sh_link
].s
;
2705 if (sh
->sh_type
== SHT_RELX
) {
2706 s
->sh_info
= sm_table
[sh
->sh_info
].s
->sh_num
;
2707 /* update backward link */
2708 s1
->sections
[s
->sh_info
]->reloc
= s
;
2713 /* resolve symbols */
2714 old_to_new_syms
= tcc_mallocz(nb_syms
* sizeof(int));
2717 for(i
= 1; i
< nb_syms
; i
++, sym
++) {
2718 if (sym
->st_shndx
!= SHN_UNDEF
&&
2719 sym
->st_shndx
< SHN_LORESERVE
) {
2720 sm
= &sm_table
[sym
->st_shndx
];
2721 if (sm
->link_once
) {
2722 /* if a symbol is in a link once section, we use the
2723 already defined symbol. It is very important to get
2724 correct relocations */
2725 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
2726 name
= (char *) strtab
+ sym
->st_name
;
2727 sym_index
= find_elf_sym(symtab_section
, name
);
2729 old_to_new_syms
[i
] = sym_index
;
2733 /* if no corresponding section added, no need to add symbol */
2736 /* convert section number */
2737 sym
->st_shndx
= sm
->s
->sh_num
;
2739 sym
->st_value
+= sm
->offset
;
2742 name
= (char *) strtab
+ sym
->st_name
;
2743 sym_index
= add_elf_sym(symtab_section
, sym
->st_value
, sym
->st_size
,
2744 sym
->st_info
, sym
->st_other
,
2745 sym
->st_shndx
, name
);
2746 old_to_new_syms
[i
] = sym_index
;
2749 /* third pass to patch relocation entries */
2750 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2755 offset
= sm_table
[i
].offset
;
2756 switch(s
->sh_type
) {
2758 /* take relocation offset information */
2759 offseti
= sm_table
[sh
->sh_info
].offset
;
2760 for_each_elem(s
, (offset
/ sizeof(*rel
)), rel
, ElfW_Rel
) {
2763 /* convert symbol index */
2764 type
= ELFW(R_TYPE
)(rel
->r_info
);
2765 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
2766 /* NOTE: only one symtab assumed */
2767 if (sym_index
>= nb_syms
)
2769 sym_index
= old_to_new_syms
[sym_index
];
2770 /* ignore link_once in rel section. */
2771 if (!sym_index
&& !sm
->link_once
2772 #ifdef TCC_TARGET_ARM
2773 && type
!= R_ARM_V4BX
2777 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2778 i
, strsec
+ sh
->sh_name
, rel
->r_offset
);
2781 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
2782 /* offset the relocation offset */
2783 rel
->r_offset
+= offseti
;
2784 #ifdef TCC_TARGET_ARM
2785 /* Jumps and branches from a Thumb code to a PLT entry need
2786 special handling since PLT entries are ARM code.
2787 Unconditional bl instructions referencing PLT entries are
2788 handled by converting these instructions into blx
2789 instructions. Other case of instructions referencing a PLT
2790 entry require to add a Thumb stub before the PLT entry to
2791 switch to ARM mode. We set bit plt_thumb_stub of the
2792 attribute of a symbol to indicate such a case. */
2793 if (type
== R_ARM_THM_JUMP24
)
2794 alloc_sym_attr(s1
, sym_index
)->plt_thumb_stub
= 1;
2807 tcc_free(old_to_new_syms
);
2814 typedef struct ArchiveHeader
{
2815 char ar_name
[16]; /* name of this member */
2816 char ar_date
[12]; /* file mtime */
2817 char ar_uid
[6]; /* owner uid; printed as decimal */
2818 char ar_gid
[6]; /* owner gid; printed as decimal */
2819 char ar_mode
[8]; /* file mode, printed as octal */
2820 char ar_size
[10]; /* file size, printed as decimal */
2821 char ar_fmag
[2]; /* should contain ARFMAG */
2824 static int get_be32(const uint8_t *b
)
2826 return b
[3] | (b
[2] << 8) | (b
[1] << 16) | (b
[0] << 24);
2829 /* load only the objects which resolve undefined symbols */
2830 static int tcc_load_alacarte(TCCState
*s1
, int fd
, int size
)
2832 int i
, bound
, nsyms
, sym_index
, off
, ret
;
2834 const char *ar_names
, *p
;
2835 const uint8_t *ar_index
;
2838 data
= tcc_malloc(size
);
2839 if (read(fd
, data
, size
) != size
)
2841 nsyms
= get_be32(data
);
2842 ar_index
= data
+ 4;
2843 ar_names
= (char *) ar_index
+ nsyms
* 4;
2847 for(p
= ar_names
, i
= 0; i
< nsyms
; i
++, p
+= strlen(p
)+1) {
2848 sym_index
= find_elf_sym(symtab_section
, p
);
2850 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
2851 if(sym
->st_shndx
== SHN_UNDEF
) {
2852 off
= get_be32(ar_index
+ i
* 4) + sizeof(ArchiveHeader
);
2854 lseek(fd
, off
, SEEK_SET
);
2855 if(tcc_load_object_file(s1
, fd
, off
) < 0) {
2870 /* load a '.a' file */
2871 ST_FUNC
int tcc_load_archive(TCCState
*s1
, int fd
)
2878 unsigned long file_offset
;
2880 /* skip magic which was already checked */
2881 read(fd
, magic
, sizeof(magic
));
2884 len
= read(fd
, &hdr
, sizeof(hdr
));
2887 if (len
!= sizeof(hdr
)) {
2888 tcc_error_noabort("invalid archive");
2891 memcpy(ar_size
, hdr
.ar_size
, sizeof(hdr
.ar_size
));
2892 ar_size
[sizeof(hdr
.ar_size
)] = '\0';
2893 size
= strtol(ar_size
, NULL
, 0);
2894 memcpy(ar_name
, hdr
.ar_name
, sizeof(hdr
.ar_name
));
2895 for(i
= sizeof(hdr
.ar_name
) - 1; i
>= 0; i
--) {
2896 if (ar_name
[i
] != ' ')
2899 ar_name
[i
+ 1] = '\0';
2900 file_offset
= lseek(fd
, 0, SEEK_CUR
);
2902 size
= (size
+ 1) & ~1;
2903 if (!strcmp(ar_name
, "/")) {
2904 /* coff symbol table : we handle it */
2905 if(s1
->alacarte_link
)
2906 return tcc_load_alacarte(s1
, fd
, size
);
2907 } else if (!strcmp(ar_name
, "//") ||
2908 !strcmp(ar_name
, "__.SYMDEF") ||
2909 !strcmp(ar_name
, "__.SYMDEF/") ||
2910 !strcmp(ar_name
, "ARFILENAMES/")) {
2911 /* skip symbol table or archive names */
2913 if (tcc_load_object_file(s1
, fd
, file_offset
) < 0)
2916 lseek(fd
, file_offset
+ size
, SEEK_SET
);
2921 #ifndef TCC_TARGET_PE
2922 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2923 is referenced by the user (so it should be added as DT_NEEDED in
2924 the generated ELF file) */
2925 ST_FUNC
int tcc_load_dll(TCCState
*s1
, int fd
, const char *filename
, int level
)
2928 ElfW(Shdr
) *shdr
, *sh
, *sh1
;
2929 int i
, j
, nb_syms
, nb_dts
, sym_bind
, ret
;
2930 ElfW(Sym
) *sym
, *dynsym
;
2931 ElfW(Dyn
) *dt
, *dynamic
;
2932 unsigned char *dynstr
;
2933 const char *name
, *soname
;
2934 DLLReference
*dllref
;
2936 read(fd
, &ehdr
, sizeof(ehdr
));
2938 /* test CPU specific stuff */
2939 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2940 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2941 tcc_error_noabort("bad architecture");
2946 shdr
= load_data(fd
, ehdr
.e_shoff
, sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2948 /* load dynamic section and dynamic symbols */
2952 dynsym
= NULL
; /* avoid warning */
2953 dynstr
= NULL
; /* avoid warning */
2954 for(i
= 0, sh
= shdr
; i
< ehdr
.e_shnum
; i
++, sh
++) {
2955 switch(sh
->sh_type
) {
2957 nb_dts
= sh
->sh_size
/ sizeof(ElfW(Dyn
));
2958 dynamic
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2961 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2962 dynsym
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2963 sh1
= &shdr
[sh
->sh_link
];
2964 dynstr
= load_data(fd
, sh1
->sh_offset
, sh1
->sh_size
);
2971 /* compute the real library name */
2972 soname
= tcc_basename(filename
);
2974 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2975 if (dt
->d_tag
== DT_SONAME
) {
2976 soname
= (char *) dynstr
+ dt
->d_un
.d_val
;
2980 /* if the dll is already loaded, do not load it */
2981 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2982 dllref
= s1
->loaded_dlls
[i
];
2983 if (!strcmp(soname
, dllref
->name
)) {
2984 /* but update level if needed */
2985 if (level
< dllref
->level
)
2986 dllref
->level
= level
;
2992 /* add the dll and its level */
2993 dllref
= tcc_mallocz(sizeof(DLLReference
) + strlen(soname
));
2994 dllref
->level
= level
;
2995 strcpy(dllref
->name
, soname
);
2996 dynarray_add((void ***)&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
, dllref
);
2998 /* add dynamic symbols in dynsym_section */
2999 for(i
= 1, sym
= dynsym
+ 1; i
< nb_syms
; i
++, sym
++) {
3000 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
3001 if (sym_bind
== STB_LOCAL
)
3003 name
= (char *) dynstr
+ sym
->st_name
;
3004 add_elf_sym(s1
->dynsymtab_section
, sym
->st_value
, sym
->st_size
,
3005 sym
->st_info
, sym
->st_other
, sym
->st_shndx
, name
);
3008 /* load all referenced DLLs */
3009 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
3012 name
= (char *) dynstr
+ dt
->d_un
.d_val
;
3013 for(j
= 0; j
< s1
->nb_loaded_dlls
; j
++) {
3014 dllref
= s1
->loaded_dlls
[j
];
3015 if (!strcmp(name
, dllref
->name
))
3016 goto already_loaded
;
3018 if (tcc_add_dll(s1
, name
, AFF_REFERENCED_DLL
) < 0) {
3019 tcc_error_noabort("referenced dll '%s' not found", name
);
3036 #define LD_TOK_NAME 256
3037 #define LD_TOK_EOF (-1)
3039 /* return next ld script token */
3040 static int ld_next(TCCState
*s1
, char *name
, int name_size
)
3058 file
->buf_ptr
= parse_comment(file
->buf_ptr
);
3059 ch
= file
->buf_ptr
[0];
3067 /* case 'a' ... 'z': */
3094 /* case 'A' ... 'z': */
3129 if (!((ch
>= 'a' && ch
<= 'z') ||
3130 (ch
>= 'A' && ch
<= 'Z') ||
3131 (ch
>= '0' && ch
<= '9') ||
3132 strchr("/.-_+=$:\\,~", ch
)))
3134 if ((q
- name
) < name_size
- 1) {
3153 static int ld_add_file(TCCState
*s1
, const char filename
[])
3157 ret
= tcc_add_file_internal(s1
, filename
, 0);
3159 ret
= tcc_add_dll(s1
, filename
, 0);
3163 static inline int new_undef_syms(void)
3166 ret
= new_undef_sym
;
3171 static int ld_add_file_list(TCCState
*s1
, const char *cmd
, int as_needed
)
3173 char filename
[1024], libname
[1024];
3174 int t
, group
, nblibs
= 0, ret
= 0;
3177 group
= !strcmp(cmd
, "GROUP");
3180 t
= ld_next(s1
, filename
, sizeof(filename
));
3183 t
= ld_next(s1
, filename
, sizeof(filename
));
3186 if (t
== LD_TOK_EOF
) {
3187 tcc_error_noabort("unexpected end of file");
3189 goto lib_parse_error
;
3190 } else if (t
== ')') {
3192 } else if (t
== '-') {
3193 t
= ld_next(s1
, filename
, sizeof(filename
));
3194 if ((t
!= LD_TOK_NAME
) || (filename
[0] != 'l')) {
3195 tcc_error_noabort("library name expected");
3197 goto lib_parse_error
;
3199 pstrcpy(libname
, sizeof libname
, &filename
[1]);
3200 if (s1
->static_link
) {
3201 snprintf(filename
, sizeof filename
, "lib%s.a", libname
);
3203 snprintf(filename
, sizeof filename
, "lib%s.so", libname
);
3205 } else if (t
!= LD_TOK_NAME
) {
3206 tcc_error_noabort("filename expected");
3208 goto lib_parse_error
;
3210 if (!strcmp(filename
, "AS_NEEDED")) {
3211 ret
= ld_add_file_list(s1
, cmd
, 1);
3213 goto lib_parse_error
;
3215 /* TODO: Implement AS_NEEDED support. Ignore it for now */
3217 ret
= ld_add_file(s1
, filename
);
3219 goto lib_parse_error
;
3221 /* Add the filename *and* the libname to avoid future conversions */
3222 dynarray_add((void ***) &libs
, &nblibs
, tcc_strdup(filename
));
3223 if (libname
[0] != '\0')
3224 dynarray_add((void ***) &libs
, &nblibs
, tcc_strdup(libname
));
3228 t
= ld_next(s1
, filename
, sizeof(filename
));
3230 t
= ld_next(s1
, filename
, sizeof(filename
));
3233 if (group
&& !as_needed
) {
3234 while (new_undef_syms()) {
3237 for (i
= 0; i
< nblibs
; i
++)
3238 ld_add_file(s1
, libs
[i
]);
3242 dynarray_reset(&libs
, &nblibs
);
3246 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3248 ST_FUNC
int tcc_load_ldscript(TCCState
*s1
)
3251 char filename
[1024];
3254 ch
= file
->buf_ptr
[0];
3257 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3258 if (t
== LD_TOK_EOF
)
3260 else if (t
!= LD_TOK_NAME
)
3262 if (!strcmp(cmd
, "INPUT") ||
3263 !strcmp(cmd
, "GROUP")) {
3264 ret
= ld_add_file_list(s1
, cmd
, 0);
3267 } else if (!strcmp(cmd
, "OUTPUT_FORMAT") ||
3268 !strcmp(cmd
, "TARGET")) {
3269 /* ignore some commands */
3270 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3274 t
= ld_next(s1
, filename
, sizeof(filename
));
3275 if (t
== LD_TOK_EOF
) {
3276 tcc_error_noabort("unexpected end of file");
3278 } else if (t
== ')') {
3288 #endif /* !TCC_TARGET_PE */