?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix bogus relocations with TCC_OUTPUT_DLL
[tinycc/kirr.git] / tccelf.c
blob2c54dc7479c2b56a562aa27b0396a76fcfb7aaf2
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 #if 0 //gr
1371 printf("section: f=%08x t=%08x i=%08x %s %s\n",
1372 s->sh_flags,
1373 s->sh_type,
1374 s->sh_info,
1375 s->name,
1376 s->reloc ? s->reloc->name : "n"
1377 );
1378 #endif
1379 /* when generating a DLL, we include relocations but we may
1380 patch them */
1381 if (file_type == TCC_OUTPUT_DLL &&
1382 s->sh_type == SHT_REL &&
1383 !(s->sh_flags & SHF_ALLOC)) {
1384 /* //gr: avoid bogus relocs for empty (debug) sections */
1385 if (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC)
1386 prepare_dynamic_rel(s1, s);
1387 else if (do_debug)
1388 s->sh_size = s->data_offset;
1389 } else if (do_debug ||
1390 file_type == TCC_OUTPUT_OBJ ||
1391 (s->sh_flags & SHF_ALLOC) ||
1392 i == (s1->nb_sections - 1)) {
1393 /* we output all sections if debug or object file */
1394 s->sh_size = s->data_offset;
1395 }
1396 }
1397
1398 /* allocate program segment headers */
1399 phdr = tcc_mallocz(phnum * sizeof(Elf32_Phdr));
1400
1401 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1402 file_offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr);
1403 } else {
1404 file_offset = 0;
1405 }
1406 if (phnum > 0) {
1407 /* compute section to program header mapping */
1408 if (s1->has_text_addr) {
1409 int a_offset, p_offset;
1410 addr = s1->text_addr;
1411 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1412 ELF_PAGE_SIZE */
1413 a_offset = addr & (ELF_PAGE_SIZE - 1);
1414 p_offset = file_offset & (ELF_PAGE_SIZE - 1);
1415 if (a_offset < p_offset)
1416 a_offset += ELF_PAGE_SIZE;
1417 file_offset += (a_offset - p_offset);
1418 } else {
1419 if (file_type == TCC_OUTPUT_DLL)
1420 addr = 0;
1421 else
1422 addr = ELF_START_ADDR;
1423 /* compute address after headers */
1424 addr += (file_offset & (ELF_PAGE_SIZE - 1));
1425 }
1426
1427 /* dynamic relocation table information, for .dynamic section */
1428 rel_size = 0;
1429 rel_addr = 0;
1430
1431 /* leave one program header for the program interpreter */
1432 ph = &phdr[0];
1433 if (interp)
1434 ph++;
1435
1436 for(j = 0; j < 2; j++) {
1437 ph->p_type = PT_LOAD;
1438 if (j == 0)
1439 ph->p_flags = PF_R | PF_X;
1440 else
1441 ph->p_flags = PF_R | PF_W;
1442 ph->p_align = ELF_PAGE_SIZE;
1443
1444 /* we do the following ordering: interp, symbol tables,
1445 relocations, progbits, nobits */
1446 /* XXX: do faster and simpler sorting */
1447 for(k = 0; k < 5; k++) {
1448 for(i = 1; i < s1->nb_sections; i++) {
1449 s = s1->sections[i];
1450 /* compute if section should be included */
1451 if (j == 0) {
1452 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1453 SHF_ALLOC)
1454 continue;
1455 } else {
1456 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1457 (SHF_ALLOC | SHF_WRITE))
1458 continue;
1459 }
1460 if (s == interp) {
1461 if (k != 0)
1462 continue;
1463 } else if (s->sh_type == SHT_DYNSYM ||
1464 s->sh_type == SHT_STRTAB ||
1465 s->sh_type == SHT_HASH) {
1466 if (k != 1)
1467 continue;
1468 } else if (s->sh_type == SHT_REL) {
1469 if (k != 2)
1470 continue;
1471 } else if (s->sh_type == SHT_NOBITS) {
1472 if (k != 4)
1473 continue;
1474 } else {
1475 if (k != 3)
1476 continue;
1477 }
1478 section_order[sh_order_index++] = i;
1479
1480 /* section matches: we align it and add its size */
1481 tmp = addr;
1482 addr = (addr + s->sh_addralign - 1) &
1483 ~(s->sh_addralign - 1);
1484 file_offset += addr - tmp;
1485 s->sh_offset = file_offset;
1486 s->sh_addr = addr;
1487
1488 /* update program header infos */
1489 if (ph->p_offset == 0) {
1490 ph->p_offset = file_offset;
1491 ph->p_vaddr = addr;
1492 ph->p_paddr = ph->p_vaddr;
1493 }
1494 /* update dynamic relocation infos */
1495 if (s->sh_type == SHT_REL) {
1496 if (rel_size == 0)
1497 rel_addr = addr;
1498 rel_size += s->sh_size;
1499 }
1500 addr += s->sh_size;
1501 if (s->sh_type != SHT_NOBITS)
1502 file_offset += s->sh_size;
1503 }
1504 }
1505 ph->p_filesz = file_offset - ph->p_offset;
1506 ph->p_memsz = addr - ph->p_vaddr;
1507 ph++;
1508 if (j == 0) {
1509 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1510 /* if in the middle of a page, we duplicate the page in
1511 memory so that one copy is RX and the other is RW */
1512 if ((addr & (ELF_PAGE_SIZE - 1)) != 0)
1513 addr += ELF_PAGE_SIZE;
1514 } else {
1515 addr = (addr + ELF_PAGE_SIZE - 1) & ~(ELF_PAGE_SIZE - 1);
1516 file_offset = (file_offset + ELF_PAGE_SIZE - 1) &
1517 ~(ELF_PAGE_SIZE - 1);
1518 }
1519 }
1520 }
1521
1522 /* if interpreter, then add corresponing program header */
1523 if (interp) {
1524 ph = &phdr[0];
1525
1526 ph->p_type = PT_INTERP;
1527 ph->p_offset = interp->sh_offset;
1528 ph->p_vaddr = interp->sh_addr;
1529 ph->p_paddr = ph->p_vaddr;
1530 ph->p_filesz = interp->sh_size;
1531 ph->p_memsz = interp->sh_size;
1532 ph->p_flags = PF_R;
1533 ph->p_align = interp->sh_addralign;
1534 }
1535
1536 /* if dynamic section, then add corresponing program header */
1537 if (dynamic) {
1538 Elf32_Sym *sym_end;
1539
1540 ph = &phdr[phnum - 1];
1541
1542 ph->p_type = PT_DYNAMIC;
1543 ph->p_offset = dynamic->sh_offset;
1544 ph->p_vaddr = dynamic->sh_addr;
1545 ph->p_paddr = ph->p_vaddr;
1546 ph->p_filesz = dynamic->sh_size;
1547 ph->p_memsz = dynamic->sh_size;
1548 ph->p_flags = PF_R | PF_W;
1549 ph->p_align = dynamic->sh_addralign;
1550
1551 /* put GOT dynamic section address */
1552 put32(s1->got->data, dynamic->sh_addr);
1553
1554 /* relocate the PLT */
1555 if (file_type == TCC_OUTPUT_EXE) {
1556 uint8_t *p, *p_end;
1557
1558 p = s1->plt->data;
1559 p_end = p + s1->plt->data_offset;
1560 if (p < p_end) {
1561 #if defined(TCC_TARGET_I386)
1562 put32(p + 2, get32(p + 2) + s1->got->sh_addr);
1563 put32(p + 8, get32(p + 8) + s1->got->sh_addr);
1564 p += 16;
1565 while (p < p_end) {
1566 put32(p + 2, get32(p + 2) + s1->got->sh_addr);
1567 p += 16;
1568 }
1569 #elif defined(TCC_TARGET_ARM)
1570 int x;
1571 x=s1->got->sh_addr - s1->plt->sh_addr - 12;
1572 p +=16;
1573 while (p < p_end) {
1574 put32(p + 12, x + get32(p + 12) + s1->plt->data - p);
1575 p += 16;
1576 }
1577 #elif defined(TCC_TARGET_C67)
1578 /* XXX: TODO */
1579 #else
1580 #error unsupported CPU
1581 #endif
1582 }
1583 }
1584
1585 /* relocate symbols in .dynsym */
1586 sym_end = (Elf32_Sym *)(s1->dynsym->data + s1->dynsym->data_offset);
1587 for(sym = (Elf32_Sym *)s1->dynsym->data + 1;
1588 sym < sym_end;
1589 sym++) {
1590 if (sym->st_shndx == SHN_UNDEF) {
1591 /* relocate to the PLT if the symbol corresponds
1592 to a PLT entry */
1593 if (sym->st_value)
1594 sym->st_value += s1->plt->sh_addr;
1595 } else if (sym->st_shndx < SHN_LORESERVE) {
1596 /* do symbol relocation */
1597 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
1598 }
1599 }
1600
1601 /* put dynamic section entries */
1602 dynamic->data_offset = saved_dynamic_data_offset;
1603 put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
1604 put_dt(dynamic, DT_STRTAB, dynstr->sh_addr);
1605 put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
1606 put_dt(dynamic, DT_STRSZ, dynstr->data_offset);
1607 put_dt(dynamic, DT_SYMENT, sizeof(Elf32_Sym));
1608 put_dt(dynamic, DT_REL, rel_addr);
1609 put_dt(dynamic, DT_RELSZ, rel_size);
1610 put_dt(dynamic, DT_RELENT, sizeof(Elf32_Rel));
1611 if (do_debug)
1612 put_dt(dynamic, DT_DEBUG, 0);
1613 put_dt(dynamic, DT_NULL, 0);
1614 }
1615
1616 ehdr.e_phentsize = sizeof(Elf32_Phdr);
1617 ehdr.e_phnum = phnum;
1618 ehdr.e_phoff = sizeof(Elf32_Ehdr);
1619 }
1620
1621 /* all other sections come after */
1622 for(i = 1; i < s1->nb_sections; i++) {
1623 s = s1->sections[i];
1624 if (phnum > 0 && (s->sh_flags & SHF_ALLOC))
1625 continue;
1626 section_order[sh_order_index++] = i;
1627
1628 file_offset = (file_offset + s->sh_addralign - 1) &
1629 ~(s->sh_addralign - 1);
1630 s->sh_offset = file_offset;
1631 if (s->sh_type != SHT_NOBITS)
1632 file_offset += s->sh_size;
1633 }
1634
1635 /* if building executable or DLL, then relocate each section
1636 except the GOT which is already relocated */
1637 if (file_type != TCC_OUTPUT_OBJ) {
1638 relocate_syms(s1, 0);
1639
1640 if (s1->nb_errors != 0) {
1641 fail:
1642 ret = -1;
1643 goto the_end;
1644 }
1645
1646 /* relocate sections */
1647 /* XXX: ignore sections with allocated relocations ? */
1648 for(i = 1; i < s1->nb_sections; i++) {
1649 s = s1->sections[i];
1650 if (s->reloc && s != s1->got && (s->sh_flags & SHF_ALLOC)) //gr
1651 relocate_section(s1, s);
1652 }
1653
1654 /* relocate relocation entries if the relocation tables are
1655 allocated in the executable */
1656 for(i = 1; i < s1->nb_sections; i++) {
1657 s = s1->sections[i];
1658 if ((s->sh_flags & SHF_ALLOC) &&
1659 s->sh_type == SHT_REL) {
1660 relocate_rel(s1, s);
1661 }
1662 }
1663
1664 /* get entry point address */
1665 if (file_type == TCC_OUTPUT_EXE)
1666 ehdr.e_entry = (unsigned long)tcc_get_symbol_err(s1, "_start");
1667 else
1668 ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
1669 }
1670
1671 /* write elf file */
1672 if (file_type == TCC_OUTPUT_OBJ)
1673 mode = 0666;
1674 else
1675 mode = 0777;
1676 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
1677 if (fd < 0) {
1678 error_noabort("could not write '%s'", filename);
1679 goto fail;
1680 }
1681 f = fdopen(fd, "wb");
1682 if (verbose)
1683 printf("<- %s\n", filename);
1684
1685 #ifdef TCC_TARGET_COFF
1686 if (s1->output_format == TCC_OUTPUT_FORMAT_COFF) {
1687 tcc_output_coff(s1, f);
1688 } else
1689 #endif
1690 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1691 sort_syms(s1, symtab_section);
1692
1693 /* align to 4 */
1694 file_offset = (file_offset + 3) & -4;
1695
1696 /* fill header */
1697 ehdr.e_ident[0] = ELFMAG0;
1698 ehdr.e_ident[1] = ELFMAG1;
1699 ehdr.e_ident[2] = ELFMAG2;
1700 ehdr.e_ident[3] = ELFMAG3;
1701 ehdr.e_ident[4] = ELFCLASS32;
1702 ehdr.e_ident[5] = ELFDATA2LSB;
1703 ehdr.e_ident[6] = EV_CURRENT;
1704 #ifdef __FreeBSD__
1705 ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
1706 #endif
1707 #ifdef TCC_TARGET_ARM
1708 #ifdef TCC_ARM_EABI
1709 ehdr.e_ident[EI_OSABI] = 0;
1710 ehdr.e_flags = 4 << 24;
1711 #else
1712 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
1713 #endif
1714 #endif
1715 switch(file_type) {
1716 default:
1717 case TCC_OUTPUT_EXE:
1718 ehdr.e_type = ET_EXEC;
1719 break;
1720 case TCC_OUTPUT_DLL:
1721 ehdr.e_type = ET_DYN;
1722 break;
1723 case TCC_OUTPUT_OBJ:
1724 ehdr.e_type = ET_REL;
1725 break;
1726 }
1727 ehdr.e_machine = EM_TCC_TARGET;
1728 ehdr.e_version = EV_CURRENT;
1729 ehdr.e_shoff = file_offset;
1730 ehdr.e_ehsize = sizeof(Elf32_Ehdr);
1731 ehdr.e_shentsize = sizeof(Elf32_Shdr);
1732 ehdr.e_shnum = shnum;
1733 ehdr.e_shstrndx = shnum - 1;
1734
1735 fwrite(&ehdr, 1, sizeof(Elf32_Ehdr), f);
1736 fwrite(phdr, 1, phnum * sizeof(Elf32_Phdr), f);
1737 offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr);
1738
1739 for(i=1;i<s1->nb_sections;i++) {
1740 s = s1->sections[section_order[i]];
1741 if (s->sh_type != SHT_NOBITS) {
1742 while (offset < s->sh_offset) {
1743 fputc(0, f);
1744 offset++;
1745 }
1746 size = s->sh_size;
1747 fwrite(s->data, 1, size, f);
1748 offset += size;
1749 }
1750 }
1751
1752 /* output section headers */
1753 while (offset < ehdr.e_shoff) {
1754 fputc(0, f);
1755 offset++;
1756 }
1757
1758 for(i=0;i<s1->nb_sections;i++) {
1759 sh = &shdr;
1760 memset(sh, 0, sizeof(Elf32_Shdr));
1761 s = s1->sections[i];
1762 if (s) {
1763 sh->sh_name = s->sh_name;
1764 sh->sh_type = s->sh_type;
1765 sh->sh_flags = s->sh_flags;
1766 sh->sh_entsize = s->sh_entsize;
1767 sh->sh_info = s->sh_info;
1768 if (s->link)
1769 sh->sh_link = s->link->sh_num;
1770 sh->sh_addralign = s->sh_addralign;
1771 sh->sh_addr = s->sh_addr;
1772 sh->sh_offset = s->sh_offset;
1773 sh->sh_size = s->sh_size;
1774 }
1775 fwrite(sh, 1, sizeof(Elf32_Shdr), f);
1776 }
1777 } else {
1778 tcc_output_binary(s1, f, section_order);
1779 }
1780 fclose(f);
1781
1782 ret = 0;
1783 the_end:
1784 tcc_free(s1->symtab_to_dynsym);
1785 tcc_free(section_order);
1786 tcc_free(phdr);
1787 tcc_free(s1->got_offsets);
1788 return ret;
1789 }
1790
1791 static void *load_data(int fd, unsigned long file_offset, unsigned long size)
1792 {
1793 void *data;
1794
1795 data = tcc_malloc(size);
1796 lseek(fd, file_offset, SEEK_SET);
1797 read(fd, data, size);
1798 return data;
1799 }
1800
1801 typedef struct SectionMergeInfo {
1802 Section *s; /* corresponding existing section */
1803 unsigned long offset; /* offset of the new section in the existing section */
1804 uint8_t new_section; /* true if section 's' was added */
1805 uint8_t link_once; /* true if link once section */
1806 } SectionMergeInfo;
1807
1808 /* load an object file and merge it with current files */
1809 /* XXX: handle correctly stab (debug) info */
1810 static int tcc_load_object_file(TCCState *s1,
1811 int fd, unsigned long file_offset)
1812 {
1813 Elf32_Ehdr ehdr;
1814 Elf32_Shdr *shdr, *sh;
1815 int size, i, j, offset, offseti, nb_syms, sym_index, ret;
1816 unsigned char *strsec, *strtab;
1817 int *old_to_new_syms;
1818 char *sh_name, *name;
1819 SectionMergeInfo *sm_table, *sm;
1820 Elf32_Sym *sym, *symtab;
1821 Elf32_Rel *rel, *rel_end;
1822 Section *s;
1823
1824 if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr))
1825 goto fail1;
1826 if (ehdr.e_ident[0] != ELFMAG0 ||
1827 ehdr.e_ident[1] != ELFMAG1 ||
1828 ehdr.e_ident[2] != ELFMAG2 ||
1829 ehdr.e_ident[3] != ELFMAG3)
1830 goto fail1;
1831 /* test if object file */
1832 if (ehdr.e_type != ET_REL)
1833 goto fail1;
1834 /* test CPU specific stuff */
1835 if (ehdr.e_ident[5] != ELFDATA2LSB ||
1836 ehdr.e_machine != EM_TCC_TARGET) {
1837 fail1:
1838 error_noabort("invalid object file");
1839 return -1;
1840 }
1841 /* read sections */
1842 shdr = load_data(fd, file_offset + ehdr.e_shoff,
1843 sizeof(Elf32_Shdr) * ehdr.e_shnum);
1844 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
1845
1846 /* load section names */
1847 sh = &shdr[ehdr.e_shstrndx];
1848 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
1849
1850 /* load symtab and strtab */
1851 old_to_new_syms = NULL;
1852 symtab = NULL;
1853 strtab = NULL;
1854 nb_syms = 0;
1855 for(i = 1; i < ehdr.e_shnum; i++) {
1856 sh = &shdr[i];
1857 if (sh->sh_type == SHT_SYMTAB) {
1858 if (symtab) {
1859 error_noabort("object must contain only one symtab");
1860 fail:
1861 ret = -1;
1862 goto the_end;
1863 }
1864 nb_syms = sh->sh_size / sizeof(Elf32_Sym);
1865 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
1866 sm_table[i].s = symtab_section;
1867
1868 /* now load strtab */
1869 sh = &shdr[sh->sh_link];
1870 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
1871 }
1872 }
1873
1874 /* now examine each section and try to merge its content with the
1875 ones in memory */
1876 for(i = 1; i < ehdr.e_shnum; i++) {
1877 /* no need to examine section name strtab */
1878 if (i == ehdr.e_shstrndx)
1879 continue;
1880 sh = &shdr[i];
1881 sh_name = strsec + sh->sh_name;
1882 /* ignore sections types we do not handle */
1883 if (sh->sh_type != SHT_PROGBITS &&
1884 sh->sh_type != SHT_REL &&
1885 #ifdef TCC_ARM_EABI
1886 sh->sh_type != SHT_ARM_EXIDX &&
1887 #endif
1888 sh->sh_type != SHT_NOBITS)
1889 continue;
1890 if (sh->sh_addralign < 1)
1891 sh->sh_addralign = 1;
1892 /* find corresponding section, if any */
1893 for(j = 1; j < s1->nb_sections;j++) {
1894 s = s1->sections[j];
1895 if (!strcmp(s->name, sh_name)) {
1896 if (!strncmp(sh_name, ".gnu.linkonce",
1897 sizeof(".gnu.linkonce") - 1)) {
1898 /* if a 'linkonce' section is already present, we
1899 do not add it again. It is a little tricky as
1900 symbols can still be defined in
1901 it. */
1902 sm_table[i].link_once = 1;
1903 goto next;
1904 } else {
1905 goto found;
1906 }
1907 }
1908 }
1909 /* not found: create new section */
1910 s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags);
1911 /* take as much info as possible from the section. sh_link and
1912 sh_info will be updated later */
1913 s->sh_addralign = sh->sh_addralign;
1914 s->sh_entsize = sh->sh_entsize;
1915 sm_table[i].new_section = 1;
1916 found:
1917 if (sh->sh_type != s->sh_type) {
1918 error_noabort("invalid section type");
1919 goto fail;
1920 }
1921
1922 /* align start of section */
1923 offset = s->data_offset;
1924 size = sh->sh_addralign - 1;
1925 offset = (offset + size) & ~size;
1926 if (sh->sh_addralign > s->sh_addralign)
1927 s->sh_addralign = sh->sh_addralign;
1928 s->data_offset = offset;
1929 sm_table[i].offset = offset;
1930 sm_table[i].s = s;
1931 /* concatenate sections */
1932 size = sh->sh_size;
1933 if (sh->sh_type != SHT_NOBITS) {
1934 unsigned char *ptr;
1935 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
1936 ptr = section_ptr_add(s, size);
1937 read(fd, ptr, size);
1938 } else {
1939 s->data_offset += size;
1940 }
1941 next: ;
1942 }
1943
1944 /* second short pass to update sh_link and sh_info fields of new
1945 sections */
1946 for(i = 1; i < ehdr.e_shnum; i++) {
1947 s = sm_table[i].s;
1948 if (!s || !sm_table[i].new_section)
1949 continue;
1950 sh = &shdr[i];
1951 if (sh->sh_link > 0)
1952 s->link = sm_table[sh->sh_link].s;
1953 if (sh->sh_type == SHT_REL) {
1954 s->sh_info = sm_table[sh->sh_info].s->sh_num;
1955 /* update backward link */
1956 s1->sections[s->sh_info]->reloc = s;
1957 }
1958 }
1959 sm = sm_table;
1960
1961 /* resolve symbols */
1962 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
1963
1964 sym = symtab + 1;
1965 for(i = 1; i < nb_syms; i++, sym++) {
1966 if (sym->st_shndx != SHN_UNDEF &&
1967 sym->st_shndx < SHN_LORESERVE) {
1968 sm = &sm_table[sym->st_shndx];
1969 if (sm->link_once) {
1970 /* if a symbol is in a link once section, we use the
1971 already defined symbol. It is very important to get
1972 correct relocations */
1973 if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
1974 name = strtab + sym->st_name;
1975 sym_index = find_elf_sym(symtab_section, name);
1976 if (sym_index)
1977 old_to_new_syms[i] = sym_index;
1978 }
1979 continue;
1980 }
1981 /* if no corresponding section added, no need to add symbol */
1982 if (!sm->s)
1983 continue;
1984 /* convert section number */
1985 sym->st_shndx = sm->s->sh_num;
1986 /* offset value */
1987 sym->st_value += sm->offset;
1988 }
1989 /* add symbol */
1990 name = strtab + sym->st_name;
1991 sym_index = add_elf_sym(symtab_section, sym->st_value, sym->st_size,
1992 sym->st_info, sym->st_other,
1993 sym->st_shndx, name);
1994 old_to_new_syms[i] = sym_index;
1995 }
1996
1997 /* third pass to patch relocation entries */
1998 for(i = 1; i < ehdr.e_shnum; i++) {
1999 s = sm_table[i].s;
2000 if (!s)
2001 continue;
2002 sh = &shdr[i];
2003 offset = sm_table[i].offset;
2004 switch(s->sh_type) {
2005 case SHT_REL:
2006 /* take relocation offset information */
2007 offseti = sm_table[sh->sh_info].offset;
2008 rel_end = (Elf32_Rel *)(s->data + s->data_offset);
2009 for(rel = (Elf32_Rel *)(s->data + offset);
2010 rel < rel_end;
2011 rel++) {
2012 int type;
2013 unsigned sym_index;
2014 /* convert symbol index */
2015 type = ELF32_R_TYPE(rel->r_info);
2016 sym_index = ELF32_R_SYM(rel->r_info);
2017 /* NOTE: only one symtab assumed */
2018 if (sym_index >= nb_syms)
2019 goto invalid_reloc;
2020 sym_index = old_to_new_syms[sym_index];
2021 /* ignore link_once in rel section. */
2022 if (!sym_index && !sm->link_once) {
2023 invalid_reloc:
2024 error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2025 i, strsec + sh->sh_name, rel->r_offset);
2026 goto fail;
2027 }
2028 rel->r_info = ELF32_R_INFO(sym_index, type);
2029 /* offset the relocation offset */
2030 rel->r_offset += offseti;
2031 }
2032 break;
2033 default:
2034 break;
2035 }
2036 }
2037
2038 ret = 0;
2039 the_end:
2040 tcc_free(symtab);
2041 tcc_free(strtab);
2042 tcc_free(old_to_new_syms);
2043 tcc_free(sm_table);
2044 tcc_free(strsec);
2045 tcc_free(shdr);
2046 return ret;
2047 }
2048
2049 #define ARMAG "!<arch>\012" /* For COFF and a.out archives */
2050
2051 typedef struct ArchiveHeader {
2052 char ar_name[16]; /* name of this member */
2053 char ar_date[12]; /* file mtime */
2054 char ar_uid[6]; /* owner uid; printed as decimal */
2055 char ar_gid[6]; /* owner gid; printed as decimal */
2056 char ar_mode[8]; /* file mode, printed as octal */
2057 char ar_size[10]; /* file size, printed as decimal */
2058 char ar_fmag[2]; /* should contain ARFMAG */
2059 } ArchiveHeader;
2060
2061 static int get_be32(const uint8_t *b)
2062 {
2063 return b[3] | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
2064 }
2065
2066 /* load only the objects which resolve undefined symbols */
2067 static int tcc_load_alacarte(TCCState *s1, int fd, int size)
2068 {
2069 int i, bound, nsyms, sym_index, off, ret;
2070 uint8_t *data;
2071 const char *ar_names, *p;
2072 const uint8_t *ar_index;
2073 Elf32_Sym *sym;
2074
2075 data = tcc_malloc(size);
2076 if (read(fd, data, size) != size)
2077 goto fail;
2078 nsyms = get_be32(data);
2079 ar_index = data + 4;
2080 ar_names = ar_index + nsyms * 4;
2081
2082 do {
2083 bound = 0;
2084 for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2085 sym_index = find_elf_sym(symtab_section, p);
2086 if(sym_index) {
2087 sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
2088 if(sym->st_shndx == SHN_UNDEF) {
2089 off = get_be32(ar_index + i * 4) + sizeof(ArchiveHeader);
2090 #if 0
2091 printf("%5d\t%s\t%08x\n", i, p, sym->st_shndx);
2092 #endif
2093 ++bound;
2094 lseek(fd, off, SEEK_SET);
2095 if(tcc_load_object_file(s1, fd, off) < 0) {
2096 fail:
2097 ret = -1;
2098 goto the_end;
2099 }
2100 }
2101 }
2102 }
2103 } while(bound);
2104 ret = 0;
2105 the_end:
2106 tcc_free(data);
2107 return ret;
2108 }
2109
2110 /* load a '.a' file */
2111 static int tcc_load_archive(TCCState *s1, int fd)
2112 {
2113 ArchiveHeader hdr;
2114 char ar_size[11];
2115 char ar_name[17];
2116 char magic[8];
2117 int size, len, i;
2118 unsigned long file_offset;
2119
2120 /* skip magic which was already checked */
2121 read(fd, magic, sizeof(magic));
2122
2123 for(;;) {
2124 len = read(fd, &hdr, sizeof(hdr));
2125 if (len == 0)
2126 break;
2127 if (len != sizeof(hdr)) {
2128 error_noabort("invalid archive");
2129 return -1;
2130 }
2131 memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
2132 ar_size[sizeof(hdr.ar_size)] = '\0';
2133 size = strtol(ar_size, NULL, 0);
2134 memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
2135 for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
2136 if (ar_name[i] != ' ')
2137 break;
2138 }
2139 ar_name[i + 1] = '\0';
2140 // printf("name='%s' size=%d %s\n", ar_name, size, ar_size);
2141 file_offset = lseek(fd, 0, SEEK_CUR);
2142 /* align to even */
2143 size = (size + 1) & ~1;
2144 if (!strcmp(ar_name, "/")) {
2145 /* coff symbol table : we handle it */
2146 if(s1->alacarte_link)
2147 return tcc_load_alacarte(s1, fd, size);
2148 } else if (!strcmp(ar_name, "//") ||
2149 !strcmp(ar_name, "__.SYMDEF") ||
2150 !strcmp(ar_name, "__.SYMDEF/") ||
2151 !strcmp(ar_name, "ARFILENAMES/")) {
2152 /* skip symbol table or archive names */
2153 } else {
2154 if (tcc_load_object_file(s1, fd, file_offset) < 0)
2155 return -1;
2156 }
2157 lseek(fd, file_offset + size, SEEK_SET);
2158 }
2159 return 0;
2160 }
2161
2162 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2163 is referenced by the user (so it should be added as DT_NEEDED in
2164 the generated ELF file) */
2165 static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
2166 {
2167 Elf32_Ehdr ehdr;
2168 Elf32_Shdr *shdr, *sh, *sh1;
2169 int i, j, nb_syms, nb_dts, sym_bind, ret;
2170 Elf32_Sym *sym, *dynsym;
2171 Elf32_Dyn *dt, *dynamic;
2172 unsigned char *dynstr;
2173 const char *name, *soname;
2174 DLLReference *dllref;
2175
2176 read(fd, &ehdr, sizeof(ehdr));
2177
2178 /* test CPU specific stuff */
2179 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2180 ehdr.e_machine != EM_TCC_TARGET) {
2181 error_noabort("bad architecture");
2182 return -1;
2183 }
2184
2185 /* read sections */
2186 shdr = load_data(fd, ehdr.e_shoff, sizeof(Elf32_Shdr) * ehdr.e_shnum);
2187
2188 /* load dynamic section and dynamic symbols */
2189 nb_syms = 0;
2190 nb_dts = 0;
2191 dynamic = NULL;
2192 dynsym = NULL; /* avoid warning */
2193 dynstr = NULL; /* avoid warning */
2194 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
2195 switch(sh->sh_type) {
2196 case SHT_DYNAMIC:
2197 nb_dts = sh->sh_size / sizeof(Elf32_Dyn);
2198 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
2199 break;
2200 case SHT_DYNSYM:
2201 nb_syms = sh->sh_size / sizeof(Elf32_Sym);
2202 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
2203 sh1 = &shdr[sh->sh_link];
2204 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
2205 break;
2206 default:
2207 break;
2208 }
2209 }
2210
2211 /* compute the real library name */
2212 soname = tcc_basename(filename);
2213
2214 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2215 if (dt->d_tag == DT_SONAME) {
2216 soname = dynstr + dt->d_un.d_val;
2217 }
2218 }
2219
2220 /* if the dll is already loaded, do not load it */
2221 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2222 dllref = s1->loaded_dlls[i];
2223 if (!strcmp(soname, dllref->name)) {
2224 /* but update level if needed */
2225 if (level < dllref->level)
2226 dllref->level = level;
2227 ret = 0;
2228 goto the_end;
2229 }
2230 }
2231
2232 // printf("loading dll '%s'\n", soname);
2233
2234 /* add the dll and its level */
2235 dllref = tcc_malloc(sizeof(DLLReference) + strlen(soname));
2236 dllref->level = level;
2237 strcpy(dllref->name, soname);
2238 dynarray_add((void ***)&s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
2239
2240 /* add dynamic symbols in dynsym_section */
2241 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
2242 sym_bind = ELF32_ST_BIND(sym->st_info);
2243 if (sym_bind == STB_LOCAL)
2244 continue;
2245 name = dynstr + sym->st_name;
2246 add_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
2247 sym->st_info, sym->st_other, sym->st_shndx, name);
2248 }
2249
2250 /* load all referenced DLLs */
2251 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2252 switch(dt->d_tag) {
2253 case DT_NEEDED:
2254 name = dynstr + dt->d_un.d_val;
2255 for(j = 0; j < s1->nb_loaded_dlls; j++) {
2256 dllref = s1->loaded_dlls[j];
2257 if (!strcmp(name, dllref->name))
2258 goto already_loaded;
2259 }
2260 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
2261 error_noabort("referenced dll '%s' not found", name);
2262 ret = -1;
2263 goto the_end;
2264 }
2265 already_loaded:
2266 break;
2267 }
2268 }
2269 ret = 0;
2270 the_end:
2271 tcc_free(dynstr);
2272 tcc_free(dynsym);
2273 tcc_free(dynamic);
2274 tcc_free(shdr);
2275 return ret;
2276 }
2277
2278 #define LD_TOK_NAME 256
2279 #define LD_TOK_EOF (-1)
2280
2281 /* return next ld script token */
2282 static int ld_next(TCCState *s1, char *name, int name_size)
2283 {
2284 int c;
2285 char *q;
2286
2287 redo:
2288 switch(ch) {
2289 case ' ':
2290 case '\t':
2291 case '\f':
2292 case '\v':
2293 case '\r':
2294 case '\n':
2295 inp();
2296 goto redo;
2297 case '/':
2298 minp();
2299 if (ch == '*') {
2300 file->buf_ptr = parse_comment(file->buf_ptr);
2301 ch = file->buf_ptr[0];
2302 goto redo;
2303 } else {
2304 q = name;
2305 *q++ = '/';
2306 goto parse_name;
2307 }
2308 break;
2309 /* case 'a' ... 'z': */
2310 case 'a':
2311 case 'b':
2312 case 'c':
2313 case 'd':
2314 case 'e':
2315 case 'f':
2316 case 'g':
2317 case 'h':
2318 case 'i':
2319 case 'j':
2320 case 'k':
2321 case 'l':
2322 case 'm':
2323 case 'n':
2324 case 'o':
2325 case 'p':
2326 case 'q':
2327 case 'r':
2328 case 's':
2329 case 't':
2330 case 'u':
2331 case 'v':
2332 case 'w':
2333 case 'x':
2334 case 'y':
2335 case 'z':
2336 /* case 'A' ... 'z': */
2337 case 'A':
2338 case 'B':
2339 case 'C':
2340 case 'D':
2341 case 'E':
2342 case 'F':
2343 case 'G':
2344 case 'H':
2345 case 'I':
2346 case 'J':
2347 case 'K':
2348 case 'L':
2349 case 'M':
2350 case 'N':
2351 case 'O':
2352 case 'P':
2353 case 'Q':
2354 case 'R':
2355 case 'S':
2356 case 'T':
2357 case 'U':
2358 case 'V':
2359 case 'W':
2360 case 'X':
2361 case 'Y':
2362 case 'Z':
2363 case '_':
2364 case '\\':
2365 case '.':
2366 case '$':
2367 case '~':
2368 q = name;
2369 parse_name:
2370 for(;;) {
2371 if (!((ch >= 'a' && ch <= 'z') ||
2372 (ch >= 'A' && ch <= 'Z') ||
2373 (ch >= '0' && ch <= '9') ||
2374 strchr("/.-_+=$:\\,~", ch)))
2375 break;
2376 if ((q - name) < name_size - 1) {
2377 *q++ = ch;
2378 }
2379 minp();
2380 }
2381 *q = '\0';
2382 c = LD_TOK_NAME;
2383 break;
2384 case CH_EOF:
2385 c = LD_TOK_EOF;
2386 break;
2387 default:
2388 c = ch;
2389 inp();
2390 break;
2391 }
2392 #if 0
2393 printf("tok=%c %d\n", c, c);
2394 if (c == LD_TOK_NAME)
2395 printf(" name=%s\n", name);
2396 #endif
2397 return c;
2398 }
2399
2400 static int ld_add_file_list(TCCState *s1, int as_needed)
2401 {
2402 char filename[1024];
2403 int t, ret;
2404
2405 t = ld_next(s1, filename, sizeof(filename));
2406 if (t != '(')
2407 expect("(");
2408 t = ld_next(s1, filename, sizeof(filename));
2409 for(;;) {
2410 if (t == LD_TOK_EOF) {
2411 error_noabort("unexpected end of file");
2412 return -1;
2413 } else if (t == ')') {
2414 break;
2415 } else if (t != LD_TOK_NAME) {
2416 error_noabort("filename expected");
2417 return -1;
2418 }
2419 if (!strcmp(filename, "AS_NEEDED")) {
2420 ret = ld_add_file_list(s1, 1);
2421 if (ret)
2422 return ret;
2423 } else {
2424 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2425 if (!as_needed)
2426 tcc_add_file(s1, filename);
2427 }
2428 t = ld_next(s1, filename, sizeof(filename));
2429 if (t == ',') {
2430 t = ld_next(s1, filename, sizeof(filename));
2431 }
2432 }
2433 return 0;
2434 }
2435
2436 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
2437 files */
2438 static int tcc_load_ldscript(TCCState *s1)
2439 {
2440 char cmd[64];
2441 char filename[1024];
2442 int t, ret;
2443
2444 ch = file->buf_ptr[0];
2445 ch = handle_eob();
2446 for(;;) {
2447 t = ld_next(s1, cmd, sizeof(cmd));
2448 if (t == LD_TOK_EOF)
2449 return 0;
2450 else if (t != LD_TOK_NAME)
2451 return -1;
2452 if (!strcmp(cmd, "INPUT") ||
2453 !strcmp(cmd, "GROUP")) {
2454 ret = ld_add_file_list(s1, 0);
2455 if (ret)
2456 return ret;
2457 } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
2458 !strcmp(cmd, "TARGET")) {
2459 /* ignore some commands */
2460 t = ld_next(s1, cmd, sizeof(cmd));
2461 if (t != '(')
2462 expect("(");
2463 for(;;) {
2464 t = ld_next(s1, filename, sizeof(filename));
2465 if (t == LD_TOK_EOF) {
2466 error_noabort("unexpected end of file");
2467 return -1;
2468 } else if (t == ')') {
2469 break;
2470 }
2471 }
2472 } else {
2473 return -1;
2474 }
2475 }
2476 return 0;
2477 }
kirr's tinycc tree