?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Re-enable "Use CString to concat linker options"
[tinycc/miki.git] / tccelf.c
blob0c764ba9729c1f9eee81b75619460ba5a760de3b
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 #include "tcc.h"
22
23 static int new_undef_sym = 0; /* Is there a new undefined sym since last new_undef_sym() */
24
25 ST_FUNC int put_elf_str(Section *s, const char *sym)
26 {
27 int offset, len;
28 char *ptr;
29
30 len = strlen(sym) + 1;
31 offset = s->data_offset;
32 ptr = section_ptr_add(s, len);
33 memcpy(ptr, sym, len);
34 return offset;
35 }
36
37 /* elf symbol hashing function */
38 static unsigned long elf_hash(const unsigned char *name)
39 {
40 unsigned long h = 0, g;
41
42 while (*name) {
43 h = (h << 4) + *name++;
44 g = h & 0xf0000000;
45 if (g)
46 h ^= g >> 24;
47 h &= ~g;
48 }
49 return h;
50 }
51
52 /* rebuild hash table of section s */
53 /* NOTE: we do factorize the hash table code to go faster */
54 static void rebuild_hash(Section *s, unsigned int nb_buckets)
55 {
56 ElfW(Sym) *sym;
57 int *ptr, *hash, nb_syms, sym_index, h;
58 char *strtab;
59
60 strtab = s->link->data;
61 nb_syms = s->data_offset / sizeof(ElfW(Sym));
62
63 s->hash->data_offset = 0;
64 ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int));
65 ptr[0] = nb_buckets;
66 ptr[1] = nb_syms;
67 ptr += 2;
68 hash = ptr;
69 memset(hash, 0, (nb_buckets + 1) * sizeof(int));
70 ptr += nb_buckets + 1;
71
72 sym = (ElfW(Sym) *)s->data + 1;
73 for(sym_index = 1; sym_index < nb_syms; sym_index++) {
74 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
75 h = elf_hash(strtab + sym->st_name) % nb_buckets;
76 *ptr = hash[h];
77 hash[h] = sym_index;
78 } else {
79 *ptr = 0;
80 }
81 ptr++;
82 sym++;
83 }
84 }
85
86 /* return the symbol number */
87 ST_FUNC int put_elf_sym(Section *s, uplong value, unsigned long size,
88 int info, int other, int shndx, const char *name)
89 {
90 int name_offset, sym_index;
91 int nbuckets, h;
92 ElfW(Sym) *sym;
93 Section *hs;
94
95 sym = section_ptr_add(s, sizeof(ElfW(Sym)));
96 if (name)
97 name_offset = put_elf_str(s->link, name);
98 else
99 name_offset = 0;
100 /* XXX: endianness */
101 sym->st_name = name_offset;
102 sym->st_value = value;
103 sym->st_size = size;
104 sym->st_info = info;
105 sym->st_other = other;
106 sym->st_shndx = shndx;
107 sym_index = sym - (ElfW(Sym) *)s->data;
108 hs = s->hash;
109 if (hs) {
110 int *ptr, *base;
111 ptr = section_ptr_add(hs, sizeof(int));
112 base = (int *)hs->data;
113 /* only add global or weak symbols */
114 if (ELFW(ST_BIND)(info) != STB_LOCAL) {
115 /* add another hashing entry */
116 nbuckets = base[0];
117 h = elf_hash(name) % nbuckets;
118 *ptr = base[2 + h];
119 base[2 + h] = sym_index;
120 base[1]++;
121 /* we resize the hash table */
122 hs->nb_hashed_syms++;
123 if (hs->nb_hashed_syms > 2 * nbuckets) {
124 rebuild_hash(s, 2 * nbuckets);
125 }
126 } else {
127 *ptr = 0;
128 base[1]++;
129 }
130 }
131 return sym_index;
132 }
133
134 /* find global ELF symbol 'name' and return its index. Return 0 if not
135 found. */
136 ST_FUNC int find_elf_sym(Section *s, const char *name)
137 {
138 ElfW(Sym) *sym;
139 Section *hs;
140 int nbuckets, sym_index, h;
141 const char *name1;
142
143 hs = s->hash;
144 if (!hs)
145 return 0;
146 nbuckets = ((int *)hs->data)[0];
147 h = elf_hash(name) % nbuckets;
148 sym_index = ((int *)hs->data)[2 + h];
149 while (sym_index != 0) {
150 sym = &((ElfW(Sym) *)s->data)[sym_index];
151 name1 = s->link->data + sym->st_name;
152 if (!strcmp(name, name1))
153 return sym_index;
154 sym_index = ((int *)hs->data)[2 + nbuckets + sym_index];
155 }
156 return 0;
157 }
158
159 /* return elf symbol value, signal error if 'err' is nonzero */
160 static void *get_elf_sym_addr(TCCState *s, const char *name, int err)
161 {
162 int sym_index;
163 ElfW(Sym) *sym;
164
165 sym_index = find_elf_sym(symtab_section, name);
166 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
167 if (!sym_index || sym->st_shndx == SHN_UNDEF) {
168 if (err)
169 tcc_error("%s not defined", name);
170 return NULL;
171 }
172 return (void*)(uplong)sym->st_value;
173 }
174
175 /* return elf symbol value */
176 LIBTCCAPI void *tcc_get_symbol(TCCState *s, const char *name)
177 {
178 return get_elf_sym_addr(s, name, 0);
179 }
180
181 /* return elf symbol value or error */
182 ST_FUNC void *tcc_get_symbol_err(TCCState *s, const char *name)
183 {
184 return get_elf_sym_addr(s, name, 1);
185 }
186
187 /* add an elf symbol : check if it is already defined and patch
188 it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
189 ST_FUNC int add_elf_sym(Section *s, uplong value, unsigned long size,
190 int info, int other, int sh_num, const char *name)
191 {
192 ElfW(Sym) *esym;
193 int sym_bind, sym_index, sym_type, esym_bind;
194 unsigned char sym_vis, esym_vis, new_vis;
195
196 sym_bind = ELFW(ST_BIND)(info);
197 sym_type = ELFW(ST_TYPE)(info);
198 sym_vis = ELFW(ST_VISIBILITY)(other);
199
200 if (sym_bind != STB_LOCAL) {
201 /* we search global or weak symbols */
202 sym_index = find_elf_sym(s, name);
203 if (!sym_index)
204 goto do_def;
205 esym = &((ElfW(Sym) *)s->data)[sym_index];
206 if (esym->st_shndx != SHN_UNDEF) {
207 esym_bind = ELFW(ST_BIND)(esym->st_info);
208 /* propagate the most constraining visibility */
209 /* STV_DEFAULT(0)<STV_PROTECTED(3)<STV_HIDDEN(2)<STV_INTERNAL(1) */
210 esym_vis = ELFW(ST_VISIBILITY)(esym->st_other);
211 if (esym_vis == STV_DEFAULT) {
212 new_vis = sym_vis;
213 } else if (sym_vis == STV_DEFAULT) {
214 new_vis = esym_vis;
215 } else {
216 new_vis = (esym_vis < sym_vis) ? esym_vis : sym_vis;
217 }
218 esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
219 | new_vis;
220 other = esym->st_other; /* in case we have to patch esym */
221 if (sh_num == SHN_UNDEF) {
222 /* ignore adding of undefined symbol if the
223 corresponding symbol is already defined */
224 } else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) {
225 /* global overrides weak, so patch */
226 goto do_patch;
227 } else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) {
228 /* weak is ignored if already global */
229 } else if (sym_bind == STB_WEAK && esym_bind == STB_WEAK) {
230 /* keep first-found weak definition, ignore subsequents */
231 } else if (sym_vis == STV_HIDDEN || sym_vis == STV_INTERNAL) {
232 /* ignore hidden symbols after */
233 } else if (esym->st_shndx == SHN_COMMON
234 && (sh_num < SHN_LORESERVE || sh_num == SHN_COMMON)) {
235 /* gr: Happens with 'tcc ... -static tcctest.c' on e.g. Ubuntu 6.01
236 No idea if this is the correct solution ... */
237 goto do_patch;
238 } else if (s == tcc_state->dynsymtab_section) {
239 /* we accept that two DLL define the same symbol */
240 } else {
241 #if 1
242 printf("new_bind=%x new_shndx=%x new_vis=%x old_bind=%x old_shndx=%x old_vis=%x\n",
243 sym_bind, sh_num, new_vis, esym_bind, esym->st_shndx, esym_vis);
244 #endif
245 tcc_error_noabort("'%s' defined twice", name);
246 }
247 } else {
248 do_patch:
249 esym->st_info = ELFW(ST_INFO)(sym_bind, sym_type);
250 esym->st_shndx = sh_num;
251 new_undef_sym = 1;
252 esym->st_value = value;
253 esym->st_size = size;
254 esym->st_other = other;
255 }
256 } else {
257 do_def:
258 sym_index = put_elf_sym(s, value, size,
259 ELFW(ST_INFO)(sym_bind, sym_type), other,
260 sh_num, name);
261 }
262 return sym_index;
263 }
264
265 /* put relocation */
266 ST_FUNC void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
267 int type, int symbol)
268 {
269 char buf[256];
270 Section *sr;
271 ElfW_Rel *rel;
272
273 sr = s->reloc;
274 if (!sr) {
275 /* if no relocation section, create it */
276 snprintf(buf, sizeof(buf), REL_SECTION_FMT, s->name);
277 /* if the symtab is allocated, then we consider the relocation
278 are also */
279 sr = new_section(tcc_state, buf, SHT_RELX, symtab->sh_flags);
280 sr->sh_entsize = sizeof(ElfW_Rel);
281 sr->link = symtab;
282 sr->sh_info = s->sh_num;
283 s->reloc = sr;
284 }
285 rel = section_ptr_add(sr, sizeof(ElfW_Rel));
286 rel->r_offset = offset;
287 rel->r_info = ELFW(R_INFO)(symbol, type);
288 #ifdef TCC_TARGET_X86_64
289 rel->r_addend = 0;
290 #endif
291 }
292
293 /* put stab debug information */
294
295 ST_FUNC void put_stabs(const char *str, int type, int other, int desc,
296 unsigned long value)
297 {
298 Stab_Sym *sym;
299
300 sym = section_ptr_add(stab_section, sizeof(Stab_Sym));
301 if (str) {
302 sym->n_strx = put_elf_str(stabstr_section, str);
303 } else {
304 sym->n_strx = 0;
305 }
306 sym->n_type = type;
307 sym->n_other = other;
308 sym->n_desc = desc;
309 sym->n_value = value;
310 }
311
312 ST_FUNC void put_stabs_r(const char *str, int type, int other, int desc,
313 unsigned long value, Section *sec, int sym_index)
314 {
315 put_stabs(str, type, other, desc, value);
316 put_elf_reloc(symtab_section, stab_section,
317 stab_section->data_offset - sizeof(unsigned int),
318 R_DATA_32, sym_index);
319 }
320
321 ST_FUNC void put_stabn(int type, int other, int desc, int value)
322 {
323 put_stabs(NULL, type, other, desc, value);
324 }
325
326 ST_FUNC void put_stabd(int type, int other, int desc)
327 {
328 put_stabs(NULL, type, other, desc, 0);
329 }
330
331 /* In an ELF file symbol table, the local symbols must appear below
332 the global and weak ones. Since TCC cannot sort it while generating
333 the code, we must do it after. All the relocation tables are also
334 modified to take into account the symbol table sorting */
335 static void sort_syms(TCCState *s1, Section *s)
336 {
337 int *old_to_new_syms;
338 ElfW(Sym) *new_syms;
339 int nb_syms, i;
340 ElfW(Sym) *p, *q;
341 ElfW_Rel *rel, *rel_end;
342 Section *sr;
343 int type, sym_index;
344
345 nb_syms = s->data_offset / sizeof(ElfW(Sym));
346 new_syms = tcc_malloc(nb_syms * sizeof(ElfW(Sym)));
347 old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
348
349 /* first pass for local symbols */
350 p = (ElfW(Sym) *)s->data;
351 q = new_syms;
352 for(i = 0; i < nb_syms; i++) {
353 if (ELFW(ST_BIND)(p->st_info) == STB_LOCAL) {
354 old_to_new_syms[i] = q - new_syms;
355 *q++ = *p;
356 }
357 p++;
358 }
359 /* save the number of local symbols in section header */
360 s->sh_info = q - new_syms;
361
362 /* then second pass for non local symbols */
363 p = (ElfW(Sym) *)s->data;
364 for(i = 0; i < nb_syms; i++) {
365 if (ELFW(ST_BIND)(p->st_info) != STB_LOCAL) {
366 old_to_new_syms[i] = q - new_syms;
367 *q++ = *p;
368 }
369 p++;
370 }
371
372 /* we copy the new symbols to the old */
373 memcpy(s->data, new_syms, nb_syms * sizeof(ElfW(Sym)));
374 tcc_free(new_syms);
375
376 /* now we modify all the relocations */
377 for(i = 1; i < s1->nb_sections; i++) {
378 sr = s1->sections[i];
379 if (sr->sh_type == SHT_RELX && sr->link == s) {
380 rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
381 for(rel = (ElfW_Rel *)sr->data;
382 rel < rel_end;
383 rel++) {
384 sym_index = ELFW(R_SYM)(rel->r_info);
385 type = ELFW(R_TYPE)(rel->r_info);
386 sym_index = old_to_new_syms[sym_index];
387 rel->r_info = ELFW(R_INFO)(sym_index, type);
388 }
389 }
390 }
391
392 tcc_free(old_to_new_syms);
393 }
394
395 /* relocate common symbols in the .bss section */
396 ST_FUNC void relocate_common_syms(void)
397 {
398 ElfW(Sym) *sym, *sym_end;
399 unsigned long offset, align;
400
401 sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
402 for(sym = (ElfW(Sym) *)symtab_section->data + 1;
403 sym < sym_end;
404 sym++) {
405 if (sym->st_shndx == SHN_COMMON) {
406 /* align symbol */
407 align = sym->st_value;
408 offset = bss_section->data_offset;
409 offset = (offset + align - 1) & -align;
410 sym->st_value = offset;
411 sym->st_shndx = bss_section->sh_num;
412 offset += sym->st_size;
413 bss_section->data_offset = offset;
414 }
415 }
416 }
417
418 /* relocate symbol table, resolve undefined symbols if do_resolve is
419 true and output error if undefined symbol. */
420 ST_FUNC void relocate_syms(TCCState *s1, int do_resolve)
421 {
422 ElfW(Sym) *sym, *esym, *sym_end;
423 int sym_bind, sh_num, sym_index;
424 const char *name;
425
426 sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
427 for(sym = (ElfW(Sym) *)symtab_section->data + 1;
428 sym < sym_end;
429 sym++) {
430 sh_num = sym->st_shndx;
431 if (sh_num == SHN_UNDEF) {
432 name = strtab_section->data + sym->st_name;
433 if (do_resolve) {
434 #if !defined TCC_TARGET_PE || !defined _WIN32
435 void *addr;
436 name = symtab_section->link->data + sym->st_name;
437 addr = resolve_sym(s1, name);
438 if (addr) {
439 sym->st_value = (uplong)addr;
440 goto found;
441 }
442 #endif
443 } else if (s1->dynsym) {
444 /* if dynamic symbol exist, then use it */
445 sym_index = find_elf_sym(s1->dynsym, name);
446 if (sym_index) {
447 esym = &((ElfW(Sym) *)s1->dynsym->data)[sym_index];
448 sym->st_value = esym->st_value;
449 goto found;
450 }
451 }
452 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
453 it */
454 if (!strcmp(name, "_fp_hw"))
455 goto found;
456 /* only weak symbols are accepted to be undefined. Their
457 value is zero */
458 sym_bind = ELFW(ST_BIND)(sym->st_info);
459 if (sym_bind == STB_WEAK) {
460 sym->st_value = 0;
461 } else {
462 tcc_error_noabort("undefined symbol '%s'", name);
463 }
464 } else if (sh_num < SHN_LORESERVE) {
465 /* add section base */
466 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
467 }
468 found: ;
469 }
470 }
471
472 #ifndef TCC_TARGET_PE
473 #ifdef TCC_TARGET_X86_64
474 #define JMP_TABLE_ENTRY_SIZE 14
475 static uplong add_jmp_table(TCCState *s1, uplong val)
476 {
477 char *p = s1->runtime_plt_and_got + s1->runtime_plt_and_got_offset;
478 s1->runtime_plt_and_got_offset += JMP_TABLE_ENTRY_SIZE;
479 /* jmp *0x0(%rip) */
480 p[0] = 0xff;
481 p[1] = 0x25;
482 *(int *)(p + 2) = 0;
483 *(uplong *)(p + 6) = val;
484 return (uplong)p;
485 }
486
487 static uplong add_got_table(TCCState *s1, uplong val)
488 {
489 uplong *p = (uplong *)(s1->runtime_plt_and_got + s1->runtime_plt_and_got_offset);
490 s1->runtime_plt_and_got_offset += sizeof(uplong);
491 *p = val;
492 return (uplong)p;
493 }
494 #elif defined TCC_TARGET_ARM
495 #define JMP_TABLE_ENTRY_SIZE 8
496 static uplong add_jmp_table(TCCState *s1, int val)
497 {
498 uint32_t *p = (uint32_t *)(s1->runtime_plt_and_got + s1->runtime_plt_and_got_offset);
499 s1->runtime_plt_and_got_offset += JMP_TABLE_ENTRY_SIZE;
500 /* ldr pc, [pc, #-4] */
501 p[0] = 0xE51FF004;
502 p[1] = val;
503 return (uplong)p;
504 }
505 #endif
506 #endif
507
508 /* relocate a given section (CPU dependent) */
509 ST_FUNC void relocate_section(TCCState *s1, Section *s)
510 {
511 Section *sr;
512 ElfW_Rel *rel, *rel_end, *qrel;
513 ElfW(Sym) *sym;
514 int type, sym_index;
515 unsigned char *ptr;
516 uplong val, addr;
517 #if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
518 int esym_index;
519 #endif
520
521 sr = s->reloc;
522 rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
523 qrel = (ElfW_Rel *)sr->data;
524 for(rel = qrel;
525 rel < rel_end;
526 rel++) {
527 ptr = s->data + rel->r_offset;
528
529 sym_index = ELFW(R_SYM)(rel->r_info);
530 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
531 val = sym->st_value;
532 #ifdef TCC_TARGET_X86_64
533 val += rel->r_addend;
534 #endif
535 type = ELFW(R_TYPE)(rel->r_info);
536 addr = s->sh_addr + rel->r_offset;
537
538 /* CPU specific */
539 switch(type) {
540 #if defined(TCC_TARGET_I386)
541 case R_386_32:
542 if (s1->output_type == TCC_OUTPUT_DLL) {
543 esym_index = s1->symtab_to_dynsym[sym_index];
544 qrel->r_offset = rel->r_offset;
545 if (esym_index) {
546 qrel->r_info = ELFW(R_INFO)(esym_index, R_386_32);
547 qrel++;
548 break;
549 } else {
550 qrel->r_info = ELFW(R_INFO)(0, R_386_RELATIVE);
551 qrel++;
552 }
553 }
554 *(int *)ptr += val;
555 break;
556 case R_386_PC32:
557 if (s1->output_type == TCC_OUTPUT_DLL) {
558 /* DLL relocation */
559 esym_index = s1->symtab_to_dynsym[sym_index];
560 if (esym_index) {
561 qrel->r_offset = rel->r_offset;
562 qrel->r_info = ELFW(R_INFO)(esym_index, R_386_PC32);
563 qrel++;
564 break;
565 }
566 }
567 *(int *)ptr += val - addr;
568 break;
569 case R_386_PLT32:
570 *(int *)ptr += val - addr;
571 break;
572 case R_386_GLOB_DAT:
573 case R_386_JMP_SLOT:
574 *(int *)ptr = val;
575 break;
576 case R_386_GOTPC:
577 *(int *)ptr += s1->got->sh_addr - addr;
578 break;
579 case R_386_GOTOFF:
580 *(int *)ptr += val - s1->got->sh_addr;
581 break;
582 case R_386_GOT32:
583 /* we load the got offset */
584 *(int *)ptr += s1->got_offsets[sym_index];
585 break;
586 case R_386_16:
587 if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY) {
588 output_file:
589 tcc_error("can only produce 16-bit binary files");
590 }
591 *(short *)ptr += val;
592 break;
593 case R_386_PC16:
594 if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY)
595 goto output_file;
596 *(short *)ptr += val - addr;
597 break;
598 #elif defined(TCC_TARGET_ARM)
599 case R_ARM_PC24:
600 case R_ARM_CALL:
601 case R_ARM_JUMP24:
602 case R_ARM_PLT32:
603 {
604 int x;
605 x = (*(int *)ptr)&0xffffff;
606 (*(int *)ptr) &= 0xff000000;
607 if (x & 0x800000)
608 x -= 0x1000000;
609 x *= 4;
610 x += val - addr;
611 #ifndef TCC_TARGET_PE
612 if((x & 3) != 0 || x >= 0x4000000 || x < -0x4000000)
613 if (s1->output_type == TCC_OUTPUT_MEMORY)
614 x += add_jmp_table(s1, val) - val; /* add veneer */
615 #endif
616 if((x & 3) != 0 || x >= 0x4000000 || x < -0x4000000)
617 tcc_error("can't relocate value at %x",addr);
618 x >>= 2;
619 x &= 0xffffff;
620 (*(int *)ptr) |= x;
621 }
622 break;
623 case R_ARM_PREL31:
624 {
625 int x;
626 x = (*(int *)ptr) & 0x7fffffff;
627 (*(int *)ptr) &= 0x80000000;
628 x = (x * 2) / 2;
629 x += val - addr;
630 if((x^(x>>1))&0x40000000)
631 tcc_error("can't relocate value at %x",addr);
632 (*(int *)ptr) |= x & 0x7fffffff;
633 }
634 case R_ARM_ABS32:
635 *(int *)ptr += val;
636 break;
637 case R_ARM_BASE_PREL:
638 *(int *)ptr += s1->got->sh_addr - addr;
639 break;
640 case R_ARM_GOTOFF32:
641 *(int *)ptr += val - s1->got->sh_addr;
642 break;
643 case R_ARM_GOT_BREL:
644 /* we load the got offset */
645 *(int *)ptr += s1->got_offsets[sym_index];
646 break;
647 case R_ARM_COPY:
648 break;
649 case R_ARM_V4BX:
650 /* trade Thumb support for ARMv4 support */
651 if ((0x0ffffff0 & *(int*)ptr) == 0x012FFF10)
652 *(int*)ptr ^= 0xE12FFF10 ^ 0xE1A0F000; /* BX Rm -> MOV PC, Rm */
653 break;
654 default:
655 fprintf(stderr,"FIXME: handle reloc type %x at %x [%.8x] to %x\n",
656 type, (unsigned)addr, (unsigned)(uplong)ptr, (unsigned)val);
657 break;
658 #elif defined(TCC_TARGET_C67)
659 case R_C60_32:
660 *(int *)ptr += val;
661 break;
662 case R_C60LO16:
663 {
664 uint32_t orig;
665
666 /* put the low 16 bits of the absolute address */
667 // add to what is already there
668
669 orig = ((*(int *)(ptr )) >> 7) & 0xffff;
670 orig |= (((*(int *)(ptr+4)) >> 7) & 0xffff) << 16;
671
672 //patch both at once - assumes always in pairs Low - High
673
674 *(int *) ptr = (*(int *) ptr & (~(0xffff << 7)) ) | (((val+orig) & 0xffff) << 7);
675 *(int *)(ptr+4) = (*(int *)(ptr+4) & (~(0xffff << 7)) ) | ((((val+orig)>>16) & 0xffff) << 7);
676 }
677 break;
678 case R_C60HI16:
679 break;
680 default:
681 fprintf(stderr,"FIXME: handle reloc type %x at %x [%.8x] to %x\n",
682 type, (unsigned)addr, (unsigned)(uplong)ptr, (unsigned)val);
683 break;
684 #elif defined(TCC_TARGET_X86_64)
685 case R_X86_64_64:
686 if (s1->output_type == TCC_OUTPUT_DLL) {
687 qrel->r_info = ELFW(R_INFO)(0, R_X86_64_RELATIVE);
688 qrel->r_addend = *(long long *)ptr + val;
689 qrel++;
690 }
691 *(long long *)ptr += val;
692 break;
693 case R_X86_64_32:
694 case R_X86_64_32S:
695 if (s1->output_type == TCC_OUTPUT_DLL) {
696 /* XXX: this logic may depend on TCC's codegen
697 now TCC uses R_X86_64_32 even for a 64bit pointer */
698 qrel->r_info = ELFW(R_INFO)(0, R_X86_64_RELATIVE);
699 qrel->r_addend = *(int *)ptr + val;
700 qrel++;
701 }
702 *(int *)ptr += val;
703 break;
704
705 case R_X86_64_PC32:
706 if (s1->output_type == TCC_OUTPUT_DLL) {
707 /* DLL relocation */
708 esym_index = s1->symtab_to_dynsym[sym_index];
709 if (esym_index) {
710 qrel->r_offset = rel->r_offset;
711 qrel->r_info = ELFW(R_INFO)(esym_index, R_X86_64_PC32);
712 qrel->r_addend = *(int *)ptr;
713 qrel++;
714 break;
715 }
716 }
717 /* fall through */
718 case R_X86_64_PLT32: {
719 long long diff;
720 diff = (long long)val - addr;
721 if (diff <= -2147483647 || diff > 2147483647) {
722 #ifndef TCC_TARGET_PE
723 /* XXX: naive support for over 32bit jump */
724 if (s1->output_type == TCC_OUTPUT_MEMORY) {
725 val = (add_jmp_table(s1, val - rel->r_addend) +
726 rel->r_addend);
727 diff = val - addr;
728 }
729 #endif
730 if (diff <= -2147483647 || diff > 2147483647) {
731 tcc_error("internal error: relocation failed");
732 }
733 }
734 *(int *)ptr += diff;
735 }
736 break;
737 case R_X86_64_GLOB_DAT:
738 case R_X86_64_JUMP_SLOT:
739 /* They don't need addend */
740 *(int *)ptr = val - rel->r_addend;
741 break;
742 case R_X86_64_GOTPCREL:
743 #ifndef TCC_TARGET_PE
744 if (s1->output_type == TCC_OUTPUT_MEMORY) {
745 val = add_got_table(s1, val - rel->r_addend) + rel->r_addend;
746 *(int *)ptr += val - addr;
747 break;
748 }
749 #endif
750 *(int *)ptr += (s1->got->sh_addr - addr +
751 s1->got_offsets[sym_index] - 4);
752 break;
753 case R_X86_64_GOTTPOFF:
754 *(int *)ptr += val - s1->got->sh_addr;
755 break;
756 case R_X86_64_GOT32:
757 /* we load the got offset */
758 *(int *)ptr += s1->got_offsets[sym_index];
759 break;
760 #else
761 #error unsupported processor
762 #endif
763 }
764 }
765 /* if the relocation is allocated, we change its symbol table */
766 if (sr->sh_flags & SHF_ALLOC)
767 sr->link = s1->dynsym;
768 }
769
770 /* relocate relocation table in 'sr' */
771 static void relocate_rel(TCCState *s1, Section *sr)
772 {
773 Section *s;
774 ElfW_Rel *rel, *rel_end;
775
776 s = s1->sections[sr->sh_info];
777 rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
778 for(rel = (ElfW_Rel *)sr->data;
779 rel < rel_end;
780 rel++) {
781 rel->r_offset += s->sh_addr;
782 }
783 }
784
785 /* count the number of dynamic relocations so that we can reserve
786 their space */
787 static int prepare_dynamic_rel(TCCState *s1, Section *sr)
788 {
789 ElfW_Rel *rel, *rel_end;
790 int sym_index, esym_index, type, count;
791
792 count = 0;
793 rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
794 for(rel = (ElfW_Rel *)sr->data; rel < rel_end; rel++) {
795 sym_index = ELFW(R_SYM)(rel->r_info);
796 type = ELFW(R_TYPE)(rel->r_info);
797 switch(type) {
798 #if defined(TCC_TARGET_I386)
799 case R_386_32:
800 #elif defined(TCC_TARGET_X86_64)
801 case R_X86_64_32:
802 case R_X86_64_32S:
803 case R_X86_64_64:
804 #endif
805 count++;
806 break;
807 #if defined(TCC_TARGET_I386)
808 case R_386_PC32:
809 #elif defined(TCC_TARGET_X86_64)
810 case R_X86_64_PC32:
811 #endif
812 esym_index = s1->symtab_to_dynsym[sym_index];
813 if (esym_index)
814 count++;
815 break;
816 default:
817 break;
818 }
819 }
820 if (count) {
821 /* allocate the section */
822 sr->sh_flags |= SHF_ALLOC;
823 sr->sh_size = count * sizeof(ElfW_Rel);
824 }
825 return count;
826 }
827
828 static void put_got_offset(TCCState *s1, int index, unsigned long val)
829 {
830 int n;
831 unsigned long *tab;
832
833 if (index >= s1->nb_got_offsets) {
834 /* find immediately bigger power of 2 and reallocate array */
835 n = 1;
836 while (index >= n)
837 n *= 2;
838 tab = tcc_realloc(s1->got_offsets, n * sizeof(unsigned long));
839 if (!tab)
840 tcc_error("memory full");
841 s1->got_offsets = tab;
842 memset(s1->got_offsets + s1->nb_got_offsets, 0,
843 (n - s1->nb_got_offsets) * sizeof(unsigned long));
844 s1->nb_got_offsets = n;
845 }
846 s1->got_offsets[index] = val;
847 }
848
849 /* XXX: suppress that */
850 static void put32(unsigned char *p, uint32_t val)
851 {
852 p[0] = val;
853 p[1] = val >> 8;
854 p[2] = val >> 16;
855 p[3] = val >> 24;
856 }
857
858 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_ARM) || \
859 defined(TCC_TARGET_X86_64)
860 static uint32_t get32(unsigned char *p)
861 {
862 return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
863 }
864 #endif
865
866 static void build_got(TCCState *s1)
867 {
868 unsigned char *ptr;
869
870 /* if no got, then create it */
871 s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
872 s1->got->sh_entsize = 4;
873 add_elf_sym(symtab_section, 0, 4, ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
874 0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
875 ptr = section_ptr_add(s1->got, 3 * PTR_SIZE);
876 #if PTR_SIZE == 4
877 /* keep space for _DYNAMIC pointer, if present */
878 put32(ptr, 0);
879 /* two dummy got entries */
880 put32(ptr + 4, 0);
881 put32(ptr + 8, 0);
882 #else
883 /* keep space for _DYNAMIC pointer, if present */
884 put32(ptr, 0);
885 put32(ptr + 4, 0);
886 /* two dummy got entries */
887 put32(ptr + 8, 0);
888 put32(ptr + 12, 0);
889 put32(ptr + 16, 0);
890 put32(ptr + 20, 0);
891 #endif
892 }
893
894 /* put a got entry corresponding to a symbol in symtab_section. 'size'
895 and 'info' can be modifed if more precise info comes from the DLL */
896 static void put_got_entry(TCCState *s1,
897 int reloc_type, unsigned long size, int info,
898 int sym_index)
899 {
900 int index;
901 const char *name;
902 ElfW(Sym) *sym;
903 unsigned long offset;
904 int *ptr;
905
906 if (!s1->got)
907 build_got(s1);
908
909 /* if a got entry already exists for that symbol, no need to add one */
910 if (sym_index < s1->nb_got_offsets &&
911 s1->got_offsets[sym_index] != 0)
912 return;
913
914 put_got_offset(s1, sym_index, s1->got->data_offset);
915
916 if (s1->dynsym) {
917 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
918 name = symtab_section->link->data + sym->st_name;
919 offset = sym->st_value;
920 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
921 if (reloc_type ==
922 #ifdef TCC_TARGET_X86_64
923 R_X86_64_JUMP_SLOT
924 #else
925 R_386_JMP_SLOT
926 #endif
927 ) {
928 Section *plt;
929 uint8_t *p;
930 int modrm;
931
932 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
933 modrm = 0x25;
934 #else
935 /* if we build a DLL, we add a %ebx offset */
936 if (s1->output_type == TCC_OUTPUT_DLL)
937 modrm = 0xa3;
938 else
939 modrm = 0x25;
940 #endif
941
942 /* add a PLT entry */
943 plt = s1->plt;
944 if (plt->data_offset == 0) {
945 /* first plt entry */
946 p = section_ptr_add(plt, 16);
947 p[0] = 0xff; /* pushl got + PTR_SIZE */
948 p[1] = modrm + 0x10;
949 put32(p + 2, PTR_SIZE);
950 p[6] = 0xff; /* jmp *(got + PTR_SIZE * 2) */
951 p[7] = modrm;
952 put32(p + 8, PTR_SIZE * 2);
953 }
954
955 p = section_ptr_add(plt, 16);
956 p[0] = 0xff; /* jmp *(got + x) */
957 p[1] = modrm;
958 put32(p + 2, s1->got->data_offset);
959 p[6] = 0x68; /* push $xxx */
960 put32(p + 7, (plt->data_offset - 32) >> 1);
961 p[11] = 0xe9; /* jmp plt_start */
962 put32(p + 12, -(plt->data_offset));
963
964 /* the symbol is modified so that it will be relocated to
965 the PLT */
966 #if !defined(TCC_OUTPUT_DLL_WITH_PLT)
967 if (s1->output_type == TCC_OUTPUT_EXE)
968 #endif
969 offset = plt->data_offset - 16;
970 }
971 #elif defined(TCC_TARGET_ARM)
972 if (reloc_type == R_ARM_JUMP_SLOT) {
973 Section *plt;
974 uint8_t *p;
975
976 /* if we build a DLL, we add a %ebx offset */
977 if (s1->output_type == TCC_OUTPUT_DLL)
978 tcc_error("DLLs unimplemented!");
979
980 /* add a PLT entry */
981 plt = s1->plt;
982 if (plt->data_offset == 0) {
983 /* first plt entry */
984 p = section_ptr_add(plt, 16);
985 put32(p , 0xe52de004);
986 put32(p + 4, 0xe59fe010);
987 put32(p + 8, 0xe08fe00e);
988 put32(p + 12, 0xe5bef008);
989 }
990
991 p = section_ptr_add(plt, 16);
992 put32(p , 0xe59fc004);
993 put32(p+4, 0xe08fc00c);
994 put32(p+8, 0xe59cf000);
995 put32(p+12, s1->got->data_offset);
996
997 /* the symbol is modified so that it will be relocated to
998 the PLT */
999 if (s1->output_type == TCC_OUTPUT_EXE)
1000 offset = plt->data_offset - 16;
1001 }
1002 #elif defined(TCC_TARGET_C67)
1003 tcc_error("C67 got not implemented");
1004 #else
1005 #error unsupported CPU
1006 #endif
1007 index = put_elf_sym(s1->dynsym, offset,
1008 size, info, 0, sym->st_shndx, name);
1009 /* put a got entry */
1010 put_elf_reloc(s1->dynsym, s1->got,
1011 s1->got->data_offset,
1012 reloc_type, index);
1013 }
1014 ptr = section_ptr_add(s1->got, PTR_SIZE);
1015 *ptr = 0;
1016 }
1017
1018 /* build GOT and PLT entries */
1019 ST_FUNC void build_got_entries(TCCState *s1)
1020 {
1021 Section *s;
1022 ElfW_Rel *rel, *rel_end;
1023 ElfW(Sym) *sym;
1024 int i, type, reloc_type, sym_index;
1025
1026 for(i = 1; i < s1->nb_sections; i++) {
1027 s = s1->sections[i];
1028 if (s->sh_type != SHT_RELX)
1029 continue;
1030 /* no need to handle got relocations */
1031 if (s->link != symtab_section)
1032 continue;
1033 rel_end = (ElfW_Rel *)(s->data + s->data_offset);
1034 for(rel = (ElfW_Rel *)s->data;
1035 rel < rel_end;
1036 rel++) {
1037 type = ELFW(R_TYPE)(rel->r_info);
1038 switch(type) {
1039 #if defined(TCC_TARGET_I386)
1040 case R_386_GOT32:
1041 case R_386_GOTOFF:
1042 case R_386_GOTPC:
1043 case R_386_PLT32:
1044 if (!s1->got)
1045 build_got(s1);
1046 if (type == R_386_GOT32 || type == R_386_PLT32) {
1047 sym_index = ELFW(R_SYM)(rel->r_info);
1048 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1049 /* look at the symbol got offset. If none, then add one */
1050 if (type == R_386_GOT32)
1051 reloc_type = R_386_GLOB_DAT;
1052 else
1053 reloc_type = R_386_JMP_SLOT;
1054 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
1055 sym_index);
1056 }
1057 break;
1058 #elif defined(TCC_TARGET_ARM)
1059 case R_ARM_GOT_BREL:
1060 case R_ARM_GOTOFF32:
1061 case R_ARM_BASE_PREL:
1062 case R_ARM_PLT32:
1063 if (!s1->got)
1064 build_got(s1);
1065 if (type == R_ARM_GOT_BREL || type == R_ARM_PLT32) {
1066 sym_index = ELFW(R_SYM)(rel->r_info);
1067 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1068 /* look at the symbol got offset. If none, then add one */
1069 if (type == R_ARM_GOT_BREL)
1070 reloc_type = R_ARM_GLOB_DAT;
1071 else
1072 reloc_type = R_ARM_JUMP_SLOT;
1073 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
1074 sym_index);
1075 }
1076 break;
1077 #elif defined(TCC_TARGET_C67)
1078 case R_C60_GOT32:
1079 case R_C60_GOTOFF:
1080 case R_C60_GOTPC:
1081 case R_C60_PLT32:
1082 if (!s1->got)
1083 build_got(s1);
1084 if (type == R_C60_GOT32 || type == R_C60_PLT32) {
1085 sym_index = ELFW(R_SYM)(rel->r_info);
1086 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1087 /* look at the symbol got offset. If none, then add one */
1088 if (type == R_C60_GOT32)
1089 reloc_type = R_C60_GLOB_DAT;
1090 else
1091 reloc_type = R_C60_JMP_SLOT;
1092 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
1093 sym_index);
1094 }
1095 break;
1096 #elif defined(TCC_TARGET_X86_64)
1097 case R_X86_64_GOT32:
1098 case R_X86_64_GOTTPOFF:
1099 case R_X86_64_GOTPCREL:
1100 case R_X86_64_PLT32:
1101 if (!s1->got)
1102 build_got(s1);
1103 if (type == R_X86_64_GOT32 || type == R_X86_64_GOTPCREL ||
1104 type == R_X86_64_PLT32) {
1105 sym_index = ELFW(R_SYM)(rel->r_info);
1106 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1107 /* look at the symbol got offset. If none, then add one */
1108 if (type == R_X86_64_GOT32 || type == R_X86_64_GOTPCREL)
1109 reloc_type = R_X86_64_GLOB_DAT;
1110 else
1111 reloc_type = R_X86_64_JUMP_SLOT;
1112 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
1113 sym_index);
1114 }
1115 break;
1116 #else
1117 #error unsupported CPU
1118 #endif
1119 default:
1120 break;
1121 }
1122 }
1123 }
1124 }
1125
1126 ST_FUNC Section *new_symtab(TCCState *s1,
1127 const char *symtab_name, int sh_type, int sh_flags,
1128 const char *strtab_name,
1129 const char *hash_name, int hash_sh_flags)
1130 {
1131 Section *symtab, *strtab, *hash;
1132 int *ptr, nb_buckets;
1133
1134 symtab = new_section(s1, symtab_name, sh_type, sh_flags);
1135 symtab->sh_entsize = sizeof(ElfW(Sym));
1136 strtab = new_section(s1, strtab_name, SHT_STRTAB, sh_flags);
1137 put_elf_str(strtab, "");
1138 symtab->link = strtab;
1139 put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL);
1140
1141 nb_buckets = 1;
1142
1143 hash = new_section(s1, hash_name, SHT_HASH, hash_sh_flags);
1144 hash->sh_entsize = sizeof(int);
1145 symtab->hash = hash;
1146 hash->link = symtab;
1147
1148 ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int));
1149 ptr[0] = nb_buckets;
1150 ptr[1] = 1;
1151 memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int));
1152 return symtab;
1153 }
1154
1155 /* put dynamic tag */
1156 static void put_dt(Section *dynamic, int dt, uplong val)
1157 {
1158 ElfW(Dyn) *dyn;
1159 dyn = section_ptr_add(dynamic, sizeof(ElfW(Dyn)));
1160 dyn->d_tag = dt;
1161 dyn->d_un.d_val = val;
1162 }
1163
1164 static void add_init_array_defines(TCCState *s1, const char *section_name)
1165 {
1166 Section *s;
1167 long end_offset;
1168 char sym_start[1024];
1169 char sym_end[1024];
1170
1171 snprintf(sym_start, sizeof(sym_start), "__%s_start", section_name + 1);
1172 snprintf(sym_end, sizeof(sym_end), "__%s_end", section_name + 1);
1173
1174 s = find_section(s1, section_name);
1175 if (!s) {
1176 end_offset = 0;
1177 s = data_section;
1178 } else {
1179 end_offset = s->data_offset;
1180 }
1181
1182 add_elf_sym(symtab_section,
1183 0, 0,
1184 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1185 s->sh_num, sym_start);
1186 add_elf_sym(symtab_section,
1187 end_offset, 0,
1188 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1189 s->sh_num, sym_end);
1190 }
1191
1192 static int tcc_add_support(TCCState *s1, const char *filename)
1193 {
1194 char buf[1024];
1195 snprintf(buf, sizeof(buf), "%s/%s", s1->tcc_lib_path, filename);
1196 return tcc_add_file(s1, buf);
1197 }
1198
1199 ST_FUNC void tcc_add_bcheck(TCCState *s1)
1200 {
1201 #ifdef CONFIG_TCC_BCHECK
1202 unsigned long *ptr;
1203 Section *init_section;
1204 unsigned char *pinit;
1205 int sym_index;
1206
1207 if (0 == s1->do_bounds_check)
1208 return;
1209
1210 /* XXX: add an object file to do that */
1211 ptr = section_ptr_add(bounds_section, sizeof(unsigned long));
1212 *ptr = 0;
1213 add_elf_sym(symtab_section, 0, 0,
1214 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1215 bounds_section->sh_num, "__bounds_start");
1216 /* add bound check code */
1217 #ifndef TCC_TARGET_PE
1218 tcc_add_support(s1, "bcheck.o");
1219 #endif
1220 #ifdef TCC_TARGET_I386
1221 if (s1->output_type != TCC_OUTPUT_MEMORY) {
1222 /* add 'call __bound_init()' in .init section */
1223 init_section = find_section(s1, ".init");
1224 pinit = section_ptr_add(init_section, 5);
1225 pinit[0] = 0xe8;
1226 put32(pinit + 1, -4);
1227 sym_index = find_elf_sym(symtab_section, "__bound_init");
1228 put_elf_reloc(symtab_section, init_section,
1229 init_section->data_offset - 4, R_386_PC32, sym_index);
1230 }
1231 #endif
1232 #endif
1233 }
1234
1235 /* add tcc runtime libraries */
1236 ST_FUNC void tcc_add_runtime(TCCState *s1)
1237 {
1238 tcc_add_bcheck(s1);
1239
1240 /* add libc */
1241 if (!s1->nostdlib) {
1242 tcc_add_library(s1, "c");
1243 #ifdef CONFIG_USE_LIBGCC
1244 tcc_add_file(s1, TCC_LIBGCC);
1245 #elif !defined WITHOUT_LIBTCC
1246 tcc_add_support(s1, "libtcc1.a");
1247 #endif
1248 /* add crt end if not memory output */
1249 if (s1->output_type != TCC_OUTPUT_MEMORY)
1250 tcc_add_crt(s1, "crtn.o");
1251 }
1252 }
1253
1254 /* add various standard linker symbols (must be done after the
1255 sections are filled (for example after allocating common
1256 symbols)) */
1257 ST_FUNC void tcc_add_linker_symbols(TCCState *s1)
1258 {
1259 char buf[1024];
1260 int i;
1261 Section *s;
1262
1263 add_elf_sym(symtab_section,
1264 text_section->data_offset, 0,
1265 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1266 text_section->sh_num, "_etext");
1267 add_elf_sym(symtab_section,
1268 data_section->data_offset, 0,
1269 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1270 data_section->sh_num, "_edata");
1271 add_elf_sym(symtab_section,
1272 bss_section->data_offset, 0,
1273 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1274 bss_section->sh_num, "_end");
1275 /* horrible new standard ldscript defines */
1276 add_init_array_defines(s1, ".preinit_array");
1277 add_init_array_defines(s1, ".init_array");
1278 add_init_array_defines(s1, ".fini_array");
1279
1280 /* add start and stop symbols for sections whose name can be
1281 expressed in C */
1282 for(i = 1; i < s1->nb_sections; i++) {
1283 s = s1->sections[i];
1284 if (s->sh_type == SHT_PROGBITS &&
1285 (s->sh_flags & SHF_ALLOC)) {
1286 const char *p;
1287 int ch;
1288
1289 /* check if section name can be expressed in C */
1290 p = s->name;
1291 for(;;) {
1292 ch = *p;
1293 if (!ch)
1294 break;
1295 if (!isid(ch) && !isnum(ch))
1296 goto next_sec;
1297 p++;
1298 }
1299 snprintf(buf, sizeof(buf), "__start_%s", s->name);
1300 add_elf_sym(symtab_section,
1301 0, 0,
1302 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1303 s->sh_num, buf);
1304 snprintf(buf, sizeof(buf), "__stop_%s", s->name);
1305 add_elf_sym(symtab_section,
1306 s->data_offset, 0,
1307 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1308 s->sh_num, buf);
1309 }
1310 next_sec: ;
1311 }
1312 }
1313
1314 static void tcc_output_binary(TCCState *s1, FILE *f,
1315 const int *section_order)
1316 {
1317 Section *s;
1318 int i, offset, size;
1319
1320 offset = 0;
1321 for(i=1;i<s1->nb_sections;i++) {
1322 s = s1->sections[section_order[i]];
1323 if (s->sh_type != SHT_NOBITS &&
1324 (s->sh_flags & SHF_ALLOC)) {
1325 while (offset < s->sh_offset) {
1326 fputc(0, f);
1327 offset++;
1328 }
1329 size = s->sh_size;
1330 fwrite(s->data, 1, size, f);
1331 offset += size;
1332 }
1333 }
1334 }
1335
1336 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1337 #define HAVE_PHDR 1
1338 #define EXTRA_RELITEMS 14
1339
1340 /* move the relocation value from .dynsym to .got */
1341 void patch_dynsym_undef(TCCState *s1, Section *s)
1342 {
1343 uint32_t *gotd = (void *)s1->got->data;
1344 ElfW(Sym) *sym, *sym_end;
1345
1346 gotd += 3; // dummy entries in .got
1347 /* relocate symbols in .dynsym */
1348 sym_end = (ElfW(Sym) *)(s->data + s->data_offset);
1349 for (sym = (ElfW(Sym) *)s->data + 1; sym < sym_end; sym++) {
1350 if (sym->st_shndx == SHN_UNDEF) {
1351 *gotd++ = sym->st_value + 6; // XXX 6 is magic ?
1352 sym->st_value = 0;
1353 }
1354 }
1355 }
1356 #else
1357 #define HAVE_PHDR 0
1358 #define EXTRA_RELITEMS 9
1359
1360 /* zero plt offsets of weak symbols in .dynsym */
1361 void patch_dynsym_undef(TCCState *s1, Section *s)
1362 {
1363 ElfW(Sym) *sym, *sym_end;
1364
1365 sym_end = (ElfW(Sym) *)(s->data + s->data_offset);
1366 for (sym = (ElfW(Sym) *)s->data + 1; sym < sym_end; sym++)
1367 if (sym->st_shndx == SHN_UNDEF && ELFW(ST_BIND)(sym->st_info) == STB_WEAK)
1368 sym->st_value = 0;
1369 }
1370 #endif
1371
1372 ST_FUNC void fill_got_entry(TCCState *s1, ElfW_Rel *rel)
1373 {
1374 int sym_index = ELFW(R_SYM) (rel->r_info);
1375 ElfW(Sym) *sym = &((ElfW(Sym) *) symtab_section->data)[sym_index];
1376 unsigned long offset;
1377
1378 if (sym_index >= s1->nb_got_offsets)
1379 return;
1380 offset = s1->got_offsets[sym_index];
1381 section_reserve(s1->got, offset + PTR_SIZE);
1382 #ifdef TCC_TARGET_X86_64
1383 /* only works for x86-64 */
1384 put32(s1->got->data + offset + 4, sym->st_value >> 32);
1385 #endif
1386 put32(s1->got->data + offset, sym->st_value & 0xffffffff);
1387 }
1388
1389 ST_FUNC void fill_got(TCCState *s1)
1390 {
1391 Section *s;
1392 ElfW_Rel *rel, *rel_end;
1393 int i;
1394
1395 for(i = 1; i < s1->nb_sections; i++) {
1396 s = s1->sections[i];
1397 if (s->sh_type != SHT_RELX)
1398 continue;
1399 /* no need to handle got relocations */
1400 if (s->link != symtab_section)
1401 continue;
1402 rel_end = (ElfW_Rel *) (s->data + s->data_offset);
1403 for(rel = (ElfW_Rel *) s->data; rel < rel_end; rel++) {
1404 switch (ELFW(R_TYPE) (rel->r_info)) {
1405 case R_X86_64_GOT32:
1406 case R_X86_64_GOTPCREL:
1407 case R_X86_64_PLT32:
1408 fill_got_entry(s1, rel);
1409 break;
1410 }
1411 }
1412 }
1413 }
1414
1415
1416 /* output an ELF file */
1417 /* XXX: suppress unneeded sections */
1418 static int elf_output_file(TCCState *s1, const char *filename)
1419 {
1420 ElfW(Ehdr) ehdr;
1421 FILE *f;
1422 int fd, mode, ret;
1423 int *section_order;
1424 int shnum, i, phnum, file_offset, offset, size, j, sh_order_index, k;
1425 long long tmp;
1426 uplong addr;
1427 Section *strsec, *s;
1428 ElfW(Shdr) shdr, *sh;
1429 ElfW(Phdr) *phdr, *ph;
1430 Section *interp, *dynamic, *dynstr;
1431 unsigned long saved_dynamic_data_offset;
1432 ElfW(Sym) *sym;
1433 int type, file_type;
1434 uplong rel_addr, rel_size;
1435 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1436 uplong bss_addr, bss_size;
1437 #endif
1438
1439 file_type = s1->output_type;
1440 s1->nb_errors = 0;
1441
1442 if (file_type != TCC_OUTPUT_OBJ) {
1443 tcc_add_runtime(s1);
1444 }
1445
1446 phdr = NULL;
1447 section_order = NULL;
1448 interp = NULL;
1449 dynamic = NULL;
1450 dynstr = NULL; /* avoid warning */
1451 saved_dynamic_data_offset = 0; /* avoid warning */
1452
1453 if (file_type != TCC_OUTPUT_OBJ) {
1454 relocate_common_syms();
1455
1456 tcc_add_linker_symbols(s1);
1457
1458 if (!s1->static_link) {
1459 const char *name;
1460 int sym_index, index;
1461 ElfW(Sym) *esym, *sym_end;
1462
1463 if (file_type == TCC_OUTPUT_EXE) {
1464 char *ptr;
1465 /* allow override the dynamic loader */
1466 const char *elfint = getenv("LD_SO");
1467 if (elfint == NULL)
1468 elfint = CONFIG_TCC_ELFINTERP;
1469 /* add interpreter section only if executable */
1470 interp = new_section(s1, ".interp", SHT_PROGBITS, SHF_ALLOC);
1471 interp->sh_addralign = 1;
1472 ptr = section_ptr_add(interp, 1+strlen(elfint));
1473 strcpy(ptr, elfint);
1474 }
1475
1476 /* add dynamic symbol table */
1477 s1->dynsym = new_symtab(s1, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
1478 ".dynstr",
1479 ".hash", SHF_ALLOC);
1480 dynstr = s1->dynsym->link;
1481
1482 /* add dynamic section */
1483 dynamic = new_section(s1, ".dynamic", SHT_DYNAMIC,
1484 SHF_ALLOC | SHF_WRITE);
1485 dynamic->link = dynstr;
1486 dynamic->sh_entsize = sizeof(ElfW(Dyn));
1487
1488 /* add PLT */
1489 s1->plt = new_section(s1, ".plt", SHT_PROGBITS,
1490 SHF_ALLOC | SHF_EXECINSTR);
1491 s1->plt->sh_entsize = 4;
1492
1493 build_got(s1);
1494
1495 /* scan for undefined symbols and see if they are in the
1496 dynamic symbols. If a symbol STT_FUNC or STT_GNU_IFUNC
1497 is found, then we add it in the PLT. If a symbol
1498 STT_OBJECT is found, we add it in the .bss section with
1499 a suitable relocation */
1500 sym_end = (ElfW(Sym) *)(symtab_section->data +
1501 symtab_section->data_offset);
1502 if (file_type == TCC_OUTPUT_EXE) {
1503 for(sym = (ElfW(Sym) *)symtab_section->data + 1;
1504 sym < sym_end;
1505 sym++) {
1506 if (sym->st_shndx == SHN_UNDEF) {
1507 name = symtab_section->link->data + sym->st_name;
1508 sym_index = find_elf_sym(s1->dynsymtab_section, name);
1509 if (sym_index) {
1510 esym = &((ElfW(Sym) *)s1->dynsymtab_section->data)[sym_index];
1511 type = ELFW(ST_TYPE)(esym->st_info);
1512 if ((type == STT_FUNC) || (type == STT_GNU_IFUNC)) {
1513 put_got_entry(s1, R_JMP_SLOT, esym->st_size,
1514 ELFW(ST_INFO)(STB_GLOBAL,type),
1515 sym - (ElfW(Sym) *)symtab_section->data);
1516 } else if (type == STT_OBJECT) {
1517 unsigned long offset;
1518 ElfW(Sym) *dynsym, *dynsym_end;
1519 offset = bss_section->data_offset;
1520 /* XXX: which alignment ? */
1521 offset = (offset + 16 - 1) & -16;
1522 index = put_elf_sym(s1->dynsym, offset, esym->st_size,
1523 esym->st_info, 0,
1524 bss_section->sh_num, name);
1525 // Ensure R_COPY works for weak symbol aliases
1526 if (ELFW(ST_BIND)(esym->st_info) == STB_WEAK) {
1527 dynsym_end = (ElfW(Sym) *)
1528 (s1->dynsymtab_section->data +
1529 s1->dynsymtab_section->data_offset);
1530 for(dynsym = (ElfW(Sym) *)s1->dynsymtab_section->data + 1;
1531 dynsym < dynsym_end; dynsym++) {
1532 if ((dynsym->st_value == esym->st_value)
1533 && (ELFW(ST_BIND)(dynsym->st_info) == STB_GLOBAL)) {
1534 char *dynname;
1535 dynname = s1->dynsymtab_section->link->data
1536 + dynsym->st_name;
1537 put_elf_sym(s1->dynsym, offset,
1538 dynsym->st_size,
1539 dynsym->st_info, 0,
1540 bss_section->sh_num,
1541 dynname);
1542 break;
1543 }
1544 }
1545 }
1546 put_elf_reloc(s1->dynsym, bss_section,
1547 offset, R_COPY, index);
1548 offset += esym->st_size;
1549 bss_section->data_offset = offset;
1550 }
1551 } else {
1552 /* STB_WEAK undefined symbols are accepted */
1553 /* XXX: _fp_hw seems to be part of the ABI, so we ignore
1554 it */
1555 if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK ||
1556 !strcmp(name, "_fp_hw")) {
1557 } else {
1558 tcc_error_noabort("undefined symbol '%s'", name);
1559 }
1560 }
1561 } else if (s1->rdynamic &&
1562 ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1563 /* if -rdynamic option, then export all non
1564 local symbols */
1565 name = symtab_section->link->data + sym->st_name;
1566 put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1567 sym->st_info, 0,
1568 sym->st_shndx, name);
1569 }
1570 }
1571
1572 if (s1->nb_errors)
1573 goto fail;
1574
1575 /* now look at unresolved dynamic symbols and export
1576 corresponding symbol */
1577 sym_end = (ElfW(Sym) *)(s1->dynsymtab_section->data +
1578 s1->dynsymtab_section->data_offset);
1579 for(esym = (ElfW(Sym) *)s1->dynsymtab_section->data + 1;
1580 esym < sym_end;
1581 esym++) {
1582 if (esym->st_shndx == SHN_UNDEF) {
1583 name = s1->dynsymtab_section->link->data + esym->st_name;
1584 sym_index = find_elf_sym(symtab_section, name);
1585 if (sym_index) {
1586 /* XXX: avoid adding a symbol if already
1587 present because of -rdynamic ? */
1588 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1589 put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1590 sym->st_info, 0,
1591 sym->st_shndx, name);
1592 } else {
1593 if (ELFW(ST_BIND)(esym->st_info) == STB_WEAK) {
1594 /* weak symbols can stay undefined */
1595 } else {
1596 tcc_warning("undefined dynamic symbol '%s'", name);
1597 }
1598 }
1599 }
1600 }
1601 } else {
1602 int nb_syms;
1603 /* shared library case : we simply export all the global symbols */
1604 nb_syms = symtab_section->data_offset / sizeof(ElfW(Sym));
1605 s1->symtab_to_dynsym = tcc_mallocz(sizeof(int) * nb_syms);
1606 for(sym = (ElfW(Sym) *)symtab_section->data + 1;
1607 sym < sym_end;
1608 sym++) {
1609 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
1610 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
1611 if ((ELFW(ST_TYPE)(sym->st_info) == STT_FUNC ||
1612 ELFW(ST_TYPE)(sym->st_info) == STT_GNU_IFUNC)
1613 && sym->st_shndx == SHN_UNDEF) {
1614 put_got_entry(s1, R_JMP_SLOT, sym->st_size,
1615 sym->st_info,
1616 sym - (ElfW(Sym) *)symtab_section->data);
1617 }
1618 else if (ELFW(ST_TYPE)(sym->st_info) == STT_OBJECT) {
1619 put_got_entry(s1, R_X86_64_GLOB_DAT, sym->st_size,
1620 sym->st_info,
1621 sym - (ElfW(Sym) *)symtab_section->data);
1622 }
1623 else
1624 #endif
1625 {
1626 name = symtab_section->link->data + sym->st_name;
1627 index = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
1628 sym->st_info, 0,
1629 sym->st_shndx, name);
1630 s1->symtab_to_dynsym[sym -
1631 (ElfW(Sym) *)symtab_section->data] =
1632 index;
1633 }
1634 }
1635 }
1636 }
1637
1638 build_got_entries(s1);
1639
1640 /* add a list of needed dlls */
1641 for(i = 0; i < s1->nb_loaded_dlls; i++) {
1642 DLLReference *dllref = s1->loaded_dlls[i];
1643 if (dllref->level == 0)
1644 put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name));
1645 }
1646
1647 if (s1->rpath)
1648 put_dt(dynamic, DT_RPATH, put_elf_str(dynstr, s1->rpath));
1649
1650 /* XXX: currently, since we do not handle PIC code, we
1651 must relocate the readonly segments */
1652 if (file_type == TCC_OUTPUT_DLL) {
1653 if (s1->soname)
1654 put_dt(dynamic, DT_SONAME, put_elf_str(dynstr, s1->soname));
1655 put_dt(dynamic, DT_TEXTREL, 0);
1656 }
1657
1658 if (s1->symbolic)
1659 put_dt(dynamic, DT_SYMBOLIC, 0);
1660
1661 /* add necessary space for other entries */
1662 saved_dynamic_data_offset = dynamic->data_offset;
1663 dynamic->data_offset += sizeof(ElfW(Dyn)) * EXTRA_RELITEMS;
1664 } else {
1665 /* still need to build got entries in case of static link */
1666 build_got_entries(s1);
1667 }
1668 }
1669
1670 memset(&ehdr, 0, sizeof(ehdr));
1671
1672 /* we add a section for symbols */
1673 strsec = new_section(s1, ".shstrtab", SHT_STRTAB, 0);
1674 put_elf_str(strsec, "");
1675
1676 /* compute number of sections */
1677 shnum = s1->nb_sections;
1678
1679 /* this array is used to reorder sections in the output file */
1680 section_order = tcc_malloc(sizeof(int) * shnum);
1681 section_order[0] = 0;
1682 sh_order_index = 1;
1683
1684 /* compute number of program headers */
1685 switch(file_type) {
1686 default:
1687 case TCC_OUTPUT_OBJ:
1688 phnum = 0;
1689 break;
1690 case TCC_OUTPUT_EXE:
1691 if (!s1->static_link)
1692 phnum = 4 + HAVE_PHDR;
1693 else
1694 phnum = 2;
1695 break;
1696 case TCC_OUTPUT_DLL:
1697 phnum = 3;
1698 break;
1699 }
1700
1701 /* allocate strings for section names and decide if an unallocated
1702 section should be output */
1703 /* NOTE: the strsec section comes last, so its size is also
1704 correct ! */
1705 for(i = 1; i < s1->nb_sections; i++) {
1706 s = s1->sections[i];
1707 s->sh_name = put_elf_str(strsec, s->name);
1708 #if 0 //gr
1709 printf("section: f=%08x t=%08x i=%08x %s %s\n",
1710 s->sh_flags,
1711 s->sh_type,
1712 s->sh_info,
1713 s->name,
1714 s->reloc ? s->reloc->name : "n"
1715 );
1716 #endif
1717 /* when generating a DLL, we include relocations but we may
1718 patch them */
1719 if (file_type == TCC_OUTPUT_DLL &&
1720 s->sh_type == SHT_RELX &&
1721 !(s->sh_flags & SHF_ALLOC)) {
1722 /* //gr: avoid bogus relocs for empty (debug) sections */
1723 if (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC)
1724 prepare_dynamic_rel(s1, s);
1725 else if (s1->do_debug)
1726 s->sh_size = s->data_offset;
1727 } else if (s1->do_debug ||
1728 file_type == TCC_OUTPUT_OBJ ||
1729 (s->sh_flags & SHF_ALLOC) ||
1730 i == (s1->nb_sections - 1)) {
1731 /* we output all sections if debug or object file */
1732 s->sh_size = s->data_offset;
1733 }
1734 }
1735
1736 /* allocate program segment headers */
1737 phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
1738
1739 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1740 file_offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1741 } else {
1742 file_offset = 0;
1743 }
1744 if (phnum > 0) {
1745 /* compute section to program header mapping */
1746 if (s1->has_text_addr) {
1747 int a_offset, p_offset;
1748 addr = s1->text_addr;
1749 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1750 ELF_PAGE_SIZE */
1751 a_offset = (int) (addr & (s1->section_align - 1));
1752 p_offset = file_offset & (s1->section_align - 1);
1753 if (a_offset < p_offset)
1754 a_offset += s1->section_align;
1755 file_offset += (a_offset - p_offset);
1756 } else {
1757 if (file_type == TCC_OUTPUT_DLL)
1758 addr = 0;
1759 else
1760 addr = ELF_START_ADDR;
1761 /* compute address after headers */
1762 addr += (file_offset & (s1->section_align - 1));
1763 }
1764
1765 /* dynamic relocation table information, for .dynamic section */
1766 rel_size = 0;
1767 rel_addr = 0;
1768
1769 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1770 bss_addr = bss_size = 0;
1771 #endif
1772 /* leave one program header for the program interpreter */
1773 ph = &phdr[0];
1774 if (interp)
1775 ph += 1 + HAVE_PHDR;
1776
1777 for(j = 0; j < 2; j++) {
1778 ph->p_type = PT_LOAD;
1779 if (j == 0)
1780 ph->p_flags = PF_R | PF_X;
1781 else
1782 ph->p_flags = PF_R | PF_W;
1783 ph->p_align = s1->section_align;
1784
1785 /* we do the following ordering: interp, symbol tables,
1786 relocations, progbits, nobits */
1787 /* XXX: do faster and simpler sorting */
1788 for(k = 0; k < 5; k++) {
1789 for(i = 1; i < s1->nb_sections; i++) {
1790 s = s1->sections[i];
1791 /* compute if section should be included */
1792 if (j == 0) {
1793 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1794 SHF_ALLOC)
1795 continue;
1796 } else {
1797 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1798 (SHF_ALLOC | SHF_WRITE))
1799 continue;
1800 }
1801 if (s == interp) {
1802 if (k != 0)
1803 continue;
1804 } else if (s->sh_type == SHT_DYNSYM ||
1805 s->sh_type == SHT_STRTAB ||
1806 s->sh_type == SHT_HASH) {
1807 if (k != 1)
1808 continue;
1809 } else if (s->sh_type == SHT_RELX) {
1810 if (k != 2)
1811 continue;
1812 } else if (s->sh_type == SHT_NOBITS) {
1813 if (k != 4)
1814 continue;
1815 } else {
1816 if (k != 3)
1817 continue;
1818 }
1819 section_order[sh_order_index++] = i;
1820
1821 /* section matches: we align it and add its size */
1822 tmp = addr;
1823 addr = (addr + s->sh_addralign - 1) &
1824 ~(s->sh_addralign - 1);
1825 file_offset += (int) ( addr - tmp );
1826 s->sh_offset = file_offset;
1827 s->sh_addr = addr;
1828
1829 /* update program header infos */
1830 if (ph->p_offset == 0) {
1831 ph->p_offset = file_offset;
1832 ph->p_vaddr = addr;
1833 ph->p_paddr = ph->p_vaddr;
1834 }
1835 /* update dynamic relocation infos */
1836 if (s->sh_type == SHT_RELX) {
1837 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1838 if (!strcmp(strsec->data + s->sh_name, ".rel.got")) { // rel_size == 0) {
1839 rel_addr = addr;
1840 rel_size += s->sh_size; // XXX only first rel.
1841 }
1842 if (!strcmp(strsec->data + s->sh_name, ".rel.bss")) { // rel_size == 0) {
1843 bss_addr = addr;
1844 bss_size = s->sh_size; // XXX only first rel.
1845 }
1846 #else
1847 if (rel_size == 0)
1848 rel_addr = addr;
1849 rel_size += s->sh_size;
1850 #endif
1851 }
1852 addr += s->sh_size;
1853 if (s->sh_type != SHT_NOBITS)
1854 file_offset += s->sh_size;
1855 }
1856 }
1857 ph->p_filesz = file_offset - ph->p_offset;
1858 ph->p_memsz = addr - ph->p_vaddr;
1859 ph++;
1860 if (j == 0) {
1861 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1862 /* if in the middle of a page, we duplicate the page in
1863 memory so that one copy is RX and the other is RW */
1864 if ((addr & (s1->section_align - 1)) != 0)
1865 addr += s1->section_align;
1866 } else {
1867 addr = (addr + s1->section_align - 1) & ~(s1->section_align - 1);
1868 file_offset = (file_offset + s1->section_align - 1) &
1869 ~(s1->section_align - 1);
1870 }
1871 }
1872 }
1873
1874 /* if interpreter, then add corresponing program header */
1875 if (interp) {
1876 ph = &phdr[0];
1877
1878 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1879 {
1880 int len = phnum * sizeof(ElfW(Phdr));
1881
1882 ph->p_type = PT_PHDR;
1883 ph->p_offset = sizeof(ElfW(Ehdr));
1884 ph->p_vaddr = interp->sh_addr - len;
1885 ph->p_paddr = ph->p_vaddr;
1886 ph->p_filesz = ph->p_memsz = len;
1887 ph->p_flags = PF_R | PF_X;
1888 ph->p_align = 4; // interp->sh_addralign;
1889 ph++;
1890 }
1891 #endif
1892
1893 ph->p_type = PT_INTERP;
1894 ph->p_offset = interp->sh_offset;
1895 ph->p_vaddr = interp->sh_addr;
1896 ph->p_paddr = ph->p_vaddr;
1897 ph->p_filesz = interp->sh_size;
1898 ph->p_memsz = interp->sh_size;
1899 ph->p_flags = PF_R;
1900 ph->p_align = interp->sh_addralign;
1901 }
1902
1903 /* if dynamic section, then add corresponing program header */
1904 if (dynamic) {
1905 ElfW(Sym) *sym_end;
1906
1907 ph = &phdr[phnum - 1];
1908
1909 ph->p_type = PT_DYNAMIC;
1910 ph->p_offset = dynamic->sh_offset;
1911 ph->p_vaddr = dynamic->sh_addr;
1912 ph->p_paddr = ph->p_vaddr;
1913 ph->p_filesz = dynamic->sh_size;
1914 ph->p_memsz = dynamic->sh_size;
1915 ph->p_flags = PF_R | PF_W;
1916 ph->p_align = dynamic->sh_addralign;
1917
1918 /* put GOT dynamic section address */
1919 put32(s1->got->data, dynamic->sh_addr);
1920
1921 /* relocate the PLT */
1922 if (file_type == TCC_OUTPUT_EXE
1923 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
1924 || file_type == TCC_OUTPUT_DLL
1925 #endif
1926 ) {
1927 uint8_t *p, *p_end;
1928
1929 p = s1->plt->data;
1930 p_end = p + s1->plt->data_offset;
1931 if (p < p_end) {
1932 #if defined(TCC_TARGET_I386)
1933 put32(p + 2, get32(p + 2) + s1->got->sh_addr);
1934 put32(p + 8, get32(p + 8) + s1->got->sh_addr);
1935 p += 16;
1936 while (p < p_end) {
1937 put32(p + 2, get32(p + 2) + s1->got->sh_addr);
1938 p += 16;
1939 }
1940 #elif defined(TCC_TARGET_X86_64)
1941 int x = s1->got->sh_addr - s1->plt->sh_addr - 6;
1942 put32(p + 2, get32(p + 2) + x);
1943 put32(p + 8, get32(p + 8) + x - 6);
1944 p += 16;
1945 while (p < p_end) {
1946 put32(p + 2, get32(p + 2) + x + s1->plt->data - p);
1947 p += 16;
1948 }
1949 #elif defined(TCC_TARGET_ARM)
1950 int x;
1951 x=s1->got->sh_addr - s1->plt->sh_addr - 12;
1952 p +=16;
1953 while (p < p_end) {
1954 put32(p + 12, x + get32(p + 12) + s1->plt->data - p);
1955 p += 16;
1956 }
1957 #elif defined(TCC_TARGET_C67)
1958 /* XXX: TODO */
1959 #else
1960 #error unsupported CPU
1961 #endif
1962 }
1963 }
1964
1965 /* relocate symbols in .dynsym */
1966 sym_end = (ElfW(Sym) *)(s1->dynsym->data + s1->dynsym->data_offset);
1967 for(sym = (ElfW(Sym) *)s1->dynsym->data + 1;
1968 sym < sym_end;
1969 sym++) {
1970 if (sym->st_shndx == SHN_UNDEF) {
1971 /* relocate to the PLT if the symbol corresponds
1972 to a PLT entry */
1973 if (sym->st_value)
1974 sym->st_value += s1->plt->sh_addr;
1975 } else if (sym->st_shndx < SHN_LORESERVE) {
1976 /* do symbol relocation */
1977 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
1978 }
1979 }
1980
1981 /* put dynamic section entries */
1982 dynamic->data_offset = saved_dynamic_data_offset;
1983 put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
1984 put_dt(dynamic, DT_STRTAB, dynstr->sh_addr);
1985 put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
1986 put_dt(dynamic, DT_STRSZ, dynstr->data_offset);
1987 put_dt(dynamic, DT_SYMENT, sizeof(ElfW(Sym)));
1988 #ifdef TCC_TARGET_X86_64
1989 put_dt(dynamic, DT_RELA, rel_addr);
1990 put_dt(dynamic, DT_RELASZ, rel_size);
1991 put_dt(dynamic, DT_RELAENT, sizeof(ElfW_Rel));
1992 #else
1993 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1994 put_dt(dynamic, DT_PLTGOT, s1->got->sh_addr);
1995 put_dt(dynamic, DT_PLTRELSZ, rel_size);
1996 put_dt(dynamic, DT_JMPREL, rel_addr);
1997 put_dt(dynamic, DT_PLTREL, DT_REL);
1998 put_dt(dynamic, DT_REL, bss_addr);
1999 put_dt(dynamic, DT_RELSZ, bss_size);
2000 #else
2001 put_dt(dynamic, DT_REL, rel_addr);
2002 put_dt(dynamic, DT_RELSZ, rel_size);
2003 put_dt(dynamic, DT_RELENT, sizeof(ElfW_Rel));
2004 #endif
2005 #endif
2006 if (s1->do_debug)
2007 put_dt(dynamic, DT_DEBUG, 0);
2008 put_dt(dynamic, DT_NULL, 0);
2009 }
2010
2011 ehdr.e_phentsize = sizeof(ElfW(Phdr));
2012 ehdr.e_phnum = phnum;
2013 ehdr.e_phoff = sizeof(ElfW(Ehdr));
2014 }
2015
2016 /* all other sections come after */
2017 for(i = 1; i < s1->nb_sections; i++) {
2018 s = s1->sections[i];
2019 if (phnum > 0 && (s->sh_flags & SHF_ALLOC))
2020 continue;
2021 section_order[sh_order_index++] = i;
2022
2023 file_offset = (file_offset + s->sh_addralign - 1) &
2024 ~(s->sh_addralign - 1);
2025 s->sh_offset = file_offset;
2026 if (s->sh_type != SHT_NOBITS)
2027 file_offset += s->sh_size;
2028 }
2029
2030 /* if building executable or DLL, then relocate each section
2031 except the GOT which is already relocated */
2032 if (file_type != TCC_OUTPUT_OBJ) {
2033 relocate_syms(s1, 0);
2034
2035 if (s1->nb_errors != 0) {
2036 fail:
2037 ret = -1;
2038 goto the_end;
2039 }
2040
2041 /* relocate sections */
2042 /* XXX: ignore sections with allocated relocations ? */
2043 for(i = 1; i < s1->nb_sections; i++) {
2044 s = s1->sections[i];
2045 if (s->reloc && s != s1->got && (s->sh_flags & SHF_ALLOC)) //gr
2046 relocate_section(s1, s);
2047 }
2048
2049 /* relocate relocation entries if the relocation tables are
2050 allocated in the executable */
2051 for(i = 1; i < s1->nb_sections; i++) {
2052 s = s1->sections[i];
2053 if ((s->sh_flags & SHF_ALLOC) &&
2054 s->sh_type == SHT_RELX) {
2055 relocate_rel(s1, s);
2056 }
2057 }
2058
2059 /* get entry point address */
2060 if (file_type == TCC_OUTPUT_EXE)
2061 ehdr.e_entry = (uplong)tcc_get_symbol_err(s1, "_start");
2062 else
2063 ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
2064 }
2065 if (file_type == TCC_OUTPUT_EXE && s1->static_link)
2066 fill_got(s1);
2067
2068 /* write elf file */
2069 if (file_type == TCC_OUTPUT_OBJ)
2070 mode = 0666;
2071 else
2072 mode = 0777;
2073 unlink(filename);
2074 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
2075 if (fd < 0) {
2076 tcc_error_noabort("could not write '%s'", filename);
2077 goto fail;
2078 }
2079 f = fdopen(fd, "wb");
2080 if (s1->verbose)
2081 printf("<- %s\n", filename);
2082
2083 #ifdef TCC_TARGET_COFF
2084 if (s1->output_format == TCC_OUTPUT_FORMAT_COFF) {
2085 tcc_output_coff(s1, f);
2086 } else
2087 #endif
2088 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
2089 sort_syms(s1, symtab_section);
2090
2091 /* align to 4 */
2092 file_offset = (file_offset + 3) & -4;
2093
2094 /* fill header */
2095 ehdr.e_ident[0] = ELFMAG0;
2096 ehdr.e_ident[1] = ELFMAG1;
2097 ehdr.e_ident[2] = ELFMAG2;
2098 ehdr.e_ident[3] = ELFMAG3;
2099 ehdr.e_ident[4] = ELFCLASSW;
2100 ehdr.e_ident[5] = ELFDATA2LSB;
2101 ehdr.e_ident[6] = EV_CURRENT;
2102 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2103 ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
2104 #endif
2105 #ifdef TCC_TARGET_ARM
2106 #ifdef TCC_ARM_EABI
2107 ehdr.e_ident[EI_OSABI] = 0;
2108 ehdr.e_flags = 4 << 24;
2109 #else
2110 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
2111 #endif
2112 #endif
2113 switch(file_type) {
2114 default:
2115 case TCC_OUTPUT_EXE:
2116 ehdr.e_type = ET_EXEC;
2117 break;
2118 case TCC_OUTPUT_DLL:
2119 ehdr.e_type = ET_DYN;
2120 break;
2121 case TCC_OUTPUT_OBJ:
2122 ehdr.e_type = ET_REL;
2123 break;
2124 }
2125 ehdr.e_machine = EM_TCC_TARGET;
2126 ehdr.e_version = EV_CURRENT;
2127 ehdr.e_shoff = file_offset;
2128 ehdr.e_ehsize = sizeof(ElfW(Ehdr));
2129 ehdr.e_shentsize = sizeof(ElfW(Shdr));
2130 ehdr.e_shnum = shnum;
2131 ehdr.e_shstrndx = shnum - 1;
2132
2133 fwrite(&ehdr, 1, sizeof(ElfW(Ehdr)), f);
2134 fwrite(phdr, 1, phnum * sizeof(ElfW(Phdr)), f);
2135 offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
2136
2137 for(i=1;i<s1->nb_sections;i++) {
2138 s = s1->sections[section_order[i]];
2139 if (s->sh_type != SHT_NOBITS) {
2140 if (s->sh_type == SHT_DYNSYM)
2141 patch_dynsym_undef(s1, s);
2142 while (offset < s->sh_offset) {
2143 fputc(0, f);
2144 offset++;
2145 }
2146 size = s->sh_size;
2147 fwrite(s->data, 1, size, f);
2148 offset += size;
2149 }
2150 }
2151
2152 /* output section headers */
2153 while (offset < ehdr.e_shoff) {
2154 fputc(0, f);
2155 offset++;
2156 }
2157
2158 for(i=0;i<s1->nb_sections;i++) {
2159 sh = &shdr;
2160 memset(sh, 0, sizeof(ElfW(Shdr)));
2161 s = s1->sections[i];
2162 if (s) {
2163 sh->sh_name = s->sh_name;
2164 sh->sh_type = s->sh_type;
2165 sh->sh_flags = s->sh_flags;
2166 sh->sh_entsize = s->sh_entsize;
2167 sh->sh_info = s->sh_info;
2168 if (s->link)
2169 sh->sh_link = s->link->sh_num;
2170 sh->sh_addralign = s->sh_addralign;
2171 sh->sh_addr = s->sh_addr;
2172 sh->sh_offset = s->sh_offset;
2173 sh->sh_size = s->sh_size;
2174 }
2175 fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
2176 }
2177 } else {
2178 tcc_output_binary(s1, f, section_order);
2179 }
2180 fclose(f);
2181
2182 ret = 0;
2183 the_end:
2184 tcc_free(s1->symtab_to_dynsym);
2185 tcc_free(section_order);
2186 tcc_free(phdr);
2187 tcc_free(s1->got_offsets);
2188 return ret;
2189 }
2190
2191 LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename)
2192 {
2193 int ret;
2194 #ifdef TCC_TARGET_PE
2195 if (s->output_type != TCC_OUTPUT_OBJ) {
2196 ret = pe_output_file(s, filename);
2197 } else
2198 #endif
2199 {
2200 ret = elf_output_file(s, filename);
2201 }
2202 return ret;
2203 }
2204
2205 static void *load_data(int fd, unsigned long file_offset, unsigned long size)
2206 {
2207 void *data;
2208
2209 data = tcc_malloc(size);
2210 lseek(fd, file_offset, SEEK_SET);
2211 read(fd, data, size);
2212 return data;
2213 }
2214
2215 typedef struct SectionMergeInfo {
2216 Section *s; /* corresponding existing section */
2217 unsigned long offset; /* offset of the new section in the existing section */
2218 uint8_t new_section; /* true if section 's' was added */
2219 uint8_t link_once; /* true if link once section */
2220 } SectionMergeInfo;
2221
2222 /* load an object file and merge it with current files */
2223 /* XXX: handle correctly stab (debug) info */
2224 ST_FUNC int tcc_load_object_file(TCCState *s1,
2225 int fd, unsigned long file_offset)
2226 {
2227 ElfW(Ehdr) ehdr;
2228 ElfW(Shdr) *shdr, *sh;
2229 int size, i, j, offset, offseti, nb_syms, sym_index, ret;
2230 unsigned char *strsec, *strtab;
2231 int *old_to_new_syms;
2232 char *sh_name, *name;
2233 SectionMergeInfo *sm_table, *sm;
2234 ElfW(Sym) *sym, *symtab;
2235 ElfW_Rel *rel, *rel_end;
2236 Section *s;
2237
2238 int stab_index;
2239 int stabstr_index;
2240
2241 stab_index = stabstr_index = 0;
2242
2243 if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr))
2244 goto fail1;
2245 if (ehdr.e_ident[0] != ELFMAG0 ||
2246 ehdr.e_ident[1] != ELFMAG1 ||
2247 ehdr.e_ident[2] != ELFMAG2 ||
2248 ehdr.e_ident[3] != ELFMAG3)
2249 goto fail1;
2250 /* test if object file */
2251 if (ehdr.e_type != ET_REL)
2252 goto fail1;
2253 /* test CPU specific stuff */
2254 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2255 ehdr.e_machine != EM_TCC_TARGET) {
2256 fail1:
2257 tcc_error_noabort("invalid object file");
2258 return -1;
2259 }
2260 /* read sections */
2261 shdr = load_data(fd, file_offset + ehdr.e_shoff,
2262 sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2263 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
2264
2265 /* load section names */
2266 sh = &shdr[ehdr.e_shstrndx];
2267 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2268
2269 /* load symtab and strtab */
2270 old_to_new_syms = NULL;
2271 symtab = NULL;
2272 strtab = NULL;
2273 nb_syms = 0;
2274 for(i = 1; i < ehdr.e_shnum; i++) {
2275 sh = &shdr[i];
2276 if (sh->sh_type == SHT_SYMTAB) {
2277 if (symtab) {
2278 tcc_error_noabort("object must contain only one symtab");
2279 fail:
2280 ret = -1;
2281 goto the_end;
2282 }
2283 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2284 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2285 sm_table[i].s = symtab_section;
2286
2287 /* now load strtab */
2288 sh = &shdr[sh->sh_link];
2289 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2290 }
2291 }
2292
2293 /* now examine each section and try to merge its content with the
2294 ones in memory */
2295 for(i = 1; i < ehdr.e_shnum; i++) {
2296 /* no need to examine section name strtab */
2297 if (i == ehdr.e_shstrndx)
2298 continue;
2299 sh = &shdr[i];
2300 sh_name = strsec + sh->sh_name;
2301 /* ignore sections types we do not handle */
2302 if (sh->sh_type != SHT_PROGBITS &&
2303 sh->sh_type != SHT_RELX &&
2304 #ifdef TCC_ARM_EABI
2305 sh->sh_type != SHT_ARM_EXIDX &&
2306 #endif
2307 sh->sh_type != SHT_NOBITS &&
2308 sh->sh_type != SHT_PREINIT_ARRAY &&
2309 sh->sh_type != SHT_INIT_ARRAY &&
2310 sh->sh_type != SHT_FINI_ARRAY &&
2311 strcmp(sh_name, ".stabstr")
2312 )
2313 continue;
2314 if (sh->sh_addralign < 1)
2315 sh->sh_addralign = 1;
2316 /* find corresponding section, if any */
2317 for(j = 1; j < s1->nb_sections;j++) {
2318 s = s1->sections[j];
2319 if (!strcmp(s->name, sh_name)) {
2320 if (!strncmp(sh_name, ".gnu.linkonce",
2321 sizeof(".gnu.linkonce") - 1)) {
2322 /* if a 'linkonce' section is already present, we
2323 do not add it again. It is a little tricky as
2324 symbols can still be defined in
2325 it. */
2326 sm_table[i].link_once = 1;
2327 goto next;
2328 } else {
2329 goto found;
2330 }
2331 }
2332 }
2333 /* not found: create new section */
2334 s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags);
2335 /* take as much info as possible from the section. sh_link and
2336 sh_info will be updated later */
2337 s->sh_addralign = sh->sh_addralign;
2338 s->sh_entsize = sh->sh_entsize;
2339 sm_table[i].new_section = 1;
2340 found:
2341 if (sh->sh_type != s->sh_type) {
2342 tcc_error_noabort("invalid section type");
2343 goto fail;
2344 }
2345
2346 /* align start of section */
2347 offset = s->data_offset;
2348
2349 if (0 == strcmp(sh_name, ".stab")) {
2350 stab_index = i;
2351 goto no_align;
2352 }
2353 if (0 == strcmp(sh_name, ".stabstr")) {
2354 stabstr_index = i;
2355 goto no_align;
2356 }
2357
2358 size = sh->sh_addralign - 1;
2359 offset = (offset + size) & ~size;
2360 if (sh->sh_addralign > s->sh_addralign)
2361 s->sh_addralign = sh->sh_addralign;
2362 s->data_offset = offset;
2363 no_align:
2364 sm_table[i].offset = offset;
2365 sm_table[i].s = s;
2366 /* concatenate sections */
2367 size = sh->sh_size;
2368 if (sh->sh_type != SHT_NOBITS) {
2369 unsigned char *ptr;
2370 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
2371 ptr = section_ptr_add(s, size);
2372 read(fd, ptr, size);
2373 } else {
2374 s->data_offset += size;
2375 }
2376 next: ;
2377 }
2378
2379 /* //gr relocate stab strings */
2380 if (stab_index && stabstr_index) {
2381 Stab_Sym *a, *b;
2382 unsigned o;
2383 s = sm_table[stab_index].s;
2384 a = (Stab_Sym *)(s->data + sm_table[stab_index].offset);
2385 b = (Stab_Sym *)(s->data + s->data_offset);
2386 o = sm_table[stabstr_index].offset;
2387 while (a < b)
2388 a->n_strx += o, a++;
2389 }
2390
2391 /* second short pass to update sh_link and sh_info fields of new
2392 sections */
2393 for(i = 1; i < ehdr.e_shnum; i++) {
2394 s = sm_table[i].s;
2395 if (!s || !sm_table[i].new_section)
2396 continue;
2397 sh = &shdr[i];
2398 if (sh->sh_link > 0)
2399 s->link = sm_table[sh->sh_link].s;
2400 if (sh->sh_type == SHT_RELX) {
2401 s->sh_info = sm_table[sh->sh_info].s->sh_num;
2402 /* update backward link */
2403 s1->sections[s->sh_info]->reloc = s;
2404 }
2405 }
2406 sm = sm_table;
2407
2408 /* resolve symbols */
2409 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
2410
2411 sym = symtab + 1;
2412 for(i = 1; i < nb_syms; i++, sym++) {
2413 if (sym->st_shndx != SHN_UNDEF &&
2414 sym->st_shndx < SHN_LORESERVE) {
2415 sm = &sm_table[sym->st_shndx];
2416 if (sm->link_once) {
2417 /* if a symbol is in a link once section, we use the
2418 already defined symbol. It is very important to get
2419 correct relocations */
2420 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
2421 name = strtab + sym->st_name;
2422 sym_index = find_elf_sym(symtab_section, name);
2423 if (sym_index)
2424 old_to_new_syms[i] = sym_index;
2425 }
2426 continue;
2427 }
2428 /* if no corresponding section added, no need to add symbol */
2429 if (!sm->s)
2430 continue;
2431 /* convert section number */
2432 sym->st_shndx = sm->s->sh_num;
2433 /* offset value */
2434 sym->st_value += sm->offset;
2435 }
2436 /* add symbol */
2437 name = strtab + sym->st_name;
2438 sym_index = add_elf_sym(symtab_section, sym->st_value, sym->st_size,
2439 sym->st_info, sym->st_other,
2440 sym->st_shndx, name);
2441 old_to_new_syms[i] = sym_index;
2442 }
2443
2444 /* third pass to patch relocation entries */
2445 for(i = 1; i < ehdr.e_shnum; i++) {
2446 s = sm_table[i].s;
2447 if (!s)
2448 continue;
2449 sh = &shdr[i];
2450 offset = sm_table[i].offset;
2451 switch(s->sh_type) {
2452 case SHT_RELX:
2453 /* take relocation offset information */
2454 offseti = sm_table[sh->sh_info].offset;
2455 rel_end = (ElfW_Rel *)(s->data + s->data_offset);
2456 for(rel = (ElfW_Rel *)(s->data + offset);
2457 rel < rel_end;
2458 rel++) {
2459 int type;
2460 unsigned sym_index;
2461 /* convert symbol index */
2462 type = ELFW(R_TYPE)(rel->r_info);
2463 sym_index = ELFW(R_SYM)(rel->r_info);
2464 /* NOTE: only one symtab assumed */
2465 if (sym_index >= nb_syms)
2466 goto invalid_reloc;
2467 sym_index = old_to_new_syms[sym_index];
2468 /* ignore link_once in rel section. */
2469 if (!sym_index && !sm->link_once
2470 #ifdef TCC_TARGET_ARM
2471 && type != R_ARM_V4BX
2472 #endif
2473 ) {
2474 invalid_reloc:
2475 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2476 i, strsec + sh->sh_name, rel->r_offset);
2477 goto fail;
2478 }
2479 rel->r_info = ELFW(R_INFO)(sym_index, type);
2480 /* offset the relocation offset */
2481 rel->r_offset += offseti;
2482 }
2483 break;
2484 default:
2485 break;
2486 }
2487 }
2488
2489 ret = 0;
2490 the_end:
2491 tcc_free(symtab);
2492 tcc_free(strtab);
2493 tcc_free(old_to_new_syms);
2494 tcc_free(sm_table);
2495 tcc_free(strsec);
2496 tcc_free(shdr);
2497 return ret;
2498 }
2499
2500 typedef struct ArchiveHeader {
2501 char ar_name[16]; /* name of this member */
2502 char ar_date[12]; /* file mtime */
2503 char ar_uid[6]; /* owner uid; printed as decimal */
2504 char ar_gid[6]; /* owner gid; printed as decimal */
2505 char ar_mode[8]; /* file mode, printed as octal */
2506 char ar_size[10]; /* file size, printed as decimal */
2507 char ar_fmag[2]; /* should contain ARFMAG */
2508 } ArchiveHeader;
2509
2510 static int get_be32(const uint8_t *b)
2511 {
2512 return b[3] | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
2513 }
2514
2515 /* load only the objects which resolve undefined symbols */
2516 static int tcc_load_alacarte(TCCState *s1, int fd, int size)
2517 {
2518 int i, bound, nsyms, sym_index, off, ret;
2519 uint8_t *data;
2520 const char *ar_names, *p;
2521 const uint8_t *ar_index;
2522 ElfW(Sym) *sym;
2523
2524 data = tcc_malloc(size);
2525 if (read(fd, data, size) != size)
2526 goto fail;
2527 nsyms = get_be32(data);
2528 ar_index = data + 4;
2529 ar_names = ar_index + nsyms * 4;
2530
2531 do {
2532 bound = 0;
2533 for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2534 sym_index = find_elf_sym(symtab_section, p);
2535 if(sym_index) {
2536 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
2537 if(sym->st_shndx == SHN_UNDEF) {
2538 off = get_be32(ar_index + i * 4) + sizeof(ArchiveHeader);
2539 #if 0
2540 printf("%5d\t%s\t%08x\n", i, p, sym->st_shndx);
2541 #endif
2542 ++bound;
2543 lseek(fd, off, SEEK_SET);
2544 if(tcc_load_object_file(s1, fd, off) < 0) {
2545 fail:
2546 ret = -1;
2547 goto the_end;
2548 }
2549 }
2550 }
2551 }
2552 } while(bound);
2553 ret = 0;
2554 the_end:
2555 tcc_free(data);
2556 return ret;
2557 }
2558
2559 /* load a '.a' file */
2560 ST_FUNC int tcc_load_archive(TCCState *s1, int fd)
2561 {
2562 ArchiveHeader hdr;
2563 char ar_size[11];
2564 char ar_name[17];
2565 char magic[8];
2566 int size, len, i;
2567 unsigned long file_offset;
2568
2569 /* skip magic which was already checked */
2570 read(fd, magic, sizeof(magic));
2571
2572 for(;;) {
2573 len = read(fd, &hdr, sizeof(hdr));
2574 if (len == 0)
2575 break;
2576 if (len != sizeof(hdr)) {
2577 tcc_error_noabort("invalid archive");
2578 return -1;
2579 }
2580 memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
2581 ar_size[sizeof(hdr.ar_size)] = '\0';
2582 size = strtol(ar_size, NULL, 0);
2583 memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
2584 for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
2585 if (ar_name[i] != ' ')
2586 break;
2587 }
2588 ar_name[i + 1] = '\0';
2589 // printf("name='%s' size=%d %s\n", ar_name, size, ar_size);
2590 file_offset = lseek(fd, 0, SEEK_CUR);
2591 /* align to even */
2592 size = (size + 1) & ~1;
2593 if (!strcmp(ar_name, "/")) {
2594 /* coff symbol table : we handle it */
2595 if(s1->alacarte_link)
2596 return tcc_load_alacarte(s1, fd, size);
2597 } else if (!strcmp(ar_name, "//") ||
2598 !strcmp(ar_name, "__.SYMDEF") ||
2599 !strcmp(ar_name, "__.SYMDEF/") ||
2600 !strcmp(ar_name, "ARFILENAMES/")) {
2601 /* skip symbol table or archive names */
2602 } else {
2603 if (tcc_load_object_file(s1, fd, file_offset) < 0)
2604 return -1;
2605 }
2606 lseek(fd, file_offset + size, SEEK_SET);
2607 }
2608 return 0;
2609 }
2610
2611 #ifndef TCC_TARGET_PE
2612 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2613 is referenced by the user (so it should be added as DT_NEEDED in
2614 the generated ELF file) */
2615 ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
2616 {
2617 ElfW(Ehdr) ehdr;
2618 ElfW(Shdr) *shdr, *sh, *sh1;
2619 int i, j, nb_syms, nb_dts, sym_bind, ret;
2620 ElfW(Sym) *sym, *dynsym;
2621 ElfW(Dyn) *dt, *dynamic;
2622 unsigned char *dynstr;
2623 const char *name, *soname;
2624 DLLReference *dllref;
2625
2626 read(fd, &ehdr, sizeof(ehdr));
2627
2628 /* test CPU specific stuff */
2629 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2630 ehdr.e_machine != EM_TCC_TARGET) {
2631 tcc_error_noabort("bad architecture");
2632 return -1;
2633 }
2634
2635 /* read sections */
2636 shdr = load_data(fd, ehdr.e_shoff, sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2637
2638 /* load dynamic section and dynamic symbols */
2639 nb_syms = 0;
2640 nb_dts = 0;
2641 dynamic = NULL;
2642 dynsym = NULL; /* avoid warning */
2643 dynstr = NULL; /* avoid warning */
2644 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
2645 switch(sh->sh_type) {
2646 case SHT_DYNAMIC:
2647 nb_dts = sh->sh_size / sizeof(ElfW(Dyn));
2648 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
2649 break;
2650 case SHT_DYNSYM:
2651 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2652 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
2653 sh1 = &shdr[sh->sh_link];
2654 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
2655 break;
2656 default:
2657 break;
2658 }
2659 }
2660
2661 /* compute the real library name */
2662 soname = tcc_basename(filename);
2663
2664 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2665 if (dt->d_tag == DT_SONAME) {
2666 soname = dynstr + dt->d_un.d_val;
2667 }
2668 }
2669
2670 /* if the dll is already loaded, do not load it */
2671 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2672 dllref = s1->loaded_dlls[i];
2673 if (!strcmp(soname, dllref->name)) {
2674 /* but update level if needed */
2675 if (level < dllref->level)
2676 dllref->level = level;
2677 ret = 0;
2678 goto the_end;
2679 }
2680 }
2681
2682 // printf("loading dll '%s'\n", soname);
2683
2684 /* add the dll and its level */
2685 dllref = tcc_mallocz(sizeof(DLLReference) + strlen(soname));
2686 dllref->level = level;
2687 strcpy(dllref->name, soname);
2688 dynarray_add((void ***)&s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
2689
2690 /* add dynamic symbols in dynsym_section */
2691 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
2692 sym_bind = ELFW(ST_BIND)(sym->st_info);
2693 if (sym_bind == STB_LOCAL)
2694 continue;
2695 name = dynstr + sym->st_name;
2696 add_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
2697 sym->st_info, sym->st_other, sym->st_shndx, name);
2698 }
2699
2700 /* load all referenced DLLs */
2701 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2702 switch(dt->d_tag) {
2703 case DT_NEEDED:
2704 name = dynstr + dt->d_un.d_val;
2705 for(j = 0; j < s1->nb_loaded_dlls; j++) {
2706 dllref = s1->loaded_dlls[j];
2707 if (!strcmp(name, dllref->name))
2708 goto already_loaded;
2709 }
2710 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
2711 tcc_error_noabort("referenced dll '%s' not found", name);
2712 ret = -1;
2713 goto the_end;
2714 }
2715 already_loaded:
2716 break;
2717 }
2718 }
2719 ret = 0;
2720 the_end:
2721 tcc_free(dynstr);
2722 tcc_free(dynsym);
2723 tcc_free(dynamic);
2724 tcc_free(shdr);
2725 return ret;
2726 }
2727
2728 #define LD_TOK_NAME 256
2729 #define LD_TOK_EOF (-1)
2730
2731 /* return next ld script token */
2732 static int ld_next(TCCState *s1, char *name, int name_size)
2733 {
2734 int c;
2735 char *q;
2736
2737 redo:
2738 switch(ch) {
2739 case ' ':
2740 case '\t':
2741 case '\f':
2742 case '\v':
2743 case '\r':
2744 case '\n':
2745 inp();
2746 goto redo;
2747 case '/':
2748 minp();
2749 if (ch == '*') {
2750 file->buf_ptr = parse_comment(file->buf_ptr);
2751 ch = file->buf_ptr[0];
2752 goto redo;
2753 } else {
2754 q = name;
2755 *q++ = '/';
2756 goto parse_name;
2757 }
2758 break;
2759 /* case 'a' ... 'z': */
2760 case 'a':
2761 case 'b':
2762 case 'c':
2763 case 'd':
2764 case 'e':
2765 case 'f':
2766 case 'g':
2767 case 'h':
2768 case 'i':
2769 case 'j':
2770 case 'k':
2771 case 'l':
2772 case 'm':
2773 case 'n':
2774 case 'o':
2775 case 'p':
2776 case 'q':
2777 case 'r':
2778 case 's':
2779 case 't':
2780 case 'u':
2781 case 'v':
2782 case 'w':
2783 case 'x':
2784 case 'y':
2785 case 'z':
2786 /* case 'A' ... 'z': */
2787 case 'A':
2788 case 'B':
2789 case 'C':
2790 case 'D':
2791 case 'E':
2792 case 'F':
2793 case 'G':
2794 case 'H':
2795 case 'I':
2796 case 'J':
2797 case 'K':
2798 case 'L':
2799 case 'M':
2800 case 'N':
2801 case 'O':
2802 case 'P':
2803 case 'Q':
2804 case 'R':
2805 case 'S':
2806 case 'T':
2807 case 'U':
2808 case 'V':
2809 case 'W':
2810 case 'X':
2811 case 'Y':
2812 case 'Z':
2813 case '_':
2814 case '\\':
2815 case '.':
2816 case '$':
2817 case '~':
2818 q = name;
2819 parse_name:
2820 for(;;) {
2821 if (!((ch >= 'a' && ch <= 'z') ||
2822 (ch >= 'A' && ch <= 'Z') ||
2823 (ch >= '0' && ch <= '9') ||
2824 strchr("/.-_+=$:\\,~", ch)))
2825 break;
2826 if ((q - name) < name_size - 1) {
2827 *q++ = ch;
2828 }
2829 minp();
2830 }
2831 *q = '\0';
2832 c = LD_TOK_NAME;
2833 break;
2834 case CH_EOF:
2835 c = LD_TOK_EOF;
2836 break;
2837 default:
2838 c = ch;
2839 inp();
2840 break;
2841 }
2842 #if 0
2843 printf("tok=%c %d\n", c, c);
2844 if (c == LD_TOK_NAME)
2845 printf(" name=%s\n", name);
2846 #endif
2847 return c;
2848 }
2849
2850 /*
2851 * Extract the file name from the library name
2852 *
2853 * /!\ No test on filename capacity, be careful
2854 */
2855 static void libname_to_filename(TCCState *s1, const char libname[], char filename[])
2856 {
2857 if (!s1->static_link) {
2858 sprintf(filename, "lib%s.so", libname);
2859 } else {
2860 sprintf(filename, "lib%s.a", libname);
2861 }
2862 }
2863
2864 static int ld_add_file(TCCState *s1, const char filename[])
2865 {
2866 int ret;
2867
2868 ret = tcc_add_file_internal(s1, filename, 0);
2869 if (ret)
2870 ret = tcc_add_dll(s1, filename, 0);
2871 return ret;
2872 }
2873
2874 static inline int new_undef_syms(void)
2875 {
2876 int ret = 0;
2877 ret = new_undef_sym;
2878 new_undef_sym = 0;
2879 return ret;
2880 }
2881
2882 static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
2883 {
2884 char filename[1024], libname[1024];
2885 int t, group, nblibs = 0, ret = 0;
2886 char **libs = NULL;
2887
2888 group = !strcmp(cmd, "GROUP");
2889 if (!as_needed)
2890 new_undef_syms();
2891 t = ld_next(s1, filename, sizeof(filename));
2892 if (t != '(')
2893 expect("(");
2894 t = ld_next(s1, filename, sizeof(filename));
2895 for(;;) {
2896 libname[0] = '\0';
2897 if (t == LD_TOK_EOF) {
2898 tcc_error_noabort("unexpected end of file");
2899 ret = -1;
2900 goto lib_parse_error;
2901 } else if (t == ')') {
2902 break;
2903 } else if (t == '-') {
2904 t = ld_next(s1, filename, sizeof(filename));
2905 if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
2906 tcc_error_noabort("library name expected");
2907 ret = -1;
2908 goto lib_parse_error;
2909 }
2910 strcpy(libname, &filename[1]);
2911 libname_to_filename(s1, libname, filename);
2912 } else if (t != LD_TOK_NAME) {
2913 tcc_error_noabort("filename expected");
2914 ret = -1;
2915 goto lib_parse_error;
2916 }
2917 if (!strcmp(filename, "AS_NEEDED")) {
2918 ret = ld_add_file_list(s1, cmd, 1);
2919 if (ret)
2920 goto lib_parse_error;
2921 } else {
2922 /* TODO: Implement AS_NEEDED support. Ignore it for now */
2923 if (!as_needed) {
2924 ret = ld_add_file(s1, filename);
2925 if (ret)
2926 goto lib_parse_error;
2927 if (group) {
2928 /* Add the filename *and* the libname to avoid future conversions */
2929 dynarray_add((void ***) &libs, &nblibs, tcc_strdup(filename));
2930 if (libname[0] != '\0')
2931 dynarray_add((void ***) &libs, &nblibs, tcc_strdup(libname));
2932 }
2933 }
2934 }
2935 t = ld_next(s1, filename, sizeof(filename));
2936 if (t == ',') {
2937 t = ld_next(s1, filename, sizeof(filename));
2938 }
2939 }
2940 if (group && !as_needed) {
2941 while (new_undef_syms()) {
2942 int i;
2943
2944 for (i = 0; i < nblibs; i ++)
2945 ld_add_file(s1, libs[i]);
2946 }
2947 }
2948 lib_parse_error:
2949 dynarray_reset(&libs, &nblibs);
2950 return ret;
2951 }
2952
2953 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
2954 files */
2955 ST_FUNC int tcc_load_ldscript(TCCState *s1)
2956 {
2957 char cmd[64];
2958 char filename[1024];
2959 int t, ret;
2960
2961 ch = file->buf_ptr[0];
2962 ch = handle_eob();
2963 for(;;) {
2964 t = ld_next(s1, cmd, sizeof(cmd));
2965 if (t == LD_TOK_EOF)
2966 return 0;
2967 else if (t != LD_TOK_NAME)
2968 return -1;
2969 if (!strcmp(cmd, "INPUT") ||
2970 !strcmp(cmd, "GROUP")) {
2971 ret = ld_add_file_list(s1, cmd, 0);
2972 if (ret)
2973 return ret;
2974 } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
2975 !strcmp(cmd, "TARGET")) {
2976 /* ignore some commands */
2977 t = ld_next(s1, cmd, sizeof(cmd));
2978 if (t != '(')
2979 expect("(");
2980 for(;;) {
2981 t = ld_next(s1, filename, sizeof(filename));
2982 if (t == LD_TOK_EOF) {
2983 tcc_error_noabort("unexpected end of file");
2984 return -1;
2985 } else if (t == ')') {
2986 break;
2987 }
2988 }
2989 } else {
2990 return -1;
2991 }
2992 }
2993 return 0;
2994 }
2995 #endif /* ndef TCC_TARGET_PE */
tinycc fork to help me test changes before commit to mob