Unified · Split
| @@ -0,0 +1,1844 @@ | ||
| 1 | +/* | |
| 2 | + * ELF file handling for TCC | |
| 3 | + * | |
| 4 | + * Copyright (c) 2001, 2002 Fabrice Bellard | |
| 5 | + * | |
| 6 | + * This program is free software; you can redistribute it and/or modify | |
| 7 | + * it under the terms of the GNU General Public License as published by | |
| 8 | + * the Free Software Foundation; either version 2 of the License, or | |
| 9 | + * (at your option) any later version. | |
| 10 | + * | |
| 11 | + * This program 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 | |
| 14 | + * GNU General Public License for more details. | |
| 15 | + * | |
| 16 | + * You should have received a copy of the GNU General Public License | |
| 17 | + * along with this program; if not, write to the Free Software | |
| 18 | + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
| 19 | + */ | |
| 20 | + | |
| 21 | +static int put_elf_str(Section *s, const char *sym) | |
| 22 | +{ | |
| 23 | + int offset, len; | |
| 24 | + char *ptr; | |
| 25 | + | |
| 26 | + len = strlen(sym) + 1; | |
| 27 | + offset = s->data_offset; | |
| 28 | + ptr = section_ptr_add(s, len); | |
| 29 | + memcpy(ptr, sym, len); | |
| 30 | + return offset; | |
| 31 | +} | |
| 32 | + | |
| 33 | +/* elf symbol hashing function */ | |
| 34 | +static unsigned long elf_hash(const unsigned char *name) | |
| 35 | +{ | |
| 36 | + unsigned long h = 0, g; | |
| 37 | + | |
| 38 | + while (*name) { | |
| 39 | + h = (h << 4) + *name++; | |
| 40 | + g = h & 0xf0000000; | |
| 41 | + if (g) | |
| 42 | + h ^= g >> 24; | |
| 43 | + h &= ~g; | |
| 44 | + } | |
| 45 | + return h; | |
| 46 | +} | |
| 47 | + | |
| 48 | +/* rebuild hash table of section s */ | |
| 49 | +/* NOTE: we do factorize the hash table code to go faster */ | |
| 50 | +static void rebuild_hash(Section *s, unsigned int nb_buckets) | |
| 51 | +{ | |
| 52 | + Elf32_Sym *sym; | |
| 53 | + int *ptr, *hash, nb_syms, sym_index, h; | |
| 54 | + char *strtab; | |
| 55 | + | |
| 56 | + strtab = s->link->data; | |
| 57 | + nb_syms = s->data_offset / sizeof(Elf32_Sym); | |
| 58 | + | |
| 59 | + s->hash->data_offset = 0; | |
| 60 | + ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int)); | |
| 61 | + ptr[0] = nb_buckets; | |
| 62 | + ptr[1] = nb_syms; | |
| 63 | + ptr += 2; | |
| 64 | + hash = ptr; | |
| 65 | + memset(hash, 0, (nb_buckets + 1) * sizeof(int)); | |
| 66 | + ptr += nb_buckets + 1; | |
| 67 | + | |
| 68 | + sym = (Elf32_Sym *)s->data + 1; | |
| 69 | + for(sym_index = 1; sym_index < nb_syms; sym_index++) { | |
| 70 | + if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) { | |
| 71 | + h = elf_hash(strtab + sym->st_name) % nb_buckets; | |
| 72 | + *ptr = hash[h]; | |
| 73 | + hash[h] = sym_index; | |
| 74 | + } else { | |
| 75 | + *ptr = 0; | |
| 76 | + } | |
| 77 | + ptr++; | |
| 78 | + sym++; | |
| 79 | + } | |
| 80 | +} | |
| 81 | + | |
| 82 | +/* return the symbol number */ | |
| 83 | +static int put_elf_sym(Section *s, | |
| 84 | + unsigned long value, unsigned long size, | |
| 85 | + int info, int other, int shndx, const char *name) | |
| 86 | +{ | |
| 87 | + int name_offset, sym_index; | |
| 88 | + int nbuckets, h; | |
| 89 | + Elf32_Sym *sym; | |
| 90 | + Section *hs; | |
| 91 | + | |
| 92 | + sym = section_ptr_add(s, sizeof(Elf32_Sym)); | |
| 93 | + if (name) | |
| 94 | + name_offset = put_elf_str(s->link, name); | |
| 95 | + else | |
| 96 | + name_offset = 0; | |
| 97 | + /* XXX: endianness */ | |
| 98 | + sym->st_name = name_offset; | |
| 99 | + sym->st_value = value; | |
| 100 | + sym->st_size = size; | |
| 101 | + sym->st_info = info; | |
| 102 | + sym->st_other = other; | |
| 103 | + sym->st_shndx = shndx; | |
| 104 | + sym_index = sym - (Elf32_Sym *)s->data; | |
| 105 | + hs = s->hash; | |
| 106 | + if (hs) { | |
| 107 | + int *ptr, *base; | |
| 108 | + ptr = section_ptr_add(hs, sizeof(int)); | |
| 109 | + base = (int *)hs->data; | |
| 110 | + /* only add global or weak symbols */ | |
| 111 | + if (ELF32_ST_BIND(info) != STB_LOCAL) { | |
| 112 | + /* add another hashing entry */ | |
| 113 | + nbuckets = base[0]; | |
| 114 | + h = elf_hash(name) % nbuckets; | |
| 115 | + *ptr = base[2 + h]; | |
| 116 | + base[2 + h] = sym_index; | |
| 117 | + base[1]++; | |
| 118 | + /* we resize the hash table */ | |
| 119 | + hs->nb_hashed_syms++; | |
| 120 | + if (hs->nb_hashed_syms > 2 * nbuckets) { | |
| 121 | + rebuild_hash(s, 2 * nbuckets); | |
| 122 | + } | |
| 123 | + } else { | |
| 124 | + *ptr = 0; | |
| 125 | + base[1]++; | |
| 126 | + } | |
| 127 | + } | |
| 128 | + return sym_index; | |
| 129 | +} | |
| 130 | + | |
| 131 | +/* find global ELF symbol 'name' and return its index. Return 0 if not | |
| 132 | + found. */ | |
| 133 | +static int find_elf_sym(Section *s, const char *name) | |
| 134 | +{ | |
| 135 | + Elf32_Sym *sym; | |
| 136 | + Section *hs; | |
| 137 | + int nbuckets, sym_index, h; | |
| 138 | + const char *name1; | |
| 139 | + | |
| 140 | + hs = s->hash; | |
| 141 | + if (!hs) | |
| 142 | + return 0; | |
| 143 | + nbuckets = ((int *)hs->data)[0]; | |
| 144 | + h = elf_hash(name) % nbuckets; | |
| 145 | + sym_index = ((int *)hs->data)[2 + h]; | |
| 146 | + while (sym_index != 0) { | |
| 147 | + sym = &((Elf32_Sym *)s->data)[sym_index]; | |
| 148 | + name1 = s->link->data + sym->st_name; | |
| 149 | + if (!strcmp(name, name1)) | |
| 150 | + return sym_index; | |
| 151 | + sym_index = ((int *)hs->data)[2 + nbuckets + sym_index]; | |
| 152 | + } | |
| 153 | + return 0; | |
| 154 | +} | |
| 155 | + | |
| 156 | +/* return elf symbol value or error */ | |
| 157 | +static unsigned long get_elf_sym_val(const char *name) | |
| 158 | +{ | |
| 159 | + int sym_index; | |
| 160 | + Elf32_Sym *sym; | |
| 161 | + | |
| 162 | + sym_index = find_elf_sym(symtab_section, name); | |
| 163 | + if (!sym_index) | |
| 164 | + error("%s not defined", name); | |
| 165 | + sym = &((Elf32_Sym *)symtab_section->data)[sym_index]; | |
| 166 | + return sym->st_value; | |
| 167 | +} | |
| 168 | + | |
| 169 | +/* add an elf symbol : check if it is already defined and patch | |
| 170 | + it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */ | |
| 171 | +static int add_elf_sym(Section *s, unsigned long value, unsigned long size, | |
| 172 | + int info, int sh_num, const char *name) | |
| 173 | +{ | |
| 174 | + Elf32_Sym *esym; | |
| 175 | + int sym_bind, sym_index, sym_type, esym_bind; | |
| 176 | + | |
| 177 | + sym_bind = ELF32_ST_BIND(info); | |
| 178 | + sym_type = ELF32_ST_TYPE(info); | |
| 179 | + | |
| 180 | + if (sym_bind != STB_LOCAL) { | |
| 181 | + /* we search global or weak symbols */ | |
| 182 | + sym_index = find_elf_sym(s, name); | |
| 183 | + if (!sym_index) | |
| 184 | + goto do_def; | |
| 185 | + esym = &((Elf32_Sym *)s->data)[sym_index]; | |
| 186 | + if (esym->st_shndx != SHN_UNDEF) { | |
| 187 | + esym_bind = ELF32_ST_BIND(esym->st_info); | |
| 188 | + if (sh_num == SHN_UNDEF) { | |
| 189 | + /* ignore adding of undefined symbol if the | |
| 190 | + corresponding symbol is already defined */ | |
| 191 | + } else if (sym_bind == STB_GLOBAL && esym_bind == STB_WEAK) { | |
| 192 | + /* global overrides weak, so patch */ | |
| 193 | + goto do_patch; | |
| 194 | + } else if (sym_bind == STB_WEAK && esym_bind == STB_GLOBAL) { | |
| 195 | + /* weak is ignored if already global */ | |
| 196 | + } else { | |
| 197 | +#if 0 | |
| 198 | + printf("new_bind=%d new_shndx=%d last_bind=%d old_shndx=%d\n", | |
| 199 | + sym_bind, sh_num, esym_bind, esym->st_shndx); | |
| 200 | +#endif | |
| 201 | + /* NOTE: we accept that two DLL define the same symbol */ | |
| 202 | + if (s != dynsymtab_section) | |
| 203 | + error("'%s' defined twice", name); | |
| 204 | + } | |
| 205 | + } else { | |
| 206 | + do_patch: | |
| 207 | + esym->st_info = ELF32_ST_INFO(sym_bind, sym_type); | |
| 208 | + esym->st_shndx = sh_num; | |
| 209 | + esym->st_value = value; | |
| 210 | + esym->st_size = size; | |
| 211 | + } | |
| 212 | + } else { | |
| 213 | + do_def: | |
| 214 | + sym_index = put_elf_sym(s, value, size, | |
| 215 | + ELF32_ST_INFO(sym_bind, sym_type), 0, | |
| 216 | + sh_num, name); | |
| 217 | + } | |
| 218 | + return sym_index; | |
| 219 | +} | |
| 220 | + | |
| 221 | +/* put relocation */ | |
| 222 | +static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset, | |
| 223 | + int type, int symbol) | |
| 224 | +{ | |
| 225 | + char buf[256]; | |
| 226 | + Section *sr; | |
| 227 | + Elf32_Rel *rel; | |
| 228 | + | |
| 229 | + sr = s->reloc; | |
| 230 | + if (!sr) { | |
| 231 | + /* if no relocation section, create it */ | |
| 232 | + snprintf(buf, sizeof(buf), ".rel%s", s->name); | |
| 233 | + /* if the symtab is allocated, then we consider the relocation | |
| 234 | + are also */ | |
| 235 | + sr = new_section(buf, SHT_REL, symtab->sh_flags); | |
| 236 | + sr->sh_entsize = sizeof(Elf32_Rel); | |
| 237 | + sr->link = symtab; | |
| 238 | + sr->sh_info = s->sh_num; | |
| 239 | + s->reloc = sr; | |
| 240 | + } | |
| 241 | + rel = section_ptr_add(sr, sizeof(Elf32_Rel)); | |
| 242 | + rel->r_offset = offset; | |
| 243 | + rel->r_info = ELF32_R_INFO(symbol, type); | |
| 244 | +} | |
| 245 | + | |
| 246 | +/* put stab debug information */ | |
| 247 | + | |
| 248 | +typedef struct { | |
| 249 | + unsigned long n_strx; /* index into string table of name */ | |
| 250 | + unsigned char n_type; /* type of symbol */ | |
| 251 | + unsigned char n_other; /* misc info (usually empty) */ | |
| 252 | + unsigned short n_desc; /* description field */ | |
| 253 | + unsigned long n_value; /* value of symbol */ | |
| 254 | +} Stab_Sym; | |
| 255 | + | |
| 256 | +static void put_stabs(const char *str, int type, int other, int desc, | |
| 257 | + unsigned long value) | |
| 258 | +{ | |
| 259 | + Stab_Sym *sym; | |
| 260 | + | |
| 261 | + sym = section_ptr_add(stab_section, sizeof(Stab_Sym)); | |
| 262 | + if (str) { | |
| 263 | + sym->n_strx = put_elf_str(stabstr_section, str); | |
| 264 | + } else { | |
| 265 | + sym->n_strx = 0; | |
| 266 | + } | |
| 267 | + sym->n_type = type; | |
| 268 | + sym->n_other = other; | |
| 269 | + sym->n_desc = desc; | |
| 270 | + sym->n_value = value; | |
| 271 | +} | |
| 272 | + | |
| 273 | +static void put_stabs_r(const char *str, int type, int other, int desc, | |
| 274 | + unsigned long value, Section *sec, int sym_index) | |
| 275 | +{ | |
| 276 | + put_stabs(str, type, other, desc, value); | |
| 277 | + put_elf_reloc(symtab_section, stab_section, | |
| 278 | + stab_section->data_offset - sizeof(unsigned long), | |
| 279 | + R_DATA_32, sym_index); | |
| 280 | +} | |
| 281 | + | |
| 282 | +static void put_stabn(int type, int other, int desc, int value) | |
| 283 | +{ | |
| 284 | + put_stabs(NULL, type, other, desc, value); | |
| 285 | +} | |
| 286 | + | |
| 287 | +static void put_stabd(int type, int other, int desc) | |
| 288 | +{ | |
| 289 | + put_stabs(NULL, type, other, desc, 0); | |
| 290 | +} | |
| 291 | + | |
| 292 | +/* In an ELF file symbol table, the local symbols must appear below | |
| 293 | + the global and weak ones. Since TCC cannot sort it while generating | |
| 294 | + the code, we must do it after. All the relocation tables are also | |
| 295 | + modified to take into account the symbol table sorting */ | |
| 296 | +static void sort_syms(Section *s) | |
| 297 | +{ | |
| 298 | + int *old_to_new_syms; | |
| 299 | + Elf32_Sym *new_syms; | |
| 300 | + int nb_syms, i; | |
| 301 | + Elf32_Sym *p, *q; | |
| 302 | + Elf32_Rel *rel, *rel_end; | |
| 303 | + Section *sr; | |
| 304 | + int type, sym_index; | |
| 305 | + | |
| 306 | + nb_syms = s->data_offset / sizeof(Elf32_Sym); | |
| 307 | + new_syms = tcc_malloc(nb_syms * sizeof(Elf32_Sym)); | |
| 308 | + old_to_new_syms = tcc_malloc(nb_syms * sizeof(int)); | |
| 309 | + | |
| 310 | + /* first pass for local symbols */ | |
| 311 | + p = (Elf32_Sym *)s->data; | |
| 312 | + q = new_syms; | |
| 313 | + for(i = 0; i < nb_syms; i++) { | |
| 314 | + if (ELF32_ST_BIND(p->st_info) == STB_LOCAL) { | |
| 315 | + old_to_new_syms[i] = q - new_syms; | |
| 316 | + *q++ = *p; | |
| 317 | + } | |
| 318 | + p++; | |
| 319 | + } | |
| 320 | + /* save the number of local symbols in section header */ | |
| 321 | + s->sh_info = q - new_syms; | |
| 322 | + | |
| 323 | + /* then second pass for non local symbols */ | |
| 324 | + p = (Elf32_Sym *)s->data; | |
| 325 | + for(i = 0; i < nb_syms; i++) { | |
| 326 | + if (ELF32_ST_BIND(p->st_info) != STB_LOCAL) { | |
| 327 | + old_to_new_syms[i] = q - new_syms; | |
| 328 | + *q++ = *p; | |
| 329 | + } | |
| 330 | + p++; | |
| 331 | + } | |
| 332 | + | |
| 333 | + /* we copy the new symbols to the old */ | |
| 334 | + memcpy(s->data, new_syms, nb_syms * sizeof(Elf32_Sym)); | |
| 335 | + tcc_free(new_syms); | |
| 336 | + | |
| 337 | + /* now we modify all the relocations */ | |
| 338 | + for(i = 1; i < nb_sections; i++) { | |
| 339 | + sr = sections[i]; | |
| 340 | + if (sr->sh_type == SHT_REL && sr->link == s) { | |
| 341 | + rel_end = (Elf32_Rel *)(sr->data + sr->data_offset); | |
| 342 | + for(rel = (Elf32_Rel *)sr->data; | |
| 343 | + rel < rel_end; | |
| 344 | + rel++) { | |
| 345 | + sym_index = ELF32_R_SYM(rel->r_info); | |
| 346 | + type = ELF32_R_TYPE(rel->r_info); | |
| 347 | + sym_index = old_to_new_syms[sym_index]; | |
| 348 | + rel->r_info = ELF32_R_INFO(sym_index, type); | |
| 349 | + } | |
| 350 | + } | |
| 351 | + } | |
| 352 | + | |
| 353 | + tcc_free(old_to_new_syms); | |
| 354 | +} | |
| 355 | + | |
| 356 | +/* relocate common symbols in the .bss section */ | |
| 357 | +static void relocate_common_syms(void) | |
| 358 | +{ | |
| 359 | + Elf32_Sym *sym, *sym_end; | |
| 360 | + unsigned long offset, align; | |
| 361 | + | |
| 362 | + sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset); | |
| 363 | + for(sym = (Elf32_Sym *)symtab_section->data + 1; | |
| 364 | + sym < sym_end; | |
| 365 | + sym++) { | |
| 366 | + if (sym->st_shndx == SHN_COMMON) { | |
| 367 | + /* align symbol */ | |
| 368 | + align = sym->st_value; | |
| 369 | + offset = bss_section->data_offset; | |
| 370 | + offset = (offset + align - 1) & -align; | |
| 371 | + sym->st_value = offset; | |
| 372 | + sym->st_shndx = bss_section->sh_num; | |
| 373 | + offset += sym->st_size; | |
| 374 | + bss_section->data_offset = offset; | |
| 375 | + } | |
| 376 | + } | |
| 377 | +} | |
| 378 | + | |
| 379 | +static void *resolve_sym(const char *sym) | |
| 380 | +{ | |
| 381 | + return dlsym(NULL, sym); | |
| 382 | +} | |
| 383 | + | |
| 384 | +/* relocate symbol table, resolve undefined symbols if do_resolve is | |
| 385 | + true and output error if undefined symbol. */ | |
| 386 | +static void relocate_syms(int do_resolve) | |
| 387 | +{ | |
| 388 | + Elf32_Sym *sym, *esym, *sym_end; | |
| 389 | + int sym_bind, sh_num, sym_index; | |
| 390 | + const char *name; | |
| 391 | + unsigned long addr; | |
| 392 | + | |
| 393 | + sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset); | |
| 394 | + for(sym = (Elf32_Sym *)symtab_section->data + 1; | |
| 395 | + sym < sym_end; | |
| 396 | + sym++) { | |
| 397 | + sh_num = sym->st_shndx; | |
| 398 | + if (sh_num == SHN_UNDEF) { | |
| 399 | + name = strtab_section->data + sym->st_name; | |
| 400 | + if (do_resolve) { | |
| 401 | + name = symtab_section->link->data + sym->st_name; | |
| 402 | + addr = (unsigned long)resolve_sym(name); | |
| 403 | + if (addr) { | |
| 404 | + sym->st_value = addr; | |
| 405 | + goto found; | |
| 406 | + } | |
| 407 | + } else if (dynsym) { | |
| 408 | + /* if dynamic symbol exist, then use it */ | |
| 409 | + sym_index = find_elf_sym(dynsym, name); | |
| 410 | + if (sym_index) { | |
| 411 | + esym = &((Elf32_Sym *)dynsym->data)[sym_index]; | |
| 412 | + sym->st_value = esym->st_value; | |
| 413 | + goto found; | |
| 414 | + } | |
| 415 | + } | |
| 416 | + /* XXX: _fp_hw seems to be part of the ABI, so we ignore | |
| 417 | + it */ | |
| 418 | + if (!strcmp(name, "_fp_hw")) | |
| 419 | + goto found; | |
| 420 | + /* only weak symbols are accepted to be undefined. Their | |
| 421 | + value is zero */ | |
| 422 | + sym_bind = ELF32_ST_BIND(sym->st_info); | |
| 423 | + if (sym_bind == STB_WEAK) { | |
| 424 | + sym->st_value = 0; | |
| 425 | + } else { | |
| 426 | + error("undefined symbol '%s'", name); | |
| 427 | + } | |
| 428 | + } else if (sh_num < SHN_LORESERVE) { | |
| 429 | + /* add section base */ | |
| 430 | + sym->st_value += sections[sym->st_shndx]->sh_addr; | |
| 431 | + } | |
| 432 | + found: ; | |
| 433 | + } | |
| 434 | +} | |
| 435 | + | |
| 436 | +/* relocate a given section (CPU dependant) */ | |
| 437 | +static void relocate_section(TCCState *s1, Section *s) | |
| 438 | +{ | |
| 439 | + Section *sr; | |
| 440 | + Elf32_Rel *rel, *rel_end, *qrel; | |
| 441 | + Elf32_Sym *sym; | |
| 442 | + int type, sym_index, esym_index; | |
| 443 | + unsigned char *ptr; | |
| 444 | + unsigned long val, addr; | |
| 445 | + | |
| 446 | + sr = s->reloc; | |
| 447 | + rel_end = (Elf32_Rel *)(sr->data + sr->data_offset); | |
| 448 | + qrel = (Elf32_Rel *)sr->data; | |
| 449 | + for(rel = qrel; | |
| 450 | + rel < rel_end; | |
| 451 | + rel++) { | |
| 452 | + ptr = s->data + rel->r_offset; | |
| 453 | + | |
| 454 | + sym_index = ELF32_R_SYM(rel->r_info); | |
| 455 | + sym = &((Elf32_Sym *)symtab_section->data)[sym_index]; | |
| 456 | + val = sym->st_value; | |
| 457 | + type = ELF32_R_TYPE(rel->r_info); | |
| 458 | + addr = s->sh_addr + rel->r_offset; | |
| 459 | + | |
| 460 | + /* CPU specific */ | |
| 461 | + switch(type) { | |
| 462 | + case R_386_32: | |
| 463 | + if (s1->output_type == TCC_OUTPUT_DLL) { | |
| 464 | + esym_index = symtab_to_dynsym[sym_index]; | |
| 465 | + qrel->r_offset = rel->r_offset; | |
| 466 | + if (esym_index) { | |
| 467 | + qrel->r_info = ELF32_R_INFO(esym_index, R_386_32); | |
| 468 | + qrel++; | |
| 469 | + break; | |
| 470 | + } else { | |
| 471 | + qrel->r_info = ELF32_R_INFO(0, R_386_RELATIVE); | |
| 472 | + qrel++; | |
| 473 | + } | |
| 474 | + } | |
| 475 | + *(int *)ptr += val; | |
| 476 | + break; | |
| 477 | + case R_386_PC32: | |
| 478 | + if (s1->output_type == TCC_OUTPUT_DLL) { | |
| 479 | + /* DLL relocation */ | |
| 480 | + esym_index = symtab_to_dynsym[sym_index]; | |
| 481 | + if (esym_index) { | |
| 482 | + qrel->r_offset = rel->r_offset; | |
| 483 | + qrel->r_info = ELF32_R_INFO(esym_index, R_386_PC32); | |
| 484 | + qrel++; | |
| 485 | + break; | |
| 486 | + } | |
| 487 | + } | |
| 488 | + *(int *)ptr += val - addr; | |
| 489 | + break; | |
| 490 | + case R_386_PLT32: | |
| 491 | + *(int *)ptr += val - addr; | |
| 492 | + break; | |
| 493 | + case R_386_GLOB_DAT: | |
| 494 | + case R_386_JMP_SLOT: | |
| 495 | + *(int *)ptr = val; | |
| 496 | + break; | |
| 497 | + case R_386_GOTPC: | |
| 498 | + *(int *)ptr += got->sh_addr - addr; | |
| 499 | + break; | |
| 500 | + case R_386_GOTOFF: | |
| 501 | + *(int *)ptr += val - got->sh_addr; | |
| 502 | + break; | |
| 503 | + case R_386_GOT32: | |
| 504 | + /* we load the got offset */ | |
| 505 | + *(int *)ptr += got_offsets[sym_index]; | |
| 506 | + break; | |
| 507 | + } | |
| 508 | + } | |
| 509 | + /* if the relocation is allocated, we change its symbol table */ | |
| 510 | + if (sr->sh_flags & SHF_ALLOC) | |
| 511 | + sr->link = dynsym; | |
| 512 | +} | |
| 513 | + | |
| 514 | +/* relocate relocation table in 'sr' */ | |
| 515 | +static void relocate_rel(Section *sr) | |
| 516 | +{ | |
| 517 | + Section *s; | |
| 518 | + Elf32_Rel *rel, *rel_end; | |
| 519 | + | |
| 520 | + s = sections[sr->sh_info]; | |
| 521 | + rel_end = (Elf32_Rel *)(sr->data + sr->data_offset); | |
| 522 | + for(rel = (Elf32_Rel *)sr->data; | |
| 523 | + rel < rel_end; | |
| 524 | + rel++) { | |
| 525 | + rel->r_offset += s->sh_addr; | |
| 526 | + } | |
| 527 | +} | |
| 528 | + | |
| 529 | +/* count the number of dynamic relocations so that we can reserve | |
| 530 | + their space */ | |
| 531 | +static int prepare_dynamic_rel(Section *sr) | |
| 532 | +{ | |
| 533 | + Elf32_Rel *rel, *rel_end; | |
| 534 | + int sym_index, esym_index, type, count; | |
| 535 | + | |
| 536 | + count = 0; | |
| 537 | + rel_end = (Elf32_Rel *)(sr->data + sr->data_offset); | |
| 538 | + for(rel = (Elf32_Rel *)sr->data; rel < rel_end; rel++) { | |
| 539 | + sym_index = ELF32_R_SYM(rel->r_info); | |
| 540 | + type = ELF32_R_TYPE(rel->r_info); | |
| 541 | + switch(type) { | |
| 542 | + case R_386_32: | |
| 543 | + count++; | |
| 544 | + break; | |
| 545 | + case R_386_PC32: | |
| 546 | + esym_index = symtab_to_dynsym[sym_index]; | |
| 547 | + if (esym_index) | |
| 548 | + count++; | |
| 549 | + break; | |
| 550 | + default: | |
| 551 | + break; | |
| 552 | + } | |
| 553 | + } | |
| 554 | + if (count) { | |
| 555 | + /* allocate the section */ | |
| 556 | + sr->sh_flags |= SHF_ALLOC; | |
| 557 | + sr->sh_size = count * sizeof(Elf32_Rel); | |
| 558 | + } | |
| 559 | + return count; | |
| 560 | +} | |
| 561 | + | |
| 562 | +static void put_got_offset(int index, unsigned long val) | |
| 563 | +{ | |
| 564 | + int n; | |
| 565 | + unsigned long *tab; | |
| 566 | + | |
| 567 | + if (index >= nb_got_offsets) { | |
| 568 | + /* find immediately bigger power of 2 and reallocate array */ | |
| 569 | + n = 1; | |
| 570 | + while (index >= n) | |
| 571 | + n *= 2; | |
| 572 | + tab = tcc_realloc(got_offsets, n * sizeof(unsigned long)); | |
| 573 | + if (!tab) | |
| 574 | + error("memory full"); | |
| 575 | + got_offsets = tab; | |
| 576 | + memset(got_offsets + nb_got_offsets, 0, | |
| 577 | + (n - nb_got_offsets) * sizeof(unsigned long)); | |
| 578 | + nb_got_offsets = n; | |
| 579 | + } | |
| 580 | + got_offsets[index] = val; | |
| 581 | +} | |
| 582 | + | |
| 583 | +/* XXX: suppress that */ | |
| 584 | +static void put32(unsigned char *p, unsigned int val) | |
| 585 | +{ | |
| 586 | + p[0] = val; | |
| 587 | + p[1] = val >> 8; | |
| 588 | + p[2] = val >> 16; | |
| 589 | + p[3] = val >> 24; | |
| 590 | +} | |
| 591 | + | |
| 592 | +static void build_got(void) | |
| 593 | +{ | |
| 594 | + unsigned char *ptr; | |
| 595 | + | |
| 596 | + /* if no got, then create it */ | |
| 597 | + got = new_section(".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE); | |
| 598 | + got->sh_entsize = 4; | |
| 599 | + add_elf_sym(symtab_section, 0, 4, ELF32_ST_INFO(STB_GLOBAL, STT_OBJECT), | |
| 600 | + got->sh_num, "_GLOBAL_OFFSET_TABLE_"); | |
| 601 | + ptr = section_ptr_add(got, 3 * sizeof(int)); | |
| 602 | + /* keep space for _DYNAMIC pointer, if present */ | |
| 603 | + put32(ptr, 0); | |
| 604 | + /* two dummy got entries */ | |
| 605 | + put32(ptr + 4, 0); | |
| 606 | + put32(ptr + 8, 0); | |
| 607 | +} | |
| 608 | + | |
| 609 | +/* put a got entry corresponding to a symbol in symtab_section. 'size' | |
| 610 | + and 'info' can be modifed if more precise info comes from the DLL */ | |
| 611 | +static void put_got_entry(int reloc_type, unsigned long size, int info, | |
| 612 | + int sym_index) | |
| 613 | +{ | |
| 614 | + int index; | |
| 615 | + const char *name; | |
| 616 | + Elf32_Sym *sym; | |
| 617 | + unsigned long offset; | |
| 618 | + int *ptr; | |
| 619 | + | |
| 620 | + if (!got) | |
| 621 | + build_got(); | |
| 622 | + | |
| 623 | + /* if a got entry already exists for that symbol, no need to add one */ | |
| 624 | + if (sym_index < nb_got_offsets && | |
| 625 | + got_offsets[sym_index] != 0) | |
| 626 | + return; | |
| 627 | + | |
| 628 | + put_got_offset(sym_index, got->data_offset); | |
| 629 | + | |
| 630 | + if (dynsym) { | |
| 631 | + sym = &((Elf32_Sym *)symtab_section->data)[sym_index]; | |
| 632 | + name = symtab_section->link->data + sym->st_name; | |
| 633 | + offset = sym->st_value; | |
| 634 | + /* NOTE: we put temporarily the got offset */ | |
| 635 | + if (reloc_type == R_386_JMP_SLOT) { | |
| 636 | + nb_plt_entries++; | |
| 637 | + offset = got->data_offset; | |
| 638 | + } | |
| 639 | + index = put_elf_sym(dynsym, offset, | |
| 640 | + size, info, 0, sym->st_shndx, name); | |
| 641 | + /* put a got entry */ | |
| 642 | + put_elf_reloc(dynsym, got, | |
| 643 | + got->data_offset, | |
| 644 | + reloc_type, index); | |
| 645 | + } | |
| 646 | + ptr = section_ptr_add(got, sizeof(int)); | |
| 647 | + *ptr = 0; | |
| 648 | +} | |
| 649 | + | |
| 650 | +/* build GOT and PLT entries */ | |
| 651 | +static void build_got_entries(void) | |
| 652 | +{ | |
| 653 | + Section *s, *symtab; | |
| 654 | + Elf32_Rel *rel, *rel_end; | |
| 655 | + Elf32_Sym *sym; | |
| 656 | + int i, type, reloc_type, sym_index; | |
| 657 | + | |
| 658 | + for(i = 1; i < nb_sections; i++) { | |
| 659 | + s = sections[i]; | |
| 660 | + if (s->sh_type != SHT_REL) | |
| 661 | + continue; | |
| 662 | + /* no need to handle got relocations */ | |
| 663 | + if (s->link != symtab_section) | |
| 664 | + continue; | |
| 665 | + symtab = s->link; | |
| 666 | + rel_end = (Elf32_Rel *)(s->data + s->data_offset); | |
| 667 | + for(rel = (Elf32_Rel *)s->data; | |
| 668 | + rel < rel_end; | |
| 669 | + rel++) { | |
| 670 | + type = ELF32_R_TYPE(rel->r_info); | |
| 671 | + switch(type) { | |
| 672 | + case R_386_GOT32: | |
| 673 | + case R_386_GOTOFF: | |
| 674 | + case R_386_GOTPC: | |
| 675 | + case R_386_PLT32: | |
| 676 | + if (!got) | |
| 677 | + build_got(); | |
| 678 | + if (type == R_386_GOT32 || type == R_386_PLT32) { | |
| 679 | + sym_index = ELF32_R_SYM(rel->r_info); | |
| 680 | + sym = &((Elf32_Sym *)symtab_section->data)[sym_index]; | |
| 681 | + /* look at the symbol got offset. If none, then add one */ | |
| 682 | + if (type == R_386_GOT32) | |
| 683 | + reloc_type = R_386_GLOB_DAT; | |
| 684 | + else | |
| 685 | + reloc_type = R_386_JMP_SLOT; | |
| 686 | + put_got_entry(reloc_type, sym->st_size, sym->st_info, | |
| 687 | + sym_index); | |
| 688 | + } | |
| 689 | + break; | |
| 690 | + default: | |
| 691 | + break; | |
| 692 | + } | |
| 693 | + } | |
| 694 | + } | |
| 695 | +} | |
| 696 | + | |
| 697 | +static Section *new_symtab(const char *symtab_name, int sh_type, int sh_flags, | |
| 698 | + const char *strtab_name, | |
| 699 | + const char *hash_name, int hash_sh_flags) | |
| 700 | +{ | |
| 701 | + Section *symtab, *strtab, *hash; | |
| 702 | + int *ptr, nb_buckets; | |
| 703 | + | |
| 704 | + symtab = new_section(symtab_name, sh_type, sh_flags); | |
| 705 | + symtab->sh_entsize = sizeof(Elf32_Sym); | |
| 706 | + strtab = new_section(strtab_name, SHT_STRTAB, sh_flags); | |
| 707 | + put_elf_str(strtab, ""); | |
| 708 | + symtab->link = strtab; | |
| 709 | + put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL); | |
| 710 | + | |
| 711 | + nb_buckets = 1; | |
| 712 | + | |
| 713 | + hash = new_section(hash_name, SHT_HASH, hash_sh_flags); | |
| 714 | + hash->sh_entsize = sizeof(int); | |
| 715 | + symtab->hash = hash; | |
| 716 | + hash->link = symtab; | |
| 717 | + | |
| 718 | + ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int)); | |
| 719 | + ptr[0] = nb_buckets; | |
| 720 | + ptr[1] = 1; | |
| 721 | + memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int)); | |
| 722 | + return symtab; | |
| 723 | +} | |
| 724 | + | |
| 725 | +/* put dynamic tag */ | |
| 726 | +static void put_dt(Section *dynamic, int dt, unsigned long val) | |
| 727 | +{ | |
| 728 | + Elf32_Dyn *dyn; | |
| 729 | + dyn = section_ptr_add(dynamic, sizeof(Elf32_Dyn)); | |
| 730 | + dyn->d_tag = dt; | |
| 731 | + dyn->d_un.d_val = val; | |
| 732 | +} | |
| 733 | + | |
| 734 | +/* add tcc runtime libraries */ | |
| 735 | +static void tcc_add_runtime(TCCState *s1) | |
| 736 | +{ | |
| 737 | + char buf[1024]; | |
| 738 | + int i; | |
| 739 | + Section *s; | |
| 740 | + | |
| 741 | + snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "libtcc1.o"); | |
| 742 | + tcc_add_file(s1, buf); | |
| 743 | +#ifdef CONFIG_TCC_BCHECK | |
| 744 | + if (do_bounds_check) { | |
| 745 | + unsigned long *ptr; | |
| 746 | + Section *init_section; | |
| 747 | + unsigned char *pinit; | |
| 748 | + int sym_index; | |
| 749 | + | |
| 750 | + /* XXX: add an object file to do that */ | |
| 751 | + ptr = section_ptr_add(bounds_section, sizeof(unsigned long)); | |
| 752 | + *ptr = 0; | |
| 753 | + add_elf_sym(symtab_section, 0, 0, | |
| 754 | + ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), | |
| 755 | + bounds_section->sh_num, "__bounds_start"); | |
| 756 | + /* add bound check code */ | |
| 757 | + snprintf(buf, sizeof(buf), "%s/%s", tcc_lib_path, "bcheck.o"); | |
| 758 | + tcc_add_file(s1, buf); | |
| 759 | +#ifdef TCC_TARGET_I386 | |
| 760 | + if (s1->output_type != TCC_OUTPUT_MEMORY) { | |
| 761 | + /* add 'call __bound_init()' in .init section */ | |
| 762 | + init_section = find_section(".init"); | |
| 763 | + pinit = section_ptr_add(init_section, 5); | |
| 764 | + pinit[0] = 0xe8; | |
| 765 | + put32(pinit + 1, -4); | |
| 766 | + sym_index = find_elf_sym(symtab_section, "__bound_init"); | |
| 767 | + put_elf_reloc(symtab_section, init_section, | |
| 768 | + init_section->data_offset - 4, R_386_PC32, sym_index); | |
| 769 | + } | |
| 770 | +#endif | |
| 771 | + } | |
| 772 | +#endif | |
| 773 | + /* add libc if not memory output */ | |
| 774 | + if (s1->output_type != TCC_OUTPUT_MEMORY) { | |
| 775 | + tcc_add_library(s1, "c"); | |
| 776 | + tcc_add_file(s1, CONFIG_TCC_CRT_PREFIX "/crtn.o"); | |
| 777 | + } | |
| 778 | + /* add various standard linker symbols */ | |
| 779 | + add_elf_sym(symtab_section, | |
| 780 | + text_section->data_offset, 0, | |
| 781 | + ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), | |
| 782 | + text_section->sh_num, "_etext"); | |
| 783 | + add_elf_sym(symtab_section, | |
| 784 | + data_section->data_offset, 0, | |
| 785 | + ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), | |
| 786 | + data_section->sh_num, "_edata"); | |
| 787 | + add_elf_sym(symtab_section, | |
| 788 | + bss_section->data_offset, 0, | |
| 789 | + ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), | |
| 790 | + bss_section->sh_num, "_end"); | |
| 791 | + /* add start and stop symbols for sections whose name can be | |
| 792 | + expressed in C */ | |
| 793 | + for(i = 1; i < nb_sections; i++) { | |
| 794 | + s = sections[i]; | |
| 795 | + if (s->sh_type == SHT_PROGBITS && | |
| 796 | + (s->sh_flags & SHF_ALLOC)) { | |
| 797 | + const char *p; | |
| 798 | + int ch; | |
| 799 | + | |
| 800 | + /* check if section name can be expressed in C */ | |
| 801 | + p = s->name; | |
| 802 | + for(;;) { | |
| 803 | + ch = *p; | |
| 804 | + if (!ch) | |
| 805 | + break; | |
| 806 | + if (!isid(ch) && !isnum(ch)) | |
| 807 | + goto next_sec; | |
| 808 | + p++; | |
| 809 | + } | |
| 810 | + snprintf(buf, sizeof(buf), "__start_%s", s->name); | |
| 811 | + add_elf_sym(symtab_section, | |
| 812 | + 0, 0, | |
| 813 | + ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), | |
| 814 | + s->sh_num, buf); | |
| 815 | + snprintf(buf, sizeof(buf), "__stop_%s", s->name); | |
| 816 | + add_elf_sym(symtab_section, | |
| 817 | + s->data_offset, 0, | |
| 818 | + ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), | |
| 819 | + s->sh_num, buf); | |
| 820 | + } | |
| 821 | + next_sec: ; | |
| 822 | + } | |
| 823 | +} | |
| 824 | + | |
| 825 | +/* name of ELF interpreter */ | |
| 826 | +static char elf_interp[] = "/lib/ld-linux.so.2"; | |
| 827 | + | |
| 828 | +#define ELF_START_ADDR 0x08048000 | |
| 829 | +#define ELF_PAGE_SIZE 0x1000 | |
| 830 | + | |
| 831 | +/* output an ELF file */ | |
| 832 | +/* XXX: suppress unneeded sections */ | |
| 833 | +int tcc_output_file(TCCState *s1, const char *filename) | |
| 834 | +{ | |
| 835 | + Elf32_Ehdr ehdr; | |
| 836 | + FILE *f; | |
| 837 | + int fd, mode; | |
| 838 | + int *section_order; | |
| 839 | + int shnum, i, phnum, file_offset, offset, size, j, tmp, sh_order_index, k; | |
| 840 | + unsigned long addr; | |
| 841 | + Section *strsec, *s; | |
| 842 | + Elf32_Shdr shdr, *sh; | |
| 843 | + Elf32_Phdr *phdr, *ph; | |
| 844 | + Section *interp, *plt, *dynamic, *dynstr; | |
| 845 | + unsigned long saved_dynamic_data_offset; | |
| 846 | + Elf32_Sym *sym; | |
| 847 | + int type, file_type; | |
| 848 | + unsigned long rel_addr, rel_size; | |
| 849 | + | |
| 850 | + file_type = s1->output_type; | |
| 851 | + | |
| 852 | + if (file_type != TCC_OUTPUT_OBJ) | |
| 853 | + tcc_add_runtime(s1); | |
| 854 | + | |
| 855 | + interp = NULL; | |
| 856 | + dynamic = NULL; | |
| 857 | + dynsym = NULL; | |
| 858 | + got = NULL; | |
| 859 | + nb_plt_entries = 0; | |
| 860 | + plt = NULL; /* avoid warning */ | |
| 861 | + dynstr = NULL; /* avoid warning */ | |
| 862 | + saved_dynamic_data_offset = 0; /* avoid warning */ | |
| 863 | + | |
| 864 | + if (file_type != TCC_OUTPUT_OBJ) { | |
| 865 | + | |
| 866 | + relocate_common_syms(); | |
| 867 | + | |
| 868 | + if (!static_link) { | |
| 869 | + const char *name; | |
| 870 | + int sym_index, index; | |
| 871 | + Elf32_Sym *esym, *sym_end; | |
| 872 | + | |
| 873 | + if (file_type == TCC_OUTPUT_EXE) { | |
| 874 | + char *ptr; | |
| 875 | + /* add interpreter section only if executable */ | |
| 876 | + interp = new_section(".interp", SHT_PROGBITS, SHF_ALLOC); | |
| 877 | + interp->sh_addralign = 1; | |
| 878 | + ptr = section_ptr_add(interp, sizeof(elf_interp)); | |
| 879 | + strcpy(ptr, elf_interp); | |
| 880 | + } | |
| 881 | + | |
| 882 | + /* add dynamic symbol table */ | |
| 883 | + dynsym = new_symtab(".dynsym", SHT_DYNSYM, SHF_ALLOC, | |
| 884 | + ".dynstr", | |
| 885 | + ".hash", SHF_ALLOC); | |
| 886 | + dynstr = dynsym->link; | |
| 887 | + | |
| 888 | + /* add dynamic section */ | |
| 889 | + dynamic = new_section(".dynamic", SHT_DYNAMIC, | |
| 890 | + SHF_ALLOC | SHF_WRITE); | |
| 891 | + dynamic->link = dynstr; | |
| 892 | + dynamic->sh_entsize = sizeof(Elf32_Dyn); | |
| 893 | + | |
| 894 | + /* add PLT */ | |
| 895 | + plt = new_section(".plt", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR); | |
| 896 | + plt->sh_entsize = 4; | |
| 897 | + | |
| 898 | + build_got(); | |
| 899 | + | |
| 900 | + /* scan for undefined symbols and see if they are in the | |
| 901 | + dynamic symbols. If a symbol STT_FUNC is found, then we | |
| 902 | + add it in the PLT. If a symbol STT_OBJECT is found, we | |
| 903 | + add it in the .bss section with a suitable relocation */ | |
| 904 | + sym_end = (Elf32_Sym *)(symtab_section->data + | |
| 905 | + symtab_section->data_offset); | |
| 906 | + if (file_type == TCC_OUTPUT_EXE) { | |
| 907 | + for(sym = (Elf32_Sym *)symtab_section->data + 1; | |
| 908 | + sym < sym_end; | |
| 909 | + sym++) { | |
| 910 | + if (sym->st_shndx == SHN_UNDEF) { | |
| 911 | + name = symtab_section->link->data + sym->st_name; | |
| 912 | + sym_index = find_elf_sym(dynsymtab_section, name); | |
| 913 | + if (sym_index) { | |
| 914 | + esym = &((Elf32_Sym *)dynsymtab_section->data)[sym_index]; | |
| 915 | + type = ELF32_ST_TYPE(esym->st_info); | |
| 916 | + if (type == STT_FUNC) { | |
| 917 | + put_got_entry(R_386_JMP_SLOT, esym->st_size, | |
| 918 | + esym->st_info, | |
| 919 | + sym - (Elf32_Sym *)symtab_section->data); | |
| 920 | + } else if (type == STT_OBJECT) { | |
| 921 | + unsigned long offset; | |
| 922 | + offset = bss_section->data_offset; | |
| 923 | + /* XXX: which alignment ? */ | |
| 924 | + offset = (offset + 8 - 1) & -8; | |
| 925 | + index = put_elf_sym(dynsym, offset, esym->st_size, | |
| 926 | + esym->st_info, 0, | |
| 927 | + bss_section->sh_num, name); | |
| 928 | + put_elf_reloc(dynsym, bss_section, | |
| 929 | + offset, R_386_COPY, index); | |
| 930 | + offset += esym->st_size; | |
| 931 | + bss_section->data_offset = offset; | |
| 932 | + } | |
| 933 | + } else { | |
| 934 | + /* STB_WEAK undefined symbols are accepted */ | |
| 935 | + /* XXX: _fp_hw seems to be part of the ABI, so we ignore | |
| 936 | + it */ | |
| 937 | + if (ELF32_ST_BIND(sym->st_info) == STB_WEAK || | |
| 938 | + !strcmp(name, "_fp_hw")) { | |
| 939 | + } else { | |
| 940 | + error("undefined symbol '%s'", name); | |
| 941 | + } | |
| 942 | + } | |
| 943 | + } | |
| 944 | + } | |
| 945 | + | |
| 946 | + /* now look at unresolved dynamic symbols and export | |
| 947 | + corresponding symbol */ | |
| 948 | + sym_end = (Elf32_Sym *)(dynsymtab_section->data + | |
| 949 | + dynsymtab_section->data_offset); | |
| 950 | + for(esym = (Elf32_Sym *)dynsymtab_section->data + 1; | |
| 951 | + esym < sym_end; | |
| 952 | + esym++) { | |
| 953 | + if (esym->st_shndx == SHN_UNDEF) { | |
| 954 | + name = dynsymtab_section->link->data + esym->st_name; | |
| 955 | + sym_index = find_elf_sym(symtab_section, name); | |
| 956 | + if (sym_index) { | |
| 957 | + sym = &((Elf32_Sym *)symtab_section->data)[sym_index]; | |
| 958 | + put_elf_sym(dynsym, sym->st_value, sym->st_size, | |
| 959 | + sym->st_info, 0, | |
| 960 | + sym->st_shndx, name); | |
| 961 | + } else { | |
| 962 | + if (ELF32_ST_BIND(esym->st_info) == STB_WEAK) { | |
| 963 | + /* weak symbols can stay undefined */ | |
| 964 | + } else { | |
| 965 | + warning("undefined dynamic symbol '%s'", name); | |
| 966 | + } | |
| 967 | + } | |
| 968 | + } | |
| 969 | + } | |
| 970 | + } else { | |
| 971 | + int nb_syms; | |
| 972 | + /* shared library case : we simply export all the global symbols */ | |
| 973 | + nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym); | |
| 974 | + symtab_to_dynsym = tcc_mallocz(sizeof(int) * nb_syms); | |
| 975 | + for(sym = (Elf32_Sym *)symtab_section->data + 1; | |
| 976 | + sym < sym_end; | |
| 977 | + sym++) { | |
| 978 | + if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) { | |
| 979 | + name = symtab_section->link->data + sym->st_name; | |
| 980 | + index = put_elf_sym(dynsym, sym->st_value, sym->st_size, | |
| 981 | + sym->st_info, 0, | |
| 982 | + sym->st_shndx, name); | |
| 983 | + symtab_to_dynsym[sym - (Elf32_Sym *)symtab_section->data] = | |
| 984 | + index; | |
| 985 | + } | |
| 986 | + } | |
| 987 | + } | |
| 988 | + | |
| 989 | + build_got_entries(); | |
| 990 | + | |
| 991 | + /* update PLT/GOT sizes so that we can allocate their space */ | |
| 992 | + plt->data_offset += 16 * (nb_plt_entries + 1); | |
| 993 | + | |
| 994 | + /* add a list of needed dlls */ | |
| 995 | + for(i = 0; i < nb_loaded_dlls; i++) { | |
| 996 | + DLLReference *dllref = loaded_dlls[i]; | |
| 997 | + if (dllref->level == 0) | |
| 998 | + put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name)); | |
| 999 | + } | |
| 1000 | + /* XXX: currently, since we do not handle PIC code, we | |
| 1001 | + must relocate the readonly segments */ | |
| 1002 | + if (file_type == TCC_OUTPUT_DLL) | |
| 1003 | + put_dt(dynamic, DT_TEXTREL, 0); | |
| 1004 | + | |
| 1005 | + /* add necessary space for other entries */ | |
| 1006 | + saved_dynamic_data_offset = dynamic->data_offset; | |
| 1007 | + dynamic->data_offset += 8 * 9; | |
| 1008 | + } else { | |
| 1009 | + /* still need to build got entries in case of static link */ | |
| 1010 | + build_got_entries(); | |
| 1011 | + } | |
| 1012 | + } | |
| 1013 | + | |
| 1014 | + memset(&ehdr, 0, sizeof(ehdr)); | |
| 1015 | + | |
| 1016 | + /* we add a section for symbols */ | |
| 1017 | + strsec = new_section(".shstrtab", SHT_STRTAB, 0); | |
| 1018 | + put_elf_str(strsec, ""); | |
| 1019 | + | |
| 1020 | + /* compute number of sections */ | |
| 1021 | + shnum = nb_sections; | |
| 1022 | + | |
| 1023 | + /* this array is used to reorder sections in the output file */ | |
| 1024 | + section_order = tcc_malloc(sizeof(int) * shnum); | |
| 1025 | + section_order[0] = 0; | |
| 1026 | + sh_order_index = 1; | |
| 1027 | + | |
| 1028 | + /* compute number of program headers */ | |
| 1029 | + switch(file_type) { | |
| 1030 | + default: | |
| 1031 | + case TCC_OUTPUT_OBJ: | |
| 1032 | + phnum = 0; | |
| 1033 | + break; | |
| 1034 | + case TCC_OUTPUT_EXE: | |
| 1035 | + if (!static_link) | |
| 1036 | + phnum = 4; | |
| 1037 | + else | |
| 1038 | + phnum = 2; | |
| 1039 | + break; | |
| 1040 | + case TCC_OUTPUT_DLL: | |
| 1041 | + phnum = 3; | |
| 1042 | + break; | |
| 1043 | + } | |
| 1044 | + | |
| 1045 | + /* allocate strings for section names and decide if an unallocated | |
| 1046 | + section should be output */ | |
| 1047 | + /* NOTE: the strsec section comes last, so its size is also | |
| 1048 | + correct ! */ | |
| 1049 | + for(i = 1; i < nb_sections; i++) { | |
| 1050 | + s = sections[i]; | |
| 1051 | + s->sh_name = put_elf_str(strsec, s->name); | |
| 1052 | + /* when generating a DLL, we include relocations but we may | |
| 1053 | + patch them */ | |
| 1054 | + if (file_type == TCC_OUTPUT_DLL && | |
| 1055 | + s->sh_type == SHT_REL && | |
| 1056 | + !(s->sh_flags & SHF_ALLOC)) { | |
| 1057 | + prepare_dynamic_rel(s); | |
| 1058 | + } else if (do_debug || | |
| 1059 | + file_type == TCC_OUTPUT_OBJ || | |
| 1060 | + (s->sh_flags & SHF_ALLOC) || | |
| 1061 | + i == (nb_sections - 1)) { | |
| 1062 | + /* we output all sections if debug or object file */ | |
| 1063 | + s->sh_size = s->data_offset; | |
| 1064 | + } | |
| 1065 | + } | |
| 1066 | + | |
| 1067 | + /* allocate program segment headers */ | |
| 1068 | + phdr = tcc_mallocz(phnum * sizeof(Elf32_Phdr)); | |
| 1069 | + | |
| 1070 | + file_offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr); | |
| 1071 | + if (phnum > 0) { | |
| 1072 | + /* compute section to program header mapping */ | |
| 1073 | + if (file_type == TCC_OUTPUT_DLL) | |
| 1074 | + addr = 0; | |
| 1075 | + else | |
| 1076 | + addr = ELF_START_ADDR; | |
| 1077 | + | |
| 1078 | + /* dynamic relocation table information, for .dynamic section */ | |
| 1079 | + rel_size = 0; | |
| 1080 | + rel_addr = 0; | |
| 1081 | + | |
| 1082 | + /* compute address after headers */ | |
| 1083 | + addr += (file_offset & (ELF_PAGE_SIZE - 1)); | |
| 1084 | + | |
| 1085 | + /* leave one program header for the program interpreter */ | |
| 1086 | + ph = &phdr[0]; | |
| 1087 | + if (interp) | |
| 1088 | + ph++; | |
| 1089 | + | |
| 1090 | + for(j = 0; j < 2; j++) { | |
| 1091 | + ph->p_type = PT_LOAD; | |
| 1092 | + if (j == 0) | |
| 1093 | + ph->p_flags = PF_R | PF_X; | |
| 1094 | + else | |
| 1095 | + ph->p_flags = PF_R | PF_W; | |
| 1096 | + ph->p_align = ELF_PAGE_SIZE; | |
| 1097 | + | |
| 1098 | + /* we do the following ordering: interp, symbol tables, | |
| 1099 | + relocations, progbits, nobits */ | |
| 1100 | + /* XXX: do faster and simpler sorting */ | |
| 1101 | + for(k = 0; k < 5; k++) { | |
| 1102 | + for(i = 1; i < nb_sections; i++) { | |
| 1103 | + s = sections[i]; | |
| 1104 | + /* compute if section should be included */ | |
| 1105 | + if (j == 0) { | |
| 1106 | + if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) != | |
| 1107 | + SHF_ALLOC) | |
| 1108 | + continue; | |
| 1109 | + } else { | |
| 1110 | + if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE)) != | |
| 1111 | + (SHF_ALLOC | SHF_WRITE)) | |
| 1112 | + continue; | |
| 1113 | + } | |
| 1114 | + if (s == interp) { | |
| 1115 | + if (k != 0) | |
| 1116 | + continue; | |
| 1117 | + } else if (s->sh_type == SHT_DYNSYM || | |
| 1118 | + s->sh_type == SHT_STRTAB || | |
| 1119 | + s->sh_type == SHT_HASH) { | |
| 1120 | + if (k != 1) | |
| 1121 | + continue; | |
| 1122 | + } else if (s->sh_type == SHT_REL) { | |
| 1123 | + if (k != 2) | |
| 1124 | + continue; | |
| 1125 | + } else if (s->sh_type == SHT_NOBITS) { | |
| 1126 | + if (k != 4) | |
| 1127 | + continue; | |
| 1128 | + } else { | |
| 1129 | + if (k != 3) | |
| 1130 | + continue; | |
| 1131 | + } | |
| 1132 | + section_order[sh_order_index++] = i; | |
| 1133 | + | |
| 1134 | + /* section matches: we align it and add its size */ | |
| 1135 | + tmp = file_offset; | |
| 1136 | + file_offset = (file_offset + s->sh_addralign - 1) & | |
| 1137 | + ~(s->sh_addralign - 1); | |
| 1138 | + s->sh_offset = file_offset; | |
| 1139 | + addr += file_offset - tmp; | |
| 1140 | + s->sh_addr = addr; | |
| 1141 | + | |
| 1142 | + /* update program header infos */ | |
| 1143 | + if (ph->p_offset == 0) { | |
| 1144 | + ph->p_offset = file_offset; | |
| 1145 | + ph->p_vaddr = addr; | |
| 1146 | + ph->p_paddr = ph->p_vaddr; | |
| 1147 | + } | |
| 1148 | + /* update dynamic relocation infos */ | |
| 1149 | + if (s->sh_type == SHT_REL) { | |
| 1150 | + if (rel_size == 0) | |
| 1151 | + rel_addr = addr; | |
| 1152 | + rel_size += s->sh_size; | |
| 1153 | + } | |
| 1154 | + addr += s->sh_size; | |
| 1155 | + if (s->sh_type != SHT_NOBITS) | |
| 1156 | + file_offset += s->sh_size; | |
| 1157 | + } | |
| 1158 | + } | |
| 1159 | + ph->p_filesz = file_offset - ph->p_offset; | |
| 1160 | + ph->p_memsz = addr - ph->p_vaddr; | |
| 1161 | + ph++; | |
| 1162 | + } | |
| 1163 | + | |
| 1164 | + /* if interpreter, then add corresponing program header */ | |
| 1165 | + if (interp) { | |
| 1166 | + ph = &phdr[0]; | |
| 1167 | + | |
| 1168 | + ph->p_type = PT_INTERP; | |
| 1169 | + ph->p_offset = interp->sh_offset; | |
| 1170 | + ph->p_vaddr = interp->sh_addr; | |
| 1171 | + ph->p_paddr = ph->p_vaddr; | |
| 1172 | + ph->p_filesz = interp->sh_size; | |
| 1173 | + ph->p_memsz = interp->sh_size; | |
| 1174 | + ph->p_flags = PF_R; | |
| 1175 | + ph->p_align = interp->sh_addralign; | |
| 1176 | + } | |
| 1177 | + | |
| 1178 | + /* if dynamic section, then add corresponing program header */ | |
| 1179 | + if (dynamic) { | |
| 1180 | + int plt_offset; | |
| 1181 | + unsigned char *p; | |
| 1182 | + Elf32_Sym *sym_end; | |
| 1183 | + | |
| 1184 | + ph = &phdr[phnum - 1]; | |
| 1185 | + | |
| 1186 | + ph->p_type = PT_DYNAMIC; | |
| 1187 | + ph->p_offset = dynamic->sh_offset; | |
| 1188 | + ph->p_vaddr = dynamic->sh_addr; | |
| 1189 | + ph->p_paddr = ph->p_vaddr; | |
| 1190 | + ph->p_filesz = dynamic->sh_size; | |
| 1191 | + ph->p_memsz = dynamic->sh_size; | |
| 1192 | + ph->p_flags = PF_R | PF_W; | |
| 1193 | + ph->p_align = dynamic->sh_addralign; | |
| 1194 | + | |
| 1195 | + /* put GOT dynamic section address */ | |
| 1196 | + put32(got->data, dynamic->sh_addr); | |
| 1197 | + | |
| 1198 | + /* compute the PLT */ | |
| 1199 | + plt->data_offset = 0; | |
| 1200 | + | |
| 1201 | + /* first plt entry */ | |
| 1202 | + p = section_ptr_add(plt, 16); | |
| 1203 | + p[0] = 0xff; /* pushl got + 4 */ | |
| 1204 | + p[1] = 0x35; | |
| 1205 | + put32(p + 2, got->sh_addr + 4); | |
| 1206 | + p[6] = 0xff; /* jmp *(got + 8) */ | |
| 1207 | + p[7] = 0x25; | |
| 1208 | + put32(p + 8, got->sh_addr + 8); | |
| 1209 | + | |
| 1210 | + /* relocation symbols in .dynsym and build PLT. */ | |
| 1211 | + plt_offset = 0; | |
| 1212 | + sym_end = (Elf32_Sym *)(dynsym->data + dynsym->data_offset); | |
| 1213 | + for(sym = (Elf32_Sym *)dynsym->data + 1; | |
| 1214 | + sym < sym_end; | |
| 1215 | + sym++) { | |
| 1216 | + type = ELF32_ST_TYPE(sym->st_info); | |
| 1217 | + if (sym->st_shndx == SHN_UNDEF) { | |
| 1218 | + if (type == STT_FUNC) { | |
| 1219 | + /* one more entry in PLT */ | |
| 1220 | + p = section_ptr_add(plt, 16); | |
| 1221 | + p[0] = 0xff; /* jmp *(got + x) */ | |
| 1222 | + p[1] = 0x25; | |
| 1223 | + put32(p + 2, got->sh_addr + sym->st_value); | |
| 1224 | + p[6] = 0x68; /* push $xxx */ | |
| 1225 | + put32(p + 7, plt_offset); | |
| 1226 | + p[11] = 0xe9; /* jmp plt_start */ | |
| 1227 | + put32(p + 12, -(plt->data_offset)); | |
| 1228 | + | |
| 1229 | + /* patch symbol value to point to plt */ | |
| 1230 | + sym->st_value = plt->sh_addr + p - plt->data; | |
| 1231 | + | |
| 1232 | + plt_offset += 8; | |
| 1233 | + } | |
| 1234 | + } else if (sym->st_shndx < SHN_LORESERVE) { | |
| 1235 | + /* do symbol relocation */ | |
| 1236 | + sym->st_value += sections[sym->st_shndx]->sh_addr; | |
| 1237 | + } | |
| 1238 | + } | |
| 1239 | + /* put dynamic section entries */ | |
| 1240 | + | |
| 1241 | + dynamic->data_offset = saved_dynamic_data_offset; | |
| 1242 | + put_dt(dynamic, DT_HASH, dynsym->hash->sh_addr); | |
| 1243 | + put_dt(dynamic, DT_STRTAB, dynstr->sh_addr); | |
| 1244 | + put_dt(dynamic, DT_SYMTAB, dynsym->sh_addr); | |
| 1245 | + put_dt(dynamic, DT_STRSZ, dynstr->data_offset); | |
| 1246 | + put_dt(dynamic, DT_SYMENT, sizeof(Elf32_Sym)); | |
| 1247 | + put_dt(dynamic, DT_REL, rel_addr); | |
| 1248 | + put_dt(dynamic, DT_RELSZ, rel_size); | |
| 1249 | + put_dt(dynamic, DT_RELENT, sizeof(Elf32_Rel)); | |
| 1250 | + put_dt(dynamic, DT_NULL, 0); | |
| 1251 | + } | |
| 1252 | + | |
| 1253 | + ehdr.e_phentsize = sizeof(Elf32_Phdr); | |
| 1254 | + ehdr.e_phnum = phnum; | |
| 1255 | + ehdr.e_phoff = sizeof(Elf32_Ehdr); | |
| 1256 | + } | |
| 1257 | + | |
| 1258 | + /* all other sections come after */ | |
| 1259 | + for(i = 1; i < nb_sections; i++) { | |
| 1260 | + s = sections[i]; | |
| 1261 | + if (phnum > 0 && (s->sh_flags & SHF_ALLOC)) | |
| 1262 | + continue; | |
| 1263 | + section_order[sh_order_index++] = i; | |
| 1264 | + | |
| 1265 | + file_offset = (file_offset + s->sh_addralign - 1) & | |
| 1266 | + ~(s->sh_addralign - 1); | |
| 1267 | + s->sh_offset = file_offset; | |
| 1268 | + if (s->sh_type != SHT_NOBITS) | |
| 1269 | + file_offset += s->sh_size; | |
| 1270 | + } | |
| 1271 | + | |
| 1272 | + /* if building executable or DLL, then relocate each section | |
| 1273 | + except the GOT which is already relocated */ | |
| 1274 | + if (file_type != TCC_OUTPUT_OBJ) { | |
| 1275 | + relocate_syms(0); | |
| 1276 | + | |
| 1277 | + /* relocate sections */ | |
| 1278 | + /* XXX: ignore sections with allocated relocations ? */ | |
| 1279 | + for(i = 1; i < nb_sections; i++) { | |
| 1280 | + s = sections[i]; | |
| 1281 | + if (s->reloc && s != got) | |
| 1282 | + relocate_section(s1, s); | |
| 1283 | + } | |
| 1284 | + | |
| 1285 | + /* relocate relocation entries if the relocation tables are | |
| 1286 | + allocated in the executable */ | |
| 1287 | + for(i = 1; i < nb_sections; i++) { | |
| 1288 | + s = sections[i]; | |
| 1289 | + if ((s->sh_flags & SHF_ALLOC) && | |
| 1290 | + s->sh_type == SHT_REL) { | |
| 1291 | + relocate_rel(s); | |
| 1292 | + } | |
| 1293 | + } | |
| 1294 | + | |
| 1295 | + /* get entry point address */ | |
| 1296 | + if (file_type == TCC_OUTPUT_EXE) | |
| 1297 | + ehdr.e_entry = get_elf_sym_val("_start"); | |
| 1298 | + else | |
| 1299 | + ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */ | |
| 1300 | + } | |
| 1301 | + | |
| 1302 | + sort_syms(symtab_section); | |
| 1303 | + | |
| 1304 | + /* align to 4 */ | |
| 1305 | + file_offset = (file_offset + 3) & -4; | |
| 1306 | + | |
| 1307 | + /* fill header */ | |
| 1308 | + ehdr.e_ident[0] = ELFMAG0; | |
| 1309 | + ehdr.e_ident[1] = ELFMAG1; | |
| 1310 | + ehdr.e_ident[2] = ELFMAG2; | |
| 1311 | + ehdr.e_ident[3] = ELFMAG3; | |
| 1312 | + ehdr.e_ident[4] = ELFCLASS32; | |
| 1313 | + ehdr.e_ident[5] = ELFDATA2LSB; | |
| 1314 | + ehdr.e_ident[6] = EV_CURRENT; | |
| 1315 | + switch(file_type) { | |
| 1316 | + default: | |
| 1317 | + case TCC_OUTPUT_EXE: | |
| 1318 | + ehdr.e_type = ET_EXEC; | |
| 1319 | + break; | |
| 1320 | + case TCC_OUTPUT_DLL: | |
| 1321 | + ehdr.e_type = ET_DYN; | |
| 1322 | + break; | |
| 1323 | + case TCC_OUTPUT_OBJ: | |
| 1324 | + ehdr.e_type = ET_REL; | |
| 1325 | + break; | |
| 1326 | + } | |
| 1327 | + ehdr.e_machine = EM_386; | |
| 1328 | + ehdr.e_version = EV_CURRENT; | |
| 1329 | + ehdr.e_shoff = file_offset; | |
| 1330 | + ehdr.e_ehsize = sizeof(Elf32_Ehdr); | |
| 1331 | + ehdr.e_shentsize = sizeof(Elf32_Shdr); | |
| 1332 | + ehdr.e_shnum = shnum; | |
| 1333 | + ehdr.e_shstrndx = shnum - 1; | |
| 1334 | + | |
| 1335 | + /* write elf file */ | |
| 1336 | + if (file_type == TCC_OUTPUT_OBJ) | |
| 1337 | + mode = 0666; | |
| 1338 | + else | |
| 1339 | + mode = 0777; | |
| 1340 | + fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, mode); | |
| 1341 | + if (fd < 0) | |
| 1342 | + error("could not write '%s'", filename); | |
| 1343 | + | |
| 1344 | + f = fdopen(fd, "w"); | |
| 1345 | + fwrite(&ehdr, 1, sizeof(Elf32_Ehdr), f); | |
| 1346 | + fwrite(phdr, 1, phnum * sizeof(Elf32_Phdr), f); | |
| 1347 | + offset = sizeof(Elf32_Ehdr) + phnum * sizeof(Elf32_Phdr); | |
| 1348 | + for(i=1;i<nb_sections;i++) { | |
| 1349 | + s = sections[section_order[i]]; | |
| 1350 | + if (s->sh_type != SHT_NOBITS) { | |
| 1351 | + while (offset < s->sh_offset) { | |
| 1352 | + fputc(0, f); | |
| 1353 | + offset++; | |
| 1354 | + } | |
| 1355 | + size = s->sh_size; | |
| 1356 | + fwrite(s->data, 1, size, f); | |
| 1357 | + offset += size; | |
| 1358 | + } | |
| 1359 | + } | |
| 1360 | + while (offset < ehdr.e_shoff) { | |
| 1361 | + fputc(0, f); | |
| 1362 | + offset++; | |
| 1363 | + } | |
| 1364 | + | |
| 1365 | + /* output section headers */ | |
| 1366 | + for(i=0;i<nb_sections;i++) { | |
| 1367 | + sh = &shdr; | |
| 1368 | + memset(sh, 0, sizeof(Elf32_Shdr)); | |
| 1369 | + s = sections[i]; | |
| 1370 | + if (s) { | |
| 1371 | + sh->sh_name = s->sh_name; | |
| 1372 | + sh->sh_type = s->sh_type; | |
| 1373 | + sh->sh_flags = s->sh_flags; | |
| 1374 | + sh->sh_entsize = s->sh_entsize; | |
| 1375 | + sh->sh_info = s->sh_info; | |
| 1376 | + if (s->link) | |
| 1377 | + sh->sh_link = s->link->sh_num; | |
| 1378 | + sh->sh_addralign = s->sh_addralign; | |
| 1379 | + sh->sh_addr = s->sh_addr; | |
| 1380 | + sh->sh_offset = s->sh_offset; | |
| 1381 | + sh->sh_size = s->sh_size; | |
| 1382 | + } | |
| 1383 | + fwrite(sh, 1, sizeof(Elf32_Shdr), f); | |
| 1384 | + } | |
| 1385 | + fclose(f); | |
| 1386 | + | |
| 1387 | + tcc_free(section_order); | |
| 1388 | + tcc_free(phdr); | |
| 1389 | + return 0; | |
| 1390 | +} | |
| 1391 | + | |
| 1392 | +static void *load_data(int fd, unsigned long file_offset, unsigned long size) | |
| 1393 | +{ | |
| 1394 | + void *data; | |
| 1395 | + | |
| 1396 | + data = tcc_malloc(size); | |
| 1397 | + lseek(fd, file_offset, SEEK_SET); | |
| 1398 | + read(fd, data, size); | |
| 1399 | + return data; | |
| 1400 | +} | |
| 1401 | + | |
| 1402 | +typedef struct SectionMergeInfo { | |
| 1403 | + Section *s; /* corresponding existing section */ | |
| 1404 | + unsigned long offset; /* offset of the new section in the existing section */ | |
| 1405 | + int new_section; /* true if section 's' was added */ | |
| 1406 | +} SectionMergeInfo; | |
| 1407 | + | |
| 1408 | +/* load an object file and merge it with current files */ | |
| 1409 | +/* XXX: handle correctly stab (debug) info */ | |
| 1410 | +static int tcc_load_object_file(TCCState *s1, | |
| 1411 | + int fd, unsigned long file_offset) | |
| 1412 | +{ | |
| 1413 | + Elf32_Ehdr ehdr; | |
| 1414 | + Elf32_Shdr *shdr, *sh; | |
| 1415 | + int size, i, j, offset, offseti, nb_syms, sym_index; | |
| 1416 | + unsigned char *strsec, *strtab; | |
| 1417 | + int *old_to_new_syms; | |
| 1418 | + char *sh_name, *name; | |
| 1419 | + SectionMergeInfo *sm_table, *sm; | |
| 1420 | + Elf32_Sym *sym, *symtab; | |
| 1421 | + Elf32_Rel *rel, *rel_end; | |
| 1422 | + Section *s; | |
| 1423 | + | |
| 1424 | + if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr)) | |
| 1425 | + goto fail; | |
| 1426 | + if (ehdr.e_ident[0] != ELFMAG0 || | |
| 1427 | + ehdr.e_ident[1] != ELFMAG1 || | |
| 1428 | + ehdr.e_ident[2] != ELFMAG2 || | |
| 1429 | + ehdr.e_ident[3] != ELFMAG3) | |
| 1430 | + goto fail; | |
| 1431 | + /* test if object file */ | |
| 1432 | + if (ehdr.e_type != ET_REL) | |
| 1433 | + goto fail; | |
| 1434 | + /* test CPU specific stuff */ | |
| 1435 | + if (ehdr.e_ident[5] != ELFDATA2LSB || | |
| 1436 | + ehdr.e_machine != EM_386) { | |
| 1437 | + fail: | |
| 1438 | + error("invalid object file"); | |
| 1439 | + } | |
| 1440 | + /* read sections */ | |
| 1441 | + shdr = load_data(fd, file_offset + ehdr.e_shoff, | |
| 1442 | + sizeof(Elf32_Shdr) * ehdr.e_shnum); | |
| 1443 | + sm_table = tcc_mallocz(sizeof(SectionMergeInfo) * ehdr.e_shnum); | |
| 1444 | + | |
| 1445 | + /* load section names */ | |
| 1446 | + sh = &shdr[ehdr.e_shstrndx]; | |
| 1447 | + strsec = load_data(fd, file_offset + sh->sh_offset, sh->sh_size); | |
| 1448 | + | |
| 1449 | + /* load symtab and strtab */ | |
| 1450 | + symtab = NULL; | |
| 1451 | + strtab = NULL; | |
| 1452 | + nb_syms = 0; | |
| 1453 | + for(i = 1; i < ehdr.e_shnum; i++) { | |
| 1454 | + sh = &shdr[i]; | |
| 1455 | + if (sh->sh_type == SHT_SYMTAB) { | |
| 1456 | + if (symtab) | |
| 1457 | + error("object must contain only one symtab"); | |
| 1458 | + nb_syms = sh->sh_size / sizeof(Elf32_Sym); | |
| 1459 | + symtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size); | |
| 1460 | + sm_table[i].s = symtab_section; | |
| 1461 | + | |
| 1462 | + /* now load strtab */ | |
| 1463 | + sh = &shdr[sh->sh_link]; | |
| 1464 | + strtab = load_data(fd, file_offset + sh->sh_offset, sh->sh_size); | |
| 1465 | + } | |
| 1466 | + } | |
| 1467 | + | |
| 1468 | + /* now examine each section and try to merge its content with the | |
| 1469 | + ones in memory */ | |
| 1470 | + for(i = 1; i < ehdr.e_shnum; i++) { | |
| 1471 | + /* no need to examine section name strtab */ | |
| 1472 | + if (i == ehdr.e_shstrndx) | |
| 1473 | + continue; | |
| 1474 | + sh = &shdr[i]; | |
| 1475 | + sh_name = strsec + sh->sh_name; | |
| 1476 | + /* ignore sections types we do not handle */ | |
| 1477 | + if (sh->sh_type != SHT_PROGBITS && | |
| 1478 | + sh->sh_type != SHT_REL && | |
| 1479 | + sh->sh_type != SHT_NOBITS) | |
| 1480 | + continue; | |
| 1481 | + if (sh->sh_addralign < 1) | |
| 1482 | + sh->sh_addralign = 1; | |
| 1483 | + /* find corresponding section, if any */ | |
| 1484 | + for(j = 1; j < nb_sections;j++) { | |
| 1485 | + s = sections[j]; | |
| 1486 | + if (!strcmp(s->name, sh_name)) | |
| 1487 | + goto found; | |
| 1488 | + } | |
| 1489 | + /* not found: create new section */ | |
| 1490 | + s = new_section(sh_name, sh->sh_type, sh->sh_flags); | |
| 1491 | + /* take as much info as possible from the section. sh_link and | |
| 1492 | + sh_info will be updated later */ | |
| 1493 | + s->sh_addralign = sh->sh_addralign; | |
| 1494 | + s->sh_entsize = sh->sh_entsize; | |
| 1495 | + sm_table[i].new_section = 1; | |
| 1496 | + found: | |
| 1497 | + if (sh->sh_type != s->sh_type) | |
| 1498 | + goto fail; | |
| 1499 | + | |
| 1500 | + /* align start of section */ | |
| 1501 | + offset = s->data_offset; | |
| 1502 | + size = sh->sh_addralign - 1; | |
| 1503 | + offset = (offset + size) & ~size; | |
| 1504 | + if (sh->sh_addralign > s->sh_addralign) | |
| 1505 | + s->sh_addralign = sh->sh_addralign; | |
| 1506 | + s->data_offset = offset; | |
| 1507 | + sm_table[i].offset = offset; | |
| 1508 | + sm_table[i].s = s; | |
| 1509 | + /* concatenate sections */ | |
| 1510 | + size = sh->sh_size; | |
| 1511 | + if (sh->sh_type != SHT_NOBITS) { | |
| 1512 | + unsigned char *ptr; | |
| 1513 | + lseek(fd, file_offset + sh->sh_offset, SEEK_SET); | |
| 1514 | + ptr = section_ptr(s, size); | |
| 1515 | + read(fd, ptr, size); | |
| 1516 | + } | |
| 1517 | + s->data_offset += size; | |
| 1518 | + } | |
| 1519 | + | |
| 1520 | + /* second short pass to update sh_link and sh_info fields of new | |
| 1521 | + sections */ | |
| 1522 | + sm = sm_table; | |
| 1523 | + for(i = 1; i < ehdr.e_shnum; i++) { | |
| 1524 | + s = sm_table[i].s; | |
| 1525 | + if (!s || !sm_table[i].new_section) | |
| 1526 | + continue; | |
| 1527 | + sh = &shdr[i]; | |
| 1528 | + if (sh->sh_link > 0) | |
| 1529 | + s->link = sm_table[sh->sh_link].s; | |
| 1530 | + if (sh->sh_type == SHT_REL) { | |
| 1531 | + s->sh_info = sm_table[sh->sh_info].s->sh_num; | |
| 1532 | + /* update backward link */ | |
| 1533 | + sections[s->sh_info]->reloc = s; | |
| 1534 | + } | |
| 1535 | + } | |
| 1536 | + | |
| 1537 | + /* resolve symbols */ | |
| 1538 | + old_to_new_syms = tcc_mallocz(nb_syms * sizeof(int)); | |
| 1539 | + | |
| 1540 | + sym = symtab + 1; | |
| 1541 | + for(i = 1; i < nb_syms; i++, sym++) { | |
| 1542 | + if (sym->st_shndx != SHN_UNDEF && | |
| 1543 | + sym->st_shndx < SHN_LORESERVE) { | |
| 1544 | + sm = &sm_table[sym->st_shndx]; | |
| 1545 | + /* if no corresponding section added, no need to add symbol */ | |
| 1546 | + if (!sm->s) | |
| 1547 | + continue; | |
| 1548 | + /* convert section number */ | |
| 1549 | + sym->st_shndx = sm->s->sh_num; | |
| 1550 | + /* offset value */ | |
| 1551 | + sym->st_value += sm->offset; | |
| 1552 | + } | |
| 1553 | + /* add symbol */ | |
| 1554 | + name = strtab + sym->st_name; | |
| 1555 | + sym_index = add_elf_sym(symtab_section, sym->st_value, sym->st_size, | |
| 1556 | + sym->st_info, sym->st_shndx, name); | |
| 1557 | + old_to_new_syms[i] = sym_index; | |
| 1558 | + } | |
| 1559 | + | |
| 1560 | + /* third pass to patch relocation entries */ | |
| 1561 | + for(i = 1; i < ehdr.e_shnum; i++) { | |
| 1562 | + s = sm_table[i].s; | |
| 1563 | + if (!s) | |
| 1564 | + continue; | |
| 1565 | + sh = &shdr[i]; | |
| 1566 | + offset = sm_table[i].offset; | |
| 1567 | + switch(s->sh_type) { | |
| 1568 | + case SHT_REL: | |
| 1569 | + /* take relocation offset information */ | |
| 1570 | + offseti = sm_table[sh->sh_info].offset; | |
| 1571 | + rel_end = (Elf32_Rel *)(s->data + s->data_offset); | |
| 1572 | + for(rel = (Elf32_Rel *)(s->data + offset); | |
| 1573 | + rel < rel_end; | |
| 1574 | + rel++) { | |
| 1575 | + int type; | |
| 1576 | + unsigned sym_index; | |
| 1577 | + /* convert symbol index */ | |
| 1578 | + type = ELF32_R_TYPE(rel->r_info); | |
| 1579 | + sym_index = ELF32_R_SYM(rel->r_info); | |
| 1580 | + /* NOTE: only one symtab assumed */ | |
| 1581 | + if (sym_index >= nb_syms) | |
| 1582 | + goto invalid_reloc; | |
| 1583 | + sym_index = old_to_new_syms[sym_index]; | |
| 1584 | + if (!sym_index) { | |
| 1585 | + invalid_reloc: | |
| 1586 | + error("Invalid relocation entry"); | |
| 1587 | + } | |
| 1588 | + rel->r_info = ELF32_R_INFO(sym_index, type); | |
| 1589 | + /* offset the relocation offset */ | |
| 1590 | + rel->r_offset += offseti; | |
| 1591 | + } | |
| 1592 | + break; | |
| 1593 | + default: | |
| 1594 | + break; | |
| 1595 | + } | |
| 1596 | + } | |
| 1597 | + tcc_free(symtab); | |
| 1598 | + tcc_free(strtab); | |
| 1599 | + tcc_free(old_to_new_syms); | |
| 1600 | + tcc_free(sm_table); | |
| 1601 | + tcc_free(shdr); | |
| 1602 | + return 0; | |
| 1603 | +} | |
| 1604 | + | |
| 1605 | +#define ARMAG "!<arch>\012" /* For COFF and a.out archives */ | |
| 1606 | + | |
| 1607 | +typedef struct ArchiveHeader { | |
| 1608 | + char ar_name[16]; /* name of this member */ | |
| 1609 | + char ar_date[12]; /* file mtime */ | |
| 1610 | + char ar_uid[6]; /* owner uid; printed as decimal */ | |
| 1611 | + char ar_gid[6]; /* owner gid; printed as decimal */ | |
| 1612 | + char ar_mode[8]; /* file mode, printed as octal */ | |
| 1613 | + char ar_size[10]; /* file size, printed as decimal */ | |
| 1614 | + char ar_fmag[2]; /* should contain ARFMAG */ | |
| 1615 | +} ArchiveHeader; | |
| 1616 | + | |
| 1617 | +/* load a '.a' file */ | |
| 1618 | +static int tcc_load_archive(TCCState *s1, int fd) | |
| 1619 | +{ | |
| 1620 | + ArchiveHeader hdr; | |
| 1621 | + char ar_size[11]; | |
| 1622 | + char ar_name[17]; | |
| 1623 | + char magic[8]; | |
| 1624 | + int size, len, i; | |
| 1625 | + unsigned long file_offset; | |
| 1626 | + | |
| 1627 | + /* skip magic which was already checked */ | |
| 1628 | + read(fd, magic, sizeof(magic)); | |
| 1629 | + | |
| 1630 | + for(;;) { | |
| 1631 | + len = read(fd, &hdr, sizeof(hdr)); | |
| 1632 | + if (len == 0) | |
| 1633 | + break; | |
| 1634 | + if (len != sizeof(hdr)) | |
| 1635 | + error("invalid archive"); | |
| 1636 | + memcpy(ar_size, hdr.ar_size, sizeof(hdr.ar_size)); | |
| 1637 | + ar_size[sizeof(hdr.ar_size)] = '\0'; | |
| 1638 | + size = strtol(ar_size, NULL, 0); | |
| 1639 | + memcpy(ar_name, hdr.ar_name, sizeof(hdr.ar_name)); | |
| 1640 | + for(i = sizeof(hdr.ar_name) - 1; i >= 0; i--) { | |
| 1641 | + if (ar_name[i] != ' ') | |
| 1642 | + break; | |
| 1643 | + } | |
| 1644 | + ar_name[i + 1] = '\0'; | |
| 1645 | + // printf("name='%s' size=%d %s\n", ar_name, size, ar_size); | |
| 1646 | + file_offset = lseek(fd, 0, SEEK_CUR); | |
| 1647 | + if (!strcmp(ar_name, "/") || | |
| 1648 | + !strcmp(ar_name, "//") || | |
| 1649 | + !strcmp(ar_name, "__.SYMDEF") || | |
| 1650 | + !strcmp(ar_name, "__.SYMDEF/") || | |
| 1651 | + !strcmp(ar_name, "ARFILENAMES/")) { | |
| 1652 | + /* skip symbol table or archive names */ | |
| 1653 | + } else { | |
| 1654 | + tcc_load_object_file(s1, fd, file_offset); | |
| 1655 | + } | |
| 1656 | + /* align to even */ | |
| 1657 | + size = (size + 1) & ~1; | |
| 1658 | + lseek(fd, file_offset + size, SEEK_SET); | |
| 1659 | + } | |
| 1660 | + return 0; | |
| 1661 | +} | |
| 1662 | + | |
| 1663 | +/* load a DLL and all referenced DLLs. 'level = 0' means that the DLL | |
| 1664 | + is referenced by the user (so it should be added as DT_NEEDED in | |
| 1665 | + the generated ELF file) */ | |
| 1666 | +static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level) | |
| 1667 | +{ | |
| 1668 | + Elf32_Ehdr ehdr; | |
| 1669 | + Elf32_Shdr *shdr, *sh, *sh1; | |
| 1670 | + int i, nb_syms, nb_dts, sym_bind; | |
| 1671 | + Elf32_Sym *sym, *dynsym; | |
| 1672 | + Elf32_Dyn *dt, *dynamic; | |
| 1673 | + unsigned char *dynstr; | |
| 1674 | + const char *name, *soname, *p; | |
| 1675 | + DLLReference *dllref; | |
| 1676 | + | |
| 1677 | + read(fd, &ehdr, sizeof(ehdr)); | |
| 1678 | + | |
| 1679 | + /* test CPU specific stuff */ | |
| 1680 | + if (ehdr.e_ident[5] != ELFDATA2LSB || | |
| 1681 | + ehdr.e_machine != EM_386) | |
| 1682 | + error("bad architecture"); | |
| 1683 | + | |
| 1684 | + /* read sections */ | |
| 1685 | + shdr = load_data(fd, ehdr.e_shoff, sizeof(Elf32_Shdr) * ehdr.e_shnum); | |
| 1686 | + | |
| 1687 | + /* load dynamic section and dynamic symbols */ | |
| 1688 | + nb_syms = 0; | |
| 1689 | + nb_dts = 0; | |
| 1690 | + dynamic = NULL; | |
| 1691 | + dynsym = NULL; /* avoid warning */ | |
| 1692 | + dynstr = NULL; /* avoid warning */ | |
| 1693 | + for(i = 0, sh = shdr; i < ehdr.e_shnum; i++, sh++) { | |
| 1694 | + switch(sh->sh_type) { | |
| 1695 | + case SHT_DYNAMIC: | |
| 1696 | + nb_dts = sh->sh_size / sizeof(Elf32_Dyn); | |
| 1697 | + dynamic = load_data(fd, sh->sh_offset, sh->sh_size); | |
| 1698 | + break; | |
| 1699 | + case SHT_DYNSYM: | |
| 1700 | + nb_syms = sh->sh_size / sizeof(Elf32_Sym); | |
| 1701 | + dynsym = load_data(fd, sh->sh_offset, sh->sh_size); | |
| 1702 | + sh1 = &shdr[sh->sh_link]; | |
| 1703 | + dynstr = load_data(fd, sh1->sh_offset, sh1->sh_size); | |
| 1704 | + break; | |
| 1705 | + default: | |
| 1706 | + break; | |
| 1707 | + } | |
| 1708 | + } | |
| 1709 | + | |
| 1710 | + /* compute the real library name */ | |
| 1711 | + soname = filename; | |
| 1712 | + p = strrchr(soname, '/'); | |
| 1713 | + if (p) | |
| 1714 | + soname = p + 1; | |
| 1715 | + | |
| 1716 | + for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) { | |
| 1717 | + if (dt->d_tag == DT_SONAME) { | |
| 1718 | + soname = dynstr + dt->d_un.d_val; | |
| 1719 | + } | |
| 1720 | + } | |
| 1721 | + | |
| 1722 | + /* if the dll is already loaded, do not load it */ | |
| 1723 | + for(i = 0; i < nb_loaded_dlls; i++) { | |
| 1724 | + dllref = loaded_dlls[i]; | |
| 1725 | + if (!strcmp(soname, dllref->name)) { | |
| 1726 | + /* but update level if needed */ | |
| 1727 | + if (level < dllref->level) | |
| 1728 | + dllref->level = level; | |
| 1729 | + goto the_end; | |
| 1730 | + } | |
| 1731 | + } | |
| 1732 | + | |
| 1733 | + // printf("loading dll '%s'\n", soname); | |
| 1734 | + | |
| 1735 | + /* add the dll and its level */ | |
| 1736 | + dllref = tcc_malloc(sizeof(DLLReference) + strlen(soname)); | |
| 1737 | + dllref->level = level; | |
| 1738 | + strcpy(dllref->name, soname); | |
| 1739 | + dynarray_add((void ***)&loaded_dlls, &nb_loaded_dlls, dllref); | |
| 1740 | + | |
| 1741 | + /* add dynamic symbols in dynsym_section */ | |
| 1742 | + for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) { | |
| 1743 | + sym_bind = ELF32_ST_BIND(sym->st_info); | |
| 1744 | + if (sym_bind == STB_LOCAL) | |
| 1745 | + continue; | |
| 1746 | + name = dynstr + sym->st_name; | |
| 1747 | + add_elf_sym(dynsymtab_section, sym->st_value, sym->st_size, | |
| 1748 | + sym->st_info, sym->st_shndx, name); | |
| 1749 | + } | |
| 1750 | + | |
| 1751 | + /* load all referenced DLLs */ | |
| 1752 | + for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) { | |
| 1753 | + switch(dt->d_tag) { | |
| 1754 | + case DT_NEEDED: | |
| 1755 | + name = dynstr + dt->d_un.d_val; | |
| 1756 | + for(i = 0; i < nb_loaded_dlls; i++) { | |
| 1757 | + dllref = loaded_dlls[i]; | |
| 1758 | + if (!strcmp(name, dllref->name)) | |
| 1759 | + goto already_loaded; | |
| 1760 | + } | |
| 1761 | + if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) | |
| 1762 | + error("referenced dll '%s' not found", name); | |
| 1763 | + already_loaded: | |
| 1764 | + break; | |
| 1765 | + } | |
| 1766 | + } | |
| 1767 | + the_end: | |
| 1768 | + tcc_free(shdr); | |
| 1769 | + return 0; | |
| 1770 | +} | |
| 1771 | + | |
| 1772 | +/* return -2 if error and CH_EOF if eof */ | |
| 1773 | +static void ld_skipspaces(void) | |
| 1774 | +{ | |
| 1775 | + while (ch == ' ' || ch == '\t' || ch == '\n') | |
| 1776 | + cinp(); | |
| 1777 | +} | |
| 1778 | + | |
| 1779 | +static int ld_get_cmd(char *cmd, int cmd_size) | |
| 1780 | +{ | |
| 1781 | + char *q; | |
| 1782 | + | |
| 1783 | + ld_skipspaces(); | |
| 1784 | + if (ch == CH_EOF) | |
| 1785 | + return -1; | |
| 1786 | + q = cmd; | |
| 1787 | + for(;;) { | |
| 1788 | + if (!((ch >= 'a' && ch <= 'z') || | |
| 1789 | + (ch >= 'A' && ch <= 'Z') || | |
| 1790 | + (ch >= '0' && ch <= '9') || | |
| 1791 | + strchr("/.-_+=$:\\,~?*", ch))) | |
| 1792 | + break; | |
| 1793 | + if ((q - cmd) >= (cmd_size - 1)) | |
| 1794 | + return -2; | |
| 1795 | + *q++ = ch; | |
| 1796 | + cinp(); | |
| 1797 | + } | |
| 1798 | + *q = '\0'; | |
| 1799 | + return 0; | |
| 1800 | +} | |
| 1801 | + | |
| 1802 | +/* interpret a subset of GNU ldscripts to handle the dummy libc.so | |
| 1803 | + files */ | |
| 1804 | +static int tcc_load_ldscript(TCCState *s1) | |
| 1805 | +{ | |
| 1806 | + char cmd[64]; | |
| 1807 | + char filename[1024]; | |
| 1808 | + int ret; | |
| 1809 | + | |
| 1810 | + inp(); | |
| 1811 | + cinp(); | |
| 1812 | + for(;;) { | |
| 1813 | + ret = ld_get_cmd(cmd, sizeof(cmd)); | |
| 1814 | + if (ret == CH_EOF) | |
| 1815 | + return 0; | |
| 1816 | + else if (ret < 0) | |
| 1817 | + return -1; | |
| 1818 | + // printf("cmd='%s'\n", cmd); | |
| 1819 | + if (!strcmp(cmd, "INPUT") || | |
| 1820 | + !strcmp(cmd, "GROUP")) { | |
| 1821 | + ld_skipspaces(); | |
| 1822 | + if (ch != '(') | |
| 1823 | + expect("("); | |
| 1824 | + cinp(); | |
| 1825 | + for(;;) { | |
| 1826 | + ld_get_cmd(filename, sizeof(filename)); | |
| 1827 | + tcc_add_file(s1, filename); | |
| 1828 | + ld_skipspaces(); | |
| 1829 | + if (ch == ',') { | |
| 1830 | + cinp(); | |
| 1831 | + } else if (ch == ')') { | |
| 1832 | + cinp(); | |
| 1833 | + break; | |
| 1834 | + } else if (ch == CH_EOF) { | |
| 1835 | + error("unexpected end of file"); | |
| 1836 | + } | |
| 1837 | + } | |
| 1838 | + } else { | |
| 1839 | + return -1; | |
| 1840 | + } | |
| 1841 | + } | |
| 1842 | + return 0; | |
| 1843 | +} | |
| 1844 | + | |