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
1585 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 /* pull bcheck.o from libtcc1.a */
1594 sym_index
= add_elf_sym(symtab_section
, 0, 0,
1595 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1596 SHN_UNDEF
, "__bound_init");
1597 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
) {
1598 /* add 'call __bound_init()' in .init section */
1599 Section
*init_section
= find_section(s1
, ".init");
1600 unsigned char *pinit
= section_ptr_add(init_section
, 5);
1602 write32le(pinit
+ 1, -4);
1603 put_elf_reloc(symtab_section
, init_section
,
1604 init_section
->data_offset
- 4, R_386_PC32
, sym_index
);
1605 /* R_386_PC32 = R_X86_64_PC32 = 2 */
1610 /* add tcc runtime libraries */
1611 ST_FUNC
void tcc_add_runtime(TCCState
*s1
)
1614 tcc_add_pragma_libs(s1
);
1616 if (!s1
->nostdlib
) {
1617 tcc_add_library(s1
, "c");
1618 #ifdef CONFIG_USE_LIBGCC
1619 if (!s1
->static_link
) {
1620 tcc_add_file(s1
, TCC_LIBGCC
);
1623 tcc_add_support(s1
, "libtcc1.a");
1624 /* add crt end if not memory output */
1625 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
)
1626 tcc_add_crt(s1
, "crtn.o");
1630 /* add various standard linker symbols (must be done after the
1631 sections are filled (for example after allocating common
1633 ST_FUNC
void tcc_add_linker_symbols(TCCState
*s1
)
1639 add_elf_sym(symtab_section
,
1640 text_section
->data_offset
, 0,
1641 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1642 text_section
->sh_num
, "_etext");
1643 add_elf_sym(symtab_section
,
1644 data_section
->data_offset
, 0,
1645 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1646 data_section
->sh_num
, "_edata");
1647 add_elf_sym(symtab_section
,
1648 bss_section
->data_offset
, 0,
1649 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1650 bss_section
->sh_num
, "_end");
1651 /* horrible new standard ldscript defines */
1652 add_init_array_defines(s1
, ".preinit_array");
1653 add_init_array_defines(s1
, ".init_array");
1654 add_init_array_defines(s1
, ".fini_array");
1656 /* add start and stop symbols for sections whose name can be
1658 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1659 s
= s1
->sections
[i
];
1660 if (s
->sh_type
== SHT_PROGBITS
&&
1661 (s
->sh_flags
& SHF_ALLOC
)) {
1665 /* check if section name can be expressed in C */
1671 if (!isid(ch
) && !isnum(ch
))
1675 snprintf(buf
, sizeof(buf
), "__start_%s", s
->name
);
1676 add_elf_sym(symtab_section
,
1678 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1680 snprintf(buf
, sizeof(buf
), "__stop_%s", s
->name
);
1681 add_elf_sym(symtab_section
,
1683 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
1690 static void tcc_output_binary(TCCState
*s1
, FILE *f
,
1691 const int *sec_order
)
1694 int i
, offset
, size
;
1697 for(i
=1;i
<s1
->nb_sections
;i
++) {
1698 s
= s1
->sections
[sec_order
[i
]];
1699 if (s
->sh_type
!= SHT_NOBITS
&&
1700 (s
->sh_flags
& SHF_ALLOC
)) {
1701 while (offset
< s
->sh_offset
) {
1706 fwrite(s
->data
, 1, size
, f
);
1712 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1714 #define EXTRA_RELITEMS 14
1716 /* move the relocation value from .dynsym to .got */
1717 static void patch_dynsym_undef(TCCState
*s1
, Section
*s
)
1719 uint32_t *gotd
= (void *)s1
->got
->data
;
1722 gotd
+= 3; /* dummy entries in .got */
1723 /* relocate symbols in .dynsym */
1724 for_each_elem(s
, 1, sym
, ElfW(Sym
)) {
1725 if (sym
->st_shndx
== SHN_UNDEF
) {
1726 *gotd
++ = sym
->st_value
+ 6; /* XXX 6 is magic ? */
1733 #define EXTRA_RELITEMS 9
1735 /* zero plt offsets of weak symbols in .dynsym */
1736 static void patch_dynsym_undef(TCCState
*s1
, Section
*s
)
1740 for_each_elem(s
, 1, sym
, ElfW(Sym
))
1741 if (sym
->st_shndx
== SHN_UNDEF
&& ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
)
1746 ST_FUNC
void fill_got_entry(TCCState
*s1
, ElfW_Rel
*rel
)
1748 int sym_index
= ELFW(R_SYM
) (rel
->r_info
);
1749 ElfW(Sym
) *sym
= &((ElfW(Sym
) *) symtab_section
->data
)[sym_index
];
1750 unsigned long offset
;
1752 if (sym_index
>= s1
->nb_sym_attrs
)
1754 offset
= s1
->sym_attrs
[sym_index
].got_offset
;
1755 section_reserve(s1
->got
, offset
+ PTR_SIZE
);
1756 #ifdef TCC_TARGET_X86_64
1757 /* only works for x86-64 */
1758 write32le(s1
->got
->data
+ offset
+ 4, sym
->st_value
>> 32);
1760 write32le(s1
->got
->data
+ offset
, sym
->st_value
& 0xffffffff);
1763 /* Perform relocation to GOT or PLT entries */
1764 ST_FUNC
void fill_got(TCCState
*s1
)
1770 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1771 s
= s1
->sections
[i
];
1772 if (s
->sh_type
!= SHT_RELX
)
1774 /* no need to handle got relocations */
1775 if (s
->link
!= symtab_section
)
1777 for_each_elem(s
, 0, rel
, ElfW_Rel
) {
1778 switch (ELFW(R_TYPE
) (rel
->r_info
)) {
1779 case R_X86_64_GOT32
:
1780 case R_X86_64_GOTPCREL
:
1781 case R_X86_64_GOTPCRELX
:
1782 case R_X86_64_REX_GOTPCRELX
:
1783 case R_X86_64_PLT32
:
1784 fill_got_entry(s1
, rel
);
1791 /* Bind symbols of executable: resolve undefined symbols from exported symbols
1792 in shared libraries and export non local defined symbols to shared libraries
1793 if -rdynamic switch was given on command line */
1794 static void bind_exe_dynsyms(TCCState
*s1
)
1797 int sym_index
, index
;
1798 ElfW(Sym
) *sym
, *esym
;
1801 /* Resolve undefined symbols from dynamic symbols. When there is a match:
1802 - if STT_FUNC or STT_GNU_IFUNC symbol -> add it in PLT
1803 - if STT_OBJECT symbol -> add it in .bss section with suitable reloc */
1804 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1805 if (sym
->st_shndx
== SHN_UNDEF
) {
1806 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1807 sym_index
= find_elf_sym(s1
->dynsymtab_section
, name
);
1809 esym
= &((ElfW(Sym
) *)s1
->dynsymtab_section
->data
)[sym_index
];
1810 type
= ELFW(ST_TYPE
)(esym
->st_info
);
1811 if ((type
== STT_FUNC
) || (type
== STT_GNU_IFUNC
)) {
1812 /* Indirect functions shall have STT_FUNC type in executable
1813 * dynsym section. Indeed, a dlsym call following a lazy
1814 * resolution would pick the symbol value from the
1815 * executable dynsym entry which would contain the address
1816 * of the function wanted by the caller of dlsym instead of
1817 * the address of the function that would return that
1819 put_got_entry(s1
, R_JMP_SLOT
, esym
->st_size
,
1820 ELFW(ST_INFO
)(STB_GLOBAL
,STT_FUNC
),
1821 sym
- (ElfW(Sym
) *)symtab_section
->data
);
1822 } else if (type
== STT_OBJECT
) {
1823 unsigned long offset
;
1825 offset
= bss_section
->data_offset
;
1826 /* XXX: which alignment ? */
1827 offset
= (offset
+ 16 - 1) & -16;
1828 index
= put_elf_sym(s1
->dynsym
, offset
, esym
->st_size
,
1829 esym
->st_info
, 0, bss_section
->sh_num
,
1831 /* Ensure R_COPY works for weak symbol aliases */
1832 if (ELFW(ST_BIND
)(esym
->st_info
) == STB_WEAK
) {
1833 for_each_elem(s1
->dynsymtab_section
, 1, dynsym
, ElfW(Sym
)) {
1834 if ((dynsym
->st_value
== esym
->st_value
)
1835 && (ELFW(ST_BIND
)(dynsym
->st_info
) == STB_GLOBAL
)) {
1836 char *dynname
= (char *) s1
->dynsymtab_section
->link
->data
1838 put_elf_sym(s1
->dynsym
, offset
, dynsym
->st_size
,
1840 bss_section
->sh_num
, dynname
);
1845 put_elf_reloc(s1
->dynsym
, bss_section
,
1846 offset
, R_COPY
, index
);
1847 offset
+= esym
->st_size
;
1848 bss_section
->data_offset
= offset
;
1851 /* STB_WEAK undefined symbols are accepted */
1852 /* XXX: _fp_hw seems to be part of the ABI, so we ignore it */
1853 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
||
1854 !strcmp(name
, "_fp_hw")) {
1856 tcc_error_noabort("undefined symbol '%s'", name
);
1859 } else if (s1
->rdynamic
&& ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1860 /* if -rdynamic option, then export all non local symbols */
1861 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1862 put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
, sym
->st_info
,
1863 0, sym
->st_shndx
, name
);
1868 /* Bind symbols of libraries: export non local symbols of executable that
1869 resolve undefined symbols of shared libraries */
1870 static void bind_libs_dynsyms(TCCState
*s1
)
1874 ElfW(Sym
) *sym
, *esym
;
1876 /* now look at unresolved dynamic symbols and export
1877 corresponding symbol */
1878 for_each_elem(s1
->dynsymtab_section
, 1, esym
, ElfW(Sym
)) {
1879 name
= (char *) s1
->dynsymtab_section
->link
->data
+ esym
->st_name
;
1880 sym_index
= find_elf_sym(symtab_section
, name
);
1882 /* XXX: avoid adding a symbol if already present because of
1884 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
1885 if (sym
->st_shndx
!= SHN_UNDEF
)
1886 put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1887 sym
->st_info
, 0, sym
->st_shndx
, name
);
1888 } else if (esym
->st_shndx
== SHN_UNDEF
) {
1889 /* weak symbols can stay undefined */
1890 if (ELFW(ST_BIND
)(esym
->st_info
) != STB_WEAK
)
1891 tcc_warning("undefined dynamic symbol '%s'", name
);
1896 /* Export all non local symbols (for shared libraries) */
1897 static void export_global_syms(TCCState
*s1
)
1899 int nb_syms
, dynindex
, index
;
1903 nb_syms
= symtab_section
->data_offset
/ sizeof(ElfW(Sym
));
1904 s1
->symtab_to_dynsym
= tcc_mallocz(sizeof(int) * nb_syms
);
1905 for_each_elem(symtab_section
, 1, sym
, ElfW(Sym
)) {
1906 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
1907 name
= (char *) symtab_section
->link
->data
+ sym
->st_name
;
1908 dynindex
= put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1909 sym
->st_info
, 0, sym
->st_shndx
, name
);
1910 index
= sym
- (ElfW(Sym
) *) symtab_section
->data
;
1911 s1
->symtab_to_dynsym
[index
] = dynindex
;
1916 /* relocate the PLT: compute addresses and offsets in the PLT now that final
1917 address for PLT and GOT are known (see fill_program_header) */
1918 ST_FUNC
void relocate_plt(TCCState
*s1
)
1926 p_end
= p
+ s1
->plt
->data_offset
;
1928 #if defined(TCC_TARGET_I386)
1929 write32le(p
+ 2, read32le(p
+ 2) + s1
->got
->sh_addr
);
1930 write32le(p
+ 8, read32le(p
+ 8) + s1
->got
->sh_addr
);
1933 write32le(p
+ 2, read32le(p
+ 2) + s1
->got
->sh_addr
);
1936 #elif defined(TCC_TARGET_X86_64)
1937 int x
= s1
->got
->sh_addr
- s1
->plt
->sh_addr
- 6;
1938 write32le(p
+ 2, read32le(p
+ 2) + x
);
1939 write32le(p
+ 8, read32le(p
+ 8) + x
- 6);
1942 write32le(p
+ 2, read32le(p
+ 2) + x
+ s1
->plt
->data
- p
);
1945 #elif defined(TCC_TARGET_ARM)
1947 x
=s1
->got
->sh_addr
- s1
->plt
->sh_addr
- 12;
1950 if (read32le(p
) == 0x46c04778) /* PLT Thumb stub present */
1952 write32le(p
+ 12, x
+ read32le(p
+ 12) + s1
->plt
->data
- p
);
1955 #elif defined(TCC_TARGET_ARM64)
1956 uint64_t plt
= s1
->plt
->sh_addr
;
1957 uint64_t got
= s1
->got
->sh_addr
;
1958 uint64_t off
= (got
>> 12) - (plt
>> 12);
1959 if ((off
+ ((uint32_t)1 << 20)) >> 21)
1960 tcc_error("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", off
, got
, plt
);
1961 write32le(p
, 0xa9bf7bf0); // stp x16,x30,[sp,#-16]!
1962 write32le(p
+ 4, (0x90000010 | // adrp x16,...
1963 (off
& 0x1ffffc) << 3 | (off
& 3) << 29));
1964 write32le(p
+ 8, (0xf9400211 | // ldr x17,[x16,#...]
1965 (got
& 0xff8) << 7));
1966 write32le(p
+ 12, (0x91000210 | // add x16,x16,#...
1967 (got
& 0xfff) << 10));
1968 write32le(p
+ 16, 0xd61f0220); // br x17
1969 write32le(p
+ 20, 0xd503201f); // nop
1970 write32le(p
+ 24, 0xd503201f); // nop
1971 write32le(p
+ 28, 0xd503201f); // nop
1974 uint64_t pc
= plt
+ (p
- s1
->plt
->data
);
1975 uint64_t addr
= got
+ read64le(p
);
1976 uint64_t off
= (addr
>> 12) - (pc
>> 12);
1977 if ((off
+ ((uint32_t)1 << 20)) >> 21)
1978 tcc_error("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", off
, addr
, pc
);
1979 write32le(p
, (0x90000010 | // adrp x16,...
1980 (off
& 0x1ffffc) << 3 | (off
& 3) << 29));
1981 write32le(p
+ 4, (0xf9400211 | // ldr x17,[x16,#...]
1982 (addr
& 0xff8) << 7));
1983 write32le(p
+ 8, (0x91000210 | // add x16,x16,#...
1984 (addr
& 0xfff) << 10));
1985 write32le(p
+ 12, 0xd61f0220); // br x17
1988 #elif defined(TCC_TARGET_C67)
1991 #error unsupported CPU
1996 /* Allocate strings for section names and decide if an unallocated section
1999 NOTE: the strsec section comes last, so its size is also correct ! */
2000 static void alloc_sec_names(TCCState
*s1
, int file_type
, Section
*strsec
)
2005 /* Allocate strings for section names */
2006 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2007 s
= s1
->sections
[i
];
2008 s
->sh_name
= put_elf_str(strsec
, s
->name
);
2009 /* when generating a DLL, we include relocations but we may
2011 if (file_type
== TCC_OUTPUT_DLL
&&
2012 s
->sh_type
== SHT_RELX
&&
2013 !(s
->sh_flags
& SHF_ALLOC
)) {
2014 /* gr: avoid bogus relocs for empty (debug) sections */
2015 if (s1
->sections
[s
->sh_info
]->sh_flags
& SHF_ALLOC
)
2016 prepare_dynamic_rel(s1
, s
);
2017 else if (s1
->do_debug
)
2018 s
->sh_size
= s
->data_offset
;
2019 } else if (s1
->do_debug
||
2020 file_type
== TCC_OUTPUT_OBJ
||
2021 (s
->sh_flags
& SHF_ALLOC
) ||
2022 i
== (s1
->nb_sections
- 1)) {
2023 /* we output all sections if debug or object file */
2024 s
->sh_size
= s
->data_offset
;
2029 /* Info to be copied in dynamic section */
2033 unsigned long dyn_rel_off
;
2036 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2042 /* Assign sections to segments and decide how are sections laid out when loaded
2043 in memory. This function also fills corresponding program headers. */
2044 static int layout_sections(TCCState
*s1
, ElfW(Phdr
) *phdr
, int phnum
,
2045 Section
*interp
, Section
* strsec
,
2046 struct dyn_inf
*dyninf
, int *sec_order
)
2048 int i
, j
, k
, file_type
, sh_order_index
, file_offset
;
2049 unsigned long s_align
;
2055 file_type
= s1
->output_type
;
2058 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
2059 file_offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
2060 s_align
= ELF_PAGE_SIZE
;
2061 if (s1
->section_align
)
2062 s_align
= s1
->section_align
;
2065 if (s1
->has_text_addr
) {
2066 int a_offset
, p_offset
;
2067 addr
= s1
->text_addr
;
2068 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
2070 a_offset
= (int) (addr
& (s_align
- 1));
2071 p_offset
= file_offset
& (s_align
- 1);
2072 if (a_offset
< p_offset
)
2073 a_offset
+= s_align
;
2074 file_offset
+= (a_offset
- p_offset
);
2076 if (file_type
== TCC_OUTPUT_DLL
)
2079 addr
= ELF_START_ADDR
;
2080 /* compute address after headers */
2081 addr
+= (file_offset
& (s_align
- 1));
2085 /* Leave one program headers for the program interpreter and one for
2086 the program header table itself if needed. These are done later as
2087 they require section layout to be done first. */
2089 ph
+= 1 + HAVE_PHDR
;
2091 /* dynamic relocation table information, for .dynamic section */
2092 dyninf
->rel_addr
= dyninf
->rel_size
= 0;
2093 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2094 dyninf
->bss_addr
= dyninf
->bss_size
= 0;
2097 for(j
= 0; j
< 2; j
++) {
2098 ph
->p_type
= PT_LOAD
;
2100 ph
->p_flags
= PF_R
| PF_X
;
2102 ph
->p_flags
= PF_R
| PF_W
;
2103 ph
->p_align
= s_align
;
2105 /* Decide the layout of sections loaded in memory. This must
2106 be done before program headers are filled since they contain
2107 info about the layout. We do the following ordering: interp,
2108 symbol tables, relocations, progbits, nobits */
2109 /* XXX: do faster and simpler sorting */
2110 for(k
= 0; k
< 5; k
++) {
2111 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2112 s
= s1
->sections
[i
];
2113 /* compute if section should be included */
2115 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
2119 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
2120 (SHF_ALLOC
| SHF_WRITE
))
2126 } else if (s
->sh_type
== SHT_DYNSYM
||
2127 s
->sh_type
== SHT_STRTAB
||
2128 s
->sh_type
== SHT_HASH
) {
2131 } else if (s
->sh_type
== SHT_RELX
) {
2134 } else if (s
->sh_type
== SHT_NOBITS
) {
2141 sec_order
[sh_order_index
++] = i
;
2143 /* section matches: we align it and add its size */
2145 addr
= (addr
+ s
->sh_addralign
- 1) &
2146 ~(s
->sh_addralign
- 1);
2147 file_offset
+= (int) ( addr
- tmp
);
2148 s
->sh_offset
= file_offset
;
2151 /* update program header infos */
2152 if (ph
->p_offset
== 0) {
2153 ph
->p_offset
= file_offset
;
2155 ph
->p_paddr
= ph
->p_vaddr
;
2157 /* update dynamic relocation infos */
2158 if (s
->sh_type
== SHT_RELX
) {
2159 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2160 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.got")) {
2161 dyninf
->rel_addr
= addr
;
2162 dyninf
->rel_size
+= s
->sh_size
; /* XXX only first rel. */
2164 if (!strcmp(strsec
->data
+ s
->sh_name
, ".rel.bss")) {
2165 dyninf
->bss_addr
= addr
;
2166 dyninf
->bss_size
= s
->sh_size
; /* XXX only first rel. */
2169 if (dyninf
->rel_size
== 0)
2170 dyninf
->rel_addr
= addr
;
2171 dyninf
->rel_size
+= s
->sh_size
;
2175 if (s
->sh_type
!= SHT_NOBITS
)
2176 file_offset
+= s
->sh_size
;
2180 /* Make the first PT_LOAD segment include the program
2181 headers itself (and the ELF header as well), it'll
2182 come out with same memory use but will make various
2183 tools like binutils strip work better. */
2184 ph
->p_offset
&= ~(ph
->p_align
- 1);
2185 ph
->p_vaddr
&= ~(ph
->p_align
- 1);
2186 ph
->p_paddr
&= ~(ph
->p_align
- 1);
2188 ph
->p_filesz
= file_offset
- ph
->p_offset
;
2189 ph
->p_memsz
= addr
- ph
->p_vaddr
;
2192 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
) {
2193 /* if in the middle of a page, we duplicate the page in
2194 memory so that one copy is RX and the other is RW */
2195 if ((addr
& (s_align
- 1)) != 0)
2198 addr
= (addr
+ s_align
- 1) & ~(s_align
- 1);
2199 file_offset
= (file_offset
+ s_align
- 1) & ~(s_align
- 1);
2205 /* all other sections come after */
2206 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2207 s
= s1
->sections
[i
];
2208 if (phnum
> 0 && (s
->sh_flags
& SHF_ALLOC
))
2210 sec_order
[sh_order_index
++] = i
;
2212 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
2213 ~(s
->sh_addralign
- 1);
2214 s
->sh_offset
= file_offset
;
2215 if (s
->sh_type
!= SHT_NOBITS
)
2216 file_offset
+= s
->sh_size
;
2222 static void fill_unloadable_phdr(ElfW(Phdr
) *phdr
, int phnum
, Section
*interp
,
2227 /* if interpreter, then add corresponding program header */
2233 int len
= phnum
* sizeof(ElfW(Phdr
));
2235 ph
->p_type
= PT_PHDR
;
2236 ph
->p_offset
= sizeof(ElfW(Ehdr
));
2237 ph
->p_vaddr
= interp
->sh_addr
- len
;
2238 ph
->p_paddr
= ph
->p_vaddr
;
2239 ph
->p_filesz
= ph
->p_memsz
= len
;
2240 ph
->p_flags
= PF_R
| PF_X
;
2241 ph
->p_align
= 4; /* interp->sh_addralign; */
2245 ph
->p_type
= PT_INTERP
;
2246 ph
->p_offset
= interp
->sh_offset
;
2247 ph
->p_vaddr
= interp
->sh_addr
;
2248 ph
->p_paddr
= ph
->p_vaddr
;
2249 ph
->p_filesz
= interp
->sh_size
;
2250 ph
->p_memsz
= interp
->sh_size
;
2252 ph
->p_align
= interp
->sh_addralign
;
2255 /* if dynamic section, then add corresponding program header */
2257 ph
= &phdr
[phnum
- 1];
2259 ph
->p_type
= PT_DYNAMIC
;
2260 ph
->p_offset
= dynamic
->sh_offset
;
2261 ph
->p_vaddr
= dynamic
->sh_addr
;
2262 ph
->p_paddr
= ph
->p_vaddr
;
2263 ph
->p_filesz
= dynamic
->sh_size
;
2264 ph
->p_memsz
= dynamic
->sh_size
;
2265 ph
->p_flags
= PF_R
| PF_W
;
2266 ph
->p_align
= dynamic
->sh_addralign
;
2270 /* Fill the dynamic section with tags describing the address and size of
2272 static void fill_dynamic(TCCState
*s1
, struct dyn_inf
*dyninf
)
2276 dynamic
= dyninf
->dynamic
;
2278 /* put dynamic section entries */
2279 dynamic
->data_offset
= dyninf
->dyn_rel_off
;
2280 put_dt(dynamic
, DT_HASH
, s1
->dynsym
->hash
->sh_addr
);
2281 put_dt(dynamic
, DT_STRTAB
, dyninf
->dynstr
->sh_addr
);
2282 put_dt(dynamic
, DT_SYMTAB
, s1
->dynsym
->sh_addr
);
2283 put_dt(dynamic
, DT_STRSZ
, dyninf
->dynstr
->data_offset
);
2284 put_dt(dynamic
, DT_SYMENT
, sizeof(ElfW(Sym
)));
2285 #if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)
2286 put_dt(dynamic
, DT_RELA
, dyninf
->rel_addr
);
2287 put_dt(dynamic
, DT_RELASZ
, dyninf
->rel_size
);
2288 put_dt(dynamic
, DT_RELAENT
, sizeof(ElfW_Rel
));
2290 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2291 put_dt(dynamic
, DT_PLTGOT
, s1
->got
->sh_addr
);
2292 put_dt(dynamic
, DT_PLTRELSZ
, dyninf
->rel_size
);
2293 put_dt(dynamic
, DT_JMPREL
, dyninf
->rel_addr
);
2294 put_dt(dynamic
, DT_PLTREL
, DT_REL
);
2295 put_dt(dynamic
, DT_REL
, dyninf
->bss_addr
);
2296 put_dt(dynamic
, DT_RELSZ
, dyninf
->bss_size
);
2298 put_dt(dynamic
, DT_REL
, dyninf
->rel_addr
);
2299 put_dt(dynamic
, DT_RELSZ
, dyninf
->rel_size
);
2300 put_dt(dynamic
, DT_RELENT
, sizeof(ElfW_Rel
));
2304 put_dt(dynamic
, DT_DEBUG
, 0);
2305 put_dt(dynamic
, DT_NULL
, 0);
2308 /* Relocate remaining sections and symbols (that is those not related to
2310 static int final_sections_reloc(TCCState
*s1
)
2315 relocate_syms(s1
, 0);
2317 if (s1
->nb_errors
!= 0)
2320 /* relocate sections */
2321 /* XXX: ignore sections with allocated relocations ? */
2322 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2323 s
= s1
->sections
[i
];
2324 #ifdef TCC_TARGET_I386
2325 if (s
->reloc
&& s
!= s1
->got
&& (s
->sh_flags
& SHF_ALLOC
)) //gr
2326 /* On X86 gdb 7.3 works in any case but gdb 6.6 will crash if SHF_ALLOC
2327 checking is removed */
2329 if (s
->reloc
&& s
!= s1
->got
)
2330 /* On X86_64 gdb 7.3 will crash if SHF_ALLOC checking is present */
2332 relocate_section(s1
, s
);
2335 /* relocate relocation entries if the relocation tables are
2336 allocated in the executable */
2337 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2338 s
= s1
->sections
[i
];
2339 if ((s
->sh_flags
& SHF_ALLOC
) &&
2340 s
->sh_type
== SHT_RELX
) {
2341 relocate_rel(s1
, s
);
2347 /* Create an ELF file on disk.
2348 This function handle ELF specific layout requirements */
2349 static void tcc_output_elf(TCCState
*s1
, FILE *f
, int phnum
, ElfW(Phdr
) *phdr
,
2350 int file_offset
, int *sec_order
)
2352 int i
, shnum
, offset
, size
, file_type
;
2355 ElfW(Shdr
) shdr
, *sh
;
2357 file_type
= s1
->output_type
;
2358 shnum
= s1
->nb_sections
;
2360 memset(&ehdr
, 0, sizeof(ehdr
));
2363 ehdr
.e_phentsize
= sizeof(ElfW(Phdr
));
2364 ehdr
.e_phnum
= phnum
;
2365 ehdr
.e_phoff
= sizeof(ElfW(Ehdr
));
2369 file_offset
= (file_offset
+ 3) & -4;
2372 ehdr
.e_ident
[0] = ELFMAG0
;
2373 ehdr
.e_ident
[1] = ELFMAG1
;
2374 ehdr
.e_ident
[2] = ELFMAG2
;
2375 ehdr
.e_ident
[3] = ELFMAG3
;
2376 ehdr
.e_ident
[4] = ELFCLASSW
;
2377 ehdr
.e_ident
[5] = ELFDATA2LSB
;
2378 ehdr
.e_ident
[6] = EV_CURRENT
;
2379 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2380 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
2382 #ifdef TCC_TARGET_ARM
2384 ehdr
.e_ident
[EI_OSABI
] = 0;
2385 ehdr
.e_flags
= EF_ARM_EABI_VER4
;
2386 if (file_type
== TCC_OUTPUT_EXE
|| file_type
== TCC_OUTPUT_DLL
)
2387 ehdr
.e_flags
|= EF_ARM_HASENTRY
;
2388 if (s1
->float_abi
== ARM_HARD_FLOAT
)
2389 ehdr
.e_flags
|= EF_ARM_VFP_FLOAT
;
2391 ehdr
.e_flags
|= EF_ARM_SOFT_FLOAT
;
2393 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_ARM
;
2398 case TCC_OUTPUT_EXE
:
2399 ehdr
.e_type
= ET_EXEC
;
2400 ehdr
.e_entry
= get_elf_sym_addr(s1
, "_start", 1);
2402 case TCC_OUTPUT_DLL
:
2403 ehdr
.e_type
= ET_DYN
;
2404 ehdr
.e_entry
= text_section
->sh_addr
; /* XXX: is it correct ? */
2406 case TCC_OUTPUT_OBJ
:
2407 ehdr
.e_type
= ET_REL
;
2410 ehdr
.e_machine
= EM_TCC_TARGET
;
2411 ehdr
.e_version
= EV_CURRENT
;
2412 ehdr
.e_shoff
= file_offset
;
2413 ehdr
.e_ehsize
= sizeof(ElfW(Ehdr
));
2414 ehdr
.e_shentsize
= sizeof(ElfW(Shdr
));
2415 ehdr
.e_shnum
= shnum
;
2416 ehdr
.e_shstrndx
= shnum
- 1;
2418 fwrite(&ehdr
, 1, sizeof(ElfW(Ehdr
)), f
);
2419 fwrite(phdr
, 1, phnum
* sizeof(ElfW(Phdr
)), f
);
2420 offset
= sizeof(ElfW(Ehdr
)) + phnum
* sizeof(ElfW(Phdr
));
2422 sort_syms(s1
, symtab_section
);
2423 for(i
= 1; i
< s1
->nb_sections
; i
++) {
2424 s
= s1
->sections
[sec_order
[i
]];
2425 if (s
->sh_type
!= SHT_NOBITS
) {
2426 if (s
->sh_type
== SHT_DYNSYM
)
2427 patch_dynsym_undef(s1
, s
);
2428 while (offset
< s
->sh_offset
) {
2434 fwrite(s
->data
, 1, size
, f
);
2439 /* output section headers */
2440 while (offset
< ehdr
.e_shoff
) {
2445 for(i
= 0; i
< s1
->nb_sections
; i
++) {
2447 memset(sh
, 0, sizeof(ElfW(Shdr
)));
2448 s
= s1
->sections
[i
];
2450 sh
->sh_name
= s
->sh_name
;
2451 sh
->sh_type
= s
->sh_type
;
2452 sh
->sh_flags
= s
->sh_flags
;
2453 sh
->sh_entsize
= s
->sh_entsize
;
2454 sh
->sh_info
= s
->sh_info
;
2456 sh
->sh_link
= s
->link
->sh_num
;
2457 sh
->sh_addralign
= s
->sh_addralign
;
2458 sh
->sh_addr
= s
->sh_addr
;
2459 sh
->sh_offset
= s
->sh_offset
;
2460 sh
->sh_size
= s
->sh_size
;
2462 fwrite(sh
, 1, sizeof(ElfW(Shdr
)), f
);
2466 /* Write an elf, coff or "binary" file */
2467 static int tcc_write_elf_file(TCCState
*s1
, const char *filename
, int phnum
,
2468 ElfW(Phdr
) *phdr
, int file_offset
, int *sec_order
)
2470 int fd
, mode
, file_type
;
2473 file_type
= s1
->output_type
;
2474 if (file_type
== TCC_OUTPUT_OBJ
)
2479 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
, mode
);
2481 tcc_error_noabort("could not write '%s'", filename
);
2484 f
= fdopen(fd
, "wb");
2486 printf("<- %s\n", filename
);
2488 #ifdef TCC_TARGET_COFF
2489 if (s1
->output_format
== TCC_OUTPUT_FORMAT_COFF
)
2490 tcc_output_coff(s1
, f
);
2493 if (s1
->output_format
== TCC_OUTPUT_FORMAT_ELF
)
2494 tcc_output_elf(s1
, f
, phnum
, phdr
, file_offset
, sec_order
);
2496 tcc_output_binary(s1
, f
, sec_order
);
2502 /* Output an elf, coff or binary file */
2503 /* XXX: suppress unneeded sections */
2504 static int elf_output_file(TCCState
*s1
, const char *filename
)
2506 int i
, ret
, phnum
, shnum
, file_type
, file_offset
, *sec_order
;
2507 struct dyn_inf dyninf
;
2510 Section
*strsec
, *interp
, *dynamic
, *dynstr
;
2512 file_type
= s1
->output_type
;
2515 /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
2516 if (file_type
!= TCC_OUTPUT_OBJ
) {
2517 tcc_add_runtime(s1
);
2522 interp
= dynamic
= dynstr
= NULL
; /* avoid warning */
2523 dyninf
.dyn_rel_off
= 0; /* avoid warning */
2525 if (file_type
!= TCC_OUTPUT_OBJ
) {
2526 relocate_common_syms();
2528 tcc_add_linker_symbols(s1
);
2530 if (!s1
->static_link
) {
2531 if (file_type
== TCC_OUTPUT_EXE
) {
2533 /* allow override the dynamic loader */
2534 const char *elfint
= getenv("LD_SO");
2536 elfint
= DEFAULT_ELFINTERP(s1
);
2537 /* add interpreter section only if executable */
2538 interp
= new_section(s1
, ".interp", SHT_PROGBITS
, SHF_ALLOC
);
2539 interp
->sh_addralign
= 1;
2540 ptr
= section_ptr_add(interp
, 1 + strlen(elfint
));
2541 strcpy(ptr
, elfint
);
2544 /* add dynamic symbol table */
2545 s1
->dynsym
= new_symtab(s1
, ".dynsym", SHT_DYNSYM
, SHF_ALLOC
,
2547 ".hash", SHF_ALLOC
);
2548 dynstr
= s1
->dynsym
->link
;
2550 /* add dynamic section */
2551 dynamic
= new_section(s1
, ".dynamic", SHT_DYNAMIC
,
2552 SHF_ALLOC
| SHF_WRITE
);
2553 dynamic
->link
= dynstr
;
2554 dynamic
->sh_entsize
= sizeof(ElfW(Dyn
));
2558 if (file_type
== TCC_OUTPUT_EXE
) {
2559 bind_exe_dynsyms(s1
);
2561 if (s1
->nb_errors
) {
2566 bind_libs_dynsyms(s1
);
2567 } else /* shared library case: simply export all global symbols */
2568 export_global_syms(s1
);
2570 build_got_entries(s1
);
2572 /* add a list of needed dlls */
2573 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
2574 DLLReference
*dllref
= s1
->loaded_dlls
[i
];
2575 if (dllref
->level
== 0)
2576 put_dt(dynamic
, DT_NEEDED
, put_elf_str(dynstr
, dllref
->name
));
2580 put_dt(dynamic
, DT_RPATH
, put_elf_str(dynstr
, s1
->rpath
));
2582 /* XXX: currently, since we do not handle PIC code, we
2583 must relocate the readonly segments */
2584 if (file_type
== TCC_OUTPUT_DLL
) {
2586 put_dt(dynamic
, DT_SONAME
, put_elf_str(dynstr
, s1
->soname
));
2587 put_dt(dynamic
, DT_TEXTREL
, 0);
2591 put_dt(dynamic
, DT_SYMBOLIC
, 0);
2593 /* add necessary space for other entries */
2594 dyninf
.dyn_rel_off
= dynamic
->data_offset
;
2595 dynamic
->data_offset
+= sizeof(ElfW(Dyn
)) * EXTRA_RELITEMS
;
2597 /* still need to build got entries in case of static link */
2598 build_got_entries(s1
);
2602 /* we add a section for symbols */
2603 strsec
= new_section(s1
, ".shstrtab", SHT_STRTAB
, 0);
2604 put_elf_str(strsec
, "");
2606 /* compute number of sections */
2607 shnum
= s1
->nb_sections
;
2609 /* this array is used to reorder sections in the output file */
2610 sec_order
= tcc_malloc(sizeof(int) * shnum
);
2613 /* compute number of program headers */
2616 case TCC_OUTPUT_OBJ
:
2619 case TCC_OUTPUT_EXE
:
2620 if (!s1
->static_link
)
2621 phnum
= 4 + HAVE_PHDR
;
2625 case TCC_OUTPUT_DLL
:
2630 /* Allocate strings for section names */
2631 alloc_sec_names(s1
, file_type
, strsec
);
2633 /* allocate program segment headers */
2634 phdr
= tcc_mallocz(phnum
* sizeof(ElfW(Phdr
)));
2636 /* compute section to program header mapping */
2637 file_offset
= layout_sections(s1
, phdr
, phnum
, interp
, strsec
, &dyninf
,
2640 /* Fill remaining program header and finalize relocation related to dynamic
2643 fill_unloadable_phdr(phdr
, phnum
, interp
, dynamic
);
2645 dyninf
.dynamic
= dynamic
;
2646 dyninf
.dynstr
= dynstr
;
2648 fill_dynamic(s1
, &dyninf
);
2650 /* put in GOT the dynamic section address and relocate PLT */
2651 write32le(s1
->got
->data
, dynamic
->sh_addr
);
2652 if (file_type
== TCC_OUTPUT_EXE
2653 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
2654 || file_type
== TCC_OUTPUT_DLL
2659 /* relocate symbols in .dynsym now that final addresses are known */
2660 for_each_elem(s1
->dynsym
, 1, sym
, ElfW(Sym
)) {
2661 if (sym
->st_shndx
== SHN_UNDEF
) {
2662 /* relocate to PLT if symbol corresponds to a PLT entry,
2663 but not if it's a weak symbol */
2664 if (ELFW(ST_BIND
)(sym
->st_info
) == STB_WEAK
)
2666 else if (sym
->st_value
)
2667 sym
->st_value
+= s1
->plt
->sh_addr
;
2668 } else if (sym
->st_shndx
< SHN_LORESERVE
) {
2669 /* do symbol relocation */
2670 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
2676 /* if building executable or DLL, then relocate each section
2677 except the GOT which is already relocated */
2678 if (file_type
!= TCC_OUTPUT_OBJ
) {
2679 ret
= final_sections_reloc(s1
);
2684 /* Perform relocation to GOT or PLT entries */
2685 if (file_type
== TCC_OUTPUT_EXE
&& s1
->static_link
)
2688 /* Create the ELF file with name 'filename' */
2689 ret
= tcc_write_elf_file(s1
, filename
, phnum
, phdr
, file_offset
, sec_order
);
2691 tcc_free(s1
->symtab_to_dynsym
);
2692 tcc_free(sec_order
);
2694 tcc_free(s1
->sym_attrs
);
2695 s1
->sym_attrs
= NULL
;
2699 LIBTCCAPI
int tcc_output_file(TCCState
*s
, const char *filename
)
2702 #ifdef TCC_TARGET_PE
2703 if (s
->output_type
!= TCC_OUTPUT_OBJ
) {
2704 ret
= pe_output_file(s
, filename
);
2707 ret
= elf_output_file(s
, filename
);
2711 static void *load_data(int fd
, unsigned long file_offset
, unsigned long size
)
2715 data
= tcc_malloc(size
);
2716 lseek(fd
, file_offset
, SEEK_SET
);
2717 read(fd
, data
, size
);
2721 typedef struct SectionMergeInfo
{
2722 Section
*s
; /* corresponding existing section */
2723 unsigned long offset
; /* offset of the new section in the existing section */
2724 uint8_t new_section
; /* true if section 's' was added */
2725 uint8_t link_once
; /* true if link once section */
2728 ST_FUNC
int tcc_object_type(int fd
, ElfW(Ehdr
) *h
)
2730 int size
= read(fd
, h
, sizeof *h
);
2731 if (size
== sizeof *h
&& 0 == memcmp(h
, ELFMAG
, 4)) {
2732 if (h
->e_type
== ET_REL
)
2733 return AFF_BINTYPE_REL
;
2734 if (h
->e_type
== ET_DYN
)
2735 return AFF_BINTYPE_DYN
;
2736 } else if (size
>= 8) {
2737 if (0 == memcmp(h
, ARMAG
, 8))
2738 return AFF_BINTYPE_AR
;
2739 #ifdef TCC_TARGET_COFF
2740 if (((struct filehdr
*)h
)->f_magic
== COFF_C67_MAGIC
)
2741 return AFF_BINTYPE_C67
;
2747 /* load an object file and merge it with current files */
2748 /* XXX: handle correctly stab (debug) info */
2749 ST_FUNC
int tcc_load_object_file(TCCState
*s1
,
2750 int fd
, unsigned long file_offset
)
2753 ElfW(Shdr
) *shdr
, *sh
;
2754 int size
, i
, j
, offset
, offseti
, nb_syms
, sym_index
, ret
;
2755 unsigned char *strsec
, *strtab
;
2756 int *old_to_new_syms
;
2757 char *sh_name
, *name
;
2758 SectionMergeInfo
*sm_table
, *sm
;
2759 ElfW(Sym
) *sym
, *symtab
;
2766 stab_index
= stabstr_index
= 0;
2768 lseek(fd
, file_offset
, SEEK_SET
);
2769 if (tcc_object_type(fd
, &ehdr
) != AFF_BINTYPE_REL
)
2771 /* test CPU specific stuff */
2772 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
2773 ehdr
.e_machine
!= EM_TCC_TARGET
) {
2775 tcc_error_noabort("invalid object file");
2779 shdr
= load_data(fd
, file_offset
+ ehdr
.e_shoff
,
2780 sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
2781 sm_table
= tcc_mallocz(sizeof(SectionMergeInfo
) * ehdr
.e_shnum
);
2783 /* load section names */
2784 sh
= &shdr
[ehdr
.e_shstrndx
];
2785 strsec
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2787 /* load symtab and strtab */
2788 old_to_new_syms
= NULL
;
2792 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2794 if (sh
->sh_type
== SHT_SYMTAB
) {
2796 tcc_error_noabort("object must contain only one symtab");
2801 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
2802 symtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2803 sm_table
[i
].s
= symtab_section
;
2805 /* now load strtab */
2806 sh
= &shdr
[sh
->sh_link
];
2807 strtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
2811 /* now examine each section and try to merge its content with the
2813 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2814 /* no need to examine section name strtab */
2815 if (i
== ehdr
.e_shstrndx
)
2818 sh_name
= (char *) strsec
+ sh
->sh_name
;
2819 /* ignore sections types we do not handle */
2820 if (sh
->sh_type
!= SHT_PROGBITS
&&
2821 sh
->sh_type
!= SHT_RELX
&&
2823 sh
->sh_type
!= SHT_ARM_EXIDX
&&
2825 sh
->sh_type
!= SHT_NOBITS
&&
2826 sh
->sh_type
!= SHT_PREINIT_ARRAY
&&
2827 sh
->sh_type
!= SHT_INIT_ARRAY
&&
2828 sh
->sh_type
!= SHT_FINI_ARRAY
&&
2829 strcmp(sh_name
, ".stabstr")
2832 if (sh
->sh_addralign
< 1)
2833 sh
->sh_addralign
= 1;
2834 /* find corresponding section, if any */
2835 for(j
= 1; j
< s1
->nb_sections
;j
++) {
2836 s
= s1
->sections
[j
];
2837 if (!strcmp(s
->name
, sh_name
)) {
2838 if (!strncmp(sh_name
, ".gnu.linkonce",
2839 sizeof(".gnu.linkonce") - 1)) {
2840 /* if a 'linkonce' section is already present, we
2841 do not add it again. It is a little tricky as
2842 symbols can still be defined in
2844 sm_table
[i
].link_once
= 1;
2851 /* not found: create new section */
2852 s
= new_section(s1
, sh_name
, sh
->sh_type
, sh
->sh_flags
);
2853 /* take as much info as possible from the section. sh_link and
2854 sh_info will be updated later */
2855 s
->sh_addralign
= sh
->sh_addralign
;
2856 s
->sh_entsize
= sh
->sh_entsize
;
2857 sm_table
[i
].new_section
= 1;
2859 if (sh
->sh_type
!= s
->sh_type
) {
2860 tcc_error_noabort("invalid section type");
2864 /* align start of section */
2865 offset
= s
->data_offset
;
2867 if (0 == strcmp(sh_name
, ".stab")) {
2871 if (0 == strcmp(sh_name
, ".stabstr")) {
2876 size
= sh
->sh_addralign
- 1;
2877 offset
= (offset
+ size
) & ~size
;
2878 if (sh
->sh_addralign
> s
->sh_addralign
)
2879 s
->sh_addralign
= sh
->sh_addralign
;
2880 s
->data_offset
= offset
;
2882 sm_table
[i
].offset
= offset
;
2884 /* concatenate sections */
2886 if (sh
->sh_type
!= SHT_NOBITS
) {
2888 lseek(fd
, file_offset
+ sh
->sh_offset
, SEEK_SET
);
2889 ptr
= section_ptr_add(s
, size
);
2890 read(fd
, ptr
, size
);
2892 s
->data_offset
+= size
;
2897 /* gr relocate stab strings */
2898 if (stab_index
&& stabstr_index
) {
2901 s
= sm_table
[stab_index
].s
;
2902 a
= (Stab_Sym
*)(s
->data
+ sm_table
[stab_index
].offset
);
2903 b
= (Stab_Sym
*)(s
->data
+ s
->data_offset
);
2904 o
= sm_table
[stabstr_index
].offset
;
2906 a
->n_strx
+= o
, a
++;
2909 /* second short pass to update sh_link and sh_info fields of new
2911 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2913 if (!s
|| !sm_table
[i
].new_section
)
2916 if (sh
->sh_link
> 0)
2917 s
->link
= sm_table
[sh
->sh_link
].s
;
2918 if (sh
->sh_type
== SHT_RELX
) {
2919 s
->sh_info
= sm_table
[sh
->sh_info
].s
->sh_num
;
2920 /* update backward link */
2921 s1
->sections
[s
->sh_info
]->reloc
= s
;
2926 /* resolve symbols */
2927 old_to_new_syms
= tcc_mallocz(nb_syms
* sizeof(int));
2930 for(i
= 1; i
< nb_syms
; i
++, sym
++) {
2931 if (sym
->st_shndx
!= SHN_UNDEF
&&
2932 sym
->st_shndx
< SHN_LORESERVE
) {
2933 sm
= &sm_table
[sym
->st_shndx
];
2934 if (sm
->link_once
) {
2935 /* if a symbol is in a link once section, we use the
2936 already defined symbol. It is very important to get
2937 correct relocations */
2938 if (ELFW(ST_BIND
)(sym
->st_info
) != STB_LOCAL
) {
2939 name
= (char *) strtab
+ sym
->st_name
;
2940 sym_index
= find_elf_sym(symtab_section
, name
);
2942 old_to_new_syms
[i
] = sym_index
;
2946 /* if no corresponding section added, no need to add symbol */
2949 /* convert section number */
2950 sym
->st_shndx
= sm
->s
->sh_num
;
2952 sym
->st_value
+= sm
->offset
;
2955 name
= (char *) strtab
+ sym
->st_name
;
2956 sym_index
= add_elf_sym(symtab_section
, sym
->st_value
, sym
->st_size
,
2957 sym
->st_info
, sym
->st_other
,
2958 sym
->st_shndx
, name
);
2959 old_to_new_syms
[i
] = sym_index
;
2962 /* third pass to patch relocation entries */
2963 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
2968 offset
= sm_table
[i
].offset
;
2969 switch(s
->sh_type
) {
2971 /* take relocation offset information */
2972 offseti
= sm_table
[sh
->sh_info
].offset
;
2973 for_each_elem(s
, (offset
/ sizeof(*rel
)), rel
, ElfW_Rel
) {
2976 /* convert symbol index */
2977 type
= ELFW(R_TYPE
)(rel
->r_info
);
2978 sym_index
= ELFW(R_SYM
)(rel
->r_info
);
2979 /* NOTE: only one symtab assumed */
2980 if (sym_index
>= nb_syms
)
2982 sym_index
= old_to_new_syms
[sym_index
];
2983 /* ignore link_once in rel section. */
2984 if (!sym_index
&& !sm
->link_once
2985 #ifdef TCC_TARGET_ARM
2986 && type
!= R_ARM_V4BX
2990 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2991 i
, strsec
+ sh
->sh_name
, rel
->r_offset
);
2994 rel
->r_info
= ELFW(R_INFO
)(sym_index
, type
);
2995 /* offset the relocation offset */
2996 rel
->r_offset
+= offseti
;
2997 #ifdef TCC_TARGET_ARM
2998 /* Jumps and branches from a Thumb code to a PLT entry need
2999 special handling since PLT entries are ARM code.
3000 Unconditional bl instructions referencing PLT entries are
3001 handled by converting these instructions into blx
3002 instructions. Other case of instructions referencing a PLT
3003 entry require to add a Thumb stub before the PLT entry to
3004 switch to ARM mode. We set bit plt_thumb_stub of the
3005 attribute of a symbol to indicate such a case. */
3006 if (type
== R_ARM_THM_JUMP24
)
3007 alloc_sym_attr(s1
, sym_index
)->plt_thumb_stub
= 1;
3020 tcc_free(old_to_new_syms
);
3027 typedef struct ArchiveHeader
{
3028 char ar_name
[16]; /* name of this member */
3029 char ar_date
[12]; /* file mtime */
3030 char ar_uid
[6]; /* owner uid; printed as decimal */
3031 char ar_gid
[6]; /* owner gid; printed as decimal */
3032 char ar_mode
[8]; /* file mode, printed as octal */
3033 char ar_size
[10]; /* file size, printed as decimal */
3034 char ar_fmag
[2]; /* should contain ARFMAG */
3037 static int get_be32(const uint8_t *b
)
3039 return b
[3] | (b
[2] << 8) | (b
[1] << 16) | (b
[0] << 24);
3042 /* load only the objects which resolve undefined symbols */
3043 static int tcc_load_alacarte(TCCState
*s1
, int fd
, int size
)
3045 int i
, bound
, nsyms
, sym_index
, off
, ret
;
3047 const char *ar_names
, *p
;
3048 const uint8_t *ar_index
;
3051 data
= tcc_malloc(size
);
3052 if (read(fd
, data
, size
) != size
)
3054 nsyms
= get_be32(data
);
3055 ar_index
= data
+ 4;
3056 ar_names
= (char *) ar_index
+ nsyms
* 4;
3060 for(p
= ar_names
, i
= 0; i
< nsyms
; i
++, p
+= strlen(p
)+1) {
3061 sym_index
= find_elf_sym(symtab_section
, p
);
3063 sym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym_index
];
3064 if(sym
->st_shndx
== SHN_UNDEF
) {
3065 off
= get_be32(ar_index
+ i
* 4) + sizeof(ArchiveHeader
);
3067 if(tcc_load_object_file(s1
, fd
, off
) < 0) {
3082 /* load a '.a' file */
3083 ST_FUNC
int tcc_load_archive(TCCState
*s1
, int fd
)
3090 unsigned long file_offset
;
3092 /* skip magic which was already checked */
3093 read(fd
, magic
, sizeof(magic
));
3096 len
= read(fd
, &hdr
, sizeof(hdr
));
3099 if (len
!= sizeof(hdr
)) {
3100 tcc_error_noabort("invalid archive");
3103 memcpy(ar_size
, hdr
.ar_size
, sizeof(hdr
.ar_size
));
3104 ar_size
[sizeof(hdr
.ar_size
)] = '\0';
3105 size
= strtol(ar_size
, NULL
, 0);
3106 memcpy(ar_name
, hdr
.ar_name
, sizeof(hdr
.ar_name
));
3107 for(i
= sizeof(hdr
.ar_name
) - 1; i
>= 0; i
--) {
3108 if (ar_name
[i
] != ' ')
3111 ar_name
[i
+ 1] = '\0';
3112 file_offset
= lseek(fd
, 0, SEEK_CUR
);
3114 size
= (size
+ 1) & ~1;
3115 if (!strcmp(ar_name
, "/")) {
3116 /* coff symbol table : we handle it */
3117 if(s1
->alacarte_link
)
3118 return tcc_load_alacarte(s1
, fd
, size
);
3121 if (tcc_object_type(fd
, &ehdr
) == AFF_BINTYPE_REL
) {
3122 if (tcc_load_object_file(s1
, fd
, file_offset
) < 0)
3126 lseek(fd
, file_offset
+ size
, SEEK_SET
);
3131 #ifndef TCC_TARGET_PE
3132 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
3133 is referenced by the user (so it should be added as DT_NEEDED in
3134 the generated ELF file) */
3135 ST_FUNC
int tcc_load_dll(TCCState
*s1
, int fd
, const char *filename
, int level
)
3138 ElfW(Shdr
) *shdr
, *sh
, *sh1
;
3139 int i
, j
, nb_syms
, nb_dts
, sym_bind
, ret
;
3140 ElfW(Sym
) *sym
, *dynsym
;
3141 ElfW(Dyn
) *dt
, *dynamic
;
3142 unsigned char *dynstr
;
3143 const char *name
, *soname
;
3144 DLLReference
*dllref
;
3146 read(fd
, &ehdr
, sizeof(ehdr
));
3148 /* test CPU specific stuff */
3149 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
3150 ehdr
.e_machine
!= EM_TCC_TARGET
) {
3151 tcc_error_noabort("bad architecture");
3156 shdr
= load_data(fd
, ehdr
.e_shoff
, sizeof(ElfW(Shdr
)) * ehdr
.e_shnum
);
3158 /* load dynamic section and dynamic symbols */
3162 dynsym
= NULL
; /* avoid warning */
3163 dynstr
= NULL
; /* avoid warning */
3164 for(i
= 0, sh
= shdr
; i
< ehdr
.e_shnum
; i
++, sh
++) {
3165 switch(sh
->sh_type
) {
3167 nb_dts
= sh
->sh_size
/ sizeof(ElfW(Dyn
));
3168 dynamic
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
3171 nb_syms
= sh
->sh_size
/ sizeof(ElfW(Sym
));
3172 dynsym
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
3173 sh1
= &shdr
[sh
->sh_link
];
3174 dynstr
= load_data(fd
, sh1
->sh_offset
, sh1
->sh_size
);
3181 /* compute the real library name */
3182 soname
= tcc_basename(filename
);
3184 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
3185 if (dt
->d_tag
== DT_SONAME
) {
3186 soname
= (char *) dynstr
+ dt
->d_un
.d_val
;
3190 /* if the dll is already loaded, do not load it */
3191 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
3192 dllref
= s1
->loaded_dlls
[i
];
3193 if (!strcmp(soname
, dllref
->name
)) {
3194 /* but update level if needed */
3195 if (level
< dllref
->level
)
3196 dllref
->level
= level
;
3202 /* add the dll and its level */
3203 dllref
= tcc_mallocz(sizeof(DLLReference
) + strlen(soname
));
3204 dllref
->level
= level
;
3205 strcpy(dllref
->name
, soname
);
3206 dynarray_add((void ***)&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
, dllref
);
3208 /* add dynamic symbols in dynsym_section */
3209 for(i
= 1, sym
= dynsym
+ 1; i
< nb_syms
; i
++, sym
++) {
3210 sym_bind
= ELFW(ST_BIND
)(sym
->st_info
);
3211 if (sym_bind
== STB_LOCAL
)
3213 name
= (char *) dynstr
+ sym
->st_name
;
3214 add_elf_sym(s1
->dynsymtab_section
, sym
->st_value
, sym
->st_size
,
3215 sym
->st_info
, sym
->st_other
, sym
->st_shndx
, name
);
3218 /* load all referenced DLLs */
3219 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
3222 name
= (char *) dynstr
+ dt
->d_un
.d_val
;
3223 for(j
= 0; j
< s1
->nb_loaded_dlls
; j
++) {
3224 dllref
= s1
->loaded_dlls
[j
];
3225 if (!strcmp(name
, dllref
->name
))
3226 goto already_loaded
;
3228 if (tcc_add_dll(s1
, name
, AFF_REFERENCED_DLL
) < 0) {
3229 tcc_error_noabort("referenced dll '%s' not found", name
);
3246 #define LD_TOK_NAME 256
3247 #define LD_TOK_EOF (-1)
3249 /* return next ld script token */
3250 static int ld_next(TCCState
*s1
, char *name
, int name_size
)
3268 file
->buf_ptr
= parse_comment(file
->buf_ptr
);
3269 ch
= file
->buf_ptr
[0];
3282 /* case 'a' ... 'z': */
3309 /* case 'A' ... 'z': */
3343 if (!((ch
>= 'a' && ch
<= 'z') ||
3344 (ch
>= 'A' && ch
<= 'Z') ||
3345 (ch
>= '0' && ch
<= '9') ||
3346 strchr("/.-_+=$:\\,~", ch
)))
3348 if ((q
- name
) < name_size
- 1) {
3367 static int ld_add_file(TCCState
*s1
, const char filename
[])
3371 ret
= tcc_add_file_internal(s1
, filename
, AFF_TYPE_BIN
);
3373 ret
= tcc_add_dll(s1
, filename
, 0);
3377 static inline int new_undef_syms(void)
3380 ret
= new_undef_sym
;
3385 static int ld_add_file_list(TCCState
*s1
, const char *cmd
, int as_needed
)
3387 char filename
[1024], libname
[1024];
3388 int t
, group
, nblibs
= 0, ret
= 0;
3391 group
= !strcmp(cmd
, "GROUP");
3394 t
= ld_next(s1
, filename
, sizeof(filename
));
3397 t
= ld_next(s1
, filename
, sizeof(filename
));
3400 if (t
== LD_TOK_EOF
) {
3401 tcc_error_noabort("unexpected end of file");
3403 goto lib_parse_error
;
3404 } else if (t
== ')') {
3406 } else if (t
== '-') {
3407 t
= ld_next(s1
, filename
, sizeof(filename
));
3408 if ((t
!= LD_TOK_NAME
) || (filename
[0] != 'l')) {
3409 tcc_error_noabort("library name expected");
3411 goto lib_parse_error
;
3413 pstrcpy(libname
, sizeof libname
, &filename
[1]);
3414 if (s1
->static_link
) {
3415 snprintf(filename
, sizeof filename
, "lib%s.a", libname
);
3417 snprintf(filename
, sizeof filename
, "lib%s.so", libname
);
3419 } else if (t
!= LD_TOK_NAME
) {
3420 tcc_error_noabort("filename expected");
3422 goto lib_parse_error
;
3424 if (!strcmp(filename
, "AS_NEEDED")) {
3425 ret
= ld_add_file_list(s1
, cmd
, 1);
3427 goto lib_parse_error
;
3429 /* TODO: Implement AS_NEEDED support. Ignore it for now */
3431 ret
= ld_add_file(s1
, filename
);
3433 goto lib_parse_error
;
3435 /* Add the filename *and* the libname to avoid future conversions */
3436 dynarray_add((void ***) &libs
, &nblibs
, tcc_strdup(filename
));
3437 if (libname
[0] != '\0')
3438 dynarray_add((void ***) &libs
, &nblibs
, tcc_strdup(libname
));
3442 t
= ld_next(s1
, filename
, sizeof(filename
));
3444 t
= ld_next(s1
, filename
, sizeof(filename
));
3447 if (group
&& !as_needed
) {
3448 while (new_undef_syms()) {
3451 for (i
= 0; i
< nblibs
; i
++)
3452 ld_add_file(s1
, libs
[i
]);
3456 dynarray_reset(&libs
, &nblibs
);
3460 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3462 ST_FUNC
int tcc_load_ldscript(TCCState
*s1
)
3465 char filename
[1024];
3470 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3471 if (t
== LD_TOK_EOF
)
3473 else if (t
!= LD_TOK_NAME
)
3475 if (!strcmp(cmd
, "INPUT") ||
3476 !strcmp(cmd
, "GROUP")) {
3477 ret
= ld_add_file_list(s1
, cmd
, 0);
3480 } else if (!strcmp(cmd
, "OUTPUT_FORMAT") ||
3481 !strcmp(cmd
, "TARGET")) {
3482 /* ignore some commands */
3483 t
= ld_next(s1
, cmd
, sizeof(cmd
));
3487 t
= ld_next(s1
, filename
, sizeof(filename
));
3488 if (t
== LD_TOK_EOF
) {
3489 tcc_error_noabort("unexpected end of file");
3491 } else if (t
== ')') {
3501 #endif /* !TCC_TARGET_PE */