2 * ELF file handling for TCC
4 * Copyright (c) 2001, 2002 Fabrice Bellard
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program 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
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 static int put_elf_str(Section
*s
, const char *sym
)
26 len
= strlen(sym
) + 1;
27 offset
= s
->data_offset
;
28 ptr
= section_ptr_add(s
, len
);
29 memcpy(ptr
, sym
, len
);
33 /* elf symbol hashing function */
34 static unsigned long elf_hash(const unsigned char *name
)
36 unsigned long h
= 0, g
;
39 h
= (h
<< 4) + *name
++;
48 /* rebuild hash table of section s */
49 /* NOTE: we do factorize the hash table code to go faster */
50 static void rebuild_hash(Section
*s
, unsigned int nb_buckets
)
53 int *ptr
, *hash
, nb_syms
, sym_index
, h
;
56 strtab
= s
->link
->data
;
57 nb_syms
= s
->data_offset
/ sizeof(Elf32_Sym
);
59 s
->hash
->data_offset
= 0;
60 ptr
= section_ptr_add(s
->hash
, (2 + nb_buckets
+ nb_syms
) * sizeof(int));
65 memset(hash
, 0, (nb_buckets
+ 1) * sizeof(int));
66 ptr
+= nb_buckets
+ 1;
68 sym
= (Elf32_Sym
*)s
->data
+ 1;
69 for(sym_index
= 1; sym_index
< nb_syms
; sym_index
++) {
70 if (ELF32_ST_BIND(sym
->st_info
) != STB_LOCAL
) {
71 h
= elf_hash(strtab
+ sym
->st_name
) % nb_buckets
;
82 /* return the symbol number */
83 static int put_elf_sym(Section
*s
,
84 unsigned long value
, unsigned long size
,
85 int info
, int other
, int shndx
, const char *name
)
87 int name_offset
, sym_index
;
92 sym
= section_ptr_add(s
, sizeof(Elf32_Sym
));
94 name_offset
= put_elf_str(s
->link
, name
);
98 sym
->st_name
= name_offset
;
99 sym
->st_value
= value
;
102 sym
->st_other
= other
;
103 sym
->st_shndx
= shndx
;
104 sym_index
= sym
- (Elf32_Sym
*)s
->data
;
108 ptr
= section_ptr_add(hs
, sizeof(int));
109 base
= (int *)hs
->data
;
110 /* only add global or weak symbols */
111 if (ELF32_ST_BIND(info
) != STB_LOCAL
) {
112 /* add another hashing entry */
114 h
= elf_hash(name
) % nbuckets
;
116 base
[2 + h
] = sym_index
;
118 /* we resize the hash table */
119 hs
->nb_hashed_syms
++;
120 if (hs
->nb_hashed_syms
> 2 * nbuckets
) {
121 rebuild_hash(s
, 2 * nbuckets
);
131 /* find global ELF symbol 'name' and return its index. Return 0 if not
133 static int find_elf_sym(Section
*s
, const char *name
)
137 int nbuckets
, sym_index
, h
;
143 nbuckets
= ((int *)hs
->data
)[0];
144 h
= elf_hash(name
) % nbuckets
;
145 sym_index
= ((int *)hs
->data
)[2 + h
];
146 while (sym_index
!= 0) {
147 sym
= &((Elf32_Sym
*)s
->data
)[sym_index
];
148 name1
= s
->link
->data
+ sym
->st_name
;
149 if (!strcmp(name
, name1
))
151 sym_index
= ((int *)hs
->data
)[2 + nbuckets
+ sym_index
];
156 /* return elf symbol value or error */
157 void *tcc_get_symbol(TCCState
*s
, const char *name
)
162 sym_index
= find_elf_sym(symtab_section
, name
);
164 error("%s not defined", name
);
165 sym
= &((Elf32_Sym
*)symtab_section
->data
)[sym_index
];
166 return (void *)sym
->st_value
;
169 /* add an elf symbol : check if it is already defined and patch
170 it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
171 static int add_elf_sym(Section
*s
, unsigned long value
, unsigned long size
,
172 int info
, int sh_num
, const char *name
)
175 int sym_bind
, sym_index
, sym_type
, esym_bind
;
177 sym_bind
= ELF32_ST_BIND(info
);
178 sym_type
= ELF32_ST_TYPE(info
);
180 if (sym_bind
!= STB_LOCAL
) {
181 /* we search global or weak symbols */
182 sym_index
= find_elf_sym(s
, name
);
185 esym
= &((Elf32_Sym
*)s
->data
)[sym_index
];
186 if (esym
->st_shndx
!= SHN_UNDEF
) {
187 esym_bind
= ELF32_ST_BIND(esym
->st_info
);
188 if (sh_num
== SHN_UNDEF
) {
189 /* ignore adding of undefined symbol if the
190 corresponding symbol is already defined */
191 } else if (sym_bind
== STB_GLOBAL
&& esym_bind
== STB_WEAK
) {
192 /* global overrides weak, so patch */
194 } else if (sym_bind
== STB_WEAK
&& esym_bind
== STB_GLOBAL
) {
195 /* weak is ignored if already global */
198 printf("new_bind=%d new_shndx=%d last_bind=%d old_shndx=%d\n",
199 sym_bind
, sh_num
, esym_bind
, esym
->st_shndx
);
201 /* NOTE: we accept that two DLL define the same symbol */
202 if (s
!= tcc_state
->dynsymtab_section
)
203 error_noabort("'%s' defined twice", name
);
207 esym
->st_info
= ELF32_ST_INFO(sym_bind
, sym_type
);
208 esym
->st_shndx
= sh_num
;
209 esym
->st_value
= value
;
210 esym
->st_size
= size
;
214 sym_index
= put_elf_sym(s
, value
, size
,
215 ELF32_ST_INFO(sym_bind
, sym_type
), 0,
222 static void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
223 int type
, int symbol
)
231 /* if no relocation section, create it */
232 snprintf(buf
, sizeof(buf
), ".rel%s", s
->name
);
233 /* if the symtab is allocated, then we consider the relocation
235 sr
= new_section(tcc_state
, buf
, SHT_REL
, symtab
->sh_flags
);
236 sr
->sh_entsize
= sizeof(Elf32_Rel
);
238 sr
->sh_info
= s
->sh_num
;
241 rel
= section_ptr_add(sr
, sizeof(Elf32_Rel
));
242 rel
->r_offset
= offset
;
243 rel
->r_info
= ELF32_R_INFO(symbol
, type
);
246 /* put stab debug information */
249 unsigned long n_strx
; /* index into string table of name */
250 unsigned char n_type
; /* type of symbol */
251 unsigned char n_other
; /* misc info (usually empty) */
252 unsigned short n_desc
; /* description field */
253 unsigned long n_value
; /* value of symbol */
256 static void put_stabs(const char *str
, int type
, int other
, int desc
,
261 sym
= section_ptr_add(stab_section
, sizeof(Stab_Sym
));
263 sym
->n_strx
= put_elf_str(stabstr_section
, str
);
268 sym
->n_other
= other
;
270 sym
->n_value
= value
;
273 static void put_stabs_r(const char *str
, int type
, int other
, int desc
,
274 unsigned long value
, Section
*sec
, int sym_index
)
276 put_stabs(str
, type
, other
, desc
, value
);
277 put_elf_reloc(symtab_section
, stab_section
,
278 stab_section
->data_offset
- sizeof(unsigned long),
279 R_DATA_32
, sym_index
);
282 static void put_stabn(int type
, int other
, int desc
, int value
)
284 put_stabs(NULL
, type
, other
, desc
, value
);
287 static void put_stabd(int type
, int other
, int desc
)
289 put_stabs(NULL
, type
, other
, desc
, 0);
292 /* In an ELF file symbol table, the local symbols must appear below
293 the global and weak ones. Since TCC cannot sort it while generating
294 the code, we must do it after. All the relocation tables are also
295 modified to take into account the symbol table sorting */
296 static void sort_syms(TCCState
*s1
, Section
*s
)
298 int *old_to_new_syms
;
302 Elf32_Rel
*rel
, *rel_end
;
306 nb_syms
= s
->data_offset
/ sizeof(Elf32_Sym
);
307 new_syms
= tcc_malloc(nb_syms
* sizeof(Elf32_Sym
));
308 old_to_new_syms
= tcc_malloc(nb_syms
* sizeof(int));
310 /* first pass for local symbols */
311 p
= (Elf32_Sym
*)s
->data
;
313 for(i
= 0; i
< nb_syms
; i
++) {
314 if (ELF32_ST_BIND(p
->st_info
) == STB_LOCAL
) {
315 old_to_new_syms
[i
] = q
- new_syms
;
320 /* save the number of local symbols in section header */
321 s
->sh_info
= q
- new_syms
;
323 /* then second pass for non local symbols */
324 p
= (Elf32_Sym
*)s
->data
;
325 for(i
= 0; i
< nb_syms
; i
++) {
326 if (ELF32_ST_BIND(p
->st_info
) != STB_LOCAL
) {
327 old_to_new_syms
[i
] = q
- new_syms
;
333 /* we copy the new symbols to the old */
334 memcpy(s
->data
, new_syms
, nb_syms
* sizeof(Elf32_Sym
));
337 /* now we modify all the relocations */
338 for(i
= 1; i
< s1
->nb_sections
; i
++) {
339 sr
= s1
->sections
[i
];
340 if (sr
->sh_type
== SHT_REL
&& sr
->link
== s
) {
341 rel_end
= (Elf32_Rel
*)(sr
->data
+ sr
->data_offset
);
342 for(rel
= (Elf32_Rel
*)sr
->data
;
345 sym_index
= ELF32_R_SYM(rel
->r_info
);
346 type
= ELF32_R_TYPE(rel
->r_info
);
347 sym_index
= old_to_new_syms
[sym_index
];
348 rel
->r_info
= ELF32_R_INFO(sym_index
, type
);
353 tcc_free(old_to_new_syms
);
356 /* relocate common symbols in the .bss section */
357 static void relocate_common_syms(void)
359 Elf32_Sym
*sym
, *sym_end
;
360 unsigned long offset
, align
;
362 sym_end
= (Elf32_Sym
*)(symtab_section
->data
+ symtab_section
->data_offset
);
363 for(sym
= (Elf32_Sym
*)symtab_section
->data
+ 1;
366 if (sym
->st_shndx
== SHN_COMMON
) {
368 align
= sym
->st_value
;
369 offset
= bss_section
->data_offset
;
370 offset
= (offset
+ align
- 1) & -align
;
371 sym
->st_value
= offset
;
372 sym
->st_shndx
= bss_section
->sh_num
;
373 offset
+= sym
->st_size
;
374 bss_section
->data_offset
= offset
;
379 static void *resolve_sym(const char *sym
)
381 return dlsym(RTLD_DEFAULT
, sym
);
384 /* relocate symbol table, resolve undefined symbols if do_resolve is
385 true and output error if undefined symbol. */
386 static void relocate_syms(TCCState
*s1
, int do_resolve
)
388 Elf32_Sym
*sym
, *esym
, *sym_end
;
389 int sym_bind
, sh_num
, sym_index
;
393 sym_end
= (Elf32_Sym
*)(symtab_section
->data
+ symtab_section
->data_offset
);
394 for(sym
= (Elf32_Sym
*)symtab_section
->data
+ 1;
397 sh_num
= sym
->st_shndx
;
398 if (sh_num
== SHN_UNDEF
) {
399 name
= strtab_section
->data
+ sym
->st_name
;
401 name
= symtab_section
->link
->data
+ sym
->st_name
;
402 addr
= (unsigned long)resolve_sym(name
);
404 sym
->st_value
= addr
;
407 } else if (s1
->dynsym
) {
408 /* if dynamic symbol exist, then use it */
409 sym_index
= find_elf_sym(s1
->dynsym
, name
);
411 esym
= &((Elf32_Sym
*)s1
->dynsym
->data
)[sym_index
];
412 sym
->st_value
= esym
->st_value
;
416 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
418 if (!strcmp(name
, "_fp_hw"))
420 /* only weak symbols are accepted to be undefined. Their
422 sym_bind
= ELF32_ST_BIND(sym
->st_info
);
423 if (sym_bind
== STB_WEAK
) {
426 error_noabort("undefined symbol '%s'", name
);
428 } else if (sh_num
< SHN_LORESERVE
) {
429 /* add section base */
430 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
436 /* relocate a given section (CPU dependent) */
437 static void relocate_section(TCCState
*s1
, Section
*s
)
440 Elf32_Rel
*rel
, *rel_end
, *qrel
;
442 int type
, sym_index
, esym_index
;
444 unsigned long val
, addr
;
447 rel_end
= (Elf32_Rel
*)(sr
->data
+ sr
->data_offset
);
448 qrel
= (Elf32_Rel
*)sr
->data
;
452 ptr
= s
->data
+ rel
->r_offset
;
454 sym_index
= ELF32_R_SYM(rel
->r_info
);
455 sym
= &((Elf32_Sym
*)symtab_section
->data
)[sym_index
];
457 type
= ELF32_R_TYPE(rel
->r_info
);
458 addr
= s
->sh_addr
+ rel
->r_offset
;
463 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
464 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
465 qrel
->r_offset
= rel
->r_offset
;
467 qrel
->r_info
= ELF32_R_INFO(esym_index
, R_386_32
);
471 qrel
->r_info
= ELF32_R_INFO(0, R_386_RELATIVE
);
478 if (s1
->output_type
== TCC_OUTPUT_DLL
) {
480 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
482 qrel
->r_offset
= rel
->r_offset
;
483 qrel
->r_info
= ELF32_R_INFO(esym_index
, R_386_PC32
);
488 *(int *)ptr
+= val
- addr
;
491 *(int *)ptr
+= val
- addr
;
498 *(int *)ptr
+= s1
->got
->sh_addr
- addr
;
501 *(int *)ptr
+= val
- s1
->got
->sh_addr
;
504 /* we load the got offset */
505 *(int *)ptr
+= s1
->got_offsets
[sym_index
];
509 /* if the relocation is allocated, we change its symbol table */
510 if (sr
->sh_flags
& SHF_ALLOC
)
511 sr
->link
= s1
->dynsym
;
514 /* relocate relocation table in 'sr' */
515 static void relocate_rel(TCCState
*s1
, Section
*sr
)
518 Elf32_Rel
*rel
, *rel_end
;
520 s
= s1
->sections
[sr
->sh_info
];
521 rel_end
= (Elf32_Rel
*)(sr
->data
+ sr
->data_offset
);
522 for(rel
= (Elf32_Rel
*)sr
->data
;
525 rel
->r_offset
+= s
->sh_addr
;
529 /* count the number of dynamic relocations so that we can reserve
531 static int prepare_dynamic_rel(TCCState
*s1
, Section
*sr
)
533 Elf32_Rel
*rel
, *rel_end
;
534 int sym_index
, esym_index
, type
, count
;
537 rel_end
= (Elf32_Rel
*)(sr
->data
+ sr
->data_offset
);
538 for(rel
= (Elf32_Rel
*)sr
->data
; rel
< rel_end
; rel
++) {
539 sym_index
= ELF32_R_SYM(rel
->r_info
);
540 type
= ELF32_R_TYPE(rel
->r_info
);
546 esym_index
= s1
->symtab_to_dynsym
[sym_index
];
555 /* allocate the section */
556 sr
->sh_flags
|= SHF_ALLOC
;
557 sr
->sh_size
= count
* sizeof(Elf32_Rel
);
562 static void put_got_offset(TCCState
*s1
, int index
, unsigned long val
)
567 if (index
>= s1
->nb_got_offsets
) {
568 /* find immediately bigger power of 2 and reallocate array */
572 tab
= tcc_realloc(s1
->got_offsets
, n
* sizeof(unsigned long));
574 error("memory full");
575 s1
->got_offsets
= tab
;
576 memset(s1
->got_offsets
+ s1
->nb_got_offsets
, 0,
577 (n
- s1
->nb_got_offsets
) * sizeof(unsigned long));
578 s1
->nb_got_offsets
= n
;
580 s1
->got_offsets
[index
] = val
;
583 /* XXX: suppress that */
584 static void put32(unsigned char *p
, uint32_t val
)
592 static uint32_t get32(unsigned char *p
)
594 return p
[0] | (p
[1] << 8) | (p
[2] << 16) | (p
[3] << 24);
597 static void build_got(TCCState
*s1
)
601 /* if no got, then create it */
602 s1
->got
= new_section(s1
, ".got", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
603 s1
->got
->sh_entsize
= 4;
604 add_elf_sym(symtab_section
, 0, 4, ELF32_ST_INFO(STB_GLOBAL
, STT_OBJECT
),
605 s1
->got
->sh_num
, "_GLOBAL_OFFSET_TABLE_");
606 ptr
= section_ptr_add(s1
->got
, 3 * sizeof(int));
607 /* keep space for _DYNAMIC pointer, if present */
609 /* two dummy got entries */
614 /* put a got entry corresponding to a symbol in symtab_section. 'size'
615 and 'info' can be modifed if more precise info comes from the DLL */
616 static void put_got_entry(TCCState
*s1
,
617 int reloc_type
, unsigned long size
, int info
,
623 unsigned long offset
;
629 /* if a got entry already exists for that symbol, no need to add one */
630 if (sym_index
< s1
->nb_got_offsets
&&
631 s1
->got_offsets
[sym_index
] != 0)
634 put_got_offset(s1
, sym_index
, s1
->got
->data_offset
);
637 sym
= &((Elf32_Sym
*)symtab_section
->data
)[sym_index
];
638 name
= symtab_section
->link
->data
+ sym
->st_name
;
639 offset
= sym
->st_value
;
640 if (reloc_type
== R_386_JMP_SLOT
) {
645 /* if we build a DLL, we add a %ebx offset */
646 if (s1
->output_type
== TCC_OUTPUT_DLL
)
651 /* add a PLT entry */
653 if (plt
->data_offset
== 0) {
654 /* first plt entry */
655 p
= section_ptr_add(plt
, 16);
656 p
[0] = 0xff; /* pushl got + 4 */
659 p
[6] = 0xff; /* jmp *(got + 8) */
664 p
= section_ptr_add(plt
, 16);
665 p
[0] = 0xff; /* jmp *(got + x) */
667 put32(p
+ 2, s1
->got
->data_offset
);
668 p
[6] = 0x68; /* push $xxx */
669 put32(p
+ 7, (plt
->data_offset
- 32) >> 1);
670 p
[11] = 0xe9; /* jmp plt_start */
671 put32(p
+ 12, -(plt
->data_offset
));
673 /* the symbol is modified so that it will be relocated to
675 if (s1
->output_type
== TCC_OUTPUT_EXE
)
676 offset
= plt
->data_offset
- 16;
678 index
= put_elf_sym(s1
->dynsym
, offset
,
679 size
, info
, 0, sym
->st_shndx
, name
);
680 /* put a got entry */
681 put_elf_reloc(s1
->dynsym
, s1
->got
,
682 s1
->got
->data_offset
,
685 ptr
= section_ptr_add(s1
->got
, sizeof(int));
689 /* build GOT and PLT entries */
690 static void build_got_entries(TCCState
*s1
)
693 Elf32_Rel
*rel
, *rel_end
;
695 int i
, type
, reloc_type
, sym_index
;
697 for(i
= 1; i
< s1
->nb_sections
; i
++) {
699 if (s
->sh_type
!= SHT_REL
)
701 /* no need to handle got relocations */
702 if (s
->link
!= symtab_section
)
705 rel_end
= (Elf32_Rel
*)(s
->data
+ s
->data_offset
);
706 for(rel
= (Elf32_Rel
*)s
->data
;
709 type
= ELF32_R_TYPE(rel
->r_info
);
717 if (type
== R_386_GOT32
|| type
== R_386_PLT32
) {
718 sym_index
= ELF32_R_SYM(rel
->r_info
);
719 sym
= &((Elf32_Sym
*)symtab_section
->data
)[sym_index
];
720 /* look at the symbol got offset. If none, then add one */
721 if (type
== R_386_GOT32
)
722 reloc_type
= R_386_GLOB_DAT
;
724 reloc_type
= R_386_JMP_SLOT
;
725 put_got_entry(s1
, reloc_type
, sym
->st_size
, sym
->st_info
,
736 static Section
*new_symtab(TCCState
*s1
,
737 const char *symtab_name
, int sh_type
, int sh_flags
,
738 const char *strtab_name
,
739 const char *hash_name
, int hash_sh_flags
)
741 Section
*symtab
, *strtab
, *hash
;
742 int *ptr
, nb_buckets
;
744 symtab
= new_section(s1
, symtab_name
, sh_type
, sh_flags
);
745 symtab
->sh_entsize
= sizeof(Elf32_Sym
);
746 strtab
= new_section(s1
, strtab_name
, SHT_STRTAB
, sh_flags
);
747 put_elf_str(strtab
, "");
748 symtab
->link
= strtab
;
749 put_elf_sym(symtab
, 0, 0, 0, 0, 0, NULL
);
753 hash
= new_section(s1
, hash_name
, SHT_HASH
, hash_sh_flags
);
754 hash
->sh_entsize
= sizeof(int);
758 ptr
= section_ptr_add(hash
, (2 + nb_buckets
+ 1) * sizeof(int));
761 memset(ptr
+ 2, 0, (nb_buckets
+ 1) * sizeof(int));
765 /* put dynamic tag */
766 static void put_dt(Section
*dynamic
, int dt
, unsigned long val
)
769 dyn
= section_ptr_add(dynamic
, sizeof(Elf32_Dyn
));
771 dyn
->d_un
.d_val
= val
;
774 /* add tcc runtime libraries */
775 static void tcc_add_runtime(TCCState
*s1
)
782 snprintf(buf
, sizeof(buf
), "%s/%s", tcc_lib_path
, "libtcc1.o");
783 tcc_add_file(s1
, buf
);
785 #ifdef CONFIG_TCC_BCHECK
786 if (do_bounds_check
) {
788 Section
*init_section
;
789 unsigned char *pinit
;
792 /* XXX: add an object file to do that */
793 ptr
= section_ptr_add(bounds_section
, sizeof(unsigned long));
795 add_elf_sym(symtab_section
, 0, 0,
796 ELF32_ST_INFO(STB_GLOBAL
, STT_NOTYPE
),
797 bounds_section
->sh_num
, "__bounds_start");
798 /* add bound check code */
799 snprintf(buf
, sizeof(buf
), "%s/%s", tcc_lib_path
, "bcheck.o");
800 tcc_add_file(s1
, buf
);
801 #ifdef TCC_TARGET_I386
802 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
) {
803 /* add 'call __bound_init()' in .init section */
804 init_section
= find_section(s1
, ".init");
805 pinit
= section_ptr_add(init_section
, 5);
807 put32(pinit
+ 1, -4);
808 sym_index
= find_elf_sym(symtab_section
, "__bound_init");
809 put_elf_reloc(symtab_section
, init_section
,
810 init_section
->data_offset
- 4, R_386_PC32
, sym_index
);
815 /* add libc if not memory output */
816 if (s1
->output_type
!= TCC_OUTPUT_MEMORY
&& !s1
->nostdlib
) {
817 tcc_add_library(s1
, "c");
818 tcc_add_file(s1
, CONFIG_TCC_CRT_PREFIX
"/crtn.o");
820 /* add various standard linker symbols */
821 add_elf_sym(symtab_section
,
822 text_section
->data_offset
, 0,
823 ELF32_ST_INFO(STB_GLOBAL
, STT_NOTYPE
),
824 text_section
->sh_num
, "_etext");
825 add_elf_sym(symtab_section
,
826 data_section
->data_offset
, 0,
827 ELF32_ST_INFO(STB_GLOBAL
, STT_NOTYPE
),
828 data_section
->sh_num
, "_edata");
829 add_elf_sym(symtab_section
,
830 bss_section
->data_offset
, 0,
831 ELF32_ST_INFO(STB_GLOBAL
, STT_NOTYPE
),
832 bss_section
->sh_num
, "_end");
833 /* add start and stop symbols for sections whose name can be
835 for(i
= 1; i
< s1
->nb_sections
; i
++) {
837 if (s
->sh_type
== SHT_PROGBITS
&&
838 (s
->sh_flags
& SHF_ALLOC
)) {
842 /* check if section name can be expressed in C */
848 if (!isid(ch
) && !isnum(ch
))
852 snprintf(buf
, sizeof(buf
), "__start_%s", s
->name
);
853 add_elf_sym(symtab_section
,
855 ELF32_ST_INFO(STB_GLOBAL
, STT_NOTYPE
),
857 snprintf(buf
, sizeof(buf
), "__stop_%s", s
->name
);
858 add_elf_sym(symtab_section
,
860 ELF32_ST_INFO(STB_GLOBAL
, STT_NOTYPE
),
867 /* name of ELF interpreter */
869 static char elf_interp
[] = "/usr/libexec/ld-elf.so.1";
871 static char elf_interp
[] = "/lib/ld-linux.so.2";
874 #define ELF_START_ADDR 0x08048000
875 #define ELF_PAGE_SIZE 0x1000
877 /* output an ELF file */
878 /* XXX: suppress unneeded sections */
879 int tcc_output_file(TCCState
*s1
, const char *filename
)
885 int shnum
, i
, phnum
, file_offset
, offset
, size
, j
, tmp
, sh_order_index
, k
;
888 Elf32_Shdr shdr
, *sh
;
889 Elf32_Phdr
*phdr
, *ph
;
890 Section
*interp
, *dynamic
, *dynstr
;
891 unsigned long saved_dynamic_data_offset
;
894 unsigned long rel_addr
, rel_size
;
896 file_type
= s1
->output_type
;
899 if (file_type
!= TCC_OUTPUT_OBJ
)
903 section_order
= NULL
;
906 dynstr
= NULL
; /* avoid warning */
907 saved_dynamic_data_offset
= 0; /* avoid warning */
909 if (file_type
!= TCC_OUTPUT_OBJ
) {
911 relocate_common_syms();
913 if (!s1
->static_link
) {
915 int sym_index
, index
;
916 Elf32_Sym
*esym
, *sym_end
;
918 if (file_type
== TCC_OUTPUT_EXE
) {
920 /* add interpreter section only if executable */
921 interp
= new_section(s1
, ".interp", SHT_PROGBITS
, SHF_ALLOC
);
922 interp
->sh_addralign
= 1;
923 ptr
= section_ptr_add(interp
, sizeof(elf_interp
));
924 strcpy(ptr
, elf_interp
);
927 /* add dynamic symbol table */
928 s1
->dynsym
= new_symtab(s1
, ".dynsym", SHT_DYNSYM
, SHF_ALLOC
,
931 dynstr
= s1
->dynsym
->link
;
933 /* add dynamic section */
934 dynamic
= new_section(s1
, ".dynamic", SHT_DYNAMIC
,
935 SHF_ALLOC
| SHF_WRITE
);
936 dynamic
->link
= dynstr
;
937 dynamic
->sh_entsize
= sizeof(Elf32_Dyn
);
940 s1
->plt
= new_section(s1
, ".plt", SHT_PROGBITS
,
941 SHF_ALLOC
| SHF_EXECINSTR
);
942 s1
->plt
->sh_entsize
= 4;
946 /* scan for undefined symbols and see if they are in the
947 dynamic symbols. If a symbol STT_FUNC is found, then we
948 add it in the PLT. If a symbol STT_OBJECT is found, we
949 add it in the .bss section with a suitable relocation */
950 sym_end
= (Elf32_Sym
*)(symtab_section
->data
+
951 symtab_section
->data_offset
);
952 if (file_type
== TCC_OUTPUT_EXE
) {
953 for(sym
= (Elf32_Sym
*)symtab_section
->data
+ 1;
956 if (sym
->st_shndx
== SHN_UNDEF
) {
957 name
= symtab_section
->link
->data
+ sym
->st_name
;
958 sym_index
= find_elf_sym(s1
->dynsymtab_section
, name
);
960 esym
= &((Elf32_Sym
*)s1
->dynsymtab_section
->data
)[sym_index
];
961 type
= ELF32_ST_TYPE(esym
->st_info
);
962 if (type
== STT_FUNC
) {
963 put_got_entry(s1
, R_386_JMP_SLOT
, esym
->st_size
,
965 sym
- (Elf32_Sym
*)symtab_section
->data
);
966 } else if (type
== STT_OBJECT
) {
967 unsigned long offset
;
968 offset
= bss_section
->data_offset
;
969 /* XXX: which alignment ? */
970 offset
= (offset
+ 8 - 1) & -8;
971 index
= put_elf_sym(s1
->dynsym
, offset
, esym
->st_size
,
973 bss_section
->sh_num
, name
);
974 put_elf_reloc(s1
->dynsym
, bss_section
,
975 offset
, R_386_COPY
, index
);
976 offset
+= esym
->st_size
;
977 bss_section
->data_offset
= offset
;
980 /* STB_WEAK undefined symbols are accepted */
981 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
983 if (ELF32_ST_BIND(sym
->st_info
) == STB_WEAK
||
984 !strcmp(name
, "_fp_hw")) {
986 error_noabort("undefined symbol '%s'", name
);
995 /* now look at unresolved dynamic symbols and export
996 corresponding symbol */
997 sym_end
= (Elf32_Sym
*)(s1
->dynsymtab_section
->data
+
998 s1
->dynsymtab_section
->data_offset
);
999 for(esym
= (Elf32_Sym
*)s1
->dynsymtab_section
->data
+ 1;
1002 if (esym
->st_shndx
== SHN_UNDEF
) {
1003 name
= s1
->dynsymtab_section
->link
->data
+ esym
->st_name
;
1004 sym_index
= find_elf_sym(symtab_section
, name
);
1006 sym
= &((Elf32_Sym
*)symtab_section
->data
)[sym_index
];
1007 put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1009 sym
->st_shndx
, name
);
1011 if (ELF32_ST_BIND(esym
->st_info
) == STB_WEAK
) {
1012 /* weak symbols can stay undefined */
1014 warning("undefined dynamic symbol '%s'", name
);
1021 /* shared library case : we simply export all the global symbols */
1022 nb_syms
= symtab_section
->data_offset
/ sizeof(Elf32_Sym
);
1023 s1
->symtab_to_dynsym
= tcc_mallocz(sizeof(int) * nb_syms
);
1024 for(sym
= (Elf32_Sym
*)symtab_section
->data
+ 1;
1027 if (ELF32_ST_BIND(sym
->st_info
) != STB_LOCAL
) {
1028 name
= symtab_section
->link
->data
+ sym
->st_name
;
1029 index
= put_elf_sym(s1
->dynsym
, sym
->st_value
, sym
->st_size
,
1031 sym
->st_shndx
, name
);
1032 s1
->symtab_to_dynsym
[sym
-
1033 (Elf32_Sym
*)symtab_section
->data
] =
1039 build_got_entries(s1
);
1041 /* add a list of needed dlls */
1042 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
1043 DLLReference
*dllref
= s1
->loaded_dlls
[i
];
1044 if (dllref
->level
== 0)
1045 put_dt(dynamic
, DT_NEEDED
, put_elf_str(dynstr
, dllref
->name
));
1047 /* XXX: currently, since we do not handle PIC code, we
1048 must relocate the readonly segments */
1049 if (file_type
== TCC_OUTPUT_DLL
)
1050 put_dt(dynamic
, DT_TEXTREL
, 0);
1052 /* add necessary space for other entries */
1053 saved_dynamic_data_offset
= dynamic
->data_offset
;
1054 dynamic
->data_offset
+= 8 * 9;
1056 /* still need to build got entries in case of static link */
1057 build_got_entries(s1
);
1061 memset(&ehdr
, 0, sizeof(ehdr
));
1063 /* we add a section for symbols */
1064 strsec
= new_section(s1
, ".shstrtab", SHT_STRTAB
, 0);
1065 put_elf_str(strsec
, "");
1067 /* compute number of sections */
1068 shnum
= s1
->nb_sections
;
1070 /* this array is used to reorder sections in the output file */
1071 section_order
= tcc_malloc(sizeof(int) * shnum
);
1072 section_order
[0] = 0;
1075 /* compute number of program headers */
1078 case TCC_OUTPUT_OBJ
:
1081 case TCC_OUTPUT_EXE
:
1082 if (!s1
->static_link
)
1087 case TCC_OUTPUT_DLL
:
1092 /* allocate strings for section names and decide if an unallocated
1093 section should be output */
1094 /* NOTE: the strsec section comes last, so its size is also
1096 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1097 s
= s1
->sections
[i
];
1098 s
->sh_name
= put_elf_str(strsec
, s
->name
);
1099 /* when generating a DLL, we include relocations but we may
1101 if (file_type
== TCC_OUTPUT_DLL
&&
1102 s
->sh_type
== SHT_REL
&&
1103 !(s
->sh_flags
& SHF_ALLOC
)) {
1104 prepare_dynamic_rel(s1
, s
);
1105 } else if (do_debug
||
1106 file_type
== TCC_OUTPUT_OBJ
||
1107 (s
->sh_flags
& SHF_ALLOC
) ||
1108 i
== (s1
->nb_sections
- 1)) {
1109 /* we output all sections if debug or object file */
1110 s
->sh_size
= s
->data_offset
;
1114 /* allocate program segment headers */
1115 phdr
= tcc_mallocz(phnum
* sizeof(Elf32_Phdr
));
1117 file_offset
= sizeof(Elf32_Ehdr
) + phnum
* sizeof(Elf32_Phdr
);
1119 /* compute section to program header mapping */
1120 if (file_type
== TCC_OUTPUT_DLL
)
1123 addr
= ELF_START_ADDR
;
1125 /* dynamic relocation table information, for .dynamic section */
1129 /* compute address after headers */
1130 addr
+= (file_offset
& (ELF_PAGE_SIZE
- 1));
1132 /* leave one program header for the program interpreter */
1137 for(j
= 0; j
< 2; j
++) {
1138 ph
->p_type
= PT_LOAD
;
1140 ph
->p_flags
= PF_R
| PF_X
;
1142 ph
->p_flags
= PF_R
| PF_W
;
1143 ph
->p_align
= ELF_PAGE_SIZE
;
1145 /* we do the following ordering: interp, symbol tables,
1146 relocations, progbits, nobits */
1147 /* XXX: do faster and simpler sorting */
1148 for(k
= 0; k
< 5; k
++) {
1149 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1150 s
= s1
->sections
[i
];
1151 /* compute if section should be included */
1153 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1157 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_WRITE
)) !=
1158 (SHF_ALLOC
| SHF_WRITE
))
1164 } else if (s
->sh_type
== SHT_DYNSYM
||
1165 s
->sh_type
== SHT_STRTAB
||
1166 s
->sh_type
== SHT_HASH
) {
1169 } else if (s
->sh_type
== SHT_REL
) {
1172 } else if (s
->sh_type
== SHT_NOBITS
) {
1179 section_order
[sh_order_index
++] = i
;
1181 /* section matches: we align it and add its size */
1183 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
1184 ~(s
->sh_addralign
- 1);
1185 s
->sh_offset
= file_offset
;
1186 addr
+= file_offset
- tmp
;
1189 /* update program header infos */
1190 if (ph
->p_offset
== 0) {
1191 ph
->p_offset
= file_offset
;
1193 ph
->p_paddr
= ph
->p_vaddr
;
1195 /* update dynamic relocation infos */
1196 if (s
->sh_type
== SHT_REL
) {
1199 rel_size
+= s
->sh_size
;
1202 if (s
->sh_type
!= SHT_NOBITS
)
1203 file_offset
+= s
->sh_size
;
1206 ph
->p_filesz
= file_offset
- ph
->p_offset
;
1207 ph
->p_memsz
= addr
- ph
->p_vaddr
;
1209 /* if in the middle of a page, we duplicate the page in
1210 memory so that one copy is RX and the other is RW */
1211 if ((addr
& (ELF_PAGE_SIZE
- 1)) != 0)
1212 addr
+= ELF_PAGE_SIZE
;
1215 /* if interpreter, then add corresponing program header */
1219 ph
->p_type
= PT_INTERP
;
1220 ph
->p_offset
= interp
->sh_offset
;
1221 ph
->p_vaddr
= interp
->sh_addr
;
1222 ph
->p_paddr
= ph
->p_vaddr
;
1223 ph
->p_filesz
= interp
->sh_size
;
1224 ph
->p_memsz
= interp
->sh_size
;
1226 ph
->p_align
= interp
->sh_addralign
;
1229 /* if dynamic section, then add corresponing program header */
1233 ph
= &phdr
[phnum
- 1];
1235 ph
->p_type
= PT_DYNAMIC
;
1236 ph
->p_offset
= dynamic
->sh_offset
;
1237 ph
->p_vaddr
= dynamic
->sh_addr
;
1238 ph
->p_paddr
= ph
->p_vaddr
;
1239 ph
->p_filesz
= dynamic
->sh_size
;
1240 ph
->p_memsz
= dynamic
->sh_size
;
1241 ph
->p_flags
= PF_R
| PF_W
;
1242 ph
->p_align
= dynamic
->sh_addralign
;
1244 /* put GOT dynamic section address */
1245 put32(s1
->got
->data
, dynamic
->sh_addr
);
1247 /* relocate the PLT */
1248 if (file_type
== TCC_OUTPUT_EXE
) {
1252 p_end
= p
+ s1
->plt
->data_offset
;
1254 put32(p
+ 2, get32(p
+ 2) + s1
->got
->sh_addr
);
1255 put32(p
+ 8, get32(p
+ 8) + s1
->got
->sh_addr
);
1258 put32(p
+ 2, get32(p
+ 2) + s1
->got
->sh_addr
);
1264 /* relocate symbols in .dynsym */
1265 sym_end
= (Elf32_Sym
*)(s1
->dynsym
->data
+ s1
->dynsym
->data_offset
);
1266 for(sym
= (Elf32_Sym
*)s1
->dynsym
->data
+ 1;
1269 if (sym
->st_shndx
== SHN_UNDEF
) {
1270 /* relocate to the PLT if the symbol corresponds
1273 sym
->st_value
+= s1
->plt
->sh_addr
;
1274 } else if (sym
->st_shndx
< SHN_LORESERVE
) {
1275 /* do symbol relocation */
1276 sym
->st_value
+= s1
->sections
[sym
->st_shndx
]->sh_addr
;
1280 /* put dynamic section entries */
1281 dynamic
->data_offset
= saved_dynamic_data_offset
;
1282 put_dt(dynamic
, DT_HASH
, s1
->dynsym
->hash
->sh_addr
);
1283 put_dt(dynamic
, DT_STRTAB
, dynstr
->sh_addr
);
1284 put_dt(dynamic
, DT_SYMTAB
, s1
->dynsym
->sh_addr
);
1285 put_dt(dynamic
, DT_STRSZ
, dynstr
->data_offset
);
1286 put_dt(dynamic
, DT_SYMENT
, sizeof(Elf32_Sym
));
1287 put_dt(dynamic
, DT_REL
, rel_addr
);
1288 put_dt(dynamic
, DT_RELSZ
, rel_size
);
1289 put_dt(dynamic
, DT_RELENT
, sizeof(Elf32_Rel
));
1290 put_dt(dynamic
, DT_NULL
, 0);
1293 ehdr
.e_phentsize
= sizeof(Elf32_Phdr
);
1294 ehdr
.e_phnum
= phnum
;
1295 ehdr
.e_phoff
= sizeof(Elf32_Ehdr
);
1298 /* all other sections come after */
1299 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1300 s
= s1
->sections
[i
];
1301 if (phnum
> 0 && (s
->sh_flags
& SHF_ALLOC
))
1303 section_order
[sh_order_index
++] = i
;
1305 file_offset
= (file_offset
+ s
->sh_addralign
- 1) &
1306 ~(s
->sh_addralign
- 1);
1307 s
->sh_offset
= file_offset
;
1308 if (s
->sh_type
!= SHT_NOBITS
)
1309 file_offset
+= s
->sh_size
;
1312 /* if building executable or DLL, then relocate each section
1313 except the GOT which is already relocated */
1314 if (file_type
!= TCC_OUTPUT_OBJ
) {
1315 relocate_syms(s1
, 0);
1317 if (s1
->nb_errors
!= 0) {
1323 /* relocate sections */
1324 /* XXX: ignore sections with allocated relocations ? */
1325 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1326 s
= s1
->sections
[i
];
1327 if (s
->reloc
&& s
!= s1
->got
)
1328 relocate_section(s1
, s
);
1331 /* relocate relocation entries if the relocation tables are
1332 allocated in the executable */
1333 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1334 s
= s1
->sections
[i
];
1335 if ((s
->sh_flags
& SHF_ALLOC
) &&
1336 s
->sh_type
== SHT_REL
) {
1337 relocate_rel(s1
, s
);
1341 /* get entry point address */
1342 if (file_type
== TCC_OUTPUT_EXE
)
1343 ehdr
.e_entry
= (unsigned long)tcc_get_symbol(s1
, "_start");
1345 ehdr
.e_entry
= text_section
->sh_addr
; /* XXX: is it correct ? */
1348 sort_syms(s1
, symtab_section
);
1351 file_offset
= (file_offset
+ 3) & -4;
1354 ehdr
.e_ident
[0] = ELFMAG0
;
1355 ehdr
.e_ident
[1] = ELFMAG1
;
1356 ehdr
.e_ident
[2] = ELFMAG2
;
1357 ehdr
.e_ident
[3] = ELFMAG3
;
1358 ehdr
.e_ident
[4] = ELFCLASS32
;
1359 ehdr
.e_ident
[5] = ELFDATA2LSB
;
1360 ehdr
.e_ident
[6] = EV_CURRENT
;
1362 ehdr
.e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
1366 case TCC_OUTPUT_EXE
:
1367 ehdr
.e_type
= ET_EXEC
;
1369 case TCC_OUTPUT_DLL
:
1370 ehdr
.e_type
= ET_DYN
;
1372 case TCC_OUTPUT_OBJ
:
1373 ehdr
.e_type
= ET_REL
;
1376 ehdr
.e_machine
= EM_386
;
1377 ehdr
.e_version
= EV_CURRENT
;
1378 ehdr
.e_shoff
= file_offset
;
1379 ehdr
.e_ehsize
= sizeof(Elf32_Ehdr
);
1380 ehdr
.e_shentsize
= sizeof(Elf32_Shdr
);
1381 ehdr
.e_shnum
= shnum
;
1382 ehdr
.e_shstrndx
= shnum
- 1;
1384 /* write elf file */
1385 if (file_type
== TCC_OUTPUT_OBJ
)
1389 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
, mode
);
1391 error_noabort("could not write '%s'", filename
);
1394 f
= fdopen(fd
, "w");
1395 fwrite(&ehdr
, 1, sizeof(Elf32_Ehdr
), f
);
1396 fwrite(phdr
, 1, phnum
* sizeof(Elf32_Phdr
), f
);
1397 offset
= sizeof(Elf32_Ehdr
) + phnum
* sizeof(Elf32_Phdr
);
1398 for(i
=1;i
<s1
->nb_sections
;i
++) {
1399 s
= s1
->sections
[section_order
[i
]];
1400 if (s
->sh_type
!= SHT_NOBITS
) {
1401 while (offset
< s
->sh_offset
) {
1406 fwrite(s
->data
, 1, size
, f
);
1410 while (offset
< ehdr
.e_shoff
) {
1415 /* output section headers */
1416 for(i
=0;i
<s1
->nb_sections
;i
++) {
1418 memset(sh
, 0, sizeof(Elf32_Shdr
));
1419 s
= s1
->sections
[i
];
1421 sh
->sh_name
= s
->sh_name
;
1422 sh
->sh_type
= s
->sh_type
;
1423 sh
->sh_flags
= s
->sh_flags
;
1424 sh
->sh_entsize
= s
->sh_entsize
;
1425 sh
->sh_info
= s
->sh_info
;
1427 sh
->sh_link
= s
->link
->sh_num
;
1428 sh
->sh_addralign
= s
->sh_addralign
;
1429 sh
->sh_addr
= s
->sh_addr
;
1430 sh
->sh_offset
= s
->sh_offset
;
1431 sh
->sh_size
= s
->sh_size
;
1433 fwrite(sh
, 1, sizeof(Elf32_Shdr
), f
);
1439 tcc_free(s1
->symtab_to_dynsym
);
1440 tcc_free(section_order
);
1442 tcc_free(s1
->got_offsets
);
1446 static void *load_data(int fd
, unsigned long file_offset
, unsigned long size
)
1450 data
= tcc_malloc(size
);
1451 lseek(fd
, file_offset
, SEEK_SET
);
1452 read(fd
, data
, size
);
1456 typedef struct SectionMergeInfo
{
1457 Section
*s
; /* corresponding existing section */
1458 unsigned long offset
; /* offset of the new section in the existing section */
1459 int new_section
; /* true if section 's' was added */
1462 /* load an object file and merge it with current files */
1463 /* XXX: handle correctly stab (debug) info */
1464 static int tcc_load_object_file(TCCState
*s1
,
1465 int fd
, unsigned long file_offset
)
1468 Elf32_Shdr
*shdr
, *sh
;
1469 int size
, i
, j
, offset
, offseti
, nb_syms
, sym_index
, ret
;
1470 unsigned char *strsec
, *strtab
;
1471 int *old_to_new_syms
;
1472 char *sh_name
, *name
;
1473 SectionMergeInfo
*sm_table
, *sm
;
1474 Elf32_Sym
*sym
, *symtab
;
1475 Elf32_Rel
*rel
, *rel_end
;
1478 if (read(fd
, &ehdr
, sizeof(ehdr
)) != sizeof(ehdr
))
1480 if (ehdr
.e_ident
[0] != ELFMAG0
||
1481 ehdr
.e_ident
[1] != ELFMAG1
||
1482 ehdr
.e_ident
[2] != ELFMAG2
||
1483 ehdr
.e_ident
[3] != ELFMAG3
)
1485 /* test if object file */
1486 if (ehdr
.e_type
!= ET_REL
)
1488 /* test CPU specific stuff */
1489 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
1490 ehdr
.e_machine
!= EM_386
) {
1492 error_noabort("invalid object file");
1496 shdr
= load_data(fd
, file_offset
+ ehdr
.e_shoff
,
1497 sizeof(Elf32_Shdr
) * ehdr
.e_shnum
);
1498 sm_table
= tcc_mallocz(sizeof(SectionMergeInfo
) * ehdr
.e_shnum
);
1500 /* load section names */
1501 sh
= &shdr
[ehdr
.e_shstrndx
];
1502 strsec
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
1504 /* load symtab and strtab */
1505 old_to_new_syms
= NULL
;
1509 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
1511 if (sh
->sh_type
== SHT_SYMTAB
) {
1513 error_noabort("object must contain only one symtab");
1518 nb_syms
= sh
->sh_size
/ sizeof(Elf32_Sym
);
1519 symtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
1520 sm_table
[i
].s
= symtab_section
;
1522 /* now load strtab */
1523 sh
= &shdr
[sh
->sh_link
];
1524 strtab
= load_data(fd
, file_offset
+ sh
->sh_offset
, sh
->sh_size
);
1528 /* now examine each section and try to merge its content with the
1530 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
1531 /* no need to examine section name strtab */
1532 if (i
== ehdr
.e_shstrndx
)
1535 sh_name
= strsec
+ sh
->sh_name
;
1536 /* ignore sections types we do not handle */
1537 if (sh
->sh_type
!= SHT_PROGBITS
&&
1538 sh
->sh_type
!= SHT_REL
&&
1539 sh
->sh_type
!= SHT_NOBITS
)
1541 if (sh
->sh_addralign
< 1)
1542 sh
->sh_addralign
= 1;
1543 /* find corresponding section, if any */
1544 for(j
= 1; j
< s1
->nb_sections
;j
++) {
1545 s
= s1
->sections
[j
];
1546 if (!strcmp(s
->name
, sh_name
))
1549 /* not found: create new section */
1550 s
= new_section(s1
, sh_name
, sh
->sh_type
, sh
->sh_flags
);
1551 /* take as much info as possible from the section. sh_link and
1552 sh_info will be updated later */
1553 s
->sh_addralign
= sh
->sh_addralign
;
1554 s
->sh_entsize
= sh
->sh_entsize
;
1555 sm_table
[i
].new_section
= 1;
1557 if (sh
->sh_type
!= s
->sh_type
) {
1558 error_noabort("invalid section type");
1562 /* align start of section */
1563 offset
= s
->data_offset
;
1564 size
= sh
->sh_addralign
- 1;
1565 offset
= (offset
+ size
) & ~size
;
1566 if (sh
->sh_addralign
> s
->sh_addralign
)
1567 s
->sh_addralign
= sh
->sh_addralign
;
1568 s
->data_offset
= offset
;
1569 sm_table
[i
].offset
= offset
;
1571 /* concatenate sections */
1573 if (sh
->sh_type
!= SHT_NOBITS
) {
1575 lseek(fd
, file_offset
+ sh
->sh_offset
, SEEK_SET
);
1576 ptr
= section_ptr_add(s
, size
);
1577 read(fd
, ptr
, size
);
1579 s
->data_offset
+= size
;
1583 /* second short pass to update sh_link and sh_info fields of new
1586 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
1588 if (!s
|| !sm_table
[i
].new_section
)
1591 if (sh
->sh_link
> 0)
1592 s
->link
= sm_table
[sh
->sh_link
].s
;
1593 if (sh
->sh_type
== SHT_REL
) {
1594 s
->sh_info
= sm_table
[sh
->sh_info
].s
->sh_num
;
1595 /* update backward link */
1596 s1
->sections
[s
->sh_info
]->reloc
= s
;
1600 /* resolve symbols */
1601 old_to_new_syms
= tcc_mallocz(nb_syms
* sizeof(int));
1604 for(i
= 1; i
< nb_syms
; i
++, sym
++) {
1605 if (sym
->st_shndx
!= SHN_UNDEF
&&
1606 sym
->st_shndx
< SHN_LORESERVE
) {
1607 sm
= &sm_table
[sym
->st_shndx
];
1608 /* if no corresponding section added, no need to add symbol */
1611 /* convert section number */
1612 sym
->st_shndx
= sm
->s
->sh_num
;
1614 sym
->st_value
+= sm
->offset
;
1617 name
= strtab
+ sym
->st_name
;
1618 sym_index
= add_elf_sym(symtab_section
, sym
->st_value
, sym
->st_size
,
1619 sym
->st_info
, sym
->st_shndx
, name
);
1620 old_to_new_syms
[i
] = sym_index
;
1623 /* third pass to patch relocation entries */
1624 for(i
= 1; i
< ehdr
.e_shnum
; i
++) {
1629 offset
= sm_table
[i
].offset
;
1630 switch(s
->sh_type
) {
1632 /* take relocation offset information */
1633 offseti
= sm_table
[sh
->sh_info
].offset
;
1634 rel_end
= (Elf32_Rel
*)(s
->data
+ s
->data_offset
);
1635 for(rel
= (Elf32_Rel
*)(s
->data
+ offset
);
1640 /* convert symbol index */
1641 type
= ELF32_R_TYPE(rel
->r_info
);
1642 sym_index
= ELF32_R_SYM(rel
->r_info
);
1643 /* NOTE: only one symtab assumed */
1644 if (sym_index
>= nb_syms
)
1646 sym_index
= old_to_new_syms
[sym_index
];
1649 error_noabort("Invalid relocation entry");
1652 rel
->r_info
= ELF32_R_INFO(sym_index
, type
);
1653 /* offset the relocation offset */
1654 rel
->r_offset
+= offseti
;
1666 tcc_free(old_to_new_syms
);
1673 #define ARMAG "!<arch>\012" /* For COFF and a.out archives */
1675 typedef struct ArchiveHeader
{
1676 char ar_name
[16]; /* name of this member */
1677 char ar_date
[12]; /* file mtime */
1678 char ar_uid
[6]; /* owner uid; printed as decimal */
1679 char ar_gid
[6]; /* owner gid; printed as decimal */
1680 char ar_mode
[8]; /* file mode, printed as octal */
1681 char ar_size
[10]; /* file size, printed as decimal */
1682 char ar_fmag
[2]; /* should contain ARFMAG */
1685 static int get_be32(const uint8_t *b
)
1687 return b
[3] | (b
[2] << 8) | (b
[1] << 16) | (b
[0] << 24);
1690 /* load only the objects which resolve undefined symbols */
1691 static int tcc_load_alacarte(TCCState
*s1
, int fd
, int size
)
1693 int i
, bound
, nsyms
, sym_index
, off
, ret
;
1695 const char *ar_names
, *p
;
1696 const uint8_t *ar_index
;
1699 data
= tcc_malloc(size
);
1700 if (read(fd
, data
, size
) != size
)
1702 nsyms
= get_be32(data
);
1703 ar_index
= data
+ 4;
1704 ar_names
= ar_index
+ nsyms
* 4;
1708 for(p
= ar_names
, i
= 0; i
< nsyms
; i
++, p
+= strlen(p
)+1) {
1709 sym_index
= find_elf_sym(symtab_section
, p
);
1711 sym
= &((Elf32_Sym
*)symtab_section
->data
)[sym_index
];
1712 if(sym
->st_shndx
== SHN_UNDEF
) {
1713 off
= get_be32(ar_index
+ i
* 4) + sizeof(ArchiveHeader
);
1715 printf("%5d\t%s\t%08x\n", i
, p
, sym
->st_shndx
);
1718 lseek(fd
, off
, SEEK_SET
);
1719 if(tcc_load_object_file(s1
, fd
, off
) < 0) {
1734 /* load a '.a' file */
1735 static int tcc_load_archive(TCCState
*s1
, int fd
)
1742 unsigned long file_offset
;
1744 /* skip magic which was already checked */
1745 read(fd
, magic
, sizeof(magic
));
1748 len
= read(fd
, &hdr
, sizeof(hdr
));
1751 if (len
!= sizeof(hdr
)) {
1752 error_noabort("invalid archive");
1755 memcpy(ar_size
, hdr
.ar_size
, sizeof(hdr
.ar_size
));
1756 ar_size
[sizeof(hdr
.ar_size
)] = '\0';
1757 size
= strtol(ar_size
, NULL
, 0);
1758 memcpy(ar_name
, hdr
.ar_name
, sizeof(hdr
.ar_name
));
1759 for(i
= sizeof(hdr
.ar_name
) - 1; i
>= 0; i
--) {
1760 if (ar_name
[i
] != ' ')
1763 ar_name
[i
+ 1] = '\0';
1764 // printf("name='%s' size=%d %s\n", ar_name, size, ar_size);
1765 file_offset
= lseek(fd
, 0, SEEK_CUR
);
1767 size
= (size
+ 1) & ~1;
1768 if (!strcmp(ar_name
, "/")) {
1769 /* coff symbol table : we handle it */
1770 if(s1
->alacarte_link
)
1771 return tcc_load_alacarte(s1
, fd
, size
);
1772 } else if (!strcmp(ar_name
, "//") ||
1773 !strcmp(ar_name
, "__.SYMDEF") ||
1774 !strcmp(ar_name
, "__.SYMDEF/") ||
1775 !strcmp(ar_name
, "ARFILENAMES/")) {
1776 /* skip symbol table or archive names */
1778 if (tcc_load_object_file(s1
, fd
, file_offset
) < 0)
1781 lseek(fd
, file_offset
+ size
, SEEK_SET
);
1786 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
1787 is referenced by the user (so it should be added as DT_NEEDED in
1788 the generated ELF file) */
1789 static int tcc_load_dll(TCCState
*s1
, int fd
, const char *filename
, int level
)
1792 Elf32_Shdr
*shdr
, *sh
, *sh1
;
1793 int i
, nb_syms
, nb_dts
, sym_bind
, ret
;
1794 Elf32_Sym
*sym
, *dynsym
;
1795 Elf32_Dyn
*dt
, *dynamic
;
1796 unsigned char *dynstr
;
1797 const char *name
, *soname
, *p
;
1798 DLLReference
*dllref
;
1800 read(fd
, &ehdr
, sizeof(ehdr
));
1802 /* test CPU specific stuff */
1803 if (ehdr
.e_ident
[5] != ELFDATA2LSB
||
1804 ehdr
.e_machine
!= EM_386
) {
1805 error_noabort("bad architecture");
1810 shdr
= load_data(fd
, ehdr
.e_shoff
, sizeof(Elf32_Shdr
) * ehdr
.e_shnum
);
1812 /* load dynamic section and dynamic symbols */
1816 dynsym
= NULL
; /* avoid warning */
1817 dynstr
= NULL
; /* avoid warning */
1818 for(i
= 0, sh
= shdr
; i
< ehdr
.e_shnum
; i
++, sh
++) {
1819 switch(sh
->sh_type
) {
1821 nb_dts
= sh
->sh_size
/ sizeof(Elf32_Dyn
);
1822 dynamic
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
1825 nb_syms
= sh
->sh_size
/ sizeof(Elf32_Sym
);
1826 dynsym
= load_data(fd
, sh
->sh_offset
, sh
->sh_size
);
1827 sh1
= &shdr
[sh
->sh_link
];
1828 dynstr
= load_data(fd
, sh1
->sh_offset
, sh1
->sh_size
);
1835 /* compute the real library name */
1837 p
= strrchr(soname
, '/');
1841 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
1842 if (dt
->d_tag
== DT_SONAME
) {
1843 soname
= dynstr
+ dt
->d_un
.d_val
;
1847 /* if the dll is already loaded, do not load it */
1848 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
1849 dllref
= s1
->loaded_dlls
[i
];
1850 if (!strcmp(soname
, dllref
->name
)) {
1851 /* but update level if needed */
1852 if (level
< dllref
->level
)
1853 dllref
->level
= level
;
1859 // printf("loading dll '%s'\n", soname);
1861 /* add the dll and its level */
1862 dllref
= tcc_malloc(sizeof(DLLReference
) + strlen(soname
));
1863 dllref
->level
= level
;
1864 strcpy(dllref
->name
, soname
);
1865 dynarray_add((void ***)&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
, dllref
);
1867 /* add dynamic symbols in dynsym_section */
1868 for(i
= 1, sym
= dynsym
+ 1; i
< nb_syms
; i
++, sym
++) {
1869 sym_bind
= ELF32_ST_BIND(sym
->st_info
);
1870 if (sym_bind
== STB_LOCAL
)
1872 name
= dynstr
+ sym
->st_name
;
1873 add_elf_sym(s1
->dynsymtab_section
, sym
->st_value
, sym
->st_size
,
1874 sym
->st_info
, sym
->st_shndx
, name
);
1877 /* load all referenced DLLs */
1878 for(i
= 0, dt
= dynamic
; i
< nb_dts
; i
++, dt
++) {
1881 name
= dynstr
+ dt
->d_un
.d_val
;
1882 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
1883 dllref
= s1
->loaded_dlls
[i
];
1884 if (!strcmp(name
, dllref
->name
))
1885 goto already_loaded
;
1887 if (tcc_add_dll(s1
, name
, AFF_REFERENCED_DLL
) < 0) {
1888 error_noabort("referenced dll '%s' not found", name
);
1905 #define LD_TOK_NAME 256
1906 #define LD_TOK_EOF (-1)
1908 /* return next ld script token */
1909 static int ld_next(TCCState
*s1
, char *name
, int name_size
)
1927 file
->buf_ptr
= parse_comment(file
->buf_ptr
);
1928 ch
= file
->buf_ptr
[0];
1946 if (!((ch
>= 'a' && ch
<= 'z') ||
1947 (ch
>= 'A' && ch
<= 'Z') ||
1948 (ch
>= '0' && ch
<= '9') ||
1949 strchr("/.-_+=$:\\,~", ch
)))
1951 if ((q
- name
) < name_size
- 1) {
1968 printf("tok=%c %d\n", c
, c
);
1969 if (c
== LD_TOK_NAME
)
1970 printf(" name=%s\n", name
);
1975 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
1977 static int tcc_load_ldscript(TCCState
*s1
)
1980 char filename
[1024];
1983 ch
= file
->buf_ptr
[0];
1986 t
= ld_next(s1
, cmd
, sizeof(cmd
));
1987 if (t
== LD_TOK_EOF
)
1989 else if (t
!= LD_TOK_NAME
)
1991 if (!strcmp(cmd
, "INPUT") ||
1992 !strcmp(cmd
, "GROUP")) {
1993 t
= ld_next(s1
, cmd
, sizeof(cmd
));
1996 t
= ld_next(s1
, filename
, sizeof(filename
));
1998 if (t
== LD_TOK_EOF
) {
1999 error_noabort("unexpected end of file");
2001 } else if (t
== ')') {
2003 } else if (t
!= LD_TOK_NAME
) {
2004 error_noabort("filename expected");
2007 tcc_add_file(s1
, filename
);
2008 t
= ld_next(s1
, filename
, sizeof(filename
));
2010 t
= ld_next(s1
, filename
, sizeof(filename
));
2013 } else if (!strcmp(cmd
, "OUTPUT_FORMAT") ||
2014 !strcmp(cmd
, "TARGET")) {
2015 /* ignore some commands */
2016 t
= ld_next(s1
, cmd
, sizeof(cmd
));
2020 t
= ld_next(s1
, filename
, sizeof(filename
));
2021 if (t
== LD_TOK_EOF
) {
2022 error_noabort("unexpected end of file");
2024 } else if (t
== ')') {