?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added cvsignore
[tinycc.git] / tccelf.c
blobcd654ce32607bc8765181b77ea93db57e10ad672
1 /*
2 * ELF file handling for TCC
3 *
4 * Copyright (c) 2001, 2002 Fabrice Bellard
5 *
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.
10 *
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.
15 *
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.
19 */
20
21 static int put_elf_str(Section *s, const char *sym)
22 {
23 int offset, len;
24 char *ptr;
25
26 len = strlen(sym) + 1;
27 offset = s->data_offset;
28 ptr = section_ptr_add(s, len);
29 memcpy(ptr, sym, len);
30 return offset;
31 }
32
33 /* elf symbol hashing function */
34 static unsigned long elf_hash(const unsigned char *name)
35 {
36 unsigned long h = 0, g;
37
38 while (*name) {
39 h = (h << 4) + *name++;
40 g = h & 0xf0000000;
41 if (g)
42 h ^= g >> 24;
43 h &= ~g;
44 }
45 return h;
46 }
47
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)
51 {
52 Elf32_Sym *sym;
53 int *ptr, *hash, nb_syms, sym_index, h;
54 char *strtab;
55
56 strtab = s->link->data;
57 nb_syms = s->data_offset / sizeof(Elf32_Sym);
58
59 s->hash->data_offset = 0;
60 ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int));
61 ptr[0] = nb_buckets;
62 ptr[1] = nb_syms;
63 ptr += 2;
64 hash = ptr;
65 memset(hash, 0, (nb_buckets + 1) * sizeof(int));
66 ptr += nb_buckets + 1;
67
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;
72 *ptr = hash[h];
73 hash[h] = sym_index;
74 } else {
75 *ptr = 0;
76 }
77 ptr++;
78 sym++;
79 }
80 }
81
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)
86 {
87 int name_offset, sym_index;
88 int nbuckets, h;
89 Elf32_Sym *sym;
90 Section *hs;
91
92 sym = section_ptr_add(s, sizeof(Elf32_Sym));
93 if (name)
94 name_offset = put_elf_str(s->link, name);
95 else
96 name_offset = 0;
97 /* XXX: endianness */
98 sym->st_name = name_offset;
99 sym->st_value = value;
100 sym->st_size = size;
101 sym->st_info = info;
102 sym->st_other = other;
103 sym->st_shndx = shndx;
104 sym_index = sym - (Elf32_Sym *)s->data;
105 hs = s->hash;
106 if (hs) {
107 int *ptr, *base;
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 */
113 nbuckets = base[0];
114 h = elf_hash(name) % nbuckets;
115 *ptr = base[2 + h];
116 base[2 + h] = sym_index;
117 base[1]++;
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);
122 }
123 } else {
124 *ptr = 0;
125 base[1]++;
126 }
127 }
128 return sym_index;
129 }
130
131 /* find global ELF symbol 'name' and return its index. Return 0 if not
132 found. */
133 static int find_elf_sym(Section *s, const char *name)
134 {
135 Elf32_Sym *sym;
136 Section *hs;
137 int nbuckets, sym_index, h;
138 const char *name1;
139
140 hs = s->hash;
141 if (!hs)
142 return 0;
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))
150 return sym_index;
151 sym_index = ((int *)hs->data)[2 + nbuckets + sym_index];
152 }
153 return 0;
154 }
155
156 /* return elf symbol value or error */
157 static unsigned long get_elf_sym_val(const char *name)
158 {
159 int sym_index;
160 Elf32_Sym *sym;
161
162 sym_index = find_elf_sym(symtab_section, name);
163 if (!sym_index)
164 error("%s not defined", name);
165 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
166 return sym->st_value;
167 }
168
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)
173 {
174 Elf32_Sym *esym;
175 int sym_bind, sym_index, sym_type, esym_bind;
176
177 sym_bind = ELF32_ST_BIND(info);
178 sym_type = ELF32_ST_TYPE(info);
179
180 if (sym_bind != STB_LOCAL) {
181 /* we search global or weak symbols */
182 sym_index = find_elf_sym(s, name);
183 if (!sym_index)
184 goto do_def;
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 */
193 goto do_patch;
194 } else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) {
195 /* weak is ignored if already global */
196 } else {
197 #if 0
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);
200 #endif
201 /* NOTE: we accept that two DLL define the same symbol */
202 if (s != dynsymtab_section)
203 error("'%s' defined twice", name);
204 }
205 } else {
206 do_patch:
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;
211 }
212 } else {
213 do_def:
214 sym_index = put_elf_sym(s, value, size,
215 ELF32_ST_INFO(sym_bind, sym_type), 0,
216 sh_num, name);
217 }
218 return sym_index;
219 }
220
221 /* put relocation */
222 static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
223 int type, int symbol)
224 {
225 char buf[256];
226 Section *sr;
227 Elf32_Rel *rel;
228
229 sr = s->reloc;
230 if (!sr) {
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
234 are also */
235 sr = new_section(buf, SHT_REL, symtab->sh_flags);
236 sr->sh_entsize = sizeof(Elf32_Rel);
237 sr->link = symtab;
238 sr->sh_info = s->sh_num;
239 s->reloc = sr;
240 }
241 rel = section_ptr_add(sr, sizeof(Elf32_Rel));
242 rel->r_offset = offset;
243 rel->r_info = ELF32_R_INFO(symbol, type);
244 }
245
246 /* put stab debug information */
247
248 typedef struct {
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 */
254 } Stab_Sym;
255
256 static void put_stabs(const char *str, int type, int other, int desc,
257 unsigned long value)
258 {
259 Stab_Sym *sym;
260
261 sym = section_ptr_add(stab_section, sizeof(Stab_Sym));
262 if (str) {
263 sym->n_strx = put_elf_str(stabstr_section, str);
264 } else {
265 sym->n_strx = 0;
266 }
267 sym->n_type = type;
268 sym->n_other = other;
269 sym->n_desc = desc;
270 sym->n_value = value;
271 }
272
273 static void put_stabs_r(const char *str, int type, int other, int desc,
274 unsigned long value, Section *sec, int sym_index)
275 {
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);
280 }
281
282 static void put_stabn(int type, int other, int desc, int value)
283 {
284 put_stabs(NULL, type, other, desc, value);
285 }
286
287 static void put_stabd(int type, int other, int desc)
288 {
289 put_stabs(NULL, type, other, desc, 0);
290 }
291
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(Section *s)
297 {
298 int *old_to_new_syms;
299 Elf32_Sym *new_syms;
300 int nb_syms, i;
301 Elf32_Sym *p, *q;
302 Elf32_Rel *rel, *rel_end;
303 Section *sr;
304 int type, sym_index;
305
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));
309
310 /* first pass for local symbols */
311 p = (Elf32_Sym *)s->data;
312 q = new_syms;
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;
316 *q++ = *p;
317 }
318 p++;
319 }
320 /* save the number of local symbols in section header */
321 s->sh_info = q - new_syms;
322
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;
328 *q++ = *p;
329 }
330 p++;
331 }
332
333 /* we copy the new symbols to the old */
334 memcpy(s->data, new_syms, nb_syms * sizeof(Elf32_Sym));
335 tcc_free(new_syms);
336
337 /* now we modify all the relocations */
338 for(i = 1; i < nb_sections; i++) {
339 sr = 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;
343 rel < rel_end;
344 rel++) {
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);
349 }
350 }
351 }
352
353 tcc_free(old_to_new_syms);
354 }
355
356 /* relocate common symbols in the .bss section */
357 static void relocate_common_syms(void)
358 {
359 Elf32_Sym *sym, *sym_end;
360 unsigned long offset, align;
361
362 sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);
363 for(sym = (Elf32_Sym *)symtab_section->data + 1;
364 sym < sym_end;
365 sym++) {
366 if (sym->st_shndx == SHN_COMMON) {
367 /* align symbol */
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;
375 }
376 }
377 }
378
379 static void *resolve_sym(const char *sym)
380 {
381 return dlsym(NULL, sym);
382 }
383
384 /* relocate symbol table, resolve undefined symbols if do_resolve is
385 true and output error if undefined symbol. */
386 static void relocate_syms(int do_resolve)
387 {
388 Elf32_Sym *sym, *esym, *sym_end;
389 int sym_bind, sh_num, sym_index;
390 const char *name;
391 unsigned long addr;
392
393 sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);
394 for(sym = (Elf32_Sym *)symtab_section->data + 1;
395 sym < sym_end;
396 sym++) {
397 sh_num = sym->st_shndx;
398 if (sh_num == SHN_UNDEF) {
399 name = strtab_section->data + sym->st_name;
400 if (do_resolve) {
401 name = symtab_section->link->data + sym->st_name;
402 addr = (unsigned long)resolve_sym(name);
403 if (addr) {
404 sym->st_value = addr;
405 goto found;
406 }
407 } else if (dynsym) {
408 /* if dynamic symbol exist, then use it */
409 sym_index = find_elf_sym(dynsym, name);
410 if (sym_index) {
411 esym = &((Elf32_Sym *)dynsym->data)[sym_index];
412 sym->st_value = esym->st_value;
413 goto found;
414 }
415 }
416 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
417 it */
418 if (!strcmp(name, "_fp_hw"))
419 goto found;
420 /* only weak symbols are accepted to be undefined. Their
421 value is zero */
422 sym_bind = ELF32_ST_BIND(sym->st_info);
423 if (sym_bind == STB_WEAK) {
424 sym->st_value = 0;
425 } else {
426 error("undefined symbol '%s'", name);
427 }
428 } else if (sh_num < SHN_LORESERVE) {
429 /* add section base */
430 sym->st_value += sections[sym->st_shndx]->sh_addr;
431 }
432 found: ;
433 }
434 }
435
436 /* relocate a given section (CPU dependant) */
437 static void relocate_section(TCCState *s1, Section *s)
438 {
439 Section *sr;
440 Elf32_Rel *rel, *rel_end, *qrel;
441 Elf32_Sym *sym;
442 int type, sym_index, esym_index;
443 unsigned char *ptr;
444 unsigned long val, addr;
445
446 sr = s->reloc;
447 rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
448 qrel = (Elf32_Rel *)sr->data;
449 for(rel = qrel;
450 rel < rel_end;
451 rel++) {
452 ptr = s->data + rel->r_offset;
453
454 sym_index = ELF32_R_SYM(rel->r_info);
455 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
456 val = sym->st_value;
457 type = ELF32_R_TYPE(rel->r_info);
458 addr = s->sh_addr + rel->r_offset;
459
460 /* CPU specific */
461 switch(type) {
462 case R_386_32:
463 if (s1->output_type == TCC_OUTPUT_DLL) {
464 esym_index = symtab_to_dynsym[sym_index];
465 qrel->r_offset = rel->r_offset;
466 if (esym_index) {
467 qrel->r_info = ELF32_R_INFO(esym_index, R_386_32);
468 qrel++;
469 break;
470 } else {
471 qrel->r_info = ELF32_R_INFO(0, R_386_RELATIVE);
472 qrel++;
473 }
474 }
475 *(int *)ptr += val;
476 break;
477 case R_386_PC32:
478 if (s1->output_type == TCC_OUTPUT_DLL) {
479 /* DLL relocation */
480 esym_index = symtab_to_dynsym[sym_index];
481 if (esym_index) {
482 qrel->r_offset = rel->r_offset;
483 qrel->r_info = ELF32_R_INFO(esym_index, R_386_PC32);
484 qrel++;
485 break;
486 }
487 }
488 *(int *)ptr += val - addr;
489 break;
490 case R_386_PLT32:
491 *(int *)ptr += val - addr;
492 break;
493 case R_386_GLOB_DAT:
494 case R_386_JMP_SLOT:
495 *(int *)ptr = val;
496 break;
497 case R_386_GOTPC:
498 *(int *)ptr += got->sh_addr - addr;
499 break;
500 case R_386_GOTOFF:
501 *(int *)ptr += val - got->sh_addr;
502 break;
503 case R_386_GOT32:
504 /* we load the got offset */
505 *(int *)ptr += got_offsets[sym_index];
506 break;
507 }
508 }
509 /* if the relocation is allocated, we change its symbol table */
510 if (sr->sh_flags & SHF_ALLOC)
511 sr->link = dynsym;
512 }
513
514 /* relocate relocation table in 'sr' */
515 static void relocate_rel(Section *sr)
516 {
517 Section *s;
518 Elf32_Rel *rel, *rel_end;
519
520 s = sections[sr->sh_info];
521 rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
522 for(rel = (Elf32_Rel *)sr->data;
523 rel < rel_end;
524 rel++) {
525 rel->r_offset += s->sh_addr;
526 }
527 }
528
529 /* count the number of dynamic relocations so that we can reserve
530 their space */
531 static int prepare_dynamic_rel(Section *sr)
532 {
533 Elf32_Rel *rel, *rel_end;
534 int sym_index, esym_index, type, count;
535
536 count = 0;
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);
541 switch(type) {
542 case R_386_32:
543 count++;
544 break;
545 case R_386_PC32:
546 esym_index = symtab_to_dynsym[sym_index];
547 if (esym_index)
548 count++;
549 break;
550 default:
551 break;
552 }
553 }
554 if (count) {
555 /* allocate the section */
556 sr->sh_flags |= SHF_ALLOC;
557 sr->sh_size = count * sizeof(Elf32_Rel);
558 }
559 return count;
560 }
561
562 static void put_got_offset(int index, unsigned long val)
563 {
564 int n;
565 unsigned long *tab;
566
567 if (index >= nb_got_offsets) {
568 /* find immediately bigger power of 2 and reallocate array */
569 n = 1;
570 while (index >= n)
571 n *= 2;
572 tab = tcc_realloc(got_offsets, n * sizeof(unsigned long));
573 if (!tab)
574 error("memory full");
575 got_offsets = tab;
576 memset(got_offsets + nb_got_offsets, 0,
577 (n - nb_got_offsets) * sizeof(unsigned long));
578 nb_got_offsets = n;
579 }
580 got_offsets[index] = val;
581 }
582
583 /* XXX: suppress that */
584 static void put32(unsigned char *p, unsigned int val)
585 {
586 p[0] = val;
587 p[1] = val >> 8;
588 p[2] = val >> 16;
589 p[3] = val >> 24;
590 }
591
592 static void build_got(void)
593 {
594 unsigned char *ptr;
595
596 /* if no got, then create it */
597 got = new_section(".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
598 got->sh_entsize = 4;
599 add_elf_sym(symtab_section, 0, 4, ELF32_ST_INFO(STB_GLOBAL, STT_OBJECT),
600 got->sh_num, "_GLOBAL_OFFSET_TABLE_");
601 ptr = section_ptr_add(got, 3 * sizeof(int));
602 /* keep space for _DYNAMIC pointer, if present */
603 put32(ptr, 0);
604 /* two dummy got entries */
605 put32(ptr + 4, 0);
606 put32(ptr + 8, 0);
607 }
608
609 /* put a got entry corresponding to a symbol in symtab_section. 'size'
610 and 'info' can be modifed if more precise info comes from the DLL */
611 static void put_got_entry(int reloc_type, unsigned long size, int info,
612 int sym_index)
613 {
614 int index;
615 const char *name;
616 Elf32_Sym *sym;
617 unsigned long offset;
618 int *ptr;
619
620 if (!got)
621 build_got();
622
623 /* if a got entry already exists for that symbol, no need to add one */
624 if (sym_index < nb_got_offsets &&
625 got_offsets[sym_index] != 0)
626 return;
627
628 put_got_offset(sym_index, got->data_offset);
629
630 if (dynsym) {
631 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
632 name = symtab_section->link->data + sym->st_name;
633 offset = sym->st_value;
634 /* NOTE: we put temporarily the got offset */
635 if (reloc_type == R_386_JMP_SLOT) {
636 nb_plt_entries++;
637 offset = got->data_offset;
638 }
639 index = put_elf_sym(dynsym, offset,
640 size, info, 0, sym->st_shndx, name);
641 /* put a got entry */
642 put_elf_reloc(dynsym, got,
643 got->data_offset,
644 reloc_type, index);
645 }
646 ptr = section_ptr_add(got, sizeof(int));
647 *ptr = 0;
648 }
649
650 /* build GOT and PLT entries */
651 static void build_got_entries(void)
652 {
653 Section *s, *symtab;
654 Elf32_Rel *rel, *rel_end;
655 Elf32_Sym *sym;
656 int i, type, reloc_type, sym_index;
657
658 for(i = 1; i < nb_sections; i++) {
659 s = sections[i];
660 if (s->sh_type != SHT_REL)
661 continue;
662 /* no need to handle got relocations */
663 if (s->link != symtab_section)
664 continue;
665 symtab = s->link;
666 rel_end = (Elf32_Rel *)(s->data + s->data_offset);
667 for(rel = (Elf32_Rel *)s->data;
668 rel < rel_end;
669 rel++) {
670 type = ELF32_R_TYPE(rel->r_info);
671 switch(type) {
672 case R_386_GOT32:
673 case R_386_GOTOFF:
674 case R_386_GOTPC:
675 case R_386_PLT32:
676 if (!got)
677 build_got();
678 if (type == R_386_GOT32 || type == R_386_PLT32) {
679 sym_index = ELF32_R_SYM(rel->r_info);
680 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
681 /* look at the symbol got offset. If none, then add one */
682 if (type == R_386_GOT32)
683 reloc_type = R_386_GLOB_DAT;
684 else
685 reloc_type = R_386_JMP_SLOT;
686 put_got_entry(reloc_type, sym->st_size, sym->st_info,
687 sym_index);
688 }
689 break;
690 default:
691 break;
692 }
693 }
694 }
695 }
696
697 static Section *new_symtab(const char *symtab_name, int sh_type, int sh_flags,
698 const char *strtab_name,
699 const char *hash_name, int hash_sh_flags)
700 {
701 Section *symtab, *strtab, *hash;
702 int *ptr, nb_buckets;
703
704 symtab = new_section(symtab_name, sh_type, sh_flags);
705 symtab->sh_entsize = sizeof(Elf32_Sym);
706 strtab = new_section(strtab_name, SHT_STRTAB, sh_flags);
707 put_elf_str(strtab, "");
708 symtab->link = strtab;
709 put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL);
710
711 nb_buckets = 1;
712
713 hash = new_section(hash_name, SHT_HASH, hash_sh_flags);
714 hash->sh_entsize = sizeof(int);
715 symtab->hash = hash;
716 hash->link = symtab;
717
718 ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int));
719 ptr[0] = nb_buckets;
720 ptr[1] = 1;
721 memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int));
722 return symtab;
723 }
724
725 /* put dynamic tag */
726 static void put_dt(Section *dynamic, int dt, unsigned long val)
727 {
728 Elf32_Dyn *dyn;
729 dyn = section_ptr_add(dynamic, sizeof(Elf32_Dyn));
730 dyn->d_tag = dt;
731 dyn->d_un.d_val = val;
732 }
733
734 /* add tcc runtime libraries */
735 static void tcc_add_runtime(TCCState *s1)
736 {
737 char buf[1024];
738 int i;
739 Section *s;
740
741 snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "libtcc1.o");
742 tcc_add_file(s1, buf);
743 #ifdef CONFIG_TCC_BCHECK
744 if (do_bounds_check) {
745 unsigned long *ptr;
746 Section *init_section;
747 unsigned char *pinit;
748 int sym_index;
749
750 /* XXX: add an object file to do that */
751 ptr = section_ptr_add(bounds_section, sizeof(unsigned long));
752 *ptr = 0;
753 add_elf_sym(symtab_section, 0, 0,
754 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE),
755 bounds_section->sh_num, "__bounds_start");
756 /* add bound check code */
757 snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "bcheck.o");
758 tcc_add_file(s1, buf);
759 #ifdef TCC_TARGET_I386
760 if (s1->output_type != TCC_OUTPUT_MEMORY) {
761 /* add 'call __bound_init()' in .init section */
762 init_section = find_section(".init");
763 pinit = section_ptr_add(init_section, 5);
764 pinit[0] = 0xe8;
765 put32(pinit + 1, -4);
766 sym_index = find_elf_sym(symtab_section, "__bound_init");
767 put_elf_reloc(symtab_section, init_section,
768 init_section->data_offset - 4, R_386_PC32, sym_index);
769 }
770 #endif
771 }
772 #endif
773 /* add libc if not memory output */
774 if (s1->output_type != TCC_OUTPUT_MEMORY) {
775 tcc_add_library(s1, "c");
776 tcc_add_file(s1, CONFIG_TCC_CRT_PREFIX "/crtn.o");
777 }
778 /* add various standard linker symbols */
779 add_elf_sym(symtab_section,
780 text_section->data_offset, 0,
781 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE),
782 text_section->sh_num, "_etext");
783 add_elf_sym(symtab_section,
784 data_section->data_offset, 0,
785 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE),
786 data_section->sh_num, "_edata");
787 add_elf_sym(symtab_section,
788 bss_section->data_offset, 0,
789 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE),
790 bss_section->sh_num, "_end");
791 /* add start and stop symbols for sections whose name can be
792 expressed in C */
793 for(i = 1; i < nb_sections; i++) {
794 s = sections[i];
795 if (s->sh_type == SHT_PROGBITS &&
796 (s->sh_flags & SHF_ALLOC)) {
797 const char *p;
798 int ch;
799
800 /* check if section name can be expressed in C */
801 p = s->name;
802 for(;;) {
803 ch = *p;
804 if (!ch)
805 break;
806 if (!isid(ch) && !isnum(ch))
807 goto next_sec;
808 p++;
809 }
810 snprintf(buf, sizeof(buf), "__start_%s", s->name);
811 add_elf_sym(symtab_section,
812 0, 0,
813 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE),
814 s->sh_num, buf);
815 snprintf(buf, sizeof(buf), "__stop_%s", s->name);
816 add_elf_sym(symtab_section,
817 s->data_offset, 0,
818 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE),
819 s->sh_num, buf);
820 }
821 next_sec: ;
822 }
823 }
824
825 /* name of ELF interpreter */
826 static char elf_interp[] = "/lib/ld-linux.so.2";
827
828 #define ELF_START_ADDR 0x08048000
829 #define ELF_PAGE_SIZE 0x1000
830
831 /* output an ELF file */
832 /* XXX: suppress unneeded sections */
833 int tcc_output_file(TCCState *s1, const char *filename)
834 {
835 Elf32_Ehdr ehdr;
836 FILE *f;
837 int fd, mode;
838 int *section_order;
839 int shnum, i, phnum, file_offset, offset, size, j, tmp, sh_order_index, k;
840 unsigned long addr;
841 Section *strsec, *s;
842 Elf32_Shdr shdr, *sh;
843 Elf32_Phdr *phdr, *ph;
844 Section *interp, *plt, *dynamic, *dynstr;
845 unsigned long saved_dynamic_data_offset;
846 Elf32_Sym *sym;
847 int type, file_type;
848 unsigned long rel_addr, rel_size;
849
850 file_type = s1->output_type;
851
852 if (file_type != TCC_OUTPUT_OBJ)
853 tcc_add_runtime(s1);
854
855 interp = NULL;
856 dynamic = NULL;
857 dynsym = NULL;
858 got = NULL;
859 nb_plt_entries = 0;
860 plt = NULL; /* avoid warning */
861 dynstr = NULL; /* avoid warning */
862 saved_dynamic_data_offset = 0; /* avoid warning */
863
864 if (file_type != TCC_OUTPUT_OBJ) {
865
866 relocate_common_syms();
867
868 if (!static_link) {
869 const char *name;
870 int sym_index, index;
871 Elf32_Sym *esym, *sym_end;
872
873 if (file_type == TCC_OUTPUT_EXE) {
874 char *ptr;
875 /* add interpreter section only if executable */
876 interp = new_section(".interp", SHT_PROGBITS, SHF_ALLOC);
877 interp->sh_addralign = 1;
878 ptr = section_ptr_add(interp, sizeof(elf_interp));
879 strcpy(ptr, elf_interp);
880 }
881
882 /* add dynamic symbol table */
883 dynsym = new_symtab(".dynsym", SHT_DYNSYM, SHF_ALLOC,
884 ".dynstr",
885 ".hash", SHF_ALLOC);
886 dynstr = dynsym->link;
887
888 /* add dynamic section */
889 dynamic = new_section(".dynamic", SHT_DYNAMIC,
890 SHF_ALLOC | SHF_WRITE);
891 dynamic->link = dynstr;
892 dynamic->sh_entsize = sizeof(Elf32_Dyn);
893
894 /* add PLT */
895 plt = new_section(".plt", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
896 plt->sh_entsize = 4;
897
898 build_got();
899
900 /* scan for undefined symbols and see if they are in the
901 dynamic symbols. If a symbol STT_FUNC is found, then we
902 add it in the PLT. If a symbol STT_OBJECT is found, we
903 add it in the .bss section with a suitable relocation */
904 sym_end = (Elf32_Sym *)(symtab_section->data +
905 symtab_section->data_offset);
906 if (file_type == TCC_OUTPUT_EXE) {
907 for(sym = (Elf32_Sym *)symtab_section->data + 1;
908 sym < sym_end;
909 sym++) {
910 if (sym->st_shndx == SHN_UNDEF) {
911 name = symtab_section->link->data + sym->st_name;
912 sym_index = find_elf_sym(dynsymtab_section, name);
913 if (sym_index) {
914 esym = &((Elf32_Sym *)dynsymtab_section->data)[sym_index];
915 type = ELF32_ST_TYPE(esym->st_info);
916 if (type == STT_FUNC) {
917 put_got_entry(R_386_JMP_SLOT, esym->st_size,
918 esym->st_info,
919 sym - (Elf32_Sym *)symtab_section->data);
920 } else if (type == STT_OBJECT) {
921 unsigned long offset;
922 offset = bss_section->data_offset;
923 /* XXX: which alignment ? */
924 offset = (offset + 8 - 1) & -8;
925 index = put_elf_sym(dynsym, offset, esym->st_size,
926 esym->st_info, 0,
927 bss_section->sh_num, name);
928 put_elf_reloc(dynsym, bss_section,
929 offset, R_386_COPY, index);
930 offset += esym->st_size;
931 bss_section->data_offset = offset;
932 }
933 } else {
934 /* STB_WEAK undefined symbols are accepted */
935 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
936 it */
937 if (ELF32_ST_BIND(sym->st_info) == STB_WEAK ||
938 !strcmp(name, "_fp_hw")) {
939 } else {
940 error("undefined symbol '%s'", name);
941 }
942 }
943 }
944 }
945
946 /* now look at unresolved dynamic symbols and export
947 corresponding symbol */
948 sym_end = (Elf32_Sym *)(dynsymtab_section->data +
949 dynsymtab_section->data_offset);
950 for(esym = (Elf32_Sym *)dynsymtab_section->data + 1;
951 esym < sym_end;
952 esym++) {
953 if (esym->st_shndx == SHN_UNDEF) {
954 name = dynsymtab_section->link->data + esym->st_name;
955 sym_index = find_elf_sym(symtab_section, name);
956 if (sym_index) {
957 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
958 put_elf_sym(dynsym, sym->st_value, sym->st_size,
959 sym->st_info, 0,
960 sym->st_shndx, name);
961 } else {
962 if (ELF32_ST_BIND(esym->st_info) == STB_WEAK) {
963 /* weak symbols can stay undefined */
964 } else {
965 warning("undefined dynamic symbol '%s'", name);
966 }
967 }
968 }
969 }
970 } else {
971 int nb_syms;
972 /* shared library case : we simply export all the global symbols */
973 nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym);
974 symtab_to_dynsym = tcc_mallocz(sizeof(int) * nb_syms);
975 for(sym = (Elf32_Sym *)symtab_section->data + 1;
976 sym < sym_end;
977 sym++) {
978 if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
979 name = symtab_section->link->data + sym->st_name;
980 index = put_elf_sym(dynsym, sym->st_value, sym->st_size,
981 sym->st_info, 0,
982 sym->st_shndx, name);
983 symtab_to_dynsym[sym - (Elf32_Sym *)symtab_section->data] =
984 index;
985 }
986 }
987 }
988
989 build_got_entries();
990
991 /* update PLT/GOT sizes so that we can allocate their space */
992 plt->data_offset += 16 * (nb_plt_entries + 1);
993
994 /* add a list of needed dlls */
995 for(i = 0; i < nb_loaded_dlls; i++) {
996 DLLReference *dllref = loaded_dlls[i];
997 if (dllref->level == 0)
998 put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name));
999 }
1000 /* XXX: currently, since we do not handle PIC code, we
1001 must relocate the readonly segments */
1002 if (file_type == TCC_OUTPUT_DLL)
1003 put_dt(dynamic, DT_TEXTREL, 0);
1004
1005 /* add necessary space for other entries */
1006 saved_dynamic_data_offset = dynamic->data_offset;
1007 dynamic->data_offset += 8 * 9;
1008 } else {
1009 /* still need to build got entries in case of static link */
1010 build_got_entries();
1011 }
1012 }
1013
1014 memset(&ehdr, 0, sizeof(ehdr));
1015
1016 /* we add a section for symbols */
1017 strsec = new_section(".shstrtab", SHT_STRTAB, 0);
1018 put_elf_str(strsec, "");
1019
1020 /* compute number of sections */
1021 shnum = nb_sections;
1022
1023 /* this array is used to reorder sections in the output file */
1024 section_order = tcc_malloc(sizeof(int) * shnum);
1025 section_order[0] = 0;
1026 sh_order_index = 1;
1027
1028 /* compute number of program headers */
1029 switch(file_type) {
1030 default:
1031 case TCC_OUTPUT_OBJ:
1032 phnum = 0;
1033 break;
1034 case TCC_OUTPUT_EXE:
1035 if (!static_link)
1036 phnum = 4;
1037 else
1038 phnum = 2;
1039 break;
1040 case TCC_OUTPUT_DLL:
1041 phnum = 3;
1042 break;
1043 }
1044
1045 /* allocate strings for section names and decide if an unallocated
1046 section should be output */
1047 /* NOTE: the strsec section comes last, so its size is also
1048 correct ! */
1049 for(i = 1; i < nb_sections; i++) {
1050 s = sections[i];
1051 s->sh_name = put_elf_str(strsec, s->name);
1052 /* when generating a DLL, we include relocations but we may
1053 patch them */
1054 if (file_type == TCC_OUTPUT_DLL &&
1055 s->sh_type == SHT_REL &&
1056 !(s->sh_flags & SHF_ALLOC)) {
1057 prepare_dynamic_rel(s);
1058 } else if (do_debug ||
1059 file_type == TCC_OUTPUT_OBJ ||
1060 (s->sh_flags & SHF_ALLOC) ||
1061 i == (nb_sections - 1)) {
1062 /* we output all sections if debug or object file */
1063 s->sh_size = s->data_offset;
1064 }
1065 }
1066
1067 /* allocate program segment headers */
1068 phdr = tcc_mallocz(phnum * sizeof(Elf32_Phdr));
1069
1070 file_offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr);
1071 if (phnum > 0) {
1072 /* compute section to program header mapping */
1073 if (file_type == TCC_OUTPUT_DLL)
1074 addr = 0;
1075 else
1076 addr = ELF_START_ADDR;
1077
1078 /* dynamic relocation table information, for .dynamic section */
1079 rel_size = 0;
1080 rel_addr = 0;
1081
1082 /* compute address after headers */
1083 addr += (file_offset & (ELF_PAGE_SIZE - 1));
1084
1085 /* leave one program header for the program interpreter */
1086 ph = &phdr[0];
1087 if (interp)
1088 ph++;
1089
1090 for(j = 0; j < 2; j++) {
1091 ph->p_type = PT_LOAD;
1092 if (j == 0)
1093 ph->p_flags = PF_R | PF_X;
1094 else
1095 ph->p_flags = PF_R | PF_W;
1096 ph->p_align = ELF_PAGE_SIZE;
1097
1098 /* we do the following ordering: interp, symbol tables,
1099 relocations, progbits, nobits */
1100 /* XXX: do faster and simpler sorting */
1101 for(k = 0; k < 5; k++) {
1102 for(i = 1; i < nb_sections; i++) {
1103 s = sections[i];
1104 /* compute if section should be included */
1105 if (j == 0) {
1106 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1107 SHF_ALLOC)
1108 continue;
1109 } else {
1110 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1111 (SHF_ALLOC | SHF_WRITE))
1112 continue;
1113 }
1114 if (s == interp) {
1115 if (k != 0)
1116 continue;
1117 } else if (s->sh_type == SHT_DYNSYM ||
1118 s->sh_type == SHT_STRTAB ||
1119 s->sh_type == SHT_HASH) {
1120 if (k != 1)
1121 continue;
1122 } else if (s->sh_type == SHT_REL) {
1123 if (k != 2)
1124 continue;
1125 } else if (s->sh_type == SHT_NOBITS) {
1126 if (k != 4)
1127 continue;
1128 } else {
1129 if (k != 3)
1130 continue;
1131 }
1132 section_order[sh_order_index++] = i;
1133
1134 /* section matches: we align it and add its size */
1135 tmp = file_offset;
1136 file_offset = (file_offset + s->sh_addralign - 1) &
1137 ~(s->sh_addralign - 1);
1138 s->sh_offset = file_offset;
1139 addr += file_offset - tmp;
1140 s->sh_addr = addr;
1141
1142 /* update program header infos */
1143 if (ph->p_offset == 0) {
1144 ph->p_offset = file_offset;
1145 ph->p_vaddr = addr;
1146 ph->p_paddr = ph->p_vaddr;
1147 }
1148 /* update dynamic relocation infos */
1149 if (s->sh_type == SHT_REL) {
1150 if (rel_size == 0)
1151 rel_addr = addr;
1152 rel_size += s->sh_size;
1153 }
1154 addr += s->sh_size;
1155 if (s->sh_type != SHT_NOBITS)
1156 file_offset += s->sh_size;
1157 }
1158 }
1159 ph->p_filesz = file_offset - ph->p_offset;
1160 ph->p_memsz = addr - ph->p_vaddr;
1161 ph++;
1162 }
1163
1164 /* if interpreter, then add corresponing program header */
1165 if (interp) {
1166 ph = &phdr[0];
1167
1168 ph->p_type = PT_INTERP;
1169 ph->p_offset = interp->sh_offset;
1170 ph->p_vaddr = interp->sh_addr;
1171 ph->p_paddr = ph->p_vaddr;
1172 ph->p_filesz = interp->sh_size;
1173 ph->p_memsz = interp->sh_size;
1174 ph->p_flags = PF_R;
1175 ph->p_align = interp->sh_addralign;
1176 }
1177
1178 /* if dynamic section, then add corresponing program header */
1179 if (dynamic) {
1180 int plt_offset;
1181 unsigned char *p;
1182 Elf32_Sym *sym_end;
1183
1184 ph = &phdr[phnum - 1];
1185
1186 ph->p_type = PT_DYNAMIC;
1187 ph->p_offset = dynamic->sh_offset;
1188 ph->p_vaddr = dynamic->sh_addr;
1189 ph->p_paddr = ph->p_vaddr;
1190 ph->p_filesz = dynamic->sh_size;
1191 ph->p_memsz = dynamic->sh_size;
1192 ph->p_flags = PF_R | PF_W;
1193 ph->p_align = dynamic->sh_addralign;
1194
1195 /* put GOT dynamic section address */
1196 put32(got->data, dynamic->sh_addr);
1197
1198 /* compute the PLT */
1199 plt->data_offset = 0;
1200
1201 /* first plt entry */
1202 p = section_ptr_add(plt, 16);
1203 p[0] = 0xff; /* pushl got + 4 */
1204 p[1] = 0x35;
1205 put32(p + 2, got->sh_addr + 4);
1206 p[6] = 0xff; /* jmp *(got + 8) */
1207 p[7] = 0x25;
1208 put32(p + 8, got->sh_addr + 8);
1209
1210 /* relocation symbols in .dynsym and build PLT. */
1211 plt_offset = 0;
1212 sym_end = (Elf32_Sym *)(dynsym->data + dynsym->data_offset);
1213 for(sym = (Elf32_Sym *)dynsym->data + 1;
1214 sym < sym_end;
1215 sym++) {
1216 type = ELF32_ST_TYPE(sym->st_info);
1217 if (sym->st_shndx == SHN_UNDEF) {
1218 if (type == STT_FUNC) {
1219 /* one more entry in PLT */
1220 p = section_ptr_add(plt, 16);
1221 p[0] = 0xff; /* jmp *(got + x) */
1222 p[1] = 0x25;
1223 put32(p + 2, got->sh_addr + sym->st_value);
1224 p[6] = 0x68; /* push $xxx */
1225 put32(p + 7, plt_offset);
1226 p[11] = 0xe9; /* jmp plt_start */
1227 put32(p + 12, -(plt->data_offset));
1228
1229 /* patch symbol value to point to plt */
1230 sym->st_value = plt->sh_addr + p - plt->data;
1231
1232 plt_offset += 8;
1233 }
1234 } else if (sym->st_shndx < SHN_LORESERVE) {
1235 /* do symbol relocation */
1236 sym->st_value += sections[sym->st_shndx]->sh_addr;
1237 }
1238 }
1239 /* put dynamic section entries */
1240
1241 dynamic->data_offset = saved_dynamic_data_offset;
1242 put_dt(dynamic, DT_HASH, dynsym->hash->sh_addr);
1243 put_dt(dynamic, DT_STRTAB, dynstr->sh_addr);
1244 put_dt(dynamic, DT_SYMTAB, dynsym->sh_addr);
1245 put_dt(dynamic, DT_STRSZ, dynstr->data_offset);
1246 put_dt(dynamic, DT_SYMENT, sizeof(Elf32_Sym));
1247 put_dt(dynamic, DT_REL, rel_addr);
1248 put_dt(dynamic, DT_RELSZ, rel_size);
1249 put_dt(dynamic, DT_RELENT, sizeof(Elf32_Rel));
1250 put_dt(dynamic, DT_NULL, 0);
1251 }
1252
1253 ehdr.e_phentsize = sizeof(Elf32_Phdr);
1254 ehdr.e_phnum = phnum;
1255 ehdr.e_phoff = sizeof(Elf32_Ehdr);
1256 }
1257
1258 /* all other sections come after */
1259 for(i = 1; i < nb_sections; i++) {
1260 s = sections[i];
1261 if (phnum > 0 && (s->sh_flags & SHF_ALLOC))
1262 continue;
1263 section_order[sh_order_index++] = i;
1264
1265 file_offset = (file_offset + s->sh_addralign - 1) &
1266 ~(s->sh_addralign - 1);
1267 s->sh_offset = file_offset;
1268 if (s->sh_type != SHT_NOBITS)
1269 file_offset += s->sh_size;
1270 }
1271
1272 /* if building executable or DLL, then relocate each section
1273 except the GOT which is already relocated */
1274 if (file_type != TCC_OUTPUT_OBJ) {
1275 relocate_syms(0);
1276
1277 /* relocate sections */
1278 /* XXX: ignore sections with allocated relocations ? */
1279 for(i = 1; i < nb_sections; i++) {
1280 s = sections[i];
1281 if (s->reloc && s != got)
1282 relocate_section(s1, s);
1283 }
1284
1285 /* relocate relocation entries if the relocation tables are
1286 allocated in the executable */
1287 for(i = 1; i < nb_sections; i++) {
1288 s = sections[i];
1289 if ((s->sh_flags & SHF_ALLOC) &&
1290 s->sh_type == SHT_REL) {
1291 relocate_rel(s);
1292 }
1293 }
1294
1295 /* get entry point address */
1296 if (file_type == TCC_OUTPUT_EXE)
1297 ehdr.e_entry = get_elf_sym_val("_start");
1298 else
1299 ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
1300 }
1301
1302 sort_syms(symtab_section);
1303
1304 /* align to 4 */
1305 file_offset = (file_offset + 3) & -4;
1306
1307 /* fill header */
1308 ehdr.e_ident[0] = ELFMAG0;
1309 ehdr.e_ident[1] = ELFMAG1;
1310 ehdr.e_ident[2] = ELFMAG2;
1311 ehdr.e_ident[3] = ELFMAG3;
1312 ehdr.e_ident[4] = ELFCLASS32;
1313 ehdr.e_ident[5] = ELFDATA2LSB;
1314 ehdr.e_ident[6] = EV_CURRENT;
1315 switch(file_type) {
1316 default:
1317 case TCC_OUTPUT_EXE:
1318 ehdr.e_type = ET_EXEC;
1319 break;
1320 case TCC_OUTPUT_DLL:
1321 ehdr.e_type = ET_DYN;
1322 break;
1323 case TCC_OUTPUT_OBJ:
1324 ehdr.e_type = ET_REL;
1325 break;
1326 }
1327 ehdr.e_machine = EM_386;
1328 ehdr.e_version = EV_CURRENT;
1329 ehdr.e_shoff = file_offset;
1330 ehdr.e_ehsize = sizeof(Elf32_Ehdr);
1331 ehdr.e_shentsize = sizeof(Elf32_Shdr);
1332 ehdr.e_shnum = shnum;
1333 ehdr.e_shstrndx = shnum - 1;
1334
1335 /* write elf file */
1336 if (file_type == TCC_OUTPUT_OBJ)
1337 mode = 0666;
1338 else
1339 mode = 0777;
1340 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, mode);
1341 if (fd < 0)
1342 error("could not write '%s'", filename);
1343
1344 f = fdopen(fd, "w");
1345 fwrite(&ehdr, 1, sizeof(Elf32_Ehdr), f);
1346 fwrite(phdr, 1, phnum * sizeof(Elf32_Phdr), f);
1347 offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr);
1348 for(i=1;i<nb_sections;i++) {
1349 s = sections[section_order[i]];
1350 if (s->sh_type != SHT_NOBITS) {
1351 while (offset < s->sh_offset) {
1352 fputc(0, f);
1353 offset++;
1354 }
1355 size = s->sh_size;
1356 fwrite(s->data, 1, size, f);
1357 offset += size;
1358 }
1359 }
1360 while (offset < ehdr.e_shoff) {
1361 fputc(0, f);
1362 offset++;
1363 }
1364
1365 /* output section headers */
1366 for(i=0;i<nb_sections;i++) {
1367 sh = &shdr;
1368 memset(sh, 0, sizeof(Elf32_Shdr));
1369 s = sections[i];
1370 if (s) {
1371 sh->sh_name = s->sh_name;
1372 sh->sh_type = s->sh_type;
1373 sh->sh_flags = s->sh_flags;
1374 sh->sh_entsize = s->sh_entsize;
1375 sh->sh_info = s->sh_info;
1376 if (s->link)
1377 sh->sh_link = s->link->sh_num;
1378 sh->sh_addralign = s->sh_addralign;
1379 sh->sh_addr = s->sh_addr;
1380 sh->sh_offset = s->sh_offset;
1381 sh->sh_size = s->sh_size;
1382 }
1383 fwrite(sh, 1, sizeof(Elf32_Shdr), f);
1384 }
1385 fclose(f);
1386
1387 tcc_free(section_order);
1388 tcc_free(phdr);
1389 return 0;
1390 }
1391
1392 static void *load_data(int fd, unsigned long file_offset, unsigned long size)
1393 {
1394 void *data;
1395
1396 data = tcc_malloc(size);
1397 lseek(fd, file_offset, SEEK_SET);
1398 read(fd, data, size);
1399 return data;
1400 }
1401
1402 typedef struct SectionMergeInfo {
1403 Section *s; /* corresponding existing section */
1404 unsigned long offset; /* offset of the new section in the existing section */
1405 int new_section; /* true if section 's' was added */
1406 } SectionMergeInfo;
1407
1408 /* load an object file and merge it with current files */
1409 /* XXX: handle correctly stab (debug) info */
1410 static int tcc_load_object_file(TCCState *s1,
1411 int fd, unsigned long file_offset)
1412 {
1413 Elf32_Ehdr ehdr;
1414 Elf32_Shdr *shdr, *sh;
1415 int size, i, j, offset, offseti, nb_syms, sym_index;
1416 unsigned char *strsec, *strtab;
1417 int *old_to_new_syms;
1418 char *sh_name, *name;
1419 SectionMergeInfo *sm_table, *sm;
1420 Elf32_Sym *sym, *symtab;
1421 Elf32_Rel *rel, *rel_end;
1422 Section *s;
1423
1424 if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr))
1425 goto fail;
1426 if (ehdr.e_ident[0] != ELFMAG0 ||
1427 ehdr.e_ident[1] != ELFMAG1 ||
1428 ehdr.e_ident[2] != ELFMAG2 ||
1429 ehdr.e_ident[3] != ELFMAG3)
1430 goto fail;
1431 /* test if object file */
1432 if (ehdr.e_type != ET_REL)
1433 goto fail;
1434 /* test CPU specific stuff */
1435 if (ehdr.e_ident[5] != ELFDATA2LSB ||
1436 ehdr.e_machine != EM_386) {
1437 fail:
1438 error("invalid object file");
1439 }
1440 /* read sections */
1441 shdr = load_data(fd, file_offset + ehdr.e_shoff,
1442 sizeof(Elf32_Shdr) * ehdr.e_shnum);
1443 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
1444
1445 /* load section names */
1446 sh = &shdr[ehdr.e_shstrndx];
1447 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
1448
1449 /* load symtab and strtab */
1450 symtab = NULL;
1451 strtab = NULL;
1452 nb_syms = 0;
1453 for(i = 1; i < ehdr.e_shnum; i++) {
1454 sh = &shdr[i];
1455 if (sh->sh_type == SHT_SYMTAB) {
1456 if (symtab)
1457 error("object must contain only one symtab");
1458 nb_syms = sh->sh_size / sizeof(Elf32_Sym);
1459 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
1460 sm_table[i].s = symtab_section;
1461
1462 /* now load strtab */
1463 sh = &shdr[sh->sh_link];
1464 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
1465 }
1466 }
1467
1468 /* now examine each section and try to merge its content with the
1469 ones in memory */
1470 for(i = 1; i < ehdr.e_shnum; i++) {
1471 /* no need to examine section name strtab */
1472 if (i == ehdr.e_shstrndx)
1473 continue;
1474 sh = &shdr[i];
1475 sh_name = strsec + sh->sh_name;
1476 /* ignore sections types we do not handle */
1477 if (sh->sh_type != SHT_PROGBITS &&
1478 sh->sh_type != SHT_REL &&
1479 sh->sh_type != SHT_NOBITS)
1480 continue;
1481 if (sh->sh_addralign < 1)
1482 sh->sh_addralign = 1;
1483 /* find corresponding section, if any */
1484 for(j = 1; j < nb_sections;j++) {
1485 s = sections[j];
1486 if (!strcmp(s->name, sh_name))
1487 goto found;
1488 }
1489 /* not found: create new section */
1490 s = new_section(sh_name, sh->sh_type, sh->sh_flags);
1491 /* take as much info as possible from the section. sh_link and
1492 sh_info will be updated later */
1493 s->sh_addralign = sh->sh_addralign;
1494 s->sh_entsize = sh->sh_entsize;
1495 sm_table[i].new_section = 1;
1496 found:
1497 if (sh->sh_type != s->sh_type)
1498 goto fail;
1499
1500 /* align start of section */
1501 offset = s->data_offset;
1502 size = sh->sh_addralign - 1;
1503 offset = (offset + size) & ~size;
1504 if (sh->sh_addralign > s->sh_addralign)
1505 s->sh_addralign = sh->sh_addralign;
1506 s->data_offset = offset;
1507 sm_table[i].offset = offset;
1508 sm_table[i].s = s;
1509 /* concatenate sections */
1510 size = sh->sh_size;
1511 if (sh->sh_type != SHT_NOBITS) {
1512 unsigned char *ptr;
1513 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
1514 ptr = section_ptr(s, size);
1515 read(fd, ptr, size);
1516 }
1517 s->data_offset += size;
1518 }
1519
1520 /* second short pass to update sh_link and sh_info fields of new
1521 sections */
1522 sm = sm_table;
1523 for(i = 1; i < ehdr.e_shnum; i++) {
1524 s = sm_table[i].s;
1525 if (!s || !sm_table[i].new_section)
1526 continue;
1527 sh = &shdr[i];
1528 if (sh->sh_link > 0)
1529 s->link = sm_table[sh->sh_link].s;
1530 if (sh->sh_type == SHT_REL) {
1531 s->sh_info = sm_table[sh->sh_info].s->sh_num;
1532 /* update backward link */
1533 sections[s->sh_info]->reloc = s;
1534 }
1535 }
1536
1537 /* resolve symbols */
1538 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
1539
1540 sym = symtab + 1;
1541 for(i = 1; i < nb_syms; i++, sym++) {
1542 if (sym->st_shndx != SHN_UNDEF &&
1543 sym->st_shndx < SHN_LORESERVE) {
1544 sm = &sm_table[sym->st_shndx];
1545 /* if no corresponding section added, no need to add symbol */
1546 if (!sm->s)
1547 continue;
1548 /* convert section number */
1549 sym->st_shndx = sm->s->sh_num;
1550 /* offset value */
1551 sym->st_value += sm->offset;
1552 }
1553 /* add symbol */
1554 name = strtab + sym->st_name;
1555 sym_index = add_elf_sym(symtab_section, sym->st_value, sym->st_size,
1556 sym->st_info, sym->st_shndx, name);
1557 old_to_new_syms[i] = sym_index;
1558 }
1559
1560 /* third pass to patch relocation entries */
1561 for(i = 1; i < ehdr.e_shnum; i++) {
1562 s = sm_table[i].s;
1563 if (!s)
1564 continue;
1565 sh = &shdr[i];
1566 offset = sm_table[i].offset;
1567 switch(s->sh_type) {
1568 case SHT_REL:
1569 /* take relocation offset information */
1570 offseti = sm_table[sh->sh_info].offset;
1571 rel_end = (Elf32_Rel *)(s->data + s->data_offset);
1572 for(rel = (Elf32_Rel *)(s->data + offset);
1573 rel < rel_end;
1574 rel++) {
1575 int type;
1576 unsigned sym_index;
1577 /* convert symbol index */
1578 type = ELF32_R_TYPE(rel->r_info);
1579 sym_index = ELF32_R_SYM(rel->r_info);
1580 /* NOTE: only one symtab assumed */
1581 if (sym_index >= nb_syms)
1582 goto invalid_reloc;
1583 sym_index = old_to_new_syms[sym_index];
1584 if (!sym_index) {
1585 invalid_reloc:
1586 error("Invalid relocation entry");
1587 }
1588 rel->r_info = ELF32_R_INFO(sym_index, type);
1589 /* offset the relocation offset */
1590 rel->r_offset += offseti;
1591 }
1592 break;
1593 default:
1594 break;
1595 }
1596 }
1597 tcc_free(symtab);
1598 tcc_free(strtab);
1599 tcc_free(old_to_new_syms);
1600 tcc_free(sm_table);
1601 tcc_free(shdr);
1602 return 0;
1603 }
1604
1605 #define ARMAG "!<arch>\012" /* For COFF and a.out archives */
1606
1607 typedef struct ArchiveHeader {
1608 char ar_name[16]; /* name of this member */
1609 char ar_date[12]; /* file mtime */
1610 char ar_uid[6]; /* owner uid; printed as decimal */
1611 char ar_gid[6]; /* owner gid; printed as decimal */
1612 char ar_mode[8]; /* file mode, printed as octal */
1613 char ar_size[10]; /* file size, printed as decimal */
1614 char ar_fmag[2]; /* should contain ARFMAG */
1615 } ArchiveHeader;
1616
1617 /* load a '.a' file */
1618 static int tcc_load_archive(TCCState *s1, int fd)
1619 {
1620 ArchiveHeader hdr;
1621 char ar_size[11];
1622 char ar_name[17];
1623 char magic[8];
1624 int size, len, i;
1625 unsigned long file_offset;
1626
1627 /* skip magic which was already checked */
1628 read(fd, magic, sizeof(magic));
1629
1630 for(;;) {
1631 len = read(fd, &hdr, sizeof(hdr));
1632 if (len == 0)
1633 break;
1634 if (len != sizeof(hdr))
1635 error("invalid archive");
1636 memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
1637 ar_size[sizeof(hdr.ar_size)] = '\0';
1638 size = strtol(ar_size, NULL, 0);
1639 memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
1640 for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
1641 if (ar_name[i] != ' ')
1642 break;
1643 }
1644 ar_name[i + 1] = '\0';
1645 // printf("name='%s' size=%d %s\n", ar_name, size, ar_size);
1646 file_offset = lseek(fd, 0, SEEK_CUR);
1647 if (!strcmp(ar_name, "/") ||
1648 !strcmp(ar_name, "//") ||
1649 !strcmp(ar_name, "__.SYMDEF") ||
1650 !strcmp(ar_name, "__.SYMDEF/") ||
1651 !strcmp(ar_name, "ARFILENAMES/")) {
1652 /* skip symbol table or archive names */
1653 } else {
1654 tcc_load_object_file(s1, fd, file_offset);
1655 }
1656 /* align to even */
1657 size = (size + 1) & ~1;
1658 lseek(fd, file_offset + size, SEEK_SET);
1659 }
1660 return 0;
1661 }
1662
1663 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
1664 is referenced by the user (so it should be added as DT_NEEDED in
1665 the generated ELF file) */
1666 static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
1667 {
1668 Elf32_Ehdr ehdr;
1669 Elf32_Shdr *shdr, *sh, *sh1;
1670 int i, nb_syms, nb_dts, sym_bind;
1671 Elf32_Sym *sym, *dynsym;
1672 Elf32_Dyn *dt, *dynamic;
1673 unsigned char *dynstr;
1674 const char *name, *soname, *p;
1675 DLLReference *dllref;
1676
1677 read(fd, &ehdr, sizeof(ehdr));
1678
1679 /* test CPU specific stuff */
1680 if (ehdr.e_ident[5] != ELFDATA2LSB ||
1681 ehdr.e_machine != EM_386)
1682 error("bad architecture");
1683
1684 /* read sections */
1685 shdr = load_data(fd, ehdr.e_shoff, sizeof(Elf32_Shdr) * ehdr.e_shnum);
1686
1687 /* load dynamic section and dynamic symbols */
1688 nb_syms = 0;
1689 nb_dts = 0;
1690 dynamic = NULL;
1691 dynsym = NULL; /* avoid warning */
1692 dynstr = NULL; /* avoid warning */
1693 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
1694 switch(sh->sh_type) {
1695 case SHT_DYNAMIC:
1696 nb_dts = sh->sh_size / sizeof(Elf32_Dyn);
1697 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
1698 break;
1699 case SHT_DYNSYM:
1700 nb_syms = sh->sh_size / sizeof(Elf32_Sym);
1701 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
1702 sh1 = &shdr[sh->sh_link];
1703 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
1704 break;
1705 default:
1706 break;
1707 }
1708 }
1709
1710 /* compute the real library name */
1711 soname = filename;
1712 p = strrchr(soname, '/');
1713 if (p)
1714 soname = p + 1;
1715
1716 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
1717 if (dt->d_tag == DT_SONAME) {
1718 soname = dynstr + dt->d_un.d_val;
1719 }
1720 }
1721
1722 /* if the dll is already loaded, do not load it */
1723 for(i = 0; i < nb_loaded_dlls; i++) {
1724 dllref = loaded_dlls[i];
1725 if (!strcmp(soname, dllref->name)) {
1726 /* but update level if needed */
1727 if (level < dllref->level)
1728 dllref->level = level;
1729 goto the_end;
1730 }
1731 }
1732
1733 // printf("loading dll '%s'\n", soname);
1734
1735 /* add the dll and its level */
1736 dllref = tcc_malloc(sizeof(DLLReference) + strlen(soname));
1737 dllref->level = level;
1738 strcpy(dllref->name, soname);
1739 dynarray_add((void ***)&loaded_dlls, &nb_loaded_dlls, dllref);
1740
1741 /* add dynamic symbols in dynsym_section */
1742 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
1743 sym_bind = ELF32_ST_BIND(sym->st_info);
1744 if (sym_bind == STB_LOCAL)
1745 continue;
1746 name = dynstr + sym->st_name;
1747 add_elf_sym(dynsymtab_section, sym->st_value, sym->st_size,
1748 sym->st_info, sym->st_shndx, name);
1749 }
1750
1751 /* load all referenced DLLs */
1752 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
1753 switch(dt->d_tag) {
1754 case DT_NEEDED:
1755 name = dynstr + dt->d_un.d_val;
1756 for(i = 0; i < nb_loaded_dlls; i++) {
1757 dllref = loaded_dlls[i];
1758 if (!strcmp(name, dllref->name))
1759 goto already_loaded;
1760 }
1761 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0)
1762 error("referenced dll '%s' not found", name);
1763 already_loaded:
1764 break;
1765 }
1766 }
1767 the_end:
1768 tcc_free(shdr);
1769 return 0;
1770 }
1771
1772 /* return -2 if error and CH_EOF if eof */
1773 static void ld_skipspaces(void)
1774 {
1775 while (ch == ' ' || ch == '\t' || ch == '\n')
1776 cinp();
1777 }
1778
1779 static int ld_get_cmd(char *cmd, int cmd_size)
1780 {
1781 char *q;
1782
1783 ld_skipspaces();
1784 if (ch == CH_EOF)
1785 return -1;
1786 q = cmd;
1787 for(;;) {
1788 if (!((ch >= 'a' && ch <= 'z') ||
1789 (ch >= 'A' && ch <= 'Z') ||
1790 (ch >= '0' && ch <= '9') ||
1791 strchr("/.-_+=$:\\,~?*", ch)))
1792 break;
1793 if ((q - cmd) >= (cmd_size - 1))
1794 return -2;
1795 *q++ = ch;
1796 cinp();
1797 }
1798 *q = '\0';
1799 return 0;
1800 }
1801
1802 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
1803 files */
1804 static int tcc_load_ldscript(TCCState *s1)
1805 {
1806 char cmd[64];
1807 char filename[1024];
1808 int ret;
1809
1810 inp();
1811 cinp();
1812 for(;;) {
1813 ret = ld_get_cmd(cmd, sizeof(cmd));
1814 if (ret == CH_EOF)
1815 return 0;
1816 else if (ret < 0)
1817 return -1;
1818 // printf("cmd='%s'\n", cmd);
1819 if (!strcmp(cmd, "INPUT") ||
1820 !strcmp(cmd, "GROUP")) {
1821 ld_skipspaces();
1822 if (ch != '(')
1823 expect("(");
1824 cinp();
1825 for(;;) {
1826 ld_get_cmd(filename, sizeof(filename));
1827 tcc_add_file(s1, filename);
1828 ld_skipspaces();
1829 if (ch == ',') {
1830 cinp();
1831 } else if (ch == ')') {
1832 cinp();
1833 break;
1834 } else if (ch == CH_EOF) {
1835 error("unexpected end of file");
1836 }
1837 }
1838 } else {
1839 return -1;
1840 }
1841 }
1842 return 0;
1843 }
1844
Tiny C Compiler main repository