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 | |||