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 /* XXX: avoid static variable */
27 static int new_undef_sym
= 0; /* Is there a new undefined sym since last new_undef_sym() */
29 ST_FUNC
int put_elf_str(Section
*s
, const char *sym
)
34 len
= strlen(sym
) + 1;
35 offset
= s
->data_offset
;
36 ptr
= section_ptr_add(s
, len
);
37 memcpy(ptr
, sym
, len
);
41 /* elf symbol hashing function */
42 static unsigned long elf_hash(const unsigned char *name
)
44 unsigned long h
= 0, g
;
47 h
= (h
<< 4) + *name
++;
56 /* rebuild hash table of section s */
57 /* NOTE: we do factorize the hash table code to go faster */
58 static void rebuild_hash(Section
*s
, unsigned int nb_buckets
)
61 int *ptr
, *hash
, nb_syms
, sym_index
, h
;
62 unsigned char *strtab
;
64 strtab
= s
->link
->data
;
65 nb_syms
= s
->data_offset
/ sizeof(ElfW(Sym
));
67 s
->hash
->data_offset
= 0;
68 ptr
= section_ptr_add(s
->hash
, (2 + nb_buckets
+ nb_syms
) * sizeof(int));
73 memset(hash
, 0, (nb_buckets
+ 1) * sizeof(int));
74 ptr
+= nb_buckets
+ 1;
76 sym
= (ElfW(Sym
) *)s
->data
+ 1;
77 for(sym_index
= 1; sym_index
< nb_syms
; sym_index
++) {
78 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
79 h
= elf_hash(strtab
+ sym
->st_name
) % nb_buckets
;
90 /* return the symbol number */
91 ST_FUNC
int put_elf_sym(Section
*s
, addr_t value
, unsigned long size
,
92 int info
, int other
, int shndx
, const char *name
)
94 int name_offset
, sym_index
;
99 sym
= section_ptr_add(s
, sizeof(ElfW(Sym
)));
101 name_offset
= put_elf_str(s
->link
, name
);
104 /* XXX: endianness */
105 sym
->st_name
= name_offset
;
106 sym
->st_value
= value
;
109 sym
->st_other
= other
;
110 sym
->st_shndx
= shndx
;
111 sym_index
= sym
- (ElfW(Sym
) *)s
->data
;
115 ptr
= section_ptr_add(hs
, sizeof(int));
116 base
= (int *)hs
->data
;
117 /* only add global or weak symbols */
118 if (ELFW(ST_BIND
)(info
) != STB_LOCAL
) {
119 /* add another hashing entry */
121 h
= elf_hash((unsigned char *) name
) % nbuckets
;
123 base
[2 + h
] = sym_index
;
125 /* we resize the hash table */
126 hs
->nb_hashed_syms
++;
127 if (hs
->nb_hashed_syms
> 2 * nbuckets
) {
128 rebuild_hash(s
, 2 * nbuckets
);
138 /* find global ELF symbol 'name' and return its index. Return 0 if not
140 ST_FUNC
int find_elf_sym(Section
*s
, const char *name
)
144 int nbuckets
, sym_index
, h
;
150 nbuckets
= ((int *)hs
->data
)[0];
151 h
= elf_hash((unsigned char *) name
) % nbuckets
;
152 sym_index
= ((int *)hs
->data
)[2 + h
];
153 while (sym_index
!= 0) {
154 sym
= &((ElfW(Sym
) *)s
->data
)[sym_index
];
155 name1
= (char *) s
->link
->data
+ sym
->st_name
;
156 if (!strcmp(name
, name1
))
158 sym_index
= ((int *)hs
->data
)[2 + nbuckets
+ sym_index
];
163 /* return elf symbol value, signal error if 'err' is nonzero */
164 ST_FUNC addr_t
get_elf_sym_addr(TCCState
*s
, const char *name
, int err
)
169 sym_index
= find_elf_sym(s
->symtab
, name
);
170 sym
= &((ElfW(Sym
) *)s
->symtab
->data
)[sym_index
];
171 if (!sym_index
|| sym
->st_shndx
== SHN_UNDEF
) {
173 tcc_error("%s not defined", name
);
176 return sym
->st_value
;
179 /* return elf symbol value */
180 LIBTCCAPI
void *tcc_get_symbol(TCCState
*s
, const char *name
)
182 return (void*)(uintptr_t)get_elf_sym_addr(s
, name
, 0);
185 #if defined TCC_IS_NATIVE || defined TCC_TARGET_PE
186 /* return elf symbol value or error */
187 ST_FUNC
void* tcc_get_symbol_err(TCCState
*s
, const char *name
)
189 return (void*)(uintptr_t)get_elf_sym_addr(s
, name
, 1);
193 /* add an elf symbol : check if it is already defined and patch
194 it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
195 ST_FUNC
int add_elf_sym(Section
*s
, addr_t value
, unsigned long size
,
196 int info
, int other
, int sh_num
, const char *name
)
199 int sym_bind
, sym_index
, sym_type
, esym_bind
;
200 unsigned char sym_vis
, esym_vis
, new_vis
;
202 sym_bind
= ELFW(ST_BIND
)(info
);
203 sym_type
= ELFW(ST_TYPE
)(info
);
204 sym_vis
= ELFW(ST_VISIBILITY
)(other
);
206 if (sym_bind
!= STB_LOCAL
) {
207 /* we search global or weak symbols */
208 sym_index
= find_elf_sym(s
, name
);
211 esym
= &((ElfW(Sym
) *)s
->data
)[sym_index
];
212 if (esym
->st_shndx
!= SHN_UNDEF
) {
213 esym_bind
= ELFW(ST_BIND
)(esym
->st_info
);
214 /* propagate the most constraining visibility */
215 /* STV_DEFAULT(0)<STV_PROTECTED(3)<STV_HIDDEN(2)<STV_INTERNAL(1) */
216 esym_vis
= ELFW(ST_VISIBILITY
)(esym
->st_other
);
217 if (esym_vis
== STV_DEFAULT
) {
219 } else if (sym_vis
== STV_DEFAULT
) {
222 new_vis
= (esym_vis
< sym_vis
) ? esym_vis
: sym_vis
;
224 esym
->st_other
= (esym
->st_other
& ~ELFW(ST_VISIBILITY
)(-1))
226 other
= esym
->st_other
; /* in case we have to patch esym */
227 if (sh_num
== SHN_UNDEF
) {
228 /* ignore adding of undefined symbol if the
229 corresponding symbol is already defined */
230 } else if (sym_bind
== STB_GLOBAL
&& esym_bind
== STB_WEAK
) {
231 /* global overrides weak, so patch */
233 } else if (sym_bind
== STB_WEAK
&& esym_bind
== STB_GLOBAL
) {
234 /* weak is ignored if already global */
235 } else if (sym_bind
== STB_WEAK
&& esym_bind
== STB_WEAK
) {
236 /* keep first-found weak definition, ignore subsequents */
237 } else if (sym_vis
== STV_HIDDEN
|| sym_vis
== STV_INTERNAL
) {
238 /* ignore hidden symbols after */
239 } else if (esym
->st_shndx
== SHN_COMMON
240 && (sh_num
< SHN_LORESERVE
|| sh_num
== SHN_COMMON
)) {
241 /* gr: Happens with 'tcc ... -static tcctest.c' on e.g. Ubuntu 6.01
242 No idea if this is the correct solution ... */
244 } else if (s
== tcc_state
->dynsymtab_section
) {
245 /* we accept that two DLL define the same symbol */
248 printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",
249 sym_bind
, sh_num
, new_vis
, esym_bind
, esym
->st_shndx
, esym_vis
);
251 tcc_error_noabort("'%s' defined twice", name
);
255 esym
->st_info
= ELFW(ST_INFO
)(sym_bind
, sym_type
);
256 esym
->st_shndx
= sh_num
;
258 esym
->st_value
= value
;
259 esym
->st_size
= size
;
260 esym
->st_other
= other
;
264 sym_index
= put_elf_sym(s
, value
, size
,
265 ELFW(ST_INFO
)(sym_bind
, sym_type
), other
,
272 ST_FUNC
void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
273 int type
, int symbol
)
281 /* if no relocation section, create it */
282 snprintf(buf
, sizeof(buf
), REL_SECTION_FMT
, s
->name
);
283 /* if the symtab is allocated, then we consider the relocation
285 sr
= new_section(tcc_state
, buf
, SHT_RELX
, symtab
->sh_flags
);
286 sr
->sh_entsize
= sizeof(ElfW_Rel
);
288 sr
->sh_info
= s
->sh_num
;
291 rel
= section_ptr_add(sr
, sizeof(ElfW_Rel
));
292 rel
->r_offset
= offset
;
293 rel
->r_info
= ELFW(R_INFO
)(symbol
, type
);
294 #ifdef TCC_TARGET_X86_64
299 /* put stab debug information */
301 ST_FUNC
void put_stabs(const char *str
, int type
, int other
, int desc
,
306 sym
= section_ptr_add(stab_section
, sizeof(Stab_Sym
));
308 sym
->n_strx
= put_elf_str(stabstr_section
, str
);
313 sym
->n_other
= other
;
315 sym
->n_value
= value
;
318 ST_FUNC
void put_stabs_r(const char *str
, int type
, int other
, int desc
,
319 unsigned long value
, Section
*sec
, int sym_index
)
321 put_stabs(str
, type
, other
, desc
, value
);
322 put_elf_reloc(symtab_section
, stab_section
,
323 stab_section
->data_offset
- sizeof(unsigned int),
324 R_DATA_32
, sym_index
);
327 ST_FUNC
void put_stabn(int type
, int other
, int desc
, int value
)
329 put_stabs(NULL
, type
, other
, desc
, value
);
332 ST_FUNC
void put_stabd(int type
, int other
, int desc
)
334 put_stabs(NULL
, type
, other
, desc
, 0);
337 /* Browse each elem of type <type> in section <sec> starting at elem <startoff>
338 using variable <elem> */
339 #define for_each_elem(sec, startoff, elem, type) \
340 for (elem = (type *) sec->data + startoff; \
341 elem < (type *) (sec->data + sec->data_offset); elem++)
343 /* In an ELF file symbol table, the local symbols must appear below
344 the global and weak ones. Since TCC cannot sort it while generating
345 the code, we must do it after. All the relocation tables are also
346 modified to take into account the symbol table sorting */
347 static void sort_syms(TCCState
*s1
, Section
*s
)
349 int *old_to_new_syms
;
357 nb_syms
= s
->data_offset
/ sizeof(ElfW(Sym
));
358 new_syms
= tcc_malloc(nb_syms
* sizeof(ElfW(Sym
)));
359 old_to_new_syms
= tcc_malloc(nb_syms
* sizeof(int));
361 /* first pass for local symbols */
362 p
= (ElfW(Sym
) *)s
->data
;
364 for(i
= 0; i
< nb_syms
; i
++) {
365 if (ELFW(ST_BIND
)(p
->st_info
) == STB_LOCAL
) {
366 old_to_new_syms
[i
] = q
- new_syms
;
371 /* save the number of local symbols in section header */
372 s
->sh_info
= q
- new_syms
;
374 /* then second pass for non local symbols */
375 p
= (ElfW(Sym
) *)s
->data
;
376 for(i
= 0; i
< nb_syms
; i
++) {
377 if (ELFW(ST_BIND
)(p
->st_info
) != STB_LOCAL
) {
378 old_to_new_syms
[i
] = q
- new_syms
;
384 /* we copy the new symbols to the old */
385 memcpy(s
->data
, new_syms
, nb_syms
* sizeof(ElfW(Sym
)));
388 /* now we modify all the relocations */
389 for(i
= 1; i
< s1
->nb_sections
; i
++) {
390 sr
= s1
->sections
[i
];
391 if (sr
->sh_type
== SHT_RELX
&& sr
->link
== s
) {
392 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
393 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
394 type
= ELFW(R_TYPE
)(rel
->r_info
);
395 sym_index
= old_to_new_syms
[sym_index
];
396 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
401 tcc_free(old_to_new_syms
);
404 /* relocate common symbols in the .bss section */
405 ST_FUNC
void relocate_common_syms(void)
408 unsigned long offset
, align
;
410 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
411 if (sym
->st_shndx
== SHN_COMMON
) {
413 align
= sym
->st_value
;
414 offset
= bss_section
->data_offset
;
415 offset
= (offset
+ align
- 1) & -align
;
416 sym
->st_value
= offset
;
417 sym
->st_shndx
= bss_section
->sh_num
;
418 offset
+= sym
->st_size
;
419 bss_section
->data_offset
= offset
;
424 /* relocate symbol table, resolve undefined symbols if do_resolve is
425 true and output error if undefined symbol. */
426 ST_FUNC
void relocate_syms(TCCState
*s1
, int do_resolve
)
428 ElfW(Sym
) *sym
, *esym
;
429 int sym_bind
, sh_num
, sym_index
;
432 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
433 sh_num
= sym
->st_shndx
;
434 if (sh_num
== SHN_UNDEF
) {
435 name
= (char *) strtab_section
->data
+ sym
->st_name
;
436 /* Use ld.so to resolve symbol for us (for tcc -run) */
438 #if defined TCC_IS_NATIVE && !defined _WIN32
440 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
441 addr
= resolve_sym(s1
, name
);
443 sym
->st_value
= (addr_t
)addr
;
445 printf ("relocate_sym: %s -> 0x%x\n", name
, sym
->st_value
);
450 } else if (s1
->dynsym
) {
451 /* if dynamic symbol exist, then use it */
452 sym_index
= find_elf_sym(s1
->dynsym
, name
);
454 esym
= &((ElfW(Sym
) *)s1
->dynsym
->data
)[sym_index
];
455 sym
->st_value
= esym
->st_value
;
459 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
461 if (!strcmp(name
, "_fp_hw"))
463 /* only weak symbols are accepted to be undefined. Their
465 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
466 if (sym_bind
== STB_WEAK
) {
469 tcc_error_noabort("undefined symbol '%s'", name
);
471 } else if (sh_num
< SHN_LORESERVE
) {
472 /* add section base */
473 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
479 /* relocate a given section (CPU dependent) by applying the relocations
480 in the associated relocation section */
481 ST_FUNC
void relocate_section(TCCState
*s1
, Section
*s
)
483 Section
*sr
= s
->reloc
;
489 #if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
490 ElfW_Rel
*qrel
= (ElfW_Rel
*) sr
->data
; /* ptr to next reloc entry reused */
494 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
495 ptr
= s
->data
+ rel
->r_offset
;
497 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
498 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
500 #ifdef TCC_TARGET_X86_64
501 val
+= rel
->r_addend
;
503 type
= ELFW(R_TYPE
)(rel
->r_info
);
504 addr
= s
->sh_addr
+ rel
->r_offset
;
508 #if defined(TCC_TARGET_I386)
510 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
511 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
512 qrel
->r_offset
= rel
->r_offset
;
514 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_386_32
);
518 qrel
->r_info
= ELFW(R_INFO
)(0, R_386_RELATIVE
);
525 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
527 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
529 qrel
->r_offset
= rel
->r_offset
;
530 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_386_PC32
);
535 *(int *)ptr
+= val
- addr
;
538 *(int *)ptr
+= val
- addr
;
545 *(int *)ptr
+= s1
->got
->sh_addr
- addr
;
548 *(int *)ptr
+= val
- s1
->got
->sh_addr
;
551 /* we load the got offset */
552 *(int *)ptr
+= s1
->sym_attrs
[sym_index
].got_offset
;
555 if (s1
->output_format
!= TCC_OUTPUT_FORMAT_BINARY
) {
557 tcc_error("can only produce 16-bit binary files");
559 *(short *)ptr
+= val
;
562 if (s1
->output_format
!= TCC_OUTPUT_FORMAT_BINARY
)
564 *(short *)ptr
+= val
- addr
;
566 #elif defined(TCC_TARGET_ARM)
572 int x
, is_thumb
, is_call
, h
, blx_avail
, is_bl
, th_ko
;
573 x
= (*(int *) ptr
) & 0xffffff;
574 if (sym
->st_shndx
== SHN_UNDEF
)
575 val
= s1
->plt
->sh_addr
;
577 printf ("reloc %d: x=0x%x val=0x%x ", type
, x
, val
);
579 (*(int *)ptr
) &= 0xff000000;
583 blx_avail
= (TCC_ARM_VERSION
>= 5);
585 is_bl
= (*(unsigned *) ptr
) >> 24 == 0xeb;
586 is_call
= (type
== R_ARM_CALL
|| (type
== R_ARM_PC24
&& is_bl
));
589 printf (" newx=0x%x name=%s\n", x
,
590 (char *) symtab_section
->link
->data
+ sym
->st_name
);
593 th_ko
= (x
& 3) && (!blx_avail
|| !is_call
);
594 if (th_ko
|| x
>= 0x2000000 || x
< -0x2000000)
595 tcc_error("can't relocate value at %x,%d",addr
, type
);
598 /* Only reached if blx is avail and it is a call */
601 (*(int *)ptr
) = 0xfa << 24; /* bl -> blx */
606 /* Since these relocations only concern Thumb-2 and blx instruction was
607 introduced before Thumb-2, we can assume blx is available and not
610 case R_ARM_THM_JUMP24
:
612 int x
, hi
, lo
, s
, j1
, j2
, i1
, i2
, imm10
, imm11
;
613 int to_thumb
, is_call
, to_plt
, blx_bit
= 1 << 12;
617 if (sym
->st_shndx
== SHN_UNDEF
&&
618 ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
)
621 /* Get initial offset */
622 hi
= (*(uint16_t *)ptr
);
623 lo
= (*(uint16_t *)(ptr
+2));
631 x
= (s
<< 24) | (i1
<< 23) | (i2
<< 22) |
632 (imm10
<< 12) | (imm11
<< 1);
636 /* Relocation infos */
639 to_plt
= (val
>= plt
->sh_addr
) &&
640 (val
< plt
->sh_addr
+ plt
->data_offset
);
641 is_call
= (type
== R_ARM_THM_PC22
);
643 /* Compute final offset */
644 if (to_plt
&& !is_call
) /* Point to 1st instr of Thumb stub */
647 if (!to_thumb
&& is_call
) {
648 blx_bit
= 0; /* bl -> blx */
649 x
= (x
+ 3) & -4; /* Compute offset from aligned PC */
652 /* Check that relocation is possible
653 * offset must not be out of range
654 * if target is to be entered in arm mode:
656 - instruction must be a call (bl) or a jump to PLT */
657 if (!to_thumb
|| x
>= 0x1000000 || x
< -0x1000000)
658 if (to_thumb
|| (val
& 2) || (!is_call
&& !to_plt
))
659 tcc_error("can't relocate value at %x,%d",addr
, type
);
661 /* Compute and store final offset */
667 imm10
= (x
>> 12) & 0x3ff;
668 imm11
= (x
>> 1) & 0x7ff;
669 (*(uint16_t *)ptr
) = (uint16_t) ((hi
& 0xf800) |
671 (*(uint16_t *)(ptr
+2)) = (uint16_t) ((lo
& 0xc000) |
672 (j1
<< 13) | blx_bit
| (j2
<< 11) |
677 case R_ARM_MOVW_ABS_NC
:
680 if (type
== R_ARM_MOVT_ABS
)
683 imm4
= (val
>> 12) & 0xf;
684 x
= (imm4
<< 16) | imm12
;
685 if (type
== R_ARM_THM_MOVT_ABS
)
691 case R_ARM_THM_MOVT_ABS
:
692 case R_ARM_THM_MOVW_ABS_NC
:
694 int x
, i
, imm4
, imm3
, imm8
;
695 if (type
== R_ARM_THM_MOVT_ABS
)
698 imm3
= (val
>> 8) & 0x7;
700 imm4
= (val
>> 12) & 0xf;
701 x
= (imm3
<< 28) | (imm8
<< 16) | (i
<< 10) | imm4
;
702 if (type
== R_ARM_THM_MOVT_ABS
)
711 x
= (*(int *)ptr
) & 0x7fffffff;
712 (*(int *)ptr
) &= 0x80000000;
715 if((x
^(x
>>1))&0x40000000)
716 tcc_error("can't relocate value at %x,%d",addr
, type
);
717 (*(int *)ptr
) |= x
& 0x7fffffff;
723 *(int *)ptr
+= val
- addr
;
726 *(int *)ptr
+= s1
->got
->sh_addr
- addr
;
729 *(int *)ptr
+= val
- s1
->got
->sh_addr
;
732 /* we load the got offset */
733 *(int *)ptr
+= s1
->sym_attrs
[sym_index
].got_offset
;
738 /* trade Thumb support for ARMv4 support */
739 if ((0x0ffffff0 & *(int*)ptr
) == 0x012FFF10)
740 *(int*)ptr
^= 0xE12FFF10 ^ 0xE1A0F000; /* BX Rm -> MOV PC, Rm */
743 case R_ARM_JUMP_SLOT
:
744 *(addr_t
*)ptr
= val
;
747 /* Nothing to do. Normally used to indicate a dependency
748 on a certain symbol (like for exception handling under EABI). */
751 fprintf(stderr
,"FIXME: handle reloc type %x at %x [%p] to %x\n",
752 type
, (unsigned)addr
, ptr
, (unsigned)val
);
754 #elif defined(TCC_TARGET_C67)
762 /* put the low 16 bits of the absolute address
763 add to what is already there */
765 orig
= ((*(int *)(ptr
)) >> 7) & 0xffff;
766 orig
|= (((*(int *)(ptr
+4)) >> 7) & 0xffff) << 16;
768 /* patch both at once - assumes always in pairs Low - High */
770 *(int *) ptr
= (*(int *) ptr
& (~(0xffff << 7)) ) | (((val
+orig
) & 0xffff) << 7);
771 *(int *)(ptr
+4) = (*(int *)(ptr
+4) & (~(0xffff << 7)) ) | ((((val
+orig
)>>16) & 0xffff) << 7);
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_X86_64)
782 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
783 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
784 qrel
->r_offset
= rel
->r_offset
;
786 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_X86_64_64
);
787 qrel
->r_addend
= rel
->r_addend
;
791 qrel
->r_info
= ELFW(R_INFO
)(0, R_X86_64_RELATIVE
);
792 qrel
->r_addend
= *(long long *)ptr
+ val
;
796 *(long long *)ptr
+= val
;
800 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
801 /* XXX: this logic may depend on TCC's codegen
802 now TCC uses R_X86_64_32 even for a 64bit pointer */
803 qrel
->r_info
= ELFW(R_INFO
)(0, R_X86_64_RELATIVE
);
804 qrel
->r_addend
= *(int *)ptr
+ val
;
811 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
813 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
815 qrel
->r_offset
= rel
->r_offset
;
816 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_X86_64_PC32
);
817 qrel
->r_addend
= *(int *)ptr
;
825 /* We've put the PLT slot offset into r_addend when generating
826 it, and that's what we must use as relocation value (adjusted
827 by section offset of course). */
828 val
= s1
->plt
->sh_addr
+ rel
->r_addend
;
834 diff
= (long long)val
- addr
;
835 if (diff
<= -2147483647 || diff
> 2147483647) {
836 tcc_error("internal error: relocation failed");
841 case R_X86_64_GLOB_DAT
:
842 case R_X86_64_JUMP_SLOT
:
843 /* They don't need addend */
844 *(addr_t
*)ptr
= val
- rel
->r_addend
;
846 case R_X86_64_GOTPCREL
:
847 *(int *)ptr
+= (s1
->got
->sh_addr
- addr
+
848 s1
->sym_attrs
[sym_index
].got_offset
- 4);
850 case R_X86_64_GOTTPOFF
:
851 *(int *)ptr
+= val
- s1
->got
->sh_addr
;
854 /* we load the got offset */
855 *(int *)ptr
+= s1
->sym_attrs
[sym_index
].got_offset
;
858 #error unsupported processor
862 /* if the relocation is allocated, we change its symbol table */
863 if (sr
->sh_flags
& SHF_ALLOC
)
864 sr
->link
= s1
->dynsym
;
867 /* relocate relocation table in 'sr' */
868 static void relocate_rel(TCCState
*s1
, Section
*sr
)
873 s
= s1
->sections
[sr
->sh_info
];
874 for_each_elem(sr
, 0, rel
, ElfW_Rel
)
875 rel
->r_offset
+= s
->sh_addr
;
878 /* count the number of dynamic relocations so that we can reserve
880 static int prepare_dynamic_rel(TCCState
*s1
, Section
*sr
)
883 int sym_index
, esym_index
, type
, count
;
886 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
887 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
888 type
= ELFW(R_TYPE
)(rel
->r_info
);
890 #if defined(TCC_TARGET_I386)
892 #elif defined(TCC_TARGET_X86_64)
899 #if defined(TCC_TARGET_I386)
901 #elif defined(TCC_TARGET_X86_64)
904 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
913 /* allocate the section */
914 sr
->sh_flags
|= SHF_ALLOC
;
915 sr
->sh_size
= count
* sizeof(ElfW_Rel
);
920 static struct sym_attr
*alloc_sym_attr(TCCState
*s1
, int index
)
923 struct sym_attr
*tab
;
925 if (index
>= s1
->nb_sym_attrs
) {
926 /* find immediately bigger power of 2 and reallocate array */
930 tab
= tcc_realloc(s1
->sym_attrs
, n
* sizeof(*s1
->sym_attrs
));
932 memset(s1
->sym_attrs
+ s1
->nb_sym_attrs
, 0,
933 (n
- s1
->nb_sym_attrs
) * sizeof(*s1
->sym_attrs
));
934 s1
->nb_sym_attrs
= n
;
936 return &s1
->sym_attrs
[index
];
939 /* XXX: suppress that */
940 static void put32(unsigned char *p
, uint32_t val
)
948 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_ARM) || \
949 defined(TCC_TARGET_X86_64)
950 static uint32_t get32(unsigned char *p
)
952 return p
[0] | (p
[1] << 8) | (p
[2] << 16) | (p
[3] << 24);
956 static void build_got(TCCState
*s1
)
960 /* if no got, then create it */
961 s1
->got
= new_section(s1
, ".got", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
962 s1
->got
->sh_entsize
= 4;
963 add_elf_sym(symtab_section
, 0, 4, ELFW(ST_INFO
)(STB_GLOBAL
, STT_OBJECT
),
964 0, s1
->got
->sh_num
, "_GLOBAL_OFFSET_TABLE_");
965 ptr
= section_ptr_add(s1
->got
, 3 * PTR_SIZE
);
967 /* keep space for _DYNAMIC pointer, if present */
969 /* two dummy got entries */
973 /* keep space for _DYNAMIC pointer, if present */
976 /* two dummy got entries */
984 /* put a got or plt entry corresponding to a symbol in symtab_section. 'size'
985 and 'info' can be modifed if more precise info comes from the DLL.
986 Returns offset of GOT or PLT slot. */
987 static unsigned long put_got_entry(TCCState
*s1
,
988 int reloc_type
, unsigned long size
, int info
,
991 int index
, need_plt_entry
;
994 unsigned long offset
;
996 struct sym_attr
*symattr
;
1002 #ifdef TCC_TARGET_X86_64
1003 (reloc_type
== R_X86_64_JUMP_SLOT
);
1004 #elif defined(TCC_TARGET_I386)
1005 (reloc_type
== R_386_JMP_SLOT
);
1006 #elif defined(TCC_TARGET_ARM)
1007 (reloc_type
== R_ARM_JUMP_SLOT
);
1012 if (need_plt_entry
&& !s1
->plt
) {
1014 s1
->plt
= new_section(s1
, ".plt", SHT_PROGBITS
,
1015 SHF_ALLOC
| SHF_EXECINSTR
);
1016 s1
->plt
->sh_entsize
= 4;
1019 /* If a got/plt entry already exists for that symbol, no need to add one */
1020 if (sym_index
< s1
->nb_sym_attrs
) {
1021 if (need_plt_entry
&& s1
->sym_attrs
[sym_index
].plt_offset
)
1022 return s1
->sym_attrs
[sym_index
].plt_offset
;
1023 else if (!need_plt_entry
&& s1
->sym_attrs
[sym_index
].got_offset
)
1024 return s1
->sym_attrs
[sym_index
].got_offset
;
1027 symattr
= alloc_sym_attr(s1
, sym_index
);
1029 /* Only store the GOT offset if it's not generated for the PLT entry. */
1030 if (!need_plt_entry
)
1031 symattr
->got_offset
= s1
->got
->data_offset
;
1033 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1034 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1035 offset
= sym
->st_value
;
1036 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
1037 if (need_plt_entry
) {
1041 unsigned long relofs
;
1043 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
1046 /* if we build a DLL, we add a %ebx offset */
1047 if (s1
->output_type
== TCC_OUTPUT_DLL
)
1053 /* add a PLT entry */
1055 if (plt
->data_offset
== 0) {
1056 /* first plt entry */
1057 p
= section_ptr_add(plt
, 16);
1058 p
[0] = 0xff; /* pushl got + PTR_SIZE */
1059 p
[1] = modrm
+ 0x10;
1060 put32(p
+ 2, PTR_SIZE
);
1061 p
[6] = 0xff; /* jmp *(got + PTR_SIZE * 2) */
1063 put32(p
+ 8, PTR_SIZE
* 2);
1066 /* The PLT slot refers to the relocation entry it needs
1067 via offset. The reloc entry is created below, so its
1068 offset is the current data_offset. */
1069 relofs
= s1
->got
->reloc
? s1
->got
->reloc
->data_offset
: 0;
1070 symattr
->plt_offset
= plt
->data_offset
;
1071 p
= section_ptr_add(plt
, 16);
1072 p
[0] = 0xff; /* jmp *(got + x) */
1074 put32(p
+ 2, s1
->got
->data_offset
);
1075 p
[6] = 0x68; /* push $xxx */
1076 #ifdef TCC_TARGET_X86_64
1077 /* On x86-64, the relocation is referred to by _index_. */
1078 put32(p
+ 7, relofs
/ sizeof (ElfW_Rel
));
1080 put32(p
+ 7, relofs
);
1082 p
[11] = 0xe9; /* jmp plt_start */
1083 put32(p
+ 12, -(plt
->data_offset
));
1085 /* If this was an UNDEF symbol set the offset in the
1086 dynsymtab to the PLT slot, so that PC32 relocs to it
1088 if (sym
->st_shndx
== SHN_UNDEF
)
1089 offset
= plt
->data_offset
- 16;
1091 #elif defined(TCC_TARGET_ARM)
1092 if (need_plt_entry
) {
1096 /* if we build a DLL, we add a %ebx offset */
1097 if (s1
->output_type
== TCC_OUTPUT_DLL
)
1098 tcc_error("DLLs unimplemented!");
1100 /* add a PLT entry */
1102 if (plt
->data_offset
== 0) {
1103 /* first plt entry */
1104 p
= section_ptr_add(plt
, 16);
1105 put32(p
, 0xe52de004); /* push {lr} */
1106 put32(p
+4, 0xe59fe010); /* ldr lr, [pc, #16] */
1107 put32(p
+8, 0xe08fe00e); /* add lr, pc, lr */
1108 put32(p
+12, 0xe5bef008); /* ldr pc, [lr, #8]! */
1111 symattr
->plt_offset
= plt
->data_offset
;
1112 if (symattr
->plt_thumb_stub
) {
1113 p
= section_ptr_add(plt
, 20);
1114 put32(p
, 0x4778); /* bx pc */
1115 put32(p
+2, 0x46c0); /* nop */
1118 p
= section_ptr_add(plt
, 16);
1119 put32(p
, 0xe59fc004); /* ldr ip, [pc, #4] ; GOT entry offset */
1120 put32(p
+4, 0xe08fc00c); /* add ip, pc, ip ; addr of GOT entry */
1121 put32(p
+8, 0xe59cf000); /* ldr pc, [ip] ; jump to GOT entry */
1122 put32(p
+12, s1
->got
->data_offset
); /* GOT entry off once patched */
1124 /* the symbol is modified so that it will be relocated to
1126 if (sym
->st_shndx
== SHN_UNDEF
)
1127 offset
= plt
->data_offset
- 16;
1129 #elif defined(TCC_TARGET_C67)
1131 tcc_error("C67 got not implemented");
1134 #error unsupported CPU
1137 /* XXX This might generate multiple syms for name. */
1138 index
= put_elf_sym(s1
->dynsym
, offset
,
1139 size
, info
, 0, sym
->st_shndx
, name
);
1140 /* Create the relocation (it's against the GOT for PLT
1142 put_elf_reloc(s1
->dynsym
, s1
->got
,
1143 s1
->got
->data_offset
,
1146 /* Without .dynsym (i.e. static link or memory output) we
1147 still need relocs against the generated got, so as to fill
1148 the entries with the symbol values (determined later). */
1149 put_elf_reloc(symtab_section
, s1
->got
,
1150 s1
->got
->data_offset
,
1151 reloc_type
, sym_index
);
1153 /* And now create the GOT slot itself. */
1154 ptr
= section_ptr_add(s1
->got
, PTR_SIZE
);
1157 return symattr
->plt_offset
;
1159 return symattr
->got_offset
;
1162 /* build GOT and PLT entries */
1163 ST_FUNC
void build_got_entries(TCCState
*s1
)
1168 int i
, type
, reloc_type
, sym_index
;
1170 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1171 s
= s1
->sections
[i
];
1172 if (s
->sh_type
!= SHT_RELX
)
1174 /* no need to handle got relocations */
1175 if (s
->link
!= symtab_section
)
1177 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1178 type
= ELFW(R_TYPE
)(rel
->r_info
);
1180 #if defined(TCC_TARGET_I386)
1187 if (type
== R_386_GOT32
|| type
== R_386_PLT32
) {
1188 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1189 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1190 /* look at the symbol got offset. If none, then add one */
1191 if (type
== R_386_GOT32
)
1192 reloc_type
= R_386_GLOB_DAT
;
1194 reloc_type
= R_386_JMP_SLOT
;
1195 put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
1199 #elif defined(TCC_TARGET_ARM)
1209 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1210 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1211 if (type
!= R_ARM_GOTOFF
&& type
!= R_ARM_GOTPC
1212 && sym
->st_shndx
== SHN_UNDEF
) {
1214 /* look at the symbol got offset. If none, then add one */
1215 if (type
== R_ARM_GOT32
)
1216 reloc_type
= R_ARM_GLOB_DAT
;
1218 reloc_type
= R_ARM_JUMP_SLOT
;
1219 ofs
= put_got_entry(s1
, reloc_type
, sym
->st_size
,
1220 sym
->st_info
, sym_index
);
1222 printf ("maybegot: %s, %d, %d --> ofs=0x%x\n",
1223 (char *) symtab_section
->link
->data
+ sym
->st_name
,
1224 type
, sym
->st_shndx
, ofs
);
1226 if (type
!= R_ARM_GOT32
) {
1227 addr_t
*ptr
= (addr_t
*)(s1
->sections
[s
->sh_info
]->data
1229 /* x must be signed! */
1230 int x
= *ptr
& 0xffffff;
1236 printf ("insn=0x%x --> 0x%x (x==0x%x)\n", *ptr
,
1237 (*ptr
& 0xff000000) | x
, x
);
1239 *ptr
= (*ptr
& 0xff000000) | x
;
1243 case R_ARM_THM_JUMP24
:
1244 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1245 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1246 /* We are relocating a jump from thumb code to arm code */
1247 if (sym
->st_shndx
!= SHN_UNDEF
&& !(sym
->st_value
& 1)) {
1250 char *name
, buf
[1024];
1251 Section
*text_section
;
1253 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1254 text_section
= s1
->sections
[sym
->st_shndx
];
1255 /* Modify reloc to target a thumb stub to switch to ARM */
1256 snprintf(buf
, sizeof(buf
), "%s_from_thumb", name
);
1257 index
= put_elf_sym(symtab_section
,
1258 text_section
->data_offset
+ 1,
1259 sym
->st_size
, sym
->st_info
, 0,
1260 sym
->st_shndx
, buf
);
1261 rel
->r_info
= ELFW(R_INFO
)(index
, type
);
1262 /* Create a thumb stub fonction to switch to ARM mode */
1263 put_elf_reloc(symtab_section
, text_section
,
1264 text_section
->data_offset
+ 4, R_ARM_JUMP24
,
1266 p
= section_ptr_add(text_section
, 8);
1267 put32(p
, 0x4778); /* bx pc */
1268 put32(p
+2, 0x46c0); /* nop */
1269 put32(p
+4, 0xeafffffe); /* b $sym */
1271 #elif defined(TCC_TARGET_C67)
1278 if (type
== R_C60_GOT32
|| type
== R_C60_PLT32
) {
1279 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1280 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1281 /* look at the symbol got offset. If none, then add one */
1282 if (type
== R_C60_GOT32
)
1283 reloc_type
= R_C60_GLOB_DAT
;
1285 reloc_type
= R_C60_JMP_SLOT
;
1286 put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
1290 #elif defined(TCC_TARGET_X86_64)
1291 case R_X86_64_GOT32
:
1292 case R_X86_64_GOTTPOFF
:
1293 case R_X86_64_GOTPCREL
:
1294 case R_X86_64_PLT32
:
1297 if (type
== R_X86_64_GOT32
|| type
== R_X86_64_GOTPCREL
||
1298 type
== R_X86_64_PLT32
) {
1300 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1301 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1302 /* look at the symbol got offset. If none, then add one */
1303 if (type
== R_X86_64_GOT32
|| type
== R_X86_64_GOTPCREL
)
1304 reloc_type
= R_X86_64_GLOB_DAT
;
1306 reloc_type
= R_X86_64_JUMP_SLOT
;
1307 ofs
= put_got_entry(s1
, reloc_type
, sym
->st_size
,
1308 sym
->st_info
, sym_index
);
1309 if (type
== R_X86_64_PLT32
)
1310 /* We store the place of the generated PLT slot
1312 rel
->r_addend
+= ofs
;
1316 #error unsupported CPU
1325 ST_FUNC Section
*new_symtab(TCCState
*s1
,
1326 const char *symtab_name
, int sh_type
, int sh_flags
,
1327 const char *strtab_name
,
1328 const char *hash_name
, int hash_sh_flags
)
1330 Section
*symtab
, *strtab
, *hash
;
1331 int *ptr
, nb_buckets
;
1333 symtab
= new_section(s1
, symtab_name
, sh_type
, sh_flags
);
1334 symtab
->sh_entsize
= sizeof(ElfW(Sym
));
1335 strtab
= new_section(s1
, strtab_name
, SHT_STRTAB
, sh_flags
);
1336 put_elf_str(strtab
, "");
1337 symtab
->link
= strtab
;
1338 put_elf_sym(symtab
, 0, 0, 0, 0, 0, NULL
);
1342 hash
= new_section(s1
, hash_name
, SHT_HASH
, hash_sh_flags
);
1343 hash
->sh_entsize
= sizeof(int);
1344 symtab
->hash
= hash
;
1345 hash
->link
= symtab
;
1347 ptr
= section_ptr_add(hash
, (2 + nb_buckets
+ 1) * sizeof(int));
1348 ptr
[0] = nb_buckets
;
1350 memset(ptr
+ 2, 0, (nb_buckets
+ 1) * sizeof(int));
1354 /* put dynamic tag */
1355 static void put_dt(Section
*dynamic
, int dt
, addr_t val
)
1358 dyn
= section_ptr_add(dynamic
, sizeof(ElfW(Dyn
)));
1360 dyn
->d_un
.d_val
= val
;
1363 static void add_init_array_defines(TCCState
*s1
, const char *section_name
)
1367 char sym_start
[1024];
1370 snprintf(sym_start
, sizeof(sym_start
), "__%s_start", section_name
+ 1);
1371 snprintf(sym_end
, sizeof(sym_end
), "__%s_end", section_name
+ 1);
1373 s
= find_section(s1
, section_name
);
1378 end_offset
= s
->data_offset
;
1381 add_elf_sym(symtab_section
,
1383 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1384 s
->sh_num
, sym_start
);
1385 add_elf_sym(symtab_section
,
1387 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1388 s
->sh_num
, sym_end
);
1391 ST_FUNC
void tcc_add_bcheck(TCCState
*s1
)
1393 #ifdef CONFIG_TCC_BCHECK
1395 Section
*init_section
;
1396 unsigned char *pinit
;
1399 if (0 == s1
->do_bounds_check
)
1402 /* XXX: add an object file to do that */
1403 ptr
= section_ptr_add(bounds_section
, sizeof(unsigned long));
1405 add_elf_sym(symtab_section
, 0, 0,
1406 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1407 bounds_section
->sh_num
, "__bounds_start");
1408 #ifdef TCC_TARGET_I386
1409 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
) {
1410 /* add 'call __bound_init()' in .init section */
1411 init_section
= find_section(s1
, ".init");
1412 pinit
= section_ptr_add(init_section
, 5);
1414 put32(pinit
+ 1, -4);
1415 sym_index
= find_elf_sym(symtab_section
, "__bound_init");
1416 put_elf_reloc(symtab_section
, init_section
,
1417 init_section
->data_offset
- 4, R_386_PC32
, sym_index
);
1423 static inline int tcc_add_support(TCCState
*s1
, const char *filename
)
1426 snprintf(buf
, sizeof(buf
), "%s/%s", s1
->tcc_lib_path
, filename
);
1427 return tcc_add_file(s1
, buf
);
1430 /* add tcc runtime libraries */
1431 ST_FUNC
void tcc_add_runtime(TCCState
*s1
)
1434 if (!s1
->nostdlib
) {
1435 tcc_add_library(s1
, "c");
1436 #ifdef CONFIG_USE_LIBGCC
1437 if (!s1
->static_link
) {
1438 tcc_add_file(s1
, TCC_LIBGCC
);
1439 tcc_add_support(s1
, "libtcc1.a");
1441 tcc_add_support(s1
, "libtcc1.a");
1443 tcc_add_support(s1
, "libtcc1.a");
1447 /* tcc_add_bcheck tries to relocate a call to __bound_init in _init so
1448 libtcc1.a must be loaded before for __bound_init to be defined and
1449 crtn.o must be loaded after to not finalize _init too early. */
1452 if (!s1
->nostdlib
) {
1453 /* add crt end if not memory output */
1454 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
)
1455 tcc_add_crt(s1
, "crtn.o");
1459 /* add various standard linker symbols (must be done after the
1460 sections are filled (for example after allocating common
1462 ST_FUNC
void tcc_add_linker_symbols(TCCState
*s1
)
1468 add_elf_sym(symtab_section
,
1469 text_section
->data_offset
, 0,
1470 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1471 text_section
->sh_num
, "_etext");
1472 add_elf_sym(symtab_section
,
1473 data_section
->data_offset
, 0,
1474 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1475 data_section
->sh_num
, "_edata");
1476 add_elf_sym(symtab_section
,
1477 bss_section
->data_offset
, 0,
1478 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1479 bss_section
->sh_num
, "_end");
1480 /* horrible new standard ldscript defines */
1481 add_init_array_defines(s1
, ".preinit_array");
1482 add_init_array_defines(s1
, ".init_array");
1483 add_init_array_defines(s1
, ".fini_array");
1485 /* add start and stop symbols for sections whose name can be
1487 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1488 s
= s1
->sections
[i
];
1489 if (s
->sh_type
== SHT_PROGBITS
&&
1490 (s
->sh_flags
& SHF_ALLOC
)) {
1494 /* check if section name can be expressed in C */
1500 if (!isid(ch
) && !isnum(ch
))
1504 snprintf(buf
, sizeof(buf
), "__start_%s", s
->name
);
1505 add_elf_sym(symtab_section
,
1507 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1509 snprintf(buf
, sizeof(buf
), "__stop_%s", s
->name
);
1510 add_elf_sym(symtab_section
,
1512 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1519 static void tcc_output_binary(TCCState
*s1
, FILE *f
,
1520 const int *sec_order
)
1523 int i
, offset
, size
;
1526 for(i
=1;i
<s1
->nb_sections
;i
++) {
1527 s
= s1
->sections
[sec_order
[i
]];
1528 if (s
->sh_type
!= SHT_NOBITS
&&
1529 (s
->sh_flags
& SHF_ALLOC
)) {
1530 while (offset
< s
->sh_offset
) {
1535 fwrite(s
->data
, 1, size
, f
);
1541 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1543 #define EXTRA_RELITEMS 14
1545 /* move the relocation value from .dynsym to .got */
1546 void patch_dynsym_undef(TCCState
*s1
, Section
*s
)
1548 uint32_t *gotd
= (void *)s1
->got
->data
;
1551 gotd
+= 3; /* dummy entries in .got */
1552 /* relocate symbols in .dynsym */
1553 for_each_elem(s
, 1, sym
, ElfW(Sym
)) {
1554 if (sym
->st_shndx
== SHN_UNDEF
) {
1555 *gotd
++ = sym
->st_value
+ 6; /* XXX 6 is magic ? */
1562 #define EXTRA_RELITEMS 9
1564 /* zero plt offsets of weak symbols in .dynsym */
1565 void patch_dynsym_undef(TCCState
*s1
, Section
*s
)
1569 for_each_elem(s
, 1, sym
, ElfW(Sym
))
1570 if (sym
->st_shndx
== SHN_UNDEF
&& ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
)
1575 ST_FUNC
void fill_got_entry(TCCState
*s1
, ElfW_Rel
*rel
)
1577 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1578 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1579 unsigned long offset
;
1581 if (sym_index
>= s1
->nb_sym_attrs
)
1583 offset
= s1
->sym_attrs
[sym_index
].got_offset
;
1584 section_reserve(s1
->got
, offset
+ PTR_SIZE
);
1585 #ifdef TCC_TARGET_X86_64
1586 /* only works for x86-64 */
1587 put32(s1
->got
->data
+ offset
+ 4, sym
->st_value
>> 32);
1589 put32(s1
->got
->data
+ offset
, sym
->st_value
& 0xffffffff);
1592 /* Perform relocation to GOT or PLTÂ entries */
1593 ST_FUNC
void fill_got(TCCState
*s1
)
1599 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1600 s
= s1
->sections
[i
];
1601 if (s
->sh_type
!= SHT_RELX
)
1603 /* no need to handle got relocations */
1604 if (s
->link
!= symtab_section
)
1606 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1607 switch (ELFW(R_TYPE
) (rel
->r_info
)) {
1608 case R_X86_64_GOT32
:
1609 case R_X86_64_GOTPCREL
:
1610 case R_X86_64_PLT32
:
1611 fill_got_entry(s1
, rel
);
1618 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1619 in shared libraries and export non local defined symbols to shared libraries
1620 if -rdynamic switch was given on command line */
1621 static void bind_exe_dynsyms(TCCState
*s1
)
1624 int sym_index
, index
;
1625 ElfW(Sym
) *sym
, *esym
;
1628 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1629 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1630 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1631 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1632 if (sym
->st_shndx
== SHN_UNDEF
) {
1633 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1634 sym_index
= find_elf_sym(s1
->dynsymtab_section
, name
);
1636 esym
= &((ElfW(Sym
) *)s1
->dynsymtab_section
->data
)[sym_index
];
1637 type
= ELFW(ST_TYPE
)(esym
->st_info
);
1638 if ((type
== STT_FUNC
) || (type
== STT_GNU_IFUNC
)) {
1639 /* Indirect functions shall have STT_FUNC type in executable
1640 * dynsym section. Indeed, a dlsym call following a lazy
1641 * resolution would pick the symbol value from the
1642 * executable dynsym entry which would contain the address
1643 * of the function wanted by the caller of dlsym instead of
1644 * the address of the function that would return that
1646 put_got_entry(s1
, R_JMP_SLOT
, esym
->st_size
,
1647 ELFW(ST_INFO
)(STB_GLOBAL
,STT_FUNC
),
1648 sym
- (ElfW(Sym
) *)symtab_section
->data
);
1649 } else if (type
== STT_OBJECT
) {
1650 unsigned long offset
;
1652 offset
= bss_section
->data_offset
;
1653 /* XXX: which alignment ? */
1654 offset
= (offset
+ 16 - 1) & -16;
1655 index
= put_elf_sym(s1
->dynsym
, offset
, esym
->st_size
,
1656 esym
->st_info
, 0, bss_section
->sh_num
,
1658 /* Ensure R_COPY works for weak symbol aliases */
1659 if (ELFW(ST_BIND
)(esym
->st_info
) == STB_WEAK
) {
1660 for_each_elem(s1
->dynsymtab_section
, 1, dynsym
, ElfW(Sym
)) {
1661 if ((dynsym
->st_value
== esym
->st_value
)
1662 && (ELFW(ST_BIND
)(dynsym
->st_info
) == STB_GLOBAL
)) {
1663 char *dynname
= (char *) s1
->dynsymtab_section
->link
->data
1665 put_elf_sym(s1
->dynsym
, offset
, dynsym
->st_size
,
1667 bss_section
->sh_num
, dynname
);
1672 put_elf_reloc(s1
->dynsym
, bss_section
,
1673 offset
, R_COPY
, index
);
1674 offset
+= esym
->st_size
;
1675 bss_section
->data_offset
= offset
;
1678 /* STB_WEAK undefined symbols are accepted */
1679 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1680 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
||
1681 !strcmp(name
, "_fp_hw")) {
1683 tcc_error_noabort("undefined symbol '%s'", name
);
1686 } else if (s1
->rdynamic
&& ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1687 /* if -rdynamic option, then export all non local symbols */
1688 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1689 put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1690 0, sym
->st_shndx
, name
);
1695 /* Bind symbols of libraries: export non local symbols of executable that
1696 resolve undefined symbols of shared libraries */
1697 static void bind_libs_dynsyms(TCCState
*s1
)
1701 ElfW(Sym
) *sym
, *esym
;
1703 /* now look at unresolved dynamic symbols and export
1704 corresponding symbol */
1705 for_each_elem(s1
->dynsymtab_section
, 1, esym
, ElfW(Sym
)) {
1706 if (esym
->st_shndx
== SHN_UNDEF
) {
1707 name
= (char *) s1
->dynsymtab_section
->link
->data
+ esym
->st_name
;
1708 sym_index
= find_elf_sym(symtab_section
, name
);
1710 /* XXX: avoid adding a symbol if already present because of
1712 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1713 put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1714 sym
->st_info
, 0, sym
->st_shndx
, name
);
1716 /* weak symbols can stay undefined */
1717 if (ELFW(ST_BIND
)(esym
->st_info
) != STB_WEAK
)
1718 tcc_warning("undefined dynamic symbol '%s'", name
);
1724 /* Export all non local symbols (for shared libraries) */
1725 static void export_global_syms(TCCState
*s1
)
1727 int nb_syms
, dynindex
, index
;
1731 nb_syms
= symtab_section
->data_offset
/ sizeof(ElfW(Sym
));
1732 s1
->symtab_to_dynsym
= tcc_mallocz(sizeof(int) * nb_syms
);
1733 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1734 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1735 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1736 dynindex
= put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1737 sym
->st_info
, 0, sym
->st_shndx
, name
);
1738 index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1739 s1
->symtab_to_dynsym
[index
] = dynindex
;
1744 /* relocate the PLT: compute addresses and offsets in the PLT now that final
1745 address for PLT and GOT are known (see fill_program_header) */
1746 ST_FUNC
void relocate_plt(TCCState
*s1
)
1754 p_end
= p
+ s1
->plt
->data_offset
;
1756 #if defined(TCC_TARGET_I386)
1757 put32(p
+ 2, get32(p
+ 2) + s1
->got
->sh_addr
);
1758 put32(p
+ 8, get32(p
+ 8) + s1
->got
->sh_addr
);
1761 put32(p
+ 2, get32(p
+ 2) + s1
->got
->sh_addr
);
1764 #elif defined(TCC_TARGET_X86_64)
1765 int x
= s1
->got
->sh_addr
- s1
->plt
->sh_addr
- 6;
1766 put32(p
+ 2, get32(p
+ 2) + x
);
1767 put32(p
+ 8, get32(p
+ 8) + x
- 6);
1770 put32(p
+ 2, get32(p
+ 2) + x
+ s1
->plt
->data
- p
);
1773 #elif defined(TCC_TARGET_ARM)
1775 x
=s1
->got
->sh_addr
- s1
->plt
->sh_addr
- 12;
1778 if (get32(p
) == 0x46c04778) /* PLT Thumb stub present */
1780 put32(p
+ 12, x
+ get32(p
+ 12) + s1
->plt
->data
- p
);
1783 #elif defined(TCC_TARGET_C67)
1786 #error unsupported CPU
1791 /* Allocate strings for section names and decide if an unallocated section
1794 NOTE: the strsec section comes last, so its size is also correct ! */
1795 static void alloc_sec_names(TCCState
*s1
, int file_type
, Section
*strsec
)
1800 /* Allocate strings for section names */
1801 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1802 s
= s1
->sections
[i
];
1803 s
->sh_name
= put_elf_str(strsec
, s
->name
);
1804 /* when generating a DLL, we include relocations but we may
1806 if (file_type
== TCC_OUTPUT_DLL
&&
1807 s
->sh_type
== SHT_RELX
&&
1808 !(s
->sh_flags
& SHF_ALLOC
)) {
1809 /* gr: avoid bogus relocs for empty (debug) sections */
1810 if (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_ALLOC
)
1811 prepare_dynamic_rel(s1
, s
);
1812 else if (s1
->do_debug
)
1813 s
->sh_size
= s
->data_offset
;
1814 } else if (s1
->do_debug
||
1815 file_type
== TCC_OUTPUT_OBJ
||
1816 (s
->sh_flags
& SHF_ALLOC
) ||
1817 i
== (s1
->nb_sections
- 1)) {
1818 /* we output all sections if debug or object file */
1819 s
->sh_size
= s
->data_offset
;
1824 /* Info to be copied in dynamic section */
1828 unsigned long dyn_rel_off
;
1831 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1837 /* Assign sections to segments and decide how are sections laid out when loaded
1838 in memory. This function also fills corresponding program headers. */
1839 static int layout_sections(TCCState
*s1
, ElfW(Phdr
) *phdr
, int phnum
,
1840 Section
*interp
, struct dyn_inf
*dyninf
,
1843 int i
, j
, k
, file_type
, sh_order_index
, file_offset
;
1849 file_type
= s1
->output_type
;
1851 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
1852 file_offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
1857 if (s1
->has_text_addr
) {
1858 int a_offset
, p_offset
;
1859 addr
= s1
->text_addr
;
1860 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1862 a_offset
= (int) (addr
& (s1
->section_align
- 1));
1863 p_offset
= file_offset
& (s1
->section_align
- 1);
1864 if (a_offset
< p_offset
)
1865 a_offset
+= s1
->section_align
;
1866 file_offset
+= (a_offset
- p_offset
);
1868 if (file_type
== TCC_OUTPUT_DLL
)
1871 addr
= ELF_START_ADDR
;
1872 /* compute address after headers */
1873 addr
+= (file_offset
& (s1
->section_align
- 1));
1877 /* Leave one program headers for the program interpreter and one for
1878 the program header table itself if needed. These are done later as
1879 they require section layout to be done first. */
1881 ph
+= 1 + HAVE_PHDR
;
1883 /* dynamic relocation table information, for .dynamic section */
1884 dyninf
->rel_addr
= dyninf
->rel_size
= 0;
1885 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1886 dyninf
->bss_addr
= dyninf
->bss_size
= 0;
1889 for(j
= 0; j
< 2; j
++) {
1890 ph
->p_type
= PT_LOAD
;
1892 ph
->p_flags
= PF_R
| PF_X
;
1894 ph
->p_flags
= PF_R
| PF_W
;
1895 ph
->p_align
= s1
->section_align
;
1897 /* Decide the layout of sections loaded in memory. This must
1898 be done before program headers are filled since they contain
1899 info about the layout. We do the following ordering: interp,
1900 symbol tables, relocations, progbits, nobits */
1901 /* XXX: do faster and simpler sorting */
1902 for(k
= 0; k
< 5; k
++) {
1903 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1904 s
= s1
->sections
[i
];
1905 /* compute if section should be included */
1907 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1911 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1912 (SHF_ALLOC
| SHF_WRITE
))
1918 } else if (s
->sh_type
== SHT_DYNSYM
||
1919 s
->sh_type
== SHT_STRTAB
||
1920 s
->sh_type
== SHT_HASH
) {
1923 } else if (s
->sh_type
== SHT_RELX
) {
1926 } else if (s
->sh_type
== SHT_NOBITS
) {
1933 sec_order
[sh_order_index
++] = i
;
1935 /* section matches: we align it and add its size */
1937 addr
= (addr
+ s
->sh_addralign
- 1) &
1938 ~(s
->sh_addralign
- 1);
1939 file_offset
+= (int) ( addr
- tmp
);
1940 s
->sh_offset
= file_offset
;
1943 /* update program header infos */
1944 if (ph
->p_offset
== 0) {
1945 ph
->p_offset
= file_offset
;
1947 ph
->p_paddr
= ph
->p_vaddr
;
1949 /* update dynamic relocation infos */
1950 if (s
->sh_type
== SHT_RELX
) {
1951 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1952 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.got")) {
1953 dyninf
->rel_addr
= addr
;
1954 dyninf
->rel_size
+= s
->sh_size
; /* XXX only first rel. */
1956 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.bss")) {
1957 dyninf
->bss_addr
= addr
;
1958 dyninf
->bss_size
= s
->sh_size
; /* XXX only first rel. */
1961 if (dyninf
->rel_size
== 0)
1962 dyninf
->rel_addr
= addr
;
1963 dyninf
->rel_size
+= s
->sh_size
;
1967 if (s
->sh_type
!= SHT_NOBITS
)
1968 file_offset
+= s
->sh_size
;
1972 /* Make the first PT_LOAD segment include the program
1973 headers itself (and the ELF header as well), it'll
1974 come out with same memory use but will make various
1975 tools like binutils strip work better. */
1976 ph
->p_offset
&= ~(ph
->p_align
- 1);
1977 ph
->p_vaddr
&= ~(ph
->p_align
- 1);
1978 ph
->p_paddr
&= ~(ph
->p_align
- 1);
1980 ph
->p_filesz
= file_offset
- ph
->p_offset
;
1981 ph
->p_memsz
= addr
- ph
->p_vaddr
;
1984 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
) {
1985 /* if in the middle of a page, we duplicate the page in
1986 memory so that one copy is RX and the other is RW */
1987 if ((addr
& (s1
->section_align
- 1)) != 0)
1988 addr
+= s1
->section_align
;
1990 addr
= (addr
+ s1
->section_align
- 1) & ~(s1
->section_align
- 1);
1991 file_offset
= (file_offset
+ s1
->section_align
- 1) &
1992 ~(s1
->section_align
- 1);
1998 /* all other sections come after */
1999 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2000 s
= s1
->sections
[i
];
2001 if (phnum
> 0 && (s
->sh_flags
& SHF_ALLOC
))
2003 sec_order
[sh_order_index
++] = i
;
2005 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
2006 ~(s
->sh_addralign
- 1);
2007 s
->sh_offset
= file_offset
;
2008 if (s
->sh_type
!= SHT_NOBITS
)
2009 file_offset
+= s
->sh_size
;
2015 static void fill_unloadable_phdr(ElfW(Phdr
) *phdr
, int phnum
, Section
*interp
,
2020 /* if interpreter, then add corresponding program header */
2026 int len
= phnum
* sizeof(ElfW(Phdr
));
2028 ph
->p_type
= PT_PHDR
;
2029 ph
->p_offset
= sizeof(ElfW(Ehdr
));
2030 ph
->p_vaddr
= interp
->sh_addr
- len
;
2031 ph
->p_paddr
= ph
->p_vaddr
;
2032 ph
->p_filesz
= ph
->p_memsz
= len
;
2033 ph
->p_flags
= PF_R
| PF_X
;
2034 ph
->p_align
= 4; /* interp->sh_addralign; */
2038 ph
->p_type
= PT_INTERP
;
2039 ph
->p_offset
= interp
->sh_offset
;
2040 ph
->p_vaddr
= interp
->sh_addr
;
2041 ph
->p_paddr
= ph
->p_vaddr
;
2042 ph
->p_filesz
= interp
->sh_size
;
2043 ph
->p_memsz
= interp
->sh_size
;
2045 ph
->p_align
= interp
->sh_addralign
;
2048 /* if dynamic section, then add corresponding program header */
2050 ph
= &phdr
[phnum
- 1];
2052 ph
->p_type
= PT_DYNAMIC
;
2053 ph
->p_offset
= dynamic
->sh_offset
;
2054 ph
->p_vaddr
= dynamic
->sh_addr
;
2055 ph
->p_paddr
= ph
->p_vaddr
;
2056 ph
->p_filesz
= dynamic
->sh_size
;
2057 ph
->p_memsz
= dynamic
->sh_size
;
2058 ph
->p_flags
= PF_R
| PF_W
;
2059 ph
->p_align
= dynamic
->sh_addralign
;
2063 /* Fill the dynamic section with tags describing the address and size of
2065 static void fill_dynamic(TCCState
*s1
, struct dyn_inf
*dyninf
)
2069 dynamic
= dyninf
->dynamic
;
2071 /* put dynamic section entries */
2072 dynamic
->data_offset
= dyninf
->dyn_rel_off
;
2073 put_dt(dynamic
, DT_HASH
, s1
->dynsym
->hash
->sh_addr
);
2074 put_dt(dynamic
, DT_STRTAB
, dyninf
->dynstr
->sh_addr
);
2075 put_dt(dynamic
, DT_SYMTAB
, s1
->dynsym
->sh_addr
);
2076 put_dt(dynamic
, DT_STRSZ
, dyninf
->dynstr
->data_offset
);
2077 put_dt(dynamic
, DT_SYMENT
, sizeof(ElfW(Sym
)));
2078 #ifdef TCC_TARGET_X86_64
2079 put_dt(dynamic
, DT_RELA
, dyninf
->rel_addr
);
2080 put_dt(dynamic
, DT_RELASZ
, dyninf
->rel_size
);
2081 put_dt(dynamic
, DT_RELAENT
, sizeof(ElfW_Rel
));
2083 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2084 put_dt(dynamic
, DT_PLTGOT
, s1
->got
->sh_addr
);
2085 put_dt(dynamic
, DT_PLTRELSZ
, dyninf
->rel_size
);
2086 put_dt(dynamic
, DT_JMPREL
, dyninf
->rel_addr
);
2087 put_dt(dynamic
, DT_PLTREL
, DT_REL
);
2088 put_dt(dynamic
, DT_REL
, dyninf
->bss_addr
);
2089 put_dt(dynamic
, DT_RELSZ
, dyninf
->bss_size
);
2091 put_dt(dynamic
, DT_REL
, dyninf
->rel_addr
);
2092 put_dt(dynamic
, DT_RELSZ
, dyninf
->rel_size
);
2093 put_dt(dynamic
, DT_RELENT
, sizeof(ElfW_Rel
));
2097 put_dt(dynamic
, DT_DEBUG
, 0);
2098 put_dt(dynamic
, DT_NULL
, 0);
2101 /* Relocate remaining sections and symbols (that is those not related to
2103 static int final_sections_reloc(TCCState
*s1
)
2108 relocate_syms(s1
, 0);
2110 if (s1
->nb_errors
!= 0)
2113 /* relocate sections */
2114 /* XXX: ignore sections with allocated relocations ? */
2115 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2116 s
= s1
->sections
[i
];
2117 if (s
->reloc
&& s
!= s1
->got
)
2118 relocate_section(s1
, s
);
2121 /* relocate relocation entries if the relocation tables are
2122 allocated in the executable */
2123 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2124 s
= s1
->sections
[i
];
2125 if ((s
->sh_flags
& SHF_ALLOC
) &&
2126 s
->sh_type
== SHT_RELX
) {
2127 relocate_rel(s1
, s
);
2133 /* Create an ELF file on disk.
2134 This function handle ELF specific layout requirements */
2135 static void tcc_output_elf(TCCState
*s1
, FILE *f
, int phnum
, ElfW(Phdr
) *phdr
,
2136 int file_offset
, int *sec_order
)
2138 int i
, shnum
, offset
, size
, file_type
;
2141 ElfW(Shdr
) shdr
, *sh
;
2143 file_type
= s1
->output_type
;
2144 shnum
= s1
->nb_sections
;
2146 memset(&ehdr
, 0, sizeof(ehdr
));
2149 ehdr
.e_phentsize
= sizeof(ElfW(Phdr
));
2150 ehdr
.e_phnum
= phnum
;
2151 ehdr
.e_phoff
= sizeof(ElfW(Ehdr
));
2155 file_offset
= (file_offset
+ 3) & -4;
2158 ehdr
.e_ident
[0] = ELFMAG0
;
2159 ehdr
.e_ident
[1] = ELFMAG1
;
2160 ehdr
.e_ident
[2] = ELFMAG2
;
2161 ehdr
.e_ident
[3] = ELFMAG3
;
2162 ehdr
.e_ident
[4] = ELFCLASSW
;
2163 ehdr
.e_ident
[5] = ELFDATA2LSB
;
2164 ehdr
.e_ident
[6] = EV_CURRENT
;
2165 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2166 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
2168 #ifdef TCC_TARGET_ARM
2170 ehdr
.e_ident
[EI_OSABI
] = 0;
2171 ehdr
.e_flags
= EF_ARM_EABI_VER4
;
2172 if (file_type
== TCC_OUTPUT_EXE
|| file_type
== TCC_OUTPUT_DLL
)
2173 ehdr
.e_flags
|= EF_ARM_HASENTRY
;
2174 if (s1
->float_abi
== ARM_HARD_FLOAT
)
2175 ehdr
.e_flags
|= EF_ARM_VFP_FLOAT
;
2177 ehdr
.e_flags
|= EF_ARM_SOFT_FLOAT
;
2179 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_ARM
;
2184 case TCC_OUTPUT_EXE
:
2185 ehdr
.e_type
= ET_EXEC
;
2186 ehdr
.e_entry
= get_elf_sym_addr(s1
, "_start", 1);
2188 case TCC_OUTPUT_DLL
:
2189 ehdr
.e_type
= ET_DYN
;
2190 ehdr
.e_entry
= text_section
->sh_addr
; /* XXX: is it correct ? */
2192 case TCC_OUTPUT_OBJ
:
2193 ehdr
.e_type
= ET_REL
;
2196 ehdr
.e_machine
= EM_TCC_TARGET
;
2197 ehdr
.e_version
= EV_CURRENT
;
2198 ehdr
.e_shoff
= file_offset
;
2199 ehdr
.e_ehsize
= sizeof(ElfW(Ehdr
));
2200 ehdr
.e_shentsize
= sizeof(ElfW(Shdr
));
2201 ehdr
.e_shnum
= shnum
;
2202 ehdr
.e_shstrndx
= shnum
- 1;
2204 fwrite(&ehdr
, 1, sizeof(ElfW(Ehdr
)), f
);
2205 fwrite(phdr
, 1, phnum
* sizeof(ElfW(Phdr
)), f
);
2206 offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
2208 sort_syms(s1
, symtab_section
);
2209 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2210 s
= s1
->sections
[sec_order
[i
]];
2211 if (s
->sh_type
!= SHT_NOBITS
) {
2212 if (s
->sh_type
== SHT_DYNSYM
)
2213 patch_dynsym_undef(s1
, s
);
2214 while (offset
< s
->sh_offset
) {
2219 fwrite(s
->data
, 1, size
, f
);
2224 /* output section headers */
2225 while (offset
< ehdr
.e_shoff
) {
2230 for(i
= 0; i
< s1
->nb_sections
; i
++) {
2232 memset(sh
, 0, sizeof(ElfW(Shdr
)));
2233 s
= s1
->sections
[i
];
2235 sh
->sh_name
= s
->sh_name
;
2236 sh
->sh_type
= s
->sh_type
;
2237 sh
->sh_flags
= s
->sh_flags
;
2238 sh
->sh_entsize
= s
->sh_entsize
;
2239 sh
->sh_info
= s
->sh_info
;
2241 sh
->sh_link
= s
->link
->sh_num
;
2242 sh
->sh_addralign
= s
->sh_addralign
;
2243 sh
->sh_addr
= s
->sh_addr
;
2244 sh
->sh_offset
= s
->sh_offset
;
2245 sh
->sh_size
= s
->sh_size
;
2247 fwrite(sh
, 1, sizeof(ElfW(Shdr
)), f
);
2251 /* Write an elf, coff or "binary" file */
2252 static int tcc_write_elf_file(TCCState
*s1
, const char *filename
, int phnum
,
2253 ElfW(Phdr
) *phdr
, int file_offset
, int *sec_order
)
2255 int fd
, mode
, file_type
;
2258 file_type
= s1
->output_type
;
2259 if (file_type
== TCC_OUTPUT_OBJ
)
2264 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, mode
);
2266 tcc_error_noabort("could not write '%s'", filename
);
2269 f
= fdopen(fd
, "wb");
2271 printf("<- %s\n", filename
);
2273 #ifdef TCC_TARGET_COFF
2274 if (s1
->output_format
== TCC_OUTPUT_FORMAT_COFF
)
2275 tcc_output_coff(s1
, f
);
2278 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
2279 tcc_output_elf(s1
, f
, phnum
, phdr
, file_offset
, sec_order
);
2281 tcc_output_binary(s1
, f
, sec_order
);
2287 /* Output an elf, coff or binary file */
2288 /* XXX: suppress unneeded sections */
2289 static int elf_output_file(TCCState
*s1
, const char *filename
)
2291 int i
, ret
, phnum
, shnum
, file_type
, file_offset
, *sec_order
;
2292 struct dyn_inf dyninf
;
2295 Section
*strsec
, *interp
, *dynamic
, *dynstr
;
2297 file_type
= s1
->output_type
;
2300 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2301 if (file_type
!= TCC_OUTPUT_OBJ
) {
2302 tcc_add_runtime(s1
);
2307 interp
= dynamic
= dynstr
= NULL
; /* avoid warning */
2308 dyninf
.dyn_rel_off
= 0; /* avoid warning */
2310 if (file_type
!= TCC_OUTPUT_OBJ
) {
2311 relocate_common_syms();
2313 tcc_add_linker_symbols(s1
);
2315 if (!s1
->static_link
) {
2316 if (file_type
== TCC_OUTPUT_EXE
) {
2318 /* allow override the dynamic loader */
2319 const char *elfint
= getenv("LD_SO");
2321 elfint
= DEFAULT_ELFINTERP(s1
);
2322 /* add interpreter section only if executable */
2323 interp
= new_section(s1
, ".interp", SHT_PROGBITS
, SHF_ALLOC
);
2324 interp
->sh_addralign
= 1;
2325 ptr
= section_ptr_add(interp
, 1 + strlen(elfint
));
2326 strcpy(ptr
, elfint
);
2329 /* add dynamic symbol table */
2330 s1
->dynsym
= new_symtab(s1
, ".dynsym", SHT_DYNSYM
, SHF_ALLOC
,
2332 ".hash", SHF_ALLOC
);
2333 dynstr
= s1
->dynsym
->link
;
2335 /* add dynamic section */
2336 dynamic
= new_section(s1
, ".dynamic", SHT_DYNAMIC
,
2337 SHF_ALLOC
| SHF_WRITE
);
2338 dynamic
->link
= dynstr
;
2339 dynamic
->sh_entsize
= sizeof(ElfW(Dyn
));
2343 if (file_type
== TCC_OUTPUT_EXE
) {
2344 bind_exe_dynsyms(s1
);
2346 if (s1
->nb_errors
) {
2351 bind_libs_dynsyms(s1
);
2352 } else /* shared library case: simply export all global symbols */
2353 export_global_syms(s1
);
2355 build_got_entries(s1
);
2357 /* add a list of needed dlls */
2358 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2359 DLLReference
*dllref
= s1
->loaded_dlls
[i
];
2360 if (dllref
->level
== 0)
2361 put_dt(dynamic
, DT_NEEDED
, put_elf_str(dynstr
, dllref
->name
));
2365 put_dt(dynamic
, DT_RPATH
, put_elf_str(dynstr
, s1
->rpath
));
2367 /* XXX: currently, since we do not handle PIC code, we
2368 must relocate the readonly segments */
2369 if (file_type
== TCC_OUTPUT_DLL
) {
2371 put_dt(dynamic
, DT_SONAME
, put_elf_str(dynstr
, s1
->soname
));
2372 put_dt(dynamic
, DT_TEXTREL
, 0);
2376 put_dt(dynamic
, DT_SYMBOLIC
, 0);
2378 /* add necessary space for other entries */
2379 dyninf
.dyn_rel_off
= dynamic
->data_offset
;
2380 dynamic
->data_offset
+= sizeof(ElfW(Dyn
)) * EXTRA_RELITEMS
;
2382 /* still need to build got entries in case of static link */
2383 build_got_entries(s1
);
2387 /* we add a section for symbols */
2388 strsec
= new_section(s1
, ".shstrtab", SHT_STRTAB
, 0);
2389 put_elf_str(strsec
, "");
2391 /* compute number of sections */
2392 shnum
= s1
->nb_sections
;
2394 /* this array is used to reorder sections in the output file */
2395 sec_order
= tcc_malloc(sizeof(int) * shnum
);
2398 /* compute number of program headers */
2401 case TCC_OUTPUT_OBJ
:
2404 case TCC_OUTPUT_EXE
:
2405 if (!s1
->static_link
)
2406 phnum
= 4 + HAVE_PHDR
;
2410 case TCC_OUTPUT_DLL
:
2415 /* Allocate strings for section names */
2416 alloc_sec_names(s1
, file_type
, strsec
);
2418 /* allocate program segment headers */
2419 phdr
= tcc_mallocz(phnum
* sizeof(ElfW(Phdr
)));
2421 /* compute section to program header mapping */
2422 file_offset
= layout_sections(s1
, phdr
, phnum
, interp
, &dyninf
, sec_order
);
2424 /* Fill remaining program header and finalize relocation related to dynamic
2427 fill_unloadable_phdr(phdr
, phnum
, interp
, dynamic
);
2429 dyninf
.dynamic
= dynamic
;
2430 dyninf
.dynstr
= dynstr
;
2432 fill_dynamic(s1
, &dyninf
);
2434 /* put in GOT the dynamic section address and relocate PLT */
2435 put32(s1
->got
->data
, dynamic
->sh_addr
);
2436 if (file_type
== TCC_OUTPUT_EXE
2437 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
2438 || file_type
== TCC_OUTPUT_DLL
2443 /* relocate symbols in .dynsym now that final addresses are known */
2444 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
)) {
2445 /* relocate to PLT if symbol corresponds to a PLT entry */
2446 if (sym
->st_shndx
== SHN_UNDEF
) {
2448 sym
->st_value
+= s1
->plt
->sh_addr
;
2449 } else if (sym
->st_shndx
< SHN_LORESERVE
) {
2450 /* do symbol relocation */
2451 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
2457 /* if building executable or DLL, then relocate each section
2458 except the GOT which is already relocated */
2459 if (file_type
!= TCC_OUTPUT_OBJ
) {
2460 ret
= final_sections_reloc(s1
);
2465 /* Perform relocation to GOT or PLTÂ entries */
2466 if (file_type
== TCC_OUTPUT_EXE
&& s1
->static_link
)
2469 /* Create the ELF file with name 'filename' */
2470 ret
= tcc_write_elf_file(s1
, filename
, phnum
, phdr
, file_offset
, sec_order
);
2472 tcc_free(s1
->symtab_to_dynsym
);
2473 tcc_free(sec_order
);
2475 tcc_free(s1
->sym_attrs
);
2476 s1
->sym_attrs
= NULL
;
2480 LIBTCCAPI
int tcc_output_file(TCCState
*s
, const char *filename
)
2483 #ifdef TCC_TARGET_PE
2484 if (s
->output_type
!= TCC_OUTPUT_OBJ
) {
2485 ret
= pe_output_file(s
, filename
);
2488 ret
= elf_output_file(s
, filename
);
2492 static void *load_data(int fd
, unsigned long file_offset
, unsigned long size
)
2496 data
= tcc_malloc(size
);
2497 lseek(fd
, file_offset
, SEEK_SET
);
2498 read(fd
, data
, size
);
2502 typedef struct SectionMergeInfo
{
2503 Section
*s
; /* corresponding existing section */
2504 unsigned long offset
; /* offset of the new section in the existing section */
2505 uint8_t new_section
; /* true if section 's' was added */
2506 uint8_t link_once
; /* true if link once section */
2509 /* load an object file and merge it with current files */
2510 /* XXX: handle correctly stab (debug) info */
2511 ST_FUNC
int tcc_load_object_file(TCCState
*s1
,
2512 int fd
, unsigned long file_offset
)
2515 ElfW(Shdr
) *shdr
, *sh
;
2516 int size
, i
, j
, offset
, offseti
, nb_syms
, sym_index
, ret
;
2517 unsigned char *strsec
, *strtab
;
2518 int *old_to_new_syms
;
2519 char *sh_name
, *name
;
2520 SectionMergeInfo
*sm_table
, *sm
;
2521 ElfW(Sym
) *sym
, *symtab
;
2528 stab_index
= stabstr_index
= 0;
2530 if (read(fd
, &ehdr
, sizeof(ehdr
)) != sizeof(ehdr
))
2532 if (ehdr
.e_ident
[0] != ELFMAG0
||
2533 ehdr
.e_ident
[1] != ELFMAG1
||
2534 ehdr
.e_ident
[2] != ELFMAG2
||
2535 ehdr
.e_ident
[3] != ELFMAG3
)
2537 /* test if object file */
2538 if (ehdr
.e_type
!= ET_REL
)
2540 /* test CPU specific stuff */
2541 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2542 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2544 tcc_error_noabort("invalid object file");
2548 shdr
= load_data(fd
, file_offset
+ ehdr
.e_shoff
,
2549 sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2550 sm_table
= tcc_mallocz(sizeof(SectionMergeInfo
) * ehdr
.e_shnum
);
2552 /* load section names */
2553 sh
= &shdr
[ehdr
.e_shstrndx
];
2554 strsec
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2556 /* load symtab and strtab */
2557 old_to_new_syms
= NULL
;
2561 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2563 if (sh
->sh_type
== SHT_SYMTAB
) {
2565 tcc_error_noabort("object must contain only one symtab");
2570 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2571 symtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2572 sm_table
[i
].s
= symtab_section
;
2574 /* now load strtab */
2575 sh
= &shdr
[sh
->sh_link
];
2576 strtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2580 /* now examine each section and try to merge its content with the
2582 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2583 /* no need to examine section name strtab */
2584 if (i
== ehdr
.e_shstrndx
)
2587 sh_name
= (char *) strsec
+ sh
->sh_name
;
2588 /* ignore sections types we do not handle */
2589 if (sh
->sh_type
!= SHT_PROGBITS
&&
2590 sh
->sh_type
!= SHT_RELX
&&
2592 sh
->sh_type
!= SHT_ARM_EXIDX
&&
2594 sh
->sh_type
!= SHT_NOBITS
&&
2595 sh
->sh_type
!= SHT_PREINIT_ARRAY
&&
2596 sh
->sh_type
!= SHT_INIT_ARRAY
&&
2597 sh
->sh_type
!= SHT_FINI_ARRAY
&&
2598 strcmp(sh_name
, ".stabstr")
2601 if (sh
->sh_addralign
< 1)
2602 sh
->sh_addralign
= 1;
2603 /* find corresponding section, if any */
2604 for(j
= 1; j
< s1
->nb_sections
;j
++) {
2605 s
= s1
->sections
[j
];
2606 if (!strcmp(s
->name
, sh_name
)) {
2607 if (!strncmp(sh_name
, ".gnu.linkonce",
2608 sizeof(".gnu.linkonce") - 1)) {
2609 /* if a 'linkonce' section is already present, we
2610 do not add it again. It is a little tricky as
2611 symbols can still be defined in
2613 sm_table
[i
].link_once
= 1;
2620 /* not found: create new section */
2621 s
= new_section(s1
, sh_name
, sh
->sh_type
, sh
->sh_flags
);
2622 /* take as much info as possible from the section. sh_link and
2623 sh_info will be updated later */
2624 s
->sh_addralign
= sh
->sh_addralign
;
2625 s
->sh_entsize
= sh
->sh_entsize
;
2626 sm_table
[i
].new_section
= 1;
2628 if (sh
->sh_type
!= s
->sh_type
) {
2629 tcc_error_noabort("invalid section type");
2633 /* align start of section */
2634 offset
= s
->data_offset
;
2636 if (0 == strcmp(sh_name
, ".stab")) {
2640 if (0 == strcmp(sh_name
, ".stabstr")) {
2645 size
= sh
->sh_addralign
- 1;
2646 offset
= (offset
+ size
) & ~size
;
2647 if (sh
->sh_addralign
> s
->sh_addralign
)
2648 s
->sh_addralign
= sh
->sh_addralign
;
2649 s
->data_offset
= offset
;
2651 sm_table
[i
].offset
= offset
;
2653 /* concatenate sections */
2655 if (sh
->sh_type
!= SHT_NOBITS
) {
2657 lseek(fd
, file_offset
+ sh
->sh_offset
, SEEK_SET
);
2658 ptr
= section_ptr_add(s
, size
);
2659 read(fd
, ptr
, size
);
2661 s
->data_offset
+= size
;
2666 /* gr relocate stab strings */
2667 if (stab_index
&& stabstr_index
) {
2670 s
= sm_table
[stab_index
].s
;
2671 a
= (Stab_Sym
*)(s
->data
+ sm_table
[stab_index
].offset
);
2672 b
= (Stab_Sym
*)(s
->data
+ s
->data_offset
);
2673 o
= sm_table
[stabstr_index
].offset
;
2675 a
->n_strx
+= o
, a
++;
2678 /* second short pass to update sh_link and sh_info fields of new
2680 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2682 if (!s
|| !sm_table
[i
].new_section
)
2685 if (sh
->sh_link
> 0)
2686 s
->link
= sm_table
[sh
->sh_link
].s
;
2687 if (sh
->sh_type
== SHT_RELX
) {
2688 s
->sh_info
= sm_table
[sh
->sh_info
].s
->sh_num
;
2689 /* update backward link */
2690 s1
->sections
[s
->sh_info
]->reloc
= s
;
2695 /* resolve symbols */
2696 old_to_new_syms
= tcc_mallocz(nb_syms
* sizeof(int));
2699 for(i
= 1; i
< nb_syms
; i
++, sym
++) {
2700 if (sym
->st_shndx
!= SHN_UNDEF
&&
2701 sym
->st_shndx
< SHN_LORESERVE
) {
2702 sm
= &sm_table
[sym
->st_shndx
];
2703 if (sm
->link_once
) {
2704 /* if a symbol is in a link once section, we use the
2705 already defined symbol. It is very important to get
2706 correct relocations */
2707 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
2708 name
= (char *) strtab
+ sym
->st_name
;
2709 sym_index
= find_elf_sym(symtab_section
, name
);
2711 old_to_new_syms
[i
] = sym_index
;
2715 /* if no corresponding section added, no need to add symbol */
2718 /* convert section number */
2719 sym
->st_shndx
= sm
->s
->sh_num
;
2721 sym
->st_value
+= sm
->offset
;
2724 name
= (char *) strtab
+ sym
->st_name
;
2725 sym_index
= add_elf_sym(symtab_section
, sym
->st_value
, sym
->st_size
,
2726 sym
->st_info
, sym
->st_other
,
2727 sym
->st_shndx
, name
);
2728 old_to_new_syms
[i
] = sym_index
;
2731 /* third pass to patch relocation entries */
2732 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2737 offset
= sm_table
[i
].offset
;
2738 switch(s
->sh_type
) {
2740 /* take relocation offset information */
2741 offseti
= sm_table
[sh
->sh_info
].offset
;
2742 for_each_elem(s
, (offset
/ sizeof(*rel
)), rel
, ElfW_Rel
) {
2745 /* convert symbol index */
2746 type
= ELFW(R_TYPE
)(rel
->r_info
);
2747 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
2748 /* NOTE: only one symtab assumed */
2749 if (sym_index
>= nb_syms
)
2751 sym_index
= old_to_new_syms
[sym_index
];
2752 /* ignore link_once in rel section. */
2753 if (!sym_index
&& !sm
->link_once
2754 #ifdef TCC_TARGET_ARM
2755 && type
!= R_ARM_V4BX
2759 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2760 i
, strsec
+ sh
->sh_name
, rel
->r_offset
);
2763 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
2764 /* offset the relocation offset */
2765 rel
->r_offset
+= offseti
;
2766 #ifdef TCC_TARGET_ARM
2767 /* Jumps and branches from a Thumb code to a PLT entry need
2768 special handling since PLT entries are ARM code.
2769 Unconditional bl instructions referencing PLT entries are
2770 handled by converting these instructions into blx
2771 instructions. Other case of instructions referencing a PLT
2772 entry require to add a Thumb stub before the PLT entry to
2773 switch to ARM mode. We set bit plt_thumb_stub of the
2774 attribute of a symbol to indicate such a case. */
2775 if (type
== R_ARM_THM_JUMP24
)
2776 alloc_sym_attr(s1
, sym_index
)->plt_thumb_stub
= 1;
2789 tcc_free(old_to_new_syms
);
2796 typedef struct ArchiveHeader
{
2797 char ar_name
[16]; /* name of this member */
2798 char ar_date
[12]; /* file mtime */
2799 char ar_uid
[6]; /* owner uid; printed as decimal */
2800 char ar_gid
[6]; /* owner gid; printed as decimal */
2801 char ar_mode
[8]; /* file mode, printed as octal */
2802 char ar_size
[10]; /* file size, printed as decimal */
2803 char ar_fmag
[2]; /* should contain ARFMAG */
2806 static int get_be32(const uint8_t *b
)
2808 return b
[3] | (b
[2] << 8) | (b
[1] << 16) | (b
[0] << 24);
2811 /* load only the objects which resolve undefined symbols */
2812 static int tcc_load_alacarte(TCCState
*s1
, int fd
, int size
)
2814 int i
, bound
, nsyms
, sym_index
, off
, ret
;
2816 const char *ar_names
, *p
;
2817 const uint8_t *ar_index
;
2820 data
= tcc_malloc(size
);
2821 if (read(fd
, data
, size
) != size
)
2823 nsyms
= get_be32(data
);
2824 ar_index
= data
+ 4;
2825 ar_names
= (char *) ar_index
+ nsyms
* 4;
2829 for(p
= ar_names
, i
= 0; i
< nsyms
; i
++, p
+= strlen(p
)+1) {
2830 sym_index
= find_elf_sym(symtab_section
, p
);
2832 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
2833 if(sym
->st_shndx
== SHN_UNDEF
) {
2834 off
= get_be32(ar_index
+ i
* 4) + sizeof(ArchiveHeader
);
2836 lseek(fd
, off
, SEEK_SET
);
2837 if(tcc_load_object_file(s1
, fd
, off
) < 0) {
2852 /* load a '.a' file */
2853 ST_FUNC
int tcc_load_archive(TCCState
*s1
, int fd
)
2860 unsigned long file_offset
;
2862 /* skip magic which was already checked */
2863 read(fd
, magic
, sizeof(magic
));
2866 len
= read(fd
, &hdr
, sizeof(hdr
));
2869 if (len
!= sizeof(hdr
)) {
2870 tcc_error_noabort("invalid archive");
2873 memcpy(ar_size
, hdr
.ar_size
, sizeof(hdr
.ar_size
));
2874 ar_size
[sizeof(hdr
.ar_size
)] = '\0';
2875 size
= strtol(ar_size
, NULL
, 0);
2876 memcpy(ar_name
, hdr
.ar_name
, sizeof(hdr
.ar_name
));
2877 for(i
= sizeof(hdr
.ar_name
) - 1; i
>= 0; i
--) {
2878 if (ar_name
[i
] != ' ')
2881 ar_name
[i
+ 1] = '\0';
2882 file_offset
= lseek(fd
, 0, SEEK_CUR
);
2884 size
= (size
+ 1) & ~1;
2885 if (!strcmp(ar_name
, "/")) {
2886 /* coff symbol table : we handle it */
2887 if(s1
->alacarte_link
)
2888 return tcc_load_alacarte(s1
, fd
, size
);
2889 } else if (!strcmp(ar_name
, "//") ||
2890 !strcmp(ar_name
, "__.SYMDEF") ||
2891 !strcmp(ar_name
, "__.SYMDEF/") ||
2892 !strcmp(ar_name
, "ARFILENAMES/")) {
2893 /* skip symbol table or archive names */
2895 if (tcc_load_object_file(s1
, fd
, file_offset
) < 0)
2898 lseek(fd
, file_offset
+ size
, SEEK_SET
);
2903 #ifndef TCC_TARGET_PE
2904 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2905 is referenced by the user (so it should be added as DT_NEEDED in
2906 the generated ELF file) */
2907 ST_FUNC
int tcc_load_dll(TCCState
*s1
, int fd
, const char *filename
, int level
)
2910 ElfW(Shdr
) *shdr
, *sh
, *sh1
;
2911 int i
, j
, nb_syms
, nb_dts
, sym_bind
, ret
;
2912 ElfW(Sym
) *sym
, *dynsym
;
2913 ElfW(Dyn
) *dt
, *dynamic
;
2914 unsigned char *dynstr
;
2915 const char *name
, *soname
;
2916 DLLReference
*dllref
;
2918 read(fd
, &ehdr
, sizeof(ehdr
));
2920 /* test CPU specific stuff */
2921 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2922 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2923 tcc_error_noabort("bad architecture");
2928 shdr
= load_data(fd
, ehdr
.e_shoff
, sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2930 /* load dynamic section and dynamic symbols */
2934 dynsym
= NULL
; /* avoid warning */
2935 dynstr
= NULL
; /* avoid warning */
2936 for(i
= 0, sh
= shdr
; i
< ehdr
.e_shnum
; i
++, sh
++) {
2937 switch(sh
->sh_type
) {
2939 nb_dts
= sh
->sh_size
/ sizeof(ElfW(Dyn
));
2940 dynamic
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2943 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2944 dynsym
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
2945 sh1
= &shdr
[sh
->sh_link
];
2946 dynstr
= load_data(fd
, sh1
->sh_offset
, sh1
->sh_size
);
2953 /* compute the real library name */
2954 soname
= tcc_basename(filename
);
2956 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2957 if (dt
->d_tag
== DT_SONAME
) {
2958 soname
= (char *) dynstr
+ dt
->d_un
.d_val
;
2962 /* if the dll is already loaded, do not load it */
2963 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2964 dllref
= s1
->loaded_dlls
[i
];
2965 if (!strcmp(soname
, dllref
->name
)) {
2966 /* but update level if needed */
2967 if (level
< dllref
->level
)
2968 dllref
->level
= level
;
2974 /* add the dll and its level */
2975 dllref
= tcc_mallocz(sizeof(DLLReference
) + strlen(soname
));
2976 dllref
->level
= level
;
2977 strcpy(dllref
->name
, soname
);
2978 dynarray_add((void ***)&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
, dllref
);
2980 /* add dynamic symbols in dynsym_section */
2981 for(i
= 1, sym
= dynsym
+ 1; i
< nb_syms
; i
++, sym
++) {
2982 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
2983 if (sym_bind
== STB_LOCAL
)
2985 name
= (char *) dynstr
+ sym
->st_name
;
2986 add_elf_sym(s1
->dynsymtab_section
, sym
->st_value
, sym
->st_size
,
2987 sym
->st_info
, sym
->st_other
, sym
->st_shndx
, name
);
2990 /* load all referenced DLLs */
2991 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
2994 name
= (char *) dynstr
+ dt
->d_un
.d_val
;
2995 for(j
= 0; j
< s1
->nb_loaded_dlls
; j
++) {
2996 dllref
= s1
->loaded_dlls
[j
];
2997 if (!strcmp(name
, dllref
->name
))
2998 goto already_loaded
;
3000 if (tcc_add_dll(s1
, name
, AFF_REFERENCED_DLL
) < 0) {
3001 tcc_error_noabort("referenced dll '%s' not found", name
);
3018 #define LD_TOK_NAME 256
3019 #define LD_TOK_EOF (-1)
3021 /* return next ld script token */
3022 static int ld_next(TCCState
*s1
, char *name
, int name_size
)
3040 file
->buf_ptr
= parse_comment(file
->buf_ptr
);
3041 ch
= file
->buf_ptr
[0];
3049 /* case 'a' ... 'z': */
3076 /* case 'A' ... 'z': */
3111 if (!((ch
>= 'a' && ch
<= 'z') ||
3112 (ch
>= 'A' && ch
<= 'Z') ||
3113 (ch
>= '0' && ch
<= '9') ||
3114 strchr("/.-_+=$:\\,~", ch
)))
3116 if ((q
- name
) < name_size
- 1) {
3135 static int ld_add_file(TCCState
*s1
, const char filename
[])
3139 ret
= tcc_add_file_internal(s1
, filename
, 0);
3141 ret
= tcc_add_dll(s1
, filename
, 0);
3145 static inline int new_undef_syms(void)
3148 ret
= new_undef_sym
;
3153 static int ld_add_file_list(TCCState
*s1
, const char *cmd
, int as_needed
)
3155 char filename
[1024], libname
[1024];
3156 int t
, group
, nblibs
= 0, ret
= 0;
3159 group
= !strcmp(cmd
, "GROUP");
3162 t
= ld_next(s1
, filename
, sizeof(filename
));
3165 t
= ld_next(s1
, filename
, sizeof(filename
));
3168 if (t
== LD_TOK_EOF
) {
3169 tcc_error_noabort("unexpected end of file");
3171 goto lib_parse_error
;
3172 } else if (t
== ')') {
3174 } else if (t
== '-') {
3175 t
= ld_next(s1
, filename
, sizeof(filename
));
3176 if ((t
!= LD_TOK_NAME
) || (filename
[0] != 'l')) {
3177 tcc_error_noabort("library name expected");
3179 goto lib_parse_error
;
3181 pstrcpy(libname
, sizeof libname
, &filename
[1]);
3182 if (s1
->static_link
) {
3183 snprintf(filename
, sizeof filename
, "lib%s.a", libname
);
3185 snprintf(filename
, sizeof filename
, "lib%s.so", libname
);
3187 } else if (t
!= LD_TOK_NAME
) {
3188 tcc_error_noabort("filename expected");
3190 goto lib_parse_error
;
3192 if (!strcmp(filename
, "AS_NEEDED")) {
3193 ret
= ld_add_file_list(s1
, cmd
, 1);
3195 goto lib_parse_error
;
3197 /* TODO: Implement AS_NEEDED support. Ignore it for now */
3199 ret
= ld_add_file(s1
, filename
);
3201 goto lib_parse_error
;
3203 /* Add the filename *and* the libname to avoid future conversions */
3204 dynarray_add((void ***) &libs
, &nblibs
, tcc_strdup(filename
));
3205 if (libname
[0] != '\0')
3206 dynarray_add((void ***) &libs
, &nblibs
, tcc_strdup(libname
));
3210 t
= ld_next(s1
, filename
, sizeof(filename
));
3212 t
= ld_next(s1
, filename
, sizeof(filename
));
3215 if (group
&& !as_needed
) {
3216 while (new_undef_syms()) {
3219 for (i
= 0; i
< nblibs
; i
++)
3220 ld_add_file(s1
, libs
[i
]);
3224 dynarray_reset(&libs
, &nblibs
);
3228 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3230 ST_FUNC
int tcc_load_ldscript(TCCState
*s1
)
3233 char filename
[1024];
3236 ch
= file
->buf_ptr
[0];
3239 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3240 if (t
== LD_TOK_EOF
)
3242 else if (t
!= LD_TOK_NAME
)
3244 if (!strcmp(cmd
, "INPUT") ||
3245 !strcmp(cmd
, "GROUP")) {
3246 ret
= ld_add_file_list(s1
, cmd
, 0);
3249 } else if (!strcmp(cmd
, "OUTPUT_FORMAT") ||
3250 !strcmp(cmd
, "TARGET")) {
3251 /* ignore some commands */
3252 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3256 t
= ld_next(s1
, filename
, sizeof(filename
));
3257 if (t
== LD_TOK_EOF
) {
3258 tcc_error_noabort("unexpected end of file");
3260 } else if (t
== ')') {
3270 #endif /* !TCC_TARGET_PE */