?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added verbosity levels (-vv -vvv)
[tinycc.git] / tccelf.c
blob40ffc71d05e811f67d1d2dbbc5b9eab83745b2a3
1 /*
2 * ELF file handling for TCC
3 *
4 * Copyright (c) 2001-2004 Fabrice Bellard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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 int tcc_get_symbol(TCCState *s, unsigned long *pval, 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 return -1;
165 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
166 *pval = sym->st_value;
167 return 0;
168 }
169
170 void *tcc_get_symbol_err(TCCState *s, const char *name)
171 {
172 unsigned long val;
173 if (tcc_get_symbol(s, &val, name) < 0)
174 error("%s not defined", name);
175 return (void *)val;
176 }
177
178 /* add an elf symbol : check if it is already defined and patch
179 it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
180 static int add_elf_sym(Section *s, unsigned long value, unsigned long size,
181 int info, int other, int sh_num, const char *name)
182 {
183 Elf32_Sym *esym;
184 int sym_bind, sym_index, sym_type, esym_bind;
185 unsigned char sym_vis, esym_vis, new_vis;
186
187 sym_bind = ELF32_ST_BIND(info);
188 sym_type = ELF32_ST_TYPE(info);
189 sym_vis = ELF32_ST_VISIBILITY(other);
190
191 if (sym_bind != STB_LOCAL) {
192 /* we search global or weak symbols */
193 sym_index = find_elf_sym(s, name);
194 if (!sym_index)
195 goto do_def;
196 esym = &((Elf32_Sym *)s->data)[sym_index];
197 if (esym->st_shndx != SHN_UNDEF) {
198 esym_bind = ELF32_ST_BIND(esym->st_info);
199 /* propagate the most constraining visibility */
200 /* STV_DEFAULT(0)<STV_PROTECTED(3)<STV_HIDDEN(2)<STV_INTERNAL(1) */
201 esym_vis = ELF32_ST_VISIBILITY(esym->st_other);
202 if (esym_vis == STV_DEFAULT) {
203 new_vis = sym_vis;
204 } else if (sym_vis == STV_DEFAULT) {
205 new_vis = esym_vis;
206 } else {
207 new_vis = (esym_vis < sym_vis) ? esym_vis : sym_vis;
208 }
209 esym->st_other = (esym->st_other & ~ELF32_ST_VISIBILITY(-1))
210 | new_vis;
211 other = esym->st_other; /* in case we have to patch esym */
212 if (sh_num == SHN_UNDEF) {
213 /* ignore adding of undefined symbol if the
214 corresponding symbol is already defined */
215 } else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) {
216 /* global overrides weak, so patch */
217 goto do_patch;
218 } else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) {
219 /* weak is ignored if already global */
220 } else if (sym_vis == STV_HIDDEN || sym_vis == STV_INTERNAL) {
221 /* ignore hidden symbols after */
222 } else if (esym->st_shndx == SHN_COMMON && sh_num < SHN_LORESERVE) {
223 /* gr: Happens with 'tcc ... -static tcctest.c' on e.g. Ubuntu 6.01
224 No idea if this is the correct solution ... */
225 goto do_patch;
226 } else if (s == tcc_state->dynsymtab_section) {
227 /* we accept that two DLL define the same symbol */
228 } else {
229 #if 1
230 printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",
231 sym_bind, sh_num, new_vis, esym_bind, esym->st_shndx, esym_vis);
232 #endif
233 error_noabort("'%s' defined twice", name);
234 }
235 } else {
236 do_patch:
237 esym->st_info = ELF32_ST_INFO(sym_bind, sym_type);
238 esym->st_shndx = sh_num;
239 esym->st_value = value;
240 esym->st_size = size;
241 esym->st_other = other;
242 }
243 } else {
244 do_def:
245 sym_index = put_elf_sym(s, value, size,
246 ELF32_ST_INFO(sym_bind, sym_type), other,
247 sh_num, name);
248 }
249 return sym_index;
250 }
251
252 /* put relocation */
253 static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
254 int type, int symbol)
255 {
256 char buf[256];
257 Section *sr;
258 Elf32_Rel *rel;
259
260 sr = s->reloc;
261 if (!sr) {
262 /* if no relocation section, create it */
263 snprintf(buf, sizeof(buf), ".rel%s", s->name);
264 /* if the symtab is allocated, then we consider the relocation
265 are also */
266 sr = new_section(tcc_state, buf, SHT_REL, symtab->sh_flags);
267 sr->sh_entsize = sizeof(Elf32_Rel);
268 sr->link = symtab;
269 sr->sh_info = s->sh_num;
270 s->reloc = sr;
271 }
272 rel = section_ptr_add(sr, sizeof(Elf32_Rel));
273 rel->r_offset = offset;
274 rel->r_info = ELF32_R_INFO(symbol, type);
275 }
276
277 /* put stab debug information */
278
279 typedef struct {
280 unsigned long n_strx; /* index into string table of name */
281 unsigned char n_type; /* type of symbol */
282 unsigned char n_other; /* misc info (usually empty) */
283 unsigned short n_desc; /* description field */
284 unsigned long n_value; /* value of symbol */
285 } Stab_Sym;
286
287 static void put_stabs(const char *str, int type, int other, int desc,
288 unsigned long value)
289 {
290 Stab_Sym *sym;
291
292 sym = section_ptr_add(stab_section, sizeof(Stab_Sym));
293 if (str) {
294 sym->n_strx = put_elf_str(stabstr_section, str);
295 } else {
296 sym->n_strx = 0;
297 }
298 sym->n_type = type;
299 sym->n_other = other;
300 sym->n_desc = desc;
301 sym->n_value = value;
302 }
303
304 static void put_stabs_r(const char *str, int type, int other, int desc,
305 unsigned long value, Section *sec, int sym_index)
306 {
307 put_stabs(str, type, other, desc, value);
308 put_elf_reloc(symtab_section, stab_section,
309 stab_section->data_offset - sizeof(unsigned long),
310 R_DATA_32, sym_index);
311 }
312
313 static void put_stabn(int type, int other, int desc, int value)
314 {
315 put_stabs(NULL, type, other, desc, value);
316 }
317
318 static void put_stabd(int type, int other, int desc)
319 {
320 put_stabs(NULL, type, other, desc, 0);
321 }
322
323 /* In an ELF file symbol table, the local symbols must appear below
324 the global and weak ones. Since TCC cannot sort it while generating
325 the code, we must do it after. All the relocation tables are also
326 modified to take into account the symbol table sorting */
327 static void sort_syms(TCCState *s1, Section *s)
328 {
329 int *old_to_new_syms;
330 Elf32_Sym *new_syms;
331 int nb_syms, i;
332 Elf32_Sym *p, *q;
333 Elf32_Rel *rel, *rel_end;
334 Section *sr;
335 int type, sym_index;
336
337 nb_syms = s->data_offset / sizeof(Elf32_Sym);
338 new_syms = tcc_malloc(nb_syms * sizeof(Elf32_Sym));
339 old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
340
341 /* first pass for local symbols */
342 p = (Elf32_Sym *)s->data;
343 q = new_syms;
344 for(i = 0; i < nb_syms; i++) {
345 if (ELF32_ST_BIND(p->st_info) == STB_LOCAL) {
346 old_to_new_syms[i] = q - new_syms;
347 *q++ = *p;
348 }
349 p++;
350 }
351 /* save the number of local symbols in section header */
352 s->sh_info = q - new_syms;
353
354 /* then second pass for non local symbols */
355 p = (Elf32_Sym *)s->data;
356 for(i = 0; i < nb_syms; i++) {
357 if (ELF32_ST_BIND(p->st_info) != STB_LOCAL) {
358 old_to_new_syms[i] = q - new_syms;
359 *q++ = *p;
360 }
361 p++;
362 }
363
364 /* we copy the new symbols to the old */
365 memcpy(s->data, new_syms, nb_syms * sizeof(Elf32_Sym));
366 tcc_free(new_syms);
367
368 /* now we modify all the relocations */
369 for(i = 1; i < s1->nb_sections; i++) {
370 sr = s1->sections[i];
371 if (sr->sh_type == SHT_REL && sr->link == s) {
372 rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
373 for(rel = (Elf32_Rel *)sr->data;
374 rel < rel_end;
375 rel++) {
376 sym_index = ELF32_R_SYM(rel->r_info);
377 type = ELF32_R_TYPE(rel->r_info);
378 sym_index = old_to_new_syms[sym_index];
379 rel->r_info = ELF32_R_INFO(sym_index, type);
380 }
381 }
382 }
383
384 tcc_free(old_to_new_syms);
385 }
386
387 /* relocate common symbols in the .bss section */
388 static void relocate_common_syms(void)
389 {
390 Elf32_Sym *sym, *sym_end;
391 unsigned long offset, align;
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 if (sym->st_shndx == SHN_COMMON) {
398 /* align symbol */
399 align = sym->st_value;
400 offset = bss_section->data_offset;
401 offset = (offset + align - 1) & -align;
402 sym->st_value = offset;
403 sym->st_shndx = bss_section->sh_num;
404 offset += sym->st_size;
405 bss_section->data_offset = offset;
406 }
407 }
408 }
409
410 /* relocate symbol table, resolve undefined symbols if do_resolve is
411 true and output error if undefined symbol. */
412 static void relocate_syms(TCCState *s1, int do_resolve)
413 {
414 Elf32_Sym *sym, *esym, *sym_end;
415 int sym_bind, sh_num, sym_index;
416 const char *name;
417 unsigned long addr;
418
419 sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);
420 for(sym = (Elf32_Sym *)symtab_section->data + 1;
421 sym < sym_end;
422 sym++) {
423 sh_num = sym->st_shndx;
424 if (sh_num == SHN_UNDEF) {
425 name = strtab_section->data + sym->st_name;
426 if (do_resolve) {
427 name = symtab_section->link->data + sym->st_name;
428 addr = (unsigned long)resolve_sym(s1, name, ELF32_ST_TYPE(sym->st_info));
429 if (addr) {
430 sym->st_value = addr;
431 goto found;
432 }
433 } else if (s1->dynsym) {
434 /* if dynamic symbol exist, then use it */
435 sym_index = find_elf_sym(s1->dynsym, name);
436 if (sym_index) {
437 esym = &((Elf32_Sym *)s1->dynsym->data)[sym_index];
438 sym->st_value = esym->st_value;
439 goto found;
440 }
441 }
442 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
443 it */
444 if (!strcmp(name, "_fp_hw"))
445 goto found;
446 /* only weak symbols are accepted to be undefined. Their
447 value is zero */
448 sym_bind = ELF32_ST_BIND(sym->st_info);
449 if (sym_bind == STB_WEAK) {
450 sym->st_value = 0;
451 } else {
452 error_noabort("undefined symbol '%s'", name);
453 }
454 } else if (sh_num < SHN_LORESERVE) {
455 /* add section base */
456 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
457 }
458 found: ;
459 }
460 }
461
462 /* relocate a given section (CPU dependent) */
463 static void relocate_section(TCCState *s1, Section *s)
464 {
465 Section *sr;
466 Elf32_Rel *rel, *rel_end, *qrel;
467 Elf32_Sym *sym;
468 int type, sym_index;
469 unsigned char *ptr;
470 unsigned long val, addr;
471 #if defined(TCC_TARGET_I386)
472 int esym_index;
473 #endif
474
475 sr = s->reloc;
476 rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
477 qrel = (Elf32_Rel *)sr->data;
478 for(rel = qrel;
479 rel < rel_end;
480 rel++) {
481 ptr = s->data + rel->r_offset;
482
483 sym_index = ELF32_R_SYM(rel->r_info);
484 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
485 val = sym->st_value;
486 type = ELF32_R_TYPE(rel->r_info);
487 addr = s->sh_addr + rel->r_offset;
488
489 /* CPU specific */
490 switch(type) {
491 #if defined(TCC_TARGET_I386)
492 case R_386_32:
493 if (s1->output_type == TCC_OUTPUT_DLL) {
494 esym_index = s1->symtab_to_dynsym[sym_index];
495 qrel->r_offset = rel->r_offset;
496 if (esym_index) {
497 qrel->r_info = ELF32_R_INFO(esym_index, R_386_32);
498 qrel++;
499 break;
500 } else {
501 qrel->r_info = ELF32_R_INFO(0, R_386_RELATIVE);
502 qrel++;
503 }
504 }
505 *(int *)ptr += val;
506 break;
507 case R_386_PC32:
508 if (s1->output_type == TCC_OUTPUT_DLL) {
509 /* DLL relocation */
510 esym_index = s1->symtab_to_dynsym[sym_index];
511 if (esym_index) {
512 qrel->r_offset = rel->r_offset;
513 qrel->r_info = ELF32_R_INFO(esym_index, R_386_PC32);
514 qrel++;
515 break;
516 }
517 }
518 *(int *)ptr += val - addr;
519 break;
520 case R_386_PLT32:
521 *(int *)ptr += val - addr;
522 break;
523 case R_386_GLOB_DAT:
524 case R_386_JMP_SLOT:
525 *(int *)ptr = val;
526 break;
527 case R_386_GOTPC:
528 *(int *)ptr += s1->got->sh_addr - addr;
529 break;
530 case R_386_GOTOFF:
531 *(int *)ptr += val - s1->got->sh_addr;
532 break;
533 case R_386_GOT32:
534 /* we load the got offset */
535 *(int *)ptr += s1->got_offsets[sym_index];
536 break;
537 #elif defined(TCC_TARGET_ARM)
538 case R_ARM_PC24:
539 case R_ARM_CALL:
540 case R_ARM_JUMP24:
541 case R_ARM_PLT32:
542 {
543 int x;
544 x = (*(int *)ptr)&0xffffff;
545 (*(int *)ptr) &= 0xff000000;
546 if (x & 0x800000)
547 x -= 0x1000000;
548 x *= 4;
549 x += val - addr;
550 if((x & 3) != 0 || x >= 0x4000000 || x < -0x4000000)
551 error("can't relocate value at %x",addr);
552 x >>= 2;
553 x &= 0xffffff;
554 (*(int *)ptr) |= x;
555 }
556 break;
557 case R_ARM_PREL31:
558 {
559 int x;
560 x = (*(int *)ptr) & 0x7fffffff;
561 (*(int *)ptr) &= 0x80000000;
562 x = (x * 2) / 2;
563 x += val - addr;
564 if((x^(x>>1))&0x40000000)
565 error("can't relocate value at %x",addr);
566 (*(int *)ptr) |= x & 0x7fffffff;
567 }
568 case R_ARM_ABS32:
569 *(int *)ptr += val;
570 break;
571 case R_ARM_BASE_PREL:
572 *(int *)ptr += s1->got->sh_addr - addr;
573 break;
574 case R_ARM_GOTOFF32:
575 *(int *)ptr += val - s1->got->sh_addr;
576 break;
577 case R_ARM_GOT_BREL:
578 /* we load the got offset */
579 *(int *)ptr += s1->got_offsets[sym_index];
580 break;
581 case R_ARM_COPY:
582 break;
583 default:
584 fprintf(stderr,"FIXME: handle reloc type %x at %lx [%.8x] to %lx\n",
585 type,addr,(unsigned int )ptr,val);
586 break;
587 #elif defined(TCC_TARGET_C67)
588 case R_C60_32:
589 *(int *)ptr += val;
590 break;
591 case R_C60LO16:
592 {
593 uint32_t orig;
594
595 /* put the low 16 bits of the absolute address */
596 // add to what is already there
597
598 orig = ((*(int *)(ptr )) >> 7) & 0xffff;
599 orig |= (((*(int *)(ptr+4)) >> 7) & 0xffff) << 16;
600
601 //patch both at once - assumes always in pairs Low - High
602
603 *(int *) ptr = (*(int *) ptr & (~(0xffff << 7)) ) | (((val+orig) & 0xffff) << 7);
604 *(int *)(ptr+4) = (*(int *)(ptr+4) & (~(0xffff << 7)) ) | ((((val+orig)>>16) & 0xffff) << 7);
605 }
606 break;
607 case R_C60HI16:
608 break;
609 default:
610 fprintf(stderr,"FIXME: handle reloc type %x at %lx [%.8x] to %lx\n",
611 type,addr,(unsigned int )ptr,val);
612 break;
613 #else
614 #error unsupported processor
615 #endif
616 }
617 }
618 /* if the relocation is allocated, we change its symbol table */
619 if (sr->sh_flags & SHF_ALLOC)
620 sr->link = s1->dynsym;
621 }
622
623 /* relocate relocation table in 'sr' */
624 static void relocate_rel(TCCState *s1, Section *sr)
625 {
626 Section *s;
627 Elf32_Rel *rel, *rel_end;
628
629 s = s1->sections[sr->sh_info];
630 rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
631 for(rel = (Elf32_Rel *)sr->data;
632 rel < rel_end;
633 rel++) {
634 rel->r_offset += s->sh_addr;
635 }
636 }
637
638 /* count the number of dynamic relocations so that we can reserve
639 their space */
640 static int prepare_dynamic_rel(TCCState *s1, Section *sr)
641 {
642 Elf32_Rel *rel, *rel_end;
643 int sym_index, esym_index, type, count;
644
645 count = 0;
646 rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
647 for(rel = (Elf32_Rel *)sr->data; rel < rel_end; rel++) {
648 sym_index = ELF32_R_SYM(rel->r_info);
649 type = ELF32_R_TYPE(rel->r_info);
650 switch(type) {
651 case R_386_32:
652 count++;
653 break;
654 case R_386_PC32:
655 esym_index = s1->symtab_to_dynsym[sym_index];
656 if (esym_index)
657 count++;
658 break;
659 default:
660 break;
661 }
662 }
663 if (count) {
664 /* allocate the section */
665 sr->sh_flags |= SHF_ALLOC;
666 sr->sh_size = count * sizeof(Elf32_Rel);
667 }
668 return count;
669 }
670
671 static void put_got_offset(TCCState *s1, int index, unsigned long val)
672 {
673 int n;
674 unsigned long *tab;
675
676 if (index >= s1->nb_got_offsets) {
677 /* find immediately bigger power of 2 and reallocate array */
678 n = 1;
679 while (index >= n)
680 n *= 2;
681 tab = tcc_realloc(s1->got_offsets, n * sizeof(unsigned long));
682 if (!tab)
683 error("memory full");
684 s1->got_offsets = tab;
685 memset(s1->got_offsets + s1->nb_got_offsets, 0,
686 (n - s1->nb_got_offsets) * sizeof(unsigned long));
687 s1->nb_got_offsets = n;
688 }
689 s1->got_offsets[index] = val;
690 }
691
692 /* XXX: suppress that */
693 static void put32(unsigned char *p, uint32_t val)
694 {
695 p[0] = val;
696 p[1] = val >> 8;
697 p[2] = val >> 16;
698 p[3] = val >> 24;
699 }
700
701 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_ARM)
702 static uint32_t get32(unsigned char *p)
703 {
704 return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
705 }
706 #endif
707
708 static void build_got(TCCState *s1)
709 {
710 unsigned char *ptr;
711
712 /* if no got, then create it */
713 s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
714 s1->got->sh_entsize = 4;
715 add_elf_sym(symtab_section, 0, 4, ELF32_ST_INFO(STB_GLOBAL, STT_OBJECT),
716 0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
717 ptr = section_ptr_add(s1->got, 3 * sizeof(int));
718 /* keep space for _DYNAMIC pointer, if present */
719 put32(ptr, 0);
720 /* two dummy got entries */
721 put32(ptr + 4, 0);
722 put32(ptr + 8, 0);
723 }
724
725 /* put a got entry corresponding to a symbol in symtab_section. 'size'
726 and 'info' can be modifed if more precise info comes from the DLL */
727 static void put_got_entry(TCCState *s1,
728 int reloc_type, unsigned long size, int info,
729 int sym_index)
730 {
731 int index;
732 const char *name;
733 Elf32_Sym *sym;
734 unsigned long offset;
735 int *ptr;
736
737 if (!s1->got)
738 build_got(s1);
739
740 /* if a got entry already exists for that symbol, no need to add one */
741 if (sym_index < s1->nb_got_offsets &&
742 s1->got_offsets[sym_index] != 0)
743 return;
744
745 put_got_offset(s1, sym_index, s1->got->data_offset);
746
747 if (s1->dynsym) {
748 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
749 name = symtab_section->link->data + sym->st_name;
750 offset = sym->st_value;
751 #ifdef TCC_TARGET_I386
752 if (reloc_type == R_386_JMP_SLOT) {
753 Section *plt;
754 uint8_t *p;
755 int modrm;
756
757 /* if we build a DLL, we add a %ebx offset */
758 if (s1->output_type == TCC_OUTPUT_DLL)
759 modrm = 0xa3;
760 else
761 modrm = 0x25;
762
763 /* add a PLT entry */
764 plt = s1->plt;
765 if (plt->data_offset == 0) {
766 /* first plt entry */
767 p = section_ptr_add(plt, 16);
768 p[0] = 0xff; /* pushl got + 4 */
769 p[1] = modrm + 0x10;
770 put32(p + 2, 4);
771 p[6] = 0xff; /* jmp *(got + 8) */
772 p[7] = modrm;
773 put32(p + 8, 8);
774 }
775
776 p = section_ptr_add(plt, 16);
777 p[0] = 0xff; /* jmp *(got + x) */
778 p[1] = modrm;
779 put32(p + 2, s1->got->data_offset);
780 p[6] = 0x68; /* push $xxx */
781 put32(p + 7, (plt->data_offset - 32) >> 1);
782 p[11] = 0xe9; /* jmp plt_start */
783 put32(p + 12, -(plt->data_offset));
784
785 /* the symbol is modified so that it will be relocated to
786 the PLT */
787 if (s1->output_type == TCC_OUTPUT_EXE)
788 offset = plt->data_offset - 16;
789 }
790 #elif defined(TCC_TARGET_ARM)
791 if (reloc_type == R_ARM_JUMP_SLOT) {
792 Section *plt;
793 uint8_t *p;
794
795 /* if we build a DLL, we add a %ebx offset */
796 if (s1->output_type == TCC_OUTPUT_DLL)
797 error("DLLs unimplemented!");
798
799 /* add a PLT entry */
800 plt = s1->plt;
801 if (plt->data_offset == 0) {
802 /* first plt entry */
803 p = section_ptr_add(plt, 16);
804 put32(p , 0xe52de004);
805 put32(p + 4, 0xe59fe010);
806 put32(p + 8, 0xe08fe00e);
807 put32(p + 12, 0xe5bef008);
808 }
809
810 p = section_ptr_add(plt, 16);
811 put32(p , 0xe59fc004);
812 put32(p+4, 0xe08fc00c);
813 put32(p+8, 0xe59cf000);
814 put32(p+12, s1->got->data_offset);
815
816 /* the symbol is modified so that it will be relocated to
817 the PLT */
818 if (s1->output_type == TCC_OUTPUT_EXE)
819 offset = plt->data_offset - 16;
820 }
821 #elif defined(TCC_TARGET_C67)
822 error("C67 got not implemented");
823 #else
824 #error unsupported CPU
825 #endif
826 index = put_elf_sym(s1->dynsym, offset,
827 size, info, 0, sym->st_shndx, name);
828 /* put a got entry */
829 put_elf_reloc(s1->dynsym, s1->got,
830 s1->got->data_offset,
831 reloc_type, index);
832 }
833 ptr = section_ptr_add(s1->got, sizeof(int));
834 *ptr = 0;
835 }
836
837 /* build GOT and PLT entries */
838 static void build_got_entries(TCCState *s1)
839 {
840 Section *s, *symtab;
841 Elf32_Rel *rel, *rel_end;
842 Elf32_Sym *sym;
843 int i, type, reloc_type, sym_index;
844
845 for(i = 1; i < s1->nb_sections; i++) {
846 s = s1->sections[i];
847 if (s->sh_type != SHT_REL)
848 continue;
849 /* no need to handle got relocations */
850 if (s->link != symtab_section)
851 continue;
852 symtab = s->link;
853 rel_end = (Elf32_Rel *)(s->data + s->data_offset);
854 for(rel = (Elf32_Rel *)s->data;
855 rel < rel_end;
856 rel++) {
857 type = ELF32_R_TYPE(rel->r_info);
858 switch(type) {
859 #if defined(TCC_TARGET_I386)
860 case R_386_GOT32:
861 case R_386_GOTOFF:
862 case R_386_GOTPC:
863 case R_386_PLT32:
864 if (!s1->got)
865 build_got(s1);
866 if (type == R_386_GOT32 || type == R_386_PLT32) {
867 sym_index = ELF32_R_SYM(rel->r_info);
868 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
869 /* look at the symbol got offset. If none, then add one */
870 if (type == R_386_GOT32)
871 reloc_type = R_386_GLOB_DAT;
872 else
873 reloc_type = R_386_JMP_SLOT;
874 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
875 sym_index);
876 }
877 break;
878 #elif defined(TCC_TARGET_ARM)
879 case R_ARM_GOT_BREL:
880 case R_ARM_GOTOFF32:
881 case R_ARM_BASE_PREL:
882 case R_ARM_PLT32:
883 if (!s1->got)
884 build_got(s1);
885 if (type == R_ARM_GOT_BREL || type == R_ARM_PLT32) {
886 sym_index = ELF32_R_SYM(rel->r_info);
887 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
888 /* look at the symbol got offset. If none, then add one */
889 if (type == R_ARM_GOT_BREL)
890 reloc_type = R_ARM_GLOB_DAT;
891 else
892 reloc_type = R_ARM_JUMP_SLOT;
893 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
894 sym_index);
895 }
896 break;
897 #elif defined(TCC_TARGET_C67)
898 case R_C60_GOT32:
899 case R_C60_GOTOFF:
900 case R_C60_GOTPC:
901 case R_C60_PLT32:
902 if (!s1->got)
903 build_got(s1);
904 if (type == R_C60_GOT32 || type == R_C60_PLT32) {
905 sym_index = ELF32_R_SYM(rel->r_info);
906 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
907 /* look at the symbol got offset. If none, then add one */
908 if (type == R_C60_GOT32)
909 reloc_type = R_C60_GLOB_DAT;
910 else
911 reloc_type = R_C60_JMP_SLOT;
912 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
913 sym_index);
914 }
915 break;
916 #else
917 #error unsupported CPU
918 #endif
919 default:
920 break;
921 }
922 }
923 }
924 }
925
926 static Section *new_symtab(TCCState *s1,
927 const char *symtab_name, int sh_type, int sh_flags,
928 const char *strtab_name,
929 const char *hash_name, int hash_sh_flags)
930 {
931 Section *symtab, *strtab, *hash;
932 int *ptr, nb_buckets;
933
934 symtab = new_section(s1, symtab_name, sh_type, sh_flags);
935 symtab->sh_entsize = sizeof(Elf32_Sym);
936 strtab = new_section(s1, strtab_name, SHT_STRTAB, sh_flags);
937 put_elf_str(strtab, "");
938 symtab->link = strtab;
939 put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL);
940
941 nb_buckets = 1;
942
943 hash = new_section(s1, hash_name, SHT_HASH, hash_sh_flags);
944 hash->sh_entsize = sizeof(int);
945 symtab->hash = hash;
946 hash->link = symtab;
947
948 ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int));
949 ptr[0] = nb_buckets;
950 ptr[1] = 1;
951 memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int));
952 return symtab;
953 }
954
955 /* put dynamic tag */
956 static void put_dt(Section *dynamic, int dt, unsigned long val)
957 {
958 Elf32_Dyn *dyn;
959 dyn = section_ptr_add(dynamic, sizeof(Elf32_Dyn));
960 dyn->d_tag = dt;
961 dyn->d_un.d_val = val;
962 }
963
964 static void add_init_array_defines(TCCState *s1, const char *section_name)
965 {
966 Section *s;
967 long end_offset;
968 char sym_start[1024];
969 char sym_end[1024];
970
971 snprintf(sym_start, sizeof(sym_start), "__%s_start", section_name + 1);
972 snprintf(sym_end, sizeof(sym_end), "__%s_end", section_name + 1);
973
974 s = find_section(s1, section_name);
975 if (!s) {
976 end_offset = 0;
977 s = data_section;
978 } else {
979 end_offset = s->data_offset;
980 }
981
982 add_elf_sym(symtab_section,
983 0, 0,
984 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
985 s->sh_num, sym_start);
986 add_elf_sym(symtab_section,
987 end_offset, 0,
988 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
989 s->sh_num, sym_end);
990 }
991
992 /* add tcc runtime libraries */
993 static void tcc_add_runtime(TCCState *s1)
994 {
995 char buf[1024];
996
997 #ifdef CONFIG_TCC_BCHECK
998 if (do_bounds_check) {
999 unsigned long *ptr;
1000 Section *init_section;
1001 unsigned char *pinit;
1002 int sym_index;
1003
1004 /* XXX: add an object file to do that */
1005 ptr = section_ptr_add(bounds_section, sizeof(unsigned long));
1006 *ptr = 0;
1007 add_elf_sym(symtab_section, 0, 0,
1008 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
1009 bounds_section->sh_num, "__bounds_start");
1010 /* add bound check code */
1011 snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "bcheck.o");
1012 tcc_add_file(s1, buf);
1013 #ifdef TCC_TARGET_I386
1014 if (s1->output_type != TCC_OUTPUT_MEMORY) {
1015 /* add 'call __bound_init()' in .init section */
1016 init_section = find_section(s1, ".init");
1017 pinit = section_ptr_add(init_section, 5);
1018 pinit[0] = 0xe8;
1019 put32(pinit + 1, -4);
1020 sym_index = find_elf_sym(symtab_section, "__bound_init");
1021 put_elf_reloc(symtab_section, init_section,
1022 init_section->data_offset - 4, R_386_PC32, sym_index);
1023 }
1024 #endif
1025 }
1026 #endif
1027 /* add libc */
1028 if (!s1->nostdlib) {
1029 tcc_add_library(s1, "c");
1030
1031 snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "libtcc1.a");
1032 tcc_add_file(s1, buf);
1033 }
1034 /* add crt end if not memory output */
1035 if (s1->output_type != TCC_OUTPUT_MEMORY && !s1->nostdlib) {
1036 tcc_add_file(s1, CONFIG_TCC_CRT_PREFIX "/crtn.o");
1037 }
1038 }
1039
1040 /* add various standard linker symbols (must be done after the
1041 sections are filled (for example after allocating common
1042 symbols)) */
1043 static void tcc_add_linker_symbols(TCCState *s1)
1044 {
1045 char buf[1024];
1046 int i;
1047 Section *s;
1048
1049 add_elf_sym(symtab_section,
1050 text_section->data_offset, 0,
1051 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
1052 text_section->sh_num, "_etext");
1053 add_elf_sym(symtab_section,
1054 data_section->data_offset, 0,
1055 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
1056 data_section->sh_num, "_edata");
1057 add_elf_sym(symtab_section,
1058 bss_section->data_offset, 0,
1059 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
1060 bss_section->sh_num, "_end");
1061 /* horrible new standard ldscript defines */
1062 add_init_array_defines(s1, ".preinit_array");
1063 add_init_array_defines(s1, ".init_array");
1064 add_init_array_defines(s1, ".fini_array");
1065
1066 /* add start and stop symbols for sections whose name can be
1067 expressed in C */
1068 for(i = 1; i < s1->nb_sections; i++) {
1069 s = s1->sections[i];
1070 if (s->sh_type == SHT_PROGBITS &&
1071 (s->sh_flags & SHF_ALLOC)) {
1072 const char *p;
1073 int ch;
1074
1075 /* check if section name can be expressed in C */
1076 p = s->name;
1077 for(;;) {
1078 ch = *p;
1079 if (!ch)
1080 break;
1081 if (!isid(ch) && !isnum(ch))
1082 goto next_sec;
1083 p++;
1084 }
1085 snprintf(buf, sizeof(buf), "__start_%s", s->name);
1086 add_elf_sym(symtab_section,
1087 0, 0,
1088 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
1089 s->sh_num, buf);
1090 snprintf(buf, sizeof(buf), "__stop_%s", s->name);
1091 add_elf_sym(symtab_section,
1092 s->data_offset, 0,
1093 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
1094 s->sh_num, buf);
1095 }
1096 next_sec: ;
1097 }
1098 }
1099
1100 /* name of ELF interpreter */
1101 #ifdef __FreeBSD__
1102 static char elf_interp[] = "/usr/libexec/ld-elf.so.1";
1103 #else
1104 #ifdef TCC_ARM_EABI
1105 static char elf_interp[] = "/lib/ld-linux.so.3";
1106 #else
1107 static char elf_interp[] = "/lib/ld-linux.so.2";
1108 #endif
1109 #endif
1110
1111 static void tcc_output_binary(TCCState *s1, FILE *f,
1112 const int *section_order)
1113 {
1114 Section *s;
1115 int i, offset, size;
1116
1117 offset = 0;
1118 for(i=1;i<s1->nb_sections;i++) {
1119 s = s1->sections[section_order[i]];
1120 if (s->sh_type != SHT_NOBITS &&
1121 (s->sh_flags & SHF_ALLOC)) {
1122 while (offset < s->sh_offset) {
1123 fputc(0, f);
1124 offset++;
1125 }
1126 size = s->sh_size;
1127 fwrite(s->data, 1, size, f);
1128 offset += size;
1129 }
1130 }
1131 }
1132
1133 /* output an ELF file */
1134 /* XXX: suppress unneeded sections */
1135 int tcc_output_file(TCCState *s1, const char *filename)
1136 {
1137 Elf32_Ehdr ehdr;
1138 FILE *f;
1139 int fd, mode, ret;
1140 int *section_order;
1141 int shnum, i, phnum, file_offset, offset, size, j, tmp, sh_order_index, k;
1142 unsigned long addr;
1143 Section *strsec, *s;
1144 Elf32_Shdr shdr, *sh;
1145 Elf32_Phdr *phdr, *ph;
1146 Section *interp, *dynamic, *dynstr;
1147 unsigned long saved_dynamic_data_offset;
1148 Elf32_Sym *sym;
1149 int type, file_type;
1150 unsigned long rel_addr, rel_size;
1151
1152 file_type = s1->output_type;
1153 s1->nb_errors = 0;
1154
1155 if (file_type != TCC_OUTPUT_OBJ) {
1156 tcc_add_runtime(s1);
1157 }
1158
1159 phdr = NULL;
1160 section_order = NULL;
1161 interp = NULL;
1162 dynamic = NULL;
1163 dynstr = NULL; /* avoid warning */
1164 saved_dynamic_data_offset = 0; /* avoid warning */
1165
1166 if (file_type != TCC_OUTPUT_OBJ) {
1167 relocate_common_syms();
1168
1169 tcc_add_linker_symbols(s1);
1170
1171 if (!s1->static_link) {
1172 const char *name;
1173 int sym_index, index;
1174 Elf32_Sym *esym, *sym_end;
1175
1176 if (file_type == TCC_OUTPUT_EXE) {
1177 char *ptr;
1178 /* add interpreter section only if executable */
1179 interp = new_section(s1, ".interp", SHT_PROGBITS, SHF_ALLOC);
1180 interp->sh_addralign = 1;
1181 ptr = section_ptr_add(interp, sizeof(elf_interp));
1182 strcpy(ptr, elf_interp);
1183 }
1184
1185 /* add dynamic symbol table */
1186 s1->dynsym = new_symtab(s1, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
1187 ".dynstr",
1188 ".hash", SHF_ALLOC);
1189 dynstr = s1->dynsym->link;
1190
1191 /* add dynamic section */
1192 dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC,
1193 SHF_ALLOC | SHF_WRITE);
1194 dynamic->link = dynstr;
1195 dynamic->sh_entsize = sizeof(Elf32_Dyn);
1196
1197 /* add PLT */
1198 s1->plt = new_section(s1, ".plt", SHT_PROGBITS,
1199 SHF_ALLOC | SHF_EXECINSTR);
1200 s1->plt->sh_entsize = 4;
1201
1202 build_got(s1);
1203
1204 /* scan for undefined symbols and see if they are in the
1205 dynamic symbols. If a symbol STT_FUNC is found, then we
1206 add it in the PLT. If a symbol STT_OBJECT is found, we
1207 add it in the .bss section with a suitable relocation */
1208 sym_end = (Elf32_Sym *)(symtab_section->data +
1209 symtab_section->data_offset);
1210 if (file_type == TCC_OUTPUT_EXE) {
1211 for(sym = (Elf32_Sym *)symtab_section->data + 1;
1212 sym < sym_end;
1213 sym++) {
1214 if (sym->st_shndx == SHN_UNDEF) {
1215 name = symtab_section->link->data + sym->st_name;
1216 sym_index = find_elf_sym(s1->dynsymtab_section, name);
1217 if (sym_index) {
1218 esym = &((Elf32_Sym *)s1->dynsymtab_section->data)[sym_index];
1219 type = ELF32_ST_TYPE(esym->st_info);
1220 if (type == STT_FUNC) {
1221 put_got_entry(s1, R_JMP_SLOT, esym->st_size,
1222 esym->st_info,
1223 sym - (Elf32_Sym *)symtab_section->data);
1224 } else if (type == STT_OBJECT) {
1225 unsigned long offset;
1226 offset = bss_section->data_offset;
1227 /* XXX: which alignment ? */
1228 offset = (offset + 16 - 1) & -16;
1229 index = put_elf_sym(s1->dynsym, offset, esym->st_size,
1230 esym->st_info, 0,
1231 bss_section->sh_num, name);
1232 put_elf_reloc(s1->dynsym, bss_section,
1233 offset, R_COPY, index);
1234 offset += esym->st_size;
1235 bss_section->data_offset = offset;
1236 }
1237 } else {
1238 /* STB_WEAK undefined symbols are accepted */
1239 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
1240 it */
1241 if (ELF32_ST_BIND(sym->st_info) == STB_WEAK ||
1242 !strcmp(name, "_fp_hw")) {
1243 } else {
1244 error_noabort("undefined symbol '%s'", name);
1245 }
1246 }
1247 } else if (s1->rdynamic &&
1248 ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
1249 /* if -rdynamic option, then export all non
1250 local symbols */
1251 name = symtab_section->link->data + sym->st_name;
1252 put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1253 sym->st_info, 0,
1254 sym->st_shndx, name);
1255 }
1256 }
1257
1258 if (s1->nb_errors)
1259 goto fail;
1260
1261 /* now look at unresolved dynamic symbols and export
1262 corresponding symbol */
1263 sym_end = (Elf32_Sym *)(s1->dynsymtab_section->data +
1264 s1->dynsymtab_section->data_offset);
1265 for(esym = (Elf32_Sym *)s1->dynsymtab_section->data + 1;
1266 esym < sym_end;
1267 esym++) {
1268 if (esym->st_shndx == SHN_UNDEF) {
1269 name = s1->dynsymtab_section->link->data + esym->st_name;
1270 sym_index = find_elf_sym(symtab_section, name);
1271 if (sym_index) {
1272 /* XXX: avoid adding a symbol if already
1273 present because of -rdynamic ? */
1274 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
1275 put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1276 sym->st_info, 0,
1277 sym->st_shndx, name);
1278 } else {
1279 if (ELF32_ST_BIND(esym->st_info) == STB_WEAK) {
1280 /* weak symbols can stay undefined */
1281 } else {
1282 warning("undefined dynamic symbol '%s'", name);
1283 }
1284 }
1285 }
1286 }
1287 } else {
1288 int nb_syms;
1289 /* shared library case : we simply export all the global symbols */
1290 nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym);
1291 s1->symtab_to_dynsym = tcc_mallocz(sizeof(int) * nb_syms);
1292 for(sym = (Elf32_Sym *)symtab_section->data + 1;
1293 sym < sym_end;
1294 sym++) {
1295 if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
1296 name = symtab_section->link->data + sym->st_name;
1297 index = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1298 sym->st_info, 0,
1299 sym->st_shndx, name);
1300 s1->symtab_to_dynsym[sym -
1301 (Elf32_Sym *)symtab_section->data] =
1302 index;
1303 }
1304 }
1305 }
1306
1307 build_got_entries(s1);
1308
1309 /* add a list of needed dlls */
1310 for(i = 0; i < s1->nb_loaded_dlls; i++) {
1311 DLLReference *dllref = s1->loaded_dlls[i];
1312 if (dllref->level == 0)
1313 put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name));
1314 }
1315 /* XXX: currently, since we do not handle PIC code, we
1316 must relocate the readonly segments */
1317 if (file_type == TCC_OUTPUT_DLL) {
1318 if (s1->soname)
1319 put_dt(dynamic, DT_SONAME, put_elf_str(dynstr, s1->soname));
1320 put_dt(dynamic, DT_TEXTREL, 0);
1321 }
1322
1323 /* add necessary space for other entries */
1324 saved_dynamic_data_offset = dynamic->data_offset;
1325 dynamic->data_offset += 8 * 9;
1326 } else {
1327 /* still need to build got entries in case of static link */
1328 build_got_entries(s1);
1329 }
1330 }
1331
1332 memset(&ehdr, 0, sizeof(ehdr));
1333
1334 /* we add a section for symbols */
1335 strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0);
1336 put_elf_str(strsec, "");
1337
1338 /* compute number of sections */
1339 shnum = s1->nb_sections;
1340
1341 /* this array is used to reorder sections in the output file */
1342 section_order = tcc_malloc(sizeof(int) * shnum);
1343 section_order[0] = 0;
1344 sh_order_index = 1;
1345
1346 /* compute number of program headers */
1347 switch(file_type) {
1348 default:
1349 case TCC_OUTPUT_OBJ:
1350 phnum = 0;
1351 break;
1352 case TCC_OUTPUT_EXE:
1353 if (!s1->static_link)
1354 phnum = 4;
1355 else
1356 phnum = 2;
1357 break;
1358 case TCC_OUTPUT_DLL:
1359 phnum = 3;
1360 break;
1361 }
1362
1363 /* allocate strings for section names and decide if an unallocated
1364 section should be output */
1365 /* NOTE: the strsec section comes last, so its size is also
1366 correct ! */
1367 for(i = 1; i < s1->nb_sections; i++) {
1368 s = s1->sections[i];
1369 s->sh_name = put_elf_str(strsec, s->name);
1370 /* when generating a DLL, we include relocations but we may
1371 patch them */
1372 if (file_type == TCC_OUTPUT_DLL &&
1373 s->sh_type == SHT_REL &&
1374 !(s->sh_flags & SHF_ALLOC)) {
1375 prepare_dynamic_rel(s1, s);
1376 } else if (do_debug ||
1377 file_type == TCC_OUTPUT_OBJ ||
1378 (s->sh_flags & SHF_ALLOC) ||
1379 i == (s1->nb_sections - 1)) {
1380 /* we output all sections if debug or object file */
1381 s->sh_size = s->data_offset;
1382 }
1383 }
1384
1385 /* allocate program segment headers */
1386 phdr = tcc_mallocz(phnum * sizeof(Elf32_Phdr));
1387
1388 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1389 file_offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr);
1390 } else {
1391 file_offset = 0;
1392 }
1393 if (phnum > 0) {
1394 /* compute section to program header mapping */
1395 if (s1->has_text_addr) {
1396 int a_offset, p_offset;
1397 addr = s1->text_addr;
1398 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1399 ELF_PAGE_SIZE */
1400 a_offset = addr & (ELF_PAGE_SIZE - 1);
1401 p_offset = file_offset & (ELF_PAGE_SIZE - 1);
1402 if (a_offset < p_offset)
1403 a_offset += ELF_PAGE_SIZE;
1404 file_offset += (a_offset - p_offset);
1405 } else {
1406 if (file_type == TCC_OUTPUT_DLL)
1407 addr = 0;
1408 else
1409 addr = ELF_START_ADDR;
1410 /* compute address after headers */
1411 addr += (file_offset & (ELF_PAGE_SIZE - 1));
1412 }
1413
1414 /* dynamic relocation table information, for .dynamic section */
1415 rel_size = 0;
1416 rel_addr = 0;
1417
1418 /* leave one program header for the program interpreter */
1419 ph = &phdr[0];
1420 if (interp)
1421 ph++;
1422
1423 for(j = 0; j < 2; j++) {
1424 ph->p_type = PT_LOAD;
1425 if (j == 0)
1426 ph->p_flags = PF_R | PF_X;
1427 else
1428 ph->p_flags = PF_R | PF_W;
1429 ph->p_align = ELF_PAGE_SIZE;
1430
1431 /* we do the following ordering: interp, symbol tables,
1432 relocations, progbits, nobits */
1433 /* XXX: do faster and simpler sorting */
1434 for(k = 0; k < 5; k++) {
1435 for(i = 1; i < s1->nb_sections; i++) {
1436 s = s1->sections[i];
1437 /* compute if section should be included */
1438 if (j == 0) {
1439 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1440 SHF_ALLOC)
1441 continue;
1442 } else {
1443 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1444 (SHF_ALLOC | SHF_WRITE))
1445 continue;
1446 }
1447 if (s == interp) {
1448 if (k != 0)
1449 continue;
1450 } else if (s->sh_type == SHT_DYNSYM ||
1451 s->sh_type == SHT_STRTAB ||
1452 s->sh_type == SHT_HASH) {
1453 if (k != 1)
1454 continue;
1455 } else if (s->sh_type == SHT_REL) {
1456 if (k != 2)
1457 continue;
1458 } else if (s->sh_type == SHT_NOBITS) {
1459 if (k != 4)
1460 continue;
1461 } else {
1462 if (k != 3)
1463 continue;
1464 }
1465 section_order[sh_order_index++] = i;
1466
1467 /* section matches: we align it and add its size */
1468 tmp = addr;
1469 addr = (addr + s->sh_addralign - 1) &
1470 ~(s->sh_addralign - 1);
1471 file_offset += addr - tmp;
1472 s->sh_offset = file_offset;
1473 s->sh_addr = addr;
1474
1475 /* update program header infos */
1476 if (ph->p_offset == 0) {
1477 ph->p_offset = file_offset;
1478 ph->p_vaddr = addr;
1479 ph->p_paddr = ph->p_vaddr;
1480 }
1481 /* update dynamic relocation infos */
1482 if (s->sh_type == SHT_REL) {
1483 if (rel_size == 0)
1484 rel_addr = addr;
1485 rel_size += s->sh_size;
1486 }
1487 addr += s->sh_size;
1488 if (s->sh_type != SHT_NOBITS)
1489 file_offset += s->sh_size;
1490 }
1491 }
1492 ph->p_filesz = file_offset - ph->p_offset;
1493 ph->p_memsz = addr - ph->p_vaddr;
1494 ph++;
1495 if (j == 0) {
1496 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1497 /* if in the middle of a page, we duplicate the page in
1498 memory so that one copy is RX and the other is RW */
1499 if ((addr & (ELF_PAGE_SIZE - 1)) != 0)
1500 addr += ELF_PAGE_SIZE;
1501 } else {
1502 addr = (addr + ELF_PAGE_SIZE - 1) & ~(ELF_PAGE_SIZE - 1);
1503 file_offset = (file_offset + ELF_PAGE_SIZE - 1) &
1504 ~(ELF_PAGE_SIZE - 1);
1505 }
1506 }
1507 }
1508
1509 /* if interpreter, then add corresponing program header */
1510 if (interp) {
1511 ph = &phdr[0];
1512
1513 ph->p_type = PT_INTERP;
1514 ph->p_offset = interp->sh_offset;
1515 ph->p_vaddr = interp->sh_addr;
1516 ph->p_paddr = ph->p_vaddr;
1517 ph->p_filesz = interp->sh_size;
1518 ph->p_memsz = interp->sh_size;
1519 ph->p_flags = PF_R;
1520 ph->p_align = interp->sh_addralign;
1521 }
1522
1523 /* if dynamic section, then add corresponing program header */
1524 if (dynamic) {
1525 Elf32_Sym *sym_end;
1526
1527 ph = &phdr[phnum - 1];
1528
1529 ph->p_type = PT_DYNAMIC;
1530 ph->p_offset = dynamic->sh_offset;
1531 ph->p_vaddr = dynamic->sh_addr;
1532 ph->p_paddr = ph->p_vaddr;
1533 ph->p_filesz = dynamic->sh_size;
1534 ph->p_memsz = dynamic->sh_size;
1535 ph->p_flags = PF_R | PF_W;
1536 ph->p_align = dynamic->sh_addralign;
1537
1538 /* put GOT dynamic section address */
1539 put32(s1->got->data, dynamic->sh_addr);
1540
1541 /* relocate the PLT */
1542 if (file_type == TCC_OUTPUT_EXE) {
1543 uint8_t *p, *p_end;
1544
1545 p = s1->plt->data;
1546 p_end = p + s1->plt->data_offset;
1547 if (p < p_end) {
1548 #if defined(TCC_TARGET_I386)
1549 put32(p + 2, get32(p + 2) + s1->got->sh_addr);
1550 put32(p + 8, get32(p + 8) + s1->got->sh_addr);
1551 p += 16;
1552 while (p < p_end) {
1553 put32(p + 2, get32(p + 2) + s1->got->sh_addr);
1554 p += 16;
1555 }
1556 #elif defined(TCC_TARGET_ARM)
1557 int x;
1558 x=s1->got->sh_addr - s1->plt->sh_addr - 12;
1559 p +=16;
1560 while (p < p_end) {
1561 put32(p + 12, x + get32(p + 12) + s1->plt->data - p);
1562 p += 16;
1563 }
1564 #elif defined(TCC_TARGET_C67)
1565 /* XXX: TODO */
1566 #else
1567 #error unsupported CPU
1568 #endif
1569 }
1570 }
1571
1572 /* relocate symbols in .dynsym */
1573 sym_end = (Elf32_Sym *)(s1->dynsym->data + s1->dynsym->data_offset);
1574 for(sym = (Elf32_Sym *)s1->dynsym->data + 1;
1575 sym < sym_end;
1576 sym++) {
1577 if (sym->st_shndx == SHN_UNDEF) {
1578 /* relocate to the PLT if the symbol corresponds
1579 to a PLT entry */
1580 if (sym->st_value)
1581 sym->st_value += s1->plt->sh_addr;
1582 } else if (sym->st_shndx < SHN_LORESERVE) {
1583 /* do symbol relocation */
1584 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
1585 }
1586 }
1587
1588 /* put dynamic section entries */
1589 dynamic->data_offset = saved_dynamic_data_offset;
1590 put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
1591 put_dt(dynamic, DT_STRTAB, dynstr->sh_addr);
1592 put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
1593 put_dt(dynamic, DT_STRSZ, dynstr->data_offset);
1594 put_dt(dynamic, DT_SYMENT, sizeof(Elf32_Sym));
1595 put_dt(dynamic, DT_REL, rel_addr);
1596 put_dt(dynamic, DT_RELSZ, rel_size);
1597 put_dt(dynamic, DT_RELENT, sizeof(Elf32_Rel));
1598 put_dt(dynamic, DT_NULL, 0);
1599 }
1600
1601 ehdr.e_phentsize = sizeof(Elf32_Phdr);
1602 ehdr.e_phnum = phnum;
1603 ehdr.e_phoff = sizeof(Elf32_Ehdr);
1604 }
1605
1606 /* all other sections come after */
1607 for(i = 1; i < s1->nb_sections; i++) {
1608 s = s1->sections[i];
1609 if (phnum > 0 && (s->sh_flags & SHF_ALLOC))
1610 continue;
1611 section_order[sh_order_index++] = i;
1612
1613 file_offset = (file_offset + s->sh_addralign - 1) &
1614 ~(s->sh_addralign - 1);
1615 s->sh_offset = file_offset;
1616 if (s->sh_type != SHT_NOBITS)
1617 file_offset += s->sh_size;
1618 }
1619
1620 /* if building executable or DLL, then relocate each section
1621 except the GOT which is already relocated */
1622 if (file_type != TCC_OUTPUT_OBJ) {
1623 relocate_syms(s1, 0);
1624
1625 if (s1->nb_errors != 0) {
1626 fail:
1627 ret = -1;
1628 goto the_end;
1629 }
1630
1631 /* relocate sections */
1632 /* XXX: ignore sections with allocated relocations ? */
1633 for(i = 1; i < s1->nb_sections; i++) {
1634 s = s1->sections[i];
1635 if (s->reloc && s != s1->got)
1636 relocate_section(s1, s);
1637 }
1638
1639 /* relocate relocation entries if the relocation tables are
1640 allocated in the executable */
1641 for(i = 1; i < s1->nb_sections; i++) {
1642 s = s1->sections[i];
1643 if ((s->sh_flags & SHF_ALLOC) &&
1644 s->sh_type == SHT_REL) {
1645 relocate_rel(s1, s);
1646 }
1647 }
1648
1649 /* get entry point address */
1650 if (file_type == TCC_OUTPUT_EXE)
1651 ehdr.e_entry = (unsigned long)tcc_get_symbol_err(s1, "_start");
1652 else
1653 ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
1654 }
1655
1656 /* write elf file */
1657 if (file_type == TCC_OUTPUT_OBJ)
1658 mode = 0666;
1659 else
1660 mode = 0777;
1661 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
1662 if (fd < 0) {
1663 error_noabort("could not write '%s'", filename);
1664 goto fail;
1665 }
1666 f = fdopen(fd, "wb");
1667 if (verbose)
1668 printf("<- %s\n", filename);
1669
1670 #ifdef TCC_TARGET_COFF
1671 if (s1->output_format == TCC_OUTPUT_FORMAT_COFF) {
1672 tcc_output_coff(s1, f);
1673 } else
1674 #endif
1675 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1676 sort_syms(s1, symtab_section);
1677
1678 /* align to 4 */
1679 file_offset = (file_offset + 3) & -4;
1680
1681 /* fill header */
1682 ehdr.e_ident[0] = ELFMAG0;
1683 ehdr.e_ident[1] = ELFMAG1;
1684 ehdr.e_ident[2] = ELFMAG2;
1685 ehdr.e_ident[3] = ELFMAG3;
1686 ehdr.e_ident[4] = ELFCLASS32;
1687 ehdr.e_ident[5] = ELFDATA2LSB;
1688 ehdr.e_ident[6] = EV_CURRENT;
1689 #ifdef __FreeBSD__
1690 ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
1691 #endif
1692 #ifdef TCC_TARGET_ARM
1693 #ifdef TCC_ARM_EABI
1694 ehdr.e_ident[EI_OSABI] = 0;
1695 ehdr.e_flags = 4 << 24;
1696 #else
1697 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
1698 #endif
1699 #endif
1700 switch(file_type) {
1701 default:
1702 case TCC_OUTPUT_EXE:
1703 ehdr.e_type = ET_EXEC;
1704 break;
1705 case TCC_OUTPUT_DLL:
1706 ehdr.e_type = ET_DYN;
1707 break;
1708 case TCC_OUTPUT_OBJ:
1709 ehdr.e_type = ET_REL;
1710 break;
1711 }
1712 ehdr.e_machine = EM_TCC_TARGET;
1713 ehdr.e_version = EV_CURRENT;
1714 ehdr.e_shoff = file_offset;
1715 ehdr.e_ehsize = sizeof(Elf32_Ehdr);
1716 ehdr.e_shentsize = sizeof(Elf32_Shdr);
1717 ehdr.e_shnum = shnum;
1718 ehdr.e_shstrndx = shnum - 1;
1719
1720 fwrite(&ehdr, 1, sizeof(Elf32_Ehdr), f);
1721 fwrite(phdr, 1, phnum * sizeof(Elf32_Phdr), f);
1722 offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr);
1723
1724 for(i=1;i<s1->nb_sections;i++) {
1725 s = s1->sections[section_order[i]];
1726 if (s->sh_type != SHT_NOBITS) {
1727 while (offset < s->sh_offset) {
1728 fputc(0, f);
1729 offset++;
1730 }
1731 size = s->sh_size;
1732 fwrite(s->data, 1, size, f);
1733 offset += size;
1734 }
1735 }
1736
1737 /* output section headers */
1738 while (offset < ehdr.e_shoff) {
1739 fputc(0, f);
1740 offset++;
1741 }
1742
1743 for(i=0;i<s1->nb_sections;i++) {
1744 sh = &shdr;
1745 memset(sh, 0, sizeof(Elf32_Shdr));
1746 s = s1->sections[i];
1747 if (s) {
1748 sh->sh_name = s->sh_name;
1749 sh->sh_type = s->sh_type;
1750 sh->sh_flags = s->sh_flags;
1751 sh->sh_entsize = s->sh_entsize;
1752 sh->sh_info = s->sh_info;
1753 if (s->link)
1754 sh->sh_link = s->link->sh_num;
1755 sh->sh_addralign = s->sh_addralign;
1756 sh->sh_addr = s->sh_addr;
1757 sh->sh_offset = s->sh_offset;
1758 sh->sh_size = s->sh_size;
1759 }
1760 fwrite(sh, 1, sizeof(Elf32_Shdr), f);
1761 }
1762 } else {
1763 tcc_output_binary(s1, f, section_order);
1764 }
1765 fclose(f);
1766
1767 ret = 0;
1768 the_end:
1769 tcc_free(s1->symtab_to_dynsym);
1770 tcc_free(section_order);
1771 tcc_free(phdr);
1772 tcc_free(s1->got_offsets);
1773 return ret;
1774 }
1775
1776 static void *load_data(int fd, unsigned long file_offset, unsigned long size)
1777 {
1778 void *data;
1779
1780 data = tcc_malloc(size);
1781 lseek(fd, file_offset, SEEK_SET);
1782 read(fd, data, size);
1783 return data;
1784 }
1785
1786 typedef struct SectionMergeInfo {
1787 Section *s; /* corresponding existing section */
1788 unsigned long offset; /* offset of the new section in the existing section */
1789 uint8_t new_section; /* true if section 's' was added */
1790 uint8_t link_once; /* true if link once section */
1791 } SectionMergeInfo;
1792
1793 /* load an object file and merge it with current files */
1794 /* XXX: handle correctly stab (debug) info */
1795 static int tcc_load_object_file(TCCState *s1,
1796 int fd, unsigned long file_offset)
1797 {
1798 Elf32_Ehdr ehdr;
1799 Elf32_Shdr *shdr, *sh;
1800 int size, i, j, offset, offseti, nb_syms, sym_index, ret;
1801 unsigned char *strsec, *strtab;
1802 int *old_to_new_syms;
1803 char *sh_name, *name;
1804 SectionMergeInfo *sm_table, *sm;
1805 Elf32_Sym *sym, *symtab;
1806 Elf32_Rel *rel, *rel_end;
1807 Section *s;
1808
1809 if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr))
1810 goto fail1;
1811 if (ehdr.e_ident[0] != ELFMAG0 ||
1812 ehdr.e_ident[1] != ELFMAG1 ||
1813 ehdr.e_ident[2] != ELFMAG2 ||
1814 ehdr.e_ident[3] != ELFMAG3)
1815 goto fail1;
1816 /* test if object file */
1817 if (ehdr.e_type != ET_REL)
1818 goto fail1;
1819 /* test CPU specific stuff */
1820 if (ehdr.e_ident[5] != ELFDATA2LSB ||
1821 ehdr.e_machine != EM_TCC_TARGET) {
1822 fail1:
1823 error_noabort("invalid object file");
1824 return -1;
1825 }
1826 /* read sections */
1827 shdr = load_data(fd, file_offset + ehdr.e_shoff,
1828 sizeof(Elf32_Shdr) * ehdr.e_shnum);
1829 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
1830
1831 /* load section names */
1832 sh = &shdr[ehdr.e_shstrndx];
1833 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
1834
1835 /* load symtab and strtab */
1836 old_to_new_syms = NULL;
1837 symtab = NULL;
1838 strtab = NULL;
1839 nb_syms = 0;
1840 for(i = 1; i < ehdr.e_shnum; i++) {
1841 sh = &shdr[i];
1842 if (sh->sh_type == SHT_SYMTAB) {
1843 if (symtab) {
1844 error_noabort("object must contain only one symtab");
1845 fail:
1846 ret = -1;
1847 goto the_end;
1848 }
1849 nb_syms = sh->sh_size / sizeof(Elf32_Sym);
1850 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
1851 sm_table[i].s = symtab_section;
1852
1853 /* now load strtab */
1854 sh = &shdr[sh->sh_link];
1855 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
1856 }
1857 }
1858
1859 /* now examine each section and try to merge its content with the
1860 ones in memory */
1861 for(i = 1; i < ehdr.e_shnum; i++) {
1862 /* no need to examine section name strtab */
1863 if (i == ehdr.e_shstrndx)
1864 continue;
1865 sh = &shdr[i];
1866 sh_name = strsec + sh->sh_name;
1867 /* ignore sections types we do not handle */
1868 if (sh->sh_type != SHT_PROGBITS &&
1869 sh->sh_type != SHT_REL &&
1870 #ifdef TCC_ARM_EABI
1871 sh->sh_type != SHT_ARM_EXIDX &&
1872 #endif
1873 sh->sh_type != SHT_NOBITS)
1874 continue;
1875 if (sh->sh_addralign < 1)
1876 sh->sh_addralign = 1;
1877 /* find corresponding section, if any */
1878 for(j = 1; j < s1->nb_sections;j++) {
1879 s = s1->sections[j];
1880 if (!strcmp(s->name, sh_name)) {
1881 if (!strncmp(sh_name, ".gnu.linkonce",
1882 sizeof(".gnu.linkonce") - 1)) {
1883 /* if a 'linkonce' section is already present, we
1884 do not add it again. It is a little tricky as
1885 symbols can still be defined in
1886 it. */
1887 sm_table[i].link_once = 1;
1888 goto next;
1889 } else {
1890 goto found;
1891 }
1892 }
1893 }
1894 /* not found: create new section */
1895 s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags);
1896 /* take as much info as possible from the section. sh_link and
1897 sh_info will be updated later */
1898 s->sh_addralign = sh->sh_addralign;
1899 s->sh_entsize = sh->sh_entsize;
1900 sm_table[i].new_section = 1;
1901 found:
1902 if (sh->sh_type != s->sh_type) {
1903 error_noabort("invalid section type");
1904 goto fail;
1905 }
1906
1907 /* align start of section */
1908 offset = s->data_offset;
1909 size = sh->sh_addralign - 1;
1910 offset = (offset + size) & ~size;
1911 if (sh->sh_addralign > s->sh_addralign)
1912 s->sh_addralign = sh->sh_addralign;
1913 s->data_offset = offset;
1914 sm_table[i].offset = offset;
1915 sm_table[i].s = s;
1916 /* concatenate sections */
1917 size = sh->sh_size;
1918 if (sh->sh_type != SHT_NOBITS) {
1919 unsigned char *ptr;
1920 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
1921 ptr = section_ptr_add(s, size);
1922 read(fd, ptr, size);
1923 } else {
1924 s->data_offset += size;
1925 }
1926 next: ;
1927 }
1928
1929 /* second short pass to update sh_link and sh_info fields of new
1930 sections */
1931 for(i = 1; i < ehdr.e_shnum; i++) {
1932 s = sm_table[i].s;
1933 if (!s || !sm_table[i].new_section)
1934 continue;
1935 sh = &shdr[i];
1936 if (sh->sh_link > 0)
1937 s->link = sm_table[sh->sh_link].s;
1938 if (sh->sh_type == SHT_REL) {
1939 s->sh_info = sm_table[sh->sh_info].s->sh_num;
1940 /* update backward link */
1941 s1->sections[s->sh_info]->reloc = s;
1942 }
1943 }
1944 sm = sm_table;
1945
1946 /* resolve symbols */
1947 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
1948
1949 sym = symtab + 1;
1950 for(i = 1; i < nb_syms; i++, sym++) {
1951 if (sym->st_shndx != SHN_UNDEF &&
1952 sym->st_shndx < SHN_LORESERVE) {
1953 sm = &sm_table[sym->st_shndx];
1954 if (sm->link_once) {
1955 /* if a symbol is in a link once section, we use the
1956 already defined symbol. It is very important to get
1957 correct relocations */
1958 if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
1959 name = strtab + sym->st_name;
1960 sym_index = find_elf_sym(symtab_section, name);
1961 if (sym_index)
1962 old_to_new_syms[i] = sym_index;
1963 }
1964 continue;
1965 }
1966 /* if no corresponding section added, no need to add symbol */
1967 if (!sm->s)
1968 continue;
1969 /* convert section number */
1970 sym->st_shndx = sm->s->sh_num;
1971 /* offset value */
1972 sym->st_value += sm->offset;
1973 }
1974 /* add symbol */
1975 name = strtab + sym->st_name;
1976 sym_index = add_elf_sym(symtab_section, sym->st_value, sym->st_size,
1977 sym->st_info, sym->st_other,
1978 sym->st_shndx, name);
1979 old_to_new_syms[i] = sym_index;
1980 }
1981
1982 /* third pass to patch relocation entries */
1983 for(i = 1; i < ehdr.e_shnum; i++) {
1984 s = sm_table[i].s;
1985 if (!s)
1986 continue;
1987 sh = &shdr[i];
1988 offset = sm_table[i].offset;
1989 switch(s->sh_type) {
1990 case SHT_REL:
1991 /* take relocation offset information */
1992 offseti = sm_table[sh->sh_info].offset;
1993 rel_end = (Elf32_Rel *)(s->data + s->data_offset);
1994 for(rel = (Elf32_Rel *)(s->data + offset);
1995 rel < rel_end;
1996 rel++) {
1997 int type;
1998 unsigned sym_index;
1999 /* convert symbol index */
2000 type = ELF32_R_TYPE(rel->r_info);
2001 sym_index = ELF32_R_SYM(rel->r_info);
2002 /* NOTE: only one symtab assumed */
2003 if (sym_index >= nb_syms)
2004 goto invalid_reloc;
2005 sym_index = old_to_new_syms[sym_index];
2006 /* ignore link_once in rel section. */
2007 if (!sym_index && !sm->link_once) {
2008 invalid_reloc:
2009 error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2010 i, strsec + sh->sh_name, rel->r_offset);
2011 goto fail;
2012 }
2013 rel->r_info = ELF32_R_INFO(sym_index, type);
2014 /* offset the relocation offset */
2015 rel->r_offset += offseti;
2016 }
2017 break;
2018 default:
2019 break;
2020 }
2021 }
2022
2023 ret = 0;
2024 the_end:
2025 tcc_free(symtab);
2026 tcc_free(strtab);
2027 tcc_free(old_to_new_syms);
2028 tcc_free(sm_table);
2029 tcc_free(strsec);
2030 tcc_free(shdr);
2031 return ret;
2032 }
2033
2034 #define ARMAG "!<arch>\012" /* For COFF and a.out archives */
2035
2036 typedef struct ArchiveHeader {
2037 char ar_name[16]; /* name of this member */
2038 char ar_date[12]; /* file mtime */
2039 char ar_uid[6]; /* owner uid; printed as decimal */
2040 char ar_gid[6]; /* owner gid; printed as decimal */
2041 char ar_mode[8]; /* file mode, printed as octal */
2042 char ar_size[10]; /* file size, printed as decimal */
2043 char ar_fmag[2]; /* should contain ARFMAG */
2044 } ArchiveHeader;
2045
2046 static int get_be32(const uint8_t *b)
2047 {
2048 return b[3] | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
2049 }
2050
2051 /* load only the objects which resolve undefined symbols */
2052 static int tcc_load_alacarte(TCCState *s1, int fd, int size)
2053 {
2054 int i, bound, nsyms, sym_index, off, ret;
2055 uint8_t *data;
2056 const char *ar_names, *p;
2057 const uint8_t *ar_index;
2058 Elf32_Sym *sym;
2059
2060 data = tcc_malloc(size);
2061 if (read(fd, data, size) != size)
2062 goto fail;
2063 nsyms = get_be32(data);
2064 ar_index = data + 4;
2065 ar_names = ar_index + nsyms * 4;
2066
2067 do {
2068 bound = 0;
2069 for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2070 sym_index = find_elf_sym(symtab_section, p);
2071 if(sym_index) {
2072 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
2073 if(sym->st_shndx == SHN_UNDEF) {
2074 off = get_be32(ar_index + i * 4) + sizeof(ArchiveHeader);
2075 #if 0
2076 printf("%5d\t%s\t%08x\n", i, p, sym->st_shndx);
2077 #endif
2078 ++bound;
2079 lseek(fd, off, SEEK_SET);
2080 if(tcc_load_object_file(s1, fd, off) < 0) {
2081 fail:
2082 ret = -1;
2083 goto the_end;
2084 }
2085 }
2086 }
2087 }
2088 } while(bound);
2089 ret = 0;
2090 the_end:
2091 tcc_free(data);
2092 return ret;
2093 }
2094
2095 /* load a '.a' file */
2096 static int tcc_load_archive(TCCState *s1, int fd)
2097 {
2098 ArchiveHeader hdr;
2099 char ar_size[11];
2100 char ar_name[17];
2101 char magic[8];
2102 int size, len, i;
2103 unsigned long file_offset;
2104
2105 /* skip magic which was already checked */
2106 read(fd, magic, sizeof(magic));
2107
2108 for(;;) {
2109 len = read(fd, &hdr, sizeof(hdr));
2110 if (len == 0)
2111 break;
2112 if (len != sizeof(hdr)) {
2113 error_noabort("invalid archive");
2114 return -1;
2115 }
2116 memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
2117 ar_size[sizeof(hdr.ar_size)] = '\0';
2118 size = strtol(ar_size, NULL, 0);
2119 memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
2120 for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
2121 if (ar_name[i] != ' ')
2122 break;
2123 }
2124 ar_name[i + 1] = '\0';
2125 // printf("name='%s' size=%d %s\n", ar_name, size, ar_size);
2126 file_offset = lseek(fd, 0, SEEK_CUR);
2127 /* align to even */
2128 size = (size + 1) & ~1;
2129 if (!strcmp(ar_name, "/")) {
2130 /* coff symbol table : we handle it */
2131 if(s1->alacarte_link)
2132 return tcc_load_alacarte(s1, fd, size);
2133 } else if (!strcmp(ar_name, "//") ||
2134 !strcmp(ar_name, "__.SYMDEF") ||
2135 !strcmp(ar_name, "__.SYMDEF/") ||
2136 !strcmp(ar_name, "ARFILENAMES/")) {
2137 /* skip symbol table or archive names */
2138 } else {
2139 if (tcc_load_object_file(s1, fd, file_offset) < 0)
2140 return -1;
2141 }
2142 lseek(fd, file_offset + size, SEEK_SET);
2143 }
2144 return 0;
2145 }
2146
2147 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2148 is referenced by the user (so it should be added as DT_NEEDED in
2149 the generated ELF file) */
2150 static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
2151 {
2152 Elf32_Ehdr ehdr;
2153 Elf32_Shdr *shdr, *sh, *sh1;
2154 int i, j, nb_syms, nb_dts, sym_bind, ret;
2155 Elf32_Sym *sym, *dynsym;
2156 Elf32_Dyn *dt, *dynamic;
2157 unsigned char *dynstr;
2158 const char *name, *soname;
2159 DLLReference *dllref;
2160
2161 read(fd, &ehdr, sizeof(ehdr));
2162
2163 /* test CPU specific stuff */
2164 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2165 ehdr.e_machine != EM_TCC_TARGET) {
2166 error_noabort("bad architecture");
2167 return -1;
2168 }
2169
2170 /* read sections */
2171 shdr = load_data(fd, ehdr.e_shoff, sizeof(Elf32_Shdr) * ehdr.e_shnum);
2172
2173 /* load dynamic section and dynamic symbols */
2174 nb_syms = 0;
2175 nb_dts = 0;
2176 dynamic = NULL;
2177 dynsym = NULL; /* avoid warning */
2178 dynstr = NULL; /* avoid warning */
2179 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
2180 switch(sh->sh_type) {
2181 case SHT_DYNAMIC:
2182 nb_dts = sh->sh_size / sizeof(Elf32_Dyn);
2183 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
2184 break;
2185 case SHT_DYNSYM:
2186 nb_syms = sh->sh_size / sizeof(Elf32_Sym);
2187 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
2188 sh1 = &shdr[sh->sh_link];
2189 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
2190 break;
2191 default:
2192 break;
2193 }
2194 }
2195
2196 /* compute the real library name */
2197 soname = tcc_basename(filename);
2198
2199 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2200 if (dt->d_tag == DT_SONAME) {
2201 soname = dynstr + dt->d_un.d_val;
2202 }
2203 }
2204
2205 /* if the dll is already loaded, do not load it */
2206 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2207 dllref = s1->loaded_dlls[i];
2208 if (!strcmp(soname, dllref->name)) {
2209 /* but update level if needed */
2210 if (level < dllref->level)
2211 dllref->level = level;
2212 ret = 0;
2213 goto the_end;
2214 }
2215 }
2216
2217 // printf("loading dll '%s'\n", soname);
2218
2219 /* add the dll and its level */
2220 dllref = tcc_malloc(sizeof(DLLReference) + strlen(soname));
2221 dllref->level = level;
2222 strcpy(dllref->name, soname);
2223 dynarray_add((void ***)&s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
2224
2225 /* add dynamic symbols in dynsym_section */
2226 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
2227 sym_bind = ELF32_ST_BIND(sym->st_info);
2228 if (sym_bind == STB_LOCAL)
2229 continue;
2230 name = dynstr + sym->st_name;
2231 add_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
2232 sym->st_info, sym->st_other, sym->st_shndx, name);
2233 }
2234
2235 /* load all referenced DLLs */
2236 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2237 switch(dt->d_tag) {
2238 case DT_NEEDED:
2239 name = dynstr + dt->d_un.d_val;
2240 for(j = 0; j < s1->nb_loaded_dlls; j++) {
2241 dllref = s1->loaded_dlls[j];
2242 if (!strcmp(name, dllref->name))
2243 goto already_loaded;
2244 }
2245 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
2246 error_noabort("referenced dll '%s' not found", name);
2247 ret = -1;
2248 goto the_end;
2249 }
2250 already_loaded:
2251 break;
2252 }
2253 }
2254 ret = 0;
2255 the_end:
2256 tcc_free(dynstr);
2257 tcc_free(dynsym);
2258 tcc_free(dynamic);
2259 tcc_free(shdr);
2260 return ret;
2261 }
2262
2263 #define LD_TOK_NAME 256
2264 #define LD_TOK_EOF (-1)
2265
2266 /* return next ld script token */
2267 static int ld_next(TCCState *s1, char *name, int name_size)
2268 {
2269 int c;
2270 char *q;
2271
2272 redo:
2273 switch(ch) {
2274 case ' ':
2275 case '\t':
2276 case '\f':
2277 case '\v':
2278 case '\r':
2279 case '\n':
2280 inp();
2281 goto redo;
2282 case '/':
2283 minp();
2284 if (ch == '*') {
2285 file->buf_ptr = parse_comment(file->buf_ptr);
2286 ch = file->buf_ptr[0];
2287 goto redo;
2288 } else {
2289 q = name;
2290 *q++ = '/';
2291 goto parse_name;
2292 }
2293 break;
2294 /* case 'a' ... 'z': */
2295 case 'a':
2296 case 'b':
2297 case 'c':
2298 case 'd':
2299 case 'e':
2300 case 'f':
2301 case 'g':
2302 case 'h':
2303 case 'i':
2304 case 'j':
2305 case 'k':
2306 case 'l':
2307 case 'm':
2308 case 'n':
2309 case 'o':
2310 case 'p':
2311 case 'q':
2312 case 'r':
2313 case 's':
2314 case 't':
2315 case 'u':
2316 case 'v':
2317 case 'w':
2318 case 'x':
2319 case 'y':
2320 case 'z':
2321 /* case 'A' ... 'z': */
2322 case 'A':
2323 case 'B':
2324 case 'C':
2325 case 'D':
2326 case 'E':
2327 case 'F':
2328 case 'G':
2329 case 'H':
2330 case 'I':
2331 case 'J':
2332 case 'K':
2333 case 'L':
2334 case 'M':
2335 case 'N':
2336 case 'O':
2337 case 'P':
2338 case 'Q':
2339 case 'R':
2340 case 'S':
2341 case 'T':
2342 case 'U':
2343 case 'V':
2344 case 'W':
2345 case 'X':
2346 case 'Y':
2347 case 'Z':
2348 case '_':
2349 case '\\':
2350 case '.':
2351 case '$':
2352 case '~':
2353 q = name;
2354 parse_name:
2355 for(;;) {
2356 if (!((ch >= 'a' && ch <= 'z') ||
2357 (ch >= 'A' && ch <= 'Z') ||
2358 (ch >= '0' && ch <= '9') ||
2359 strchr("/.-_+=$:\\,~", ch)))
2360 break;
2361 if ((q - name) < name_size - 1) {
2362 *q++ = ch;
2363 }
2364 minp();
2365 }
2366 *q = '\0';
2367 c = LD_TOK_NAME;
2368 break;
2369 case CH_EOF:
2370 c = LD_TOK_EOF;
2371 break;
2372 default:
2373 c = ch;
2374 inp();
2375 break;
2376 }
2377 #if 0
2378 printf("tok=%c %d\n", c, c);
2379 if (c == LD_TOK_NAME)
2380 printf(" name=%s\n", name);
2381 #endif
2382 return c;
2383 }
2384
2385 static int ld_add_file_list(TCCState *s1, int as_needed)
2386 {
2387 char filename[1024];
2388 int t, ret;
2389
2390 t = ld_next(s1, filename, sizeof(filename));
2391 if (t != '(')
2392 expect("(");
2393 t = ld_next(s1, filename, sizeof(filename));
2394 for(;;) {
2395 if (t == LD_TOK_EOF) {
2396 error_noabort("unexpected end of file");
2397 return -1;
2398 } else if (t == ')') {
2399 break;
2400 } else if (t != LD_TOK_NAME) {
2401 error_noabort("filename expected");
2402 return -1;
2403 }
2404 if (!strcmp(filename, "AS_NEEDED")) {
2405 ret = ld_add_file_list(s1, 1);
2406 if (ret)
2407 return ret;
2408 } else {
2409 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2410 if (!as_needed)
2411 tcc_add_file(s1, filename);
2412 }
2413 t = ld_next(s1, filename, sizeof(filename));
2414 if (t == ',') {
2415 t = ld_next(s1, filename, sizeof(filename));
2416 }
2417 }
2418 return 0;
2419 }
2420
2421 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
2422 files */
2423 static int tcc_load_ldscript(TCCState *s1)
2424 {
2425 char cmd[64];
2426 char filename[1024];
2427 int t, ret;
2428
2429 ch = file->buf_ptr[0];
2430 ch = handle_eob();
2431 for(;;) {
2432 t = ld_next(s1, cmd, sizeof(cmd));
2433 if (t == LD_TOK_EOF)
2434 return 0;
2435 else if (t != LD_TOK_NAME)
2436 return -1;
2437 if (!strcmp(cmd, "INPUT") ||
2438 !strcmp(cmd, "GROUP")) {
2439 ret = ld_add_file_list(s1, 0);
2440 if (ret)
2441 return ret;
2442 } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
2443 !strcmp(cmd, "TARGET")) {
2444 /* ignore some commands */
2445 t = ld_next(s1, cmd, sizeof(cmd));
2446 if (t != '(')
2447 expect("(");
2448 for(;;) {
2449 t = ld_next(s1, filename, sizeof(filename));
2450 if (t == LD_TOK_EOF) {
2451 error_noabort("unexpected end of file");
2452 return -1;
2453 } else if (t == ')') {
2454 break;
2455 }
2456 }
2457 } else {
2458 return -1;
2459 }
2460 }
2461 return 0;
2462 }
Tiny C Compiler main repository