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