elf32-i386.c revision 33966
1/* Intel 80386/80486-specific support for 32-bit ELF 2 Copyright 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc. 3 4This file is part of BFD, the Binary File Descriptor library. 5 6This program is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 2 of the License, or 9(at your option) any later version. 10 11This program is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along with this program; if not, write to the Free Software 18Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 19 20#include "bfd.h" 21#include "sysdep.h" 22#include "bfdlink.h" 23#include "libbfd.h" 24#include "elf-bfd.h" 25 26static reloc_howto_type *elf_i386_reloc_type_lookup 27 PARAMS ((bfd *, bfd_reloc_code_real_type)); 28static void elf_i386_info_to_howto 29 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *)); 30static void elf_i386_info_to_howto_rel 31 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *)); 32static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *)); 33static struct bfd_hash_entry *elf_i386_link_hash_newfunc 34 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 35static struct bfd_link_hash_table *elf_i386_link_hash_table_create 36 PARAMS ((bfd *)); 37static boolean elf_i386_check_relocs 38 PARAMS ((bfd *, struct bfd_link_info *, asection *, 39 const Elf_Internal_Rela *)); 40static boolean elf_i386_adjust_dynamic_symbol 41 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 42static boolean elf_i386_size_dynamic_sections 43 PARAMS ((bfd *, struct bfd_link_info *)); 44static boolean elf_i386_relocate_section 45 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 46 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 47static boolean elf_i386_finish_dynamic_symbol 48 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 49 Elf_Internal_Sym *)); 50static boolean elf_i386_finish_dynamic_sections 51 PARAMS ((bfd *, struct bfd_link_info *)); 52 53#define USE_REL 1 /* 386 uses REL relocations instead of RELA */ 54 55enum reloc_type 56 { 57 R_386_NONE = 0, 58 R_386_32, 59 R_386_PC32, 60 R_386_GOT32, 61 R_386_PLT32, 62 R_386_COPY, 63 R_386_GLOB_DAT, 64 R_386_JUMP_SLOT, 65 R_386_RELATIVE, 66 R_386_GOTOFF, 67 R_386_GOTPC, 68 FIRST_INVALID_RELOC, 69 LAST_INVALID_RELOC = 19, 70 /* The remaining relocs are a GNU extension. */ 71 R_386_16 = 20, 72 R_386_PC16, 73 R_386_8, 74 R_386_PC8, 75 R_386_max 76 }; 77 78#if 0 79static CONST char *CONST reloc_type_names[] = 80{ 81 "R_386_NONE", 82 "R_386_32", 83 "R_386_PC32", 84 "R_386_GOT32", 85 "R_386_PLT32", 86 "R_386_COPY", 87 "R_386_GLOB_DAT", 88 "R_386_JUMP_SLOT", 89 "R_386_RELATIVE", 90 "R_386_GOTOFF", 91 "R_386_GOTPC", 92}; 93#endif 94 95static reloc_howto_type elf_howto_table[]= 96{ 97 HOWTO(R_386_NONE, 0,0, 0,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_NONE", true,0x00000000,0x00000000,false), 98 HOWTO(R_386_32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_32", true,0xffffffff,0xffffffff,false), 99 HOWTO(R_386_PC32, 0,2,32,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC32", true,0xffffffff,0xffffffff,true), 100 HOWTO(R_386_GOT32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOT32", true,0xffffffff,0xffffffff,false), 101 HOWTO(R_386_PLT32, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PLT32", true,0xffffffff,0xffffffff,true), 102 HOWTO(R_386_COPY, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_COPY", true,0xffffffff,0xffffffff,false), 103 HOWTO(R_386_GLOB_DAT, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GLOB_DAT", true,0xffffffff,0xffffffff,false), 104 HOWTO(R_386_JUMP_SLOT, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_JUMP_SLOT",true,0xffffffff,0xffffffff,false), 105 HOWTO(R_386_RELATIVE, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_RELATIVE", true,0xffffffff,0xffffffff,false), 106 HOWTO(R_386_GOTOFF, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTOFF", true,0xffffffff,0xffffffff,false), 107 HOWTO(R_386_GOTPC, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTPC", true,0xffffffff,0xffffffff,true), 108 { 11 }, 109 { 12 }, 110 { 13 }, 111 { 14 }, 112 { 15 }, 113 { 16 }, 114 { 17 }, 115 { 18 }, 116 { 19 }, 117 /* The remaining relocs are a GNU extension. */ 118 HOWTO(R_386_16, 0,1,16,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_16", true,0xffff,0xffff,false), 119 HOWTO(R_386_PC16, 0,1,16,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC16", true,0xffff,0xffff,true), 120 HOWTO(R_386_8, 0,0,8,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_8", true,0xff,0xff,false), 121 HOWTO(R_386_PC8, 0,0,8,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC8", true,0xff,0xff,true), 122}; 123 124#ifdef DEBUG_GEN_RELOC 125#define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str) 126#else 127#define TRACE(str) 128#endif 129 130static reloc_howto_type * 131elf_i386_reloc_type_lookup (abfd, code) 132 bfd *abfd; 133 bfd_reloc_code_real_type code; 134{ 135 switch (code) 136 { 137 case BFD_RELOC_NONE: 138 TRACE ("BFD_RELOC_NONE"); 139 return &elf_howto_table[ (int)R_386_NONE ]; 140 141 case BFD_RELOC_32: 142 TRACE ("BFD_RELOC_32"); 143 return &elf_howto_table[ (int)R_386_32 ]; 144 145 case BFD_RELOC_32_PCREL: 146 TRACE ("BFD_RELOC_PC32"); 147 return &elf_howto_table[ (int)R_386_PC32 ]; 148 149 case BFD_RELOC_386_GOT32: 150 TRACE ("BFD_RELOC_386_GOT32"); 151 return &elf_howto_table[ (int)R_386_GOT32 ]; 152 153 case BFD_RELOC_386_PLT32: 154 TRACE ("BFD_RELOC_386_PLT32"); 155 return &elf_howto_table[ (int)R_386_PLT32 ]; 156 157 case BFD_RELOC_386_COPY: 158 TRACE ("BFD_RELOC_386_COPY"); 159 return &elf_howto_table[ (int)R_386_COPY ]; 160 161 case BFD_RELOC_386_GLOB_DAT: 162 TRACE ("BFD_RELOC_386_GLOB_DAT"); 163 return &elf_howto_table[ (int)R_386_GLOB_DAT ]; 164 165 case BFD_RELOC_386_JUMP_SLOT: 166 TRACE ("BFD_RELOC_386_JUMP_SLOT"); 167 return &elf_howto_table[ (int)R_386_JUMP_SLOT ]; 168 169 case BFD_RELOC_386_RELATIVE: 170 TRACE ("BFD_RELOC_386_RELATIVE"); 171 return &elf_howto_table[ (int)R_386_RELATIVE ]; 172 173 case BFD_RELOC_386_GOTOFF: 174 TRACE ("BFD_RELOC_386_GOTOFF"); 175 return &elf_howto_table[ (int)R_386_GOTOFF ]; 176 177 case BFD_RELOC_386_GOTPC: 178 TRACE ("BFD_RELOC_386_GOTPC"); 179 return &elf_howto_table[ (int)R_386_GOTPC ]; 180 181 /* The remaining relocs are a GNU extension. */ 182 case BFD_RELOC_16: 183 TRACE ("BFD_RELOC_16"); 184 return &elf_howto_table[(int) R_386_16]; 185 186 case BFD_RELOC_16_PCREL: 187 TRACE ("BFD_RELOC_16_PCREL"); 188 return &elf_howto_table[(int) R_386_PC16]; 189 190 case BFD_RELOC_8: 191 TRACE ("BFD_RELOC_8"); 192 return &elf_howto_table[(int) R_386_8]; 193 194 case BFD_RELOC_8_PCREL: 195 TRACE ("BFD_RELOC_8_PCREL"); 196 return &elf_howto_table[(int) R_386_PC8]; 197 198 default: 199 break; 200 } 201 202 TRACE ("Unknown"); 203 return 0; 204} 205 206static void 207elf_i386_info_to_howto (abfd, cache_ptr, dst) 208 bfd *abfd; 209 arelent *cache_ptr; 210 Elf32_Internal_Rela *dst; 211{ 212 abort (); 213} 214 215static void 216elf_i386_info_to_howto_rel (abfd, cache_ptr, dst) 217 bfd *abfd; 218 arelent *cache_ptr; 219 Elf32_Internal_Rel *dst; 220{ 221 enum reloc_type type; 222 223 type = (enum reloc_type) ELF32_R_TYPE (dst->r_info); 224 BFD_ASSERT (type < R_386_max); 225 BFD_ASSERT (type < FIRST_INVALID_RELOC || type > LAST_INVALID_RELOC); 226 227 cache_ptr->howto = &elf_howto_table[(int) type]; 228} 229 230/* Return whether a symbol name implies a local label. The UnixWare 231 2.1 cc generates temporary symbols that start with .X, so we 232 recognize them here. FIXME: do other SVR4 compilers also use .X?. 233 If so, we should move the .X recognition into 234 _bfd_elf_is_local_label_name. */ 235 236static boolean 237elf_i386_is_local_label_name (abfd, name) 238 bfd *abfd; 239 const char *name; 240{ 241 if (name[0] == '.' && name[1] == 'X') 242 return true; 243 244 return _bfd_elf_is_local_label_name (abfd, name); 245} 246 247/* Functions for the i386 ELF linker. */ 248 249/* The name of the dynamic interpreter. This is put in the .interp 250 section. */ 251 252#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" 253 254/* The size in bytes of an entry in the procedure linkage table. */ 255 256#define PLT_ENTRY_SIZE 16 257 258/* The first entry in an absolute procedure linkage table looks like 259 this. See the SVR4 ABI i386 supplement to see how this works. */ 260 261static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] = 262{ 263 0xff, 0x35, /* pushl contents of address */ 264 0, 0, 0, 0, /* replaced with address of .got + 4. */ 265 0xff, 0x25, /* jmp indirect */ 266 0, 0, 0, 0, /* replaced with address of .got + 8. */ 267 0, 0, 0, 0 /* pad out to 16 bytes. */ 268}; 269 270/* Subsequent entries in an absolute procedure linkage table look like 271 this. */ 272 273static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] = 274{ 275 0xff, 0x25, /* jmp indirect */ 276 0, 0, 0, 0, /* replaced with address of this symbol in .got. */ 277 0x68, /* pushl immediate */ 278 0, 0, 0, 0, /* replaced with offset into relocation table. */ 279 0xe9, /* jmp relative */ 280 0, 0, 0, 0 /* replaced with offset to start of .plt. */ 281}; 282 283/* The first entry in a PIC procedure linkage table look like this. */ 284 285static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] = 286{ 287 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */ 288 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */ 289 0, 0, 0, 0 /* pad out to 16 bytes. */ 290}; 291 292/* Subsequent entries in a PIC procedure linkage table look like this. */ 293 294static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] = 295{ 296 0xff, 0xa3, /* jmp *offset(%ebx) */ 297 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */ 298 0x68, /* pushl immediate */ 299 0, 0, 0, 0, /* replaced with offset into relocation table. */ 300 0xe9, /* jmp relative */ 301 0, 0, 0, 0 /* replaced with offset to start of .plt. */ 302}; 303 304/* The i386 linker needs to keep track of the number of relocs that it 305 decides to copy in check_relocs for each symbol. This is so that 306 it can discard PC relative relocs if it doesn't need them when 307 linking with -Bsymbolic. We store the information in a field 308 extending the regular ELF linker hash table. */ 309 310/* This structure keeps track of the number of PC relative relocs we 311 have copied for a given symbol. */ 312 313struct elf_i386_pcrel_relocs_copied 314{ 315 /* Next section. */ 316 struct elf_i386_pcrel_relocs_copied *next; 317 /* A section in dynobj. */ 318 asection *section; 319 /* Number of relocs copied in this section. */ 320 bfd_size_type count; 321}; 322 323/* i386 ELF linker hash entry. */ 324 325struct elf_i386_link_hash_entry 326{ 327 struct elf_link_hash_entry root; 328 329 /* Number of PC relative relocs copied for this symbol. */ 330 struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied; 331}; 332 333/* i386 ELF linker hash table. */ 334 335struct elf_i386_link_hash_table 336{ 337 struct elf_link_hash_table root; 338}; 339 340/* Declare this now that the above structures are defined. */ 341 342static boolean elf_i386_discard_copies 343 PARAMS ((struct elf_i386_link_hash_entry *, PTR)); 344 345/* Traverse an i386 ELF linker hash table. */ 346 347#define elf_i386_link_hash_traverse(table, func, info) \ 348 (elf_link_hash_traverse \ 349 (&(table)->root, \ 350 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \ 351 (info))) 352 353/* Get the i386 ELF linker hash table from a link_info structure. */ 354 355#define elf_i386_hash_table(p) \ 356 ((struct elf_i386_link_hash_table *) ((p)->hash)) 357 358/* Create an entry in an i386 ELF linker hash table. */ 359 360static struct bfd_hash_entry * 361elf_i386_link_hash_newfunc (entry, table, string) 362 struct bfd_hash_entry *entry; 363 struct bfd_hash_table *table; 364 const char *string; 365{ 366 struct elf_i386_link_hash_entry *ret = 367 (struct elf_i386_link_hash_entry *) entry; 368 369 /* Allocate the structure if it has not already been allocated by a 370 subclass. */ 371 if (ret == (struct elf_i386_link_hash_entry *) NULL) 372 ret = ((struct elf_i386_link_hash_entry *) 373 bfd_hash_allocate (table, 374 sizeof (struct elf_i386_link_hash_entry))); 375 if (ret == (struct elf_i386_link_hash_entry *) NULL) 376 return (struct bfd_hash_entry *) ret; 377 378 /* Call the allocation method of the superclass. */ 379 ret = ((struct elf_i386_link_hash_entry *) 380 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 381 table, string)); 382 if (ret != (struct elf_i386_link_hash_entry *) NULL) 383 { 384 ret->pcrel_relocs_copied = NULL; 385 } 386 387 return (struct bfd_hash_entry *) ret; 388} 389 390/* Create an i386 ELF linker hash table. */ 391 392static struct bfd_link_hash_table * 393elf_i386_link_hash_table_create (abfd) 394 bfd *abfd; 395{ 396 struct elf_i386_link_hash_table *ret; 397 398 ret = ((struct elf_i386_link_hash_table *) 399 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table))); 400 if (ret == (struct elf_i386_link_hash_table *) NULL) 401 return NULL; 402 403 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd, 404 elf_i386_link_hash_newfunc)) 405 { 406 bfd_release (abfd, ret); 407 return NULL; 408 } 409 410 return &ret->root.root; 411} 412 413/* Look through the relocs for a section during the first phase, and 414 allocate space in the global offset table or procedure linkage 415 table. */ 416 417static boolean 418elf_i386_check_relocs (abfd, info, sec, relocs) 419 bfd *abfd; 420 struct bfd_link_info *info; 421 asection *sec; 422 const Elf_Internal_Rela *relocs; 423{ 424 bfd *dynobj; 425 Elf_Internal_Shdr *symtab_hdr; 426 struct elf_link_hash_entry **sym_hashes; 427 bfd_vma *local_got_offsets; 428 const Elf_Internal_Rela *rel; 429 const Elf_Internal_Rela *rel_end; 430 asection *sgot; 431 asection *srelgot; 432 asection *sreloc; 433 434 if (info->relocateable) 435 return true; 436 437 dynobj = elf_hash_table (info)->dynobj; 438 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 439 sym_hashes = elf_sym_hashes (abfd); 440 local_got_offsets = elf_local_got_offsets (abfd); 441 442 sgot = NULL; 443 srelgot = NULL; 444 sreloc = NULL; 445 446 rel_end = relocs + sec->reloc_count; 447 for (rel = relocs; rel < rel_end; rel++) 448 { 449 unsigned long r_symndx; 450 struct elf_link_hash_entry *h; 451 452 r_symndx = ELF32_R_SYM (rel->r_info); 453 454 if (r_symndx < symtab_hdr->sh_info) 455 h = NULL; 456 else 457 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 458 459 /* Some relocs require a global offset table. */ 460 if (dynobj == NULL) 461 { 462 switch (ELF32_R_TYPE (rel->r_info)) 463 { 464 case R_386_GOT32: 465 case R_386_GOTOFF: 466 case R_386_GOTPC: 467 elf_hash_table (info)->dynobj = dynobj = abfd; 468 if (! _bfd_elf_create_got_section (dynobj, info)) 469 return false; 470 break; 471 472 default: 473 break; 474 } 475 } 476 477 switch (ELF32_R_TYPE (rel->r_info)) 478 { 479 case R_386_GOT32: 480 /* This symbol requires a global offset table entry. */ 481 482 if (sgot == NULL) 483 { 484 sgot = bfd_get_section_by_name (dynobj, ".got"); 485 BFD_ASSERT (sgot != NULL); 486 } 487 488 if (srelgot == NULL 489 && (h != NULL || info->shared)) 490 { 491 srelgot = bfd_get_section_by_name (dynobj, ".rel.got"); 492 if (srelgot == NULL) 493 { 494 srelgot = bfd_make_section (dynobj, ".rel.got"); 495 if (srelgot == NULL 496 || ! bfd_set_section_flags (dynobj, srelgot, 497 (SEC_ALLOC 498 | SEC_LOAD 499 | SEC_HAS_CONTENTS 500 | SEC_IN_MEMORY 501 | SEC_LINKER_CREATED 502 | SEC_READONLY)) 503 || ! bfd_set_section_alignment (dynobj, srelgot, 2)) 504 return false; 505 } 506 } 507 508 if (h != NULL) 509 { 510 if (h->got_offset != (bfd_vma) -1) 511 { 512 /* We have already allocated space in the .got. */ 513 break; 514 } 515 h->got_offset = sgot->_raw_size; 516 517 /* Make sure this symbol is output as a dynamic symbol. */ 518 if (h->dynindx == -1) 519 { 520 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 521 return false; 522 } 523 524 srelgot->_raw_size += sizeof (Elf32_External_Rel); 525 } 526 else 527 { 528 /* This is a global offset table entry for a local 529 symbol. */ 530 if (local_got_offsets == NULL) 531 { 532 size_t size; 533 register unsigned int i; 534 535 size = symtab_hdr->sh_info * sizeof (bfd_vma); 536 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size); 537 if (local_got_offsets == NULL) 538 return false; 539 elf_local_got_offsets (abfd) = local_got_offsets; 540 for (i = 0; i < symtab_hdr->sh_info; i++) 541 local_got_offsets[i] = (bfd_vma) -1; 542 } 543 if (local_got_offsets[r_symndx] != (bfd_vma) -1) 544 { 545 /* We have already allocated space in the .got. */ 546 break; 547 } 548 local_got_offsets[r_symndx] = sgot->_raw_size; 549 550 if (info->shared) 551 { 552 /* If we are generating a shared object, we need to 553 output a R_386_RELATIVE reloc so that the dynamic 554 linker can adjust this GOT entry. */ 555 srelgot->_raw_size += sizeof (Elf32_External_Rel); 556 } 557 } 558 559 sgot->_raw_size += 4; 560 561 break; 562 563 case R_386_PLT32: 564 /* This symbol requires a procedure linkage table entry. We 565 actually build the entry in adjust_dynamic_symbol, 566 because this might be a case of linking PIC code which is 567 never referenced by a dynamic object, in which case we 568 don't need to generate a procedure linkage table entry 569 after all. */ 570 571 /* If this is a local symbol, we resolve it directly without 572 creating a procedure linkage table entry. */ 573 if (h == NULL) 574 continue; 575 576 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 577 578 break; 579 580 case R_386_32: 581 case R_386_PC32: 582 /* If we are creating a shared library, and this is a reloc 583 against a global symbol, or a non PC relative reloc 584 against a local symbol, then we need to copy the reloc 585 into the shared library. However, if we are linking with 586 -Bsymbolic, we do not need to copy a reloc against a 587 global symbol which is defined in an object we are 588 including in the link (i.e., DEF_REGULAR is set). At 589 this point we have not seen all the input files, so it is 590 possible that DEF_REGULAR is not set now but will be set 591 later (it is never cleared). We account for that 592 possibility below by storing information in the 593 pcrel_relocs_copied field of the hash table entry. */ 594 if (info->shared 595 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32 596 || (h != NULL 597 && (! info->symbolic 598 || (h->elf_link_hash_flags 599 & ELF_LINK_HASH_DEF_REGULAR) == 0)))) 600 { 601 /* When creating a shared object, we must copy these 602 reloc types into the output file. We create a reloc 603 section in dynobj and make room for this reloc. */ 604 if (sreloc == NULL) 605 { 606 const char *name; 607 608 name = (bfd_elf_string_from_elf_section 609 (abfd, 610 elf_elfheader (abfd)->e_shstrndx, 611 elf_section_data (sec)->rel_hdr.sh_name)); 612 if (name == NULL) 613 return false; 614 615 BFD_ASSERT (strncmp (name, ".rel", 4) == 0 616 && strcmp (bfd_get_section_name (abfd, sec), 617 name + 4) == 0); 618 619 sreloc = bfd_get_section_by_name (dynobj, name); 620 if (sreloc == NULL) 621 { 622 flagword flags; 623 624 sreloc = bfd_make_section (dynobj, name); 625 flags = (SEC_HAS_CONTENTS | SEC_READONLY 626 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 627 if ((sec->flags & SEC_ALLOC) != 0) 628 flags |= SEC_ALLOC | SEC_LOAD; 629 if (sreloc == NULL 630 || ! bfd_set_section_flags (dynobj, sreloc, flags) 631 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 632 return false; 633 } 634 } 635 636 sreloc->_raw_size += sizeof (Elf32_External_Rel); 637 638 /* If we are linking with -Bsymbolic, and this is a 639 global symbol, we count the number of PC relative 640 relocations we have entered for this symbol, so that 641 we can discard them again if the symbol is later 642 defined by a regular object. Note that this function 643 is only called if we are using an elf_i386 linker 644 hash table, which means that h is really a pointer to 645 an elf_i386_link_hash_entry. */ 646 if (h != NULL && info->symbolic 647 && ELF32_R_TYPE (rel->r_info) == R_386_PC32) 648 { 649 struct elf_i386_link_hash_entry *eh; 650 struct elf_i386_pcrel_relocs_copied *p; 651 652 eh = (struct elf_i386_link_hash_entry *) h; 653 654 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next) 655 if (p->section == sreloc) 656 break; 657 658 if (p == NULL) 659 { 660 p = ((struct elf_i386_pcrel_relocs_copied *) 661 bfd_alloc (dynobj, sizeof *p)); 662 if (p == NULL) 663 return false; 664 p->next = eh->pcrel_relocs_copied; 665 eh->pcrel_relocs_copied = p; 666 p->section = sreloc; 667 p->count = 0; 668 } 669 670 ++p->count; 671 } 672 } 673 674 break; 675 676 default: 677 break; 678 } 679 } 680 681 return true; 682} 683 684/* Adjust a symbol defined by a dynamic object and referenced by a 685 regular object. The current definition is in some section of the 686 dynamic object, but we're not including those sections. We have to 687 change the definition to something the rest of the link can 688 understand. */ 689 690static boolean 691elf_i386_adjust_dynamic_symbol (info, h) 692 struct bfd_link_info *info; 693 struct elf_link_hash_entry *h; 694{ 695 bfd *dynobj; 696 asection *s; 697 unsigned int power_of_two; 698 699 dynobj = elf_hash_table (info)->dynobj; 700 701 /* Make sure we know what is going on here. */ 702 BFD_ASSERT (dynobj != NULL 703 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) 704 || h->weakdef != NULL 705 || ((h->elf_link_hash_flags 706 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 707 && (h->elf_link_hash_flags 708 & ELF_LINK_HASH_REF_REGULAR) != 0 709 && (h->elf_link_hash_flags 710 & ELF_LINK_HASH_DEF_REGULAR) == 0))); 711 712 /* If this is a function, put it in the procedure linkage table. We 713 will fill in the contents of the procedure linkage table later, 714 when we know the address of the .got section. */ 715 if (h->type == STT_FUNC 716 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0) 717 { 718 if (! info->shared 719 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0 720 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0) 721 { 722 /* This case can occur if we saw a PLT32 reloc in an input 723 file, but the symbol was never referred to by a dynamic 724 object. In such a case, we don't actually need to build 725 a procedure linkage table, and we can just do a PC32 726 reloc instead. */ 727 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0); 728 return true; 729 } 730 731 /* Make sure this symbol is output as a dynamic symbol. */ 732 if (h->dynindx == -1) 733 { 734 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 735 return false; 736 } 737 738 s = bfd_get_section_by_name (dynobj, ".plt"); 739 BFD_ASSERT (s != NULL); 740 741 /* If this is the first .plt entry, make room for the special 742 first entry. */ 743 if (s->_raw_size == 0) 744 s->_raw_size += PLT_ENTRY_SIZE; 745 746 /* If this symbol is not defined in a regular file, and we are 747 not generating a shared library, then set the symbol to this 748 location in the .plt. This is required to make function 749 pointers compare as equal between the normal executable and 750 the shared library. */ 751 if (! info->shared 752 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 753 { 754 h->root.u.def.section = s; 755 h->root.u.def.value = s->_raw_size; 756 } 757 758 h->plt_offset = s->_raw_size; 759 760 /* Make room for this entry. */ 761 s->_raw_size += PLT_ENTRY_SIZE; 762 763 /* We also need to make an entry in the .got.plt section, which 764 will be placed in the .got section by the linker script. */ 765 766 s = bfd_get_section_by_name (dynobj, ".got.plt"); 767 BFD_ASSERT (s != NULL); 768 s->_raw_size += 4; 769 770 /* We also need to make an entry in the .rel.plt section. */ 771 772 s = bfd_get_section_by_name (dynobj, ".rel.plt"); 773 BFD_ASSERT (s != NULL); 774 s->_raw_size += sizeof (Elf32_External_Rel); 775 776 return true; 777 } 778 779 /* If this is a weak symbol, and there is a real definition, the 780 processor independent code will have arranged for us to see the 781 real definition first, and we can just use the same value. */ 782 if (h->weakdef != NULL) 783 { 784 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 785 || h->weakdef->root.type == bfd_link_hash_defweak); 786 h->root.u.def.section = h->weakdef->root.u.def.section; 787 h->root.u.def.value = h->weakdef->root.u.def.value; 788 return true; 789 } 790 791 /* This is a reference to a symbol defined by a dynamic object which 792 is not a function. */ 793 794 /* If we are creating a shared library, we must presume that the 795 only references to the symbol are via the global offset table. 796 For such cases we need not do anything here; the relocations will 797 be handled correctly by relocate_section. */ 798 if (info->shared) 799 return true; 800 801 /* We must allocate the symbol in our .dynbss section, which will 802 become part of the .bss section of the executable. There will be 803 an entry for this symbol in the .dynsym section. The dynamic 804 object will contain position independent code, so all references 805 from the dynamic object to this symbol will go through the global 806 offset table. The dynamic linker will use the .dynsym entry to 807 determine the address it must put in the global offset table, so 808 both the dynamic object and the regular object will refer to the 809 same memory location for the variable. */ 810 811 s = bfd_get_section_by_name (dynobj, ".dynbss"); 812 BFD_ASSERT (s != NULL); 813 814 /* We must generate a R_386_COPY reloc to tell the dynamic linker to 815 copy the initial value out of the dynamic object and into the 816 runtime process image. We need to remember the offset into the 817 .rel.bss section we are going to use. */ 818 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 819 { 820 asection *srel; 821 822 srel = bfd_get_section_by_name (dynobj, ".rel.bss"); 823 BFD_ASSERT (srel != NULL); 824 srel->_raw_size += sizeof (Elf32_External_Rel); 825 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; 826 } 827 828 /* We need to figure out the alignment required for this symbol. I 829 have no idea how ELF linkers handle this. */ 830 power_of_two = bfd_log2 (h->size); 831 if (power_of_two > 3) 832 power_of_two = 3; 833 834 /* Apply the required alignment. */ 835 s->_raw_size = BFD_ALIGN (s->_raw_size, 836 (bfd_size_type) (1 << power_of_two)); 837 if (power_of_two > bfd_get_section_alignment (dynobj, s)) 838 { 839 if (! bfd_set_section_alignment (dynobj, s, power_of_two)) 840 return false; 841 } 842 843 /* Define the symbol as being at this point in the section. */ 844 h->root.u.def.section = s; 845 h->root.u.def.value = s->_raw_size; 846 847 /* Increment the section size to make room for the symbol. */ 848 s->_raw_size += h->size; 849 850 return true; 851} 852 853/* Set the sizes of the dynamic sections. */ 854 855static boolean 856elf_i386_size_dynamic_sections (output_bfd, info) 857 bfd *output_bfd; 858 struct bfd_link_info *info; 859{ 860 bfd *dynobj; 861 asection *s; 862 boolean plt; 863 boolean relocs; 864 boolean reltext; 865 866 dynobj = elf_hash_table (info)->dynobj; 867 BFD_ASSERT (dynobj != NULL); 868 869 if (elf_hash_table (info)->dynamic_sections_created) 870 { 871 /* Set the contents of the .interp section to the interpreter. */ 872 if (! info->shared) 873 { 874 s = bfd_get_section_by_name (dynobj, ".interp"); 875 BFD_ASSERT (s != NULL); 876 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 877 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 878 } 879 } 880 else 881 { 882 /* We may have created entries in the .rel.got section. 883 However, if we are not creating the dynamic sections, we will 884 not actually use these entries. Reset the size of .rel.got, 885 which will cause it to get stripped from the output file 886 below. */ 887 s = bfd_get_section_by_name (dynobj, ".rel.got"); 888 if (s != NULL) 889 s->_raw_size = 0; 890 } 891 892 /* If this is a -Bsymbolic shared link, then we need to discard all 893 PC relative relocs against symbols defined in a regular object. 894 We allocated space for them in the check_relocs routine, but we 895 will not fill them in in the relocate_section routine. */ 896 if (info->shared && info->symbolic) 897 elf_i386_link_hash_traverse (elf_i386_hash_table (info), 898 elf_i386_discard_copies, 899 (PTR) NULL); 900 901 /* The check_relocs and adjust_dynamic_symbol entry points have 902 determined the sizes of the various dynamic sections. Allocate 903 memory for them. */ 904 plt = false; 905 relocs = false; 906 reltext = false; 907 for (s = dynobj->sections; s != NULL; s = s->next) 908 { 909 const char *name; 910 boolean strip; 911 912 if ((s->flags & SEC_LINKER_CREATED) == 0) 913 continue; 914 915 /* It's OK to base decisions on the section name, because none 916 of the dynobj section names depend upon the input files. */ 917 name = bfd_get_section_name (dynobj, s); 918 919 strip = false; 920 921 if (strcmp (name, ".plt") == 0) 922 { 923 if (s->_raw_size == 0) 924 { 925 /* Strip this section if we don't need it; see the 926 comment below. */ 927 strip = true; 928 } 929 else 930 { 931 /* Remember whether there is a PLT. */ 932 plt = true; 933 } 934 } 935 else if (strncmp (name, ".rel", 4) == 0) 936 { 937 if (s->_raw_size == 0) 938 { 939 /* If we don't need this section, strip it from the 940 output file. This is mostly to handle .rel.bss and 941 .rel.plt. We must create both sections in 942 create_dynamic_sections, because they must be created 943 before the linker maps input sections to output 944 sections. The linker does that before 945 adjust_dynamic_symbol is called, and it is that 946 function which decides whether anything needs to go 947 into these sections. */ 948 strip = true; 949 } 950 else 951 { 952 asection *target; 953 954 /* Remember whether there are any reloc sections other 955 than .rel.plt. */ 956 if (strcmp (name, ".rel.plt") != 0) 957 { 958 const char *outname; 959 960 relocs = true; 961 962 /* If this relocation section applies to a read only 963 section, then we probably need a DT_TEXTREL 964 entry. The entries in the .rel.plt section 965 really apply to the .got section, which we 966 created ourselves and so know is not readonly. */ 967 outname = bfd_get_section_name (output_bfd, 968 s->output_section); 969 target = bfd_get_section_by_name (output_bfd, outname + 4); 970 if (target != NULL 971 && (target->flags & SEC_READONLY) != 0) 972 reltext = true; 973 } 974 975 /* We use the reloc_count field as a counter if we need 976 to copy relocs into the output file. */ 977 s->reloc_count = 0; 978 } 979 } 980 else if (strncmp (name, ".got", 4) != 0) 981 { 982 /* It's not one of our sections, so don't allocate space. */ 983 continue; 984 } 985 986 if (strip) 987 { 988 asection **spp; 989 990 for (spp = &s->output_section->owner->sections; 991 *spp != s->output_section; 992 spp = &(*spp)->next) 993 ; 994 *spp = s->output_section->next; 995 --s->output_section->owner->section_count; 996 997 continue; 998 } 999 1000 /* Allocate memory for the section contents. */ 1001 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size); 1002 if (s->contents == NULL && s->_raw_size != 0) 1003 return false; 1004 } 1005 1006 if (elf_hash_table (info)->dynamic_sections_created) 1007 { 1008 /* Add some entries to the .dynamic section. We fill in the 1009 values later, in elf_i386_finish_dynamic_sections, but we 1010 must add the entries now so that we get the correct size for 1011 the .dynamic section. The DT_DEBUG entry is filled in by the 1012 dynamic linker and used by the debugger. */ 1013 if (! info->shared) 1014 { 1015 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0)) 1016 return false; 1017 } 1018 1019 if (plt) 1020 { 1021 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0) 1022 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0) 1023 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL) 1024 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0)) 1025 return false; 1026 } 1027 1028 if (relocs) 1029 { 1030 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0) 1031 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0) 1032 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT, 1033 sizeof (Elf32_External_Rel))) 1034 return false; 1035 } 1036 1037 if (reltext) 1038 { 1039 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0)) 1040 return false; 1041 } 1042 } 1043 1044 return true; 1045} 1046 1047/* This function is called via elf_i386_link_hash_traverse if we are 1048 creating a shared object with -Bsymbolic. It discards the space 1049 allocated to copy PC relative relocs against symbols which are 1050 defined in regular objects. We allocated space for them in the 1051 check_relocs routine, but we won't fill them in in the 1052 relocate_section routine. */ 1053 1054/*ARGSUSED*/ 1055static boolean 1056elf_i386_discard_copies (h, ignore) 1057 struct elf_i386_link_hash_entry *h; 1058 PTR ignore; 1059{ 1060 struct elf_i386_pcrel_relocs_copied *s; 1061 1062 /* We only discard relocs for symbols defined in a regular object. */ 1063 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1064 return true; 1065 1066 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next) 1067 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel); 1068 1069 return true; 1070} 1071 1072/* Relocate an i386 ELF section. */ 1073 1074static boolean 1075elf_i386_relocate_section (output_bfd, info, input_bfd, input_section, 1076 contents, relocs, local_syms, local_sections) 1077 bfd *output_bfd; 1078 struct bfd_link_info *info; 1079 bfd *input_bfd; 1080 asection *input_section; 1081 bfd_byte *contents; 1082 Elf_Internal_Rela *relocs; 1083 Elf_Internal_Sym *local_syms; 1084 asection **local_sections; 1085{ 1086 bfd *dynobj; 1087 Elf_Internal_Shdr *symtab_hdr; 1088 struct elf_link_hash_entry **sym_hashes; 1089 bfd_vma *local_got_offsets; 1090 asection *sgot; 1091 asection *splt; 1092 asection *sreloc; 1093 Elf_Internal_Rela *rel; 1094 Elf_Internal_Rela *relend; 1095 1096 dynobj = elf_hash_table (info)->dynobj; 1097 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1098 sym_hashes = elf_sym_hashes (input_bfd); 1099 local_got_offsets = elf_local_got_offsets (input_bfd); 1100 1101 sgot = NULL; 1102 splt = NULL; 1103 sreloc = NULL; 1104 1105 rel = relocs; 1106 relend = relocs + input_section->reloc_count; 1107 for (; rel < relend; rel++) 1108 { 1109 int r_type; 1110 reloc_howto_type *howto; 1111 unsigned long r_symndx; 1112 struct elf_link_hash_entry *h; 1113 Elf_Internal_Sym *sym; 1114 asection *sec; 1115 bfd_vma relocation; 1116 bfd_reloc_status_type r; 1117 1118 r_type = ELF32_R_TYPE (rel->r_info); 1119 if (r_type < 0 1120 || r_type >= (int) R_386_max 1121 || (r_type >= (int) FIRST_INVALID_RELOC 1122 && r_type <= (int) LAST_INVALID_RELOC)) 1123 { 1124 bfd_set_error (bfd_error_bad_value); 1125 return false; 1126 } 1127 howto = elf_howto_table + r_type; 1128 1129 r_symndx = ELF32_R_SYM (rel->r_info); 1130 1131 if (info->relocateable) 1132 { 1133 /* This is a relocateable link. We don't have to change 1134 anything, unless the reloc is against a section symbol, 1135 in which case we have to adjust according to where the 1136 section symbol winds up in the output section. */ 1137 if (r_symndx < symtab_hdr->sh_info) 1138 { 1139 sym = local_syms + r_symndx; 1140 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1141 { 1142 bfd_vma val; 1143 1144 sec = local_sections[r_symndx]; 1145 val = bfd_get_32 (input_bfd, contents + rel->r_offset); 1146 val += sec->output_offset + sym->st_value; 1147 bfd_put_32 (input_bfd, val, contents + rel->r_offset); 1148 } 1149 } 1150 1151 continue; 1152 } 1153 1154 /* This is a final link. */ 1155 h = NULL; 1156 sym = NULL; 1157 sec = NULL; 1158 if (r_symndx < symtab_hdr->sh_info) 1159 { 1160 sym = local_syms + r_symndx; 1161 sec = local_sections[r_symndx]; 1162 relocation = (sec->output_section->vma 1163 + sec->output_offset 1164 + sym->st_value); 1165 } 1166 else 1167 { 1168 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1169 while (h->root.type == bfd_link_hash_indirect 1170 || h->root.type == bfd_link_hash_warning) 1171 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1172 if (h->root.type == bfd_link_hash_defined 1173 || h->root.type == bfd_link_hash_defweak) 1174 { 1175 sec = h->root.u.def.section; 1176 if (r_type == R_386_GOTPC 1177 || (r_type == R_386_PLT32 1178 && h->plt_offset != (bfd_vma) -1) 1179 || (r_type == R_386_GOT32 1180 && elf_hash_table (info)->dynamic_sections_created 1181 && (! info->shared 1182 || ! info->symbolic 1183 || (h->elf_link_hash_flags 1184 & ELF_LINK_HASH_DEF_REGULAR) == 0)) 1185 || (info->shared 1186 && (! info->symbolic 1187 || (h->elf_link_hash_flags 1188 & ELF_LINK_HASH_DEF_REGULAR) == 0) 1189 && (r_type == R_386_32 1190 || r_type == R_386_PC32))) 1191 { 1192 /* In these cases, we don't need the relocation 1193 value. We check specially because in some 1194 obscure cases sec->output_section will be NULL. */ 1195 relocation = 0; 1196 } 1197 else if (sec->output_section == NULL) 1198 { 1199 (*_bfd_error_handler) 1200 ("%s: warning: unresolvable relocation against symbol `%s' from %s section", 1201 bfd_get_filename (input_bfd), h->root.root.string, 1202 bfd_get_section_name (input_bfd, input_section)); 1203 relocation = 0; 1204 } 1205 else 1206 relocation = (h->root.u.def.value 1207 + sec->output_section->vma 1208 + sec->output_offset); 1209 } 1210 else if (h->root.type == bfd_link_hash_undefweak) 1211 relocation = 0; 1212 else if (info->shared && !info->symbolic) 1213 relocation = 0; 1214 else 1215 { 1216 if (! ((*info->callbacks->undefined_symbol) 1217 (info, h->root.root.string, input_bfd, 1218 input_section, rel->r_offset))) 1219 return false; 1220 relocation = 0; 1221 } 1222 } 1223 1224 switch (r_type) 1225 { 1226 case R_386_GOT32: 1227 /* Relocation is to the entry for this symbol in the global 1228 offset table. */ 1229 if (sgot == NULL) 1230 { 1231 sgot = bfd_get_section_by_name (dynobj, ".got"); 1232 BFD_ASSERT (sgot != NULL); 1233 } 1234 1235 if (h != NULL) 1236 { 1237 bfd_vma off; 1238 1239 off = h->got_offset; 1240 BFD_ASSERT (off != (bfd_vma) -1); 1241 1242 if (! elf_hash_table (info)->dynamic_sections_created 1243 || (info->shared 1244 && info->symbolic 1245 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) 1246 { 1247 /* This is actually a static link, or it is a 1248 -Bsymbolic link and the symbol is defined 1249 locally. We must initialize this entry in the 1250 global offset table. Since the offset must 1251 always be a multiple of 4, we use the least 1252 significant bit to record whether we have 1253 initialized it already. 1254 1255 When doing a dynamic link, we create a .rel.got 1256 relocation entry to initialize the value. This 1257 is done in the finish_dynamic_symbol routine. */ 1258 if ((off & 1) != 0) 1259 off &= ~1; 1260 else 1261 { 1262 bfd_put_32 (output_bfd, relocation, 1263 sgot->contents + off); 1264 h->got_offset |= 1; 1265 } 1266 } 1267 1268 relocation = sgot->output_offset + off; 1269 } 1270 else 1271 { 1272 bfd_vma off; 1273 1274 BFD_ASSERT (local_got_offsets != NULL 1275 && local_got_offsets[r_symndx] != (bfd_vma) -1); 1276 1277 off = local_got_offsets[r_symndx]; 1278 1279 /* The offset must always be a multiple of 4. We use 1280 the least significant bit to record whether we have 1281 already generated the necessary reloc. */ 1282 if ((off & 1) != 0) 1283 off &= ~1; 1284 else 1285 { 1286 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1287 1288 if (info->shared) 1289 { 1290 asection *srelgot; 1291 Elf_Internal_Rel outrel; 1292 1293 srelgot = bfd_get_section_by_name (dynobj, ".rel.got"); 1294 BFD_ASSERT (srelgot != NULL); 1295 1296 outrel.r_offset = (sgot->output_section->vma 1297 + sgot->output_offset 1298 + off); 1299 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1300 bfd_elf32_swap_reloc_out (output_bfd, &outrel, 1301 (((Elf32_External_Rel *) 1302 srelgot->contents) 1303 + srelgot->reloc_count)); 1304 ++srelgot->reloc_count; 1305 } 1306 1307 local_got_offsets[r_symndx] |= 1; 1308 } 1309 1310 relocation = sgot->output_offset + off; 1311 } 1312 1313 break; 1314 1315 case R_386_GOTOFF: 1316 /* Relocation is relative to the start of the global offset 1317 table. */ 1318 1319 if (sgot == NULL) 1320 { 1321 sgot = bfd_get_section_by_name (dynobj, ".got"); 1322 BFD_ASSERT (sgot != NULL); 1323 } 1324 1325 /* Note that sgot->output_offset is not involved in this 1326 calculation. We always want the start of .got. If we 1327 defined _GLOBAL_OFFSET_TABLE in a different way, as is 1328 permitted by the ABI, we might have to change this 1329 calculation. */ 1330 relocation -= sgot->output_section->vma; 1331 1332 break; 1333 1334 case R_386_GOTPC: 1335 /* Use global offset table as symbol value. */ 1336 1337 if (sgot == NULL) 1338 { 1339 sgot = bfd_get_section_by_name (dynobj, ".got"); 1340 BFD_ASSERT (sgot != NULL); 1341 } 1342 1343 relocation = sgot->output_section->vma; 1344 1345 break; 1346 1347 case R_386_PLT32: 1348 /* Relocation is to the entry for this symbol in the 1349 procedure linkage table. */ 1350 1351 /* Resolve a PLT32 reloc again a local symbol directly, 1352 without using the procedure linkage table. */ 1353 if (h == NULL) 1354 break; 1355 1356 if (h->plt_offset == (bfd_vma) -1) 1357 { 1358 /* We didn't make a PLT entry for this symbol. This 1359 happens when statically linking PIC code, or when 1360 using -Bsymbolic. */ 1361 break; 1362 } 1363 1364 if (splt == NULL) 1365 { 1366 splt = bfd_get_section_by_name (dynobj, ".plt"); 1367 BFD_ASSERT (splt != NULL); 1368 } 1369 1370 relocation = (splt->output_section->vma 1371 + splt->output_offset 1372 + h->plt_offset); 1373 1374 break; 1375 1376 case R_386_32: 1377 case R_386_PC32: 1378 if (info->shared 1379 && (r_type != R_386_PC32 1380 || (h != NULL 1381 && (! info->symbolic 1382 || (h->elf_link_hash_flags 1383 & ELF_LINK_HASH_DEF_REGULAR) == 0)))) 1384 { 1385 Elf_Internal_Rel outrel; 1386 boolean skip, relocate; 1387 1388 /* When generating a shared object, these relocations 1389 are copied into the output file to be resolved at run 1390 time. */ 1391 1392 if (sreloc == NULL) 1393 { 1394 const char *name; 1395 1396 name = (bfd_elf_string_from_elf_section 1397 (input_bfd, 1398 elf_elfheader (input_bfd)->e_shstrndx, 1399 elf_section_data (input_section)->rel_hdr.sh_name)); 1400 if (name == NULL) 1401 return false; 1402 1403 BFD_ASSERT (strncmp (name, ".rel", 4) == 0 1404 && strcmp (bfd_get_section_name (input_bfd, 1405 input_section), 1406 name + 4) == 0); 1407 1408 sreloc = bfd_get_section_by_name (dynobj, name); 1409 BFD_ASSERT (sreloc != NULL); 1410 } 1411 1412 skip = false; 1413 1414 if (elf_section_data (input_section)->stab_info == NULL) 1415 outrel.r_offset = rel->r_offset; 1416 else 1417 { 1418 bfd_vma off; 1419 1420 off = (_bfd_stab_section_offset 1421 (output_bfd, &elf_hash_table (info)->stab_info, 1422 input_section, 1423 &elf_section_data (input_section)->stab_info, 1424 rel->r_offset)); 1425 if (off == (bfd_vma) -1) 1426 skip = true; 1427 outrel.r_offset = off; 1428 } 1429 1430 outrel.r_offset += (input_section->output_section->vma 1431 + input_section->output_offset); 1432 1433 if (skip) 1434 { 1435 memset (&outrel, 0, sizeof outrel); 1436 relocate = false; 1437 } 1438 else if (r_type == R_386_PC32) 1439 { 1440 BFD_ASSERT (h != NULL && h->dynindx != -1); 1441 relocate = false; 1442 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32); 1443 } 1444 else 1445 { 1446 /* h->dynindx may be -1 if this symbol was marked to 1447 become local. */ 1448 if (h == NULL 1449 || ((info->symbolic || h->dynindx == -1) 1450 && (h->elf_link_hash_flags 1451 & ELF_LINK_HASH_DEF_REGULAR) != 0)) 1452 { 1453 relocate = true; 1454 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1455 } 1456 else 1457 { 1458 BFD_ASSERT (h->dynindx != -1); 1459 relocate = false; 1460 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32); 1461 } 1462 } 1463 1464 bfd_elf32_swap_reloc_out (output_bfd, &outrel, 1465 (((Elf32_External_Rel *) 1466 sreloc->contents) 1467 + sreloc->reloc_count)); 1468 ++sreloc->reloc_count; 1469 1470 /* If this reloc is against an external symbol, we do 1471 not want to fiddle with the addend. Otherwise, we 1472 need to include the symbol value so that it becomes 1473 an addend for the dynamic reloc. */ 1474 if (! relocate) 1475 continue; 1476 } 1477 1478 break; 1479 1480 default: 1481 break; 1482 } 1483 1484 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 1485 contents, rel->r_offset, 1486 relocation, (bfd_vma) 0); 1487 1488 if (r != bfd_reloc_ok) 1489 { 1490 switch (r) 1491 { 1492 default: 1493 case bfd_reloc_outofrange: 1494 abort (); 1495 case bfd_reloc_overflow: 1496 { 1497 const char *name; 1498 1499 if (h != NULL) 1500 name = h->root.root.string; 1501 else 1502 { 1503 name = bfd_elf_string_from_elf_section (input_bfd, 1504 symtab_hdr->sh_link, 1505 sym->st_name); 1506 if (name == NULL) 1507 return false; 1508 if (*name == '\0') 1509 name = bfd_section_name (input_bfd, sec); 1510 } 1511 if (! ((*info->callbacks->reloc_overflow) 1512 (info, name, howto->name, (bfd_vma) 0, 1513 input_bfd, input_section, rel->r_offset))) 1514 return false; 1515 } 1516 break; 1517 } 1518 } 1519 } 1520 1521 return true; 1522} 1523 1524/* Finish up dynamic symbol handling. We set the contents of various 1525 dynamic sections here. */ 1526 1527static boolean 1528elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym) 1529 bfd *output_bfd; 1530 struct bfd_link_info *info; 1531 struct elf_link_hash_entry *h; 1532 Elf_Internal_Sym *sym; 1533{ 1534 bfd *dynobj; 1535 1536 dynobj = elf_hash_table (info)->dynobj; 1537 1538 if (h->plt_offset != (bfd_vma) -1) 1539 { 1540 asection *splt; 1541 asection *sgot; 1542 asection *srel; 1543 bfd_vma plt_index; 1544 bfd_vma got_offset; 1545 Elf_Internal_Rel rel; 1546 1547 /* This symbol has an entry in the procedure linkage table. Set 1548 it up. */ 1549 1550 BFD_ASSERT (h->dynindx != -1); 1551 1552 splt = bfd_get_section_by_name (dynobj, ".plt"); 1553 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 1554 srel = bfd_get_section_by_name (dynobj, ".rel.plt"); 1555 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL); 1556 1557 /* Get the index in the procedure linkage table which 1558 corresponds to this symbol. This is the index of this symbol 1559 in all the symbols for which we are making plt entries. The 1560 first entry in the procedure linkage table is reserved. */ 1561 plt_index = h->plt_offset / PLT_ENTRY_SIZE - 1; 1562 1563 /* Get the offset into the .got table of the entry that 1564 corresponds to this function. Each .got entry is 4 bytes. 1565 The first three are reserved. */ 1566 got_offset = (plt_index + 3) * 4; 1567 1568 /* Fill in the entry in the procedure linkage table. */ 1569 if (! info->shared) 1570 { 1571 memcpy (splt->contents + h->plt_offset, elf_i386_plt_entry, 1572 PLT_ENTRY_SIZE); 1573 bfd_put_32 (output_bfd, 1574 (sgot->output_section->vma 1575 + sgot->output_offset 1576 + got_offset), 1577 splt->contents + h->plt_offset + 2); 1578 } 1579 else 1580 { 1581 memcpy (splt->contents + h->plt_offset, elf_i386_pic_plt_entry, 1582 PLT_ENTRY_SIZE); 1583 bfd_put_32 (output_bfd, got_offset, 1584 splt->contents + h->plt_offset + 2); 1585 } 1586 1587 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel), 1588 splt->contents + h->plt_offset + 7); 1589 bfd_put_32 (output_bfd, - (h->plt_offset + PLT_ENTRY_SIZE), 1590 splt->contents + h->plt_offset + 12); 1591 1592 /* Fill in the entry in the global offset table. */ 1593 bfd_put_32 (output_bfd, 1594 (splt->output_section->vma 1595 + splt->output_offset 1596 + h->plt_offset 1597 + 6), 1598 sgot->contents + got_offset); 1599 1600 /* Fill in the entry in the .rel.plt section. */ 1601 rel.r_offset = (sgot->output_section->vma 1602 + sgot->output_offset 1603 + got_offset); 1604 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT); 1605 bfd_elf32_swap_reloc_out (output_bfd, &rel, 1606 ((Elf32_External_Rel *) srel->contents 1607 + plt_index)); 1608 1609 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1610 { 1611 /* Mark the symbol as undefined, rather than as defined in 1612 the .plt section. Leave the value alone. */ 1613 sym->st_shndx = SHN_UNDEF; 1614 } 1615 } 1616 1617 if (h->got_offset != (bfd_vma) -1) 1618 { 1619 asection *sgot; 1620 asection *srel; 1621 Elf_Internal_Rel rel; 1622 1623 /* This symbol has an entry in the global offset table. Set it 1624 up. */ 1625 1626 BFD_ASSERT (h->dynindx != -1); 1627 1628 sgot = bfd_get_section_by_name (dynobj, ".got"); 1629 srel = bfd_get_section_by_name (dynobj, ".rel.got"); 1630 BFD_ASSERT (sgot != NULL && srel != NULL); 1631 1632 rel.r_offset = (sgot->output_section->vma 1633 + sgot->output_offset 1634 + (h->got_offset &~ 1)); 1635 1636 /* If this is a -Bsymbolic link, and the symbol is defined 1637 locally, we just want to emit a RELATIVE reloc. The entry in 1638 the global offset table will already have been initialized in 1639 the relocate_section function. */ 1640 if (info->shared 1641 && info->symbolic 1642 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) 1643 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1644 else 1645 { 1646 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset); 1647 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT); 1648 } 1649 1650 bfd_elf32_swap_reloc_out (output_bfd, &rel, 1651 ((Elf32_External_Rel *) srel->contents 1652 + srel->reloc_count)); 1653 ++srel->reloc_count; 1654 } 1655 1656 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) 1657 { 1658 asection *s; 1659 Elf_Internal_Rel rel; 1660 1661 /* This symbol needs a copy reloc. Set it up. */ 1662 1663 BFD_ASSERT (h->dynindx != -1 1664 && (h->root.type == bfd_link_hash_defined 1665 || h->root.type == bfd_link_hash_defweak)); 1666 1667 s = bfd_get_section_by_name (h->root.u.def.section->owner, 1668 ".rel.bss"); 1669 BFD_ASSERT (s != NULL); 1670 1671 rel.r_offset = (h->root.u.def.value 1672 + h->root.u.def.section->output_section->vma 1673 + h->root.u.def.section->output_offset); 1674 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY); 1675 bfd_elf32_swap_reloc_out (output_bfd, &rel, 1676 ((Elf32_External_Rel *) s->contents 1677 + s->reloc_count)); 1678 ++s->reloc_count; 1679 } 1680 1681 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 1682 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 1683 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1684 sym->st_shndx = SHN_ABS; 1685 1686 return true; 1687} 1688 1689/* Finish up the dynamic sections. */ 1690 1691static boolean 1692elf_i386_finish_dynamic_sections (output_bfd, info) 1693 bfd *output_bfd; 1694 struct bfd_link_info *info; 1695{ 1696 bfd *dynobj; 1697 asection *sgot; 1698 asection *sdyn; 1699 1700 dynobj = elf_hash_table (info)->dynobj; 1701 1702 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 1703 BFD_ASSERT (sgot != NULL); 1704 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 1705 1706 if (elf_hash_table (info)->dynamic_sections_created) 1707 { 1708 asection *splt; 1709 Elf32_External_Dyn *dyncon, *dynconend; 1710 1711 splt = bfd_get_section_by_name (dynobj, ".plt"); 1712 BFD_ASSERT (splt != NULL && sdyn != NULL); 1713 1714 dyncon = (Elf32_External_Dyn *) sdyn->contents; 1715 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 1716 for (; dyncon < dynconend; dyncon++) 1717 { 1718 Elf_Internal_Dyn dyn; 1719 const char *name; 1720 asection *s; 1721 1722 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 1723 1724 switch (dyn.d_tag) 1725 { 1726 default: 1727 break; 1728 1729 case DT_PLTGOT: 1730 name = ".got"; 1731 goto get_vma; 1732 case DT_JMPREL: 1733 name = ".rel.plt"; 1734 get_vma: 1735 s = bfd_get_section_by_name (output_bfd, name); 1736 BFD_ASSERT (s != NULL); 1737 dyn.d_un.d_ptr = s->vma; 1738 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1739 break; 1740 1741 case DT_PLTRELSZ: 1742 s = bfd_get_section_by_name (output_bfd, ".rel.plt"); 1743 BFD_ASSERT (s != NULL); 1744 if (s->_cooked_size != 0) 1745 dyn.d_un.d_val = s->_cooked_size; 1746 else 1747 dyn.d_un.d_val = s->_raw_size; 1748 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1749 break; 1750 1751 case DT_RELSZ: 1752 /* My reading of the SVR4 ABI indicates that the 1753 procedure linkage table relocs (DT_JMPREL) should be 1754 included in the overall relocs (DT_REL). This is 1755 what Solaris does. However, UnixWare can not handle 1756 that case. Therefore, we override the DT_RELSZ entry 1757 here to make it not include the JMPREL relocs. Since 1758 the linker script arranges for .rel.plt to follow all 1759 other relocation sections, we don't have to worry 1760 about changing the DT_REL entry. */ 1761 s = bfd_get_section_by_name (output_bfd, ".rel.plt"); 1762 if (s != NULL) 1763 { 1764 if (s->_cooked_size != 0) 1765 dyn.d_un.d_val -= s->_cooked_size; 1766 else 1767 dyn.d_un.d_val -= s->_raw_size; 1768 } 1769 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1770 break; 1771 } 1772 } 1773 1774 /* Fill in the first entry in the procedure linkage table. */ 1775 if (splt->_raw_size > 0) 1776 { 1777 if (info->shared) 1778 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE); 1779 else 1780 { 1781 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE); 1782 bfd_put_32 (output_bfd, 1783 sgot->output_section->vma + sgot->output_offset + 4, 1784 splt->contents + 2); 1785 bfd_put_32 (output_bfd, 1786 sgot->output_section->vma + sgot->output_offset + 8, 1787 splt->contents + 8); 1788 } 1789 } 1790 1791 /* UnixWare sets the entsize of .plt to 4, although that doesn't 1792 really seem like the right value. */ 1793 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4; 1794 } 1795 1796 /* Fill in the first three entries in the global offset table. */ 1797 if (sgot->_raw_size > 0) 1798 { 1799 if (sdyn == NULL) 1800 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 1801 else 1802 bfd_put_32 (output_bfd, 1803 sdyn->output_section->vma + sdyn->output_offset, 1804 sgot->contents); 1805 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 1806 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 1807 } 1808 1809 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 1810 1811 return true; 1812} 1813 1814#define TARGET_LITTLE_SYM bfd_elf32_i386_vec 1815#define TARGET_LITTLE_NAME "elf32-i386" 1816#define ELF_ARCH bfd_arch_i386 1817#define ELF_MACHINE_CODE EM_386 1818#define ELF_MAXPAGESIZE 0x1000 1819#define elf_info_to_howto elf_i386_info_to_howto 1820#define elf_info_to_howto_rel elf_i386_info_to_howto_rel 1821#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup 1822#define bfd_elf32_bfd_is_local_label_name \ 1823 elf_i386_is_local_label_name 1824#define elf_backend_create_dynamic_sections \ 1825 _bfd_elf_create_dynamic_sections 1826#define bfd_elf32_bfd_link_hash_table_create \ 1827 elf_i386_link_hash_table_create 1828#define elf_backend_check_relocs elf_i386_check_relocs 1829#define elf_backend_adjust_dynamic_symbol \ 1830 elf_i386_adjust_dynamic_symbol 1831#define elf_backend_size_dynamic_sections \ 1832 elf_i386_size_dynamic_sections 1833#define elf_backend_relocate_section elf_i386_relocate_section 1834#define elf_backend_finish_dynamic_symbol \ 1835 elf_i386_finish_dynamic_symbol 1836#define elf_backend_finish_dynamic_sections \ 1837 elf_i386_finish_dynamic_sections 1838#define elf_backend_want_got_plt 1 1839#define elf_backend_plt_readonly 1 1840#define elf_backend_want_plt_sym 0 1841 1842#include "elf32-target.h" 1843