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