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... may be -fcommon is needed?", 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_reloca(Section
*symtab
, Section
*s
, unsigned long offset
,
273 int type
, int symbol
, addr_t addend
)
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 #if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
295 rel
->r_addend
= addend
;
298 tcc_error("non-zero addend on REL architecture");
302 ST_FUNC
void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
303 int type
, int symbol
)
305 put_elf_reloca(symtab
, s
, offset
, type
, symbol
, 0);
308 /* put stab debug information */
310 ST_FUNC
void put_stabs(const char *str
, int type
, int other
, int desc
,
315 sym
= section_ptr_add(stab_section
, sizeof(Stab_Sym
));
317 sym
->n_strx
= put_elf_str(stabstr_section
, str
);
322 sym
->n_other
= other
;
324 sym
->n_value
= value
;
327 ST_FUNC
void put_stabs_r(const char *str
, int type
, int other
, int desc
,
328 unsigned long value
, Section
*sec
, int sym_index
)
330 put_stabs(str
, type
, other
, desc
, value
);
331 put_elf_reloc(symtab_section
, stab_section
,
332 stab_section
->data_offset
- sizeof(unsigned int),
333 R_DATA_32
, sym_index
);
336 ST_FUNC
void put_stabn(int type
, int other
, int desc
, int value
)
338 put_stabs(NULL
, type
, other
, desc
, value
);
341 ST_FUNC
void put_stabd(int type
, int other
, int desc
)
343 put_stabs(NULL
, type
, other
, desc
, 0);
346 /* Browse each elem of type <type> in section <sec> starting at elem <startoff>
347 using variable <elem> */
348 #define for_each_elem(sec, startoff, elem, type) \
349 for (elem = (type *) sec->data + startoff; \
350 elem < (type *) (sec->data + sec->data_offset); elem++)
352 /* In an ELF file symbol table, the local symbols must appear below
353 the global and weak ones. Since TCC cannot sort it while generating
354 the code, we must do it after. All the relocation tables are also
355 modified to take into account the symbol table sorting */
356 static void sort_syms(TCCState
*s1
, Section
*s
)
358 int *old_to_new_syms
;
366 nb_syms
= s
->data_offset
/ sizeof(ElfW(Sym
));
367 new_syms
= tcc_malloc(nb_syms
* sizeof(ElfW(Sym
)));
368 old_to_new_syms
= tcc_malloc(nb_syms
* sizeof(int));
370 /* first pass for local symbols */
371 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
;
380 /* save the number of local symbols in section header */
381 s
->sh_info
= q
- new_syms
;
383 /* then second pass for non local symbols */
384 p
= (ElfW(Sym
) *)s
->data
;
385 for(i
= 0; i
< nb_syms
; i
++) {
386 if (ELFW(ST_BIND
)(p
->st_info
) != STB_LOCAL
) {
387 old_to_new_syms
[i
] = q
- new_syms
;
393 /* we copy the new symbols to the old */
394 memcpy(s
->data
, new_syms
, nb_syms
* sizeof(ElfW(Sym
)));
397 /* now we modify all the relocations */
398 for(i
= 1; i
< s1
->nb_sections
; i
++) {
399 sr
= s1
->sections
[i
];
400 if (sr
->sh_type
== SHT_RELX
&& sr
->link
== s
) {
401 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
402 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
403 type
= ELFW(R_TYPE
)(rel
->r_info
);
404 sym_index
= old_to_new_syms
[sym_index
];
405 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
410 tcc_free(old_to_new_syms
);
413 /* relocate common symbols in the .bss section */
414 ST_FUNC
void relocate_common_syms(void)
417 unsigned long offset
, align
;
419 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
420 if (sym
->st_shndx
== SHN_COMMON
) {
422 align
= sym
->st_value
;
423 offset
= bss_section
->data_offset
;
424 offset
= (offset
+ align
- 1) & -align
;
425 sym
->st_value
= offset
;
426 sym
->st_shndx
= bss_section
->sh_num
;
427 offset
+= sym
->st_size
;
428 bss_section
->data_offset
= offset
;
433 /* relocate symbol table, resolve undefined symbols if do_resolve is
434 true and output error if undefined symbol. */
435 ST_FUNC
void relocate_syms(TCCState
*s1
, int do_resolve
)
437 ElfW(Sym
) *sym
, *esym
;
438 int sym_bind
, sh_num
, sym_index
;
441 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
442 sh_num
= sym
->st_shndx
;
443 if (sh_num
== SHN_UNDEF
) {
444 name
= (char *) strtab_section
->data
+ sym
->st_name
;
445 /* Use ld.so to resolve symbol for us (for tcc -run) */
447 #if defined TCC_IS_NATIVE && !defined _WIN32
449 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
450 addr
= resolve_sym(s1
, name
);
452 sym
->st_value
= (addr_t
)addr
;
454 printf ("relocate_sym: %s -> 0x%lx\n", name
, sym
->st_value
);
459 } else if (s1
->dynsym
) {
460 /* if dynamic symbol exist, then use it */
461 sym_index
= find_elf_sym(s1
->dynsym
, name
);
463 esym
= &((ElfW(Sym
) *)s1
->dynsym
->data
)[sym_index
];
464 sym
->st_value
= esym
->st_value
;
468 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
470 if (!strcmp(name
, "_fp_hw"))
472 /* only weak symbols are accepted to be undefined. Their
474 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
475 if (sym_bind
== STB_WEAK
) {
478 tcc_error_noabort("undefined symbol '%s'", name
);
480 } else if (sh_num
< SHN_LORESERVE
) {
481 /* add section base */
482 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
488 /* relocate a given section (CPU dependent) by applying the relocations
489 in the associated relocation section */
490 ST_FUNC
void relocate_section(TCCState
*s1
, Section
*s
)
492 Section
*sr
= s
->reloc
;
498 #if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
499 ElfW_Rel
*qrel
= (ElfW_Rel
*) sr
->data
; /* ptr to next reloc entry reused */
503 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
504 ptr
= s
->data
+ rel
->r_offset
;
506 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
507 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
509 #if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
510 val
+= rel
->r_addend
;
512 type
= ELFW(R_TYPE
)(rel
->r_info
);
513 addr
= s
->sh_addr
+ rel
->r_offset
;
517 #if defined(TCC_TARGET_I386)
519 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
520 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
521 qrel
->r_offset
= rel
->r_offset
;
523 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_386_32
);
527 qrel
->r_info
= ELFW(R_INFO
)(0, R_386_RELATIVE
);
531 write32le(ptr
, read32le(ptr
) + val
);
534 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
536 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
538 qrel
->r_offset
= rel
->r_offset
;
539 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_386_PC32
);
544 write32le(ptr
, read32le(ptr
) + val
- addr
);
547 write32le(ptr
, read32le(ptr
) + val
- addr
);
554 write32le(ptr
, read32le(ptr
) + s1
->got
->sh_addr
- addr
);
557 write32le(ptr
, read32le(ptr
) + val
- s1
->got
->sh_addr
);
561 /* we load the got offset */
562 write32le(ptr
, read32le(ptr
) + s1
->sym_attrs
[sym_index
].got_offset
);
565 if (s1
->output_format
!= TCC_OUTPUT_FORMAT_BINARY
) {
567 tcc_error("can only produce 16-bit binary files");
569 write16le(ptr
, read16le(ptr
) + val
);
572 if (s1
->output_format
!= TCC_OUTPUT_FORMAT_BINARY
)
574 write16le(ptr
, read16le(ptr
) + val
- addr
);
580 /* This reloction must copy initialized data from the library
581 to the program .bss segment. Currently made like for ARM
582 (to remove noise of defaukt case). Is this true?
586 fprintf(stderr
,"FIXME: handle reloc type %d at %x [%p] to %x\n",
587 type
, (unsigned)addr
, ptr
, (unsigned)val
);
589 #elif defined(TCC_TARGET_ARM)
595 int x
, is_thumb
, is_call
, h
, blx_avail
, is_bl
, th_ko
;
596 x
= (*(int *) ptr
) & 0xffffff;
597 if (sym
->st_shndx
== SHN_UNDEF
)
598 val
= s1
->plt
->sh_addr
;
600 printf ("reloc %d: x=0x%x val=0x%x ", type
, x
, val
);
602 (*(int *)ptr
) &= 0xff000000;
606 blx_avail
= (TCC_ARM_VERSION
>= 5);
608 is_bl
= (*(unsigned *) ptr
) >> 24 == 0xeb;
609 is_call
= (type
== R_ARM_CALL
|| (type
== R_ARM_PC24
&& is_bl
));
612 printf (" newx=0x%x name=%s\n", x
,
613 (char *) symtab_section
->link
->data
+ sym
->st_name
);
616 th_ko
= (x
& 3) && (!blx_avail
|| !is_call
);
617 if (th_ko
|| x
>= 0x2000000 || x
< -0x2000000)
618 tcc_error("can't relocate value at %x,%d",addr
, type
);
621 /* Only reached if blx is avail and it is a call */
624 (*(int *)ptr
) = 0xfa << 24; /* bl -> blx */
629 /* Since these relocations only concern Thumb-2 and blx instruction was
630 introduced before Thumb-2, we can assume blx is available and not
633 case R_ARM_THM_JUMP24
:
635 int x
, hi
, lo
, s
, j1
, j2
, i1
, i2
, imm10
, imm11
;
636 int to_thumb
, is_call
, to_plt
, blx_bit
= 1 << 12;
640 if (sym
->st_shndx
== SHN_UNDEF
&&
641 ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
)
644 /* Get initial offset */
645 hi
= (*(uint16_t *)ptr
);
646 lo
= (*(uint16_t *)(ptr
+2));
654 x
= (s
<< 24) | (i1
<< 23) | (i2
<< 22) |
655 (imm10
<< 12) | (imm11
<< 1);
659 /* Relocation infos */
662 to_plt
= (val
>= plt
->sh_addr
) &&
663 (val
< plt
->sh_addr
+ plt
->data_offset
);
664 is_call
= (type
== R_ARM_THM_PC22
);
666 /* Compute final offset */
667 if (to_plt
&& !is_call
) /* Point to 1st instr of Thumb stub */
670 if (!to_thumb
&& is_call
) {
671 blx_bit
= 0; /* bl -> blx */
672 x
= (x
+ 3) & -4; /* Compute offset from aligned PC */
675 /* Check that relocation is possible
676 * offset must not be out of range
677 * if target is to be entered in arm mode:
679 - instruction must be a call (bl) or a jump to PLT */
680 if (!to_thumb
|| x
>= 0x1000000 || x
< -0x1000000)
681 if (to_thumb
|| (val
& 2) || (!is_call
&& !to_plt
))
682 tcc_error("can't relocate value at %x,%d",addr
, type
);
684 /* Compute and store final offset */
690 imm10
= (x
>> 12) & 0x3ff;
691 imm11
= (x
>> 1) & 0x7ff;
692 (*(uint16_t *)ptr
) = (uint16_t) ((hi
& 0xf800) |
694 (*(uint16_t *)(ptr
+2)) = (uint16_t) ((lo
& 0xc000) |
695 (j1
<< 13) | blx_bit
| (j2
<< 11) |
700 case R_ARM_MOVW_ABS_NC
:
703 if (type
== R_ARM_MOVT_ABS
)
706 imm4
= (val
>> 12) & 0xf;
707 x
= (imm4
<< 16) | imm12
;
708 if (type
== R_ARM_THM_MOVT_ABS
)
714 case R_ARM_THM_MOVT_ABS
:
715 case R_ARM_THM_MOVW_ABS_NC
:
717 int x
, i
, imm4
, imm3
, imm8
;
718 if (type
== R_ARM_THM_MOVT_ABS
)
721 imm3
= (val
>> 8) & 0x7;
723 imm4
= (val
>> 12) & 0xf;
724 x
= (imm3
<< 28) | (imm8
<< 16) | (i
<< 10) | imm4
;
725 if (type
== R_ARM_THM_MOVT_ABS
)
734 x
= (*(int *)ptr
) & 0x7fffffff;
735 (*(int *)ptr
) &= 0x80000000;
738 if((x
^(x
>>1))&0x40000000)
739 tcc_error("can't relocate value at %x,%d",addr
, type
);
740 (*(int *)ptr
) |= x
& 0x7fffffff;
746 *(int *)ptr
+= val
- addr
;
749 *(int *)ptr
+= s1
->got
->sh_addr
- addr
;
752 *(int *)ptr
+= val
- s1
->got
->sh_addr
;
755 /* we load the got offset */
756 *(int *)ptr
+= s1
->sym_attrs
[sym_index
].got_offset
;
761 /* trade Thumb support for ARMv4 support */
762 if ((0x0ffffff0 & *(int*)ptr
) == 0x012FFF10)
763 *(int*)ptr
^= 0xE12FFF10 ^ 0xE1A0F000; /* BX Rm -> MOV PC, Rm */
766 case R_ARM_JUMP_SLOT
:
767 *(addr_t
*)ptr
= val
;
770 /* Nothing to do. Normally used to indicate a dependency
771 on a certain symbol (like for exception handling under EABI). */
774 fprintf(stderr
,"FIXME: handle reloc type %x at %x [%p] to %x\n",
775 type
, (unsigned)addr
, ptr
, (unsigned)val
);
777 #elif defined(TCC_TARGET_ARM64)
778 case R_AARCH64_ABS64
:
781 case R_AARCH64_ABS32
:
784 case R_AARCH64_MOVW_UABS_G0_NC
:
785 write32le(ptr
, ((read32le(ptr
) & 0xffe0001f) |
786 (val
& 0xffff) << 5));
788 case R_AARCH64_MOVW_UABS_G1_NC
:
789 write32le(ptr
, ((read32le(ptr
) & 0xffe0001f) |
790 (val
>> 16 & 0xffff) << 5));
792 case R_AARCH64_MOVW_UABS_G2_NC
:
793 write32le(ptr
, ((read32le(ptr
) & 0xffe0001f) |
794 (val
>> 32 & 0xffff) << 5));
796 case R_AARCH64_MOVW_UABS_G3
:
797 write32le(ptr
, ((read32le(ptr
) & 0xffe0001f) |
798 (val
>> 48 & 0xffff) << 5));
800 case R_AARCH64_ADR_PREL_PG_HI21
: {
801 uint64_t off
= (val
>> 12) - (addr
>> 12);
802 if ((off
+ ((uint64_t)1 << 20)) >> 21)
803 tcc_error("R_AARCH64_ADR_PREL_PG_HI21 relocation failed");
804 write32le(ptr
, ((read32le(ptr
) & 0x9f00001f) |
805 (off
& 0x1ffffc) << 3 | (off
& 3) << 29));
808 case R_AARCH64_ADD_ABS_LO12_NC
:
809 write32le(ptr
, ((read32le(ptr
) & 0xffc003ff) |
810 (val
& 0xfff) << 10));
812 case R_AARCH64_JUMP26
:
813 case R_AARCH64_CALL26
:
814 /* This check must match the one in build_got_entries, testing
815 if we really need a PLT slot. */
816 if (sym
->st_shndx
== SHN_UNDEF
)
817 /* We've put the PLT slot offset into r_addend when generating
818 it, and that's what we must use as relocation value (adjusted
819 by section offset of course). */
820 val
= s1
->plt
->sh_addr
+ rel
->r_addend
;
822 printf ("reloc %d @ 0x%lx: val=0x%lx name=%s\n", type
, addr
, val
,
823 (char *) symtab_section
->link
->data
+ sym
->st_name
);
825 if (((val
- addr
) + ((uint64_t)1 << 27)) & ~(uint64_t)0xffffffc)
827 tcc_error("R_AARCH64_(JUMP|CALL)26 relocation failed (val=%lx, addr=%lx)", addr
, val
);
829 write32le(ptr
, (0x14000000 |
830 (uint32_t)(type
== R_AARCH64_CALL26
) << 31 |
831 ((val
- addr
) >> 2 & 0x3ffffff)));
833 case R_AARCH64_ADR_GOT_PAGE
: {
835 (((s1
->got
->sh_addr
+
836 s1
->sym_attrs
[sym_index
].got_offset
) >> 12) - (addr
>> 12));
837 if ((off
+ ((uint64_t)1 << 20)) >> 21)
838 tcc_error("R_AARCH64_ADR_GOT_PAGE relocation failed");
839 write32le(ptr
, ((read32le(ptr
) & 0x9f00001f) |
840 (off
& 0x1ffffc) << 3 | (off
& 3) << 29));
843 case R_AARCH64_LD64_GOT_LO12_NC
:
845 ((read32le(ptr
) & 0xfff803ff) |
847 s1
->sym_attrs
[sym_index
].got_offset
) & 0xff8) << 7));
851 case R_AARCH64_GLOB_DAT
:
852 case R_AARCH64_JUMP_SLOT
:
853 /* They don't need addend */
855 printf ("reloc %d @ 0x%lx: val=0x%lx name=%s\n", type
, addr
,
857 (char *) symtab_section
->link
->data
+ sym
->st_name
);
859 write64le(ptr
, val
- rel
->r_addend
);
862 fprintf(stderr
, "FIXME: handle reloc type %x at %x [%p] to %x\n",
863 type
, (unsigned)addr
, ptr
, (unsigned)val
);
865 #elif defined(TCC_TARGET_C67)
873 /* put the low 16 bits of the absolute address
874 add to what is already there */
876 orig
= ((*(int *)(ptr
)) >> 7) & 0xffff;
877 orig
|= (((*(int *)(ptr
+4)) >> 7) & 0xffff) << 16;
879 /* patch both at once - assumes always in pairs Low - High */
881 *(int *) ptr
= (*(int *) ptr
& (~(0xffff << 7)) ) | (((val
+orig
) & 0xffff) << 7);
882 *(int *)(ptr
+4) = (*(int *)(ptr
+4) & (~(0xffff << 7)) ) | ((((val
+orig
)>>16) & 0xffff) << 7);
888 fprintf(stderr
,"FIXME: handle reloc type %x at %x [%p] to %x\n",
889 type
, (unsigned)addr
, ptr
, (unsigned)val
);
891 #elif defined(TCC_TARGET_X86_64)
893 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
894 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
895 qrel
->r_offset
= rel
->r_offset
;
897 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_X86_64_64
);
898 qrel
->r_addend
= rel
->r_addend
;
902 qrel
->r_info
= ELFW(R_INFO
)(0, R_X86_64_RELATIVE
);
903 qrel
->r_addend
= read64le(ptr
) + val
;
907 write64le(ptr
, read64le(ptr
) + val
);
911 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
912 /* XXX: this logic may depend on TCC's codegen
913 now TCC uses R_X86_64_32 even for a 64bit pointer */
914 qrel
->r_info
= ELFW(R_INFO
)(0, R_X86_64_RELATIVE
);
915 /* Use sign extension! */
916 qrel
->r_addend
= (int)read32le(ptr
) + val
;
919 write32le(ptr
, read32le(ptr
) + val
);
923 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
925 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
927 qrel
->r_offset
= rel
->r_offset
;
928 qrel
->r_info
= ELFW(R_INFO
)(esym_index
, R_X86_64_PC32
);
929 /* Use sign extension! */
930 qrel
->r_addend
= (int)read32le(ptr
) + rel
->r_addend
;
938 /* We've put the PLT slot offset into r_addend when generating
939 it, and that's what we must use as relocation value (adjusted
940 by section offset of course). */
941 val
= s1
->plt
->sh_addr
+ rel
->r_addend
;
947 diff
= (long long)val
- addr
;
948 if (diff
< -2147483648LL || diff
> 2147483647LL) {
949 tcc_error("internal error: relocation failed");
951 write32le(ptr
, read32le(ptr
) + diff
);
954 case R_X86_64_GLOB_DAT
:
955 case R_X86_64_JUMP_SLOT
:
956 /* They don't need addend */
957 write64le(ptr
, val
- rel
->r_addend
);
959 case R_X86_64_GOTPCREL
:
960 case R_X86_64_GOTPCRELX
:
961 case R_X86_64_REX_GOTPCRELX
:
962 write32le(ptr
, read32le(ptr
) +
963 (s1
->got
->sh_addr
- addr
+
964 s1
->sym_attrs
[sym_index
].got_offset
- 4));
966 case R_X86_64_GOTTPOFF
:
967 write32le(ptr
, read32le(ptr
) + val
- s1
->got
->sh_addr
);
970 /* we load the got offset */
971 write32le(ptr
, read32le(ptr
) + s1
->sym_attrs
[sym_index
].got_offset
);
974 #error unsupported processor
978 /* if the relocation is allocated, we change its symbol table */
979 if (sr
->sh_flags
& SHF_ALLOC
)
980 sr
->link
= s1
->dynsym
;
983 /* relocate relocation table in 'sr' */
984 static void relocate_rel(TCCState
*s1
, Section
*sr
)
989 s
= s1
->sections
[sr
->sh_info
];
990 for_each_elem(sr
, 0, rel
, ElfW_Rel
)
991 rel
->r_offset
+= s
->sh_addr
;
994 /* count the number of dynamic relocations so that we can reserve
996 static int prepare_dynamic_rel(TCCState
*s1
, Section
*sr
)
999 int sym_index
, esym_index
, type
, count
;
1002 for_each_elem(sr
, 0, rel
, ElfW_Rel
) {
1003 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1004 type
= ELFW(R_TYPE
)(rel
->r_info
);
1006 #if defined(TCC_TARGET_I386)
1008 #elif defined(TCC_TARGET_X86_64)
1015 #if defined(TCC_TARGET_I386)
1017 #elif defined(TCC_TARGET_X86_64)
1020 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
1029 /* allocate the section */
1030 sr
->sh_flags
|= SHF_ALLOC
;
1031 sr
->sh_size
= count
* sizeof(ElfW_Rel
);
1036 static struct sym_attr
*alloc_sym_attr(TCCState
*s1
, int index
)
1039 struct sym_attr
*tab
;
1041 if (index
>= s1
->nb_sym_attrs
) {
1042 /* find immediately bigger power of 2 and reallocate array */
1046 tab
= tcc_realloc(s1
->sym_attrs
, n
* sizeof(*s1
->sym_attrs
));
1047 s1
->sym_attrs
= tab
;
1048 memset(s1
->sym_attrs
+ s1
->nb_sym_attrs
, 0,
1049 (n
- s1
->nb_sym_attrs
) * sizeof(*s1
->sym_attrs
));
1050 s1
->nb_sym_attrs
= n
;
1052 return &s1
->sym_attrs
[index
];
1055 static void build_got(TCCState
*s1
)
1059 /* if no got, then create it */
1060 s1
->got
= new_section(s1
, ".got", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
1061 s1
->got
->sh_entsize
= 4;
1062 add_elf_sym(symtab_section
, 0, 4, ELFW(ST_INFO
)(STB_GLOBAL
, STT_OBJECT
),
1063 0, s1
->got
->sh_num
, "_GLOBAL_OFFSET_TABLE_");
1064 ptr
= section_ptr_add(s1
->got
, 3 * PTR_SIZE
);
1066 /* keep space for _DYNAMIC pointer, if present */
1068 /* two dummy got entries */
1069 write32le(ptr
+ 4, 0);
1070 write32le(ptr
+ 8, 0);
1072 /* keep space for _DYNAMIC pointer, if present */
1074 write32le(ptr
+ 4, 0);
1075 /* two dummy got entries */
1076 write32le(ptr
+ 8, 0);
1077 write32le(ptr
+ 12, 0);
1078 write32le(ptr
+ 16, 0);
1079 write32le(ptr
+ 20, 0);
1083 /* put a got or plt entry corresponding to a symbol in symtab_section. 'size'
1084 and 'info' can be modifed if more precise info comes from the DLL.
1085 Returns offset of GOT or PLT slot. */
1086 static unsigned long put_got_entry(TCCState
*s1
,
1087 int reloc_type
, unsigned long size
, int info
,
1090 int index
, need_plt_entry
;
1093 unsigned long offset
;
1095 struct sym_attr
*symattr
;
1101 #ifdef TCC_TARGET_X86_64
1102 (reloc_type
== R_X86_64_JUMP_SLOT
);
1103 #elif defined(TCC_TARGET_I386)
1104 (reloc_type
== R_386_JMP_SLOT
);
1105 #elif defined(TCC_TARGET_ARM)
1106 (reloc_type
== R_ARM_JUMP_SLOT
);
1107 #elif defined(TCC_TARGET_ARM64)
1108 (reloc_type
== R_AARCH64_JUMP_SLOT
);
1113 if (need_plt_entry
&& !s1
->plt
) {
1115 s1
->plt
= new_section(s1
, ".plt", SHT_PROGBITS
,
1116 SHF_ALLOC
| SHF_EXECINSTR
);
1117 s1
->plt
->sh_entsize
= 4;
1120 /* If a got/plt entry already exists for that symbol, no need to add one */
1121 if (sym_index
< s1
->nb_sym_attrs
) {
1122 if (need_plt_entry
&& s1
->sym_attrs
[sym_index
].plt_offset
)
1123 return s1
->sym_attrs
[sym_index
].plt_offset
;
1124 else if (!need_plt_entry
&& s1
->sym_attrs
[sym_index
].got_offset
)
1125 return s1
->sym_attrs
[sym_index
].got_offset
;
1128 symattr
= alloc_sym_attr(s1
, sym_index
);
1130 /* Only store the GOT offset if it's not generated for the PLT entry. */
1131 if (!need_plt_entry
)
1132 symattr
->got_offset
= s1
->got
->data_offset
;
1134 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1135 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1136 offset
= sym
->st_value
;
1137 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
1138 if (need_plt_entry
) {
1142 unsigned long relofs
;
1144 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
1147 /* if we build a DLL, we add a %ebx offset */
1148 if (s1
->output_type
== TCC_OUTPUT_DLL
)
1154 /* add a PLT entry */
1156 if (plt
->data_offset
== 0) {
1157 /* first plt entry */
1158 p
= section_ptr_add(plt
, 16);
1159 p
[0] = 0xff; /* pushl got + PTR_SIZE */
1160 p
[1] = modrm
+ 0x10;
1161 write32le(p
+ 2, PTR_SIZE
);
1162 p
[6] = 0xff; /* jmp *(got + PTR_SIZE * 2) */
1164 write32le(p
+ 8, PTR_SIZE
* 2);
1167 /* The PLT slot refers to the relocation entry it needs
1168 via offset. The reloc entry is created below, so its
1169 offset is the current data_offset. */
1170 relofs
= s1
->got
->reloc
? s1
->got
->reloc
->data_offset
: 0;
1171 symattr
->plt_offset
= plt
->data_offset
;
1172 p
= section_ptr_add(plt
, 16);
1173 p
[0] = 0xff; /* jmp *(got + x) */
1175 write32le(p
+ 2, s1
->got
->data_offset
);
1176 p
[6] = 0x68; /* push $xxx */
1177 #ifdef TCC_TARGET_X86_64
1178 /* On x86-64, the relocation is referred to by _index_. */
1179 write32le(p
+ 7, relofs
/ sizeof (ElfW_Rel
));
1181 write32le(p
+ 7, relofs
);
1183 p
[11] = 0xe9; /* jmp plt_start */
1184 write32le(p
+ 12, -(plt
->data_offset
));
1186 /* If this was an UNDEF symbol set the offset in the
1187 dynsymtab to the PLT slot, so that PC32 relocs to it
1189 if (sym
->st_shndx
== SHN_UNDEF
)
1190 offset
= plt
->data_offset
- 16;
1192 #elif defined(TCC_TARGET_ARM)
1193 if (need_plt_entry
) {
1197 /* if we build a DLL, we add a %ebx offset */
1198 if (s1
->output_type
== TCC_OUTPUT_DLL
)
1199 tcc_error("DLLs unimplemented!");
1201 /* add a PLT entry */
1203 if (plt
->data_offset
== 0) {
1204 /* first plt entry */
1205 p
= section_ptr_add(plt
, 16);
1206 write32le(p
, 0xe52de004); /* push {lr} */
1207 write32le(p
+4, 0xe59fe010); /* ldr lr, [pc, #16] */
1208 write32le(p
+8, 0xe08fe00e); /* add lr, pc, lr */
1209 write32le(p
+12, 0xe5bef008); /* ldr pc, [lr, #8]! */
1212 symattr
->plt_offset
= plt
->data_offset
;
1213 if (symattr
->plt_thumb_stub
) {
1214 p
= section_ptr_add(plt
, 20);
1215 write32le(p
, 0x4778); /* bx pc */
1216 write32le(p
+2, 0x46c0); /* nop */
1219 p
= section_ptr_add(plt
, 16);
1220 write32le(p
, 0xe59fc004); /* ldr ip, [pc, #4] ; GOT entry offset */
1221 write32le(p
+4, 0xe08fc00c); /* add ip, pc, ip ; addr of GOT entry */
1222 write32le(p
+8, 0xe59cf000); /* ldr pc, [ip] ; jump to GOT entry */
1223 write32le(p
+12, s1
->got
->data_offset
); /* GOT entry off once patched */
1225 /* the symbol is modified so that it will be relocated to
1227 if (sym
->st_shndx
== SHN_UNDEF
)
1228 offset
= plt
->data_offset
- 16;
1230 #elif defined(TCC_TARGET_ARM64)
1231 if (need_plt_entry
) {
1235 if (s1
->output_type
== TCC_OUTPUT_DLL
)
1236 tcc_error("DLLs unimplemented!");
1239 if (plt
->data_offset
== 0)
1240 section_ptr_add(plt
, 32);
1241 symattr
->plt_offset
= plt
->data_offset
;
1242 p
= section_ptr_add(plt
, 16);
1243 write32le(p
, s1
->got
->data_offset
);
1244 write32le(p
+ 4, (uint64_t)s1
->got
->data_offset
>> 32);
1246 if (sym
->st_shndx
== SHN_UNDEF
)
1247 offset
= plt
->data_offset
- 16;
1249 #elif defined(TCC_TARGET_C67)
1251 tcc_error("C67 got not implemented");
1254 #error unsupported CPU
1257 /* XXX This might generate multiple syms for name. */
1258 index
= put_elf_sym(s1
->dynsym
, offset
,
1259 size
, info
, 0, sym
->st_shndx
, name
);
1260 /* Create the relocation (it's against the GOT for PLT
1262 put_elf_reloc(s1
->dynsym
, s1
->got
,
1263 s1
->got
->data_offset
,
1266 /* Without .dynsym (i.e. static link or memory output) we
1267 still need relocs against the generated got, so as to fill
1268 the entries with the symbol values (determined later). */
1269 put_elf_reloc(symtab_section
, s1
->got
,
1270 s1
->got
->data_offset
,
1271 reloc_type
, sym_index
);
1273 /* And now create the GOT slot itself. */
1274 ptr
= section_ptr_add(s1
->got
, PTR_SIZE
);
1277 return symattr
->plt_offset
;
1279 return symattr
->got_offset
;
1282 /* build GOT and PLT entries */
1283 ST_FUNC
void build_got_entries(TCCState
*s1
)
1288 int i
, type
, reloc_type
, sym_index
;
1290 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1291 s
= s1
->sections
[i
];
1292 if (s
->sh_type
!= SHT_RELX
)
1294 /* no need to handle got relocations */
1295 if (s
->link
!= symtab_section
)
1297 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1298 type
= ELFW(R_TYPE
)(rel
->r_info
);
1300 #if defined(TCC_TARGET_I386)
1308 if (type
== R_386_GOT32
|| type
== R_386_GOT32X
||
1309 type
== R_386_PLT32
) {
1310 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1311 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1312 /* look at the symbol got offset. If none, then add one */
1313 if (type
== R_386_GOT32
|| type
== R_386_GOT32X
)
1314 reloc_type
= R_386_GLOB_DAT
;
1316 reloc_type
= R_386_JMP_SLOT
;
1317 put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
1321 #elif defined(TCC_TARGET_ARM)
1331 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1332 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1333 if (type
!= R_ARM_GOTOFF
&& type
!= R_ARM_GOTPC
1334 && sym
->st_shndx
== SHN_UNDEF
) {
1336 /* look at the symbol got offset. If none, then add one */
1337 if (type
== R_ARM_GOT32
)
1338 reloc_type
= R_ARM_GLOB_DAT
;
1340 reloc_type
= R_ARM_JUMP_SLOT
;
1341 ofs
= put_got_entry(s1
, reloc_type
, sym
->st_size
,
1342 sym
->st_info
, sym_index
);
1344 printf ("maybegot: %s, %d, %d --> ofs=0x%x\n",
1345 (char *) symtab_section
->link
->data
+ sym
->st_name
,
1346 type
, sym
->st_shndx
, ofs
);
1348 if (type
!= R_ARM_GOT32
) {
1349 addr_t
*ptr
= (addr_t
*)(s1
->sections
[s
->sh_info
]->data
1351 /* x must be signed! */
1352 int x
= *ptr
& 0xffffff;
1358 printf ("insn=0x%x --> 0x%x (x==0x%x)\n", *ptr
,
1359 (*ptr
& 0xff000000) | x
, x
);
1361 *ptr
= (*ptr
& 0xff000000) | x
;
1365 case R_ARM_THM_JUMP24
:
1366 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1367 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1368 /* We are relocating a jump from thumb code to arm code */
1369 if (sym
->st_shndx
!= SHN_UNDEF
&& !(sym
->st_value
& 1)) {
1372 char *name
, buf
[1024];
1373 Section
*text_section
;
1375 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1376 text_section
= s1
->sections
[sym
->st_shndx
];
1377 /* Modify reloc to target a thumb stub to switch to ARM */
1378 snprintf(buf
, sizeof(buf
), "%s_from_thumb", name
);
1379 index
= put_elf_sym(symtab_section
,
1380 text_section
->data_offset
+ 1,
1381 sym
->st_size
, sym
->st_info
, 0,
1382 sym
->st_shndx
, buf
);
1383 rel
->r_info
= ELFW(R_INFO
)(index
, type
);
1384 /* Create a thumb stub fonction to switch to ARM mode */
1385 put_elf_reloc(symtab_section
, text_section
,
1386 text_section
->data_offset
+ 4, R_ARM_JUMP24
,
1388 p
= section_ptr_add(text_section
, 8);
1389 write32le(p
, 0x4778); /* bx pc */
1390 write32le(p
+2, 0x46c0); /* nop */
1391 write32le(p
+4, 0xeafffffe); /* b $sym */
1393 #elif defined(TCC_TARGET_ARM64)
1394 //xx Other cases may be required here:
1395 case R_AARCH64_ADR_GOT_PAGE
:
1396 case R_AARCH64_LD64_GOT_LO12_NC
:
1399 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1400 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1401 reloc_type
= R_AARCH64_GLOB_DAT
;
1402 put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
1406 case R_AARCH64_JUMP26
:
1407 case R_AARCH64_CALL26
:
1410 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1411 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1412 if (sym
->st_shndx
== SHN_UNDEF
) {
1414 reloc_type
= R_AARCH64_JUMP_SLOT
;
1415 ofs
= put_got_entry(s1
, reloc_type
, sym
->st_size
,
1416 sym
->st_info
, sym_index
);
1417 /* We store the place of the generated PLT slot
1419 rel
->r_addend
+= ofs
;
1422 #elif defined(TCC_TARGET_C67)
1429 if (type
== R_C60_GOT32
|| type
== R_C60_PLT32
) {
1430 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1431 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1432 /* look at the symbol got offset. If none, then add one */
1433 if (type
== R_C60_GOT32
)
1434 reloc_type
= R_C60_GLOB_DAT
;
1436 reloc_type
= R_C60_JMP_SLOT
;
1437 put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
1441 #elif defined(TCC_TARGET_X86_64)
1442 case R_X86_64_GOT32
:
1443 case R_X86_64_GOTTPOFF
:
1444 case R_X86_64_GOTPCREL
:
1445 case R_X86_64_GOTPCRELX
:
1446 case R_X86_64_REX_GOTPCRELX
:
1447 case R_X86_64_PLT32
:
1448 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
1449 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1450 if (type
== R_X86_64_PLT32
&&
1451 ELFW(ST_VISIBILITY
)(sym
->st_other
) != STV_DEFAULT
)
1453 rel
->r_info
= ELFW(R_INFO
)(sym_index
, R_X86_64_PC32
);
1459 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1461 if (type
== R_X86_64_GOT32
|| type
== R_X86_64_GOTPCREL
||
1462 type
== R_X86_64_GOTPCRELX
||
1463 type
== R_X86_64_REX_GOTPCRELX
||
1464 type
== R_X86_64_PLT32
) {
1466 /* look at the symbol got offset. If none, then add one */
1467 if (type
== R_X86_64_PLT32
)
1468 reloc_type
= R_X86_64_JUMP_SLOT
;
1470 reloc_type
= R_X86_64_GLOB_DAT
;
1471 ofs
= put_got_entry(s1
, reloc_type
, sym
->st_size
,
1472 sym
->st_info
, sym_index
);
1473 if (type
== R_X86_64_PLT32
)
1474 /* We store the place of the generated PLT slot
1476 rel
->r_addend
+= ofs
;
1480 #error unsupported CPU
1489 ST_FUNC Section
*new_symtab(TCCState
*s1
,
1490 const char *symtab_name
, int sh_type
, int sh_flags
,
1491 const char *strtab_name
,
1492 const char *hash_name
, int hash_sh_flags
)
1494 Section
*symtab
, *strtab
, *hash
;
1495 int *ptr
, nb_buckets
;
1497 symtab
= new_section(s1
, symtab_name
, sh_type
, sh_flags
);
1498 symtab
->sh_entsize
= sizeof(ElfW(Sym
));
1499 strtab
= new_section(s1
, strtab_name
, SHT_STRTAB
, sh_flags
);
1500 put_elf_str(strtab
, "");
1501 symtab
->link
= strtab
;
1502 put_elf_sym(symtab
, 0, 0, 0, 0, 0, NULL
);
1506 hash
= new_section(s1
, hash_name
, SHT_HASH
, hash_sh_flags
);
1507 hash
->sh_entsize
= sizeof(int);
1508 symtab
->hash
= hash
;
1509 hash
->link
= symtab
;
1511 ptr
= section_ptr_add(hash
, (2 + nb_buckets
+ 1) * sizeof(int));
1512 ptr
[0] = nb_buckets
;
1514 memset(ptr
+ 2, 0, (nb_buckets
+ 1) * sizeof(int));
1518 /* put dynamic tag */
1519 static void put_dt(Section
*dynamic
, int dt
, addr_t val
)
1522 dyn
= section_ptr_add(dynamic
, sizeof(ElfW(Dyn
)));
1524 dyn
->d_un
.d_val
= val
;
1527 static void add_init_array_defines(TCCState
*s1
, const char *section_name
)
1531 char sym_start
[1024];
1534 snprintf(sym_start
, sizeof(sym_start
), "__%s_start", section_name
+ 1);
1535 snprintf(sym_end
, sizeof(sym_end
), "__%s_end", section_name
+ 1);
1537 s
= find_section(s1
, section_name
);
1542 end_offset
= s
->data_offset
;
1545 add_elf_sym(symtab_section
,
1547 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1548 s
->sh_num
, sym_start
);
1549 add_elf_sym(symtab_section
,
1551 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1552 s
->sh_num
, sym_end
);
1555 static int tcc_add_support(TCCState
*s1
, const char *filename
)
1558 snprintf(buf
, sizeof(buf
), "%s/%s/%s", s1
->tcc_lib_path
,
1559 /* an cpu specific path inside tcc_lib_path, mainly for keeping libtcc1.a */
1560 #ifdef TCC_TARGET_I386
1563 #ifdef TCC_TARGET_X86_64
1566 #ifdef TCC_TARGET_ARM
1569 #ifdef TCC_TARGET_ARM64
1572 #ifdef TCC_TARGET_C67
1576 return tcc_add_file(s1
, buf
);
1579 ST_FUNC
void tcc_add_bcheck(TCCState
*s1
)
1581 #ifdef CONFIG_TCC_BCHECK
1584 if (0 == s1
->do_bounds_check
)
1587 /* XXX: add an object file to do that */
1588 ptr
= section_ptr_add(bounds_section
, sizeof(*ptr
));
1590 add_elf_sym(symtab_section
, 0, 0,
1591 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1592 bounds_section
->sh_num
, "__bounds_start");
1593 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
) {
1594 /* add 'call __bound_init()' in .init section */
1596 /* XXX not called on MSYS, reason is unknown. For this
1597 case a call to __bound_init is performed in bcheck.c
1598 when __bound_ptr_add, __bound_new_region,
1599 __bound_delete_region called */
1601 int sym_index
= find_elf_sym(symtab_section
, "__bound_init");
1603 Section
*init_section
= find_section(s1
, ".init");
1604 unsigned char *pinit
= section_ptr_add(init_section
, 5);
1606 write32le(pinit
+ 1, -4);
1607 put_elf_reloc(symtab_section
, init_section
,
1608 init_section
->data_offset
- 4, R_386_PC32
, sym_index
);
1611 tcc_warning("__bound_init not defined");
1616 /* add tcc runtime libraries */
1617 ST_FUNC
void tcc_add_runtime(TCCState
*s1
)
1619 tcc_add_pragma_libs(s1
);
1622 if (!s1
->nostdlib
) {
1623 tcc_add_library(s1
, "c");
1624 #ifdef CONFIG_USE_LIBGCC
1625 if (!s1
->static_link
) {
1626 tcc_add_file(s1
, TCC_LIBGCC
);
1629 tcc_add_support(s1
, "libtcc1.a");
1632 /* tcc_add_bcheck tries to relocate a call to __bound_init in _init so
1633 libtcc1.a must be loaded before for __bound_init to be defined and
1634 crtn.o must be loaded after to not finalize _init too early. */
1637 if (!s1
->nostdlib
) {
1638 /* add crt end if not memory output */
1639 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
)
1640 tcc_add_crt(s1
, "crtn.o");
1644 /* add various standard linker symbols (must be done after the
1645 sections are filled (for example after allocating common
1647 ST_FUNC
void tcc_add_linker_symbols(TCCState
*s1
)
1653 add_elf_sym(symtab_section
,
1654 text_section
->data_offset
, 0,
1655 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1656 text_section
->sh_num
, "_etext");
1657 add_elf_sym(symtab_section
,
1658 data_section
->data_offset
, 0,
1659 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1660 data_section
->sh_num
, "_edata");
1661 add_elf_sym(symtab_section
,
1662 bss_section
->data_offset
, 0,
1663 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1664 bss_section
->sh_num
, "_end");
1665 /* horrible new standard ldscript defines */
1666 add_init_array_defines(s1
, ".preinit_array");
1667 add_init_array_defines(s1
, ".init_array");
1668 add_init_array_defines(s1
, ".fini_array");
1670 /* add start and stop symbols for sections whose name can be
1672 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1673 s
= s1
->sections
[i
];
1674 if (s
->sh_type
== SHT_PROGBITS
&&
1675 (s
->sh_flags
& SHF_ALLOC
)) {
1679 /* check if section name can be expressed in C */
1685 if (!isid(ch
) && !isnum(ch
))
1689 snprintf(buf
, sizeof(buf
), "__start_%s", s
->name
);
1690 add_elf_sym(symtab_section
,
1692 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1694 snprintf(buf
, sizeof(buf
), "__stop_%s", s
->name
);
1695 add_elf_sym(symtab_section
,
1697 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1704 static void tcc_output_binary(TCCState
*s1
, FILE *f
,
1705 const int *sec_order
)
1708 int i
, offset
, size
;
1711 for(i
=1;i
<s1
->nb_sections
;i
++) {
1712 s
= s1
->sections
[sec_order
[i
]];
1713 if (s
->sh_type
!= SHT_NOBITS
&&
1714 (s
->sh_flags
& SHF_ALLOC
)) {
1715 while (offset
< s
->sh_offset
) {
1720 fwrite(s
->data
, 1, size
, f
);
1726 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1728 #define EXTRA_RELITEMS 14
1730 /* move the relocation value from .dynsym to .got */
1731 static void patch_dynsym_undef(TCCState
*s1
, Section
*s
)
1733 uint32_t *gotd
= (void *)s1
->got
->data
;
1736 gotd
+= 3; /* dummy entries in .got */
1737 /* relocate symbols in .dynsym */
1738 for_each_elem(s
, 1, sym
, ElfW(Sym
)) {
1739 if (sym
->st_shndx
== SHN_UNDEF
) {
1740 *gotd
++ = sym
->st_value
+ 6; /* XXX 6 is magic ? */
1747 #define EXTRA_RELITEMS 9
1749 /* zero plt offsets of weak symbols in .dynsym */
1750 static void patch_dynsym_undef(TCCState
*s1
, Section
*s
)
1754 for_each_elem(s
, 1, sym
, ElfW(Sym
))
1755 if (sym
->st_shndx
== SHN_UNDEF
&& ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
)
1760 ST_FUNC
void fill_got_entry(TCCState
*s1
, ElfW_Rel
*rel
)
1762 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1763 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1764 unsigned long offset
;
1766 if (sym_index
>= s1
->nb_sym_attrs
)
1768 offset
= s1
->sym_attrs
[sym_index
].got_offset
;
1769 section_reserve(s1
->got
, offset
+ PTR_SIZE
);
1770 #ifdef TCC_TARGET_X86_64
1771 /* only works for x86-64 */
1772 write32le(s1
->got
->data
+ offset
+ 4, sym
->st_value
>> 32);
1774 write32le(s1
->got
->data
+ offset
, sym
->st_value
& 0xffffffff);
1777 /* Perform relocation to GOT or PLT entries */
1778 ST_FUNC
void fill_got(TCCState
*s1
)
1784 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1785 s
= s1
->sections
[i
];
1786 if (s
->sh_type
!= SHT_RELX
)
1788 /* no need to handle got relocations */
1789 if (s
->link
!= symtab_section
)
1791 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1792 switch (ELFW(R_TYPE
) (rel
->r_info
)) {
1793 case R_X86_64_GOT32
:
1794 case R_X86_64_GOTPCREL
:
1795 case R_X86_64_GOTPCRELX
:
1796 case R_X86_64_REX_GOTPCRELX
:
1797 case R_X86_64_PLT32
:
1798 fill_got_entry(s1
, rel
);
1805 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1806 in shared libraries and export non local defined symbols to shared libraries
1807 if -rdynamic switch was given on command line */
1808 static void bind_exe_dynsyms(TCCState
*s1
)
1811 int sym_index
, index
;
1812 ElfW(Sym
) *sym
, *esym
;
1815 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1816 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1817 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1818 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1819 if (sym
->st_shndx
== SHN_UNDEF
) {
1820 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1821 sym_index
= find_elf_sym(s1
->dynsymtab_section
, name
);
1823 esym
= &((ElfW(Sym
) *)s1
->dynsymtab_section
->data
)[sym_index
];
1824 type
= ELFW(ST_TYPE
)(esym
->st_info
);
1825 if ((type
== STT_FUNC
) || (type
== STT_GNU_IFUNC
)) {
1826 /* Indirect functions shall have STT_FUNC type in executable
1827 * dynsym section. Indeed, a dlsym call following a lazy
1828 * resolution would pick the symbol value from the
1829 * executable dynsym entry which would contain the address
1830 * of the function wanted by the caller of dlsym instead of
1831 * the address of the function that would return that
1833 put_got_entry(s1
, R_JMP_SLOT
, esym
->st_size
,
1834 ELFW(ST_INFO
)(STB_GLOBAL
,STT_FUNC
),
1835 sym
- (ElfW(Sym
) *)symtab_section
->data
);
1836 } else if (type
== STT_OBJECT
) {
1837 unsigned long offset
;
1839 offset
= bss_section
->data_offset
;
1840 /* XXX: which alignment ? */
1841 offset
= (offset
+ 16 - 1) & -16;
1842 index
= put_elf_sym(s1
->dynsym
, offset
, esym
->st_size
,
1843 esym
->st_info
, 0, bss_section
->sh_num
,
1845 /* Ensure R_COPY works for weak symbol aliases */
1846 if (ELFW(ST_BIND
)(esym
->st_info
) == STB_WEAK
) {
1847 for_each_elem(s1
->dynsymtab_section
, 1, dynsym
, ElfW(Sym
)) {
1848 if ((dynsym
->st_value
== esym
->st_value
)
1849 && (ELFW(ST_BIND
)(dynsym
->st_info
) == STB_GLOBAL
)) {
1850 char *dynname
= (char *) s1
->dynsymtab_section
->link
->data
1852 put_elf_sym(s1
->dynsym
, offset
, dynsym
->st_size
,
1854 bss_section
->sh_num
, dynname
);
1859 put_elf_reloc(s1
->dynsym
, bss_section
,
1860 offset
, R_COPY
, index
);
1861 offset
+= esym
->st_size
;
1862 bss_section
->data_offset
= offset
;
1865 /* STB_WEAK undefined symbols are accepted */
1866 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1867 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
||
1868 !strcmp(name
, "_fp_hw")) {
1870 tcc_error_noabort("undefined symbol '%s'", name
);
1873 } else if (s1
->rdynamic
&& ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1874 /* if -rdynamic option, then export all non local symbols */
1875 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1876 put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1877 0, sym
->st_shndx
, name
);
1882 /* Bind symbols of libraries: export non local symbols of executable that
1883 resolve undefined symbols of shared libraries */
1884 static void bind_libs_dynsyms(TCCState
*s1
)
1888 ElfW(Sym
) *sym
, *esym
;
1890 /* now look at unresolved dynamic symbols and export
1891 corresponding symbol */
1892 for_each_elem(s1
->dynsymtab_section
, 1, esym
, ElfW(Sym
)) {
1893 name
= (char *) s1
->dynsymtab_section
->link
->data
+ esym
->st_name
;
1894 sym_index
= find_elf_sym(symtab_section
, name
);
1896 /* XXX: avoid adding a symbol if already present because of
1898 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1899 if (sym
->st_shndx
!= SHN_UNDEF
)
1900 put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1901 sym
->st_info
, 0, sym
->st_shndx
, name
);
1902 } else if (esym
->st_shndx
== SHN_UNDEF
) {
1903 /* weak symbols can stay undefined */
1904 if (ELFW(ST_BIND
)(esym
->st_info
) != STB_WEAK
)
1905 tcc_warning("undefined dynamic symbol '%s'", name
);
1910 /* Export all non local symbols (for shared libraries) */
1911 static void export_global_syms(TCCState
*s1
)
1913 int nb_syms
, dynindex
, index
;
1917 nb_syms
= symtab_section
->data_offset
/ sizeof(ElfW(Sym
));
1918 s1
->symtab_to_dynsym
= tcc_mallocz(sizeof(int) * nb_syms
);
1919 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1920 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1921 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1922 dynindex
= put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1923 sym
->st_info
, 0, sym
->st_shndx
, name
);
1924 index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1925 s1
->symtab_to_dynsym
[index
] = dynindex
;
1930 /* relocate the PLT: compute addresses and offsets in the PLT now that final
1931 address for PLT and GOT are known (see fill_program_header) */
1932 ST_FUNC
void relocate_plt(TCCState
*s1
)
1940 p_end
= p
+ s1
->plt
->data_offset
;
1942 #if defined(TCC_TARGET_I386)
1943 write32le(p
+ 2, read32le(p
+ 2) + s1
->got
->sh_addr
);
1944 write32le(p
+ 8, read32le(p
+ 8) + s1
->got
->sh_addr
);
1947 write32le(p
+ 2, read32le(p
+ 2) + s1
->got
->sh_addr
);
1950 #elif defined(TCC_TARGET_X86_64)
1951 int x
= s1
->got
->sh_addr
- s1
->plt
->sh_addr
- 6;
1952 write32le(p
+ 2, read32le(p
+ 2) + x
);
1953 write32le(p
+ 8, read32le(p
+ 8) + x
- 6);
1956 write32le(p
+ 2, read32le(p
+ 2) + x
+ s1
->plt
->data
- p
);
1959 #elif defined(TCC_TARGET_ARM)
1961 x
=s1
->got
->sh_addr
- s1
->plt
->sh_addr
- 12;
1964 if (read32le(p
) == 0x46c04778) /* PLT Thumb stub present */
1966 write32le(p
+ 12, x
+ read32le(p
+ 12) + s1
->plt
->data
- p
);
1969 #elif defined(TCC_TARGET_ARM64)
1970 uint64_t plt
= s1
->plt
->sh_addr
;
1971 uint64_t got
= s1
->got
->sh_addr
;
1972 uint64_t off
= (got
>> 12) - (plt
>> 12);
1973 if ((off
+ ((uint32_t)1 << 20)) >> 21)
1974 tcc_error("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", off
, got
, plt
);
1975 write32le(p
, 0xa9bf7bf0); // stp x16,x30,[sp,#-16]!
1976 write32le(p
+ 4, (0x90000010 | // adrp x16,...
1977 (off
& 0x1ffffc) << 3 | (off
& 3) << 29));
1978 write32le(p
+ 8, (0xf9400211 | // ldr x17,[x16,#...]
1979 (got
& 0xff8) << 7));
1980 write32le(p
+ 12, (0x91000210 | // add x16,x16,#...
1981 (got
& 0xfff) << 10));
1982 write32le(p
+ 16, 0xd61f0220); // br x17
1983 write32le(p
+ 20, 0xd503201f); // nop
1984 write32le(p
+ 24, 0xd503201f); // nop
1985 write32le(p
+ 28, 0xd503201f); // nop
1988 uint64_t pc
= plt
+ (p
- s1
->plt
->data
);
1989 uint64_t addr
= got
+ read64le(p
);
1990 uint64_t off
= (addr
>> 12) - (pc
>> 12);
1991 if ((off
+ ((uint32_t)1 << 20)) >> 21)
1992 tcc_error("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", off
, addr
, pc
);
1993 write32le(p
, (0x90000010 | // adrp x16,...
1994 (off
& 0x1ffffc) << 3 | (off
& 3) << 29));
1995 write32le(p
+ 4, (0xf9400211 | // ldr x17,[x16,#...]
1996 (addr
& 0xff8) << 7));
1997 write32le(p
+ 8, (0x91000210 | // add x16,x16,#...
1998 (addr
& 0xfff) << 10));
1999 write32le(p
+ 12, 0xd61f0220); // br x17
2002 #elif defined(TCC_TARGET_C67)
2005 #error unsupported CPU
2010 /* Allocate strings for section names and decide if an unallocated section
2013 NOTE: the strsec section comes last, so its size is also correct ! */
2014 static void alloc_sec_names(TCCState
*s1
, int file_type
, Section
*strsec
)
2019 /* Allocate strings for section names */
2020 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2021 s
= s1
->sections
[i
];
2022 s
->sh_name
= put_elf_str(strsec
, s
->name
);
2023 /* when generating a DLL, we include relocations but we may
2025 if (file_type
== TCC_OUTPUT_DLL
&&
2026 s
->sh_type
== SHT_RELX
&&
2027 !(s
->sh_flags
& SHF_ALLOC
)) {
2028 /* gr: avoid bogus relocs for empty (debug) sections */
2029 if (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_ALLOC
)
2030 prepare_dynamic_rel(s1
, s
);
2031 else if (s1
->do_debug
)
2032 s
->sh_size
= s
->data_offset
;
2033 } else if (s1
->do_debug
||
2034 file_type
== TCC_OUTPUT_OBJ
||
2035 file_type
== TCC_OUTPUT_EXE
||
2036 (s
->sh_flags
& SHF_ALLOC
) ||
2037 i
== (s1
->nb_sections
- 1)) {
2038 /* we output all sections if debug or object file */
2039 s
->sh_size
= s
->data_offset
;
2044 /* Info to be copied in dynamic section */
2048 unsigned long dyn_rel_off
;
2051 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2057 /* Assign sections to segments and decide how are sections laid out when loaded
2058 in memory. This function also fills corresponding program headers. */
2059 static int layout_sections(TCCState
*s1
, ElfW(Phdr
) *phdr
, int phnum
,
2060 Section
*interp
, Section
* strsec
,
2061 struct dyn_inf
*dyninf
, int *sec_order
)
2063 int i
, j
, k
, file_type
, sh_order_index
, file_offset
;
2064 unsigned long s_align
;
2070 file_type
= s1
->output_type
;
2073 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
2074 file_offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
2075 s_align
= ELF_PAGE_SIZE
;
2076 if (s1
->section_align
)
2077 s_align
= s1
->section_align
;
2080 if (s1
->has_text_addr
) {
2081 int a_offset
, p_offset
;
2082 addr
= s1
->text_addr
;
2083 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
2085 a_offset
= (int) (addr
& (s_align
- 1));
2086 p_offset
= file_offset
& (s_align
- 1);
2087 if (a_offset
< p_offset
)
2088 a_offset
+= s_align
;
2089 file_offset
+= (a_offset
- p_offset
);
2091 if (file_type
== TCC_OUTPUT_DLL
)
2094 addr
= ELF_START_ADDR
;
2095 /* compute address after headers */
2096 addr
+= (file_offset
& (s_align
- 1));
2100 /* Leave one program headers for the program interpreter and one for
2101 the program header table itself if needed. These are done later as
2102 they require section layout to be done first. */
2104 ph
+= 1 + HAVE_PHDR
;
2106 /* dynamic relocation table information, for .dynamic section */
2107 dyninf
->rel_addr
= dyninf
->rel_size
= 0;
2108 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2109 dyninf
->bss_addr
= dyninf
->bss_size
= 0;
2112 for(j
= 0; j
< 2; j
++) {
2113 ph
->p_type
= PT_LOAD
;
2115 ph
->p_flags
= PF_R
| PF_X
;
2117 ph
->p_flags
= PF_R
| PF_W
;
2118 ph
->p_align
= s_align
;
2120 /* Decide the layout of sections loaded in memory. This must
2121 be done before program headers are filled since they contain
2122 info about the layout. We do the following ordering: interp,
2123 symbol tables, relocations, progbits, nobits */
2124 /* XXX: do faster and simpler sorting */
2125 for(k
= 0; k
< 5; k
++) {
2126 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2127 s
= s1
->sections
[i
];
2128 /* compute if section should be included */
2130 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
2134 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
2135 (SHF_ALLOC
| SHF_WRITE
))
2141 } else if (s
->sh_type
== SHT_DYNSYM
||
2142 s
->sh_type
== SHT_STRTAB
||
2143 s
->sh_type
== SHT_HASH
) {
2146 } else if (s
->sh_type
== SHT_RELX
) {
2149 } else if (s
->sh_type
== SHT_NOBITS
) {
2156 sec_order
[sh_order_index
++] = i
;
2158 /* section matches: we align it and add its size */
2160 addr
= (addr
+ s
->sh_addralign
- 1) &
2161 ~(s
->sh_addralign
- 1);
2162 file_offset
+= (int) ( addr
- tmp
);
2163 s
->sh_offset
= file_offset
;
2166 /* update program header infos */
2167 if (ph
->p_offset
== 0) {
2168 ph
->p_offset
= file_offset
;
2170 ph
->p_paddr
= ph
->p_vaddr
;
2172 /* update dynamic relocation infos */
2173 if (s
->sh_type
== SHT_RELX
) {
2174 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2175 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.got")) {
2176 dyninf
->rel_addr
= addr
;
2177 dyninf
->rel_size
+= s
->sh_size
; /* XXX only first rel. */
2179 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.bss")) {
2180 dyninf
->bss_addr
= addr
;
2181 dyninf
->bss_size
= s
->sh_size
; /* XXX only first rel. */
2184 if (dyninf
->rel_size
== 0)
2185 dyninf
->rel_addr
= addr
;
2186 dyninf
->rel_size
+= s
->sh_size
;
2190 if (s
->sh_type
!= SHT_NOBITS
)
2191 file_offset
+= s
->sh_size
;
2195 /* Make the first PT_LOAD segment include the program
2196 headers itself (and the ELF header as well), it'll
2197 come out with same memory use but will make various
2198 tools like binutils strip work better. */
2199 ph
->p_offset
&= ~(ph
->p_align
- 1);
2200 ph
->p_vaddr
&= ~(ph
->p_align
- 1);
2201 ph
->p_paddr
&= ~(ph
->p_align
- 1);
2203 ph
->p_filesz
= file_offset
- ph
->p_offset
;
2204 ph
->p_memsz
= addr
- ph
->p_vaddr
;
2207 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
) {
2208 /* if in the middle of a page, we duplicate the page in
2209 memory so that one copy is RX and the other is RW */
2210 if ((addr
& (s_align
- 1)) != 0)
2213 addr
= (addr
+ s_align
- 1) & ~(s_align
- 1);
2214 file_offset
= (file_offset
+ s_align
- 1) & ~(s_align
- 1);
2220 /* all other sections come after */
2221 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2222 s
= s1
->sections
[i
];
2223 if (phnum
> 0 && (s
->sh_flags
& SHF_ALLOC
))
2225 sec_order
[sh_order_index
++] = i
;
2227 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
2228 ~(s
->sh_addralign
- 1);
2229 s
->sh_offset
= file_offset
;
2230 if (s
->sh_type
!= SHT_NOBITS
)
2231 file_offset
+= s
->sh_size
;
2237 static void fill_unloadable_phdr(ElfW(Phdr
) *phdr
, int phnum
, Section
*interp
,
2242 /* if interpreter, then add corresponding program header */
2248 int len
= phnum
* sizeof(ElfW(Phdr
));
2250 ph
->p_type
= PT_PHDR
;
2251 ph
->p_offset
= sizeof(ElfW(Ehdr
));
2252 ph
->p_vaddr
= interp
->sh_addr
- len
;
2253 ph
->p_paddr
= ph
->p_vaddr
;
2254 ph
->p_filesz
= ph
->p_memsz
= len
;
2255 ph
->p_flags
= PF_R
| PF_X
;
2256 ph
->p_align
= 4; /* interp->sh_addralign; */
2260 ph
->p_type
= PT_INTERP
;
2261 ph
->p_offset
= interp
->sh_offset
;
2262 ph
->p_vaddr
= interp
->sh_addr
;
2263 ph
->p_paddr
= ph
->p_vaddr
;
2264 ph
->p_filesz
= interp
->sh_size
;
2265 ph
->p_memsz
= interp
->sh_size
;
2267 ph
->p_align
= interp
->sh_addralign
;
2270 /* if dynamic section, then add corresponding program header */
2272 ph
= &phdr
[phnum
- 1];
2274 ph
->p_type
= PT_DYNAMIC
;
2275 ph
->p_offset
= dynamic
->sh_offset
;
2276 ph
->p_vaddr
= dynamic
->sh_addr
;
2277 ph
->p_paddr
= ph
->p_vaddr
;
2278 ph
->p_filesz
= dynamic
->sh_size
;
2279 ph
->p_memsz
= dynamic
->sh_size
;
2280 ph
->p_flags
= PF_R
| PF_W
;
2281 ph
->p_align
= dynamic
->sh_addralign
;
2285 /* Fill the dynamic section with tags describing the address and size of
2287 static void fill_dynamic(TCCState
*s1
, struct dyn_inf
*dyninf
)
2291 dynamic
= dyninf
->dynamic
;
2293 /* put dynamic section entries */
2294 dynamic
->data_offset
= dyninf
->dyn_rel_off
;
2295 put_dt(dynamic
, DT_HASH
, s1
->dynsym
->hash
->sh_addr
);
2296 put_dt(dynamic
, DT_STRTAB
, dyninf
->dynstr
->sh_addr
);
2297 put_dt(dynamic
, DT_SYMTAB
, s1
->dynsym
->sh_addr
);
2298 put_dt(dynamic
, DT_STRSZ
, dyninf
->dynstr
->data_offset
);
2299 put_dt(dynamic
, DT_SYMENT
, sizeof(ElfW(Sym
)));
2300 #if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
2301 put_dt(dynamic
, DT_RELA
, dyninf
->rel_addr
);
2302 put_dt(dynamic
, DT_RELASZ
, dyninf
->rel_size
);
2303 put_dt(dynamic
, DT_RELAENT
, sizeof(ElfW_Rel
));
2305 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2306 put_dt(dynamic
, DT_PLTGOT
, s1
->got
->sh_addr
);
2307 put_dt(dynamic
, DT_PLTRELSZ
, dyninf
->rel_size
);
2308 put_dt(dynamic
, DT_JMPREL
, dyninf
->rel_addr
);
2309 put_dt(dynamic
, DT_PLTREL
, DT_REL
);
2310 put_dt(dynamic
, DT_REL
, dyninf
->bss_addr
);
2311 put_dt(dynamic
, DT_RELSZ
, dyninf
->bss_size
);
2313 put_dt(dynamic
, DT_REL
, dyninf
->rel_addr
);
2314 put_dt(dynamic
, DT_RELSZ
, dyninf
->rel_size
);
2315 put_dt(dynamic
, DT_RELENT
, sizeof(ElfW_Rel
));
2319 put_dt(dynamic
, DT_DEBUG
, 0);
2320 put_dt(dynamic
, DT_NULL
, 0);
2323 /* Relocate remaining sections and symbols (that is those not related to
2325 static int final_sections_reloc(TCCState
*s1
)
2330 relocate_syms(s1
, 0);
2332 if (s1
->nb_errors
!= 0)
2335 /* relocate sections */
2336 /* XXX: ignore sections with allocated relocations ? */
2337 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2338 s
= s1
->sections
[i
];
2339 #ifdef TCC_TARGET_I386
2340 if (s
->reloc
&& s
!= s1
->got
&& (s
->sh_flags
& SHF_ALLOC
)) //gr
2341 /* On X86 gdb 7.3 works in any case but gdb 6.6 will crash if SHF_ALLOC
2342 checking is removed */
2344 if (s
->reloc
&& s
!= s1
->got
)
2345 /* On X86_64 gdb 7.3 will crash if SHF_ALLOC checking is present */
2347 relocate_section(s1
, s
);
2350 /* relocate relocation entries if the relocation tables are
2351 allocated in the executable */
2352 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2353 s
= s1
->sections
[i
];
2354 if ((s
->sh_flags
& SHF_ALLOC
) &&
2355 s
->sh_type
== SHT_RELX
) {
2356 relocate_rel(s1
, s
);
2362 /* Create an ELF file on disk.
2363 This function handle ELF specific layout requirements */
2364 static void tcc_output_elf(TCCState
*s1
, FILE *f
, int phnum
, ElfW(Phdr
) *phdr
,
2365 int file_offset
, int *sec_order
)
2367 int i
, shnum
, offset
, size
, file_type
;
2370 ElfW(Shdr
) shdr
, *sh
;
2372 file_type
= s1
->output_type
;
2373 shnum
= s1
->nb_sections
;
2375 memset(&ehdr
, 0, sizeof(ehdr
));
2378 ehdr
.e_phentsize
= sizeof(ElfW(Phdr
));
2379 ehdr
.e_phnum
= phnum
;
2380 ehdr
.e_phoff
= sizeof(ElfW(Ehdr
));
2384 file_offset
= (file_offset
+ 3) & -4;
2387 ehdr
.e_ident
[0] = ELFMAG0
;
2388 ehdr
.e_ident
[1] = ELFMAG1
;
2389 ehdr
.e_ident
[2] = ELFMAG2
;
2390 ehdr
.e_ident
[3] = ELFMAG3
;
2391 ehdr
.e_ident
[4] = ELFCLASSW
;
2392 ehdr
.e_ident
[5] = ELFDATA2LSB
;
2393 ehdr
.e_ident
[6] = EV_CURRENT
;
2394 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2395 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
2397 #ifdef TCC_TARGET_ARM
2399 ehdr
.e_ident
[EI_OSABI
] = 0;
2400 ehdr
.e_flags
= EF_ARM_EABI_VER4
;
2401 if (file_type
== TCC_OUTPUT_EXE
|| file_type
== TCC_OUTPUT_DLL
)
2402 ehdr
.e_flags
|= EF_ARM_HASENTRY
;
2403 if (s1
->float_abi
== ARM_HARD_FLOAT
)
2404 ehdr
.e_flags
|= EF_ARM_VFP_FLOAT
;
2406 ehdr
.e_flags
|= EF_ARM_SOFT_FLOAT
;
2408 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_ARM
;
2413 case TCC_OUTPUT_EXE
:
2414 ehdr
.e_type
= ET_EXEC
;
2415 ehdr
.e_entry
= get_elf_sym_addr(s1
, "_start", 1);
2417 case TCC_OUTPUT_DLL
:
2418 ehdr
.e_type
= ET_DYN
;
2419 ehdr
.e_entry
= text_section
->sh_addr
; /* XXX: is it correct ? */
2421 case TCC_OUTPUT_OBJ
:
2422 ehdr
.e_type
= ET_REL
;
2425 ehdr
.e_machine
= EM_TCC_TARGET
;
2426 ehdr
.e_version
= EV_CURRENT
;
2427 ehdr
.e_shoff
= file_offset
;
2428 ehdr
.e_ehsize
= sizeof(ElfW(Ehdr
));
2429 ehdr
.e_shentsize
= sizeof(ElfW(Shdr
));
2430 ehdr
.e_shnum
= shnum
;
2431 ehdr
.e_shstrndx
= shnum
- 1;
2433 fwrite(&ehdr
, 1, sizeof(ElfW(Ehdr
)), f
);
2434 fwrite(phdr
, 1, phnum
* sizeof(ElfW(Phdr
)), f
);
2435 offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
2437 sort_syms(s1
, symtab_section
);
2438 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2439 s
= s1
->sections
[sec_order
[i
]];
2440 if (s
->sh_type
!= SHT_NOBITS
) {
2441 if (s
->sh_type
== SHT_DYNSYM
)
2442 patch_dynsym_undef(s1
, s
);
2443 while (offset
< s
->sh_offset
) {
2449 fwrite(s
->data
, 1, size
, f
);
2454 /* output section headers */
2455 while (offset
< ehdr
.e_shoff
) {
2460 for(i
= 0; i
< s1
->nb_sections
; i
++) {
2462 memset(sh
, 0, sizeof(ElfW(Shdr
)));
2463 s
= s1
->sections
[i
];
2465 sh
->sh_name
= s
->sh_name
;
2466 sh
->sh_type
= s
->sh_type
;
2467 sh
->sh_flags
= s
->sh_flags
;
2468 sh
->sh_entsize
= s
->sh_entsize
;
2469 sh
->sh_info
= s
->sh_info
;
2471 sh
->sh_link
= s
->link
->sh_num
;
2472 sh
->sh_addralign
= s
->sh_addralign
;
2473 sh
->sh_addr
= s
->sh_addr
;
2474 sh
->sh_offset
= s
->sh_offset
;
2475 sh
->sh_size
= s
->sh_size
;
2477 fwrite(sh
, 1, sizeof(ElfW(Shdr
)), f
);
2481 /* Write an elf, coff or "binary" file */
2482 static int tcc_write_elf_file(TCCState
*s1
, const char *filename
, int phnum
,
2483 ElfW(Phdr
) *phdr
, int file_offset
, int *sec_order
)
2485 int fd
, mode
, file_type
;
2488 file_type
= s1
->output_type
;
2489 if (file_type
== TCC_OUTPUT_OBJ
)
2494 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, mode
);
2496 tcc_error_noabort("could not write '%s'", filename
);
2499 f
= fdopen(fd
, "wb");
2501 printf("<- %s\n", filename
);
2503 #ifdef TCC_TARGET_COFF
2504 if (s1
->output_format
== TCC_OUTPUT_FORMAT_COFF
)
2505 tcc_output_coff(s1
, f
);
2508 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
2509 tcc_output_elf(s1
, f
, phnum
, phdr
, file_offset
, sec_order
);
2511 tcc_output_binary(s1
, f
, sec_order
);
2517 /* Output an elf, coff or binary file */
2518 /* XXX: suppress unneeded sections */
2519 static int elf_output_file(TCCState
*s1
, const char *filename
)
2521 int i
, ret
, phnum
, shnum
, file_type
, file_offset
, *sec_order
;
2522 struct dyn_inf dyninf
;
2525 Section
*strsec
, *interp
, *dynamic
, *dynstr
;
2527 file_type
= s1
->output_type
;
2530 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2531 if (file_type
!= TCC_OUTPUT_OBJ
) {
2532 tcc_add_runtime(s1
);
2537 interp
= dynamic
= dynstr
= NULL
; /* avoid warning */
2538 dyninf
.dyn_rel_off
= 0; /* avoid warning */
2540 if (file_type
!= TCC_OUTPUT_OBJ
) {
2541 relocate_common_syms();
2543 tcc_add_linker_symbols(s1
);
2545 if (!s1
->static_link
) {
2546 if (file_type
== TCC_OUTPUT_EXE
) {
2548 /* allow override the dynamic loader */
2549 const char *elfint
= getenv("LD_SO");
2551 elfint
= DEFAULT_ELFINTERP(s1
);
2552 /* add interpreter section only if executable */
2553 interp
= new_section(s1
, ".interp", SHT_PROGBITS
, SHF_ALLOC
);
2554 interp
->sh_addralign
= 1;
2555 ptr
= section_ptr_add(interp
, 1 + strlen(elfint
));
2556 strcpy(ptr
, elfint
);
2559 /* add dynamic symbol table */
2560 s1
->dynsym
= new_symtab(s1
, ".dynsym", SHT_DYNSYM
, SHF_ALLOC
,
2562 ".hash", SHF_ALLOC
);
2563 dynstr
= s1
->dynsym
->link
;
2565 /* add dynamic section */
2566 dynamic
= new_section(s1
, ".dynamic", SHT_DYNAMIC
,
2567 SHF_ALLOC
| SHF_WRITE
);
2568 dynamic
->link
= dynstr
;
2569 dynamic
->sh_entsize
= sizeof(ElfW(Dyn
));
2573 if (file_type
== TCC_OUTPUT_EXE
) {
2574 bind_exe_dynsyms(s1
);
2576 if (s1
->nb_errors
) {
2581 bind_libs_dynsyms(s1
);
2582 } else /* shared library case: simply export all global symbols */
2583 export_global_syms(s1
);
2585 build_got_entries(s1
);
2587 /* add a list of needed dlls */
2588 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2589 DLLReference
*dllref
= s1
->loaded_dlls
[i
];
2590 if (dllref
->level
== 0)
2591 put_dt(dynamic
, DT_NEEDED
, put_elf_str(dynstr
, dllref
->name
));
2595 put_dt(dynamic
, DT_RPATH
, put_elf_str(dynstr
, s1
->rpath
));
2597 /* XXX: currently, since we do not handle PIC code, we
2598 must relocate the readonly segments */
2599 if (file_type
== TCC_OUTPUT_DLL
) {
2601 put_dt(dynamic
, DT_SONAME
, put_elf_str(dynstr
, s1
->soname
));
2602 put_dt(dynamic
, DT_TEXTREL
, 0);
2606 put_dt(dynamic
, DT_SYMBOLIC
, 0);
2608 /* add necessary space for other entries */
2609 dyninf
.dyn_rel_off
= dynamic
->data_offset
;
2610 dynamic
->data_offset
+= sizeof(ElfW(Dyn
)) * EXTRA_RELITEMS
;
2612 /* still need to build got entries in case of static link */
2613 build_got_entries(s1
);
2617 /* we add a section for symbols */
2618 strsec
= new_section(s1
, ".shstrtab", SHT_STRTAB
, 0);
2619 put_elf_str(strsec
, "");
2621 /* compute number of sections */
2622 shnum
= s1
->nb_sections
;
2624 /* this array is used to reorder sections in the output file */
2625 sec_order
= tcc_malloc(sizeof(int) * shnum
);
2628 /* compute number of program headers */
2631 case TCC_OUTPUT_OBJ
:
2634 case TCC_OUTPUT_EXE
:
2635 if (!s1
->static_link
)
2636 phnum
= 4 + HAVE_PHDR
;
2640 case TCC_OUTPUT_DLL
:
2645 /* Allocate strings for section names */
2646 alloc_sec_names(s1
, file_type
, strsec
);
2648 /* allocate program segment headers */
2649 phdr
= tcc_mallocz(phnum
* sizeof(ElfW(Phdr
)));
2651 /* compute section to program header mapping */
2652 file_offset
= layout_sections(s1
, phdr
, phnum
, interp
, strsec
, &dyninf
,
2655 /* Fill remaining program header and finalize relocation related to dynamic
2658 fill_unloadable_phdr(phdr
, phnum
, interp
, dynamic
);
2660 dyninf
.dynamic
= dynamic
;
2661 dyninf
.dynstr
= dynstr
;
2663 fill_dynamic(s1
, &dyninf
);
2665 /* put in GOT the dynamic section address and relocate PLT */
2666 write32le(s1
->got
->data
, dynamic
->sh_addr
);
2667 if (file_type
== TCC_OUTPUT_EXE
2668 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
2669 || file_type
== TCC_OUTPUT_DLL
2674 /* relocate symbols in .dynsym now that final addresses are known */
2675 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
)) {
2676 if (sym
->st_shndx
== SHN_UNDEF
) {
2677 /* relocate to PLT if symbol corresponds to a PLT entry,
2678 but not if it's a weak symbol */
2679 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
)
2681 else if (sym
->st_value
)
2682 sym
->st_value
+= s1
->plt
->sh_addr
;
2683 } else if (sym
->st_shndx
< SHN_LORESERVE
) {
2684 /* do symbol relocation */
2685 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
2691 /* if building executable or DLL, then relocate each section
2692 except the GOT which is already relocated */
2693 if (file_type
!= TCC_OUTPUT_OBJ
) {
2694 ret
= final_sections_reloc(s1
);
2699 /* Perform relocation to GOT or PLT entries */
2700 if (file_type
== TCC_OUTPUT_EXE
&& s1
->static_link
)
2703 /* Create the ELF file with name 'filename' */
2704 ret
= tcc_write_elf_file(s1
, filename
, phnum
, phdr
, file_offset
, sec_order
);
2707 const char *strip_cmd
= "sstrip "; // super strip utility from ELFkickers
2708 const char *null_dev
= " 2> /dev/null";
2710 snprintf(buf
, sizeof(buf
), "%s%s%s", strip_cmd
, filename
, null_dev
);
2713 system(buf
+1); // call a strip utility from binutils
2716 tcc_free(s1
->symtab_to_dynsym
);
2717 tcc_free(sec_order
);
2719 tcc_free(s1
->sym_attrs
);
2720 s1
->sym_attrs
= NULL
;
2724 LIBTCCAPI
int tcc_output_file(TCCState
*s
, const char *filename
)
2727 #ifdef TCC_TARGET_PE
2728 if (s
->output_type
!= TCC_OUTPUT_OBJ
) {
2729 ret
= pe_output_file(s
, filename
);
2732 ret
= elf_output_file(s
, filename
);
2736 static void *load_data(int fd
, unsigned long file_offset
, unsigned long size
)
2740 data
= tcc_malloc(size
);
2741 lseek(fd
, file_offset
, SEEK_SET
);
2742 read(fd
, data
, size
);
2746 typedef struct SectionMergeInfo
{
2747 Section
*s
; /* corresponding existing section */
2748 unsigned long offset
; /* offset of the new section in the existing section */
2749 uint8_t new_section
; /* true if section 's' was added */
2750 uint8_t link_once
; /* true if link once section */
2753 /* load an object file and merge it with current files */
2754 /* XXX: handle correctly stab (debug) info */
2755 ST_FUNC
int tcc_load_object_file(TCCState
*s1
,
2756 int fd
, unsigned long file_offset
)
2759 ElfW(Shdr
) *shdr
, *sh
;
2760 int size
, i
, j
, offset
, offseti
, nb_syms
, sym_index
, ret
;
2761 unsigned char *strsec
, *strtab
;
2762 int *old_to_new_syms
;
2763 char *sh_name
, *name
;
2764 SectionMergeInfo
*sm_table
, *sm
;
2765 ElfW(Sym
) *sym
, *symtab
;
2772 stab_index
= stabstr_index
= 0;
2774 if (read(fd
, &ehdr
, sizeof(ehdr
)) != sizeof(ehdr
))
2776 if (ehdr
.e_ident
[0] != ELFMAG0
||
2777 ehdr
.e_ident
[1] != ELFMAG1
||
2778 ehdr
.e_ident
[2] != ELFMAG2
||
2779 ehdr
.e_ident
[3] != ELFMAG3
)
2781 /* test if object file */
2782 if (ehdr
.e_type
!= ET_REL
)
2784 /* test CPU specific stuff */
2785 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2786 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2788 tcc_error_noabort("invalid object file");
2792 shdr
= load_data(fd
, file_offset
+ ehdr
.e_shoff
,
2793 sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2794 sm_table
= tcc_mallocz(sizeof(SectionMergeInfo
) * ehdr
.e_shnum
);
2796 /* load section names */
2797 sh
= &shdr
[ehdr
.e_shstrndx
];
2798 strsec
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2800 /* load symtab and strtab */
2801 old_to_new_syms
= NULL
;
2805 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2807 if (sh
->sh_type
== SHT_SYMTAB
) {
2809 tcc_error_noabort("object must contain only one symtab");
2814 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2815 symtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2816 sm_table
[i
].s
= symtab_section
;
2818 /* now load strtab */
2819 sh
= &shdr
[sh
->sh_link
];
2820 strtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2824 /* now examine each section and try to merge its content with the
2826 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2827 /* no need to examine section name strtab */
2828 if (i
== ehdr
.e_shstrndx
)
2831 sh_name
= (char *) strsec
+ sh
->sh_name
;
2832 /* ignore sections types we do not handle */
2833 if (sh
->sh_type
!= SHT_PROGBITS
&&
2834 sh
->sh_type
!= SHT_RELX
&&
2836 sh
->sh_type
!= SHT_ARM_EXIDX
&&
2838 sh
->sh_type
!= SHT_NOBITS
&&
2839 sh
->sh_type
!= SHT_PREINIT_ARRAY
&&
2840 sh
->sh_type
!= SHT_INIT_ARRAY
&&
2841 sh
->sh_type
!= SHT_FINI_ARRAY
&&
2842 strcmp(sh_name
, ".stabstr")
2845 if (sh
->sh_addralign
< 1)
2846 sh
->sh_addralign
= 1;
2847 /* find corresponding section, if any */
2848 for(j
= 1; j
< s1
->nb_sections
;j
++) {
2849 s
= s1
->sections
[j
];
2850 if (!strcmp(s
->name
, sh_name
)) {
2851 if (!strncmp(sh_name
, ".gnu.linkonce",
2852 sizeof(".gnu.linkonce") - 1)) {
2853 /* if a 'linkonce' section is already present, we
2854 do not add it again. It is a little tricky as
2855 symbols can still be defined in
2857 sm_table
[i
].link_once
= 1;
2864 /* not found: create new section */
2865 s
= new_section(s1
, sh_name
, sh
->sh_type
, sh
->sh_flags
);
2866 /* take as much info as possible from the section. sh_link and
2867 sh_info will be updated later */
2868 s
->sh_addralign
= sh
->sh_addralign
;
2869 s
->sh_entsize
= sh
->sh_entsize
;
2870 sm_table
[i
].new_section
= 1;
2872 if (sh
->sh_type
!= s
->sh_type
) {
2873 tcc_error_noabort("invalid section type");
2877 /* align start of section */
2878 offset
= s
->data_offset
;
2880 if (0 == strcmp(sh_name
, ".stab")) {
2884 if (0 == strcmp(sh_name
, ".stabstr")) {
2889 size
= sh
->sh_addralign
- 1;
2890 offset
= (offset
+ size
) & ~size
;
2891 if (sh
->sh_addralign
> s
->sh_addralign
)
2892 s
->sh_addralign
= sh
->sh_addralign
;
2893 s
->data_offset
= offset
;
2895 sm_table
[i
].offset
= offset
;
2897 /* concatenate sections */
2899 if (sh
->sh_type
!= SHT_NOBITS
) {
2901 lseek(fd
, file_offset
+ sh
->sh_offset
, SEEK_SET
);
2902 ptr
= section_ptr_add(s
, size
);
2903 read(fd
, ptr
, size
);
2905 s
->data_offset
+= size
;
2910 /* gr relocate stab strings */
2911 if (stab_index
&& stabstr_index
) {
2914 s
= sm_table
[stab_index
].s
;
2915 a
= (Stab_Sym
*)(s
->data
+ sm_table
[stab_index
].offset
);
2916 b
= (Stab_Sym
*)(s
->data
+ s
->data_offset
);
2917 o
= sm_table
[stabstr_index
].offset
;
2919 a
->n_strx
+= o
, a
++;
2922 /* second short pass to update sh_link and sh_info fields of new
2924 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2926 if (!s
|| !sm_table
[i
].new_section
)
2929 if (sh
->sh_link
> 0)
2930 s
->link
= sm_table
[sh
->sh_link
].s
;
2931 if (sh
->sh_type
== SHT_RELX
) {
2932 s
->sh_info
= sm_table
[sh
->sh_info
].s
->sh_num
;
2933 /* update backward link */
2934 s1
->sections
[s
->sh_info
]->reloc
= s
;
2939 /* resolve symbols */
2940 old_to_new_syms
= tcc_mallocz(nb_syms
* sizeof(int));
2943 for(i
= 1; i
< nb_syms
; i
++, sym
++) {
2944 if (sym
->st_shndx
!= SHN_UNDEF
&&
2945 sym
->st_shndx
< SHN_LORESERVE
) {
2946 sm
= &sm_table
[sym
->st_shndx
];
2947 if (sm
->link_once
) {
2948 /* if a symbol is in a link once section, we use the
2949 already defined symbol. It is very important to get
2950 correct relocations */
2951 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
2952 name
= (char *) strtab
+ sym
->st_name
;
2953 sym_index
= find_elf_sym(symtab_section
, name
);
2955 old_to_new_syms
[i
] = sym_index
;
2959 /* if no corresponding section added, no need to add symbol */
2962 /* convert section number */
2963 sym
->st_shndx
= sm
->s
->sh_num
;
2965 sym
->st_value
+= sm
->offset
;
2968 name
= (char *) strtab
+ sym
->st_name
;
2969 sym_index
= add_elf_sym(symtab_section
, sym
->st_value
, sym
->st_size
,
2970 sym
->st_info
, sym
->st_other
,
2971 sym
->st_shndx
, name
);
2972 old_to_new_syms
[i
] = sym_index
;
2975 /* third pass to patch relocation entries */
2976 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2981 offset
= sm_table
[i
].offset
;
2982 switch(s
->sh_type
) {
2984 /* take relocation offset information */
2985 offseti
= sm_table
[sh
->sh_info
].offset
;
2986 for_each_elem(s
, (offset
/ sizeof(*rel
)), rel
, ElfW_Rel
) {
2989 /* convert symbol index */
2990 type
= ELFW(R_TYPE
)(rel
->r_info
);
2991 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
2992 /* NOTE: only one symtab assumed */
2993 if (sym_index
>= nb_syms
)
2995 sym_index
= old_to_new_syms
[sym_index
];
2996 /* ignore link_once in rel section. */
2997 if (!sym_index
&& !sm
->link_once
2998 #ifdef TCC_TARGET_ARM
2999 && type
!= R_ARM_V4BX
3003 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
3004 i
, strsec
+ sh
->sh_name
, rel
->r_offset
);
3007 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
3008 /* offset the relocation offset */
3009 rel
->r_offset
+= offseti
;
3010 #ifdef TCC_TARGET_ARM
3011 /* Jumps and branches from a Thumb code to a PLT entry need
3012 special handling since PLT entries are ARM code.
3013 Unconditional bl instructions referencing PLT entries are
3014 handled by converting these instructions into blx
3015 instructions. Other case of instructions referencing a PLT
3016 entry require to add a Thumb stub before the PLT entry to
3017 switch to ARM mode. We set bit plt_thumb_stub of the
3018 attribute of a symbol to indicate such a case. */
3019 if (type
== R_ARM_THM_JUMP24
)
3020 alloc_sym_attr(s1
, sym_index
)->plt_thumb_stub
= 1;
3033 tcc_free(old_to_new_syms
);
3040 typedef struct ArchiveHeader
{
3041 char ar_name
[16]; /* name of this member */
3042 char ar_date
[12]; /* file mtime */
3043 char ar_uid
[6]; /* owner uid; printed as decimal */
3044 char ar_gid
[6]; /* owner gid; printed as decimal */
3045 char ar_mode
[8]; /* file mode, printed as octal */
3046 char ar_size
[10]; /* file size, printed as decimal */
3047 char ar_fmag
[2]; /* should contain ARFMAG */
3050 static int get_be32(const uint8_t *b
)
3052 return b
[3] | (b
[2] << 8) | (b
[1] << 16) | (b
[0] << 24);
3055 /* load only the objects which resolve undefined symbols */
3056 static int tcc_load_alacarte(TCCState
*s1
, int fd
, int size
)
3058 int i
, bound
, nsyms
, sym_index
, off
, ret
;
3060 const char *ar_names
, *p
;
3061 const uint8_t *ar_index
;
3064 data
= tcc_malloc(size
);
3065 if (read(fd
, data
, size
) != size
)
3067 nsyms
= get_be32(data
);
3068 ar_index
= data
+ 4;
3069 ar_names
= (char *) ar_index
+ nsyms
* 4;
3073 for(p
= ar_names
, i
= 0; i
< nsyms
; i
++, p
+= strlen(p
)+1) {
3074 sym_index
= find_elf_sym(symtab_section
, p
);
3076 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
3077 if(sym
->st_shndx
== SHN_UNDEF
) {
3078 off
= get_be32(ar_index
+ i
* 4) + sizeof(ArchiveHeader
);
3080 lseek(fd
, off
, SEEK_SET
);
3081 if(tcc_load_object_file(s1
, fd
, off
) < 0) {
3096 /* load a '.a' file */
3097 ST_FUNC
int tcc_load_archive(TCCState
*s1
, int fd
)
3104 unsigned long file_offset
;
3106 /* skip magic which was already checked */
3107 read(fd
, magic
, sizeof(magic
));
3110 len
= read(fd
, &hdr
, sizeof(hdr
));
3113 if (len
!= sizeof(hdr
)) {
3114 tcc_error_noabort("invalid archive");
3117 memcpy(ar_size
, hdr
.ar_size
, sizeof(hdr
.ar_size
));
3118 ar_size
[sizeof(hdr
.ar_size
)] = '\0';
3119 size
= strtol(ar_size
, NULL
, 0);
3120 memcpy(ar_name
, hdr
.ar_name
, sizeof(hdr
.ar_name
));
3121 for(i
= sizeof(hdr
.ar_name
) - 1; i
>= 0; i
--) {
3122 if (ar_name
[i
] != ' ')
3125 ar_name
[i
+ 1] = '\0';
3126 file_offset
= lseek(fd
, 0, SEEK_CUR
);
3128 size
= (size
+ 1) & ~1;
3129 if (!strcmp(ar_name
, "/")) {
3130 /* coff symbol table : we handle it */
3131 if(s1
->alacarte_link
)
3132 return tcc_load_alacarte(s1
, fd
, size
);
3133 } else if (!strcmp(ar_name
, "//") ||
3134 !strcmp(ar_name
, "__.SYMDEF") ||
3135 !strcmp(ar_name
, "__.SYMDEF/") ||
3136 !strcmp(ar_name
, "ARFILENAMES/")) {
3137 /* skip symbol table or archive names */
3139 if (tcc_load_object_file(s1
, fd
, file_offset
) < 0)
3142 lseek(fd
, file_offset
+ size
, SEEK_SET
);
3147 #ifndef TCC_TARGET_PE
3148 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
3149 is referenced by the user (so it should be added as DT_NEEDED in
3150 the generated ELF file) */
3151 ST_FUNC
int tcc_load_dll(TCCState
*s1
, int fd
, const char *filename
, int level
)
3154 ElfW(Shdr
) *shdr
, *sh
, *sh1
;
3155 int i
, j
, nb_syms
, nb_dts
, sym_bind
, ret
;
3156 ElfW(Sym
) *sym
, *dynsym
;
3157 ElfW(Dyn
) *dt
, *dynamic
;
3158 unsigned char *dynstr
;
3159 const char *name
, *soname
;
3160 DLLReference
*dllref
;
3162 read(fd
, &ehdr
, sizeof(ehdr
));
3164 /* test CPU specific stuff */
3165 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
3166 ehdr
.e_machine
!= EM_TCC_TARGET
) {
3167 tcc_error_noabort("bad architecture");
3172 shdr
= load_data(fd
, ehdr
.e_shoff
, sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
3174 /* load dynamic section and dynamic symbols */
3178 dynsym
= NULL
; /* avoid warning */
3179 dynstr
= NULL
; /* avoid warning */
3180 for(i
= 0, sh
= shdr
; i
< ehdr
.e_shnum
; i
++, sh
++) {
3181 switch(sh
->sh_type
) {
3183 nb_dts
= sh
->sh_size
/ sizeof(ElfW(Dyn
));
3184 dynamic
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
3187 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
3188 dynsym
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
3189 sh1
= &shdr
[sh
->sh_link
];
3190 dynstr
= load_data(fd
, sh1
->sh_offset
, sh1
->sh_size
);
3197 /* compute the real library name */
3198 soname
= tcc_basename(filename
);
3200 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
3201 if (dt
->d_tag
== DT_SONAME
) {
3202 soname
= (char *) dynstr
+ dt
->d_un
.d_val
;
3206 /* if the dll is already loaded, do not load it */
3207 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
3208 dllref
= s1
->loaded_dlls
[i
];
3209 if (!strcmp(soname
, dllref
->name
)) {
3210 /* but update level if needed */
3211 if (level
< dllref
->level
)
3212 dllref
->level
= level
;
3218 /* add the dll and its level */
3219 dllref
= tcc_mallocz(sizeof(DLLReference
) + strlen(soname
));
3220 dllref
->level
= level
;
3221 strcpy(dllref
->name
, soname
);
3222 dynarray_add((void ***)&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
, dllref
);
3224 /* add dynamic symbols in dynsym_section */
3225 for(i
= 1, sym
= dynsym
+ 1; i
< nb_syms
; i
++, sym
++) {
3226 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
3227 if (sym_bind
== STB_LOCAL
)
3229 name
= (char *) dynstr
+ sym
->st_name
;
3230 add_elf_sym(s1
->dynsymtab_section
, sym
->st_value
, sym
->st_size
,
3231 sym
->st_info
, sym
->st_other
, sym
->st_shndx
, name
);
3234 /* load all referenced DLLs */
3235 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
3238 name
= (char *) dynstr
+ dt
->d_un
.d_val
;
3239 for(j
= 0; j
< s1
->nb_loaded_dlls
; j
++) {
3240 dllref
= s1
->loaded_dlls
[j
];
3241 if (!strcmp(name
, dllref
->name
))
3242 goto already_loaded
;
3244 if (tcc_add_dll(s1
, name
, AFF_REFERENCED_DLL
) < 0) {
3245 tcc_error_noabort("referenced dll '%s' not found", name
);
3262 #define LD_TOK_NAME 256
3263 #define LD_TOK_EOF (-1)
3265 /* return next ld script token */
3266 static int ld_next(TCCState
*s1
, char *name
, int name_size
)
3284 file
->buf_ptr
= parse_comment(file
->buf_ptr
);
3285 ch
= file
->buf_ptr
[0];
3298 /* case 'a' ... 'z': */
3325 /* case 'A' ... 'z': */
3359 if (!((ch
>= 'a' && ch
<= 'z') ||
3360 (ch
>= 'A' && ch
<= 'Z') ||
3361 (ch
>= '0' && ch
<= '9') ||
3362 strchr("/.-_+=$:\\,~", ch
)))
3364 if ((q
- name
) < name_size
- 1) {
3383 static int ld_add_file(TCCState
*s1
, const char filename
[])
3387 ret
= tcc_add_file_internal(s1
, filename
, AFF_TYPE_BIN
);
3389 ret
= tcc_add_dll(s1
, filename
, 0);
3393 static inline int new_undef_syms(void)
3396 ret
= new_undef_sym
;
3401 static int ld_add_file_list(TCCState
*s1
, const char *cmd
, int as_needed
)
3403 char filename
[1024], libname
[1024];
3404 int t
, group
, nblibs
= 0, ret
= 0;
3407 group
= !strcmp(cmd
, "GROUP");
3410 t
= ld_next(s1
, filename
, sizeof(filename
));
3413 t
= ld_next(s1
, filename
, sizeof(filename
));
3416 if (t
== LD_TOK_EOF
) {
3417 tcc_error_noabort("unexpected end of file");
3419 goto lib_parse_error
;
3420 } else if (t
== ')') {
3422 } else if (t
== '-') {
3423 t
= ld_next(s1
, filename
, sizeof(filename
));
3424 if ((t
!= LD_TOK_NAME
) || (filename
[0] != 'l')) {
3425 tcc_error_noabort("library name expected");
3427 goto lib_parse_error
;
3429 pstrcpy(libname
, sizeof libname
, &filename
[1]);
3430 if (s1
->static_link
) {
3431 snprintf(filename
, sizeof filename
, "lib%s.a", libname
);
3433 snprintf(filename
, sizeof filename
, "lib%s.so", libname
);
3435 } else if (t
!= LD_TOK_NAME
) {
3436 tcc_error_noabort("filename expected");
3438 goto lib_parse_error
;
3440 if (!strcmp(filename
, "AS_NEEDED")) {
3441 ret
= ld_add_file_list(s1
, cmd
, 1);
3443 goto lib_parse_error
;
3445 /* TODO: Implement AS_NEEDED support. Ignore it for now */
3447 ret
= ld_add_file(s1
, filename
);
3449 goto lib_parse_error
;
3451 /* Add the filename *and* the libname to avoid future conversions */
3452 dynarray_add((void ***) &libs
, &nblibs
, tcc_strdup(filename
));
3453 if (libname
[0] != '\0')
3454 dynarray_add((void ***) &libs
, &nblibs
, tcc_strdup(libname
));
3458 t
= ld_next(s1
, filename
, sizeof(filename
));
3460 t
= ld_next(s1
, filename
, sizeof(filename
));
3463 if (group
&& !as_needed
) {
3464 while (new_undef_syms()) {
3467 for (i
= 0; i
< nblibs
; i
++)
3468 ld_add_file(s1
, libs
[i
]);
3472 dynarray_reset(&libs
, &nblibs
);
3476 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3478 ST_FUNC
int tcc_load_ldscript(TCCState
*s1
)
3481 char filename
[1024];
3486 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3487 if (t
== LD_TOK_EOF
)
3489 else if (t
!= LD_TOK_NAME
)
3491 if (!strcmp(cmd
, "INPUT") ||
3492 !strcmp(cmd
, "GROUP")) {
3493 ret
= ld_add_file_list(s1
, cmd
, 0);
3496 } else if (!strcmp(cmd
, "OUTPUT_FORMAT") ||
3497 !strcmp(cmd
, "TARGET")) {
3498 /* ignore some commands */
3499 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3503 t
= ld_next(s1
, filename
, sizeof(filename
));
3504 if (t
== LD_TOK_EOF
) {
3505 tcc_error_noabort("unexpected end of file");
3507 } else if (t
== ')') {
3517 #endif /* !TCC_TARGET_PE */