elf32-i386.c revision 38891
1/* Intel 80386/80486-specific support for 32-bit ELF 2 Copyright 1993-1997, 1998 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 which is in memory at run time, then 964 we probably need a DT_TEXTREL entry. The entries 965 in the .rel.plt section really apply to the 966 .got section, which we created ourselves and so 967 know is not readonly. */ 968 outname = bfd_get_section_name (output_bfd, 969 s->output_section); 970 target = bfd_get_section_by_name (output_bfd, outname + 4); 971 if (target != NULL 972 && (target->flags & SEC_READONLY) != 0 973 && (target->flags & SEC_ALLOC) != 0) 974 reltext = true; 975 } 976 977 /* We use the reloc_count field as a counter if we need 978 to copy relocs into the output file. */ 979 s->reloc_count = 0; 980 } 981 } 982 else if (strncmp (name, ".got", 4) != 0) 983 { 984 /* It's not one of our sections, so don't allocate space. */ 985 continue; 986 } 987 988 if (strip) 989 { 990 asection **spp; 991 992 for (spp = &s->output_section->owner->sections; 993 *spp != s->output_section; 994 spp = &(*spp)->next) 995 ; 996 *spp = s->output_section->next; 997 --s->output_section->owner->section_count; 998 999 continue; 1000 } 1001 1002 /* Allocate memory for the section contents. */ 1003 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size); 1004 if (s->contents == NULL && s->_raw_size != 0) 1005 return false; 1006 } 1007 1008 if (elf_hash_table (info)->dynamic_sections_created) 1009 { 1010 /* Add some entries to the .dynamic section. We fill in the 1011 values later, in elf_i386_finish_dynamic_sections, but we 1012 must add the entries now so that we get the correct size for 1013 the .dynamic section. The DT_DEBUG entry is filled in by the 1014 dynamic linker and used by the debugger. */ 1015 if (! info->shared) 1016 { 1017 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0)) 1018 return false; 1019 } 1020 1021 if (plt) 1022 { 1023 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0) 1024 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0) 1025 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL) 1026 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0)) 1027 return false; 1028 } 1029 1030 if (relocs) 1031 { 1032 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0) 1033 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0) 1034 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT, 1035 sizeof (Elf32_External_Rel))) 1036 return false; 1037 } 1038 1039 if (reltext) 1040 { 1041 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0)) 1042 return false; 1043 } 1044 } 1045 1046 return true; 1047} 1048 1049/* This function is called via elf_i386_link_hash_traverse if we are 1050 creating a shared object with -Bsymbolic. It discards the space 1051 allocated to copy PC relative relocs against symbols which are 1052 defined in regular objects. We allocated space for them in the 1053 check_relocs routine, but we won't fill them in in the 1054 relocate_section routine. */ 1055 1056/*ARGSUSED*/ 1057static boolean 1058elf_i386_discard_copies (h, ignore) 1059 struct elf_i386_link_hash_entry *h; 1060 PTR ignore; 1061{ 1062 struct elf_i386_pcrel_relocs_copied *s; 1063 1064 /* We only discard relocs for symbols defined in a regular object. */ 1065 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1066 return true; 1067 1068 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next) 1069 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel); 1070 1071 return true; 1072} 1073 1074/* Relocate an i386 ELF section. */ 1075 1076static boolean 1077elf_i386_relocate_section (output_bfd, info, input_bfd, input_section, 1078 contents, relocs, local_syms, local_sections) 1079 bfd *output_bfd; 1080 struct bfd_link_info *info; 1081 bfd *input_bfd; 1082 asection *input_section; 1083 bfd_byte *contents; 1084 Elf_Internal_Rela *relocs; 1085 Elf_Internal_Sym *local_syms; 1086 asection **local_sections; 1087{ 1088 bfd *dynobj; 1089 Elf_Internal_Shdr *symtab_hdr; 1090 struct elf_link_hash_entry **sym_hashes; 1091 bfd_vma *local_got_offsets; 1092 asection *sgot; 1093 asection *splt; 1094 asection *sreloc; 1095 Elf_Internal_Rela *rel; 1096 Elf_Internal_Rela *relend; 1097 1098 dynobj = elf_hash_table (info)->dynobj; 1099 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1100 sym_hashes = elf_sym_hashes (input_bfd); 1101 local_got_offsets = elf_local_got_offsets (input_bfd); 1102 1103 sgot = NULL; 1104 splt = NULL; 1105 sreloc = NULL; 1106 1107 rel = relocs; 1108 relend = relocs + input_section->reloc_count; 1109 for (; rel < relend; rel++) 1110 { 1111 int r_type; 1112 reloc_howto_type *howto; 1113 unsigned long r_symndx; 1114 struct elf_link_hash_entry *h; 1115 Elf_Internal_Sym *sym; 1116 asection *sec; 1117 bfd_vma relocation; 1118 bfd_reloc_status_type r; 1119 1120 r_type = ELF32_R_TYPE (rel->r_info); 1121 if (r_type < 0 1122 || r_type >= (int) R_386_max 1123 || (r_type >= (int) FIRST_INVALID_RELOC 1124 && r_type <= (int) LAST_INVALID_RELOC)) 1125 { 1126 bfd_set_error (bfd_error_bad_value); 1127 return false; 1128 } 1129 howto = elf_howto_table + r_type; 1130 1131 r_symndx = ELF32_R_SYM (rel->r_info); 1132 1133 if (info->relocateable) 1134 { 1135 /* This is a relocateable link. We don't have to change 1136 anything, unless the reloc is against a section symbol, 1137 in which case we have to adjust according to where the 1138 section symbol winds up in the output section. */ 1139 if (r_symndx < symtab_hdr->sh_info) 1140 { 1141 sym = local_syms + r_symndx; 1142 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1143 { 1144 bfd_vma val; 1145 1146 sec = local_sections[r_symndx]; 1147 val = bfd_get_32 (input_bfd, contents + rel->r_offset); 1148 val += sec->output_offset + sym->st_value; 1149 bfd_put_32 (input_bfd, val, contents + rel->r_offset); 1150 } 1151 } 1152 1153 continue; 1154 } 1155 1156 /* This is a final link. */ 1157 h = NULL; 1158 sym = NULL; 1159 sec = NULL; 1160 if (r_symndx < symtab_hdr->sh_info) 1161 { 1162 sym = local_syms + r_symndx; 1163 sec = local_sections[r_symndx]; 1164 relocation = (sec->output_section->vma 1165 + sec->output_offset 1166 + sym->st_value); 1167 } 1168 else 1169 { 1170 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1171 while (h->root.type == bfd_link_hash_indirect 1172 || h->root.type == bfd_link_hash_warning) 1173 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1174 if (h->root.type == bfd_link_hash_defined 1175 || h->root.type == bfd_link_hash_defweak) 1176 { 1177 sec = h->root.u.def.section; 1178 if (r_type == R_386_GOTPC 1179 || (r_type == R_386_PLT32 1180 && h->plt_offset != (bfd_vma) -1) 1181 || (r_type == R_386_GOT32 1182 && elf_hash_table (info)->dynamic_sections_created 1183 && (! info->shared 1184 || (! info->symbolic && h->dynindx != -1) 1185 || (h->elf_link_hash_flags 1186 & ELF_LINK_HASH_DEF_REGULAR) == 0)) 1187 || (info->shared 1188 && ((! info->symbolic && h->dynindx != -1) 1189 || (h->elf_link_hash_flags 1190 & ELF_LINK_HASH_DEF_REGULAR) == 0) 1191 && (r_type == R_386_32 1192 || r_type == R_386_PC32) 1193 && (input_section->flags & SEC_ALLOC) != 0)) 1194 { 1195 /* In these cases, we don't need the relocation 1196 value. We check specially because in some 1197 obscure cases sec->output_section will be NULL. */ 1198 relocation = 0; 1199 } 1200 else if (sec->output_section == NULL) 1201 { 1202 (*_bfd_error_handler) 1203 ("%s: warning: unresolvable relocation against symbol `%s' from %s section", 1204 bfd_get_filename (input_bfd), h->root.root.string, 1205 bfd_get_section_name (input_bfd, input_section)); 1206 relocation = 0; 1207 } 1208 else 1209 relocation = (h->root.u.def.value 1210 + sec->output_section->vma 1211 + sec->output_offset); 1212 } 1213 else if (h->root.type == bfd_link_hash_undefweak) 1214 relocation = 0; 1215 else if (info->shared && !info->symbolic) 1216 relocation = 0; 1217 else 1218 { 1219 if (! ((*info->callbacks->undefined_symbol) 1220 (info, h->root.root.string, input_bfd, 1221 input_section, rel->r_offset))) 1222 return false; 1223 relocation = 0; 1224 } 1225 } 1226 1227 switch (r_type) 1228 { 1229 case R_386_GOT32: 1230 /* Relocation is to the entry for this symbol in the global 1231 offset table. */ 1232 if (sgot == NULL) 1233 { 1234 sgot = bfd_get_section_by_name (dynobj, ".got"); 1235 BFD_ASSERT (sgot != NULL); 1236 } 1237 1238 if (h != NULL) 1239 { 1240 bfd_vma off; 1241 1242 off = h->got_offset; 1243 BFD_ASSERT (off != (bfd_vma) -1); 1244 1245 if (! elf_hash_table (info)->dynamic_sections_created 1246 || (info->shared 1247 && (info->symbolic || h->dynindx == -1) 1248 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) 1249 { 1250 /* This is actually a static link, or it is a 1251 -Bsymbolic link and the symbol is defined 1252 locally, or the symbol was forced to be local 1253 because of a version file. We must initialize 1254 this entry in the global offset table. Since the 1255 offset must always be a multiple of 4, we use the 1256 least significant bit to record whether we have 1257 initialized it already. 1258 1259 When doing a dynamic link, we create a .rel.got 1260 relocation entry to initialize the value. This 1261 is done in the finish_dynamic_symbol routine. */ 1262 if ((off & 1) != 0) 1263 off &= ~1; 1264 else 1265 { 1266 bfd_put_32 (output_bfd, relocation, 1267 sgot->contents + off); 1268 h->got_offset |= 1; 1269 } 1270 } 1271 1272 relocation = sgot->output_offset + off; 1273 } 1274 else 1275 { 1276 bfd_vma off; 1277 1278 BFD_ASSERT (local_got_offsets != NULL 1279 && local_got_offsets[r_symndx] != (bfd_vma) -1); 1280 1281 off = local_got_offsets[r_symndx]; 1282 1283 /* The offset must always be a multiple of 4. We use 1284 the least significant bit to record whether we have 1285 already generated the necessary reloc. */ 1286 if ((off & 1) != 0) 1287 off &= ~1; 1288 else 1289 { 1290 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1291 1292 if (info->shared) 1293 { 1294 asection *srelgot; 1295 Elf_Internal_Rel outrel; 1296 1297 srelgot = bfd_get_section_by_name (dynobj, ".rel.got"); 1298 BFD_ASSERT (srelgot != NULL); 1299 1300 outrel.r_offset = (sgot->output_section->vma 1301 + sgot->output_offset 1302 + off); 1303 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1304 bfd_elf32_swap_reloc_out (output_bfd, &outrel, 1305 (((Elf32_External_Rel *) 1306 srelgot->contents) 1307 + srelgot->reloc_count)); 1308 ++srelgot->reloc_count; 1309 } 1310 1311 local_got_offsets[r_symndx] |= 1; 1312 } 1313 1314 relocation = sgot->output_offset + off; 1315 } 1316 1317 break; 1318 1319 case R_386_GOTOFF: 1320 /* Relocation is relative to the start of the global offset 1321 table. */ 1322 1323 if (sgot == NULL) 1324 { 1325 sgot = bfd_get_section_by_name (dynobj, ".got"); 1326 BFD_ASSERT (sgot != NULL); 1327 } 1328 1329 /* Note that sgot->output_offset is not involved in this 1330 calculation. We always want the start of .got. If we 1331 defined _GLOBAL_OFFSET_TABLE in a different way, as is 1332 permitted by the ABI, we might have to change this 1333 calculation. */ 1334 relocation -= sgot->output_section->vma; 1335 1336 break; 1337 1338 case R_386_GOTPC: 1339 /* Use global offset table as symbol value. */ 1340 1341 if (sgot == NULL) 1342 { 1343 sgot = bfd_get_section_by_name (dynobj, ".got"); 1344 BFD_ASSERT (sgot != NULL); 1345 } 1346 1347 relocation = sgot->output_section->vma; 1348 1349 break; 1350 1351 case R_386_PLT32: 1352 /* Relocation is to the entry for this symbol in the 1353 procedure linkage table. */ 1354 1355 /* Resolve a PLT32 reloc again a local symbol directly, 1356 without using the procedure linkage table. */ 1357 if (h == NULL) 1358 break; 1359 1360 if (h->plt_offset == (bfd_vma) -1) 1361 { 1362 /* We didn't make a PLT entry for this symbol. This 1363 happens when statically linking PIC code, or when 1364 using -Bsymbolic. */ 1365 break; 1366 } 1367 1368 if (splt == NULL) 1369 { 1370 splt = bfd_get_section_by_name (dynobj, ".plt"); 1371 BFD_ASSERT (splt != NULL); 1372 } 1373 1374 relocation = (splt->output_section->vma 1375 + splt->output_offset 1376 + h->plt_offset); 1377 1378 break; 1379 1380 case R_386_32: 1381 case R_386_PC32: 1382 if (info->shared 1383 && (r_type != R_386_PC32 1384 || (h != NULL 1385 && h->dynindx != -1 1386 && (! info->symbolic 1387 || (h->elf_link_hash_flags 1388 & ELF_LINK_HASH_DEF_REGULAR) == 0)))) 1389 { 1390 Elf_Internal_Rel outrel; 1391 boolean skip, relocate; 1392 1393 /* When generating a shared object, these relocations 1394 are copied into the output file to be resolved at run 1395 time. */ 1396 1397 if (sreloc == NULL) 1398 { 1399 const char *name; 1400 1401 name = (bfd_elf_string_from_elf_section 1402 (input_bfd, 1403 elf_elfheader (input_bfd)->e_shstrndx, 1404 elf_section_data (input_section)->rel_hdr.sh_name)); 1405 if (name == NULL) 1406 return false; 1407 1408 BFD_ASSERT (strncmp (name, ".rel", 4) == 0 1409 && strcmp (bfd_get_section_name (input_bfd, 1410 input_section), 1411 name + 4) == 0); 1412 1413 sreloc = bfd_get_section_by_name (dynobj, name); 1414 BFD_ASSERT (sreloc != NULL); 1415 } 1416 1417 skip = false; 1418 1419 if (elf_section_data (input_section)->stab_info == NULL) 1420 outrel.r_offset = rel->r_offset; 1421 else 1422 { 1423 bfd_vma off; 1424 1425 off = (_bfd_stab_section_offset 1426 (output_bfd, &elf_hash_table (info)->stab_info, 1427 input_section, 1428 &elf_section_data (input_section)->stab_info, 1429 rel->r_offset)); 1430 if (off == (bfd_vma) -1) 1431 skip = true; 1432 outrel.r_offset = off; 1433 } 1434 1435 outrel.r_offset += (input_section->output_section->vma 1436 + input_section->output_offset); 1437 1438 if (skip) 1439 { 1440 memset (&outrel, 0, sizeof outrel); 1441 relocate = false; 1442 } 1443 else if (r_type == R_386_PC32) 1444 { 1445 BFD_ASSERT (h != NULL && h->dynindx != -1); 1446 if ((input_section->flags & SEC_ALLOC) != 0) 1447 relocate = false; 1448 else 1449 relocate = true; 1450 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32); 1451 } 1452 else 1453 { 1454 /* h->dynindx may be -1 if this symbol was marked to 1455 become local. */ 1456 if (h == NULL 1457 || ((info->symbolic || h->dynindx == -1) 1458 && (h->elf_link_hash_flags 1459 & ELF_LINK_HASH_DEF_REGULAR) != 0)) 1460 { 1461 relocate = true; 1462 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1463 } 1464 else 1465 { 1466 BFD_ASSERT (h->dynindx != -1); 1467 if ((input_section->flags & SEC_ALLOC) != 0) 1468 relocate = false; 1469 else 1470 relocate = true; 1471 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32); 1472 } 1473 } 1474 1475 bfd_elf32_swap_reloc_out (output_bfd, &outrel, 1476 (((Elf32_External_Rel *) 1477 sreloc->contents) 1478 + sreloc->reloc_count)); 1479 ++sreloc->reloc_count; 1480 1481 /* If this reloc is against an external symbol, we do 1482 not want to fiddle with the addend. Otherwise, we 1483 need to include the symbol value so that it becomes 1484 an addend for the dynamic reloc. */ 1485 if (! relocate) 1486 continue; 1487 } 1488 1489 break; 1490 1491 default: 1492 break; 1493 } 1494 1495 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 1496 contents, rel->r_offset, 1497 relocation, (bfd_vma) 0); 1498 1499 if (r != bfd_reloc_ok) 1500 { 1501 switch (r) 1502 { 1503 default: 1504 case bfd_reloc_outofrange: 1505 abort (); 1506 case bfd_reloc_overflow: 1507 { 1508 const char *name; 1509 1510 if (h != NULL) 1511 name = h->root.root.string; 1512 else 1513 { 1514 name = bfd_elf_string_from_elf_section (input_bfd, 1515 symtab_hdr->sh_link, 1516 sym->st_name); 1517 if (name == NULL) 1518 return false; 1519 if (*name == '\0') 1520 name = bfd_section_name (input_bfd, sec); 1521 } 1522 if (! ((*info->callbacks->reloc_overflow) 1523 (info, name, howto->name, (bfd_vma) 0, 1524 input_bfd, input_section, rel->r_offset))) 1525 return false; 1526 } 1527 break; 1528 } 1529 } 1530 } 1531 1532 return true; 1533} 1534 1535/* Finish up dynamic symbol handling. We set the contents of various 1536 dynamic sections here. */ 1537 1538static boolean 1539elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym) 1540 bfd *output_bfd; 1541 struct bfd_link_info *info; 1542 struct elf_link_hash_entry *h; 1543 Elf_Internal_Sym *sym; 1544{ 1545 bfd *dynobj; 1546 1547 dynobj = elf_hash_table (info)->dynobj; 1548 1549 if (h->plt_offset != (bfd_vma) -1) 1550 { 1551 asection *splt; 1552 asection *sgot; 1553 asection *srel; 1554 bfd_vma plt_index; 1555 bfd_vma got_offset; 1556 Elf_Internal_Rel rel; 1557 1558 /* This symbol has an entry in the procedure linkage table. Set 1559 it up. */ 1560 1561 BFD_ASSERT (h->dynindx != -1); 1562 1563 splt = bfd_get_section_by_name (dynobj, ".plt"); 1564 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 1565 srel = bfd_get_section_by_name (dynobj, ".rel.plt"); 1566 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL); 1567 1568 /* Get the index in the procedure linkage table which 1569 corresponds to this symbol. This is the index of this symbol 1570 in all the symbols for which we are making plt entries. The 1571 first entry in the procedure linkage table is reserved. */ 1572 plt_index = h->plt_offset / PLT_ENTRY_SIZE - 1; 1573 1574 /* Get the offset into the .got table of the entry that 1575 corresponds to this function. Each .got entry is 4 bytes. 1576 The first three are reserved. */ 1577 got_offset = (plt_index + 3) * 4; 1578 1579 /* Fill in the entry in the procedure linkage table. */ 1580 if (! info->shared) 1581 { 1582 memcpy (splt->contents + h->plt_offset, elf_i386_plt_entry, 1583 PLT_ENTRY_SIZE); 1584 bfd_put_32 (output_bfd, 1585 (sgot->output_section->vma 1586 + sgot->output_offset 1587 + got_offset), 1588 splt->contents + h->plt_offset + 2); 1589 } 1590 else 1591 { 1592 memcpy (splt->contents + h->plt_offset, elf_i386_pic_plt_entry, 1593 PLT_ENTRY_SIZE); 1594 bfd_put_32 (output_bfd, got_offset, 1595 splt->contents + h->plt_offset + 2); 1596 } 1597 1598 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel), 1599 splt->contents + h->plt_offset + 7); 1600 bfd_put_32 (output_bfd, - (h->plt_offset + PLT_ENTRY_SIZE), 1601 splt->contents + h->plt_offset + 12); 1602 1603 /* Fill in the entry in the global offset table. */ 1604 bfd_put_32 (output_bfd, 1605 (splt->output_section->vma 1606 + splt->output_offset 1607 + h->plt_offset 1608 + 6), 1609 sgot->contents + got_offset); 1610 1611 /* Fill in the entry in the .rel.plt section. */ 1612 rel.r_offset = (sgot->output_section->vma 1613 + sgot->output_offset 1614 + got_offset); 1615 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT); 1616 bfd_elf32_swap_reloc_out (output_bfd, &rel, 1617 ((Elf32_External_Rel *) srel->contents 1618 + plt_index)); 1619 1620 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1621 { 1622 /* Mark the symbol as undefined, rather than as defined in 1623 the .plt section. Leave the value alone. */ 1624 sym->st_shndx = SHN_UNDEF; 1625 } 1626 } 1627 1628 if (h->got_offset != (bfd_vma) -1) 1629 { 1630 asection *sgot; 1631 asection *srel; 1632 Elf_Internal_Rel rel; 1633 1634 /* This symbol has an entry in the global offset table. Set it 1635 up. */ 1636 1637 sgot = bfd_get_section_by_name (dynobj, ".got"); 1638 srel = bfd_get_section_by_name (dynobj, ".rel.got"); 1639 BFD_ASSERT (sgot != NULL && srel != NULL); 1640 1641 rel.r_offset = (sgot->output_section->vma 1642 + sgot->output_offset 1643 + (h->got_offset &~ 1)); 1644 1645 /* If this is a -Bsymbolic link, and the symbol is defined 1646 locally, we just want to emit a RELATIVE reloc. Likewise if 1647 the symbol was forced to be local because of a version file. 1648 The entry in the global offset table will already have been 1649 initialized in the relocate_section function. */ 1650 if (info->shared 1651 && (info->symbolic || h->dynindx == -1) 1652 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) 1653 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1654 else 1655 { 1656 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset); 1657 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT); 1658 } 1659 1660 bfd_elf32_swap_reloc_out (output_bfd, &rel, 1661 ((Elf32_External_Rel *) srel->contents 1662 + srel->reloc_count)); 1663 ++srel->reloc_count; 1664 } 1665 1666 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) 1667 { 1668 asection *s; 1669 Elf_Internal_Rel rel; 1670 1671 /* This symbol needs a copy reloc. Set it up. */ 1672 1673 BFD_ASSERT (h->dynindx != -1 1674 && (h->root.type == bfd_link_hash_defined 1675 || h->root.type == bfd_link_hash_defweak)); 1676 1677 s = bfd_get_section_by_name (h->root.u.def.section->owner, 1678 ".rel.bss"); 1679 BFD_ASSERT (s != NULL); 1680 1681 rel.r_offset = (h->root.u.def.value 1682 + h->root.u.def.section->output_section->vma 1683 + h->root.u.def.section->output_offset); 1684 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY); 1685 bfd_elf32_swap_reloc_out (output_bfd, &rel, 1686 ((Elf32_External_Rel *) s->contents 1687 + s->reloc_count)); 1688 ++s->reloc_count; 1689 } 1690 1691 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 1692 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 1693 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1694 sym->st_shndx = SHN_ABS; 1695 1696 return true; 1697} 1698 1699/* Finish up the dynamic sections. */ 1700 1701static boolean 1702elf_i386_finish_dynamic_sections (output_bfd, info) 1703 bfd *output_bfd; 1704 struct bfd_link_info *info; 1705{ 1706 bfd *dynobj; 1707 asection *sgot; 1708 asection *sdyn; 1709 1710 dynobj = elf_hash_table (info)->dynobj; 1711 1712 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 1713 BFD_ASSERT (sgot != NULL); 1714 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 1715 1716 if (elf_hash_table (info)->dynamic_sections_created) 1717 { 1718 asection *splt; 1719 Elf32_External_Dyn *dyncon, *dynconend; 1720 1721 splt = bfd_get_section_by_name (dynobj, ".plt"); 1722 BFD_ASSERT (splt != NULL && sdyn != NULL); 1723 1724 dyncon = (Elf32_External_Dyn *) sdyn->contents; 1725 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 1726 for (; dyncon < dynconend; dyncon++) 1727 { 1728 Elf_Internal_Dyn dyn; 1729 const char *name; 1730 asection *s; 1731 1732 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 1733 1734 switch (dyn.d_tag) 1735 { 1736 default: 1737 break; 1738 1739 case DT_PLTGOT: 1740 name = ".got"; 1741 goto get_vma; 1742 case DT_JMPREL: 1743 name = ".rel.plt"; 1744 get_vma: 1745 s = bfd_get_section_by_name (output_bfd, name); 1746 BFD_ASSERT (s != NULL); 1747 dyn.d_un.d_ptr = s->vma; 1748 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1749 break; 1750 1751 case DT_PLTRELSZ: 1752 s = bfd_get_section_by_name (output_bfd, ".rel.plt"); 1753 BFD_ASSERT (s != NULL); 1754 if (s->_cooked_size != 0) 1755 dyn.d_un.d_val = s->_cooked_size; 1756 else 1757 dyn.d_un.d_val = s->_raw_size; 1758 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1759 break; 1760 1761 case DT_RELSZ: 1762 /* My reading of the SVR4 ABI indicates that the 1763 procedure linkage table relocs (DT_JMPREL) should be 1764 included in the overall relocs (DT_REL). This is 1765 what Solaris does. However, UnixWare can not handle 1766 that case. Therefore, we override the DT_RELSZ entry 1767 here to make it not include the JMPREL relocs. Since 1768 the linker script arranges for .rel.plt to follow all 1769 other relocation sections, we don't have to worry 1770 about changing the DT_REL entry. */ 1771 s = bfd_get_section_by_name (output_bfd, ".rel.plt"); 1772 if (s != NULL) 1773 { 1774 if (s->_cooked_size != 0) 1775 dyn.d_un.d_val -= s->_cooked_size; 1776 else 1777 dyn.d_un.d_val -= s->_raw_size; 1778 } 1779 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1780 break; 1781 } 1782 } 1783 1784 /* Fill in the first entry in the procedure linkage table. */ 1785 if (splt->_raw_size > 0) 1786 { 1787 if (info->shared) 1788 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE); 1789 else 1790 { 1791 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE); 1792 bfd_put_32 (output_bfd, 1793 sgot->output_section->vma + sgot->output_offset + 4, 1794 splt->contents + 2); 1795 bfd_put_32 (output_bfd, 1796 sgot->output_section->vma + sgot->output_offset + 8, 1797 splt->contents + 8); 1798 } 1799 } 1800 1801 /* UnixWare sets the entsize of .plt to 4, although that doesn't 1802 really seem like the right value. */ 1803 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4; 1804 } 1805 1806 /* Fill in the first three entries in the global offset table. */ 1807 if (sgot->_raw_size > 0) 1808 { 1809 if (sdyn == NULL) 1810 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 1811 else 1812 bfd_put_32 (output_bfd, 1813 sdyn->output_section->vma + sdyn->output_offset, 1814 sgot->contents); 1815 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 1816 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 1817 } 1818 1819 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 1820 1821 return true; 1822} 1823 1824#define TARGET_LITTLE_SYM bfd_elf32_i386_vec 1825#define TARGET_LITTLE_NAME "elf32-i386" 1826#define ELF_ARCH bfd_arch_i386 1827#define ELF_MACHINE_CODE EM_386 1828#define ELF_MAXPAGESIZE 0x1000 1829#define elf_info_to_howto elf_i386_info_to_howto 1830#define elf_info_to_howto_rel elf_i386_info_to_howto_rel 1831#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup 1832#define bfd_elf32_bfd_is_local_label_name \ 1833 elf_i386_is_local_label_name 1834#define elf_backend_create_dynamic_sections \ 1835 _bfd_elf_create_dynamic_sections 1836#define bfd_elf32_bfd_link_hash_table_create \ 1837 elf_i386_link_hash_table_create 1838#define elf_backend_check_relocs elf_i386_check_relocs 1839#define elf_backend_adjust_dynamic_symbol \ 1840 elf_i386_adjust_dynamic_symbol 1841#define elf_backend_size_dynamic_sections \ 1842 elf_i386_size_dynamic_sections 1843#define elf_backend_relocate_section elf_i386_relocate_section 1844#define elf_backend_finish_dynamic_symbol \ 1845 elf_i386_finish_dynamic_symbol 1846#define elf_backend_finish_dynamic_sections \ 1847 elf_i386_finish_dynamic_sections 1848#define elf_backend_want_got_plt 1 1849#define elf_backend_plt_readonly 1 1850#define elf_backend_want_plt_sym 0 1851 1852#include "elf32-target.h" 1853