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