?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "Add macro to browse reloc and sym entries"
[tinycc.git] / tccelf.c
blobc54f5ca445bf30d48044585609d1460edcf69a16
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 #if defined TCC_IS_NATIVE || defined TCC_TARGET_PE
182 /* return elf symbol value or error */
183 ST_FUNC void* tcc_get_symbol_err(TCCState *s, const char *name)
184 {
185 return (void*)(uintptr_t)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 0
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, is_bl, th_ko;
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_bl = (*(unsigned *) ptr) >> 24 == 0xeb;
615 is_call = (type == R_ARM_CALL || (type == R_ARM_PC24 && is_bl));
616 x += val - addr;
617 h = x & 2;
618 th_ko = (x & 3) && (!blx_avail || !is_call);
619 #ifdef TCC_HAS_RUNTIME_PLTGOT
620 if (s1->output_type == TCC_OUTPUT_MEMORY) {
621 if (th_ko || x >= 0x2000000 || x < -0x2000000) {
622 x += add_jmp_table(s1, val) - val; /* add veneer */
623 th_ko = (x & 3) && (!blx_avail || !is_call);
624 is_thumb = 0; /* Veneer uses ARM instructions */
625 }
626 }
627 #endif
628 if (th_ko || x >= 0x2000000 || x < -0x2000000)
629 tcc_error("can't relocate value at %x",addr);
630 x >>= 2;
631 x &= 0xffffff;
632 /* Only reached if blx is avail and it is a call */
633 if (is_thumb) {
634 x |= h << 24;
635 (*(int *)ptr) = 0xfa << 24; /* bl -> blx */
636 }
637 (*(int *) ptr) |= x;
638 }
639 break;
640 /* Since these relocations only concern Thumb-2 and blx instruction was
641 introduced before Thumb-2, we can assume blx is available and not
642 guard its use */
643 case R_ARM_THM_PC22:
644 case R_ARM_THM_JUMP24:
645 {
646 int x, hi, lo, s, j1, j2, i1, i2, imm10, imm11;
647 int to_thumb, is_call, to_plt, blx_bit = 1 << 12;
648 Section *plt;
649
650 /* weak reference */
651 if (sym->st_shndx == SHN_UNDEF &&
652 ELFW(ST_BIND)(sym->st_info) == STB_WEAK)
653 break;
654
655 /* Get initial offset */
656 hi = (*(uint16_t *)ptr);
657 lo = (*(uint16_t *)(ptr+2));
658 s = (hi >> 10) & 1;
659 j1 = (lo >> 13) & 1;
660 j2 = (lo >> 11) & 1;
661 i1 = (j1 ^ s) ^ 1;
662 i2 = (j2 ^ s) ^ 1;
663 imm10 = hi & 0x3ff;
664 imm11 = lo & 0x7ff;
665 x = (s << 24) | (i1 << 23) | (i2 << 22) |
666 (imm10 << 12) | (imm11 << 1);
667 if (x & 0x01000000)
668 x -= 0x02000000;
669
670 /* Relocation infos */
671 to_thumb = val & 1;
672 plt = s1->plt;
673 to_plt = (val >= plt->sh_addr) &&
674 (val < plt->sh_addr + plt->data_offset);
675 is_call = (type == R_ARM_THM_PC22);
676
677 /* Compute final offset */
678 if (to_plt && !is_call) /* Point to 1st instr of Thumb stub */
679 x -= 4;
680 x += val - addr;
681 if (!to_thumb && is_call) {
682 blx_bit = 0; /* bl -> blx */
683 x = (x + 3) & -4; /* Compute offset from aligned PC */
684 }
685
686 /* Check that relocation is possible
687 * offset must not be out of range
688 * if target is to be entered in arm mode:
689 - bit 1 must not set
690 - instruction must be a call (bl) or a jump to PLT */
691 if (!to_thumb || x >= 0x1000000 || x < -0x1000000)
692 if (to_thumb || (val & 2) || (!is_call && !to_plt))
693 tcc_error("can't relocate value at %x",addr);
694
695 /* Compute and store final offset */
696 s = (x >> 24) & 1;
697 i1 = (x >> 23) & 1;
698 i2 = (x >> 22) & 1;
699 j1 = s ^ (i1 ^ 1);
700 j2 = s ^ (i2 ^ 1);
701 imm10 = (x >> 12) & 0x3ff;
702 imm11 = (x >> 1) & 0x7ff;
703 (*(uint16_t *)ptr) = (uint16_t) ((hi & 0xf800) |
704 (s << 10) | imm10);
705 (*(uint16_t *)(ptr+2)) = (uint16_t) ((lo & 0xc000) |
706 (j1 << 13) | blx_bit | (j2 << 11) |
707 imm11);
708 }
709 break;
710 case R_ARM_MOVT_ABS:
711 case R_ARM_MOVW_ABS_NC:
712 {
713 int x, imm4, imm12;
714 if (type == R_ARM_MOVT_ABS)
715 val >>= 16;
716 imm12 = val & 0xfff;
717 imm4 = (val >> 12) & 0xf;
718 x = (imm4 << 16) | imm12;
719 if (type == R_ARM_THM_MOVT_ABS)
720 *(int *)ptr |= x;
721 else
722 *(int *)ptr += x;
723 }
724 break;
725 case R_ARM_THM_MOVT_ABS:
726 case R_ARM_THM_MOVW_ABS_NC:
727 {
728 int x, i, imm4, imm3, imm8;
729 if (type == R_ARM_THM_MOVT_ABS)
730 val >>= 16;
731 imm8 = val & 0xff;
732 imm3 = (val >> 8) & 0x7;
733 i = (val >> 11) & 1;
734 imm4 = (val >> 12) & 0xf;
735 x = (imm3 << 28) | (imm8 << 16) | (i << 10) | imm4;
736 if (type == R_ARM_THM_MOVT_ABS)
737 *(int *)ptr |= x;
738 else
739 *(int *)ptr += x;
740 }
741 break;
742 case R_ARM_PREL31:
743 {
744 int x;
745 x = (*(int *)ptr) & 0x7fffffff;
746 (*(int *)ptr) &= 0x80000000;
747 x = (x * 2) / 2;
748 x += val - addr;
749 if((x^(x>>1))&0x40000000)
750 tcc_error("can't relocate value at %x",addr);
751 (*(int *)ptr) |= x & 0x7fffffff;
752 }
753 case R_ARM_ABS32:
754 *(int *)ptr += val;
755 break;
756 case R_ARM_REL32:
757 *(int *)ptr += val - addr;
758 break;
759 case R_ARM_GOTPC:
760 *(int *)ptr += s1->got->sh_addr - addr;
761 break;
762 case R_ARM_GOTOFF:
763 *(int *)ptr += val - s1->got->sh_addr;
764 break;
765 case R_ARM_GOT32:
766 /* we load the got offset */
767 *(int *)ptr += s1->sym_attrs[sym_index].got_offset;
768 break;
769 case R_ARM_COPY:
770 break;
771 case R_ARM_V4BX:
772 /* trade Thumb support for ARMv4 support */
773 if ((0x0ffffff0 & *(int*)ptr) == 0x012FFF10)
774 *(int*)ptr ^= 0xE12FFF10 ^ 0xE1A0F000; /* BX Rm -> MOV PC, Rm */
775 break;
776 default:
777 fprintf(stderr,"FIXME: handle reloc type %x at %x [%p] to %x\n",
778 type, (unsigned)addr, ptr, (unsigned)val);
779 break;
780 #elif defined(TCC_TARGET_C67)
781 case R_C60_32:
782 *(int *)ptr += val;
783 break;
784 case R_C60LO16:
785 {
786 uint32_t orig;
787
788 /* put the low 16 bits of the absolute address
789 add to what is already there */
790
791 orig = ((*(int *)(ptr )) >> 7) & 0xffff;
792 orig |= (((*(int *)(ptr+4)) >> 7) & 0xffff) << 16;
793
794 /* patch both at once - assumes always in pairs Low - High */
795
796 *(int *) ptr = (*(int *) ptr & (~(0xffff << 7)) ) | (((val+orig) & 0xffff) << 7);
797 *(int *)(ptr+4) = (*(int *)(ptr+4) & (~(0xffff << 7)) ) | ((((val+orig)>>16) & 0xffff) << 7);
798 }
799 break;
800 case R_C60HI16:
801 break;
802 default:
803 fprintf(stderr,"FIXME: handle reloc type %x at %x [%p] to %x\n",
804 type, (unsigned)addr, ptr, (unsigned)val);
805 break;
806 #elif defined(TCC_TARGET_X86_64)
807 case R_X86_64_64:
808 if (s1->output_type == TCC_OUTPUT_DLL) {
809 qrel->r_info = ELFW(R_INFO)(0, R_X86_64_RELATIVE);
810 qrel->r_addend = *(long long *)ptr + val;
811 qrel++;
812 }
813 *(long long *)ptr += val;
814 break;
815 case R_X86_64_32:
816 case R_X86_64_32S:
817 if (s1->output_type == TCC_OUTPUT_DLL) {
818 /* XXX: this logic may depend on TCC's codegen
819 now TCC uses R_X86_64_32 even for a 64bit pointer */
820 qrel->r_info = ELFW(R_INFO)(0, R_X86_64_RELATIVE);
821 qrel->r_addend = *(int *)ptr + val;
822 qrel++;
823 }
824 *(int *)ptr += val;
825 break;
826
827 case R_X86_64_PC32:
828 if (s1->output_type == TCC_OUTPUT_DLL) {
829 /* DLL relocation */
830 esym_index = s1->symtab_to_dynsym[sym_index];
831 if (esym_index) {
832 qrel->r_offset = rel->r_offset;
833 qrel->r_info = ELFW(R_INFO)(esym_index, R_X86_64_PC32);
834 qrel->r_addend = *(int *)ptr;
835 qrel++;
836 break;
837 }
838 }
839 /* fall through */
840 case R_X86_64_PLT32: {
841 long long diff;
842 diff = (long long)val - addr;
843 if (diff <= -2147483647 || diff > 2147483647) {
844 #ifdef TCC_HAS_RUNTIME_PLTGOT
845 /* XXX: naive support for over 32bit jump */
846 if (s1->output_type == TCC_OUTPUT_MEMORY) {
847 val = (add_jmp_table(s1, val - rel->r_addend) +
848 rel->r_addend);
849 diff = val - addr;
850 }
851 #endif
852 if (diff <= -2147483647 || diff > 2147483647) {
853 tcc_error("internal error: relocation failed");
854 }
855 }
856 *(int *)ptr += diff;
857 }
858 break;
859 case R_X86_64_GLOB_DAT:
860 case R_X86_64_JUMP_SLOT:
861 /* They don't need addend */
862 *(int *)ptr = val - rel->r_addend;
863 break;
864 case R_X86_64_GOTPCREL:
865 #ifdef TCC_HAS_RUNTIME_PLTGOT
866 if (s1->output_type == TCC_OUTPUT_MEMORY) {
867 val = add_got_table(s1, val - rel->r_addend) + rel->r_addend;
868 *(int *)ptr += val - addr;
869 break;
870 }
871 #endif
872 *(int *)ptr += (s1->got->sh_addr - addr +
873 s1->sym_attrs[sym_index].got_offset - 4);
874 break;
875 case R_X86_64_GOTTPOFF:
876 *(int *)ptr += val - s1->got->sh_addr;
877 break;
878 case R_X86_64_GOT32:
879 /* we load the got offset */
880 *(int *)ptr += s1->sym_attrs[sym_index].got_offset;
881 break;
882 #else
883 #error unsupported processor
884 #endif
885 }
886 }
887 /* if the relocation is allocated, we change its symbol table */
888 if (sr->sh_flags & SHF_ALLOC)
889 sr->link = s1->dynsym;
890 }
891
892 /* relocate relocation table in 'sr' */
893 static void relocate_rel(TCCState *s1, Section *sr)
894 {
895 Section *s;
896 ElfW_Rel *rel, *rel_end;
897
898 s = s1->sections[sr->sh_info];
899 rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
900 for(rel = (ElfW_Rel *)sr->data;
901 rel < rel_end;
902 rel++) {
903 rel->r_offset += s->sh_addr;
904 }
905 }
906
907 /* count the number of dynamic relocations so that we can reserve
908 their space */
909 static int prepare_dynamic_rel(TCCState *s1, Section *sr)
910 {
911 ElfW_Rel *rel, *rel_end;
912 int sym_index, esym_index, type, count;
913
914 count = 0;
915 rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
916 for(rel = (ElfW_Rel *)sr->data; rel < rel_end; rel++) {
917 sym_index = ELFW(R_SYM)(rel->r_info);
918 type = ELFW(R_TYPE)(rel->r_info);
919 switch(type) {
920 #if defined(TCC_TARGET_I386)
921 case R_386_32:
922 #elif defined(TCC_TARGET_X86_64)
923 case R_X86_64_32:
924 case R_X86_64_32S:
925 case R_X86_64_64:
926 #endif
927 count++;
928 break;
929 #if defined(TCC_TARGET_I386)
930 case R_386_PC32:
931 #elif defined(TCC_TARGET_X86_64)
932 case R_X86_64_PC32:
933 #endif
934 esym_index = s1->symtab_to_dynsym[sym_index];
935 if (esym_index)
936 count++;
937 break;
938 default:
939 break;
940 }
941 }
942 if (count) {
943 /* allocate the section */
944 sr->sh_flags |= SHF_ALLOC;
945 sr->sh_size = count * sizeof(ElfW_Rel);
946 }
947 return count;
948 }
949
950 static struct sym_attr *alloc_sym_attr(TCCState *s1, int index)
951 {
952 int n;
953 struct sym_attr *tab;
954
955 if (index >= s1->nb_sym_attrs) {
956 /* find immediately bigger power of 2 and reallocate array */
957 n = 1;
958 while (index >= n)
959 n *= 2;
960 tab = tcc_realloc(s1->sym_attrs, n * sizeof(*s1->sym_attrs));
961 s1->sym_attrs = tab;
962 memset(s1->sym_attrs + s1->nb_sym_attrs, 0,
963 (n - s1->nb_sym_attrs) * sizeof(*s1->sym_attrs));
964 s1->nb_sym_attrs = n;
965 }
966 return &s1->sym_attrs[index];
967 }
968
969 /* XXX: suppress that */
970 static void put32(unsigned char *p, uint32_t val)
971 {
972 p[0] = val;
973 p[1] = val >> 8;
974 p[2] = val >> 16;
975 p[3] = val >> 24;
976 }
977
978 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_ARM) || \
979 defined(TCC_TARGET_X86_64)
980 static uint32_t get32(unsigned char *p)
981 {
982 return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
983 }
984 #endif
985
986 static void build_got(TCCState *s1)
987 {
988 unsigned char *ptr;
989
990 /* if no got, then create it */
991 s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
992 s1->got->sh_entsize = 4;
993 add_elf_sym(symtab_section, 0, 4, ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
994 0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
995 ptr = section_ptr_add(s1->got, 3 * PTR_SIZE);
996 #if PTR_SIZE == 4
997 /* keep space for _DYNAMIC pointer, if present */
998 put32(ptr, 0);
999 /* two dummy got entries */
1000 put32(ptr + 4, 0);
1001 put32(ptr + 8, 0);
1002 #else
1003 /* keep space for _DYNAMIC pointer, if present */
1004 put32(ptr, 0);
1005 put32(ptr + 4, 0);
1006 /* two dummy got entries */
1007 put32(ptr + 8, 0);
1008 put32(ptr + 12, 0);
1009 put32(ptr + 16, 0);
1010 put32(ptr + 20, 0);
1011 #endif
1012 }
1013
1014 /* put a got entry corresponding to a symbol in symtab_section. 'size'
1015 and 'info' can be modifed if more precise info comes from the DLL */
1016 static void put_got_entry(TCCState *s1,
1017 int reloc_type, unsigned long size, int info,
1018 int sym_index)
1019 {
1020 int index;
1021 const char *name;
1022 ElfW(Sym) *sym;
1023 unsigned long offset;
1024 int *ptr;
1025
1026 if (!s1->got)
1027 build_got(s1);
1028
1029 /* if a got entry already exists for that symbol, no need to add one */
1030 if (sym_index < s1->nb_sym_attrs &&
1031 s1->sym_attrs[sym_index].got_offset)
1032 return;
1033
1034 alloc_sym_attr(s1, sym_index)->got_offset = s1->got->data_offset;
1035
1036 if (s1->dynsym) {
1037 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1038 name = symtab_section->link->data + sym->st_name;
1039 offset = sym->st_value;
1040 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
1041 if (reloc_type ==
1042 #ifdef TCC_TARGET_X86_64
1043 R_X86_64_JUMP_SLOT
1044 #else
1045 R_386_JMP_SLOT
1046 #endif
1047 ) {
1048 Section *plt;
1049 uint8_t *p;
1050 int modrm;
1051
1052 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
1053 modrm = 0x25;
1054 #else
1055 /* if we build a DLL, we add a %ebx offset */
1056 if (s1->output_type == TCC_OUTPUT_DLL)
1057 modrm = 0xa3;
1058 else
1059 modrm = 0x25;
1060 #endif
1061
1062 /* add a PLT entry */
1063 plt = s1->plt;
1064 if (plt->data_offset == 0) {
1065 /* first plt entry */
1066 p = section_ptr_add(plt, 16);
1067 p[0] = 0xff; /* pushl got + PTR_SIZE */
1068 p[1] = modrm + 0x10;
1069 put32(p + 2, PTR_SIZE);
1070 p[6] = 0xff; /* jmp *(got + PTR_SIZE * 2) */
1071 p[7] = modrm;
1072 put32(p + 8, PTR_SIZE * 2);
1073 }
1074
1075 p = section_ptr_add(plt, 16);
1076 p[0] = 0xff; /* jmp *(got + x) */
1077 p[1] = modrm;
1078 put32(p + 2, s1->got->data_offset);
1079 p[6] = 0x68; /* push $xxx */
1080 put32(p + 7, (plt->data_offset - 32) >> 1);
1081 p[11] = 0xe9; /* jmp plt_start */
1082 put32(p + 12, -(plt->data_offset));
1083
1084 /* the symbol is modified so that it will be relocated to
1085 the PLT */
1086 #if !defined(TCC_OUTPUT_DLL_WITH_PLT)
1087 if (s1->output_type == TCC_OUTPUT_EXE)
1088 #endif
1089 offset = plt->data_offset - 16;
1090 }
1091 #elif defined(TCC_TARGET_ARM)
1092 if (reloc_type == R_ARM_JUMP_SLOT) {
1093 Section *plt;
1094 uint8_t *p;
1095
1096 /* if we build a DLL, we add a %ebx offset */
1097 if (s1->output_type == TCC_OUTPUT_DLL)
1098 tcc_error("DLLs unimplemented!");
1099
1100 /* add a PLT entry */
1101 plt = s1->plt;
1102 if (plt->data_offset == 0) {
1103 /* first plt entry */
1104 p = section_ptr_add(plt, 16);
1105 put32(p, 0xe52de004); /* push {lr} */
1106 put32(p+4, 0xe59fe010); /* ldr lr, [pc, #16] */
1107 put32(p+8, 0xe08fe00e); /* add lr, pc, lr */
1108 put32(p+12, 0xe5bef008); /* ldr pc, [lr, #8]! */
1109 }
1110
1111 if (s1->sym_attrs[sym_index].plt_thumb_stub) {
1112 p = section_ptr_add(plt, 20);
1113 put32(p, 0x4778); /* bx pc */
1114 put32(p+2, 0x46c0); /* nop */
1115 p += 4;
1116 } else
1117 p = section_ptr_add(plt, 16);
1118 put32(p, 0xe59fc004); /* ldr ip, [pc, #4] ; GOT entry offset */
1119 put32(p+4, 0xe08fc00c); /* add ip, pc, ip ; addr of GOT entry */
1120 put32(p+8, 0xe59cf000); /* ldr pc, [ip] ; jump to GOT entry */
1121 put32(p+12, s1->got->data_offset); /* GOT entry off once patched */
1122
1123 /* the symbol is modified so that it will be relocated to
1124 the PLT */
1125 if (s1->output_type == TCC_OUTPUT_EXE)
1126 offset = plt->data_offset - 16;
1127 }
1128 #elif defined(TCC_TARGET_C67)
1129 tcc_error("C67 got not implemented");
1130 #else
1131 #error unsupported CPU
1132 #endif
1133 index = put_elf_sym(s1->dynsym, offset,
1134 size, info, 0, sym->st_shndx, name);
1135 /* put a got entry */
1136 put_elf_reloc(s1->dynsym, s1->got,
1137 s1->got->data_offset,
1138 reloc_type, index);
1139 }
1140 ptr = section_ptr_add(s1->got, PTR_SIZE);
1141 *ptr = 0;
1142 }
1143
1144 /* build GOT and PLT entries */
1145 ST_FUNC void build_got_entries(TCCState *s1)
1146 {
1147 Section *s;
1148 ElfW_Rel *rel, *rel_end;
1149 ElfW(Sym) *sym;
1150 int i, type, reloc_type, sym_index;
1151
1152 for(i = 1; i < s1->nb_sections; i++) {
1153 s = s1->sections[i];
1154 if (s->sh_type != SHT_RELX)
1155 continue;
1156 /* no need to handle got relocations */
1157 if (s->link != symtab_section)
1158 continue;
1159 rel_end = (ElfW_Rel *)(s->data + s->data_offset);
1160 for(rel = (ElfW_Rel *)s->data;
1161 rel < rel_end;
1162 rel++) {
1163 type = ELFW(R_TYPE)(rel->r_info);
1164 switch(type) {
1165 #if defined(TCC_TARGET_I386)
1166 case R_386_GOT32:
1167 case R_386_GOTOFF:
1168 case R_386_GOTPC:
1169 case R_386_PLT32:
1170 if (!s1->got)
1171 build_got(s1);
1172 if (type == R_386_GOT32 || type == R_386_PLT32) {
1173 sym_index = ELFW(R_SYM)(rel->r_info);
1174 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1175 /* look at the symbol got offset. If none, then add one */
1176 if (type == R_386_GOT32)
1177 reloc_type = R_386_GLOB_DAT;
1178 else
1179 reloc_type = R_386_JMP_SLOT;
1180 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
1181 sym_index);
1182 }
1183 break;
1184 #elif defined(TCC_TARGET_ARM)
1185 case R_ARM_GOT32:
1186 case R_ARM_GOTOFF:
1187 case R_ARM_GOTPC:
1188 case R_ARM_PLT32:
1189 if (!s1->got)
1190 build_got(s1);
1191 if (type == R_ARM_GOT32 || type == R_ARM_PLT32) {
1192 sym_index = ELFW(R_SYM)(rel->r_info);
1193 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1194 /* look at the symbol got offset. If none, then add one */
1195 if (type == R_ARM_GOT32)
1196 reloc_type = R_ARM_GLOB_DAT;
1197 else
1198 reloc_type = R_ARM_JUMP_SLOT;
1199 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
1200 sym_index);
1201 }
1202 break;
1203 #elif defined(TCC_TARGET_C67)
1204 case R_C60_GOT32:
1205 case R_C60_GOTOFF:
1206 case R_C60_GOTPC:
1207 case R_C60_PLT32:
1208 if (!s1->got)
1209 build_got(s1);
1210 if (type == R_C60_GOT32 || type == R_C60_PLT32) {
1211 sym_index = ELFW(R_SYM)(rel->r_info);
1212 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1213 /* look at the symbol got offset. If none, then add one */
1214 if (type == R_C60_GOT32)
1215 reloc_type = R_C60_GLOB_DAT;
1216 else
1217 reloc_type = R_C60_JMP_SLOT;
1218 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
1219 sym_index);
1220 }
1221 break;
1222 #elif defined(TCC_TARGET_X86_64)
1223 case R_X86_64_GOT32:
1224 case R_X86_64_GOTTPOFF:
1225 case R_X86_64_GOTPCREL:
1226 case R_X86_64_PLT32:
1227 if (!s1->got)
1228 build_got(s1);
1229 if (type == R_X86_64_GOT32 || type == R_X86_64_GOTPCREL ||
1230 type == R_X86_64_PLT32) {
1231 sym_index = ELFW(R_SYM)(rel->r_info);
1232 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
1233 /* look at the symbol got offset. If none, then add one */
1234 if (type == R_X86_64_GOT32 || type == R_X86_64_GOTPCREL)
1235 reloc_type = R_X86_64_GLOB_DAT;
1236 else
1237 reloc_type = R_X86_64_JUMP_SLOT;
1238 put_got_entry(s1, reloc_type, sym->st_size, sym->st_info,
1239 sym_index);
1240 }
1241 break;
1242 #else
1243 #error unsupported CPU
1244 #endif
1245 default:
1246 break;
1247 }
1248 }
1249 }
1250 }
1251
1252 ST_FUNC Section *new_symtab(TCCState *s1,
1253 const char *symtab_name, int sh_type, int sh_flags,
1254 const char *strtab_name,
1255 const char *hash_name, int hash_sh_flags)
1256 {
1257 Section *symtab, *strtab, *hash;
1258 int *ptr, nb_buckets;
1259
1260 symtab = new_section(s1, symtab_name, sh_type, sh_flags);
1261 symtab->sh_entsize = sizeof(ElfW(Sym));
1262 strtab = new_section(s1, strtab_name, SHT_STRTAB, sh_flags);
1263 put_elf_str(strtab, "");
1264 symtab->link = strtab;
1265 put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL);
1266
1267 nb_buckets = 1;
1268
1269 hash = new_section(s1, hash_name, SHT_HASH, hash_sh_flags);
1270 hash->sh_entsize = sizeof(int);
1271 symtab->hash = hash;
1272 hash->link = symtab;
1273
1274 ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int));
1275 ptr[0] = nb_buckets;
1276 ptr[1] = 1;
1277 memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int));
1278 return symtab;
1279 }
1280
1281 /* put dynamic tag */
1282 static void put_dt(Section *dynamic, int dt, addr_t val)
1283 {
1284 ElfW(Dyn) *dyn;
1285 dyn = section_ptr_add(dynamic, sizeof(ElfW(Dyn)));
1286 dyn->d_tag = dt;
1287 dyn->d_un.d_val = val;
1288 }
1289
1290 static void add_init_array_defines(TCCState *s1, const char *section_name)
1291 {
1292 Section *s;
1293 long end_offset;
1294 char sym_start[1024];
1295 char sym_end[1024];
1296
1297 snprintf(sym_start, sizeof(sym_start), "__%s_start", section_name + 1);
1298 snprintf(sym_end, sizeof(sym_end), "__%s_end", section_name + 1);
1299
1300 s = find_section(s1, section_name);
1301 if (!s) {
1302 end_offset = 0;
1303 s = data_section;
1304 } else {
1305 end_offset = s->data_offset;
1306 }
1307
1308 add_elf_sym(symtab_section,
1309 0, 0,
1310 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1311 s->sh_num, sym_start);
1312 add_elf_sym(symtab_section,
1313 end_offset, 0,
1314 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1315 s->sh_num, sym_end);
1316 }
1317
1318 ST_FUNC void tcc_add_bcheck(TCCState *s1)
1319 {
1320 #ifdef CONFIG_TCC_BCHECK
1321 unsigned long *ptr;
1322 Section *init_section;
1323 unsigned char *pinit;
1324 int sym_index;
1325
1326 if (0 == s1->do_bounds_check)
1327 return;
1328
1329 /* XXX: add an object file to do that */
1330 ptr = section_ptr_add(bounds_section, sizeof(unsigned long));
1331 *ptr = 0;
1332 add_elf_sym(symtab_section, 0, 0,
1333 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1334 bounds_section->sh_num, "__bounds_start");
1335 #ifdef TCC_TARGET_I386
1336 if (s1->output_type != TCC_OUTPUT_MEMORY) {
1337 /* add 'call __bound_init()' in .init section */
1338 init_section = find_section(s1, ".init");
1339 pinit = section_ptr_add(init_section, 5);
1340 pinit[0] = 0xe8;
1341 put32(pinit + 1, -4);
1342 sym_index = find_elf_sym(symtab_section, "__bound_init");
1343 put_elf_reloc(symtab_section, init_section,
1344 init_section->data_offset - 4, R_386_PC32, sym_index);
1345 }
1346 #endif
1347 #endif
1348 }
1349
1350 static inline int tcc_add_support(TCCState *s1, const char *filename)
1351 {
1352 char buf[1024];
1353 snprintf(buf, sizeof(buf), "%s/%s", s1->tcc_lib_path, filename);
1354 return tcc_add_file(s1, buf);
1355 }
1356
1357 /* add tcc runtime libraries */
1358 ST_FUNC void tcc_add_runtime(TCCState *s1)
1359 {
1360 tcc_add_bcheck(s1);
1361
1362 /* add libc */
1363 if (!s1->nostdlib) {
1364 tcc_add_library(s1, "c");
1365 #ifdef CONFIG_USE_LIBGCC
1366 if (!s1->static_link)
1367 tcc_add_file(s1, TCC_LIBGCC);
1368 else
1369 tcc_add_support(s1, "libtcc1.a");
1370 #else
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 = DEFAULT_ELFINTERP(s1);
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 /* when generating a DLL, we include relocations but we may
1843 patch them */
1844 if (file_type == TCC_OUTPUT_DLL &&
1845 s->sh_type == SHT_RELX &&
1846 !(s->sh_flags & SHF_ALLOC)) {
1847 /* gr: avoid bogus relocs for empty (debug) sections */
1848 if (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC)
1849 prepare_dynamic_rel(s1, s);
1850 else if (s1->do_debug)
1851 s->sh_size = s->data_offset;
1852 } else if (s1->do_debug ||
1853 file_type == TCC_OUTPUT_OBJ ||
1854 (s->sh_flags & SHF_ALLOC) ||
1855 i == (s1->nb_sections - 1)) {
1856 /* we output all sections if debug or object file */
1857 s->sh_size = s->data_offset;
1858 }
1859 }
1860
1861 /* allocate program segment headers */
1862 phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
1863
1864 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1865 file_offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
1866 } else {
1867 file_offset = 0;
1868 }
1869 if (phnum > 0) {
1870 /* compute section to program header mapping */
1871 if (s1->has_text_addr) {
1872 int a_offset, p_offset;
1873 addr = s1->text_addr;
1874 /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
1875 ELF_PAGE_SIZE */
1876 a_offset = (int) (addr & (s1->section_align - 1));
1877 p_offset = file_offset & (s1->section_align - 1);
1878 if (a_offset < p_offset)
1879 a_offset += s1->section_align;
1880 file_offset += (a_offset - p_offset);
1881 } else {
1882 if (file_type == TCC_OUTPUT_DLL)
1883 addr = 0;
1884 else
1885 addr = ELF_START_ADDR;
1886 /* compute address after headers */
1887 addr += (file_offset & (s1->section_align - 1));
1888 }
1889
1890 /* dynamic relocation table information, for .dynamic section */
1891 rel_size = 0;
1892 rel_addr = 0;
1893
1894 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1895 bss_addr = bss_size = 0;
1896 #endif
1897 /* leave one program header for the program interpreter */
1898 ph = &phdr[0];
1899 if (interp)
1900 ph += 1 + HAVE_PHDR;
1901
1902 for(j = 0; j < 2; j++) {
1903 ph->p_type = PT_LOAD;
1904 if (j == 0)
1905 ph->p_flags = PF_R | PF_X;
1906 else
1907 ph->p_flags = PF_R | PF_W;
1908 ph->p_align = s1->section_align;
1909
1910 /* we do the following ordering: interp, symbol tables,
1911 relocations, progbits, nobits */
1912 /* XXX: do faster and simpler sorting */
1913 for(k = 0; k < 5; k++) {
1914 for(i = 1; i < s1->nb_sections; i++) {
1915 s = s1->sections[i];
1916 /* compute if section should be included */
1917 if (j == 0) {
1918 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1919 SHF_ALLOC)
1920 continue;
1921 } else {
1922 if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) !=
1923 (SHF_ALLOC | SHF_WRITE))
1924 continue;
1925 }
1926 if (s == interp) {
1927 if (k != 0)
1928 continue;
1929 } else if (s->sh_type == SHT_DYNSYM ||
1930 s->sh_type == SHT_STRTAB ||
1931 s->sh_type == SHT_HASH) {
1932 if (k != 1)
1933 continue;
1934 } else if (s->sh_type == SHT_RELX) {
1935 if (k != 2)
1936 continue;
1937 } else if (s->sh_type == SHT_NOBITS) {
1938 if (k != 4)
1939 continue;
1940 } else {
1941 if (k != 3)
1942 continue;
1943 }
1944 section_order[sh_order_index++] = i;
1945
1946 /* section matches: we align it and add its size */
1947 tmp = addr;
1948 addr = (addr + s->sh_addralign - 1) &
1949 ~(s->sh_addralign - 1);
1950 file_offset += (int) ( addr - tmp );
1951 s->sh_offset = file_offset;
1952 s->sh_addr = addr;
1953
1954 /* update program header infos */
1955 if (ph->p_offset == 0) {
1956 ph->p_offset = file_offset;
1957 ph->p_vaddr = addr;
1958 ph->p_paddr = ph->p_vaddr;
1959 }
1960 /* update dynamic relocation infos */
1961 if (s->sh_type == SHT_RELX) {
1962 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1963 if (!strcmp(strsec->data + s->sh_name, ".rel.got")) {
1964 rel_addr = addr;
1965 rel_size += s->sh_size; /* XXX only first rel. */
1966 }
1967 if (!strcmp(strsec->data + s->sh_name, ".rel.bss")) {
1968 bss_addr = addr;
1969 bss_size = s->sh_size; /* XXX only first rel. */
1970 }
1971 #else
1972 if (rel_size == 0)
1973 rel_addr = addr;
1974 rel_size += s->sh_size;
1975 #endif
1976 }
1977 addr += s->sh_size;
1978 if (s->sh_type != SHT_NOBITS)
1979 file_offset += s->sh_size;
1980 }
1981 }
1982 ph->p_filesz = file_offset - ph->p_offset;
1983 ph->p_memsz = addr - ph->p_vaddr;
1984 ph++;
1985 if (j == 0) {
1986 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
1987 /* if in the middle of a page, we duplicate the page in
1988 memory so that one copy is RX and the other is RW */
1989 if ((addr & (s1->section_align - 1)) != 0)
1990 addr += s1->section_align;
1991 } else {
1992 addr = (addr + s1->section_align - 1) & ~(s1->section_align - 1);
1993 file_offset = (file_offset + s1->section_align - 1) &
1994 ~(s1->section_align - 1);
1995 }
1996 }
1997 }
1998
1999 /* if interpreter, then add corresponing program header */
2000 if (interp) {
2001 ph = &phdr[0];
2002
2003 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2004 {
2005 int len = phnum * sizeof(ElfW(Phdr));
2006
2007 ph->p_type = PT_PHDR;
2008 ph->p_offset = sizeof(ElfW(Ehdr));
2009 ph->p_vaddr = interp->sh_addr - len;
2010 ph->p_paddr = ph->p_vaddr;
2011 ph->p_filesz = ph->p_memsz = len;
2012 ph->p_flags = PF_R | PF_X;
2013 ph->p_align = 4; /* interp->sh_addralign; */
2014 ph++;
2015 }
2016 #endif
2017
2018 ph->p_type = PT_INTERP;
2019 ph->p_offset = interp->sh_offset;
2020 ph->p_vaddr = interp->sh_addr;
2021 ph->p_paddr = ph->p_vaddr;
2022 ph->p_filesz = interp->sh_size;
2023 ph->p_memsz = interp->sh_size;
2024 ph->p_flags = PF_R;
2025 ph->p_align = interp->sh_addralign;
2026 }
2027
2028 /* if dynamic section, then add corresponing program header */
2029 if (dynamic) {
2030 ElfW(Sym) *sym_end;
2031
2032 ph = &phdr[phnum - 1];
2033
2034 ph->p_type = PT_DYNAMIC;
2035 ph->p_offset = dynamic->sh_offset;
2036 ph->p_vaddr = dynamic->sh_addr;
2037 ph->p_paddr = ph->p_vaddr;
2038 ph->p_filesz = dynamic->sh_size;
2039 ph->p_memsz = dynamic->sh_size;
2040 ph->p_flags = PF_R | PF_W;
2041 ph->p_align = dynamic->sh_addralign;
2042
2043 /* put GOT dynamic section address */
2044 put32(s1->got->data, dynamic->sh_addr);
2045
2046 /* relocate the PLT */
2047 if (file_type == TCC_OUTPUT_EXE
2048 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
2049 || file_type == TCC_OUTPUT_DLL
2050 #endif
2051 ) {
2052 uint8_t *p, *p_end;
2053
2054 p = s1->plt->data;
2055 p_end = p + s1->plt->data_offset;
2056 if (p < p_end) {
2057 #if defined(TCC_TARGET_I386)
2058 put32(p + 2, get32(p + 2) + s1->got->sh_addr);
2059 put32(p + 8, get32(p + 8) + s1->got->sh_addr);
2060 p += 16;
2061 while (p < p_end) {
2062 put32(p + 2, get32(p + 2) + s1->got->sh_addr);
2063 p += 16;
2064 }
2065 #elif defined(TCC_TARGET_X86_64)
2066 int x = s1->got->sh_addr - s1->plt->sh_addr - 6;
2067 put32(p + 2, get32(p + 2) + x);
2068 put32(p + 8, get32(p + 8) + x - 6);
2069 p += 16;
2070 while (p < p_end) {
2071 put32(p + 2, get32(p + 2) + x + s1->plt->data - p);
2072 p += 16;
2073 }
2074 #elif defined(TCC_TARGET_ARM)
2075 int x;
2076 x=s1->got->sh_addr - s1->plt->sh_addr - 12;
2077 p += 16;
2078 while (p < p_end) {
2079 if (get32(p) == 0x46c04778) /* PLT Thumb stub present */
2080 p += 4;
2081 put32(p + 12, x + get32(p + 12) + s1->plt->data - p);
2082 p += 16;
2083 }
2084 #elif defined(TCC_TARGET_C67)
2085 /* XXX: TODO */
2086 #else
2087 #error unsupported CPU
2088 #endif
2089 }
2090 }
2091
2092 /* relocate symbols in .dynsym */
2093 sym_end = (ElfW(Sym) *)(s1->dynsym->data + s1->dynsym->data_offset);
2094 for(sym = (ElfW(Sym) *)s1->dynsym->data + 1;
2095 sym < sym_end;
2096 sym++) {
2097 if (sym->st_shndx == SHN_UNDEF) {
2098 /* relocate to the PLT if the symbol corresponds
2099 to a PLT entry */
2100 if (sym->st_value)
2101 sym->st_value += s1->plt->sh_addr;
2102 } else if (sym->st_shndx < SHN_LORESERVE) {
2103 /* do symbol relocation */
2104 sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
2105 }
2106 }
2107
2108 /* put dynamic section entries */
2109 dynamic->data_offset = saved_dynamic_data_offset;
2110 put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
2111 put_dt(dynamic, DT_STRTAB, dynstr->sh_addr);
2112 put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
2113 put_dt(dynamic, DT_STRSZ, dynstr->data_offset);
2114 put_dt(dynamic, DT_SYMENT, sizeof(ElfW(Sym)));
2115 #ifdef TCC_TARGET_X86_64
2116 put_dt(dynamic, DT_RELA, rel_addr);
2117 put_dt(dynamic, DT_RELASZ, rel_size);
2118 put_dt(dynamic, DT_RELAENT, sizeof(ElfW_Rel));
2119 #else
2120 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2121 put_dt(dynamic, DT_PLTGOT, s1->got->sh_addr);
2122 put_dt(dynamic, DT_PLTRELSZ, rel_size);
2123 put_dt(dynamic, DT_JMPREL, rel_addr);
2124 put_dt(dynamic, DT_PLTREL, DT_REL);
2125 put_dt(dynamic, DT_REL, bss_addr);
2126 put_dt(dynamic, DT_RELSZ, bss_size);
2127 #else
2128 put_dt(dynamic, DT_REL, rel_addr);
2129 put_dt(dynamic, DT_RELSZ, rel_size);
2130 put_dt(dynamic, DT_RELENT, sizeof(ElfW_Rel));
2131 #endif
2132 #endif
2133 if (s1->do_debug)
2134 put_dt(dynamic, DT_DEBUG, 0);
2135 put_dt(dynamic, DT_NULL, 0);
2136 }
2137
2138 ehdr.e_phentsize = sizeof(ElfW(Phdr));
2139 ehdr.e_phnum = phnum;
2140 ehdr.e_phoff = sizeof(ElfW(Ehdr));
2141 }
2142
2143 /* all other sections come after */
2144 for(i = 1; i < s1->nb_sections; i++) {
2145 s = s1->sections[i];
2146 if (phnum > 0 && (s->sh_flags & SHF_ALLOC))
2147 continue;
2148 section_order[sh_order_index++] = i;
2149
2150 file_offset = (file_offset + s->sh_addralign - 1) &
2151 ~(s->sh_addralign - 1);
2152 s->sh_offset = file_offset;
2153 if (s->sh_type != SHT_NOBITS)
2154 file_offset += s->sh_size;
2155 }
2156
2157 /* if building executable or DLL, then relocate each section
2158 except the GOT which is already relocated */
2159 if (file_type != TCC_OUTPUT_OBJ) {
2160 relocate_syms(s1, 0);
2161
2162 if (s1->nb_errors != 0) {
2163 fail:
2164 ret = -1;
2165 goto the_end;
2166 }
2167
2168 /* relocate sections */
2169 /* XXX: ignore sections with allocated relocations ? */
2170 for(i = 1; i < s1->nb_sections; i++) {
2171 s = s1->sections[i];
2172 if (s->reloc && s != s1->got)
2173 relocate_section(s1, s);
2174 }
2175
2176 /* relocate relocation entries if the relocation tables are
2177 allocated in the executable */
2178 for(i = 1; i < s1->nb_sections; i++) {
2179 s = s1->sections[i];
2180 if ((s->sh_flags & SHF_ALLOC) &&
2181 s->sh_type == SHT_RELX) {
2182 relocate_rel(s1, s);
2183 }
2184 }
2185
2186 /* get entry point address */
2187 if (file_type == TCC_OUTPUT_EXE)
2188 ehdr.e_entry = get_elf_sym_addr(s1, "_start", 1);
2189 else
2190 ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */
2191 }
2192 if (file_type == TCC_OUTPUT_EXE && s1->static_link)
2193 fill_got(s1);
2194
2195 /* write elf file */
2196 if (file_type == TCC_OUTPUT_OBJ)
2197 mode = 0666;
2198 else
2199 mode = 0777;
2200 unlink(filename);
2201 fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
2202 if (fd < 0) {
2203 tcc_error_noabort("could not write '%s'", filename);
2204 goto fail;
2205 }
2206 f = fdopen(fd, "wb");
2207 if (s1->verbose)
2208 printf("<- %s\n", filename);
2209
2210 #ifdef TCC_TARGET_COFF
2211 if (s1->output_format == TCC_OUTPUT_FORMAT_COFF) {
2212 tcc_output_coff(s1, f);
2213 } else
2214 #endif
2215 if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
2216 sort_syms(s1, symtab_section);
2217
2218 /* align to 4 */
2219 file_offset = (file_offset + 3) & -4;
2220
2221 /* fill header */
2222 ehdr.e_ident[0] = ELFMAG0;
2223 ehdr.e_ident[1] = ELFMAG1;
2224 ehdr.e_ident[2] = ELFMAG2;
2225 ehdr.e_ident[3] = ELFMAG3;
2226 ehdr.e_ident[4] = ELFCLASSW;
2227 ehdr.e_ident[5] = ELFDATA2LSB;
2228 ehdr.e_ident[6] = EV_CURRENT;
2229 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2230 ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
2231 #endif
2232 #ifdef TCC_TARGET_ARM
2233 #ifdef TCC_ARM_EABI
2234 ehdr.e_ident[EI_OSABI] = 0;
2235 ehdr.e_flags = EF_ARM_EABI_VER4;
2236 if (file_type == TCC_OUTPUT_EXE || file_type == TCC_OUTPUT_DLL)
2237 ehdr.e_flags |= EF_ARM_HASENTRY;
2238 if (s1->float_abi == ARM_HARD_FLOAT)
2239 ehdr.e_flags |= EF_ARM_VFP_FLOAT;
2240 else
2241 ehdr.e_flags |= EF_ARM_SOFT_FLOAT;
2242 #else
2243 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
2244 #endif
2245 #endif
2246 switch(file_type) {
2247 default:
2248 case TCC_OUTPUT_EXE:
2249 ehdr.e_type = ET_EXEC;
2250 break;
2251 case TCC_OUTPUT_DLL:
2252 ehdr.e_type = ET_DYN;
2253 break;
2254 case TCC_OUTPUT_OBJ:
2255 ehdr.e_type = ET_REL;
2256 break;
2257 }
2258 ehdr.e_machine = EM_TCC_TARGET;
2259 ehdr.e_version = EV_CURRENT;
2260 ehdr.e_shoff = file_offset;
2261 ehdr.e_ehsize = sizeof(ElfW(Ehdr));
2262 ehdr.e_shentsize = sizeof(ElfW(Shdr));
2263 ehdr.e_shnum = shnum;
2264 ehdr.e_shstrndx = shnum - 1;
2265
2266 fwrite(&ehdr, 1, sizeof(ElfW(Ehdr)), f);
2267 fwrite(phdr, 1, phnum * sizeof(ElfW(Phdr)), f);
2268 offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
2269
2270 for(i=1;i<s1->nb_sections;i++) {
2271 s = s1->sections[section_order[i]];
2272 if (s->sh_type != SHT_NOBITS) {
2273 if (s->sh_type == SHT_DYNSYM)
2274 patch_dynsym_undef(s1, s);
2275 while (offset < s->sh_offset) {
2276 fputc(0, f);
2277 offset++;
2278 }
2279 size = s->sh_size;
2280 fwrite(s->data, 1, size, f);
2281 offset += size;
2282 }
2283 }
2284
2285 /* output section headers */
2286 while (offset < ehdr.e_shoff) {
2287 fputc(0, f);
2288 offset++;
2289 }
2290
2291 for(i=0;i<s1->nb_sections;i++) {
2292 sh = &shdr;
2293 memset(sh, 0, sizeof(ElfW(Shdr)));
2294 s = s1->sections[i];
2295 if (s) {
2296 sh->sh_name = s->sh_name;
2297 sh->sh_type = s->sh_type;
2298 sh->sh_flags = s->sh_flags;
2299 sh->sh_entsize = s->sh_entsize;
2300 sh->sh_info = s->sh_info;
2301 if (s->link)
2302 sh->sh_link = s->link->sh_num;
2303 sh->sh_addralign = s->sh_addralign;
2304 sh->sh_addr = s->sh_addr;
2305 sh->sh_offset = s->sh_offset;
2306 sh->sh_size = s->sh_size;
2307 }
2308 fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
2309 }
2310 } else {
2311 tcc_output_binary(s1, f, section_order);
2312 }
2313 fclose(f);
2314
2315 ret = 0;
2316 the_end:
2317 tcc_free(s1->symtab_to_dynsym);
2318 tcc_free(section_order);
2319 tcc_free(phdr);
2320 tcc_free(s1->sym_attrs);
2321 return ret;
2322 }
2323
2324 LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename)
2325 {
2326 int ret;
2327 #ifdef TCC_TARGET_PE
2328 if (s->output_type != TCC_OUTPUT_OBJ) {
2329 ret = pe_output_file(s, filename);
2330 } else
2331 #endif
2332 {
2333 ret = elf_output_file(s, filename);
2334 }
2335 return ret;
2336 }
2337
2338 static void *load_data(int fd, unsigned long file_offset, unsigned long size)
2339 {
2340 void *data;
2341
2342 data = tcc_malloc(size);
2343 lseek(fd, file_offset, SEEK_SET);
2344 read(fd, data, size);
2345 return data;
2346 }
2347
2348 typedef struct SectionMergeInfo {
2349 Section *s; /* corresponding existing section */
2350 unsigned long offset; /* offset of the new section in the existing section */
2351 uint8_t new_section; /* true if section 's' was added */
2352 uint8_t link_once; /* true if link once section */
2353 } SectionMergeInfo;
2354
2355 /* load an object file and merge it with current files */
2356 /* XXX: handle correctly stab (debug) info */
2357 ST_FUNC int tcc_load_object_file(TCCState *s1,
2358 int fd, unsigned long file_offset)
2359 {
2360 ElfW(Ehdr) ehdr;
2361 ElfW(Shdr) *shdr, *sh;
2362 int size, i, j, offset, offseti, nb_syms, sym_index, ret;
2363 unsigned char *strsec, *strtab;
2364 int *old_to_new_syms;
2365 char *sh_name, *name;
2366 SectionMergeInfo *sm_table, *sm;
2367 ElfW(Sym) *sym, *symtab;
2368 ElfW_Rel *rel, *rel_end;
2369 Section *s;
2370
2371 int stab_index;
2372 int stabstr_index;
2373
2374 stab_index = stabstr_index = 0;
2375
2376 if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr))
2377 goto fail1;
2378 if (ehdr.e_ident[0] != ELFMAG0 ||
2379 ehdr.e_ident[1] != ELFMAG1 ||
2380 ehdr.e_ident[2] != ELFMAG2 ||
2381 ehdr.e_ident[3] != ELFMAG3)
2382 goto fail1;
2383 /* test if object file */
2384 if (ehdr.e_type != ET_REL)
2385 goto fail1;
2386 /* test CPU specific stuff */
2387 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2388 ehdr.e_machine != EM_TCC_TARGET) {
2389 fail1:
2390 tcc_error_noabort("invalid object file");
2391 return -1;
2392 }
2393 /* read sections */
2394 shdr = load_data(fd, file_offset + ehdr.e_shoff,
2395 sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2396 sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum);
2397
2398 /* load section names */
2399 sh = &shdr[ehdr.e_shstrndx];
2400 strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2401
2402 /* load symtab and strtab */
2403 old_to_new_syms = NULL;
2404 symtab = NULL;
2405 strtab = NULL;
2406 nb_syms = 0;
2407 for(i = 1; i < ehdr.e_shnum; i++) {
2408 sh = &shdr[i];
2409 if (sh->sh_type == SHT_SYMTAB) {
2410 if (symtab) {
2411 tcc_error_noabort("object must contain only one symtab");
2412 fail:
2413 ret = -1;
2414 goto the_end;
2415 }
2416 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2417 symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2418 sm_table[i].s = symtab_section;
2419
2420 /* now load strtab */
2421 sh = &shdr[sh->sh_link];
2422 strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size);
2423 }
2424 }
2425
2426 /* now examine each section and try to merge its content with the
2427 ones in memory */
2428 for(i = 1; i < ehdr.e_shnum; i++) {
2429 /* no need to examine section name strtab */
2430 if (i == ehdr.e_shstrndx)
2431 continue;
2432 sh = &shdr[i];
2433 sh_name = strsec + sh->sh_name;
2434 /* ignore sections types we do not handle */
2435 if (sh->sh_type != SHT_PROGBITS &&
2436 sh->sh_type != SHT_RELX &&
2437 #ifdef TCC_ARM_EABI
2438 sh->sh_type != SHT_ARM_EXIDX &&
2439 #endif
2440 sh->sh_type != SHT_NOBITS &&
2441 sh->sh_type != SHT_PREINIT_ARRAY &&
2442 sh->sh_type != SHT_INIT_ARRAY &&
2443 sh->sh_type != SHT_FINI_ARRAY &&
2444 strcmp(sh_name, ".stabstr")
2445 )
2446 continue;
2447 if (sh->sh_addralign < 1)
2448 sh->sh_addralign = 1;
2449 /* find corresponding section, if any */
2450 for(j = 1; j < s1->nb_sections;j++) {
2451 s = s1->sections[j];
2452 if (!strcmp(s->name, sh_name)) {
2453 if (!strncmp(sh_name, ".gnu.linkonce",
2454 sizeof(".gnu.linkonce") - 1)) {
2455 /* if a 'linkonce' section is already present, we
2456 do not add it again. It is a little tricky as
2457 symbols can still be defined in
2458 it. */
2459 sm_table[i].link_once = 1;
2460 goto next;
2461 } else {
2462 goto found;
2463 }
2464 }
2465 }
2466 /* not found: create new section */
2467 s = new_section(s1, sh_name, sh->sh_type, sh->sh_flags);
2468 /* take as much info as possible from the section. sh_link and
2469 sh_info will be updated later */
2470 s->sh_addralign = sh->sh_addralign;
2471 s->sh_entsize = sh->sh_entsize;
2472 sm_table[i].new_section = 1;
2473 found:
2474 if (sh->sh_type != s->sh_type) {
2475 tcc_error_noabort("invalid section type");
2476 goto fail;
2477 }
2478
2479 /* align start of section */
2480 offset = s->data_offset;
2481
2482 if (0 == strcmp(sh_name, ".stab")) {
2483 stab_index = i;
2484 goto no_align;
2485 }
2486 if (0 == strcmp(sh_name, ".stabstr")) {
2487 stabstr_index = i;
2488 goto no_align;
2489 }
2490
2491 size = sh->sh_addralign - 1;
2492 offset = (offset + size) & ~size;
2493 if (sh->sh_addralign > s->sh_addralign)
2494 s->sh_addralign = sh->sh_addralign;
2495 s->data_offset = offset;
2496 no_align:
2497 sm_table[i].offset = offset;
2498 sm_table[i].s = s;
2499 /* concatenate sections */
2500 size = sh->sh_size;
2501 if (sh->sh_type != SHT_NOBITS) {
2502 unsigned char *ptr;
2503 lseek(fd, file_offset + sh->sh_offset, SEEK_SET);
2504 ptr = section_ptr_add(s, size);
2505 read(fd, ptr, size);
2506 } else {
2507 s->data_offset += size;
2508 }
2509 next: ;
2510 }
2511
2512 /* gr relocate stab strings */
2513 if (stab_index && stabstr_index) {
2514 Stab_Sym *a, *b;
2515 unsigned o;
2516 s = sm_table[stab_index].s;
2517 a = (Stab_Sym *)(s->data + sm_table[stab_index].offset);
2518 b = (Stab_Sym *)(s->data + s->data_offset);
2519 o = sm_table[stabstr_index].offset;
2520 while (a < b)
2521 a->n_strx += o, a++;
2522 }
2523
2524 /* second short pass to update sh_link and sh_info fields of new
2525 sections */
2526 for(i = 1; i < ehdr.e_shnum; i++) {
2527 s = sm_table[i].s;
2528 if (!s || !sm_table[i].new_section)
2529 continue;
2530 sh = &shdr[i];
2531 if (sh->sh_link > 0)
2532 s->link = sm_table[sh->sh_link].s;
2533 if (sh->sh_type == SHT_RELX) {
2534 s->sh_info = sm_table[sh->sh_info].s->sh_num;
2535 /* update backward link */
2536 s1->sections[s->sh_info]->reloc = s;
2537 }
2538 }
2539 sm = sm_table;
2540
2541 /* resolve symbols */
2542 old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int));
2543
2544 sym = symtab + 1;
2545 for(i = 1; i < nb_syms; i++, sym++) {
2546 if (sym->st_shndx != SHN_UNDEF &&
2547 sym->st_shndx < SHN_LORESERVE) {
2548 sm = &sm_table[sym->st_shndx];
2549 if (sm->link_once) {
2550 /* if a symbol is in a link once section, we use the
2551 already defined symbol. It is very important to get
2552 correct relocations */
2553 if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
2554 name = strtab + sym->st_name;
2555 sym_index = find_elf_sym(symtab_section, name);
2556 if (sym_index)
2557 old_to_new_syms[i] = sym_index;
2558 }
2559 continue;
2560 }
2561 /* if no corresponding section added, no need to add symbol */
2562 if (!sm->s)
2563 continue;
2564 /* convert section number */
2565 sym->st_shndx = sm->s->sh_num;
2566 /* offset value */
2567 sym->st_value += sm->offset;
2568 }
2569 /* add symbol */
2570 name = strtab + sym->st_name;
2571 sym_index = add_elf_sym(symtab_section, sym->st_value, sym->st_size,
2572 sym->st_info, sym->st_other,
2573 sym->st_shndx, name);
2574 old_to_new_syms[i] = sym_index;
2575 }
2576
2577 /* third pass to patch relocation entries */
2578 for(i = 1; i < ehdr.e_shnum; i++) {
2579 s = sm_table[i].s;
2580 if (!s)
2581 continue;
2582 sh = &shdr[i];
2583 offset = sm_table[i].offset;
2584 switch(s->sh_type) {
2585 case SHT_RELX:
2586 /* take relocation offset information */
2587 offseti = sm_table[sh->sh_info].offset;
2588 rel_end = (ElfW_Rel *)(s->data + s->data_offset);
2589 for(rel = (ElfW_Rel *)(s->data + offset);
2590 rel < rel_end;
2591 rel++) {
2592 int type;
2593 unsigned sym_index;
2594 /* convert symbol index */
2595 type = ELFW(R_TYPE)(rel->r_info);
2596 sym_index = ELFW(R_SYM)(rel->r_info);
2597 /* NOTE: only one symtab assumed */
2598 if (sym_index >= nb_syms)
2599 goto invalid_reloc;
2600 sym_index = old_to_new_syms[sym_index];
2601 /* ignore link_once in rel section. */
2602 if (!sym_index && !sm->link_once
2603 #ifdef TCC_TARGET_ARM
2604 && type != R_ARM_V4BX
2605 #endif
2606 ) {
2607 invalid_reloc:
2608 tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
2609 i, strsec + sh->sh_name, rel->r_offset);
2610 goto fail;
2611 }
2612 rel->r_info = ELFW(R_INFO)(sym_index, type);
2613 /* offset the relocation offset */
2614 rel->r_offset += offseti;
2615 #ifdef TCC_TARGET_ARM
2616 /* Jumps and branches from a Thumb code to a PLT entry need
2617 special handling since PLT entries are ARM code.
2618 Unconditional bl instructions referencing PLT entries are
2619 handled by converting these instructions into blx
2620 instructions. Other case of instructions referencing a PLT
2621 entry require to add a Thumb stub before the PLT entry to
2622 switch to ARM mode. We set bit 0 of the got offset of a
2623 symbol to indicate such a case. */
2624 if (type == R_ARM_THM_JUMP24)
2625 alloc_sym_attr(s1, sym_index)->plt_thumb_stub = 1;
2626 #endif
2627 }
2628 break;
2629 default:
2630 break;
2631 }
2632 }
2633
2634 ret = 0;
2635 the_end:
2636 tcc_free(symtab);
2637 tcc_free(strtab);
2638 tcc_free(old_to_new_syms);
2639 tcc_free(sm_table);
2640 tcc_free(strsec);
2641 tcc_free(shdr);
2642 return ret;
2643 }
2644
2645 typedef struct ArchiveHeader {
2646 char ar_name[16]; /* name of this member */
2647 char ar_date[12]; /* file mtime */
2648 char ar_uid[6]; /* owner uid; printed as decimal */
2649 char ar_gid[6]; /* owner gid; printed as decimal */
2650 char ar_mode[8]; /* file mode, printed as octal */
2651 char ar_size[10]; /* file size, printed as decimal */
2652 char ar_fmag[2]; /* should contain ARFMAG */
2653 } ArchiveHeader;
2654
2655 static int get_be32(const uint8_t *b)
2656 {
2657 return b[3] | (b[2] << 8) | (b[1] << 16) | (b[0] << 24);
2658 }
2659
2660 /* load only the objects which resolve undefined symbols */
2661 static int tcc_load_alacarte(TCCState *s1, int fd, int size)
2662 {
2663 int i, bound, nsyms, sym_index, off, ret;
2664 uint8_t *data;
2665 const char *ar_names, *p;
2666 const uint8_t *ar_index;
2667 ElfW(Sym) *sym;
2668
2669 data = tcc_malloc(size);
2670 if (read(fd, data, size) != size)
2671 goto fail;
2672 nsyms = get_be32(data);
2673 ar_index = data + 4;
2674 ar_names = ar_index + nsyms * 4;
2675
2676 do {
2677 bound = 0;
2678 for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2679 sym_index = find_elf_sym(symtab_section, p);
2680 if(sym_index) {
2681 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
2682 if(sym->st_shndx == SHN_UNDEF) {
2683 off = get_be32(ar_index + i * 4) + sizeof(ArchiveHeader);
2684 ++bound;
2685 lseek(fd, off, SEEK_SET);
2686 if(tcc_load_object_file(s1, fd, off) < 0) {
2687 fail:
2688 ret = -1;
2689 goto the_end;
2690 }
2691 }
2692 }
2693 }
2694 } while(bound);
2695 ret = 0;
2696 the_end:
2697 tcc_free(data);
2698 return ret;
2699 }
2700
2701 /* load a '.a' file */
2702 ST_FUNC int tcc_load_archive(TCCState *s1, int fd)
2703 {
2704 ArchiveHeader hdr;
2705 char ar_size[11];
2706 char ar_name[17];
2707 char magic[8];
2708 int size, len, i;
2709 unsigned long file_offset;
2710
2711 /* skip magic which was already checked */
2712 read(fd, magic, sizeof(magic));
2713
2714 for(;;) {
2715 len = read(fd, &hdr, sizeof(hdr));
2716 if (len == 0)
2717 break;
2718 if (len != sizeof(hdr)) {
2719 tcc_error_noabort("invalid archive");
2720 return -1;
2721 }
2722 memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size));
2723 ar_size[sizeof(hdr.ar_size)] = '\0';
2724 size = strtol(ar_size, NULL, 0);
2725 memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name));
2726 for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) {
2727 if (ar_name[i] != ' ')
2728 break;
2729 }
2730 ar_name[i + 1] = '\0';
2731 file_offset = lseek(fd, 0, SEEK_CUR);
2732 /* align to even */
2733 size = (size + 1) & ~1;
2734 if (!strcmp(ar_name, "/")) {
2735 /* coff symbol table : we handle it */
2736 if(s1->alacarte_link)
2737 return tcc_load_alacarte(s1, fd, size);
2738 } else if (!strcmp(ar_name, "//") ||
2739 !strcmp(ar_name, "__.SYMDEF") ||
2740 !strcmp(ar_name, "__.SYMDEF/") ||
2741 !strcmp(ar_name, "ARFILENAMES/")) {
2742 /* skip symbol table or archive names */
2743 } else {
2744 if (tcc_load_object_file(s1, fd, file_offset) < 0)
2745 return -1;
2746 }
2747 lseek(fd, file_offset + size, SEEK_SET);
2748 }
2749 return 0;
2750 }
2751
2752 #ifndef TCC_TARGET_PE
2753 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
2754 is referenced by the user (so it should be added as DT_NEEDED in
2755 the generated ELF file) */
2756 ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
2757 {
2758 ElfW(Ehdr) ehdr;
2759 ElfW(Shdr) *shdr, *sh, *sh1;
2760 int i, j, nb_syms, nb_dts, sym_bind, ret;
2761 ElfW(Sym) *sym, *dynsym;
2762 ElfW(Dyn) *dt, *dynamic;
2763 unsigned char *dynstr;
2764 const char *name, *soname;
2765 DLLReference *dllref;
2766
2767 read(fd, &ehdr, sizeof(ehdr));
2768
2769 /* test CPU specific stuff */
2770 if (ehdr.e_ident[5] != ELFDATA2LSB ||
2771 ehdr.e_machine != EM_TCC_TARGET) {
2772 tcc_error_noabort("bad architecture");
2773 return -1;
2774 }
2775
2776 /* read sections */
2777 shdr = load_data(fd, ehdr.e_shoff, sizeof(ElfW(Shdr)) * ehdr.e_shnum);
2778
2779 /* load dynamic section and dynamic symbols */
2780 nb_syms = 0;
2781 nb_dts = 0;
2782 dynamic = NULL;
2783 dynsym = NULL; /* avoid warning */
2784 dynstr = NULL; /* avoid warning */
2785 for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) {
2786 switch(sh->sh_type) {
2787 case SHT_DYNAMIC:
2788 nb_dts = sh->sh_size / sizeof(ElfW(Dyn));
2789 dynamic = load_data(fd, sh->sh_offset, sh->sh_size);
2790 break;
2791 case SHT_DYNSYM:
2792 nb_syms = sh->sh_size / sizeof(ElfW(Sym));
2793 dynsym = load_data(fd, sh->sh_offset, sh->sh_size);
2794 sh1 = &shdr[sh->sh_link];
2795 dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size);
2796 break;
2797 default:
2798 break;
2799 }
2800 }
2801
2802 /* compute the real library name */
2803 soname = tcc_basename(filename);
2804
2805 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2806 if (dt->d_tag == DT_SONAME) {
2807 soname = dynstr + dt->d_un.d_val;
2808 }
2809 }
2810
2811 /* if the dll is already loaded, do not load it */
2812 for(i = 0; i < s1->nb_loaded_dlls; i++) {
2813 dllref = s1->loaded_dlls[i];
2814 if (!strcmp(soname, dllref->name)) {
2815 /* but update level if needed */
2816 if (level < dllref->level)
2817 dllref->level = level;
2818 ret = 0;
2819 goto the_end;
2820 }
2821 }
2822
2823 /* add the dll and its level */
2824 dllref = tcc_mallocz(sizeof(DLLReference) + strlen(soname));
2825 dllref->level = level;
2826 strcpy(dllref->name, soname);
2827 dynarray_add((void ***)&s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
2828
2829 /* add dynamic symbols in dynsym_section */
2830 for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
2831 sym_bind = ELFW(ST_BIND)(sym->st_info);
2832 if (sym_bind == STB_LOCAL)
2833 continue;
2834 name = dynstr + sym->st_name;
2835 add_elf_sym(s1->dynsymtab_section, sym->st_value, sym->st_size,
2836 sym->st_info, sym->st_other, sym->st_shndx, name);
2837 }
2838
2839 /* load all referenced DLLs */
2840 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
2841 switch(dt->d_tag) {
2842 case DT_NEEDED:
2843 name = dynstr + dt->d_un.d_val;
2844 for(j = 0; j < s1->nb_loaded_dlls; j++) {
2845 dllref = s1->loaded_dlls[j];
2846 if (!strcmp(name, dllref->name))
2847 goto already_loaded;
2848 }
2849 if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
2850 tcc_error_noabort("referenced dll '%s' not found", name);
2851 ret = -1;
2852 goto the_end;
2853 }
2854 already_loaded:
2855 break;
2856 }
2857 }
2858 ret = 0;
2859 the_end:
2860 tcc_free(dynstr);
2861 tcc_free(dynsym);
2862 tcc_free(dynamic);
2863 tcc_free(shdr);
2864 return ret;
2865 }
2866
2867 #define LD_TOK_NAME 256
2868 #define LD_TOK_EOF (-1)
2869
2870 /* return next ld script token */
2871 static int ld_next(TCCState *s1, char *name, int name_size)
2872 {
2873 int c;
2874 char *q;
2875
2876 redo:
2877 switch(ch) {
2878 case ' ':
2879 case '\t':
2880 case '\f':
2881 case '\v':
2882 case '\r':
2883 case '\n':
2884 inp();
2885 goto redo;
2886 case '/':
2887 minp();
2888 if (ch == '*') {
2889 file->buf_ptr = parse_comment(file->buf_ptr);
2890 ch = file->buf_ptr[0];
2891 goto redo;
2892 } else {
2893 q = name;
2894 *q++ = '/';
2895 goto parse_name;
2896 }
2897 break;
2898 /* case 'a' ... 'z': */
2899 case 'a':
2900 case 'b':
2901 case 'c':
2902 case 'd':
2903 case 'e':
2904 case 'f':
2905 case 'g':
2906 case 'h':
2907 case 'i':
2908 case 'j':
2909 case 'k':
2910 case 'l':
2911 case 'm':
2912 case 'n':
2913 case 'o':
2914 case 'p':
2915 case 'q':
2916 case 'r':
2917 case 's':
2918 case 't':
2919 case 'u':
2920 case 'v':
2921 case 'w':
2922 case 'x':
2923 case 'y':
2924 case 'z':
2925 /* case 'A' ... 'z': */
2926 case 'A':
2927 case 'B':
2928 case 'C':
2929 case 'D':
2930 case 'E':
2931 case 'F':
2932 case 'G':
2933 case 'H':
2934 case 'I':
2935 case 'J':
2936 case 'K':
2937 case 'L':
2938 case 'M':
2939 case 'N':
2940 case 'O':
2941 case 'P':
2942 case 'Q':
2943 case 'R':
2944 case 'S':
2945 case 'T':
2946 case 'U':
2947 case 'V':
2948 case 'W':
2949 case 'X':
2950 case 'Y':
2951 case 'Z':
2952 case '_':
2953 case '\\':
2954 case '.':
2955 case '$':
2956 case '~':
2957 q = name;
2958 parse_name:
2959 for(;;) {
2960 if (!((ch >= 'a' && ch <= 'z') ||
2961 (ch >= 'A' && ch <= 'Z') ||
2962 (ch >= '0' && ch <= '9') ||
2963 strchr("/.-_+=$:\\,~", ch)))
2964 break;
2965 if ((q - name) < name_size - 1) {
2966 *q++ = ch;
2967 }
2968 minp();
2969 }
2970 *q = '\0';
2971 c = LD_TOK_NAME;
2972 break;
2973 case CH_EOF:
2974 c = LD_TOK_EOF;
2975 break;
2976 default:
2977 c = ch;
2978 inp();
2979 break;
2980 }
2981 return c;
2982 }
2983
2984 static int ld_add_file(TCCState *s1, const char filename[])
2985 {
2986 int ret;
2987
2988 ret = tcc_add_file_internal(s1, filename, 0);
2989 if (ret)
2990 ret = tcc_add_dll(s1, filename, 0);
2991 return ret;
2992 }
2993
2994 static inline int new_undef_syms(void)
2995 {
2996 int ret = 0;
2997 ret = new_undef_sym;
2998 new_undef_sym = 0;
2999 return ret;
3000 }
3001
3002 static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
3003 {
3004 char filename[1024], libname[1024];
3005 int t, group, nblibs = 0, ret = 0;
3006 char **libs = NULL;
3007
3008 group = !strcmp(cmd, "GROUP");
3009 if (!as_needed)
3010 new_undef_syms();
3011 t = ld_next(s1, filename, sizeof(filename));
3012 if (t != '(')
3013 expect("(");
3014 t = ld_next(s1, filename, sizeof(filename));
3015 for(;;) {
3016 libname[0] = '\0';
3017 if (t == LD_TOK_EOF) {
3018 tcc_error_noabort("unexpected end of file");
3019 ret = -1;
3020 goto lib_parse_error;
3021 } else if (t == ')') {
3022 break;
3023 } else if (t == '-') {
3024 t = ld_next(s1, filename, sizeof(filename));
3025 if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
3026 tcc_error_noabort("library name expected");
3027 ret = -1;
3028 goto lib_parse_error;
3029 }
3030 pstrcpy(libname, sizeof libname, &filename[1]);
3031 if (s1->static_link) {
3032 snprintf(filename, sizeof filename, "lib%s.a", libname);
3033 } else {
3034 snprintf(filename, sizeof filename, "lib%s.so", libname);
3035 }
3036 } else if (t != LD_TOK_NAME) {
3037 tcc_error_noabort("filename expected");
3038 ret = -1;
3039 goto lib_parse_error;
3040 }
3041 if (!strcmp(filename, "AS_NEEDED")) {
3042 ret = ld_add_file_list(s1, cmd, 1);
3043 if (ret)
3044 goto lib_parse_error;
3045 } else {
3046 /* TODO: Implement AS_NEEDED support. Ignore it for now */
3047 if (!as_needed) {
3048 ret = ld_add_file(s1, filename);
3049 if (ret)
3050 goto lib_parse_error;
3051 if (group) {
3052 /* Add the filename *and* the libname to avoid future conversions */
3053 dynarray_add((void ***) &libs, &nblibs, tcc_strdup(filename));
3054 if (libname[0] != '\0')
3055 dynarray_add((void ***) &libs, &nblibs, tcc_strdup(libname));
3056 }
3057 }
3058 }
3059 t = ld_next(s1, filename, sizeof(filename));
3060 if (t == ',') {
3061 t = ld_next(s1, filename, sizeof(filename));
3062 }
3063 }
3064 if (group && !as_needed) {
3065 while (new_undef_syms()) {
3066 int i;
3067
3068 for (i = 0; i < nblibs; i ++)
3069 ld_add_file(s1, libs[i]);
3070 }
3071 }
3072 lib_parse_error:
3073 dynarray_reset(&libs, &nblibs);
3074 return ret;
3075 }
3076
3077 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
3078 files */
3079 ST_FUNC int tcc_load_ldscript(TCCState *s1)
3080 {
3081 char cmd[64];
3082 char filename[1024];
3083 int t, ret;
3084
3085 ch = file->buf_ptr[0];
3086 ch = handle_eob();
3087 for(;;) {
3088 t = ld_next(s1, cmd, sizeof(cmd));
3089 if (t == LD_TOK_EOF)
3090 return 0;
3091 else if (t != LD_TOK_NAME)
3092 return -1;
3093 if (!strcmp(cmd, "INPUT") ||
3094 !strcmp(cmd, "GROUP")) {
3095 ret = ld_add_file_list(s1, cmd, 0);
3096 if (ret)
3097 return ret;
3098 } else if (!strcmp(cmd, "OUTPUT_FORMAT") ||
3099 !strcmp(cmd, "TARGET")) {
3100 /* ignore some commands */
3101 t = ld_next(s1, cmd, sizeof(cmd));
3102 if (t != '(')
3103 expect("(");
3104 for(;;) {
3105 t = ld_next(s1, filename, sizeof(filename));
3106 if (t == LD_TOK_EOF) {
3107 tcc_error_noabort("unexpected end of file");
3108 return -1;
3109 } else if (t == ')') {
3110 break;
3111 }
3112 }
3113 } else {
3114 return -1;
3115 }
3116 }
3117 return 0;
3118 }
3119 #endif /* !TCC_TARGET_PE */
Tiny C Compiler main repository