1 /* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2008 Red Hat, Inc. 2 This file is part of Red Hat elfutils. 3 Written by Ulrich Drepper <drepper (at) redhat.com>, 2001. 4 5 Red Hat elfutils is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by the 7 Free Software Foundation; version 2 of the License. 8 9 Red Hat elfutils is distributed in the hope that it will be useful, but 10 WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 General Public License for more details. 13 14 You should have received a copy of the GNU General Public License along 15 with Red Hat elfutils; if not, write to the Free Software Foundation, 16 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA. 17 18 Red Hat elfutils is an included package of the Open Invention Network. 19 An included package of the Open Invention Network is a package for which 20 Open Invention Network licensees cross-license their patents. No patent 21 license is granted, either expressly or impliedly, by designation as an 22 included package. Should you wish to participate in the Open Invention 23 Network licensing program, please visit www.openinventionnetwork.com 24 <http://www.openinventionnetwork.com>. */ 25 26 #ifdef HAVE_CONFIG_H 27 # include <config.h> 28 #endif 29 30 #include <assert.h> 31 #include <error.h> 32 #include <libintl.h> 33 #include <stdlib.h> 34 #include <string.h> 35 36 // XXX For debugging 37 #include <stdio.h> 38 39 #include <system.h> 40 #include "ld.h" 41 #include "list.h" 42 /* x86 is little endian. */ 43 #define UNALIGNED_ACCESS_CLASS LITTLE_ENDIAN 44 #include "unaligned.h" 45 #include "xelf.h" 46 47 48 /* The old callbacks. */ 49 static int (*old_open_outfile) (struct ld_state *, int, int, int); 50 51 52 static int 53 elf_i386_open_outfile (struct ld_state *statep, 54 int machine __attribute__ ((unused)), 55 int klass __attribute__ ((unused)), 56 int data __attribute__ ((unused))) 57 { 58 /* This backend only handles 32-bit object files. */ 59 /* XXX For now just use the generic backend. */ 60 return old_open_outfile (statep, EM_386, ELFCLASS32, ELFDATA2LSB); 61 } 62 63 64 /* Process relocations for the output in a relocatable file. This 65 only means adjusting offset and symbol indices. */ 66 static void 67 elf_i386_relocate_section (struct ld_state *statep __attribute__ ((unused)), 68 Elf_Scn *outscn, struct scninfo *firstp, 69 const Elf32_Word *dblindirect) 70 { 71 struct scninfo *runp; 72 Elf_Data *data; 73 74 /* Iterate over all the input sections. Appropriate data buffers in the 75 output sections were already created. */ 76 runp = firstp; 77 data = NULL; 78 do 79 { 80 Elf_Data *reltgtdata; 81 Elf_Data *insymdata; 82 Elf_Data *inxndxdata = NULL; 83 size_t maxcnt; 84 size_t cnt; 85 const Elf32_Word *symindirect; 86 struct symbol **symref; 87 struct usedfiles *file = runp->fileinfo; 88 XElf_Shdr *shdr = &SCNINFO_SHDR (runp->shdr); 89 90 /* Get the output section data buffer for this input section. */ 91 data = elf_getdata (outscn, data); 92 assert (data != NULL); 93 94 /* Get the data for section in the input file this relocation 95 section is relocating. Since these buffers are reused in the 96 output modifying these buffers has the correct result. */ 97 reltgtdata = elf_getdata (file->scninfo[shdr->sh_info].scn, NULL); 98 99 /* Get the data for the input section symbol table for this 100 relocation section. */ 101 insymdata = elf_getdata (file->scninfo[shdr->sh_link].scn, NULL); 102 assert (insymdata != NULL); 103 104 /* And the extended section index table. */ 105 inxndxdata = runp->fileinfo->xndxdata; 106 107 /* Number of relocations. */ 108 maxcnt = shdr->sh_size / shdr->sh_entsize; 109 110 /* Array directing local symbol table offsets to output symbol 111 table offsets. */ 112 symindirect = file->symindirect; 113 114 /* References to the symbol records. */ 115 symref = file->symref; 116 117 /* Iterate over all the relocations in the section. */ 118 for (cnt = 0; cnt < maxcnt; ++cnt) 119 { 120 XElf_Rel_vardef (rel); 121 Elf32_Word si; 122 XElf_Sym_vardef (sym); 123 Elf32_Word xndx; 124 125 /* Get the relocation data itself. x86 uses Rel 126 relocations. In case we have to handle Rela as well the 127 whole loop probably should be duplicated. */ 128 xelf_getrel (data, cnt, rel); 129 assert (rel != NULL); 130 131 /* Compute the symbol index in the output file. */ 132 si = symindirect[XELF_R_SYM (rel->r_info)]; 133 if (si == 0) 134 { 135 /* This happens if the symbol is locally undefined or 136 superceded by some other definition. */ 137 assert (symref[XELF_R_SYM (rel->r_info)] != NULL); 138 si = symref[XELF_R_SYM (rel->r_info)]->outsymidx; 139 } 140 /* Take reordering performed to sort the symbol table into 141 account. */ 142 si = dblindirect[si]; 143 144 /* Get the symbol table entry. */ 145 xelf_getsymshndx (insymdata, inxndxdata, XELF_R_SYM (rel->r_info), 146 sym, xndx); 147 if (sym->st_shndx != SHN_XINDEX) 148 xndx = sym->st_shndx; 149 assert (xndx < SHN_LORESERVE || xndx > SHN_HIRESERVE); 150 151 /* We fortunately don't have to do much. The relocations 152 mostly get only updates of the offset. Only for a 153 relocation referring to a section do we have to do 154 something. In this case the reference to the sections 155 has no direct equivalent since the part the input section 156 contributes need not start at the same offset as in the 157 input file. Therefore we have to adjust the addend which 158 in the case of Rel relocations is in the target section 159 itself. */ 160 if (XELF_ST_TYPE (sym->st_info) == STT_SECTION) 161 { 162 /* We expect here only R_386_32 relocations. */ 163 assert (XELF_R_TYPE (rel->r_info) == R_386_32); 164 165 /* Avoid writing to the section memory if this is 166 effectively a no-op since it might save a 167 copy-on-write operation. */ 168 Elf32_Word toadd = file->scninfo[xndx].offset; 169 if (toadd != 0) 170 add_4ubyte_unaligned (reltgtdata->d_buf + rel->r_offset, 171 toadd); 172 } 173 174 /* Adjust the offset for the position of the input section 175 content in the output section. */ 176 rel->r_offset += file->scninfo[shdr->sh_info].offset; 177 178 /* And finally adjust the index of the symbol in the output 179 symbol table. */ 180 rel->r_info = XELF_R_INFO (si, XELF_R_TYPE (rel->r_info)); 181 182 /* Store the result. */ 183 (void) xelf_update_rel (data, cnt, rel); 184 } 185 186 runp = runp->next; 187 } 188 while (runp != firstp); 189 } 190 191 192 /* Each PLT entry has 16 bytes. We need one entry as overhead for 193 the code to set up the call into the runtime relocation. */ 194 #define PLT_ENTRY_SIZE 16 195 196 static void 197 elf_i386_initialize_plt (struct ld_state *statep, Elf_Scn *scn) 198 { 199 Elf_Data *data; 200 XElf_Shdr_vardef (shdr); 201 202 /* Change the entry size in the section header. */ 203 xelf_getshdr (scn, shdr); 204 assert (shdr != NULL); 205 shdr->sh_entsize = PLT_ENTRY_SIZE; 206 (void) xelf_update_shdr (scn, shdr); 207 208 data = elf_newdata (scn); 209 if (data == NULL) 210 error (EXIT_FAILURE, 0, gettext ("cannot allocate PLT section: %s"), 211 elf_errmsg (-1)); 212 213 /* We need one special PLT entry (performing the jump to the runtime 214 relocation routines) and one for each function we call in a DSO. */ 215 data->d_size = (1 + statep->nplt) * PLT_ENTRY_SIZE; 216 data->d_buf = xcalloc (1, data->d_size); 217 assert (data->d_type == ELF_T_BYTE); 218 data->d_off = 0; 219 data->d_align = 8; 220 221 statep->nplt_used = 1; 222 } 223 224 225 static void 226 elf_i386_initialize_pltrel (struct ld_state *statep, Elf_Scn *scn) 227 { 228 Elf_Data *data; 229 230 data = elf_newdata (scn); 231 if (data == NULL) 232 error (EXIT_FAILURE, 0, gettext ("cannot allocate PLTREL section: %s"), 233 elf_errmsg (-1)); 234 235 /* One relocation per PLT entry. */ 236 size_t size = statep->nplt * sizeof (Elf32_Rel); 237 data->d_buf = xcalloc (1, size); 238 data->d_type = ELF_T_REL; 239 data->d_size = size; 240 data->d_align = 4; 241 data->d_off = 0; 242 } 243 244 245 static void 246 elf_i386_initialize_got (struct ld_state *statep, Elf_Scn *scn) 247 { 248 /* If we come here we better need a GOT. */ 249 assert (statep->ngot != 0); 250 251 Elf_Data *data = elf_newdata (scn); 252 if (data == NULL) 253 error (EXIT_FAILURE, 0, gettext ("cannot allocate GOT section: %s"), 254 elf_errmsg (-1)); 255 256 /* Just a single word per GOT entry is needed. */ 257 size_t size = statep->ngot * sizeof (Elf32_Addr); 258 data->d_buf = xcalloc (1, size); 259 data->d_size = size; 260 data->d_type = ELF_T_WORD; 261 data->d_off = 0; 262 data->d_align = sizeof (Elf32_Addr); 263 } 264 265 266 static void 267 elf_i386_initialize_gotplt (struct ld_state *statep, Elf_Scn *scn) 268 { 269 /* If we come here we better need a PLT. */ 270 assert (statep->nplt != 0); 271 272 Elf_Data *data = elf_newdata (scn); 273 if (data == NULL) 274 error (EXIT_FAILURE, 0, gettext ("cannot allocate GOTPLT section: %s"), 275 elf_errmsg (-1)); 276 277 /* We construct the .got.plt section in pieces. Here we only add the data 278 structures which are used by the PLT. This includes three reserved 279 entries at the beginning (the first will contain a pointer to the 280 .dynamic section), and one word for each PLT entry. */ 281 size_t size = (3 + statep->nplt) * sizeof (Elf32_Addr); 282 data->d_buf = xcalloc (1, size); 283 data->d_type = ELF_T_WORD; 284 data->d_size = size; 285 data->d_off = 0; 286 data->d_align = sizeof (Elf32_Addr); 287 } 288 289 290 /* The first entry in an absolute procedure linkage table looks like 291 this. See the SVR4 ABI i386 supplement to see how this works. */ 292 static const unsigned char elf_i386_plt0_entry[PLT_ENTRY_SIZE] = 293 { 294 0xff, 0x35, /* pushl contents of address */ 295 0, 0, 0, 0, /* replaced with address of .got + 4. */ 296 0xff, 0x25, /* jmp indirect */ 297 0, 0, 0, 0, /* replaced with address of .got + 8. */ 298 0x0f, 0x0b, /* ud2a, to prevent further decoding. */ 299 0, 0 /* pad out to 16 bytes. */ 300 }; 301 302 /* Type describing the first PLT entry in non-PIC. */ 303 struct plt0_entry 304 { 305 /* First a 'push' of the second GOT entry. */ 306 unsigned char push_instr[2]; 307 uint32_t gotp4_addr; 308 /* Second, a 'jmp indirect' to the third GOT entry. */ 309 unsigned char jmp_instr[2]; 310 uint32_t gotp8_addr; 311 /* Padding. */ 312 unsigned char padding[4]; 313 } __attribute__ ((packed)); 314 315 /* The first entry in a PIC procedure linkage table look like this. */ 316 static const unsigned char elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] = 317 { 318 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */ 319 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */ 320 0x0f, 0x0b, /* ud2a, to prevent further decoding. */ 321 0, 0 /* pad out to 16 bytes. */ 322 }; 323 324 /* Contents of all but the first PLT entry in executable. */ 325 static const unsigned char elf_i386_plt_entry[PLT_ENTRY_SIZE] = 326 { 327 0xff, 0x25, /* jmp indirect */ 328 0, 0, 0, 0, /* replaced with address of this symbol in .got. */ 329 0x68, /* pushl immediate */ 330 0, 0, 0, 0, /* replaced with offset into relocation table. */ 331 0xe9, /* jmp relative */ 332 0, 0, 0, 0 /* replaced with offset to start of .plt. */ 333 }; 334 335 /* Contents of all but the first PLT entry in DSOs. */ 336 static const unsigned char elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] = 337 { 338 0xff, 0xa3, /* jmp *offset(%ebx) */ 339 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */ 340 0x68, /* pushl immediate */ 341 0, 0, 0, 0, /* replaced with offset into relocation table. */ 342 0xe9, /* jmp relative */ 343 0, 0, 0, 0 /* replaced with offset to start of .plt. */ 344 }; 345 346 /* Type describing a PLT entry. */ 347 struct plt_entry 348 { 349 /* The first instruction is 'jmp indirect' or 'jmp *offset(%ebs)'. */ 350 unsigned char jmp_instr[2]; 351 uint32_t offset_got; 352 /* The second instruction is 'push immediate'. */ 353 unsigned char push_instr; 354 uint32_t push_imm; 355 /* Finally a 'jmp relative'. */ 356 unsigned char jmp_instr2; 357 uint32_t plt0_offset; 358 } __attribute__ ((packed)); 359 360 361 static void 362 elf_i386_finalize_plt (struct ld_state *statep, size_t nsym, 363 size_t nsym_local, struct symbol **ndxtosym) 364 { 365 if (unlikely (statep->nplt + statep->ngot == 0)) 366 /* Nothing to be done. */ 367 return; 368 369 Elf_Scn *scn; 370 XElf_Shdr_vardef (shdr); 371 Elf_Data *data; 372 const bool build_dso = statep->file_type == dso_file_type; 373 374 /* Get the address of the .got.plt section. */ 375 scn = elf_getscn (statep->outelf, statep->gotpltscnidx); 376 xelf_getshdr (scn, shdr); 377 data = elf_getdata (scn, NULL); 378 assert (shdr != NULL && data != NULL); 379 /* The address points to the .got.plt section, not the .got section. */ 380 Elf32_Addr gotaddr = shdr->sh_addr; 381 382 /* Now create the initial values for the .got.plt section. The 383 first word contains the address of the .dynamic section. The 384 second and third entry are left empty for use by the dynamic 385 linker. The following entries are pointers to the instructions 386 following the initial jmp instruction in the corresponding PLT 387 entry. */ 388 xelf_getshdr (elf_getscn (statep->outelf, statep->dynamicscnidx), shdr); 389 assert (shdr != NULL); 390 ((Elf32_Word *) data->d_buf)[0] = shdr->sh_addr; 391 392 /* The PLT contains code which a user of a function jumps to. The first 393 PLT entry is special, so the first used one has the index 1. */ 394 scn = elf_getscn (statep->outelf, statep->pltscnidx); 395 XElf_Shdr_vardef (pltshdr); 396 xelf_getshdr (scn, pltshdr); 397 assert (pltshdr != NULL); 398 399 Elf_Data *dynsymdata = elf_getdata (elf_getscn (statep->outelf, 400 statep->dynsymscnidx), NULL); 401 assert (dynsymdata != NULL); 402 403 Elf_Data *symdata = NULL; 404 if (statep->symscnidx != 0) 405 { 406 symdata = elf_getdata (elf_getscn (statep->outelf, statep->symscnidx), 407 NULL); 408 assert (symdata != NULL); 409 } 410 411 /* Create the .plt section. */ 412 scn = elf_getscn (statep->outelf, statep->pltscnidx); 413 Elf_Data *pltdata = elf_getdata (scn, NULL); 414 assert (pltdata != NULL); 415 416 /* Also create the .rel.plt section data. It simply means relocations 417 addressing the corresponding entry in the .got.plt section. The 418 section name is misleading. */ 419 scn = elf_getscn (statep->outelf, statep->pltrelscnidx); 420 xelf_getshdr (scn, shdr); 421 Elf_Data *reldata = elf_getdata (scn, NULL); 422 assert (shdr != NULL && reldata != NULL); 423 424 /* Update the sh_link to point to the section being modified. We 425 point it here (correctly) to the .got.plt section. Some linkers 426 (e.g., the GNU binutils linker) point to the .plt section. This 427 is wrong since the .plt section isn't modified even though the 428 name .rel.plt suggests that this is correct. */ 429 shdr->sh_link = statep->dynsymscnidx; 430 shdr->sh_info = statep->gotpltscnidx; 431 (void) xelf_update_shdr (scn, shdr); 432 433 /* Create the first entry of the .plt section. */ 434 assert (pltdata->d_size >= PLT_ENTRY_SIZE); 435 if (build_dso) 436 /* Copy the entry. It's complete, no relocation needed. */ 437 memcpy (pltdata->d_buf, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE); 438 else 439 { 440 /* Copy the skeleton. */ 441 memcpy (pltdata->d_buf, elf_i386_plt0_entry, PLT_ENTRY_SIZE); 442 443 /* And fill in the addresses. */ 444 struct plt0_entry *addr = (struct plt0_entry *) pltdata->d_buf; 445 addr->gotp4_addr = target_bswap_32 (gotaddr + 4); 446 addr->gotp8_addr = target_bswap_32 (gotaddr + 8); 447 } 448 449 /* For DSOs we need GOT offsets, otherwise the GOT address. */ 450 Elf32_Addr gotaddr_off = build_dso ? 0 : gotaddr; 451 452 /* Create the remaining entries. */ 453 const unsigned char *plt_template 454 = build_dso ? elf_i386_pic_plt_entry : elf_i386_plt_entry; 455 456 for (size_t idx = nsym_local; idx < nsym; ++idx) 457 { 458 struct symbol *symbol = ndxtosym[idx]; 459 if (symbol == NULL || symbol->type != STT_FUNC 460 || ndxtosym[idx]->outdynsymidx == 0 461 // XXX is the following test correct? 462 || ! ndxtosym[idx]->in_dso) 463 continue; 464 465 size_t pltidx = symbol->merge.value; 466 467 assert (pltidx > 0); 468 assert ((3 + pltidx) * sizeof (Elf32_Word) <= data->d_size); 469 470 /* Address in the PLT. */ 471 Elf32_Addr pltentryaddr = (pltshdr->sh_addr + pltidx * PLT_ENTRY_SIZE); 472 473 /* Point the GOT entry at the PLT entry, after the initial jmp. */ 474 ((Elf32_Word *) data->d_buf)[2 + pltidx] = pltentryaddr + 6; 475 476 /* If the symbol is defined, adjust the address. */ 477 if (((Elf32_Sym *) dynsymdata->d_buf)[ndxtosym[idx]->outdynsymidx].st_shndx != SHN_UNDEF) 478 { 479 /* The value of the symbol is the address of the corresponding PLT 480 entry. Store the address, also for the normal symbol table if 481 this is necessary. */ 482 ((Elf32_Sym *) dynsymdata->d_buf)[pltidx].st_value = pltentryaddr; 483 484 if (symdata != NULL) 485 { 486 assert(nsym - statep->nplt + (pltidx - 1) == idx); 487 ((Elf32_Sym *) symdata->d_buf)[nsym - statep->nplt 488 + (pltidx - 1)].st_value 489 = pltentryaddr; 490 } 491 } 492 493 /* Copy the PLT entry template. */ 494 assert (pltdata->d_size >= (1 + pltidx) * PLT_ENTRY_SIZE); 495 struct plt_entry *addr = (struct plt_entry *) ((char *) pltdata->d_buf 496 + (pltidx 497 * PLT_ENTRY_SIZE)); 498 memcpy (addr, plt_template, PLT_ENTRY_SIZE); 499 500 /* And once more, fill in the addresses. First the address of 501 this symbol in .got. */ 502 addr->offset_got = target_bswap_32 (gotaddr_off 503 + (2 + pltidx) * sizeof (Elf32_Addr)); 504 /* Offset into relocation table. */ 505 addr->push_imm = target_bswap_32 ((pltidx - 1) * sizeof (Elf32_Rel)); 506 /* Offset to start of .plt. */ 507 addr->plt0_offset = target_bswap_32 (-(1 + pltidx) * PLT_ENTRY_SIZE); 508 509 510 XElf_Rel_vardef (rel); 511 assert (pltidx * sizeof (Elf32_Rel) <= reldata->d_size); 512 xelf_getrel_ptr (reldata, pltidx - 1, rel); 513 rel->r_offset = gotaddr + (2 + pltidx) * sizeof (Elf32_Addr); 514 /* The symbol table entries for the functions from DSOs are at 515 the beginning of the symbol table. */ 516 rel->r_info = XELF_R_INFO (ndxtosym[idx]->outdynsymidx, R_386_JMP_SLOT); 517 (void) xelf_update_rel (reldata, pltidx - 1, rel); 518 } 519 } 520 521 522 static int 523 elf_i386_rel_type (struct ld_state *statep __attribute__ ((__unused__))) 524 { 525 /* ELF/i386 uses REL. */ 526 return DT_REL; 527 } 528 529 530 static void 531 elf_i386_count_relocations (struct ld_state *statep, struct scninfo *scninfo) 532 { 533 /* We go through the list of input sections and count those relocations 534 which are not handled by the linker. At the same time we have to 535 see how many GOT entries we need and how much .bss space is needed 536 for copy relocations. */ 537 Elf_Data *data = elf_getdata (scninfo->scn, NULL); 538 XElf_Shdr *shdr = &SCNINFO_SHDR (scninfo->shdr); 539 size_t maxcnt = shdr->sh_size / shdr->sh_entsize; 540 size_t relsize = 0; 541 size_t cnt; 542 struct symbol *sym; 543 544 assert (shdr->sh_type == SHT_REL); 545 546 for (cnt = 0; cnt < maxcnt; ++cnt) 547 { 548 XElf_Rel_vardef (rel); 549 550 xelf_getrel (data, cnt, rel); 551 /* XXX Should we complain about failing accesses? */ 552 if (rel != NULL) 553 { 554 Elf32_Word r_sym = XELF_R_SYM (rel->r_info); 555 556 /* Symbols in COMDAT group sections which are discarded do 557 not have to be relocated. */ 558 if (r_sym >= scninfo->fileinfo->nlocalsymbols 559 && unlikely (scninfo->fileinfo->symref[r_sym] == NULL)) 560 continue; 561 562 switch (XELF_R_TYPE (rel->r_info)) 563 { 564 case R_386_GOT32: 565 if (! scninfo->fileinfo->symref[r_sym]->defined 566 || scninfo->fileinfo->symref[r_sym]->in_dso 567 || statep->file_type == dso_file_type) 568 { 569 relsize += sizeof (Elf32_Rel); 570 ++statep->nrel_got; 571 } 572 573 /* Even if this relocation is not emitted in the output 574 file it requires a GOT entry. */ 575 ++statep->ngot; 576 577 /* FALLTHROUGH */ 578 579 case R_386_GOTOFF: 580 case R_386_GOTPC: 581 statep->need_got = true; 582 break; 583 584 case R_386_32: 585 case R_386_PC32: 586 /* These relocations cause text relocations in DSOs. */ 587 if (linked_from_dso_p (scninfo, r_sym)) 588 { 589 if (statep->file_type == dso_file_type) 590 { 591 relsize += sizeof (Elf32_Rel); 592 // XXX Do we have to check whether the target 593 // XXX section is read-only first? 594 statep->dt_flags |= DF_TEXTREL; 595 } 596 else 597 { 598 /* Non-function objects from a DSO need to get a 599 copy relocation. */ 600 sym = scninfo->fileinfo->symref[r_sym]; 601 602 /* Only do this if we have not requested a copy 603 relocation already. */ 604 if (unlikely (sym->type != STT_FUNC) && ! sym->need_copy) 605 { 606 sym->need_copy = 1; 607 ++statep->ncopy; 608 relsize += sizeof (Elf32_Rel); 609 } 610 } 611 } 612 else if (statep->file_type == dso_file_type 613 && XELF_R_TYPE (rel->r_info) == R_386_32) 614 relsize += sizeof (Elf32_Rel); 615 616 break; 617 618 case R_386_PLT32: 619 /* We might need a PLT entry. But we cannot say for sure 620 here since one of the symbols might turn up being 621 defined in the executable (if we create such a thing). 622 If a DSO is created we still might use a local 623 definition. 624 625 If the symbol is not defined and we are not creating 626 a statically linked binary, then we need in any case 627 a PLT entry. */ 628 if (! scninfo->fileinfo->symref[r_sym]->defined 629 && !statep->statically) 630 { 631 sym = scninfo->fileinfo->symref[r_sym]; 632 sym->type = STT_FUNC; 633 sym->in_dso = 1; 634 sym->defined = 1; 635 636 /* Remove from the list of unresolved symbols. */ 637 --statep->nunresolved; 638 if (! sym->weak) 639 --statep->nunresolved_nonweak; 640 CDBL_LIST_DEL (statep->unresolved, sym); 641 642 /* Add to the list of symbols we expect from a DSO. */ 643 ++statep->nplt; 644 ++statep->nfrom_dso; 645 CDBL_LIST_ADD_REAR (statep->from_dso, sym); 646 } 647 break; 648 649 case R_386_TLS_LDO_32: 650 if (statep->file_type != executable_file_type) 651 abort (); 652 /* We do not need a relocation in the output file. */ 653 break; 654 655 case R_386_TLS_LE: 656 /* We never need a relocation in the output file. */ 657 break; 658 659 case R_386_TLS_IE: 660 if (statep->file_type == dso_file_type) 661 error (EXIT_FAILURE, 0, gettext ("initial-executable TLS relocation cannot be used ")); 662 if (!scninfo->fileinfo->symref[r_sym]->defined 663 || scninfo->fileinfo->symref[r_sym]->in_dso) 664 { 665 abort (); 666 } 667 break; 668 669 case R_386_TLS_GD: 670 if (statep->file_type != executable_file_type 671 || !scninfo->fileinfo->symref[r_sym]->defined 672 || scninfo->fileinfo->symref[r_sym]->in_dso) 673 { 674 abort (); 675 } 676 break; 677 678 case R_386_TLS_GOTIE: 679 case R_386_TLS_LDM: 680 case R_386_TLS_GD_32: 681 case R_386_TLS_GD_PUSH: 682 case R_386_TLS_GD_CALL: 683 case R_386_TLS_GD_POP: 684 case R_386_TLS_LDM_32: 685 case R_386_TLS_LDM_PUSH: 686 case R_386_TLS_LDM_CALL: 687 case R_386_TLS_LDM_POP: 688 case R_386_TLS_IE_32: 689 case R_386_TLS_LE_32: 690 /* XXX */ 691 abort (); 692 break; 693 694 case R_386_NONE: 695 /* Nothing to be done. */ 696 break; 697 698 /* These relocation should never be generated by an 699 assembler. */ 700 case R_386_COPY: 701 case R_386_GLOB_DAT: 702 case R_386_JMP_SLOT: 703 case R_386_RELATIVE: 704 case R_386_TLS_DTPMOD32: 705 case R_386_TLS_DTPOFF32: 706 case R_386_TLS_TPOFF32: 707 /* Unknown relocation. */ 708 default: 709 abort (); 710 } 711 } 712 } 713 714 scninfo->relsize = relsize; 715 } 716 717 718 static void 719 elf_i386_create_relocations (struct ld_state *statep, 720 const Elf32_Word *dblindirect __attribute__ ((unused))) 721 { 722 /* Get the address of the got section. */ 723 Elf_Scn *pltscn = elf_getscn (statep->outelf, statep->pltscnidx); 724 Elf32_Shdr *shdr = elf32_getshdr (pltscn); 725 assert (shdr != NULL); 726 Elf32_Addr pltaddr = shdr->sh_addr; 727 728 Elf_Scn *gotscn = elf_getscn (statep->outelf, statep->gotscnidx); 729 // XXX Adjust the address, if necessary, for relro 730 Elf_Data *gotdata = NULL; 731 if (statep->need_got) 732 { 733 gotdata = elf_getdata (gotscn, NULL); 734 assert (gotdata != NULL); 735 } 736 737 Elf_Scn *gotpltscn = elf_getscn (statep->outelf, statep->gotpltscnidx); 738 shdr = elf32_getshdr (gotpltscn); 739 assert (shdr != NULL); 740 Elf32_Addr gotaddr = shdr->sh_addr; 741 742 Elf_Scn *reldynscn = elf_getscn (statep->outelf, statep->reldynscnidx); 743 Elf_Data *reldyndata = elf_getdata (reldynscn, NULL); 744 assert (reldyndata != NULL); 745 746 size_t nreldyn = 0; 747 size_t ngotconst = statep->nrel_got; 748 749 struct scninfo *first = statep->rellist->next; 750 struct scninfo *runp = first; 751 do 752 { 753 XElf_Shdr *rshdr = &SCNINFO_SHDR (runp->shdr); 754 Elf_Data *reldata = elf_getdata (runp->scn, NULL); 755 int nrels = rshdr->sh_size / rshdr->sh_entsize; 756 757 /* We will need the following values a couple of times. Help 758 the compiler and improve readability. */ 759 struct symbol **symref = runp->fileinfo->symref; 760 struct scninfo *scninfo = runp->fileinfo->scninfo; 761 762 /* This is the offset of the input section we are looking at in 763 the output file. */ 764 XElf_Addr inscnoffset = scninfo[rshdr->sh_info].offset; 765 766 /* The target section. We use the data from the input file. */ 767 Elf_Data *data = elf_getdata (scninfo[rshdr->sh_info].scn, NULL); 768 769 /* We cannot handle relocations against merge-able sections. */ 770 assert ((SCNINFO_SHDR (scninfo[rshdr->sh_link].shdr).sh_flags 771 & SHF_MERGE) == 0); 772 773 /* Cache the access to the symbol table data. */ 774 Elf_Data *symdata = elf_getdata (scninfo[rshdr->sh_link].scn, NULL); 775 776 for (int cnt = 0; cnt < nrels; ++cnt) 777 { 778 XElf_Rel_vardef (rel); 779 XElf_Rel *rel2; 780 xelf_getrel (reldata, cnt, rel); 781 assert (rel != NULL); 782 XElf_Addr reladdr = inscnoffset + rel->r_offset; 783 XElf_Addr value; 784 785 size_t idx = XELF_R_SYM (rel->r_info); 786 if (idx < runp->fileinfo->nlocalsymbols) 787 { 788 XElf_Sym_vardef (sym); 789 xelf_getsym (symdata, idx, sym); 790 791 /* The value only depends on the position of the referenced 792 section in the output file and the addend. */ 793 value = scninfo[sym->st_shndx].offset + sym->st_value; 794 } 795 else 796 { 797 if (symref[idx] == NULL) 798 /* Symbol in ignored COMDAT group section. */ 799 continue; 800 801 value = symref[idx]->merge.value; 802 if (symref[idx]->in_dso) 803 { 804 /* MERGE.VALUE contains the PLT index. If this is not for 805 a function the actual value will be computed later. */ 806 assert (value != 0 || symref[idx]->type != STT_FUNC); 807 value = pltaddr + value * PLT_ENTRY_SIZE; 808 } 809 } 810 811 /* Address of the relocated memory in the data buffer. */ 812 unsigned char *relloc = (unsigned char *) data->d_buf + rel->r_offset; 813 814 uint32_t thisgotidx; 815 switch (XELF_R_TYPE (rel->r_info)) 816 { 817 /* These three cases can be handled together since the 818 symbol associated with the R_386_GOTPC relocation is 819 _GLOBAL_OFFSET_TABLE_ which has a value corresponding 820 to the address of the GOT and the address of the PLT 821 entry required for R_386_PLT32 is computed above. */ 822 case R_386_PC32: 823 case R_386_GOTPC: 824 case R_386_PLT32: 825 value -= reladdr; 826 /* FALLTHROUGH */ 827 828 case R_386_32: 829 if (linked_from_dso_p (scninfo, idx) 830 && statep->file_type != dso_file_type 831 && symref[idx]->type != STT_FUNC) 832 { 833 value = (ld_state.copy_section->offset 834 + symref[idx]->merge.value); 835 836 if (unlikely (symref[idx]->need_copy)) 837 { 838 /* Add a relocation to initialize the GOT entry. */ 839 assert (symref[idx]->outdynsymidx != 0); 840 #if NATIVE_ELF != 0 841 xelf_getrel_ptr (reldyndata, nreldyn, rel2); 842 #else 843 rel2 = &rel_mem; 844 #endif 845 rel2->r_offset = value; 846 rel2->r_info 847 = XELF_R_INFO (symref[idx]->outdynsymidx, R_386_COPY); 848 (void) xelf_update_rel (reldyndata, nreldyn, rel2); 849 ++nreldyn; 850 assert (nreldyn <= statep->nrel_got); 851 852 /* Update the symbol table record for the new 853 address. */ 854 Elf32_Word symidx = symref[idx]->outdynsymidx; 855 Elf_Scn *symscn = elf_getscn (statep->outelf, 856 statep->dynsymscnidx); 857 Elf_Data *outsymdata = elf_getdata (symscn, NULL); 858 assert (outsymdata != NULL); 859 XElf_Sym_vardef (sym); 860 xelf_getsym (outsymdata, symidx, sym); 861 sym->st_value = value; 862 sym->st_shndx = statep->copy_section->outscnndx; 863 (void) xelf_update_sym (outsymdata, symidx, sym); 864 865 symidx = symref[idx]->outsymidx; 866 if (symidx != 0) 867 { 868 symidx = statep->dblindirect[symidx]; 869 symscn = elf_getscn (statep->outelf, 870 statep->symscnidx); 871 outsymdata = elf_getdata (symscn, NULL); 872 assert (outsymdata != NULL); 873 xelf_getsym (outsymdata, symidx, sym); 874 sym->st_value = value; 875 sym->st_shndx = statep->copy_section->outscnndx; 876 (void) xelf_update_sym (outsymdata, symidx, sym); 877 } 878 879 /* Remember that we set up the copy relocation. */ 880 symref[idx]->need_copy = 0; 881 } 882 } 883 else if (statep->file_type == dso_file_type 884 && XELF_R_TYPE (rel->r_info) == R_386_32) 885 { 886 #if NATIVE_ELF != 0 887 xelf_getrel_ptr (reldyndata, nreldyn, rel2); 888 #else 889 rel2 = &rel_mem; 890 #endif 891 rel2->r_offset = value; 892 893 /* For symbols we do not export we generate a relative 894 relocation. */ 895 if (idx < SCNINFO_SHDR (scninfo[rshdr->sh_link].shdr).sh_info 896 || symref[idx]->outdynsymidx == 0) 897 rel2->r_info = XELF_R_INFO (0, R_386_RELATIVE); 898 else 899 rel2->r_info 900 = XELF_R_INFO (symref[idx]->outdynsymidx, R_386_32); 901 (void) xelf_update_rel (reldyndata, nreldyn, rel2); 902 ++nreldyn; 903 assert (nreldyn <= statep->nrel_got); 904 905 value = 0; 906 } 907 add_4ubyte_unaligned (relloc, value); 908 break; 909 910 case R_386_GOT32: 911 if (! symref[idx]->defined || symref[idx]->in_dso) 912 { 913 thisgotidx = nreldyn++; 914 assert (thisgotidx < statep->nrel_got); 915 916 /* Add a relocation to initialize the GOT entry. */ 917 #if NATIVE_ELF != 0 918 xelf_getrel_ptr (reldyndata, thisgotidx, rel2); 919 #else 920 rel2 = &rel_mem; 921 #endif 922 rel2->r_offset = gotaddr + ((thisgotidx - statep->ngot) 923 * sizeof (Elf32_Addr)); 924 rel2->r_info 925 = XELF_R_INFO (symref[idx]->outdynsymidx, R_386_GLOB_DAT); 926 (void) xelf_update_rel (reldyndata, thisgotidx, rel2); 927 } 928 else if (statep->file_type != dso_file_type) 929 { 930 thisgotidx = ngotconst++; 931 assert (thisgotidx < statep->ngot); 932 933 /* We have to use a GOT since the generated code 934 requires it but we know the address and therefore 935 do not need a relocation. */ 936 ((uint32_t *) gotdata->d_buf)[thisgotidx] = value; 937 } 938 else 939 { 940 thisgotidx = nreldyn++; 941 assert (thisgotidx < statep->nrel_got); 942 943 // XXX generate a relative relocation. 944 abort (); 945 } 946 947 store_4ubyte_unaligned (relloc, 948 (thisgotidx - statep->ngot) 949 * sizeof (Elf32_Addr)); 950 break; 951 952 case R_386_GOTOFF: 953 add_4ubyte_unaligned (relloc, value - gotaddr); 954 break; 955 956 case R_386_TLS_LE: 957 value = symref[idx]->merge.value - ld_state.tls_tcb; 958 store_4ubyte_unaligned (relloc, value); 959 break; 960 961 case R_386_TLS_IE: 962 if (symref[idx]->defined && !symref[idx]->in_dso) 963 { 964 /* The symbol is defined in the executable. 965 Perform the IE->LE optimization. 966 There are multiple versions, though. 967 968 First version: mov ADDR,REG. */ 969 if (relloc[-2] == 0x8b 970 && ((relloc[-1] & 0xc7) == 0x05)) 971 { 972 relloc[-2] = 0xc7; 973 relloc[-1] = 0xc0 | ((relloc[-1] >> 3) & 7); 974 store_4ubyte_unaligned (relloc, (symref[idx]->merge.value 975 - ld_state.tls_tcb)); 976 } 977 else 978 { 979 abort (); 980 } 981 } 982 else 983 { 984 abort (); 985 } 986 break; 987 988 case R_386_TLS_LDO_32: 989 value = symref[idx]->merge.value - ld_state.tls_start; 990 store_4ubyte_unaligned (relloc, value); 991 break; 992 993 case R_386_TLS_GD: 994 if (ld_state.file_type == executable_file_type) 995 { 996 if (symref[idx]->defined && !symref[idx]->in_dso) 997 { 998 /* The symbol is defined in the executable. 999 Perform the GD->LE optimization. */ 1000 static const char gd_to_le[] = 1001 { 1002 /* mov %gs:0x0,%eax */ 1003 0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, 1004 /* sub $OFFSET,%eax */ 1005 0x81, 0xe8 1006 }; 1007 #ifndef NDEBUG 1008 static const char gd_text[] = 1009 { 1010 /* lea 0x0(,%ebx,1),%eax */ 1011 0x8d, 0x04, 0x1d, 0x00, 0x00, 0x00, 0x00, 1012 /* call ___tls_get_addr */ 1013 0xe8 1014 }; 1015 assert (memcmp (relloc - 3, gd_text, sizeof (gd_text)) 1016 == 0); 1017 #endif 1018 relloc = mempcpy (relloc - 3, gd_to_le, 1019 sizeof (gd_to_le)); 1020 value = ld_state.tls_tcb- symref[idx]->merge.value; 1021 store_4ubyte_unaligned (relloc, value); 1022 1023 /* We have to skip over the next relocation which is 1024 the matching R_i386_PLT32 for __tls_get_addr. */ 1025 ++cnt; 1026 #ifndef NDEBUG 1027 assert (cnt < nrels); 1028 XElf_Off old_offset = rel->r_offset; 1029 xelf_getrel (reldata, cnt, rel); 1030 assert (rel != NULL); 1031 assert (XELF_R_TYPE (rel->r_info) == R_386_PLT32); 1032 idx = XELF_R_SYM (rel->r_info); 1033 assert (strcmp (symref[idx]->name, "___tls_get_addr") 1034 == 0); 1035 assert (old_offset + 5 == rel->r_offset); 1036 #endif 1037 1038 break; 1039 } 1040 } 1041 abort (); 1042 break; 1043 1044 case R_386_32PLT: 1045 case R_386_TLS_TPOFF: 1046 case R_386_TLS_GOTIE: 1047 case R_386_TLS_LDM: 1048 case R_386_16: 1049 case R_386_PC16: 1050 case R_386_8: 1051 case R_386_PC8: 1052 case R_386_TLS_GD_32: 1053 case R_386_TLS_GD_PUSH: 1054 case R_386_TLS_GD_CALL: 1055 case R_386_TLS_GD_POP: 1056 case R_386_TLS_LDM_32: 1057 case R_386_TLS_LDM_PUSH: 1058 case R_386_TLS_LDM_CALL: 1059 case R_386_TLS_LDM_POP: 1060 case R_386_TLS_IE_32: 1061 case R_386_TLS_LE_32: 1062 // XXX For now fall through 1063 break; 1064 1065 case R_386_NONE: 1066 /* Nothing to do. */ 1067 break; 1068 1069 case R_386_COPY: 1070 case R_386_JMP_SLOT: 1071 case R_386_RELATIVE: 1072 case R_386_GLOB_DAT: 1073 case R_386_TLS_DTPMOD32: 1074 case R_386_TLS_DTPOFF32: 1075 case R_386_TLS_TPOFF32: 1076 default: 1077 /* Should not happen. */ 1078 abort (); 1079 } 1080 } 1081 } 1082 while ((runp = runp->next) != first); 1083 } 1084 1085 1086 int 1087 elf_i386_ld_init (struct ld_state *statep) 1088 { 1089 /* We have a few callbacks available. */ 1090 old_open_outfile = statep->callbacks.open_outfile; 1091 statep->callbacks.open_outfile = elf_i386_open_outfile; 1092 1093 statep->callbacks.relocate_section = elf_i386_relocate_section; 1094 1095 statep->callbacks.initialize_plt = elf_i386_initialize_plt; 1096 statep->callbacks.initialize_pltrel = elf_i386_initialize_pltrel; 1097 1098 statep->callbacks.initialize_got = elf_i386_initialize_got; 1099 statep->callbacks.initialize_gotplt = elf_i386_initialize_gotplt; 1100 1101 statep->callbacks.finalize_plt = elf_i386_finalize_plt; 1102 1103 statep->callbacks.rel_type = elf_i386_rel_type; 1104 1105 statep->callbacks.count_relocations = elf_i386_count_relocations; 1106 1107 statep->callbacks.create_relocations = elf_i386_create_relocations; 1108 1109 return 0; 1110 } 1111
