tccelf.c

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