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