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